]> 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
Regen gdb/config.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
1449284b 290static const char * get_symbol_version_string
bb4d2ac2
L		 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");
1a0670f3 429 /* Fall 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);
1a0670f3 442 /* Fall through. */
66543521 443
14a91970
AM		 444 case PREFIX_HEX:
445 nc = printf ("0x");
1a0670f3 446 /* Fall 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
1449284b 559/* Returns a pointer to a static buffer containing a printable version of
74e1a04b
NC		 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 }
1a0670f3 1295 /* Fall through. */
2469cfa2
NC		 1296 case EM_MSP430_OLD:
1297 rtype = elf_msp430_reloc_type (type);
1298 break;
1299
35c08157
KLC		 1300 case EM_NDS32:
1301 rtype = elf_nds32_reloc_type (type);
1302 break;
1303
252b5132 1304 case EM_PPC:
9ea033b2 1305 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1306 break;
1307
c833c019
AM		 1308 case EM_PPC64:
1309 rtype = elf_ppc64_reloc_type (type);
1310 break;
1311
252b5132 1312 case EM_MIPS:
4fe85591 1313 case EM_MIPS_RS3_LE:
9ea033b2 1314 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1315 break;
1316
1317 case EM_ALPHA:
9ea033b2 1318 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1319 break;
1320
1321 case EM_ARM:
9ea033b2 1322 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1323 break;
1324
584da044 1325 case EM_ARC:
886a2506
NC		 1326 case EM_ARC_COMPACT:
1327 case EM_ARC_COMPACT2:
9ea033b2 1328 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1329 break;
1330
1331 case EM_PARISC:
69e617ca 1332 rtype = elf_hppa_reloc_type (type);
252b5132 1333 break;
7d466069 1334
b8720f9d
JL		 1335 case EM_H8_300:
1336 case EM_H8_300H:
1337 case EM_H8S:
1338 rtype = elf_h8_reloc_type (type);
1339 break;
1340
73589c9d
CS		 1341 case EM_OR1K:
1342 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1343 break;
1344
7d466069 1345 case EM_PJ:
2b0337b0 1346 case EM_PJ_OLD:
7d466069
ILT		 1347 rtype = elf_pj_reloc_type (type);
1348 break;
800eeca4
JW		 1349 case EM_IA_64:
1350 rtype = elf_ia64_reloc_type (type);
1351 break;
1b61cf92
HPN		 1352
1353 case EM_CRIS:
1354 rtype = elf_cris_reloc_type (type);
1355 break;
535c37ff
JE		 1356
1357 case EM_860:
1358 rtype = elf_i860_reloc_type (type);
1359 break;
bcedfee6
NC		 1360
1361 case EM_X86_64:
8a9036a4 1362 case EM_L1OM:
7a9068fe 1363 case EM_K1OM:
bcedfee6
NC		 1364 rtype = elf_x86_64_reloc_type (type);
1365 break;
a85d7ed0 1366
35b1837e
AM		 1367 case EM_S370:
1368 rtype = i370_reloc_type (type);
1369 break;
1370
53c7db4b
KH		 1371 case EM_S390_OLD:
1372 case EM_S390:
1373 rtype = elf_s390_reloc_type (type);
1374 break;
93fbbb04 1375
1c0d3aa6
NC		 1376 case EM_SCORE:
1377 rtype = elf_score_reloc_type (type);
1378 break;
1379
93fbbb04
GK		 1380 case EM_XSTORMY16:
1381 rtype = elf_xstormy16_reloc_type (type);
1382 break;
179d3252 1383
1fe1f39c
NC		 1384 case EM_CRX:
1385 rtype = elf_crx_reloc_type (type);
1386 break;
1387
179d3252
JT		 1388 case EM_VAX:
1389 rtype = elf_vax_reloc_type (type);
1390 break;
1e4cf259 1391
619ed720
EB		 1392 case EM_VISIUM:
1393 rtype = elf_visium_reloc_type (type);
1394 break;
1395
cfb8c092
NC		 1396 case EM_ADAPTEVA_EPIPHANY:
1397 rtype = elf_epiphany_reloc_type (type);
1398 break;
1399
1e4cf259
NC		 1400 case EM_IP2K:
1401 case EM_IP2K_OLD:
1402 rtype = elf_ip2k_reloc_type (type);
1403 break;
3b36097d
SC		 1404
1405 case EM_IQ2000:
1406 rtype = elf_iq2000_reloc_type (type);
1407 break;
88da6820
NC		 1408
1409 case EM_XTENSA_OLD:
1410 case EM_XTENSA:
1411 rtype = elf_xtensa_reloc_type (type);
1412 break;
a34e3ecb 1413
84e94c90
NC		 1414 case EM_LATTICEMICO32:
1415 rtype = elf_lm32_reloc_type (type);
1416 break;
1417
ff7eeb89 1418 case EM_M32C_OLD:
49f58d10
JB		 1419 case EM_M32C:
1420 rtype = elf_m32c_reloc_type (type);
1421 break;
1422
d031aafb
NS		 1423 case EM_MT:
1424 rtype = elf_mt_reloc_type (type);
a34e3ecb 1425 break;
1d65ded4
CM		 1426
1427 case EM_BLACKFIN:
1428 rtype = elf_bfin_reloc_type (type);
1429 break;
15ab5209
DB		 1430
1431 case EM_CYGNUS_MEP:
1432 rtype = elf_mep_reloc_type (type);
1433 break;
60bca95a
NC		 1434
1435 case EM_CR16:
1436 rtype = elf_cr16_reloc_type (type);
1437 break;
dd24e3da 1438
7ba29e2a
NC		 1439 case EM_MICROBLAZE:
1440 case EM_MICROBLAZE_OLD:
1441 rtype = elf_microblaze_reloc_type (type);
1442 break;
c7927a3c 1443
99c513f6
DD		 1444 case EM_RL78:
1445 rtype = elf_rl78_reloc_type (type);
1446 break;
1447
c7927a3c
NC		 1448 case EM_RX:
1449 rtype = elf_rx_reloc_type (type);
1450 break;
c29aca4a 1451
a3c62988
NC		 1452 case EM_METAG:
1453 rtype = elf_metag_reloc_type (type);
1454 break;
1455
c29aca4a
NC		 1456 case EM_XC16X:
1457 case EM_C166:
1458 rtype = elf_xc16x_reloc_type (type);
1459 break;
40b36596
JM		 1460
1461 case EM_TI_C6000:
1462 rtype = elf_tic6x_reloc_type (type);
1463 break;
aa137e4d
NC		 1464
1465 case EM_TILEGX:
1466 rtype = elf_tilegx_reloc_type (type);
1467 break;
1468
1469 case EM_TILEPRO:
1470 rtype = elf_tilepro_reloc_type (type);
1471 break;
f6c1a2d5
NC		 1472
1473 case EM_XGATE:
1474 rtype = elf_xgate_reloc_type (type);
1475 break;
36591ba1
SL		 1476
1477 case EM_ALTERA_NIOS2:
1478 rtype = elf_nios2_reloc_type (type);
1479 break;
252b5132
RH		 1480 }
1481
1482 if (rtype == NULL)
39dbeff8 1483 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1484 else
8beeaeb7 1485 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1486
7ace3541 1487 if (elf_header.e_machine == EM_ALPHA
157c2599 1488 && rtype != NULL
7ace3541
RH		 1489 && streq (rtype, "R_ALPHA_LITUSE")
1490 && is_rela)
1491 {
1492 switch (rels[i].r_addend)
1493 {
1494 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1495 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1496 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1497 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1498 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1499 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1500 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1501 default: rtype = NULL;
1502 }
1503 if (rtype)
1504 printf (" (%s)", rtype);
1505 else
1506 {
1507 putchar (' ');
1508 printf (_("<unknown addend: %lx>"),
1509 (unsigned long) rels[i].r_addend);
1510 }
1511 }
1512 else if (symtab_index)
252b5132 1513 {
af3fc3bc 1514 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1515 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1516 else
19936277 1517 {
2cf0635d 1518 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1519 const char * version_string;
1520 enum versioned_symbol_info sym_info;
1521 unsigned short vna_other;
19936277 1522
af3fc3bc 1523 psym = symtab + symtab_index;
103f02d3 1524
bb4d2ac2
L		 1525 version_string
1526 = get_symbol_version_string (file, is_dynsym,
1527 strtab, strtablen,
1528 symtab_index,
1529 psym,
1530 &sym_info,
1531 &vna_other);
1532
af3fc3bc 1533 printf (" ");
171191ba 1534
d8045f23
NC		 1535 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1536 {
1537 const char * name;
1538 unsigned int len;
1539 unsigned int width = is_32bit_elf ? 8 : 14;
1540
1541 /* Relocations against GNU_IFUNC symbols do not use the value
1542 of the symbol as the address to relocate against. Instead
1543 they invoke the function named by the symbol and use its
1544 result as the address for relocation.
1545
1546 To indicate this to the user, do not display the value of
1547 the symbol in the "Symbols's Value" field. Instead show
1548 its name followed by () as a hint that the symbol is
1549 invoked. */
1550
1551 if (strtab == NULL
1552 || psym->st_name == 0
1553 || psym->st_name >= strtablen)
1554 name = "??";
1555 else
1556 name = strtab + psym->st_name;
1557
1558 len = print_symbol (width, name);
bb4d2ac2
L		 1559 if (version_string)
1560 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1561 version_string);
d8045f23
NC		 1562 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1563 }
1564 else
1565 {
1566 print_vma (psym->st_value, LONG_HEX);
171191ba 1567
d8045f23
NC		 1568 printf (is_32bit_elf ? " " : " ");
1569 }
103f02d3 1570
af3fc3bc 1571 if (psym->st_name == 0)
f1ef08cb 1572 {
2cf0635d 1573 const char * sec_name = "<null>";
f1ef08cb
AM		 1574 char name_buf[40];
1575
1576 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1577 {
4fbb74a6 1578 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1579 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1580 else if (psym->st_shndx == SHN_ABS)
1581 sec_name = "ABS";
1582 else if (psym->st_shndx == SHN_COMMON)
1583 sec_name = "COMMON";
ac145307
BS		 1584 else if ((elf_header.e_machine == EM_MIPS
1585 && psym->st_shndx == SHN_MIPS_SCOMMON)
1586 || (elf_header.e_machine == EM_TI_C6000
1587 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1588 sec_name = "SCOMMON";
1589 else if (elf_header.e_machine == EM_MIPS
1590 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1591 sec_name = "SUNDEF";
8a9036a4 1592 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1593 || elf_header.e_machine == EM_L1OM
1594 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1595 && psym->st_shndx == SHN_X86_64_LCOMMON)
1596 sec_name = "LARGE_COMMON";
9ce701e2
L		 1597 else if (elf_header.e_machine == EM_IA_64
1598 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1599 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1600 sec_name = "ANSI_COM";
28f997cf 1601 else if (is_ia64_vms ()
148b93f2
NC		 1602 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1603 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1604 else
1605 {
1606 sprintf (name_buf, "<section 0x%x>",
1607 (unsigned int) psym->st_shndx);
1608 sec_name = name_buf;
1609 }
1610 }
1611 print_symbol (22, sec_name);
1612 }
af3fc3bc 1613 else if (strtab == NULL)
d79b3d50 1614 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1615 else if (psym->st_name >= strtablen)
d79b3d50 1616 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1617 else
bb4d2ac2
L		 1618 {
1619 print_symbol (22, strtab + psym->st_name);
1620 if (version_string)
1621 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1622 version_string);
1623 }
103f02d3 1624
af3fc3bc 1625 if (is_rela)
171191ba 1626 {
7360e63f 1627 bfd_vma off = rels[i].r_addend;
171191ba 1628
7360e63f 1629 if ((bfd_signed_vma) off < 0)
598aaa76 1630 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1631 else
598aaa76 1632 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1633 }
19936277 1634 }
252b5132 1635 }
1b228002 1636 else if (is_rela)
f7a99963 1637 {
7360e63f 1638 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1639
1640 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1641 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1642 printf ("-%" BFD_VMA_FMT "x", - off);
1643 else
1644 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1645 }
252b5132 1646
157c2599
NC		 1647 if (elf_header.e_machine == EM_SPARCV9
1648 && rtype != NULL
1649 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1650 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1651
252b5132 1652 putchar ('\n');
2c71103e 1653
aca88567 1654#ifdef BFD64
53c7db4b 1655 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1656 {
91d6fa6a
NC		 1657 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1658 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1659 const char * rtype2 = elf_mips_reloc_type (type2);
1660 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1661
2c71103e
NC		 1662 printf (" Type2: ");
1663
1664 if (rtype2 == NULL)
39dbeff8
AM		 1665 printf (_("unrecognized: %-7lx"),
1666 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1667 else
1668 printf ("%-17.17s", rtype2);
1669
18bd398b 1670 printf ("\n Type3: ");
2c71103e
NC		 1671
1672 if (rtype3 == NULL)
39dbeff8
AM		 1673 printf (_("unrecognized: %-7lx"),
1674 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1675 else
1676 printf ("%-17.17s", rtype3);
1677
53c7db4b 1678 putchar ('\n');
2c71103e 1679 }
aca88567 1680#endif /* BFD64 */
252b5132
RH		 1681 }
1682
c8286bd1 1683 free (rels);
252b5132
RH		 1684}
1685
1686static const char *
d3ba0551 1687get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1688{
1689 switch (type)
1690 {
1691 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1692 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1693 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1694 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1695 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1696 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1697 case DT_MIPS_MSYM: return "MIPS_MSYM";
1698 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1699 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1700 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1701 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1702 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1703 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1704 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1705 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1706 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1707 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1708 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1709 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1710 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1711 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1712 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1713 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1714 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1715 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1716 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1717 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1718 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1719 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1720 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1721 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1722 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1723 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1724 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1725 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1726 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1727 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1728 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1729 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1730 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1731 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1732 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1733 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1734 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1735 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1736 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1737 default:
1738 return NULL;
1739 }
1740}
1741
9a097730 1742static const char *
d3ba0551 1743get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1744{
1745 switch (type)
1746 {
1747 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1748 default:
1749 return NULL;
1750 }
103f02d3
UD		 1751}
1752
7490d522
AM		 1753static const char *
1754get_ppc_dynamic_type (unsigned long type)
1755{
1756 switch (type)
1757 {
a7f2871e 1758 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1759 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1760 default:
1761 return NULL;
1762 }
1763}
1764
f1cb7e17 1765static const char *
d3ba0551 1766get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1767{
1768 switch (type)
1769 {
a7f2871e
AM		 1770 case DT_PPC64_GLINK: return "PPC64_GLINK";
1771 case DT_PPC64_OPD: return "PPC64_OPD";
1772 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1773 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1774 default:
1775 return NULL;
1776 }
1777}
1778
103f02d3 1779static const char *
d3ba0551 1780get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1781{
1782 switch (type)
1783 {
1784 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1785 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1786 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1787 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1788 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1789 case DT_HP_PREINIT: return "HP_PREINIT";
1790 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1791 case DT_HP_NEEDED: return "HP_NEEDED";
1792 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1793 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1794 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1795 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1796 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1797 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1798 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1799 case DT_HP_FILTERED: return "HP_FILTERED";
1800 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1801 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1802 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1803 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1804 case DT_PLT: return "PLT";
1805 case DT_PLT_SIZE: return "PLT_SIZE";
1806 case DT_DLT: return "DLT";
1807 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1808 default:
1809 return NULL;
1810 }
1811}
9a097730 1812
ecc51f48 1813static const char *
d3ba0551 1814get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1815{
1816 switch (type)
1817 {
148b93f2
NC		 1818 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1819 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1820 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1821 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1822 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1823 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1824 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1825 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1826 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1827 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1828 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1829 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1830 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1831 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1832 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1833 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1834 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1835 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1836 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1837 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1838 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1839 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1840 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1841 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1842 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1843 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1844 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1845 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1846 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1847 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1848 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1849 default:
1850 return NULL;
1851 }
1852}
1853
fd85a6a1
NC		 1854static const char *
1855get_solaris_section_type (unsigned long type)
1856{
1857 switch (type)
1858 {
1859 case 0x6fffffee: return "SUNW_ancillary";
1860 case 0x6fffffef: return "SUNW_capchain";
1861 case 0x6ffffff0: return "SUNW_capinfo";
1862 case 0x6ffffff1: return "SUNW_symsort";
1863 case 0x6ffffff2: return "SUNW_tlssort";
1864 case 0x6ffffff3: return "SUNW_LDYNSYM";
1865 case 0x6ffffff4: return "SUNW_dof";
1866 case 0x6ffffff5: return "SUNW_cap";
1867 case 0x6ffffff6: return "SUNW_SIGNATURE";
1868 case 0x6ffffff7: return "SUNW_ANNOTATE";
1869 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1870 case 0x6ffffff9: return "SUNW_DEBUG";
1871 case 0x6ffffffa: return "SUNW_move";
1872 case 0x6ffffffb: return "SUNW_COMDAT";
1873 case 0x6ffffffc: return "SUNW_syminfo";
1874 case 0x6ffffffd: return "SUNW_verdef";
1875 case 0x6ffffffe: return "SUNW_verneed";
1876 case 0x6fffffff: return "SUNW_versym";
1877 case 0x70000000: return "SPARC_GOTDATA";
1878 default: return NULL;
1879 }
1880}
1881
fabcb361
RH		 1882static const char *
1883get_alpha_dynamic_type (unsigned long type)
1884{
1885 switch (type)
1886 {
1887 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1888 default:
1889 return NULL;
1890 }
1891}
1892
1c0d3aa6
NC		 1893static const char *
1894get_score_dynamic_type (unsigned long type)
1895{
1896 switch (type)
1897 {
1898 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1899 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1900 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1901 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1902 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1903 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1904 default:
1905 return NULL;
1906 }
1907}
1908
40b36596
JM		 1909static const char *
1910get_tic6x_dynamic_type (unsigned long type)
1911{
1912 switch (type)
1913 {
1914 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1915 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1916 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1917 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1918 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1919 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1920 default:
1921 return NULL;
1922 }
1923}
1c0d3aa6 1924
36591ba1
SL		 1925static const char *
1926get_nios2_dynamic_type (unsigned long type)
1927{
1928 switch (type)
1929 {
1930 case DT_NIOS2_GP: return "NIOS2_GP";
1931 default:
1932 return NULL;
1933 }
1934}
1935
fd85a6a1
NC		 1936static const char *
1937get_solaris_dynamic_type (unsigned long type)
1938{
1939 switch (type)
1940 {
1941 case 0x6000000d: return "SUNW_AUXILIARY";
1942 case 0x6000000e: return "SUNW_RTLDINF";
1943 case 0x6000000f: return "SUNW_FILTER";
1944 case 0x60000010: return "SUNW_CAP";
1945 case 0x60000011: return "SUNW_SYMTAB";
1946 case 0x60000012: return "SUNW_SYMSZ";
1947 case 0x60000013: return "SUNW_SORTENT";
1948 case 0x60000014: return "SUNW_SYMSORT";
1949 case 0x60000015: return "SUNW_SYMSORTSZ";
1950 case 0x60000016: return "SUNW_TLSSORT";
1951 case 0x60000017: return "SUNW_TLSSORTSZ";
1952 case 0x60000018: return "SUNW_CAPINFO";
1953 case 0x60000019: return "SUNW_STRPAD";
1954 case 0x6000001a: return "SUNW_CAPCHAIN";
1955 case 0x6000001b: return "SUNW_LDMACH";
1956 case 0x6000001d: return "SUNW_CAPCHAINENT";
1957 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1958 case 0x60000021: return "SUNW_PARENT";
1959 case 0x60000023: return "SUNW_ASLR";
1960 case 0x60000025: return "SUNW_RELAX";
1961 case 0x60000029: return "SUNW_NXHEAP";
1962 case 0x6000002b: return "SUNW_NXSTACK";
1963
1964 case 0x70000001: return "SPARC_REGISTER";
1965 case 0x7ffffffd: return "AUXILIARY";
1966 case 0x7ffffffe: return "USED";
1967 case 0x7fffffff: return "FILTER";
1968
1969 default: return NULL;
1970 }
1971}
1972
252b5132 1973static const char *
d3ba0551 1974get_dynamic_type (unsigned long type)
252b5132 1975{
e9e44622 1976 static char buff[64];
252b5132
RH		 1977
1978 switch (type)
1979 {
1980 case DT_NULL: return "NULL";
1981 case DT_NEEDED: return "NEEDED";
1982 case DT_PLTRELSZ: return "PLTRELSZ";
1983 case DT_PLTGOT: return "PLTGOT";
1984 case DT_HASH: return "HASH";
1985 case DT_STRTAB: return "STRTAB";
1986 case DT_SYMTAB: return "SYMTAB";
1987 case DT_RELA: return "RELA";
1988 case DT_RELASZ: return "RELASZ";
1989 case DT_RELAENT: return "RELAENT";
1990 case DT_STRSZ: return "STRSZ";
1991 case DT_SYMENT: return "SYMENT";
1992 case DT_INIT: return "INIT";
1993 case DT_FINI: return "FINI";
1994 case DT_SONAME: return "SONAME";
1995 case DT_RPATH: return "RPATH";
1996 case DT_SYMBOLIC: return "SYMBOLIC";
1997 case DT_REL: return "REL";
1998 case DT_RELSZ: return "RELSZ";
1999 case DT_RELENT: return "RELENT";
2000 case DT_PLTREL: return "PLTREL";
2001 case DT_DEBUG: return "DEBUG";
2002 case DT_TEXTREL: return "TEXTREL";
2003 case DT_JMPREL: return "JMPREL";
2004 case DT_BIND_NOW: return "BIND_NOW";
2005 case DT_INIT_ARRAY: return "INIT_ARRAY";
2006 case DT_FINI_ARRAY: return "FINI_ARRAY";
2007 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2008 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 2009 case DT_RUNPATH: return "RUNPATH";
2010 case DT_FLAGS: return "FLAGS";
2d0e6f43 2011
d1133906
NC		 2012 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2013 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
6d913794 2014 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
103f02d3 2015
05107a46 2016 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 2017 case DT_PLTPADSZ: return "PLTPADSZ";
2018 case DT_MOVEENT: return "MOVEENT";
2019 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 2020 case DT_FEATURE: return "FEATURE";
252b5132
RH		 2021 case DT_POSFLAG_1: return "POSFLAG_1";
2022 case DT_SYMINSZ: return "SYMINSZ";
2023 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 2024
252b5132 2025 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 2026 case DT_CONFIG: return "CONFIG";
2027 case DT_DEPAUDIT: return "DEPAUDIT";
2028 case DT_AUDIT: return "AUDIT";
2029 case DT_PLTPAD: return "PLTPAD";
2030 case DT_MOVETAB: return "MOVETAB";
252b5132 2031 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 2032
252b5132 2033 case DT_VERSYM: return "VERSYM";
103f02d3 2034
67a4f2b7
AO		 2035 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2036 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 2037 case DT_RELACOUNT: return "RELACOUNT";
2038 case DT_RELCOUNT: return "RELCOUNT";
2039 case DT_FLAGS_1: return "FLAGS_1";
2040 case DT_VERDEF: return "VERDEF";
2041 case DT_VERDEFNUM: return "VERDEFNUM";
2042 case DT_VERNEED: return "VERNEED";
2043 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 2044
019148e4 2045 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 2046 case DT_USED: return "USED";
2047 case DT_FILTER: return "FILTER";
103f02d3 2048
047b2264
JJ		 2049 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2050 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2051 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2052 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2053 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 2054 case DT_GNU_HASH: return "GNU_HASH";
047b2264 2055
252b5132
RH		 2056 default:
2057 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2058 {
2cf0635d 2059 const char * result;
103f02d3 2060
252b5132
RH		 2061 switch (elf_header.e_machine)
2062 {
2063 case EM_MIPS:
4fe85591 2064 case EM_MIPS_RS3_LE:
252b5132
RH		 2065 result = get_mips_dynamic_type (type);
2066 break;
9a097730
RH		 2067 case EM_SPARCV9:
2068 result = get_sparc64_dynamic_type (type);
2069 break;
7490d522
AM		 2070 case EM_PPC:
2071 result = get_ppc_dynamic_type (type);
2072 break;
f1cb7e17
AM		 2073 case EM_PPC64:
2074 result = get_ppc64_dynamic_type (type);
2075 break;
ecc51f48
NC		 2076 case EM_IA_64:
2077 result = get_ia64_dynamic_type (type);
2078 break;
fabcb361
RH		 2079 case EM_ALPHA:
2080 result = get_alpha_dynamic_type (type);
2081 break;
1c0d3aa6
NC		 2082 case EM_SCORE:
2083 result = get_score_dynamic_type (type);
2084 break;
40b36596
JM		 2085 case EM_TI_C6000:
2086 result = get_tic6x_dynamic_type (type);
2087 break;
36591ba1
SL		 2088 case EM_ALTERA_NIOS2:
2089 result = get_nios2_dynamic_type (type);
2090 break;
252b5132 2091 default:
fd85a6a1
NC		 2092 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2093 result = get_solaris_dynamic_type (type);
2094 else
2095 result = NULL;
252b5132
RH		 2096 break;
2097 }
2098
2099 if (result != NULL)
2100 return result;
2101
e9e44622 2102 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2103 }
eec8f817
DA		 2104 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2105 || (elf_header.e_machine == EM_PARISC
2106 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2107 {
2cf0635d 2108 const char * result;
103f02d3
UD		 2109
2110 switch (elf_header.e_machine)
2111 {
2112 case EM_PARISC:
2113 result = get_parisc_dynamic_type (type);
2114 break;
148b93f2
NC		 2115 case EM_IA_64:
2116 result = get_ia64_dynamic_type (type);
2117 break;
103f02d3 2118 default:
fd85a6a1
NC		 2119 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2120 result = get_solaris_dynamic_type (type);
2121 else
2122 result = NULL;
103f02d3
UD		 2123 break;
2124 }
2125
2126 if (result != NULL)
2127 return result;
2128
e9e44622
JJ		 2129 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2130 type);
103f02d3 2131 }
252b5132 2132 else
e9e44622 2133 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2134
252b5132
RH		 2135 return buff;
2136 }
2137}
2138
2139static char *
d3ba0551 2140get_file_type (unsigned e_type)
252b5132 2141{
b34976b6 2142 static char buff[32];
252b5132
RH		 2143
2144 switch (e_type)
2145 {
2146 case ET_NONE: return _("NONE (None)");
2147 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2148 case ET_EXEC: return _("EXEC (Executable file)");
2149 case ET_DYN: return _("DYN (Shared object file)");
2150 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2151
2152 default:
2153 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2154 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2155 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2156 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2157 else
e9e44622 2158 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2159 return buff;
2160 }
2161}
2162
2163static char *
d3ba0551 2164get_machine_name (unsigned e_machine)
252b5132 2165{
b34976b6 2166 static char buff[64]; /* XXX */
252b5132
RH		 2167
2168 switch (e_machine)
2169 {
c45021f2 2170 case EM_NONE: return _("None");
a06ea964 2171 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2172 case EM_M32: return "WE32100";
2173 case EM_SPARC: return "Sparc";
e9f53129 2174 case EM_SPU: return "SPU";
c45021f2
NC		 2175 case EM_386: return "Intel 80386";
2176 case EM_68K: return "MC68000";
2177 case EM_88K: return "MC88000";
22abe556 2178 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2179 case EM_860: return "Intel 80860";
2180 case EM_MIPS: return "MIPS R3000";
2181 case EM_S370: return "IBM System/370";
7036c0e1 2182 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2183 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2184 case EM_PARISC: return "HPPA";
252b5132 2185 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2186 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2187 case EM_960: return "Intel 90860";
2188 case EM_PPC: return "PowerPC";
285d1771 2189 case EM_PPC64: return "PowerPC64";
c45021f2 2190 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2191 case EM_FT32: return "FTDI FT32";
c45021f2 2192 case EM_RH32: return "TRW RH32";
b34976b6 2193 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2194 case EM_ARM: return "ARM";
2195 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2196 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2197 case EM_SPARCV9: return "Sparc v9";
2198 case EM_TRICORE: return "Siemens Tricore";
584da044 2199 case EM_ARC: return "ARC";
886a2506
NC		 2200 case EM_ARC_COMPACT: return "ARCompact";
2201 case EM_ARC_COMPACT2: return "ARCv2";
c2dcd04e
NC		 2202 case EM_H8_300: return "Renesas H8/300";
2203 case EM_H8_300H: return "Renesas H8/300H";
2204 case EM_H8S: return "Renesas H8S";
2205 case EM_H8_500: return "Renesas H8/500";
30800947 2206 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2207 case EM_MIPS_X: return "Stanford MIPS-X";
2208 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2209 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2210 case EM_CYGNUS_D10V:
2211 case EM_D10V: return "d10v";
2212 case EM_CYGNUS_D30V:
b34976b6 2213 case EM_D30V: return "d30v";
2b0337b0 2214 case EM_CYGNUS_M32R:
26597c86 2215 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2216 case EM_CYGNUS_V850:
708e2187 2217 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2218 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2219 case EM_CYGNUS_MN10300:
2220 case EM_MN10300: return "mn10300";
2221 case EM_CYGNUS_MN10200:
2222 case EM_MN10200: return "mn10200";
5506d11a 2223 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2224 case EM_CYGNUS_FR30:
2225 case EM_FR30: return "Fujitsu FR30";
b34976b6 2226 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2227 case EM_PJ_OLD:
b34976b6 2228 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2229 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2230 case EM_PCP: return "Siemens PCP";
2231 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2232 case EM_NDR1: return "Denso NDR1 microprocesspr";
2233 case EM_STARCORE: return "Motorola Star*Core processor";
2234 case EM_ME16: return "Toyota ME16 processor";
2235 case EM_ST100: return "STMicroelectronics ST100 processor";
2236 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2237 case EM_PDSP: return "Sony DSP processor";
2238 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2239 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2240 case EM_FX66: return "Siemens FX66 microcontroller";
2241 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2242 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2243 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2244 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2245 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2246 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2247 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2248 case EM_SVX: return "Silicon Graphics SVx";
2249 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2250 case EM_VAX: return "Digital VAX";
619ed720 2251 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2252 case EM_AVR_OLD:
b34976b6 2253 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2254 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2255 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2256 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2257 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2258 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2259 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2260 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2261 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2262 case EM_L1OM: return "Intel L1OM";
7a9068fe 2263 case EM_K1OM: return "Intel K1OM";
b7498e0e 2264 case EM_S390_OLD:
b34976b6 2265 case EM_S390: return "IBM S/390";
1c0d3aa6 2266 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2267 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2268 case EM_OR1K: return "OpenRISC 1000";
1fe1f39c 2269 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2270 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2271 case EM_DLX: return "OpenDLX";
1e4cf259 2272 case EM_IP2K_OLD:
b34976b6 2273 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2274 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2275 case EM_XTENSA_OLD:
2276 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2277 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2278 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2279 case EM_NS32K: return "National Semiconductor 32000 series";
2280 case EM_TPC: return "Tenor Network TPC processor";
2281 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2282 case EM_MAX: return "MAX Processor";
2283 case EM_CR: return "National Semiconductor CompactRISC";
2284 case EM_F2MC16: return "Fujitsu F2MC16";
2285 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2286 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2287 case EM_M32C_OLD:
49f58d10 2288 case EM_M32C: return "Renesas M32c";
d031aafb 2289 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2290 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2291 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2292 case EM_SEP: return "Sharp embedded microprocessor";
2293 case EM_ARCA: return "Arca RISC microprocessor";
2294 case EM_UNICORE: return "Unicore";
2295 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2296 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2297 case EM_NIOS32: return "Altera Nios";
2298 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2299 case EM_C166:
d70c5fc7 2300 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2301 case EM_M16C: return "Renesas M16C series microprocessors";
2302 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2303 case EM_CE: return "Freescale Communication Engine RISC core";
2304 case EM_TSK3000: return "Altium TSK3000 core";
2305 case EM_RS08: return "Freescale RS08 embedded processor";
2306 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2307 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2308 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2309 case EM_SE_C17: return "Seiko Epson C17 family";
2310 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2311 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2312 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2313 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2314 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2315 case EM_R32C: return "Renesas R32C series microprocessors";
2316 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2317 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2318 case EM_8051: return "Intel 8051 and variants";
2319 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2320 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2321 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2322 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2323 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2324 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2325 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2326 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2327 case EM_CR16:
f6c1a2d5 2328 case EM_MICROBLAZE:
7ba29e2a 2329 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2330 case EM_RL78: return "Renesas RL78";
c7927a3c 2331 case EM_RX: return "Renesas RX";
a3c62988 2332 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2333 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2334 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2335 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2336 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2337 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2338 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2339 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2340 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2341 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2342 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2343 case EM_XGATE: return "Motorola XGATE embedded processor";
6d913794
NC		 2344 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2345 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2346 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2347 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2348 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2349 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
1449284b
NC		 2350 case EM_BA1 : return "Beyond BA1 CPU architecture";
2351 case EM_BA2 : return "Beyond BA2 CPU architecture";
6d913794
NC		 2352 case EM_XCORE: return "XMOS xCORE processor family";
2353 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2354 case EM_KM32: return "KM211 KM32 32-bit processor";
2355 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2356 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2357 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2358 case EM_KVARC: return "KM211 KVARC processor";
1449284b 2359 case EM_CDP : return "Paneve CDP architecture family";
6d913794
NC		 2360 case EM_COGE: return "Cognitive Smart Memory Processor";
2361 case EM_COOL: return "Bluechip Systems CoolEngine";
2362 case EM_NORC: return "Nanoradio Optimized RISC";
2363 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
1449284b 2364 case EM_Z80 : return "Zilog Z80";
6d913794
NC		 2365 case EM_AMDGPU: return "AMD GPU architecture";
2366 case EM_RISCV: return "RISC-V";
252b5132 2367 default:
35d9dd2f 2368 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2369 return buff;
2370 }
2371}
2372
a9522a21
AB		 2373static void
2374decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2375{
2376 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2377 other compilers don't a specific architecture type in the e_flags, and
2378 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2379 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2380 architectures.
2381
2382 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2383 but also sets a specific architecture type in the e_flags field.
2384
2385 However, when decoding the flags we don't worry if we see an
2386 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2387 ARCEM architecture type. */
2388
2389 switch (e_flags & EF_ARC_MACH_MSK)
2390 {
2391 /* We only expect these to occur for EM_ARC_COMPACT2. */
2392 case EF_ARC_CPU_ARCV2EM:
2393 strcat (buf, ", ARC EM");
2394 break;
2395 case EF_ARC_CPU_ARCV2HS:
2396 strcat (buf, ", ARC HS");
2397 break;
2398
2399 /* We only expect these to occur for EM_ARC_COMPACT. */
2400 case E_ARC_MACH_ARC600:
2401 strcat (buf, ", ARC600");
2402 break;
2403 case E_ARC_MACH_ARC601:
2404 strcat (buf, ", ARC601");
2405 break;
2406 case E_ARC_MACH_ARC700:
2407 strcat (buf, ", ARC700");
2408 break;
2409
2410 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2411 new ELF with new architecture being read by an old version of
2412 readelf, or (c) An ELF built with non-GNU compiler that does not
2413 set the architecture in the e_flags. */
2414 default:
2415 if (e_machine == EM_ARC_COMPACT)
2416 strcat (buf, ", Unknown ARCompact");
2417 else
2418 strcat (buf, ", Unknown ARC");
2419 break;
2420 }
2421
2422 switch (e_flags & EF_ARC_OSABI_MSK)
2423 {
2424 case E_ARC_OSABI_ORIG:
2425 strcat (buf, ", (ABI:legacy)");
2426 break;
2427 case E_ARC_OSABI_V2:
2428 strcat (buf, ", (ABI:v2)");
2429 break;
2430 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2431 case E_ARC_OSABI_V3:
2432 strcat (buf, ", v3 no-legacy-syscalls ABI");
2433 break;
2434 default:
2435 strcat (buf, ", unrecognised ARC OSABI flag");
2436 break;
2437 }
2438}
2439
f3485b74 2440static void
d3ba0551 2441decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2442{
2443 unsigned eabi;
2444 int unknown = 0;
2445
2446 eabi = EF_ARM_EABI_VERSION (e_flags);
2447 e_flags &= ~ EF_ARM_EABIMASK;
2448
2449 /* Handle "generic" ARM flags. */
2450 if (e_flags & EF_ARM_RELEXEC)
2451 {
2452 strcat (buf, ", relocatable executable");
2453 e_flags &= ~ EF_ARM_RELEXEC;
2454 }
76da6bbe 2455
f3485b74
NC		 2456 /* Now handle EABI specific flags. */
2457 switch (eabi)
2458 {
2459 default:
2c71103e 2460 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2461 if (e_flags)
2462 unknown = 1;
2463 break;
2464
2465 case EF_ARM_EABI_VER1:
a5bcd848 2466 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2467 while (e_flags)
2468 {
2469 unsigned flag;
76da6bbe 2470
f3485b74
NC		 2471 /* Process flags one bit at a time. */
2472 flag = e_flags & - e_flags;
2473 e_flags &= ~ flag;
76da6bbe 2474
f3485b74
NC		 2475 switch (flag)
2476 {
a5bcd848 2477 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2478 strcat (buf, ", sorted symbol tables");
2479 break;
76da6bbe 2480
f3485b74
NC		 2481 default:
2482 unknown = 1;
2483 break;
2484 }
2485 }
2486 break;
76da6bbe 2487
a5bcd848
PB		 2488 case EF_ARM_EABI_VER2:
2489 strcat (buf, ", Version2 EABI");
2490 while (e_flags)
2491 {
2492 unsigned flag;
2493
2494 /* Process flags one bit at a time. */
2495 flag = e_flags & - e_flags;
2496 e_flags &= ~ flag;
2497
2498 switch (flag)
2499 {
2500 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2501 strcat (buf, ", sorted symbol tables");
2502 break;
2503
2504 case EF_ARM_DYNSYMSUSESEGIDX:
2505 strcat (buf, ", dynamic symbols use segment index");
2506 break;
2507
2508 case EF_ARM_MAPSYMSFIRST:
2509 strcat (buf, ", mapping symbols precede others");
2510 break;
2511
2512 default:
2513 unknown = 1;
2514 break;
2515 }
2516 }
2517 break;
2518
d507cf36
PB		 2519 case EF_ARM_EABI_VER3:
2520 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2521 break;
2522
2523 case EF_ARM_EABI_VER4:
2524 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2525 while (e_flags)
2526 {
2527 unsigned flag;
2528
2529 /* Process flags one bit at a time. */
2530 flag = e_flags & - e_flags;
2531 e_flags &= ~ flag;
2532
2533 switch (flag)
2534 {
2535 case EF_ARM_BE8:
2536 strcat (buf, ", BE8");
2537 break;
2538
2539 case EF_ARM_LE8:
2540 strcat (buf, ", LE8");
2541 break;
2542
2543 default:
2544 unknown = 1;
2545 break;
2546 }
2547 break;
2548 }
2549 break;
3a4a14e9
PB		 2550
2551 case EF_ARM_EABI_VER5:
2552 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2553 while (e_flags)
2554 {
2555 unsigned flag;
2556
2557 /* Process flags one bit at a time. */
2558 flag = e_flags & - e_flags;
2559 e_flags &= ~ flag;
2560
2561 switch (flag)
2562 {
2563 case EF_ARM_BE8:
2564 strcat (buf, ", BE8");
2565 break;
2566
2567 case EF_ARM_LE8:
2568 strcat (buf, ", LE8");
2569 break;
2570
3bfcb652
NC		 2571 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2572 strcat (buf, ", soft-float ABI");
2573 break;
2574
2575 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2576 strcat (buf, ", hard-float ABI");
2577 break;
2578
d507cf36
PB		 2579 default:
2580 unknown = 1;
2581 break;
2582 }
2583 }
2584 break;
2585
f3485b74 2586 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2587 strcat (buf, ", GNU EABI");
f3485b74
NC		 2588 while (e_flags)
2589 {
2590 unsigned flag;
76da6bbe 2591
f3485b74
NC		 2592 /* Process flags one bit at a time. */
2593 flag = e_flags & - e_flags;
2594 e_flags &= ~ flag;
76da6bbe 2595
f3485b74
NC		 2596 switch (flag)
2597 {
a5bcd848 2598 case EF_ARM_INTERWORK:
f3485b74
NC		 2599 strcat (buf, ", interworking enabled");
2600 break;
76da6bbe 2601
a5bcd848 2602 case EF_ARM_APCS_26:
f3485b74
NC		 2603 strcat (buf, ", uses APCS/26");
2604 break;
76da6bbe 2605
a5bcd848 2606 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2607 strcat (buf, ", uses APCS/float");
2608 break;
76da6bbe 2609
a5bcd848 2610 case EF_ARM_PIC:
f3485b74
NC		 2611 strcat (buf, ", position independent");
2612 break;
76da6bbe 2613
a5bcd848 2614 case EF_ARM_ALIGN8:
f3485b74
NC		 2615 strcat (buf, ", 8 bit structure alignment");
2616 break;
76da6bbe 2617
a5bcd848 2618 case EF_ARM_NEW_ABI:
f3485b74
NC		 2619 strcat (buf, ", uses new ABI");
2620 break;
76da6bbe 2621
a5bcd848 2622 case EF_ARM_OLD_ABI:
f3485b74
NC		 2623 strcat (buf, ", uses old ABI");
2624 break;
76da6bbe 2625
a5bcd848 2626 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2627 strcat (buf, ", software FP");
2628 break;
76da6bbe 2629
90e01f86
ILT		 2630 case EF_ARM_VFP_FLOAT:
2631 strcat (buf, ", VFP");
2632 break;
2633
fde78edd
NC		 2634 case EF_ARM_MAVERICK_FLOAT:
2635 strcat (buf, ", Maverick FP");
2636 break;
2637
f3485b74
NC		 2638 default:
2639 unknown = 1;
2640 break;
2641 }
2642 }
2643 }
f3485b74
NC		 2644
2645 if (unknown)
2b692964 2646 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2647}
2648
343433df
AB		 2649static void
2650decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2651{
2652 --size; /* Leave space for null terminator. */
2653
2654 switch (e_flags & EF_AVR_MACH)
2655 {
2656 case E_AVR_MACH_AVR1:
2657 strncat (buf, ", avr:1", size);
2658 break;
2659 case E_AVR_MACH_AVR2:
2660 strncat (buf, ", avr:2", size);
2661 break;
2662 case E_AVR_MACH_AVR25:
2663 strncat (buf, ", avr:25", size);
2664 break;
2665 case E_AVR_MACH_AVR3:
2666 strncat (buf, ", avr:3", size);
2667 break;
2668 case E_AVR_MACH_AVR31:
2669 strncat (buf, ", avr:31", size);
2670 break;
2671 case E_AVR_MACH_AVR35:
2672 strncat (buf, ", avr:35", size);
2673 break;
2674 case E_AVR_MACH_AVR4:
2675 strncat (buf, ", avr:4", size);
2676 break;
2677 case E_AVR_MACH_AVR5:
2678 strncat (buf, ", avr:5", size);
2679 break;
2680 case E_AVR_MACH_AVR51:
2681 strncat (buf, ", avr:51", size);
2682 break;
2683 case E_AVR_MACH_AVR6:
2684 strncat (buf, ", avr:6", size);
2685 break;
2686 case E_AVR_MACH_AVRTINY:
2687 strncat (buf, ", avr:100", size);
2688 break;
2689 case E_AVR_MACH_XMEGA1:
2690 strncat (buf, ", avr:101", size);
2691 break;
2692 case E_AVR_MACH_XMEGA2:
2693 strncat (buf, ", avr:102", size);
2694 break;
2695 case E_AVR_MACH_XMEGA3:
2696 strncat (buf, ", avr:103", size);
2697 break;
2698 case E_AVR_MACH_XMEGA4:
2699 strncat (buf, ", avr:104", size);
2700 break;
2701 case E_AVR_MACH_XMEGA5:
2702 strncat (buf, ", avr:105", size);
2703 break;
2704 case E_AVR_MACH_XMEGA6:
2705 strncat (buf, ", avr:106", size);
2706 break;
2707 case E_AVR_MACH_XMEGA7:
2708 strncat (buf, ", avr:107", size);
2709 break;
2710 default:
2711 strncat (buf, ", avr:<unknown>", size);
2712 break;
2713 }
2714
2715 size -= strlen (buf);
2716 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2717 strncat (buf, ", link-relax", size);
2718}
2719
35c08157
KLC		 2720static void
2721decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2722{
2723 unsigned abi;
2724 unsigned arch;
2725 unsigned config;
2726 unsigned version;
2727 int has_fpu = 0;
2728 int r = 0;
2729
2730 static const char *ABI_STRINGS[] =
2731 {
2732 "ABI v0", /* use r5 as return register; only used in N1213HC */
2733 "ABI v1", /* use r0 as return register */
2734 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2735 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2736 "AABI",
2737 "ABI2 FP+"
35c08157
KLC		 2738 };
2739 static const char *VER_STRINGS[] =
2740 {
2741 "Andes ELF V1.3 or older",
2742 "Andes ELF V1.3.1",
2743 "Andes ELF V1.4"
2744 };
2745 static const char *ARCH_STRINGS[] =
2746 {
2747 "",
2748 "Andes Star v1.0",
2749 "Andes Star v2.0",
2750 "Andes Star v3.0",
2751 "Andes Star v3.0m"
2752 };
2753
2754 abi = EF_NDS_ABI & e_flags;
2755 arch = EF_NDS_ARCH & e_flags;
2756 config = EF_NDS_INST & e_flags;
2757 version = EF_NDS32_ELF_VERSION & e_flags;
2758
2759 memset (buf, 0, size);
2760
2761 switch (abi)
2762 {
2763 case E_NDS_ABI_V0:
2764 case E_NDS_ABI_V1:
2765 case E_NDS_ABI_V2:
2766 case E_NDS_ABI_V2FP:
2767 case E_NDS_ABI_AABI:
40c7a7cb 2768 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2769 /* In case there are holes in the array. */
2770 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2771 break;
2772
2773 default:
2774 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2775 break;
2776 }
2777
2778 switch (version)
2779 {
2780 case E_NDS32_ELF_VER_1_2:
2781 case E_NDS32_ELF_VER_1_3:
2782 case E_NDS32_ELF_VER_1_4:
2783 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2784 break;
2785
2786 default:
2787 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2788 break;
2789 }
2790
2791 if (E_NDS_ABI_V0 == abi)
2792 {
2793 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2794 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2795 if (arch == E_NDS_ARCH_STAR_V1_0)
2796 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2797 return;
2798 }
2799
2800 switch (arch)
2801 {
2802 case E_NDS_ARCH_STAR_V1_0:
2803 case E_NDS_ARCH_STAR_V2_0:
2804 case E_NDS_ARCH_STAR_V3_0:
2805 case E_NDS_ARCH_STAR_V3_M:
2806 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2807 break;
2808
2809 default:
2810 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2811 /* ARCH version determines how the e_flags are interpreted.
2812 If it is unknown, we cannot proceed. */
2813 return;
2814 }
2815
2816 /* Newer ABI; Now handle architecture specific flags. */
2817 if (arch == E_NDS_ARCH_STAR_V1_0)
2818 {
2819 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2820 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2821
2822 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2823 r += snprintf (buf + r, size -r, ", MAC");
2824
2825 if (config & E_NDS32_HAS_DIV_INST)
2826 r += snprintf (buf + r, size -r, ", DIV");
2827
2828 if (config & E_NDS32_HAS_16BIT_INST)
2829 r += snprintf (buf + r, size -r, ", 16b");
2830 }
2831 else
2832 {
2833 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2834 {
2835 if (version <= E_NDS32_ELF_VER_1_3)
2836 r += snprintf (buf + r, size -r, ", [B8]");
2837 else
2838 r += snprintf (buf + r, size -r, ", EX9");
2839 }
2840
2841 if (config & E_NDS32_HAS_MAC_DX_INST)
2842 r += snprintf (buf + r, size -r, ", MAC_DX");
2843
2844 if (config & E_NDS32_HAS_DIV_DX_INST)
2845 r += snprintf (buf + r, size -r, ", DIV_DX");
2846
2847 if (config & E_NDS32_HAS_16BIT_INST)
2848 {
2849 if (version <= E_NDS32_ELF_VER_1_3)
2850 r += snprintf (buf + r, size -r, ", 16b");
2851 else
2852 r += snprintf (buf + r, size -r, ", IFC");
2853 }
2854 }
2855
2856 if (config & E_NDS32_HAS_EXT_INST)
2857 r += snprintf (buf + r, size -r, ", PERF1");
2858
2859 if (config & E_NDS32_HAS_EXT2_INST)
2860 r += snprintf (buf + r, size -r, ", PERF2");
2861
2862 if (config & E_NDS32_HAS_FPU_INST)
2863 {
2864 has_fpu = 1;
2865 r += snprintf (buf + r, size -r, ", FPU_SP");
2866 }
2867
2868 if (config & E_NDS32_HAS_FPU_DP_INST)
2869 {
2870 has_fpu = 1;
2871 r += snprintf (buf + r, size -r, ", FPU_DP");
2872 }
2873
2874 if (config & E_NDS32_HAS_FPU_MAC_INST)
2875 {
2876 has_fpu = 1;
2877 r += snprintf (buf + r, size -r, ", FPU_MAC");
2878 }
2879
2880 if (has_fpu)
2881 {
2882 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2883 {
2884 case E_NDS32_FPU_REG_8SP_4DP:
2885 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2886 break;
2887 case E_NDS32_FPU_REG_16SP_8DP:
2888 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2889 break;
2890 case E_NDS32_FPU_REG_32SP_16DP:
2891 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2892 break;
2893 case E_NDS32_FPU_REG_32SP_32DP:
2894 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2895 break;
2896 }
2897 }
2898
2899 if (config & E_NDS32_HAS_AUDIO_INST)
2900 r += snprintf (buf + r, size -r, ", AUDIO");
2901
2902 if (config & E_NDS32_HAS_STRING_INST)
2903 r += snprintf (buf + r, size -r, ", STR");
2904
2905 if (config & E_NDS32_HAS_REDUCED_REGS)
2906 r += snprintf (buf + r, size -r, ", 16REG");
2907
2908 if (config & E_NDS32_HAS_VIDEO_INST)
2909 {
2910 if (version <= E_NDS32_ELF_VER_1_3)
2911 r += snprintf (buf + r, size -r, ", VIDEO");
2912 else
2913 r += snprintf (buf + r, size -r, ", SATURATION");
2914 }
2915
2916 if (config & E_NDS32_HAS_ENCRIPT_INST)
2917 r += snprintf (buf + r, size -r, ", ENCRP");
2918
2919 if (config & E_NDS32_HAS_L2C_INST)
2920 r += snprintf (buf + r, size -r, ", L2C");
2921}
2922
252b5132 2923static char *
d3ba0551 2924get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2925{
b34976b6 2926 static char buf[1024];
252b5132
RH		 2927
2928 buf[0] = '\0';
76da6bbe 2929
252b5132
RH		 2930 if (e_flags)
2931 {
2932 switch (e_machine)
2933 {
2934 default:
2935 break;
2936
886a2506 2937 case EM_ARC_COMPACT2:
886a2506 2938 case EM_ARC_COMPACT:
a9522a21
AB		 2939 decode_ARC_machine_flags (e_flags, e_machine, buf);
2940 break;
886a2506 2941
f3485b74
NC		 2942 case EM_ARM:
2943 decode_ARM_machine_flags (e_flags, buf);
2944 break;
76da6bbe 2945
343433df
AB		 2946 case EM_AVR:
2947 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2948 break;
2949
781303ce
MF		 2950 case EM_BLACKFIN:
2951 if (e_flags & EF_BFIN_PIC)
2952 strcat (buf, ", PIC");
2953
2954 if (e_flags & EF_BFIN_FDPIC)
2955 strcat (buf, ", FDPIC");
2956
2957 if (e_flags & EF_BFIN_CODE_IN_L1)
2958 strcat (buf, ", code in L1");
2959
2960 if (e_flags & EF_BFIN_DATA_IN_L1)
2961 strcat (buf, ", data in L1");
2962
2963 break;
2964
ec2dfb42
AO		 2965 case EM_CYGNUS_FRV:
2966 switch (e_flags & EF_FRV_CPU_MASK)
2967 {
2968 case EF_FRV_CPU_GENERIC:
2969 break;
2970
2971 default:
2972 strcat (buf, ", fr???");
2973 break;
57346661 2974
ec2dfb42
AO		 2975 case EF_FRV_CPU_FR300:
2976 strcat (buf, ", fr300");
2977 break;
2978
2979 case EF_FRV_CPU_FR400:
2980 strcat (buf, ", fr400");
2981 break;
2982 case EF_FRV_CPU_FR405:
2983 strcat (buf, ", fr405");
2984 break;
2985
2986 case EF_FRV_CPU_FR450:
2987 strcat (buf, ", fr450");
2988 break;
2989
2990 case EF_FRV_CPU_FR500:
2991 strcat (buf, ", fr500");
2992 break;
2993 case EF_FRV_CPU_FR550:
2994 strcat (buf, ", fr550");
2995 break;
2996
2997 case EF_FRV_CPU_SIMPLE:
2998 strcat (buf, ", simple");
2999 break;
3000 case EF_FRV_CPU_TOMCAT:
3001 strcat (buf, ", tomcat");
3002 break;
3003 }
1c877e87 3004 break;
ec2dfb42 3005
53c7db4b 3006 case EM_68K:
425c6cb0 3007 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 3008 strcat (buf, ", m68000");
425c6cb0 3009 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 3010 strcat (buf, ", cpu32");
3011 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3012 strcat (buf, ", fido_a");
425c6cb0 3013 else
266abb8f 3014 {
2cf0635d
NC		 3015 char const * isa = _("unknown");
3016 char const * mac = _("unknown mac");
3017 char const * additional = NULL;
0112cd26 3018
c694fd50 3019 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 3020 {
c694fd50 3021 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 3022 isa = "A";
3023 additional = ", nodiv";
3024 break;
c694fd50 3025 case EF_M68K_CF_ISA_A:
266abb8f
NS		 3026 isa = "A";
3027 break;
c694fd50 3028 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 3029 isa = "A+";
3030 break;
c694fd50 3031 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 3032 isa = "B";
3033 additional = ", nousp";
3034 break;
c694fd50 3035 case EF_M68K_CF_ISA_B:
266abb8f
NS		 3036 isa = "B";
3037 break;
f608cd77
NS		 3038 case EF_M68K_CF_ISA_C:
3039 isa = "C";
3040 break;
3041 case EF_M68K_CF_ISA_C_NODIV:
3042 isa = "C";
3043 additional = ", nodiv";
3044 break;
266abb8f
NS		 3045 }
3046 strcat (buf, ", cf, isa ");
3047 strcat (buf, isa);
0b2e31dc
NS		 3048 if (additional)
3049 strcat (buf, additional);
c694fd50 3050 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 3051 strcat (buf, ", float");
c694fd50 3052 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 3053 {
3054 case 0:
3055 mac = NULL;
3056 break;
c694fd50 3057 case EF_M68K_CF_MAC:
266abb8f
NS		 3058 mac = "mac";
3059 break;
c694fd50 3060 case EF_M68K_CF_EMAC:
266abb8f
NS		 3061 mac = "emac";
3062 break;
f608cd77
NS		 3063 case EF_M68K_CF_EMAC_B:
3064 mac = "emac_b";
3065 break;
266abb8f
NS		 3066 }
3067 if (mac)
3068 {
3069 strcat (buf, ", ");
3070 strcat (buf, mac);
3071 }
266abb8f 3072 }
53c7db4b 3073 break;
33c63f9d 3074
153a2776
NC		 3075 case EM_CYGNUS_MEP:
3076 switch (e_flags & EF_MEP_CPU_MASK)
3077 {
3078 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3079 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3080 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3081 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3082 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3083 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3084 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3085 }
3086
3087 switch (e_flags & EF_MEP_COP_MASK)
3088 {
3089 case EF_MEP_COP_NONE: break;
3090 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3091 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3092 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3093 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3094 default: strcat (buf, _("<unknown MeP copro type>")); break;
3095 }
3096
3097 if (e_flags & EF_MEP_LIBRARY)
3098 strcat (buf, ", Built for Library");
3099
3100 if (e_flags & EF_MEP_INDEX_MASK)
3101 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3102 e_flags & EF_MEP_INDEX_MASK);
3103
3104 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3105 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3106 e_flags & ~ EF_MEP_ALL_FLAGS);
3107 break;
3108
252b5132
RH		 3109 case EM_PPC:
3110 if (e_flags & EF_PPC_EMB)
3111 strcat (buf, ", emb");
3112
3113 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 3114 strcat (buf, _(", relocatable"));
252b5132
RH		 3115
3116 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 3117 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 3118 break;
3119
ee67d69a
AM		 3120 case EM_PPC64:
3121 if (e_flags & EF_PPC64_ABI)
3122 {
3123 char abi[] = ", abiv0";
3124
3125 abi[6] += e_flags & EF_PPC64_ABI;
3126 strcat (buf, abi);
3127 }
3128 break;
3129
708e2187
NC		 3130 case EM_V800:
3131 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3132 strcat (buf, ", RH850 ABI");
0b4362b0 3133
708e2187
NC		 3134 if (e_flags & EF_V800_850E3)
3135 strcat (buf, ", V3 architecture");
3136
3137 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3138 strcat (buf, ", FPU not used");
3139
3140 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3141 strcat (buf, ", regmode: COMMON");
3142
3143 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3144 strcat (buf, ", r4 not used");
3145
3146 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3147 strcat (buf, ", r30 not used");
3148
3149 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3150 strcat (buf, ", r5 not used");
3151
3152 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3153 strcat (buf, ", r2 not used");
3154
3155 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3156 {
3157 switch (e_flags & - e_flags)
3158 {
3159 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3160 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 3161 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3162 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 3163 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3164 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3165 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3166 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3167 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3168 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3169 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3170 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3171 default: break;
3172 }
3173 }
3174 break;
3175
2b0337b0 3176 case EM_V850:
252b5132
RH		 3177 case EM_CYGNUS_V850:
3178 switch (e_flags & EF_V850_ARCH)
3179 {
78c8d46c
NC		 3180 case E_V850E3V5_ARCH:
3181 strcat (buf, ", v850e3v5");
3182 break;
1cd986c5
NC		 3183 case E_V850E2V3_ARCH:
3184 strcat (buf, ", v850e2v3");
3185 break;
3186 case E_V850E2_ARCH:
3187 strcat (buf, ", v850e2");
3188 break;
3189 case E_V850E1_ARCH:
3190 strcat (buf, ", v850e1");
8ad30312 3191 break;
252b5132
RH		 3192 case E_V850E_ARCH:
3193 strcat (buf, ", v850e");
3194 break;
252b5132
RH		 3195 case E_V850_ARCH:
3196 strcat (buf, ", v850");
3197 break;
3198 default:
2b692964 3199 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3200 break;
3201 }
3202 break;
3203
2b0337b0 3204 case EM_M32R:
252b5132
RH		 3205 case EM_CYGNUS_M32R:
3206 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3207 strcat (buf, ", m32r");
252b5132
RH		 3208 break;
3209
3210 case EM_MIPS:
4fe85591 3211 case EM_MIPS_RS3_LE:
252b5132
RH		 3212 if (e_flags & EF_MIPS_NOREORDER)
3213 strcat (buf, ", noreorder");
3214
3215 if (e_flags & EF_MIPS_PIC)
3216 strcat (buf, ", pic");
3217
3218 if (e_flags & EF_MIPS_CPIC)
3219 strcat (buf, ", cpic");
3220
d1bdd336
TS		 3221 if (e_flags & EF_MIPS_UCODE)
3222 strcat (buf, ", ugen_reserved");
3223
252b5132
RH		 3224 if (e_flags & EF_MIPS_ABI2)
3225 strcat (buf, ", abi2");
3226
43521d43
TS		 3227 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3228 strcat (buf, ", odk first");
3229
a5d22d2a
TS		 3230 if (e_flags & EF_MIPS_32BITMODE)
3231 strcat (buf, ", 32bitmode");
3232
ba92f887
MR		 3233 if (e_flags & EF_MIPS_NAN2008)
3234 strcat (buf, ", nan2008");
3235
fef1b0b3
SE		 3236 if (e_flags & EF_MIPS_FP64)
3237 strcat (buf, ", fp64");
3238
156c2f8b
NC		 3239 switch ((e_flags & EF_MIPS_MACH))
3240 {
3241 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3242 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3243 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3244 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3245 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3246 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3247 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3248 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3249 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3250 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3251 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3252 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3253 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3254 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3255 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3256 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3257 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3258 case 0:
3259 /* We simply ignore the field in this case to avoid confusion:
3260 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3261 extension. */
3262 break;
2b692964 3263 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3264 }
43521d43
TS		 3265
3266 switch ((e_flags & EF_MIPS_ABI))
3267 {
3268 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3269 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3270 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3271 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3272 case 0:
3273 /* We simply ignore the field in this case to avoid confusion:
3274 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3275 This means it is likely to be an o32 file, but not for
3276 sure. */
3277 break;
2b692964 3278 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3279 }
3280
3281 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3282 strcat (buf, ", mdmx");
3283
3284 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3285 strcat (buf, ", mips16");
3286
df58fc94
RS		 3287 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3288 strcat (buf, ", micromips");
3289
43521d43
TS		 3290 switch ((e_flags & EF_MIPS_ARCH))
3291 {
3292 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3293 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3294 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3295 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3296 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3297 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3298 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3299 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3300 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3301 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3302 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3303 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3304 }
252b5132 3305 break;
351b4b40 3306
35c08157
KLC		 3307 case EM_NDS32:
3308 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3309 break;
3310
ccde1100
AO		 3311 case EM_SH:
3312 switch ((e_flags & EF_SH_MACH_MASK))
3313 {
3314 case EF_SH1: strcat (buf, ", sh1"); break;
3315 case EF_SH2: strcat (buf, ", sh2"); break;
3316 case EF_SH3: strcat (buf, ", sh3"); break;
3317 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3318 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3319 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3320 case EF_SH3E: strcat (buf, ", sh3e"); break;
3321 case EF_SH4: strcat (buf, ", sh4"); break;
3322 case EF_SH5: strcat (buf, ", sh5"); break;
3323 case EF_SH2E: strcat (buf, ", sh2e"); break;
3324 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3325 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3326 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3327 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3328 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3329 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3330 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3331 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3332 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3333 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3334 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3335 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3336 }
3337
cec6a5b8
MR		 3338 if (e_flags & EF_SH_PIC)
3339 strcat (buf, ", pic");
3340
3341 if (e_flags & EF_SH_FDPIC)
3342 strcat (buf, ", fdpic");
ccde1100 3343 break;
948f632f 3344
73589c9d
CS		 3345 case EM_OR1K:
3346 if (e_flags & EF_OR1K_NODELAY)
3347 strcat (buf, ", no delay");
3348 break;
57346661 3349
351b4b40
RH		 3350 case EM_SPARCV9:
3351 if (e_flags & EF_SPARC_32PLUS)
3352 strcat (buf, ", v8+");
3353
3354 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3355 strcat (buf, ", ultrasparcI");
3356
3357 if (e_flags & EF_SPARC_SUN_US3)
3358 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3359
3360 if (e_flags & EF_SPARC_HAL_R1)
3361 strcat (buf, ", halr1");
3362
3363 if (e_flags & EF_SPARC_LEDATA)
3364 strcat (buf, ", ledata");
3365
3366 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3367 strcat (buf, ", tso");
3368
3369 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3370 strcat (buf, ", pso");
3371
3372 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3373 strcat (buf, ", rmo");
3374 break;
7d466069 3375
103f02d3
UD		 3376 case EM_PARISC:
3377 switch (e_flags & EF_PARISC_ARCH)
3378 {
3379 case EFA_PARISC_1_0:
3380 strcpy (buf, ", PA-RISC 1.0");
3381 break;
3382 case EFA_PARISC_1_1:
3383 strcpy (buf, ", PA-RISC 1.1");
3384 break;
3385 case EFA_PARISC_2_0:
3386 strcpy (buf, ", PA-RISC 2.0");
3387 break;
3388 default:
3389 break;
3390 }
3391 if (e_flags & EF_PARISC_TRAPNIL)
3392 strcat (buf, ", trapnil");
3393 if (e_flags & EF_PARISC_EXT)
3394 strcat (buf, ", ext");
3395 if (e_flags & EF_PARISC_LSB)
3396 strcat (buf, ", lsb");
3397 if (e_flags & EF_PARISC_WIDE)
3398 strcat (buf, ", wide");
3399 if (e_flags & EF_PARISC_NO_KABP)
3400 strcat (buf, ", no kabp");
3401 if (e_flags & EF_PARISC_LAZYSWAP)
3402 strcat (buf, ", lazyswap");
30800947 3403 break;
76da6bbe 3404
7d466069 3405 case EM_PJ:
2b0337b0 3406 case EM_PJ_OLD:
7d466069
ILT		 3407 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3408 strcat (buf, ", new calling convention");
3409
3410 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3411 strcat (buf, ", gnu calling convention");
3412 break;
4d6ed7c8
NC		 3413
3414 case EM_IA_64:
3415 if ((e_flags & EF_IA_64_ABI64))
3416 strcat (buf, ", 64-bit");
3417 else
3418 strcat (buf, ", 32-bit");
3419 if ((e_flags & EF_IA_64_REDUCEDFP))
3420 strcat (buf, ", reduced fp model");
3421 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3422 strcat (buf, ", no function descriptors, constant gp");
3423 else if ((e_flags & EF_IA_64_CONS_GP))
3424 strcat (buf, ", constant gp");
3425 if ((e_flags & EF_IA_64_ABSOLUTE))
3426 strcat (buf, ", absolute");
28f997cf
TG		 3427 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3428 {
3429 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3430 strcat (buf, ", vms_linkages");
3431 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3432 {
3433 case EF_IA_64_VMS_COMCOD_SUCCESS:
3434 break;
3435 case EF_IA_64_VMS_COMCOD_WARNING:
3436 strcat (buf, ", warning");
3437 break;
3438 case EF_IA_64_VMS_COMCOD_ERROR:
3439 strcat (buf, ", error");
3440 break;
3441 case EF_IA_64_VMS_COMCOD_ABORT:
3442 strcat (buf, ", abort");
3443 break;
3444 default:
bee0ee85
NC		 3445 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3446 e_flags & EF_IA_64_VMS_COMCOD);
3447 strcat (buf, ", <unknown>");
28f997cf
TG		 3448 }
3449 }
4d6ed7c8 3450 break;
179d3252
JT		 3451
3452 case EM_VAX:
3453 if ((e_flags & EF_VAX_NONPIC))
3454 strcat (buf, ", non-PIC");
3455 if ((e_flags & EF_VAX_DFLOAT))
3456 strcat (buf, ", D-Float");
3457 if ((e_flags & EF_VAX_GFLOAT))
3458 strcat (buf, ", G-Float");
3459 break;
c7927a3c 3460
619ed720
EB		 3461 case EM_VISIUM:
3462 if (e_flags & EF_VISIUM_ARCH_MCM)
3463 strcat (buf, ", mcm");
3464 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3465 strcat (buf, ", mcm24");
3466 if (e_flags & EF_VISIUM_ARCH_GR6)
3467 strcat (buf, ", gr6");
3468 break;
3469
4046d87a 3470 case EM_RL78:
1740ba0c
NC		 3471 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3472 {
3473 case E_FLAG_RL78_ANY_CPU: break;
3474 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3475 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3476 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3477 }
856ea05c
KP		 3478 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3479 strcat (buf, ", 64-bit doubles");
4046d87a 3480 break;
0b4362b0 3481
c7927a3c
NC		 3482 case EM_RX:
3483 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3484 strcat (buf, ", 64-bit doubles");
3485 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3486 strcat (buf, ", dsp");
d4cb0ea0 3487 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3488 strcat (buf, ", pid");
708e2187
NC		 3489 if (e_flags & E_FLAG_RX_ABI)
3490 strcat (buf, ", RX ABI");
3525236c
NC		 3491 if (e_flags & E_FLAG_RX_SINSNS_SET)
3492 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3493 ? ", uses String instructions" : ", bans String instructions");
a117b0a5
YS		 3494 if (e_flags & E_FLAG_RX_V2)
3495 strcat (buf, ", V2");
d4cb0ea0 3496 break;
55786da2
AK		 3497
3498 case EM_S390:
3499 if (e_flags & EF_S390_HIGH_GPRS)
3500 strcat (buf, ", highgprs");
d4cb0ea0 3501 break;
40b36596
JM		 3502
3503 case EM_TI_C6000:
3504 if ((e_flags & EF_C6000_REL))
3505 strcat (buf, ", relocatable module");
d4cb0ea0 3506 break;
13761a11
NC		 3507
3508 case EM_MSP430:
3509 strcat (buf, _(": architecture variant: "));
3510 switch (e_flags & EF_MSP430_MACH)
3511 {
3512 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3513 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3514 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3515 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3516 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3517 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3518 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3519 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3520 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3521 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3522 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3523 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3524 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3525 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3526 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3527 default:
3528 strcat (buf, _(": unknown")); break;
3529 }
3530
3531 if (e_flags & ~ EF_MSP430_MACH)
3532 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3533 }
3534 }
3535
3536 return buf;
3537}
3538
252b5132 3539static const char *
d3ba0551
AM		 3540get_osabi_name (unsigned int osabi)
3541{
3542 static char buff[32];
3543
3544 switch (osabi)
3545 {
3546 case ELFOSABI_NONE: return "UNIX - System V";
3547 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3548 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3549 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3550 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3551 case ELFOSABI_AIX: return "UNIX - AIX";
3552 case ELFOSABI_IRIX: return "UNIX - IRIX";
3553 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3554 case ELFOSABI_TRU64: return "UNIX - TRU64";
3555 case ELFOSABI_MODESTO: return "Novell - Modesto";
3556 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3557 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3558 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3559 case ELFOSABI_AROS: return "AROS";
11636f9e 3560 case ELFOSABI_FENIXOS: return "FenixOS";
6d913794
NC		 3561 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3562 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
d3ba0551 3563 default:
40b36596
JM		 3564 if (osabi >= 64)
3565 switch (elf_header.e_machine)
3566 {
3567 case EM_ARM:
3568 switch (osabi)
3569 {
3570 case ELFOSABI_ARM: return "ARM";
3571 default:
3572 break;
3573 }
3574 break;
3575
3576 case EM_MSP430:
3577 case EM_MSP430_OLD:
619ed720 3578 case EM_VISIUM:
40b36596
JM		 3579 switch (osabi)
3580 {
3581 case ELFOSABI_STANDALONE: return _("Standalone App");
3582 default:
3583 break;
3584 }
3585 break;
3586
3587 case EM_TI_C6000:
3588 switch (osabi)
3589 {
3590 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3591 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3592 default:
3593 break;
3594 }
3595 break;
3596
3597 default:
3598 break;
3599 }
e9e44622 3600 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3601 return buff;
3602 }
3603}
3604
a06ea964
NC		 3605static const char *
3606get_aarch64_segment_type (unsigned long type)
3607{
3608 switch (type)
3609 {
3610 case PT_AARCH64_ARCHEXT:
3611 return "AARCH64_ARCHEXT";
3612 default:
3613 break;
3614 }
3615
3616 return NULL;
3617}
3618
b294bdf8
MM		 3619static const char *
3620get_arm_segment_type (unsigned long type)
3621{
3622 switch (type)
3623 {
3624 case PT_ARM_EXIDX:
3625 return "EXIDX";
3626 default:
3627 break;
3628 }
3629
3630 return NULL;
3631}
3632
d3ba0551
AM		 3633static const char *
3634get_mips_segment_type (unsigned long type)
252b5132
RH		 3635{
3636 switch (type)
3637 {
3638 case PT_MIPS_REGINFO:
3639 return "REGINFO";
3640 case PT_MIPS_RTPROC:
3641 return "RTPROC";
3642 case PT_MIPS_OPTIONS:
3643 return "OPTIONS";
351cdf24
MF		 3644 case PT_MIPS_ABIFLAGS:
3645 return "ABIFLAGS";
252b5132
RH		 3646 default:
3647 break;
3648 }
3649
3650 return NULL;
3651}
3652
103f02d3 3653static const char *
d3ba0551 3654get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3655{
3656 switch (type)
3657 {
3658 case PT_HP_TLS: return "HP_TLS";
3659 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3660 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3661 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3662 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3663 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3664 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3665 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3666 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3667 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3668 case PT_HP_PARALLEL: return "HP_PARALLEL";
3669 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3670 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3671 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3672 case PT_HP_STACK: return "HP_STACK";
3673 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3674 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3675 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3676 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3677 default:
3678 break;
3679 }
3680
3681 return NULL;
3682}
3683
4d6ed7c8 3684static const char *
d3ba0551 3685get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3686{
3687 switch (type)
3688 {
3689 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3690 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3691 case PT_HP_TLS: return "HP_TLS";
3692 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3693 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3694 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3695 default:
3696 break;
3697 }
3698
3699 return NULL;
3700}
3701
40b36596
JM		 3702static const char *
3703get_tic6x_segment_type (unsigned long type)
3704{
3705 switch (type)
3706 {
3707 case PT_C6000_PHATTR: return "C6000_PHATTR";
3708 default:
3709 break;
3710 }
3711
3712 return NULL;
3713}
3714
5522f910
NC		 3715static const char *
3716get_solaris_segment_type (unsigned long type)
3717{
3718 switch (type)
3719 {
3720 case 0x6464e550: return "PT_SUNW_UNWIND";
3721 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3722 case 0x6ffffff7: return "PT_LOSUNW";
3723 case 0x6ffffffa: return "PT_SUNWBSS";
3724 case 0x6ffffffb: return "PT_SUNWSTACK";
3725 case 0x6ffffffc: return "PT_SUNWDTRACE";
3726 case 0x6ffffffd: return "PT_SUNWCAP";
3727 case 0x6fffffff: return "PT_HISUNW";
3728 default: return NULL;
3729 }
3730}
3731
252b5132 3732static const char *
d3ba0551 3733get_segment_type (unsigned long p_type)
252b5132 3734{
b34976b6 3735 static char buff[32];
252b5132
RH		 3736
3737 switch (p_type)
3738 {
b34976b6
AM		 3739 case PT_NULL: return "NULL";
3740 case PT_LOAD: return "LOAD";
252b5132 3741 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3742 case PT_INTERP: return "INTERP";
3743 case PT_NOTE: return "NOTE";
3744 case PT_SHLIB: return "SHLIB";
3745 case PT_PHDR: return "PHDR";
13ae64f3 3746 case PT_TLS: return "TLS";
252b5132 3747
65765700
JJ		 3748 case PT_GNU_EH_FRAME:
3749 return "GNU_EH_FRAME";
2b05f1b7 3750 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3751 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3752
252b5132
RH		 3753 default:
3754 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3755 {
2cf0635d 3756 const char * result;
103f02d3 3757
252b5132
RH		 3758 switch (elf_header.e_machine)
3759 {
a06ea964
NC		 3760 case EM_AARCH64:
3761 result = get_aarch64_segment_type (p_type);
3762 break;
b294bdf8
MM		 3763 case EM_ARM:
3764 result = get_arm_segment_type (p_type);
3765 break;
252b5132 3766 case EM_MIPS:
4fe85591 3767 case EM_MIPS_RS3_LE:
252b5132
RH		 3768 result = get_mips_segment_type (p_type);
3769 break;
103f02d3
UD		 3770 case EM_PARISC:
3771 result = get_parisc_segment_type (p_type);
3772 break;
4d6ed7c8
NC		 3773 case EM_IA_64:
3774 result = get_ia64_segment_type (p_type);
3775 break;
40b36596
JM		 3776 case EM_TI_C6000:
3777 result = get_tic6x_segment_type (p_type);
3778 break;
252b5132
RH		 3779 default:
3780 result = NULL;
3781 break;
3782 }
103f02d3 3783
252b5132
RH		 3784 if (result != NULL)
3785 return result;
103f02d3 3786
252b5132
RH		 3787 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3788 }
3789 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3790 {
2cf0635d 3791 const char * result;
103f02d3
UD		 3792
3793 switch (elf_header.e_machine)
3794 {
3795 case EM_PARISC:
3796 result = get_parisc_segment_type (p_type);
3797 break;
00428cca
AM		 3798 case EM_IA_64:
3799 result = get_ia64_segment_type (p_type);
3800 break;
103f02d3 3801 default:
5522f910
NC		 3802 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3803 result = get_solaris_segment_type (p_type);
3804 else
3805 result = NULL;
103f02d3
UD		 3806 break;
3807 }
3808
3809 if (result != NULL)
3810 return result;
3811
3812 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3813 }
252b5132 3814 else
e9e44622 3815 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3816
3817 return buff;
3818 }
3819}
3820
3821static const char *
d3ba0551 3822get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3823{
3824 switch (sh_type)
3825 {
b34976b6
AM		 3826 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3827 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3828 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3829 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3830 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3831 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3832 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3833 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3834 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3835 case SHT_MIPS_RELD: return "MIPS_RELD";
3836 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3837 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3838 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3839 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3840 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3841 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3842 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3843 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3844 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3845 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3846 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3847 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3848 case SHT_MIPS_LINE: return "MIPS_LINE";
3849 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3850 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3851 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3852 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3853 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3854 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3855 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3856 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3857 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3858 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3859 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3860 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3861 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3862 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3863 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3864 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3865 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3866 default:
3867 break;
3868 }
3869 return NULL;
3870}
3871
103f02d3 3872static const char *
d3ba0551 3873get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3874{
3875 switch (sh_type)
3876 {
3877 case SHT_PARISC_EXT: return "PARISC_EXT";
3878 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3879 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3880 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3881 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3882 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3883 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3884 default:
3885 break;
3886 }
3887 return NULL;
3888}
3889
4d6ed7c8 3890static const char *
d3ba0551 3891get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3892{
18bd398b 3893 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3894 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3895 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3896
4d6ed7c8
NC		 3897 switch (sh_type)
3898 {
148b93f2
NC		 3899 case SHT_IA_64_EXT: return "IA_64_EXT";
3900 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3901 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3902 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3903 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3904 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3905 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3906 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3907 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3908 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3909 default:
3910 break;
3911 }
3912 return NULL;
3913}
3914
d2b2c203
DJ		 3915static const char *
3916get_x86_64_section_type_name (unsigned int sh_type)
3917{
3918 switch (sh_type)
3919 {
3920 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3921 default:
3922 break;
3923 }
3924 return NULL;
3925}
3926
a06ea964
NC		 3927static const char *
3928get_aarch64_section_type_name (unsigned int sh_type)
3929{
3930 switch (sh_type)
3931 {
3932 case SHT_AARCH64_ATTRIBUTES:
3933 return "AARCH64_ATTRIBUTES";
3934 default:
3935 break;
3936 }
3937 return NULL;
3938}
3939
40a18ebd
NC		 3940static const char *
3941get_arm_section_type_name (unsigned int sh_type)
3942{
3943 switch (sh_type)
3944 {
7f6fed87
NC		 3945 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3946 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3947 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3948 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3949 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3950 default:
3951 break;
3952 }
3953 return NULL;
3954}
3955
40b36596
JM		 3956static const char *
3957get_tic6x_section_type_name (unsigned int sh_type)
3958{
3959 switch (sh_type)
3960 {
3961 case SHT_C6000_UNWIND:
3962 return "C6000_UNWIND";
3963 case SHT_C6000_PREEMPTMAP:
3964 return "C6000_PREEMPTMAP";
3965 case SHT_C6000_ATTRIBUTES:
3966 return "C6000_ATTRIBUTES";
3967 case SHT_TI_ICODE:
3968 return "TI_ICODE";
3969 case SHT_TI_XREF:
3970 return "TI_XREF";
3971 case SHT_TI_HANDLER:
3972 return "TI_HANDLER";
3973 case SHT_TI_INITINFO:
3974 return "TI_INITINFO";
3975 case SHT_TI_PHATTRS:
3976 return "TI_PHATTRS";
3977 default:
3978 break;
3979 }
3980 return NULL;
3981}
3982
13761a11
NC		 3983static const char *
3984get_msp430x_section_type_name (unsigned int sh_type)
3985{
3986 switch (sh_type)
3987 {
3988 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3989 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3990 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3991 default: return NULL;
3992 }
3993}
3994
685080f2
NC		 3995static const char *
3996get_v850_section_type_name (unsigned int sh_type)
3997{
3998 switch (sh_type)
3999 {
4000 case SHT_V850_SCOMMON: return "V850 Small Common";
4001 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4002 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4003 case SHT_RENESAS_IOP: return "RENESAS IOP";
4004 case SHT_RENESAS_INFO: return "RENESAS INFO";
4005 default: return NULL;
4006 }
4007}
4008
252b5132 4009static const char *
d3ba0551 4010get_section_type_name (unsigned int sh_type)
252b5132 4011{
b34976b6 4012 static char buff[32];
9fb71ee4 4013 const char * result;
252b5132
RH		 4014
4015 switch (sh_type)
4016 {
4017 case SHT_NULL: return "NULL";
4018 case SHT_PROGBITS: return "PROGBITS";
4019 case SHT_SYMTAB: return "SYMTAB";
4020 case SHT_STRTAB: return "STRTAB";
4021 case SHT_RELA: return "RELA";
4022 case SHT_HASH: return "HASH";
4023 case SHT_DYNAMIC: return "DYNAMIC";
4024 case SHT_NOTE: return "NOTE";
4025 case SHT_NOBITS: return "NOBITS";
4026 case SHT_REL: return "REL";
4027 case SHT_SHLIB: return "SHLIB";
4028 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 4029 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4030 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4031 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 4032 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 4033 case SHT_GROUP: return "GROUP";
4034 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 4035 case SHT_GNU_verdef: return "VERDEF";
4036 case SHT_GNU_verneed: return "VERNEED";
4037 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 4038 case 0x6ffffff0: return "VERSYM";
4039 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 4040 case 0x7ffffffd: return "AUXILIARY";
4041 case 0x7fffffff: return "FILTER";
047b2264 4042 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 4043
4044 default:
4045 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4046 {
252b5132
RH		 4047 switch (elf_header.e_machine)
4048 {
4049 case EM_MIPS:
4fe85591 4050 case EM_MIPS_RS3_LE:
252b5132
RH		 4051 result = get_mips_section_type_name (sh_type);
4052 break;
103f02d3
UD		 4053 case EM_PARISC:
4054 result = get_parisc_section_type_name (sh_type);
4055 break;
4d6ed7c8
NC		 4056 case EM_IA_64:
4057 result = get_ia64_section_type_name (sh_type);
4058 break;
d2b2c203 4059 case EM_X86_64:
8a9036a4 4060 case EM_L1OM:
7a9068fe 4061 case EM_K1OM:
d2b2c203
DJ		 4062 result = get_x86_64_section_type_name (sh_type);
4063 break;
a06ea964
NC		 4064 case EM_AARCH64:
4065 result = get_aarch64_section_type_name (sh_type);
4066 break;
40a18ebd
NC		 4067 case EM_ARM:
4068 result = get_arm_section_type_name (sh_type);
4069 break;
40b36596
JM		 4070 case EM_TI_C6000:
4071 result = get_tic6x_section_type_name (sh_type);
4072 break;
13761a11
NC		 4073 case EM_MSP430:
4074 result = get_msp430x_section_type_name (sh_type);
4075 break;
685080f2
NC		 4076 case EM_V800:
4077 case EM_V850:
4078 case EM_CYGNUS_V850:
4079 result = get_v850_section_type_name (sh_type);
4080 break;
252b5132
RH		 4081 default:
4082 result = NULL;
4083 break;
4084 }
4085
4086 if (result != NULL)
4087 return result;
4088
9fb71ee4 4089 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
252b5132
RH		 4090 }
4091 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 4092 {
148b93f2
NC		 4093 switch (elf_header.e_machine)
4094 {
4095 case EM_IA_64:
4096 result = get_ia64_section_type_name (sh_type);
4097 break;
4098 default:
fd85a6a1
NC		 4099 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4100 result = get_solaris_section_type (sh_type);
4101 else
4102 result = NULL;
148b93f2
NC		 4103 break;
4104 }
4105
4106 if (result != NULL)
4107 return result;
4108
9fb71ee4 4109 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
148b93f2 4110 }
252b5132 4111 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 4112 {
4113 switch (elf_header.e_machine)
4114 {
4115 case EM_V800:
4116 case EM_V850:
4117 case EM_CYGNUS_V850:
9fb71ee4 4118 result = get_v850_section_type_name (sh_type);
a9fb83be 4119 break;
685080f2 4120 default:
9fb71ee4 4121 result = NULL;
685080f2
NC		 4122 break;
4123 }
4124
9fb71ee4
NC		 4125 if (result != NULL)
4126 return result;
4127
4128 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
685080f2 4129 }
252b5132 4130 else
a7dbfd1c
NC		 4131 /* This message is probably going to be displayed in a 15
4132 character wide field, so put the hex value first. */
4133 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 4134
252b5132
RH		 4135 return buff;
4136 }
4137}
4138
2979dc34 4139#define OPTION_DEBUG_DUMP 512
2c610e4b 4140#define OPTION_DYN_SYMS 513
fd2f0033
TT		 4141#define OPTION_DWARF_DEPTH 514
4142#define OPTION_DWARF_START 515
4723351a 4143#define OPTION_DWARF_CHECK 516
2979dc34 4144
85b1c36d 4145static struct option options[] =
252b5132 4146{
b34976b6 4147 {"all", no_argument, 0, 'a'},
252b5132
RH		 4148 {"file-header", no_argument, 0, 'h'},
4149 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4150 {"headers", no_argument, 0, 'e'},
4151 {"histogram", no_argument, 0, 'I'},
4152 {"segments", no_argument, 0, 'l'},
4153 {"sections", no_argument, 0, 'S'},
252b5132 4154 {"section-headers", no_argument, 0, 'S'},
f5842774 4155 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4156 {"section-details", no_argument, 0, 't'},
595cf52e 4157 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4158 {"symbols", no_argument, 0, 's'},
4159 {"syms", no_argument, 0, 's'},
2c610e4b 4160 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4161 {"relocs", no_argument, 0, 'r'},
4162 {"notes", no_argument, 0, 'n'},
4163 {"dynamic", no_argument, 0, 'd'},
a952a375 4164 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4165 {"version-info", no_argument, 0, 'V'},
4166 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4167 {"unwind", no_argument, 0, 'u'},
4145f1d5 4168 {"archive-index", no_argument, 0, 'c'},
b34976b6 4169 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4170 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4171 {"string-dump", required_argument, 0, 'p'},
0e602686 4172 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4173#ifdef SUPPORT_DISASSEMBLY
4174 {"instruction-dump", required_argument, 0, 'i'},
4175#endif
cf13d699 4176 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4177
fd2f0033
TT		 4178 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4179 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4180 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4181
b34976b6
AM		 4182 {"version", no_argument, 0, 'v'},
4183 {"wide", no_argument, 0, 'W'},
4184 {"help", no_argument, 0, 'H'},
4185 {0, no_argument, 0, 0}
252b5132
RH		 4186};
4187
4188static void
2cf0635d 4189usage (FILE * stream)
252b5132 4190{
92f01d61
JM		 4191 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4192 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4193 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4194 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4195 -h --file-header Display the ELF file header\n\
4196 -l --program-headers Display the program headers\n\
4197 --segments An alias for --program-headers\n\
4198 -S --section-headers Display the sections' header\n\
4199 --sections An alias for --section-headers\n\
f5842774 4200 -g --section-groups Display the section groups\n\
5477e8a0 4201 -t --section-details Display the section details\n\
8b53311e
NC		 4202 -e --headers Equivalent to: -h -l -S\n\
4203 -s --syms Display the symbol table\n\
3f08eb35 4204 --symbols An alias for --syms\n\
2c610e4b 4205 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4206 -n --notes Display the core notes (if present)\n\
4207 -r --relocs Display the relocations (if present)\n\
4208 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4209 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4210 -V --version-info Display the version sections (if present)\n\
1b31d05e 4211 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4212 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4213 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4214 -x --hex-dump=<number|name>\n\
4215 Dump the contents of section <number|name> as bytes\n\
4216 -p --string-dump=<number|name>\n\
4217 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4218 -R --relocated-dump=<number|name>\n\
4219 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4220 -z --decompress Decompress section before dumping it\n\
f9f0e732 4221 -w[lLiaprmfFsoRt] or\n\
1ed06042 4222 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4223 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4224 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4225 =addr,=cu_index]\n\
8b53311e 4226 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4227 fprintf (stream, _("\
4228 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4229 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4230 or deeper\n"));
252b5132 4231#ifdef SUPPORT_DISASSEMBLY
92f01d61 4232 fprintf (stream, _("\
09c11c86
NC		 4233 -i --instruction-dump=<number|name>\n\
4234 Disassemble the contents of section <number|name>\n"));
252b5132 4235#endif
92f01d61 4236 fprintf (stream, _("\
8b53311e
NC		 4237 -I --histogram Display histogram of bucket list lengths\n\
4238 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4239 @<file> Read options from <file>\n\
8b53311e
NC		 4240 -H --help Display this information\n\
4241 -v --version Display the version number of readelf\n"));
1118d252 4242
92f01d61
JM		 4243 if (REPORT_BUGS_TO[0] && stream == stdout)
4244 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4245
92f01d61 4246 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4247}
4248
18bd398b
NC		 4249/* Record the fact that the user wants the contents of section number
4250 SECTION to be displayed using the method(s) encoded as flags bits
4251 in TYPE. Note, TYPE can be zero if we are creating the array for
4252 the first time. */
4253
252b5132 4254static void
09c11c86 4255request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4256{
4257 if (section >= num_dump_sects)
4258 {
2cf0635d 4259 dump_type * new_dump_sects;
252b5132 4260
3f5e193b
NC		 4261 new_dump_sects = (dump_type *) calloc (section + 1,
4262 sizeof (* dump_sects));
252b5132
RH		 4263
4264 if (new_dump_sects == NULL)
591a748a 4265 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4266 else
4267 {
21b65bac
NC		 4268 if (dump_sects)
4269 {
4270 /* Copy current flag settings. */
4271 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132 4272
21b65bac
NC		 4273 free (dump_sects);
4274 }
252b5132
RH		 4275
4276 dump_sects = new_dump_sects;
4277 num_dump_sects = section + 1;
4278 }
4279 }
4280
4281 if (dump_sects)
b34976b6 4282 dump_sects[section] |= type;
252b5132
RH		 4283
4284 return;
4285}
4286
aef1f6d0
DJ		 4287/* Request a dump by section name. */
4288
4289static void
2cf0635d 4290request_dump_byname (const char * section, dump_type type)
aef1f6d0 4291{
2cf0635d 4292 struct dump_list_entry * new_request;
aef1f6d0 4293
3f5e193b
NC		 4294 new_request = (struct dump_list_entry *)
4295 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4296 if (!new_request)
591a748a 4297 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4298
4299 new_request->name = strdup (section);
4300 if (!new_request->name)
591a748a 4301 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4302
4303 new_request->type = type;
4304
4305 new_request->next = dump_sects_byname;
4306 dump_sects_byname = new_request;
4307}
4308
cf13d699
NC		 4309static inline void
4310request_dump (dump_type type)
4311{
4312 int section;
4313 char * cp;
4314
4315 do_dump++;
4316 section = strtoul (optarg, & cp, 0);
4317
4318 if (! *cp && section >= 0)
4319 request_dump_bynumber (section, type);
4320 else
4321 request_dump_byname (optarg, type);
4322}
4323
4324
252b5132 4325static void
2cf0635d 4326parse_args (int argc, char ** argv)
252b5132
RH		 4327{
4328 int c;
4329
4330 if (argc < 2)
92f01d61 4331 usage (stderr);
252b5132
RH		 4332
4333 while ((c = getopt_long
0e602686 4334 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4335 {
252b5132
RH		 4336 switch (c)
4337 {
4338 case 0:
4339 /* Long options. */
4340 break;
4341 case 'H':
92f01d61 4342 usage (stdout);
252b5132
RH		 4343 break;
4344
4345 case 'a':
b34976b6
AM		 4346 do_syms++;
4347 do_reloc++;
4348 do_unwind++;
4349 do_dynamic++;
4350 do_header++;
4351 do_sections++;
f5842774 4352 do_section_groups++;
b34976b6
AM		 4353 do_segments++;
4354 do_version++;
4355 do_histogram++;
4356 do_arch++;
4357 do_notes++;
252b5132 4358 break;
f5842774
L		 4359 case 'g':
4360 do_section_groups++;
4361 break;
5477e8a0 4362 case 't':
595cf52e 4363 case 'N':
5477e8a0
L		 4364 do_sections++;
4365 do_section_details++;
595cf52e 4366 break;
252b5132 4367 case 'e':
b34976b6
AM		 4368 do_header++;
4369 do_sections++;
4370 do_segments++;
252b5132 4371 break;
a952a375 4372 case 'A':
b34976b6 4373 do_arch++;
a952a375 4374 break;
252b5132 4375 case 'D':
b34976b6 4376 do_using_dynamic++;
252b5132
RH		 4377 break;
4378 case 'r':
b34976b6 4379 do_reloc++;
252b5132 4380 break;
4d6ed7c8 4381 case 'u':
b34976b6 4382 do_unwind++;
4d6ed7c8 4383 break;
252b5132 4384 case 'h':
b34976b6 4385 do_header++;
252b5132
RH		 4386 break;
4387 case 'l':
b34976b6 4388 do_segments++;
252b5132
RH		 4389 break;
4390 case 's':
b34976b6 4391 do_syms++;
252b5132
RH		 4392 break;
4393 case 'S':
b34976b6 4394 do_sections++;
252b5132
RH		 4395 break;
4396 case 'd':
b34976b6 4397 do_dynamic++;
252b5132 4398 break;
a952a375 4399 case 'I':
b34976b6 4400 do_histogram++;
a952a375 4401 break;
779fe533 4402 case 'n':
b34976b6 4403 do_notes++;
779fe533 4404 break;
4145f1d5
NC		 4405 case 'c':
4406 do_archive_index++;
4407 break;
252b5132 4408 case 'x':
cf13d699 4409 request_dump (HEX_DUMP);
aef1f6d0 4410 break;
09c11c86 4411 case 'p':
cf13d699
NC		 4412 request_dump (STRING_DUMP);
4413 break;
4414 case 'R':
4415 request_dump (RELOC_DUMP);
09c11c86 4416 break;
0e602686
NC		 4417 case 'z':
4418 decompress_dumps++;
4419 break;
252b5132 4420 case 'w':
b34976b6 4421 do_dump++;
252b5132 4422 if (optarg == 0)
613ff48b
CC		 4423 {
4424 do_debugging = 1;
4425 dwarf_select_sections_all ();
4426 }
252b5132
RH		 4427 else
4428 {
4429 do_debugging = 0;
4cb93e3b 4430 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4431 }
4432 break;
2979dc34 4433 case OPTION_DEBUG_DUMP:
b34976b6 4434 do_dump++;
2979dc34
JJ		 4435 if (optarg == 0)
4436 do_debugging = 1;
4437 else
4438 {
2979dc34 4439 do_debugging = 0;
4cb93e3b 4440 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4441 }
4442 break;
fd2f0033
TT		 4443 case OPTION_DWARF_DEPTH:
4444 {
4445 char *cp;
4446
4447 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4448 }
4449 break;
4450 case OPTION_DWARF_START:
4451 {
4452 char *cp;
4453
4454 dwarf_start_die = strtoul (optarg, & cp, 0);
4455 }
4456 break;
4723351a
CC		 4457 case OPTION_DWARF_CHECK:
4458 dwarf_check = 1;
4459 break;
2c610e4b
L		 4460 case OPTION_DYN_SYMS:
4461 do_dyn_syms++;
4462 break;
252b5132
RH		 4463#ifdef SUPPORT_DISASSEMBLY
4464 case 'i':
cf13d699
NC		 4465 request_dump (DISASS_DUMP);
4466 break;
252b5132
RH		 4467#endif
4468 case 'v':
4469 print_version (program_name);
4470 break;
4471 case 'V':
b34976b6 4472 do_version++;
252b5132 4473 break;
d974e256 4474 case 'W':
b34976b6 4475 do_wide++;
d974e256 4476 break;
252b5132 4477 default:
252b5132
RH		 4478 /* xgettext:c-format */
4479 error (_("Invalid option '-%c'\n"), c);
1a0670f3 4480 /* Fall through. */
252b5132 4481 case '?':
92f01d61 4482 usage (stderr);
252b5132
RH		 4483 }
4484 }
4485
4d6ed7c8 4486 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4487 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4488 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4489 && !do_section_groups && !do_archive_index
4490 && !do_dyn_syms)
92f01d61 4491 usage (stderr);
252b5132
RH		 4492}
4493
4494static const char *
d3ba0551 4495get_elf_class (unsigned int elf_class)
252b5132 4496{
b34976b6 4497 static char buff[32];
103f02d3 4498
252b5132
RH		 4499 switch (elf_class)
4500 {
4501 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4502 case ELFCLASS32: return "ELF32";
4503 case ELFCLASS64: return "ELF64";
ab5e7794 4504 default:
e9e44622 4505 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4506 return buff;
252b5132
RH		 4507 }
4508}
4509
4510static const char *
d3ba0551 4511get_data_encoding (unsigned int encoding)
252b5132 4512{
b34976b6 4513 static char buff[32];
103f02d3 4514
252b5132
RH		 4515 switch (encoding)
4516 {
4517 case ELFDATANONE: return _("none");
33c63f9d
CM		 4518 case ELFDATA2LSB: return _("2's complement, little endian");
4519 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4520 default:
e9e44622 4521 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4522 return buff;
252b5132
RH		 4523 }
4524}
4525
252b5132 4526/* Decode the data held in 'elf_header'. */
ee42cf8c 4527
252b5132 4528static int
d3ba0551 4529process_file_header (void)
252b5132 4530{
b34976b6
AM		 4531 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4532 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4533 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4534 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4535 {
4536 error
4537 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4538 return 0;
4539 }
4540
2dc4cec1
L		 4541 init_dwarf_regnames (elf_header.e_machine);
4542
252b5132
RH		 4543 if (do_header)
4544 {
4545 int i;
4546
4547 printf (_("ELF Header:\n"));
4548 printf (_(" Magic: "));
b34976b6
AM		 4549 for (i = 0; i < EI_NIDENT; i++)
4550 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4551 printf ("\n");
4552 printf (_(" Class: %s\n"),
b34976b6 4553 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4554 printf (_(" Data: %s\n"),
b34976b6 4555 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4556 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4557 elf_header.e_ident[EI_VERSION],
4558 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4559 ? "(current)"
b34976b6 4560 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4561 ? _("<unknown: %lx>")
789be9f7 4562 : "")));
252b5132 4563 printf (_(" OS/ABI: %s\n"),
b34976b6 4564 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4565 printf (_(" ABI Version: %d\n"),
b34976b6 4566 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4567 printf (_(" Type: %s\n"),
4568 get_file_type (elf_header.e_type));
4569 printf (_(" Machine: %s\n"),
4570 get_machine_name (elf_header.e_machine));
4571 printf (_(" Version: 0x%lx\n"),
4572 (unsigned long) elf_header.e_version);
76da6bbe 4573
f7a99963
NC		 4574 printf (_(" Entry point address: "));
4575 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4576 printf (_("\n Start of program headers: "));
4577 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4578 printf (_(" (bytes into file)\n Start of section headers: "));
4579 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4580 printf (_(" (bytes into file)\n"));
76da6bbe 4581
252b5132
RH		 4582 printf (_(" Flags: 0x%lx%s\n"),
4583 (unsigned long) elf_header.e_flags,
4584 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4585 printf (_(" Size of this header: %ld (bytes)\n"),
4586 (long) elf_header.e_ehsize);
4587 printf (_(" Size of program headers: %ld (bytes)\n"),
4588 (long) elf_header.e_phentsize);
2046a35d 4589 printf (_(" Number of program headers: %ld"),
252b5132 4590 (long) elf_header.e_phnum);
2046a35d
AM		 4591 if (section_headers != NULL
4592 && elf_header.e_phnum == PN_XNUM
4593 && section_headers[0].sh_info != 0)
cc5914eb 4594 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4595 putc ('\n', stdout);
252b5132
RH		 4596 printf (_(" Size of section headers: %ld (bytes)\n"),
4597 (long) elf_header.e_shentsize);
560f3c1c 4598 printf (_(" Number of section headers: %ld"),
252b5132 4599 (long) elf_header.e_shnum);
4fbb74a6 4600 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4601 printf (" (%ld)", (long) section_headers[0].sh_size);
4602 putc ('\n', stdout);
4603 printf (_(" Section header string table index: %ld"),
252b5132 4604 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4605 if (section_headers != NULL
4606 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4607 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4608 else if (elf_header.e_shstrndx != SHN_UNDEF
4609 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4610 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4611 putc ('\n', stdout);
4612 }
4613
4614 if (section_headers != NULL)
4615 {
2046a35d
AM		 4616 if (elf_header.e_phnum == PN_XNUM
4617 && section_headers[0].sh_info != 0)
4618 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4619 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4620 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4621 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4622 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4623 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4624 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4625 free (section_headers);
4626 section_headers = NULL;
252b5132 4627 }
103f02d3 4628
9ea033b2
NC		 4629 return 1;
4630}
4631
e0a31db1 4632static bfd_boolean
91d6fa6a 4633get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4634{
2cf0635d
NC		 4635 Elf32_External_Phdr * phdrs;
4636 Elf32_External_Phdr * external;
4637 Elf_Internal_Phdr * internal;
b34976b6 4638 unsigned int i;
e0a31db1
NC		 4639 unsigned int size = elf_header.e_phentsize;
4640 unsigned int num = elf_header.e_phnum;
4641
4642 /* PR binutils/17531: Cope with unexpected section header sizes. */
4643 if (size == 0 || num == 0)
4644 return FALSE;
4645 if (size < sizeof * phdrs)
4646 {
4647 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4648 return FALSE;
4649 }
4650 if (size > sizeof * phdrs)
4651 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4652
3f5e193b 4653 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4654 size, num, _("program headers"));
4655 if (phdrs == NULL)
4656 return FALSE;
9ea033b2 4657
91d6fa6a 4658 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4659 i < elf_header.e_phnum;
b34976b6 4660 i++, internal++, external++)
252b5132 4661 {
9ea033b2
NC		 4662 internal->p_type = BYTE_GET (external->p_type);
4663 internal->p_offset = BYTE_GET (external->p_offset);
4664 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4665 internal->p_paddr = BYTE_GET (external->p_paddr);
4666 internal->p_filesz = BYTE_GET (external->p_filesz);
4667 internal->p_memsz = BYTE_GET (external->p_memsz);
4668 internal->p_flags = BYTE_GET (external->p_flags);
4669 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4670 }
4671
9ea033b2 4672 free (phdrs);
e0a31db1 4673 return TRUE;
252b5132
RH		 4674}
4675
e0a31db1 4676static bfd_boolean
91d6fa6a 4677get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4678{
2cf0635d
NC		 4679 Elf64_External_Phdr * phdrs;
4680 Elf64_External_Phdr * external;
4681 Elf_Internal_Phdr * internal;
b34976b6 4682 unsigned int i;
e0a31db1
NC		 4683 unsigned int size = elf_header.e_phentsize;
4684 unsigned int num = elf_header.e_phnum;
4685
4686 /* PR binutils/17531: Cope with unexpected section header sizes. */
4687 if (size == 0 || num == 0)
4688 return FALSE;
4689 if (size < sizeof * phdrs)
4690 {
4691 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4692 return FALSE;
4693 }
4694 if (size > sizeof * phdrs)
4695 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4696
3f5e193b 4697 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4698 size, num, _("program headers"));
a6e9f9df 4699 if (!phdrs)
e0a31db1 4700 return FALSE;
9ea033b2 4701
91d6fa6a 4702 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4703 i < elf_header.e_phnum;
b34976b6 4704 i++, internal++, external++)
9ea033b2
NC		 4705 {
4706 internal->p_type = BYTE_GET (external->p_type);
4707 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4708 internal->p_offset = BYTE_GET (external->p_offset);
4709 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4710 internal->p_paddr = BYTE_GET (external->p_paddr);
4711 internal->p_filesz = BYTE_GET (external->p_filesz);
4712 internal->p_memsz = BYTE_GET (external->p_memsz);
4713 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4714 }
4715
4716 free (phdrs);
e0a31db1 4717 return TRUE;
9ea033b2 4718}
252b5132 4719
d93f0186
NC		 4720/* Returns 1 if the program headers were read into `program_headers'. */
4721
4722static int
2cf0635d 4723get_program_headers (FILE * file)
d93f0186 4724{
2cf0635d 4725 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4726
4727 /* Check cache of prior read. */
4728 if (program_headers != NULL)
4729 return 1;
4730
3f5e193b
NC		 4731 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4732 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4733
4734 if (phdrs == NULL)
4735 {
8b73c356
NC		 4736 error (_("Out of memory reading %u program headers\n"),
4737 elf_header.e_phnum);
d93f0186
NC		 4738 return 0;
4739 }
4740
4741 if (is_32bit_elf
4742 ? get_32bit_program_headers (file, phdrs)
4743 : get_64bit_program_headers (file, phdrs))
4744 {
4745 program_headers = phdrs;
4746 return 1;
4747 }
4748
4749 free (phdrs);
4750 return 0;
4751}
4752
2f62977e
NC		 4753/* Returns 1 if the program headers were loaded. */
4754
252b5132 4755static int
2cf0635d 4756process_program_headers (FILE * file)
252b5132 4757{
2cf0635d 4758 Elf_Internal_Phdr * segment;
b34976b6 4759 unsigned int i;
252b5132
RH		 4760
4761 if (elf_header.e_phnum == 0)
4762 {
82f2dbf7
NC		 4763 /* PR binutils/12467. */
4764 if (elf_header.e_phoff != 0)
4765 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4766 " header offset, but no program headers\n"));
82f2dbf7 4767 else if (do_segments)
252b5132 4768 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4769 return 0;
252b5132
RH		 4770 }
4771
4772 if (do_segments && !do_header)
4773 {
f7a99963
NC		 4774 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4775 printf (_("Entry point "));
4776 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4777 printf (_("\nThere are %d program headers, starting at offset "),
4778 elf_header.e_phnum);
4779 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4780 printf ("\n");
252b5132
RH		 4781 }
4782
d93f0186 4783 if (! get_program_headers (file))
252b5132 4784 return 0;
103f02d3 4785
252b5132
RH		 4786 if (do_segments)
4787 {
3a1a2036
NC		 4788 if (elf_header.e_phnum > 1)
4789 printf (_("\nProgram Headers:\n"));
4790 else
4791 printf (_("\nProgram Headers:\n"));
76da6bbe 4792
f7a99963
NC		 4793 if (is_32bit_elf)
4794 printf
4795 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4796 else if (do_wide)
4797 printf
4798 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4799 else
4800 {
4801 printf
4802 (_(" Type Offset VirtAddr PhysAddr\n"));
4803 printf
4804 (_(" FileSiz MemSiz Flags Align\n"));
4805 }
252b5132
RH		 4806 }
4807
252b5132 4808 dynamic_addr = 0;
1b228002 4809 dynamic_size = 0;
252b5132
RH		 4810
4811 for (i = 0, segment = program_headers;
4812 i < elf_header.e_phnum;
b34976b6 4813 i++, segment++)
252b5132
RH		 4814 {
4815 if (do_segments)
4816 {
103f02d3 4817 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4818
4819 if (is_32bit_elf)
4820 {
4821 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4822 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4823 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4824 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4825 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4826 printf ("%c%c%c ",
4827 (segment->p_flags & PF_R ? 'R' : ' '),
4828 (segment->p_flags & PF_W ? 'W' : ' '),
4829 (segment->p_flags & PF_X ? 'E' : ' '));
4830 printf ("%#lx", (unsigned long) segment->p_align);
4831 }
d974e256
JJ		 4832 else if (do_wide)
4833 {
4834 if ((unsigned long) segment->p_offset == segment->p_offset)
4835 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4836 else
4837 {
4838 print_vma (segment->p_offset, FULL_HEX);
4839 putchar (' ');
4840 }
4841
4842 print_vma (segment->p_vaddr, FULL_HEX);
4843 putchar (' ');
4844 print_vma (segment->p_paddr, FULL_HEX);
4845 putchar (' ');
4846
4847 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4848 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4849 else
4850 {
4851 print_vma (segment->p_filesz, FULL_HEX);
4852 putchar (' ');
4853 }
4854
4855 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4856 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4857 else
4858 {
f48e6c45 4859 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4860 }
4861
4862 printf (" %c%c%c ",
4863 (segment->p_flags & PF_R ? 'R' : ' '),
4864 (segment->p_flags & PF_W ? 'W' : ' '),
4865 (segment->p_flags & PF_X ? 'E' : ' '));
4866
4867 if ((unsigned long) segment->p_align == segment->p_align)
4868 printf ("%#lx", (unsigned long) segment->p_align);
4869 else
4870 {
4871 print_vma (segment->p_align, PREFIX_HEX);
4872 }
4873 }
f7a99963
NC		 4874 else
4875 {
4876 print_vma (segment->p_offset, FULL_HEX);
4877 putchar (' ');
4878 print_vma (segment->p_vaddr, FULL_HEX);
4879 putchar (' ');
4880 print_vma (segment->p_paddr, FULL_HEX);
4881 printf ("\n ");
4882 print_vma (segment->p_filesz, FULL_HEX);
4883 putchar (' ');
4884 print_vma (segment->p_memsz, FULL_HEX);
4885 printf (" %c%c%c ",
4886 (segment->p_flags & PF_R ? 'R' : ' '),
4887 (segment->p_flags & PF_W ? 'W' : ' '),
4888 (segment->p_flags & PF_X ? 'E' : ' '));
4889 print_vma (segment->p_align, HEX);
4890 }
252b5132
RH		 4891 }
4892
f54498b4
NC		 4893 if (do_segments)
4894 putc ('\n', stdout);
4895
252b5132
RH		 4896 switch (segment->p_type)
4897 {
252b5132
RH		 4898 case PT_DYNAMIC:
4899 if (dynamic_addr)
4900 error (_("more than one dynamic segment\n"));
4901
20737c13
AM		 4902 /* By default, assume that the .dynamic section is the first
4903 section in the DYNAMIC segment. */
4904 dynamic_addr = segment->p_offset;
4905 dynamic_size = segment->p_filesz;
f54498b4
NC		 4906 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4907 if (dynamic_addr + dynamic_size >= current_file_size)
4908 {
4909 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4910 dynamic_addr = dynamic_size = 0;
4911 }
20737c13 4912
b2d38a17
NC		 4913 /* Try to locate the .dynamic section. If there is
4914 a section header table, we can easily locate it. */
4915 if (section_headers != NULL)
4916 {
2cf0635d 4917 Elf_Internal_Shdr * sec;
b2d38a17 4918
89fac5e3
RS		 4919 sec = find_section (".dynamic");
4920 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4921 {
28f997cf
TG		 4922 /* A corresponding .dynamic section is expected, but on
4923 IA-64/OpenVMS it is OK for it to be missing. */
4924 if (!is_ia64_vms ())
4925 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4926 break;
4927 }
4928
42bb2e33 4929 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4930 {
4931 dynamic_size = 0;
4932 break;
4933 }
42bb2e33 4934
b2d38a17
NC		 4935 dynamic_addr = sec->sh_offset;
4936 dynamic_size = sec->sh_size;
4937
4938 if (dynamic_addr < segment->p_offset
4939 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4940 warn (_("the .dynamic section is not contained"
4941 " within the dynamic segment\n"));
b2d38a17 4942 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4943 warn (_("the .dynamic section is not the first section"
4944 " in the dynamic segment.\n"));
b2d38a17 4945 }
252b5132
RH		 4946 break;
4947
4948 case PT_INTERP:
fb52b2f4
NC		 4949 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4950 SEEK_SET))
252b5132
RH		 4951 error (_("Unable to find program interpreter name\n"));
4952 else
4953 {
f8eae8b2 4954 char fmt [32];
9495b2e6 4955 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4956
4957 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4958 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4959
252b5132 4960 program_interpreter[0] = 0;
7bd7b3ef
AM		 4961 if (fscanf (file, fmt, program_interpreter) <= 0)
4962 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4963
4964 if (do_segments)
f54498b4 4965 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4966 program_interpreter);
4967 }
4968 break;
4969 }
252b5132
RH		 4970 }
4971
c256ffe7 4972 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4973 {
4974 printf (_("\n Section to Segment mapping:\n"));
4975 printf (_(" Segment Sections...\n"));
4976
252b5132
RH		 4977 for (i = 0; i < elf_header.e_phnum; i++)
4978 {
9ad5cbcf 4979 unsigned int j;
2cf0635d 4980 Elf_Internal_Shdr * section;
252b5132
RH		 4981
4982 segment = program_headers + i;
b391a3e3 4983 section = section_headers + 1;
252b5132
RH		 4984
4985 printf (" %2.2d ", i);
4986
b34976b6 4987 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4988 {
f4638467
AM		 4989 if (!ELF_TBSS_SPECIAL (section, segment)
4990 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4991 printf ("%s ", printable_section_name (section));
252b5132
RH		 4992 }
4993
4994 putc ('\n',stdout);
4995 }
4996 }
4997
252b5132
RH		 4998 return 1;
4999}
5000
5001
d93f0186
NC		 5002/* Find the file offset corresponding to VMA by using the program headers. */
5003
5004static long
2cf0635d 5005offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 5006{
2cf0635d 5007 Elf_Internal_Phdr * seg;
d93f0186
NC		 5008
5009 if (! get_program_headers (file))
5010 {
5011 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5012 return (long) vma;
5013 }
5014
5015 for (seg = program_headers;
5016 seg < program_headers + elf_header.e_phnum;
5017 ++seg)
5018 {
5019 if (seg->p_type != PT_LOAD)
5020 continue;
5021
5022 if (vma >= (seg->p_vaddr & -seg->p_align)
5023 && vma + size <= seg->p_vaddr + seg->p_filesz)
5024 return vma - seg->p_vaddr + seg->p_offset;
5025 }
5026
5027 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 5028 (unsigned long) vma);
d93f0186
NC		 5029 return (long) vma;
5030}
5031
5032
049b0c3a
NC		 5033/* Allocate memory and load the sections headers into the global pointer
5034 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5035 generate any error messages if the load fails. */
5036
5037static bfd_boolean
5038get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 5039{
2cf0635d
NC		 5040 Elf32_External_Shdr * shdrs;
5041 Elf_Internal_Shdr * internal;
b34976b6 5042 unsigned int i;
049b0c3a
NC		 5043 unsigned int size = elf_header.e_shentsize;
5044 unsigned int num = probe ? 1 : elf_header.e_shnum;
5045
5046 /* PR binutils/17531: Cope with unexpected section header sizes. */
5047 if (size == 0 || num == 0)
5048 return FALSE;
5049 if (size < sizeof * shdrs)
5050 {
5051 if (! probe)
5052 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5053 return FALSE;
5054 }
5055 if (!probe && size > sizeof * shdrs)
5056 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 5057
3f5e193b 5058 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5059 size, num,
5060 probe ? NULL : _("section headers"));
5061 if (shdrs == NULL)
5062 return FALSE;
252b5132 5063
049b0c3a
NC		 5064 if (section_headers != NULL)
5065 free (section_headers);
3f5e193b
NC		 5066 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5067 sizeof (Elf_Internal_Shdr));
252b5132
RH		 5068 if (section_headers == NULL)
5069 {
049b0c3a 5070 if (!probe)
8b73c356 5071 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5072 return FALSE;
252b5132
RH		 5073 }
5074
5075 for (i = 0, internal = section_headers;
560f3c1c 5076 i < num;
b34976b6 5077 i++, internal++)
252b5132
RH		 5078 {
5079 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5080 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5081 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5082 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5083 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5084 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5085 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5086 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5087 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5088 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
315350be
NC		 5089 if (!probe && internal->sh_link > num)
5090 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5091 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5092 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
252b5132
RH		 5093 }
5094
5095 free (shdrs);
049b0c3a 5096 return TRUE;
252b5132
RH		 5097}
5098
049b0c3a
NC		 5099static bfd_boolean
5100get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 5101{
2cf0635d
NC		 5102 Elf64_External_Shdr * shdrs;
5103 Elf_Internal_Shdr * internal;
b34976b6 5104 unsigned int i;
049b0c3a
NC		 5105 unsigned int size = elf_header.e_shentsize;
5106 unsigned int num = probe ? 1 : elf_header.e_shnum;
5107
5108 /* PR binutils/17531: Cope with unexpected section header sizes. */
5109 if (size == 0 || num == 0)
5110 return FALSE;
5111 if (size < sizeof * shdrs)
5112 {
5113 if (! probe)
5114 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5115 return FALSE;
5116 }
5117 if (! probe && size > sizeof * shdrs)
5118 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 5119
3f5e193b 5120 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5121 size, num,
5122 probe ? NULL : _("section headers"));
5123 if (shdrs == NULL)
5124 return FALSE;
9ea033b2 5125
049b0c3a
NC		 5126 if (section_headers != NULL)
5127 free (section_headers);
3f5e193b
NC		 5128 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5129 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 5130 if (section_headers == NULL)
5131 {
049b0c3a 5132 if (! probe)
8b73c356 5133 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5134 return FALSE;
9ea033b2
NC		 5135 }
5136
5137 for (i = 0, internal = section_headers;
560f3c1c 5138 i < num;
b34976b6 5139 i++, internal++)
9ea033b2
NC		 5140 {
5141 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5142 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 5143 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5144 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5145 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5146 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 5147 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5148 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5149 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5150 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
315350be
NC		 5151 if (!probe && internal->sh_link > num)
5152 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5153 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5154 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
9ea033b2
NC		 5155 }
5156
5157 free (shdrs);
049b0c3a 5158 return TRUE;
9ea033b2
NC		 5159}
5160
252b5132 5161static Elf_Internal_Sym *
ba5cdace
NC		 5162get_32bit_elf_symbols (FILE * file,
5163 Elf_Internal_Shdr * section,
5164 unsigned long * num_syms_return)
252b5132 5165{
ba5cdace 5166 unsigned long number = 0;
dd24e3da 5167 Elf32_External_Sym * esyms = NULL;
ba5cdace 5168 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5169 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5170 Elf_Internal_Sym * psym;
b34976b6 5171 unsigned int j;
252b5132 5172
c9c1d674
EG		 5173 if (section->sh_size == 0)
5174 {
5175 if (num_syms_return != NULL)
5176 * num_syms_return = 0;
5177 return NULL;
5178 }
5179
dd24e3da 5180 /* Run some sanity checks first. */
c9c1d674 5181 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5182 {
c9c1d674
EG		 5183 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5184 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5185 goto exit_point;
dd24e3da
NC		 5186 }
5187
f54498b4
NC		 5188 if (section->sh_size > current_file_size)
5189 {
5190 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5191 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5192 goto exit_point;
5193 }
5194
dd24e3da
NC		 5195 number = section->sh_size / section->sh_entsize;
5196
5197 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5198 {
c9c1d674 5199 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5200 (unsigned long) section->sh_size,
5201 printable_section_name (section),
5202 (unsigned long) section->sh_entsize);
ba5cdace 5203 goto exit_point;
dd24e3da
NC		 5204 }
5205
3f5e193b
NC		 5206 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5207 section->sh_size, _("symbols"));
dd24e3da 5208 if (esyms == NULL)
ba5cdace 5209 goto exit_point;
252b5132 5210
6a40cf0c
NC		 5211 {
5212 elf_section_list * entry;
5213
5214 shndx = NULL;
5215 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5216 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5217 {
6a40cf0c
NC		 5218 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5219 entry->hdr->sh_offset,
5220 1, entry->hdr->sh_size,
5221 _("symbol table section indicies"));
5222 if (shndx == NULL)
5223 goto exit_point;
5224 /* PR17531: file: heap-buffer-overflow */
5225 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5226 {
5227 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5228 printable_section_name (entry->hdr),
5229 (unsigned long) entry->hdr->sh_size,
5230 (unsigned long) section->sh_size);
5231 goto exit_point;
5232 }
c9c1d674 5233 }
6a40cf0c 5234 }
9ad5cbcf 5235
3f5e193b 5236 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5237
5238 if (isyms == NULL)
5239 {
8b73c356
NC		 5240 error (_("Out of memory reading %lu symbols\n"),
5241 (unsigned long) number);
dd24e3da 5242 goto exit_point;
252b5132
RH		 5243 }
5244
dd24e3da 5245 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5246 {
5247 psym->st_name = BYTE_GET (esyms[j].st_name);
5248 psym->st_value = BYTE_GET (esyms[j].st_value);
5249 psym->st_size = BYTE_GET (esyms[j].st_size);
5250 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5251 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5252 psym->st_shndx
5253 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5254 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5255 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5256 psym->st_info = BYTE_GET (esyms[j].st_info);
5257 psym->st_other = BYTE_GET (esyms[j].st_other);
5258 }
5259
dd24e3da 5260 exit_point:
ba5cdace 5261 if (shndx != NULL)
9ad5cbcf 5262 free (shndx);
ba5cdace 5263 if (esyms != NULL)
dd24e3da 5264 free (esyms);
252b5132 5265
ba5cdace
NC		 5266 if (num_syms_return != NULL)
5267 * num_syms_return = isyms == NULL ? 0 : number;
5268
252b5132
RH		 5269 return isyms;
5270}
5271
9ea033b2 5272static Elf_Internal_Sym *
ba5cdace
NC		 5273get_64bit_elf_symbols (FILE * file,
5274 Elf_Internal_Shdr * section,
5275 unsigned long * num_syms_return)
9ea033b2 5276{
ba5cdace
NC		 5277 unsigned long number = 0;
5278 Elf64_External_Sym * esyms = NULL;
5279 Elf_External_Sym_Shndx * shndx = NULL;
5280 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5281 Elf_Internal_Sym * psym;
b34976b6 5282 unsigned int j;
9ea033b2 5283
c9c1d674
EG		 5284 if (section->sh_size == 0)
5285 {
5286 if (num_syms_return != NULL)
5287 * num_syms_return = 0;
5288 return NULL;
5289 }
5290
dd24e3da 5291 /* Run some sanity checks first. */
c9c1d674 5292 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5293 {
c9c1d674 5294 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5295 printable_section_name (section),
5296 (unsigned long) section->sh_entsize);
ba5cdace 5297 goto exit_point;
dd24e3da
NC		 5298 }
5299
f54498b4
NC		 5300 if (section->sh_size > current_file_size)
5301 {
5302 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5303 printable_section_name (section),
5304 (unsigned long) section->sh_size);
f54498b4
NC		 5305 goto exit_point;
5306 }
5307
dd24e3da
NC		 5308 number = section->sh_size / section->sh_entsize;
5309
5310 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5311 {
c9c1d674 5312 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5313 (unsigned long) section->sh_size,
5314 printable_section_name (section),
5315 (unsigned long) section->sh_entsize);
ba5cdace 5316 goto exit_point;
dd24e3da
NC		 5317 }
5318
3f5e193b
NC		 5319 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5320 section->sh_size, _("symbols"));
a6e9f9df 5321 if (!esyms)
ba5cdace 5322 goto exit_point;
9ea033b2 5323
6a40cf0c
NC		 5324 {
5325 elf_section_list * entry;
5326
5327 shndx = NULL;
5328 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5329 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5330 {
6a40cf0c
NC		 5331 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5332 entry->hdr->sh_offset,
5333 1, entry->hdr->sh_size,
5334 _("symbol table section indicies"));
5335 if (shndx == NULL)
5336 goto exit_point;
5337 /* PR17531: file: heap-buffer-overflow */
5338 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5339 {
5340 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5341 printable_section_name (entry->hdr),
5342 (unsigned long) entry->hdr->sh_size,
5343 (unsigned long) section->sh_size);
5344 goto exit_point;
5345 }
c9c1d674 5346 }
6a40cf0c 5347 }
9ad5cbcf 5348
3f5e193b 5349 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5350
5351 if (isyms == NULL)
5352 {
8b73c356
NC		 5353 error (_("Out of memory reading %lu symbols\n"),
5354 (unsigned long) number);
ba5cdace 5355 goto exit_point;
9ea033b2
NC		 5356 }
5357
ba5cdace 5358 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5359 {
5360 psym->st_name = BYTE_GET (esyms[j].st_name);
5361 psym->st_info = BYTE_GET (esyms[j].st_info);
5362 psym->st_other = BYTE_GET (esyms[j].st_other);
5363 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5364
4fbb74a6 5365 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5366 psym->st_shndx
5367 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5368 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5369 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5370
66543521
AM		 5371 psym->st_value = BYTE_GET (esyms[j].st_value);
5372 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5373 }
5374
ba5cdace
NC		 5375 exit_point:
5376 if (shndx != NULL)
9ad5cbcf 5377 free (shndx);
ba5cdace
NC		 5378 if (esyms != NULL)
5379 free (esyms);
5380
5381 if (num_syms_return != NULL)
5382 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5383
5384 return isyms;
5385}
5386
d1133906 5387static const char *
d3ba0551 5388get_elf_section_flags (bfd_vma sh_flags)
d1133906 5389{
5477e8a0 5390 static char buff[1024];
2cf0635d 5391 char * p = buff;
8d5ff12c 5392 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5393 int sindex;
5394 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5395 bfd_vma os_flags = 0;
5396 bfd_vma proc_flags = 0;
5397 bfd_vma unknown_flags = 0;
148b93f2 5398 static const struct
5477e8a0 5399 {
2cf0635d 5400 const char * str;
5477e8a0
L		 5401 int len;
5402 }
5403 flags [] =
5404 {
cfcac11d
NC		 5405 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5406 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5407 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5408 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5409 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5410 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5411 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5412 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5413 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5414 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5415 /* IA-64 specific. */
5416 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5417 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5418 /* IA-64 OpenVMS specific. */
5419 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5420 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5421 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5422 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5423 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5424 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5425 /* Generic. */
cfcac11d 5426 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5427 /* SPARC specific. */
77115a4a 5428 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
ac4c9b04
MG		 5429 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5430 /* ARM specific. */
5431 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
f0728ee3 5432 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
ac4c9b04 5433 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5477e8a0
L		 5434 };
5435
5436 if (do_section_details)
5437 {
8d5ff12c
L		 5438 sprintf (buff, "[%*.*lx]: ",
5439 field_size, field_size, (unsigned long) sh_flags);
5440 p += field_size + 4;
5477e8a0 5441 }
76da6bbe 5442
d1133906
NC		 5443 while (sh_flags)
5444 {
5445 bfd_vma flag;
5446
5447 flag = sh_flags & - sh_flags;
5448 sh_flags &= ~ flag;
76da6bbe 5449
5477e8a0 5450 if (do_section_details)
d1133906 5451 {
5477e8a0
L		 5452 switch (flag)
5453 {
91d6fa6a
NC		 5454 case SHF_WRITE: sindex = 0; break;
5455 case SHF_ALLOC: sindex = 1; break;
5456 case SHF_EXECINSTR: sindex = 2; break;
5457 case SHF_MERGE: sindex = 3; break;
5458 case SHF_STRINGS: sindex = 4; break;
5459 case SHF_INFO_LINK: sindex = 5; break;
5460 case SHF_LINK_ORDER: sindex = 6; break;
5461 case SHF_OS_NONCONFORMING: sindex = 7; break;
5462 case SHF_GROUP: sindex = 8; break;
5463 case SHF_TLS: sindex = 9; break;
18ae9cc1 5464 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5465 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5466
5477e8a0 5467 default:
91d6fa6a 5468 sindex = -1;
cfcac11d 5469 switch (elf_header.e_machine)
148b93f2 5470 {
cfcac11d 5471 case EM_IA_64:
148b93f2 5472 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5473 sindex = 10;
148b93f2 5474 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5475 sindex = 11;
148b93f2
NC		 5476#ifdef BFD64
5477 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5478 switch (flag)
5479 {
91d6fa6a
NC		 5480 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5481 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5482 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5483 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5484 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5485 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5486 default: break;
5487 }
5488#endif
cfcac11d
NC		 5489 break;
5490
caa83f8b 5491 case EM_386:
22abe556 5492 case EM_IAMCU:
caa83f8b 5493 case EM_X86_64:
7f502d6c 5494 case EM_L1OM:
7a9068fe 5495 case EM_K1OM:
cfcac11d
NC		 5496 case EM_OLD_SPARCV9:
5497 case EM_SPARC32PLUS:
5498 case EM_SPARCV9:
5499 case EM_SPARC:
18ae9cc1 5500 if (flag == SHF_ORDERED)
91d6fa6a 5501 sindex = 19;
cfcac11d 5502 break;
ac4c9b04
MG		 5503
5504 case EM_ARM:
5505 switch (flag)
5506 {
5507 case SHF_ENTRYSECT: sindex = 21; break;
f0728ee3 5508 case SHF_ARM_PURECODE: sindex = 22; break;
ac4c9b04
MG		 5509 case SHF_COMDEF: sindex = 23; break;
5510 default: break;
5511 }
5512 break;
5513
cfcac11d
NC		 5514 default:
5515 break;
148b93f2 5516 }
5477e8a0
L		 5517 }
5518
91d6fa6a 5519 if (sindex != -1)
5477e8a0 5520 {
8d5ff12c
L		 5521 if (p != buff + field_size + 4)
5522 {
5523 if (size < (10 + 2))
bee0ee85
NC		 5524 {
5525 warn (_("Internal error: not enough buffer room for section flag info"));
5526 return _("<unknown>");
5527 }
8d5ff12c
L		 5528 size -= 2;
5529 *p++ = ',';
5530 *p++ = ' ';
5531 }
5532
91d6fa6a
NC		 5533 size -= flags [sindex].len;
5534 p = stpcpy (p, flags [sindex].str);
5477e8a0 5535 }
3b22753a 5536 else if (flag & SHF_MASKOS)
8d5ff12c 5537 os_flags |= flag;
d1133906 5538 else if (flag & SHF_MASKPROC)
8d5ff12c 5539 proc_flags |= flag;
d1133906 5540 else
8d5ff12c 5541 unknown_flags |= flag;
5477e8a0
L		 5542 }
5543 else
5544 {
5545 switch (flag)
5546 {
5547 case SHF_WRITE: *p = 'W'; break;
5548 case SHF_ALLOC: *p = 'A'; break;
5549 case SHF_EXECINSTR: *p = 'X'; break;
5550 case SHF_MERGE: *p = 'M'; break;
5551 case SHF_STRINGS: *p = 'S'; break;
5552 case SHF_INFO_LINK: *p = 'I'; break;
5553 case SHF_LINK_ORDER: *p = 'L'; break;
5554 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5555 case SHF_GROUP: *p = 'G'; break;
5556 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5557 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5558 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5559
5560 default:
8a9036a4 5561 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5562 || elf_header.e_machine == EM_L1OM
5563 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5564 && flag == SHF_X86_64_LARGE)
5565 *p = 'l';
91f68a68 5566 else if (elf_header.e_machine == EM_ARM
f0728ee3 5567 && flag == SHF_ARM_PURECODE)
91f68a68 5568 *p = 'y';
5477e8a0
L		 5569 else if (flag & SHF_MASKOS)
5570 {
5571 *p = 'o';
5572 sh_flags &= ~ SHF_MASKOS;
5573 }
5574 else if (flag & SHF_MASKPROC)
5575 {
5576 *p = 'p';
5577 sh_flags &= ~ SHF_MASKPROC;
5578 }
5579 else
5580 *p = 'x';
5581 break;
5582 }
5583 p++;
d1133906
NC		 5584 }
5585 }
76da6bbe 5586
8d5ff12c
L		 5587 if (do_section_details)
5588 {
5589 if (os_flags)
5590 {
5591 size -= 5 + field_size;
5592 if (p != buff + field_size + 4)
5593 {
5594 if (size < (2 + 1))
bee0ee85
NC		 5595 {
5596 warn (_("Internal error: not enough buffer room for section flag info"));
5597 return _("<unknown>");
5598 }
8d5ff12c
L		 5599 size -= 2;
5600 *p++ = ',';
5601 *p++ = ' ';
5602 }
5603 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5604 (unsigned long) os_flags);
5605 p += 5 + field_size;
5606 }
5607 if (proc_flags)
5608 {
5609 size -= 7 + field_size;
5610 if (p != buff + field_size + 4)
5611 {
5612 if (size < (2 + 1))
bee0ee85
NC		 5613 {
5614 warn (_("Internal error: not enough buffer room for section flag info"));
5615 return _("<unknown>");
5616 }
8d5ff12c
L		 5617 size -= 2;
5618 *p++ = ',';
5619 *p++ = ' ';
5620 }
5621 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5622 (unsigned long) proc_flags);
5623 p += 7 + field_size;
5624 }
5625 if (unknown_flags)
5626 {
5627 size -= 10 + field_size;
5628 if (p != buff + field_size + 4)
5629 {
5630 if (size < (2 + 1))
bee0ee85
NC		 5631 {
5632 warn (_("Internal error: not enough buffer room for section flag info"));
5633 return _("<unknown>");
5634 }
8d5ff12c
L		 5635 size -= 2;
5636 *p++ = ',';
5637 *p++ = ' ';
5638 }
2b692964 5639 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5640 (unsigned long) unknown_flags);
5641 p += 10 + field_size;
5642 }
5643 }
5644
e9e44622 5645 *p = '\0';
d1133906
NC		 5646 return buff;
5647}
5648
77115a4a
L		 5649static unsigned int
5650get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5651{
5652 if (is_32bit_elf)
5653 {
5654 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
d8024a91 5655
77115a4a
L		 5656 chdr->ch_type = BYTE_GET (echdr->ch_type);
5657 chdr->ch_size = BYTE_GET (echdr->ch_size);
5658 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5659 return sizeof (*echdr);
5660 }
5661 else
5662 {
5663 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
d8024a91 5664
77115a4a
L		 5665 chdr->ch_type = BYTE_GET (echdr->ch_type);
5666 chdr->ch_size = BYTE_GET (echdr->ch_size);
5667 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5668 return sizeof (*echdr);
5669 }
5670}
5671
252b5132 5672static int
2cf0635d 5673process_section_headers (FILE * file)
252b5132 5674{
2cf0635d 5675 Elf_Internal_Shdr * section;
b34976b6 5676 unsigned int i;
252b5132
RH		 5677
5678 section_headers = NULL;
5679
5680 if (elf_header.e_shnum == 0)
5681 {
82f2dbf7
NC		 5682 /* PR binutils/12467. */
5683 if (elf_header.e_shoff != 0)
5684 warn (_("possibly corrupt ELF file header - it has a non-zero"
5685 " section header offset, but no section headers\n"));
5686 else if (do_sections)
252b5132
RH		 5687 printf (_("\nThere are no sections in this file.\n"));
5688
5689 return 1;
5690 }
5691
5692 if (do_sections && !do_header)
9ea033b2 5693 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5694 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5695
9ea033b2
NC		 5696 if (is_32bit_elf)
5697 {
049b0c3a 5698 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5699 return 0;
5700 }
049b0c3a 5701 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5702 return 0;
5703
5704 /* Read in the string table, so that we have names to display. */
0b49d371 5705 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5706 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5707 {
4fbb74a6 5708 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5709
c256ffe7
JJ		 5710 if (section->sh_size != 0)
5711 {
3f5e193b
NC		 5712 string_table = (char *) get_data (NULL, file, section->sh_offset,
5713 1, section->sh_size,
5714 _("string table"));
0de14b54 5715
c256ffe7
JJ		 5716 string_table_length = string_table != NULL ? section->sh_size : 0;
5717 }
252b5132
RH		 5718 }
5719
5720 /* Scan the sections for the dynamic symbol table
e3c8793a 5721 and dynamic string table and debug sections. */
252b5132
RH		 5722 dynamic_symbols = NULL;
5723 dynamic_strings = NULL;
5724 dynamic_syminfo = NULL;
6a40cf0c 5725 symtab_shndx_list = NULL;
103f02d3 5726
89fac5e3
RS		 5727 eh_addr_size = is_32bit_elf ? 4 : 8;
5728 switch (elf_header.e_machine)
5729 {
5730 case EM_MIPS:
5731 case EM_MIPS_RS3_LE:
5732 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5733 FDE addresses. However, the ABI also has a semi-official ILP32
5734 variant for which the normal FDE address size rules apply.
5735
5736 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5737 section, where XX is the size of longs in bits. Unfortunately,
5738 earlier compilers provided no way of distinguishing ILP32 objects
5739 from LP64 objects, so if there's any doubt, we should assume that
5740 the official LP64 form is being used. */
5741 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5742 && find_section (".gcc_compiled_long32") == NULL)
5743 eh_addr_size = 8;
5744 break;
0f56a26a
DD		 5745
5746 case EM_H8_300:
5747 case EM_H8_300H:
5748 switch (elf_header.e_flags & EF_H8_MACH)
5749 {
5750 case E_H8_MACH_H8300:
5751 case E_H8_MACH_H8300HN:
5752 case E_H8_MACH_H8300SN:
5753 case E_H8_MACH_H8300SXN:
5754 eh_addr_size = 2;
5755 break;
5756 case E_H8_MACH_H8300H:
5757 case E_H8_MACH_H8300S:
5758 case E_H8_MACH_H8300SX:
5759 eh_addr_size = 4;
5760 break;
5761 }
f4236fe4
DD		 5762 break;
5763
ff7eeb89 5764 case EM_M32C_OLD:
f4236fe4
DD		 5765 case EM_M32C:
5766 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5767 {
5768 case EF_M32C_CPU_M16C:
5769 eh_addr_size = 2;
5770 break;
5771 }
5772 break;
89fac5e3
RS		 5773 }
5774
76ca31c0
NC		 5775#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5776 do \
5777 { \
5778 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5779 if (section->sh_entsize != expected_entsize) \
9dd3a467 5780 { \
76ca31c0
NC		 5781 char buf[40]; \
5782 sprintf_vma (buf, section->sh_entsize); \
5783 /* Note: coded this way so that there is a single string for \
5784 translation. */ \
5785 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5786 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5787 (unsigned) expected_entsize); \
9dd3a467 5788 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5789 } \
5790 } \
08d8fa11 5791 while (0)
9dd3a467
NC		 5792
5793#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5794 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5795 sizeof (Elf64_External_##type))
5796
252b5132
RH		 5797 for (i = 0, section = section_headers;
5798 i < elf_header.e_shnum;
b34976b6 5799 i++, section++)
252b5132 5800 {
2cf0635d 5801 char * name = SECTION_NAME (section);
252b5132
RH		 5802
5803 if (section->sh_type == SHT_DYNSYM)
5804 {
5805 if (dynamic_symbols != NULL)
5806 {
5807 error (_("File contains multiple dynamic symbol tables\n"));
5808 continue;
5809 }
5810
08d8fa11 5811 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5812 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5813 }
5814 else if (section->sh_type == SHT_STRTAB
18bd398b 5815 && streq (name, ".dynstr"))
252b5132
RH		 5816 {
5817 if (dynamic_strings != NULL)
5818 {
5819 error (_("File contains multiple dynamic string tables\n"));
5820 continue;
5821 }
5822
3f5e193b
NC		 5823 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5824 1, section->sh_size,
5825 _("dynamic strings"));
59245841 5826 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5827 }
9ad5cbcf
AM		 5828 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5829 {
6a40cf0c
NC		 5830 elf_section_list * entry = xmalloc (sizeof * entry);
5831 entry->hdr = section;
5832 entry->next = symtab_shndx_list;
5833 symtab_shndx_list = entry;
9ad5cbcf 5834 }
08d8fa11
JJ		 5835 else if (section->sh_type == SHT_SYMTAB)
5836 CHECK_ENTSIZE (section, i, Sym);
5837 else if (section->sh_type == SHT_GROUP)
5838 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5839 else if (section->sh_type == SHT_REL)
5840 CHECK_ENTSIZE (section, i, Rel);
5841 else if (section->sh_type == SHT_RELA)
5842 CHECK_ENTSIZE (section, i, Rela);
252b5132 5843 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5844 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5845 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5846 || do_debug_str || do_debug_loc || do_debug_ranges
5847 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5848 && (const_strneq (name, ".debug_")
5849 || const_strneq (name, ".zdebug_")))
252b5132 5850 {
1b315056
CS		 5851 if (name[1] == 'z')
5852 name += sizeof (".zdebug_") - 1;
5853 else
5854 name += sizeof (".debug_") - 1;
252b5132
RH		 5855
5856 if (do_debugging
4723351a
CC		 5857 || (do_debug_info && const_strneq (name, "info"))
5858 || (do_debug_info && const_strneq (name, "types"))
5859 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5860 || (do_debug_lines && strcmp (name, "line") == 0)
5861 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5862 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5863 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5864 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5865 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5866 || (do_debug_aranges && const_strneq (name, "aranges"))
5867 || (do_debug_ranges && const_strneq (name, "ranges"))
5868 || (do_debug_frames && const_strneq (name, "frame"))
5869 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5870 || (do_debug_macinfo && const_strneq (name, "macro"))
5871 || (do_debug_str && const_strneq (name, "str"))
5872 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5873 || (do_debug_addr && const_strneq (name, "addr"))
5874 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5875 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5876 )
09c11c86 5877 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5878 }
a262ae96 5879 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5880 else if ((do_debugging || do_debug_info)
0112cd26 5881 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5882 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5883 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5884 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5885 else if (do_gdb_index && streq (name, ".gdb_index"))
5886 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5887 /* Trace sections for Itanium VMS. */
5888 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5889 || do_trace_aranges)
5890 && const_strneq (name, ".trace_"))
5891 {
5892 name += sizeof (".trace_") - 1;
5893
5894 if (do_debugging
5895 || (do_trace_info && streq (name, "info"))
5896 || (do_trace_abbrevs && streq (name, "abbrev"))
5897 || (do_trace_aranges && streq (name, "aranges"))
5898 )
5899 request_dump_bynumber (i, DEBUG_DUMP);
5900 }
252b5132
RH		 5901 }
5902
5903 if (! do_sections)
5904 return 1;
5905
3a1a2036
NC		 5906 if (elf_header.e_shnum > 1)
5907 printf (_("\nSection Headers:\n"));
5908 else
5909 printf (_("\nSection Header:\n"));
76da6bbe 5910
f7a99963 5911 if (is_32bit_elf)
595cf52e 5912 {
5477e8a0 5913 if (do_section_details)
595cf52e
L		 5914 {
5915 printf (_(" [Nr] Name\n"));
5477e8a0 5916 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5917 }
5918 else
5919 printf
5920 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5921 }
d974e256 5922 else if (do_wide)
595cf52e 5923 {
5477e8a0 5924 if (do_section_details)
595cf52e
L		 5925 {
5926 printf (_(" [Nr] Name\n"));
5477e8a0 5927 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5928 }
5929 else
5930 printf
5931 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5932 }
f7a99963
NC		 5933 else
5934 {
5477e8a0 5935 if (do_section_details)
595cf52e
L		 5936 {
5937 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5938 printf (_(" Type Address Offset Link\n"));
5939 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5940 }
5941 else
5942 {
5943 printf (_(" [Nr] Name Type Address Offset\n"));
5944 printf (_(" Size EntSize Flags Link Info Align\n"));
5945 }
f7a99963 5946 }
252b5132 5947
5477e8a0
L		 5948 if (do_section_details)
5949 printf (_(" Flags\n"));
5950
252b5132
RH		 5951 for (i = 0, section = section_headers;
5952 i < elf_header.e_shnum;
b34976b6 5953 i++, section++)
252b5132 5954 {
dd905818
NC		 5955 /* Run some sanity checks on the section header. */
5956
5957 /* Check the sh_link field. */
5958 switch (section->sh_type)
5959 {
5960 case SHT_SYMTAB_SHNDX:
5961 case SHT_GROUP:
5962 case SHT_HASH:
5963 case SHT_GNU_HASH:
5964 case SHT_GNU_versym:
5965 case SHT_REL:
5966 case SHT_RELA:
5967 if (section->sh_link < 1
5968 || section->sh_link > elf_header.e_shnum
5969 || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
5970 && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
5971 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
5972 i, section->sh_link);
5973 break;
5974
5975 case SHT_DYNAMIC:
5976 case SHT_SYMTAB:
5977 case SHT_DYNSYM:
5978 case SHT_GNU_verneed:
5979 case SHT_GNU_verdef:
5980 case SHT_GNU_LIBLIST:
5981 if (section->sh_link < 1
5982 || section->sh_link > elf_header.e_shnum
5983 || section_headers[section->sh_link].sh_type != SHT_STRTAB)
5984 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
5985 i, section->sh_link);
5986 break;
5987
5988 case SHT_INIT_ARRAY:
5989 case SHT_FINI_ARRAY:
5990 case SHT_PREINIT_ARRAY:
5991 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
5992 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
5993 i, section->sh_link);
5994 break;
5995
5996 default:
5997 /* FIXME: Add support for target specific section types. */
5998#if 0 /* Currently we do not check other section types as there are too
5999 many special cases. Stab sections for example have a type
6000 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6001 section. */
6002 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6003 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6004 i, section->sh_link);
6005#endif
6006 break;
6007 }
6008
6009 /* Check the sh_info field. */
6010 switch (section->sh_type)
6011 {
6012 case SHT_REL:
6013 case SHT_RELA:
6014 if (section->sh_info < 1
6015 || section->sh_info > elf_header.e_shnum
6016 || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6017 && section_headers[section->sh_info].sh_type != SHT_NOBITS
6018 && section_headers[section->sh_info].sh_type != SHT_NOTE
6019 && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6020 /* FIXME: Are other section types valid ? */
6021 && section_headers[section->sh_info].sh_type < SHT_LOOS))
6022 {
6023 if (section->sh_info == 0
6024 && (streq (SECTION_NAME (section), ".rel.dyn")
6025 || streq (SECTION_NAME (section), ".rela.dyn")))
6026 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6027 of zero. No idea why. I would have expected the index
6028 of the .plt section. */
6029 ;
6030 else
6031 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6032 i, section->sh_info);
6033 }
6034 break;
6035
6036 case SHT_DYNAMIC:
6037 case SHT_HASH:
6038 case SHT_SYMTAB_SHNDX:
6039 case SHT_INIT_ARRAY:
6040 case SHT_FINI_ARRAY:
6041 case SHT_PREINIT_ARRAY:
6042 if (section->sh_info != 0)
6043 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6044 i, section->sh_info);
6045 break;
6046
6047 case SHT_GROUP:
6048 case SHT_SYMTAB:
6049 case SHT_DYNSYM:
6050 /* A symbol index - we assume that it is valid. */
6051 break;
6052
6053 default:
6054 /* FIXME: Add support for target specific section types. */
6055 if (section->sh_type == SHT_NOBITS)
6056 /* NOBITS section headers with non-zero sh_info fields can be
6057 created when a binary is stripped of everything but its debug
6058 information. The stripped sections have their headers preserved but their types set to SHT_NOBITS. so do not check this type of section. */
6059 ;
6060 else if (section->sh_flags & SHF_INFO_LINK)
6061 {
6062 if (section->sh_info < 1 || section->sh_info > elf_header.e_shnum)
6063 warn (_("[%2u]: Expected link to another section in info field"), i);
6064 }
6065 else if (section->sh_type < SHT_LOOS && section->sh_info != 0)
6066 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6067 i, section->sh_info);
6068 break;
6069 }
6070
7bfd842d 6071 printf (" [%2u] ", i);
5477e8a0 6072 if (do_section_details)
74e1a04b 6073 printf ("%s\n ", printable_section_name (section));
595cf52e 6074 else
74e1a04b 6075 print_symbol (-17, SECTION_NAME (section));
0b4362b0 6076
ea52a088
NC		 6077 printf (do_wide ? " %-15s " : " %-15.15s ",
6078 get_section_type_name (section->sh_type));
0b4362b0 6079
f7a99963
NC		 6080 if (is_32bit_elf)
6081 {
cfcac11d
NC		 6082 const char * link_too_big = NULL;
6083
f7a99963 6084 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 6085
f7a99963
NC		 6086 printf ( " %6.6lx %6.6lx %2.2lx",
6087 (unsigned long) section->sh_offset,
6088 (unsigned long) section->sh_size,
6089 (unsigned long) section->sh_entsize);
d1133906 6090
5477e8a0
L		 6091 if (do_section_details)
6092 fputs (" ", stdout);
6093 else
6094 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6095
cfcac11d
NC		 6096 if (section->sh_link >= elf_header.e_shnum)
6097 {
6098 link_too_big = "";
6099 /* The sh_link value is out of range. Normally this indicates
caa83f8b 6100 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 6101 switch (elf_header.e_machine)
6102 {
caa83f8b 6103 case EM_386:
22abe556 6104 case EM_IAMCU:
caa83f8b 6105 case EM_X86_64:
7f502d6c 6106 case EM_L1OM:
7a9068fe 6107 case EM_K1OM:
cfcac11d
NC		 6108 case EM_OLD_SPARCV9:
6109 case EM_SPARC32PLUS:
6110 case EM_SPARCV9:
6111 case EM_SPARC:
6112 if (section->sh_link == (SHN_BEFORE & 0xffff))
6113 link_too_big = "BEFORE";
6114 else if (section->sh_link == (SHN_AFTER & 0xffff))
6115 link_too_big = "AFTER";
6116 break;
6117 default:
6118 break;
6119 }
6120 }
6121
6122 if (do_section_details)
6123 {
6124 if (link_too_big != NULL && * link_too_big)
6125 printf ("<%s> ", link_too_big);
6126 else
6127 printf ("%2u ", section->sh_link);
6128 printf ("%3u %2lu\n", section->sh_info,
6129 (unsigned long) section->sh_addralign);
6130 }
6131 else
6132 printf ("%2u %3u %2lu\n",
6133 section->sh_link,
6134 section->sh_info,
6135 (unsigned long) section->sh_addralign);
6136
6137 if (link_too_big && ! * link_too_big)
6138 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6139 i, section->sh_link);
f7a99963 6140 }
d974e256
JJ		 6141 else if (do_wide)
6142 {
6143 print_vma (section->sh_addr, LONG_HEX);
6144
6145 if ((long) section->sh_offset == section->sh_offset)
6146 printf (" %6.6lx", (unsigned long) section->sh_offset);
6147 else
6148 {
6149 putchar (' ');
6150 print_vma (section->sh_offset, LONG_HEX);
6151 }
6152
6153 if ((unsigned long) section->sh_size == section->sh_size)
6154 printf (" %6.6lx", (unsigned long) section->sh_size);
6155 else
6156 {
6157 putchar (' ');
6158 print_vma (section->sh_size, LONG_HEX);
6159 }
6160
6161 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6162 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6163 else
6164 {
6165 putchar (' ');
6166 print_vma (section->sh_entsize, LONG_HEX);
6167 }
6168
5477e8a0
L		 6169 if (do_section_details)
6170 fputs (" ", stdout);
6171 else
6172 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 6173
72de5009 6174 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 6175
6176 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 6177 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 6178 else
6179 {
6180 print_vma (section->sh_addralign, DEC);
6181 putchar ('\n');
6182 }
6183 }
5477e8a0 6184 else if (do_section_details)
595cf52e 6185 {
5477e8a0 6186 printf (" %-15.15s ",
595cf52e 6187 get_section_type_name (section->sh_type));
595cf52e
L		 6188 print_vma (section->sh_addr, LONG_HEX);
6189 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 6190 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 6191 else
6192 {
6193 printf (" ");
6194 print_vma (section->sh_offset, LONG_HEX);
6195 }
72de5009 6196 printf (" %u\n ", section->sh_link);
595cf52e 6197 print_vma (section->sh_size, LONG_HEX);
5477e8a0 6198 putchar (' ');
595cf52e
L		 6199 print_vma (section->sh_entsize, LONG_HEX);
6200
72de5009
AM		 6201 printf (" %-16u %lu\n",
6202 section->sh_info,
595cf52e
L		 6203 (unsigned long) section->sh_addralign);
6204 }
f7a99963
NC		 6205 else
6206 {
6207 putchar (' ');
6208 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 6209 if ((long) section->sh_offset == section->sh_offset)
6210 printf (" %8.8lx", (unsigned long) section->sh_offset);
6211 else
6212 {
6213 printf (" ");
6214 print_vma (section->sh_offset, LONG_HEX);
6215 }
f7a99963
NC		 6216 printf ("\n ");
6217 print_vma (section->sh_size, LONG_HEX);
6218 printf (" ");
6219 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 6220
d1133906 6221 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6222
72de5009
AM		 6223 printf (" %2u %3u %lu\n",
6224 section->sh_link,
6225 section->sh_info,
f7a99963
NC		 6226 (unsigned long) section->sh_addralign);
6227 }
5477e8a0
L		 6228
6229 if (do_section_details)
77115a4a
L		 6230 {
6231 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6232 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6233 {
6234 /* Minimum section size is 12 bytes for 32-bit compression
6235 header + 12 bytes for compressed data header. */
6236 unsigned char buf[24];
d8024a91 6237
77115a4a
L		 6238 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6239 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6240 sizeof (buf), _("compression header")))
6241 {
6242 Elf_Internal_Chdr chdr;
d8024a91
NC		 6243
6244 (void) get_compression_header (&chdr, buf);
6245
77115a4a
L		 6246 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6247 printf (" ZLIB, ");
6248 else
6249 printf (_(" [<unknown>: 0x%x], "),
6250 chdr.ch_type);
6251 print_vma (chdr.ch_size, LONG_HEX);
6252 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6253 }
6254 }
6255 }
252b5132
RH		 6256 }
6257
5477e8a0 6258 if (!do_section_details)
3dbcc61d 6259 {
9fb71ee4
NC		 6260 /* The ordering of the letters shown here matches the ordering of the
6261 corresponding SHF_xxx values, and hence the order in which these
6262 letters will be displayed to the user. */
6263 printf (_("Key to Flags:\n\
6264 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6265 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
fd85a6a1 6266 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
3dbcc61d 6267 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 6268 || elf_header.e_machine == EM_L1OM
6269 || elf_header.e_machine == EM_K1OM)
9fb71ee4 6270 printf (_("l (large), "));
91f68a68 6271 else if (elf_header.e_machine == EM_ARM)
f0728ee3 6272 printf (_("y (purecode), "));
9fb71ee4 6273 printf ("p (processor specific)\n");
0b4362b0 6274 }
d1133906 6275
252b5132
RH		 6276 return 1;
6277}
6278
f5842774
L		 6279static const char *
6280get_group_flags (unsigned int flags)
6281{
1449284b 6282 static char buff[128];
220453ec 6283
6d913794
NC		 6284 if (flags == 0)
6285 return "";
6286 else if (flags == GRP_COMDAT)
6287 return "COMDAT ";
f5842774 6288
6d913794
NC		 6289 snprintf (buff, 14, _("[0x%x: "), flags);
6290
6291 flags &= ~ GRP_COMDAT;
6292 if (flags & GRP_MASKOS)
6293 {
6294 strcat (buff, "<OS specific>");
6295 flags &= ~ GRP_MASKOS;
f5842774 6296 }
6d913794
NC		 6297
6298 if (flags & GRP_MASKPROC)
6299 {
6300 strcat (buff, "<PROC specific>");
6301 flags &= ~ GRP_MASKPROC;
6302 }
6303
6304 if (flags)
6305 strcat (buff, "<unknown>");
6306
6307 strcat (buff, "]");
f5842774
L		 6308 return buff;
6309}
6310
6311static int
2cf0635d 6312process_section_groups (FILE * file)
f5842774 6313{
2cf0635d 6314 Elf_Internal_Shdr * section;
f5842774 6315 unsigned int i;
2cf0635d
NC		 6316 struct group * group;
6317 Elf_Internal_Shdr * symtab_sec;
6318 Elf_Internal_Shdr * strtab_sec;
6319 Elf_Internal_Sym * symtab;
ba5cdace 6320 unsigned long num_syms;
2cf0635d 6321 char * strtab;
c256ffe7 6322 size_t strtab_size;
d1f5c6e3
L		 6323
6324 /* Don't process section groups unless needed. */
6325 if (!do_unwind && !do_section_groups)
6326 return 1;
f5842774
L		 6327
6328 if (elf_header.e_shnum == 0)
6329 {
6330 if (do_section_groups)
82f2dbf7 6331 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6332
6333 return 1;
6334 }
6335
6336 if (section_headers == NULL)
6337 {
6338 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6339 /* PR 13622: This can happen with a corrupt ELF header. */
6340 return 0;
f5842774
L		 6341 }
6342
3f5e193b
NC		 6343 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6344 sizeof (struct group *));
e4b17d5c
L		 6345
6346 if (section_headers_groups == NULL)
6347 {
8b73c356
NC		 6348 error (_("Out of memory reading %u section group headers\n"),
6349 elf_header.e_shnum);
e4b17d5c
L		 6350 return 0;
6351 }
6352
f5842774 6353 /* Scan the sections for the group section. */
d1f5c6e3 6354 group_count = 0;
f5842774
L		 6355 for (i = 0, section = section_headers;
6356 i < elf_header.e_shnum;
6357 i++, section++)
e4b17d5c
L		 6358 if (section->sh_type == SHT_GROUP)
6359 group_count++;
6360
d1f5c6e3
L		 6361 if (group_count == 0)
6362 {
6363 if (do_section_groups)
6364 printf (_("\nThere are no section groups in this file.\n"));
6365
6366 return 1;
6367 }
6368
3f5e193b 6369 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6370
6371 if (section_groups == NULL)
6372 {
8b73c356
NC		 6373 error (_("Out of memory reading %lu groups\n"),
6374 (unsigned long) group_count);
e4b17d5c
L		 6375 return 0;
6376 }
6377
d1f5c6e3
L		 6378 symtab_sec = NULL;
6379 strtab_sec = NULL;
6380 symtab = NULL;
ba5cdace 6381 num_syms = 0;
d1f5c6e3 6382 strtab = NULL;
c256ffe7 6383 strtab_size = 0;
e4b17d5c
L		 6384 for (i = 0, section = section_headers, group = section_groups;
6385 i < elf_header.e_shnum;
6386 i++, section++)
f5842774
L		 6387 {
6388 if (section->sh_type == SHT_GROUP)
6389 {
74e1a04b
NC		 6390 const char * name = printable_section_name (section);
6391 const char * group_name;
2cf0635d
NC		 6392 unsigned char * start;
6393 unsigned char * indices;
f5842774 6394 unsigned int entry, j, size;
2cf0635d
NC		 6395 Elf_Internal_Shdr * sec;
6396 Elf_Internal_Sym * sym;
f5842774
L		 6397
6398 /* Get the symbol table. */
4fbb74a6
AM		 6399 if (section->sh_link >= elf_header.e_shnum
6400 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6401 != SHT_SYMTAB))
f5842774
L		 6402 {
6403 error (_("Bad sh_link in group section `%s'\n"), name);
6404 continue;
6405 }
d1f5c6e3
L		 6406
6407 if (symtab_sec != sec)
6408 {
6409 symtab_sec = sec;
6410 if (symtab)
6411 free (symtab);
ba5cdace 6412 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6413 }
f5842774 6414
dd24e3da
NC		 6415 if (symtab == NULL)
6416 {
6417 error (_("Corrupt header in group section `%s'\n"), name);
6418 continue;
6419 }
6420
ba5cdace
NC		 6421 if (section->sh_info >= num_syms)
6422 {
6423 error (_("Bad sh_info in group section `%s'\n"), name);
6424 continue;
6425 }
6426
f5842774
L		 6427 sym = symtab + section->sh_info;
6428
6429 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6430 {
4fbb74a6
AM		 6431 if (sym->st_shndx == 0
6432 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6433 {
6434 error (_("Bad sh_info in group section `%s'\n"), name);
6435 continue;
6436 }
ba2685cc 6437
4fbb74a6 6438 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6439 strtab_sec = NULL;
6440 if (strtab)
6441 free (strtab);
f5842774 6442 strtab = NULL;
c256ffe7 6443 strtab_size = 0;
f5842774
L		 6444 }
6445 else
6446 {
6447 /* Get the string table. */
4fbb74a6 6448 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6449 {
6450 strtab_sec = NULL;
6451 if (strtab)
6452 free (strtab);
6453 strtab = NULL;
6454 strtab_size = 0;
6455 }
6456 else if (strtab_sec
4fbb74a6 6457 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6458 {
6459 strtab_sec = sec;
6460 if (strtab)
6461 free (strtab);
071436c6 6462
3f5e193b 6463 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6464 1, strtab_sec->sh_size,
6465 _("string table"));
c256ffe7 6466 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6467 }
c256ffe7 6468 group_name = sym->st_name < strtab_size
2b692964 6469 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6470 }
6471
c9c1d674
EG		 6472 /* PR 17531: file: loop. */
6473 if (section->sh_entsize > section->sh_size)
6474 {
6475 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6476 printable_section_name (section),
8066deb1
AM		 6477 (unsigned long) section->sh_entsize,
6478 (unsigned long) section->sh_size);
c9c1d674
EG		 6479 break;
6480 }
6481
3f5e193b
NC		 6482 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6483 1, section->sh_size,
6484 _("section data"));
59245841
NC		 6485 if (start == NULL)
6486 continue;
f5842774
L		 6487
6488 indices = start;
6489 size = (section->sh_size / section->sh_entsize) - 1;
6490 entry = byte_get (indices, 4);
6491 indices += 4;
e4b17d5c
L		 6492
6493 if (do_section_groups)
6494 {
2b692964 6495 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6496 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6497
e4b17d5c
L		 6498 printf (_(" [Index] Name\n"));
6499 }
6500
6501 group->group_index = i;
6502
f5842774
L		 6503 for (j = 0; j < size; j++)
6504 {
2cf0635d 6505 struct group_list * g;
e4b17d5c 6506
f5842774
L		 6507 entry = byte_get (indices, 4);
6508 indices += 4;
6509
4fbb74a6 6510 if (entry >= elf_header.e_shnum)
391cb864 6511 {
57028622
NC		 6512 static unsigned num_group_errors = 0;
6513
6514 if (num_group_errors ++ < 10)
6515 {
6516 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6517 entry, i, elf_header.e_shnum - 1);
6518 if (num_group_errors == 10)
6519 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6520 }
391cb864
L		 6521 continue;
6522 }
391cb864 6523
4fbb74a6 6524 if (section_headers_groups [entry] != NULL)
e4b17d5c 6525 {
d1f5c6e3
L		 6526 if (entry)
6527 {
57028622
NC		 6528 static unsigned num_errs = 0;
6529
6530 if (num_errs ++ < 10)
6531 {
6532 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6533 entry, i,
6534 section_headers_groups [entry]->group_index);
6535 if (num_errs == 10)
6536 warn (_("Further error messages about already contained group sections suppressed\n"));
6537 }
d1f5c6e3
L		 6538 continue;
6539 }
6540 else
6541 {
6542 /* Intel C/C++ compiler may put section 0 in a
6543 section group. We just warn it the first time
6544 and ignore it afterwards. */
6545 static int warned = 0;
6546 if (!warned)
6547 {
6548 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6549 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6550 warned++;
6551 }
6552 }
e4b17d5c
L		 6553 }
6554
4fbb74a6 6555 section_headers_groups [entry] = group;
e4b17d5c
L		 6556
6557 if (do_section_groups)
6558 {
4fbb74a6 6559 sec = section_headers + entry;
74e1a04b 6560 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6561 }
6562
3f5e193b 6563 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6564 g->section_index = entry;
6565 g->next = group->root;
6566 group->root = g;
f5842774
L		 6567 }
6568
f5842774
L		 6569 if (start)
6570 free (start);
e4b17d5c
L		 6571
6572 group++;
f5842774
L		 6573 }
6574 }
6575
d1f5c6e3
L		 6576 if (symtab)
6577 free (symtab);
6578 if (strtab)
6579 free (strtab);
f5842774
L		 6580 return 1;
6581}
6582
28f997cf
TG		 6583/* Data used to display dynamic fixups. */
6584
6585struct ia64_vms_dynfixup
6586{
6587 bfd_vma needed_ident; /* Library ident number. */
6588 bfd_vma needed; /* Index in the dstrtab of the library name. */
6589 bfd_vma fixup_needed; /* Index of the library. */
6590 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6591 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6592};
6593
6594/* Data used to display dynamic relocations. */
6595
6596struct ia64_vms_dynimgrela
6597{
6598 bfd_vma img_rela_cnt; /* Number of relocations. */
6599 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6600};
6601
6602/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6603 library). */
6604
6605static void
6606dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6607 const char *strtab, unsigned int strtab_sz)
6608{
6609 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6610 long i;
6611 const char *lib_name;
6612
6613 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6614 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6615 _("dynamic section image fixups"));
6616 if (!imfs)
6617 return;
6618
6619 if (fixup->needed < strtab_sz)
6620 lib_name = strtab + fixup->needed;
6621 else
6622 {
6623 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6624 (unsigned long) fixup->needed);
28f997cf
TG		 6625 lib_name = "???";
6626 }
6627 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6628 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6629 printf
6630 (_("Seg Offset Type SymVec DataType\n"));
6631
6632 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6633 {
6634 unsigned int type;
6635 const char *rtype;
6636
6637 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6638 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6639 type = BYTE_GET (imfs [i].type);
6640 rtype = elf_ia64_reloc_type (type);
6641 if (rtype == NULL)
6642 printf (" 0x%08x ", type);
6643 else
6644 printf (" %-32s ", rtype);
6645 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6646 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6647 }
6648
6649 free (imfs);
6650}
6651
6652/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6653
6654static void
6655dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6656{
6657 Elf64_External_VMS_IMAGE_RELA *imrs;
6658 long i;
6659
6660 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6661 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6662 _("dynamic section image relocations"));
28f997cf
TG		 6663 if (!imrs)
6664 return;
6665
6666 printf (_("\nImage relocs\n"));
6667 printf
6668 (_("Seg Offset Type Addend Seg Sym Off\n"));
6669
6670 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6671 {
6672 unsigned int type;
6673 const char *rtype;
6674
6675 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6676 printf ("%08" BFD_VMA_FMT "x ",
6677 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6678 type = BYTE_GET (imrs [i].type);
6679 rtype = elf_ia64_reloc_type (type);
6680 if (rtype == NULL)
6681 printf ("0x%08x ", type);
6682 else
6683 printf ("%-31s ", rtype);
6684 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6685 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6686 printf ("%08" BFD_VMA_FMT "x\n",
6687 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6688 }
6689
6690 free (imrs);
6691}
6692
6693/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6694
6695static int
6696process_ia64_vms_dynamic_relocs (FILE *file)
6697{
6698 struct ia64_vms_dynfixup fixup;
6699 struct ia64_vms_dynimgrela imgrela;
6700 Elf_Internal_Dyn *entry;
6701 int res = 0;
6702 bfd_vma strtab_off = 0;
6703 bfd_vma strtab_sz = 0;
6704 char *strtab = NULL;
6705
6706 memset (&fixup, 0, sizeof (fixup));
6707 memset (&imgrela, 0, sizeof (imgrela));
6708
6709 /* Note: the order of the entries is specified by the OpenVMS specs. */
6710 for (entry = dynamic_section;
6711 entry < dynamic_section + dynamic_nent;
6712 entry++)
6713 {
6714 switch (entry->d_tag)
6715 {
6716 case DT_IA_64_VMS_STRTAB_OFFSET:
6717 strtab_off = entry->d_un.d_val;
6718 break;
6719 case DT_STRSZ:
6720 strtab_sz = entry->d_un.d_val;
6721 if (strtab == NULL)
6722 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6723 1, strtab_sz, _("dynamic string section"));
6724 break;
6725
6726 case DT_IA_64_VMS_NEEDED_IDENT:
6727 fixup.needed_ident = entry->d_un.d_val;
6728 break;
6729 case DT_NEEDED:
6730 fixup.needed = entry->d_un.d_val;
6731 break;
6732 case DT_IA_64_VMS_FIXUP_NEEDED:
6733 fixup.fixup_needed = entry->d_un.d_val;
6734 break;
6735 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6736 fixup.fixup_rela_cnt = entry->d_un.d_val;
6737 break;
6738 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6739 fixup.fixup_rela_off = entry->d_un.d_val;
6740 res++;
6741 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6742 break;
6743
6744 case DT_IA_64_VMS_IMG_RELA_CNT:
6745 imgrela.img_rela_cnt = entry->d_un.d_val;
6746 break;
6747 case DT_IA_64_VMS_IMG_RELA_OFF:
6748 imgrela.img_rela_off = entry->d_un.d_val;
6749 res++;
6750 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6751 break;
6752
6753 default:
6754 break;
6755 }
6756 }
6757
6758 if (strtab != NULL)
6759 free (strtab);
6760
6761 return res;
6762}
6763
85b1c36d 6764static struct
566b0d53 6765{
2cf0635d 6766 const char * name;
566b0d53
L		 6767 int reloc;
6768 int size;
6769 int rela;
6770} dynamic_relocations [] =
6771{
6772 { "REL", DT_REL, DT_RELSZ, FALSE },
6773 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6774 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6775};
6776
252b5132 6777/* Process the reloc section. */
18bd398b 6778
252b5132 6779static int
2cf0635d 6780process_relocs (FILE * file)
252b5132 6781{
b34976b6
AM		 6782 unsigned long rel_size;
6783 unsigned long rel_offset;
252b5132
RH		 6784
6785
6786 if (!do_reloc)
6787 return 1;
6788
6789 if (do_using_dynamic)
6790 {
566b0d53 6791 int is_rela;
2cf0635d 6792 const char * name;
566b0d53
L		 6793 int has_dynamic_reloc;
6794 unsigned int i;
0de14b54 6795
566b0d53 6796 has_dynamic_reloc = 0;
252b5132 6797
566b0d53 6798 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6799 {
566b0d53
L		 6800 is_rela = dynamic_relocations [i].rela;
6801 name = dynamic_relocations [i].name;
6802 rel_size = dynamic_info [dynamic_relocations [i].size];
6803 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6804
566b0d53
L		 6805 has_dynamic_reloc |= rel_size;
6806
6807 if (is_rela == UNKNOWN)
aa903cfb 6808 {
566b0d53
L		 6809 if (dynamic_relocations [i].reloc == DT_JMPREL)
6810 switch (dynamic_info[DT_PLTREL])
6811 {
6812 case DT_REL:
6813 is_rela = FALSE;
6814 break;
6815 case DT_RELA:
6816 is_rela = TRUE;
6817 break;
6818 }
aa903cfb 6819 }
252b5132 6820
566b0d53
L		 6821 if (rel_size)
6822 {
6823 printf
6824 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6825 name, rel_offset, rel_size);
252b5132 6826
d93f0186
NC		 6827 dump_relocations (file,
6828 offset_from_vma (file, rel_offset, rel_size),
6829 rel_size,
566b0d53 6830 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6831 dynamic_strings, dynamic_strings_length,
6832 is_rela, 1);
566b0d53 6833 }
252b5132 6834 }
566b0d53 6835
28f997cf
TG		 6836 if (is_ia64_vms ())
6837 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6838
566b0d53 6839 if (! has_dynamic_reloc)
252b5132
RH		 6840 printf (_("\nThere are no dynamic relocations in this file.\n"));
6841 }
6842 else
6843 {
2cf0635d 6844 Elf_Internal_Shdr * section;
b34976b6
AM		 6845 unsigned long i;
6846 int found = 0;
252b5132
RH		 6847
6848 for (i = 0, section = section_headers;
6849 i < elf_header.e_shnum;
b34976b6 6850 i++, section++)
252b5132
RH		 6851 {
6852 if ( section->sh_type != SHT_RELA
6853 && section->sh_type != SHT_REL)
6854 continue;
6855
6856 rel_offset = section->sh_offset;
6857 rel_size = section->sh_size;
6858
6859 if (rel_size)
6860 {
2cf0635d 6861 Elf_Internal_Shdr * strsec;
b34976b6 6862 int is_rela;
103f02d3 6863
252b5132
RH		 6864 printf (_("\nRelocation section "));
6865
6866 if (string_table == NULL)
19936277 6867 printf ("%d", section->sh_name);
252b5132 6868 else
74e1a04b 6869 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6870
6871 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6872 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6873
d79b3d50
NC		 6874 is_rela = section->sh_type == SHT_RELA;
6875
4fbb74a6
AM		 6876 if (section->sh_link != 0
6877 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6878 {
2cf0635d
NC		 6879 Elf_Internal_Shdr * symsec;
6880 Elf_Internal_Sym * symtab;
d79b3d50 6881 unsigned long nsyms;
c256ffe7 6882 unsigned long strtablen = 0;
2cf0635d 6883 char * strtab = NULL;
57346661 6884
4fbb74a6 6885 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6886 if (symsec->sh_type != SHT_SYMTAB
6887 && symsec->sh_type != SHT_DYNSYM)
6888 continue;
6889
ba5cdace 6890 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6891
af3fc3bc
AM		 6892 if (symtab == NULL)
6893 continue;
252b5132 6894
4fbb74a6
AM		 6895 if (symsec->sh_link != 0
6896 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6897 {
4fbb74a6 6898 strsec = section_headers + symsec->sh_link;
103f02d3 6899
3f5e193b 6900 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6901 1, strsec->sh_size,
6902 _("string table"));
c256ffe7
JJ		 6903 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6904 }
252b5132 6905
d79b3d50 6906 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6907 symtab, nsyms, strtab, strtablen,
6908 is_rela,
6909 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6910 if (strtab)
6911 free (strtab);
6912 free (symtab);
6913 }
6914 else
6915 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6916 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6917
6918 found = 1;
6919 }
6920 }
6921
6922 if (! found)
6923 printf (_("\nThere are no relocations in this file.\n"));
6924 }
6925
6926 return 1;
6927}
6928
4d6ed7c8
NC		 6929/* An absolute address consists of a section and an offset. If the
6930 section is NULL, the offset itself is the address, otherwise, the
6931 address equals to LOAD_ADDRESS(section) + offset. */
6932
6933struct absaddr
948f632f
DA		 6934{
6935 unsigned short section;
6936 bfd_vma offset;
6937};
4d6ed7c8 6938
1949de15
L		 6939#define ABSADDR(a) \
6940 ((a).section \
6941 ? section_headers [(a).section].sh_addr + (a).offset \
6942 : (a).offset)
6943
948f632f
DA		 6944/* Find the nearest symbol at or below ADDR. Returns the symbol
6945 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6946
4d6ed7c8 6947static void
2cf0635d 6948find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6949 unsigned long nsyms,
6950 const char * strtab,
6951 unsigned long strtab_size,
6952 struct absaddr addr,
6953 const char ** symname,
6954 bfd_vma * offset)
4d6ed7c8 6955{
d3ba0551 6956 bfd_vma dist = 0x100000;
2cf0635d 6957 Elf_Internal_Sym * sym;
948f632f
DA		 6958 Elf_Internal_Sym * beg;
6959 Elf_Internal_Sym * end;
2cf0635d 6960 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6961
0b6ae522 6962 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6963 beg = symtab;
6964 end = symtab + nsyms;
0b6ae522 6965
948f632f 6966 while (beg < end)
4d6ed7c8 6967 {
948f632f
DA		 6968 bfd_vma value;
6969
6970 sym = beg + (end - beg) / 2;
0b6ae522 6971
948f632f 6972 value = sym->st_value;
0b6ae522
DJ		 6973 REMOVE_ARCH_BITS (value);
6974
948f632f 6975 if (sym->st_name != 0
4d6ed7c8 6976 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6977 && addr.offset >= value
6978 && addr.offset - value < dist)
4d6ed7c8
NC		 6979 {
6980 best = sym;
0b6ae522 6981 dist = addr.offset - value;
4d6ed7c8
NC		 6982 if (!dist)
6983 break;
6984 }
948f632f
DA		 6985
6986 if (addr.offset < value)
6987 end = sym;
6988 else
6989 beg = sym + 1;
4d6ed7c8 6990 }
1b31d05e 6991
4d6ed7c8
NC		 6992 if (best)
6993 {
57346661 6994 *symname = (best->st_name >= strtab_size
2b692964 6995 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6996 *offset = dist;
6997 return;
6998 }
1b31d05e 6999
4d6ed7c8
NC		 7000 *symname = NULL;
7001 *offset = addr.offset;
7002}
7003
948f632f
DA		 7004static int
7005symcmp (const void *p, const void *q)
7006{
7007 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7008 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7009
7010 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7011}
7012
7013/* Process the unwind section. */
7014
7015#include "unwind-ia64.h"
7016
7017struct ia64_unw_table_entry
7018{
7019 struct absaddr start;
7020 struct absaddr end;
7021 struct absaddr info;
7022};
7023
7024struct ia64_unw_aux_info
7025{
7026 struct ia64_unw_table_entry *table; /* Unwind table. */
7027 unsigned long table_len; /* Length of unwind table. */
7028 unsigned char * info; /* Unwind info. */
7029 unsigned long info_size; /* Size of unwind info. */
7030 bfd_vma info_addr; /* Starting address of unwind info. */
7031 bfd_vma seg_base; /* Starting address of segment. */
7032 Elf_Internal_Sym * symtab; /* The symbol table. */
7033 unsigned long nsyms; /* Number of symbols. */
7034 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7035 unsigned long nfuns; /* Number of entries in funtab. */
7036 char * strtab; /* The string table. */
7037 unsigned long strtab_size; /* Size of string table. */
7038};
7039
4d6ed7c8 7040static void
2cf0635d 7041dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 7042{
2cf0635d 7043 struct ia64_unw_table_entry * tp;
948f632f 7044 unsigned long j, nfuns;
4d6ed7c8 7045 int in_body;
7036c0e1 7046
948f632f
DA		 7047 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7048 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7049 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7050 aux->funtab[nfuns++] = aux->symtab[j];
7051 aux->nfuns = nfuns;
7052 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7053
4d6ed7c8
NC		 7054 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7055 {
7056 bfd_vma stamp;
7057 bfd_vma offset;
2cf0635d
NC		 7058 const unsigned char * dp;
7059 const unsigned char * head;
53774b7e 7060 const unsigned char * end;
2cf0635d 7061 const char * procname;
4d6ed7c8 7062
948f632f 7063 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 7064 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 7065
7066 fputs ("\n<", stdout);
7067
7068 if (procname)
7069 {
7070 fputs (procname, stdout);
7071
7072 if (offset)
7073 printf ("+%lx", (unsigned long) offset);
7074 }
7075
7076 fputs (">: [", stdout);
7077 print_vma (tp->start.offset, PREFIX_HEX);
7078 fputc ('-', stdout);
7079 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 7080 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 7081 (unsigned long) (tp->info.offset - aux->seg_base));
7082
53774b7e
NC		 7083 /* PR 17531: file: 86232b32. */
7084 if (aux->info == NULL)
7085 continue;
7086
7087 /* PR 17531: file: 0997b4d1. */
7088 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7089 {
7090 warn (_("Invalid offset %lx in table entry %ld\n"),
7091 (long) tp->info.offset, (long) (tp - aux->table));
7092 continue;
7093 }
7094
1949de15 7095 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 7096 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 7097
86f55779 7098 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 7099 (unsigned) UNW_VER (stamp),
7100 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7101 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7102 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 7103 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 7104
7105 if (UNW_VER (stamp) != 1)
7106 {
2b692964 7107 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 7108 continue;
7109 }
7110
7111 in_body = 0;
53774b7e
NC		 7112 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7113 /* PR 17531: file: 16ceda89. */
7114 if (end > aux->info + aux->info_size)
7115 end = aux->info + aux->info_size;
7116 for (dp = head + 8; dp < end;)
b4477bc8 7117 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 7118 }
948f632f
DA		 7119
7120 free (aux->funtab);
4d6ed7c8
NC		 7121}
7122
53774b7e 7123static bfd_boolean
2cf0635d
NC		 7124slurp_ia64_unwind_table (FILE * file,
7125 struct ia64_unw_aux_info * aux,
7126 Elf_Internal_Shdr * sec)
4d6ed7c8 7127{
89fac5e3 7128 unsigned long size, nrelas, i;
2cf0635d
NC		 7129 Elf_Internal_Phdr * seg;
7130 struct ia64_unw_table_entry * tep;
7131 Elf_Internal_Shdr * relsec;
7132 Elf_Internal_Rela * rela;
7133 Elf_Internal_Rela * rp;
7134 unsigned char * table;
7135 unsigned char * tp;
7136 Elf_Internal_Sym * sym;
7137 const char * relname;
4d6ed7c8 7138
53774b7e
NC		 7139 aux->table_len = 0;
7140
4d6ed7c8
NC		 7141 /* First, find the starting address of the segment that includes
7142 this section: */
7143
7144 if (elf_header.e_phnum)
7145 {
d93f0186 7146 if (! get_program_headers (file))
53774b7e 7147 return FALSE;
4d6ed7c8 7148
d93f0186
NC		 7149 for (seg = program_headers;
7150 seg < program_headers + elf_header.e_phnum;
7151 ++seg)
4d6ed7c8
NC		 7152 {
7153 if (seg->p_type != PT_LOAD)
7154 continue;
7155
7156 if (sec->sh_addr >= seg->p_vaddr
7157 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7158 {
7159 aux->seg_base = seg->p_vaddr;
7160 break;
7161 }
7162 }
4d6ed7c8
NC		 7163 }
7164
7165 /* Second, build the unwind table from the contents of the unwind section: */
7166 size = sec->sh_size;
3f5e193b
NC		 7167 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7168 _("unwind table"));
a6e9f9df 7169 if (!table)
53774b7e 7170 return FALSE;
4d6ed7c8 7171
53774b7e 7172 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 7173 aux->table = (struct ia64_unw_table_entry *)
53774b7e 7174 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 7175 tep = aux->table;
53774b7e
NC		 7176
7177 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 7178 {
7179 tep->start.section = SHN_UNDEF;
7180 tep->end.section = SHN_UNDEF;
7181 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 7182 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7183 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7184 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 7185 tep->start.offset += aux->seg_base;
7186 tep->end.offset += aux->seg_base;
7187 tep->info.offset += aux->seg_base;
7188 }
7189 free (table);
7190
41e92641 7191 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 7192 for (relsec = section_headers;
7193 relsec < section_headers + elf_header.e_shnum;
7194 ++relsec)
7195 {
7196 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7197 || relsec->sh_info >= elf_header.e_shnum
7198 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 7199 continue;
7200
7201 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7202 & rela, & nrelas))
53774b7e
NC		 7203 {
7204 free (aux->table);
7205 aux->table = NULL;
7206 aux->table_len = 0;
7207 return FALSE;
7208 }
4d6ed7c8
NC		 7209
7210 for (rp = rela; rp < rela + nrelas; ++rp)
7211 {
aca88567
NC		 7212 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7213 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 7214
82b1b41b
NC		 7215 /* PR 17531: file: 9fa67536. */
7216 if (relname == NULL)
7217 {
7218 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7219 continue;
7220 }
948f632f 7221
0112cd26 7222 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 7223 {
82b1b41b 7224 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 7225 continue;
7226 }
7227
89fac5e3 7228 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 7229
53774b7e
NC		 7230 /* PR 17531: file: 5bc8d9bf. */
7231 if (i >= aux->table_len)
7232 {
7233 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7234 continue;
7235 }
7236
7237 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 7238 {
7239 case 0:
7240 aux->table[i].start.section = sym->st_shndx;
e466bc6e 7241 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7242 break;
7243 case 1:
7244 aux->table[i].end.section = sym->st_shndx;
e466bc6e 7245 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7246 break;
7247 case 2:
7248 aux->table[i].info.section = sym->st_shndx;
e466bc6e 7249 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7250 break;
7251 default:
7252 break;
7253 }
7254 }
7255
7256 free (rela);
7257 }
7258
53774b7e 7259 return TRUE;
4d6ed7c8
NC		 7260}
7261
1b31d05e 7262static void
2cf0635d 7263ia64_process_unwind (FILE * file)
4d6ed7c8 7264{
2cf0635d
NC		 7265 Elf_Internal_Shdr * sec;
7266 Elf_Internal_Shdr * unwsec = NULL;
7267 Elf_Internal_Shdr * strsec;
89fac5e3 7268 unsigned long i, unwcount = 0, unwstart = 0;
57346661 7269 struct ia64_unw_aux_info aux;
f1467e33 7270
4d6ed7c8
NC		 7271 memset (& aux, 0, sizeof (aux));
7272
4d6ed7c8
NC		 7273 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7274 {
c256ffe7 7275 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7276 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 7277 {
ba5cdace 7278 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 7279
4fbb74a6 7280 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7281 if (aux.strtab != NULL)
7282 {
7283 error (_("Multiple auxillary string tables encountered\n"));
7284 free (aux.strtab);
7285 }
3f5e193b
NC		 7286 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7287 1, strsec->sh_size,
7288 _("string table"));
c256ffe7 7289 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 7290 }
7291 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7292 unwcount++;
7293 }
7294
7295 if (!unwcount)
7296 printf (_("\nThere are no unwind sections in this file.\n"));
7297
7298 while (unwcount-- > 0)
7299 {
2cf0635d 7300 char * suffix;
579f31ac
JJ		 7301 size_t len, len2;
7302
4082ef84 7303 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7304 i < elf_header.e_shnum; ++i, ++sec)
7305 if (sec->sh_type == SHT_IA_64_UNWIND)
7306 {
7307 unwsec = sec;
7308 break;
7309 }
4082ef84
NC		 7310 /* We have already counted the number of SHT_IA64_UNWIND
7311 sections so the loop above should never fail. */
7312 assert (unwsec != NULL);
579f31ac
JJ		 7313
7314 unwstart = i + 1;
7315 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7316
e4b17d5c
L		 7317 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7318 {
7319 /* We need to find which section group it is in. */
4082ef84 7320 struct group_list * g;
e4b17d5c 7321
4082ef84
NC		 7322 if (section_headers_groups == NULL
7323 || section_headers_groups [i] == NULL)
7324 i = elf_header.e_shnum;
7325 else
e4b17d5c 7326 {
4082ef84 7327 g = section_headers_groups [i]->root;
18bd398b 7328
4082ef84
NC		 7329 for (; g != NULL; g = g->next)
7330 {
7331 sec = section_headers + g->section_index;
e4b17d5c 7332
4082ef84
NC		 7333 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7334 break;
7335 }
7336
7337 if (g == NULL)
7338 i = elf_header.e_shnum;
7339 }
e4b17d5c 7340 }
18bd398b 7341 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7342 {
18bd398b 7343 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7344 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7345 suffix = SECTION_NAME (unwsec) + len;
7346 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7347 ++i, ++sec)
18bd398b
NC		 7348 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7349 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7350 break;
7351 }
7352 else
7353 {
7354 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7355 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7356 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7357 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7358 suffix = "";
18bd398b 7359 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7360 suffix = SECTION_NAME (unwsec) + len;
7361 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7362 ++i, ++sec)
18bd398b
NC		 7363 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7364 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7365 break;
7366 }
7367
7368 if (i == elf_header.e_shnum)
7369 {
7370 printf (_("\nCould not find unwind info section for "));
7371
7372 if (string_table == NULL)
7373 printf ("%d", unwsec->sh_name);
7374 else
74e1a04b 7375 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7376 }
7377 else
4d6ed7c8 7378 {
4d6ed7c8 7379 aux.info_addr = sec->sh_addr;
3f5e193b 7380 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7381 sec->sh_size,
7382 _("unwind info"));
59245841 7383 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7384
579f31ac 7385 printf (_("\nUnwind section "));
4d6ed7c8 7386
579f31ac
JJ		 7387 if (string_table == NULL)
7388 printf ("%d", unwsec->sh_name);
7389 else
74e1a04b 7390 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7391
579f31ac 7392 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7393 (unsigned long) unwsec->sh_offset,
89fac5e3 7394 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7395
53774b7e
NC		 7396 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7397 && aux.table_len > 0)
579f31ac
JJ		 7398 dump_ia64_unwind (& aux);
7399
7400 if (aux.table)
7401 free ((char *) aux.table);
7402 if (aux.info)
7403 free ((char *) aux.info);
7404 aux.table = NULL;
7405 aux.info = NULL;
7406 }
4d6ed7c8 7407 }
4d6ed7c8 7408
4d6ed7c8
NC		 7409 if (aux.symtab)
7410 free (aux.symtab);
7411 if (aux.strtab)
7412 free ((char *) aux.strtab);
4d6ed7c8
NC		 7413}
7414
3f5e193b
NC		 7415struct hppa_unw_table_entry
7416 {
7417 struct absaddr start;
7418 struct absaddr end;
948f632f 7419 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7420 unsigned int Millicode:1; /* 1 */
7421 unsigned int Millicode_save_sr0:1; /* 2 */
7422 unsigned int Region_description:2; /* 3..4 */
7423 unsigned int reserved1:1; /* 5 */
7424 unsigned int Entry_SR:1; /* 6 */
7425 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7426 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7427 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7428 unsigned int Variable_Frame:1; /* 17 */
7429 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7430 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7431 unsigned int Stack_Overflow_Check:1; /* 20 */
7432 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7433 unsigned int Ada_Region:1; /* 22 */
7434 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7435 unsigned int cxx_try_catch:1; /* 24 */
7436 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7437 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7438 unsigned int Save_SP:1; /* 27 */
7439 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7440 unsigned int Save_MRP_in_frame:1; /* 29 */
7441 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7442 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7443
948f632f
DA		 7444 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7445 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7446 unsigned int Large_frame:1; /* 2 */
948f632f 7447 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7448 unsigned int reserved4:1; /* 4 */
7449 unsigned int Total_frame_size:27; /* 5..31 */
7450 };
7451
57346661 7452struct hppa_unw_aux_info
948f632f
DA		 7453{
7454 struct hppa_unw_table_entry * table; /* Unwind table. */
7455 unsigned long table_len; /* Length of unwind table. */
7456 bfd_vma seg_base; /* Starting address of segment. */
7457 Elf_Internal_Sym * symtab; /* The symbol table. */
7458 unsigned long nsyms; /* Number of symbols. */
7459 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7460 unsigned long nfuns; /* Number of entries in funtab. */
7461 char * strtab; /* The string table. */
7462 unsigned long strtab_size; /* Size of string table. */
7463};
57346661
AM		 7464
7465static void
2cf0635d 7466dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7467{
2cf0635d 7468 struct hppa_unw_table_entry * tp;
948f632f
DA		 7469 unsigned long j, nfuns;
7470
7471 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7472 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7473 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7474 aux->funtab[nfuns++] = aux->symtab[j];
7475 aux->nfuns = nfuns;
7476 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7477
57346661
AM		 7478 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7479 {
7480 bfd_vma offset;
2cf0635d 7481 const char * procname;
57346661 7482
948f632f 7483 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7484 aux->strtab_size, tp->start, &procname,
7485 &offset);
7486
7487 fputs ("\n<", stdout);
7488
7489 if (procname)
7490 {
7491 fputs (procname, stdout);
7492
7493 if (offset)
7494 printf ("+%lx", (unsigned long) offset);
7495 }
7496
7497 fputs (">: [", stdout);
7498 print_vma (tp->start.offset, PREFIX_HEX);
7499 fputc ('-', stdout);
7500 print_vma (tp->end.offset, PREFIX_HEX);
7501 printf ("]\n\t");
7502
18bd398b
NC		 7503#define PF(_m) if (tp->_m) printf (#_m " ");
7504#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7505 PF(Cannot_unwind);
7506 PF(Millicode);
7507 PF(Millicode_save_sr0);
18bd398b 7508 /* PV(Region_description); */
57346661
AM		 7509 PF(Entry_SR);
7510 PV(Entry_FR);
7511 PV(Entry_GR);
7512 PF(Args_stored);
7513 PF(Variable_Frame);
7514 PF(Separate_Package_Body);
7515 PF(Frame_Extension_Millicode);
7516 PF(Stack_Overflow_Check);
7517 PF(Two_Instruction_SP_Increment);
7518 PF(Ada_Region);
7519 PF(cxx_info);
7520 PF(cxx_try_catch);
7521 PF(sched_entry_seq);
7522 PF(Save_SP);
7523 PF(Save_RP);
7524 PF(Save_MRP_in_frame);
7525 PF(extn_ptr_defined);
7526 PF(Cleanup_defined);
7527 PF(MPE_XL_interrupt_marker);
7528 PF(HP_UX_interrupt_marker);
7529 PF(Large_frame);
7530 PF(Pseudo_SP_Set);
7531 PV(Total_frame_size);
7532#undef PF
7533#undef PV
7534 }
7535
18bd398b 7536 printf ("\n");
948f632f
DA		 7537
7538 free (aux->funtab);
57346661
AM		 7539}
7540
7541static int
2cf0635d
NC		 7542slurp_hppa_unwind_table (FILE * file,
7543 struct hppa_unw_aux_info * aux,
7544 Elf_Internal_Shdr * sec)
57346661 7545{
1c0751b2 7546 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7547 Elf_Internal_Phdr * seg;
7548 struct hppa_unw_table_entry * tep;
7549 Elf_Internal_Shdr * relsec;
7550 Elf_Internal_Rela * rela;
7551 Elf_Internal_Rela * rp;
7552 unsigned char * table;
7553 unsigned char * tp;
7554 Elf_Internal_Sym * sym;
7555 const char * relname;
57346661 7556
57346661
AM		 7557 /* First, find the starting address of the segment that includes
7558 this section. */
7559
7560 if (elf_header.e_phnum)
7561 {
7562 if (! get_program_headers (file))
7563 return 0;
7564
7565 for (seg = program_headers;
7566 seg < program_headers + elf_header.e_phnum;
7567 ++seg)
7568 {
7569 if (seg->p_type != PT_LOAD)
7570 continue;
7571
7572 if (sec->sh_addr >= seg->p_vaddr
7573 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7574 {
7575 aux->seg_base = seg->p_vaddr;
7576 break;
7577 }
7578 }
7579 }
7580
7581 /* Second, build the unwind table from the contents of the unwind
7582 section. */
7583 size = sec->sh_size;
3f5e193b
NC		 7584 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7585 _("unwind table"));
57346661
AM		 7586 if (!table)
7587 return 0;
7588
1c0751b2
DA		 7589 unw_ent_size = 16;
7590 nentries = size / unw_ent_size;
7591 size = unw_ent_size * nentries;
57346661 7592
3f5e193b
NC		 7593 tep = aux->table = (struct hppa_unw_table_entry *)
7594 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7595
1c0751b2 7596 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7597 {
7598 unsigned int tmp1, tmp2;
7599
7600 tep->start.section = SHN_UNDEF;
7601 tep->end.section = SHN_UNDEF;
7602
1c0751b2
DA		 7603 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7604 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7605 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7606 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7607
7608 tep->start.offset += aux->seg_base;
7609 tep->end.offset += aux->seg_base;
57346661
AM		 7610
7611 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7612 tep->Millicode = (tmp1 >> 30) & 0x1;
7613 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7614 tep->Region_description = (tmp1 >> 27) & 0x3;
7615 tep->reserved1 = (tmp1 >> 26) & 0x1;
7616 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7617 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7618 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7619 tep->Args_stored = (tmp1 >> 15) & 0x1;
7620 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7621 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7622 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7623 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7624 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7625 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7626 tep->cxx_info = (tmp1 >> 8) & 0x1;
7627 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7628 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7629 tep->reserved2 = (tmp1 >> 5) & 0x1;
7630 tep->Save_SP = (tmp1 >> 4) & 0x1;
7631 tep->Save_RP = (tmp1 >> 3) & 0x1;
7632 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7633 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7634 tep->Cleanup_defined = tmp1 & 0x1;
7635
7636 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7637 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7638 tep->Large_frame = (tmp2 >> 29) & 0x1;
7639 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7640 tep->reserved4 = (tmp2 >> 27) & 0x1;
7641 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7642 }
7643 free (table);
7644
7645 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7646 for (relsec = section_headers;
7647 relsec < section_headers + elf_header.e_shnum;
7648 ++relsec)
7649 {
7650 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7651 || relsec->sh_info >= elf_header.e_shnum
7652 || section_headers + relsec->sh_info != sec)
57346661
AM		 7653 continue;
7654
7655 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7656 & rela, & nrelas))
7657 return 0;
7658
7659 for (rp = rela; rp < rela + nrelas; ++rp)
7660 {
aca88567
NC		 7661 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7662 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7663
7664 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7665 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7666 {
7667 warn (_("Skipping unexpected relocation type %s\n"), relname);
7668 continue;
7669 }
7670
7671 i = rp->r_offset / unw_ent_size;
7672
89fac5e3 7673 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7674 {
7675 case 0:
7676 aux->table[i].start.section = sym->st_shndx;
1e456d54 7677 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7678 break;
7679 case 1:
7680 aux->table[i].end.section = sym->st_shndx;
1e456d54 7681 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7682 break;
7683 default:
7684 break;
7685 }
7686 }
7687
7688 free (rela);
7689 }
7690
1c0751b2 7691 aux->table_len = nentries;
57346661
AM		 7692
7693 return 1;
7694}
7695
1b31d05e 7696static void
2cf0635d 7697hppa_process_unwind (FILE * file)
57346661 7698{
57346661 7699 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7700 Elf_Internal_Shdr * unwsec = NULL;
7701 Elf_Internal_Shdr * strsec;
7702 Elf_Internal_Shdr * sec;
18bd398b 7703 unsigned long i;
57346661 7704
c256ffe7 7705 if (string_table == NULL)
1b31d05e
NC		 7706 return;
7707
7708 memset (& aux, 0, sizeof (aux));
57346661
AM		 7709
7710 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7711 {
c256ffe7 7712 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7713 && sec->sh_link < elf_header.e_shnum)
57346661 7714 {
ba5cdace 7715 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7716
4fbb74a6 7717 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7718 if (aux.strtab != NULL)
7719 {
7720 error (_("Multiple auxillary string tables encountered\n"));
7721 free (aux.strtab);
7722 }
3f5e193b
NC		 7723 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7724 1, strsec->sh_size,
7725 _("string table"));
c256ffe7 7726 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7727 }
18bd398b 7728 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7729 unwsec = sec;
7730 }
7731
7732 if (!unwsec)
7733 printf (_("\nThere are no unwind sections in this file.\n"));
7734
7735 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7736 {
18bd398b 7737 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7738 {
74e1a04b
NC		 7739 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7740 printable_section_name (sec),
57346661 7741 (unsigned long) sec->sh_offset,
89fac5e3 7742 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7743
7744 slurp_hppa_unwind_table (file, &aux, sec);
7745 if (aux.table_len > 0)
7746 dump_hppa_unwind (&aux);
7747
7748 if (aux.table)
7749 free ((char *) aux.table);
7750 aux.table = NULL;
7751 }
7752 }
7753
7754 if (aux.symtab)
7755 free (aux.symtab);
7756 if (aux.strtab)
7757 free ((char *) aux.strtab);
57346661
AM		 7758}
7759
0b6ae522
DJ		 7760struct arm_section
7761{
a734115a
NC		 7762 unsigned char * data; /* The unwind data. */
7763 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7764 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7765 unsigned long nrelas; /* The number of relocations. */
7766 unsigned int rel_type; /* REL or RELA ? */
7767 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7768};
7769
7770struct arm_unw_aux_info
7771{
a734115a
NC		 7772 FILE * file; /* The file containing the unwind sections. */
7773 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7774 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7775 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7776 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7777 char * strtab; /* The file's string table. */
7778 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7779};
7780
7781static const char *
7782arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7783 bfd_vma fn, struct absaddr addr)
7784{
7785 const char *procname;
7786 bfd_vma sym_offset;
7787
7788 if (addr.section == SHN_UNDEF)
7789 addr.offset = fn;
7790
948f632f 7791 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7792 aux->strtab_size, addr, &procname,
7793 &sym_offset);
7794
7795 print_vma (fn, PREFIX_HEX);
7796
7797 if (procname)
7798 {
7799 fputs (" <", stdout);
7800 fputs (procname, stdout);
7801
7802 if (sym_offset)
7803 printf ("+0x%lx", (unsigned long) sym_offset);
7804 fputc ('>', stdout);
7805 }
7806
7807 return procname;
7808}
7809
7810static void
7811arm_free_section (struct arm_section *arm_sec)
7812{
7813 if (arm_sec->data != NULL)
7814 free (arm_sec->data);
7815
7816 if (arm_sec->rela != NULL)
7817 free (arm_sec->rela);
7818}
7819
a734115a
NC		 7820/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7821 cached section and install SEC instead.
7822 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7823 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7824 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7825 relocation's offset in ADDR.
1b31d05e
NC		 7826 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7827 into the string table of the symbol associated with the reloc. If no
7828 reloc was applied store -1 there.
7829 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7830
7831static bfd_boolean
1b31d05e
NC		 7832get_unwind_section_word (struct arm_unw_aux_info * aux,
7833 struct arm_section * arm_sec,
7834 Elf_Internal_Shdr * sec,
7835 bfd_vma word_offset,
7836 unsigned int * wordp,
7837 struct absaddr * addr,
7838 bfd_vma * sym_name)
0b6ae522
DJ		 7839{
7840 Elf_Internal_Rela *rp;
7841 Elf_Internal_Sym *sym;
7842 const char * relname;
7843 unsigned int word;
7844 bfd_boolean wrapped;
7845
e0a31db1
NC		 7846 if (sec == NULL || arm_sec == NULL)
7847 return FALSE;
7848
0b6ae522
DJ		 7849 addr->section = SHN_UNDEF;
7850 addr->offset = 0;
7851
1b31d05e
NC		 7852 if (sym_name != NULL)
7853 *sym_name = (bfd_vma) -1;
7854
a734115a 7855 /* If necessary, update the section cache. */
0b6ae522
DJ		 7856 if (sec != arm_sec->sec)
7857 {
7858 Elf_Internal_Shdr *relsec;
7859
7860 arm_free_section (arm_sec);
7861
7862 arm_sec->sec = sec;
7863 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7864 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7865 arm_sec->rela = NULL;
7866 arm_sec->nrelas = 0;
7867
7868 for (relsec = section_headers;
7869 relsec < section_headers + elf_header.e_shnum;
7870 ++relsec)
7871 {
7872 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7873 || section_headers + relsec->sh_info != sec
7874 /* PR 15745: Check the section type as well. */
7875 || (relsec->sh_type != SHT_REL
7876 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7877 continue;
7878
a734115a 7879 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7880 if (relsec->sh_type == SHT_REL)
7881 {
7882 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7883 relsec->sh_size,
7884 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7885 return FALSE;
0b6ae522 7886 }
1ae40aa4 7887 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7888 {
7889 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7890 relsec->sh_size,
7891 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7892 return FALSE;
0b6ae522 7893 }
1ae40aa4 7894 break;
0b6ae522
DJ		 7895 }
7896
7897 arm_sec->next_rela = arm_sec->rela;
7898 }
7899
a734115a 7900 /* If there is no unwind data we can do nothing. */
0b6ae522 7901 if (arm_sec->data == NULL)
a734115a 7902 return FALSE;
0b6ae522 7903
e0a31db1 7904 /* If the offset is invalid then fail. */
1a915552
NC		 7905 if (word_offset > (sec->sh_size - 4)
7906 /* PR 18879 */
7907 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7908 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7909 return FALSE;
7910
a734115a 7911 /* Get the word at the required offset. */
0b6ae522
DJ		 7912 word = byte_get (arm_sec->data + word_offset, 4);
7913
0eff7165
NC		 7914 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7915 if (arm_sec->rela == NULL)
7916 {
7917 * wordp = word;
7918 return TRUE;
7919 }
7920
a734115a 7921 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7922 wrapped = FALSE;
7923 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7924 {
7925 bfd_vma prelval, offset;
7926
7927 if (rp->r_offset > word_offset && !wrapped)
7928 {
7929 rp = arm_sec->rela;
7930 wrapped = TRUE;
7931 }
7932 if (rp->r_offset > word_offset)
7933 break;
7934
7935 if (rp->r_offset & 3)
7936 {
7937 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7938 (unsigned long) rp->r_offset);
7939 continue;
7940 }
7941
7942 if (rp->r_offset < word_offset)
7943 continue;
7944
74e1a04b
NC		 7945 /* PR 17531: file: 027-161405-0.004 */
7946 if (aux->symtab == NULL)
7947 continue;
7948
0b6ae522
DJ		 7949 if (arm_sec->rel_type == SHT_REL)
7950 {
7951 offset = word & 0x7fffffff;
7952 if (offset & 0x40000000)
7953 offset |= ~ (bfd_vma) 0x7fffffff;
7954 }
a734115a 7955 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7956 offset = rp->r_addend;
a734115a 7957 else
74e1a04b
NC		 7958 {
7959 error (_("Unknown section relocation type %d encountered\n"),
7960 arm_sec->rel_type);
7961 break;
7962 }
0b6ae522 7963
071436c6
NC		 7964 /* PR 17531 file: 027-1241568-0.004. */
7965 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7966 {
7967 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7968 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7969 break;
7970 }
7971
7972 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7973 offset += sym->st_value;
7974 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7975
a734115a
NC		 7976 /* Check that we are processing the expected reloc type. */
7977 if (elf_header.e_machine == EM_ARM)
7978 {
7979 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7980 if (relname == NULL)
7981 {
7982 warn (_("Skipping unknown ARM relocation type: %d\n"),
7983 (int) ELF32_R_TYPE (rp->r_info));
7984 continue;
7985 }
a734115a
NC		 7986
7987 if (streq (relname, "R_ARM_NONE"))
7988 continue;
0b4362b0 7989
a734115a
NC		 7990 if (! streq (relname, "R_ARM_PREL31"))
7991 {
071436c6 7992 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7993 continue;
7994 }
7995 }
7996 else if (elf_header.e_machine == EM_TI_C6000)
7997 {
7998 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7999 if (relname == NULL)
8000 {
8001 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8002 (int) ELF32_R_TYPE (rp->r_info));
8003 continue;
8004 }
0b4362b0 8005
a734115a
NC		 8006 if (streq (relname, "R_C6000_NONE"))
8007 continue;
8008
8009 if (! streq (relname, "R_C6000_PREL31"))
8010 {
071436c6 8011 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 8012 continue;
8013 }
8014
8015 prelval >>= 1;
8016 }
8017 else
74e1a04b
NC		 8018 {
8019 /* This function currently only supports ARM and TI unwinders. */
8020 warn (_("Only TI and ARM unwinders are currently supported\n"));
8021 break;
8022 }
fa197c1c 8023
0b6ae522
DJ		 8024 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8025 addr->section = sym->st_shndx;
8026 addr->offset = offset;
74e1a04b 8027
1b31d05e
NC		 8028 if (sym_name)
8029 * sym_name = sym->st_name;
0b6ae522
DJ		 8030 break;
8031 }
8032
8033 *wordp = word;
8034 arm_sec->next_rela = rp;
8035
a734115a 8036 return TRUE;
0b6ae522
DJ		 8037}
8038
a734115a
NC		 8039static const char *tic6x_unwind_regnames[16] =
8040{
0b4362b0
RM		 8041 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8042 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 8043 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8044};
fa197c1c 8045
0b6ae522 8046static void
fa197c1c 8047decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 8048{
fa197c1c
PB		 8049 int i;
8050
8051 for (i = 12; mask; mask >>= 1, i--)
8052 {
8053 if (mask & 1)
8054 {
8055 fputs (tic6x_unwind_regnames[i], stdout);
8056 if (mask > 1)
8057 fputs (", ", stdout);
8058 }
8059 }
8060}
0b6ae522
DJ		 8061
8062#define ADVANCE \
8063 if (remaining == 0 && more_words) \
8064 { \
8065 data_offset += 4; \
1b31d05e
NC		 8066 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8067 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 8068 return; \
8069 remaining = 4; \
8070 more_words--; \
8071 } \
8072
8073#define GET_OP(OP) \
8074 ADVANCE; \
8075 if (remaining) \
8076 { \
8077 remaining--; \
8078 (OP) = word >> 24; \
8079 word <<= 8; \
8080 } \
8081 else \
8082 { \
2b692964 8083 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 8084 return; \
8085 } \
cc5914eb 8086 printf ("0x%02x ", OP)
0b6ae522 8087
fa197c1c 8088static void
948f632f
DA		 8089decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
8090 unsigned int word,
8091 unsigned int remaining,
8092 unsigned int more_words,
8093 bfd_vma data_offset,
8094 Elf_Internal_Shdr * data_sec,
8095 struct arm_section * data_arm_sec)
fa197c1c
PB		 8096{
8097 struct absaddr addr;
0b6ae522
DJ		 8098
8099 /* Decode the unwinding instructions. */
8100 while (1)
8101 {
8102 unsigned int op, op2;
8103
8104 ADVANCE;
8105 if (remaining == 0)
8106 break;
8107 remaining--;
8108 op = word >> 24;
8109 word <<= 8;
8110
cc5914eb 8111 printf (" 0x%02x ", op);
0b6ae522
DJ		 8112
8113 if ((op & 0xc0) == 0x00)
8114 {
8115 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8116
cc5914eb 8117 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 8118 }
8119 else if ((op & 0xc0) == 0x40)
8120 {
8121 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8122
cc5914eb 8123 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 8124 }
8125 else if ((op & 0xf0) == 0x80)
8126 {
8127 GET_OP (op2);
8128 if (op == 0x80 && op2 == 0)
8129 printf (_("Refuse to unwind"));
8130 else
8131 {
8132 unsigned int mask = ((op & 0x0f) << 8) | op2;
8133 int first = 1;
8134 int i;
2b692964 8135
0b6ae522
DJ		 8136 printf ("pop {");
8137 for (i = 0; i < 12; i++)
8138 if (mask & (1 << i))
8139 {
8140 if (first)
8141 first = 0;
8142 else
8143 printf (", ");
8144 printf ("r%d", 4 + i);
8145 }
8146 printf ("}");
8147 }
8148 }
8149 else if ((op & 0xf0) == 0x90)
8150 {
8151 if (op == 0x9d || op == 0x9f)
8152 printf (_(" [Reserved]"));
8153 else
cc5914eb 8154 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 8155 }
8156 else if ((op & 0xf0) == 0xa0)
8157 {
8158 int end = 4 + (op & 0x07);
8159 int first = 1;
8160 int i;
61865e30 8161
0b6ae522
DJ		 8162 printf (" pop {");
8163 for (i = 4; i <= end; i++)
8164 {
8165 if (first)
8166 first = 0;
8167 else
8168 printf (", ");
8169 printf ("r%d", i);
8170 }
8171 if (op & 0x08)
8172 {
1b31d05e 8173 if (!first)
0b6ae522
DJ		 8174 printf (", ");
8175 printf ("r14");
8176 }
8177 printf ("}");
8178 }
8179 else if (op == 0xb0)
8180 printf (_(" finish"));
8181 else if (op == 0xb1)
8182 {
8183 GET_OP (op2);
8184 if (op2 == 0 || (op2 & 0xf0) != 0)
8185 printf (_("[Spare]"));
8186 else
8187 {
8188 unsigned int mask = op2 & 0x0f;
8189 int first = 1;
8190 int i;
61865e30 8191
0b6ae522
DJ		 8192 printf ("pop {");
8193 for (i = 0; i < 12; i++)
8194 if (mask & (1 << i))
8195 {
8196 if (first)
8197 first = 0;
8198 else
8199 printf (", ");
8200 printf ("r%d", i);
8201 }
8202 printf ("}");
8203 }
8204 }
8205 else if (op == 0xb2)
8206 {
b115cf96 8207 unsigned char buf[9];
0b6ae522
DJ		 8208 unsigned int i, len;
8209 unsigned long offset;
61865e30 8210
b115cf96 8211 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 8212 {
8213 GET_OP (buf[i]);
8214 if ((buf[i] & 0x80) == 0)
8215 break;
8216 }
4082ef84
NC		 8217 if (i == sizeof (buf))
8218 printf (_("corrupt change to vsp"));
8219 else
8220 {
8221 offset = read_uleb128 (buf, &len, buf + i + 1);
8222 assert (len == i + 1);
8223 offset = offset * 4 + 0x204;
8224 printf ("vsp = vsp + %ld", offset);
8225 }
0b6ae522 8226 }
61865e30 8227 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 8228 {
61865e30
NC		 8229 unsigned int first, last;
8230
8231 GET_OP (op2);
8232 first = op2 >> 4;
8233 last = op2 & 0x0f;
8234 if (op == 0xc8)
8235 first = first + 16;
8236 printf ("pop {D%d", first);
8237 if (last)
8238 printf ("-D%d", first + last);
8239 printf ("}");
8240 }
8241 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8242 {
8243 unsigned int count = op & 0x07;
8244
8245 printf ("pop {D8");
8246 if (count)
8247 printf ("-D%d", 8 + count);
8248 printf ("}");
8249 }
8250 else if (op >= 0xc0 && op <= 0xc5)
8251 {
8252 unsigned int count = op & 0x07;
8253
8254 printf (" pop {wR10");
8255 if (count)
8256 printf ("-wR%d", 10 + count);
8257 printf ("}");
8258 }
8259 else if (op == 0xc6)
8260 {
8261 unsigned int first, last;
8262
8263 GET_OP (op2);
8264 first = op2 >> 4;
8265 last = op2 & 0x0f;
8266 printf ("pop {wR%d", first);
8267 if (last)
8268 printf ("-wR%d", first + last);
8269 printf ("}");
8270 }
8271 else if (op == 0xc7)
8272 {
8273 GET_OP (op2);
8274 if (op2 == 0 || (op2 & 0xf0) != 0)
8275 printf (_("[Spare]"));
0b6ae522
DJ		 8276 else
8277 {
61865e30
NC		 8278 unsigned int mask = op2 & 0x0f;
8279 int first = 1;
8280 int i;
8281
8282 printf ("pop {");
8283 for (i = 0; i < 4; i++)
8284 if (mask & (1 << i))
8285 {
8286 if (first)
8287 first = 0;
8288 else
8289 printf (", ");
8290 printf ("wCGR%d", i);
8291 }
8292 printf ("}");
0b6ae522
DJ		 8293 }
8294 }
61865e30
NC		 8295 else
8296 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 8297 printf ("\n");
8298 }
fa197c1c
PB		 8299}
8300
8301static void
948f632f
DA		 8302decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8303 unsigned int word,
8304 unsigned int remaining,
8305 unsigned int more_words,
8306 bfd_vma data_offset,
8307 Elf_Internal_Shdr * data_sec,
8308 struct arm_section * data_arm_sec)
fa197c1c
PB		 8309{
8310 struct absaddr addr;
8311
8312 /* Decode the unwinding instructions. */
8313 while (1)
8314 {
8315 unsigned int op, op2;
8316
8317 ADVANCE;
8318 if (remaining == 0)
8319 break;
8320 remaining--;
8321 op = word >> 24;
8322 word <<= 8;
8323
9cf03b7e 8324 printf (" 0x%02x ", op);
fa197c1c
PB		 8325
8326 if ((op & 0xc0) == 0x00)
8327 {
8328 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8329 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8330 }
8331 else if ((op & 0xc0) == 0x80)
8332 {
8333 GET_OP (op2);
8334 if (op == 0x80 && op2 == 0)
8335 printf (_("Refuse to unwind"));
8336 else
8337 {
8338 unsigned int mask = ((op & 0x1f) << 8) | op2;
8339 if (op & 0x20)
8340 printf ("pop compact {");
8341 else
8342 printf ("pop {");
8343
8344 decode_tic6x_unwind_regmask (mask);
8345 printf("}");
8346 }
8347 }
8348 else if ((op & 0xf0) == 0xc0)
8349 {
8350 unsigned int reg;
8351 unsigned int nregs;
8352 unsigned int i;
8353 const char *name;
a734115a
NC		 8354 struct
8355 {
fa197c1c
PB		 8356 unsigned int offset;
8357 unsigned int reg;
8358 } regpos[16];
8359
8360 /* Scan entire instruction first so that GET_OP output is not
8361 interleaved with disassembly. */
8362 nregs = 0;
8363 for (i = 0; nregs < (op & 0xf); i++)
8364 {
8365 GET_OP (op2);
8366 reg = op2 >> 4;
8367 if (reg != 0xf)
8368 {
8369 regpos[nregs].offset = i * 2;
8370 regpos[nregs].reg = reg;
8371 nregs++;
8372 }
8373
8374 reg = op2 & 0xf;
8375 if (reg != 0xf)
8376 {
8377 regpos[nregs].offset = i * 2 + 1;
8378 regpos[nregs].reg = reg;
8379 nregs++;
8380 }
8381 }
8382
8383 printf (_("pop frame {"));
8384 reg = nregs - 1;
8385 for (i = i * 2; i > 0; i--)
8386 {
8387 if (regpos[reg].offset == i - 1)
8388 {
8389 name = tic6x_unwind_regnames[regpos[reg].reg];
8390 if (reg > 0)
8391 reg--;
8392 }
8393 else
8394 name = _("[pad]");
8395
8396 fputs (name, stdout);
8397 if (i > 1)
8398 printf (", ");
8399 }
8400
8401 printf ("}");
8402 }
8403 else if (op == 0xd0)
8404 printf (" MOV FP, SP");
8405 else if (op == 0xd1)
8406 printf (" __c6xabi_pop_rts");
8407 else if (op == 0xd2)
8408 {
8409 unsigned char buf[9];
8410 unsigned int i, len;
8411 unsigned long offset;
a734115a 8412
fa197c1c
PB		 8413 for (i = 0; i < sizeof (buf); i++)
8414 {
8415 GET_OP (buf[i]);
8416 if ((buf[i] & 0x80) == 0)
8417 break;
8418 }
0eff7165
NC		 8419 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8420 if (i == sizeof (buf))
8421 {
8422 printf ("<corrupt sp adjust>\n");
8423 warn (_("Corrupt stack pointer adjustment detected\n"));
8424 return;
8425 }
948f632f 8426
f6f0e17b 8427 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8428 assert (len == i + 1);
8429 offset = offset * 8 + 0x408;
8430 printf (_("sp = sp + %ld"), offset);
8431 }
8432 else if ((op & 0xf0) == 0xe0)
8433 {
8434 if ((op & 0x0f) == 7)
8435 printf (" RETURN");
8436 else
8437 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8438 }
8439 else
8440 {
8441 printf (_(" [unsupported opcode]"));
8442 }
8443 putchar ('\n');
8444 }
8445}
8446
8447static bfd_vma
a734115a 8448arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8449{
8450 bfd_vma offset;
8451
8452 offset = word & 0x7fffffff;
8453 if (offset & 0x40000000)
8454 offset |= ~ (bfd_vma) 0x7fffffff;
8455
8456 if (elf_header.e_machine == EM_TI_C6000)
8457 offset <<= 1;
8458
8459 return offset + where;
8460}
8461
8462static void
1b31d05e
NC		 8463decode_arm_unwind (struct arm_unw_aux_info * aux,
8464 unsigned int word,
8465 unsigned int remaining,
8466 bfd_vma data_offset,
8467 Elf_Internal_Shdr * data_sec,
8468 struct arm_section * data_arm_sec)
fa197c1c
PB		 8469{
8470 int per_index;
8471 unsigned int more_words = 0;
37e14bc3 8472 struct absaddr addr;
1b31d05e 8473 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8474
8475 if (remaining == 0)
8476 {
1b31d05e
NC		 8477 /* Fetch the first word.
8478 Note - when decoding an object file the address extracted
8479 here will always be 0. So we also pass in the sym_name
8480 parameter so that we can find the symbol associated with
8481 the personality routine. */
8482 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8483 & word, & addr, & sym_name))
fa197c1c 8484 return;
1b31d05e 8485
fa197c1c
PB		 8486 remaining = 4;
8487 }
8488
8489 if ((word & 0x80000000) == 0)
8490 {
8491 /* Expand prel31 for personality routine. */
8492 bfd_vma fn;
8493 const char *procname;
8494
a734115a 8495 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8496 printf (_(" Personality routine: "));
1b31d05e
NC		 8497 if (fn == 0
8498 && addr.section == SHN_UNDEF && addr.offset == 0
8499 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8500 {
8501 procname = aux->strtab + sym_name;
8502 print_vma (fn, PREFIX_HEX);
8503 if (procname)
8504 {
8505 fputs (" <", stdout);
8506 fputs (procname, stdout);
8507 fputc ('>', stdout);
8508 }
8509 }
8510 else
8511 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8512 fputc ('\n', stdout);
8513
8514 /* The GCC personality routines use the standard compact
8515 encoding, starting with one byte giving the number of
8516 words. */
8517 if (procname != NULL
8518 && (const_strneq (procname, "__gcc_personality_v0")
8519 || const_strneq (procname, "__gxx_personality_v0")
8520 || const_strneq (procname, "__gcj_personality_v0")
8521 || const_strneq (procname, "__gnu_objc_personality_v0")))
8522 {
8523 remaining = 0;
8524 more_words = 1;
8525 ADVANCE;
8526 if (!remaining)
8527 {
8528 printf (_(" [Truncated data]\n"));
8529 return;
8530 }
8531 more_words = word >> 24;
8532 word <<= 8;
8533 remaining--;
8534 per_index = -1;
8535 }
8536 else
8537 return;
8538 }
8539 else
8540 {
1b31d05e 8541 /* ARM EHABI Section 6.3:
0b4362b0 8542
1b31d05e 8543 An exception-handling table entry for the compact model looks like:
0b4362b0 8544
1b31d05e
NC		 8545 31 30-28 27-24 23-0
8546 -- ----- ----- ----
8547 1 0 index Data for personalityRoutine[index] */
8548
8549 if (elf_header.e_machine == EM_ARM
8550 && (word & 0x70000000))
83c257ca 8551 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8552
fa197c1c 8553 per_index = (word >> 24) & 0x7f;
1b31d05e 8554 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8555 if (per_index == 0)
8556 {
8557 more_words = 0;
8558 word <<= 8;
8559 remaining--;
8560 }
8561 else if (per_index < 3)
8562 {
8563 more_words = (word >> 16) & 0xff;
8564 word <<= 16;
8565 remaining -= 2;
8566 }
8567 }
8568
8569 switch (elf_header.e_machine)
8570 {
8571 case EM_ARM:
8572 if (per_index < 3)
8573 {
8574 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8575 data_offset, data_sec, data_arm_sec);
8576 }
8577 else
1b31d05e
NC		 8578 {
8579 warn (_("Unknown ARM compact model index encountered\n"));
8580 printf (_(" [reserved]\n"));
8581 }
fa197c1c
PB		 8582 break;
8583
8584 case EM_TI_C6000:
8585 if (per_index < 3)
8586 {
8587 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8588 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8589 }
8590 else if (per_index < 5)
8591 {
8592 if (((word >> 17) & 0x7f) == 0x7f)
8593 printf (_(" Restore stack from frame pointer\n"));
8594 else
8595 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8596 printf (_(" Registers restored: "));
8597 if (per_index == 4)
8598 printf (" (compact) ");
8599 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8600 putchar ('\n');
8601 printf (_(" Return register: %s\n"),
8602 tic6x_unwind_regnames[word & 0xf]);
8603 }
8604 else
1b31d05e 8605 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8606 break;
8607
8608 default:
74e1a04b 8609 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8610 elf_header.e_machine);
fa197c1c 8611 }
0b6ae522
DJ		 8612
8613 /* Decode the descriptors. Not implemented. */
8614}
8615
8616static void
8617dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8618{
8619 struct arm_section exidx_arm_sec, extab_arm_sec;
8620 unsigned int i, exidx_len;
948f632f 8621 unsigned long j, nfuns;
0b6ae522
DJ		 8622
8623 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8624 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8625 exidx_len = exidx_sec->sh_size / 8;
8626
948f632f
DA		 8627 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8628 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8629 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8630 aux->funtab[nfuns++] = aux->symtab[j];
8631 aux->nfuns = nfuns;
8632 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8633
0b6ae522
DJ		 8634 for (i = 0; i < exidx_len; i++)
8635 {
8636 unsigned int exidx_fn, exidx_entry;
8637 struct absaddr fn_addr, entry_addr;
8638 bfd_vma fn;
8639
8640 fputc ('\n', stdout);
8641
1b31d05e
NC		 8642 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8643 8 * i, & exidx_fn, & fn_addr, NULL)
8644 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8645 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8646 {
948f632f 8647 free (aux->funtab);
1b31d05e
NC		 8648 arm_free_section (& exidx_arm_sec);
8649 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8650 return;
8651 }
8652
83c257ca
NC		 8653 /* ARM EHABI, Section 5:
8654 An index table entry consists of 2 words.
8655 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8656 if (exidx_fn & 0x80000000)
8657 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8658
a734115a 8659 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8660
a734115a 8661 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8662 fputs (": ", stdout);
8663
8664 if (exidx_entry == 1)
8665 {
8666 print_vma (exidx_entry, PREFIX_HEX);
8667 fputs (" [cantunwind]\n", stdout);
8668 }
8669 else if (exidx_entry & 0x80000000)
8670 {
8671 print_vma (exidx_entry, PREFIX_HEX);
8672 fputc ('\n', stdout);
8673 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8674 }
8675 else
8676 {
8f73510c 8677 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8678 Elf_Internal_Shdr *table_sec;
8679
8680 fputs ("@", stdout);
a734115a 8681 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8682 print_vma (table, PREFIX_HEX);
8683 printf ("\n");
8684
8685 /* Locate the matching .ARM.extab. */
8686 if (entry_addr.section != SHN_UNDEF
8687 && entry_addr.section < elf_header.e_shnum)
8688 {
8689 table_sec = section_headers + entry_addr.section;
8690 table_offset = entry_addr.offset;
1a915552
NC		 8691 /* PR 18879 */
8692 if (table_offset > table_sec->sh_size
8693 || ((bfd_signed_vma) table_offset) < 0)
8694 {
8695 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8696 (unsigned long) table_offset,
8697 printable_section_name (table_sec));
8698 continue;
8699 }
0b6ae522
DJ		 8700 }
8701 else
8702 {
8703 table_sec = find_section_by_address (table);
8704 if (table_sec != NULL)
8705 table_offset = table - table_sec->sh_addr;
8706 }
8707 if (table_sec == NULL)
8708 {
8709 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8710 (unsigned long) table);
8711 continue;
8712 }
8713 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8714 &extab_arm_sec);
8715 }
8716 }
8717
8718 printf ("\n");
8719
948f632f 8720 free (aux->funtab);
0b6ae522
DJ		 8721 arm_free_section (&exidx_arm_sec);
8722 arm_free_section (&extab_arm_sec);
8723}
8724
fa197c1c 8725/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8726
8727static void
0b6ae522
DJ		 8728arm_process_unwind (FILE *file)
8729{
8730 struct arm_unw_aux_info aux;
8731 Elf_Internal_Shdr *unwsec = NULL;
8732 Elf_Internal_Shdr *strsec;
8733 Elf_Internal_Shdr *sec;
8734 unsigned long i;
fa197c1c 8735 unsigned int sec_type;
0b6ae522 8736
fa197c1c
PB		 8737 switch (elf_header.e_machine)
8738 {
8739 case EM_ARM:
8740 sec_type = SHT_ARM_EXIDX;
8741 break;
8742
8743 case EM_TI_C6000:
8744 sec_type = SHT_C6000_UNWIND;
8745 break;
8746
0b4362b0 8747 default:
74e1a04b 8748 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8749 elf_header.e_machine);
8750 return;
fa197c1c
PB		 8751 }
8752
0b6ae522 8753 if (string_table == NULL)
1b31d05e
NC		 8754 return;
8755
8756 memset (& aux, 0, sizeof (aux));
8757 aux.file = file;
0b6ae522
DJ		 8758
8759 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8760 {
8761 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8762 {
ba5cdace 8763 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8764
8765 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8766
8767 /* PR binutils/17531 file: 011-12666-0.004. */
8768 if (aux.strtab != NULL)
8769 {
4082ef84 8770 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8771 free (aux.strtab);
8772 }
0b6ae522
DJ		 8773 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8774 1, strsec->sh_size, _("string table"));
8775 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8776 }
fa197c1c 8777 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8778 unwsec = sec;
8779 }
8780
1b31d05e 8781 if (unwsec == NULL)
0b6ae522 8782 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8783 else
8784 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8785 {
8786 if (sec->sh_type == sec_type)
8787 {
8788 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8789 printable_section_name (sec),
1b31d05e
NC		 8790 (unsigned long) sec->sh_offset,
8791 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8792
1b31d05e
NC		 8793 dump_arm_unwind (&aux, sec);
8794 }
8795 }
0b6ae522
DJ		 8796
8797 if (aux.symtab)
8798 free (aux.symtab);
8799 if (aux.strtab)
8800 free ((char *) aux.strtab);
0b6ae522
DJ		 8801}
8802
1b31d05e 8803static void
2cf0635d 8804process_unwind (FILE * file)
57346661 8805{
2cf0635d
NC		 8806 struct unwind_handler
8807 {
57346661 8808 int machtype;
1b31d05e 8809 void (* handler)(FILE *);
2cf0635d
NC		 8810 } handlers[] =
8811 {
0b6ae522 8812 { EM_ARM, arm_process_unwind },
57346661
AM		 8813 { EM_IA_64, ia64_process_unwind },
8814 { EM_PARISC, hppa_process_unwind },
fa197c1c 8815 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8816 { 0, 0 }
8817 };
8818 int i;
8819
8820 if (!do_unwind)
1b31d05e 8821 return;
57346661
AM		 8822
8823 for (i = 0; handlers[i].handler != NULL; i++)
8824 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8825 {
8826 handlers[i].handler (file);
8827 return;
8828 }
57346661 8829
1b31d05e
NC		 8830 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8831 get_machine_name (elf_header.e_machine));
57346661
AM		 8832}
8833
252b5132 8834static void
2cf0635d 8835dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8836{
8837 switch (entry->d_tag)
8838 {
8839 case DT_MIPS_FLAGS:
8840 if (entry->d_un.d_val == 0)
4b68bca3 8841 printf (_("NONE"));
252b5132
RH		 8842 else
8843 {
8844 static const char * opts[] =
8845 {
8846 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8847 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8848 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8849 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8850 "RLD_ORDER_SAFE"
8851 };
8852 unsigned int cnt;
8853 int first = 1;
2b692964 8854
60bca95a 8855 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8856 if (entry->d_un.d_val & (1 << cnt))
8857 {
8858 printf ("%s%s", first ? "" : " ", opts[cnt]);
8859 first = 0;
8860 }
252b5132
RH		 8861 }
8862 break;
103f02d3 8863
252b5132 8864 case DT_MIPS_IVERSION:
d79b3d50 8865 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8866 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8867 else
76ca31c0
NC		 8868 {
8869 char buf[40];
8870 sprintf_vma (buf, entry->d_un.d_ptr);
8871 /* Note: coded this way so that there is a single string for translation. */
8872 printf (_("<corrupt: %s>"), buf);
8873 }
252b5132 8874 break;
103f02d3 8875
252b5132
RH		 8876 case DT_MIPS_TIME_STAMP:
8877 {
d5b07ef4 8878 char timebuf[128];
2cf0635d 8879 struct tm * tmp;
91d6fa6a 8880 time_t atime = entry->d_un.d_val;
82b1b41b 8881
91d6fa6a 8882 tmp = gmtime (&atime);
82b1b41b
NC		 8883 /* PR 17531: file: 6accc532. */
8884 if (tmp == NULL)
8885 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8886 else
8887 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8888 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8889 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8890 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8891 }
8892 break;
103f02d3 8893
252b5132
RH		 8894 case DT_MIPS_RLD_VERSION:
8895 case DT_MIPS_LOCAL_GOTNO:
8896 case DT_MIPS_CONFLICTNO:
8897 case DT_MIPS_LIBLISTNO:
8898 case DT_MIPS_SYMTABNO:
8899 case DT_MIPS_UNREFEXTNO:
8900 case DT_MIPS_HIPAGENO:
8901 case DT_MIPS_DELTA_CLASS_NO:
8902 case DT_MIPS_DELTA_INSTANCE_NO:
8903 case DT_MIPS_DELTA_RELOC_NO:
8904 case DT_MIPS_DELTA_SYM_NO:
8905 case DT_MIPS_DELTA_CLASSSYM_NO:
8906 case DT_MIPS_COMPACT_SIZE:
c69075ac 8907 print_vma (entry->d_un.d_val, DEC);
252b5132 8908 break;
103f02d3
UD		 8909
8910 default:
4b68bca3 8911 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8912 }
4b68bca3 8913 putchar ('\n');
103f02d3
UD		 8914}
8915
103f02d3 8916static void
2cf0635d 8917dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8918{
8919 switch (entry->d_tag)
8920 {
8921 case DT_HP_DLD_FLAGS:
8922 {
8923 static struct
8924 {
8925 long int bit;
2cf0635d 8926 const char * str;
5e220199
NC		 8927 }
8928 flags[] =
8929 {
8930 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8931 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8932 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8933 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8934 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8935 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8936 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8937 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8938 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8939 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8940 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8941 { DT_HP_GST, "HP_GST" },
8942 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8943 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8944 { DT_HP_NODELETE, "HP_NODELETE" },
8945 { DT_HP_GROUP, "HP_GROUP" },
8946 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8947 };
103f02d3 8948 int first = 1;
5e220199 8949 size_t cnt;
f7a99963 8950 bfd_vma val = entry->d_un.d_val;
103f02d3 8951
60bca95a 8952 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8953 if (val & flags[cnt].bit)
30800947
NC		 8954 {
8955 if (! first)
8956 putchar (' ');
8957 fputs (flags[cnt].str, stdout);
8958 first = 0;
8959 val ^= flags[cnt].bit;
8960 }
76da6bbe 8961
103f02d3 8962 if (val != 0 || first)
f7a99963
NC		 8963 {
8964 if (! first)
8965 putchar (' ');
8966 print_vma (val, HEX);
8967 }
103f02d3
UD		 8968 }
8969 break;
76da6bbe 8970
252b5132 8971 default:
f7a99963
NC		 8972 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8973 break;
252b5132 8974 }
35b1837e 8975 putchar ('\n');
252b5132
RH		 8976}
8977
28f997cf
TG		 8978#ifdef BFD64
8979
8980/* VMS vs Unix time offset and factor. */
8981
8982#define VMS_EPOCH_OFFSET 35067168000000000LL
8983#define VMS_GRANULARITY_FACTOR 10000000
8984
8985/* Display a VMS time in a human readable format. */
8986
8987static void
8988print_vms_time (bfd_int64_t vmstime)
8989{
8990 struct tm *tm;
8991 time_t unxtime;
8992
8993 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8994 tm = gmtime (&unxtime);
8995 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8996 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8997 tm->tm_hour, tm->tm_min, tm->tm_sec);
8998}
8999#endif /* BFD64 */
9000
ecc51f48 9001static void
2cf0635d 9002dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 9003{
9004 switch (entry->d_tag)
9005 {
0de14b54 9006 case DT_IA_64_PLT_RESERVE:
bdf4d63a 9007 /* First 3 slots reserved. */
ecc51f48
NC		 9008 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9009 printf (" -- ");
9010 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 9011 break;
9012
28f997cf
TG		 9013 case DT_IA_64_VMS_LINKTIME:
9014#ifdef BFD64
9015 print_vms_time (entry->d_un.d_val);
9016#endif
9017 break;
9018
9019 case DT_IA_64_VMS_LNKFLAGS:
9020 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9021 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9022 printf (" CALL_DEBUG");
9023 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9024 printf (" NOP0BUFS");
9025 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9026 printf (" P0IMAGE");
9027 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9028 printf (" MKTHREADS");
9029 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9030 printf (" UPCALLS");
9031 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9032 printf (" IMGSTA");
9033 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9034 printf (" INITIALIZE");
9035 if (entry->d_un.d_val & VMS_LF_MAIN)
9036 printf (" MAIN");
9037 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9038 printf (" EXE_INIT");
9039 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9040 printf (" TBK_IN_IMG");
9041 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9042 printf (" DBG_IN_IMG");
9043 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9044 printf (" TBK_IN_DSF");
9045 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9046 printf (" DBG_IN_DSF");
9047 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9048 printf (" SIGNATURES");
9049 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9050 printf (" REL_SEG_OFF");
9051 break;
9052
bdf4d63a
JJ		 9053 default:
9054 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9055 break;
ecc51f48 9056 }
bdf4d63a 9057 putchar ('\n');
ecc51f48
NC		 9058}
9059
252b5132 9060static int
2cf0635d 9061get_32bit_dynamic_section (FILE * file)
252b5132 9062{
2cf0635d
NC		 9063 Elf32_External_Dyn * edyn;
9064 Elf32_External_Dyn * ext;
9065 Elf_Internal_Dyn * entry;
103f02d3 9066
3f5e193b
NC		 9067 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9068 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 9069 if (!edyn)
9070 return 0;
103f02d3 9071
071436c6
NC		 9072 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9073 might not have the luxury of section headers. Look for the DT_NULL
9074 terminator to determine the number of entries. */
ba2685cc 9075 for (ext = edyn, dynamic_nent = 0;
53c3012c 9076 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9077 ext++)
9078 {
9079 dynamic_nent++;
9080 if (BYTE_GET (ext->d_tag) == DT_NULL)
9081 break;
9082 }
252b5132 9083
3f5e193b
NC		 9084 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9085 sizeof (* entry));
b2d38a17 9086 if (dynamic_section == NULL)
252b5132 9087 {
8b73c356
NC		 9088 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9089 (unsigned long) dynamic_nent);
9ea033b2
NC		 9090 free (edyn);
9091 return 0;
9092 }
252b5132 9093
fb514b26 9094 for (ext = edyn, entry = dynamic_section;
ba2685cc 9095 entry < dynamic_section + dynamic_nent;
fb514b26 9096 ext++, entry++)
9ea033b2 9097 {
fb514b26
AM		 9098 entry->d_tag = BYTE_GET (ext->d_tag);
9099 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9100 }
9101
9ea033b2
NC		 9102 free (edyn);
9103
9104 return 1;
9105}
9106
9107static int
2cf0635d 9108get_64bit_dynamic_section (FILE * file)
9ea033b2 9109{
2cf0635d
NC		 9110 Elf64_External_Dyn * edyn;
9111 Elf64_External_Dyn * ext;
9112 Elf_Internal_Dyn * entry;
103f02d3 9113
071436c6 9114 /* Read in the data. */
3f5e193b
NC		 9115 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9116 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 9117 if (!edyn)
9118 return 0;
103f02d3 9119
071436c6
NC		 9120 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9121 might not have the luxury of section headers. Look for the DT_NULL
9122 terminator to determine the number of entries. */
ba2685cc 9123 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 9124 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9125 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9126 ext++)
9127 {
9128 dynamic_nent++;
66543521 9129 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 9130 break;
9131 }
252b5132 9132
3f5e193b
NC		 9133 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9134 sizeof (* entry));
b2d38a17 9135 if (dynamic_section == NULL)
252b5132 9136 {
8b73c356
NC		 9137 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9138 (unsigned long) dynamic_nent);
252b5132
RH		 9139 free (edyn);
9140 return 0;
9141 }
9142
071436c6 9143 /* Convert from external to internal formats. */
fb514b26 9144 for (ext = edyn, entry = dynamic_section;
ba2685cc 9145 entry < dynamic_section + dynamic_nent;
fb514b26 9146 ext++, entry++)
252b5132 9147 {
66543521
AM		 9148 entry->d_tag = BYTE_GET (ext->d_tag);
9149 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9150 }
9151
9152 free (edyn);
9153
9ea033b2
NC		 9154 return 1;
9155}
9156
e9e44622
JJ		 9157static void
9158print_dynamic_flags (bfd_vma flags)
d1133906 9159{
e9e44622 9160 int first = 1;
13ae64f3 9161
d1133906
NC		 9162 while (flags)
9163 {
9164 bfd_vma flag;
9165
9166 flag = flags & - flags;
9167 flags &= ~ flag;
9168
e9e44622
JJ		 9169 if (first)
9170 first = 0;
9171 else
9172 putc (' ', stdout);
13ae64f3 9173
d1133906
NC		 9174 switch (flag)
9175 {
e9e44622
JJ		 9176 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9177 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9178 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9179 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9180 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 9181 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 9182 }
9183 }
e9e44622 9184 puts ("");
d1133906
NC		 9185}
9186
b2d38a17
NC		 9187/* Parse and display the contents of the dynamic section. */
9188
9ea033b2 9189static int
2cf0635d 9190process_dynamic_section (FILE * file)
9ea033b2 9191{
2cf0635d 9192 Elf_Internal_Dyn * entry;
9ea033b2
NC		 9193
9194 if (dynamic_size == 0)
9195 {
9196 if (do_dynamic)
b2d38a17 9197 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 9198
9199 return 1;
9200 }
9201
9202 if (is_32bit_elf)
9203 {
b2d38a17 9204 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 9205 return 0;
9206 }
b2d38a17 9207 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 9208 return 0;
9209
252b5132
RH		 9210 /* Find the appropriate symbol table. */
9211 if (dynamic_symbols == NULL)
9212 {
86dba8ee
AM		 9213 for (entry = dynamic_section;
9214 entry < dynamic_section + dynamic_nent;
9215 ++entry)
252b5132 9216 {
c8286bd1 9217 Elf_Internal_Shdr section;
252b5132
RH		 9218
9219 if (entry->d_tag != DT_SYMTAB)
9220 continue;
9221
9222 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9223
9224 /* Since we do not know how big the symbol table is,
9225 we default to reading in the entire file (!) and
9226 processing that. This is overkill, I know, but it
e3c8793a 9227 should work. */
d93f0186 9228 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 9229
fb52b2f4
NC		 9230 if (archive_file_offset != 0)
9231 section.sh_size = archive_file_size - section.sh_offset;
9232 else
9233 {
9234 if (fseek (file, 0, SEEK_END))
591a748a 9235 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 9236
9237 section.sh_size = ftell (file) - section.sh_offset;
9238 }
252b5132 9239
9ea033b2 9240 if (is_32bit_elf)
9ad5cbcf 9241 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 9242 else
9ad5cbcf 9243 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 9244 section.sh_name = string_table_length;
252b5132 9245
ba5cdace 9246 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 9247 if (num_dynamic_syms < 1)
252b5132
RH		 9248 {
9249 error (_("Unable to determine the number of symbols to load\n"));
9250 continue;
9251 }
252b5132
RH		 9252 }
9253 }
9254
9255 /* Similarly find a string table. */
9256 if (dynamic_strings == NULL)
9257 {
86dba8ee
AM		 9258 for (entry = dynamic_section;
9259 entry < dynamic_section + dynamic_nent;
9260 ++entry)
252b5132
RH		 9261 {
9262 unsigned long offset;
b34976b6 9263 long str_tab_len;
252b5132
RH		 9264
9265 if (entry->d_tag != DT_STRTAB)
9266 continue;
9267
9268 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9269
9270 /* Since we do not know how big the string table is,
9271 we default to reading in the entire file (!) and
9272 processing that. This is overkill, I know, but it
e3c8793a 9273 should work. */
252b5132 9274
d93f0186 9275 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 9276
9277 if (archive_file_offset != 0)
9278 str_tab_len = archive_file_size - offset;
9279 else
9280 {
9281 if (fseek (file, 0, SEEK_END))
9282 error (_("Unable to seek to end of file\n"));
9283 str_tab_len = ftell (file) - offset;
9284 }
252b5132
RH		 9285
9286 if (str_tab_len < 1)
9287 {
9288 error
9289 (_("Unable to determine the length of the dynamic string table\n"));
9290 continue;
9291 }
9292
3f5e193b
NC		 9293 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9294 str_tab_len,
9295 _("dynamic string table"));
59245841 9296 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9297 break;
9298 }
9299 }
9300
9301 /* And find the syminfo section if available. */
9302 if (dynamic_syminfo == NULL)
9303 {
3e8bba36 9304 unsigned long syminsz = 0;
252b5132 9305
86dba8ee
AM		 9306 for (entry = dynamic_section;
9307 entry < dynamic_section + dynamic_nent;
9308 ++entry)
252b5132
RH		 9309 {
9310 if (entry->d_tag == DT_SYMINENT)
9311 {
9312 /* Note: these braces are necessary to avoid a syntax
9313 error from the SunOS4 C compiler. */
049b0c3a
NC		 9314 /* PR binutils/17531: A corrupt file can trigger this test.
9315 So do not use an assert, instead generate an error message. */
9316 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9317 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9318 (int) entry->d_un.d_val);
252b5132
RH		 9319 }
9320 else if (entry->d_tag == DT_SYMINSZ)
9321 syminsz = entry->d_un.d_val;
9322 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9323 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9324 syminsz);
252b5132
RH		 9325 }
9326
9327 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9328 {
2cf0635d
NC		 9329 Elf_External_Syminfo * extsyminfo;
9330 Elf_External_Syminfo * extsym;
9331 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9332
9333 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9334 extsyminfo = (Elf_External_Syminfo *)
9335 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9336 _("symbol information"));
a6e9f9df
AM		 9337 if (!extsyminfo)
9338 return 0;
252b5132 9339
3f5e193b 9340 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9341 if (dynamic_syminfo == NULL)
9342 {
8b73c356
NC		 9343 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9344 (unsigned long) syminsz);
252b5132
RH		 9345 return 0;
9346 }
9347
9348 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9349 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9350 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9351 ++syminfo, ++extsym)
252b5132 9352 {
86dba8ee
AM		 9353 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9354 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9355 }
9356
9357 free (extsyminfo);
9358 }
9359 }
9360
9361 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9362 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9363 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9364 if (do_dynamic)
9365 printf (_(" Tag Type Name/Value\n"));
9366
86dba8ee
AM		 9367 for (entry = dynamic_section;
9368 entry < dynamic_section + dynamic_nent;
9369 entry++)
252b5132
RH		 9370 {
9371 if (do_dynamic)
f7a99963 9372 {
2cf0635d 9373 const char * dtype;
e699b9ff 9374
f7a99963
NC		 9375 putchar (' ');
9376 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9377 dtype = get_dynamic_type (entry->d_tag);
9378 printf (" (%s)%*s", dtype,
9379 ((is_32bit_elf ? 27 : 19)
9380 - (int) strlen (dtype)),
f7a99963
NC		 9381 " ");
9382 }
252b5132
RH		 9383
9384 switch (entry->d_tag)
9385 {
d1133906
NC		 9386 case DT_FLAGS:
9387 if (do_dynamic)
e9e44622 9388 print_dynamic_flags (entry->d_un.d_val);
d1133906 9389 break;
76da6bbe 9390
252b5132
RH		 9391 case DT_AUXILIARY:
9392 case DT_FILTER:
019148e4
L		 9393 case DT_CONFIG:
9394 case DT_DEPAUDIT:
9395 case DT_AUDIT:
252b5132
RH		 9396 if (do_dynamic)
9397 {
019148e4 9398 switch (entry->d_tag)
b34976b6 9399 {
019148e4
L		 9400 case DT_AUXILIARY:
9401 printf (_("Auxiliary library"));
9402 break;
9403
9404 case DT_FILTER:
9405 printf (_("Filter library"));
9406 break;
9407
b34976b6 9408 case DT_CONFIG:
019148e4
L		 9409 printf (_("Configuration file"));
9410 break;
9411
9412 case DT_DEPAUDIT:
9413 printf (_("Dependency audit library"));
9414 break;
9415
9416 case DT_AUDIT:
9417 printf (_("Audit library"));
9418 break;
9419 }
252b5132 9420
d79b3d50
NC		 9421 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9422 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9423 else
f7a99963
NC		 9424 {
9425 printf (": ");
9426 print_vma (entry->d_un.d_val, PREFIX_HEX);
9427 putchar ('\n');
9428 }
252b5132
RH		 9429 }
9430 break;
9431
dcefbbbd 9432 case DT_FEATURE:
252b5132
RH		 9433 if (do_dynamic)
9434 {
9435 printf (_("Flags:"));
86f55779 9436
252b5132
RH		 9437 if (entry->d_un.d_val == 0)
9438 printf (_(" None\n"));
9439 else
9440 {
9441 unsigned long int val = entry->d_un.d_val;
86f55779 9442
252b5132
RH		 9443 if (val & DTF_1_PARINIT)
9444 {
9445 printf (" PARINIT");
9446 val ^= DTF_1_PARINIT;
9447 }
dcefbbbd
L		 9448 if (val & DTF_1_CONFEXP)
9449 {
9450 printf (" CONFEXP");
9451 val ^= DTF_1_CONFEXP;
9452 }
252b5132
RH		 9453 if (val != 0)
9454 printf (" %lx", val);
9455 puts ("");
9456 }
9457 }
9458 break;
9459
9460 case DT_POSFLAG_1:
9461 if (do_dynamic)
9462 {
9463 printf (_("Flags:"));
86f55779 9464
252b5132
RH		 9465 if (entry->d_un.d_val == 0)
9466 printf (_(" None\n"));
9467 else
9468 {
9469 unsigned long int val = entry->d_un.d_val;
86f55779 9470
252b5132
RH		 9471 if (val & DF_P1_LAZYLOAD)
9472 {
9473 printf (" LAZYLOAD");
9474 val ^= DF_P1_LAZYLOAD;
9475 }
9476 if (val & DF_P1_GROUPPERM)
9477 {
9478 printf (" GROUPPERM");
9479 val ^= DF_P1_GROUPPERM;
9480 }
9481 if (val != 0)
9482 printf (" %lx", val);
9483 puts ("");
9484 }
9485 }
9486 break;
9487
9488 case DT_FLAGS_1:
9489 if (do_dynamic)
9490 {
9491 printf (_("Flags:"));
9492 if (entry->d_un.d_val == 0)
9493 printf (_(" None\n"));
9494 else
9495 {
9496 unsigned long int val = entry->d_un.d_val;
86f55779 9497
252b5132
RH		 9498 if (val & DF_1_NOW)
9499 {
9500 printf (" NOW");
9501 val ^= DF_1_NOW;
9502 }
9503 if (val & DF_1_GLOBAL)
9504 {
9505 printf (" GLOBAL");
9506 val ^= DF_1_GLOBAL;
9507 }
9508 if (val & DF_1_GROUP)
9509 {
9510 printf (" GROUP");
9511 val ^= DF_1_GROUP;
9512 }
9513 if (val & DF_1_NODELETE)
9514 {
9515 printf (" NODELETE");
9516 val ^= DF_1_NODELETE;
9517 }
9518 if (val & DF_1_LOADFLTR)
9519 {
9520 printf (" LOADFLTR");
9521 val ^= DF_1_LOADFLTR;
9522 }
9523 if (val & DF_1_INITFIRST)
9524 {
9525 printf (" INITFIRST");
9526 val ^= DF_1_INITFIRST;
9527 }
9528 if (val & DF_1_NOOPEN)
9529 {
9530 printf (" NOOPEN");
9531 val ^= DF_1_NOOPEN;
9532 }
9533 if (val & DF_1_ORIGIN)
9534 {
9535 printf (" ORIGIN");
9536 val ^= DF_1_ORIGIN;
9537 }
9538 if (val & DF_1_DIRECT)
9539 {
9540 printf (" DIRECT");
9541 val ^= DF_1_DIRECT;
9542 }
9543 if (val & DF_1_TRANS)
9544 {
9545 printf (" TRANS");
9546 val ^= DF_1_TRANS;
9547 }
9548 if (val & DF_1_INTERPOSE)
9549 {
9550 printf (" INTERPOSE");
9551 val ^= DF_1_INTERPOSE;
9552 }
f7db6139 9553 if (val & DF_1_NODEFLIB)
dcefbbbd 9554 {
f7db6139
L		 9555 printf (" NODEFLIB");
9556 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9557 }
9558 if (val & DF_1_NODUMP)
9559 {
9560 printf (" NODUMP");
9561 val ^= DF_1_NODUMP;
9562 }
34b60028 9563 if (val & DF_1_CONFALT)
dcefbbbd 9564 {
34b60028
L		 9565 printf (" CONFALT");
9566 val ^= DF_1_CONFALT;
9567 }
9568 if (val & DF_1_ENDFILTEE)
9569 {
9570 printf (" ENDFILTEE");
9571 val ^= DF_1_ENDFILTEE;
9572 }
9573 if (val & DF_1_DISPRELDNE)
9574 {
9575 printf (" DISPRELDNE");
9576 val ^= DF_1_DISPRELDNE;
9577 }
9578 if (val & DF_1_DISPRELPND)
9579 {
9580 printf (" DISPRELPND");
9581 val ^= DF_1_DISPRELPND;
9582 }
9583 if (val & DF_1_NODIRECT)
9584 {
9585 printf (" NODIRECT");
9586 val ^= DF_1_NODIRECT;
9587 }
9588 if (val & DF_1_IGNMULDEF)
9589 {
9590 printf (" IGNMULDEF");
9591 val ^= DF_1_IGNMULDEF;
9592 }
9593 if (val & DF_1_NOKSYMS)
9594 {
9595 printf (" NOKSYMS");
9596 val ^= DF_1_NOKSYMS;
9597 }
9598 if (val & DF_1_NOHDR)
9599 {
9600 printf (" NOHDR");
9601 val ^= DF_1_NOHDR;
9602 }
9603 if (val & DF_1_EDITED)
9604 {
9605 printf (" EDITED");
9606 val ^= DF_1_EDITED;
9607 }
9608 if (val & DF_1_NORELOC)
9609 {
9610 printf (" NORELOC");
9611 val ^= DF_1_NORELOC;
9612 }
9613 if (val & DF_1_SYMINTPOSE)
9614 {
9615 printf (" SYMINTPOSE");
9616 val ^= DF_1_SYMINTPOSE;
9617 }
9618 if (val & DF_1_GLOBAUDIT)
9619 {
9620 printf (" GLOBAUDIT");
9621 val ^= DF_1_GLOBAUDIT;
9622 }
9623 if (val & DF_1_SINGLETON)
9624 {
9625 printf (" SINGLETON");
9626 val ^= DF_1_SINGLETON;
dcefbbbd 9627 }
5c383f02
RO		 9628 if (val & DF_1_STUB)
9629 {
9630 printf (" STUB");
9631 val ^= DF_1_STUB;
9632 }
9633 if (val & DF_1_PIE)
9634 {
9635 printf (" PIE");
9636 val ^= DF_1_PIE;
9637 }
252b5132
RH		 9638 if (val != 0)
9639 printf (" %lx", val);
9640 puts ("");
9641 }
9642 }
9643 break;
9644
9645 case DT_PLTREL:
566b0d53 9646 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9647 if (do_dynamic)
9648 puts (get_dynamic_type (entry->d_un.d_val));
9649 break;
9650
9651 case DT_NULL :
9652 case DT_NEEDED :
9653 case DT_PLTGOT :
9654 case DT_HASH :
9655 case DT_STRTAB :
9656 case DT_SYMTAB :
9657 case DT_RELA :
9658 case DT_INIT :
9659 case DT_FINI :
9660 case DT_SONAME :
9661 case DT_RPATH :
9662 case DT_SYMBOLIC:
9663 case DT_REL :
9664 case DT_DEBUG :
9665 case DT_TEXTREL :
9666 case DT_JMPREL :
019148e4 9667 case DT_RUNPATH :
252b5132
RH		 9668 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9669
9670 if (do_dynamic)
9671 {
2cf0635d 9672 char * name;
252b5132 9673
d79b3d50
NC		 9674 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9675 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9676 else
d79b3d50 9677 name = NULL;
252b5132
RH		 9678
9679 if (name)
9680 {
9681 switch (entry->d_tag)
9682 {
9683 case DT_NEEDED:
9684 printf (_("Shared library: [%s]"), name);
9685
18bd398b 9686 if (streq (name, program_interpreter))
f7a99963 9687 printf (_(" program interpreter"));
252b5132
RH		 9688 break;
9689
9690 case DT_SONAME:
f7a99963 9691 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9692 break;
9693
9694 case DT_RPATH:
f7a99963 9695 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9696 break;
9697
019148e4
L		 9698 case DT_RUNPATH:
9699 printf (_("Library runpath: [%s]"), name);
9700 break;
9701
252b5132 9702 default:
f7a99963
NC		 9703 print_vma (entry->d_un.d_val, PREFIX_HEX);
9704 break;
252b5132
RH		 9705 }
9706 }
9707 else
f7a99963
NC		 9708 print_vma (entry->d_un.d_val, PREFIX_HEX);
9709
9710 putchar ('\n');
252b5132
RH		 9711 }
9712 break;
9713
9714 case DT_PLTRELSZ:
9715 case DT_RELASZ :
9716 case DT_STRSZ :
9717 case DT_RELSZ :
9718 case DT_RELAENT :
9719 case DT_SYMENT :
9720 case DT_RELENT :
566b0d53 9721 dynamic_info[entry->d_tag] = entry->d_un.d_val;
1a0670f3 9722 /* Fall through. */
252b5132
RH		 9723 case DT_PLTPADSZ:
9724 case DT_MOVEENT :
9725 case DT_MOVESZ :
9726 case DT_INIT_ARRAYSZ:
9727 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9728 case DT_GNU_CONFLICTSZ:
9729 case DT_GNU_LIBLISTSZ:
252b5132 9730 if (do_dynamic)
f7a99963
NC		 9731 {
9732 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9733 printf (_(" (bytes)\n"));
f7a99963 9734 }
252b5132
RH		 9735 break;
9736
9737 case DT_VERDEFNUM:
9738 case DT_VERNEEDNUM:
9739 case DT_RELACOUNT:
9740 case DT_RELCOUNT:
9741 if (do_dynamic)
f7a99963
NC		 9742 {
9743 print_vma (entry->d_un.d_val, UNSIGNED);
9744 putchar ('\n');
9745 }
252b5132
RH		 9746 break;
9747
9748 case DT_SYMINSZ:
9749 case DT_SYMINENT:
9750 case DT_SYMINFO:
9751 case DT_USED:
9752 case DT_INIT_ARRAY:
9753 case DT_FINI_ARRAY:
9754 if (do_dynamic)
9755 {
d79b3d50
NC		 9756 if (entry->d_tag == DT_USED
9757 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9758 {
2cf0635d 9759 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9760
b34976b6 9761 if (*name)
252b5132
RH		 9762 {
9763 printf (_("Not needed object: [%s]\n"), name);
9764 break;
9765 }
9766 }
103f02d3 9767
f7a99963
NC		 9768 print_vma (entry->d_un.d_val, PREFIX_HEX);
9769 putchar ('\n');
252b5132
RH		 9770 }
9771 break;
9772
9773 case DT_BIND_NOW:
9774 /* The value of this entry is ignored. */
35b1837e
AM		 9775 if (do_dynamic)
9776 putchar ('\n');
252b5132 9777 break;
103f02d3 9778
047b2264
JJ		 9779 case DT_GNU_PRELINKED:
9780 if (do_dynamic)
9781 {
2cf0635d 9782 struct tm * tmp;
91d6fa6a 9783 time_t atime = entry->d_un.d_val;
047b2264 9784
91d6fa6a 9785 tmp = gmtime (&atime);
071436c6
NC		 9786 /* PR 17533 file: 041-1244816-0.004. */
9787 if (tmp == NULL)
5a2cbcf4
L		 9788 printf (_("<corrupt time val: %lx"),
9789 (unsigned long) atime);
071436c6
NC		 9790 else
9791 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9792 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9793 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9794
9795 }
9796 break;
9797
fdc90cb4
JJ		 9798 case DT_GNU_HASH:
9799 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9800 if (do_dynamic)
9801 {
9802 print_vma (entry->d_un.d_val, PREFIX_HEX);
9803 putchar ('\n');
9804 }
9805 break;
9806
252b5132
RH		 9807 default:
9808 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9809 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9810 entry->d_un.d_val;
9811
9812 if (do_dynamic)
9813 {
9814 switch (elf_header.e_machine)
9815 {
9816 case EM_MIPS:
4fe85591 9817 case EM_MIPS_RS3_LE:
b2d38a17 9818 dynamic_section_mips_val (entry);
252b5132 9819 break;
103f02d3 9820 case EM_PARISC:
b2d38a17 9821 dynamic_section_parisc_val (entry);
103f02d3 9822 break;
ecc51f48 9823 case EM_IA_64:
b2d38a17 9824 dynamic_section_ia64_val (entry);
ecc51f48 9825 break;
252b5132 9826 default:
f7a99963
NC		 9827 print_vma (entry->d_un.d_val, PREFIX_HEX);
9828 putchar ('\n');
252b5132
RH		 9829 }
9830 }
9831 break;
9832 }
9833 }
9834
9835 return 1;
9836}
9837
9838static char *
d3ba0551 9839get_ver_flags (unsigned int flags)
252b5132 9840{
b34976b6 9841 static char buff[32];
252b5132
RH		 9842
9843 buff[0] = 0;
9844
9845 if (flags == 0)
9846 return _("none");
9847
9848 if (flags & VER_FLG_BASE)
9849 strcat (buff, "BASE ");
9850
9851 if (flags & VER_FLG_WEAK)
9852 {
9853 if (flags & VER_FLG_BASE)
9854 strcat (buff, "| ");
9855
9856 strcat (buff, "WEAK ");
9857 }
9858
44ec90b9
RO		 9859 if (flags & VER_FLG_INFO)
9860 {
9861 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9862 strcat (buff, "| ");
9863
9864 strcat (buff, "INFO ");
9865 }
9866
9867 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9868 strcat (buff, _("| <unknown>"));
252b5132
RH		 9869
9870 return buff;
9871}
9872
9873/* Display the contents of the version sections. */
98fb390a 9874
252b5132 9875static int
2cf0635d 9876process_version_sections (FILE * file)
252b5132 9877{
2cf0635d 9878 Elf_Internal_Shdr * section;
b34976b6
AM		 9879 unsigned i;
9880 int found = 0;
252b5132
RH		 9881
9882 if (! do_version)
9883 return 1;
9884
9885 for (i = 0, section = section_headers;
9886 i < elf_header.e_shnum;
b34976b6 9887 i++, section++)
252b5132
RH		 9888 {
9889 switch (section->sh_type)
9890 {
9891 case SHT_GNU_verdef:
9892 {
2cf0635d 9893 Elf_External_Verdef * edefs;
b34976b6
AM		 9894 unsigned int idx;
9895 unsigned int cnt;
2cf0635d 9896 char * endbuf;
252b5132
RH		 9897
9898 found = 1;
9899
74e1a04b
NC		 9900 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9901 printable_section_name (section),
9902 section->sh_info);
252b5132
RH		 9903
9904 printf (_(" Addr: 0x"));
9905 printf_vma (section->sh_addr);
74e1a04b 9906 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9907 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9908 printable_section_name_from_index (section->sh_link));
252b5132 9909
3f5e193b
NC		 9910 edefs = (Elf_External_Verdef *)
9911 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9912 _("version definition section"));
a6e9f9df
AM		 9913 if (!edefs)
9914 break;
59245841 9915 endbuf = (char *) edefs + section->sh_size;
252b5132 9916
b34976b6 9917 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9918 {
2cf0635d
NC		 9919 char * vstart;
9920 Elf_External_Verdef * edef;
b34976b6 9921 Elf_Internal_Verdef ent;
2cf0635d 9922 Elf_External_Verdaux * eaux;
b34976b6
AM		 9923 Elf_Internal_Verdaux aux;
9924 int j;
9925 int isum;
103f02d3 9926
7e26601c
NC		 9927 /* Check for very large indicies. */
9928 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9929 break;
9930
252b5132 9931 vstart = ((char *) edefs) + idx;
54806181
AM		 9932 if (vstart + sizeof (*edef) > endbuf)
9933 break;
252b5132
RH		 9934
9935 edef = (Elf_External_Verdef *) vstart;
9936
9937 ent.vd_version = BYTE_GET (edef->vd_version);
9938 ent.vd_flags = BYTE_GET (edef->vd_flags);
9939 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9940 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9941 ent.vd_hash = BYTE_GET (edef->vd_hash);
9942 ent.vd_aux = BYTE_GET (edef->vd_aux);
9943 ent.vd_next = BYTE_GET (edef->vd_next);
9944
9945 printf (_(" %#06x: Rev: %d Flags: %s"),
9946 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9947
9948 printf (_(" Index: %d Cnt: %d "),
9949 ent.vd_ndx, ent.vd_cnt);
9950
dd24e3da 9951 /* Check for overflow. */
7e26601c 9952 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9953 break;
9954
252b5132
RH		 9955 vstart += ent.vd_aux;
9956
9957 eaux = (Elf_External_Verdaux *) vstart;
9958
9959 aux.vda_name = BYTE_GET (eaux->vda_name);
9960 aux.vda_next = BYTE_GET (eaux->vda_next);
9961
d79b3d50
NC		 9962 if (VALID_DYNAMIC_NAME (aux.vda_name))
9963 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9964 else
9965 printf (_("Name index: %ld\n"), aux.vda_name);
9966
9967 isum = idx + ent.vd_aux;
9968
b34976b6 9969 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9970 {
dd24e3da 9971 /* Check for overflow. */
7e26601c 9972 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9973 break;
9974
252b5132
RH		 9975 isum += aux.vda_next;
9976 vstart += aux.vda_next;
9977
9978 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9979 if (vstart + sizeof (*eaux) > endbuf)
9980 break;
252b5132
RH		 9981
9982 aux.vda_name = BYTE_GET (eaux->vda_name);
9983 aux.vda_next = BYTE_GET (eaux->vda_next);
9984
d79b3d50 9985 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9986 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9987 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9988 else
9989 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9990 isum, j, aux.vda_name);
9991 }
dd24e3da 9992
54806181
AM		 9993 if (j < ent.vd_cnt)
9994 printf (_(" Version def aux past end of section\n"));
252b5132 9995
5d921cbd
NC		 9996 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9997 if (idx + ent.vd_next <= idx)
9998 break;
9999
252b5132
RH		 10000 idx += ent.vd_next;
10001 }
dd24e3da 10002
54806181
AM		 10003 if (cnt < section->sh_info)
10004 printf (_(" Version definition past end of section\n"));
252b5132
RH		 10005
10006 free (edefs);
10007 }
10008 break;
103f02d3 10009
252b5132
RH		 10010 case SHT_GNU_verneed:
10011 {
2cf0635d 10012 Elf_External_Verneed * eneed;
b34976b6
AM		 10013 unsigned int idx;
10014 unsigned int cnt;
2cf0635d 10015 char * endbuf;
252b5132
RH		 10016
10017 found = 1;
10018
72de5009 10019 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 10020 printable_section_name (section), section->sh_info);
252b5132
RH		 10021
10022 printf (_(" Addr: 0x"));
10023 printf_vma (section->sh_addr);
72de5009 10024 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10025 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10026 printable_section_name_from_index (section->sh_link));
252b5132 10027
3f5e193b
NC		 10028 eneed = (Elf_External_Verneed *) get_data (NULL, file,
10029 section->sh_offset, 1,
10030 section->sh_size,
9cf03b7e 10031 _("Version Needs section"));
a6e9f9df
AM		 10032 if (!eneed)
10033 break;
59245841 10034 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 10035
10036 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10037 {
2cf0635d 10038 Elf_External_Verneed * entry;
b34976b6
AM		 10039 Elf_Internal_Verneed ent;
10040 int j;
10041 int isum;
2cf0635d 10042 char * vstart;
252b5132 10043
7e26601c 10044 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 10045 break;
10046
252b5132 10047 vstart = ((char *) eneed) + idx;
54806181
AM		 10048 if (vstart + sizeof (*entry) > endbuf)
10049 break;
252b5132
RH		 10050
10051 entry = (Elf_External_Verneed *) vstart;
10052
10053 ent.vn_version = BYTE_GET (entry->vn_version);
10054 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10055 ent.vn_file = BYTE_GET (entry->vn_file);
10056 ent.vn_aux = BYTE_GET (entry->vn_aux);
10057 ent.vn_next = BYTE_GET (entry->vn_next);
10058
10059 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
10060
d79b3d50
NC		 10061 if (VALID_DYNAMIC_NAME (ent.vn_file))
10062 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 10063 else
10064 printf (_(" File: %lx"), ent.vn_file);
10065
10066 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10067
dd24e3da 10068 /* Check for overflow. */
7e26601c 10069 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 10070 break;
252b5132
RH		 10071 vstart += ent.vn_aux;
10072
10073 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10074 {
2cf0635d 10075 Elf_External_Vernaux * eaux;
b34976b6 10076 Elf_Internal_Vernaux aux;
252b5132 10077
54806181
AM		 10078 if (vstart + sizeof (*eaux) > endbuf)
10079 break;
252b5132
RH		 10080 eaux = (Elf_External_Vernaux *) vstart;
10081
10082 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10083 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10084 aux.vna_other = BYTE_GET (eaux->vna_other);
10085 aux.vna_name = BYTE_GET (eaux->vna_name);
10086 aux.vna_next = BYTE_GET (eaux->vna_next);
10087
d79b3d50 10088 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 10089 printf (_(" %#06x: Name: %s"),
d79b3d50 10090 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 10091 else
ecc2063b 10092 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 10093 isum, aux.vna_name);
10094
10095 printf (_(" Flags: %s Version: %d\n"),
10096 get_ver_flags (aux.vna_flags), aux.vna_other);
10097
dd24e3da 10098 /* Check for overflow. */
53774b7e
NC		 10099 if (aux.vna_next > (size_t) (endbuf - vstart)
10100 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10101 {
10102 warn (_("Invalid vna_next field of %lx\n"),
10103 aux.vna_next);
10104 j = ent.vn_cnt;
10105 break;
10106 }
252b5132
RH		 10107 isum += aux.vna_next;
10108 vstart += aux.vna_next;
10109 }
9cf03b7e 10110
54806181 10111 if (j < ent.vn_cnt)
9cf03b7e 10112 warn (_("Missing Version Needs auxillary information\n"));
252b5132 10113
bcf83b2a 10114 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 10115 {
10116 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10117 cnt = section->sh_info;
10118 break;
10119 }
252b5132
RH		 10120 idx += ent.vn_next;
10121 }
9cf03b7e 10122
54806181 10123 if (cnt < section->sh_info)
9cf03b7e 10124 warn (_("Missing Version Needs information\n"));
103f02d3 10125
252b5132
RH		 10126 free (eneed);
10127 }
10128 break;
10129
10130 case SHT_GNU_versym:
10131 {
2cf0635d 10132 Elf_Internal_Shdr * link_section;
8b73c356
NC		 10133 size_t total;
10134 unsigned int cnt;
2cf0635d
NC		 10135 unsigned char * edata;
10136 unsigned short * data;
10137 char * strtab;
10138 Elf_Internal_Sym * symbols;
10139 Elf_Internal_Shdr * string_sec;
ba5cdace 10140 unsigned long num_syms;
d3ba0551 10141 long off;
252b5132 10142
4fbb74a6 10143 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10144 break;
10145
4fbb74a6 10146 link_section = section_headers + section->sh_link;
08d8fa11 10147 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 10148
4fbb74a6 10149 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10150 break;
10151
252b5132
RH		 10152 found = 1;
10153
ba5cdace 10154 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 10155 if (symbols == NULL)
10156 break;
252b5132 10157
4fbb74a6 10158 string_sec = section_headers + link_section->sh_link;
252b5132 10159
3f5e193b
NC		 10160 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10161 string_sec->sh_size,
10162 _("version string table"));
a6e9f9df 10163 if (!strtab)
0429c154
MS		 10164 {
10165 free (symbols);
10166 break;
10167 }
252b5132 10168
8b73c356
NC		 10169 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10170 printable_section_name (section), (unsigned long) total);
252b5132
RH		 10171
10172 printf (_(" Addr: "));
10173 printf_vma (section->sh_addr);
72de5009 10174 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10175 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10176 printable_section_name (link_section));
252b5132 10177
d3ba0551
AM		 10178 off = offset_from_vma (file,
10179 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10180 total * sizeof (short));
3f5e193b
NC		 10181 edata = (unsigned char *) get_data (NULL, file, off, total,
10182 sizeof (short),
10183 _("version symbol data"));
a6e9f9df
AM		 10184 if (!edata)
10185 {
10186 free (strtab);
0429c154 10187 free (symbols);
a6e9f9df
AM		 10188 break;
10189 }
252b5132 10190
3f5e193b 10191 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 10192
10193 for (cnt = total; cnt --;)
b34976b6
AM		 10194 data[cnt] = byte_get (edata + cnt * sizeof (short),
10195 sizeof (short));
252b5132
RH		 10196
10197 free (edata);
10198
10199 for (cnt = 0; cnt < total; cnt += 4)
10200 {
10201 int j, nn;
ab273396
AM		 10202 char *name;
10203 char *invalid = _("*invalid*");
252b5132
RH		 10204
10205 printf (" %03x:", cnt);
10206
10207 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 10208 switch (data[cnt + j])
252b5132
RH		 10209 {
10210 case 0:
10211 fputs (_(" 0 (*local*) "), stdout);
10212 break;
10213
10214 case 1:
10215 fputs (_(" 1 (*global*) "), stdout);
10216 break;
10217
10218 default:
c244d050
NC		 10219 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10220 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 10221
dd24e3da 10222 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 10223 array, break to avoid an out-of-bounds read. */
10224 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 10225 {
10226 warn (_("invalid index into symbol array\n"));
10227 break;
10228 }
10229
ab273396
AM		 10230 name = NULL;
10231 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 10232 {
b34976b6
AM		 10233 Elf_Internal_Verneed ivn;
10234 unsigned long offset;
252b5132 10235
d93f0186
NC		 10236 offset = offset_from_vma
10237 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10238 sizeof (Elf_External_Verneed));
252b5132 10239
b34976b6 10240 do
252b5132 10241 {
b34976b6
AM		 10242 Elf_Internal_Vernaux ivna;
10243 Elf_External_Verneed evn;
10244 Elf_External_Vernaux evna;
10245 unsigned long a_off;
252b5132 10246
59245841
NC		 10247 if (get_data (&evn, file, offset, sizeof (evn), 1,
10248 _("version need")) == NULL)
10249 break;
0b4362b0 10250
252b5132
RH		 10251 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10252 ivn.vn_next = BYTE_GET (evn.vn_next);
10253
10254 a_off = offset + ivn.vn_aux;
10255
10256 do
10257 {
59245841
NC		 10258 if (get_data (&evna, file, a_off, sizeof (evna),
10259 1, _("version need aux (2)")) == NULL)
10260 {
10261 ivna.vna_next = 0;
10262 ivna.vna_other = 0;
10263 }
10264 else
10265 {
10266 ivna.vna_next = BYTE_GET (evna.vna_next);
10267 ivna.vna_other = BYTE_GET (evna.vna_other);
10268 }
252b5132
RH		 10269
10270 a_off += ivna.vna_next;
10271 }
b34976b6 10272 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 10273 && ivna.vna_next != 0);
10274
b34976b6 10275 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 10276 {
10277 ivna.vna_name = BYTE_GET (evna.vna_name);
10278
54806181 10279 if (ivna.vna_name >= string_sec->sh_size)
ab273396 10280 name = invalid;
54806181
AM		 10281 else
10282 name = strtab + ivna.vna_name;
252b5132
RH		 10283 break;
10284 }
10285
10286 offset += ivn.vn_next;
10287 }
10288 while (ivn.vn_next);
10289 }
00d93f34 10290
ab273396 10291 if (data[cnt + j] != 0x8001
b34976b6 10292 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10293 {
b34976b6
AM		 10294 Elf_Internal_Verdef ivd;
10295 Elf_External_Verdef evd;
10296 unsigned long offset;
252b5132 10297
d93f0186
NC		 10298 offset = offset_from_vma
10299 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10300 sizeof evd);
252b5132
RH		 10301
10302 do
10303 {
59245841
NC		 10304 if (get_data (&evd, file, offset, sizeof (evd), 1,
10305 _("version def")) == NULL)
10306 {
10307 ivd.vd_next = 0;
948f632f 10308 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10309 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10310 break;
59245841
NC		 10311 }
10312 else
10313 {
10314 ivd.vd_next = BYTE_GET (evd.vd_next);
10315 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10316 }
252b5132
RH		 10317
10318 offset += ivd.vd_next;
10319 }
c244d050 10320 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10321 && ivd.vd_next != 0);
10322
c244d050 10323 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10324 {
b34976b6
AM		 10325 Elf_External_Verdaux evda;
10326 Elf_Internal_Verdaux ivda;
252b5132
RH		 10327
10328 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10329
59245841
NC		 10330 if (get_data (&evda, file,
10331 offset - ivd.vd_next + ivd.vd_aux,
10332 sizeof (evda), 1,
10333 _("version def aux")) == NULL)
10334 break;
252b5132
RH		 10335
10336 ivda.vda_name = BYTE_GET (evda.vda_name);
10337
54806181 10338 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10339 name = invalid;
10340 else if (name != NULL && name != invalid)
10341 name = _("*both*");
54806181
AM		 10342 else
10343 name = strtab + ivda.vda_name;
252b5132
RH		 10344 }
10345 }
ab273396
AM		 10346 if (name != NULL)
10347 nn += printf ("(%s%-*s",
10348 name,
10349 12 - (int) strlen (name),
10350 ")");
252b5132
RH		 10351
10352 if (nn < 18)
10353 printf ("%*c", 18 - nn, ' ');
10354 }
10355
10356 putchar ('\n');
10357 }
10358
10359 free (data);
10360 free (strtab);
10361 free (symbols);
10362 }
10363 break;
103f02d3 10364
252b5132
RH		 10365 default:
10366 break;
10367 }
10368 }
10369
10370 if (! found)
10371 printf (_("\nNo version information found in this file.\n"));
10372
10373 return 1;
10374}
10375
d1133906 10376static const char *
d3ba0551 10377get_symbol_binding (unsigned int binding)
252b5132 10378{
b34976b6 10379 static char buff[32];
252b5132
RH		 10380
10381 switch (binding)
10382 {
b34976b6
AM		 10383 case STB_LOCAL: return "LOCAL";
10384 case STB_GLOBAL: return "GLOBAL";
10385 case STB_WEAK: return "WEAK";
252b5132
RH		 10386 default:
10387 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10388 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10389 binding);
252b5132 10390 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10391 {
10392 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10393 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10394 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10395 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10396 return "UNIQUE";
10397 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10398 }
252b5132 10399 else
e9e44622 10400 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10401 return buff;
10402 }
10403}
10404
d1133906 10405static const char *
d3ba0551 10406get_symbol_type (unsigned int type)
252b5132 10407{
b34976b6 10408 static char buff[32];
252b5132
RH		 10409
10410 switch (type)
10411 {
b34976b6
AM		 10412 case STT_NOTYPE: return "NOTYPE";
10413 case STT_OBJECT: return "OBJECT";
10414 case STT_FUNC: return "FUNC";
10415 case STT_SECTION: return "SECTION";
10416 case STT_FILE: return "FILE";
10417 case STT_COMMON: return "COMMON";
10418 case STT_TLS: return "TLS";
15ab5209
DB		 10419 case STT_RELC: return "RELC";
10420 case STT_SRELC: return "SRELC";
252b5132
RH		 10421 default:
10422 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10423 {
3510a7b8
NC		 10424 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10425 return "THUMB_FUNC";
103f02d3 10426
351b4b40 10427 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10428 return "REGISTER";
10429
10430 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10431 return "PARISC_MILLI";
10432
e9e44622 10433 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10434 }
252b5132 10435 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10436 {
10437 if (elf_header.e_machine == EM_PARISC)
10438 {
10439 if (type == STT_HP_OPAQUE)
10440 return "HP_OPAQUE";
10441 if (type == STT_HP_STUB)
10442 return "HP_STUB";
10443 }
10444
d8045f23 10445 if (type == STT_GNU_IFUNC
9c55345c 10446 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10447 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10448 /* GNU is still using the default value 0. */
d8045f23
NC		 10449 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10450 return "IFUNC";
10451
e9e44622 10452 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10453 }
252b5132 10454 else
e9e44622 10455 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10456 return buff;
10457 }
10458}
10459
d1133906 10460static const char *
d3ba0551 10461get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10462{
10463 switch (visibility)
10464 {
b34976b6
AM		 10465 case STV_DEFAULT: return "DEFAULT";
10466 case STV_INTERNAL: return "INTERNAL";
10467 case STV_HIDDEN: return "HIDDEN";
d1133906 10468 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10469 default:
10470 error (_("Unrecognized visibility value: %u"), visibility);
10471 return _("<unknown>");
d1133906
NC		 10472 }
10473}
10474
fd85a6a1
NC		 10475static const char *
10476get_solaris_symbol_visibility (unsigned int visibility)
10477{
10478 switch (visibility)
10479 {
10480 case 4: return "EXPORTED";
10481 case 5: return "SINGLETON";
10482 case 6: return "ELIMINATE";
10483 default: return get_symbol_visibility (visibility);
10484 }
10485}
10486
5e2b0d47
NC		 10487static const char *
10488get_mips_symbol_other (unsigned int other)
10489{
10490 switch (other)
10491 {
df58fc94
RS		 10492 case STO_OPTIONAL:
10493 return "OPTIONAL";
10494 case STO_MIPS_PLT:
10495 return "MIPS PLT";
10496 case STO_MIPS_PIC:
10497 return "MIPS PIC";
10498 case STO_MICROMIPS:
10499 return "MICROMIPS";
10500 case STO_MICROMIPS | STO_MIPS_PIC:
10501 return "MICROMIPS, MIPS PIC";
10502 case STO_MIPS16:
10503 return "MIPS16";
10504 default:
10505 return NULL;
5e2b0d47
NC		 10506 }
10507}
10508
28f997cf
TG		 10509static const char *
10510get_ia64_symbol_other (unsigned int other)
10511{
10512 if (is_ia64_vms ())
10513 {
10514 static char res[32];
10515
10516 res[0] = 0;
10517
10518 /* Function types is for images and .STB files only. */
10519 switch (elf_header.e_type)
10520 {
10521 case ET_DYN:
10522 case ET_EXEC:
10523 switch (VMS_ST_FUNC_TYPE (other))
10524 {
10525 case VMS_SFT_CODE_ADDR:
10526 strcat (res, " CA");
10527 break;
10528 case VMS_SFT_SYMV_IDX:
10529 strcat (res, " VEC");
10530 break;
10531 case VMS_SFT_FD:
10532 strcat (res, " FD");
10533 break;
10534 case VMS_SFT_RESERVE:
10535 strcat (res, " RSV");
10536 break;
10537 default:
bee0ee85
NC		 10538 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10539 VMS_ST_FUNC_TYPE (other));
10540 strcat (res, " <unknown>");
10541 break;
28f997cf
TG		 10542 }
10543 break;
10544 default:
10545 break;
10546 }
10547 switch (VMS_ST_LINKAGE (other))
10548 {
10549 case VMS_STL_IGNORE:
10550 strcat (res, " IGN");
10551 break;
10552 case VMS_STL_RESERVE:
10553 strcat (res, " RSV");
10554 break;
10555 case VMS_STL_STD:
10556 strcat (res, " STD");
10557 break;
10558 case VMS_STL_LNK:
10559 strcat (res, " LNK");
10560 break;
10561 default:
bee0ee85
NC		 10562 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10563 VMS_ST_LINKAGE (other));
10564 strcat (res, " <unknown>");
10565 break;
28f997cf
TG		 10566 }
10567
10568 if (res[0] != 0)
10569 return res + 1;
10570 else
10571 return res;
10572 }
10573 return NULL;
10574}
10575
6911b7dc
AM		 10576static const char *
10577get_ppc64_symbol_other (unsigned int other)
10578{
10579 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10580 {
10581 static char buf[32];
10582 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10583 PPC64_LOCAL_ENTRY_OFFSET (other));
10584 return buf;
10585 }
10586 return NULL;
10587}
10588
5e2b0d47
NC		 10589static const char *
10590get_symbol_other (unsigned int other)
10591{
10592 const char * result = NULL;
10593 static char buff [32];
10594
10595 if (other == 0)
10596 return "";
10597
10598 switch (elf_header.e_machine)
10599 {
10600 case EM_MIPS:
10601 result = get_mips_symbol_other (other);
28f997cf
TG		 10602 break;
10603 case EM_IA_64:
10604 result = get_ia64_symbol_other (other);
10605 break;
6911b7dc
AM		 10606 case EM_PPC64:
10607 result = get_ppc64_symbol_other (other);
10608 break;
5e2b0d47 10609 default:
fd85a6a1 10610 result = NULL;
5e2b0d47
NC		 10611 break;
10612 }
10613
10614 if (result)
10615 return result;
10616
10617 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10618 return buff;
10619}
10620
d1133906 10621static const char *
d3ba0551 10622get_symbol_index_type (unsigned int type)
252b5132 10623{
b34976b6 10624 static char buff[32];
5cf1065c 10625
252b5132
RH		 10626 switch (type)
10627 {
b34976b6
AM		 10628 case SHN_UNDEF: return "UND";
10629 case SHN_ABS: return "ABS";
10630 case SHN_COMMON: return "COM";
252b5132 10631 default:
9ce701e2
L		 10632 if (type == SHN_IA_64_ANSI_COMMON
10633 && elf_header.e_machine == EM_IA_64
10634 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10635 return "ANSI_COM";
8a9036a4 10636 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10637 || elf_header.e_machine == EM_L1OM
10638 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10639 && type == SHN_X86_64_LCOMMON)
10640 return "LARGE_COM";
ac145307
BS		 10641 else if ((type == SHN_MIPS_SCOMMON
10642 && elf_header.e_machine == EM_MIPS)
10643 || (type == SHN_TIC6X_SCOMMON
10644 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10645 return "SCOM";
10646 else if (type == SHN_MIPS_SUNDEFINED
10647 && elf_header.e_machine == EM_MIPS)
10648 return "SUND";
9ce701e2 10649 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10650 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10651 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10652 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10653 else if (type >= SHN_LORESERVE)
10654 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10655 else if (type >= elf_header.e_shnum)
e0a31db1 10656 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10657 else
232e7cb8 10658 sprintf (buff, "%3d", type);
5cf1065c 10659 break;
252b5132 10660 }
5cf1065c
NC		 10661
10662 return buff;
252b5132
RH		 10663}
10664
66543521 10665static bfd_vma *
57028622 10666get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10667{
2cf0635d
NC		 10668 unsigned char * e_data;
10669 bfd_vma * i_data;
252b5132 10670
57028622
NC		 10671 /* If the size_t type is smaller than the bfd_size_type, eg because
10672 you are building a 32-bit tool on a 64-bit host, then make sure
10673 that when (number) is cast to (size_t) no information is lost. */
10674 if (sizeof (size_t) < sizeof (bfd_size_type)
10675 && (bfd_size_type) ((size_t) number) != number)
10676 {
ed754a13
AM		 10677 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10678 " elements of size %u\n"),
10679 number, ent_size);
57028622
NC		 10680 return NULL;
10681 }
948f632f 10682
3102e897
NC		 10683 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10684 attempting to allocate memory when the read is bound to fail. */
10685 if (ent_size * number > current_file_size)
10686 {
ed754a13
AM		 10687 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10688 number);
3102e897
NC		 10689 return NULL;
10690 }
10691
57028622 10692 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10693 if (e_data == NULL)
10694 {
ed754a13
AM		 10695 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10696 number);
252b5132
RH		 10697 return NULL;
10698 }
10699
57028622 10700 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10701 {
ed754a13
AM		 10702 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10703 number * ent_size);
3102e897 10704 free (e_data);
252b5132
RH		 10705 return NULL;
10706 }
10707
57028622 10708 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10709 if (i_data == NULL)
10710 {
ed754a13
AM		 10711 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10712 " dynamic entries\n"),
10713 number);
252b5132
RH		 10714 free (e_data);
10715 return NULL;
10716 }
10717
10718 while (number--)
66543521 10719 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10720
10721 free (e_data);
10722
10723 return i_data;
10724}
10725
6bd1a22c
L		 10726static void
10727print_dynamic_symbol (bfd_vma si, unsigned long hn)
10728{
2cf0635d 10729 Elf_Internal_Sym * psym;
6bd1a22c
L		 10730 int n;
10731
6bd1a22c
L		 10732 n = print_vma (si, DEC_5);
10733 if (n < 5)
0b4362b0 10734 fputs (&" "[n], stdout);
6bd1a22c 10735 printf (" %3lu: ", hn);
e0a31db1
NC		 10736
10737 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10738 {
3102e897
NC		 10739 printf (_("<No info available for dynamic symbol number %lu>\n"),
10740 (unsigned long) si);
e0a31db1
NC		 10741 return;
10742 }
10743
10744 psym = dynamic_symbols + si;
6bd1a22c
L		 10745 print_vma (psym->st_value, LONG_HEX);
10746 putchar (' ');
10747 print_vma (psym->st_size, DEC_5);
10748
f4be36b3
AM		 10749 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10750 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 10751
10752 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10753 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10754 else
10755 {
10756 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10757
10758 printf (" %-7s", get_symbol_visibility (vis));
10759 /* Check to see if any other bits in the st_other field are set.
10760 Note - displaying this information disrupts the layout of the
10761 table being generated, but for the moment this case is very
10762 rare. */
10763 if (psym->st_other ^ vis)
10764 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10765 }
10766
6bd1a22c
L		 10767 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10768 if (VALID_DYNAMIC_NAME (psym->st_name))
10769 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10770 else
2b692964 10771 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10772 putchar ('\n');
10773}
10774
bb4d2ac2 10775static const char *
1449284b
NC		 10776get_symbol_version_string (FILE * file,
10777 bfd_boolean is_dynsym,
10778 const char * strtab,
10779 unsigned long int strtab_size,
10780 unsigned int si,
10781 Elf_Internal_Sym * psym,
10782 enum versioned_symbol_info * sym_info,
10783 unsigned short * vna_other)
bb4d2ac2 10784{
ab273396
AM		 10785 unsigned char data[2];
10786 unsigned short vers_data;
10787 unsigned long offset;
bb4d2ac2 10788
ab273396
AM		 10789 if (!is_dynsym
10790 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10791 return NULL;
bb4d2ac2 10792
ab273396
AM		 10793 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10794 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10795
ab273396
AM		 10796 if (get_data (&data, file, offset + si * sizeof (vers_data),
10797 sizeof (data), 1, _("version data")) == NULL)
10798 return NULL;
10799
10800 vers_data = byte_get (data, 2);
bb4d2ac2 10801
ab273396
AM		 10802 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10803 return NULL;
bb4d2ac2 10804
ab273396
AM		 10805 /* Usually we'd only see verdef for defined symbols, and verneed for
10806 undefined symbols. However, symbols defined by the linker in
10807 .dynbss for variables copied from a shared library in order to
10808 avoid text relocations are defined yet have verneed. We could
10809 use a heuristic to detect the special case, for example, check
10810 for verneed first on symbols defined in SHT_NOBITS sections, but
10811 it is simpler and more reliable to just look for both verdef and
10812 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10813
ab273396
AM		 10814 if (psym->st_shndx != SHN_UNDEF
10815 && vers_data != 0x8001
10816 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10817 {
10818 Elf_Internal_Verdef ivd;
10819 Elf_Internal_Verdaux ivda;
10820 Elf_External_Verdaux evda;
10821 unsigned long off;
bb4d2ac2 10822
ab273396
AM		 10823 off = offset_from_vma (file,
10824 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10825 sizeof (Elf_External_Verdef));
10826
10827 do
bb4d2ac2 10828 {
ab273396
AM		 10829 Elf_External_Verdef evd;
10830
10831 if (get_data (&evd, file, off, sizeof (evd), 1,
10832 _("version def")) == NULL)
10833 {
10834 ivd.vd_ndx = 0;
10835 ivd.vd_aux = 0;
10836 ivd.vd_next = 0;
10837 }
10838 else
bb4d2ac2 10839 {
ab273396
AM		 10840 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10841 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10842 ivd.vd_next = BYTE_GET (evd.vd_next);
10843 }
bb4d2ac2 10844
ab273396
AM		 10845 off += ivd.vd_next;
10846 }
10847 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10848
ab273396
AM		 10849 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10850 {
10851 off -= ivd.vd_next;
10852 off += ivd.vd_aux;
bb4d2ac2 10853
ab273396
AM		 10854 if (get_data (&evda, file, off, sizeof (evda), 1,
10855 _("version def aux")) != NULL)
10856 {
10857 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10858
ab273396
AM		 10859 if (psym->st_name != ivda.vda_name)
10860 {
10861 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10862 ? symbol_hidden : symbol_public);
10863 return (ivda.vda_name < strtab_size
10864 ? strtab + ivda.vda_name : _("<corrupt>"));
10865 }
10866 }
10867 }
10868 }
bb4d2ac2 10869
ab273396
AM		 10870 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10871 {
10872 Elf_External_Verneed evn;
10873 Elf_Internal_Verneed ivn;
10874 Elf_Internal_Vernaux ivna;
bb4d2ac2 10875
ab273396
AM		 10876 offset = offset_from_vma (file,
10877 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10878 sizeof evn);
10879 do
10880 {
10881 unsigned long vna_off;
bb4d2ac2 10882
ab273396
AM		 10883 if (get_data (&evn, file, offset, sizeof (evn), 1,
10884 _("version need")) == NULL)
10885 {
10886 ivna.vna_next = 0;
10887 ivna.vna_other = 0;
10888 ivna.vna_name = 0;
10889 break;
10890 }
bb4d2ac2 10891
ab273396
AM		 10892 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10893 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 10894
ab273396 10895 vna_off = offset + ivn.vn_aux;
bb4d2ac2 10896
ab273396
AM		 10897 do
10898 {
10899 Elf_External_Vernaux evna;
bb4d2ac2 10900
ab273396
AM		 10901 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10902 _("version need aux (3)")) == NULL)
bb4d2ac2 10903 {
ab273396
AM		 10904 ivna.vna_next = 0;
10905 ivna.vna_other = 0;
10906 ivna.vna_name = 0;
bb4d2ac2 10907 }
bb4d2ac2 10908 else
bb4d2ac2 10909 {
ab273396
AM		 10910 ivna.vna_other = BYTE_GET (evna.vna_other);
10911 ivna.vna_next = BYTE_GET (evna.vna_next);
10912 ivna.vna_name = BYTE_GET (evna.vna_name);
10913 }
bb4d2ac2 10914
ab273396
AM		 10915 vna_off += ivna.vna_next;
10916 }
10917 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 10918
ab273396
AM		 10919 if (ivna.vna_other == vers_data)
10920 break;
bb4d2ac2 10921
ab273396
AM		 10922 offset += ivn.vn_next;
10923 }
10924 while (ivn.vn_next != 0);
bb4d2ac2 10925
ab273396
AM		 10926 if (ivna.vna_other == vers_data)
10927 {
10928 *sym_info = symbol_undefined;
10929 *vna_other = ivna.vna_other;
10930 return (ivna.vna_name < strtab_size
10931 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 10932 }
10933 }
ab273396 10934 return NULL;
bb4d2ac2
L		 10935}
10936
e3c8793a 10937/* Dump the symbol table. */
252b5132 10938static int
2cf0635d 10939process_symbol_table (FILE * file)
252b5132 10940{
2cf0635d 10941 Elf_Internal_Shdr * section;
8b73c356
NC		 10942 bfd_size_type nbuckets = 0;
10943 bfd_size_type nchains = 0;
2cf0635d
NC		 10944 bfd_vma * buckets = NULL;
10945 bfd_vma * chains = NULL;
fdc90cb4 10946 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10947 bfd_vma * gnubuckets = NULL;
10948 bfd_vma * gnuchains = NULL;
6bd1a22c 10949 bfd_vma gnusymidx = 0;
071436c6 10950 bfd_size_type ngnuchains = 0;
252b5132 10951
2c610e4b 10952 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10953 return 1;
10954
6bd1a22c
L		 10955 if (dynamic_info[DT_HASH]
10956 && (do_histogram
2c610e4b
L		 10957 || (do_using_dynamic
10958 && !do_dyn_syms
10959 && dynamic_strings != NULL)))
252b5132 10960 {
66543521
AM		 10961 unsigned char nb[8];
10962 unsigned char nc[8];
8b73c356 10963 unsigned int hash_ent_size = 4;
66543521
AM		 10964
10965 if ((elf_header.e_machine == EM_ALPHA
10966 || elf_header.e_machine == EM_S390
10967 || elf_header.e_machine == EM_S390_OLD)
10968 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10969 hash_ent_size = 8;
10970
fb52b2f4
NC		 10971 if (fseek (file,
10972 (archive_file_offset
10973 + offset_from_vma (file, dynamic_info[DT_HASH],
10974 sizeof nb + sizeof nc)),
d93f0186 10975 SEEK_SET))
252b5132 10976 {
591a748a 10977 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10978 goto no_hash;
252b5132
RH		 10979 }
10980
66543521 10981 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10982 {
10983 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10984 goto no_hash;
252b5132
RH		 10985 }
10986
66543521 10987 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10988 {
10989 error (_("Failed to read in number of chains\n"));
d3a44ec6 10990 goto no_hash;
252b5132
RH		 10991 }
10992
66543521
AM		 10993 nbuckets = byte_get (nb, hash_ent_size);
10994 nchains = byte_get (nc, hash_ent_size);
252b5132 10995
66543521
AM		 10996 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10997 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10998
d3a44ec6 10999 no_hash:
252b5132 11000 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 11001 {
11002 if (do_using_dynamic)
11003 return 0;
11004 free (buckets);
11005 free (chains);
11006 buckets = NULL;
11007 chains = NULL;
11008 nbuckets = 0;
11009 nchains = 0;
11010 }
252b5132
RH		 11011 }
11012
6bd1a22c
L		 11013 if (dynamic_info_DT_GNU_HASH
11014 && (do_histogram
2c610e4b
L		 11015 || (do_using_dynamic
11016 && !do_dyn_syms
11017 && dynamic_strings != NULL)))
252b5132 11018 {
6bd1a22c
L		 11019 unsigned char nb[16];
11020 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11021 bfd_vma buckets_vma;
11022
11023 if (fseek (file,
11024 (archive_file_offset
11025 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11026 sizeof nb)),
11027 SEEK_SET))
11028 {
11029 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11030 goto no_gnu_hash;
6bd1a22c 11031 }
252b5132 11032
6bd1a22c
L		 11033 if (fread (nb, 16, 1, file) != 1)
11034 {
11035 error (_("Failed to read in number of buckets\n"));
d3a44ec6 11036 goto no_gnu_hash;
6bd1a22c
L		 11037 }
11038
11039 ngnubuckets = byte_get (nb, 4);
11040 gnusymidx = byte_get (nb + 4, 4);
11041 bitmaskwords = byte_get (nb + 8, 4);
11042 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 11043 if (is_32bit_elf)
6bd1a22c 11044 buckets_vma += bitmaskwords * 4;
f7a99963 11045 else
6bd1a22c 11046 buckets_vma += bitmaskwords * 8;
252b5132 11047
6bd1a22c
L		 11048 if (fseek (file,
11049 (archive_file_offset
11050 + offset_from_vma (file, buckets_vma, 4)),
11051 SEEK_SET))
252b5132 11052 {
6bd1a22c 11053 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11054 goto no_gnu_hash;
6bd1a22c
L		 11055 }
11056
11057 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 11058
6bd1a22c 11059 if (gnubuckets == NULL)
d3a44ec6 11060 goto no_gnu_hash;
6bd1a22c
L		 11061
11062 for (i = 0; i < ngnubuckets; i++)
11063 if (gnubuckets[i] != 0)
11064 {
11065 if (gnubuckets[i] < gnusymidx)
11066 return 0;
11067
11068 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11069 maxchain = gnubuckets[i];
11070 }
11071
11072 if (maxchain == 0xffffffff)
d3a44ec6 11073 goto no_gnu_hash;
6bd1a22c
L		 11074
11075 maxchain -= gnusymidx;
11076
11077 if (fseek (file,
11078 (archive_file_offset
11079 + offset_from_vma (file, buckets_vma
11080 + 4 * (ngnubuckets + maxchain), 4)),
11081 SEEK_SET))
11082 {
11083 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11084 goto no_gnu_hash;
6bd1a22c
L		 11085 }
11086
11087 do
11088 {
11089 if (fread (nb, 4, 1, file) != 1)
252b5132 11090 {
6bd1a22c 11091 error (_("Failed to determine last chain length\n"));
d3a44ec6 11092 goto no_gnu_hash;
6bd1a22c 11093 }
252b5132 11094
6bd1a22c 11095 if (maxchain + 1 == 0)
d3a44ec6 11096 goto no_gnu_hash;
252b5132 11097
6bd1a22c
L		 11098 ++maxchain;
11099 }
11100 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 11101
6bd1a22c
L		 11102 if (fseek (file,
11103 (archive_file_offset
11104 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11105 SEEK_SET))
11106 {
11107 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11108 goto no_gnu_hash;
6bd1a22c
L		 11109 }
11110
11111 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 11112 ngnuchains = maxchain;
6bd1a22c 11113
d3a44ec6 11114 no_gnu_hash:
6bd1a22c 11115 if (gnuchains == NULL)
d3a44ec6
JJ		 11116 {
11117 free (gnubuckets);
d3a44ec6
JJ		 11118 gnubuckets = NULL;
11119 ngnubuckets = 0;
f64fddf1
NC		 11120 if (do_using_dynamic)
11121 return 0;
d3a44ec6 11122 }
6bd1a22c
L		 11123 }
11124
11125 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11126 && do_syms
11127 && do_using_dynamic
3102e897
NC		 11128 && dynamic_strings != NULL
11129 && dynamic_symbols != NULL)
6bd1a22c
L		 11130 {
11131 unsigned long hn;
11132
11133 if (dynamic_info[DT_HASH])
11134 {
11135 bfd_vma si;
11136
11137 printf (_("\nSymbol table for image:\n"));
11138 if (is_32bit_elf)
11139 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11140 else
11141 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11142
11143 for (hn = 0; hn < nbuckets; hn++)
11144 {
11145 if (! buckets[hn])
11146 continue;
11147
11148 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11149 print_dynamic_symbol (si, hn);
252b5132
RH		 11150 }
11151 }
6bd1a22c
L		 11152
11153 if (dynamic_info_DT_GNU_HASH)
11154 {
11155 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11156 if (is_32bit_elf)
11157 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11158 else
11159 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11160
11161 for (hn = 0; hn < ngnubuckets; ++hn)
11162 if (gnubuckets[hn] != 0)
11163 {
11164 bfd_vma si = gnubuckets[hn];
11165 bfd_vma off = si - gnusymidx;
11166
11167 do
11168 {
11169 print_dynamic_symbol (si, hn);
11170 si++;
11171 }
071436c6 11172 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 11173 }
11174 }
252b5132 11175 }
8b73c356
NC		 11176 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11177 && section_headers != NULL)
252b5132 11178 {
b34976b6 11179 unsigned int i;
252b5132
RH		 11180
11181 for (i = 0, section = section_headers;
11182 i < elf_header.e_shnum;
11183 i++, section++)
11184 {
b34976b6 11185 unsigned int si;
2cf0635d 11186 char * strtab = NULL;
c256ffe7 11187 unsigned long int strtab_size = 0;
2cf0635d
NC		 11188 Elf_Internal_Sym * symtab;
11189 Elf_Internal_Sym * psym;
ba5cdace 11190 unsigned long num_syms;
252b5132 11191
2c610e4b
L		 11192 if ((section->sh_type != SHT_SYMTAB
11193 && section->sh_type != SHT_DYNSYM)
11194 || (!do_syms
11195 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 11196 continue;
11197
dd24e3da
NC		 11198 if (section->sh_entsize == 0)
11199 {
11200 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 11201 printable_section_name (section));
dd24e3da
NC		 11202 continue;
11203 }
11204
252b5132 11205 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 11206 printable_section_name (section),
252b5132 11207 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 11208
f7a99963 11209 if (is_32bit_elf)
ca47b30c 11210 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 11211 else
ca47b30c 11212 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 11213
ba5cdace 11214 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 11215 if (symtab == NULL)
11216 continue;
11217
11218 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 11219 {
11220 strtab = string_table;
11221 strtab_size = string_table_length;
11222 }
4fbb74a6 11223 else if (section->sh_link < elf_header.e_shnum)
252b5132 11224 {
2cf0635d 11225 Elf_Internal_Shdr * string_sec;
252b5132 11226
4fbb74a6 11227 string_sec = section_headers + section->sh_link;
252b5132 11228
3f5e193b
NC		 11229 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11230 1, string_sec->sh_size,
11231 _("string table"));
c256ffe7 11232 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 11233 }
11234
ba5cdace 11235 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 11236 {
bb4d2ac2
L		 11237 const char *version_string;
11238 enum versioned_symbol_info sym_info;
11239 unsigned short vna_other;
11240
5e220199 11241 printf ("%6d: ", si);
f7a99963
NC		 11242 print_vma (psym->st_value, LONG_HEX);
11243 putchar (' ');
11244 print_vma (psym->st_size, DEC_5);
d1133906
NC		 11245 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11246 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 11247 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11248 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11249 else
11250 {
11251 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11252
11253 printf (" %-7s", get_symbol_visibility (vis));
11254 /* Check to see if any other bits in the st_other field are set.
11255 Note - displaying this information disrupts the layout of the
11256 table being generated, but for the moment this case is very rare. */
11257 if (psym->st_other ^ vis)
11258 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11259 }
31104126 11260 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 11261 print_symbol (25, psym->st_name < strtab_size
2b692964 11262 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 11263
bb4d2ac2
L		 11264 version_string
11265 = get_symbol_version_string (file,
11266 section->sh_type == SHT_DYNSYM,
11267 strtab, strtab_size, si,
11268 psym, &sym_info, &vna_other);
11269 if (version_string)
252b5132 11270 {
bb4d2ac2
L		 11271 if (sym_info == symbol_undefined)
11272 printf ("@%s (%d)", version_string, vna_other);
11273 else
11274 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11275 version_string);
252b5132
RH		 11276 }
11277
11278 putchar ('\n');
52c3c391
NC		 11279
11280 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
dd905818
NC		 11281 && si >= section->sh_info
11282 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11283 && elf_header.e_machine != EM_MIPS
11284 /* Solaris binaries have been found to violate this requirement as
11285 well. Not sure if this is a bug or an ABI requirement. */
11286 && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
52c3c391
NC		 11287 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11288 si, printable_section_name (section), section->sh_info);
252b5132
RH		 11289 }
11290
11291 free (symtab);
11292 if (strtab != string_table)
11293 free (strtab);
11294 }
11295 }
11296 else if (do_syms)
11297 printf
11298 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11299
11300 if (do_histogram && buckets != NULL)
11301 {
2cf0635d
NC		 11302 unsigned long * lengths;
11303 unsigned long * counts;
66543521
AM		 11304 unsigned long hn;
11305 bfd_vma si;
11306 unsigned long maxlength = 0;
11307 unsigned long nzero_counts = 0;
11308 unsigned long nsyms = 0;
94d15024 11309 unsigned long chained;
252b5132 11310
66543521
AM		 11311 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11312 (unsigned long) nbuckets);
252b5132 11313
3f5e193b 11314 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 11315 if (lengths == NULL)
11316 {
8b73c356 11317 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 11318 return 0;
11319 }
8b73c356
NC		 11320
11321 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 11322 for (hn = 0; hn < nbuckets; ++hn)
11323 {
94d15024
MF		 11324 for (si = buckets[hn], chained = 0;
11325 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11326 si = chains[si], ++chained)
252b5132 11327 {
b34976b6 11328 ++nsyms;
252b5132 11329 if (maxlength < ++lengths[hn])
b34976b6 11330 ++maxlength;
252b5132 11331 }
94d15024
MF		 11332
11333 /* PR binutils/17531: A corrupt binary could contain broken
11334 histogram data. Do not go into an infinite loop trying
11335 to process it. */
11336 if (chained > nchains)
11337 {
11338 error (_("histogram chain is corrupt\n"));
11339 break;
11340 }
252b5132
RH		 11341 }
11342
3f5e193b 11343 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11344 if (counts == NULL)
11345 {
b2e951ec 11346 free (lengths);
8b73c356 11347 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 11348 return 0;
11349 }
11350
11351 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11352 ++counts[lengths[hn]];
252b5132 11353
103f02d3 11354 if (nbuckets > 0)
252b5132 11355 {
66543521
AM		 11356 unsigned long i;
11357 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11358 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11359 for (i = 1; i <= maxlength; ++i)
103f02d3 11360 {
66543521
AM		 11361 nzero_counts += counts[i] * i;
11362 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11363 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11364 (nzero_counts * 100.0) / nsyms);
11365 }
252b5132
RH		 11366 }
11367
11368 free (counts);
11369 free (lengths);
11370 }
11371
11372 if (buckets != NULL)
11373 {
11374 free (buckets);
11375 free (chains);
11376 }
11377
d3a44ec6 11378 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11379 {
2cf0635d
NC		 11380 unsigned long * lengths;
11381 unsigned long * counts;
fdc90cb4
JJ		 11382 unsigned long hn;
11383 unsigned long maxlength = 0;
11384 unsigned long nzero_counts = 0;
11385 unsigned long nsyms = 0;
fdc90cb4 11386
8b73c356
NC		 11387 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11388 (unsigned long) ngnubuckets);
11389
3f5e193b 11390 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11391 if (lengths == NULL)
11392 {
8b73c356 11393 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11394 return 0;
11395 }
11396
fdc90cb4
JJ		 11397 printf (_(" Length Number %% of total Coverage\n"));
11398
11399 for (hn = 0; hn < ngnubuckets; ++hn)
11400 if (gnubuckets[hn] != 0)
11401 {
11402 bfd_vma off, length = 1;
11403
6bd1a22c 11404 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11405 /* PR 17531 file: 010-77222-0.004. */
11406 off < ngnuchains && (gnuchains[off] & 1) == 0;
11407 ++off)
fdc90cb4
JJ		 11408 ++length;
11409 lengths[hn] = length;
11410 if (length > maxlength)
11411 maxlength = length;
11412 nsyms += length;
11413 }
11414
3f5e193b 11415 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11416 if (counts == NULL)
11417 {
b2e951ec 11418 free (lengths);
8b73c356 11419 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11420 return 0;
11421 }
11422
11423 for (hn = 0; hn < ngnubuckets; ++hn)
11424 ++counts[lengths[hn]];
11425
11426 if (ngnubuckets > 0)
11427 {
11428 unsigned long j;
11429 printf (" 0 %-10lu (%5.1f%%)\n",
11430 counts[0], (counts[0] * 100.0) / ngnubuckets);
11431 for (j = 1; j <= maxlength; ++j)
11432 {
11433 nzero_counts += counts[j] * j;
11434 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11435 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11436 (nzero_counts * 100.0) / nsyms);
11437 }
11438 }
11439
11440 free (counts);
11441 free (lengths);
11442 free (gnubuckets);
11443 free (gnuchains);
11444 }
11445
252b5132
RH		 11446 return 1;
11447}
11448
11449static int
2cf0635d 11450process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11451{
b4c96d0d 11452 unsigned int i;
252b5132
RH		 11453
11454 if (dynamic_syminfo == NULL
11455 || !do_dynamic)
11456 /* No syminfo, this is ok. */
11457 return 1;
11458
11459 /* There better should be a dynamic symbol section. */
11460 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11461 return 0;
11462
11463 if (dynamic_addr)
11464 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11465 dynamic_syminfo_offset, dynamic_syminfo_nent);
11466
11467 printf (_(" Num: Name BoundTo Flags\n"));
11468 for (i = 0; i < dynamic_syminfo_nent; ++i)
11469 {
11470 unsigned short int flags = dynamic_syminfo[i].si_flags;
11471
31104126 11472 printf ("%4d: ", i);
4082ef84
NC		 11473 if (i >= num_dynamic_syms)
11474 printf (_("<corrupt index>"));
11475 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11476 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11477 else
2b692964 11478 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11479 putchar (' ');
252b5132
RH		 11480
11481 switch (dynamic_syminfo[i].si_boundto)
11482 {
11483 case SYMINFO_BT_SELF:
11484 fputs ("SELF ", stdout);
11485 break;
11486 case SYMINFO_BT_PARENT:
11487 fputs ("PARENT ", stdout);
11488 break;
11489 default:
11490 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11491 && dynamic_syminfo[i].si_boundto < dynamic_nent
11492 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11493 {
d79b3d50 11494 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11495 putchar (' ' );
11496 }
252b5132
RH		 11497 else
11498 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11499 break;
11500 }
11501
11502 if (flags & SYMINFO_FLG_DIRECT)
11503 printf (" DIRECT");
11504 if (flags & SYMINFO_FLG_PASSTHRU)
11505 printf (" PASSTHRU");
11506 if (flags & SYMINFO_FLG_COPY)
11507 printf (" COPY");
11508 if (flags & SYMINFO_FLG_LAZYLOAD)
11509 printf (" LAZYLOAD");
11510
11511 puts ("");
11512 }
11513
11514 return 1;
11515}
11516
cf13d699
NC		 11517/* Check to see if the given reloc needs to be handled in a target specific
11518 manner. If so then process the reloc and return TRUE otherwise return
11519 FALSE. */
09c11c86 11520
cf13d699
NC		 11521static bfd_boolean
11522target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11523 unsigned char * start,
11524 Elf_Internal_Sym * symtab)
252b5132 11525{
cf13d699 11526 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11527
cf13d699 11528 switch (elf_header.e_machine)
252b5132 11529 {
13761a11
NC		 11530 case EM_MSP430:
11531 case EM_MSP430_OLD:
11532 {
11533 static Elf_Internal_Sym * saved_sym = NULL;
11534
11535 switch (reloc_type)
11536 {
11537 case 10: /* R_MSP430_SYM_DIFF */
11538 if (uses_msp430x_relocs ())
11539 break;
1a0670f3 11540 /* Fall through. */
13761a11
NC		 11541 case 21: /* R_MSP430X_SYM_DIFF */
11542 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11543 return TRUE;
11544
11545 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11546 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11547 goto handle_sym_diff;
0b4362b0 11548
13761a11
NC		 11549 case 5: /* R_MSP430_16_BYTE */
11550 case 9: /* R_MSP430_8 */
11551 if (uses_msp430x_relocs ())
11552 break;
11553 goto handle_sym_diff;
11554
11555 case 2: /* R_MSP430_ABS16 */
11556 case 15: /* R_MSP430X_ABS16 */
11557 if (! uses_msp430x_relocs ())
11558 break;
11559 goto handle_sym_diff;
0b4362b0 11560
13761a11
NC		 11561 handle_sym_diff:
11562 if (saved_sym != NULL)
11563 {
11564 bfd_vma value;
11565
11566 value = reloc->r_addend
11567 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11568 - saved_sym->st_value);
11569
11570 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11571
11572 saved_sym = NULL;
11573 return TRUE;
11574 }
11575 break;
11576
11577 default:
11578 if (saved_sym != NULL)
071436c6 11579 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11580 break;
11581 }
11582 break;
11583 }
11584
cf13d699
NC		 11585 case EM_MN10300:
11586 case EM_CYGNUS_MN10300:
11587 {
11588 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11589
cf13d699
NC		 11590 switch (reloc_type)
11591 {
11592 case 34: /* R_MN10300_ALIGN */
11593 return TRUE;
11594 case 33: /* R_MN10300_SYM_DIFF */
11595 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11596 return TRUE;
11597 case 1: /* R_MN10300_32 */
11598 case 2: /* R_MN10300_16 */
11599 if (saved_sym != NULL)
11600 {
11601 bfd_vma value;
252b5132 11602
cf13d699
NC		 11603 value = reloc->r_addend
11604 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11605 - saved_sym->st_value);
252b5132 11606
cf13d699 11607 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11608
cf13d699
NC		 11609 saved_sym = NULL;
11610 return TRUE;
11611 }
11612 break;
11613 default:
11614 if (saved_sym != NULL)
071436c6 11615 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11616 break;
11617 }
11618 break;
11619 }
6ff71e76
NC		 11620
11621 case EM_RL78:
11622 {
11623 static bfd_vma saved_sym1 = 0;
11624 static bfd_vma saved_sym2 = 0;
11625 static bfd_vma value;
11626
11627 switch (reloc_type)
11628 {
11629 case 0x80: /* R_RL78_SYM. */
11630 saved_sym1 = saved_sym2;
11631 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11632 saved_sym2 += reloc->r_addend;
11633 return TRUE;
11634
11635 case 0x83: /* R_RL78_OPsub. */
11636 value = saved_sym1 - saved_sym2;
11637 saved_sym2 = saved_sym1 = 0;
11638 return TRUE;
11639 break;
11640
11641 case 0x41: /* R_RL78_ABS32. */
11642 byte_put (start + reloc->r_offset, value, 4);
11643 value = 0;
11644 return TRUE;
11645
11646 case 0x43: /* R_RL78_ABS16. */
11647 byte_put (start + reloc->r_offset, value, 2);
11648 value = 0;
11649 return TRUE;
11650
11651 default:
11652 break;
11653 }
11654 break;
11655 }
252b5132
RH		 11656 }
11657
cf13d699 11658 return FALSE;
252b5132
RH		 11659}
11660
aca88567
NC		 11661/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11662 DWARF debug sections. This is a target specific test. Note - we do not
11663 go through the whole including-target-headers-multiple-times route, (as
11664 we have already done with <elf/h8.h>) because this would become very
11665 messy and even then this function would have to contain target specific
11666 information (the names of the relocs instead of their numeric values).
11667 FIXME: This is not the correct way to solve this problem. The proper way
11668 is to have target specific reloc sizing and typing functions created by
11669 the reloc-macros.h header, in the same way that it already creates the
11670 reloc naming functions. */
11671
11672static bfd_boolean
11673is_32bit_abs_reloc (unsigned int reloc_type)
11674{
d347c9df 11675 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567
NC		 11676 switch (elf_header.e_machine)
11677 {
41e92641 11678 case EM_386:
22abe556 11679 case EM_IAMCU:
41e92641 11680 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11681 case EM_68K:
11682 return reloc_type == 1; /* R_68K_32. */
11683 case EM_860:
11684 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11685 case EM_960:
11686 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11687 case EM_AARCH64:
11688 return reloc_type == 258; /* R_AARCH64_ABS32 */
d347c9df
PS		 11689 case EM_ADAPTEVA_EPIPHANY:
11690 return reloc_type == 3;
aca88567 11691 case EM_ALPHA:
137b6b5f 11692 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11693 case EM_ARC:
11694 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11695 case EM_ARC_COMPACT:
11696 case EM_ARC_COMPACT2:
11697 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11698 case EM_ARM:
11699 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11700 case EM_AVR_OLD:
aca88567
NC		 11701 case EM_AVR:
11702 return reloc_type == 1;
11703 case EM_BLACKFIN:
11704 return reloc_type == 0x12; /* R_byte4_data. */
11705 case EM_CRIS:
11706 return reloc_type == 3; /* R_CRIS_32. */
11707 case EM_CR16:
11708 return reloc_type == 3; /* R_CR16_NUM32. */
11709 case EM_CRX:
11710 return reloc_type == 15; /* R_CRX_NUM32. */
11711 case EM_CYGNUS_FRV:
11712 return reloc_type == 1;
41e92641
NC		 11713 case EM_CYGNUS_D10V:
11714 case EM_D10V:
11715 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11716 case EM_CYGNUS_D30V:
11717 case EM_D30V:
11718 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11719 case EM_DLX:
11720 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11721 case EM_CYGNUS_FR30:
11722 case EM_FR30:
11723 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11724 case EM_FT32:
11725 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11726 case EM_H8S:
11727 case EM_H8_300:
11728 case EM_H8_300H:
11729 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11730 case EM_IA_64:
d1c4b12b
NC		 11731 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11732 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11733 case EM_IP2K_OLD:
11734 case EM_IP2K:
11735 return reloc_type == 2; /* R_IP2K_32. */
11736 case EM_IQ2000:
11737 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11738 case EM_LATTICEMICO32:
11739 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11740 case EM_M32C_OLD:
aca88567
NC		 11741 case EM_M32C:
11742 return reloc_type == 3; /* R_M32C_32. */
11743 case EM_M32R:
11744 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 11745 case EM_68HC11:
11746 case EM_68HC12:
11747 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 11748 case EM_MCORE:
11749 return reloc_type == 1; /* R_MCORE_ADDR32. */
11750 case EM_CYGNUS_MEP:
11751 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11752 case EM_METAG:
11753 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11754 case EM_MICROBLAZE:
11755 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11756 case EM_MIPS:
11757 return reloc_type == 2; /* R_MIPS_32. */
11758 case EM_MMIX:
11759 return reloc_type == 4; /* R_MMIX_32. */
11760 case EM_CYGNUS_MN10200:
11761 case EM_MN10200:
11762 return reloc_type == 1; /* R_MN10200_32. */
11763 case EM_CYGNUS_MN10300:
11764 case EM_MN10300:
11765 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11766 case EM_MOXIE:
11767 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11768 case EM_MSP430_OLD:
11769 case EM_MSP430:
13761a11 11770 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11771 case EM_MT:
11772 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11773 case EM_NDS32:
11774 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11775 case EM_ALTERA_NIOS2:
36591ba1 11776 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11777 case EM_NIOS32:
11778 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11779 case EM_OR1K:
11780 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11781 case EM_PARISC:
5fda8eca
NC		 11782 return (reloc_type == 1 /* R_PARISC_DIR32. */
11783 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11784 case EM_PJ:
11785 case EM_PJ_OLD:
11786 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11787 case EM_PPC64:
11788 return reloc_type == 1; /* R_PPC64_ADDR32. */
11789 case EM_PPC:
11790 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11791 case EM_RL78:
11792 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11793 case EM_RX:
11794 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11795 case EM_S370:
11796 return reloc_type == 1; /* R_I370_ADDR31. */
11797 case EM_S390_OLD:
11798 case EM_S390:
11799 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11800 case EM_SCORE:
11801 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11802 case EM_SH:
11803 return reloc_type == 1; /* R_SH_DIR32. */
11804 case EM_SPARC32PLUS:
11805 case EM_SPARCV9:
11806 case EM_SPARC:
11807 return reloc_type == 3 /* R_SPARC_32. */
11808 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11809 case EM_SPU:
11810 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11811 case EM_TI_C6000:
11812 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11813 case EM_TILEGX:
11814 return reloc_type == 2; /* R_TILEGX_32. */
11815 case EM_TILEPRO:
11816 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11817 case EM_CYGNUS_V850:
11818 case EM_V850:
11819 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11820 case EM_V800:
11821 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11822 case EM_VAX:
11823 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11824 case EM_VISIUM:
11825 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11826 case EM_X86_64:
8a9036a4 11827 case EM_L1OM:
7a9068fe 11828 case EM_K1OM:
aca88567 11829 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11830 case EM_XC16X:
11831 case EM_C166:
11832 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11833 case EM_XGATE:
11834 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11835 case EM_XSTORMY16:
11836 return reloc_type == 1; /* R_XSTROMY16_32. */
11837 case EM_XTENSA_OLD:
11838 case EM_XTENSA:
11839 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11840 default:
bee0ee85
NC		 11841 {
11842 static unsigned int prev_warn = 0;
11843
11844 /* Avoid repeating the same warning multiple times. */
11845 if (prev_warn != elf_header.e_machine)
11846 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11847 elf_header.e_machine);
11848 prev_warn = elf_header.e_machine;
11849 return FALSE;
11850 }
aca88567
NC		 11851 }
11852}
11853
11854/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11855 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11856
11857static bfd_boolean
11858is_32bit_pcrel_reloc (unsigned int reloc_type)
11859{
11860 switch (elf_header.e_machine)
d347c9df 11861 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567 11862 {
41e92641 11863 case EM_386:
22abe556 11864 case EM_IAMCU:
3e0873ac 11865 return reloc_type == 2; /* R_386_PC32. */
aca88567 11866 case EM_68K:
3e0873ac 11867 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11868 case EM_AARCH64:
11869 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11870 case EM_ADAPTEVA_EPIPHANY:
11871 return reloc_type == 6;
aca88567
NC		 11872 case EM_ALPHA:
11873 return reloc_type == 10; /* R_ALPHA_SREL32. */
726c18e1
CZ		 11874 case EM_ARC_COMPACT:
11875 case EM_ARC_COMPACT2:
11876 return reloc_type == 49; /* R_ARC_32_PCREL. */
41e92641 11877 case EM_ARM:
3e0873ac 11878 return reloc_type == 3; /* R_ARM_REL32 */
d347c9df
PS		 11879 case EM_AVR_OLD:
11880 case EM_AVR:
11881 return reloc_type == 36; /* R_AVR_32_PCREL. */
137b6b5f
AM		 11882 case EM_MICROBLAZE:
11883 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11884 case EM_OR1K:
11885 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11886 case EM_PARISC:
85acf597 11887 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11888 case EM_PPC:
11889 return reloc_type == 26; /* R_PPC_REL32. */
11890 case EM_PPC64:
3e0873ac 11891 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11892 case EM_S390_OLD:
11893 case EM_S390:
3e0873ac 11894 return reloc_type == 5; /* R_390_PC32. */
aca88567 11895 case EM_SH:
3e0873ac 11896 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11897 case EM_SPARC32PLUS:
11898 case EM_SPARCV9:
11899 case EM_SPARC:
3e0873ac 11900 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11901 case EM_SPU:
11902 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11903 case EM_TILEGX:
11904 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11905 case EM_TILEPRO:
11906 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11907 case EM_VISIUM:
11908 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11909 case EM_X86_64:
8a9036a4 11910 case EM_L1OM:
7a9068fe 11911 case EM_K1OM:
3e0873ac 11912 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11913 case EM_XTENSA_OLD:
11914 case EM_XTENSA:
11915 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11916 default:
11917 /* Do not abort or issue an error message here. Not all targets use
11918 pc-relative 32-bit relocs in their DWARF debug information and we
11919 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11920 more helpful warning message will be generated by apply_relocations
11921 anyway, so just return. */
aca88567
NC		 11922 return FALSE;
11923 }
11924}
11925
11926/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11927 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11928
11929static bfd_boolean
11930is_64bit_abs_reloc (unsigned int reloc_type)
11931{
11932 switch (elf_header.e_machine)
11933 {
a06ea964
NC		 11934 case EM_AARCH64:
11935 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11936 case EM_ALPHA:
11937 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11938 case EM_IA_64:
11939 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11940 case EM_PARISC:
11941 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11942 case EM_PPC64:
11943 return reloc_type == 38; /* R_PPC64_ADDR64. */
11944 case EM_SPARC32PLUS:
11945 case EM_SPARCV9:
11946 case EM_SPARC:
11947 return reloc_type == 54; /* R_SPARC_UA64. */
11948 case EM_X86_64:
8a9036a4 11949 case EM_L1OM:
7a9068fe 11950 case EM_K1OM:
aca88567 11951 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11952 case EM_S390_OLD:
11953 case EM_S390:
aa137e4d
NC		 11954 return reloc_type == 22; /* R_S390_64. */
11955 case EM_TILEGX:
11956 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11957 case EM_MIPS:
aa137e4d 11958 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11959 default:
11960 return FALSE;
11961 }
11962}
11963
85acf597
RH		 11964/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11965 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11966
11967static bfd_boolean
11968is_64bit_pcrel_reloc (unsigned int reloc_type)
11969{
11970 switch (elf_header.e_machine)
11971 {
a06ea964
NC		 11972 case EM_AARCH64:
11973 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11974 case EM_ALPHA:
aa137e4d 11975 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11976 case EM_IA_64:
aa137e4d 11977 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11978 case EM_PARISC:
aa137e4d 11979 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11980 case EM_PPC64:
aa137e4d 11981 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11982 case EM_SPARC32PLUS:
11983 case EM_SPARCV9:
11984 case EM_SPARC:
aa137e4d 11985 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11986 case EM_X86_64:
8a9036a4 11987 case EM_L1OM:
7a9068fe 11988 case EM_K1OM:
aa137e4d 11989 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11990 case EM_S390_OLD:
11991 case EM_S390:
aa137e4d
NC		 11992 return reloc_type == 23; /* R_S390_PC64. */
11993 case EM_TILEGX:
11994 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11995 default:
11996 return FALSE;
11997 }
11998}
11999
4dc3c23d
AM		 12000/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12001 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12002
12003static bfd_boolean
12004is_24bit_abs_reloc (unsigned int reloc_type)
12005{
12006 switch (elf_header.e_machine)
12007 {
12008 case EM_CYGNUS_MN10200:
12009 case EM_MN10200:
12010 return reloc_type == 4; /* R_MN10200_24. */
3ee6e4fb
NC		 12011 case EM_FT32:
12012 return reloc_type == 5; /* R_FT32_20. */
4dc3c23d
AM		 12013 default:
12014 return FALSE;
12015 }
12016}
12017
aca88567
NC		 12018/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12019 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12020
12021static bfd_boolean
12022is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a 12023{
d347c9df 12024 /* Please keep this table alpha-sorted for ease of visual lookup. */
4b78141a
NC		 12025 switch (elf_header.e_machine)
12026 {
886a2506
NC		 12027 case EM_ARC:
12028 case EM_ARC_COMPACT:
12029 case EM_ARC_COMPACT2:
12030 return reloc_type == 2; /* R_ARC_16. */
d347c9df
PS		 12031 case EM_ADAPTEVA_EPIPHANY:
12032 return reloc_type == 5;
aca88567
NC		 12033 case EM_AVR_OLD:
12034 case EM_AVR:
12035 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 12036 case EM_CYGNUS_D10V:
12037 case EM_D10V:
12038 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 12039 case EM_H8S:
12040 case EM_H8_300:
12041 case EM_H8_300H:
aca88567
NC		 12042 return reloc_type == R_H8_DIR16;
12043 case EM_IP2K_OLD:
12044 case EM_IP2K:
12045 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 12046 case EM_M32C_OLD:
f4236fe4
DD		 12047 case EM_M32C:
12048 return reloc_type == 1; /* R_M32C_16 */
d347c9df
PS		 12049 case EM_CYGNUS_MN10200:
12050 case EM_MN10200:
12051 return reloc_type == 2; /* R_MN10200_16. */
12052 case EM_CYGNUS_MN10300:
12053 case EM_MN10300:
12054 return reloc_type == 2; /* R_MN10300_16. */
aca88567 12055 case EM_MSP430:
13761a11
NC		 12056 if (uses_msp430x_relocs ())
12057 return reloc_type == 2; /* R_MSP430_ABS16. */
1a0670f3 12058 /* Fall through. */
78c8d46c 12059 case EM_MSP430_OLD:
aca88567 12060 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 12061 case EM_NDS32:
12062 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 12063 case EM_ALTERA_NIOS2:
36591ba1 12064 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 12065 case EM_NIOS32:
12066 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 12067 case EM_OR1K:
12068 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 12069 case EM_TI_C6000:
12070 return reloc_type == 2; /* R_C6000_ABS16. */
d347c9df
PS		 12071 case EM_VISIUM:
12072 return reloc_type == 2; /* R_VISIUM_16. */
c29aca4a
NC		 12073 case EM_XC16X:
12074 case EM_C166:
12075 return reloc_type == 2; /* R_XC16C_ABS_16. */
f6c1a2d5
NC		 12076 case EM_XGATE:
12077 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 12078 default:
aca88567 12079 return FALSE;
4b78141a
NC		 12080 }
12081}
12082
2a7b2e88
JK		 12083/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12084 relocation entries (possibly formerly used for SHT_GROUP sections). */
12085
12086static bfd_boolean
12087is_none_reloc (unsigned int reloc_type)
12088{
12089 switch (elf_header.e_machine)
12090 {
cb8f3167 12091 case EM_386: /* R_386_NONE. */
d347c9df 12092 case EM_68K: /* R_68K_NONE. */
cfb8c092 12093 case EM_ADAPTEVA_EPIPHANY:
d347c9df
PS		 12094 case EM_ALPHA: /* R_ALPHA_NONE. */
12095 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
886a2506 12096 case EM_ARC: /* R_ARC_NONE. */
886a2506 12097 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
d347c9df 12098 case EM_ARC_COMPACT: /* R_ARC_NONE. */
cb8f3167 12099 case EM_ARM: /* R_ARM_NONE. */
d347c9df 12100 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 12101 case EM_CRIS: /* R_CRIS_NONE. */
d347c9df
PS		 12102 case EM_FT32: /* R_FT32_NONE. */
12103 case EM_IA_64: /* R_IA64_NONE. */
7a9068fe 12104 case EM_K1OM: /* R_X86_64_NONE. */
d347c9df
PS		 12105 case EM_L1OM: /* R_X86_64_NONE. */
12106 case EM_M32R: /* R_M32R_NONE. */
12107 case EM_MIPS: /* R_MIPS_NONE. */
cb8f3167 12108 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 12109 case EM_MOXIE: /* R_MOXIE_NONE. */
d347c9df
PS		 12110 case EM_NIOS32: /* R_NIOS_NONE. */
12111 case EM_OR1K: /* R_OR1K_NONE. */
12112 case EM_PARISC: /* R_PARISC_NONE. */
12113 case EM_PPC64: /* R_PPC64_NONE. */
12114 case EM_PPC: /* R_PPC_NONE. */
12115 case EM_S390: /* R_390_NONE. */
12116 case EM_S390_OLD:
12117 case EM_SH: /* R_SH_NONE. */
12118 case EM_SPARC32PLUS:
12119 case EM_SPARC: /* R_SPARC_NONE. */
12120 case EM_SPARCV9:
aa137e4d
NC		 12121 case EM_TILEGX: /* R_TILEGX_NONE. */
12122 case EM_TILEPRO: /* R_TILEPRO_NONE. */
d347c9df
PS		 12123 case EM_TI_C6000:/* R_C6000_NONE. */
12124 case EM_X86_64: /* R_X86_64_NONE. */
c29aca4a 12125 case EM_XC16X:
cb8f3167 12126 return reloc_type == 0;
d347c9df 12127
a06ea964
NC		 12128 case EM_AARCH64:
12129 return reloc_type == 0 || reloc_type == 256;
d347c9df
PS		 12130 case EM_AVR_OLD:
12131 case EM_AVR:
12132 return (reloc_type == 0 /* R_AVR_NONE. */
12133 || reloc_type == 30 /* R_AVR_DIFF8. */
12134 || reloc_type == 31 /* R_AVR_DIFF16. */
12135 || reloc_type == 32 /* R_AVR_DIFF32. */);
12136 case EM_METAG:
12137 return reloc_type == 3; /* R_METAG_NONE. */
35c08157
KLC		 12138 case EM_NDS32:
12139 return (reloc_type == 0 /* R_XTENSA_NONE. */
12140 || reloc_type == 204 /* R_NDS32_DIFF8. */
12141 || reloc_type == 205 /* R_NDS32_DIFF16. */
12142 || reloc_type == 206 /* R_NDS32_DIFF32. */
12143 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 12144 case EM_XTENSA_OLD:
12145 case EM_XTENSA:
4dc3c23d
AM		 12146 return (reloc_type == 0 /* R_XTENSA_NONE. */
12147 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12148 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12149 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 12150 }
12151 return FALSE;
12152}
12153
d1c4b12b
NC		 12154/* Returns TRUE if there is a relocation against
12155 section NAME at OFFSET bytes. */
12156
12157bfd_boolean
12158reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12159{
12160 Elf_Internal_Rela * relocs;
12161 Elf_Internal_Rela * rp;
12162
12163 if (dsec == NULL || dsec->reloc_info == NULL)
12164 return FALSE;
12165
12166 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12167
12168 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12169 if (rp->r_offset == offset)
12170 return TRUE;
12171
12172 return FALSE;
12173}
12174
cf13d699
NC		 12175/* Apply relocations to a section.
12176 Note: So far support has been added only for those relocations
12177 which can be found in debug sections.
d1c4b12b
NC		 12178 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12179 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 12180 FIXME: Add support for more relocations ? */
1b315056 12181
cf13d699 12182static void
d1c4b12b
NC		 12183apply_relocations (void * file,
12184 const Elf_Internal_Shdr * section,
12185 unsigned char * start,
12186 bfd_size_type size,
1449284b 12187 void ** relocs_return,
d1c4b12b 12188 unsigned long * num_relocs_return)
1b315056 12189{
cf13d699 12190 Elf_Internal_Shdr * relsec;
0d2a7a93 12191 unsigned char * end = start + size;
cb8f3167 12192
d1c4b12b
NC		 12193 if (relocs_return != NULL)
12194 {
12195 * (Elf_Internal_Rela **) relocs_return = NULL;
12196 * num_relocs_return = 0;
12197 }
12198
cf13d699
NC		 12199 if (elf_header.e_type != ET_REL)
12200 return;
1b315056 12201
cf13d699 12202 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 12203 for (relsec = section_headers;
12204 relsec < section_headers + elf_header.e_shnum;
12205 ++relsec)
252b5132 12206 {
41e92641
NC		 12207 bfd_boolean is_rela;
12208 unsigned long num_relocs;
2cf0635d
NC		 12209 Elf_Internal_Rela * relocs;
12210 Elf_Internal_Rela * rp;
12211 Elf_Internal_Shdr * symsec;
12212 Elf_Internal_Sym * symtab;
ba5cdace 12213 unsigned long num_syms;
2cf0635d 12214 Elf_Internal_Sym * sym;
252b5132 12215
41e92641 12216 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 12217 || relsec->sh_info >= elf_header.e_shnum
12218 || section_headers + relsec->sh_info != section
c256ffe7 12219 || relsec->sh_size == 0
4fbb74a6 12220 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 12221 continue;
428409d5 12222
41e92641
NC		 12223 is_rela = relsec->sh_type == SHT_RELA;
12224
12225 if (is_rela)
12226 {
3f5e193b
NC		 12227 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12228 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12229 return;
12230 }
12231 else
12232 {
3f5e193b
NC		 12233 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12234 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12235 return;
12236 }
12237
12238 /* SH uses RELA but uses in place value instead of the addend field. */
12239 if (elf_header.e_machine == EM_SH)
12240 is_rela = FALSE;
428409d5 12241
4fbb74a6 12242 symsec = section_headers + relsec->sh_link;
1449284b
NC		 12243 if (symsec->sh_type != SHT_SYMTAB
12244 && symsec->sh_type != SHT_DYNSYM)
12245 return;
ba5cdace 12246 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 12247
41e92641 12248 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 12249 {
41e92641
NC		 12250 bfd_vma addend;
12251 unsigned int reloc_type;
12252 unsigned int reloc_size;
91d6fa6a 12253 unsigned char * rloc;
ba5cdace 12254 unsigned long sym_index;
4b78141a 12255
aca88567 12256 reloc_type = get_reloc_type (rp->r_info);
41e92641 12257
98fb390a 12258 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 12259 continue;
98fb390a
NC		 12260 else if (is_none_reloc (reloc_type))
12261 continue;
12262 else if (is_32bit_abs_reloc (reloc_type)
12263 || is_32bit_pcrel_reloc (reloc_type))
aca88567 12264 reloc_size = 4;
85acf597
RH		 12265 else if (is_64bit_abs_reloc (reloc_type)
12266 || is_64bit_pcrel_reloc (reloc_type))
aca88567 12267 reloc_size = 8;
4dc3c23d
AM		 12268 else if (is_24bit_abs_reloc (reloc_type))
12269 reloc_size = 3;
aca88567
NC		 12270 else if (is_16bit_abs_reloc (reloc_type))
12271 reloc_size = 2;
12272 else
4b78141a 12273 {
bee0ee85
NC		 12274 static unsigned int prev_reloc = 0;
12275 if (reloc_type != prev_reloc)
12276 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12277 reloc_type, printable_section_name (section));
12278 prev_reloc = reloc_type;
4b78141a
NC		 12279 continue;
12280 }
103f02d3 12281
91d6fa6a 12282 rloc = start + rp->r_offset;
c8da6823 12283 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 12284 {
12285 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12286 (unsigned long) rp->r_offset,
74e1a04b 12287 printable_section_name (section));
700dd8b7
L		 12288 continue;
12289 }
103f02d3 12290
ba5cdace
NC		 12291 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12292 if (sym_index >= num_syms)
12293 {
12294 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 12295 sym_index, printable_section_name (section));
ba5cdace
NC		 12296 continue;
12297 }
12298 sym = symtab + sym_index;
41e92641
NC		 12299
12300 /* If the reloc has a symbol associated with it,
55f25fc3
L		 12301 make sure that it is of an appropriate type.
12302
12303 Relocations against symbols without type can happen.
12304 Gcc -feliminate-dwarf2-dups may generate symbols
12305 without type for debug info.
12306
12307 Icc generates relocations against function symbols
12308 instead of local labels.
12309
12310 Relocations against object symbols can happen, eg when
12311 referencing a global array. For an example of this see
12312 the _clz.o binary in libgcc.a. */
aca88567 12313 if (sym != symtab
b8871f35 12314 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
55f25fc3 12315 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 12316 {
41e92641 12317 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 12318 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 12319 (long int)(rp - relocs),
74e1a04b 12320 printable_section_name (relsec));
aca88567 12321 continue;
5b18a4bc 12322 }
252b5132 12323
4dc3c23d
AM		 12324 addend = 0;
12325 if (is_rela)
12326 addend += rp->r_addend;
c47320c3
AM		 12327 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12328 partial_inplace. */
4dc3c23d
AM		 12329 if (!is_rela
12330 || (elf_header.e_machine == EM_XTENSA
12331 && reloc_type == 1)
12332 || ((elf_header.e_machine == EM_PJ
12333 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 12334 && reloc_type == 1)
12335 || ((elf_header.e_machine == EM_D30V
12336 || elf_header.e_machine == EM_CYGNUS_D30V)
12337 && reloc_type == 12))
91d6fa6a 12338 addend += byte_get (rloc, reloc_size);
cb8f3167 12339
85acf597
RH		 12340 if (is_32bit_pcrel_reloc (reloc_type)
12341 || is_64bit_pcrel_reloc (reloc_type))
12342 {
12343 /* On HPPA, all pc-relative relocations are biased by 8. */
12344 if (elf_header.e_machine == EM_PARISC)
12345 addend -= 8;
91d6fa6a 12346 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 12347 reloc_size);
12348 }
41e92641 12349 else
91d6fa6a 12350 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12351 }
252b5132 12352
5b18a4bc 12353 free (symtab);
d1c4b12b
NC		 12354
12355 if (relocs_return)
12356 {
12357 * (Elf_Internal_Rela **) relocs_return = relocs;
12358 * num_relocs_return = num_relocs;
12359 }
12360 else
12361 free (relocs);
12362
5b18a4bc
NC		 12363 break;
12364 }
5b18a4bc 12365}
103f02d3 12366
cf13d699
NC		 12367#ifdef SUPPORT_DISASSEMBLY
12368static int
12369disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12370{
74e1a04b 12371 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12372
74e1a04b 12373 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12374
12375 return 1;
12376}
12377#endif
12378
12379/* Reads in the contents of SECTION from FILE, returning a pointer
12380 to a malloc'ed buffer or NULL if something went wrong. */
12381
12382static char *
12383get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12384{
12385 bfd_size_type num_bytes;
12386
12387 num_bytes = section->sh_size;
12388
12389 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12390 {
12391 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12392 printable_section_name (section));
cf13d699
NC		 12393 return NULL;
12394 }
12395
3f5e193b
NC		 12396 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12397 _("section contents"));
cf13d699
NC		 12398}
12399
0e602686
NC		 12400/* Uncompresses a section that was compressed using zlib, in place. */
12401
12402static bfd_boolean
12403uncompress_section_contents (unsigned char **buffer,
12404 dwarf_size_type uncompressed_size,
12405 dwarf_size_type *size)
12406{
12407 dwarf_size_type compressed_size = *size;
12408 unsigned char * compressed_buffer = *buffer;
12409 unsigned char * uncompressed_buffer;
12410 z_stream strm;
12411 int rc;
12412
12413 /* It is possible the section consists of several compressed
12414 buffers concatenated together, so we uncompress in a loop. */
12415 /* PR 18313: The state field in the z_stream structure is supposed
12416 to be invisible to the user (ie us), but some compilers will
12417 still complain about it being used without initialisation. So
12418 we first zero the entire z_stream structure and then set the fields
12419 that we need. */
12420 memset (& strm, 0, sizeof strm);
12421 strm.avail_in = compressed_size;
12422 strm.next_in = (Bytef *) compressed_buffer;
12423 strm.avail_out = uncompressed_size;
12424 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12425
12426 rc = inflateInit (& strm);
12427 while (strm.avail_in > 0)
12428 {
12429 if (rc != Z_OK)
12430 goto fail;
12431 strm.next_out = ((Bytef *) uncompressed_buffer
12432 + (uncompressed_size - strm.avail_out));
12433 rc = inflate (&strm, Z_FINISH);
12434 if (rc != Z_STREAM_END)
12435 goto fail;
12436 rc = inflateReset (& strm);
12437 }
12438 rc = inflateEnd (& strm);
12439 if (rc != Z_OK
12440 || strm.avail_out != 0)
12441 goto fail;
12442
12443 *buffer = uncompressed_buffer;
12444 *size = uncompressed_size;
12445 return TRUE;
12446
12447 fail:
12448 free (uncompressed_buffer);
12449 /* Indicate decompression failure. */
12450 *buffer = NULL;
12451 return FALSE;
12452}
dd24e3da 12453
cf13d699
NC		 12454static void
12455dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12456{
0e602686
NC		 12457 Elf_Internal_Shdr * relsec;
12458 bfd_size_type num_bytes;
fd8008d8
L		 12459 unsigned char * data;
12460 unsigned char * end;
12461 unsigned char * real_start;
12462 unsigned char * start;
0e602686 12463 bfd_boolean some_strings_shown;
cf13d699 12464
fd8008d8
L		 12465 real_start = start = (unsigned char *) get_section_contents (section,
12466 file);
cf13d699
NC		 12467 if (start == NULL)
12468 return;
0e602686 12469 num_bytes = section->sh_size;
cf13d699 12470
74e1a04b 12471 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12472
0e602686
NC		 12473 if (decompress_dumps)
12474 {
12475 dwarf_size_type new_size = num_bytes;
12476 dwarf_size_type uncompressed_size = 0;
12477
12478 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12479 {
12480 Elf_Internal_Chdr chdr;
12481 unsigned int compression_header_size
12482 = get_compression_header (& chdr, (unsigned char *) start);
12483
813dabb9 12484 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12485 {
813dabb9
L		 12486 warn (_("section '%s' has unsupported compress type: %d\n"),
12487 printable_section_name (section), chdr.ch_type);
12488 return;
12489 }
12490 else if (chdr.ch_addralign != section->sh_addralign)
12491 {
12492 warn (_("compressed section '%s' is corrupted\n"),
12493 printable_section_name (section));
12494 return;
0e602686 12495 }
813dabb9
L		 12496 uncompressed_size = chdr.ch_size;
12497 start += compression_header_size;
12498 new_size -= compression_header_size;
0e602686
NC		 12499 }
12500 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12501 {
12502 /* Read the zlib header. In this case, it should be "ZLIB"
12503 followed by the uncompressed section size, 8 bytes in
12504 big-endian order. */
12505 uncompressed_size = start[4]; uncompressed_size <<= 8;
12506 uncompressed_size += start[5]; uncompressed_size <<= 8;
12507 uncompressed_size += start[6]; uncompressed_size <<= 8;
12508 uncompressed_size += start[7]; uncompressed_size <<= 8;
12509 uncompressed_size += start[8]; uncompressed_size <<= 8;
12510 uncompressed_size += start[9]; uncompressed_size <<= 8;
12511 uncompressed_size += start[10]; uncompressed_size <<= 8;
12512 uncompressed_size += start[11];
12513 start += 12;
12514 new_size -= 12;
12515 }
12516
12517 if (uncompressed_size
fd8008d8 12518 && uncompress_section_contents (& start,
0e602686
NC		 12519 uncompressed_size, & new_size))
12520 num_bytes = new_size;
12521 }
fd8008d8 12522
cf13d699
NC		 12523 /* If the section being dumped has relocations against it the user might
12524 be expecting these relocations to have been applied. Check for this
12525 case and issue a warning message in order to avoid confusion.
12526 FIXME: Maybe we ought to have an option that dumps a section with
12527 relocs applied ? */
12528 for (relsec = section_headers;
12529 relsec < section_headers + elf_header.e_shnum;
12530 ++relsec)
12531 {
12532 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12533 || relsec->sh_info >= elf_header.e_shnum
12534 || section_headers + relsec->sh_info != section
12535 || relsec->sh_size == 0
12536 || relsec->sh_link >= elf_header.e_shnum)
12537 continue;
12538
12539 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12540 break;
12541 }
12542
cf13d699
NC		 12543 data = start;
12544 end = start + num_bytes;
12545 some_strings_shown = FALSE;
12546
12547 while (data < end)
12548 {
12549 while (!ISPRINT (* data))
12550 if (++ data >= end)
12551 break;
12552
12553 if (data < end)
12554 {
071436c6
NC		 12555 size_t maxlen = end - data;
12556
cf13d699 12557#ifndef __MSVCRT__
c975cc98
NC		 12558 /* PR 11128: Use two separate invocations in order to work
12559 around bugs in the Solaris 8 implementation of printf. */
12560 printf (" [%6tx] ", data - start);
cf13d699 12561#else
071436c6 12562 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12563#endif
4082ef84
NC		 12564 if (maxlen > 0)
12565 {
fd8008d8 12566 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12567 putchar ('\n');
fd8008d8 12568 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12569 }
12570 else
12571 {
12572 printf (_("<corrupt>\n"));
12573 data = end;
12574 }
cf13d699
NC		 12575 some_strings_shown = TRUE;
12576 }
12577 }
12578
12579 if (! some_strings_shown)
12580 printf (_(" No strings found in this section."));
12581
0e602686 12582 free (real_start);
cf13d699
NC		 12583
12584 putchar ('\n');
12585}
12586
12587static void
12588dump_section_as_bytes (Elf_Internal_Shdr * section,
12589 FILE * file,
12590 bfd_boolean relocate)
12591{
12592 Elf_Internal_Shdr * relsec;
0e602686
NC		 12593 bfd_size_type bytes;
12594 bfd_size_type section_size;
12595 bfd_vma addr;
12596 unsigned char * data;
12597 unsigned char * real_start;
12598 unsigned char * start;
12599
12600 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12601 if (start == NULL)
12602 return;
0e602686 12603 section_size = section->sh_size;
cf13d699 12604
74e1a04b 12605 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12606
0e602686
NC		 12607 if (decompress_dumps)
12608 {
12609 dwarf_size_type new_size = section_size;
12610 dwarf_size_type uncompressed_size = 0;
12611
12612 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12613 {
12614 Elf_Internal_Chdr chdr;
12615 unsigned int compression_header_size
12616 = get_compression_header (& chdr, start);
12617
813dabb9 12618 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12619 {
813dabb9
L		 12620 warn (_("section '%s' has unsupported compress type: %d\n"),
12621 printable_section_name (section), chdr.ch_type);
12622 return;
0e602686 12623 }
813dabb9
L		 12624 else if (chdr.ch_addralign != section->sh_addralign)
12625 {
12626 warn (_("compressed section '%s' is corrupted\n"),
12627 printable_section_name (section));
12628 return;
12629 }
12630 uncompressed_size = chdr.ch_size;
12631 start += compression_header_size;
12632 new_size -= compression_header_size;
0e602686
NC		 12633 }
12634 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12635 {
12636 /* Read the zlib header. In this case, it should be "ZLIB"
12637 followed by the uncompressed section size, 8 bytes in
12638 big-endian order. */
12639 uncompressed_size = start[4]; uncompressed_size <<= 8;
12640 uncompressed_size += start[5]; uncompressed_size <<= 8;
12641 uncompressed_size += start[6]; uncompressed_size <<= 8;
12642 uncompressed_size += start[7]; uncompressed_size <<= 8;
12643 uncompressed_size += start[8]; uncompressed_size <<= 8;
12644 uncompressed_size += start[9]; uncompressed_size <<= 8;
12645 uncompressed_size += start[10]; uncompressed_size <<= 8;
12646 uncompressed_size += start[11];
12647 start += 12;
12648 new_size -= 12;
12649 }
12650
12651 if (uncompressed_size
12652 && uncompress_section_contents (& start, uncompressed_size,
12653 & new_size))
12654 section_size = new_size;
12655 }
14ae95f2 12656
cf13d699
NC		 12657 if (relocate)
12658 {
0e602686 12659 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12660 }
12661 else
12662 {
12663 /* If the section being dumped has relocations against it the user might
12664 be expecting these relocations to have been applied. Check for this
12665 case and issue a warning message in order to avoid confusion.
12666 FIXME: Maybe we ought to have an option that dumps a section with
12667 relocs applied ? */
12668 for (relsec = section_headers;
12669 relsec < section_headers + elf_header.e_shnum;
12670 ++relsec)
12671 {
12672 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12673 || relsec->sh_info >= elf_header.e_shnum
12674 || section_headers + relsec->sh_info != section
12675 || relsec->sh_size == 0
12676 || relsec->sh_link >= elf_header.e_shnum)
12677 continue;
12678
12679 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12680 break;
12681 }
12682 }
12683
12684 addr = section->sh_addr;
0e602686 12685 bytes = section_size;
cf13d699
NC		 12686 data = start;
12687
12688 while (bytes)
12689 {
12690 int j;
12691 int k;
12692 int lbytes;
12693
12694 lbytes = (bytes > 16 ? 16 : bytes);
12695
12696 printf (" 0x%8.8lx ", (unsigned long) addr);
12697
12698 for (j = 0; j < 16; j++)
12699 {
12700 if (j < lbytes)
12701 printf ("%2.2x", data[j]);
12702 else
12703 printf (" ");
12704
12705 if ((j & 3) == 3)
12706 printf (" ");
12707 }
12708
12709 for (j = 0; j < lbytes; j++)
12710 {
12711 k = data[j];
12712 if (k >= ' ' && k < 0x7f)
12713 printf ("%c", k);
12714 else
12715 printf (".");
12716 }
12717
12718 putchar ('\n');
12719
12720 data += lbytes;
12721 addr += lbytes;
12722 bytes -= lbytes;
12723 }
12724
0e602686 12725 free (real_start);
cf13d699
NC		 12726
12727 putchar ('\n');
12728}
12729
d966045b
DJ		 12730static int
12731load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12732 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12733{
2cf0635d 12734 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12735 char buf [64];
1007acb3 12736
19e6b90e
L		 12737 /* If it is already loaded, do nothing. */
12738 if (section->start != NULL)
12739 return 1;
1007acb3 12740
19e6b90e
L		 12741 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12742 section->address = sec->sh_addr;
06614111 12743 section->user_data = NULL;
3f5e193b
NC		 12744 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12745 sec->sh_offset, 1,
12746 sec->sh_size, buf);
59245841
NC		 12747 if (section->start == NULL)
12748 section->size = 0;
12749 else
12750 {
77115a4a
L		 12751 unsigned char *start = section->start;
12752 dwarf_size_type size = sec->sh_size;
dab394de 12753 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12754
12755 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12756 {
12757 Elf_Internal_Chdr chdr;
d8024a91
NC		 12758 unsigned int compression_header_size;
12759
f53be977
L		 12760 if (size < (is_32bit_elf
12761 ? sizeof (Elf32_External_Chdr)
12762 : sizeof (Elf64_External_Chdr)))
d8024a91
NC		 12763 {
12764 warn (_("compressed section %s is too small to contain a compression header"),
12765 section->name);
12766 return 0;
12767 }
12768
12769 compression_header_size = get_compression_header (&chdr, start);
12770
813dabb9
L		 12771 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12772 {
12773 warn (_("section '%s' has unsupported compress type: %d\n"),
12774 section->name, chdr.ch_type);
12775 return 0;
12776 }
12777 else if (chdr.ch_addralign != sec->sh_addralign)
12778 {
12779 warn (_("compressed section '%s' is corrupted\n"),
12780 section->name);
12781 return 0;
12782 }
dab394de 12783 uncompressed_size = chdr.ch_size;
77115a4a
L		 12784 start += compression_header_size;
12785 size -= compression_header_size;
12786 }
dab394de
L		 12787 else if (size > 12 && streq ((char *) start, "ZLIB"))
12788 {
12789 /* Read the zlib header. In this case, it should be "ZLIB"
12790 followed by the uncompressed section size, 8 bytes in
12791 big-endian order. */
12792 uncompressed_size = start[4]; uncompressed_size <<= 8;
12793 uncompressed_size += start[5]; uncompressed_size <<= 8;
12794 uncompressed_size += start[6]; uncompressed_size <<= 8;
12795 uncompressed_size += start[7]; uncompressed_size <<= 8;
12796 uncompressed_size += start[8]; uncompressed_size <<= 8;
12797 uncompressed_size += start[9]; uncompressed_size <<= 8;
12798 uncompressed_size += start[10]; uncompressed_size <<= 8;
12799 uncompressed_size += start[11];
12800 start += 12;
12801 size -= 12;
12802 }
12803
12804 if (uncompressed_size
12805 && uncompress_section_contents (&start, uncompressed_size,
12806 &size))
77115a4a
L		 12807 {
12808 /* Free the compressed buffer, update the section buffer
12809 and the section size if uncompress is successful. */
12810 free (section->start);
12811 section->start = start;
77115a4a
L		 12812 }
12813 section->size = size;
59245841 12814 }
4a114e3e 12815
1b315056
CS		 12816 if (section->start == NULL)
12817 return 0;
12818
19e6b90e 12819 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12820 apply_relocations ((FILE *) file, sec, section->start, section->size,
12821 & section->reloc_info, & section->num_relocs);
12822 else
12823 {
12824 section->reloc_info = NULL;
12825 section->num_relocs = 0;
12826 }
1007acb3 12827
1b315056 12828 return 1;
1007acb3
L		 12829}
12830
657d0d47
CC		 12831/* If this is not NULL, load_debug_section will only look for sections
12832 within the list of sections given here. */
12833unsigned int *section_subset = NULL;
12834
d966045b 12835int
2cf0635d 12836load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12837{
2cf0635d
NC		 12838 struct dwarf_section * section = &debug_displays [debug].section;
12839 Elf_Internal_Shdr * sec;
d966045b
DJ		 12840
12841 /* Locate the debug section. */
657d0d47 12842 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12843 if (sec != NULL)
12844 section->name = section->uncompressed_name;
12845 else
12846 {
657d0d47 12847 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12848 if (sec != NULL)
12849 section->name = section->compressed_name;
12850 }
12851 if (sec == NULL)
12852 return 0;
12853
657d0d47
CC		 12854 /* If we're loading from a subset of sections, and we've loaded
12855 a section matching this name before, it's likely that it's a
12856 different one. */
12857 if (section_subset != NULL)
12858 free_debug_section (debug);
12859
3f5e193b 12860 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12861}
12862
19e6b90e
L		 12863void
12864free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12865{
2cf0635d 12866 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12867
19e6b90e
L		 12868 if (section->start == NULL)
12869 return;
1007acb3 12870
19e6b90e
L		 12871 free ((char *) section->start);
12872 section->start = NULL;
12873 section->address = 0;
12874 section->size = 0;
1007acb3
L		 12875}
12876
1007acb3 12877static int
657d0d47 12878display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12879{
2cf0635d 12880 char * name = SECTION_NAME (section);
74e1a04b 12881 const char * print_name = printable_section_name (section);
19e6b90e
L		 12882 bfd_size_type length;
12883 int result = 1;
3f5e193b 12884 int i;
1007acb3 12885
19e6b90e
L		 12886 length = section->sh_size;
12887 if (length == 0)
1007acb3 12888 {
74e1a04b 12889 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12890 return 0;
1007acb3 12891 }
5dff79d8
NC		 12892 if (section->sh_type == SHT_NOBITS)
12893 {
12894 /* There is no point in dumping the contents of a debugging section
12895 which has the NOBITS type - the bits in the file will be random.
12896 This can happen when a file containing a .eh_frame section is
12897 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12898 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12899 print_name);
5dff79d8
NC		 12900 return 0;
12901 }
1007acb3 12902
0112cd26 12903 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12904 name = ".debug_info";
1007acb3 12905
19e6b90e
L		 12906 /* See if we know how to display the contents of this section. */
12907 for (i = 0; i < max; i++)
1b315056 12908 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12909 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12910 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12911 {
2cf0635d 12912 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12913 int secondary = (section != find_section (name));
12914
12915 if (secondary)
3f5e193b 12916 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12917
b40bf0a2
NC		 12918 if (i == line && const_strneq (name, ".debug_line."))
12919 sec->name = name;
12920 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12921 sec->name = sec->uncompressed_name;
12922 else
12923 sec->name = sec->compressed_name;
3f5e193b
NC		 12924 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12925 section, file))
19e6b90e 12926 {
657d0d47
CC		 12927 /* If this debug section is part of a CU/TU set in a .dwp file,
12928 restrict load_debug_section to the sections in that set. */
12929 section_subset = find_cu_tu_set (file, shndx);
12930
19e6b90e 12931 result &= debug_displays[i].display (sec, file);
1007acb3 12932
657d0d47
CC		 12933 section_subset = NULL;
12934
d966045b 12935 if (secondary || (i != info && i != abbrev))
3f5e193b 12936 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12937 }
1007acb3 12938
19e6b90e
L		 12939 break;
12940 }
1007acb3 12941
19e6b90e 12942 if (i == max)
1007acb3 12943 {
74e1a04b 12944 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12945 result = 0;
1007acb3
L		 12946 }
12947
19e6b90e 12948 return result;
5b18a4bc 12949}
103f02d3 12950
aef1f6d0
DJ		 12951/* Set DUMP_SECTS for all sections where dumps were requested
12952 based on section name. */
12953
12954static void
12955initialise_dumps_byname (void)
12956{
2cf0635d 12957 struct dump_list_entry * cur;
aef1f6d0
DJ		 12958
12959 for (cur = dump_sects_byname; cur; cur = cur->next)
12960 {
12961 unsigned int i;
12962 int any;
12963
12964 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12965 if (streq (SECTION_NAME (section_headers + i), cur->name))
12966 {
09c11c86 12967 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12968 any = 1;
12969 }
12970
12971 if (!any)
12972 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12973 cur->name);
12974 }
12975}
12976
5b18a4bc 12977static void
2cf0635d 12978process_section_contents (FILE * file)
5b18a4bc 12979{
2cf0635d 12980 Elf_Internal_Shdr * section;
19e6b90e 12981 unsigned int i;
103f02d3 12982
19e6b90e
L		 12983 if (! do_dump)
12984 return;
103f02d3 12985
aef1f6d0
DJ		 12986 initialise_dumps_byname ();
12987
19e6b90e
L		 12988 for (i = 0, section = section_headers;
12989 i < elf_header.e_shnum && i < num_dump_sects;
12990 i++, section++)
12991 {
12992#ifdef SUPPORT_DISASSEMBLY
12993 if (dump_sects[i] & DISASS_DUMP)
12994 disassemble_section (section, file);
12995#endif
12996 if (dump_sects[i] & HEX_DUMP)
cf13d699 12997 dump_section_as_bytes (section, file, FALSE);
103f02d3 12998
cf13d699
NC		 12999 if (dump_sects[i] & RELOC_DUMP)
13000 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 13001
13002 if (dump_sects[i] & STRING_DUMP)
13003 dump_section_as_strings (section, file);
cf13d699
NC		 13004
13005 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 13006 display_debug_section (i, section, file);
5b18a4bc 13007 }
103f02d3 13008
19e6b90e
L		 13009 /* Check to see if the user requested a
13010 dump of a section that does not exist. */
13011 while (i++ < num_dump_sects)
13012 if (dump_sects[i])
13013 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 13014}
103f02d3 13015
5b18a4bc 13016static void
19e6b90e 13017process_mips_fpe_exception (int mask)
5b18a4bc 13018{
19e6b90e
L		 13019 if (mask)
13020 {
13021 int first = 1;
13022 if (mask & OEX_FPU_INEX)
13023 fputs ("INEX", stdout), first = 0;
13024 if (mask & OEX_FPU_UFLO)
13025 printf ("%sUFLO", first ? "" : "|"), first = 0;
13026 if (mask & OEX_FPU_OFLO)
13027 printf ("%sOFLO", first ? "" : "|"), first = 0;
13028 if (mask & OEX_FPU_DIV0)
13029 printf ("%sDIV0", first ? "" : "|"), first = 0;
13030 if (mask & OEX_FPU_INVAL)
13031 printf ("%sINVAL", first ? "" : "|");
13032 }
5b18a4bc 13033 else
19e6b90e 13034 fputs ("0", stdout);
5b18a4bc 13035}
103f02d3 13036
f6f0e17b
NC		 13037/* Display's the value of TAG at location P. If TAG is
13038 greater than 0 it is assumed to be an unknown tag, and
13039 a message is printed to this effect. Otherwise it is
13040 assumed that a message has already been printed.
13041
13042 If the bottom bit of TAG is set it assumed to have a
13043 string value, otherwise it is assumed to have an integer
13044 value.
13045
13046 Returns an updated P pointing to the first unread byte
13047 beyond the end of TAG's value.
13048
13049 Reads at or beyond END will not be made. */
13050
13051static unsigned char *
13052display_tag_value (int tag,
13053 unsigned char * p,
13054 const unsigned char * const end)
13055{
13056 unsigned long val;
13057
13058 if (tag > 0)
13059 printf (" Tag_unknown_%d: ", tag);
13060
13061 if (p >= end)
13062 {
4082ef84 13063 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 13064 }
13065 else if (tag & 1)
13066 {
071436c6
NC		 13067 /* PR 17531 file: 027-19978-0.004. */
13068 size_t maxlen = (end - p) - 1;
13069
13070 putchar ('"');
4082ef84
NC		 13071 if (maxlen > 0)
13072 {
13073 print_symbol ((int) maxlen, (const char *) p);
13074 p += strnlen ((char *) p, maxlen) + 1;
13075 }
13076 else
13077 {
13078 printf (_("<corrupt string tag>"));
13079 p = (unsigned char *) end;
13080 }
071436c6 13081 printf ("\"\n");
f6f0e17b
NC		 13082 }
13083 else
13084 {
13085 unsigned int len;
13086
13087 val = read_uleb128 (p, &len, end);
13088 p += len;
13089 printf ("%ld (0x%lx)\n", val, val);
13090 }
13091
4082ef84 13092 assert (p <= end);
f6f0e17b
NC		 13093 return p;
13094}
13095
11c1ff18
PB		 13096/* ARM EABI attributes section. */
13097typedef struct
13098{
70e99720 13099 unsigned int tag;
2cf0635d 13100 const char * name;
11c1ff18 13101 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 13102 unsigned int type;
2cf0635d 13103 const char ** table;
11c1ff18
PB		 13104} arm_attr_public_tag;
13105
2cf0635d 13106static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 13107 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ff8646ee
TP		 13108 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13109 "v8-M.mainline"};
2cf0635d
NC		 13110static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13111static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 13112 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 13113static const char * arm_attr_tag_FP_arch[] =
bca38921 13114 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 13115 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 13116static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 13117static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9411fd44
MW		 13118 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13119 "NEON for ARMv8.1"};
2cf0635d 13120static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 13121 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13122 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 13123static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 13124 {"V6", "SB", "TLS", "Unused"};
2cf0635d 13125static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 13126 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 13127static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 13128 {"Absolute", "PC-relative", "None"};
2cf0635d 13129static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 13130 {"None", "direct", "GOT-indirect"};
2cf0635d 13131static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 13132 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 13133static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13134static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 13135 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 13136static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13137static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13138static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 13139 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 13140static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 13141 {"Unused", "small", "int", "forced to int"};
2cf0635d 13142static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 13143 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 13144static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 13145 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 13146static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 13147 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 13148static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 13149 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13150 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 13151static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 13152 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13153 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 13154static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 13155static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 13156 {"Not Allowed", "Allowed"};
2cf0635d 13157static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 13158 {"None", "IEEE 754", "Alternative Format"};
15afaa63
TP		 13159static const char * arm_attr_tag_DSP_extension[] =
13160 {"Follow architecture", "Allowed"};
dd24e3da 13161static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 13162 {"Not Allowed", "Allowed"};
13163static const char * arm_attr_tag_DIV_use[] =
dd24e3da 13164 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 13165 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 13166static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13167static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 13168 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 13169 "TrustZone and Virtualization Extensions"};
dd24e3da 13170static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 13171 {"Not Allowed", "Allowed"};
11c1ff18
PB		 13172
13173#define LOOKUP(id, name) \
13174 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 13175static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 13176{
13177 {4, "CPU_raw_name", 1, NULL},
13178 {5, "CPU_name", 1, NULL},
13179 LOOKUP(6, CPU_arch),
13180 {7, "CPU_arch_profile", 0, NULL},
13181 LOOKUP(8, ARM_ISA_use),
13182 LOOKUP(9, THUMB_ISA_use),
75375b3e 13183 LOOKUP(10, FP_arch),
11c1ff18 13184 LOOKUP(11, WMMX_arch),
f5f53991
AS		 13185 LOOKUP(12, Advanced_SIMD_arch),
13186 LOOKUP(13, PCS_config),
11c1ff18
PB		 13187 LOOKUP(14, ABI_PCS_R9_use),
13188 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 13189 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 13190 LOOKUP(17, ABI_PCS_GOT_use),
13191 LOOKUP(18, ABI_PCS_wchar_t),
13192 LOOKUP(19, ABI_FP_rounding),
13193 LOOKUP(20, ABI_FP_denormal),
13194 LOOKUP(21, ABI_FP_exceptions),
13195 LOOKUP(22, ABI_FP_user_exceptions),
13196 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 13197 {24, "ABI_align_needed", 0, NULL},
13198 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 13199 LOOKUP(26, ABI_enum_size),
13200 LOOKUP(27, ABI_HardFP_use),
13201 LOOKUP(28, ABI_VFP_args),
13202 LOOKUP(29, ABI_WMMX_args),
13203 LOOKUP(30, ABI_optimization_goals),
13204 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 13205 {32, "compatibility", 0, NULL},
f5f53991 13206 LOOKUP(34, CPU_unaligned_access),
75375b3e 13207 LOOKUP(36, FP_HP_extension),
8e79c3df 13208 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 13209 LOOKUP(42, MPextension_use),
13210 LOOKUP(44, DIV_use),
15afaa63 13211 LOOKUP(46, DSP_extension),
f5f53991
AS		 13212 {64, "nodefaults", 0, NULL},
13213 {65, "also_compatible_with", 0, NULL},
13214 LOOKUP(66, T2EE_use),
13215 {67, "conformance", 1, NULL},
13216 LOOKUP(68, Virtualization_use),
cd21e546 13217 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 13218};
13219#undef LOOKUP
13220
11c1ff18 13221static unsigned char *
f6f0e17b
NC		 13222display_arm_attribute (unsigned char * p,
13223 const unsigned char * const end)
11c1ff18 13224{
70e99720 13225 unsigned int tag;
11c1ff18 13226 unsigned int len;
70e99720 13227 unsigned int val;
2cf0635d 13228 arm_attr_public_tag * attr;
11c1ff18 13229 unsigned i;
70e99720 13230 unsigned int type;
11c1ff18 13231
f6f0e17b 13232 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 13233 p += len;
13234 attr = NULL;
2cf0635d 13235 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 13236 {
13237 if (arm_attr_public_tags[i].tag == tag)
13238 {
13239 attr = &arm_attr_public_tags[i];
13240 break;
13241 }
13242 }
13243
13244 if (attr)
13245 {
13246 printf (" Tag_%s: ", attr->name);
13247 switch (attr->type)
13248 {
13249 case 0:
13250 switch (tag)
13251 {
13252 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 13253 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13254 p += len;
13255 switch (val)
13256 {
2b692964
NC		 13257 case 0: printf (_("None\n")); break;
13258 case 'A': printf (_("Application\n")); break;
13259 case 'R': printf (_("Realtime\n")); break;
13260 case 'M': printf (_("Microcontroller\n")); break;
13261 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 13262 default: printf ("??? (%d)\n", val); break;
13263 }
13264 break;
13265
75375b3e 13266 case 24: /* Tag_align_needed. */
f6f0e17b 13267 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13268 p += len;
13269 switch (val)
13270 {
2b692964
NC		 13271 case 0: printf (_("None\n")); break;
13272 case 1: printf (_("8-byte\n")); break;
13273 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 13274 case 3: printf ("??? 3\n"); break;
13275 default:
13276 if (val <= 12)
dd24e3da 13277 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13278 1 << val);
13279 else
13280 printf ("??? (%d)\n", val);
13281 break;
13282 }
13283 break;
13284
13285 case 25: /* Tag_align_preserved. */
f6f0e17b 13286 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13287 p += len;
13288 switch (val)
13289 {
2b692964
NC		 13290 case 0: printf (_("None\n")); break;
13291 case 1: printf (_("8-byte, except leaf SP\n")); break;
13292 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 13293 case 3: printf ("??? 3\n"); break;
13294 default:
13295 if (val <= 12)
dd24e3da 13296 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13297 1 << val);
13298 else
13299 printf ("??? (%d)\n", val);
13300 break;
13301 }
13302 break;
13303
11c1ff18 13304 case 32: /* Tag_compatibility. */
071436c6 13305 {
071436c6
NC		 13306 val = read_uleb128 (p, &len, end);
13307 p += len;
071436c6 13308 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13309 if (p < end - 1)
13310 {
13311 size_t maxlen = (end - p) - 1;
13312
13313 print_symbol ((int) maxlen, (const char *) p);
13314 p += strnlen ((char *) p, maxlen) + 1;
13315 }
13316 else
13317 {
13318 printf (_("<corrupt>"));
13319 p = (unsigned char *) end;
13320 }
071436c6 13321 putchar ('\n');
071436c6 13322 }
11c1ff18
PB		 13323 break;
13324
f5f53991 13325 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 13326 /* PR 17531: file: 001-505008-0.01. */
13327 if (p < end)
13328 p++;
2b692964 13329 printf (_("True\n"));
f5f53991
AS		 13330 break;
13331
13332 case 65: /* Tag_also_compatible_with. */
f6f0e17b 13333 val = read_uleb128 (p, &len, end);
f5f53991
AS		 13334 p += len;
13335 if (val == 6 /* Tag_CPU_arch. */)
13336 {
f6f0e17b 13337 val = read_uleb128 (p, &len, end);
f5f53991 13338 p += len;
071436c6 13339 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 13340 printf ("??? (%d)\n", val);
13341 else
13342 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13343 }
13344 else
13345 printf ("???\n");
071436c6
NC		 13346 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13347 ;
f5f53991
AS		 13348 break;
13349
11c1ff18 13350 default:
bee0ee85
NC		 13351 printf (_("<unknown: %d>\n"), tag);
13352 break;
11c1ff18
PB		 13353 }
13354 return p;
13355
13356 case 1:
f6f0e17b 13357 return display_tag_value (-1, p, end);
11c1ff18 13358 case 2:
f6f0e17b 13359 return display_tag_value (0, p, end);
11c1ff18
PB		 13360
13361 default:
13362 assert (attr->type & 0x80);
f6f0e17b 13363 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13364 p += len;
13365 type = attr->type & 0x7f;
13366 if (val >= type)
13367 printf ("??? (%d)\n", val);
13368 else
13369 printf ("%s\n", attr->table[val]);
13370 return p;
13371 }
13372 }
11c1ff18 13373
f6f0e17b 13374 return display_tag_value (tag, p, end);
11c1ff18
PB		 13375}
13376
104d59d1 13377static unsigned char *
60bca95a 13378display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 13379 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13380 const unsigned char * const end)
104d59d1
JM		 13381{
13382 int tag;
13383 unsigned int len;
13384 int val;
104d59d1 13385
f6f0e17b 13386 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13387 p += len;
13388
13389 /* Tag_compatibility is the only generic GNU attribute defined at
13390 present. */
13391 if (tag == 32)
13392 {
f6f0e17b 13393 val = read_uleb128 (p, &len, end);
104d59d1 13394 p += len;
071436c6
NC		 13395
13396 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13397 if (p == end)
13398 {
071436c6 13399 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13400 warn (_("corrupt vendor attribute\n"));
13401 }
13402 else
13403 {
4082ef84
NC		 13404 if (p < end - 1)
13405 {
13406 size_t maxlen = (end - p) - 1;
071436c6 13407
4082ef84
NC		 13408 print_symbol ((int) maxlen, (const char *) p);
13409 p += strnlen ((char *) p, maxlen) + 1;
13410 }
13411 else
13412 {
13413 printf (_("<corrupt>"));
13414 p = (unsigned char *) end;
13415 }
071436c6 13416 putchar ('\n');
f6f0e17b 13417 }
104d59d1
JM		 13418 return p;
13419 }
13420
13421 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13422 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13423
f6f0e17b 13424 return display_tag_value (tag, p, end);
104d59d1
JM		 13425}
13426
34c8bcba 13427static unsigned char *
f6f0e17b
NC		 13428display_power_gnu_attribute (unsigned char * p,
13429 int tag,
13430 const unsigned char * const end)
34c8bcba 13431{
34c8bcba 13432 unsigned int len;
005d79fd 13433 unsigned int val;
34c8bcba
JM		 13434
13435 if (tag == Tag_GNU_Power_ABI_FP)
13436 {
f6f0e17b 13437 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13438 p += len;
13439 printf (" Tag_GNU_Power_ABI_FP: ");
005d79fd
AM		 13440 if (len == 0)
13441 {
13442 printf (_("<corrupt>\n"));
13443 return p;
13444 }
60bca95a 13445
005d79fd
AM		 13446 if (val > 15)
13447 printf ("(%#x), ", val);
13448
13449 switch (val & 3)
34c8bcba
JM		 13450 {
13451 case 0:
005d79fd 13452 printf (_("unspecified hard/soft float, "));
34c8bcba
JM		 13453 break;
13454 case 1:
005d79fd 13455 printf (_("hard float, "));
34c8bcba
JM		 13456 break;
13457 case 2:
005d79fd 13458 printf (_("soft float, "));
34c8bcba 13459 break;
3c7b9897 13460 case 3:
005d79fd 13461 printf (_("single-precision hard float, "));
3c7b9897 13462 break;
005d79fd
AM		 13463 }
13464
13465 switch (val & 0xC)
13466 {
13467 case 0:
13468 printf (_("unspecified long double\n"));
13469 break;
13470 case 4:
13471 printf (_("128-bit IBM long double\n"));
13472 break;
13473 case 8:
13474 printf (_("64-bit long double\n"));
13475 break;
13476 case 12:
13477 printf (_("128-bit IEEE long double\n"));
34c8bcba
JM		 13478 break;
13479 }
13480 return p;
005d79fd 13481 }
34c8bcba 13482
c6e65352
DJ		 13483 if (tag == Tag_GNU_Power_ABI_Vector)
13484 {
f6f0e17b 13485 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13486 p += len;
13487 printf (" Tag_GNU_Power_ABI_Vector: ");
005d79fd
AM		 13488 if (len == 0)
13489 {
13490 printf (_("<corrupt>\n"));
13491 return p;
13492 }
13493
13494 if (val > 3)
13495 printf ("(%#x), ", val);
13496
13497 switch (val & 3)
c6e65352
DJ		 13498 {
13499 case 0:
005d79fd 13500 printf (_("unspecified\n"));
c6e65352
DJ		 13501 break;
13502 case 1:
005d79fd 13503 printf (_("generic\n"));
c6e65352
DJ		 13504 break;
13505 case 2:
13506 printf ("AltiVec\n");
13507 break;
13508 case 3:
13509 printf ("SPE\n");
13510 break;
c6e65352
DJ		 13511 }
13512 return p;
005d79fd 13513 }
c6e65352 13514
f82e0623
NF		 13515 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13516 {
005d79fd
AM		 13517 val = read_uleb128 (p, &len, end);
13518 p += len;
13519 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13520 if (len == 0)
f6f0e17b 13521 {
005d79fd 13522 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13523 return p;
13524 }
0b4362b0 13525
005d79fd
AM		 13526 if (val > 2)
13527 printf ("(%#x), ", val);
13528
13529 switch (val & 3)
13530 {
13531 case 0:
13532 printf (_("unspecified\n"));
13533 break;
13534 case 1:
13535 printf ("r3/r4\n");
13536 break;
13537 case 2:
13538 printf (_("memory\n"));
13539 break;
13540 case 3:
13541 printf ("???\n");
13542 break;
13543 }
f82e0623
NF		 13544 return p;
13545 }
13546
f6f0e17b 13547 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13548}
13549
643f7afb
AK		 13550static unsigned char *
13551display_s390_gnu_attribute (unsigned char * p,
13552 int tag,
13553 const unsigned char * const end)
13554{
13555 unsigned int len;
13556 int val;
13557
13558 if (tag == Tag_GNU_S390_ABI_Vector)
13559 {
13560 val = read_uleb128 (p, &len, end);
13561 p += len;
13562 printf (" Tag_GNU_S390_ABI_Vector: ");
13563
13564 switch (val)
13565 {
13566 case 0:
13567 printf (_("any\n"));
13568 break;
13569 case 1:
13570 printf (_("software\n"));
13571 break;
13572 case 2:
13573 printf (_("hardware\n"));
13574 break;
13575 default:
13576 printf ("??? (%d)\n", val);
13577 break;
13578 }
13579 return p;
13580 }
13581
13582 return display_tag_value (tag & 1, p, end);
13583}
13584
9e8c70f9
DM		 13585static void
13586display_sparc_hwcaps (int mask)
13587{
13588 if (mask)
13589 {
13590 int first = 1;
071436c6 13591
9e8c70f9
DM		 13592 if (mask & ELF_SPARC_HWCAP_MUL32)
13593 fputs ("mul32", stdout), first = 0;
13594 if (mask & ELF_SPARC_HWCAP_DIV32)
13595 printf ("%sdiv32", first ? "" : "|"), first = 0;
13596 if (mask & ELF_SPARC_HWCAP_FSMULD)
13597 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13598 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13599 printf ("%sv8plus", first ? "" : "|"), first = 0;
13600 if (mask & ELF_SPARC_HWCAP_POPC)
13601 printf ("%spopc", first ? "" : "|"), first = 0;
13602 if (mask & ELF_SPARC_HWCAP_VIS)
13603 printf ("%svis", first ? "" : "|"), first = 0;
13604 if (mask & ELF_SPARC_HWCAP_VIS2)
13605 printf ("%svis2", first ? "" : "|"), first = 0;
13606 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13607 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13608 if (mask & ELF_SPARC_HWCAP_FMAF)
13609 printf ("%sfmaf", first ? "" : "|"), first = 0;
13610 if (mask & ELF_SPARC_HWCAP_VIS3)
13611 printf ("%svis3", first ? "" : "|"), first = 0;
13612 if (mask & ELF_SPARC_HWCAP_HPC)
13613 printf ("%shpc", first ? "" : "|"), first = 0;
13614 if (mask & ELF_SPARC_HWCAP_RANDOM)
13615 printf ("%srandom", first ? "" : "|"), first = 0;
13616 if (mask & ELF_SPARC_HWCAP_TRANS)
13617 printf ("%strans", first ? "" : "|"), first = 0;
13618 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13619 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13620 if (mask & ELF_SPARC_HWCAP_IMA)
13621 printf ("%sima", first ? "" : "|"), first = 0;
13622 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13623 printf ("%scspare", first ? "" : "|"), first = 0;
13624 }
13625 else
071436c6
NC		 13626 fputc ('0', stdout);
13627 fputc ('\n', stdout);
9e8c70f9
DM		 13628}
13629
3d68f91c
JM		 13630static void
13631display_sparc_hwcaps2 (int mask)
13632{
13633 if (mask)
13634 {
13635 int first = 1;
071436c6 13636
3d68f91c
JM		 13637 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13638 fputs ("fjathplus", stdout), first = 0;
13639 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13640 printf ("%svis3b", first ? "" : "|"), first = 0;
13641 if (mask & ELF_SPARC_HWCAP2_ADP)
13642 printf ("%sadp", first ? "" : "|"), first = 0;
13643 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13644 printf ("%ssparc5", first ? "" : "|"), first = 0;
13645 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13646 printf ("%smwait", first ? "" : "|"), first = 0;
13647 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13648 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13649 if (mask & ELF_SPARC_HWCAP2_XMONT)
13650 printf ("%sxmont2", first ? "" : "|"), first = 0;
13651 if (mask & ELF_SPARC_HWCAP2_NSEC)
13652 printf ("%snsec", first ? "" : "|"), first = 0;
13653 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13654 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13655 if (mask & ELF_SPARC_HWCAP2_FJDES)
13656 printf ("%sfjdes", first ? "" : "|"), first = 0;
13657 if (mask & ELF_SPARC_HWCAP2_FJAES)
13658 printf ("%sfjaes", first ? "" : "|"), first = 0;
13659 }
13660 else
071436c6
NC		 13661 fputc ('0', stdout);
13662 fputc ('\n', stdout);
3d68f91c
JM		 13663}
13664
9e8c70f9 13665static unsigned char *
f6f0e17b
NC		 13666display_sparc_gnu_attribute (unsigned char * p,
13667 int tag,
13668 const unsigned char * const end)
9e8c70f9 13669{
3d68f91c
JM		 13670 unsigned int len;
13671 int val;
13672
9e8c70f9
DM		 13673 if (tag == Tag_GNU_Sparc_HWCAPS)
13674 {
f6f0e17b 13675 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13676 p += len;
13677 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13678 display_sparc_hwcaps (val);
13679 return p;
3d68f91c
JM		 13680 }
13681 if (tag == Tag_GNU_Sparc_HWCAPS2)
13682 {
13683 val = read_uleb128 (p, &len, end);
13684 p += len;
13685 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13686 display_sparc_hwcaps2 (val);
13687 return p;
13688 }
9e8c70f9 13689
f6f0e17b 13690 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13691}
13692
351cdf24
MF		 13693static void
13694print_mips_fp_abi_value (int val)
13695{
13696 switch (val)
13697 {
13698 case Val_GNU_MIPS_ABI_FP_ANY:
13699 printf (_("Hard or soft float\n"));
13700 break;
13701 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13702 printf (_("Hard float (double precision)\n"));
13703 break;
13704 case Val_GNU_MIPS_ABI_FP_SINGLE:
13705 printf (_("Hard float (single precision)\n"));
13706 break;
13707 case Val_GNU_MIPS_ABI_FP_SOFT:
13708 printf (_("Soft float\n"));
13709 break;
13710 case Val_GNU_MIPS_ABI_FP_OLD_64:
13711 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13712 break;
13713 case Val_GNU_MIPS_ABI_FP_XX:
13714 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13715 break;
13716 case Val_GNU_MIPS_ABI_FP_64:
13717 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13718 break;
13719 case Val_GNU_MIPS_ABI_FP_64A:
13720 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13721 break;
3350cc01
CM		 13722 case Val_GNU_MIPS_ABI_FP_NAN2008:
13723 printf (_("NaN 2008 compatibility\n"));
13724 break;
351cdf24
MF		 13725 default:
13726 printf ("??? (%d)\n", val);
13727 break;
13728 }
13729}
13730
2cf19d5c 13731static unsigned char *
f6f0e17b
NC		 13732display_mips_gnu_attribute (unsigned char * p,
13733 int tag,
13734 const unsigned char * const end)
2cf19d5c 13735{
2cf19d5c
JM		 13736 if (tag == Tag_GNU_MIPS_ABI_FP)
13737 {
f6f0e17b
NC		 13738 unsigned int len;
13739 int val;
13740
13741 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13742 p += len;
13743 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13744
351cdf24
MF		 13745 print_mips_fp_abi_value (val);
13746
2cf19d5c
JM		 13747 return p;
13748 }
13749
a9f58168
CF		 13750 if (tag == Tag_GNU_MIPS_ABI_MSA)
13751 {
13752 unsigned int len;
13753 int val;
13754
13755 val = read_uleb128 (p, &len, end);
13756 p += len;
13757 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13758
13759 switch (val)
13760 {
13761 case Val_GNU_MIPS_ABI_MSA_ANY:
13762 printf (_("Any MSA or not\n"));
13763 break;
13764 case Val_GNU_MIPS_ABI_MSA_128:
13765 printf (_("128-bit MSA\n"));
13766 break;
13767 default:
13768 printf ("??? (%d)\n", val);
13769 break;
13770 }
13771 return p;
13772 }
13773
f6f0e17b 13774 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13775}
13776
59e6276b 13777static unsigned char *
f6f0e17b
NC		 13778display_tic6x_attribute (unsigned char * p,
13779 const unsigned char * const end)
59e6276b
JM		 13780{
13781 int tag;
13782 unsigned int len;
13783 int val;
13784
f6f0e17b 13785 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13786 p += len;
13787
13788 switch (tag)
13789 {
75fa6dc1 13790 case Tag_ISA:
f6f0e17b 13791 val = read_uleb128 (p, &len, end);
59e6276b 13792 p += len;
75fa6dc1 13793 printf (" Tag_ISA: ");
59e6276b
JM		 13794
13795 switch (val)
13796 {
75fa6dc1 13797 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13798 printf (_("None\n"));
13799 break;
75fa6dc1 13800 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13801 printf ("C62x\n");
13802 break;
75fa6dc1 13803 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13804 printf ("C67x\n");
13805 break;
75fa6dc1 13806 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13807 printf ("C67x+\n");
13808 break;
75fa6dc1 13809 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13810 printf ("C64x\n");
13811 break;
75fa6dc1 13812 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13813 printf ("C64x+\n");
13814 break;
75fa6dc1 13815 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13816 printf ("C674x\n");
13817 break;
13818 default:
13819 printf ("??? (%d)\n", val);
13820 break;
13821 }
13822 return p;
13823
87779176 13824 case Tag_ABI_wchar_t:
f6f0e17b 13825 val = read_uleb128 (p, &len, end);
87779176
JM		 13826 p += len;
13827 printf (" Tag_ABI_wchar_t: ");
13828 switch (val)
13829 {
13830 case 0:
13831 printf (_("Not used\n"));
13832 break;
13833 case 1:
13834 printf (_("2 bytes\n"));
13835 break;
13836 case 2:
13837 printf (_("4 bytes\n"));
13838 break;
13839 default:
13840 printf ("??? (%d)\n", val);
13841 break;
13842 }
13843 return p;
13844
13845 case Tag_ABI_stack_align_needed:
f6f0e17b 13846 val = read_uleb128 (p, &len, end);
87779176
JM		 13847 p += len;
13848 printf (" Tag_ABI_stack_align_needed: ");
13849 switch (val)
13850 {
13851 case 0:
13852 printf (_("8-byte\n"));
13853 break;
13854 case 1:
13855 printf (_("16-byte\n"));
13856 break;
13857 default:
13858 printf ("??? (%d)\n", val);
13859 break;
13860 }
13861 return p;
13862
13863 case Tag_ABI_stack_align_preserved:
f6f0e17b 13864 val = read_uleb128 (p, &len, end);
87779176
JM		 13865 p += len;
13866 printf (" Tag_ABI_stack_align_preserved: ");
13867 switch (val)
13868 {
13869 case 0:
13870 printf (_("8-byte\n"));
13871 break;
13872 case 1:
13873 printf (_("16-byte\n"));
13874 break;
13875 default:
13876 printf ("??? (%d)\n", val);
13877 break;
13878 }
13879 return p;
13880
b5593623 13881 case Tag_ABI_DSBT:
f6f0e17b 13882 val = read_uleb128 (p, &len, end);
b5593623
JM		 13883 p += len;
13884 printf (" Tag_ABI_DSBT: ");
13885 switch (val)
13886 {
13887 case 0:
13888 printf (_("DSBT addressing not used\n"));
13889 break;
13890 case 1:
13891 printf (_("DSBT addressing used\n"));
13892 break;
13893 default:
13894 printf ("??? (%d)\n", val);
13895 break;
13896 }
13897 return p;
13898
87779176 13899 case Tag_ABI_PID:
f6f0e17b 13900 val = read_uleb128 (p, &len, end);
87779176
JM		 13901 p += len;
13902 printf (" Tag_ABI_PID: ");
13903 switch (val)
13904 {
13905 case 0:
13906 printf (_("Data addressing position-dependent\n"));
13907 break;
13908 case 1:
13909 printf (_("Data addressing position-independent, GOT near DP\n"));
13910 break;
13911 case 2:
13912 printf (_("Data addressing position-independent, GOT far from DP\n"));
13913 break;
13914 default:
13915 printf ("??? (%d)\n", val);
13916 break;
13917 }
13918 return p;
13919
13920 case Tag_ABI_PIC:
f6f0e17b 13921 val = read_uleb128 (p, &len, end);
87779176
JM		 13922 p += len;
13923 printf (" Tag_ABI_PIC: ");
13924 switch (val)
13925 {
13926 case 0:
13927 printf (_("Code addressing position-dependent\n"));
13928 break;
13929 case 1:
13930 printf (_("Code addressing position-independent\n"));
13931 break;
13932 default:
13933 printf ("??? (%d)\n", val);
13934 break;
13935 }
13936 return p;
13937
13938 case Tag_ABI_array_object_alignment:
f6f0e17b 13939 val = read_uleb128 (p, &len, end);
87779176
JM		 13940 p += len;
13941 printf (" Tag_ABI_array_object_alignment: ");
13942 switch (val)
13943 {
13944 case 0:
13945 printf (_("8-byte\n"));
13946 break;
13947 case 1:
13948 printf (_("4-byte\n"));
13949 break;
13950 case 2:
13951 printf (_("16-byte\n"));
13952 break;
13953 default:
13954 printf ("??? (%d)\n", val);
13955 break;
13956 }
13957 return p;
13958
13959 case Tag_ABI_array_object_align_expected:
f6f0e17b 13960 val = read_uleb128 (p, &len, end);
87779176
JM		 13961 p += len;
13962 printf (" Tag_ABI_array_object_align_expected: ");
13963 switch (val)
13964 {
13965 case 0:
13966 printf (_("8-byte\n"));
13967 break;
13968 case 1:
13969 printf (_("4-byte\n"));
13970 break;
13971 case 2:
13972 printf (_("16-byte\n"));
13973 break;
13974 default:
13975 printf ("??? (%d)\n", val);
13976 break;
13977 }
13978 return p;
13979
3cbd1c06 13980 case Tag_ABI_compatibility:
071436c6 13981 {
071436c6
NC		 13982 val = read_uleb128 (p, &len, end);
13983 p += len;
13984 printf (" Tag_ABI_compatibility: ");
071436c6 13985 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13986 if (p < end - 1)
13987 {
13988 size_t maxlen = (end - p) - 1;
13989
13990 print_symbol ((int) maxlen, (const char *) p);
13991 p += strnlen ((char *) p, maxlen) + 1;
13992 }
13993 else
13994 {
13995 printf (_("<corrupt>"));
13996 p = (unsigned char *) end;
13997 }
071436c6 13998 putchar ('\n');
071436c6
NC		 13999 return p;
14000 }
87779176
JM		 14001
14002 case Tag_ABI_conformance:
071436c6 14003 {
4082ef84
NC		 14004 printf (" Tag_ABI_conformance: \"");
14005 if (p < end - 1)
14006 {
14007 size_t maxlen = (end - p) - 1;
071436c6 14008
4082ef84
NC		 14009 print_symbol ((int) maxlen, (const char *) p);
14010 p += strnlen ((char *) p, maxlen) + 1;
14011 }
14012 else
14013 {
14014 printf (_("<corrupt>"));
14015 p = (unsigned char *) end;
14016 }
071436c6 14017 printf ("\"\n");
071436c6
NC		 14018 return p;
14019 }
59e6276b
JM		 14020 }
14021
f6f0e17b
NC		 14022 return display_tag_value (tag, p, end);
14023}
59e6276b 14024
f6f0e17b
NC		 14025static void
14026display_raw_attribute (unsigned char * p, unsigned char * end)
14027{
14028 unsigned long addr = 0;
14029 size_t bytes = end - p;
14030
e0a31db1 14031 assert (end > p);
f6f0e17b 14032 while (bytes)
87779176 14033 {
f6f0e17b
NC		 14034 int j;
14035 int k;
14036 int lbytes = (bytes > 16 ? 16 : bytes);
14037
14038 printf (" 0x%8.8lx ", addr);
14039
14040 for (j = 0; j < 16; j++)
14041 {
14042 if (j < lbytes)
14043 printf ("%2.2x", p[j]);
14044 else
14045 printf (" ");
14046
14047 if ((j & 3) == 3)
14048 printf (" ");
14049 }
14050
14051 for (j = 0; j < lbytes; j++)
14052 {
14053 k = p[j];
14054 if (k >= ' ' && k < 0x7f)
14055 printf ("%c", k);
14056 else
14057 printf (".");
14058 }
14059
14060 putchar ('\n');
14061
14062 p += lbytes;
14063 bytes -= lbytes;
14064 addr += lbytes;
87779176 14065 }
59e6276b 14066
f6f0e17b 14067 putchar ('\n');
59e6276b
JM		 14068}
14069
13761a11
NC		 14070static unsigned char *
14071display_msp430x_attribute (unsigned char * p,
14072 const unsigned char * const end)
14073{
14074 unsigned int len;
14075 int val;
14076 int tag;
14077
14078 tag = read_uleb128 (p, & len, end);
14079 p += len;
0b4362b0 14080
13761a11
NC		 14081 switch (tag)
14082 {
14083 case OFBA_MSPABI_Tag_ISA:
14084 val = read_uleb128 (p, &len, end);
14085 p += len;
14086 printf (" Tag_ISA: ");
14087 switch (val)
14088 {
14089 case 0: printf (_("None\n")); break;
14090 case 1: printf (_("MSP430\n")); break;
14091 case 2: printf (_("MSP430X\n")); break;
14092 default: printf ("??? (%d)\n", val); break;
14093 }
14094 break;
14095
14096 case OFBA_MSPABI_Tag_Code_Model:
14097 val = read_uleb128 (p, &len, end);
14098 p += len;
14099 printf (" Tag_Code_Model: ");
14100 switch (val)
14101 {
14102 case 0: printf (_("None\n")); break;
14103 case 1: printf (_("Small\n")); break;
14104 case 2: printf (_("Large\n")); break;
14105 default: printf ("??? (%d)\n", val); break;
14106 }
14107 break;
14108
14109 case OFBA_MSPABI_Tag_Data_Model:
14110 val = read_uleb128 (p, &len, end);
14111 p += len;
14112 printf (" Tag_Data_Model: ");
14113 switch (val)
14114 {
14115 case 0: printf (_("None\n")); break;
14116 case 1: printf (_("Small\n")); break;
14117 case 2: printf (_("Large\n")); break;
14118 case 3: printf (_("Restricted Large\n")); break;
14119 default: printf ("??? (%d)\n", val); break;
14120 }
14121 break;
14122
14123 default:
14124 printf (_(" <unknown tag %d>: "), tag);
14125
14126 if (tag & 1)
14127 {
071436c6 14128 putchar ('"');
4082ef84
NC		 14129 if (p < end - 1)
14130 {
14131 size_t maxlen = (end - p) - 1;
14132
14133 print_symbol ((int) maxlen, (const char *) p);
14134 p += strnlen ((char *) p, maxlen) + 1;
14135 }
14136 else
14137 {
14138 printf (_("<corrupt>"));
14139 p = (unsigned char *) end;
14140 }
071436c6 14141 printf ("\"\n");
13761a11
NC		 14142 }
14143 else
14144 {
14145 val = read_uleb128 (p, &len, end);
14146 p += len;
14147 printf ("%d (0x%x)\n", val, val);
14148 }
14149 break;
14150 }
14151
4082ef84 14152 assert (p <= end);
13761a11
NC		 14153 return p;
14154}
14155
11c1ff18 14156static int
60bca95a
NC		 14157process_attributes (FILE * file,
14158 const char * public_name,
104d59d1 14159 unsigned int proc_type,
f6f0e17b
NC		 14160 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14161 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 14162{
2cf0635d 14163 Elf_Internal_Shdr * sect;
11c1ff18
PB		 14164 unsigned i;
14165
14166 /* Find the section header so that we get the size. */
14167 for (i = 0, sect = section_headers;
14168 i < elf_header.e_shnum;
14169 i++, sect++)
14170 {
071436c6
NC		 14171 unsigned char * contents;
14172 unsigned char * p;
14173
104d59d1 14174 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 14175 continue;
14176
3f5e193b
NC		 14177 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14178 sect->sh_size, _("attributes"));
60bca95a 14179 if (contents == NULL)
11c1ff18 14180 continue;
60bca95a 14181
11c1ff18
PB		 14182 p = contents;
14183 if (*p == 'A')
14184 {
071436c6
NC		 14185 bfd_vma section_len;
14186
14187 section_len = sect->sh_size - 1;
11c1ff18 14188 p++;
60bca95a 14189
071436c6 14190 while (section_len > 0)
11c1ff18 14191 {
071436c6 14192 bfd_vma attr_len;
e9847026 14193 unsigned int namelen;
11c1ff18 14194 bfd_boolean public_section;
104d59d1 14195 bfd_boolean gnu_section;
11c1ff18 14196
071436c6 14197 if (section_len <= 4)
e0a31db1
NC		 14198 {
14199 error (_("Tag section ends prematurely\n"));
14200 break;
14201 }
071436c6 14202 attr_len = byte_get (p, 4);
11c1ff18 14203 p += 4;
60bca95a 14204
071436c6 14205 if (attr_len > section_len)
11c1ff18 14206 {
071436c6
NC		 14207 error (_("Bad attribute length (%u > %u)\n"),
14208 (unsigned) attr_len, (unsigned) section_len);
14209 attr_len = section_len;
11c1ff18 14210 }
74e1a04b 14211 /* PR 17531: file: 001-101425-0.004 */
071436c6 14212 else if (attr_len < 5)
74e1a04b 14213 {
071436c6 14214 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 14215 break;
14216 }
e9847026 14217
071436c6
NC		 14218 section_len -= attr_len;
14219 attr_len -= 4;
14220
14221 namelen = strnlen ((char *) p, attr_len) + 1;
14222 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 14223 {
14224 error (_("Corrupt attribute section name\n"));
14225 break;
14226 }
14227
071436c6
NC		 14228 printf (_("Attribute Section: "));
14229 print_symbol (INT_MAX, (const char *) p);
14230 putchar ('\n');
60bca95a
NC		 14231
14232 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 14233 public_section = TRUE;
14234 else
14235 public_section = FALSE;
60bca95a
NC		 14236
14237 if (streq ((char *) p, "gnu"))
104d59d1
JM		 14238 gnu_section = TRUE;
14239 else
14240 gnu_section = FALSE;
60bca95a 14241
11c1ff18 14242 p += namelen;
071436c6 14243 attr_len -= namelen;
e0a31db1 14244
071436c6 14245 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 14246 {
e0a31db1 14247 int tag;
11c1ff18
PB		 14248 int val;
14249 bfd_vma size;
071436c6 14250 unsigned char * end;
60bca95a 14251
e0a31db1 14252 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 14253 if (attr_len < 6)
e0a31db1
NC		 14254 {
14255 error (_("Unused bytes at end of section\n"));
14256 section_len = 0;
14257 break;
14258 }
14259
14260 tag = *(p++);
11c1ff18 14261 size = byte_get (p, 4);
071436c6 14262 if (size > attr_len)
11c1ff18 14263 {
e9847026 14264 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 14265 (unsigned) size, (unsigned) attr_len);
14266 size = attr_len;
11c1ff18 14267 }
e0a31db1
NC		 14268 /* PR binutils/17531: Safe handling of corrupt files. */
14269 if (size < 6)
14270 {
14271 error (_("Bad subsection length (%u < 6)\n"),
14272 (unsigned) size);
14273 section_len = 0;
14274 break;
14275 }
60bca95a 14276
071436c6 14277 attr_len -= size;
11c1ff18 14278 end = p + size - 1;
071436c6 14279 assert (end <= contents + sect->sh_size);
11c1ff18 14280 p += 4;
60bca95a 14281
11c1ff18
PB		 14282 switch (tag)
14283 {
14284 case 1:
2b692964 14285 printf (_("File Attributes\n"));
11c1ff18
PB		 14286 break;
14287 case 2:
2b692964 14288 printf (_("Section Attributes:"));
11c1ff18
PB		 14289 goto do_numlist;
14290 case 3:
2b692964 14291 printf (_("Symbol Attributes:"));
1a0670f3 14292 /* Fall through. */
11c1ff18
PB		 14293 do_numlist:
14294 for (;;)
14295 {
91d6fa6a 14296 unsigned int j;
60bca95a 14297
f6f0e17b 14298 val = read_uleb128 (p, &j, end);
91d6fa6a 14299 p += j;
11c1ff18
PB		 14300 if (val == 0)
14301 break;
14302 printf (" %d", val);
14303 }
14304 printf ("\n");
14305 break;
14306 default:
2b692964 14307 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 14308 public_section = FALSE;
14309 break;
14310 }
60bca95a 14311
071436c6 14312 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 14313 {
14314 while (p < end)
f6f0e17b 14315 p = display_pub_attribute (p, end);
071436c6 14316 assert (p <= end);
104d59d1 14317 }
071436c6 14318 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 14319 {
14320 while (p < end)
14321 p = display_gnu_attribute (p,
f6f0e17b
NC		 14322 display_proc_gnu_attribute,
14323 end);
071436c6 14324 assert (p <= end);
11c1ff18 14325 }
071436c6 14326 else if (p < end)
11c1ff18 14327 {
071436c6 14328 printf (_(" Unknown attribute:\n"));
f6f0e17b 14329 display_raw_attribute (p, end);
11c1ff18
PB		 14330 p = end;
14331 }
071436c6
NC		 14332 else
14333 attr_len = 0;
11c1ff18
PB		 14334 }
14335 }
14336 }
14337 else
e9847026 14338 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 14339
60bca95a 14340 free (contents);
11c1ff18
PB		 14341 }
14342 return 1;
14343}
14344
104d59d1 14345static int
2cf0635d 14346process_arm_specific (FILE * file)
104d59d1
JM		 14347{
14348 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
14349 display_arm_attribute, NULL);
14350}
14351
34c8bcba 14352static int
2cf0635d 14353process_power_specific (FILE * file)
34c8bcba
JM		 14354{
14355 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14356 display_power_gnu_attribute);
14357}
14358
643f7afb
AK		 14359static int
14360process_s390_specific (FILE * file)
14361{
14362 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14363 display_s390_gnu_attribute);
14364}
14365
9e8c70f9
DM		 14366static int
14367process_sparc_specific (FILE * file)
14368{
14369 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14370 display_sparc_gnu_attribute);
14371}
14372
59e6276b
JM		 14373static int
14374process_tic6x_specific (FILE * file)
14375{
14376 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
14377 display_tic6x_attribute, NULL);
14378}
14379
13761a11
NC		 14380static int
14381process_msp430x_specific (FILE * file)
14382{
14383 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
14384 display_msp430x_attribute, NULL);
14385}
14386
ccb4c951
RS		 14387/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14388 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 14389 and return the VMA of the next entry, or -1 if there was a problem.
14390 Does not read from DATA_END or beyond. */
ccb4c951
RS		 14391
14392static bfd_vma
82b1b41b
NC		 14393print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14394 unsigned char * data_end)
ccb4c951
RS		 14395{
14396 printf (" ");
14397 print_vma (addr, LONG_HEX);
14398 printf (" ");
14399 if (addr < pltgot + 0xfff0)
14400 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14401 else
14402 printf ("%10s", "");
14403 printf (" ");
14404 if (data == NULL)
2b692964 14405 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14406 else
14407 {
14408 bfd_vma entry;
82b1b41b 14409 unsigned char * from = data + addr - pltgot;
ccb4c951 14410
82b1b41b
NC		 14411 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14412 {
14413 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14414 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14415 return (bfd_vma) -1;
14416 }
14417 else
14418 {
14419 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14420 print_vma (entry, LONG_HEX);
14421 }
ccb4c951
RS		 14422 }
14423 return addr + (is_32bit_elf ? 4 : 8);
14424}
14425
861fb55a
DJ		 14426/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14427 PLTGOT. Print the Address and Initial fields of an entry at VMA
14428 ADDR and return the VMA of the next entry. */
14429
14430static bfd_vma
2cf0635d 14431print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14432{
14433 printf (" ");
14434 print_vma (addr, LONG_HEX);
14435 printf (" ");
14436 if (data == NULL)
2b692964 14437 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14438 else
14439 {
14440 bfd_vma entry;
14441
14442 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14443 print_vma (entry, LONG_HEX);
14444 }
14445 return addr + (is_32bit_elf ? 4 : 8);
14446}
14447
351cdf24
MF		 14448static void
14449print_mips_ases (unsigned int mask)
14450{
14451 if (mask & AFL_ASE_DSP)
14452 fputs ("\n\tDSP ASE", stdout);
14453 if (mask & AFL_ASE_DSPR2)
14454 fputs ("\n\tDSP R2 ASE", stdout);
8f4f9071
MF		 14455 if (mask & AFL_ASE_DSPR3)
14456 fputs ("\n\tDSP R3 ASE", stdout);
351cdf24
MF		 14457 if (mask & AFL_ASE_EVA)
14458 fputs ("\n\tEnhanced VA Scheme", stdout);
14459 if (mask & AFL_ASE_MCU)
14460 fputs ("\n\tMCU (MicroController) ASE", stdout);
14461 if (mask & AFL_ASE_MDMX)
14462 fputs ("\n\tMDMX ASE", stdout);
14463 if (mask & AFL_ASE_MIPS3D)
14464 fputs ("\n\tMIPS-3D ASE", stdout);
14465 if (mask & AFL_ASE_MT)
14466 fputs ("\n\tMT ASE", stdout);
14467 if (mask & AFL_ASE_SMARTMIPS)
14468 fputs ("\n\tSmartMIPS ASE", stdout);
14469 if (mask & AFL_ASE_VIRT)
14470 fputs ("\n\tVZ ASE", stdout);
14471 if (mask & AFL_ASE_MSA)
14472 fputs ("\n\tMSA ASE", stdout);
14473 if (mask & AFL_ASE_MIPS16)
14474 fputs ("\n\tMIPS16 ASE", stdout);
14475 if (mask & AFL_ASE_MICROMIPS)
14476 fputs ("\n\tMICROMIPS ASE", stdout);
14477 if (mask & AFL_ASE_XPA)
14478 fputs ("\n\tXPA ASE", stdout);
14479 if (mask == 0)
14480 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14481 else if ((mask & ~AFL_ASE_MASK) != 0)
14482 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14483}
14484
14485static void
14486print_mips_isa_ext (unsigned int isa_ext)
14487{
14488 switch (isa_ext)
14489 {
14490 case 0:
14491 fputs (_("None"), stdout);
14492 break;
14493 case AFL_EXT_XLR:
14494 fputs ("RMI XLR", stdout);
14495 break;
2c629856
N		 14496 case AFL_EXT_OCTEON3:
14497 fputs ("Cavium Networks Octeon3", stdout);
14498 break;
351cdf24
MF		 14499 case AFL_EXT_OCTEON2:
14500 fputs ("Cavium Networks Octeon2", stdout);
14501 break;
14502 case AFL_EXT_OCTEONP:
14503 fputs ("Cavium Networks OcteonP", stdout);
14504 break;
14505 case AFL_EXT_LOONGSON_3A:
14506 fputs ("Loongson 3A", stdout);
14507 break;
14508 case AFL_EXT_OCTEON:
14509 fputs ("Cavium Networks Octeon", stdout);
14510 break;
14511 case AFL_EXT_5900:
14512 fputs ("Toshiba R5900", stdout);
14513 break;
14514 case AFL_EXT_4650:
14515 fputs ("MIPS R4650", stdout);
14516 break;
14517 case AFL_EXT_4010:
14518 fputs ("LSI R4010", stdout);
14519 break;
14520 case AFL_EXT_4100:
14521 fputs ("NEC VR4100", stdout);
14522 break;
14523 case AFL_EXT_3900:
14524 fputs ("Toshiba R3900", stdout);
14525 break;
14526 case AFL_EXT_10000:
14527 fputs ("MIPS R10000", stdout);
14528 break;
14529 case AFL_EXT_SB1:
14530 fputs ("Broadcom SB-1", stdout);
14531 break;
14532 case AFL_EXT_4111:
14533 fputs ("NEC VR4111/VR4181", stdout);
14534 break;
14535 case AFL_EXT_4120:
14536 fputs ("NEC VR4120", stdout);
14537 break;
14538 case AFL_EXT_5400:
14539 fputs ("NEC VR5400", stdout);
14540 break;
14541 case AFL_EXT_5500:
14542 fputs ("NEC VR5500", stdout);
14543 break;
14544 case AFL_EXT_LOONGSON_2E:
14545 fputs ("ST Microelectronics Loongson 2E", stdout);
14546 break;
14547 case AFL_EXT_LOONGSON_2F:
14548 fputs ("ST Microelectronics Loongson 2F", stdout);
14549 break;
14550 default:
00ac7aa0 14551 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14552 }
14553}
14554
14555static int
14556get_mips_reg_size (int reg_size)
14557{
14558 return (reg_size == AFL_REG_NONE) ? 0
14559 : (reg_size == AFL_REG_32) ? 32
14560 : (reg_size == AFL_REG_64) ? 64
14561 : (reg_size == AFL_REG_128) ? 128
14562 : -1;
14563}
14564
19e6b90e 14565static int
2cf0635d 14566process_mips_specific (FILE * file)
5b18a4bc 14567{
2cf0635d 14568 Elf_Internal_Dyn * entry;
351cdf24 14569 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14570 size_t liblist_offset = 0;
14571 size_t liblistno = 0;
14572 size_t conflictsno = 0;
14573 size_t options_offset = 0;
14574 size_t conflicts_offset = 0;
861fb55a
DJ		 14575 size_t pltrelsz = 0;
14576 size_t pltrel = 0;
ccb4c951 14577 bfd_vma pltgot = 0;
861fb55a
DJ		 14578 bfd_vma mips_pltgot = 0;
14579 bfd_vma jmprel = 0;
ccb4c951
RS		 14580 bfd_vma local_gotno = 0;
14581 bfd_vma gotsym = 0;
14582 bfd_vma symtabno = 0;
103f02d3 14583
2cf19d5c
JM		 14584 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14585 display_mips_gnu_attribute);
14586
351cdf24
MF		 14587 sect = find_section (".MIPS.abiflags");
14588
14589 if (sect != NULL)
14590 {
14591 Elf_External_ABIFlags_v0 *abiflags_ext;
14592 Elf_Internal_ABIFlags_v0 abiflags_in;
14593
14594 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14595 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14596 else
14597 {
14598 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14599 sect->sh_size, _("MIPS ABI Flags section"));
14600 if (abiflags_ext)
14601 {
14602 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14603 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14604 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14605 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14606 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14607 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14608 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14609 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14610 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14611 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14612 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14613
14614 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14615 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14616 if (abiflags_in.isa_rev > 1)
14617 printf ("r%d", abiflags_in.isa_rev);
14618 printf ("\nGPR size: %d",
14619 get_mips_reg_size (abiflags_in.gpr_size));
14620 printf ("\nCPR1 size: %d",
14621 get_mips_reg_size (abiflags_in.cpr1_size));
14622 printf ("\nCPR2 size: %d",
14623 get_mips_reg_size (abiflags_in.cpr2_size));
14624 fputs ("\nFP ABI: ", stdout);
14625 print_mips_fp_abi_value (abiflags_in.fp_abi);
14626 fputs ("ISA Extension: ", stdout);
14627 print_mips_isa_ext (abiflags_in.isa_ext);
14628 fputs ("\nASEs:", stdout);
14629 print_mips_ases (abiflags_in.ases);
14630 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14631 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14632 fputc ('\n', stdout);
14633 free (abiflags_ext);
14634 }
14635 }
14636 }
14637
19e6b90e
L		 14638 /* We have a lot of special sections. Thanks SGI! */
14639 if (dynamic_section == NULL)
14640 /* No information available. */
14641 return 0;
252b5132 14642
071436c6
NC		 14643 for (entry = dynamic_section;
14644 /* PR 17531 file: 012-50589-0.004. */
14645 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14646 ++entry)
252b5132
RH		 14647 switch (entry->d_tag)
14648 {
14649 case DT_MIPS_LIBLIST:
d93f0186
NC		 14650 liblist_offset
14651 = offset_from_vma (file, entry->d_un.d_val,
14652 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14653 break;
14654 case DT_MIPS_LIBLISTNO:
14655 liblistno = entry->d_un.d_val;
14656 break;
14657 case DT_MIPS_OPTIONS:
d93f0186 14658 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14659 break;
14660 case DT_MIPS_CONFLICT:
d93f0186
NC		 14661 conflicts_offset
14662 = offset_from_vma (file, entry->d_un.d_val,
14663 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14664 break;
14665 case DT_MIPS_CONFLICTNO:
14666 conflictsno = entry->d_un.d_val;
14667 break;
ccb4c951 14668 case DT_PLTGOT:
861fb55a
DJ		 14669 pltgot = entry->d_un.d_ptr;
14670 break;
ccb4c951
RS		 14671 case DT_MIPS_LOCAL_GOTNO:
14672 local_gotno = entry->d_un.d_val;
14673 break;
14674 case DT_MIPS_GOTSYM:
14675 gotsym = entry->d_un.d_val;
14676 break;
14677 case DT_MIPS_SYMTABNO:
14678 symtabno = entry->d_un.d_val;
14679 break;
861fb55a
DJ		 14680 case DT_MIPS_PLTGOT:
14681 mips_pltgot = entry->d_un.d_ptr;
14682 break;
14683 case DT_PLTREL:
14684 pltrel = entry->d_un.d_val;
14685 break;
14686 case DT_PLTRELSZ:
14687 pltrelsz = entry->d_un.d_val;
14688 break;
14689 case DT_JMPREL:
14690 jmprel = entry->d_un.d_ptr;
14691 break;
252b5132
RH		 14692 default:
14693 break;
14694 }
14695
14696 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14697 {
2cf0635d 14698 Elf32_External_Lib * elib;
252b5132
RH		 14699 size_t cnt;
14700
3f5e193b
NC		 14701 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14702 liblistno,
14703 sizeof (Elf32_External_Lib),
9cf03b7e 14704 _("liblist section data"));
a6e9f9df 14705 if (elib)
252b5132 14706 {
2b692964 14707 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14708 (unsigned long) liblistno);
2b692964 14709 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14710 stdout);
14711
14712 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14713 {
a6e9f9df 14714 Elf32_Lib liblist;
91d6fa6a 14715 time_t atime;
d5b07ef4 14716 char timebuf[128];
2cf0635d 14717 struct tm * tmp;
a6e9f9df
AM		 14718
14719 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14720 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14721 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14722 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14723 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14724
91d6fa6a 14725 tmp = gmtime (&atime);
e9e44622
JJ		 14726 snprintf (timebuf, sizeof (timebuf),
14727 "%04u-%02u-%02uT%02u:%02u:%02u",
14728 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14729 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14730
31104126 14731 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14732 if (VALID_DYNAMIC_NAME (liblist.l_name))
14733 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14734 else
2b692964 14735 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14736 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14737 liblist.l_version);
a6e9f9df
AM		 14738
14739 if (liblist.l_flags == 0)
2b692964 14740 puts (_(" NONE"));
a6e9f9df
AM		 14741 else
14742 {
14743 static const struct
252b5132 14744 {
2cf0635d 14745 const char * name;
a6e9f9df 14746 int bit;
252b5132 14747 }
a6e9f9df
AM		 14748 l_flags_vals[] =
14749 {
14750 { " EXACT_MATCH", LL_EXACT_MATCH },
14751 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14752 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14753 { " EXPORTS", LL_EXPORTS },
14754 { " DELAY_LOAD", LL_DELAY_LOAD },
14755 { " DELTA", LL_DELTA }
14756 };
14757 int flags = liblist.l_flags;
14758 size_t fcnt;
14759
60bca95a 14760 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14761 if ((flags & l_flags_vals[fcnt].bit) != 0)
14762 {
14763 fputs (l_flags_vals[fcnt].name, stdout);
14764 flags ^= l_flags_vals[fcnt].bit;
14765 }
14766 if (flags != 0)
14767 printf (" %#x", (unsigned int) flags);
252b5132 14768
a6e9f9df
AM		 14769 puts ("");
14770 }
252b5132 14771 }
252b5132 14772
a6e9f9df
AM		 14773 free (elib);
14774 }
252b5132
RH		 14775 }
14776
14777 if (options_offset != 0)
14778 {
2cf0635d 14779 Elf_External_Options * eopt;
2cf0635d
NC		 14780 Elf_Internal_Options * iopt;
14781 Elf_Internal_Options * option;
252b5132
RH		 14782 size_t offset;
14783 int cnt;
351cdf24 14784 sect = section_headers;
252b5132
RH		 14785
14786 /* Find the section header so that we get the size. */
071436c6 14787 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14788 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14789 if (sect == NULL)
14790 {
14791 error (_("No MIPS_OPTIONS header found\n"));
14792 return 0;
14793 }
252b5132 14794
3f5e193b
NC		 14795 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14796 sect->sh_size, _("options"));
a6e9f9df 14797 if (eopt)
252b5132 14798 {
3f5e193b
NC		 14799 iopt = (Elf_Internal_Options *)
14800 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14801 if (iopt == NULL)
14802 {
fb324ee9 14803 error (_("Out of memory allocating space for MIPS options\n"));
a6e9f9df
AM		 14804 return 0;
14805 }
76da6bbe 14806
a6e9f9df
AM		 14807 offset = cnt = 0;
14808 option = iopt;
252b5132 14809
82b1b41b 14810 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14811 {
2cf0635d 14812 Elf_External_Options * eoption;
252b5132 14813
a6e9f9df 14814 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14815
a6e9f9df
AM		 14816 option->kind = BYTE_GET (eoption->kind);
14817 option->size = BYTE_GET (eoption->size);
14818 option->section = BYTE_GET (eoption->section);
14819 option->info = BYTE_GET (eoption->info);
76da6bbe 14820
82b1b41b
NC		 14821 /* PR 17531: file: ffa0fa3b. */
14822 if (option->size < sizeof (* eopt)
14823 || offset + option->size > sect->sh_size)
14824 {
55325047
NC		 14825 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14826 return 0;
82b1b41b 14827 }
a6e9f9df 14828 offset += option->size;
14ae95f2 14829
a6e9f9df
AM		 14830 ++option;
14831 ++cnt;
14832 }
252b5132 14833
a6e9f9df 14834 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14835 printable_section_name (sect), cnt);
76da6bbe 14836
a6e9f9df 14837 option = iopt;
82b1b41b 14838 offset = 0;
252b5132 14839
a6e9f9df 14840 while (cnt-- > 0)
252b5132 14841 {
a6e9f9df
AM		 14842 size_t len;
14843
14844 switch (option->kind)
252b5132 14845 {
a6e9f9df
AM		 14846 case ODK_NULL:
14847 /* This shouldn't happen. */
14848 printf (" NULL %d %lx", option->section, option->info);
14849 break;
14850 case ODK_REGINFO:
14851 printf (" REGINFO ");
14852 if (elf_header.e_machine == EM_MIPS)
14853 {
14854 /* 32bit form. */
2cf0635d 14855 Elf32_External_RegInfo * ereg;
b34976b6 14856 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14857
14858 ereg = (Elf32_External_RegInfo *) (option + 1);
14859 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14860 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14861 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14862 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14863 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14864 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14865
14866 printf ("GPR %08lx GP 0x%lx\n",
14867 reginfo.ri_gprmask,
14868 (unsigned long) reginfo.ri_gp_value);
14869 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14870 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14871 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14872 }
14873 else
14874 {
14875 /* 64 bit form. */
2cf0635d 14876 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14877 Elf64_Internal_RegInfo reginfo;
14878
14879 ereg = (Elf64_External_RegInfo *) (option + 1);
14880 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14881 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14882 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14883 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14884 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14885 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14886
14887 printf ("GPR %08lx GP 0x",
14888 reginfo.ri_gprmask);
14889 printf_vma (reginfo.ri_gp_value);
14890 printf ("\n");
14891
14892 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14893 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14894 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14895 }
14896 ++option;
14897 continue;
14898 case ODK_EXCEPTIONS:
14899 fputs (" EXCEPTIONS fpe_min(", stdout);
14900 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14901 fputs (") fpe_max(", stdout);
14902 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14903 fputs (")", stdout);
14904
14905 if (option->info & OEX_PAGE0)
14906 fputs (" PAGE0", stdout);
14907 if (option->info & OEX_SMM)
14908 fputs (" SMM", stdout);
14909 if (option->info & OEX_FPDBUG)
14910 fputs (" FPDBUG", stdout);
14911 if (option->info & OEX_DISMISS)
14912 fputs (" DISMISS", stdout);
14913 break;
14914 case ODK_PAD:
14915 fputs (" PAD ", stdout);
14916 if (option->info & OPAD_PREFIX)
14917 fputs (" PREFIX", stdout);
14918 if (option->info & OPAD_POSTFIX)
14919 fputs (" POSTFIX", stdout);
14920 if (option->info & OPAD_SYMBOL)
14921 fputs (" SYMBOL", stdout);
14922 break;
14923 case ODK_HWPATCH:
14924 fputs (" HWPATCH ", stdout);
14925 if (option->info & OHW_R4KEOP)
14926 fputs (" R4KEOP", stdout);
14927 if (option->info & OHW_R8KPFETCH)
14928 fputs (" R8KPFETCH", stdout);
14929 if (option->info & OHW_R5KEOP)
14930 fputs (" R5KEOP", stdout);
14931 if (option->info & OHW_R5KCVTL)
14932 fputs (" R5KCVTL", stdout);
14933 break;
14934 case ODK_FILL:
14935 fputs (" FILL ", stdout);
14936 /* XXX Print content of info word? */
14937 break;
14938 case ODK_TAGS:
14939 fputs (" TAGS ", stdout);
14940 /* XXX Print content of info word? */
14941 break;
14942 case ODK_HWAND:
14943 fputs (" HWAND ", stdout);
14944 if (option->info & OHWA0_R4KEOP_CHECKED)
14945 fputs (" R4KEOP_CHECKED", stdout);
14946 if (option->info & OHWA0_R4KEOP_CLEAN)
14947 fputs (" R4KEOP_CLEAN", stdout);
14948 break;
14949 case ODK_HWOR:
14950 fputs (" HWOR ", stdout);
14951 if (option->info & OHWA0_R4KEOP_CHECKED)
14952 fputs (" R4KEOP_CHECKED", stdout);
14953 if (option->info & OHWA0_R4KEOP_CLEAN)
14954 fputs (" R4KEOP_CLEAN", stdout);
14955 break;
14956 case ODK_GP_GROUP:
14957 printf (" GP_GROUP %#06lx self-contained %#06lx",
14958 option->info & OGP_GROUP,
14959 (option->info & OGP_SELF) >> 16);
14960 break;
14961 case ODK_IDENT:
14962 printf (" IDENT %#06lx self-contained %#06lx",
14963 option->info & OGP_GROUP,
14964 (option->info & OGP_SELF) >> 16);
14965 break;
14966 default:
14967 /* This shouldn't happen. */
14968 printf (" %3d ??? %d %lx",
14969 option->kind, option->section, option->info);
14970 break;
252b5132 14971 }
a6e9f9df 14972
2cf0635d 14973 len = sizeof (* eopt);
a6e9f9df 14974 while (len < option->size)
82b1b41b 14975 {
7e27a9d5 14976 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14977
82b1b41b
NC		 14978 if (ISPRINT (datum))
14979 printf ("%c", datum);
14980 else
14981 printf ("\\%03o", datum);
14982 len ++;
14983 }
a6e9f9df 14984 fputs ("\n", stdout);
82b1b41b
NC		 14985
14986 offset += option->size;
252b5132 14987 ++option;
252b5132
RH		 14988 }
14989
a6e9f9df 14990 free (eopt);
252b5132 14991 }
252b5132
RH		 14992 }
14993
14994 if (conflicts_offset != 0 && conflictsno != 0)
14995 {
2cf0635d 14996 Elf32_Conflict * iconf;
252b5132
RH		 14997 size_t cnt;
14998
14999 if (dynamic_symbols == NULL)
15000 {
591a748a 15001 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 15002 return 0;
15003 }
15004
3f5e193b 15005 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 15006 if (iconf == NULL)
15007 {
8b73c356 15008 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 15009 return 0;
15010 }
15011
9ea033b2 15012 if (is_32bit_elf)
252b5132 15013 {
2cf0635d 15014 Elf32_External_Conflict * econf32;
a6e9f9df 15015
3f5e193b
NC		 15016 econf32 = (Elf32_External_Conflict *)
15017 get_data (NULL, file, conflicts_offset, conflictsno,
15018 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 15019 if (!econf32)
15020 return 0;
252b5132
RH		 15021
15022 for (cnt = 0; cnt < conflictsno; ++cnt)
15023 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 15024
15025 free (econf32);
252b5132
RH		 15026 }
15027 else
15028 {
2cf0635d 15029 Elf64_External_Conflict * econf64;
a6e9f9df 15030
3f5e193b
NC		 15031 econf64 = (Elf64_External_Conflict *)
15032 get_data (NULL, file, conflicts_offset, conflictsno,
15033 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 15034 if (!econf64)
15035 return 0;
252b5132
RH		 15036
15037 for (cnt = 0; cnt < conflictsno; ++cnt)
15038 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 15039
15040 free (econf64);
252b5132
RH		 15041 }
15042
c7e7ca54
NC		 15043 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15044 (unsigned long) conflictsno);
252b5132
RH		 15045 puts (_(" Num: Index Value Name"));
15046
15047 for (cnt = 0; cnt < conflictsno; ++cnt)
15048 {
b34976b6 15049 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 15050
15051 if (iconf[cnt] >= num_dynamic_syms)
15052 printf (_("<corrupt symbol index>"));
d79b3d50 15053 else
e0a31db1
NC		 15054 {
15055 Elf_Internal_Sym * psym;
15056
15057 psym = & dynamic_symbols[iconf[cnt]];
15058 print_vma (psym->st_value, FULL_HEX);
15059 putchar (' ');
15060 if (VALID_DYNAMIC_NAME (psym->st_name))
15061 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15062 else
15063 printf (_("<corrupt: %14ld>"), psym->st_name);
15064 }
31104126 15065 putchar ('\n');
252b5132
RH		 15066 }
15067
252b5132
RH		 15068 free (iconf);
15069 }
15070
ccb4c951
RS		 15071 if (pltgot != 0 && local_gotno != 0)
15072 {
91d6fa6a 15073 bfd_vma ent, local_end, global_end;
bbeee7ea 15074 size_t i, offset;
2cf0635d 15075 unsigned char * data;
82b1b41b 15076 unsigned char * data_end;
bbeee7ea 15077 int addr_size;
ccb4c951 15078
91d6fa6a 15079 ent = pltgot;
ccb4c951
RS		 15080 addr_size = (is_32bit_elf ? 4 : 8);
15081 local_end = pltgot + local_gotno * addr_size;
ccb4c951 15082
74e1a04b
NC		 15083 /* PR binutils/17533 file: 012-111227-0.004 */
15084 if (symtabno < gotsym)
15085 {
15086 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 15087 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 15088 return 0;
15089 }
82b1b41b 15090
74e1a04b 15091 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 15092 /* PR 17531: file: 54c91a34. */
15093 if (global_end < local_end)
15094 {
15095 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15096 return 0;
15097 }
948f632f 15098
ccb4c951 15099 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 15100 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 15101 global_end - pltgot, 1,
15102 _("Global Offset Table data"));
59245841
NC		 15103 if (data == NULL)
15104 return 0;
82b1b41b 15105 data_end = data + (global_end - pltgot);
59245841 15106
ccb4c951
RS		 15107 printf (_("\nPrimary GOT:\n"));
15108 printf (_(" Canonical gp value: "));
15109 print_vma (pltgot + 0x7ff0, LONG_HEX);
15110 printf ("\n\n");
15111
15112 printf (_(" Reserved entries:\n"));
15113 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 15114 addr_size * 2, _("Address"), _("Access"),
15115 addr_size * 2, _("Initial"));
82b1b41b 15116 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15117 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 15118 if (ent == (bfd_vma) -1)
15119 goto got_print_fail;
ccb4c951 15120 if (data
91d6fa6a 15121 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 15122 >> (addr_size * 8 - 1)) != 0)
15123 {
82b1b41b 15124 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15125 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 15126 if (ent == (bfd_vma) -1)
15127 goto got_print_fail;
ccb4c951
RS		 15128 }
15129 printf ("\n");
15130
91d6fa6a 15131 if (ent < local_end)
ccb4c951
RS		 15132 {
15133 printf (_(" Local entries:\n"));
cc5914eb 15134 printf (" %*s %10s %*s\n",
2b692964
NC		 15135 addr_size * 2, _("Address"), _("Access"),
15136 addr_size * 2, _("Initial"));
91d6fa6a 15137 while (ent < local_end)
ccb4c951 15138 {
82b1b41b 15139 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15140 printf ("\n");
82b1b41b
NC		 15141 if (ent == (bfd_vma) -1)
15142 goto got_print_fail;
ccb4c951
RS		 15143 }
15144 printf ("\n");
15145 }
15146
15147 if (gotsym < symtabno)
15148 {
15149 int sym_width;
15150
15151 printf (_(" Global entries:\n"));
cc5914eb 15152 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 15153 addr_size * 2, _("Address"),
15154 _("Access"),
2b692964 15155 addr_size * 2, _("Initial"),
9cf03b7e
NC		 15156 addr_size * 2, _("Sym.Val."),
15157 _("Type"),
15158 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15159 _("Ndx"), _("Name"));
0b4362b0 15160
ccb4c951 15161 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 15162
ccb4c951
RS		 15163 for (i = gotsym; i < symtabno; i++)
15164 {
82b1b41b 15165 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15166 printf (" ");
e0a31db1
NC		 15167
15168 if (dynamic_symbols == NULL)
15169 printf (_("<no dynamic symbols>"));
15170 else if (i < num_dynamic_syms)
15171 {
15172 Elf_Internal_Sym * psym = dynamic_symbols + i;
15173
15174 print_vma (psym->st_value, LONG_HEX);
15175 printf (" %-7s %3s ",
15176 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15177 get_symbol_index_type (psym->st_shndx));
15178
15179 if (VALID_DYNAMIC_NAME (psym->st_name))
15180 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15181 else
15182 printf (_("<corrupt: %14ld>"), psym->st_name);
15183 }
ccb4c951 15184 else
7fc5ac57
JBG		 15185 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15186 (unsigned long) i);
e0a31db1 15187
ccb4c951 15188 printf ("\n");
82b1b41b
NC		 15189 if (ent == (bfd_vma) -1)
15190 break;
ccb4c951
RS		 15191 }
15192 printf ("\n");
15193 }
15194
82b1b41b 15195 got_print_fail:
ccb4c951
RS		 15196 if (data)
15197 free (data);
15198 }
15199
861fb55a
DJ		 15200 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15201 {
91d6fa6a 15202 bfd_vma ent, end;
861fb55a
DJ		 15203 size_t offset, rel_offset;
15204 unsigned long count, i;
2cf0635d 15205 unsigned char * data;
861fb55a 15206 int addr_size, sym_width;
2cf0635d 15207 Elf_Internal_Rela * rels;
861fb55a
DJ		 15208
15209 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15210 if (pltrel == DT_RELA)
15211 {
15212 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15213 return 0;
15214 }
15215 else
15216 {
15217 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15218 return 0;
15219 }
15220
91d6fa6a 15221 ent = mips_pltgot;
861fb55a
DJ		 15222 addr_size = (is_32bit_elf ? 4 : 8);
15223 end = mips_pltgot + (2 + count) * addr_size;
15224
15225 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 15226 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 15227 1, _("Procedure Linkage Table data"));
59245841
NC		 15228 if (data == NULL)
15229 return 0;
15230
9cf03b7e 15231 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 15232 printf (_(" Reserved entries:\n"));
15233 printf (_(" %*s %*s Purpose\n"),
2b692964 15234 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 15235 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15236 printf (_(" PLT lazy resolver\n"));
91d6fa6a 15237 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15238 printf (_(" Module pointer\n"));
861fb55a
DJ		 15239 printf ("\n");
15240
15241 printf (_(" Entries:\n"));
cc5914eb 15242 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 15243 addr_size * 2, _("Address"),
15244 addr_size * 2, _("Initial"),
15245 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 15246 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15247 for (i = 0; i < count; i++)
15248 {
df97ab2a 15249 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 15250
91d6fa6a 15251 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 15252 printf (" ");
e0a31db1 15253
df97ab2a
MF		 15254 if (idx >= num_dynamic_syms)
15255 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 15256 else
e0a31db1 15257 {
df97ab2a 15258 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 15259
15260 print_vma (psym->st_value, LONG_HEX);
15261 printf (" %-7s %3s ",
15262 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15263 get_symbol_index_type (psym->st_shndx));
15264 if (VALID_DYNAMIC_NAME (psym->st_name))
15265 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15266 else
15267 printf (_("<corrupt: %14ld>"), psym->st_name);
15268 }
861fb55a
DJ		 15269 printf ("\n");
15270 }
15271 printf ("\n");
15272
15273 if (data)
15274 free (data);
15275 free (rels);
15276 }
15277
252b5132
RH		 15278 return 1;
15279}
15280
35c08157
KLC		 15281static int
15282process_nds32_specific (FILE * file)
15283{
15284 Elf_Internal_Shdr *sect = NULL;
15285
15286 sect = find_section (".nds32_e_flags");
15287 if (sect != NULL)
15288 {
15289 unsigned int *flag;
15290
15291 printf ("\nNDS32 elf flags section:\n");
15292 flag = get_data (NULL, file, sect->sh_offset, 1,
15293 sect->sh_size, _("NDS32 elf flags section"));
15294
15295 switch ((*flag) & 0x3)
15296 {
15297 case 0:
15298 printf ("(VEC_SIZE):\tNo entry.\n");
15299 break;
15300 case 1:
15301 printf ("(VEC_SIZE):\t4 bytes\n");
15302 break;
15303 case 2:
15304 printf ("(VEC_SIZE):\t16 bytes\n");
15305 break;
15306 case 3:
15307 printf ("(VEC_SIZE):\treserved\n");
15308 break;
15309 }
15310 }
15311
15312 return TRUE;
15313}
15314
047b2264 15315static int
2cf0635d 15316process_gnu_liblist (FILE * file)
047b2264 15317{
2cf0635d
NC		 15318 Elf_Internal_Shdr * section;
15319 Elf_Internal_Shdr * string_sec;
15320 Elf32_External_Lib * elib;
15321 char * strtab;
c256ffe7 15322 size_t strtab_size;
047b2264
JJ		 15323 size_t cnt;
15324 unsigned i;
15325
15326 if (! do_arch)
15327 return 0;
15328
15329 for (i = 0, section = section_headers;
15330 i < elf_header.e_shnum;
b34976b6 15331 i++, section++)
047b2264
JJ		 15332 {
15333 switch (section->sh_type)
15334 {
15335 case SHT_GNU_LIBLIST:
4fbb74a6 15336 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 15337 break;
15338
3f5e193b
NC		 15339 elib = (Elf32_External_Lib *)
15340 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 15341 _("liblist section data"));
047b2264
JJ		 15342
15343 if (elib == NULL)
15344 break;
4fbb74a6 15345 string_sec = section_headers + section->sh_link;
047b2264 15346
3f5e193b
NC		 15347 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15348 string_sec->sh_size,
15349 _("liblist string table"));
047b2264
JJ		 15350 if (strtab == NULL
15351 || section->sh_entsize != sizeof (Elf32_External_Lib))
15352 {
15353 free (elib);
2842702f 15354 free (strtab);
047b2264
JJ		 15355 break;
15356 }
59245841 15357 strtab_size = string_sec->sh_size;
047b2264
JJ		 15358
15359 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 15360 printable_section_name (section),
0af1713e 15361 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 15362
2b692964 15363 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 15364
15365 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15366 ++cnt)
15367 {
15368 Elf32_Lib liblist;
91d6fa6a 15369 time_t atime;
d5b07ef4 15370 char timebuf[128];
2cf0635d 15371 struct tm * tmp;
047b2264
JJ		 15372
15373 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 15374 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 15375 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15376 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15377 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15378
91d6fa6a 15379 tmp = gmtime (&atime);
e9e44622
JJ		 15380 snprintf (timebuf, sizeof (timebuf),
15381 "%04u-%02u-%02uT%02u:%02u:%02u",
15382 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15383 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 15384
15385 printf ("%3lu: ", (unsigned long) cnt);
15386 if (do_wide)
c256ffe7 15387 printf ("%-20s", liblist.l_name < strtab_size
2b692964 15388 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 15389 else
c256ffe7 15390 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 15391 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 15392 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15393 liblist.l_version, liblist.l_flags);
15394 }
15395
15396 free (elib);
2842702f 15397 free (strtab);
047b2264
JJ		 15398 }
15399 }
15400
15401 return 1;
15402}
15403
9437c45b 15404static const char *
d3ba0551 15405get_note_type (unsigned e_type)
779fe533
NC		 15406{
15407 static char buff[64];
103f02d3 15408
1ec5cd37
NC		 15409 if (elf_header.e_type == ET_CORE)
15410 switch (e_type)
15411 {
57346661 15412 case NT_AUXV:
1ec5cd37 15413 return _("NT_AUXV (auxiliary vector)");
57346661 15414 case NT_PRSTATUS:
1ec5cd37 15415 return _("NT_PRSTATUS (prstatus structure)");
57346661 15416 case NT_FPREGSET:
1ec5cd37 15417 return _("NT_FPREGSET (floating point registers)");
57346661 15418 case NT_PRPSINFO:
1ec5cd37 15419 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15420 case NT_TASKSTRUCT:
1ec5cd37 15421 return _("NT_TASKSTRUCT (task structure)");
57346661 15422 case NT_PRXFPREG:
1ec5cd37 15423 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15424 case NT_PPC_VMX:
15425 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15426 case NT_PPC_VSX:
15427 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15428 case NT_386_TLS:
15429 return _("NT_386_TLS (x86 TLS information)");
15430 case NT_386_IOPERM:
15431 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15432 case NT_X86_XSTATE:
15433 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15434 case NT_S390_HIGH_GPRS:
15435 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15436 case NT_S390_TIMER:
15437 return _("NT_S390_TIMER (s390 timer register)");
15438 case NT_S390_TODCMP:
15439 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15440 case NT_S390_TODPREG:
15441 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15442 case NT_S390_CTRS:
15443 return _("NT_S390_CTRS (s390 control registers)");
15444 case NT_S390_PREFIX:
15445 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15446 case NT_S390_LAST_BREAK:
15447 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15448 case NT_S390_SYSTEM_CALL:
15449 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15450 case NT_S390_TDB:
15451 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15452 case NT_S390_VXRS_LOW:
15453 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15454 case NT_S390_VXRS_HIGH:
15455 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15456 case NT_ARM_VFP:
15457 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15458 case NT_ARM_TLS:
15459 return _("NT_ARM_TLS (AArch TLS registers)");
15460 case NT_ARM_HW_BREAK:
15461 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15462 case NT_ARM_HW_WATCH:
15463 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15464 case NT_PSTATUS:
1ec5cd37 15465 return _("NT_PSTATUS (pstatus structure)");
57346661 15466 case NT_FPREGS:
1ec5cd37 15467 return _("NT_FPREGS (floating point registers)");
57346661 15468 case NT_PSINFO:
1ec5cd37 15469 return _("NT_PSINFO (psinfo structure)");
57346661 15470 case NT_LWPSTATUS:
1ec5cd37 15471 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15472 case NT_LWPSINFO:
1ec5cd37 15473 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15474 case NT_WIN32PSTATUS:
1ec5cd37 15475 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15476 case NT_SIGINFO:
15477 return _("NT_SIGINFO (siginfo_t data)");
15478 case NT_FILE:
15479 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15480 default:
15481 break;
15482 }
15483 else
15484 switch (e_type)
15485 {
15486 case NT_VERSION:
15487 return _("NT_VERSION (version)");
15488 case NT_ARCH:
15489 return _("NT_ARCH (architecture)");
15490 default:
15491 break;
15492 }
15493
e9e44622 15494 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15495 return buff;
779fe533
NC		 15496}
15497
9ece1fa9
TT		 15498static int
15499print_core_note (Elf_Internal_Note *pnote)
15500{
15501 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15502 bfd_vma count, page_size;
15503 unsigned char *descdata, *filenames, *descend;
15504
15505 if (pnote->type != NT_FILE)
15506 return 1;
15507
15508#ifndef BFD64
15509 if (!is_32bit_elf)
15510 {
15511 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15512 /* Still "successful". */
15513 return 1;
15514 }
15515#endif
15516
15517 if (pnote->descsz < 2 * addr_size)
15518 {
15519 printf (_(" Malformed note - too short for header\n"));
15520 return 0;
15521 }
15522
15523 descdata = (unsigned char *) pnote->descdata;
15524 descend = descdata + pnote->descsz;
15525
15526 if (descdata[pnote->descsz - 1] != '\0')
15527 {
15528 printf (_(" Malformed note - does not end with \\0\n"));
15529 return 0;
15530 }
15531
15532 count = byte_get (descdata, addr_size);
15533 descdata += addr_size;
15534
15535 page_size = byte_get (descdata, addr_size);
15536 descdata += addr_size;
15537
15538 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15539 {
15540 printf (_(" Malformed note - too short for supplied file count\n"));
15541 return 0;
15542 }
15543
15544 printf (_(" Page size: "));
15545 print_vma (page_size, DEC);
15546 printf ("\n");
15547
15548 printf (_(" %*s%*s%*s\n"),
15549 (int) (2 + 2 * addr_size), _("Start"),
15550 (int) (4 + 2 * addr_size), _("End"),
15551 (int) (4 + 2 * addr_size), _("Page Offset"));
15552 filenames = descdata + count * 3 * addr_size;
595712bb 15553 while (count-- > 0)
9ece1fa9
TT		 15554 {
15555 bfd_vma start, end, file_ofs;
15556
15557 if (filenames == descend)
15558 {
15559 printf (_(" Malformed note - filenames end too early\n"));
15560 return 0;
15561 }
15562
15563 start = byte_get (descdata, addr_size);
15564 descdata += addr_size;
15565 end = byte_get (descdata, addr_size);
15566 descdata += addr_size;
15567 file_ofs = byte_get (descdata, addr_size);
15568 descdata += addr_size;
15569
15570 printf (" ");
15571 print_vma (start, FULL_HEX);
15572 printf (" ");
15573 print_vma (end, FULL_HEX);
15574 printf (" ");
15575 print_vma (file_ofs, FULL_HEX);
15576 printf ("\n %s\n", filenames);
15577
15578 filenames += 1 + strlen ((char *) filenames);
15579 }
15580
15581 return 1;
15582}
15583
1118d252
RM		 15584static const char *
15585get_gnu_elf_note_type (unsigned e_type)
15586{
1449284b 15587 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
1118d252
RM		 15588 switch (e_type)
15589 {
15590 case NT_GNU_ABI_TAG:
15591 return _("NT_GNU_ABI_TAG (ABI version tag)");
15592 case NT_GNU_HWCAP:
15593 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15594 case NT_GNU_BUILD_ID:
15595 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15596 case NT_GNU_GOLD_VERSION:
15597 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252 15598 default:
1449284b
NC		 15599 {
15600 static char buff[64];
1118d252 15601
1449284b
NC		 15602 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15603 return buff;
15604 }
15605 }
1118d252
RM		 15606}
15607
664f90a3
TT		 15608static int
15609print_gnu_note (Elf_Internal_Note *pnote)
15610{
1449284b 15611 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
664f90a3
TT		 15612 switch (pnote->type)
15613 {
15614 case NT_GNU_BUILD_ID:
15615 {
15616 unsigned long i;
15617
15618 printf (_(" Build ID: "));
15619 for (i = 0; i < pnote->descsz; ++i)
15620 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15621 printf ("\n");
664f90a3
TT		 15622 }
15623 break;
15624
15625 case NT_GNU_ABI_TAG:
15626 {
15627 unsigned long os, major, minor, subminor;
15628 const char *osname;
15629
3102e897
NC		 15630 /* PR 17531: file: 030-599401-0.004. */
15631 if (pnote->descsz < 16)
15632 {
15633 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15634 break;
15635 }
15636
664f90a3
TT		 15637 os = byte_get ((unsigned char *) pnote->descdata, 4);
15638 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15639 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15640 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15641
15642 switch (os)
15643 {
15644 case GNU_ABI_TAG_LINUX:
15645 osname = "Linux";
15646 break;
15647 case GNU_ABI_TAG_HURD:
15648 osname = "Hurd";
15649 break;
15650 case GNU_ABI_TAG_SOLARIS:
15651 osname = "Solaris";
15652 break;
15653 case GNU_ABI_TAG_FREEBSD:
15654 osname = "FreeBSD";
15655 break;
15656 case GNU_ABI_TAG_NETBSD:
15657 osname = "NetBSD";
15658 break;
14ae95f2
RM		 15659 case GNU_ABI_TAG_SYLLABLE:
15660 osname = "Syllable";
15661 break;
15662 case GNU_ABI_TAG_NACL:
15663 osname = "NaCl";
15664 break;
664f90a3
TT		 15665 default:
15666 osname = "Unknown";
15667 break;
15668 }
15669
15670 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15671 major, minor, subminor);
15672 }
15673 break;
926c5385
CC		 15674
15675 case NT_GNU_GOLD_VERSION:
15676 {
15677 unsigned long i;
15678
15679 printf (_(" Version: "));
15680 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15681 printf ("%c", pnote->descdata[i]);
15682 printf ("\n");
15683 }
15684 break;
1449284b
NC		 15685
15686 case NT_GNU_HWCAP:
15687 {
15688 unsigned long num_entries, mask;
15689
15690 /* Hardware capabilities information. Word 0 is the number of entries.
15691 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15692 is a series of entries, where each entry is a single byte followed
15693 by a nul terminated string. The byte gives the bit number to test
15694 if enabled in the bitmask. */
15695 printf (_(" Hardware Capabilities: "));
15696 if (pnote->descsz < 8)
15697 {
15698 printf (_("<corrupt GNU_HWCAP>\n"));
15699 break;
15700 }
15701 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
15702 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15703 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
15704 /* FIXME: Add code to display the entries... */
15705 }
15706 break;
15707
15708 default:
15709 /* Handle unrecognised types. An error message should have already been
15710 created by get_gnu_elf_note_type(), so all that we need to do is to
15711 display the data. */
15712 {
15713 unsigned long i;
15714
15715 printf (_(" Description data: "));
15716 for (i = 0; i < pnote->descsz; ++i)
15717 printf ("%02x ", pnote->descdata[i] & 0xff);
15718 printf ("\n");
15719 }
15720 break;
664f90a3
TT		 15721 }
15722
15723 return 1;
15724}
15725
685080f2
NC		 15726static const char *
15727get_v850_elf_note_type (enum v850_notes n_type)
15728{
15729 static char buff[64];
15730
15731 switch (n_type)
15732 {
15733 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15734 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15735 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15736 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15737 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15738 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15739 default:
15740 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15741 return buff;
15742 }
15743}
15744
15745static int
15746print_v850_note (Elf_Internal_Note * pnote)
15747{
15748 unsigned int val;
15749
15750 if (pnote->descsz != 4)
15751 return 0;
15752 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15753
15754 if (val == 0)
15755 {
15756 printf (_("not set\n"));
15757 return 1;
15758 }
15759
15760 switch (pnote->type)
15761 {
15762 case V850_NOTE_ALIGNMENT:
15763 switch (val)
15764 {
15765 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15766 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15767 }
15768 break;
14ae95f2 15769
685080f2
NC		 15770 case V850_NOTE_DATA_SIZE:
15771 switch (val)
15772 {
15773 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15774 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15775 }
15776 break;
14ae95f2 15777
685080f2
NC		 15778 case V850_NOTE_FPU_INFO:
15779 switch (val)
15780 {
15781 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15782 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15783 }
15784 break;
14ae95f2 15785
685080f2
NC		 15786 case V850_NOTE_MMU_INFO:
15787 case V850_NOTE_CACHE_INFO:
15788 case V850_NOTE_SIMD_INFO:
15789 if (val == EF_RH850_SIMD)
15790 {
15791 printf (_("yes\n"));
15792 return 1;
15793 }
15794 break;
15795
15796 default:
15797 /* An 'unknown note type' message will already have been displayed. */
15798 break;
15799 }
15800
15801 printf (_("unknown value: %x\n"), val);
15802 return 0;
15803}
15804
c6056a74
SF		 15805static int
15806process_netbsd_elf_note (Elf_Internal_Note * pnote)
15807{
15808 unsigned int version;
15809
15810 switch (pnote->type)
15811 {
15812 case NT_NETBSD_IDENT:
15813 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15814 if ((version / 10000) % 100)
15815 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15816 version, version / 100000000, (version / 1000000) % 100,
15817 (version / 10000) % 100 > 26 ? "Z" : "",
15818 'A' + (version / 10000) % 26);
15819 else
15820 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15821 version, version / 100000000, (version / 1000000) % 100,
15822 (version / 100) % 100);
15823 return 1;
15824
15825 case NT_NETBSD_MARCH:
15826 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15827 pnote->descdata);
15828 return 1;
15829
15830 default:
15831 break;
15832 }
15833
15834 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15835 pnote->type);
15836 return 1;
15837}
15838
f4ddf30f
JB		 15839static const char *
15840get_freebsd_elfcore_note_type (unsigned e_type)
15841{
f4ddf30f
JB		 15842 switch (e_type)
15843 {
15844 case NT_FREEBSD_THRMISC:
15845 return _("NT_THRMISC (thrmisc structure)");
15846 case NT_FREEBSD_PROCSTAT_PROC:
15847 return _("NT_PROCSTAT_PROC (proc data)");
15848 case NT_FREEBSD_PROCSTAT_FILES:
15849 return _("NT_PROCSTAT_FILES (files data)");
15850 case NT_FREEBSD_PROCSTAT_VMMAP:
15851 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15852 case NT_FREEBSD_PROCSTAT_GROUPS:
15853 return _("NT_PROCSTAT_GROUPS (groups data)");
15854 case NT_FREEBSD_PROCSTAT_UMASK:
15855 return _("NT_PROCSTAT_UMASK (umask data)");
15856 case NT_FREEBSD_PROCSTAT_RLIMIT:
15857 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15858 case NT_FREEBSD_PROCSTAT_OSREL:
15859 return _("NT_PROCSTAT_OSREL (osreldate data)");
15860 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
15861 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15862 case NT_FREEBSD_PROCSTAT_AUXV:
15863 return _("NT_PROCSTAT_AUXV (auxv data)");
15864 }
15865 return get_note_type (e_type);
15866}
15867
9437c45b 15868static const char *
d3ba0551 15869get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15870{
15871 static char buff[64];
15872
b4db1224 15873 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15874 {
15875 /* NetBSD core "procinfo" structure. */
15876 return _("NetBSD procinfo structure");
15877 }
15878
15879 /* As of Jan 2002 there are no other machine-independent notes
15880 defined for NetBSD core files. If the note type is less
15881 than the start of the machine-dependent note types, we don't
15882 understand it. */
15883
b4db1224 15884 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15885 {
e9e44622 15886 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15887 return buff;
15888 }
15889
15890 switch (elf_header.e_machine)
15891 {
15892 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15893 and PT_GETFPREGS == mach+2. */
15894
15895 case EM_OLD_ALPHA:
15896 case EM_ALPHA:
15897 case EM_SPARC:
15898 case EM_SPARC32PLUS:
15899 case EM_SPARCV9:
15900 switch (e_type)
15901 {
2b692964 15902 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15903 return _("PT_GETREGS (reg structure)");
2b692964 15904 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15905 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15906 default:
15907 break;
15908 }
15909 break;
15910
15911 /* On all other arch's, PT_GETREGS == mach+1 and
15912 PT_GETFPREGS == mach+3. */
15913 default:
15914 switch (e_type)
15915 {
2b692964 15916 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15917 return _("PT_GETREGS (reg structure)");
2b692964 15918 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15919 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15920 default:
15921 break;
15922 }
15923 }
15924
9cf03b7e 15925 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15926 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15927 return buff;
15928}
15929
70616151
TT		 15930static const char *
15931get_stapsdt_note_type (unsigned e_type)
15932{
15933 static char buff[64];
15934
15935 switch (e_type)
15936 {
15937 case NT_STAPSDT:
15938 return _("NT_STAPSDT (SystemTap probe descriptors)");
15939
15940 default:
15941 break;
15942 }
15943
15944 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15945 return buff;
15946}
15947
c6a9fc58
TT		 15948static int
15949print_stapsdt_note (Elf_Internal_Note *pnote)
15950{
15951 int addr_size = is_32bit_elf ? 4 : 8;
15952 char *data = pnote->descdata;
15953 char *data_end = pnote->descdata + pnote->descsz;
15954 bfd_vma pc, base_addr, semaphore;
15955 char *provider, *probe, *arg_fmt;
15956
15957 pc = byte_get ((unsigned char *) data, addr_size);
15958 data += addr_size;
15959 base_addr = byte_get ((unsigned char *) data, addr_size);
15960 data += addr_size;
15961 semaphore = byte_get ((unsigned char *) data, addr_size);
15962 data += addr_size;
15963
15964 provider = data;
15965 data += strlen (data) + 1;
15966 probe = data;
15967 data += strlen (data) + 1;
15968 arg_fmt = data;
15969 data += strlen (data) + 1;
15970
15971 printf (_(" Provider: %s\n"), provider);
15972 printf (_(" Name: %s\n"), probe);
15973 printf (_(" Location: "));
15974 print_vma (pc, FULL_HEX);
15975 printf (_(", Base: "));
15976 print_vma (base_addr, FULL_HEX);
15977 printf (_(", Semaphore: "));
15978 print_vma (semaphore, FULL_HEX);
9cf03b7e 15979 printf ("\n");
c6a9fc58
TT		 15980 printf (_(" Arguments: %s\n"), arg_fmt);
15981
15982 return data == data_end;
15983}
15984
00e98fc7
TG		 15985static const char *
15986get_ia64_vms_note_type (unsigned e_type)
15987{
15988 static char buff[64];
15989
15990 switch (e_type)
15991 {
15992 case NT_VMS_MHD:
15993 return _("NT_VMS_MHD (module header)");
15994 case NT_VMS_LNM:
15995 return _("NT_VMS_LNM (language name)");
15996 case NT_VMS_SRC:
15997 return _("NT_VMS_SRC (source files)");
15998 case NT_VMS_TITLE:
9cf03b7e 15999 return "NT_VMS_TITLE";
00e98fc7
TG		 16000 case NT_VMS_EIDC:
16001 return _("NT_VMS_EIDC (consistency check)");
16002 case NT_VMS_FPMODE:
16003 return _("NT_VMS_FPMODE (FP mode)");
16004 case NT_VMS_LINKTIME:
9cf03b7e 16005 return "NT_VMS_LINKTIME";
00e98fc7
TG		 16006 case NT_VMS_IMGNAM:
16007 return _("NT_VMS_IMGNAM (image name)");
16008 case NT_VMS_IMGID:
16009 return _("NT_VMS_IMGID (image id)");
16010 case NT_VMS_LINKID:
16011 return _("NT_VMS_LINKID (link id)");
16012 case NT_VMS_IMGBID:
16013 return _("NT_VMS_IMGBID (build id)");
16014 case NT_VMS_GSTNAM:
16015 return _("NT_VMS_GSTNAM (sym table name)");
16016 case NT_VMS_ORIG_DYN:
9cf03b7e 16017 return "NT_VMS_ORIG_DYN";
00e98fc7 16018 case NT_VMS_PATCHTIME:
9cf03b7e 16019 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 16020 default:
16021 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16022 return buff;
16023 }
16024}
16025
16026static int
16027print_ia64_vms_note (Elf_Internal_Note * pnote)
16028{
16029 switch (pnote->type)
16030 {
16031 case NT_VMS_MHD:
16032 if (pnote->descsz > 36)
16033 {
16034 size_t l = strlen (pnote->descdata + 34);
16035 printf (_(" Creation date : %.17s\n"), pnote->descdata);
16036 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
16037 printf (_(" Module name : %s\n"), pnote->descdata + 34);
16038 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
16039 }
16040 else
16041 printf (_(" Invalid size\n"));
16042 break;
16043 case NT_VMS_LNM:
16044 printf (_(" Language: %s\n"), pnote->descdata);
16045 break;
16046#ifdef BFD64
16047 case NT_VMS_FPMODE:
9cf03b7e 16048 printf (_(" Floating Point mode: "));
4a5cb34f 16049 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16050 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 16051 break;
16052 case NT_VMS_LINKTIME:
16053 printf (_(" Link time: "));
16054 print_vms_time
16055 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16056 printf ("\n");
16057 break;
16058 case NT_VMS_PATCHTIME:
16059 printf (_(" Patch time: "));
16060 print_vms_time
16061 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16062 printf ("\n");
16063 break;
16064 case NT_VMS_ORIG_DYN:
16065 printf (_(" Major id: %u, minor id: %u\n"),
16066 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16067 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 16068 printf (_(" Last modified : "));
00e98fc7
TG		 16069 print_vms_time
16070 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 16071 printf (_("\n Link flags : "));
4a5cb34f 16072 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16073 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 16074 printf (_(" Header flags: 0x%08x\n"),
948f632f 16075 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 16076 printf (_(" Image id : %s\n"), pnote->descdata + 32);
16077 break;
16078#endif
16079 case NT_VMS_IMGNAM:
16080 printf (_(" Image name: %s\n"), pnote->descdata);
16081 break;
16082 case NT_VMS_GSTNAM:
16083 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
16084 break;
16085 case NT_VMS_IMGID:
16086 printf (_(" Image id: %s\n"), pnote->descdata);
16087 break;
16088 case NT_VMS_LINKID:
16089 printf (_(" Linker id: %s\n"), pnote->descdata);
16090 break;
16091 default:
16092 break;
16093 }
16094 return 1;
16095}
16096
6d118b09
NC		 16097/* Note that by the ELF standard, the name field is already null byte
16098 terminated, and namesz includes the terminating null byte.
16099 I.E. the value of namesz for the name "FSF" is 4.
16100
e3c8793a 16101 If the value of namesz is zero, there is no name present. */
779fe533 16102static int
1449284b
NC		 16103process_note (Elf_Internal_Note * pnote,
16104 FILE * file ATTRIBUTE_UNUSED,
16105 Elf_Internal_Shdr * section ATTRIBUTE_UNUSED)
779fe533 16106{
2cf0635d
NC		 16107 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
16108 const char * nt;
9437c45b
JT		 16109
16110 if (pnote->namesz == 0)
1ec5cd37
NC		 16111 /* If there is no note name, then use the default set of
16112 note type strings. */
16113 nt = get_note_type (pnote->type);
16114
1118d252
RM		 16115 else if (const_strneq (pnote->namedata, "GNU"))
16116 /* GNU-specific object file notes. */
16117 nt = get_gnu_elf_note_type (pnote->type);
f4ddf30f
JB		 16118
16119 else if (const_strneq (pnote->namedata, "FreeBSD"))
16120 /* FreeBSD-specific core file notes. */
16121 nt = get_freebsd_elfcore_note_type (pnote->type);
1118d252 16122
0112cd26 16123 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 16124 /* NetBSD-specific core file notes. */
16125 nt = get_netbsd_elfcore_note_type (pnote->type);
16126
c6056a74
SF		 16127 else if (const_strneq (pnote->namedata, "NetBSD"))
16128 /* NetBSD-specific core file notes. */
16129 return process_netbsd_elf_note (pnote);
16130
b15fa79e
AM		 16131 else if (strneq (pnote->namedata, "SPU/", 4))
16132 {
16133 /* SPU-specific core file notes. */
16134 nt = pnote->namedata + 4;
16135 name = "SPU";
16136 }
16137
00e98fc7
TG		 16138 else if (const_strneq (pnote->namedata, "IPF/VMS"))
16139 /* VMS/ia64-specific file notes. */
16140 nt = get_ia64_vms_note_type (pnote->type);
16141
70616151
TT		 16142 else if (const_strneq (pnote->namedata, "stapsdt"))
16143 nt = get_stapsdt_note_type (pnote->type);
16144
9437c45b 16145 else
1ec5cd37
NC		 16146 /* Don't recognize this note name; just use the default set of
16147 note type strings. */
00e98fc7 16148 nt = get_note_type (pnote->type);
9437c45b 16149
1449284b
NC		 16150 printf (" ");
16151 print_symbol (-20, name);
16152 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
00e98fc7
TG		 16153
16154 if (const_strneq (pnote->namedata, "IPF/VMS"))
16155 return print_ia64_vms_note (pnote);
664f90a3
TT		 16156 else if (const_strneq (pnote->namedata, "GNU"))
16157 return print_gnu_note (pnote);
c6a9fc58
TT		 16158 else if (const_strneq (pnote->namedata, "stapsdt"))
16159 return print_stapsdt_note (pnote);
9ece1fa9
TT		 16160 else if (const_strneq (pnote->namedata, "CORE"))
16161 return print_core_note (pnote);
779fe533 16162
1449284b
NC		 16163 else if (pnote->descsz)
16164 {
16165 unsigned long i;
16166
16167 printf (_(" description data: "));
16168 for (i = 0; i < pnote->descsz; i++)
16169 printf ("%02x ", pnote->descdata[i]);
16170 printf ("\n");
16171 }
16172
16173 return 1;
16174}
6d118b09 16175
779fe533 16176static int
1449284b
NC		 16177process_notes_at (FILE * file,
16178 Elf_Internal_Shdr * section,
16179 bfd_vma offset,
16180 bfd_vma length)
779fe533 16181{
2cf0635d
NC		 16182 Elf_External_Note * pnotes;
16183 Elf_External_Note * external;
c8071705 16184 char * end;
b34976b6 16185 int res = 1;
103f02d3 16186
779fe533
NC		 16187 if (length <= 0)
16188 return 0;
103f02d3 16189
1449284b
NC		 16190 if (section)
16191 {
16192 pnotes = (Elf_External_Note *) get_section_contents (section, file);
16193 if (pnotes)
16194 apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL);
16195 }
16196 else
16197 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16198 _("notes"));
dd24e3da 16199 if (pnotes == NULL)
a6e9f9df 16200 return 0;
779fe533 16201
103f02d3 16202 external = pnotes;
103f02d3 16203
1449284b
NC		 16204 if (section)
16205 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
16206 else
16207 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16208 (unsigned long) offset, (unsigned long) length);
16209
2aee03ae 16210 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 16211
c8071705
NC		 16212 end = (char *) pnotes + length;
16213 while ((char *) external < end)
779fe533 16214 {
b34976b6 16215 Elf_Internal_Note inote;
15b42fb0
AM		 16216 size_t min_notesz;
16217 char *next;
2cf0635d 16218 char * temp = NULL;
c8071705 16219 size_t data_remaining = end - (char *) external;
6d118b09 16220
00e98fc7 16221 if (!is_ia64_vms ())
15b42fb0 16222 {
9dd3a467
NC		 16223 /* PR binutils/15191
16224 Make sure that there is enough data to read. */
15b42fb0
AM		 16225 min_notesz = offsetof (Elf_External_Note, name);
16226 if (data_remaining < min_notesz)
9dd3a467
NC		 16227 {
16228 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16229 (int) data_remaining);
16230 break;
16231 }
15b42fb0
AM		 16232 inote.type = BYTE_GET (external->type);
16233 inote.namesz = BYTE_GET (external->namesz);
16234 inote.namedata = external->name;
16235 inote.descsz = BYTE_GET (external->descsz);
16236 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 16237 /* PR 17531: file: 3443835e. */
c8071705 16238 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 16239 {
16240 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16241 inote.descdata = inote.namedata;
16242 inote.namesz = 0;
16243 }
14ae95f2 16244
15b42fb0
AM		 16245 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16246 next = inote.descdata + align_power (inote.descsz, 2);
16247 }
00e98fc7 16248 else
15b42fb0
AM		 16249 {
16250 Elf64_External_VMS_Note *vms_external;
00e98fc7 16251
9dd3a467
NC		 16252 /* PR binutils/15191
16253 Make sure that there is enough data to read. */
15b42fb0
AM		 16254 min_notesz = offsetof (Elf64_External_VMS_Note, name);
16255 if (data_remaining < min_notesz)
9dd3a467
NC		 16256 {
16257 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16258 (int) data_remaining);
16259 break;
16260 }
3e55a963 16261
15b42fb0
AM		 16262 vms_external = (Elf64_External_VMS_Note *) external;
16263 inote.type = BYTE_GET (vms_external->type);
16264 inote.namesz = BYTE_GET (vms_external->namesz);
16265 inote.namedata = vms_external->name;
16266 inote.descsz = BYTE_GET (vms_external->descsz);
16267 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
16268 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16269 next = inote.descdata + align_power (inote.descsz, 3);
16270 }
16271
16272 if (inote.descdata < (char *) external + min_notesz
16273 || next < (char *) external + min_notesz
5d921cbd
NC		 16274 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16275 || inote.namedata + inote.namesz < inote.namedata
16276 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 16277 || data_remaining < (size_t)(next - (char *) external))
3e55a963 16278 {
15b42fb0 16279 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 16280 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 16281 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 16282 inote.type, inote.namesz, inote.descsz);
16283 break;
16284 }
16285
15b42fb0 16286 external = (Elf_External_Note *) next;
dd24e3da 16287
6d118b09
NC		 16288 /* Verify that name is null terminated. It appears that at least
16289 one version of Linux (RedHat 6.0) generates corefiles that don't
16290 comply with the ELF spec by failing to include the null byte in
16291 namesz. */
8b971f9f 16292 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 16293 {
3f5e193b 16294 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 16295 if (temp == NULL)
16296 {
8b73c356 16297 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 16298 res = 0;
16299 break;
16300 }
76da6bbe 16301
6d118b09
NC		 16302 strncpy (temp, inote.namedata, inote.namesz);
16303 temp[inote.namesz] = 0;
76da6bbe 16304
6d118b09
NC		 16305 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16306 inote.namedata = temp;
16307 }
16308
1449284b 16309 res &= process_note (& inote, file, section);
103f02d3 16310
6d118b09
NC		 16311 if (temp != NULL)
16312 {
16313 free (temp);
16314 temp = NULL;
16315 }
779fe533
NC		 16316 }
16317
16318 free (pnotes);
103f02d3 16319
779fe533
NC		 16320 return res;
16321}
16322
16323static int
2cf0635d 16324process_corefile_note_segments (FILE * file)
779fe533 16325{
2cf0635d 16326 Elf_Internal_Phdr * segment;
b34976b6
AM		 16327 unsigned int i;
16328 int res = 1;
103f02d3 16329
d93f0186 16330 if (! get_program_headers (file))
779fe533 16331 return 0;
103f02d3 16332
779fe533
NC		 16333 for (i = 0, segment = program_headers;
16334 i < elf_header.e_phnum;
b34976b6 16335 i++, segment++)
779fe533
NC		 16336 {
16337 if (segment->p_type == PT_NOTE)
1449284b
NC		 16338 res &= process_notes_at (file, NULL,
16339 (bfd_vma) segment->p_offset,
16340 (bfd_vma) segment->p_filesz);
779fe533 16341 }
103f02d3 16342
779fe533
NC		 16343 return res;
16344}
16345
685080f2
NC		 16346static int
16347process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
16348{
16349 Elf_External_Note * pnotes;
16350 Elf_External_Note * external;
c8071705 16351 char * end;
685080f2
NC		 16352 int res = 1;
16353
16354 if (length <= 0)
16355 return 0;
16356
16357 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16358 _("v850 notes"));
16359 if (pnotes == NULL)
16360 return 0;
16361
16362 external = pnotes;
c8071705 16363 end = (char*) pnotes + length;
685080f2
NC		 16364
16365 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16366 (unsigned long) offset, (unsigned long) length);
16367
c8071705 16368 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 16369 {
16370 Elf_External_Note * next;
16371 Elf_Internal_Note inote;
16372
16373 inote.type = BYTE_GET (external->type);
16374 inote.namesz = BYTE_GET (external->namesz);
16375 inote.namedata = external->name;
16376 inote.descsz = BYTE_GET (external->descsz);
16377 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
16378 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16379
c8071705
NC		 16380 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
16381 {
16382 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16383 inote.descdata = inote.namedata;
16384 inote.namesz = 0;
16385 }
16386
685080f2
NC		 16387 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
16388
c8071705 16389 if ( ((char *) next > end)
685080f2
NC		 16390 || ((char *) next < (char *) pnotes))
16391 {
16392 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16393 (unsigned long) ((char *) external - (char *) pnotes));
16394 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16395 inote.type, inote.namesz, inote.descsz);
16396 break;
16397 }
16398
16399 external = next;
16400
16401 /* Prevent out-of-bounds indexing. */
c8071705 16402 if ( inote.namedata + inote.namesz > end
685080f2
NC		 16403 || inote.namedata + inote.namesz < inote.namedata)
16404 {
16405 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16406 (unsigned long) ((char *) external - (char *) pnotes));
16407 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16408 inote.type, inote.namesz, inote.descsz);
16409 break;
16410 }
16411
16412 printf (" %s: ", get_v850_elf_note_type (inote.type));
16413
16414 if (! print_v850_note (& inote))
16415 {
16416 res = 0;
16417 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16418 inote.namesz, inote.descsz);
16419 }
16420 }
16421
16422 free (pnotes);
16423
16424 return res;
16425}
16426
779fe533 16427static int
2cf0635d 16428process_note_sections (FILE * file)
1ec5cd37 16429{
2cf0635d 16430 Elf_Internal_Shdr * section;
1ec5cd37 16431 unsigned long i;
df565f32 16432 int n = 0;
1ec5cd37
NC		 16433 int res = 1;
16434
16435 for (i = 0, section = section_headers;
fa1908fd 16436 i < elf_header.e_shnum && section != NULL;
1ec5cd37 16437 i++, section++)
685080f2
NC		 16438 {
16439 if (section->sh_type == SHT_NOTE)
16440 {
1449284b
NC		 16441 res &= process_notes_at (file, section,
16442 (bfd_vma) section->sh_offset,
16443 (bfd_vma) section->sh_size);
685080f2
NC		 16444 n++;
16445 }
16446
16447 if (( elf_header.e_machine == EM_V800
16448 || elf_header.e_machine == EM_V850
16449 || elf_header.e_machine == EM_CYGNUS_V850)
16450 && section->sh_type == SHT_RENESAS_INFO)
16451 {
16452 res &= process_v850_notes (file,
16453 (bfd_vma) section->sh_offset,
16454 (bfd_vma) section->sh_size);
16455 n++;
16456 }
16457 }
df565f32
NC		 16458
16459 if (n == 0)
16460 /* Try processing NOTE segments instead. */
16461 return process_corefile_note_segments (file);
1ec5cd37
NC		 16462
16463 return res;
16464}
16465
16466static int
2cf0635d 16467process_notes (FILE * file)
779fe533
NC		 16468{
16469 /* If we have not been asked to display the notes then do nothing. */
16470 if (! do_notes)
16471 return 1;
103f02d3 16472
779fe533 16473 if (elf_header.e_type != ET_CORE)
1ec5cd37 16474 return process_note_sections (file);
103f02d3 16475
779fe533 16476 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 16477 if (elf_header.e_phnum > 0)
16478 return process_corefile_note_segments (file);
779fe533 16479
1ec5cd37
NC		 16480 printf (_("No note segments present in the core file.\n"));
16481 return 1;
779fe533
NC		 16482}
16483
252b5132 16484static int
2cf0635d 16485process_arch_specific (FILE * file)
252b5132 16486{
a952a375
NC		 16487 if (! do_arch)
16488 return 1;
16489
252b5132
RH		 16490 switch (elf_header.e_machine)
16491 {
11c1ff18
PB		 16492 case EM_ARM:
16493 return process_arm_specific (file);
252b5132 16494 case EM_MIPS:
4fe85591 16495 case EM_MIPS_RS3_LE:
252b5132
RH		 16496 return process_mips_specific (file);
16497 break;
35c08157
KLC		 16498 case EM_NDS32:
16499 return process_nds32_specific (file);
16500 break;
34c8bcba 16501 case EM_PPC:
b82317dd 16502 case EM_PPC64:
34c8bcba
JM		 16503 return process_power_specific (file);
16504 break;
643f7afb
AK		 16505 case EM_S390:
16506 case EM_S390_OLD:
16507 return process_s390_specific (file);
16508 break;
9e8c70f9
DM		 16509 case EM_SPARC:
16510 case EM_SPARC32PLUS:
16511 case EM_SPARCV9:
16512 return process_sparc_specific (file);
16513 break;
59e6276b
JM		 16514 case EM_TI_C6000:
16515 return process_tic6x_specific (file);
16516 break;
13761a11
NC		 16517 case EM_MSP430:
16518 return process_msp430x_specific (file);
252b5132
RH		 16519 default:
16520 break;
16521 }
16522 return 1;
16523}
16524
16525static int
2cf0635d 16526get_file_header (FILE * file)
252b5132 16527{
9ea033b2
NC		 16528 /* Read in the identity array. */
16529 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16530 return 0;
16531
9ea033b2 16532 /* Determine how to read the rest of the header. */
b34976b6 16533 switch (elf_header.e_ident[EI_DATA])
9ea033b2 16534 {
1a0670f3
AM		 16535 default:
16536 case ELFDATANONE:
adab8cdc
AO		 16537 case ELFDATA2LSB:
16538 byte_get = byte_get_little_endian;
16539 byte_put = byte_put_little_endian;
16540 break;
16541 case ELFDATA2MSB:
16542 byte_get = byte_get_big_endian;
16543 byte_put = byte_put_big_endian;
16544 break;
9ea033b2
NC		 16545 }
16546
16547 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16548 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16549
16550 /* Read in the rest of the header. */
16551 if (is_32bit_elf)
16552 {
16553 Elf32_External_Ehdr ehdr32;
252b5132 16554
9ea033b2
NC		 16555 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16556 return 0;
103f02d3 16557
9ea033b2
NC		 16558 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16559 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16560 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16561 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16562 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16563 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16564 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16565 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16566 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16567 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16568 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16569 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16570 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16571 }
252b5132 16572 else
9ea033b2
NC		 16573 {
16574 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16575
16576 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16577 we will not be able to cope with the 64bit data found in
16578 64 ELF files. Detect this now and abort before we start
50c2245b 16579 overwriting things. */
a952a375
NC		 16580 if (sizeof (bfd_vma) < 8)
16581 {
e3c8793a
NC		 16582 error (_("This instance of readelf has been built without support for a\n\
1658364 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16584 return 0;
16585 }
103f02d3 16586
9ea033b2
NC		 16587 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16588 return 0;
103f02d3 16589
9ea033b2
NC		 16590 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16591 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16592 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16593 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16594 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16595 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16596 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16597 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16598 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16599 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16600 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16601 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16602 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16603 }
252b5132 16604
7ece0d85
JJ		 16605 if (elf_header.e_shoff)
16606 {
16607 /* There may be some extensions in the first section header. Don't
16608 bomb if we can't read it. */
16609 if (is_32bit_elf)
049b0c3a 16610 get_32bit_section_headers (file, TRUE);
7ece0d85 16611 else
049b0c3a 16612 get_64bit_section_headers (file, TRUE);
7ece0d85 16613 }
560f3c1c 16614
252b5132
RH		 16615 return 1;
16616}
16617
fb52b2f4
NC		 16618/* Process one ELF object file according to the command line options.
16619 This file may actually be stored in an archive. The file is
16620 positioned at the start of the ELF object. */
16621
ff78d6d6 16622static int
2cf0635d 16623process_object (char * file_name, FILE * file)
252b5132 16624{
252b5132
RH		 16625 unsigned int i;
16626
252b5132
RH		 16627 if (! get_file_header (file))
16628 {
16629 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16630 return 1;
252b5132
RH		 16631 }
16632
16633 /* Initialise per file variables. */
60bca95a 16634 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16635 version_info[i] = 0;
16636
60bca95a 16637 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16638 dynamic_info[i] = 0;
5115b233 16639 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16640
16641 /* Process the file. */
16642 if (show_name)
16643 printf (_("\nFile: %s\n"), file_name);
16644
18bd398b
NC		 16645 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16646 Note we do this even if cmdline_dump_sects is empty because we
16647 must make sure that the dump_sets array is zeroed out before each
16648 object file is processed. */
16649 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16650 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16651
16652 if (num_cmdline_dump_sects > 0)
16653 {
16654 if (num_dump_sects == 0)
16655 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16656 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16657
16658 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16659 memcpy (dump_sects, cmdline_dump_sects,
16660 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16661 }
d70c5fc7 16662
252b5132 16663 if (! process_file_header ())
fb52b2f4 16664 return 1;
252b5132 16665
d1f5c6e3 16666 if (! process_section_headers (file))
2f62977e 16667 {
d1f5c6e3
L		 16668 /* Without loaded section headers we cannot process lots of
16669 things. */
2f62977e 16670 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16671
2f62977e 16672 if (! do_using_dynamic)
2c610e4b 16673 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16674 }
252b5132 16675
d1f5c6e3
L		 16676 if (! process_section_groups (file))
16677 {
16678 /* Without loaded section groups we cannot process unwind. */
16679 do_unwind = 0;
16680 }
16681
2f62977e 16682 if (process_program_headers (file))
b2d38a17 16683 process_dynamic_section (file);
252b5132
RH		 16684
16685 process_relocs (file);
16686
4d6ed7c8
NC		 16687 process_unwind (file);
16688
252b5132
RH		 16689 process_symbol_table (file);
16690
16691 process_syminfo (file);
16692
16693 process_version_sections (file);
16694
16695 process_section_contents (file);
f5842774 16696
1ec5cd37 16697 process_notes (file);
103f02d3 16698
047b2264
JJ		 16699 process_gnu_liblist (file);
16700
252b5132
RH		 16701 process_arch_specific (file);
16702
d93f0186
NC		 16703 if (program_headers)
16704 {
16705 free (program_headers);
16706 program_headers = NULL;
16707 }
16708
252b5132
RH		 16709 if (section_headers)
16710 {
16711 free (section_headers);
16712 section_headers = NULL;
16713 }
16714
16715 if (string_table)
16716 {
16717 free (string_table);
16718 string_table = NULL;
d40ac9bd 16719 string_table_length = 0;
252b5132
RH		 16720 }
16721
16722 if (dynamic_strings)
16723 {
16724 free (dynamic_strings);
16725 dynamic_strings = NULL;
d79b3d50 16726 dynamic_strings_length = 0;
252b5132
RH		 16727 }
16728
16729 if (dynamic_symbols)
16730 {
16731 free (dynamic_symbols);
16732 dynamic_symbols = NULL;
19936277 16733 num_dynamic_syms = 0;
252b5132
RH		 16734 }
16735
16736 if (dynamic_syminfo)
16737 {
16738 free (dynamic_syminfo);
16739 dynamic_syminfo = NULL;
16740 }
ff78d6d6 16741
293c573e
MR		 16742 if (dynamic_section)
16743 {
16744 free (dynamic_section);
16745 dynamic_section = NULL;
16746 }
16747
e4b17d5c
L		 16748 if (section_headers_groups)
16749 {
16750 free (section_headers_groups);
16751 section_headers_groups = NULL;
16752 }
16753
16754 if (section_groups)
16755 {
2cf0635d
NC		 16756 struct group_list * g;
16757 struct group_list * next;
e4b17d5c
L		 16758
16759 for (i = 0; i < group_count; i++)
16760 {
16761 for (g = section_groups [i].root; g != NULL; g = next)
16762 {
16763 next = g->next;
16764 free (g);
16765 }
16766 }
16767
16768 free (section_groups);
16769 section_groups = NULL;
16770 }
16771
19e6b90e 16772 free_debug_memory ();
18bd398b 16773
ff78d6d6 16774 return 0;
252b5132
RH		 16775}
16776
2cf0635d
NC		 16777/* Process an ELF archive.
16778 On entry the file is positioned just after the ARMAG string. */
16779
16780static int
16781process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16782{
16783 struct archive_info arch;
16784 struct archive_info nested_arch;
16785 size_t got;
2cf0635d
NC		 16786 int ret;
16787
16788 show_name = 1;
16789
16790 /* The ARCH structure is used to hold information about this archive. */
16791 arch.file_name = NULL;
16792 arch.file = NULL;
16793 arch.index_array = NULL;
16794 arch.sym_table = NULL;
16795 arch.longnames = NULL;
16796
16797 /* The NESTED_ARCH structure is used as a single-item cache of information
16798 about a nested archive (when members of a thin archive reside within
16799 another regular archive file). */
16800 nested_arch.file_name = NULL;
16801 nested_arch.file = NULL;
16802 nested_arch.index_array = NULL;
16803 nested_arch.sym_table = NULL;
16804 nested_arch.longnames = NULL;
16805
16806 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16807 {
16808 ret = 1;
16809 goto out;
4145f1d5 16810 }
fb52b2f4 16811
4145f1d5
NC		 16812 if (do_archive_index)
16813 {
2cf0635d 16814 if (arch.sym_table == NULL)
4145f1d5
NC		 16815 error (_("%s: unable to dump the index as none was found\n"), file_name);
16816 else
16817 {
591f7597 16818 unsigned long i, l;
4145f1d5
NC		 16819 unsigned long current_pos;
16820
591f7597
NC		 16821 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16822 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16823 current_pos = ftell (file);
16824
2cf0635d 16825 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16826 {
2cf0635d
NC		 16827 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16828 {
16829 char * member_name;
4145f1d5 16830
2cf0635d
NC		 16831 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16832
16833 if (member_name != NULL)
16834 {
16835 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16836
16837 if (qualified_name != NULL)
16838 {
c2a7d3f5
NC		 16839 printf (_("Contents of binary %s at offset "), qualified_name);
16840 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16841 putchar ('\n');
2cf0635d
NC		 16842 free (qualified_name);
16843 }
4145f1d5
NC		 16844 }
16845 }
2cf0635d
NC		 16846
16847 if (l >= arch.sym_size)
4145f1d5
NC		 16848 {
16849 error (_("%s: end of the symbol table reached before the end of the index\n"),
16850 file_name);
cb8f3167 16851 break;
4145f1d5 16852 }
591f7597
NC		 16853 /* PR 17531: file: 0b6630b2. */
16854 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16855 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16856 }
16857
c2a7d3f5
NC		 16858 if (arch.uses_64bit_indicies)
16859 l = (l + 7) & ~ 7;
16860 else
16861 l += l & 1;
16862
2cf0635d 16863 if (l < arch.sym_size)
c2a7d3f5
NC		 16864 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16865 file_name, arch.sym_size - l);
4145f1d5 16866
4145f1d5
NC		 16867 if (fseek (file, current_pos, SEEK_SET) != 0)
16868 {
16869 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16870 ret = 1;
16871 goto out;
4145f1d5 16872 }
fb52b2f4 16873 }
4145f1d5
NC		 16874
16875 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16876 && !do_segments && !do_header && !do_dump && !do_version
16877 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16878 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16879 {
16880 ret = 0; /* Archive index only. */
16881 goto out;
16882 }
fb52b2f4
NC		 16883 }
16884
d989285c 16885 ret = 0;
fb52b2f4
NC		 16886
16887 while (1)
16888 {
2cf0635d
NC		 16889 char * name;
16890 size_t namelen;
16891 char * qualified_name;
16892
16893 /* Read the next archive header. */
16894 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16895 {
16896 error (_("%s: failed to seek to next archive header\n"), file_name);
16897 return 1;
16898 }
16899 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16900 if (got != sizeof arch.arhdr)
16901 {
16902 if (got == 0)
16903 break;
16904 error (_("%s: failed to read archive header\n"), file_name);
16905 ret = 1;
16906 break;
16907 }
16908 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16909 {
16910 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16911 ret = 1;
16912 break;
16913 }
16914
16915 arch.next_arhdr_offset += sizeof arch.arhdr;
16916
16917 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16918 if (archive_file_size & 01)
16919 ++archive_file_size;
16920
16921 name = get_archive_member_name (&arch, &nested_arch);
16922 if (name == NULL)
fb52b2f4 16923 {
0fd3a477 16924 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16925 ret = 1;
16926 break;
fb52b2f4 16927 }
2cf0635d 16928 namelen = strlen (name);
fb52b2f4 16929
2cf0635d
NC		 16930 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16931 if (qualified_name == NULL)
fb52b2f4 16932 {
2cf0635d 16933 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16934 ret = 1;
16935 break;
fb52b2f4
NC		 16936 }
16937
2cf0635d
NC		 16938 if (is_thin_archive && arch.nested_member_origin == 0)
16939 {
16940 /* This is a proxy for an external member of a thin archive. */
16941 FILE * member_file;
16942 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16943 if (member_file_name == NULL)
16944 {
16945 ret = 1;
16946 break;
16947 }
16948
16949 member_file = fopen (member_file_name, "rb");
16950 if (member_file == NULL)
16951 {
16952 error (_("Input file '%s' is not readable.\n"), member_file_name);
16953 free (member_file_name);
16954 ret = 1;
16955 break;
16956 }
16957
16958 archive_file_offset = arch.nested_member_origin;
16959
16960 ret |= process_object (qualified_name, member_file);
16961
16962 fclose (member_file);
16963 free (member_file_name);
16964 }
16965 else if (is_thin_archive)
16966 {
a043396b
NC		 16967 /* PR 15140: Allow for corrupt thin archives. */
16968 if (nested_arch.file == NULL)
16969 {
16970 error (_("%s: contains corrupt thin archive: %s\n"),
16971 file_name, name);
16972 ret = 1;
16973 break;
16974 }
16975
2cf0635d
NC		 16976 /* This is a proxy for a member of a nested archive. */
16977 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16978
16979 /* The nested archive file will have been opened and setup by
16980 get_archive_member_name. */
16981 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16982 {
16983 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16984 ret = 1;
16985 break;
16986 }
16987
16988 ret |= process_object (qualified_name, nested_arch.file);
16989 }
16990 else
16991 {
16992 archive_file_offset = arch.next_arhdr_offset;
16993 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16994
2cf0635d
NC		 16995 ret |= process_object (qualified_name, file);
16996 }
fb52b2f4 16997
2b52916e
L		 16998 if (dump_sects != NULL)
16999 {
17000 free (dump_sects);
17001 dump_sects = NULL;
17002 num_dump_sects = 0;
17003 }
17004
2cf0635d 17005 free (qualified_name);
fb52b2f4
NC		 17006 }
17007
4145f1d5 17008 out:
2cf0635d
NC		 17009 if (nested_arch.file != NULL)
17010 fclose (nested_arch.file);
17011 release_archive (&nested_arch);
17012 release_archive (&arch);
fb52b2f4 17013
d989285c 17014 return ret;
fb52b2f4
NC		 17015}
17016
17017static int
2cf0635d 17018process_file (char * file_name)
fb52b2f4 17019{
2cf0635d 17020 FILE * file;
fb52b2f4
NC		 17021 struct stat statbuf;
17022 char armag[SARMAG];
17023 int ret;
17024
17025 if (stat (file_name, &statbuf) < 0)
17026 {
f24ddbdd
NC		 17027 if (errno == ENOENT)
17028 error (_("'%s': No such file\n"), file_name);
17029 else
17030 error (_("Could not locate '%s'. System error message: %s\n"),
17031 file_name, strerror (errno));
17032 return 1;
17033 }
17034
17035 if (! S_ISREG (statbuf.st_mode))
17036 {
17037 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 17038 return 1;
17039 }
17040
17041 file = fopen (file_name, "rb");
17042 if (file == NULL)
17043 {
f24ddbdd 17044 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 17045 return 1;
17046 }
17047
17048 if (fread (armag, SARMAG, 1, file) != 1)
17049 {
4145f1d5 17050 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 17051 fclose (file);
17052 return 1;
17053 }
17054
f54498b4
NC		 17055 current_file_size = (bfd_size_type) statbuf.st_size;
17056
fb52b2f4 17057 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 17058 ret = process_archive (file_name, file, FALSE);
17059 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
17060 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 17061 else
17062 {
4145f1d5
NC		 17063 if (do_archive_index)
17064 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17065 file_name);
17066
fb52b2f4
NC		 17067 rewind (file);
17068 archive_file_size = archive_file_offset = 0;
17069 ret = process_object (file_name, file);
17070 }
17071
17072 fclose (file);
17073
f54498b4 17074 current_file_size = 0;
fb52b2f4
NC		 17075 return ret;
17076}
17077
252b5132
RH		 17078#ifdef SUPPORT_DISASSEMBLY
17079/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 17080 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 17081 symbols. */
252b5132
RH		 17082
17083void
2cf0635d 17084print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 17085{
17086 fprintf (outfile,"0x%8.8x", addr);
17087}
17088
e3c8793a 17089/* Needed by the i386 disassembler. */
252b5132
RH		 17090void
17091db_task_printsym (unsigned int addr)
17092{
17093 print_address (addr, stderr);
17094}
17095#endif
17096
17097int
2cf0635d 17098main (int argc, char ** argv)
252b5132 17099{
ff78d6d6
L		 17100 int err;
17101
252b5132
RH		 17102#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17103 setlocale (LC_MESSAGES, "");
3882b010
L		 17104#endif
17105#if defined (HAVE_SETLOCALE)
17106 setlocale (LC_CTYPE, "");
252b5132
RH		 17107#endif
17108 bindtextdomain (PACKAGE, LOCALEDIR);
17109 textdomain (PACKAGE);
17110
869b9d07
MM		 17111 expandargv (&argc, &argv);
17112
252b5132
RH		 17113 parse_args (argc, argv);
17114
18bd398b 17115 if (num_dump_sects > 0)
59f14fc0 17116 {
18bd398b 17117 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 17118 cmdline_dump_sects = (dump_type *)
17119 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 17120 if (cmdline_dump_sects == NULL)
591a748a 17121 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 17122 else
17123 {
09c11c86
NC		 17124 memcpy (cmdline_dump_sects, dump_sects,
17125 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 17126 num_cmdline_dump_sects = num_dump_sects;
17127 }
17128 }
17129
18bd398b
NC		 17130 if (optind < (argc - 1))
17131 show_name = 1;
5656ba2c
L		 17132 else if (optind >= argc)
17133 {
17134 warn (_("Nothing to do.\n"));
17135 usage (stderr);
17136 }
18bd398b 17137
ff78d6d6 17138 err = 0;
252b5132 17139 while (optind < argc)
18bd398b 17140 err |= process_file (argv[optind++]);
252b5132
RH		 17141
17142 if (dump_sects != NULL)
17143 free (dump_sects);
59f14fc0
AS		 17144 if (cmdline_dump_sects != NULL)
17145 free (cmdline_dump_sects);
252b5132 17146
ff78d6d6 17147 return err;
252b5132 17148}
A mirror of the official binutils-gdb repository