projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* emultempl/elf32.em (gld${EMULATION_NAME}_before_allocation):
[deliverable/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
7e26601c 2 Copyright 1998-2013 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
CS		 46#ifdef HAVE_ZLIB_H
47#include <zlib.h>
48#endif
3bfcb652 49#ifdef HAVE_WCHAR_H
7bfd842d 50#include <wchar.h>
3bfcb652 51#endif
252b5132 52
a952a375 53#if __GNUC__ >= 2
19936277 54/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 55 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 56 Only do this if we believe that the compiler can support a 64 bit
a952a375 57 data type. For now we only rely on GCC being able to do this. */
19936277 58#define BFD64
a952a375
NC		 59#endif
60
3db64b00
AM		 61#include "bfd.h"
62#include "bucomm.h"
3284fe0c 63#include "elfcomm.h"
19e6b90e 64#include "dwarf.h"
252b5132
RH		 65
66#include "elf/common.h"
67#include "elf/external.h"
68#include "elf/internal.h"
252b5132 69
4b78141a
NC		 70
71/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76#include "elf/h8.h"
77#undef _ELF_H8_H
78
79/* Undo the effects of #including reloc-macros.h. */
80
81#undef START_RELOC_NUMBERS
82#undef RELOC_NUMBER
83#undef FAKE_RELOC
84#undef EMPTY_RELOC
85#undef END_RELOC_NUMBERS
86#undef _RELOC_MACROS_H
87
252b5132
RH		 88/* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92#define RELOC_MACROS_GEN_FUNC
93
a06ea964 94#include "elf/aarch64.h"
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
cfb8c092 106#include "elf/epiphany.h"
252b5132 107#include "elf/fr30.h"
5c70f934 108#include "elf/frv.h"
3b16e843
NC		 109#include "elf/h8.h"
110#include "elf/hppa.h"
111#include "elf/i386.h"
35b1837e 112#include "elf/i370.h"
3b16e843
NC		 113#include "elf/i860.h"
114#include "elf/i960.h"
115#include "elf/ia64.h"
1e4cf259 116#include "elf/ip2k.h"
84e94c90 117#include "elf/lm32.h"
1c0d3aa6 118#include "elf/iq2000.h"
49f58d10 119#include "elf/m32c.h"
3b16e843
NC		 120#include "elf/m32r.h"
121#include "elf/m68k.h"
75751cd9 122#include "elf/m68hc11.h"
252b5132 123#include "elf/mcore.h"
15ab5209 124#include "elf/mep.h"
a3c62988 125#include "elf/metag.h"
7ba29e2a 126#include "elf/microblaze.h"
3b16e843 127#include "elf/mips.h"
3c3bdf30 128#include "elf/mmix.h"
3b16e843
NC		 129#include "elf/mn10200.h"
130#include "elf/mn10300.h"
5506d11a 131#include "elf/moxie.h"
4970f871 132#include "elf/mt.h"
2469cfa2 133#include "elf/msp430.h"
3b16e843 134#include "elf/or32.h"
7d466069 135#include "elf/pj.h"
3b16e843 136#include "elf/ppc.h"
c833c019 137#include "elf/ppc64.h"
99c513f6 138#include "elf/rl78.h"
c7927a3c 139#include "elf/rx.h"
a85d7ed0 140#include "elf/s390.h"
1c0d3aa6 141#include "elf/score.h"
3b16e843
NC		 142#include "elf/sh.h"
143#include "elf/sparc.h"
e9f53129 144#include "elf/spu.h"
40b36596 145#include "elf/tic6x.h"
aa137e4d
NC		 146#include "elf/tilegx.h"
147#include "elf/tilepro.h"
3b16e843 148#include "elf/v850.h"
179d3252 149#include "elf/vax.h"
3b16e843 150#include "elf/x86-64.h"
c29aca4a 151#include "elf/xc16x.h"
f6c1a2d5 152#include "elf/xgate.h"
93fbbb04 153#include "elf/xstormy16.h"
88da6820 154#include "elf/xtensa.h"
252b5132 155
36591ba1
SL		 156#include "elf/nios2.h"
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
2cf0635d 167char * program_name = "readelf";
85b1c36d
BE		 168static long archive_file_offset;
169static unsigned long archive_file_size;
170static unsigned long dynamic_addr;
171static bfd_size_type dynamic_size;
172static unsigned int dynamic_nent;
2cf0635d 173static char * dynamic_strings;
85b1c36d 174static unsigned long dynamic_strings_length;
2cf0635d 175static char * string_table;
85b1c36d
BE		 176static unsigned long string_table_length;
177static unsigned long num_dynamic_syms;
2cf0635d
NC		 178static Elf_Internal_Sym * dynamic_symbols;
179static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 180static unsigned long dynamic_syminfo_offset;
181static unsigned int dynamic_syminfo_nent;
f8eae8b2 182static char program_interpreter[PATH_MAX];
bb8a0291 183static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 184static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 185static bfd_vma version_info[16];
186static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 187static Elf_Internal_Shdr * section_headers;
188static Elf_Internal_Phdr * program_headers;
189static Elf_Internal_Dyn * dynamic_section;
190static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 191static int show_name;
192static int do_dynamic;
193static int do_syms;
2c610e4b 194static int do_dyn_syms;
85b1c36d
BE		 195static int do_reloc;
196static int do_sections;
197static int do_section_groups;
5477e8a0 198static int do_section_details;
85b1c36d
BE		 199static int do_segments;
200static int do_unwind;
201static int do_using_dynamic;
202static int do_header;
203static int do_dump;
204static int do_version;
85b1c36d
BE		 205static int do_histogram;
206static int do_debugging;
85b1c36d
BE		 207static int do_arch;
208static int do_notes;
4145f1d5 209static int do_archive_index;
85b1c36d 210static int is_32bit_elf;
252b5132 211
e4b17d5c
L		 212struct group_list
213{
2cf0635d 214 struct group_list * next;
e4b17d5c
L		 215 unsigned int section_index;
216};
217
218struct group
219{
2cf0635d 220 struct group_list * root;
e4b17d5c
L		 221 unsigned int group_index;
222};
223
85b1c36d 224static size_t group_count;
2cf0635d
NC		 225static struct group * section_groups;
226static struct group ** section_headers_groups;
e4b17d5c 227
09c11c86
NC		 228
229/* Flag bits indicating particular types of dump. */
230#define HEX_DUMP (1 << 0) /* The -x command line switch. */
231#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
232#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
233#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 234#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 235
236typedef unsigned char dump_type;
237
238/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 239struct dump_list_entry
240{
2cf0635d 241 char * name;
09c11c86 242 dump_type type;
2cf0635d 243 struct dump_list_entry * next;
aef1f6d0 244};
2cf0635d 245static struct dump_list_entry * dump_sects_byname;
aef1f6d0 246
09c11c86
NC		 247/* A dynamic array of flags indicating for which sections a dump
248 has been requested via command line switches. */
249static dump_type * cmdline_dump_sects = NULL;
250static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 251
252/* A dynamic array of flags indicating for which sections a dump of
253 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 254 basis and then initialised from the cmdline_dump_sects array,
255 the results of interpreting the -w switch, and the
256 dump_sects_byname list. */
09c11c86
NC		 257static dump_type * dump_sects = NULL;
258static unsigned int num_dump_sects = 0;
252b5132 259
252b5132 260
c256ffe7 261/* How to print a vma value. */
843dd992
NC		 262typedef enum print_mode
263{
264 HEX,
265 DEC,
266 DEC_5,
267 UNSIGNED,
268 PREFIX_HEX,
269 FULL_HEX,
270 LONG_HEX
271}
272print_mode;
273
9c19a809
NC		 274#define UNKNOWN -1
275
2b692964
NC		 276#define SECTION_NAME(X) \
277 ((X) == NULL ? _("<none>") \
278 : string_table == NULL ? _("<no-name>") \
279 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 280 : string_table + (X)->sh_name))
252b5132 281
ee42cf8c 282#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 283
ba5cdace
NC		 284#define GET_ELF_SYMBOLS(file, section, sym_count) \
285 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
286 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 287
d79b3d50
NC		 288#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
289/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
290 already been called and verified that the string exists. */
291#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 292
61865e30
NC		 293#define REMOVE_ARCH_BITS(ADDR) \
294 do \
295 { \
296 if (elf_header.e_machine == EM_ARM) \
297 (ADDR) &= ~1; \
298 } \
299 while (0)
d79b3d50 300\f
59245841
NC		 301/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
302 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
303 using malloc and fill that. In either case return the pointer to the start of
304 the retrieved data or NULL if something went wrong. If something does go wrong
305 emit an error message using REASON as part of the context. */
306
c256ffe7 307static void *
2cf0635d
NC		 308get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
309 const char * reason)
a6e9f9df 310{
2cf0635d 311 void * mvar;
a6e9f9df 312
c256ffe7 313 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 314 return NULL;
315
fb52b2f4 316 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 317 {
0fd3a477 318 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 319 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 320 return NULL;
321 }
322
323 mvar = var;
324 if (mvar == NULL)
325 {
c256ffe7
JJ		 326 /* Check for overflow. */
327 if (nmemb < (~(size_t) 0 - 1) / size)
328 /* + 1 so that we can '\0' terminate invalid string table sections. */
329 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 330
331 if (mvar == NULL)
332 {
0fd3a477
JW		 333 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
334 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 335 return NULL;
336 }
c256ffe7
JJ		 337
338 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 339 }
340
c256ffe7 341 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 342 {
0fd3a477
JW		 343 error (_("Unable to read in 0x%lx bytes of %s\n"),
344 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 345 if (mvar != var)
346 free (mvar);
347 return NULL;
348 }
349
350 return mvar;
351}
352
14a91970 353/* Print a VMA value. */
cb8f3167 354
66543521 355static int
14a91970 356print_vma (bfd_vma vma, print_mode mode)
66543521 357{
66543521
AM		 358 int nc = 0;
359
14a91970 360 switch (mode)
66543521 361 {
14a91970
AM		 362 case FULL_HEX:
363 nc = printf ("0x");
364 /* Drop through. */
66543521 365
14a91970 366 case LONG_HEX:
f7a99963 367#ifdef BFD64
14a91970 368 if (is_32bit_elf)
437c2fb7 369 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 370#endif
14a91970
AM		 371 printf_vma (vma);
372 return nc + 16;
b19aac67 373
14a91970
AM		 374 case DEC_5:
375 if (vma <= 99999)
376 return printf ("%5" BFD_VMA_FMT "d", vma);
377 /* Drop through. */
66543521 378
14a91970
AM		 379 case PREFIX_HEX:
380 nc = printf ("0x");
381 /* Drop through. */
66543521 382
14a91970
AM		 383 case HEX:
384 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 385
14a91970
AM		 386 case DEC:
387 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 388
14a91970
AM		 389 case UNSIGNED:
390 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 391 }
66543521 392 return 0;
f7a99963
NC		 393}
394
7bfd842d 395/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 396 multibye characters (assuming the host environment supports them).
31104126 397
7bfd842d
NC		 398 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
399
400 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
401 padding as necessary.
171191ba
NC		 402
403 Returns the number of emitted characters. */
404
405static unsigned int
7a88bc9c 406print_symbol (int width, const char *symbol)
31104126 407{
171191ba 408 bfd_boolean extra_padding = FALSE;
7bfd842d 409 int num_printed = 0;
3bfcb652 410#ifdef HAVE_MBSTATE_T
7bfd842d 411 mbstate_t state;
3bfcb652 412#endif
7bfd842d 413 int width_remaining;
961c521f 414
7bfd842d 415 if (width < 0)
961c521f 416 {
961c521f
NC		 417 /* Keep the width positive. This also helps. */
418 width = - width;
171191ba 419 extra_padding = TRUE;
7bfd842d 420 }
961c521f 421
7bfd842d
NC		 422 if (do_wide)
423 /* Set the remaining width to a very large value.
424 This simplifies the code below. */
425 width_remaining = INT_MAX;
426 else
427 width_remaining = width;
cb8f3167 428
3bfcb652 429#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 430 /* Initialise the multibyte conversion state. */
431 memset (& state, 0, sizeof (state));
3bfcb652 432#endif
961c521f 433
7bfd842d
NC		 434 while (width_remaining)
435 {
436 size_t n;
7bfd842d 437 const char c = *symbol++;
961c521f 438
7bfd842d 439 if (c == 0)
961c521f
NC		 440 break;
441
7bfd842d
NC		 442 /* Do not print control characters directly as they can affect terminal
443 settings. Such characters usually appear in the names generated
444 by the assembler for local labels. */
445 if (ISCNTRL (c))
961c521f 446 {
7bfd842d 447 if (width_remaining < 2)
961c521f
NC		 448 break;
449
7bfd842d
NC		 450 printf ("^%c", c + 0x40);
451 width_remaining -= 2;
171191ba 452 num_printed += 2;
961c521f 453 }
7bfd842d
NC		 454 else if (ISPRINT (c))
455 {
456 putchar (c);
457 width_remaining --;
458 num_printed ++;
459 }
961c521f
NC		 460 else
461 {
3bfcb652
NC		 462#ifdef HAVE_MBSTATE_T
463 wchar_t w;
464#endif
7bfd842d
NC		 465 /* Let printf do the hard work of displaying multibyte characters. */
466 printf ("%.1s", symbol - 1);
467 width_remaining --;
468 num_printed ++;
469
3bfcb652 470#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 471 /* Try to find out how many bytes made up the character that was
472 just printed. Advance the symbol pointer past the bytes that
473 were displayed. */
474 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 475#else
476 n = 1;
477#endif
7bfd842d
NC		 478 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
479 symbol += (n - 1);
961c521f 480 }
961c521f 481 }
171191ba 482
7bfd842d 483 if (extra_padding && num_printed < width)
171191ba
NC		 484 {
485 /* Fill in the remaining spaces. */
7bfd842d
NC		 486 printf ("%-*s", width - num_printed, " ");
487 num_printed = width;
171191ba
NC		 488 }
489
490 return num_printed;
31104126
NC		 491}
492
89fac5e3
RS		 493/* Return a pointer to section NAME, or NULL if no such section exists. */
494
495static Elf_Internal_Shdr *
2cf0635d 496find_section (const char * name)
89fac5e3
RS		 497{
498 unsigned int i;
499
500 for (i = 0; i < elf_header.e_shnum; i++)
501 if (streq (SECTION_NAME (section_headers + i), name))
502 return section_headers + i;
503
504 return NULL;
505}
506
0b6ae522
DJ		 507/* Return a pointer to a section containing ADDR, or NULL if no such
508 section exists. */
509
510static Elf_Internal_Shdr *
511find_section_by_address (bfd_vma addr)
512{
513 unsigned int i;
514
515 for (i = 0; i < elf_header.e_shnum; i++)
516 {
517 Elf_Internal_Shdr *sec = section_headers + i;
518 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
519 return sec;
520 }
521
522 return NULL;
523}
524
657d0d47
CC		 525/* Return a pointer to section NAME, or NULL if no such section exists,
526 restricted to the list of sections given in SET. */
527
528static Elf_Internal_Shdr *
529find_section_in_set (const char * name, unsigned int * set)
530{
531 unsigned int i;
532
533 if (set != NULL)
534 {
535 while ((i = *set++) > 0)
536 if (streq (SECTION_NAME (section_headers + i), name))
537 return section_headers + i;
538 }
539
540 return find_section (name);
541}
542
0b6ae522
DJ		 543/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
544 bytes read. */
545
f6f0e17b
NC		 546static inline unsigned long
547read_uleb128 (unsigned char *data,
548 unsigned int *length_return,
549 const unsigned char * const end)
0b6ae522 550{
f6f0e17b 551 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 552}
553
28f997cf
TG		 554/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
555 This OS has so many departures from the ELF standard that we test it at
556 many places. */
557
558static inline int
559is_ia64_vms (void)
560{
561 return elf_header.e_machine == EM_IA_64
562 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
563}
564
bcedfee6 565/* Guess the relocation size commonly used by the specific machines. */
252b5132 566
252b5132 567static int
2dc4cec1 568guess_is_rela (unsigned int e_machine)
252b5132 569{
9c19a809 570 switch (e_machine)
252b5132
RH		 571 {
572 /* Targets that use REL relocations. */
252b5132
RH		 573 case EM_386:
574 case EM_486:
63fcb9e9 575 case EM_960:
e9f53129 576 case EM_ARM:
2b0337b0 577 case EM_D10V:
252b5132 578 case EM_CYGNUS_D10V:
e9f53129 579 case EM_DLX:
252b5132 580 case EM_MIPS:
4fe85591 581 case EM_MIPS_RS3_LE:
e9f53129
AM		 582 case EM_CYGNUS_M32R:
583 case EM_OPENRISC:
584 case EM_OR32:
1c0d3aa6 585 case EM_SCORE:
f6c1a2d5 586 case EM_XGATE:
9c19a809 587 return FALSE;
103f02d3 588
252b5132
RH		 589 /* Targets that use RELA relocations. */
590 case EM_68K:
e9f53129 591 case EM_860:
a06ea964 592 case EM_AARCH64:
cfb8c092 593 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 594 case EM_ALPHA:
595 case EM_ALTERA_NIOS2:
596 case EM_AVR:
597 case EM_AVR_OLD:
598 case EM_BLACKFIN:
60bca95a 599 case EM_CR16:
e9f53129
AM		 600 case EM_CRIS:
601 case EM_CRX:
2b0337b0 602 case EM_D30V:
252b5132 603 case EM_CYGNUS_D30V:
2b0337b0 604 case EM_FR30:
252b5132 605 case EM_CYGNUS_FR30:
5c70f934 606 case EM_CYGNUS_FRV:
e9f53129
AM		 607 case EM_H8S:
608 case EM_H8_300:
609 case EM_H8_300H:
800eeca4 610 case EM_IA_64:
1e4cf259
NC		 611 case EM_IP2K:
612 case EM_IP2K_OLD:
3b36097d 613 case EM_IQ2000:
84e94c90 614 case EM_LATTICEMICO32:
ff7eeb89 615 case EM_M32C_OLD:
49f58d10 616 case EM_M32C:
e9f53129
AM		 617 case EM_M32R:
618 case EM_MCORE:
15ab5209 619 case EM_CYGNUS_MEP:
a3c62988 620 case EM_METAG:
e9f53129
AM		 621 case EM_MMIX:
622 case EM_MN10200:
623 case EM_CYGNUS_MN10200:
624 case EM_MN10300:
625 case EM_CYGNUS_MN10300:
5506d11a 626 case EM_MOXIE:
e9f53129
AM		 627 case EM_MSP430:
628 case EM_MSP430_OLD:
d031aafb 629 case EM_MT:
64fd6348 630 case EM_NIOS32:
e9f53129
AM		 631 case EM_PPC64:
632 case EM_PPC:
99c513f6 633 case EM_RL78:
c7927a3c 634 case EM_RX:
e9f53129
AM		 635 case EM_S390:
636 case EM_S390_OLD:
637 case EM_SH:
638 case EM_SPARC:
639 case EM_SPARC32PLUS:
640 case EM_SPARCV9:
641 case EM_SPU:
40b36596 642 case EM_TI_C6000:
aa137e4d
NC		 643 case EM_TILEGX:
644 case EM_TILEPRO:
708e2187 645 case EM_V800:
e9f53129
AM		 646 case EM_V850:
647 case EM_CYGNUS_V850:
648 case EM_VAX:
649 case EM_X86_64:
8a9036a4 650 case EM_L1OM:
7a9068fe 651 case EM_K1OM:
e9f53129
AM		 652 case EM_XSTORMY16:
653 case EM_XTENSA:
654 case EM_XTENSA_OLD:
7ba29e2a
NC		 655 case EM_MICROBLAZE:
656 case EM_MICROBLAZE_OLD:
9c19a809 657 return TRUE;
103f02d3 658
e9f53129
AM		 659 case EM_68HC05:
660 case EM_68HC08:
661 case EM_68HC11:
662 case EM_68HC16:
663 case EM_FX66:
664 case EM_ME16:
d1133906 665 case EM_MMA:
d1133906
NC		 666 case EM_NCPU:
667 case EM_NDR1:
e9f53129 668 case EM_PCP:
d1133906 669 case EM_ST100:
e9f53129 670 case EM_ST19:
d1133906 671 case EM_ST7:
e9f53129
AM		 672 case EM_ST9PLUS:
673 case EM_STARCORE:
d1133906 674 case EM_SVX:
e9f53129 675 case EM_TINYJ:
9c19a809
NC		 676 default:
677 warn (_("Don't know about relocations on this machine architecture\n"));
678 return FALSE;
679 }
680}
252b5132 681
9c19a809 682static int
2cf0635d 683slurp_rela_relocs (FILE * file,
d3ba0551
AM		 684 unsigned long rel_offset,
685 unsigned long rel_size,
2cf0635d
NC		 686 Elf_Internal_Rela ** relasp,
687 unsigned long * nrelasp)
9c19a809 688{
2cf0635d 689 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 690 unsigned long nrelas;
691 unsigned int i;
252b5132 692
4d6ed7c8
NC		 693 if (is_32bit_elf)
694 {
2cf0635d 695 Elf32_External_Rela * erelas;
103f02d3 696
3f5e193b 697 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 698 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 699 if (!erelas)
700 return 0;
252b5132 701
4d6ed7c8 702 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 703
3f5e193b
NC		 704 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
705 sizeof (Elf_Internal_Rela));
103f02d3 706
4d6ed7c8
NC		 707 if (relas == NULL)
708 {
c256ffe7 709 free (erelas);
591a748a 710 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 711 return 0;
712 }
103f02d3 713
4d6ed7c8
NC		 714 for (i = 0; i < nrelas; i++)
715 {
716 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
717 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 718 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 719 }
103f02d3 720
4d6ed7c8
NC		 721 free (erelas);
722 }
723 else
724 {
2cf0635d 725 Elf64_External_Rela * erelas;
103f02d3 726
3f5e193b 727 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 728 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 729 if (!erelas)
730 return 0;
4d6ed7c8
NC		 731
732 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 733
3f5e193b
NC		 734 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
735 sizeof (Elf_Internal_Rela));
103f02d3 736
4d6ed7c8
NC		 737 if (relas == NULL)
738 {
c256ffe7 739 free (erelas);
591a748a 740 error (_("out of memory parsing relocs\n"));
4d6ed7c8 741 return 0;
9c19a809 742 }
4d6ed7c8
NC		 743
744 for (i = 0; i < nrelas; i++)
9c19a809 745 {
66543521
AM		 746 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
747 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 748 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 749
750 /* The #ifdef BFD64 below is to prevent a compile time
751 warning. We know that if we do not have a 64 bit data
752 type that we will never execute this code anyway. */
753#ifdef BFD64
754 if (elf_header.e_machine == EM_MIPS
755 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
756 {
757 /* In little-endian objects, r_info isn't really a
758 64-bit little-endian value: it has a 32-bit
759 little-endian symbol index followed by four
760 individual byte fields. Reorder INFO
761 accordingly. */
91d6fa6a
NC		 762 bfd_vma inf = relas[i].r_info;
763 inf = (((inf & 0xffffffff) << 32)
764 | ((inf >> 56) & 0xff)
765 | ((inf >> 40) & 0xff00)
766 | ((inf >> 24) & 0xff0000)
767 | ((inf >> 8) & 0xff000000));
768 relas[i].r_info = inf;
861fb55a
DJ		 769 }
770#endif /* BFD64 */
4d6ed7c8 771 }
103f02d3 772
4d6ed7c8
NC		 773 free (erelas);
774 }
775 *relasp = relas;
776 *nrelasp = nrelas;
777 return 1;
778}
103f02d3 779
4d6ed7c8 780static int
2cf0635d 781slurp_rel_relocs (FILE * file,
d3ba0551
AM		 782 unsigned long rel_offset,
783 unsigned long rel_size,
2cf0635d
NC		 784 Elf_Internal_Rela ** relsp,
785 unsigned long * nrelsp)
4d6ed7c8 786{
2cf0635d 787 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 788 unsigned long nrels;
789 unsigned int i;
103f02d3 790
4d6ed7c8
NC		 791 if (is_32bit_elf)
792 {
2cf0635d 793 Elf32_External_Rel * erels;
103f02d3 794
3f5e193b 795 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 796 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 797 if (!erels)
798 return 0;
103f02d3 799
4d6ed7c8 800 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 801
3f5e193b 802 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 803
4d6ed7c8
NC		 804 if (rels == NULL)
805 {
c256ffe7 806 free (erels);
591a748a 807 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 808 return 0;
809 }
810
811 for (i = 0; i < nrels; i++)
812 {
813 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
814 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 815 rels[i].r_addend = 0;
9ea033b2 816 }
4d6ed7c8
NC		 817
818 free (erels);
9c19a809
NC		 819 }
820 else
821 {
2cf0635d 822 Elf64_External_Rel * erels;
9ea033b2 823
3f5e193b 824 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 825 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 826 if (!erels)
827 return 0;
103f02d3 828
4d6ed7c8 829 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 830
3f5e193b 831 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 832
4d6ed7c8 833 if (rels == NULL)
9c19a809 834 {
c256ffe7 835 free (erels);
591a748a 836 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 837 return 0;
838 }
103f02d3 839
4d6ed7c8
NC		 840 for (i = 0; i < nrels; i++)
841 {
66543521
AM		 842 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
843 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 844 rels[i].r_addend = 0;
861fb55a
DJ		 845
846 /* The #ifdef BFD64 below is to prevent a compile time
847 warning. We know that if we do not have a 64 bit data
848 type that we will never execute this code anyway. */
849#ifdef BFD64
850 if (elf_header.e_machine == EM_MIPS
851 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
852 {
853 /* In little-endian objects, r_info isn't really a
854 64-bit little-endian value: it has a 32-bit
855 little-endian symbol index followed by four
856 individual byte fields. Reorder INFO
857 accordingly. */
91d6fa6a
NC		 858 bfd_vma inf = rels[i].r_info;
859 inf = (((inf & 0xffffffff) << 32)
860 | ((inf >> 56) & 0xff)
861 | ((inf >> 40) & 0xff00)
862 | ((inf >> 24) & 0xff0000)
863 | ((inf >> 8) & 0xff000000));
864 rels[i].r_info = inf;
861fb55a
DJ		 865 }
866#endif /* BFD64 */
4d6ed7c8 867 }
103f02d3 868
4d6ed7c8
NC		 869 free (erels);
870 }
871 *relsp = rels;
872 *nrelsp = nrels;
873 return 1;
874}
103f02d3 875
aca88567
NC		 876/* Returns the reloc type extracted from the reloc info field. */
877
878static unsigned int
879get_reloc_type (bfd_vma reloc_info)
880{
881 if (is_32bit_elf)
882 return ELF32_R_TYPE (reloc_info);
883
884 switch (elf_header.e_machine)
885 {
886 case EM_MIPS:
887 /* Note: We assume that reloc_info has already been adjusted for us. */
888 return ELF64_MIPS_R_TYPE (reloc_info);
889
890 case EM_SPARCV9:
891 return ELF64_R_TYPE_ID (reloc_info);
892
893 default:
894 return ELF64_R_TYPE (reloc_info);
895 }
896}
897
898/* Return the symbol index extracted from the reloc info field. */
899
900static bfd_vma
901get_reloc_symindex (bfd_vma reloc_info)
902{
903 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
904}
905
d3ba0551
AM		 906/* Display the contents of the relocation data found at the specified
907 offset. */
ee42cf8c 908
41e92641 909static void
2cf0635d 910dump_relocations (FILE * file,
d3ba0551
AM		 911 unsigned long rel_offset,
912 unsigned long rel_size,
2cf0635d 913 Elf_Internal_Sym * symtab,
d3ba0551 914 unsigned long nsyms,
2cf0635d 915 char * strtab,
d79b3d50 916 unsigned long strtablen,
d3ba0551 917 int is_rela)
4d6ed7c8 918{
b34976b6 919 unsigned int i;
2cf0635d 920 Elf_Internal_Rela * rels;
103f02d3 921
4d6ed7c8
NC		 922 if (is_rela == UNKNOWN)
923 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 924
4d6ed7c8
NC		 925 if (is_rela)
926 {
c8286bd1 927 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 928 return;
4d6ed7c8
NC		 929 }
930 else
931 {
932 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 933 return;
252b5132
RH		 934 }
935
410f7a12
L		 936 if (is_32bit_elf)
937 {
938 if (is_rela)
2c71103e
NC		 939 {
940 if (do_wide)
941 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
942 else
943 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
944 }
410f7a12 945 else
2c71103e
NC		 946 {
947 if (do_wide)
948 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
949 else
950 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
951 }
410f7a12 952 }
252b5132 953 else
410f7a12
L		 954 {
955 if (is_rela)
2c71103e
NC		 956 {
957 if (do_wide)
8beeaeb7 958 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 959 else
960 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
961 }
410f7a12 962 else
2c71103e
NC		 963 {
964 if (do_wide)
8beeaeb7 965 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 966 else
967 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
968 }
410f7a12 969 }
252b5132
RH		 970
971 for (i = 0; i < rel_size; i++)
972 {
2cf0635d 973 const char * rtype;
b34976b6 974 bfd_vma offset;
91d6fa6a 975 bfd_vma inf;
b34976b6
AM		 976 bfd_vma symtab_index;
977 bfd_vma type;
103f02d3 978
b34976b6 979 offset = rels[i].r_offset;
91d6fa6a 980 inf = rels[i].r_info;
103f02d3 981
91d6fa6a
NC		 982 type = get_reloc_type (inf);
983 symtab_index = get_reloc_symindex (inf);
252b5132 984
410f7a12
L		 985 if (is_32bit_elf)
986 {
39dbeff8
AM		 987 printf ("%8.8lx %8.8lx ",
988 (unsigned long) offset & 0xffffffff,
91d6fa6a 989 (unsigned long) inf & 0xffffffff);
410f7a12
L		 990 }
991 else
992 {
39dbeff8
AM		 993#if BFD_HOST_64BIT_LONG
994 printf (do_wide
995 ? "%16.16lx %16.16lx "
996 : "%12.12lx %12.12lx ",
91d6fa6a 997 offset, inf);
39dbeff8 998#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 999#ifndef __MSVCRT__
39dbeff8
AM		 1000 printf (do_wide
1001 ? "%16.16llx %16.16llx "
1002 : "%12.12llx %12.12llx ",
91d6fa6a 1003 offset, inf);
6e3d6dc1
NC		 1004#else
1005 printf (do_wide
1006 ? "%16.16I64x %16.16I64x "
1007 : "%12.12I64x %12.12I64x ",
91d6fa6a 1008 offset, inf);
6e3d6dc1 1009#endif
39dbeff8 1010#else
2c71103e
NC		 1011 printf (do_wide
1012 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1013 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1014 _bfd_int64_high (offset),
1015 _bfd_int64_low (offset),
91d6fa6a
NC		 1016 _bfd_int64_high (inf),
1017 _bfd_int64_low (inf));
9ea033b2 1018#endif
410f7a12 1019 }
103f02d3 1020
252b5132
RH		 1021 switch (elf_header.e_machine)
1022 {
1023 default:
1024 rtype = NULL;
1025 break;
1026
a06ea964
NC		 1027 case EM_AARCH64:
1028 rtype = elf_aarch64_reloc_type (type);
1029 break;
1030
2b0337b0 1031 case EM_M32R:
252b5132 1032 case EM_CYGNUS_M32R:
9ea033b2 1033 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1034 break;
1035
1036 case EM_386:
1037 case EM_486:
9ea033b2 1038 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1039 break;
1040
ba2685cc
AM		 1041 case EM_68HC11:
1042 case EM_68HC12:
1043 rtype = elf_m68hc11_reloc_type (type);
1044 break;
75751cd9 1045
252b5132 1046 case EM_68K:
9ea033b2 1047 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1048 break;
1049
63fcb9e9 1050 case EM_960:
9ea033b2 1051 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1052 break;
1053
adde6300 1054 case EM_AVR:
2b0337b0 1055 case EM_AVR_OLD:
adde6300
AM		 1056 rtype = elf_avr_reloc_type (type);
1057 break;
1058
9ea033b2
NC		 1059 case EM_OLD_SPARCV9:
1060 case EM_SPARC32PLUS:
1061 case EM_SPARCV9:
252b5132 1062 case EM_SPARC:
9ea033b2 1063 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1064 break;
1065
e9f53129
AM		 1066 case EM_SPU:
1067 rtype = elf_spu_reloc_type (type);
1068 break;
1069
708e2187
NC		 1070 case EM_V800:
1071 rtype = v800_reloc_type (type);
1072 break;
2b0337b0 1073 case EM_V850:
252b5132 1074 case EM_CYGNUS_V850:
9ea033b2 1075 rtype = v850_reloc_type (type);
252b5132
RH		 1076 break;
1077
2b0337b0 1078 case EM_D10V:
252b5132 1079 case EM_CYGNUS_D10V:
9ea033b2 1080 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1081 break;
1082
2b0337b0 1083 case EM_D30V:
252b5132 1084 case EM_CYGNUS_D30V:
9ea033b2 1085 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1086 break;
1087
d172d4ba
NC		 1088 case EM_DLX:
1089 rtype = elf_dlx_reloc_type (type);
1090 break;
1091
252b5132 1092 case EM_SH:
9ea033b2 1093 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1094 break;
1095
2b0337b0 1096 case EM_MN10300:
252b5132 1097 case EM_CYGNUS_MN10300:
9ea033b2 1098 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1099 break;
1100
2b0337b0 1101 case EM_MN10200:
252b5132 1102 case EM_CYGNUS_MN10200:
9ea033b2 1103 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1104 break;
1105
2b0337b0 1106 case EM_FR30:
252b5132 1107 case EM_CYGNUS_FR30:
9ea033b2 1108 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1109 break;
1110
ba2685cc
AM		 1111 case EM_CYGNUS_FRV:
1112 rtype = elf_frv_reloc_type (type);
1113 break;
5c70f934 1114
252b5132 1115 case EM_MCORE:
9ea033b2 1116 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1117 break;
1118
3c3bdf30
NC		 1119 case EM_MMIX:
1120 rtype = elf_mmix_reloc_type (type);
1121 break;
1122
5506d11a
AM		 1123 case EM_MOXIE:
1124 rtype = elf_moxie_reloc_type (type);
1125 break;
1126
2469cfa2
NC		 1127 case EM_MSP430:
1128 case EM_MSP430_OLD:
1129 rtype = elf_msp430_reloc_type (type);
1130 break;
1131
252b5132 1132 case EM_PPC:
9ea033b2 1133 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1134 break;
1135
c833c019
AM		 1136 case EM_PPC64:
1137 rtype = elf_ppc64_reloc_type (type);
1138 break;
1139
252b5132 1140 case EM_MIPS:
4fe85591 1141 case EM_MIPS_RS3_LE:
9ea033b2 1142 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1143 break;
1144
1145 case EM_ALPHA:
9ea033b2 1146 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1147 break;
1148
1149 case EM_ARM:
9ea033b2 1150 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1151 break;
1152
584da044 1153 case EM_ARC:
9ea033b2 1154 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1155 break;
1156
1157 case EM_PARISC:
69e617ca 1158 rtype = elf_hppa_reloc_type (type);
252b5132 1159 break;
7d466069 1160
b8720f9d
JL		 1161 case EM_H8_300:
1162 case EM_H8_300H:
1163 case EM_H8S:
1164 rtype = elf_h8_reloc_type (type);
1165 break;
1166
3b16e843
NC		 1167 case EM_OPENRISC:
1168 case EM_OR32:
1169 rtype = elf_or32_reloc_type (type);
1170 break;
1171
7d466069 1172 case EM_PJ:
2b0337b0 1173 case EM_PJ_OLD:
7d466069
ILT		 1174 rtype = elf_pj_reloc_type (type);
1175 break;
800eeca4
JW		 1176 case EM_IA_64:
1177 rtype = elf_ia64_reloc_type (type);
1178 break;
1b61cf92
HPN		 1179
1180 case EM_CRIS:
1181 rtype = elf_cris_reloc_type (type);
1182 break;
535c37ff
JE		 1183
1184 case EM_860:
1185 rtype = elf_i860_reloc_type (type);
1186 break;
bcedfee6
NC		 1187
1188 case EM_X86_64:
8a9036a4 1189 case EM_L1OM:
7a9068fe 1190 case EM_K1OM:
bcedfee6
NC		 1191 rtype = elf_x86_64_reloc_type (type);
1192 break;
a85d7ed0 1193
35b1837e
AM		 1194 case EM_S370:
1195 rtype = i370_reloc_type (type);
1196 break;
1197
53c7db4b
KH		 1198 case EM_S390_OLD:
1199 case EM_S390:
1200 rtype = elf_s390_reloc_type (type);
1201 break;
93fbbb04 1202
1c0d3aa6
NC		 1203 case EM_SCORE:
1204 rtype = elf_score_reloc_type (type);
1205 break;
1206
93fbbb04
GK		 1207 case EM_XSTORMY16:
1208 rtype = elf_xstormy16_reloc_type (type);
1209 break;
179d3252 1210
1fe1f39c
NC		 1211 case EM_CRX:
1212 rtype = elf_crx_reloc_type (type);
1213 break;
1214
179d3252
JT		 1215 case EM_VAX:
1216 rtype = elf_vax_reloc_type (type);
1217 break;
1e4cf259 1218
cfb8c092
NC		 1219 case EM_ADAPTEVA_EPIPHANY:
1220 rtype = elf_epiphany_reloc_type (type);
1221 break;
1222
1e4cf259
NC		 1223 case EM_IP2K:
1224 case EM_IP2K_OLD:
1225 rtype = elf_ip2k_reloc_type (type);
1226 break;
3b36097d
SC		 1227
1228 case EM_IQ2000:
1229 rtype = elf_iq2000_reloc_type (type);
1230 break;
88da6820
NC		 1231
1232 case EM_XTENSA_OLD:
1233 case EM_XTENSA:
1234 rtype = elf_xtensa_reloc_type (type);
1235 break;
a34e3ecb 1236
84e94c90
NC		 1237 case EM_LATTICEMICO32:
1238 rtype = elf_lm32_reloc_type (type);
1239 break;
1240
ff7eeb89 1241 case EM_M32C_OLD:
49f58d10
JB		 1242 case EM_M32C:
1243 rtype = elf_m32c_reloc_type (type);
1244 break;
1245
d031aafb
NS		 1246 case EM_MT:
1247 rtype = elf_mt_reloc_type (type);
a34e3ecb 1248 break;
1d65ded4
CM		 1249
1250 case EM_BLACKFIN:
1251 rtype = elf_bfin_reloc_type (type);
1252 break;
15ab5209
DB		 1253
1254 case EM_CYGNUS_MEP:
1255 rtype = elf_mep_reloc_type (type);
1256 break;
60bca95a
NC		 1257
1258 case EM_CR16:
1259 rtype = elf_cr16_reloc_type (type);
1260 break;
dd24e3da 1261
7ba29e2a
NC		 1262 case EM_MICROBLAZE:
1263 case EM_MICROBLAZE_OLD:
1264 rtype = elf_microblaze_reloc_type (type);
1265 break;
c7927a3c 1266
99c513f6
DD		 1267 case EM_RL78:
1268 rtype = elf_rl78_reloc_type (type);
1269 break;
1270
c7927a3c
NC		 1271 case EM_RX:
1272 rtype = elf_rx_reloc_type (type);
1273 break;
c29aca4a 1274
a3c62988
NC		 1275 case EM_METAG:
1276 rtype = elf_metag_reloc_type (type);
1277 break;
1278
c29aca4a
NC		 1279 case EM_XC16X:
1280 case EM_C166:
1281 rtype = elf_xc16x_reloc_type (type);
1282 break;
40b36596
JM		 1283
1284 case EM_TI_C6000:
1285 rtype = elf_tic6x_reloc_type (type);
1286 break;
aa137e4d
NC		 1287
1288 case EM_TILEGX:
1289 rtype = elf_tilegx_reloc_type (type);
1290 break;
1291
1292 case EM_TILEPRO:
1293 rtype = elf_tilepro_reloc_type (type);
1294 break;
f6c1a2d5
NC		 1295
1296 case EM_XGATE:
1297 rtype = elf_xgate_reloc_type (type);
1298 break;
36591ba1
SL		 1299
1300 case EM_ALTERA_NIOS2:
1301 rtype = elf_nios2_reloc_type (type);
1302 break;
252b5132
RH		 1303 }
1304
1305 if (rtype == NULL)
39dbeff8 1306 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1307 else
8beeaeb7 1308 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1309
7ace3541 1310 if (elf_header.e_machine == EM_ALPHA
157c2599 1311 && rtype != NULL
7ace3541
RH		 1312 && streq (rtype, "R_ALPHA_LITUSE")
1313 && is_rela)
1314 {
1315 switch (rels[i].r_addend)
1316 {
1317 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1318 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1319 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1320 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1321 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1322 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1323 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1324 default: rtype = NULL;
1325 }
1326 if (rtype)
1327 printf (" (%s)", rtype);
1328 else
1329 {
1330 putchar (' ');
1331 printf (_("<unknown addend: %lx>"),
1332 (unsigned long) rels[i].r_addend);
1333 }
1334 }
1335 else if (symtab_index)
252b5132 1336 {
af3fc3bc 1337 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1338 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1339 else
19936277 1340 {
2cf0635d 1341 Elf_Internal_Sym * psym;
19936277 1342
af3fc3bc 1343 psym = symtab + symtab_index;
103f02d3 1344
af3fc3bc 1345 printf (" ");
171191ba 1346
d8045f23
NC		 1347 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1348 {
1349 const char * name;
1350 unsigned int len;
1351 unsigned int width = is_32bit_elf ? 8 : 14;
1352
1353 /* Relocations against GNU_IFUNC symbols do not use the value
1354 of the symbol as the address to relocate against. Instead
1355 they invoke the function named by the symbol and use its
1356 result as the address for relocation.
1357
1358 To indicate this to the user, do not display the value of
1359 the symbol in the "Symbols's Value" field. Instead show
1360 its name followed by () as a hint that the symbol is
1361 invoked. */
1362
1363 if (strtab == NULL
1364 || psym->st_name == 0
1365 || psym->st_name >= strtablen)
1366 name = "??";
1367 else
1368 name = strtab + psym->st_name;
1369
1370 len = print_symbol (width, name);
1371 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1372 }
1373 else
1374 {
1375 print_vma (psym->st_value, LONG_HEX);
171191ba 1376
d8045f23
NC		 1377 printf (is_32bit_elf ? " " : " ");
1378 }
103f02d3 1379
af3fc3bc 1380 if (psym->st_name == 0)
f1ef08cb 1381 {
2cf0635d 1382 const char * sec_name = "<null>";
f1ef08cb
AM		 1383 char name_buf[40];
1384
1385 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1386 {
4fbb74a6
AM		 1387 if (psym->st_shndx < elf_header.e_shnum)
1388 sec_name
1389 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1390 else if (psym->st_shndx == SHN_ABS)
1391 sec_name = "ABS";
1392 else if (psym->st_shndx == SHN_COMMON)
1393 sec_name = "COMMON";
ac145307
BS		 1394 else if ((elf_header.e_machine == EM_MIPS
1395 && psym->st_shndx == SHN_MIPS_SCOMMON)
1396 || (elf_header.e_machine == EM_TI_C6000
1397 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1398 sec_name = "SCOMMON";
1399 else if (elf_header.e_machine == EM_MIPS
1400 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1401 sec_name = "SUNDEF";
8a9036a4 1402 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1403 || elf_header.e_machine == EM_L1OM
1404 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1405 && psym->st_shndx == SHN_X86_64_LCOMMON)
1406 sec_name = "LARGE_COMMON";
9ce701e2
L		 1407 else if (elf_header.e_machine == EM_IA_64
1408 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1409 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1410 sec_name = "ANSI_COM";
28f997cf 1411 else if (is_ia64_vms ()
148b93f2
NC		 1412 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1413 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1414 else
1415 {
1416 sprintf (name_buf, "<section 0x%x>",
1417 (unsigned int) psym->st_shndx);
1418 sec_name = name_buf;
1419 }
1420 }
1421 print_symbol (22, sec_name);
1422 }
af3fc3bc 1423 else if (strtab == NULL)
d79b3d50 1424 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1425 else if (psym->st_name >= strtablen)
d79b3d50 1426 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1427 else
2c71103e 1428 print_symbol (22, strtab + psym->st_name);
103f02d3 1429
af3fc3bc 1430 if (is_rela)
171191ba 1431 {
598aaa76 1432 bfd_signed_vma off = rels[i].r_addend;
171191ba 1433
91d6fa6a 1434 if (off < 0)
598aaa76 1435 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1436 else
598aaa76 1437 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1438 }
19936277 1439 }
252b5132 1440 }
1b228002 1441 else if (is_rela)
f7a99963 1442 {
e04d7088
L		 1443 bfd_signed_vma off = rels[i].r_addend;
1444
1445 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1446 if (off < 0)
1447 printf ("-%" BFD_VMA_FMT "x", - off);
1448 else
1449 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1450 }
252b5132 1451
157c2599
NC		 1452 if (elf_header.e_machine == EM_SPARCV9
1453 && rtype != NULL
1454 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1455 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1456
252b5132 1457 putchar ('\n');
2c71103e 1458
aca88567 1459#ifdef BFD64
53c7db4b 1460 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1461 {
91d6fa6a
NC		 1462 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1463 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1464 const char * rtype2 = elf_mips_reloc_type (type2);
1465 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1466
2c71103e
NC		 1467 printf (" Type2: ");
1468
1469 if (rtype2 == NULL)
39dbeff8
AM		 1470 printf (_("unrecognized: %-7lx"),
1471 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1472 else
1473 printf ("%-17.17s", rtype2);
1474
18bd398b 1475 printf ("\n Type3: ");
2c71103e
NC		 1476
1477 if (rtype3 == NULL)
39dbeff8
AM		 1478 printf (_("unrecognized: %-7lx"),
1479 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1480 else
1481 printf ("%-17.17s", rtype3);
1482
53c7db4b 1483 putchar ('\n');
2c71103e 1484 }
aca88567 1485#endif /* BFD64 */
252b5132
RH		 1486 }
1487
c8286bd1 1488 free (rels);
252b5132
RH		 1489}
1490
1491static const char *
d3ba0551 1492get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1493{
1494 switch (type)
1495 {
1496 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1497 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1498 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1499 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1500 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1501 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1502 case DT_MIPS_MSYM: return "MIPS_MSYM";
1503 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1504 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1505 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1506 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1507 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1508 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1509 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1510 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1511 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1512 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1513 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1514 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1515 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1516 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1517 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1518 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1519 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1520 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1521 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1522 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1523 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1524 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1525 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1526 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1527 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1528 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1529 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1530 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1531 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1532 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1533 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1534 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1535 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1536 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1537 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1538 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1539 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1540 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1541 default:
1542 return NULL;
1543 }
1544}
1545
9a097730 1546static const char *
d3ba0551 1547get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1548{
1549 switch (type)
1550 {
1551 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1552 default:
1553 return NULL;
1554 }
103f02d3
UD		 1555}
1556
7490d522
AM		 1557static const char *
1558get_ppc_dynamic_type (unsigned long type)
1559{
1560 switch (type)
1561 {
a7f2871e
AM		 1562 case DT_PPC_GOT: return "PPC_GOT";
1563 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1564 default:
1565 return NULL;
1566 }
1567}
1568
f1cb7e17 1569static const char *
d3ba0551 1570get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1571{
1572 switch (type)
1573 {
a7f2871e
AM		 1574 case DT_PPC64_GLINK: return "PPC64_GLINK";
1575 case DT_PPC64_OPD: return "PPC64_OPD";
1576 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1577 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1578 default:
1579 return NULL;
1580 }
1581}
1582
103f02d3 1583static const char *
d3ba0551 1584get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1585{
1586 switch (type)
1587 {
1588 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1589 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1590 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1591 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1592 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1593 case DT_HP_PREINIT: return "HP_PREINIT";
1594 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1595 case DT_HP_NEEDED: return "HP_NEEDED";
1596 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1597 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1598 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1599 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1600 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1601 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1602 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1603 case DT_HP_FILTERED: return "HP_FILTERED";
1604 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1605 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1606 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1607 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1608 case DT_PLT: return "PLT";
1609 case DT_PLT_SIZE: return "PLT_SIZE";
1610 case DT_DLT: return "DLT";
1611 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1612 default:
1613 return NULL;
1614 }
1615}
9a097730 1616
ecc51f48 1617static const char *
d3ba0551 1618get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1619{
1620 switch (type)
1621 {
148b93f2
NC		 1622 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1623 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1624 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1625 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1626 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1627 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1628 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1629 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1630 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1631 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1632 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1633 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1634 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1635 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1636 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1637 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1638 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1639 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1640 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1641 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1642 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1643 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1644 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1645 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1646 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1647 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1648 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1649 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1650 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1651 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1652 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1653 default:
1654 return NULL;
1655 }
1656}
1657
fabcb361
RH		 1658static const char *
1659get_alpha_dynamic_type (unsigned long type)
1660{
1661 switch (type)
1662 {
1663 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1664 default:
1665 return NULL;
1666 }
1667}
1668
1c0d3aa6
NC		 1669static const char *
1670get_score_dynamic_type (unsigned long type)
1671{
1672 switch (type)
1673 {
1674 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1675 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1676 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1677 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1678 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1679 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1680 default:
1681 return NULL;
1682 }
1683}
1684
40b36596
JM		 1685static const char *
1686get_tic6x_dynamic_type (unsigned long type)
1687{
1688 switch (type)
1689 {
1690 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1691 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1692 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1693 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1694 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1695 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1696 default:
1697 return NULL;
1698 }
1699}
1c0d3aa6 1700
36591ba1
SL		 1701static const char *
1702get_nios2_dynamic_type (unsigned long type)
1703{
1704 switch (type)
1705 {
1706 case DT_NIOS2_GP: return "NIOS2_GP";
1707 default:
1708 return NULL;
1709 }
1710}
1711
252b5132 1712static const char *
d3ba0551 1713get_dynamic_type (unsigned long type)
252b5132 1714{
e9e44622 1715 static char buff[64];
252b5132
RH		 1716
1717 switch (type)
1718 {
1719 case DT_NULL: return "NULL";
1720 case DT_NEEDED: return "NEEDED";
1721 case DT_PLTRELSZ: return "PLTRELSZ";
1722 case DT_PLTGOT: return "PLTGOT";
1723 case DT_HASH: return "HASH";
1724 case DT_STRTAB: return "STRTAB";
1725 case DT_SYMTAB: return "SYMTAB";
1726 case DT_RELA: return "RELA";
1727 case DT_RELASZ: return "RELASZ";
1728 case DT_RELAENT: return "RELAENT";
1729 case DT_STRSZ: return "STRSZ";
1730 case DT_SYMENT: return "SYMENT";
1731 case DT_INIT: return "INIT";
1732 case DT_FINI: return "FINI";
1733 case DT_SONAME: return "SONAME";
1734 case DT_RPATH: return "RPATH";
1735 case DT_SYMBOLIC: return "SYMBOLIC";
1736 case DT_REL: return "REL";
1737 case DT_RELSZ: return "RELSZ";
1738 case DT_RELENT: return "RELENT";
1739 case DT_PLTREL: return "PLTREL";
1740 case DT_DEBUG: return "DEBUG";
1741 case DT_TEXTREL: return "TEXTREL";
1742 case DT_JMPREL: return "JMPREL";
1743 case DT_BIND_NOW: return "BIND_NOW";
1744 case DT_INIT_ARRAY: return "INIT_ARRAY";
1745 case DT_FINI_ARRAY: return "FINI_ARRAY";
1746 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1747 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1748 case DT_RUNPATH: return "RUNPATH";
1749 case DT_FLAGS: return "FLAGS";
2d0e6f43 1750
d1133906
NC		 1751 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1752 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1753
05107a46 1754 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1755 case DT_PLTPADSZ: return "PLTPADSZ";
1756 case DT_MOVEENT: return "MOVEENT";
1757 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1758 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1759 case DT_POSFLAG_1: return "POSFLAG_1";
1760 case DT_SYMINSZ: return "SYMINSZ";
1761 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1762
252b5132 1763 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1764 case DT_CONFIG: return "CONFIG";
1765 case DT_DEPAUDIT: return "DEPAUDIT";
1766 case DT_AUDIT: return "AUDIT";
1767 case DT_PLTPAD: return "PLTPAD";
1768 case DT_MOVETAB: return "MOVETAB";
252b5132 1769 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1770
252b5132 1771 case DT_VERSYM: return "VERSYM";
103f02d3 1772
67a4f2b7
AO		 1773 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1774 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1775 case DT_RELACOUNT: return "RELACOUNT";
1776 case DT_RELCOUNT: return "RELCOUNT";
1777 case DT_FLAGS_1: return "FLAGS_1";
1778 case DT_VERDEF: return "VERDEF";
1779 case DT_VERDEFNUM: return "VERDEFNUM";
1780 case DT_VERNEED: return "VERNEED";
1781 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1782
019148e4 1783 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1784 case DT_USED: return "USED";
1785 case DT_FILTER: return "FILTER";
103f02d3 1786
047b2264
JJ		 1787 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1788 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1789 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1790 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1791 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1792 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1793
252b5132
RH		 1794 default:
1795 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1796 {
2cf0635d 1797 const char * result;
103f02d3 1798
252b5132
RH		 1799 switch (elf_header.e_machine)
1800 {
1801 case EM_MIPS:
4fe85591 1802 case EM_MIPS_RS3_LE:
252b5132
RH		 1803 result = get_mips_dynamic_type (type);
1804 break;
9a097730
RH		 1805 case EM_SPARCV9:
1806 result = get_sparc64_dynamic_type (type);
1807 break;
7490d522
AM		 1808 case EM_PPC:
1809 result = get_ppc_dynamic_type (type);
1810 break;
f1cb7e17
AM		 1811 case EM_PPC64:
1812 result = get_ppc64_dynamic_type (type);
1813 break;
ecc51f48
NC		 1814 case EM_IA_64:
1815 result = get_ia64_dynamic_type (type);
1816 break;
fabcb361
RH		 1817 case EM_ALPHA:
1818 result = get_alpha_dynamic_type (type);
1819 break;
1c0d3aa6
NC		 1820 case EM_SCORE:
1821 result = get_score_dynamic_type (type);
1822 break;
40b36596
JM		 1823 case EM_TI_C6000:
1824 result = get_tic6x_dynamic_type (type);
1825 break;
36591ba1
SL		 1826 case EM_ALTERA_NIOS2:
1827 result = get_nios2_dynamic_type (type);
1828 break;
252b5132
RH		 1829 default:
1830 result = NULL;
1831 break;
1832 }
1833
1834 if (result != NULL)
1835 return result;
1836
e9e44622 1837 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1838 }
eec8f817
DA		 1839 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1840 || (elf_header.e_machine == EM_PARISC
1841 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1842 {
2cf0635d 1843 const char * result;
103f02d3
UD		 1844
1845 switch (elf_header.e_machine)
1846 {
1847 case EM_PARISC:
1848 result = get_parisc_dynamic_type (type);
1849 break;
148b93f2
NC		 1850 case EM_IA_64:
1851 result = get_ia64_dynamic_type (type);
1852 break;
103f02d3
UD		 1853 default:
1854 result = NULL;
1855 break;
1856 }
1857
1858 if (result != NULL)
1859 return result;
1860
e9e44622
JJ		 1861 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1862 type);
103f02d3 1863 }
252b5132 1864 else
e9e44622 1865 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1866
252b5132
RH		 1867 return buff;
1868 }
1869}
1870
1871static char *
d3ba0551 1872get_file_type (unsigned e_type)
252b5132 1873{
b34976b6 1874 static char buff[32];
252b5132
RH		 1875
1876 switch (e_type)
1877 {
1878 case ET_NONE: return _("NONE (None)");
1879 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1880 case ET_EXEC: return _("EXEC (Executable file)");
1881 case ET_DYN: return _("DYN (Shared object file)");
1882 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1883
1884 default:
1885 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1886 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1887 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1888 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1889 else
e9e44622 1890 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1891 return buff;
1892 }
1893}
1894
1895static char *
d3ba0551 1896get_machine_name (unsigned e_machine)
252b5132 1897{
b34976b6 1898 static char buff[64]; /* XXX */
252b5132
RH		 1899
1900 switch (e_machine)
1901 {
c45021f2 1902 case EM_NONE: return _("None");
a06ea964 1903 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1904 case EM_M32: return "WE32100";
1905 case EM_SPARC: return "Sparc";
e9f53129 1906 case EM_SPU: return "SPU";
c45021f2
NC		 1907 case EM_386: return "Intel 80386";
1908 case EM_68K: return "MC68000";
1909 case EM_88K: return "MC88000";
1910 case EM_486: return "Intel 80486";
1911 case EM_860: return "Intel 80860";
1912 case EM_MIPS: return "MIPS R3000";
1913 case EM_S370: return "IBM System/370";
7036c0e1 1914 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1915 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1916 case EM_PARISC: return "HPPA";
252b5132 1917 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1918 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1919 case EM_960: return "Intel 90860";
1920 case EM_PPC: return "PowerPC";
285d1771 1921 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1922 case EM_FR20: return "Fujitsu FR20";
1923 case EM_RH32: return "TRW RH32";
b34976b6 1924 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1925 case EM_ARM: return "ARM";
1926 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1927 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1928 case EM_SPARCV9: return "Sparc v9";
1929 case EM_TRICORE: return "Siemens Tricore";
584da044 1930 case EM_ARC: return "ARC";
c2dcd04e
NC		 1931 case EM_H8_300: return "Renesas H8/300";
1932 case EM_H8_300H: return "Renesas H8/300H";
1933 case EM_H8S: return "Renesas H8S";
1934 case EM_H8_500: return "Renesas H8/500";
30800947 1935 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1936 case EM_MIPS_X: return "Stanford MIPS-X";
1937 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1938 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1939 case EM_CYGNUS_D10V:
1940 case EM_D10V: return "d10v";
1941 case EM_CYGNUS_D30V:
b34976b6 1942 case EM_D30V: return "d30v";
2b0337b0 1943 case EM_CYGNUS_M32R:
26597c86 1944 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1945 case EM_CYGNUS_V850:
708e2187 1946 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 1947 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1948 case EM_CYGNUS_MN10300:
1949 case EM_MN10300: return "mn10300";
1950 case EM_CYGNUS_MN10200:
1951 case EM_MN10200: return "mn10200";
5506d11a 1952 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1953 case EM_CYGNUS_FR30:
1954 case EM_FR30: return "Fujitsu FR30";
b34976b6 1955 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1956 case EM_PJ_OLD:
b34976b6 1957 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1958 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1959 case EM_PCP: return "Siemens PCP";
1960 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1961 case EM_NDR1: return "Denso NDR1 microprocesspr";
1962 case EM_STARCORE: return "Motorola Star*Core processor";
1963 case EM_ME16: return "Toyota ME16 processor";
1964 case EM_ST100: return "STMicroelectronics ST100 processor";
1965 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1966 case EM_PDSP: return "Sony DSP processor";
1967 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1968 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1969 case EM_FX66: return "Siemens FX66 microcontroller";
1970 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1971 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1972 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1973 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1974 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1975 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1976 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1977 case EM_SVX: return "Silicon Graphics SVx";
1978 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1979 case EM_VAX: return "Digital VAX";
2b0337b0 1980 case EM_AVR_OLD:
b34976b6 1981 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1982 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1983 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1984 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1985 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1986 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1987 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1988 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1989 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1990 case EM_L1OM: return "Intel L1OM";
7a9068fe 1991 case EM_K1OM: return "Intel K1OM";
b7498e0e 1992 case EM_S390_OLD:
b34976b6 1993 case EM_S390: return "IBM S/390";
1c0d3aa6 1994 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1995 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1996 case EM_OPENRISC:
1997 case EM_OR32: return "OpenRISC";
11636f9e 1998 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1999 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2000 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2001 case EM_DLX: return "OpenDLX";
1e4cf259 2002 case EM_IP2K_OLD:
b34976b6 2003 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2004 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2005 case EM_XTENSA_OLD:
2006 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2007 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2008 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2009 case EM_NS32K: return "National Semiconductor 32000 series";
2010 case EM_TPC: return "Tenor Network TPC processor";
2011 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2012 case EM_MAX: return "MAX Processor";
2013 case EM_CR: return "National Semiconductor CompactRISC";
2014 case EM_F2MC16: return "Fujitsu F2MC16";
2015 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2016 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2017 case EM_M32C_OLD:
49f58d10 2018 case EM_M32C: return "Renesas M32c";
d031aafb 2019 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2020 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2021 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2022 case EM_SEP: return "Sharp embedded microprocessor";
2023 case EM_ARCA: return "Arca RISC microprocessor";
2024 case EM_UNICORE: return "Unicore";
2025 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2026 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2027 case EM_NIOS32: return "Altera Nios";
2028 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2029 case EM_C166:
d70c5fc7 2030 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2031 case EM_M16C: return "Renesas M16C series microprocessors";
2032 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2033 case EM_CE: return "Freescale Communication Engine RISC core";
2034 case EM_TSK3000: return "Altium TSK3000 core";
2035 case EM_RS08: return "Freescale RS08 embedded processor";
2036 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2037 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2038 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2039 case EM_SE_C17: return "Seiko Epson C17 family";
2040 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2041 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2042 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2043 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2044 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2045 case EM_R32C: return "Renesas R32C series microprocessors";
2046 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2047 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2048 case EM_8051: return "Intel 8051 and variants";
2049 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2050 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2051 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2052 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2053 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2054 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2055 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2056 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2057 case EM_CR16:
f6c1a2d5 2058 case EM_MICROBLAZE:
7ba29e2a 2059 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2060 case EM_RL78: return "Renesas RL78";
c7927a3c 2061 case EM_RX: return "Renesas RX";
a3c62988 2062 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2063 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2064 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2065 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2066 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2067 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2068 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2069 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2070 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2071 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2072 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2073 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2074 default:
35d9dd2f 2075 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2076 return buff;
2077 }
2078}
2079
f3485b74 2080static void
d3ba0551 2081decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2082{
2083 unsigned eabi;
2084 int unknown = 0;
2085
2086 eabi = EF_ARM_EABI_VERSION (e_flags);
2087 e_flags &= ~ EF_ARM_EABIMASK;
2088
2089 /* Handle "generic" ARM flags. */
2090 if (e_flags & EF_ARM_RELEXEC)
2091 {
2092 strcat (buf, ", relocatable executable");
2093 e_flags &= ~ EF_ARM_RELEXEC;
2094 }
76da6bbe 2095
f3485b74
NC		 2096 if (e_flags & EF_ARM_HASENTRY)
2097 {
2098 strcat (buf, ", has entry point");
2099 e_flags &= ~ EF_ARM_HASENTRY;
2100 }
76da6bbe 2101
f3485b74
NC		 2102 /* Now handle EABI specific flags. */
2103 switch (eabi)
2104 {
2105 default:
2c71103e 2106 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2107 if (e_flags)
2108 unknown = 1;
2109 break;
2110
2111 case EF_ARM_EABI_VER1:
a5bcd848 2112 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2113 while (e_flags)
2114 {
2115 unsigned flag;
76da6bbe 2116
f3485b74
NC		 2117 /* Process flags one bit at a time. */
2118 flag = e_flags & - e_flags;
2119 e_flags &= ~ flag;
76da6bbe 2120
f3485b74
NC		 2121 switch (flag)
2122 {
a5bcd848 2123 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2124 strcat (buf, ", sorted symbol tables");
2125 break;
76da6bbe 2126
f3485b74
NC		 2127 default:
2128 unknown = 1;
2129 break;
2130 }
2131 }
2132 break;
76da6bbe 2133
a5bcd848
PB		 2134 case EF_ARM_EABI_VER2:
2135 strcat (buf, ", Version2 EABI");
2136 while (e_flags)
2137 {
2138 unsigned flag;
2139
2140 /* Process flags one bit at a time. */
2141 flag = e_flags & - e_flags;
2142 e_flags &= ~ flag;
2143
2144 switch (flag)
2145 {
2146 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2147 strcat (buf, ", sorted symbol tables");
2148 break;
2149
2150 case EF_ARM_DYNSYMSUSESEGIDX:
2151 strcat (buf, ", dynamic symbols use segment index");
2152 break;
2153
2154 case EF_ARM_MAPSYMSFIRST:
2155 strcat (buf, ", mapping symbols precede others");
2156 break;
2157
2158 default:
2159 unknown = 1;
2160 break;
2161 }
2162 }
2163 break;
2164
d507cf36
PB		 2165 case EF_ARM_EABI_VER3:
2166 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2167 break;
2168
2169 case EF_ARM_EABI_VER4:
2170 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2171 while (e_flags)
2172 {
2173 unsigned flag;
2174
2175 /* Process flags one bit at a time. */
2176 flag = e_flags & - e_flags;
2177 e_flags &= ~ flag;
2178
2179 switch (flag)
2180 {
2181 case EF_ARM_BE8:
2182 strcat (buf, ", BE8");
2183 break;
2184
2185 case EF_ARM_LE8:
2186 strcat (buf, ", LE8");
2187 break;
2188
2189 default:
2190 unknown = 1;
2191 break;
2192 }
2193 break;
2194 }
2195 break;
3a4a14e9
PB		 2196
2197 case EF_ARM_EABI_VER5:
2198 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2199 while (e_flags)
2200 {
2201 unsigned flag;
2202
2203 /* Process flags one bit at a time. */
2204 flag = e_flags & - e_flags;
2205 e_flags &= ~ flag;
2206
2207 switch (flag)
2208 {
2209 case EF_ARM_BE8:
2210 strcat (buf, ", BE8");
2211 break;
2212
2213 case EF_ARM_LE8:
2214 strcat (buf, ", LE8");
2215 break;
2216
3bfcb652
NC		 2217 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2218 strcat (buf, ", soft-float ABI");
2219 break;
2220
2221 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2222 strcat (buf, ", hard-float ABI");
2223 break;
2224
d507cf36
PB		 2225 default:
2226 unknown = 1;
2227 break;
2228 }
2229 }
2230 break;
2231
f3485b74 2232 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2233 strcat (buf, ", GNU EABI");
f3485b74
NC		 2234 while (e_flags)
2235 {
2236 unsigned flag;
76da6bbe 2237
f3485b74
NC		 2238 /* Process flags one bit at a time. */
2239 flag = e_flags & - e_flags;
2240 e_flags &= ~ flag;
76da6bbe 2241
f3485b74
NC		 2242 switch (flag)
2243 {
a5bcd848 2244 case EF_ARM_INTERWORK:
f3485b74
NC		 2245 strcat (buf, ", interworking enabled");
2246 break;
76da6bbe 2247
a5bcd848 2248 case EF_ARM_APCS_26:
f3485b74
NC		 2249 strcat (buf, ", uses APCS/26");
2250 break;
76da6bbe 2251
a5bcd848 2252 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2253 strcat (buf, ", uses APCS/float");
2254 break;
76da6bbe 2255
a5bcd848 2256 case EF_ARM_PIC:
f3485b74
NC		 2257 strcat (buf, ", position independent");
2258 break;
76da6bbe 2259
a5bcd848 2260 case EF_ARM_ALIGN8:
f3485b74
NC		 2261 strcat (buf, ", 8 bit structure alignment");
2262 break;
76da6bbe 2263
a5bcd848 2264 case EF_ARM_NEW_ABI:
f3485b74
NC		 2265 strcat (buf, ", uses new ABI");
2266 break;
76da6bbe 2267
a5bcd848 2268 case EF_ARM_OLD_ABI:
f3485b74
NC		 2269 strcat (buf, ", uses old ABI");
2270 break;
76da6bbe 2271
a5bcd848 2272 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2273 strcat (buf, ", software FP");
2274 break;
76da6bbe 2275
90e01f86
ILT		 2276 case EF_ARM_VFP_FLOAT:
2277 strcat (buf, ", VFP");
2278 break;
2279
fde78edd
NC		 2280 case EF_ARM_MAVERICK_FLOAT:
2281 strcat (buf, ", Maverick FP");
2282 break;
2283
f3485b74
NC		 2284 default:
2285 unknown = 1;
2286 break;
2287 }
2288 }
2289 }
f3485b74
NC		 2290
2291 if (unknown)
2b692964 2292 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2293}
2294
252b5132 2295static char *
d3ba0551 2296get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2297{
b34976b6 2298 static char buf[1024];
252b5132
RH		 2299
2300 buf[0] = '\0';
76da6bbe 2301
252b5132
RH		 2302 if (e_flags)
2303 {
2304 switch (e_machine)
2305 {
2306 default:
2307 break;
2308
f3485b74
NC		 2309 case EM_ARM:
2310 decode_ARM_machine_flags (e_flags, buf);
2311 break;
76da6bbe 2312
781303ce
MF		 2313 case EM_BLACKFIN:
2314 if (e_flags & EF_BFIN_PIC)
2315 strcat (buf, ", PIC");
2316
2317 if (e_flags & EF_BFIN_FDPIC)
2318 strcat (buf, ", FDPIC");
2319
2320 if (e_flags & EF_BFIN_CODE_IN_L1)
2321 strcat (buf, ", code in L1");
2322
2323 if (e_flags & EF_BFIN_DATA_IN_L1)
2324 strcat (buf, ", data in L1");
2325
2326 break;
2327
ec2dfb42
AO		 2328 case EM_CYGNUS_FRV:
2329 switch (e_flags & EF_FRV_CPU_MASK)
2330 {
2331 case EF_FRV_CPU_GENERIC:
2332 break;
2333
2334 default:
2335 strcat (buf, ", fr???");
2336 break;
57346661 2337
ec2dfb42
AO		 2338 case EF_FRV_CPU_FR300:
2339 strcat (buf, ", fr300");
2340 break;
2341
2342 case EF_FRV_CPU_FR400:
2343 strcat (buf, ", fr400");
2344 break;
2345 case EF_FRV_CPU_FR405:
2346 strcat (buf, ", fr405");
2347 break;
2348
2349 case EF_FRV_CPU_FR450:
2350 strcat (buf, ", fr450");
2351 break;
2352
2353 case EF_FRV_CPU_FR500:
2354 strcat (buf, ", fr500");
2355 break;
2356 case EF_FRV_CPU_FR550:
2357 strcat (buf, ", fr550");
2358 break;
2359
2360 case EF_FRV_CPU_SIMPLE:
2361 strcat (buf, ", simple");
2362 break;
2363 case EF_FRV_CPU_TOMCAT:
2364 strcat (buf, ", tomcat");
2365 break;
2366 }
1c877e87 2367 break;
ec2dfb42 2368
53c7db4b 2369 case EM_68K:
425c6cb0 2370 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2371 strcat (buf, ", m68000");
425c6cb0 2372 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2373 strcat (buf, ", cpu32");
2374 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2375 strcat (buf, ", fido_a");
425c6cb0 2376 else
266abb8f 2377 {
2cf0635d
NC		 2378 char const * isa = _("unknown");
2379 char const * mac = _("unknown mac");
2380 char const * additional = NULL;
0112cd26 2381
c694fd50 2382 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2383 {
c694fd50 2384 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2385 isa = "A";
2386 additional = ", nodiv";
2387 break;
c694fd50 2388 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2389 isa = "A";
2390 break;
c694fd50 2391 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2392 isa = "A+";
2393 break;
c694fd50 2394 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2395 isa = "B";
2396 additional = ", nousp";
2397 break;
c694fd50 2398 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2399 isa = "B";
2400 break;
f608cd77
NS		 2401 case EF_M68K_CF_ISA_C:
2402 isa = "C";
2403 break;
2404 case EF_M68K_CF_ISA_C_NODIV:
2405 isa = "C";
2406 additional = ", nodiv";
2407 break;
266abb8f
NS		 2408 }
2409 strcat (buf, ", cf, isa ");
2410 strcat (buf, isa);
0b2e31dc
NS		 2411 if (additional)
2412 strcat (buf, additional);
c694fd50 2413 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2414 strcat (buf, ", float");
c694fd50 2415 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2416 {
2417 case 0:
2418 mac = NULL;
2419 break;
c694fd50 2420 case EF_M68K_CF_MAC:
266abb8f
NS		 2421 mac = "mac";
2422 break;
c694fd50 2423 case EF_M68K_CF_EMAC:
266abb8f
NS		 2424 mac = "emac";
2425 break;
f608cd77
NS		 2426 case EF_M68K_CF_EMAC_B:
2427 mac = "emac_b";
2428 break;
266abb8f
NS		 2429 }
2430 if (mac)
2431 {
2432 strcat (buf, ", ");
2433 strcat (buf, mac);
2434 }
266abb8f 2435 }
53c7db4b 2436 break;
33c63f9d 2437
252b5132
RH		 2438 case EM_PPC:
2439 if (e_flags & EF_PPC_EMB)
2440 strcat (buf, ", emb");
2441
2442 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2443 strcat (buf, _(", relocatable"));
252b5132
RH		 2444
2445 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2446 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2447 break;
2448
708e2187
NC		 2449 case EM_V800:
2450 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2451 strcat (buf, ", RH850 ABI");
2452
2453 if (e_flags & EF_V800_850E3)
2454 strcat (buf, ", V3 architecture");
2455
2456 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2457 strcat (buf, ", FPU not used");
2458
2459 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2460 strcat (buf, ", regmode: COMMON");
2461
2462 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2463 strcat (buf, ", r4 not used");
2464
2465 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2466 strcat (buf, ", r30 not used");
2467
2468 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2469 strcat (buf, ", r5 not used");
2470
2471 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2472 strcat (buf, ", r2 not used");
2473
2474 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2475 {
2476 switch (e_flags & - e_flags)
2477 {
2478 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2479 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2480 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2481 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2482 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2483 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2484 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2485 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2486 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2487 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2488 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2489 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2490 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2491 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2492 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2493 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2494 default: break;
2495 }
2496 }
2497 break;
2498
2b0337b0 2499 case EM_V850:
252b5132
RH		 2500 case EM_CYGNUS_V850:
2501 switch (e_flags & EF_V850_ARCH)
2502 {
78c8d46c
NC		 2503 case E_V850E3V5_ARCH:
2504 strcat (buf, ", v850e3v5");
2505 break;
1cd986c5
NC		 2506 case E_V850E2V3_ARCH:
2507 strcat (buf, ", v850e2v3");
2508 break;
2509 case E_V850E2_ARCH:
2510 strcat (buf, ", v850e2");
2511 break;
2512 case E_V850E1_ARCH:
2513 strcat (buf, ", v850e1");
8ad30312 2514 break;
252b5132
RH		 2515 case E_V850E_ARCH:
2516 strcat (buf, ", v850e");
2517 break;
252b5132
RH		 2518 case E_V850_ARCH:
2519 strcat (buf, ", v850");
2520 break;
2521 default:
2b692964 2522 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2523 break;
2524 }
2525 break;
2526
2b0337b0 2527 case EM_M32R:
252b5132
RH		 2528 case EM_CYGNUS_M32R:
2529 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2530 strcat (buf, ", m32r");
252b5132
RH		 2531 break;
2532
2533 case EM_MIPS:
4fe85591 2534 case EM_MIPS_RS3_LE:
252b5132
RH		 2535 if (e_flags & EF_MIPS_NOREORDER)
2536 strcat (buf, ", noreorder");
2537
2538 if (e_flags & EF_MIPS_PIC)
2539 strcat (buf, ", pic");
2540
2541 if (e_flags & EF_MIPS_CPIC)
2542 strcat (buf, ", cpic");
2543
d1bdd336
TS		 2544 if (e_flags & EF_MIPS_UCODE)
2545 strcat (buf, ", ugen_reserved");
2546
252b5132
RH		 2547 if (e_flags & EF_MIPS_ABI2)
2548 strcat (buf, ", abi2");
2549
43521d43
TS		 2550 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2551 strcat (buf, ", odk first");
2552
a5d22d2a
TS		 2553 if (e_flags & EF_MIPS_32BITMODE)
2554 strcat (buf, ", 32bitmode");
2555
156c2f8b
NC		 2556 switch ((e_flags & EF_MIPS_MACH))
2557 {
2558 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2559 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2560 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2561 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2562 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2563 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2564 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2565 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2566 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2567 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2568 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2569 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2570 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2571 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2572 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2573 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2574 case 0:
2575 /* We simply ignore the field in this case to avoid confusion:
2576 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2577 extension. */
2578 break;
2b692964 2579 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2580 }
43521d43
TS		 2581
2582 switch ((e_flags & EF_MIPS_ABI))
2583 {
2584 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2585 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2586 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2587 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2588 case 0:
2589 /* We simply ignore the field in this case to avoid confusion:
2590 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2591 This means it is likely to be an o32 file, but not for
2592 sure. */
2593 break;
2b692964 2594 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2595 }
2596
2597 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2598 strcat (buf, ", mdmx");
2599
2600 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2601 strcat (buf, ", mips16");
2602
df58fc94
RS		 2603 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2604 strcat (buf, ", micromips");
2605
43521d43
TS		 2606 switch ((e_flags & EF_MIPS_ARCH))
2607 {
2608 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2609 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2610 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2611 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2612 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2613 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2614 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2615 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2616 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2617 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2618 }
252b5132 2619 break;
351b4b40 2620
ccde1100
AO		 2621 case EM_SH:
2622 switch ((e_flags & EF_SH_MACH_MASK))
2623 {
2624 case EF_SH1: strcat (buf, ", sh1"); break;
2625 case EF_SH2: strcat (buf, ", sh2"); break;
2626 case EF_SH3: strcat (buf, ", sh3"); break;
2627 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2628 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2629 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2630 case EF_SH3E: strcat (buf, ", sh3e"); break;
2631 case EF_SH4: strcat (buf, ", sh4"); break;
2632 case EF_SH5: strcat (buf, ", sh5"); break;
2633 case EF_SH2E: strcat (buf, ", sh2e"); break;
2634 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2635 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2636 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2637 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2638 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2639 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2640 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2641 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2642 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2643 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2644 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2645 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2646 }
2647
cec6a5b8
MR		 2648 if (e_flags & EF_SH_PIC)
2649 strcat (buf, ", pic");
2650
2651 if (e_flags & EF_SH_FDPIC)
2652 strcat (buf, ", fdpic");
ccde1100 2653 break;
57346661 2654
351b4b40
RH		 2655 case EM_SPARCV9:
2656 if (e_flags & EF_SPARC_32PLUS)
2657 strcat (buf, ", v8+");
2658
2659 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2660 strcat (buf, ", ultrasparcI");
2661
2662 if (e_flags & EF_SPARC_SUN_US3)
2663 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2664
2665 if (e_flags & EF_SPARC_HAL_R1)
2666 strcat (buf, ", halr1");
2667
2668 if (e_flags & EF_SPARC_LEDATA)
2669 strcat (buf, ", ledata");
2670
2671 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2672 strcat (buf, ", tso");
2673
2674 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2675 strcat (buf, ", pso");
2676
2677 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2678 strcat (buf, ", rmo");
2679 break;
7d466069 2680
103f02d3
UD		 2681 case EM_PARISC:
2682 switch (e_flags & EF_PARISC_ARCH)
2683 {
2684 case EFA_PARISC_1_0:
2685 strcpy (buf, ", PA-RISC 1.0");
2686 break;
2687 case EFA_PARISC_1_1:
2688 strcpy (buf, ", PA-RISC 1.1");
2689 break;
2690 case EFA_PARISC_2_0:
2691 strcpy (buf, ", PA-RISC 2.0");
2692 break;
2693 default:
2694 break;
2695 }
2696 if (e_flags & EF_PARISC_TRAPNIL)
2697 strcat (buf, ", trapnil");
2698 if (e_flags & EF_PARISC_EXT)
2699 strcat (buf, ", ext");
2700 if (e_flags & EF_PARISC_LSB)
2701 strcat (buf, ", lsb");
2702 if (e_flags & EF_PARISC_WIDE)
2703 strcat (buf, ", wide");
2704 if (e_flags & EF_PARISC_NO_KABP)
2705 strcat (buf, ", no kabp");
2706 if (e_flags & EF_PARISC_LAZYSWAP)
2707 strcat (buf, ", lazyswap");
30800947 2708 break;
76da6bbe 2709
7d466069 2710 case EM_PJ:
2b0337b0 2711 case EM_PJ_OLD:
7d466069
ILT		 2712 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2713 strcat (buf, ", new calling convention");
2714
2715 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2716 strcat (buf, ", gnu calling convention");
2717 break;
4d6ed7c8
NC		 2718
2719 case EM_IA_64:
2720 if ((e_flags & EF_IA_64_ABI64))
2721 strcat (buf, ", 64-bit");
2722 else
2723 strcat (buf, ", 32-bit");
2724 if ((e_flags & EF_IA_64_REDUCEDFP))
2725 strcat (buf, ", reduced fp model");
2726 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2727 strcat (buf, ", no function descriptors, constant gp");
2728 else if ((e_flags & EF_IA_64_CONS_GP))
2729 strcat (buf, ", constant gp");
2730 if ((e_flags & EF_IA_64_ABSOLUTE))
2731 strcat (buf, ", absolute");
28f997cf
TG		 2732 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2733 {
2734 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2735 strcat (buf, ", vms_linkages");
2736 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2737 {
2738 case EF_IA_64_VMS_COMCOD_SUCCESS:
2739 break;
2740 case EF_IA_64_VMS_COMCOD_WARNING:
2741 strcat (buf, ", warning");
2742 break;
2743 case EF_IA_64_VMS_COMCOD_ERROR:
2744 strcat (buf, ", error");
2745 break;
2746 case EF_IA_64_VMS_COMCOD_ABORT:
2747 strcat (buf, ", abort");
2748 break;
2749 default:
2750 abort ();
2751 }
2752 }
4d6ed7c8 2753 break;
179d3252
JT		 2754
2755 case EM_VAX:
2756 if ((e_flags & EF_VAX_NONPIC))
2757 strcat (buf, ", non-PIC");
2758 if ((e_flags & EF_VAX_DFLOAT))
2759 strcat (buf, ", D-Float");
2760 if ((e_flags & EF_VAX_GFLOAT))
2761 strcat (buf, ", G-Float");
2762 break;
c7927a3c
NC		 2763
2764 case EM_RX:
2765 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2766 strcat (buf, ", 64-bit doubles");
2767 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2768 strcat (buf, ", dsp");
d4cb0ea0
NC		 2769 if (e_flags & E_FLAG_RX_PID)
2770 strcat (buf, ", pid");
708e2187
NC		 2771 if (e_flags & E_FLAG_RX_ABI)
2772 strcat (buf, ", RX ABI");
d4cb0ea0 2773 break;
55786da2
AK		 2774
2775 case EM_S390:
2776 if (e_flags & EF_S390_HIGH_GPRS)
2777 strcat (buf, ", highgprs");
d4cb0ea0 2778 break;
40b36596
JM		 2779
2780 case EM_TI_C6000:
2781 if ((e_flags & EF_C6000_REL))
2782 strcat (buf, ", relocatable module");
d4cb0ea0 2783 break;
252b5132
RH		 2784 }
2785 }
2786
2787 return buf;
2788}
2789
252b5132 2790static const char *
d3ba0551
AM		 2791get_osabi_name (unsigned int osabi)
2792{
2793 static char buff[32];
2794
2795 switch (osabi)
2796 {
2797 case ELFOSABI_NONE: return "UNIX - System V";
2798 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2799 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2800 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2801 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2802 case ELFOSABI_AIX: return "UNIX - AIX";
2803 case ELFOSABI_IRIX: return "UNIX - IRIX";
2804 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2805 case ELFOSABI_TRU64: return "UNIX - TRU64";
2806 case ELFOSABI_MODESTO: return "Novell - Modesto";
2807 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2808 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2809 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2810 case ELFOSABI_AROS: return "AROS";
11636f9e 2811 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2812 default:
40b36596
JM		 2813 if (osabi >= 64)
2814 switch (elf_header.e_machine)
2815 {
2816 case EM_ARM:
2817 switch (osabi)
2818 {
2819 case ELFOSABI_ARM: return "ARM";
2820 default:
2821 break;
2822 }
2823 break;
2824
2825 case EM_MSP430:
2826 case EM_MSP430_OLD:
2827 switch (osabi)
2828 {
2829 case ELFOSABI_STANDALONE: return _("Standalone App");
2830 default:
2831 break;
2832 }
2833 break;
2834
2835 case EM_TI_C6000:
2836 switch (osabi)
2837 {
2838 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2839 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2840 default:
2841 break;
2842 }
2843 break;
2844
2845 default:
2846 break;
2847 }
e9e44622 2848 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2849 return buff;
2850 }
2851}
2852
a06ea964
NC		 2853static const char *
2854get_aarch64_segment_type (unsigned long type)
2855{
2856 switch (type)
2857 {
2858 case PT_AARCH64_ARCHEXT:
2859 return "AARCH64_ARCHEXT";
2860 default:
2861 break;
2862 }
2863
2864 return NULL;
2865}
2866
b294bdf8
MM		 2867static const char *
2868get_arm_segment_type (unsigned long type)
2869{
2870 switch (type)
2871 {
2872 case PT_ARM_EXIDX:
2873 return "EXIDX";
2874 default:
2875 break;
2876 }
2877
2878 return NULL;
2879}
2880
d3ba0551
AM		 2881static const char *
2882get_mips_segment_type (unsigned long type)
252b5132
RH		 2883{
2884 switch (type)
2885 {
2886 case PT_MIPS_REGINFO:
2887 return "REGINFO";
2888 case PT_MIPS_RTPROC:
2889 return "RTPROC";
2890 case PT_MIPS_OPTIONS:
2891 return "OPTIONS";
2892 default:
2893 break;
2894 }
2895
2896 return NULL;
2897}
2898
103f02d3 2899static const char *
d3ba0551 2900get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2901{
2902 switch (type)
2903 {
2904 case PT_HP_TLS: return "HP_TLS";
2905 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2906 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2907 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2908 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2909 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2910 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2911 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2912 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2913 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2914 case PT_HP_PARALLEL: return "HP_PARALLEL";
2915 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2916 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2917 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2918 case PT_HP_STACK: return "HP_STACK";
2919 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2920 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2921 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2922 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2923 default:
2924 break;
2925 }
2926
2927 return NULL;
2928}
2929
4d6ed7c8 2930static const char *
d3ba0551 2931get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2932{
2933 switch (type)
2934 {
2935 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2936 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2937 case PT_HP_TLS: return "HP_TLS";
2938 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2939 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2940 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2941 default:
2942 break;
2943 }
2944
2945 return NULL;
2946}
2947
40b36596
JM		 2948static const char *
2949get_tic6x_segment_type (unsigned long type)
2950{
2951 switch (type)
2952 {
2953 case PT_C6000_PHATTR: return "C6000_PHATTR";
2954 default:
2955 break;
2956 }
2957
2958 return NULL;
2959}
2960
252b5132 2961static const char *
d3ba0551 2962get_segment_type (unsigned long p_type)
252b5132 2963{
b34976b6 2964 static char buff[32];
252b5132
RH		 2965
2966 switch (p_type)
2967 {
b34976b6
AM		 2968 case PT_NULL: return "NULL";
2969 case PT_LOAD: return "LOAD";
252b5132 2970 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2971 case PT_INTERP: return "INTERP";
2972 case PT_NOTE: return "NOTE";
2973 case PT_SHLIB: return "SHLIB";
2974 case PT_PHDR: return "PHDR";
13ae64f3 2975 case PT_TLS: return "TLS";
252b5132 2976
65765700
JJ		 2977 case PT_GNU_EH_FRAME:
2978 return "GNU_EH_FRAME";
2b05f1b7 2979 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2980 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2981
252b5132
RH		 2982 default:
2983 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2984 {
2cf0635d 2985 const char * result;
103f02d3 2986
252b5132
RH		 2987 switch (elf_header.e_machine)
2988 {
a06ea964
NC		 2989 case EM_AARCH64:
2990 result = get_aarch64_segment_type (p_type);
2991 break;
b294bdf8
MM		 2992 case EM_ARM:
2993 result = get_arm_segment_type (p_type);
2994 break;
252b5132 2995 case EM_MIPS:
4fe85591 2996 case EM_MIPS_RS3_LE:
252b5132
RH		 2997 result = get_mips_segment_type (p_type);
2998 break;
103f02d3
UD		 2999 case EM_PARISC:
3000 result = get_parisc_segment_type (p_type);
3001 break;
4d6ed7c8
NC		 3002 case EM_IA_64:
3003 result = get_ia64_segment_type (p_type);
3004 break;
40b36596
JM		 3005 case EM_TI_C6000:
3006 result = get_tic6x_segment_type (p_type);
3007 break;
252b5132
RH		 3008 default:
3009 result = NULL;
3010 break;
3011 }
103f02d3 3012
252b5132
RH		 3013 if (result != NULL)
3014 return result;
103f02d3 3015
252b5132
RH		 3016 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3017 }
3018 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3019 {
2cf0635d 3020 const char * result;
103f02d3
UD		 3021
3022 switch (elf_header.e_machine)
3023 {
3024 case EM_PARISC:
3025 result = get_parisc_segment_type (p_type);
3026 break;
00428cca
AM		 3027 case EM_IA_64:
3028 result = get_ia64_segment_type (p_type);
3029 break;
103f02d3
UD		 3030 default:
3031 result = NULL;
3032 break;
3033 }
3034
3035 if (result != NULL)
3036 return result;
3037
3038 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3039 }
252b5132 3040 else
e9e44622 3041 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3042
3043 return buff;
3044 }
3045}
3046
3047static const char *
d3ba0551 3048get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3049{
3050 switch (sh_type)
3051 {
b34976b6
AM		 3052 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3053 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3054 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3055 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3056 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3057 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3058 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3059 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3060 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3061 case SHT_MIPS_RELD: return "MIPS_RELD";
3062 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3063 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3064 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3065 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3066 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3067 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3068 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3069 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3070 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3071 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3072 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3073 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3074 case SHT_MIPS_LINE: return "MIPS_LINE";
3075 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3076 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3077 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3078 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3079 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3080 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3081 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3082 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3083 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3084 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3085 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3086 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3087 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3088 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3089 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 3090 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3091 default:
3092 break;
3093 }
3094 return NULL;
3095}
3096
103f02d3 3097static const char *
d3ba0551 3098get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3099{
3100 switch (sh_type)
3101 {
3102 case SHT_PARISC_EXT: return "PARISC_EXT";
3103 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3104 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3105 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3106 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3107 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3108 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3109 default:
3110 break;
3111 }
3112 return NULL;
3113}
3114
4d6ed7c8 3115static const char *
d3ba0551 3116get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3117{
18bd398b 3118 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3119 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3120 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3121
4d6ed7c8
NC		 3122 switch (sh_type)
3123 {
148b93f2
NC		 3124 case SHT_IA_64_EXT: return "IA_64_EXT";
3125 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3126 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3127 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3128 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3129 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3130 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3131 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3132 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3133 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3134 default:
3135 break;
3136 }
3137 return NULL;
3138}
3139
d2b2c203
DJ		 3140static const char *
3141get_x86_64_section_type_name (unsigned int sh_type)
3142{
3143 switch (sh_type)
3144 {
3145 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3146 default:
3147 break;
3148 }
3149 return NULL;
3150}
3151
a06ea964
NC		 3152static const char *
3153get_aarch64_section_type_name (unsigned int sh_type)
3154{
3155 switch (sh_type)
3156 {
3157 case SHT_AARCH64_ATTRIBUTES:
3158 return "AARCH64_ATTRIBUTES";
3159 default:
3160 break;
3161 }
3162 return NULL;
3163}
3164
40a18ebd
NC		 3165static const char *
3166get_arm_section_type_name (unsigned int sh_type)
3167{
3168 switch (sh_type)
3169 {
7f6fed87
NC		 3170 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3171 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3172 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3173 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3174 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3175 default:
3176 break;
3177 }
3178 return NULL;
3179}
3180
40b36596
JM		 3181static const char *
3182get_tic6x_section_type_name (unsigned int sh_type)
3183{
3184 switch (sh_type)
3185 {
3186 case SHT_C6000_UNWIND:
3187 return "C6000_UNWIND";
3188 case SHT_C6000_PREEMPTMAP:
3189 return "C6000_PREEMPTMAP";
3190 case SHT_C6000_ATTRIBUTES:
3191 return "C6000_ATTRIBUTES";
3192 case SHT_TI_ICODE:
3193 return "TI_ICODE";
3194 case SHT_TI_XREF:
3195 return "TI_XREF";
3196 case SHT_TI_HANDLER:
3197 return "TI_HANDLER";
3198 case SHT_TI_INITINFO:
3199 return "TI_INITINFO";
3200 case SHT_TI_PHATTRS:
3201 return "TI_PHATTRS";
3202 default:
3203 break;
3204 }
3205 return NULL;
3206}
3207
252b5132 3208static const char *
d3ba0551 3209get_section_type_name (unsigned int sh_type)
252b5132 3210{
b34976b6 3211 static char buff[32];
252b5132
RH		 3212
3213 switch (sh_type)
3214 {
3215 case SHT_NULL: return "NULL";
3216 case SHT_PROGBITS: return "PROGBITS";
3217 case SHT_SYMTAB: return "SYMTAB";
3218 case SHT_STRTAB: return "STRTAB";
3219 case SHT_RELA: return "RELA";
3220 case SHT_HASH: return "HASH";
3221 case SHT_DYNAMIC: return "DYNAMIC";
3222 case SHT_NOTE: return "NOTE";
3223 case SHT_NOBITS: return "NOBITS";
3224 case SHT_REL: return "REL";
3225 case SHT_SHLIB: return "SHLIB";
3226 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3227 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3228 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3229 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3230 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3231 case SHT_GROUP: return "GROUP";
3232 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3233 case SHT_GNU_verdef: return "VERDEF";
3234 case SHT_GNU_verneed: return "VERNEED";
3235 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3236 case 0x6ffffff0: return "VERSYM";
3237 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3238 case 0x7ffffffd: return "AUXILIARY";
3239 case 0x7fffffff: return "FILTER";
047b2264 3240 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3241
3242 default:
3243 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3244 {
2cf0635d 3245 const char * result;
252b5132
RH		 3246
3247 switch (elf_header.e_machine)
3248 {
3249 case EM_MIPS:
4fe85591 3250 case EM_MIPS_RS3_LE:
252b5132
RH		 3251 result = get_mips_section_type_name (sh_type);
3252 break;
103f02d3
UD		 3253 case EM_PARISC:
3254 result = get_parisc_section_type_name (sh_type);
3255 break;
4d6ed7c8
NC		 3256 case EM_IA_64:
3257 result = get_ia64_section_type_name (sh_type);
3258 break;
d2b2c203 3259 case EM_X86_64:
8a9036a4 3260 case EM_L1OM:
7a9068fe 3261 case EM_K1OM:
d2b2c203
DJ		 3262 result = get_x86_64_section_type_name (sh_type);
3263 break;
a06ea964
NC		 3264 case EM_AARCH64:
3265 result = get_aarch64_section_type_name (sh_type);
3266 break;
40a18ebd
NC		 3267 case EM_ARM:
3268 result = get_arm_section_type_name (sh_type);
3269 break;
40b36596
JM		 3270 case EM_TI_C6000:
3271 result = get_tic6x_section_type_name (sh_type);
3272 break;
252b5132
RH		 3273 default:
3274 result = NULL;
3275 break;
3276 }
3277
3278 if (result != NULL)
3279 return result;
3280
c91d0dfb 3281 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3282 }
3283 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3284 {
2cf0635d 3285 const char * result;
148b93f2
NC		 3286
3287 switch (elf_header.e_machine)
3288 {
3289 case EM_IA_64:
3290 result = get_ia64_section_type_name (sh_type);
3291 break;
3292 default:
3293 result = NULL;
3294 break;
3295 }
3296
3297 if (result != NULL)
3298 return result;
3299
3300 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3301 }
252b5132 3302 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3303 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3304 else
a7dbfd1c
NC		 3305 /* This message is probably going to be displayed in a 15
3306 character wide field, so put the hex value first. */
3307 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3308
252b5132
RH		 3309 return buff;
3310 }
3311}
3312
2979dc34 3313#define OPTION_DEBUG_DUMP 512
2c610e4b 3314#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3315#define OPTION_DWARF_DEPTH 514
3316#define OPTION_DWARF_START 515
4723351a 3317#define OPTION_DWARF_CHECK 516
2979dc34 3318
85b1c36d 3319static struct option options[] =
252b5132 3320{
b34976b6 3321 {"all", no_argument, 0, 'a'},
252b5132
RH		 3322 {"file-header", no_argument, 0, 'h'},
3323 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3324 {"headers", no_argument, 0, 'e'},
3325 {"histogram", no_argument, 0, 'I'},
3326 {"segments", no_argument, 0, 'l'},
3327 {"sections", no_argument, 0, 'S'},
252b5132 3328 {"section-headers", no_argument, 0, 'S'},
f5842774 3329 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3330 {"section-details", no_argument, 0, 't'},
595cf52e 3331 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3332 {"symbols", no_argument, 0, 's'},
3333 {"syms", no_argument, 0, 's'},
2c610e4b 3334 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3335 {"relocs", no_argument, 0, 'r'},
3336 {"notes", no_argument, 0, 'n'},
3337 {"dynamic", no_argument, 0, 'd'},
a952a375 3338 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3339 {"version-info", no_argument, 0, 'V'},
3340 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3341 {"unwind", no_argument, 0, 'u'},
4145f1d5 3342 {"archive-index", no_argument, 0, 'c'},
b34976b6 3343 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3344 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3345 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3346#ifdef SUPPORT_DISASSEMBLY
3347 {"instruction-dump", required_argument, 0, 'i'},
3348#endif
cf13d699 3349 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3350
fd2f0033
TT		 3351 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3352 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3353 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3354
b34976b6
AM		 3355 {"version", no_argument, 0, 'v'},
3356 {"wide", no_argument, 0, 'W'},
3357 {"help", no_argument, 0, 'H'},
3358 {0, no_argument, 0, 0}
252b5132
RH		 3359};
3360
3361static void
2cf0635d 3362usage (FILE * stream)
252b5132 3363{
92f01d61
JM		 3364 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3365 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3366 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3367 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3368 -h --file-header Display the ELF file header\n\
3369 -l --program-headers Display the program headers\n\
3370 --segments An alias for --program-headers\n\
3371 -S --section-headers Display the sections' header\n\
3372 --sections An alias for --section-headers\n\
f5842774 3373 -g --section-groups Display the section groups\n\
5477e8a0 3374 -t --section-details Display the section details\n\
8b53311e
NC		 3375 -e --headers Equivalent to: -h -l -S\n\
3376 -s --syms Display the symbol table\n\
3f08eb35 3377 --symbols An alias for --syms\n\
2c610e4b 3378 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3379 -n --notes Display the core notes (if present)\n\
3380 -r --relocs Display the relocations (if present)\n\
3381 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3382 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3383 -V --version-info Display the version sections (if present)\n\
1b31d05e 3384 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3385 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3386 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3387 -x --hex-dump=<number|name>\n\
3388 Dump the contents of section <number|name> as bytes\n\
3389 -p --string-dump=<number|name>\n\
3390 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3391 -R --relocated-dump=<number|name>\n\
3392 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3393 -w[lLiaprmfFsoRt] or\n\
1ed06042 3394 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3395 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3396 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3397 =addr,=cu_index]\n\
8b53311e 3398 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3399 fprintf (stream, _("\
3400 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3401 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3402 or deeper\n"));
252b5132 3403#ifdef SUPPORT_DISASSEMBLY
92f01d61 3404 fprintf (stream, _("\
09c11c86
NC		 3405 -i --instruction-dump=<number|name>\n\
3406 Disassemble the contents of section <number|name>\n"));
252b5132 3407#endif
92f01d61 3408 fprintf (stream, _("\
8b53311e
NC		 3409 -I --histogram Display histogram of bucket list lengths\n\
3410 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3411 @<file> Read options from <file>\n\
8b53311e
NC		 3412 -H --help Display this information\n\
3413 -v --version Display the version number of readelf\n"));
1118d252 3414
92f01d61
JM		 3415 if (REPORT_BUGS_TO[0] && stream == stdout)
3416 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3417
92f01d61 3418 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3419}
3420
18bd398b
NC		 3421/* Record the fact that the user wants the contents of section number
3422 SECTION to be displayed using the method(s) encoded as flags bits
3423 in TYPE. Note, TYPE can be zero if we are creating the array for
3424 the first time. */
3425
252b5132 3426static void
09c11c86 3427request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3428{
3429 if (section >= num_dump_sects)
3430 {
2cf0635d 3431 dump_type * new_dump_sects;
252b5132 3432
3f5e193b
NC		 3433 new_dump_sects = (dump_type *) calloc (section + 1,
3434 sizeof (* dump_sects));
252b5132
RH		 3435
3436 if (new_dump_sects == NULL)
591a748a 3437 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3438 else
3439 {
3440 /* Copy current flag settings. */
09c11c86 3441 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3442
3443 free (dump_sects);
3444
3445 dump_sects = new_dump_sects;
3446 num_dump_sects = section + 1;
3447 }
3448 }
3449
3450 if (dump_sects)
b34976b6 3451 dump_sects[section] |= type;
252b5132
RH		 3452
3453 return;
3454}
3455
aef1f6d0
DJ		 3456/* Request a dump by section name. */
3457
3458static void
2cf0635d 3459request_dump_byname (const char * section, dump_type type)
aef1f6d0 3460{
2cf0635d 3461 struct dump_list_entry * new_request;
aef1f6d0 3462
3f5e193b
NC		 3463 new_request = (struct dump_list_entry *)
3464 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3465 if (!new_request)
591a748a 3466 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3467
3468 new_request->name = strdup (section);
3469 if (!new_request->name)
591a748a 3470 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3471
3472 new_request->type = type;
3473
3474 new_request->next = dump_sects_byname;
3475 dump_sects_byname = new_request;
3476}
3477
cf13d699
NC		 3478static inline void
3479request_dump (dump_type type)
3480{
3481 int section;
3482 char * cp;
3483
3484 do_dump++;
3485 section = strtoul (optarg, & cp, 0);
3486
3487 if (! *cp && section >= 0)
3488 request_dump_bynumber (section, type);
3489 else
3490 request_dump_byname (optarg, type);
3491}
3492
3493
252b5132 3494static void
2cf0635d 3495parse_args (int argc, char ** argv)
252b5132
RH		 3496{
3497 int c;
3498
3499 if (argc < 2)
92f01d61 3500 usage (stderr);
252b5132
RH		 3501
3502 while ((c = getopt_long
cf13d699 3503 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3504 {
252b5132
RH		 3505 switch (c)
3506 {
3507 case 0:
3508 /* Long options. */
3509 break;
3510 case 'H':
92f01d61 3511 usage (stdout);
252b5132
RH		 3512 break;
3513
3514 case 'a':
b34976b6
AM		 3515 do_syms++;
3516 do_reloc++;
3517 do_unwind++;
3518 do_dynamic++;
3519 do_header++;
3520 do_sections++;
f5842774 3521 do_section_groups++;
b34976b6
AM		 3522 do_segments++;
3523 do_version++;
3524 do_histogram++;
3525 do_arch++;
3526 do_notes++;
252b5132 3527 break;
f5842774
L		 3528 case 'g':
3529 do_section_groups++;
3530 break;
5477e8a0 3531 case 't':
595cf52e 3532 case 'N':
5477e8a0
L		 3533 do_sections++;
3534 do_section_details++;
595cf52e 3535 break;
252b5132 3536 case 'e':
b34976b6
AM		 3537 do_header++;
3538 do_sections++;
3539 do_segments++;
252b5132 3540 break;
a952a375 3541 case 'A':
b34976b6 3542 do_arch++;
a952a375 3543 break;
252b5132 3544 case 'D':
b34976b6 3545 do_using_dynamic++;
252b5132
RH		 3546 break;
3547 case 'r':
b34976b6 3548 do_reloc++;
252b5132 3549 break;
4d6ed7c8 3550 case 'u':
b34976b6 3551 do_unwind++;
4d6ed7c8 3552 break;
252b5132 3553 case 'h':
b34976b6 3554 do_header++;
252b5132
RH		 3555 break;
3556 case 'l':
b34976b6 3557 do_segments++;
252b5132
RH		 3558 break;
3559 case 's':
b34976b6 3560 do_syms++;
252b5132
RH		 3561 break;
3562 case 'S':
b34976b6 3563 do_sections++;
252b5132
RH		 3564 break;
3565 case 'd':
b34976b6 3566 do_dynamic++;
252b5132 3567 break;
a952a375 3568 case 'I':
b34976b6 3569 do_histogram++;
a952a375 3570 break;
779fe533 3571 case 'n':
b34976b6 3572 do_notes++;
779fe533 3573 break;
4145f1d5
NC		 3574 case 'c':
3575 do_archive_index++;
3576 break;
252b5132 3577 case 'x':
cf13d699 3578 request_dump (HEX_DUMP);
aef1f6d0 3579 break;
09c11c86 3580 case 'p':
cf13d699
NC		 3581 request_dump (STRING_DUMP);
3582 break;
3583 case 'R':
3584 request_dump (RELOC_DUMP);
09c11c86 3585 break;
252b5132 3586 case 'w':
b34976b6 3587 do_dump++;
252b5132 3588 if (optarg == 0)
613ff48b
CC		 3589 {
3590 do_debugging = 1;
3591 dwarf_select_sections_all ();
3592 }
252b5132
RH		 3593 else
3594 {
3595 do_debugging = 0;
4cb93e3b 3596 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3597 }
3598 break;
2979dc34 3599 case OPTION_DEBUG_DUMP:
b34976b6 3600 do_dump++;
2979dc34
JJ		 3601 if (optarg == 0)
3602 do_debugging = 1;
3603 else
3604 {
2979dc34 3605 do_debugging = 0;
4cb93e3b 3606 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3607 }
3608 break;
fd2f0033
TT		 3609 case OPTION_DWARF_DEPTH:
3610 {
3611 char *cp;
3612
3613 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3614 }
3615 break;
3616 case OPTION_DWARF_START:
3617 {
3618 char *cp;
3619
3620 dwarf_start_die = strtoul (optarg, & cp, 0);
3621 }
3622 break;
4723351a
CC		 3623 case OPTION_DWARF_CHECK:
3624 dwarf_check = 1;
3625 break;
2c610e4b
L		 3626 case OPTION_DYN_SYMS:
3627 do_dyn_syms++;
3628 break;
252b5132
RH		 3629#ifdef SUPPORT_DISASSEMBLY
3630 case 'i':
cf13d699
NC		 3631 request_dump (DISASS_DUMP);
3632 break;
252b5132
RH		 3633#endif
3634 case 'v':
3635 print_version (program_name);
3636 break;
3637 case 'V':
b34976b6 3638 do_version++;
252b5132 3639 break;
d974e256 3640 case 'W':
b34976b6 3641 do_wide++;
d974e256 3642 break;
252b5132 3643 default:
252b5132
RH		 3644 /* xgettext:c-format */
3645 error (_("Invalid option '-%c'\n"), c);
3646 /* Drop through. */
3647 case '?':
92f01d61 3648 usage (stderr);
252b5132
RH		 3649 }
3650 }
3651
4d6ed7c8 3652 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3653 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3654 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3655 && !do_section_groups && !do_archive_index
3656 && !do_dyn_syms)
92f01d61 3657 usage (stderr);
252b5132
RH		 3658 else if (argc < 3)
3659 {
3660 warn (_("Nothing to do.\n"));
92f01d61 3661 usage (stderr);
252b5132
RH		 3662 }
3663}
3664
3665static const char *
d3ba0551 3666get_elf_class (unsigned int elf_class)
252b5132 3667{
b34976b6 3668 static char buff[32];
103f02d3 3669
252b5132
RH		 3670 switch (elf_class)
3671 {
3672 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3673 case ELFCLASS32: return "ELF32";
3674 case ELFCLASS64: return "ELF64";
ab5e7794 3675 default:
e9e44622 3676 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3677 return buff;
252b5132
RH		 3678 }
3679}
3680
3681static const char *
d3ba0551 3682get_data_encoding (unsigned int encoding)
252b5132 3683{
b34976b6 3684 static char buff[32];
103f02d3 3685
252b5132
RH		 3686 switch (encoding)
3687 {
3688 case ELFDATANONE: return _("none");
33c63f9d
CM		 3689 case ELFDATA2LSB: return _("2's complement, little endian");
3690 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3691 default:
e9e44622 3692 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3693 return buff;
252b5132
RH		 3694 }
3695}
3696
252b5132 3697/* Decode the data held in 'elf_header'. */
ee42cf8c 3698
252b5132 3699static int
d3ba0551 3700process_file_header (void)
252b5132 3701{
b34976b6
AM		 3702 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3703 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3704 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3705 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3706 {
3707 error
3708 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3709 return 0;
3710 }
3711
2dc4cec1
L		 3712 init_dwarf_regnames (elf_header.e_machine);
3713
252b5132
RH		 3714 if (do_header)
3715 {
3716 int i;
3717
3718 printf (_("ELF Header:\n"));
3719 printf (_(" Magic: "));
b34976b6
AM		 3720 for (i = 0; i < EI_NIDENT; i++)
3721 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3722 printf ("\n");
3723 printf (_(" Class: %s\n"),
b34976b6 3724 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3725 printf (_(" Data: %s\n"),
b34976b6 3726 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3727 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3728 elf_header.e_ident[EI_VERSION],
3729 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3730 ? "(current)"
b34976b6 3731 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3732 ? _("<unknown: %lx>")
789be9f7 3733 : "")));
252b5132 3734 printf (_(" OS/ABI: %s\n"),
b34976b6 3735 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3736 printf (_(" ABI Version: %d\n"),
b34976b6 3737 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3738 printf (_(" Type: %s\n"),
3739 get_file_type (elf_header.e_type));
3740 printf (_(" Machine: %s\n"),
3741 get_machine_name (elf_header.e_machine));
3742 printf (_(" Version: 0x%lx\n"),
3743 (unsigned long) elf_header.e_version);
76da6bbe 3744
f7a99963
NC		 3745 printf (_(" Entry point address: "));
3746 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3747 printf (_("\n Start of program headers: "));
3748 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3749 printf (_(" (bytes into file)\n Start of section headers: "));
3750 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3751 printf (_(" (bytes into file)\n"));
76da6bbe 3752
252b5132
RH		 3753 printf (_(" Flags: 0x%lx%s\n"),
3754 (unsigned long) elf_header.e_flags,
3755 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3756 printf (_(" Size of this header: %ld (bytes)\n"),
3757 (long) elf_header.e_ehsize);
3758 printf (_(" Size of program headers: %ld (bytes)\n"),
3759 (long) elf_header.e_phentsize);
2046a35d 3760 printf (_(" Number of program headers: %ld"),
252b5132 3761 (long) elf_header.e_phnum);
2046a35d
AM		 3762 if (section_headers != NULL
3763 && elf_header.e_phnum == PN_XNUM
3764 && section_headers[0].sh_info != 0)
cc5914eb 3765 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3766 putc ('\n', stdout);
252b5132
RH		 3767 printf (_(" Size of section headers: %ld (bytes)\n"),
3768 (long) elf_header.e_shentsize);
560f3c1c 3769 printf (_(" Number of section headers: %ld"),
252b5132 3770 (long) elf_header.e_shnum);
4fbb74a6 3771 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3772 printf (" (%ld)", (long) section_headers[0].sh_size);
3773 putc ('\n', stdout);
3774 printf (_(" Section header string table index: %ld"),
252b5132 3775 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3776 if (section_headers != NULL
3777 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3778 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3779 else if (elf_header.e_shstrndx != SHN_UNDEF
3780 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3781 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3782 putc ('\n', stdout);
3783 }
3784
3785 if (section_headers != NULL)
3786 {
2046a35d
AM		 3787 if (elf_header.e_phnum == PN_XNUM
3788 && section_headers[0].sh_info != 0)
3789 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3790 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3791 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3792 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3793 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3794 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3795 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3796 free (section_headers);
3797 section_headers = NULL;
252b5132 3798 }
103f02d3 3799
9ea033b2
NC		 3800 return 1;
3801}
3802
252b5132 3803
9ea033b2 3804static int
91d6fa6a 3805get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3806{
2cf0635d
NC		 3807 Elf32_External_Phdr * phdrs;
3808 Elf32_External_Phdr * external;
3809 Elf_Internal_Phdr * internal;
b34976b6 3810 unsigned int i;
103f02d3 3811
3f5e193b
NC		 3812 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3813 elf_header.e_phentsize,
3814 elf_header.e_phnum,
3815 _("program headers"));
a6e9f9df
AM		 3816 if (!phdrs)
3817 return 0;
9ea033b2 3818
91d6fa6a 3819 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3820 i < elf_header.e_phnum;
b34976b6 3821 i++, internal++, external++)
252b5132 3822 {
9ea033b2
NC		 3823 internal->p_type = BYTE_GET (external->p_type);
3824 internal->p_offset = BYTE_GET (external->p_offset);
3825 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3826 internal->p_paddr = BYTE_GET (external->p_paddr);
3827 internal->p_filesz = BYTE_GET (external->p_filesz);
3828 internal->p_memsz = BYTE_GET (external->p_memsz);
3829 internal->p_flags = BYTE_GET (external->p_flags);
3830 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3831 }
3832
9ea033b2
NC		 3833 free (phdrs);
3834
252b5132
RH		 3835 return 1;
3836}
3837
9ea033b2 3838static int
91d6fa6a 3839get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3840{
2cf0635d
NC		 3841 Elf64_External_Phdr * phdrs;
3842 Elf64_External_Phdr * external;
3843 Elf_Internal_Phdr * internal;
b34976b6 3844 unsigned int i;
103f02d3 3845
3f5e193b
NC		 3846 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3847 elf_header.e_phentsize,
3848 elf_header.e_phnum,
3849 _("program headers"));
a6e9f9df
AM		 3850 if (!phdrs)
3851 return 0;
9ea033b2 3852
91d6fa6a 3853 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3854 i < elf_header.e_phnum;
b34976b6 3855 i++, internal++, external++)
9ea033b2
NC		 3856 {
3857 internal->p_type = BYTE_GET (external->p_type);
3858 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3859 internal->p_offset = BYTE_GET (external->p_offset);
3860 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3861 internal->p_paddr = BYTE_GET (external->p_paddr);
3862 internal->p_filesz = BYTE_GET (external->p_filesz);
3863 internal->p_memsz = BYTE_GET (external->p_memsz);
3864 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3865 }
3866
3867 free (phdrs);
3868
3869 return 1;
3870}
252b5132 3871
d93f0186
NC		 3872/* Returns 1 if the program headers were read into `program_headers'. */
3873
3874static int
2cf0635d 3875get_program_headers (FILE * file)
d93f0186 3876{
2cf0635d 3877 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3878
3879 /* Check cache of prior read. */
3880 if (program_headers != NULL)
3881 return 1;
3882
3f5e193b
NC		 3883 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3884 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3885
3886 if (phdrs == NULL)
3887 {
3888 error (_("Out of memory\n"));
3889 return 0;
3890 }
3891
3892 if (is_32bit_elf
3893 ? get_32bit_program_headers (file, phdrs)
3894 : get_64bit_program_headers (file, phdrs))
3895 {
3896 program_headers = phdrs;
3897 return 1;
3898 }
3899
3900 free (phdrs);
3901 return 0;
3902}
3903
2f62977e
NC		 3904/* Returns 1 if the program headers were loaded. */
3905
252b5132 3906static int
2cf0635d 3907process_program_headers (FILE * file)
252b5132 3908{
2cf0635d 3909 Elf_Internal_Phdr * segment;
b34976b6 3910 unsigned int i;
252b5132
RH		 3911
3912 if (elf_header.e_phnum == 0)
3913 {
82f2dbf7
NC		 3914 /* PR binutils/12467. */
3915 if (elf_header.e_phoff != 0)
3916 warn (_("possibly corrupt ELF header - it has a non-zero program"
3917 " header offset, but no program headers"));
3918 else if (do_segments)
252b5132 3919 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3920 return 0;
252b5132
RH		 3921 }
3922
3923 if (do_segments && !do_header)
3924 {
f7a99963
NC		 3925 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3926 printf (_("Entry point "));
3927 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3928 printf (_("\nThere are %d program headers, starting at offset "),
3929 elf_header.e_phnum);
3930 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3931 printf ("\n");
252b5132
RH		 3932 }
3933
d93f0186 3934 if (! get_program_headers (file))
252b5132 3935 return 0;
103f02d3 3936
252b5132
RH		 3937 if (do_segments)
3938 {
3a1a2036
NC		 3939 if (elf_header.e_phnum > 1)
3940 printf (_("\nProgram Headers:\n"));
3941 else
3942 printf (_("\nProgram Headers:\n"));
76da6bbe 3943
f7a99963
NC		 3944 if (is_32bit_elf)
3945 printf
3946 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3947 else if (do_wide)
3948 printf
3949 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3950 else
3951 {
3952 printf
3953 (_(" Type Offset VirtAddr PhysAddr\n"));
3954 printf
3955 (_(" FileSiz MemSiz Flags Align\n"));
3956 }
252b5132
RH		 3957 }
3958
252b5132 3959 dynamic_addr = 0;
1b228002 3960 dynamic_size = 0;
252b5132
RH		 3961
3962 for (i = 0, segment = program_headers;
3963 i < elf_header.e_phnum;
b34976b6 3964 i++, segment++)
252b5132
RH		 3965 {
3966 if (do_segments)
3967 {
103f02d3 3968 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3969
3970 if (is_32bit_elf)
3971 {
3972 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3973 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3974 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3975 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3976 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3977 printf ("%c%c%c ",
3978 (segment->p_flags & PF_R ? 'R' : ' '),
3979 (segment->p_flags & PF_W ? 'W' : ' '),
3980 (segment->p_flags & PF_X ? 'E' : ' '));
3981 printf ("%#lx", (unsigned long) segment->p_align);
3982 }
d974e256
JJ		 3983 else if (do_wide)
3984 {
3985 if ((unsigned long) segment->p_offset == segment->p_offset)
3986 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3987 else
3988 {
3989 print_vma (segment->p_offset, FULL_HEX);
3990 putchar (' ');
3991 }
3992
3993 print_vma (segment->p_vaddr, FULL_HEX);
3994 putchar (' ');
3995 print_vma (segment->p_paddr, FULL_HEX);
3996 putchar (' ');
3997
3998 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3999 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4000 else
4001 {
4002 print_vma (segment->p_filesz, FULL_HEX);
4003 putchar (' ');
4004 }
4005
4006 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4007 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4008 else
4009 {
f48e6c45 4010 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4011 }
4012
4013 printf (" %c%c%c ",
4014 (segment->p_flags & PF_R ? 'R' : ' '),
4015 (segment->p_flags & PF_W ? 'W' : ' '),
4016 (segment->p_flags & PF_X ? 'E' : ' '));
4017
4018 if ((unsigned long) segment->p_align == segment->p_align)
4019 printf ("%#lx", (unsigned long) segment->p_align);
4020 else
4021 {
4022 print_vma (segment->p_align, PREFIX_HEX);
4023 }
4024 }
f7a99963
NC		 4025 else
4026 {
4027 print_vma (segment->p_offset, FULL_HEX);
4028 putchar (' ');
4029 print_vma (segment->p_vaddr, FULL_HEX);
4030 putchar (' ');
4031 print_vma (segment->p_paddr, FULL_HEX);
4032 printf ("\n ");
4033 print_vma (segment->p_filesz, FULL_HEX);
4034 putchar (' ');
4035 print_vma (segment->p_memsz, FULL_HEX);
4036 printf (" %c%c%c ",
4037 (segment->p_flags & PF_R ? 'R' : ' '),
4038 (segment->p_flags & PF_W ? 'W' : ' '),
4039 (segment->p_flags & PF_X ? 'E' : ' '));
4040 print_vma (segment->p_align, HEX);
4041 }
252b5132
RH		 4042 }
4043
4044 switch (segment->p_type)
4045 {
252b5132
RH		 4046 case PT_DYNAMIC:
4047 if (dynamic_addr)
4048 error (_("more than one dynamic segment\n"));
4049
20737c13
AM		 4050 /* By default, assume that the .dynamic section is the first
4051 section in the DYNAMIC segment. */
4052 dynamic_addr = segment->p_offset;
4053 dynamic_size = segment->p_filesz;
4054
b2d38a17
NC		 4055 /* Try to locate the .dynamic section. If there is
4056 a section header table, we can easily locate it. */
4057 if (section_headers != NULL)
4058 {
2cf0635d 4059 Elf_Internal_Shdr * sec;
b2d38a17 4060
89fac5e3
RS		 4061 sec = find_section (".dynamic");
4062 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4063 {
28f997cf
TG		 4064 /* A corresponding .dynamic section is expected, but on
4065 IA-64/OpenVMS it is OK for it to be missing. */
4066 if (!is_ia64_vms ())
4067 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4068 break;
4069 }
4070
42bb2e33 4071 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4072 {
4073 dynamic_size = 0;
4074 break;
4075 }
42bb2e33 4076
b2d38a17
NC		 4077 dynamic_addr = sec->sh_offset;
4078 dynamic_size = sec->sh_size;
4079
4080 if (dynamic_addr < segment->p_offset
4081 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4082 warn (_("the .dynamic section is not contained"
4083 " within the dynamic segment\n"));
b2d38a17 4084 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4085 warn (_("the .dynamic section is not the first section"
4086 " in the dynamic segment.\n"));
b2d38a17 4087 }
252b5132
RH		 4088 break;
4089
4090 case PT_INTERP:
fb52b2f4
NC		 4091 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4092 SEEK_SET))
252b5132
RH		 4093 error (_("Unable to find program interpreter name\n"));
4094 else
4095 {
f8eae8b2
L		 4096 char fmt [32];
4097 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4098
4099 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4100 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4101
252b5132 4102 program_interpreter[0] = 0;
7bd7b3ef
AM		 4103 if (fscanf (file, fmt, program_interpreter) <= 0)
4104 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4105
4106 if (do_segments)
4107 printf (_("\n [Requesting program interpreter: %s]"),
4108 program_interpreter);
4109 }
4110 break;
4111 }
4112
4113 if (do_segments)
4114 putc ('\n', stdout);
4115 }
4116
c256ffe7 4117 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4118 {
4119 printf (_("\n Section to Segment mapping:\n"));
4120 printf (_(" Segment Sections...\n"));
4121
252b5132
RH		 4122 for (i = 0; i < elf_header.e_phnum; i++)
4123 {
9ad5cbcf 4124 unsigned int j;
2cf0635d 4125 Elf_Internal_Shdr * section;
252b5132
RH		 4126
4127 segment = program_headers + i;
b391a3e3 4128 section = section_headers + 1;
252b5132
RH		 4129
4130 printf (" %2.2d ", i);
4131
b34976b6 4132 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4133 {
f4638467
AM		 4134 if (!ELF_TBSS_SPECIAL (section, segment)
4135 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 4136 printf ("%s ", SECTION_NAME (section));
4137 }
4138
4139 putc ('\n',stdout);
4140 }
4141 }
4142
252b5132
RH		 4143 return 1;
4144}
4145
4146
d93f0186
NC		 4147/* Find the file offset corresponding to VMA by using the program headers. */
4148
4149static long
2cf0635d 4150offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4151{
2cf0635d 4152 Elf_Internal_Phdr * seg;
d93f0186
NC		 4153
4154 if (! get_program_headers (file))
4155 {
4156 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4157 return (long) vma;
4158 }
4159
4160 for (seg = program_headers;
4161 seg < program_headers + elf_header.e_phnum;
4162 ++seg)
4163 {
4164 if (seg->p_type != PT_LOAD)
4165 continue;
4166
4167 if (vma >= (seg->p_vaddr & -seg->p_align)
4168 && vma + size <= seg->p_vaddr + seg->p_filesz)
4169 return vma - seg->p_vaddr + seg->p_offset;
4170 }
4171
4172 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4173 (unsigned long) vma);
d93f0186
NC		 4174 return (long) vma;
4175}
4176
4177
252b5132 4178static int
2cf0635d 4179get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4180{
2cf0635d
NC		 4181 Elf32_External_Shdr * shdrs;
4182 Elf_Internal_Shdr * internal;
b34976b6 4183 unsigned int i;
252b5132 4184
3f5e193b
NC		 4185 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4186 elf_header.e_shentsize, num,
4187 _("section headers"));
a6e9f9df
AM		 4188 if (!shdrs)
4189 return 0;
252b5132 4190
3f5e193b
NC		 4191 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4192 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4193
4194 if (section_headers == NULL)
4195 {
4196 error (_("Out of memory\n"));
4197 return 0;
4198 }
4199
4200 for (i = 0, internal = section_headers;
560f3c1c 4201 i < num;
b34976b6 4202 i++, internal++)
252b5132
RH		 4203 {
4204 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4205 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4206 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4207 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4208 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4209 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4210 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4211 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4212 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4213 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4214 }
4215
4216 free (shdrs);
4217
4218 return 1;
4219}
4220
9ea033b2 4221static int
2cf0635d 4222get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4223{
2cf0635d
NC		 4224 Elf64_External_Shdr * shdrs;
4225 Elf_Internal_Shdr * internal;
b34976b6 4226 unsigned int i;
9ea033b2 4227
3f5e193b
NC		 4228 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4229 elf_header.e_shentsize, num,
4230 _("section headers"));
a6e9f9df
AM		 4231 if (!shdrs)
4232 return 0;
9ea033b2 4233
3f5e193b
NC		 4234 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4235 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4236
4237 if (section_headers == NULL)
4238 {
4239 error (_("Out of memory\n"));
4240 return 0;
4241 }
4242
4243 for (i = 0, internal = section_headers;
560f3c1c 4244 i < num;
b34976b6 4245 i++, internal++)
9ea033b2
NC		 4246 {
4247 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4248 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4249 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4250 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4251 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4252 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4253 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4254 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4255 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4256 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4257 }
4258
4259 free (shdrs);
4260
4261 return 1;
4262}
4263
252b5132 4264static Elf_Internal_Sym *
ba5cdace
NC		 4265get_32bit_elf_symbols (FILE * file,
4266 Elf_Internal_Shdr * section,
4267 unsigned long * num_syms_return)
252b5132 4268{
ba5cdace 4269 unsigned long number = 0;
dd24e3da 4270 Elf32_External_Sym * esyms = NULL;
ba5cdace 4271 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4272 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4273 Elf_Internal_Sym * psym;
b34976b6 4274 unsigned int j;
252b5132 4275
dd24e3da
NC		 4276 /* Run some sanity checks first. */
4277 if (section->sh_entsize == 0)
4278 {
4279 error (_("sh_entsize is zero\n"));
ba5cdace 4280 goto exit_point;
dd24e3da
NC		 4281 }
4282
4283 number = section->sh_size / section->sh_entsize;
4284
4285 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4286 {
4287 error (_("Invalid sh_entsize\n"));
ba5cdace 4288 goto exit_point;
dd24e3da
NC		 4289 }
4290
3f5e193b
NC		 4291 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4292 section->sh_size, _("symbols"));
dd24e3da 4293 if (esyms == NULL)
ba5cdace 4294 goto exit_point;
252b5132 4295
9ad5cbcf
AM		 4296 shndx = NULL;
4297 if (symtab_shndx_hdr != NULL
4298 && (symtab_shndx_hdr->sh_link
4fbb74a6 4299 == (unsigned long) (section - section_headers)))
9ad5cbcf 4300 {
3f5e193b
NC		 4301 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4302 symtab_shndx_hdr->sh_offset,
4303 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4304 _("symbol table section indicies"));
dd24e3da
NC		 4305 if (shndx == NULL)
4306 goto exit_point;
9ad5cbcf
AM		 4307 }
4308
3f5e193b 4309 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4310
4311 if (isyms == NULL)
4312 {
4313 error (_("Out of memory\n"));
dd24e3da 4314 goto exit_point;
252b5132
RH		 4315 }
4316
dd24e3da 4317 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4318 {
4319 psym->st_name = BYTE_GET (esyms[j].st_name);
4320 psym->st_value = BYTE_GET (esyms[j].st_value);
4321 psym->st_size = BYTE_GET (esyms[j].st_size);
4322 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4323 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4324 psym->st_shndx
4325 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4326 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4327 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4328 psym->st_info = BYTE_GET (esyms[j].st_info);
4329 psym->st_other = BYTE_GET (esyms[j].st_other);
4330 }
4331
dd24e3da 4332 exit_point:
ba5cdace 4333 if (shndx != NULL)
9ad5cbcf 4334 free (shndx);
ba5cdace 4335 if (esyms != NULL)
dd24e3da 4336 free (esyms);
252b5132 4337
ba5cdace
NC		 4338 if (num_syms_return != NULL)
4339 * num_syms_return = isyms == NULL ? 0 : number;
4340
252b5132
RH		 4341 return isyms;
4342}
4343
9ea033b2 4344static Elf_Internal_Sym *
ba5cdace
NC		 4345get_64bit_elf_symbols (FILE * file,
4346 Elf_Internal_Shdr * section,
4347 unsigned long * num_syms_return)
9ea033b2 4348{
ba5cdace
NC		 4349 unsigned long number = 0;
4350 Elf64_External_Sym * esyms = NULL;
4351 Elf_External_Sym_Shndx * shndx = NULL;
4352 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4353 Elf_Internal_Sym * psym;
b34976b6 4354 unsigned int j;
9ea033b2 4355
dd24e3da
NC		 4356 /* Run some sanity checks first. */
4357 if (section->sh_entsize == 0)
4358 {
4359 error (_("sh_entsize is zero\n"));
ba5cdace 4360 goto exit_point;
dd24e3da
NC		 4361 }
4362
4363 number = section->sh_size / section->sh_entsize;
4364
4365 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4366 {
4367 error (_("Invalid sh_entsize\n"));
ba5cdace 4368 goto exit_point;
dd24e3da
NC		 4369 }
4370
3f5e193b
NC		 4371 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4372 section->sh_size, _("symbols"));
a6e9f9df 4373 if (!esyms)
ba5cdace 4374 goto exit_point;
9ea033b2 4375
9ad5cbcf
AM		 4376 if (symtab_shndx_hdr != NULL
4377 && (symtab_shndx_hdr->sh_link
4fbb74a6 4378 == (unsigned long) (section - section_headers)))
9ad5cbcf 4379 {
3f5e193b
NC		 4380 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4381 symtab_shndx_hdr->sh_offset,
4382 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4383 _("symbol table section indicies"));
ba5cdace
NC		 4384 if (shndx == NULL)
4385 goto exit_point;
9ad5cbcf
AM		 4386 }
4387
3f5e193b 4388 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4389
4390 if (isyms == NULL)
4391 {
4392 error (_("Out of memory\n"));
ba5cdace 4393 goto exit_point;
9ea033b2
NC		 4394 }
4395
ba5cdace 4396 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4397 {
4398 psym->st_name = BYTE_GET (esyms[j].st_name);
4399 psym->st_info = BYTE_GET (esyms[j].st_info);
4400 psym->st_other = BYTE_GET (esyms[j].st_other);
4401 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4402
4fbb74a6 4403 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4404 psym->st_shndx
4405 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4406 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4407 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4408
66543521
AM		 4409 psym->st_value = BYTE_GET (esyms[j].st_value);
4410 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4411 }
4412
ba5cdace
NC		 4413 exit_point:
4414 if (shndx != NULL)
9ad5cbcf 4415 free (shndx);
ba5cdace
NC		 4416 if (esyms != NULL)
4417 free (esyms);
4418
4419 if (num_syms_return != NULL)
4420 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4421
4422 return isyms;
4423}
4424
d1133906 4425static const char *
d3ba0551 4426get_elf_section_flags (bfd_vma sh_flags)
d1133906 4427{
5477e8a0 4428 static char buff[1024];
2cf0635d 4429 char * p = buff;
8d5ff12c 4430 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4431 int sindex;
4432 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4433 bfd_vma os_flags = 0;
4434 bfd_vma proc_flags = 0;
4435 bfd_vma unknown_flags = 0;
148b93f2 4436 static const struct
5477e8a0 4437 {
2cf0635d 4438 const char * str;
5477e8a0
L		 4439 int len;
4440 }
4441 flags [] =
4442 {
cfcac11d
NC		 4443 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4444 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4445 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4446 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4447 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4448 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4449 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4450 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4451 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4452 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4453 /* IA-64 specific. */
4454 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4455 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4456 /* IA-64 OpenVMS specific. */
4457 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4458 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4459 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4460 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4461 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4462 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4463 /* Generic. */
cfcac11d 4464 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4465 /* SPARC specific. */
cfcac11d 4466 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4467 };
4468
4469 if (do_section_details)
4470 {
8d5ff12c
L		 4471 sprintf (buff, "[%*.*lx]: ",
4472 field_size, field_size, (unsigned long) sh_flags);
4473 p += field_size + 4;
5477e8a0 4474 }
76da6bbe 4475
d1133906
NC		 4476 while (sh_flags)
4477 {
4478 bfd_vma flag;
4479
4480 flag = sh_flags & - sh_flags;
4481 sh_flags &= ~ flag;
76da6bbe 4482
5477e8a0 4483 if (do_section_details)
d1133906 4484 {
5477e8a0
L		 4485 switch (flag)
4486 {
91d6fa6a
NC		 4487 case SHF_WRITE: sindex = 0; break;
4488 case SHF_ALLOC: sindex = 1; break;
4489 case SHF_EXECINSTR: sindex = 2; break;
4490 case SHF_MERGE: sindex = 3; break;
4491 case SHF_STRINGS: sindex = 4; break;
4492 case SHF_INFO_LINK: sindex = 5; break;
4493 case SHF_LINK_ORDER: sindex = 6; break;
4494 case SHF_OS_NONCONFORMING: sindex = 7; break;
4495 case SHF_GROUP: sindex = 8; break;
4496 case SHF_TLS: sindex = 9; break;
18ae9cc1 4497 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4498
5477e8a0 4499 default:
91d6fa6a 4500 sindex = -1;
cfcac11d 4501 switch (elf_header.e_machine)
148b93f2 4502 {
cfcac11d 4503 case EM_IA_64:
148b93f2 4504 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4505 sindex = 10;
148b93f2 4506 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4507 sindex = 11;
148b93f2
NC		 4508#ifdef BFD64
4509 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4510 switch (flag)
4511 {
91d6fa6a
NC		 4512 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4513 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4514 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4515 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4516 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4517 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4518 default: break;
4519 }
4520#endif
cfcac11d
NC		 4521 break;
4522
caa83f8b
NC		 4523 case EM_386:
4524 case EM_486:
4525 case EM_X86_64:
7f502d6c 4526 case EM_L1OM:
7a9068fe 4527 case EM_K1OM:
cfcac11d
NC		 4528 case EM_OLD_SPARCV9:
4529 case EM_SPARC32PLUS:
4530 case EM_SPARCV9:
4531 case EM_SPARC:
18ae9cc1 4532 if (flag == SHF_ORDERED)
91d6fa6a 4533 sindex = 19;
cfcac11d
NC		 4534 break;
4535 default:
4536 break;
148b93f2 4537 }
5477e8a0
L		 4538 }
4539
91d6fa6a 4540 if (sindex != -1)
5477e8a0 4541 {
8d5ff12c
L		 4542 if (p != buff + field_size + 4)
4543 {
4544 if (size < (10 + 2))
4545 abort ();
4546 size -= 2;
4547 *p++ = ',';
4548 *p++ = ' ';
4549 }
4550
91d6fa6a
NC		 4551 size -= flags [sindex].len;
4552 p = stpcpy (p, flags [sindex].str);
5477e8a0 4553 }
3b22753a 4554 else if (flag & SHF_MASKOS)
8d5ff12c 4555 os_flags |= flag;
d1133906 4556 else if (flag & SHF_MASKPROC)
8d5ff12c 4557 proc_flags |= flag;
d1133906 4558 else
8d5ff12c 4559 unknown_flags |= flag;
5477e8a0
L		 4560 }
4561 else
4562 {
4563 switch (flag)
4564 {
4565 case SHF_WRITE: *p = 'W'; break;
4566 case SHF_ALLOC: *p = 'A'; break;
4567 case SHF_EXECINSTR: *p = 'X'; break;
4568 case SHF_MERGE: *p = 'M'; break;
4569 case SHF_STRINGS: *p = 'S'; break;
4570 case SHF_INFO_LINK: *p = 'I'; break;
4571 case SHF_LINK_ORDER: *p = 'L'; break;
4572 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4573 case SHF_GROUP: *p = 'G'; break;
4574 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4575 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4576
4577 default:
8a9036a4 4578 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4579 || elf_header.e_machine == EM_L1OM
4580 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4581 && flag == SHF_X86_64_LARGE)
4582 *p = 'l';
4583 else if (flag & SHF_MASKOS)
4584 {
4585 *p = 'o';
4586 sh_flags &= ~ SHF_MASKOS;
4587 }
4588 else if (flag & SHF_MASKPROC)
4589 {
4590 *p = 'p';
4591 sh_flags &= ~ SHF_MASKPROC;
4592 }
4593 else
4594 *p = 'x';
4595 break;
4596 }
4597 p++;
d1133906
NC		 4598 }
4599 }
76da6bbe 4600
8d5ff12c
L		 4601 if (do_section_details)
4602 {
4603 if (os_flags)
4604 {
4605 size -= 5 + field_size;
4606 if (p != buff + field_size + 4)
4607 {
4608 if (size < (2 + 1))
4609 abort ();
4610 size -= 2;
4611 *p++ = ',';
4612 *p++ = ' ';
4613 }
4614 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4615 (unsigned long) os_flags);
4616 p += 5 + field_size;
4617 }
4618 if (proc_flags)
4619 {
4620 size -= 7 + field_size;
4621 if (p != buff + field_size + 4)
4622 {
4623 if (size < (2 + 1))
4624 abort ();
4625 size -= 2;
4626 *p++ = ',';
4627 *p++ = ' ';
4628 }
4629 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4630 (unsigned long) proc_flags);
4631 p += 7 + field_size;
4632 }
4633 if (unknown_flags)
4634 {
4635 size -= 10 + field_size;
4636 if (p != buff + field_size + 4)
4637 {
4638 if (size < (2 + 1))
4639 abort ();
4640 size -= 2;
4641 *p++ = ',';
4642 *p++ = ' ';
4643 }
2b692964 4644 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4645 (unsigned long) unknown_flags);
4646 p += 10 + field_size;
4647 }
4648 }
4649
e9e44622 4650 *p = '\0';
d1133906
NC		 4651 return buff;
4652}
4653
252b5132 4654static int
2cf0635d 4655process_section_headers (FILE * file)
252b5132 4656{
2cf0635d 4657 Elf_Internal_Shdr * section;
b34976b6 4658 unsigned int i;
252b5132
RH		 4659
4660 section_headers = NULL;
4661
4662 if (elf_header.e_shnum == 0)
4663 {
82f2dbf7
NC		 4664 /* PR binutils/12467. */
4665 if (elf_header.e_shoff != 0)
4666 warn (_("possibly corrupt ELF file header - it has a non-zero"
4667 " section header offset, but no section headers\n"));
4668 else if (do_sections)
252b5132
RH		 4669 printf (_("\nThere are no sections in this file.\n"));
4670
4671 return 1;
4672 }
4673
4674 if (do_sections && !do_header)
9ea033b2 4675 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4676 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4677
9ea033b2
NC		 4678 if (is_32bit_elf)
4679 {
560f3c1c 4680 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4681 return 0;
4682 }
560f3c1c 4683 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4684 return 0;
4685
4686 /* Read in the string table, so that we have names to display. */
0b49d371 4687 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4688 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4689 {
4fbb74a6 4690 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4691
c256ffe7
JJ		 4692 if (section->sh_size != 0)
4693 {
3f5e193b
NC		 4694 string_table = (char *) get_data (NULL, file, section->sh_offset,
4695 1, section->sh_size,
4696 _("string table"));
0de14b54 4697
c256ffe7
JJ		 4698 string_table_length = string_table != NULL ? section->sh_size : 0;
4699 }
252b5132
RH		 4700 }
4701
4702 /* Scan the sections for the dynamic symbol table
e3c8793a 4703 and dynamic string table and debug sections. */
252b5132
RH		 4704 dynamic_symbols = NULL;
4705 dynamic_strings = NULL;
4706 dynamic_syminfo = NULL;
f1ef08cb 4707 symtab_shndx_hdr = NULL;
103f02d3 4708
89fac5e3
RS		 4709 eh_addr_size = is_32bit_elf ? 4 : 8;
4710 switch (elf_header.e_machine)
4711 {
4712 case EM_MIPS:
4713 case EM_MIPS_RS3_LE:
4714 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4715 FDE addresses. However, the ABI also has a semi-official ILP32
4716 variant for which the normal FDE address size rules apply.
4717
4718 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4719 section, where XX is the size of longs in bits. Unfortunately,
4720 earlier compilers provided no way of distinguishing ILP32 objects
4721 from LP64 objects, so if there's any doubt, we should assume that
4722 the official LP64 form is being used. */
4723 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4724 && find_section (".gcc_compiled_long32") == NULL)
4725 eh_addr_size = 8;
4726 break;
0f56a26a
DD		 4727
4728 case EM_H8_300:
4729 case EM_H8_300H:
4730 switch (elf_header.e_flags & EF_H8_MACH)
4731 {
4732 case E_H8_MACH_H8300:
4733 case E_H8_MACH_H8300HN:
4734 case E_H8_MACH_H8300SN:
4735 case E_H8_MACH_H8300SXN:
4736 eh_addr_size = 2;
4737 break;
4738 case E_H8_MACH_H8300H:
4739 case E_H8_MACH_H8300S:
4740 case E_H8_MACH_H8300SX:
4741 eh_addr_size = 4;
4742 break;
4743 }
f4236fe4
DD		 4744 break;
4745
ff7eeb89 4746 case EM_M32C_OLD:
f4236fe4
DD		 4747 case EM_M32C:
4748 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4749 {
4750 case EF_M32C_CPU_M16C:
4751 eh_addr_size = 2;
4752 break;
4753 }
4754 break;
89fac5e3
RS		 4755 }
4756
08d8fa11
JJ		 4757#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4758 do \
4759 { \
9dd3a467 4760 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
08d8fa11 4761 if (section->sh_entsize != expected_entsize) \
9dd3a467 4762 { \
15b42fb0 4763 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
9dd3a467
NC		 4764 i, section->sh_entsize); \
4765 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
4766 (int) expected_entsize); \
4767 section->sh_entsize = expected_entsize; \
4768 } \
08d8fa11
JJ		 4769 } \
4770 while (0)
9dd3a467
NC		 4771
4772#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 4773 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4774 sizeof (Elf64_External_##type))
4775
252b5132
RH		 4776 for (i = 0, section = section_headers;
4777 i < elf_header.e_shnum;
b34976b6 4778 i++, section++)
252b5132 4779 {
2cf0635d 4780 char * name = SECTION_NAME (section);
252b5132
RH		 4781
4782 if (section->sh_type == SHT_DYNSYM)
4783 {
4784 if (dynamic_symbols != NULL)
4785 {
4786 error (_("File contains multiple dynamic symbol tables\n"));
4787 continue;
4788 }
4789
08d8fa11 4790 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4791 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 4792 }
4793 else if (section->sh_type == SHT_STRTAB
18bd398b 4794 && streq (name, ".dynstr"))
252b5132
RH		 4795 {
4796 if (dynamic_strings != NULL)
4797 {
4798 error (_("File contains multiple dynamic string tables\n"));
4799 continue;
4800 }
4801
3f5e193b
NC		 4802 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4803 1, section->sh_size,
4804 _("dynamic strings"));
59245841 4805 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4806 }
9ad5cbcf
AM		 4807 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4808 {
4809 if (symtab_shndx_hdr != NULL)
4810 {
4811 error (_("File contains multiple symtab shndx tables\n"));
4812 continue;
4813 }
4814 symtab_shndx_hdr = section;
4815 }
08d8fa11
JJ		 4816 else if (section->sh_type == SHT_SYMTAB)
4817 CHECK_ENTSIZE (section, i, Sym);
4818 else if (section->sh_type == SHT_GROUP)
4819 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4820 else if (section->sh_type == SHT_REL)
4821 CHECK_ENTSIZE (section, i, Rel);
4822 else if (section->sh_type == SHT_RELA)
4823 CHECK_ENTSIZE (section, i, Rela);
252b5132 4824 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4825 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4826 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 4827 || do_debug_str || do_debug_loc || do_debug_ranges
4828 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 4829 && (const_strneq (name, ".debug_")
4830 || const_strneq (name, ".zdebug_")))
252b5132 4831 {
1b315056
CS		 4832 if (name[1] == 'z')
4833 name += sizeof (".zdebug_") - 1;
4834 else
4835 name += sizeof (".debug_") - 1;
252b5132
RH		 4836
4837 if (do_debugging
4723351a
CC		 4838 || (do_debug_info && const_strneq (name, "info"))
4839 || (do_debug_info && const_strneq (name, "types"))
4840 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 4841 || (do_debug_lines && strcmp (name, "line") == 0)
4842 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 4843 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4844 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4845 || (do_debug_aranges && const_strneq (name, "aranges"))
4846 || (do_debug_ranges && const_strneq (name, "ranges"))
4847 || (do_debug_frames && const_strneq (name, "frame"))
4848 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4849 || (do_debug_macinfo && const_strneq (name, "macro"))
4850 || (do_debug_str && const_strneq (name, "str"))
4851 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 4852 || (do_debug_addr && const_strneq (name, "addr"))
4853 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4854 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 4855 )
09c11c86 4856 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4857 }
a262ae96 4858 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4859 else if ((do_debugging || do_debug_info)
0112cd26 4860 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4861 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4862 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4863 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4864 else if (do_gdb_index && streq (name, ".gdb_index"))
4865 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4866 /* Trace sections for Itanium VMS. */
4867 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4868 || do_trace_aranges)
4869 && const_strneq (name, ".trace_"))
4870 {
4871 name += sizeof (".trace_") - 1;
4872
4873 if (do_debugging
4874 || (do_trace_info && streq (name, "info"))
4875 || (do_trace_abbrevs && streq (name, "abbrev"))
4876 || (do_trace_aranges && streq (name, "aranges"))
4877 )
4878 request_dump_bynumber (i, DEBUG_DUMP);
4879 }
4880
252b5132
RH		 4881 }
4882
4883 if (! do_sections)
4884 return 1;
4885
3a1a2036
NC		 4886 if (elf_header.e_shnum > 1)
4887 printf (_("\nSection Headers:\n"));
4888 else
4889 printf (_("\nSection Header:\n"));
76da6bbe 4890
f7a99963 4891 if (is_32bit_elf)
595cf52e 4892 {
5477e8a0 4893 if (do_section_details)
595cf52e
L		 4894 {
4895 printf (_(" [Nr] Name\n"));
5477e8a0 4896 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4897 }
4898 else
4899 printf
4900 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4901 }
d974e256 4902 else if (do_wide)
595cf52e 4903 {
5477e8a0 4904 if (do_section_details)
595cf52e
L		 4905 {
4906 printf (_(" [Nr] Name\n"));
5477e8a0 4907 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4908 }
4909 else
4910 printf
4911 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4912 }
f7a99963
NC		 4913 else
4914 {
5477e8a0 4915 if (do_section_details)
595cf52e
L		 4916 {
4917 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4918 printf (_(" Type Address Offset Link\n"));
4919 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4920 }
4921 else
4922 {
4923 printf (_(" [Nr] Name Type Address Offset\n"));
4924 printf (_(" Size EntSize Flags Link Info Align\n"));
4925 }
f7a99963 4926 }
252b5132 4927
5477e8a0
L		 4928 if (do_section_details)
4929 printf (_(" Flags\n"));
4930
252b5132
RH		 4931 for (i = 0, section = section_headers;
4932 i < elf_header.e_shnum;
b34976b6 4933 i++, section++)
252b5132 4934 {
7bfd842d 4935 printf (" [%2u] ", i);
5477e8a0 4936 if (do_section_details)
595cf52e 4937 {
7bfd842d 4938 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 4939 printf ("\n ");
595cf52e
L		 4940 }
4941 else
7bfd842d
NC		 4942 {
4943 print_symbol (-17, SECTION_NAME (section));
7bfd842d 4944 }
ea52a088
NC		 4945
4946 printf (do_wide ? " %-15s " : " %-15.15s ",
4947 get_section_type_name (section->sh_type));
4948
f7a99963
NC		 4949 if (is_32bit_elf)
4950 {
cfcac11d
NC		 4951 const char * link_too_big = NULL;
4952
f7a99963 4953 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4954
f7a99963
NC		 4955 printf ( " %6.6lx %6.6lx %2.2lx",
4956 (unsigned long) section->sh_offset,
4957 (unsigned long) section->sh_size,
4958 (unsigned long) section->sh_entsize);
d1133906 4959
5477e8a0
L		 4960 if (do_section_details)
4961 fputs (" ", stdout);
4962 else
4963 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4964
cfcac11d
NC		 4965 if (section->sh_link >= elf_header.e_shnum)
4966 {
4967 link_too_big = "";
4968 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4969 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4970 switch (elf_header.e_machine)
4971 {
caa83f8b
NC		 4972 case EM_386:
4973 case EM_486:
4974 case EM_X86_64:
7f502d6c 4975 case EM_L1OM:
7a9068fe 4976 case EM_K1OM:
cfcac11d
NC		 4977 case EM_OLD_SPARCV9:
4978 case EM_SPARC32PLUS:
4979 case EM_SPARCV9:
4980 case EM_SPARC:
4981 if (section->sh_link == (SHN_BEFORE & 0xffff))
4982 link_too_big = "BEFORE";
4983 else if (section->sh_link == (SHN_AFTER & 0xffff))
4984 link_too_big = "AFTER";
4985 break;
4986 default:
4987 break;
4988 }
4989 }
4990
4991 if (do_section_details)
4992 {
4993 if (link_too_big != NULL && * link_too_big)
4994 printf ("<%s> ", link_too_big);
4995 else
4996 printf ("%2u ", section->sh_link);
4997 printf ("%3u %2lu\n", section->sh_info,
4998 (unsigned long) section->sh_addralign);
4999 }
5000 else
5001 printf ("%2u %3u %2lu\n",
5002 section->sh_link,
5003 section->sh_info,
5004 (unsigned long) section->sh_addralign);
5005
5006 if (link_too_big && ! * link_too_big)
5007 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5008 i, section->sh_link);
f7a99963 5009 }
d974e256
JJ		 5010 else if (do_wide)
5011 {
5012 print_vma (section->sh_addr, LONG_HEX);
5013
5014 if ((long) section->sh_offset == section->sh_offset)
5015 printf (" %6.6lx", (unsigned long) section->sh_offset);
5016 else
5017 {
5018 putchar (' ');
5019 print_vma (section->sh_offset, LONG_HEX);
5020 }
5021
5022 if ((unsigned long) section->sh_size == section->sh_size)
5023 printf (" %6.6lx", (unsigned long) section->sh_size);
5024 else
5025 {
5026 putchar (' ');
5027 print_vma (section->sh_size, LONG_HEX);
5028 }
5029
5030 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5031 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5032 else
5033 {
5034 putchar (' ');
5035 print_vma (section->sh_entsize, LONG_HEX);
5036 }
5037
5477e8a0
L		 5038 if (do_section_details)
5039 fputs (" ", stdout);
5040 else
5041 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5042
72de5009 5043 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5044
5045 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5046 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5047 else
5048 {
5049 print_vma (section->sh_addralign, DEC);
5050 putchar ('\n');
5051 }
5052 }
5477e8a0 5053 else if (do_section_details)
595cf52e 5054 {
5477e8a0 5055 printf (" %-15.15s ",
595cf52e 5056 get_section_type_name (section->sh_type));
595cf52e
L		 5057 print_vma (section->sh_addr, LONG_HEX);
5058 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5059 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5060 else
5061 {
5062 printf (" ");
5063 print_vma (section->sh_offset, LONG_HEX);
5064 }
72de5009 5065 printf (" %u\n ", section->sh_link);
595cf52e 5066 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5067 putchar (' ');
595cf52e
L		 5068 print_vma (section->sh_entsize, LONG_HEX);
5069
72de5009
AM		 5070 printf (" %-16u %lu\n",
5071 section->sh_info,
595cf52e
L		 5072 (unsigned long) section->sh_addralign);
5073 }
f7a99963
NC		 5074 else
5075 {
5076 putchar (' ');
5077 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5078 if ((long) section->sh_offset == section->sh_offset)
5079 printf (" %8.8lx", (unsigned long) section->sh_offset);
5080 else
5081 {
5082 printf (" ");
5083 print_vma (section->sh_offset, LONG_HEX);
5084 }
f7a99963
NC		 5085 printf ("\n ");
5086 print_vma (section->sh_size, LONG_HEX);
5087 printf (" ");
5088 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5089
d1133906 5090 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5091
72de5009
AM		 5092 printf (" %2u %3u %lu\n",
5093 section->sh_link,
5094 section->sh_info,
f7a99963
NC		 5095 (unsigned long) section->sh_addralign);
5096 }
5477e8a0
L		 5097
5098 if (do_section_details)
5099 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5100 }
5101
5477e8a0 5102 if (!do_section_details)
3dbcc61d
NC		 5103 {
5104 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5105 || elf_header.e_machine == EM_L1OM
5106 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5107 printf (_("Key to Flags:\n\
5108 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5109 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5110 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5111 else
5112 printf (_("Key to Flags:\n\
e3c8793a 5113 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5114 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5115 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 5116 }
d1133906 5117
252b5132
RH		 5118 return 1;
5119}
5120
f5842774
L		 5121static const char *
5122get_group_flags (unsigned int flags)
5123{
5124 static char buff[32];
5125 switch (flags)
5126 {
220453ec
AM		 5127 case 0:
5128 return "";
5129
f5842774 5130 case GRP_COMDAT:
220453ec 5131 return "COMDAT ";
f5842774
L		 5132
5133 default:
220453ec 5134 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5135 break;
5136 }
5137 return buff;
5138}
5139
5140static int
2cf0635d 5141process_section_groups (FILE * file)
f5842774 5142{
2cf0635d 5143 Elf_Internal_Shdr * section;
f5842774 5144 unsigned int i;
2cf0635d
NC		 5145 struct group * group;
5146 Elf_Internal_Shdr * symtab_sec;
5147 Elf_Internal_Shdr * strtab_sec;
5148 Elf_Internal_Sym * symtab;
ba5cdace 5149 unsigned long num_syms;
2cf0635d 5150 char * strtab;
c256ffe7 5151 size_t strtab_size;
d1f5c6e3
L		 5152
5153 /* Don't process section groups unless needed. */
5154 if (!do_unwind && !do_section_groups)
5155 return 1;
f5842774
L		 5156
5157 if (elf_header.e_shnum == 0)
5158 {
5159 if (do_section_groups)
82f2dbf7 5160 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5161
5162 return 1;
5163 }
5164
5165 if (section_headers == NULL)
5166 {
5167 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5168 /* PR 13622: This can happen with a corrupt ELF header. */
5169 return 0;
f5842774
L		 5170 }
5171
3f5e193b
NC		 5172 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5173 sizeof (struct group *));
e4b17d5c
L		 5174
5175 if (section_headers_groups == NULL)
5176 {
5177 error (_("Out of memory\n"));
5178 return 0;
5179 }
5180
f5842774 5181 /* Scan the sections for the group section. */
d1f5c6e3 5182 group_count = 0;
f5842774
L		 5183 for (i = 0, section = section_headers;
5184 i < elf_header.e_shnum;
5185 i++, section++)
e4b17d5c
L		 5186 if (section->sh_type == SHT_GROUP)
5187 group_count++;
5188
d1f5c6e3
L		 5189 if (group_count == 0)
5190 {
5191 if (do_section_groups)
5192 printf (_("\nThere are no section groups in this file.\n"));
5193
5194 return 1;
5195 }
5196
3f5e193b 5197 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5198
5199 if (section_groups == NULL)
5200 {
5201 error (_("Out of memory\n"));
5202 return 0;
5203 }
5204
d1f5c6e3
L		 5205 symtab_sec = NULL;
5206 strtab_sec = NULL;
5207 symtab = NULL;
ba5cdace 5208 num_syms = 0;
d1f5c6e3 5209 strtab = NULL;
c256ffe7 5210 strtab_size = 0;
e4b17d5c
L		 5211 for (i = 0, section = section_headers, group = section_groups;
5212 i < elf_header.e_shnum;
5213 i++, section++)
f5842774
L		 5214 {
5215 if (section->sh_type == SHT_GROUP)
5216 {
2cf0635d
NC		 5217 char * name = SECTION_NAME (section);
5218 char * group_name;
5219 unsigned char * start;
5220 unsigned char * indices;
f5842774 5221 unsigned int entry, j, size;
2cf0635d
NC		 5222 Elf_Internal_Shdr * sec;
5223 Elf_Internal_Sym * sym;
f5842774
L		 5224
5225 /* Get the symbol table. */
4fbb74a6
AM		 5226 if (section->sh_link >= elf_header.e_shnum
5227 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5228 != SHT_SYMTAB))
f5842774
L		 5229 {
5230 error (_("Bad sh_link in group section `%s'\n"), name);
5231 continue;
5232 }
d1f5c6e3
L		 5233
5234 if (symtab_sec != sec)
5235 {
5236 symtab_sec = sec;
5237 if (symtab)
5238 free (symtab);
ba5cdace 5239 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5240 }
f5842774 5241
dd24e3da
NC		 5242 if (symtab == NULL)
5243 {
5244 error (_("Corrupt header in group section `%s'\n"), name);
5245 continue;
5246 }
5247
ba5cdace
NC		 5248 if (section->sh_info >= num_syms)
5249 {
5250 error (_("Bad sh_info in group section `%s'\n"), name);
5251 continue;
5252 }
5253
f5842774
L		 5254 sym = symtab + section->sh_info;
5255
5256 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5257 {
4fbb74a6
AM		 5258 if (sym->st_shndx == 0
5259 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5260 {
5261 error (_("Bad sh_info in group section `%s'\n"), name);
5262 continue;
5263 }
ba2685cc 5264
4fbb74a6 5265 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5266 strtab_sec = NULL;
5267 if (strtab)
5268 free (strtab);
f5842774 5269 strtab = NULL;
c256ffe7 5270 strtab_size = 0;
f5842774
L		 5271 }
5272 else
5273 {
5274 /* Get the string table. */
4fbb74a6 5275 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5276 {
5277 strtab_sec = NULL;
5278 if (strtab)
5279 free (strtab);
5280 strtab = NULL;
5281 strtab_size = 0;
5282 }
5283 else if (strtab_sec
4fbb74a6 5284 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5285 {
5286 strtab_sec = sec;
5287 if (strtab)
5288 free (strtab);
3f5e193b
NC		 5289 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5290 1, strtab_sec->sh_size,
5291 _("string table"));
c256ffe7 5292 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5293 }
c256ffe7 5294 group_name = sym->st_name < strtab_size
2b692964 5295 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5296 }
5297
3f5e193b
NC		 5298 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5299 1, section->sh_size,
5300 _("section data"));
59245841
NC		 5301 if (start == NULL)
5302 continue;
f5842774
L		 5303
5304 indices = start;
5305 size = (section->sh_size / section->sh_entsize) - 1;
5306 entry = byte_get (indices, 4);
5307 indices += 4;
e4b17d5c
L		 5308
5309 if (do_section_groups)
5310 {
2b692964 5311 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5312 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5313
e4b17d5c
L		 5314 printf (_(" [Index] Name\n"));
5315 }
5316
5317 group->group_index = i;
5318
f5842774
L		 5319 for (j = 0; j < size; j++)
5320 {
2cf0635d 5321 struct group_list * g;
e4b17d5c 5322
f5842774
L		 5323 entry = byte_get (indices, 4);
5324 indices += 4;
5325
4fbb74a6 5326 if (entry >= elf_header.e_shnum)
391cb864
L		 5327 {
5328 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5329 entry, i, elf_header.e_shnum - 1);
5330 continue;
5331 }
391cb864 5332
4fbb74a6 5333 if (section_headers_groups [entry] != NULL)
e4b17d5c 5334 {
d1f5c6e3
L		 5335 if (entry)
5336 {
391cb864
L		 5337 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5338 entry, i,
4fbb74a6 5339 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5340 continue;
5341 }
5342 else
5343 {
5344 /* Intel C/C++ compiler may put section 0 in a
5345 section group. We just warn it the first time
5346 and ignore it afterwards. */
5347 static int warned = 0;
5348 if (!warned)
5349 {
5350 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5351 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5352 warned++;
5353 }
5354 }
e4b17d5c
L		 5355 }
5356
4fbb74a6 5357 section_headers_groups [entry] = group;
e4b17d5c
L		 5358
5359 if (do_section_groups)
5360 {
4fbb74a6 5361 sec = section_headers + entry;
c256ffe7 5362 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5363 }
5364
3f5e193b 5365 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5366 g->section_index = entry;
5367 g->next = group->root;
5368 group->root = g;
f5842774
L		 5369 }
5370
f5842774
L		 5371 if (start)
5372 free (start);
e4b17d5c
L		 5373
5374 group++;
f5842774
L		 5375 }
5376 }
5377
d1f5c6e3
L		 5378 if (symtab)
5379 free (symtab);
5380 if (strtab)
5381 free (strtab);
f5842774
L		 5382 return 1;
5383}
5384
28f997cf
TG		 5385/* Data used to display dynamic fixups. */
5386
5387struct ia64_vms_dynfixup
5388{
5389 bfd_vma needed_ident; /* Library ident number. */
5390 bfd_vma needed; /* Index in the dstrtab of the library name. */
5391 bfd_vma fixup_needed; /* Index of the library. */
5392 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5393 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5394};
5395
5396/* Data used to display dynamic relocations. */
5397
5398struct ia64_vms_dynimgrela
5399{
5400 bfd_vma img_rela_cnt; /* Number of relocations. */
5401 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5402};
5403
5404/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5405 library). */
5406
5407static void
5408dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5409 const char *strtab, unsigned int strtab_sz)
5410{
5411 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5412 long i;
5413 const char *lib_name;
5414
5415 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5416 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5417 _("dynamic section image fixups"));
5418 if (!imfs)
5419 return;
5420
5421 if (fixup->needed < strtab_sz)
5422 lib_name = strtab + fixup->needed;
5423 else
5424 {
5425 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5426 (unsigned long) fixup->needed);
28f997cf
TG		 5427 lib_name = "???";
5428 }
5429 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5430 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5431 printf
5432 (_("Seg Offset Type SymVec DataType\n"));
5433
5434 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5435 {
5436 unsigned int type;
5437 const char *rtype;
5438
5439 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5440 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5441 type = BYTE_GET (imfs [i].type);
5442 rtype = elf_ia64_reloc_type (type);
5443 if (rtype == NULL)
5444 printf (" 0x%08x ", type);
5445 else
5446 printf (" %-32s ", rtype);
5447 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5448 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5449 }
5450
5451 free (imfs);
5452}
5453
5454/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5455
5456static void
5457dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5458{
5459 Elf64_External_VMS_IMAGE_RELA *imrs;
5460 long i;
5461
5462 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5463 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5464 _("dynamic section image relocations"));
28f997cf
TG		 5465 if (!imrs)
5466 return;
5467
5468 printf (_("\nImage relocs\n"));
5469 printf
5470 (_("Seg Offset Type Addend Seg Sym Off\n"));
5471
5472 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5473 {
5474 unsigned int type;
5475 const char *rtype;
5476
5477 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5478 printf ("%08" BFD_VMA_FMT "x ",
5479 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5480 type = BYTE_GET (imrs [i].type);
5481 rtype = elf_ia64_reloc_type (type);
5482 if (rtype == NULL)
5483 printf ("0x%08x ", type);
5484 else
5485 printf ("%-31s ", rtype);
5486 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5487 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5488 printf ("%08" BFD_VMA_FMT "x\n",
5489 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5490 }
5491
5492 free (imrs);
5493}
5494
5495/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5496
5497static int
5498process_ia64_vms_dynamic_relocs (FILE *file)
5499{
5500 struct ia64_vms_dynfixup fixup;
5501 struct ia64_vms_dynimgrela imgrela;
5502 Elf_Internal_Dyn *entry;
5503 int res = 0;
5504 bfd_vma strtab_off = 0;
5505 bfd_vma strtab_sz = 0;
5506 char *strtab = NULL;
5507
5508 memset (&fixup, 0, sizeof (fixup));
5509 memset (&imgrela, 0, sizeof (imgrela));
5510
5511 /* Note: the order of the entries is specified by the OpenVMS specs. */
5512 for (entry = dynamic_section;
5513 entry < dynamic_section + dynamic_nent;
5514 entry++)
5515 {
5516 switch (entry->d_tag)
5517 {
5518 case DT_IA_64_VMS_STRTAB_OFFSET:
5519 strtab_off = entry->d_un.d_val;
5520 break;
5521 case DT_STRSZ:
5522 strtab_sz = entry->d_un.d_val;
5523 if (strtab == NULL)
5524 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5525 1, strtab_sz, _("dynamic string section"));
5526 break;
5527
5528 case DT_IA_64_VMS_NEEDED_IDENT:
5529 fixup.needed_ident = entry->d_un.d_val;
5530 break;
5531 case DT_NEEDED:
5532 fixup.needed = entry->d_un.d_val;
5533 break;
5534 case DT_IA_64_VMS_FIXUP_NEEDED:
5535 fixup.fixup_needed = entry->d_un.d_val;
5536 break;
5537 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5538 fixup.fixup_rela_cnt = entry->d_un.d_val;
5539 break;
5540 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5541 fixup.fixup_rela_off = entry->d_un.d_val;
5542 res++;
5543 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5544 break;
5545
5546 case DT_IA_64_VMS_IMG_RELA_CNT:
5547 imgrela.img_rela_cnt = entry->d_un.d_val;
5548 break;
5549 case DT_IA_64_VMS_IMG_RELA_OFF:
5550 imgrela.img_rela_off = entry->d_un.d_val;
5551 res++;
5552 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5553 break;
5554
5555 default:
5556 break;
5557 }
5558 }
5559
5560 if (strtab != NULL)
5561 free (strtab);
5562
5563 return res;
5564}
5565
85b1c36d 5566static struct
566b0d53 5567{
2cf0635d 5568 const char * name;
566b0d53
L		 5569 int reloc;
5570 int size;
5571 int rela;
5572} dynamic_relocations [] =
5573{
5574 { "REL", DT_REL, DT_RELSZ, FALSE },
5575 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5576 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5577};
5578
252b5132 5579/* Process the reloc section. */
18bd398b 5580
252b5132 5581static int
2cf0635d 5582process_relocs (FILE * file)
252b5132 5583{
b34976b6
AM		 5584 unsigned long rel_size;
5585 unsigned long rel_offset;
252b5132
RH		 5586
5587
5588 if (!do_reloc)
5589 return 1;
5590
5591 if (do_using_dynamic)
5592 {
566b0d53 5593 int is_rela;
2cf0635d 5594 const char * name;
566b0d53
L		 5595 int has_dynamic_reloc;
5596 unsigned int i;
0de14b54 5597
566b0d53 5598 has_dynamic_reloc = 0;
252b5132 5599
566b0d53 5600 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5601 {
566b0d53
L		 5602 is_rela = dynamic_relocations [i].rela;
5603 name = dynamic_relocations [i].name;
5604 rel_size = dynamic_info [dynamic_relocations [i].size];
5605 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5606
566b0d53
L		 5607 has_dynamic_reloc |= rel_size;
5608
5609 if (is_rela == UNKNOWN)
aa903cfb 5610 {
566b0d53
L		 5611 if (dynamic_relocations [i].reloc == DT_JMPREL)
5612 switch (dynamic_info[DT_PLTREL])
5613 {
5614 case DT_REL:
5615 is_rela = FALSE;
5616 break;
5617 case DT_RELA:
5618 is_rela = TRUE;
5619 break;
5620 }
aa903cfb 5621 }
252b5132 5622
566b0d53
L		 5623 if (rel_size)
5624 {
5625 printf
5626 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5627 name, rel_offset, rel_size);
252b5132 5628
d93f0186
NC		 5629 dump_relocations (file,
5630 offset_from_vma (file, rel_offset, rel_size),
5631 rel_size,
566b0d53 5632 dynamic_symbols, num_dynamic_syms,
d79b3d50 5633 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5634 }
252b5132 5635 }
566b0d53 5636
28f997cf
TG		 5637 if (is_ia64_vms ())
5638 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5639
566b0d53 5640 if (! has_dynamic_reloc)
252b5132
RH		 5641 printf (_("\nThere are no dynamic relocations in this file.\n"));
5642 }
5643 else
5644 {
2cf0635d 5645 Elf_Internal_Shdr * section;
b34976b6
AM		 5646 unsigned long i;
5647 int found = 0;
252b5132
RH		 5648
5649 for (i = 0, section = section_headers;
5650 i < elf_header.e_shnum;
b34976b6 5651 i++, section++)
252b5132
RH		 5652 {
5653 if ( section->sh_type != SHT_RELA
5654 && section->sh_type != SHT_REL)
5655 continue;
5656
5657 rel_offset = section->sh_offset;
5658 rel_size = section->sh_size;
5659
5660 if (rel_size)
5661 {
2cf0635d 5662 Elf_Internal_Shdr * strsec;
b34976b6 5663 int is_rela;
103f02d3 5664
252b5132
RH		 5665 printf (_("\nRelocation section "));
5666
5667 if (string_table == NULL)
19936277 5668 printf ("%d", section->sh_name);
252b5132 5669 else
9cf03b7e 5670 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5671
5672 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5673 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5674
d79b3d50
NC		 5675 is_rela = section->sh_type == SHT_RELA;
5676
4fbb74a6
AM		 5677 if (section->sh_link != 0
5678 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5679 {
2cf0635d
NC		 5680 Elf_Internal_Shdr * symsec;
5681 Elf_Internal_Sym * symtab;
d79b3d50 5682 unsigned long nsyms;
c256ffe7 5683 unsigned long strtablen = 0;
2cf0635d 5684 char * strtab = NULL;
57346661 5685
4fbb74a6 5686 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5687 if (symsec->sh_type != SHT_SYMTAB
5688 && symsec->sh_type != SHT_DYNSYM)
5689 continue;
5690
ba5cdace 5691 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5692
af3fc3bc
AM		 5693 if (symtab == NULL)
5694 continue;
252b5132 5695
4fbb74a6
AM		 5696 if (symsec->sh_link != 0
5697 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5698 {
4fbb74a6 5699 strsec = section_headers + symsec->sh_link;
103f02d3 5700
3f5e193b
NC		 5701 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5702 1, strsec->sh_size,
5703 _("string table"));
c256ffe7
JJ		 5704 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5705 }
252b5132 5706
d79b3d50
NC		 5707 dump_relocations (file, rel_offset, rel_size,
5708 symtab, nsyms, strtab, strtablen, is_rela);
5709 if (strtab)
5710 free (strtab);
5711 free (symtab);
5712 }
5713 else
5714 dump_relocations (file, rel_offset, rel_size,
5715 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5716
5717 found = 1;
5718 }
5719 }
5720
5721 if (! found)
5722 printf (_("\nThere are no relocations in this file.\n"));
5723 }
5724
5725 return 1;
5726}
5727
57346661
AM		 5728/* Process the unwind section. */
5729
4d6ed7c8
NC		 5730#include "unwind-ia64.h"
5731
5732/* An absolute address consists of a section and an offset. If the
5733 section is NULL, the offset itself is the address, otherwise, the
5734 address equals to LOAD_ADDRESS(section) + offset. */
5735
5736struct absaddr
5737 {
5738 unsigned short section;
5739 bfd_vma offset;
5740 };
5741
1949de15
L		 5742#define ABSADDR(a) \
5743 ((a).section \
5744 ? section_headers [(a).section].sh_addr + (a).offset \
5745 : (a).offset)
5746
3f5e193b
NC		 5747struct ia64_unw_table_entry
5748 {
5749 struct absaddr start;
5750 struct absaddr end;
5751 struct absaddr info;
5752 };
5753
57346661 5754struct ia64_unw_aux_info
4d6ed7c8 5755 {
3f5e193b
NC		 5756
5757 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5758 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5759 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5760 unsigned long info_size; /* Size of unwind info. */
5761 bfd_vma info_addr; /* starting address of unwind info. */
5762 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5763 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5764 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5765 char * strtab; /* The string table. */
b34976b6 5766 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5767 };
5768
4d6ed7c8 5769static void
2cf0635d 5770find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5771 unsigned long nsyms,
2cf0635d 5772 const char * strtab,
57346661 5773 unsigned long strtab_size,
d3ba0551 5774 struct absaddr addr,
2cf0635d
NC		 5775 const char ** symname,
5776 bfd_vma * offset)
4d6ed7c8 5777{
d3ba0551 5778 bfd_vma dist = 0x100000;
2cf0635d
NC		 5779 Elf_Internal_Sym * sym;
5780 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5781 unsigned long i;
5782
0b6ae522
DJ		 5783 REMOVE_ARCH_BITS (addr.offset);
5784
57346661 5785 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5786 {
0b6ae522
DJ		 5787 bfd_vma value = sym->st_value;
5788
5789 REMOVE_ARCH_BITS (value);
5790
4d6ed7c8
NC		 5791 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5792 && sym->st_name != 0
5793 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5794 && addr.offset >= value
5795 && addr.offset - value < dist)
4d6ed7c8
NC		 5796 {
5797 best = sym;
0b6ae522 5798 dist = addr.offset - value;
4d6ed7c8
NC		 5799 if (!dist)
5800 break;
5801 }
5802 }
1b31d05e 5803
4d6ed7c8
NC		 5804 if (best)
5805 {
57346661 5806 *symname = (best->st_name >= strtab_size
2b692964 5807 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5808 *offset = dist;
5809 return;
5810 }
1b31d05e 5811
4d6ed7c8
NC		 5812 *symname = NULL;
5813 *offset = addr.offset;
5814}
5815
5816static void
2cf0635d 5817dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5818{
2cf0635d 5819 struct ia64_unw_table_entry * tp;
4d6ed7c8 5820 int in_body;
7036c0e1 5821
4d6ed7c8
NC		 5822 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5823 {
5824 bfd_vma stamp;
5825 bfd_vma offset;
2cf0635d
NC		 5826 const unsigned char * dp;
5827 const unsigned char * head;
5828 const char * procname;
4d6ed7c8 5829
57346661
AM		 5830 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5831 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5832
5833 fputs ("\n<", stdout);
5834
5835 if (procname)
5836 {
5837 fputs (procname, stdout);
5838
5839 if (offset)
5840 printf ("+%lx", (unsigned long) offset);
5841 }
5842
5843 fputs (">: [", stdout);
5844 print_vma (tp->start.offset, PREFIX_HEX);
5845 fputc ('-', stdout);
5846 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5847 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5848 (unsigned long) (tp->info.offset - aux->seg_base));
5849
1949de15 5850 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5851 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5852
86f55779 5853 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5854 (unsigned) UNW_VER (stamp),
5855 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5856 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5857 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5858 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5859
5860 if (UNW_VER (stamp) != 1)
5861 {
2b692964 5862 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5863 continue;
5864 }
5865
5866 in_body = 0;
89fac5e3 5867 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5868 dp = unw_decode (dp, in_body, & in_body);
5869 }
5870}
5871
5872static int
2cf0635d
NC		 5873slurp_ia64_unwind_table (FILE * file,
5874 struct ia64_unw_aux_info * aux,
5875 Elf_Internal_Shdr * sec)
4d6ed7c8 5876{
89fac5e3 5877 unsigned long size, nrelas, i;
2cf0635d
NC		 5878 Elf_Internal_Phdr * seg;
5879 struct ia64_unw_table_entry * tep;
5880 Elf_Internal_Shdr * relsec;
5881 Elf_Internal_Rela * rela;
5882 Elf_Internal_Rela * rp;
5883 unsigned char * table;
5884 unsigned char * tp;
5885 Elf_Internal_Sym * sym;
5886 const char * relname;
4d6ed7c8 5887
4d6ed7c8
NC		 5888 /* First, find the starting address of the segment that includes
5889 this section: */
5890
5891 if (elf_header.e_phnum)
5892 {
d93f0186 5893 if (! get_program_headers (file))
4d6ed7c8 5894 return 0;
4d6ed7c8 5895
d93f0186
NC		 5896 for (seg = program_headers;
5897 seg < program_headers + elf_header.e_phnum;
5898 ++seg)
4d6ed7c8
NC		 5899 {
5900 if (seg->p_type != PT_LOAD)
5901 continue;
5902
5903 if (sec->sh_addr >= seg->p_vaddr
5904 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5905 {
5906 aux->seg_base = seg->p_vaddr;
5907 break;
5908 }
5909 }
4d6ed7c8
NC		 5910 }
5911
5912 /* Second, build the unwind table from the contents of the unwind section: */
5913 size = sec->sh_size;
3f5e193b
NC		 5914 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5915 _("unwind table"));
a6e9f9df
AM		 5916 if (!table)
5917 return 0;
4d6ed7c8 5918
3f5e193b
NC		 5919 aux->table = (struct ia64_unw_table_entry *)
5920 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5921 tep = aux->table;
c6a0c689 5922 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5923 {
5924 tep->start.section = SHN_UNDEF;
5925 tep->end.section = SHN_UNDEF;
5926 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5927 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5928 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5929 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5930 tep->start.offset += aux->seg_base;
5931 tep->end.offset += aux->seg_base;
5932 tep->info.offset += aux->seg_base;
5933 }
5934 free (table);
5935
41e92641 5936 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5937 for (relsec = section_headers;
5938 relsec < section_headers + elf_header.e_shnum;
5939 ++relsec)
5940 {
5941 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5942 || relsec->sh_info >= elf_header.e_shnum
5943 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5944 continue;
5945
5946 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5947 & rela, & nrelas))
5948 return 0;
5949
5950 for (rp = rela; rp < rela + nrelas; ++rp)
5951 {
aca88567
NC		 5952 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5953 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5954
0112cd26 5955 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5956 {
e5fb9629 5957 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5958 continue;
5959 }
5960
89fac5e3 5961 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5962
89fac5e3 5963 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5964 {
5965 case 0:
5966 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5967 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5968 break;
5969 case 1:
5970 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5971 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5972 break;
5973 case 2:
5974 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5975 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5976 break;
5977 default:
5978 break;
5979 }
5980 }
5981
5982 free (rela);
5983 }
5984
89fac5e3 5985 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5986 return 1;
5987}
5988
1b31d05e 5989static void
2cf0635d 5990ia64_process_unwind (FILE * file)
4d6ed7c8 5991{
2cf0635d
NC		 5992 Elf_Internal_Shdr * sec;
5993 Elf_Internal_Shdr * unwsec = NULL;
5994 Elf_Internal_Shdr * strsec;
89fac5e3 5995 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5996 struct ia64_unw_aux_info aux;
f1467e33 5997
4d6ed7c8
NC		 5998 memset (& aux, 0, sizeof (aux));
5999
4d6ed7c8
NC		 6000 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6001 {
c256ffe7 6002 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6003 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6004 {
ba5cdace 6005 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6006
4fbb74a6 6007 strsec = section_headers + sec->sh_link;
59245841 6008 assert (aux.strtab == NULL);
3f5e193b
NC		 6009 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6010 1, strsec->sh_size,
6011 _("string table"));
c256ffe7 6012 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6013 }
6014 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6015 unwcount++;
6016 }
6017
6018 if (!unwcount)
6019 printf (_("\nThere are no unwind sections in this file.\n"));
6020
6021 while (unwcount-- > 0)
6022 {
2cf0635d 6023 char * suffix;
579f31ac
JJ		 6024 size_t len, len2;
6025
6026 for (i = unwstart, sec = section_headers + unwstart;
6027 i < elf_header.e_shnum; ++i, ++sec)
6028 if (sec->sh_type == SHT_IA_64_UNWIND)
6029 {
6030 unwsec = sec;
6031 break;
6032 }
6033
6034 unwstart = i + 1;
6035 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6036
e4b17d5c
L		 6037 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6038 {
6039 /* We need to find which section group it is in. */
2cf0635d 6040 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 6041
6042 for (; g != NULL; g = g->next)
6043 {
4fbb74a6 6044 sec = section_headers + g->section_index;
18bd398b
NC		 6045
6046 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6047 break;
e4b17d5c
L		 6048 }
6049
6050 if (g == NULL)
6051 i = elf_header.e_shnum;
6052 }
18bd398b 6053 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6054 {
18bd398b 6055 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6056 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6057 suffix = SECTION_NAME (unwsec) + len;
6058 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6059 ++i, ++sec)
18bd398b
NC		 6060 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6061 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6062 break;
6063 }
6064 else
6065 {
6066 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6067 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6068 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6069 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6070 suffix = "";
18bd398b 6071 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6072 suffix = SECTION_NAME (unwsec) + len;
6073 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6074 ++i, ++sec)
18bd398b
NC		 6075 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6076 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6077 break;
6078 }
6079
6080 if (i == elf_header.e_shnum)
6081 {
6082 printf (_("\nCould not find unwind info section for "));
6083
6084 if (string_table == NULL)
6085 printf ("%d", unwsec->sh_name);
6086 else
3a1a2036 6087 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 6088 }
6089 else
4d6ed7c8 6090 {
4d6ed7c8 6091 aux.info_addr = sec->sh_addr;
3f5e193b 6092 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6093 sec->sh_size,
3f5e193b 6094 _("unwind info"));
59245841 6095 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6096
579f31ac 6097 printf (_("\nUnwind section "));
4d6ed7c8 6098
579f31ac
JJ		 6099 if (string_table == NULL)
6100 printf ("%d", unwsec->sh_name);
6101 else
3a1a2036 6102 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6103
579f31ac 6104 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6105 (unsigned long) unwsec->sh_offset,
89fac5e3 6106 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6107
579f31ac 6108 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6109
579f31ac
JJ		 6110 if (aux.table_len > 0)
6111 dump_ia64_unwind (& aux);
6112
6113 if (aux.table)
6114 free ((char *) aux.table);
6115 if (aux.info)
6116 free ((char *) aux.info);
6117 aux.table = NULL;
6118 aux.info = NULL;
6119 }
4d6ed7c8 6120 }
4d6ed7c8 6121
4d6ed7c8
NC		 6122 if (aux.symtab)
6123 free (aux.symtab);
6124 if (aux.strtab)
6125 free ((char *) aux.strtab);
4d6ed7c8
NC		 6126}
6127
3f5e193b
NC		 6128struct hppa_unw_table_entry
6129 {
6130 struct absaddr start;
6131 struct absaddr end;
6132 unsigned int Cannot_unwind:1; /* 0 */
6133 unsigned int Millicode:1; /* 1 */
6134 unsigned int Millicode_save_sr0:1; /* 2 */
6135 unsigned int Region_description:2; /* 3..4 */
6136 unsigned int reserved1:1; /* 5 */
6137 unsigned int Entry_SR:1; /* 6 */
6138 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6139 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6140 unsigned int Args_stored:1; /* 16 */
6141 unsigned int Variable_Frame:1; /* 17 */
6142 unsigned int Separate_Package_Body:1; /* 18 */
6143 unsigned int Frame_Extension_Millicode:1; /* 19 */
6144 unsigned int Stack_Overflow_Check:1; /* 20 */
6145 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6146 unsigned int Ada_Region:1; /* 22 */
6147 unsigned int cxx_info:1; /* 23 */
6148 unsigned int cxx_try_catch:1; /* 24 */
6149 unsigned int sched_entry_seq:1; /* 25 */
6150 unsigned int reserved2:1; /* 26 */
6151 unsigned int Save_SP:1; /* 27 */
6152 unsigned int Save_RP:1; /* 28 */
6153 unsigned int Save_MRP_in_frame:1; /* 29 */
6154 unsigned int extn_ptr_defined:1; /* 30 */
6155 unsigned int Cleanup_defined:1; /* 31 */
6156
6157 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6158 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6159 unsigned int Large_frame:1; /* 2 */
6160 unsigned int Pseudo_SP_Set:1; /* 3 */
6161 unsigned int reserved4:1; /* 4 */
6162 unsigned int Total_frame_size:27; /* 5..31 */
6163 };
6164
57346661
AM		 6165struct hppa_unw_aux_info
6166 {
3f5e193b 6167 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6168 unsigned long table_len; /* Length of unwind table. */
6169 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6170 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6171 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6172 char * strtab; /* The string table. */
57346661
AM		 6173 unsigned long strtab_size; /* Size of string table. */
6174 };
6175
6176static void
2cf0635d 6177dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6178{
2cf0635d 6179 struct hppa_unw_table_entry * tp;
57346661 6180
57346661
AM		 6181 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6182 {
6183 bfd_vma offset;
2cf0635d 6184 const char * procname;
57346661
AM		 6185
6186 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6187 aux->strtab_size, tp->start, &procname,
6188 &offset);
6189
6190 fputs ("\n<", stdout);
6191
6192 if (procname)
6193 {
6194 fputs (procname, stdout);
6195
6196 if (offset)
6197 printf ("+%lx", (unsigned long) offset);
6198 }
6199
6200 fputs (">: [", stdout);
6201 print_vma (tp->start.offset, PREFIX_HEX);
6202 fputc ('-', stdout);
6203 print_vma (tp->end.offset, PREFIX_HEX);
6204 printf ("]\n\t");
6205
18bd398b
NC		 6206#define PF(_m) if (tp->_m) printf (#_m " ");
6207#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6208 PF(Cannot_unwind);
6209 PF(Millicode);
6210 PF(Millicode_save_sr0);
18bd398b 6211 /* PV(Region_description); */
57346661
AM		 6212 PF(Entry_SR);
6213 PV(Entry_FR);
6214 PV(Entry_GR);
6215 PF(Args_stored);
6216 PF(Variable_Frame);
6217 PF(Separate_Package_Body);
6218 PF(Frame_Extension_Millicode);
6219 PF(Stack_Overflow_Check);
6220 PF(Two_Instruction_SP_Increment);
6221 PF(Ada_Region);
6222 PF(cxx_info);
6223 PF(cxx_try_catch);
6224 PF(sched_entry_seq);
6225 PF(Save_SP);
6226 PF(Save_RP);
6227 PF(Save_MRP_in_frame);
6228 PF(extn_ptr_defined);
6229 PF(Cleanup_defined);
6230 PF(MPE_XL_interrupt_marker);
6231 PF(HP_UX_interrupt_marker);
6232 PF(Large_frame);
6233 PF(Pseudo_SP_Set);
6234 PV(Total_frame_size);
6235#undef PF
6236#undef PV
6237 }
6238
18bd398b 6239 printf ("\n");
57346661
AM		 6240}
6241
6242static int
2cf0635d
NC		 6243slurp_hppa_unwind_table (FILE * file,
6244 struct hppa_unw_aux_info * aux,
6245 Elf_Internal_Shdr * sec)
57346661 6246{
1c0751b2 6247 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6248 Elf_Internal_Phdr * seg;
6249 struct hppa_unw_table_entry * tep;
6250 Elf_Internal_Shdr * relsec;
6251 Elf_Internal_Rela * rela;
6252 Elf_Internal_Rela * rp;
6253 unsigned char * table;
6254 unsigned char * tp;
6255 Elf_Internal_Sym * sym;
6256 const char * relname;
57346661 6257
57346661
AM		 6258 /* First, find the starting address of the segment that includes
6259 this section. */
6260
6261 if (elf_header.e_phnum)
6262 {
6263 if (! get_program_headers (file))
6264 return 0;
6265
6266 for (seg = program_headers;
6267 seg < program_headers + elf_header.e_phnum;
6268 ++seg)
6269 {
6270 if (seg->p_type != PT_LOAD)
6271 continue;
6272
6273 if (sec->sh_addr >= seg->p_vaddr
6274 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6275 {
6276 aux->seg_base = seg->p_vaddr;
6277 break;
6278 }
6279 }
6280 }
6281
6282 /* Second, build the unwind table from the contents of the unwind
6283 section. */
6284 size = sec->sh_size;
3f5e193b
NC		 6285 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6286 _("unwind table"));
57346661
AM		 6287 if (!table)
6288 return 0;
6289
1c0751b2
DA		 6290 unw_ent_size = 16;
6291 nentries = size / unw_ent_size;
6292 size = unw_ent_size * nentries;
57346661 6293
3f5e193b
NC		 6294 tep = aux->table = (struct hppa_unw_table_entry *)
6295 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6296
1c0751b2 6297 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6298 {
6299 unsigned int tmp1, tmp2;
6300
6301 tep->start.section = SHN_UNDEF;
6302 tep->end.section = SHN_UNDEF;
6303
1c0751b2
DA		 6304 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6305 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6306 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6307 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6308
6309 tep->start.offset += aux->seg_base;
6310 tep->end.offset += aux->seg_base;
57346661
AM		 6311
6312 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6313 tep->Millicode = (tmp1 >> 30) & 0x1;
6314 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6315 tep->Region_description = (tmp1 >> 27) & 0x3;
6316 tep->reserved1 = (tmp1 >> 26) & 0x1;
6317 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6318 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6319 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6320 tep->Args_stored = (tmp1 >> 15) & 0x1;
6321 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6322 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6323 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6324 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6325 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6326 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6327 tep->cxx_info = (tmp1 >> 8) & 0x1;
6328 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6329 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6330 tep->reserved2 = (tmp1 >> 5) & 0x1;
6331 tep->Save_SP = (tmp1 >> 4) & 0x1;
6332 tep->Save_RP = (tmp1 >> 3) & 0x1;
6333 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6334 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6335 tep->Cleanup_defined = tmp1 & 0x1;
6336
6337 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6338 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6339 tep->Large_frame = (tmp2 >> 29) & 0x1;
6340 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6341 tep->reserved4 = (tmp2 >> 27) & 0x1;
6342 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6343 }
6344 free (table);
6345
6346 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6347 for (relsec = section_headers;
6348 relsec < section_headers + elf_header.e_shnum;
6349 ++relsec)
6350 {
6351 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6352 || relsec->sh_info >= elf_header.e_shnum
6353 || section_headers + relsec->sh_info != sec)
57346661
AM		 6354 continue;
6355
6356 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6357 & rela, & nrelas))
6358 return 0;
6359
6360 for (rp = rela; rp < rela + nrelas; ++rp)
6361 {
aca88567
NC		 6362 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6363 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6364
6365 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6366 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6367 {
6368 warn (_("Skipping unexpected relocation type %s\n"), relname);
6369 continue;
6370 }
6371
6372 i = rp->r_offset / unw_ent_size;
6373
89fac5e3 6374 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6375 {
6376 case 0:
6377 aux->table[i].start.section = sym->st_shndx;
1e456d54 6378 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6379 break;
6380 case 1:
6381 aux->table[i].end.section = sym->st_shndx;
1e456d54 6382 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6383 break;
6384 default:
6385 break;
6386 }
6387 }
6388
6389 free (rela);
6390 }
6391
1c0751b2 6392 aux->table_len = nentries;
57346661
AM		 6393
6394 return 1;
6395}
6396
1b31d05e 6397static void
2cf0635d 6398hppa_process_unwind (FILE * file)
57346661 6399{
57346661 6400 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6401 Elf_Internal_Shdr * unwsec = NULL;
6402 Elf_Internal_Shdr * strsec;
6403 Elf_Internal_Shdr * sec;
18bd398b 6404 unsigned long i;
57346661 6405
c256ffe7 6406 if (string_table == NULL)
1b31d05e
NC		 6407 return;
6408
6409 memset (& aux, 0, sizeof (aux));
57346661
AM		 6410
6411 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6412 {
c256ffe7 6413 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6414 && sec->sh_link < elf_header.e_shnum)
57346661 6415 {
ba5cdace 6416 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6417
4fbb74a6 6418 strsec = section_headers + sec->sh_link;
59245841 6419 assert (aux.strtab == NULL);
3f5e193b
NC		 6420 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6421 1, strsec->sh_size,
6422 _("string table"));
c256ffe7 6423 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6424 }
18bd398b 6425 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6426 unwsec = sec;
6427 }
6428
6429 if (!unwsec)
6430 printf (_("\nThere are no unwind sections in this file.\n"));
6431
6432 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6433 {
18bd398b 6434 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6435 {
57346661
AM		 6436 printf (_("\nUnwind section "));
6437 printf (_("'%s'"), SECTION_NAME (sec));
6438
6439 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6440 (unsigned long) sec->sh_offset,
89fac5e3 6441 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6442
6443 slurp_hppa_unwind_table (file, &aux, sec);
6444 if (aux.table_len > 0)
6445 dump_hppa_unwind (&aux);
6446
6447 if (aux.table)
6448 free ((char *) aux.table);
6449 aux.table = NULL;
6450 }
6451 }
6452
6453 if (aux.symtab)
6454 free (aux.symtab);
6455 if (aux.strtab)
6456 free ((char *) aux.strtab);
57346661
AM		 6457}
6458
0b6ae522
DJ		 6459struct arm_section
6460{
a734115a
NC		 6461 unsigned char * data; /* The unwind data. */
6462 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6463 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6464 unsigned long nrelas; /* The number of relocations. */
6465 unsigned int rel_type; /* REL or RELA ? */
6466 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6467};
6468
6469struct arm_unw_aux_info
6470{
a734115a
NC		 6471 FILE * file; /* The file containing the unwind sections. */
6472 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6473 unsigned long nsyms; /* Number of symbols. */
6474 char * strtab; /* The file's string table. */
6475 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6476};
6477
6478static const char *
6479arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6480 bfd_vma fn, struct absaddr addr)
6481{
6482 const char *procname;
6483 bfd_vma sym_offset;
6484
6485 if (addr.section == SHN_UNDEF)
6486 addr.offset = fn;
6487
6488 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6489 aux->strtab_size, addr, &procname,
6490 &sym_offset);
6491
6492 print_vma (fn, PREFIX_HEX);
6493
6494 if (procname)
6495 {
6496 fputs (" <", stdout);
6497 fputs (procname, stdout);
6498
6499 if (sym_offset)
6500 printf ("+0x%lx", (unsigned long) sym_offset);
6501 fputc ('>', stdout);
6502 }
6503
6504 return procname;
6505}
6506
6507static void
6508arm_free_section (struct arm_section *arm_sec)
6509{
6510 if (arm_sec->data != NULL)
6511 free (arm_sec->data);
6512
6513 if (arm_sec->rela != NULL)
6514 free (arm_sec->rela);
6515}
6516
a734115a
NC		 6517/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6518 cached section and install SEC instead.
6519 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6520 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6521 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6522 relocation's offset in ADDR.
1b31d05e
NC		 6523 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6524 into the string table of the symbol associated with the reloc. If no
6525 reloc was applied store -1 there.
6526 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6527
6528static bfd_boolean
1b31d05e
NC		 6529get_unwind_section_word (struct arm_unw_aux_info * aux,
6530 struct arm_section * arm_sec,
6531 Elf_Internal_Shdr * sec,
6532 bfd_vma word_offset,
6533 unsigned int * wordp,
6534 struct absaddr * addr,
6535 bfd_vma * sym_name)
0b6ae522
DJ		 6536{
6537 Elf_Internal_Rela *rp;
6538 Elf_Internal_Sym *sym;
6539 const char * relname;
6540 unsigned int word;
6541 bfd_boolean wrapped;
6542
6543 addr->section = SHN_UNDEF;
6544 addr->offset = 0;
6545
1b31d05e
NC		 6546 if (sym_name != NULL)
6547 *sym_name = (bfd_vma) -1;
6548
a734115a 6549 /* If necessary, update the section cache. */
0b6ae522
DJ		 6550 if (sec != arm_sec->sec)
6551 {
6552 Elf_Internal_Shdr *relsec;
6553
6554 arm_free_section (arm_sec);
6555
6556 arm_sec->sec = sec;
6557 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6558 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6559 arm_sec->rela = NULL;
6560 arm_sec->nrelas = 0;
6561
6562 for (relsec = section_headers;
6563 relsec < section_headers + elf_header.e_shnum;
6564 ++relsec)
6565 {
6566 if (relsec->sh_info >= elf_header.e_shnum
6567 || section_headers + relsec->sh_info != sec)
6568 continue;
6569
a734115a 6570 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6571 if (relsec->sh_type == SHT_REL)
6572 {
6573 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6574 relsec->sh_size,
6575 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6576 return FALSE;
0b6ae522
DJ		 6577 break;
6578 }
6579 else if (relsec->sh_type == SHT_RELA)
6580 {
6581 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6582 relsec->sh_size,
6583 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6584 return FALSE;
0b6ae522
DJ		 6585 break;
6586 }
a734115a
NC		 6587 else
6588 warn (_("unexpected relocation type (%d) for section %d"),
6589 relsec->sh_type, relsec->sh_info);
0b6ae522
DJ		 6590 }
6591
6592 arm_sec->next_rela = arm_sec->rela;
6593 }
6594
a734115a 6595 /* If there is no unwind data we can do nothing. */
0b6ae522 6596 if (arm_sec->data == NULL)
a734115a 6597 return FALSE;
0b6ae522 6598
a734115a 6599 /* Get the word at the required offset. */
0b6ae522
DJ		 6600 word = byte_get (arm_sec->data + word_offset, 4);
6601
a734115a 6602 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6603 wrapped = FALSE;
6604 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6605 {
6606 bfd_vma prelval, offset;
6607
6608 if (rp->r_offset > word_offset && !wrapped)
6609 {
6610 rp = arm_sec->rela;
6611 wrapped = TRUE;
6612 }
6613 if (rp->r_offset > word_offset)
6614 break;
6615
6616 if (rp->r_offset & 3)
6617 {
6618 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6619 (unsigned long) rp->r_offset);
6620 continue;
6621 }
6622
6623 if (rp->r_offset < word_offset)
6624 continue;
6625
0b6ae522
DJ		 6626 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6627
6628 if (arm_sec->rel_type == SHT_REL)
6629 {
6630 offset = word & 0x7fffffff;
6631 if (offset & 0x40000000)
6632 offset |= ~ (bfd_vma) 0x7fffffff;
6633 }
a734115a 6634 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6635 offset = rp->r_addend;
a734115a
NC		 6636 else
6637 abort ();
0b6ae522
DJ		 6638
6639 offset += sym->st_value;
6640 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6641
a734115a
NC		 6642 /* Check that we are processing the expected reloc type. */
6643 if (elf_header.e_machine == EM_ARM)
6644 {
6645 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6646
6647 if (streq (relname, "R_ARM_NONE"))
6648 continue;
6649
6650 if (! streq (relname, "R_ARM_PREL31"))
6651 {
6652 warn (_("Skipping unexpected relocation type %s\n"), relname);
6653 continue;
6654 }
6655 }
6656 else if (elf_header.e_machine == EM_TI_C6000)
6657 {
6658 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6659
6660 if (streq (relname, "R_C6000_NONE"))
6661 continue;
6662
6663 if (! streq (relname, "R_C6000_PREL31"))
6664 {
6665 warn (_("Skipping unexpected relocation type %s\n"), relname);
6666 continue;
6667 }
6668
6669 prelval >>= 1;
6670 }
6671 else
6672 /* This function currently only supports ARM and TI unwinders. */
6673 abort ();
fa197c1c 6674
0b6ae522
DJ		 6675 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6676 addr->section = sym->st_shndx;
6677 addr->offset = offset;
1b31d05e
NC		 6678 if (sym_name)
6679 * sym_name = sym->st_name;
0b6ae522
DJ		 6680 break;
6681 }
6682
6683 *wordp = word;
6684 arm_sec->next_rela = rp;
6685
a734115a 6686 return TRUE;
0b6ae522
DJ		 6687}
6688
a734115a
NC		 6689static const char *tic6x_unwind_regnames[16] =
6690{
6691 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6692 "A14", "A13", "A12", "A11", "A10",
6693 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6694};
fa197c1c 6695
0b6ae522 6696static void
fa197c1c 6697decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6698{
fa197c1c
PB		 6699 int i;
6700
6701 for (i = 12; mask; mask >>= 1, i--)
6702 {
6703 if (mask & 1)
6704 {
6705 fputs (tic6x_unwind_regnames[i], stdout);
6706 if (mask > 1)
6707 fputs (", ", stdout);
6708 }
6709 }
6710}
0b6ae522
DJ		 6711
6712#define ADVANCE \
6713 if (remaining == 0 && more_words) \
6714 { \
6715 data_offset += 4; \
1b31d05e
NC		 6716 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6717 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 6718 return; \
6719 remaining = 4; \
6720 more_words--; \
6721 } \
6722
6723#define GET_OP(OP) \
6724 ADVANCE; \
6725 if (remaining) \
6726 { \
6727 remaining--; \
6728 (OP) = word >> 24; \
6729 word <<= 8; \
6730 } \
6731 else \
6732 { \
2b692964 6733 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6734 return; \
6735 } \
cc5914eb 6736 printf ("0x%02x ", OP)
0b6ae522 6737
fa197c1c
PB		 6738static void
6739decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6740 unsigned int word, unsigned int remaining,
6741 unsigned int more_words,
6742 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6743 struct arm_section *data_arm_sec)
6744{
6745 struct absaddr addr;
0b6ae522
DJ		 6746
6747 /* Decode the unwinding instructions. */
6748 while (1)
6749 {
6750 unsigned int op, op2;
6751
6752 ADVANCE;
6753 if (remaining == 0)
6754 break;
6755 remaining--;
6756 op = word >> 24;
6757 word <<= 8;
6758
cc5914eb 6759 printf (" 0x%02x ", op);
0b6ae522
DJ		 6760
6761 if ((op & 0xc0) == 0x00)
6762 {
6763 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6764
cc5914eb 6765 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6766 }
6767 else if ((op & 0xc0) == 0x40)
6768 {
6769 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6770
cc5914eb 6771 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6772 }
6773 else if ((op & 0xf0) == 0x80)
6774 {
6775 GET_OP (op2);
6776 if (op == 0x80 && op2 == 0)
6777 printf (_("Refuse to unwind"));
6778 else
6779 {
6780 unsigned int mask = ((op & 0x0f) << 8) | op2;
6781 int first = 1;
6782 int i;
2b692964 6783
0b6ae522
DJ		 6784 printf ("pop {");
6785 for (i = 0; i < 12; i++)
6786 if (mask & (1 << i))
6787 {
6788 if (first)
6789 first = 0;
6790 else
6791 printf (", ");
6792 printf ("r%d", 4 + i);
6793 }
6794 printf ("}");
6795 }
6796 }
6797 else if ((op & 0xf0) == 0x90)
6798 {
6799 if (op == 0x9d || op == 0x9f)
6800 printf (_(" [Reserved]"));
6801 else
cc5914eb 6802 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6803 }
6804 else if ((op & 0xf0) == 0xa0)
6805 {
6806 int end = 4 + (op & 0x07);
6807 int first = 1;
6808 int i;
61865e30 6809
0b6ae522
DJ		 6810 printf (" pop {");
6811 for (i = 4; i <= end; i++)
6812 {
6813 if (first)
6814 first = 0;
6815 else
6816 printf (", ");
6817 printf ("r%d", i);
6818 }
6819 if (op & 0x08)
6820 {
1b31d05e 6821 if (!first)
0b6ae522
DJ		 6822 printf (", ");
6823 printf ("r14");
6824 }
6825 printf ("}");
6826 }
6827 else if (op == 0xb0)
6828 printf (_(" finish"));
6829 else if (op == 0xb1)
6830 {
6831 GET_OP (op2);
6832 if (op2 == 0 || (op2 & 0xf0) != 0)
6833 printf (_("[Spare]"));
6834 else
6835 {
6836 unsigned int mask = op2 & 0x0f;
6837 int first = 1;
6838 int i;
61865e30 6839
0b6ae522
DJ		 6840 printf ("pop {");
6841 for (i = 0; i < 12; i++)
6842 if (mask & (1 << i))
6843 {
6844 if (first)
6845 first = 0;
6846 else
6847 printf (", ");
6848 printf ("r%d", i);
6849 }
6850 printf ("}");
6851 }
6852 }
6853 else if (op == 0xb2)
6854 {
b115cf96 6855 unsigned char buf[9];
0b6ae522
DJ		 6856 unsigned int i, len;
6857 unsigned long offset;
61865e30 6858
b115cf96 6859 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6860 {
6861 GET_OP (buf[i]);
6862 if ((buf[i] & 0x80) == 0)
6863 break;
6864 }
6865 assert (i < sizeof (buf));
f6f0e17b 6866 offset = read_uleb128 (buf, &len, buf + i + 1);
0b6ae522
DJ		 6867 assert (len == i + 1);
6868 offset = offset * 4 + 0x204;
cc5914eb 6869 printf ("vsp = vsp + %ld", offset);
0b6ae522 6870 }
61865e30 6871 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6872 {
61865e30
NC		 6873 unsigned int first, last;
6874
6875 GET_OP (op2);
6876 first = op2 >> 4;
6877 last = op2 & 0x0f;
6878 if (op == 0xc8)
6879 first = first + 16;
6880 printf ("pop {D%d", first);
6881 if (last)
6882 printf ("-D%d", first + last);
6883 printf ("}");
6884 }
6885 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6886 {
6887 unsigned int count = op & 0x07;
6888
6889 printf ("pop {D8");
6890 if (count)
6891 printf ("-D%d", 8 + count);
6892 printf ("}");
6893 }
6894 else if (op >= 0xc0 && op <= 0xc5)
6895 {
6896 unsigned int count = op & 0x07;
6897
6898 printf (" pop {wR10");
6899 if (count)
6900 printf ("-wR%d", 10 + count);
6901 printf ("}");
6902 }
6903 else if (op == 0xc6)
6904 {
6905 unsigned int first, last;
6906
6907 GET_OP (op2);
6908 first = op2 >> 4;
6909 last = op2 & 0x0f;
6910 printf ("pop {wR%d", first);
6911 if (last)
6912 printf ("-wR%d", first + last);
6913 printf ("}");
6914 }
6915 else if (op == 0xc7)
6916 {
6917 GET_OP (op2);
6918 if (op2 == 0 || (op2 & 0xf0) != 0)
6919 printf (_("[Spare]"));
0b6ae522
DJ		 6920 else
6921 {
61865e30
NC		 6922 unsigned int mask = op2 & 0x0f;
6923 int first = 1;
6924 int i;
6925
6926 printf ("pop {");
6927 for (i = 0; i < 4; i++)
6928 if (mask & (1 << i))
6929 {
6930 if (first)
6931 first = 0;
6932 else
6933 printf (", ");
6934 printf ("wCGR%d", i);
6935 }
6936 printf ("}");
0b6ae522
DJ		 6937 }
6938 }
61865e30
NC		 6939 else
6940 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6941 printf ("\n");
6942 }
fa197c1c
PB		 6943}
6944
6945static void
6946decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6947 unsigned int word, unsigned int remaining,
6948 unsigned int more_words,
6949 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6950 struct arm_section *data_arm_sec)
6951{
6952 struct absaddr addr;
6953
6954 /* Decode the unwinding instructions. */
6955 while (1)
6956 {
6957 unsigned int op, op2;
6958
6959 ADVANCE;
6960 if (remaining == 0)
6961 break;
6962 remaining--;
6963 op = word >> 24;
6964 word <<= 8;
6965
9cf03b7e 6966 printf (" 0x%02x ", op);
fa197c1c
PB		 6967
6968 if ((op & 0xc0) == 0x00)
6969 {
6970 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 6971 printf (" sp = sp + %d", offset);
fa197c1c
PB		 6972 }
6973 else if ((op & 0xc0) == 0x80)
6974 {
6975 GET_OP (op2);
6976 if (op == 0x80 && op2 == 0)
6977 printf (_("Refuse to unwind"));
6978 else
6979 {
6980 unsigned int mask = ((op & 0x1f) << 8) | op2;
6981 if (op & 0x20)
6982 printf ("pop compact {");
6983 else
6984 printf ("pop {");
6985
6986 decode_tic6x_unwind_regmask (mask);
6987 printf("}");
6988 }
6989 }
6990 else if ((op & 0xf0) == 0xc0)
6991 {
6992 unsigned int reg;
6993 unsigned int nregs;
6994 unsigned int i;
6995 const char *name;
a734115a
NC		 6996 struct
6997 {
fa197c1c
PB		 6998 unsigned int offset;
6999 unsigned int reg;
7000 } regpos[16];
7001
7002 /* Scan entire instruction first so that GET_OP output is not
7003 interleaved with disassembly. */
7004 nregs = 0;
7005 for (i = 0; nregs < (op & 0xf); i++)
7006 {
7007 GET_OP (op2);
7008 reg = op2 >> 4;
7009 if (reg != 0xf)
7010 {
7011 regpos[nregs].offset = i * 2;
7012 regpos[nregs].reg = reg;
7013 nregs++;
7014 }
7015
7016 reg = op2 & 0xf;
7017 if (reg != 0xf)
7018 {
7019 regpos[nregs].offset = i * 2 + 1;
7020 regpos[nregs].reg = reg;
7021 nregs++;
7022 }
7023 }
7024
7025 printf (_("pop frame {"));
7026 reg = nregs - 1;
7027 for (i = i * 2; i > 0; i--)
7028 {
7029 if (regpos[reg].offset == i - 1)
7030 {
7031 name = tic6x_unwind_regnames[regpos[reg].reg];
7032 if (reg > 0)
7033 reg--;
7034 }
7035 else
7036 name = _("[pad]");
7037
7038 fputs (name, stdout);
7039 if (i > 1)
7040 printf (", ");
7041 }
7042
7043 printf ("}");
7044 }
7045 else if (op == 0xd0)
7046 printf (" MOV FP, SP");
7047 else if (op == 0xd1)
7048 printf (" __c6xabi_pop_rts");
7049 else if (op == 0xd2)
7050 {
7051 unsigned char buf[9];
7052 unsigned int i, len;
7053 unsigned long offset;
a734115a 7054
fa197c1c
PB		 7055 for (i = 0; i < sizeof (buf); i++)
7056 {
7057 GET_OP (buf[i]);
7058 if ((buf[i] & 0x80) == 0)
7059 break;
7060 }
7061 assert (i < sizeof (buf));
f6f0e17b 7062 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7063 assert (len == i + 1);
7064 offset = offset * 8 + 0x408;
7065 printf (_("sp = sp + %ld"), offset);
7066 }
7067 else if ((op & 0xf0) == 0xe0)
7068 {
7069 if ((op & 0x0f) == 7)
7070 printf (" RETURN");
7071 else
7072 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7073 }
7074 else
7075 {
7076 printf (_(" [unsupported opcode]"));
7077 }
7078 putchar ('\n');
7079 }
7080}
7081
7082static bfd_vma
a734115a 7083arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7084{
7085 bfd_vma offset;
7086
7087 offset = word & 0x7fffffff;
7088 if (offset & 0x40000000)
7089 offset |= ~ (bfd_vma) 0x7fffffff;
7090
7091 if (elf_header.e_machine == EM_TI_C6000)
7092 offset <<= 1;
7093
7094 return offset + where;
7095}
7096
7097static void
1b31d05e
NC		 7098decode_arm_unwind (struct arm_unw_aux_info * aux,
7099 unsigned int word,
7100 unsigned int remaining,
7101 bfd_vma data_offset,
7102 Elf_Internal_Shdr * data_sec,
7103 struct arm_section * data_arm_sec)
fa197c1c
PB		 7104{
7105 int per_index;
7106 unsigned int more_words = 0;
7107 struct absaddr addr;
1b31d05e 7108 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7109
7110 if (remaining == 0)
7111 {
1b31d05e
NC		 7112 /* Fetch the first word.
7113 Note - when decoding an object file the address extracted
7114 here will always be 0. So we also pass in the sym_name
7115 parameter so that we can find the symbol associated with
7116 the personality routine. */
7117 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7118 & word, & addr, & sym_name))
fa197c1c 7119 return;
1b31d05e 7120
fa197c1c
PB		 7121 remaining = 4;
7122 }
7123
7124 if ((word & 0x80000000) == 0)
7125 {
7126 /* Expand prel31 for personality routine. */
7127 bfd_vma fn;
7128 const char *procname;
7129
a734115a 7130 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7131 printf (_(" Personality routine: "));
1b31d05e
NC		 7132 if (fn == 0
7133 && addr.section == SHN_UNDEF && addr.offset == 0
7134 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7135 {
7136 procname = aux->strtab + sym_name;
7137 print_vma (fn, PREFIX_HEX);
7138 if (procname)
7139 {
7140 fputs (" <", stdout);
7141 fputs (procname, stdout);
7142 fputc ('>', stdout);
7143 }
7144 }
7145 else
7146 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7147 fputc ('\n', stdout);
7148
7149 /* The GCC personality routines use the standard compact
7150 encoding, starting with one byte giving the number of
7151 words. */
7152 if (procname != NULL
7153 && (const_strneq (procname, "__gcc_personality_v0")
7154 || const_strneq (procname, "__gxx_personality_v0")
7155 || const_strneq (procname, "__gcj_personality_v0")
7156 || const_strneq (procname, "__gnu_objc_personality_v0")))
7157 {
7158 remaining = 0;
7159 more_words = 1;
7160 ADVANCE;
7161 if (!remaining)
7162 {
7163 printf (_(" [Truncated data]\n"));
7164 return;
7165 }
7166 more_words = word >> 24;
7167 word <<= 8;
7168 remaining--;
7169 per_index = -1;
7170 }
7171 else
7172 return;
7173 }
7174 else
7175 {
1b31d05e
NC		 7176 /* ARM EHABI Section 6.3:
7177
7178 An exception-handling table entry for the compact model looks like:
7179
7180 31 30-28 27-24 23-0
7181 -- ----- ----- ----
7182 1 0 index Data for personalityRoutine[index] */
7183
7184 if (elf_header.e_machine == EM_ARM
7185 && (word & 0x70000000))
83c257ca 7186 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7187
fa197c1c 7188 per_index = (word >> 24) & 0x7f;
1b31d05e 7189 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7190 if (per_index == 0)
7191 {
7192 more_words = 0;
7193 word <<= 8;
7194 remaining--;
7195 }
7196 else if (per_index < 3)
7197 {
7198 more_words = (word >> 16) & 0xff;
7199 word <<= 16;
7200 remaining -= 2;
7201 }
7202 }
7203
7204 switch (elf_header.e_machine)
7205 {
7206 case EM_ARM:
7207 if (per_index < 3)
7208 {
7209 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7210 data_offset, data_sec, data_arm_sec);
7211 }
7212 else
1b31d05e
NC		 7213 {
7214 warn (_("Unknown ARM compact model index encountered\n"));
7215 printf (_(" [reserved]\n"));
7216 }
fa197c1c
PB		 7217 break;
7218
7219 case EM_TI_C6000:
7220 if (per_index < 3)
7221 {
7222 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7223 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7224 }
7225 else if (per_index < 5)
7226 {
7227 if (((word >> 17) & 0x7f) == 0x7f)
7228 printf (_(" Restore stack from frame pointer\n"));
7229 else
7230 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7231 printf (_(" Registers restored: "));
7232 if (per_index == 4)
7233 printf (" (compact) ");
7234 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7235 putchar ('\n');
7236 printf (_(" Return register: %s\n"),
7237 tic6x_unwind_regnames[word & 0xf]);
7238 }
7239 else
1b31d05e 7240 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7241 break;
7242
7243 default:
1b31d05e
NC		 7244 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7245 elf_header.e_machine);
fa197c1c 7246 }
0b6ae522
DJ		 7247
7248 /* Decode the descriptors. Not implemented. */
7249}
7250
7251static void
7252dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7253{
7254 struct arm_section exidx_arm_sec, extab_arm_sec;
7255 unsigned int i, exidx_len;
7256
7257 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7258 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7259 exidx_len = exidx_sec->sh_size / 8;
7260
7261 for (i = 0; i < exidx_len; i++)
7262 {
7263 unsigned int exidx_fn, exidx_entry;
7264 struct absaddr fn_addr, entry_addr;
7265 bfd_vma fn;
7266
7267 fputc ('\n', stdout);
7268
1b31d05e
NC		 7269 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7270 8 * i, & exidx_fn, & fn_addr, NULL)
7271 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7272 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7273 {
1b31d05e
NC		 7274 arm_free_section (& exidx_arm_sec);
7275 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7276 return;
7277 }
7278
83c257ca
NC		 7279 /* ARM EHABI, Section 5:
7280 An index table entry consists of 2 words.
7281 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7282 if (exidx_fn & 0x80000000)
7283 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7284
a734115a 7285 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7286
a734115a 7287 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7288 fputs (": ", stdout);
7289
7290 if (exidx_entry == 1)
7291 {
7292 print_vma (exidx_entry, PREFIX_HEX);
7293 fputs (" [cantunwind]\n", stdout);
7294 }
7295 else if (exidx_entry & 0x80000000)
7296 {
7297 print_vma (exidx_entry, PREFIX_HEX);
7298 fputc ('\n', stdout);
7299 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7300 }
7301 else
7302 {
8f73510c 7303 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7304 Elf_Internal_Shdr *table_sec;
7305
7306 fputs ("@", stdout);
a734115a 7307 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7308 print_vma (table, PREFIX_HEX);
7309 printf ("\n");
7310
7311 /* Locate the matching .ARM.extab. */
7312 if (entry_addr.section != SHN_UNDEF
7313 && entry_addr.section < elf_header.e_shnum)
7314 {
7315 table_sec = section_headers + entry_addr.section;
7316 table_offset = entry_addr.offset;
7317 }
7318 else
7319 {
7320 table_sec = find_section_by_address (table);
7321 if (table_sec != NULL)
7322 table_offset = table - table_sec->sh_addr;
7323 }
7324 if (table_sec == NULL)
7325 {
7326 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7327 (unsigned long) table);
7328 continue;
7329 }
7330 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7331 &extab_arm_sec);
7332 }
7333 }
7334
7335 printf ("\n");
7336
7337 arm_free_section (&exidx_arm_sec);
7338 arm_free_section (&extab_arm_sec);
7339}
7340
fa197c1c 7341/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7342
7343static void
0b6ae522
DJ		 7344arm_process_unwind (FILE *file)
7345{
7346 struct arm_unw_aux_info aux;
7347 Elf_Internal_Shdr *unwsec = NULL;
7348 Elf_Internal_Shdr *strsec;
7349 Elf_Internal_Shdr *sec;
7350 unsigned long i;
fa197c1c 7351 unsigned int sec_type;
0b6ae522 7352
fa197c1c
PB		 7353 switch (elf_header.e_machine)
7354 {
7355 case EM_ARM:
7356 sec_type = SHT_ARM_EXIDX;
7357 break;
7358
7359 case EM_TI_C6000:
7360 sec_type = SHT_C6000_UNWIND;
7361 break;
7362
1b31d05e
NC		 7363 default:
7364 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7365 elf_header.e_machine);
7366 return;
fa197c1c
PB		 7367 }
7368
0b6ae522 7369 if (string_table == NULL)
1b31d05e
NC		 7370 return;
7371
7372 memset (& aux, 0, sizeof (aux));
7373 aux.file = file;
0b6ae522
DJ		 7374
7375 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7376 {
7377 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7378 {
ba5cdace 7379 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7380
7381 strsec = section_headers + sec->sh_link;
59245841 7382 assert (aux.strtab == NULL);
0b6ae522
DJ		 7383 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7384 1, strsec->sh_size, _("string table"));
7385 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7386 }
fa197c1c 7387 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7388 unwsec = sec;
7389 }
7390
1b31d05e 7391 if (unwsec == NULL)
0b6ae522 7392 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7393 else
7394 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7395 {
7396 if (sec->sh_type == sec_type)
7397 {
7398 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7399 SECTION_NAME (sec),
7400 (unsigned long) sec->sh_offset,
7401 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7402
1b31d05e
NC		 7403 dump_arm_unwind (&aux, sec);
7404 }
7405 }
0b6ae522
DJ		 7406
7407 if (aux.symtab)
7408 free (aux.symtab);
7409 if (aux.strtab)
7410 free ((char *) aux.strtab);
0b6ae522
DJ		 7411}
7412
1b31d05e 7413static void
2cf0635d 7414process_unwind (FILE * file)
57346661 7415{
2cf0635d
NC		 7416 struct unwind_handler
7417 {
57346661 7418 int machtype;
1b31d05e 7419 void (* handler)(FILE *);
2cf0635d
NC		 7420 } handlers[] =
7421 {
0b6ae522 7422 { EM_ARM, arm_process_unwind },
57346661
AM		 7423 { EM_IA_64, ia64_process_unwind },
7424 { EM_PARISC, hppa_process_unwind },
fa197c1c 7425 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7426 { 0, 0 }
7427 };
7428 int i;
7429
7430 if (!do_unwind)
1b31d05e 7431 return;
57346661
AM		 7432
7433 for (i = 0; handlers[i].handler != NULL; i++)
7434 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7435 return handlers[i].handler (file);
57346661 7436
1b31d05e
NC		 7437 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7438 get_machine_name (elf_header.e_machine));
57346661
AM		 7439}
7440
252b5132 7441static void
2cf0635d 7442dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7443{
7444 switch (entry->d_tag)
7445 {
7446 case DT_MIPS_FLAGS:
7447 if (entry->d_un.d_val == 0)
4b68bca3 7448 printf (_("NONE"));
252b5132
RH		 7449 else
7450 {
7451 static const char * opts[] =
7452 {
7453 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7454 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7455 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7456 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7457 "RLD_ORDER_SAFE"
7458 };
7459 unsigned int cnt;
7460 int first = 1;
2b692964 7461
60bca95a 7462 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7463 if (entry->d_un.d_val & (1 << cnt))
7464 {
7465 printf ("%s%s", first ? "" : " ", opts[cnt]);
7466 first = 0;
7467 }
252b5132
RH		 7468 }
7469 break;
103f02d3 7470
252b5132 7471 case DT_MIPS_IVERSION:
d79b3d50 7472 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7473 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7474 else
4b68bca3 7475 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7476 break;
103f02d3 7477
252b5132
RH		 7478 case DT_MIPS_TIME_STAMP:
7479 {
7480 char timebuf[20];
2cf0635d 7481 struct tm * tmp;
50da7a9c 7482
91d6fa6a
NC		 7483 time_t atime = entry->d_un.d_val;
7484 tmp = gmtime (&atime);
e9e44622
JJ		 7485 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7486 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7487 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7488 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7489 }
7490 break;
103f02d3 7491
252b5132
RH		 7492 case DT_MIPS_RLD_VERSION:
7493 case DT_MIPS_LOCAL_GOTNO:
7494 case DT_MIPS_CONFLICTNO:
7495 case DT_MIPS_LIBLISTNO:
7496 case DT_MIPS_SYMTABNO:
7497 case DT_MIPS_UNREFEXTNO:
7498 case DT_MIPS_HIPAGENO:
7499 case DT_MIPS_DELTA_CLASS_NO:
7500 case DT_MIPS_DELTA_INSTANCE_NO:
7501 case DT_MIPS_DELTA_RELOC_NO:
7502 case DT_MIPS_DELTA_SYM_NO:
7503 case DT_MIPS_DELTA_CLASSSYM_NO:
7504 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7505 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7506 break;
103f02d3
UD		 7507
7508 default:
4b68bca3 7509 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7510 }
4b68bca3 7511 putchar ('\n');
103f02d3
UD		 7512}
7513
103f02d3 7514static void
2cf0635d 7515dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7516{
7517 switch (entry->d_tag)
7518 {
7519 case DT_HP_DLD_FLAGS:
7520 {
7521 static struct
7522 {
7523 long int bit;
2cf0635d 7524 const char * str;
5e220199
NC		 7525 }
7526 flags[] =
7527 {
7528 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7529 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7530 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7531 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7532 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7533 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7534 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7535 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7536 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7537 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7538 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7539 { DT_HP_GST, "HP_GST" },
7540 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7541 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7542 { DT_HP_NODELETE, "HP_NODELETE" },
7543 { DT_HP_GROUP, "HP_GROUP" },
7544 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7545 };
103f02d3 7546 int first = 1;
5e220199 7547 size_t cnt;
f7a99963 7548 bfd_vma val = entry->d_un.d_val;
103f02d3 7549
60bca95a 7550 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7551 if (val & flags[cnt].bit)
30800947
NC		 7552 {
7553 if (! first)
7554 putchar (' ');
7555 fputs (flags[cnt].str, stdout);
7556 first = 0;
7557 val ^= flags[cnt].bit;
7558 }
76da6bbe 7559
103f02d3 7560 if (val != 0 || first)
f7a99963
NC		 7561 {
7562 if (! first)
7563 putchar (' ');
7564 print_vma (val, HEX);
7565 }
103f02d3
UD		 7566 }
7567 break;
76da6bbe 7568
252b5132 7569 default:
f7a99963
NC		 7570 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7571 break;
252b5132 7572 }
35b1837e 7573 putchar ('\n');
252b5132
RH		 7574}
7575
28f997cf
TG		 7576#ifdef BFD64
7577
7578/* VMS vs Unix time offset and factor. */
7579
7580#define VMS_EPOCH_OFFSET 35067168000000000LL
7581#define VMS_GRANULARITY_FACTOR 10000000
7582
7583/* Display a VMS time in a human readable format. */
7584
7585static void
7586print_vms_time (bfd_int64_t vmstime)
7587{
7588 struct tm *tm;
7589 time_t unxtime;
7590
7591 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7592 tm = gmtime (&unxtime);
7593 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7594 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7595 tm->tm_hour, tm->tm_min, tm->tm_sec);
7596}
7597#endif /* BFD64 */
7598
ecc51f48 7599static void
2cf0635d 7600dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7601{
7602 switch (entry->d_tag)
7603 {
0de14b54 7604 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7605 /* First 3 slots reserved. */
ecc51f48
NC		 7606 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7607 printf (" -- ");
7608 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7609 break;
7610
28f997cf
TG		 7611 case DT_IA_64_VMS_LINKTIME:
7612#ifdef BFD64
7613 print_vms_time (entry->d_un.d_val);
7614#endif
7615 break;
7616
7617 case DT_IA_64_VMS_LNKFLAGS:
7618 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7619 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7620 printf (" CALL_DEBUG");
7621 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7622 printf (" NOP0BUFS");
7623 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7624 printf (" P0IMAGE");
7625 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7626 printf (" MKTHREADS");
7627 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7628 printf (" UPCALLS");
7629 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7630 printf (" IMGSTA");
7631 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7632 printf (" INITIALIZE");
7633 if (entry->d_un.d_val & VMS_LF_MAIN)
7634 printf (" MAIN");
7635 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7636 printf (" EXE_INIT");
7637 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7638 printf (" TBK_IN_IMG");
7639 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7640 printf (" DBG_IN_IMG");
7641 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7642 printf (" TBK_IN_DSF");
7643 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7644 printf (" DBG_IN_DSF");
7645 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7646 printf (" SIGNATURES");
7647 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7648 printf (" REL_SEG_OFF");
7649 break;
7650
bdf4d63a
JJ		 7651 default:
7652 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7653 break;
ecc51f48 7654 }
bdf4d63a 7655 putchar ('\n');
ecc51f48
NC		 7656}
7657
252b5132 7658static int
2cf0635d 7659get_32bit_dynamic_section (FILE * file)
252b5132 7660{
2cf0635d
NC		 7661 Elf32_External_Dyn * edyn;
7662 Elf32_External_Dyn * ext;
7663 Elf_Internal_Dyn * entry;
103f02d3 7664
3f5e193b
NC		 7665 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7666 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7667 if (!edyn)
7668 return 0;
103f02d3 7669
ba2685cc
AM		 7670/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7671 might not have the luxury of section headers. Look for the DT_NULL
7672 terminator to determine the number of entries. */
7673 for (ext = edyn, dynamic_nent = 0;
7674 (char *) ext < (char *) edyn + dynamic_size;
7675 ext++)
7676 {
7677 dynamic_nent++;
7678 if (BYTE_GET (ext->d_tag) == DT_NULL)
7679 break;
7680 }
252b5132 7681
3f5e193b
NC		 7682 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7683 sizeof (* entry));
b2d38a17 7684 if (dynamic_section == NULL)
252b5132 7685 {
9ea033b2
NC		 7686 error (_("Out of memory\n"));
7687 free (edyn);
7688 return 0;
7689 }
252b5132 7690
fb514b26 7691 for (ext = edyn, entry = dynamic_section;
ba2685cc 7692 entry < dynamic_section + dynamic_nent;
fb514b26 7693 ext++, entry++)
9ea033b2 7694 {
fb514b26
AM		 7695 entry->d_tag = BYTE_GET (ext->d_tag);
7696 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7697 }
7698
9ea033b2
NC		 7699 free (edyn);
7700
7701 return 1;
7702}
7703
7704static int
2cf0635d 7705get_64bit_dynamic_section (FILE * file)
9ea033b2 7706{
2cf0635d
NC		 7707 Elf64_External_Dyn * edyn;
7708 Elf64_External_Dyn * ext;
7709 Elf_Internal_Dyn * entry;
103f02d3 7710
3f5e193b
NC		 7711 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7712 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7713 if (!edyn)
7714 return 0;
103f02d3 7715
ba2685cc
AM		 7716/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7717 might not have the luxury of section headers. Look for the DT_NULL
7718 terminator to determine the number of entries. */
7719 for (ext = edyn, dynamic_nent = 0;
7720 (char *) ext < (char *) edyn + dynamic_size;
7721 ext++)
7722 {
7723 dynamic_nent++;
66543521 7724 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7725 break;
7726 }
252b5132 7727
3f5e193b
NC		 7728 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7729 sizeof (* entry));
b2d38a17 7730 if (dynamic_section == NULL)
252b5132
RH		 7731 {
7732 error (_("Out of memory\n"));
7733 free (edyn);
7734 return 0;
7735 }
7736
fb514b26 7737 for (ext = edyn, entry = dynamic_section;
ba2685cc 7738 entry < dynamic_section + dynamic_nent;
fb514b26 7739 ext++, entry++)
252b5132 7740 {
66543521
AM		 7741 entry->d_tag = BYTE_GET (ext->d_tag);
7742 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7743 }
7744
7745 free (edyn);
7746
9ea033b2
NC		 7747 return 1;
7748}
7749
e9e44622
JJ		 7750static void
7751print_dynamic_flags (bfd_vma flags)
d1133906 7752{
e9e44622 7753 int first = 1;
13ae64f3 7754
d1133906
NC		 7755 while (flags)
7756 {
7757 bfd_vma flag;
7758
7759 flag = flags & - flags;
7760 flags &= ~ flag;
7761
e9e44622
JJ		 7762 if (first)
7763 first = 0;
7764 else
7765 putc (' ', stdout);
13ae64f3 7766
d1133906
NC		 7767 switch (flag)
7768 {
e9e44622
JJ		 7769 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7770 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7771 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7772 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7773 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7774 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7775 }
7776 }
e9e44622 7777 puts ("");
d1133906
NC		 7778}
7779
b2d38a17
NC		 7780/* Parse and display the contents of the dynamic section. */
7781
9ea033b2 7782static int
2cf0635d 7783process_dynamic_section (FILE * file)
9ea033b2 7784{
2cf0635d 7785 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7786
7787 if (dynamic_size == 0)
7788 {
7789 if (do_dynamic)
b2d38a17 7790 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7791
7792 return 1;
7793 }
7794
7795 if (is_32bit_elf)
7796 {
b2d38a17 7797 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7798 return 0;
7799 }
b2d38a17 7800 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7801 return 0;
7802
252b5132
RH		 7803 /* Find the appropriate symbol table. */
7804 if (dynamic_symbols == NULL)
7805 {
86dba8ee
AM		 7806 for (entry = dynamic_section;
7807 entry < dynamic_section + dynamic_nent;
7808 ++entry)
252b5132 7809 {
c8286bd1 7810 Elf_Internal_Shdr section;
252b5132
RH		 7811
7812 if (entry->d_tag != DT_SYMTAB)
7813 continue;
7814
7815 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7816
7817 /* Since we do not know how big the symbol table is,
7818 we default to reading in the entire file (!) and
7819 processing that. This is overkill, I know, but it
e3c8793a 7820 should work. */
d93f0186 7821 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7822
fb52b2f4
NC		 7823 if (archive_file_offset != 0)
7824 section.sh_size = archive_file_size - section.sh_offset;
7825 else
7826 {
7827 if (fseek (file, 0, SEEK_END))
591a748a 7828 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7829
7830 section.sh_size = ftell (file) - section.sh_offset;
7831 }
252b5132 7832
9ea033b2 7833 if (is_32bit_elf)
9ad5cbcf 7834 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7835 else
9ad5cbcf 7836 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7837
ba5cdace 7838 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7839 if (num_dynamic_syms < 1)
252b5132
RH		 7840 {
7841 error (_("Unable to determine the number of symbols to load\n"));
7842 continue;
7843 }
252b5132
RH		 7844 }
7845 }
7846
7847 /* Similarly find a string table. */
7848 if (dynamic_strings == NULL)
7849 {
86dba8ee
AM		 7850 for (entry = dynamic_section;
7851 entry < dynamic_section + dynamic_nent;
7852 ++entry)
252b5132
RH		 7853 {
7854 unsigned long offset;
b34976b6 7855 long str_tab_len;
252b5132
RH		 7856
7857 if (entry->d_tag != DT_STRTAB)
7858 continue;
7859
7860 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7861
7862 /* Since we do not know how big the string table is,
7863 we default to reading in the entire file (!) and
7864 processing that. This is overkill, I know, but it
e3c8793a 7865 should work. */
252b5132 7866
d93f0186 7867 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7868
7869 if (archive_file_offset != 0)
7870 str_tab_len = archive_file_size - offset;
7871 else
7872 {
7873 if (fseek (file, 0, SEEK_END))
7874 error (_("Unable to seek to end of file\n"));
7875 str_tab_len = ftell (file) - offset;
7876 }
252b5132
RH		 7877
7878 if (str_tab_len < 1)
7879 {
7880 error
7881 (_("Unable to determine the length of the dynamic string table\n"));
7882 continue;
7883 }
7884
3f5e193b
NC		 7885 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7886 str_tab_len,
7887 _("dynamic string table"));
59245841 7888 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7889 break;
7890 }
7891 }
7892
7893 /* And find the syminfo section if available. */
7894 if (dynamic_syminfo == NULL)
7895 {
3e8bba36 7896 unsigned long syminsz = 0;
252b5132 7897
86dba8ee
AM		 7898 for (entry = dynamic_section;
7899 entry < dynamic_section + dynamic_nent;
7900 ++entry)
252b5132
RH		 7901 {
7902 if (entry->d_tag == DT_SYMINENT)
7903 {
7904 /* Note: these braces are necessary to avoid a syntax
7905 error from the SunOS4 C compiler. */
7906 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7907 }
7908 else if (entry->d_tag == DT_SYMINSZ)
7909 syminsz = entry->d_un.d_val;
7910 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7911 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7912 syminsz);
252b5132
RH		 7913 }
7914
7915 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7916 {
2cf0635d
NC		 7917 Elf_External_Syminfo * extsyminfo;
7918 Elf_External_Syminfo * extsym;
7919 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7920
7921 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7922 extsyminfo = (Elf_External_Syminfo *)
7923 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7924 _("symbol information"));
a6e9f9df
AM		 7925 if (!extsyminfo)
7926 return 0;
252b5132 7927
3f5e193b 7928 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7929 if (dynamic_syminfo == NULL)
7930 {
7931 error (_("Out of memory\n"));
7932 return 0;
7933 }
7934
7935 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7936 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7937 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7938 ++syminfo, ++extsym)
252b5132 7939 {
86dba8ee
AM		 7940 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7941 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7942 }
7943
7944 free (extsyminfo);
7945 }
7946 }
7947
7948 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7949 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7950 dynamic_addr, dynamic_nent);
252b5132
RH		 7951 if (do_dynamic)
7952 printf (_(" Tag Type Name/Value\n"));
7953
86dba8ee
AM		 7954 for (entry = dynamic_section;
7955 entry < dynamic_section + dynamic_nent;
7956 entry++)
252b5132
RH		 7957 {
7958 if (do_dynamic)
f7a99963 7959 {
2cf0635d 7960 const char * dtype;
e699b9ff 7961
f7a99963
NC		 7962 putchar (' ');
7963 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7964 dtype = get_dynamic_type (entry->d_tag);
7965 printf (" (%s)%*s", dtype,
7966 ((is_32bit_elf ? 27 : 19)
7967 - (int) strlen (dtype)),
f7a99963
NC		 7968 " ");
7969 }
252b5132
RH		 7970
7971 switch (entry->d_tag)
7972 {
d1133906
NC		 7973 case DT_FLAGS:
7974 if (do_dynamic)
e9e44622 7975 print_dynamic_flags (entry->d_un.d_val);
d1133906 7976 break;
76da6bbe 7977
252b5132
RH		 7978 case DT_AUXILIARY:
7979 case DT_FILTER:
019148e4
L		 7980 case DT_CONFIG:
7981 case DT_DEPAUDIT:
7982 case DT_AUDIT:
252b5132
RH		 7983 if (do_dynamic)
7984 {
019148e4 7985 switch (entry->d_tag)
b34976b6 7986 {
019148e4
L		 7987 case DT_AUXILIARY:
7988 printf (_("Auxiliary library"));
7989 break;
7990
7991 case DT_FILTER:
7992 printf (_("Filter library"));
7993 break;
7994
b34976b6 7995 case DT_CONFIG:
019148e4
L		 7996 printf (_("Configuration file"));
7997 break;
7998
7999 case DT_DEPAUDIT:
8000 printf (_("Dependency audit library"));
8001 break;
8002
8003 case DT_AUDIT:
8004 printf (_("Audit library"));
8005 break;
8006 }
252b5132 8007
d79b3d50
NC		 8008 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8009 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8010 else
f7a99963
NC		 8011 {
8012 printf (": ");
8013 print_vma (entry->d_un.d_val, PREFIX_HEX);
8014 putchar ('\n');
8015 }
252b5132
RH		 8016 }
8017 break;
8018
dcefbbbd 8019 case DT_FEATURE:
252b5132
RH		 8020 if (do_dynamic)
8021 {
8022 printf (_("Flags:"));
86f55779 8023
252b5132
RH		 8024 if (entry->d_un.d_val == 0)
8025 printf (_(" None\n"));
8026 else
8027 {
8028 unsigned long int val = entry->d_un.d_val;
86f55779 8029
252b5132
RH		 8030 if (val & DTF_1_PARINIT)
8031 {
8032 printf (" PARINIT");
8033 val ^= DTF_1_PARINIT;
8034 }
dcefbbbd
L		 8035 if (val & DTF_1_CONFEXP)
8036 {
8037 printf (" CONFEXP");
8038 val ^= DTF_1_CONFEXP;
8039 }
252b5132
RH		 8040 if (val != 0)
8041 printf (" %lx", val);
8042 puts ("");
8043 }
8044 }
8045 break;
8046
8047 case DT_POSFLAG_1:
8048 if (do_dynamic)
8049 {
8050 printf (_("Flags:"));
86f55779 8051
252b5132
RH		 8052 if (entry->d_un.d_val == 0)
8053 printf (_(" None\n"));
8054 else
8055 {
8056 unsigned long int val = entry->d_un.d_val;
86f55779 8057
252b5132
RH		 8058 if (val & DF_P1_LAZYLOAD)
8059 {
8060 printf (" LAZYLOAD");
8061 val ^= DF_P1_LAZYLOAD;
8062 }
8063 if (val & DF_P1_GROUPPERM)
8064 {
8065 printf (" GROUPPERM");
8066 val ^= DF_P1_GROUPPERM;
8067 }
8068 if (val != 0)
8069 printf (" %lx", val);
8070 puts ("");
8071 }
8072 }
8073 break;
8074
8075 case DT_FLAGS_1:
8076 if (do_dynamic)
8077 {
8078 printf (_("Flags:"));
8079 if (entry->d_un.d_val == 0)
8080 printf (_(" None\n"));
8081 else
8082 {
8083 unsigned long int val = entry->d_un.d_val;
86f55779 8084
252b5132
RH		 8085 if (val & DF_1_NOW)
8086 {
8087 printf (" NOW");
8088 val ^= DF_1_NOW;
8089 }
8090 if (val & DF_1_GLOBAL)
8091 {
8092 printf (" GLOBAL");
8093 val ^= DF_1_GLOBAL;
8094 }
8095 if (val & DF_1_GROUP)
8096 {
8097 printf (" GROUP");
8098 val ^= DF_1_GROUP;
8099 }
8100 if (val & DF_1_NODELETE)
8101 {
8102 printf (" NODELETE");
8103 val ^= DF_1_NODELETE;
8104 }
8105 if (val & DF_1_LOADFLTR)
8106 {
8107 printf (" LOADFLTR");
8108 val ^= DF_1_LOADFLTR;
8109 }
8110 if (val & DF_1_INITFIRST)
8111 {
8112 printf (" INITFIRST");
8113 val ^= DF_1_INITFIRST;
8114 }
8115 if (val & DF_1_NOOPEN)
8116 {
8117 printf (" NOOPEN");
8118 val ^= DF_1_NOOPEN;
8119 }
8120 if (val & DF_1_ORIGIN)
8121 {
8122 printf (" ORIGIN");
8123 val ^= DF_1_ORIGIN;
8124 }
8125 if (val & DF_1_DIRECT)
8126 {
8127 printf (" DIRECT");
8128 val ^= DF_1_DIRECT;
8129 }
8130 if (val & DF_1_TRANS)
8131 {
8132 printf (" TRANS");
8133 val ^= DF_1_TRANS;
8134 }
8135 if (val & DF_1_INTERPOSE)
8136 {
8137 printf (" INTERPOSE");
8138 val ^= DF_1_INTERPOSE;
8139 }
f7db6139 8140 if (val & DF_1_NODEFLIB)
dcefbbbd 8141 {
f7db6139
L		 8142 printf (" NODEFLIB");
8143 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8144 }
8145 if (val & DF_1_NODUMP)
8146 {
8147 printf (" NODUMP");
8148 val ^= DF_1_NODUMP;
8149 }
34b60028 8150 if (val & DF_1_CONFALT)
dcefbbbd 8151 {
34b60028
L		 8152 printf (" CONFALT");
8153 val ^= DF_1_CONFALT;
8154 }
8155 if (val & DF_1_ENDFILTEE)
8156 {
8157 printf (" ENDFILTEE");
8158 val ^= DF_1_ENDFILTEE;
8159 }
8160 if (val & DF_1_DISPRELDNE)
8161 {
8162 printf (" DISPRELDNE");
8163 val ^= DF_1_DISPRELDNE;
8164 }
8165 if (val & DF_1_DISPRELPND)
8166 {
8167 printf (" DISPRELPND");
8168 val ^= DF_1_DISPRELPND;
8169 }
8170 if (val & DF_1_NODIRECT)
8171 {
8172 printf (" NODIRECT");
8173 val ^= DF_1_NODIRECT;
8174 }
8175 if (val & DF_1_IGNMULDEF)
8176 {
8177 printf (" IGNMULDEF");
8178 val ^= DF_1_IGNMULDEF;
8179 }
8180 if (val & DF_1_NOKSYMS)
8181 {
8182 printf (" NOKSYMS");
8183 val ^= DF_1_NOKSYMS;
8184 }
8185 if (val & DF_1_NOHDR)
8186 {
8187 printf (" NOHDR");
8188 val ^= DF_1_NOHDR;
8189 }
8190 if (val & DF_1_EDITED)
8191 {
8192 printf (" EDITED");
8193 val ^= DF_1_EDITED;
8194 }
8195 if (val & DF_1_NORELOC)
8196 {
8197 printf (" NORELOC");
8198 val ^= DF_1_NORELOC;
8199 }
8200 if (val & DF_1_SYMINTPOSE)
8201 {
8202 printf (" SYMINTPOSE");
8203 val ^= DF_1_SYMINTPOSE;
8204 }
8205 if (val & DF_1_GLOBAUDIT)
8206 {
8207 printf (" GLOBAUDIT");
8208 val ^= DF_1_GLOBAUDIT;
8209 }
8210 if (val & DF_1_SINGLETON)
8211 {
8212 printf (" SINGLETON");
8213 val ^= DF_1_SINGLETON;
dcefbbbd 8214 }
252b5132
RH		 8215 if (val != 0)
8216 printf (" %lx", val);
8217 puts ("");
8218 }
8219 }
8220 break;
8221
8222 case DT_PLTREL:
566b0d53 8223 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8224 if (do_dynamic)
8225 puts (get_dynamic_type (entry->d_un.d_val));
8226 break;
8227
8228 case DT_NULL :
8229 case DT_NEEDED :
8230 case DT_PLTGOT :
8231 case DT_HASH :
8232 case DT_STRTAB :
8233 case DT_SYMTAB :
8234 case DT_RELA :
8235 case DT_INIT :
8236 case DT_FINI :
8237 case DT_SONAME :
8238 case DT_RPATH :
8239 case DT_SYMBOLIC:
8240 case DT_REL :
8241 case DT_DEBUG :
8242 case DT_TEXTREL :
8243 case DT_JMPREL :
019148e4 8244 case DT_RUNPATH :
252b5132
RH		 8245 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8246
8247 if (do_dynamic)
8248 {
2cf0635d 8249 char * name;
252b5132 8250
d79b3d50
NC		 8251 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8252 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8253 else
d79b3d50 8254 name = NULL;
252b5132
RH		 8255
8256 if (name)
8257 {
8258 switch (entry->d_tag)
8259 {
8260 case DT_NEEDED:
8261 printf (_("Shared library: [%s]"), name);
8262
18bd398b 8263 if (streq (name, program_interpreter))
f7a99963 8264 printf (_(" program interpreter"));
252b5132
RH		 8265 break;
8266
8267 case DT_SONAME:
f7a99963 8268 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8269 break;
8270
8271 case DT_RPATH:
f7a99963 8272 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8273 break;
8274
019148e4
L		 8275 case DT_RUNPATH:
8276 printf (_("Library runpath: [%s]"), name);
8277 break;
8278
252b5132 8279 default:
f7a99963
NC		 8280 print_vma (entry->d_un.d_val, PREFIX_HEX);
8281 break;
252b5132
RH		 8282 }
8283 }
8284 else
f7a99963
NC		 8285 print_vma (entry->d_un.d_val, PREFIX_HEX);
8286
8287 putchar ('\n');
252b5132
RH		 8288 }
8289 break;
8290
8291 case DT_PLTRELSZ:
8292 case DT_RELASZ :
8293 case DT_STRSZ :
8294 case DT_RELSZ :
8295 case DT_RELAENT :
8296 case DT_SYMENT :
8297 case DT_RELENT :
566b0d53 8298 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8299 case DT_PLTPADSZ:
8300 case DT_MOVEENT :
8301 case DT_MOVESZ :
8302 case DT_INIT_ARRAYSZ:
8303 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8304 case DT_GNU_CONFLICTSZ:
8305 case DT_GNU_LIBLISTSZ:
252b5132 8306 if (do_dynamic)
f7a99963
NC		 8307 {
8308 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8309 printf (_(" (bytes)\n"));
f7a99963 8310 }
252b5132
RH		 8311 break;
8312
8313 case DT_VERDEFNUM:
8314 case DT_VERNEEDNUM:
8315 case DT_RELACOUNT:
8316 case DT_RELCOUNT:
8317 if (do_dynamic)
f7a99963
NC		 8318 {
8319 print_vma (entry->d_un.d_val, UNSIGNED);
8320 putchar ('\n');
8321 }
252b5132
RH		 8322 break;
8323
8324 case DT_SYMINSZ:
8325 case DT_SYMINENT:
8326 case DT_SYMINFO:
8327 case DT_USED:
8328 case DT_INIT_ARRAY:
8329 case DT_FINI_ARRAY:
8330 if (do_dynamic)
8331 {
d79b3d50
NC		 8332 if (entry->d_tag == DT_USED
8333 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8334 {
2cf0635d 8335 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8336
b34976b6 8337 if (*name)
252b5132
RH		 8338 {
8339 printf (_("Not needed object: [%s]\n"), name);
8340 break;
8341 }
8342 }
103f02d3 8343
f7a99963
NC		 8344 print_vma (entry->d_un.d_val, PREFIX_HEX);
8345 putchar ('\n');
252b5132
RH		 8346 }
8347 break;
8348
8349 case DT_BIND_NOW:
8350 /* The value of this entry is ignored. */
35b1837e
AM		 8351 if (do_dynamic)
8352 putchar ('\n');
252b5132 8353 break;
103f02d3 8354
047b2264
JJ		 8355 case DT_GNU_PRELINKED:
8356 if (do_dynamic)
8357 {
2cf0635d 8358 struct tm * tmp;
91d6fa6a 8359 time_t atime = entry->d_un.d_val;
047b2264 8360
91d6fa6a 8361 tmp = gmtime (&atime);
047b2264
JJ		 8362 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8363 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8364 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8365
8366 }
8367 break;
8368
fdc90cb4
JJ		 8369 case DT_GNU_HASH:
8370 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8371 if (do_dynamic)
8372 {
8373 print_vma (entry->d_un.d_val, PREFIX_HEX);
8374 putchar ('\n');
8375 }
8376 break;
8377
252b5132
RH		 8378 default:
8379 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8380 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8381 entry->d_un.d_val;
8382
8383 if (do_dynamic)
8384 {
8385 switch (elf_header.e_machine)
8386 {
8387 case EM_MIPS:
4fe85591 8388 case EM_MIPS_RS3_LE:
b2d38a17 8389 dynamic_section_mips_val (entry);
252b5132 8390 break;
103f02d3 8391 case EM_PARISC:
b2d38a17 8392 dynamic_section_parisc_val (entry);
103f02d3 8393 break;
ecc51f48 8394 case EM_IA_64:
b2d38a17 8395 dynamic_section_ia64_val (entry);
ecc51f48 8396 break;
252b5132 8397 default:
f7a99963
NC		 8398 print_vma (entry->d_un.d_val, PREFIX_HEX);
8399 putchar ('\n');
252b5132
RH		 8400 }
8401 }
8402 break;
8403 }
8404 }
8405
8406 return 1;
8407}
8408
8409static char *
d3ba0551 8410get_ver_flags (unsigned int flags)
252b5132 8411{
b34976b6 8412 static char buff[32];
252b5132
RH		 8413
8414 buff[0] = 0;
8415
8416 if (flags == 0)
8417 return _("none");
8418
8419 if (flags & VER_FLG_BASE)
8420 strcat (buff, "BASE ");
8421
8422 if (flags & VER_FLG_WEAK)
8423 {
8424 if (flags & VER_FLG_BASE)
8425 strcat (buff, "| ");
8426
8427 strcat (buff, "WEAK ");
8428 }
8429
44ec90b9
RO		 8430 if (flags & VER_FLG_INFO)
8431 {
8432 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8433 strcat (buff, "| ");
8434
8435 strcat (buff, "INFO ");
8436 }
8437
8438 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8439 strcat (buff, _("| <unknown>"));
252b5132
RH		 8440
8441 return buff;
8442}
8443
8444/* Display the contents of the version sections. */
98fb390a 8445
252b5132 8446static int
2cf0635d 8447process_version_sections (FILE * file)
252b5132 8448{
2cf0635d 8449 Elf_Internal_Shdr * section;
b34976b6
AM		 8450 unsigned i;
8451 int found = 0;
252b5132
RH		 8452
8453 if (! do_version)
8454 return 1;
8455
8456 for (i = 0, section = section_headers;
8457 i < elf_header.e_shnum;
b34976b6 8458 i++, section++)
252b5132
RH		 8459 {
8460 switch (section->sh_type)
8461 {
8462 case SHT_GNU_verdef:
8463 {
2cf0635d 8464 Elf_External_Verdef * edefs;
b34976b6
AM		 8465 unsigned int idx;
8466 unsigned int cnt;
2cf0635d 8467 char * endbuf;
252b5132
RH		 8468
8469 found = 1;
8470
8471 printf
72de5009 8472 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8473 SECTION_NAME (section), section->sh_info);
8474
8475 printf (_(" Addr: 0x"));
8476 printf_vma (section->sh_addr);
72de5009 8477 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8478 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8479 section->sh_link < elf_header.e_shnum
8480 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8481 : _("<corrupt>"));
252b5132 8482
3f5e193b
NC		 8483 edefs = (Elf_External_Verdef *)
8484 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8485 _("version definition section"));
a6e9f9df
AM		 8486 if (!edefs)
8487 break;
59245841 8488 endbuf = (char *) edefs + section->sh_size;
252b5132 8489
b34976b6 8490 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8491 {
2cf0635d
NC		 8492 char * vstart;
8493 Elf_External_Verdef * edef;
b34976b6 8494 Elf_Internal_Verdef ent;
2cf0635d 8495 Elf_External_Verdaux * eaux;
b34976b6
AM		 8496 Elf_Internal_Verdaux aux;
8497 int j;
8498 int isum;
103f02d3 8499
7e26601c
NC		 8500 /* Check for very large indicies. */
8501 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 8502 break;
8503
252b5132 8504 vstart = ((char *) edefs) + idx;
54806181
AM		 8505 if (vstart + sizeof (*edef) > endbuf)
8506 break;
252b5132
RH		 8507
8508 edef = (Elf_External_Verdef *) vstart;
8509
8510 ent.vd_version = BYTE_GET (edef->vd_version);
8511 ent.vd_flags = BYTE_GET (edef->vd_flags);
8512 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8513 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8514 ent.vd_hash = BYTE_GET (edef->vd_hash);
8515 ent.vd_aux = BYTE_GET (edef->vd_aux);
8516 ent.vd_next = BYTE_GET (edef->vd_next);
8517
8518 printf (_(" %#06x: Rev: %d Flags: %s"),
8519 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8520
8521 printf (_(" Index: %d Cnt: %d "),
8522 ent.vd_ndx, ent.vd_cnt);
8523
dd24e3da 8524 /* Check for overflow. */
7e26601c 8525 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8526 break;
8527
252b5132
RH		 8528 vstart += ent.vd_aux;
8529
8530 eaux = (Elf_External_Verdaux *) vstart;
8531
8532 aux.vda_name = BYTE_GET (eaux->vda_name);
8533 aux.vda_next = BYTE_GET (eaux->vda_next);
8534
d79b3d50
NC		 8535 if (VALID_DYNAMIC_NAME (aux.vda_name))
8536 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8537 else
8538 printf (_("Name index: %ld\n"), aux.vda_name);
8539
8540 isum = idx + ent.vd_aux;
8541
b34976b6 8542 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8543 {
dd24e3da 8544 /* Check for overflow. */
7e26601c 8545 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8546 break;
8547
252b5132
RH		 8548 isum += aux.vda_next;
8549 vstart += aux.vda_next;
8550
8551 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8552 if (vstart + sizeof (*eaux) > endbuf)
8553 break;
252b5132
RH		 8554
8555 aux.vda_name = BYTE_GET (eaux->vda_name);
8556 aux.vda_next = BYTE_GET (eaux->vda_next);
8557
d79b3d50 8558 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8559 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8560 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8561 else
8562 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8563 isum, j, aux.vda_name);
8564 }
dd24e3da 8565
54806181
AM		 8566 if (j < ent.vd_cnt)
8567 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8568
8569 idx += ent.vd_next;
8570 }
dd24e3da 8571
54806181
AM		 8572 if (cnt < section->sh_info)
8573 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8574
8575 free (edefs);
8576 }
8577 break;
103f02d3 8578
252b5132
RH		 8579 case SHT_GNU_verneed:
8580 {
2cf0635d 8581 Elf_External_Verneed * eneed;
b34976b6
AM		 8582 unsigned int idx;
8583 unsigned int cnt;
2cf0635d 8584 char * endbuf;
252b5132
RH		 8585
8586 found = 1;
8587
72de5009 8588 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8589 SECTION_NAME (section), section->sh_info);
8590
8591 printf (_(" Addr: 0x"));
8592 printf_vma (section->sh_addr);
72de5009 8593 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8594 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8595 section->sh_link < elf_header.e_shnum
8596 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8597 : _("<corrupt>"));
252b5132 8598
3f5e193b
NC		 8599 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8600 section->sh_offset, 1,
8601 section->sh_size,
9cf03b7e 8602 _("Version Needs section"));
a6e9f9df
AM		 8603 if (!eneed)
8604 break;
59245841 8605 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8606
8607 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8608 {
2cf0635d 8609 Elf_External_Verneed * entry;
b34976b6
AM		 8610 Elf_Internal_Verneed ent;
8611 int j;
8612 int isum;
2cf0635d 8613 char * vstart;
252b5132 8614
7e26601c 8615 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 8616 break;
8617
252b5132 8618 vstart = ((char *) eneed) + idx;
54806181
AM		 8619 if (vstart + sizeof (*entry) > endbuf)
8620 break;
252b5132
RH		 8621
8622 entry = (Elf_External_Verneed *) vstart;
8623
8624 ent.vn_version = BYTE_GET (entry->vn_version);
8625 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8626 ent.vn_file = BYTE_GET (entry->vn_file);
8627 ent.vn_aux = BYTE_GET (entry->vn_aux);
8628 ent.vn_next = BYTE_GET (entry->vn_next);
8629
8630 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8631
d79b3d50
NC		 8632 if (VALID_DYNAMIC_NAME (ent.vn_file))
8633 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8634 else
8635 printf (_(" File: %lx"), ent.vn_file);
8636
8637 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8638
dd24e3da 8639 /* Check for overflow. */
7e26601c 8640 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8641 break;
8642
252b5132
RH		 8643 vstart += ent.vn_aux;
8644
8645 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8646 {
2cf0635d 8647 Elf_External_Vernaux * eaux;
b34976b6 8648 Elf_Internal_Vernaux aux;
252b5132 8649
54806181
AM		 8650 if (vstart + sizeof (*eaux) > endbuf)
8651 break;
252b5132
RH		 8652 eaux = (Elf_External_Vernaux *) vstart;
8653
8654 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8655 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8656 aux.vna_other = BYTE_GET (eaux->vna_other);
8657 aux.vna_name = BYTE_GET (eaux->vna_name);
8658 aux.vna_next = BYTE_GET (eaux->vna_next);
8659
d79b3d50 8660 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8661 printf (_(" %#06x: Name: %s"),
d79b3d50 8662 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8663 else
ecc2063b 8664 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8665 isum, aux.vna_name);
8666
8667 printf (_(" Flags: %s Version: %d\n"),
8668 get_ver_flags (aux.vna_flags), aux.vna_other);
8669
dd24e3da 8670 /* Check for overflow. */
7e26601c 8671 if (aux.vna_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8672 break;
8673
252b5132
RH		 8674 isum += aux.vna_next;
8675 vstart += aux.vna_next;
8676 }
9cf03b7e 8677
54806181 8678 if (j < ent.vn_cnt)
9cf03b7e 8679 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8680
8681 idx += ent.vn_next;
8682 }
9cf03b7e 8683
54806181 8684 if (cnt < section->sh_info)
9cf03b7e 8685 warn (_("Missing Version Needs information\n"));
103f02d3 8686
252b5132
RH		 8687 free (eneed);
8688 }
8689 break;
8690
8691 case SHT_GNU_versym:
8692 {
2cf0635d 8693 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8694 int total;
8695 int cnt;
2cf0635d
NC		 8696 unsigned char * edata;
8697 unsigned short * data;
8698 char * strtab;
8699 Elf_Internal_Sym * symbols;
8700 Elf_Internal_Shdr * string_sec;
ba5cdace 8701 unsigned long num_syms;
d3ba0551 8702 long off;
252b5132 8703
4fbb74a6 8704 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8705 break;
8706
4fbb74a6 8707 link_section = section_headers + section->sh_link;
08d8fa11 8708 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8709
4fbb74a6 8710 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8711 break;
8712
252b5132
RH		 8713 found = 1;
8714
ba5cdace 8715 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 8716 if (symbols == NULL)
8717 break;
252b5132 8718
4fbb74a6 8719 string_sec = section_headers + link_section->sh_link;
252b5132 8720
3f5e193b
NC		 8721 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8722 string_sec->sh_size,
8723 _("version string table"));
a6e9f9df 8724 if (!strtab)
0429c154
MS		 8725 {
8726 free (symbols);
8727 break;
8728 }
252b5132
RH		 8729
8730 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8731 SECTION_NAME (section), total);
8732
8733 printf (_(" Addr: "));
8734 printf_vma (section->sh_addr);
72de5009 8735 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8736 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8737 SECTION_NAME (link_section));
8738
d3ba0551
AM		 8739 off = offset_from_vma (file,
8740 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8741 total * sizeof (short));
3f5e193b
NC		 8742 edata = (unsigned char *) get_data (NULL, file, off, total,
8743 sizeof (short),
8744 _("version symbol data"));
a6e9f9df
AM		 8745 if (!edata)
8746 {
8747 free (strtab);
0429c154 8748 free (symbols);
a6e9f9df
AM		 8749 break;
8750 }
252b5132 8751
3f5e193b 8752 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8753
8754 for (cnt = total; cnt --;)
b34976b6
AM		 8755 data[cnt] = byte_get (edata + cnt * sizeof (short),
8756 sizeof (short));
252b5132
RH		 8757
8758 free (edata);
8759
8760 for (cnt = 0; cnt < total; cnt += 4)
8761 {
8762 int j, nn;
00d93f34 8763 int check_def, check_need;
2cf0635d 8764 char * name;
252b5132
RH		 8765
8766 printf (" %03x:", cnt);
8767
8768 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8769 switch (data[cnt + j])
252b5132
RH		 8770 {
8771 case 0:
8772 fputs (_(" 0 (*local*) "), stdout);
8773 break;
8774
8775 case 1:
8776 fputs (_(" 1 (*global*) "), stdout);
8777 break;
8778
8779 default:
c244d050
NC		 8780 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8781 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8782
dd24e3da 8783 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 8784 array, break to avoid an out-of-bounds read. */
8785 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 8786 {
8787 warn (_("invalid index into symbol array\n"));
8788 break;
8789 }
8790
00d93f34
JJ		 8791 check_def = 1;
8792 check_need = 1;
4fbb74a6
AM		 8793 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8794 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8795 != SHT_NOBITS)
252b5132 8796 {
b34976b6 8797 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8798 check_def = 0;
8799 else
8800 check_need = 0;
252b5132 8801 }
00d93f34
JJ		 8802
8803 if (check_need
b34976b6 8804 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8805 {
b34976b6
AM		 8806 Elf_Internal_Verneed ivn;
8807 unsigned long offset;
252b5132 8808
d93f0186
NC		 8809 offset = offset_from_vma
8810 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8811 sizeof (Elf_External_Verneed));
252b5132 8812
b34976b6 8813 do
252b5132 8814 {
b34976b6
AM		 8815 Elf_Internal_Vernaux ivna;
8816 Elf_External_Verneed evn;
8817 Elf_External_Vernaux evna;
8818 unsigned long a_off;
252b5132 8819
59245841
NC		 8820 if (get_data (&evn, file, offset, sizeof (evn), 1,
8821 _("version need")) == NULL)
8822 break;
8823
252b5132
RH		 8824 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8825 ivn.vn_next = BYTE_GET (evn.vn_next);
8826
8827 a_off = offset + ivn.vn_aux;
8828
8829 do
8830 {
59245841
NC		 8831 if (get_data (&evna, file, a_off, sizeof (evna),
8832 1, _("version need aux (2)")) == NULL)
8833 {
8834 ivna.vna_next = 0;
8835 ivna.vna_other = 0;
8836 }
8837 else
8838 {
8839 ivna.vna_next = BYTE_GET (evna.vna_next);
8840 ivna.vna_other = BYTE_GET (evna.vna_other);
8841 }
252b5132
RH		 8842
8843 a_off += ivna.vna_next;
8844 }
b34976b6 8845 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8846 && ivna.vna_next != 0);
8847
b34976b6 8848 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8849 {
8850 ivna.vna_name = BYTE_GET (evna.vna_name);
8851
54806181
AM		 8852 if (ivna.vna_name >= string_sec->sh_size)
8853 name = _("*invalid*");
8854 else
8855 name = strtab + ivna.vna_name;
252b5132 8856 nn += printf ("(%s%-*s",
16062207
ILT		 8857 name,
8858 12 - (int) strlen (name),
252b5132 8859 ")");
00d93f34 8860 check_def = 0;
252b5132
RH		 8861 break;
8862 }
8863
8864 offset += ivn.vn_next;
8865 }
8866 while (ivn.vn_next);
8867 }
00d93f34 8868
b34976b6
AM		 8869 if (check_def && data[cnt + j] != 0x8001
8870 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8871 {
b34976b6
AM		 8872 Elf_Internal_Verdef ivd;
8873 Elf_External_Verdef evd;
8874 unsigned long offset;
252b5132 8875
d93f0186
NC		 8876 offset = offset_from_vma
8877 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8878 sizeof evd);
252b5132
RH		 8879
8880 do
8881 {
59245841
NC		 8882 if (get_data (&evd, file, offset, sizeof (evd), 1,
8883 _("version def")) == NULL)
8884 {
8885 ivd.vd_next = 0;
8886 ivd.vd_ndx = 0;
8887 }
8888 else
8889 {
8890 ivd.vd_next = BYTE_GET (evd.vd_next);
8891 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8892 }
252b5132
RH		 8893
8894 offset += ivd.vd_next;
8895 }
c244d050 8896 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8897 && ivd.vd_next != 0);
8898
c244d050 8899 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8900 {
b34976b6
AM		 8901 Elf_External_Verdaux evda;
8902 Elf_Internal_Verdaux ivda;
252b5132
RH		 8903
8904 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8905
59245841
NC		 8906 if (get_data (&evda, file,
8907 offset - ivd.vd_next + ivd.vd_aux,
8908 sizeof (evda), 1,
8909 _("version def aux")) == NULL)
8910 break;
252b5132
RH		 8911
8912 ivda.vda_name = BYTE_GET (evda.vda_name);
8913
54806181
AM		 8914 if (ivda.vda_name >= string_sec->sh_size)
8915 name = _("*invalid*");
8916 else
8917 name = strtab + ivda.vda_name;
252b5132 8918 nn += printf ("(%s%-*s",
16062207
ILT		 8919 name,
8920 12 - (int) strlen (name),
252b5132
RH		 8921 ")");
8922 }
8923 }
8924
8925 if (nn < 18)
8926 printf ("%*c", 18 - nn, ' ');
8927 }
8928
8929 putchar ('\n');
8930 }
8931
8932 free (data);
8933 free (strtab);
8934 free (symbols);
8935 }
8936 break;
103f02d3 8937
252b5132
RH		 8938 default:
8939 break;
8940 }
8941 }
8942
8943 if (! found)
8944 printf (_("\nNo version information found in this file.\n"));
8945
8946 return 1;
8947}
8948
d1133906 8949static const char *
d3ba0551 8950get_symbol_binding (unsigned int binding)
252b5132 8951{
b34976b6 8952 static char buff[32];
252b5132
RH		 8953
8954 switch (binding)
8955 {
b34976b6
AM		 8956 case STB_LOCAL: return "LOCAL";
8957 case STB_GLOBAL: return "GLOBAL";
8958 case STB_WEAK: return "WEAK";
252b5132
RH		 8959 default:
8960 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8961 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8962 binding);
252b5132 8963 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8964 {
8965 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8966 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8967 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8968 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8969 return "UNIQUE";
8970 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8971 }
252b5132 8972 else
e9e44622 8973 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8974 return buff;
8975 }
8976}
8977
d1133906 8978static const char *
d3ba0551 8979get_symbol_type (unsigned int type)
252b5132 8980{
b34976b6 8981 static char buff[32];
252b5132
RH		 8982
8983 switch (type)
8984 {
b34976b6
AM		 8985 case STT_NOTYPE: return "NOTYPE";
8986 case STT_OBJECT: return "OBJECT";
8987 case STT_FUNC: return "FUNC";
8988 case STT_SECTION: return "SECTION";
8989 case STT_FILE: return "FILE";
8990 case STT_COMMON: return "COMMON";
8991 case STT_TLS: return "TLS";
15ab5209
DB		 8992 case STT_RELC: return "RELC";
8993 case STT_SRELC: return "SRELC";
252b5132
RH		 8994 default:
8995 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8996 {
8997 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8998 return "THUMB_FUNC";
8999
351b4b40 9000 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9001 return "REGISTER";
9002
9003 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9004 return "PARISC_MILLI";
9005
e9e44622 9006 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9007 }
252b5132 9008 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9009 {
9010 if (elf_header.e_machine == EM_PARISC)
9011 {
9012 if (type == STT_HP_OPAQUE)
9013 return "HP_OPAQUE";
9014 if (type == STT_HP_STUB)
9015 return "HP_STUB";
9016 }
9017
d8045f23 9018 if (type == STT_GNU_IFUNC
9c55345c 9019 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9020 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9021 /* GNU is still using the default value 0. */
d8045f23
NC		 9022 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9023 return "IFUNC";
9024
e9e44622 9025 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9026 }
252b5132 9027 else
e9e44622 9028 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9029 return buff;
9030 }
9031}
9032
d1133906 9033static const char *
d3ba0551 9034get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9035{
9036 switch (visibility)
9037 {
b34976b6
AM		 9038 case STV_DEFAULT: return "DEFAULT";
9039 case STV_INTERNAL: return "INTERNAL";
9040 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9041 case STV_PROTECTED: return "PROTECTED";
9042 default: abort ();
9043 }
9044}
9045
5e2b0d47
NC		 9046static const char *
9047get_mips_symbol_other (unsigned int other)
9048{
9049 switch (other)
9050 {
df58fc94
RS		 9051 case STO_OPTIONAL:
9052 return "OPTIONAL";
9053 case STO_MIPS_PLT:
9054 return "MIPS PLT";
9055 case STO_MIPS_PIC:
9056 return "MIPS PIC";
9057 case STO_MICROMIPS:
9058 return "MICROMIPS";
9059 case STO_MICROMIPS | STO_MIPS_PIC:
9060 return "MICROMIPS, MIPS PIC";
9061 case STO_MIPS16:
9062 return "MIPS16";
9063 default:
9064 return NULL;
5e2b0d47
NC		 9065 }
9066}
9067
28f997cf
TG		 9068static const char *
9069get_ia64_symbol_other (unsigned int other)
9070{
9071 if (is_ia64_vms ())
9072 {
9073 static char res[32];
9074
9075 res[0] = 0;
9076
9077 /* Function types is for images and .STB files only. */
9078 switch (elf_header.e_type)
9079 {
9080 case ET_DYN:
9081 case ET_EXEC:
9082 switch (VMS_ST_FUNC_TYPE (other))
9083 {
9084 case VMS_SFT_CODE_ADDR:
9085 strcat (res, " CA");
9086 break;
9087 case VMS_SFT_SYMV_IDX:
9088 strcat (res, " VEC");
9089 break;
9090 case VMS_SFT_FD:
9091 strcat (res, " FD");
9092 break;
9093 case VMS_SFT_RESERVE:
9094 strcat (res, " RSV");
9095 break;
9096 default:
9097 abort ();
9098 }
9099 break;
9100 default:
9101 break;
9102 }
9103 switch (VMS_ST_LINKAGE (other))
9104 {
9105 case VMS_STL_IGNORE:
9106 strcat (res, " IGN");
9107 break;
9108 case VMS_STL_RESERVE:
9109 strcat (res, " RSV");
9110 break;
9111 case VMS_STL_STD:
9112 strcat (res, " STD");
9113 break;
9114 case VMS_STL_LNK:
9115 strcat (res, " LNK");
9116 break;
9117 default:
9118 abort ();
9119 }
9120
9121 if (res[0] != 0)
9122 return res + 1;
9123 else
9124 return res;
9125 }
9126 return NULL;
9127}
9128
5e2b0d47
NC		 9129static const char *
9130get_symbol_other (unsigned int other)
9131{
9132 const char * result = NULL;
9133 static char buff [32];
9134
9135 if (other == 0)
9136 return "";
9137
9138 switch (elf_header.e_machine)
9139 {
9140 case EM_MIPS:
9141 result = get_mips_symbol_other (other);
28f997cf
TG		 9142 break;
9143 case EM_IA_64:
9144 result = get_ia64_symbol_other (other);
9145 break;
5e2b0d47
NC		 9146 default:
9147 break;
9148 }
9149
9150 if (result)
9151 return result;
9152
9153 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9154 return buff;
9155}
9156
d1133906 9157static const char *
d3ba0551 9158get_symbol_index_type (unsigned int type)
252b5132 9159{
b34976b6 9160 static char buff[32];
5cf1065c 9161
252b5132
RH		 9162 switch (type)
9163 {
b34976b6
AM		 9164 case SHN_UNDEF: return "UND";
9165 case SHN_ABS: return "ABS";
9166 case SHN_COMMON: return "COM";
252b5132 9167 default:
9ce701e2
L		 9168 if (type == SHN_IA_64_ANSI_COMMON
9169 && elf_header.e_machine == EM_IA_64
9170 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9171 return "ANSI_COM";
8a9036a4 9172 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9173 || elf_header.e_machine == EM_L1OM
9174 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9175 && type == SHN_X86_64_LCOMMON)
9176 return "LARGE_COM";
ac145307
BS		 9177 else if ((type == SHN_MIPS_SCOMMON
9178 && elf_header.e_machine == EM_MIPS)
9179 || (type == SHN_TIC6X_SCOMMON
9180 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9181 return "SCOM";
9182 else if (type == SHN_MIPS_SUNDEFINED
9183 && elf_header.e_machine == EM_MIPS)
9184 return "SUND";
9ce701e2 9185 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9186 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9187 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9188 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9189 else if (type >= SHN_LORESERVE)
9190 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L		 9191 else if (type >= elf_header.e_shnum)
9192 sprintf (buff, "bad section index[%3d]", type);
252b5132 9193 else
232e7cb8 9194 sprintf (buff, "%3d", type);
5cf1065c 9195 break;
252b5132 9196 }
5cf1065c
NC		 9197
9198 return buff;
252b5132
RH		 9199}
9200
66543521 9201static bfd_vma *
2cf0635d 9202get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9203{
2cf0635d
NC		 9204 unsigned char * e_data;
9205 bfd_vma * i_data;
252b5132 9206
3f5e193b 9207 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9208
9209 if (e_data == NULL)
9210 {
9211 error (_("Out of memory\n"));
9212 return NULL;
9213 }
9214
66543521 9215 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9216 {
9217 error (_("Unable to read in dynamic data\n"));
9218 return NULL;
9219 }
9220
3f5e193b 9221 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9222
9223 if (i_data == NULL)
9224 {
9225 error (_("Out of memory\n"));
9226 free (e_data);
9227 return NULL;
9228 }
9229
9230 while (number--)
66543521 9231 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9232
9233 free (e_data);
9234
9235 return i_data;
9236}
9237
6bd1a22c
L		 9238static void
9239print_dynamic_symbol (bfd_vma si, unsigned long hn)
9240{
2cf0635d 9241 Elf_Internal_Sym * psym;
6bd1a22c
L		 9242 int n;
9243
9244 psym = dynamic_symbols + si;
9245
9246 n = print_vma (si, DEC_5);
9247 if (n < 5)
9248 fputs (" " + n, stdout);
9249 printf (" %3lu: ", hn);
9250 print_vma (psym->st_value, LONG_HEX);
9251 putchar (' ');
9252 print_vma (psym->st_size, DEC_5);
9253
f4be36b3
AM		 9254 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9255 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9256 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9257 /* Check to see if any other bits in the st_other field are set.
9258 Note - displaying this information disrupts the layout of the
9259 table being generated, but for the moment this case is very
9260 rare. */
9261 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9262 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9263 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9264 if (VALID_DYNAMIC_NAME (psym->st_name))
9265 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9266 else
2b692964 9267 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9268 putchar ('\n');
9269}
9270
e3c8793a 9271/* Dump the symbol table. */
252b5132 9272static int
2cf0635d 9273process_symbol_table (FILE * file)
252b5132 9274{
2cf0635d 9275 Elf_Internal_Shdr * section;
66543521
AM		 9276 bfd_vma nbuckets = 0;
9277 bfd_vma nchains = 0;
2cf0635d
NC		 9278 bfd_vma * buckets = NULL;
9279 bfd_vma * chains = NULL;
fdc90cb4 9280 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9281 bfd_vma * gnubuckets = NULL;
9282 bfd_vma * gnuchains = NULL;
6bd1a22c 9283 bfd_vma gnusymidx = 0;
252b5132 9284
2c610e4b 9285 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9286 return 1;
9287
6bd1a22c
L		 9288 if (dynamic_info[DT_HASH]
9289 && (do_histogram
2c610e4b
L		 9290 || (do_using_dynamic
9291 && !do_dyn_syms
9292 && dynamic_strings != NULL)))
252b5132 9293 {
66543521
AM		 9294 unsigned char nb[8];
9295 unsigned char nc[8];
9296 int hash_ent_size = 4;
9297
9298 if ((elf_header.e_machine == EM_ALPHA
9299 || elf_header.e_machine == EM_S390
9300 || elf_header.e_machine == EM_S390_OLD)
9301 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9302 hash_ent_size = 8;
9303
fb52b2f4
NC		 9304 if (fseek (file,
9305 (archive_file_offset
9306 + offset_from_vma (file, dynamic_info[DT_HASH],
9307 sizeof nb + sizeof nc)),
d93f0186 9308 SEEK_SET))
252b5132 9309 {
591a748a 9310 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9311 goto no_hash;
252b5132
RH		 9312 }
9313
66543521 9314 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9315 {
9316 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9317 goto no_hash;
252b5132
RH		 9318 }
9319
66543521 9320 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9321 {
9322 error (_("Failed to read in number of chains\n"));
d3a44ec6 9323 goto no_hash;
252b5132
RH		 9324 }
9325
66543521
AM		 9326 nbuckets = byte_get (nb, hash_ent_size);
9327 nchains = byte_get (nc, hash_ent_size);
252b5132 9328
66543521
AM		 9329 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9330 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9331
d3a44ec6 9332 no_hash:
252b5132 9333 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9334 {
9335 if (do_using_dynamic)
9336 return 0;
9337 free (buckets);
9338 free (chains);
9339 buckets = NULL;
9340 chains = NULL;
9341 nbuckets = 0;
9342 nchains = 0;
9343 }
252b5132
RH		 9344 }
9345
6bd1a22c
L		 9346 if (dynamic_info_DT_GNU_HASH
9347 && (do_histogram
2c610e4b
L		 9348 || (do_using_dynamic
9349 && !do_dyn_syms
9350 && dynamic_strings != NULL)))
252b5132 9351 {
6bd1a22c
L		 9352 unsigned char nb[16];
9353 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9354 bfd_vma buckets_vma;
9355
9356 if (fseek (file,
9357 (archive_file_offset
9358 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9359 sizeof nb)),
9360 SEEK_SET))
9361 {
9362 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9363 goto no_gnu_hash;
6bd1a22c 9364 }
252b5132 9365
6bd1a22c
L		 9366 if (fread (nb, 16, 1, file) != 1)
9367 {
9368 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9369 goto no_gnu_hash;
6bd1a22c
L		 9370 }
9371
9372 ngnubuckets = byte_get (nb, 4);
9373 gnusymidx = byte_get (nb + 4, 4);
9374 bitmaskwords = byte_get (nb + 8, 4);
9375 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9376 if (is_32bit_elf)
6bd1a22c 9377 buckets_vma += bitmaskwords * 4;
f7a99963 9378 else
6bd1a22c 9379 buckets_vma += bitmaskwords * 8;
252b5132 9380
6bd1a22c
L		 9381 if (fseek (file,
9382 (archive_file_offset
9383 + offset_from_vma (file, buckets_vma, 4)),
9384 SEEK_SET))
252b5132 9385 {
6bd1a22c 9386 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9387 goto no_gnu_hash;
6bd1a22c
L		 9388 }
9389
9390 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9391
6bd1a22c 9392 if (gnubuckets == NULL)
d3a44ec6 9393 goto no_gnu_hash;
6bd1a22c
L		 9394
9395 for (i = 0; i < ngnubuckets; i++)
9396 if (gnubuckets[i] != 0)
9397 {
9398 if (gnubuckets[i] < gnusymidx)
9399 return 0;
9400
9401 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9402 maxchain = gnubuckets[i];
9403 }
9404
9405 if (maxchain == 0xffffffff)
d3a44ec6 9406 goto no_gnu_hash;
6bd1a22c
L		 9407
9408 maxchain -= gnusymidx;
9409
9410 if (fseek (file,
9411 (archive_file_offset
9412 + offset_from_vma (file, buckets_vma
9413 + 4 * (ngnubuckets + maxchain), 4)),
9414 SEEK_SET))
9415 {
9416 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9417 goto no_gnu_hash;
6bd1a22c
L		 9418 }
9419
9420 do
9421 {
9422 if (fread (nb, 4, 1, file) != 1)
252b5132 9423 {
6bd1a22c 9424 error (_("Failed to determine last chain length\n"));
d3a44ec6 9425 goto no_gnu_hash;
6bd1a22c 9426 }
252b5132 9427
6bd1a22c 9428 if (maxchain + 1 == 0)
d3a44ec6 9429 goto no_gnu_hash;
252b5132 9430
6bd1a22c
L		 9431 ++maxchain;
9432 }
9433 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9434
6bd1a22c
L		 9435 if (fseek (file,
9436 (archive_file_offset
9437 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9438 SEEK_SET))
9439 {
9440 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9441 goto no_gnu_hash;
6bd1a22c
L		 9442 }
9443
9444 gnuchains = get_dynamic_data (file, maxchain, 4);
9445
d3a44ec6 9446 no_gnu_hash:
6bd1a22c 9447 if (gnuchains == NULL)
d3a44ec6
JJ		 9448 {
9449 free (gnubuckets);
d3a44ec6
JJ		 9450 gnubuckets = NULL;
9451 ngnubuckets = 0;
f64fddf1
NC		 9452 if (do_using_dynamic)
9453 return 0;
d3a44ec6 9454 }
6bd1a22c
L		 9455 }
9456
9457 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9458 && do_syms
9459 && do_using_dynamic
9460 && dynamic_strings != NULL)
9461 {
9462 unsigned long hn;
9463
9464 if (dynamic_info[DT_HASH])
9465 {
9466 bfd_vma si;
9467
9468 printf (_("\nSymbol table for image:\n"));
9469 if (is_32bit_elf)
9470 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9471 else
9472 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9473
9474 for (hn = 0; hn < nbuckets; hn++)
9475 {
9476 if (! buckets[hn])
9477 continue;
9478
9479 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9480 print_dynamic_symbol (si, hn);
252b5132
RH		 9481 }
9482 }
6bd1a22c
L		 9483
9484 if (dynamic_info_DT_GNU_HASH)
9485 {
9486 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9487 if (is_32bit_elf)
9488 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9489 else
9490 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9491
9492 for (hn = 0; hn < ngnubuckets; ++hn)
9493 if (gnubuckets[hn] != 0)
9494 {
9495 bfd_vma si = gnubuckets[hn];
9496 bfd_vma off = si - gnusymidx;
9497
9498 do
9499 {
9500 print_dynamic_symbol (si, hn);
9501 si++;
9502 }
9503 while ((gnuchains[off++] & 1) == 0);
9504 }
9505 }
252b5132 9506 }
2c610e4b 9507 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9508 {
b34976b6 9509 unsigned int i;
252b5132
RH		 9510
9511 for (i = 0, section = section_headers;
9512 i < elf_header.e_shnum;
9513 i++, section++)
9514 {
b34976b6 9515 unsigned int si;
2cf0635d 9516 char * strtab = NULL;
c256ffe7 9517 unsigned long int strtab_size = 0;
2cf0635d
NC		 9518 Elf_Internal_Sym * symtab;
9519 Elf_Internal_Sym * psym;
ba5cdace 9520 unsigned long num_syms;
252b5132 9521
2c610e4b
L		 9522 if ((section->sh_type != SHT_SYMTAB
9523 && section->sh_type != SHT_DYNSYM)
9524 || (!do_syms
9525 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9526 continue;
9527
dd24e3da
NC		 9528 if (section->sh_entsize == 0)
9529 {
9530 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9531 SECTION_NAME (section));
9532 continue;
9533 }
9534
252b5132
RH		 9535 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9536 SECTION_NAME (section),
9537 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9538
f7a99963 9539 if (is_32bit_elf)
ca47b30c 9540 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9541 else
ca47b30c 9542 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9543
ba5cdace 9544 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9545 if (symtab == NULL)
9546 continue;
9547
9548 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9549 {
9550 strtab = string_table;
9551 strtab_size = string_table_length;
9552 }
4fbb74a6 9553 else if (section->sh_link < elf_header.e_shnum)
252b5132 9554 {
2cf0635d 9555 Elf_Internal_Shdr * string_sec;
252b5132 9556
4fbb74a6 9557 string_sec = section_headers + section->sh_link;
252b5132 9558
3f5e193b
NC		 9559 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9560 1, string_sec->sh_size,
9561 _("string table"));
c256ffe7 9562 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9563 }
9564
ba5cdace 9565 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9566 {
5e220199 9567 printf ("%6d: ", si);
f7a99963
NC		 9568 print_vma (psym->st_value, LONG_HEX);
9569 putchar (' ');
9570 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9571 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9572 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9573 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9574 /* Check to see if any other bits in the st_other field are set.
9575 Note - displaying this information disrupts the layout of the
9576 table being generated, but for the moment this case is very rare. */
9577 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9578 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9579 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9580 print_symbol (25, psym->st_name < strtab_size
2b692964 9581 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9582
59245841
NC		 9583 if (section->sh_type == SHT_DYNSYM
9584 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9585 {
b34976b6
AM		 9586 unsigned char data[2];
9587 unsigned short vers_data;
9588 unsigned long offset;
9589 int is_nobits;
9590 int check_def;
252b5132 9591
d93f0186
NC		 9592 offset = offset_from_vma
9593 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9594 sizeof data + si * sizeof (vers_data));
252b5132 9595
59245841
NC		 9596 if (get_data (&data, file, offset + si * sizeof (vers_data),
9597 sizeof (data), 1, _("version data")) == NULL)
9598 break;
252b5132
RH		 9599
9600 vers_data = byte_get (data, 2);
9601
4fbb74a6
AM		 9602 is_nobits = (psym->st_shndx < elf_header.e_shnum
9603 && section_headers[psym->st_shndx].sh_type
c256ffe7 9604 == SHT_NOBITS);
252b5132
RH		 9605
9606 check_def = (psym->st_shndx != SHN_UNDEF);
9607
c244d050 9608 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9609 {
b34976b6 9610 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9611 && (is_nobits || ! check_def))
252b5132 9612 {
b34976b6
AM		 9613 Elf_External_Verneed evn;
9614 Elf_Internal_Verneed ivn;
9615 Elf_Internal_Vernaux ivna;
252b5132
RH		 9616
9617 /* We must test both. */
d93f0186
NC		 9618 offset = offset_from_vma
9619 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9620 sizeof evn);
252b5132 9621
252b5132
RH		 9622 do
9623 {
b34976b6 9624 unsigned long vna_off;
252b5132 9625
59245841
NC		 9626 if (get_data (&evn, file, offset, sizeof (evn), 1,
9627 _("version need")) == NULL)
9628 {
9629 ivna.vna_next = 0;
9630 ivna.vna_other = 0;
9631 ivna.vna_name = 0;
9632 break;
9633 }
dd27201e
L		 9634
9635 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9636 ivn.vn_next = BYTE_GET (evn.vn_next);
9637
252b5132
RH		 9638 vna_off = offset + ivn.vn_aux;
9639
9640 do
9641 {
b34976b6 9642 Elf_External_Vernaux evna;
252b5132 9643
59245841
NC		 9644 if (get_data (&evna, file, vna_off,
9645 sizeof (evna), 1,
9646 _("version need aux (3)")) == NULL)
9647 {
9648 ivna.vna_next = 0;
9649 ivna.vna_other = 0;
9650 ivna.vna_name = 0;
9651 }
9652 else
9653 {
9654 ivna.vna_other = BYTE_GET (evna.vna_other);
9655 ivna.vna_next = BYTE_GET (evna.vna_next);
9656 ivna.vna_name = BYTE_GET (evna.vna_name);
9657 }
252b5132
RH		 9658
9659 vna_off += ivna.vna_next;
9660 }
9661 while (ivna.vna_other != vers_data
9662 && ivna.vna_next != 0);
9663
9664 if (ivna.vna_other == vers_data)
9665 break;
9666
9667 offset += ivn.vn_next;
9668 }
9669 while (ivn.vn_next != 0);
9670
9671 if (ivna.vna_other == vers_data)
9672 {
9673 printf ("@%s (%d)",
c256ffe7 9674 ivna.vna_name < strtab_size
2b692964 9675 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9676 ivna.vna_other);
252b5132
RH		 9677 check_def = 0;
9678 }
9679 else if (! is_nobits)
591a748a 9680 error (_("bad dynamic symbol\n"));
252b5132
RH		 9681 else
9682 check_def = 1;
9683 }
9684
9685 if (check_def)
9686 {
00d93f34 9687 if (vers_data != 0x8001
b34976b6 9688 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9689 {
b34976b6
AM		 9690 Elf_Internal_Verdef ivd;
9691 Elf_Internal_Verdaux ivda;
9692 Elf_External_Verdaux evda;
91d6fa6a 9693 unsigned long off;
252b5132 9694
91d6fa6a 9695 off = offset_from_vma
d93f0186
NC		 9696 (file,
9697 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9698 sizeof (Elf_External_Verdef));
252b5132
RH		 9699
9700 do
9701 {
b34976b6 9702 Elf_External_Verdef evd;
252b5132 9703
59245841
NC		 9704 if (get_data (&evd, file, off, sizeof (evd),
9705 1, _("version def")) == NULL)
9706 {
9707 ivd.vd_ndx = 0;
9708 ivd.vd_aux = 0;
9709 ivd.vd_next = 0;
9710 }
9711 else
9712 {
9713 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9714 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9715 ivd.vd_next = BYTE_GET (evd.vd_next);
9716 }
252b5132 9717
91d6fa6a 9718 off += ivd.vd_next;
252b5132 9719 }
c244d050 9720 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9721 && ivd.vd_next != 0);
9722
91d6fa6a
NC		 9723 off -= ivd.vd_next;
9724 off += ivd.vd_aux;
252b5132 9725
59245841
NC		 9726 if (get_data (&evda, file, off, sizeof (evda),
9727 1, _("version def aux")) == NULL)
9728 break;
252b5132
RH		 9729
9730 ivda.vda_name = BYTE_GET (evda.vda_name);
9731
9732 if (psym->st_name != ivda.vda_name)
c244d050 9733 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9734 ? "@%s" : "@@%s",
c256ffe7 9735 ivda.vda_name < strtab_size
2b692964 9736 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9737 }
9738 }
9739 }
9740 }
9741
9742 putchar ('\n');
9743 }
9744
9745 free (symtab);
9746 if (strtab != string_table)
9747 free (strtab);
9748 }
9749 }
9750 else if (do_syms)
9751 printf
9752 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9753
9754 if (do_histogram && buckets != NULL)
9755 {
2cf0635d
NC		 9756 unsigned long * lengths;
9757 unsigned long * counts;
66543521
AM		 9758 unsigned long hn;
9759 bfd_vma si;
9760 unsigned long maxlength = 0;
9761 unsigned long nzero_counts = 0;
9762 unsigned long nsyms = 0;
252b5132 9763
66543521
AM		 9764 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9765 (unsigned long) nbuckets);
252b5132
RH		 9766 printf (_(" Length Number %% of total Coverage\n"));
9767
3f5e193b 9768 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9769 if (lengths == NULL)
9770 {
591a748a 9771 error (_("Out of memory\n"));
252b5132
RH		 9772 return 0;
9773 }
9774 for (hn = 0; hn < nbuckets; ++hn)
9775 {
f7a99963 9776 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9777 {
b34976b6 9778 ++nsyms;
252b5132 9779 if (maxlength < ++lengths[hn])
b34976b6 9780 ++maxlength;
252b5132
RH		 9781 }
9782 }
9783
3f5e193b 9784 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9785 if (counts == NULL)
9786 {
591a748a 9787 error (_("Out of memory\n"));
252b5132
RH		 9788 return 0;
9789 }
9790
9791 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9792 ++counts[lengths[hn]];
252b5132 9793
103f02d3 9794 if (nbuckets > 0)
252b5132 9795 {
66543521
AM		 9796 unsigned long i;
9797 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9798 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9799 for (i = 1; i <= maxlength; ++i)
103f02d3 9800 {
66543521
AM		 9801 nzero_counts += counts[i] * i;
9802 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9803 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9804 (nzero_counts * 100.0) / nsyms);
9805 }
252b5132
RH		 9806 }
9807
9808 free (counts);
9809 free (lengths);
9810 }
9811
9812 if (buckets != NULL)
9813 {
9814 free (buckets);
9815 free (chains);
9816 }
9817
d3a44ec6 9818 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9819 {
2cf0635d
NC		 9820 unsigned long * lengths;
9821 unsigned long * counts;
fdc90cb4
JJ		 9822 unsigned long hn;
9823 unsigned long maxlength = 0;
9824 unsigned long nzero_counts = 0;
9825 unsigned long nsyms = 0;
fdc90cb4 9826
3f5e193b 9827 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9828 if (lengths == NULL)
9829 {
591a748a 9830 error (_("Out of memory\n"));
fdc90cb4
JJ		 9831 return 0;
9832 }
9833
9834 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9835 (unsigned long) ngnubuckets);
9836 printf (_(" Length Number %% of total Coverage\n"));
9837
9838 for (hn = 0; hn < ngnubuckets; ++hn)
9839 if (gnubuckets[hn] != 0)
9840 {
9841 bfd_vma off, length = 1;
9842
6bd1a22c 9843 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9844 (gnuchains[off] & 1) == 0; ++off)
9845 ++length;
9846 lengths[hn] = length;
9847 if (length > maxlength)
9848 maxlength = length;
9849 nsyms += length;
9850 }
9851
3f5e193b 9852 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9853 if (counts == NULL)
9854 {
591a748a 9855 error (_("Out of memory\n"));
fdc90cb4
JJ		 9856 return 0;
9857 }
9858
9859 for (hn = 0; hn < ngnubuckets; ++hn)
9860 ++counts[lengths[hn]];
9861
9862 if (ngnubuckets > 0)
9863 {
9864 unsigned long j;
9865 printf (" 0 %-10lu (%5.1f%%)\n",
9866 counts[0], (counts[0] * 100.0) / ngnubuckets);
9867 for (j = 1; j <= maxlength; ++j)
9868 {
9869 nzero_counts += counts[j] * j;
9870 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9871 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9872 (nzero_counts * 100.0) / nsyms);
9873 }
9874 }
9875
9876 free (counts);
9877 free (lengths);
9878 free (gnubuckets);
9879 free (gnuchains);
9880 }
9881
252b5132
RH		 9882 return 1;
9883}
9884
9885static int
2cf0635d 9886process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9887{
b4c96d0d 9888 unsigned int i;
252b5132
RH		 9889
9890 if (dynamic_syminfo == NULL
9891 || !do_dynamic)
9892 /* No syminfo, this is ok. */
9893 return 1;
9894
9895 /* There better should be a dynamic symbol section. */
9896 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9897 return 0;
9898
9899 if (dynamic_addr)
9900 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9901 dynamic_syminfo_offset, dynamic_syminfo_nent);
9902
9903 printf (_(" Num: Name BoundTo Flags\n"));
9904 for (i = 0; i < dynamic_syminfo_nent; ++i)
9905 {
9906 unsigned short int flags = dynamic_syminfo[i].si_flags;
9907
31104126 9908 printf ("%4d: ", i);
d79b3d50
NC		 9909 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9910 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9911 else
2b692964 9912 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9913 putchar (' ');
252b5132
RH		 9914
9915 switch (dynamic_syminfo[i].si_boundto)
9916 {
9917 case SYMINFO_BT_SELF:
9918 fputs ("SELF ", stdout);
9919 break;
9920 case SYMINFO_BT_PARENT:
9921 fputs ("PARENT ", stdout);
9922 break;
9923 default:
9924 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9925 && dynamic_syminfo[i].si_boundto < dynamic_nent
9926 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9927 {
d79b3d50 9928 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9929 putchar (' ' );
9930 }
252b5132
RH		 9931 else
9932 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9933 break;
9934 }
9935
9936 if (flags & SYMINFO_FLG_DIRECT)
9937 printf (" DIRECT");
9938 if (flags & SYMINFO_FLG_PASSTHRU)
9939 printf (" PASSTHRU");
9940 if (flags & SYMINFO_FLG_COPY)
9941 printf (" COPY");
9942 if (flags & SYMINFO_FLG_LAZYLOAD)
9943 printf (" LAZYLOAD");
9944
9945 puts ("");
9946 }
9947
9948 return 1;
9949}
9950
cf13d699
NC		 9951/* Check to see if the given reloc needs to be handled in a target specific
9952 manner. If so then process the reloc and return TRUE otherwise return
9953 FALSE. */
09c11c86 9954
cf13d699
NC		 9955static bfd_boolean
9956target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9957 unsigned char * start,
9958 Elf_Internal_Sym * symtab)
252b5132 9959{
cf13d699 9960 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9961
cf13d699 9962 switch (elf_header.e_machine)
252b5132 9963 {
cf13d699
NC		 9964 case EM_MN10300:
9965 case EM_CYGNUS_MN10300:
9966 {
9967 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9968
cf13d699
NC		 9969 switch (reloc_type)
9970 {
9971 case 34: /* R_MN10300_ALIGN */
9972 return TRUE;
9973 case 33: /* R_MN10300_SYM_DIFF */
9974 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9975 return TRUE;
9976 case 1: /* R_MN10300_32 */
9977 case 2: /* R_MN10300_16 */
9978 if (saved_sym != NULL)
9979 {
9980 bfd_vma value;
252b5132 9981
cf13d699
NC		 9982 value = reloc->r_addend
9983 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9984 - saved_sym->st_value);
252b5132 9985
cf13d699 9986 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9987
cf13d699
NC		 9988 saved_sym = NULL;
9989 return TRUE;
9990 }
9991 break;
9992 default:
9993 if (saved_sym != NULL)
9994 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9995 break;
9996 }
9997 break;
9998 }
252b5132
RH		 9999 }
10000
cf13d699 10001 return FALSE;
252b5132
RH		 10002}
10003
aca88567
NC		 10004/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10005 DWARF debug sections. This is a target specific test. Note - we do not
10006 go through the whole including-target-headers-multiple-times route, (as
10007 we have already done with <elf/h8.h>) because this would become very
10008 messy and even then this function would have to contain target specific
10009 information (the names of the relocs instead of their numeric values).
10010 FIXME: This is not the correct way to solve this problem. The proper way
10011 is to have target specific reloc sizing and typing functions created by
10012 the reloc-macros.h header, in the same way that it already creates the
10013 reloc naming functions. */
10014
10015static bfd_boolean
10016is_32bit_abs_reloc (unsigned int reloc_type)
10017{
10018 switch (elf_header.e_machine)
10019 {
41e92641
NC		 10020 case EM_386:
10021 case EM_486:
10022 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 10023 case EM_68K:
10024 return reloc_type == 1; /* R_68K_32. */
10025 case EM_860:
10026 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10027 case EM_960:
10028 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10029 case EM_AARCH64:
10030 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10031 case EM_ALPHA:
137b6b5f 10032 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10033 case EM_ARC:
10034 return reloc_type == 1; /* R_ARC_32. */
10035 case EM_ARM:
10036 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10037 case EM_AVR_OLD:
aca88567
NC		 10038 case EM_AVR:
10039 return reloc_type == 1;
cfb8c092
NC		 10040 case EM_ADAPTEVA_EPIPHANY:
10041 return reloc_type == 3;
aca88567
NC		 10042 case EM_BLACKFIN:
10043 return reloc_type == 0x12; /* R_byte4_data. */
10044 case EM_CRIS:
10045 return reloc_type == 3; /* R_CRIS_32. */
10046 case EM_CR16:
10047 return reloc_type == 3; /* R_CR16_NUM32. */
10048 case EM_CRX:
10049 return reloc_type == 15; /* R_CRX_NUM32. */
10050 case EM_CYGNUS_FRV:
10051 return reloc_type == 1;
41e92641
NC		 10052 case EM_CYGNUS_D10V:
10053 case EM_D10V:
10054 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10055 case EM_CYGNUS_D30V:
10056 case EM_D30V:
10057 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10058 case EM_DLX:
10059 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10060 case EM_CYGNUS_FR30:
10061 case EM_FR30:
10062 return reloc_type == 3; /* R_FR30_32. */
10063 case EM_H8S:
10064 case EM_H8_300:
10065 case EM_H8_300H:
10066 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10067 case EM_IA_64:
10068 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10069 case EM_IP2K_OLD:
10070 case EM_IP2K:
10071 return reloc_type == 2; /* R_IP2K_32. */
10072 case EM_IQ2000:
10073 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10074 case EM_LATTICEMICO32:
10075 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10076 case EM_M32C_OLD:
aca88567
NC		 10077 case EM_M32C:
10078 return reloc_type == 3; /* R_M32C_32. */
10079 case EM_M32R:
10080 return reloc_type == 34; /* R_M32R_32_RELA. */
10081 case EM_MCORE:
10082 return reloc_type == 1; /* R_MCORE_ADDR32. */
10083 case EM_CYGNUS_MEP:
10084 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10085 case EM_METAG:
10086 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10087 case EM_MICROBLAZE:
10088 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10089 case EM_MIPS:
10090 return reloc_type == 2; /* R_MIPS_32. */
10091 case EM_MMIX:
10092 return reloc_type == 4; /* R_MMIX_32. */
10093 case EM_CYGNUS_MN10200:
10094 case EM_MN10200:
10095 return reloc_type == 1; /* R_MN10200_32. */
10096 case EM_CYGNUS_MN10300:
10097 case EM_MN10300:
10098 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10099 case EM_MOXIE:
10100 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10101 case EM_MSP430_OLD:
10102 case EM_MSP430:
10103 return reloc_type == 1; /* R_MSP43_32. */
10104 case EM_MT:
10105 return reloc_type == 2; /* R_MT_32. */
3e0873ac 10106 case EM_ALTERA_NIOS2:
36591ba1 10107 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 10108 case EM_NIOS32:
10109 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 10110 case EM_OPENRISC:
10111 case EM_OR32:
10112 return reloc_type == 1; /* R_OR32_32. */
aca88567 10113 case EM_PARISC:
5fda8eca
NC		 10114 return (reloc_type == 1 /* R_PARISC_DIR32. */
10115 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10116 case EM_PJ:
10117 case EM_PJ_OLD:
10118 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10119 case EM_PPC64:
10120 return reloc_type == 1; /* R_PPC64_ADDR32. */
10121 case EM_PPC:
10122 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10123 case EM_RL78:
10124 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10125 case EM_RX:
10126 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10127 case EM_S370:
10128 return reloc_type == 1; /* R_I370_ADDR31. */
10129 case EM_S390_OLD:
10130 case EM_S390:
10131 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10132 case EM_SCORE:
10133 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10134 case EM_SH:
10135 return reloc_type == 1; /* R_SH_DIR32. */
10136 case EM_SPARC32PLUS:
10137 case EM_SPARCV9:
10138 case EM_SPARC:
10139 return reloc_type == 3 /* R_SPARC_32. */
10140 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10141 case EM_SPU:
10142 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10143 case EM_TI_C6000:
10144 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10145 case EM_TILEGX:
10146 return reloc_type == 2; /* R_TILEGX_32. */
10147 case EM_TILEPRO:
10148 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10149 case EM_CYGNUS_V850:
10150 case EM_V850:
10151 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10152 case EM_V800:
10153 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10154 case EM_VAX:
10155 return reloc_type == 1; /* R_VAX_32. */
10156 case EM_X86_64:
8a9036a4 10157 case EM_L1OM:
7a9068fe 10158 case EM_K1OM:
aca88567 10159 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10160 case EM_XC16X:
10161 case EM_C166:
10162 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10163 case EM_XGATE:
10164 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10165 case EM_XSTORMY16:
10166 return reloc_type == 1; /* R_XSTROMY16_32. */
10167 case EM_XTENSA_OLD:
10168 case EM_XTENSA:
10169 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10170 default:
10171 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10172 elf_header.e_machine);
10173 abort ();
10174 }
10175}
10176
10177/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10178 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10179
10180static bfd_boolean
10181is_32bit_pcrel_reloc (unsigned int reloc_type)
10182{
10183 switch (elf_header.e_machine)
10184 {
41e92641
NC		 10185 case EM_386:
10186 case EM_486:
3e0873ac 10187 return reloc_type == 2; /* R_386_PC32. */
aca88567 10188 case EM_68K:
3e0873ac 10189 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10190 case EM_AARCH64:
10191 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10192 case EM_ADAPTEVA_EPIPHANY:
10193 return reloc_type == 6;
aca88567
NC		 10194 case EM_ALPHA:
10195 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10196 case EM_ARM:
3e0873ac 10197 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10198 case EM_MICROBLAZE:
10199 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 10200 case EM_PARISC:
85acf597 10201 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10202 case EM_PPC:
10203 return reloc_type == 26; /* R_PPC_REL32. */
10204 case EM_PPC64:
3e0873ac 10205 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10206 case EM_S390_OLD:
10207 case EM_S390:
3e0873ac 10208 return reloc_type == 5; /* R_390_PC32. */
aca88567 10209 case EM_SH:
3e0873ac 10210 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10211 case EM_SPARC32PLUS:
10212 case EM_SPARCV9:
10213 case EM_SPARC:
3e0873ac 10214 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10215 case EM_SPU:
10216 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10217 case EM_TILEGX:
10218 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10219 case EM_TILEPRO:
10220 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10221 case EM_X86_64:
8a9036a4 10222 case EM_L1OM:
7a9068fe 10223 case EM_K1OM:
3e0873ac 10224 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10225 case EM_XTENSA_OLD:
10226 case EM_XTENSA:
10227 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10228 default:
10229 /* Do not abort or issue an error message here. Not all targets use
10230 pc-relative 32-bit relocs in their DWARF debug information and we
10231 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10232 more helpful warning message will be generated by apply_relocations
10233 anyway, so just return. */
aca88567
NC		 10234 return FALSE;
10235 }
10236}
10237
10238/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10239 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10240
10241static bfd_boolean
10242is_64bit_abs_reloc (unsigned int reloc_type)
10243{
10244 switch (elf_header.e_machine)
10245 {
a06ea964
NC		 10246 case EM_AARCH64:
10247 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10248 case EM_ALPHA:
10249 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10250 case EM_IA_64:
10251 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10252 case EM_PARISC:
10253 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10254 case EM_PPC64:
10255 return reloc_type == 38; /* R_PPC64_ADDR64. */
10256 case EM_SPARC32PLUS:
10257 case EM_SPARCV9:
10258 case EM_SPARC:
10259 return reloc_type == 54; /* R_SPARC_UA64. */
10260 case EM_X86_64:
8a9036a4 10261 case EM_L1OM:
7a9068fe 10262 case EM_K1OM:
aca88567 10263 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10264 case EM_S390_OLD:
10265 case EM_S390:
aa137e4d
NC		 10266 return reloc_type == 22; /* R_S390_64. */
10267 case EM_TILEGX:
10268 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10269 case EM_MIPS:
aa137e4d 10270 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10271 default:
10272 return FALSE;
10273 }
10274}
10275
85acf597
RH		 10276/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10277 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10278
10279static bfd_boolean
10280is_64bit_pcrel_reloc (unsigned int reloc_type)
10281{
10282 switch (elf_header.e_machine)
10283 {
a06ea964
NC		 10284 case EM_AARCH64:
10285 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10286 case EM_ALPHA:
aa137e4d 10287 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10288 case EM_IA_64:
aa137e4d 10289 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10290 case EM_PARISC:
aa137e4d 10291 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10292 case EM_PPC64:
aa137e4d 10293 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10294 case EM_SPARC32PLUS:
10295 case EM_SPARCV9:
10296 case EM_SPARC:
aa137e4d 10297 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10298 case EM_X86_64:
8a9036a4 10299 case EM_L1OM:
7a9068fe 10300 case EM_K1OM:
aa137e4d 10301 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10302 case EM_S390_OLD:
10303 case EM_S390:
aa137e4d
NC		 10304 return reloc_type == 23; /* R_S390_PC64. */
10305 case EM_TILEGX:
10306 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10307 default:
10308 return FALSE;
10309 }
10310}
10311
4dc3c23d
AM		 10312/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10313 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10314
10315static bfd_boolean
10316is_24bit_abs_reloc (unsigned int reloc_type)
10317{
10318 switch (elf_header.e_machine)
10319 {
10320 case EM_CYGNUS_MN10200:
10321 case EM_MN10200:
10322 return reloc_type == 4; /* R_MN10200_24. */
10323 default:
10324 return FALSE;
10325 }
10326}
10327
aca88567
NC		 10328/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10329 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10330
10331static bfd_boolean
10332is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10333{
10334 switch (elf_header.e_machine)
10335 {
aca88567
NC		 10336 case EM_AVR_OLD:
10337 case EM_AVR:
10338 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10339 case EM_ADAPTEVA_EPIPHANY:
10340 return reloc_type == 5;
41e92641
NC		 10341 case EM_CYGNUS_D10V:
10342 case EM_D10V:
10343 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10344 case EM_H8S:
10345 case EM_H8_300:
10346 case EM_H8_300H:
aca88567
NC		 10347 return reloc_type == R_H8_DIR16;
10348 case EM_IP2K_OLD:
10349 case EM_IP2K:
10350 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10351 case EM_M32C_OLD:
f4236fe4
DD		 10352 case EM_M32C:
10353 return reloc_type == 1; /* R_M32C_16 */
aca88567 10354 case EM_MSP430:
78c8d46c 10355 case EM_MSP430_OLD:
aca88567 10356 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac 10357 case EM_ALTERA_NIOS2:
36591ba1 10358 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 10359 case EM_NIOS32:
10360 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10361 case EM_TI_C6000:
10362 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10363 case EM_XC16X:
10364 case EM_C166:
10365 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10366 case EM_CYGNUS_MN10200:
10367 case EM_MN10200:
10368 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10369 case EM_CYGNUS_MN10300:
10370 case EM_MN10300:
10371 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10372 case EM_XGATE:
10373 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10374 default:
aca88567 10375 return FALSE;
4b78141a
NC		 10376 }
10377}
10378
2a7b2e88
JK		 10379/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10380 relocation entries (possibly formerly used for SHT_GROUP sections). */
10381
10382static bfd_boolean
10383is_none_reloc (unsigned int reloc_type)
10384{
10385 switch (elf_header.e_machine)
10386 {
cb8f3167
NC		 10387 case EM_68K: /* R_68K_NONE. */
10388 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10389 case EM_SPARC32PLUS:
10390 case EM_SPARCV9:
cb8f3167
NC		 10391 case EM_SPARC: /* R_SPARC_NONE. */
10392 case EM_MIPS: /* R_MIPS_NONE. */
10393 case EM_PARISC: /* R_PARISC_NONE. */
10394 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10395 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10396 case EM_PPC: /* R_PPC_NONE. */
10397 case EM_PPC64: /* R_PPC64_NONE. */
10398 case EM_ARM: /* R_ARM_NONE. */
10399 case EM_IA_64: /* R_IA64_NONE. */
10400 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10401 case EM_S390_OLD:
cb8f3167
NC		 10402 case EM_S390: /* R_390_NONE. */
10403 case EM_CRIS: /* R_CRIS_NONE. */
10404 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10405 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10406 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10407 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10408 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10409 case EM_M32R: /* R_M32R_NONE. */
40b36596 10410 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10411 case EM_TILEGX: /* R_TILEGX_NONE. */
10412 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10413 case EM_XC16X:
10414 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 10415 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
10416 case EM_NIOS32: /* R_NIOS_NONE. */
cb8f3167 10417 return reloc_type == 0;
a06ea964
NC		 10418 case EM_AARCH64:
10419 return reloc_type == 0 || reloc_type == 256;
58332dda
JK		 10420 case EM_XTENSA_OLD:
10421 case EM_XTENSA:
4dc3c23d
AM		 10422 return (reloc_type == 0 /* R_XTENSA_NONE. */
10423 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10424 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10425 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 10426 case EM_METAG:
10427 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 10428 }
10429 return FALSE;
10430}
10431
cf13d699
NC		 10432/* Apply relocations to a section.
10433 Note: So far support has been added only for those relocations
10434 which can be found in debug sections.
10435 FIXME: Add support for more relocations ? */
1b315056 10436
cf13d699
NC		 10437static void
10438apply_relocations (void * file,
10439 Elf_Internal_Shdr * section,
10440 unsigned char * start)
1b315056 10441{
cf13d699
NC		 10442 Elf_Internal_Shdr * relsec;
10443 unsigned char * end = start + section->sh_size;
cb8f3167 10444
cf13d699
NC		 10445 if (elf_header.e_type != ET_REL)
10446 return;
1b315056 10447
cf13d699 10448 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10449 for (relsec = section_headers;
10450 relsec < section_headers + elf_header.e_shnum;
10451 ++relsec)
252b5132 10452 {
41e92641
NC		 10453 bfd_boolean is_rela;
10454 unsigned long num_relocs;
2cf0635d
NC		 10455 Elf_Internal_Rela * relocs;
10456 Elf_Internal_Rela * rp;
10457 Elf_Internal_Shdr * symsec;
10458 Elf_Internal_Sym * symtab;
ba5cdace 10459 unsigned long num_syms;
2cf0635d 10460 Elf_Internal_Sym * sym;
252b5132 10461
41e92641 10462 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10463 || relsec->sh_info >= elf_header.e_shnum
10464 || section_headers + relsec->sh_info != section
c256ffe7 10465 || relsec->sh_size == 0
4fbb74a6 10466 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10467 continue;
428409d5 10468
41e92641
NC		 10469 is_rela = relsec->sh_type == SHT_RELA;
10470
10471 if (is_rela)
10472 {
3f5e193b
NC		 10473 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10474 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10475 return;
10476 }
10477 else
10478 {
3f5e193b
NC		 10479 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10480 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10481 return;
10482 }
10483
10484 /* SH uses RELA but uses in place value instead of the addend field. */
10485 if (elf_header.e_machine == EM_SH)
10486 is_rela = FALSE;
428409d5 10487
4fbb74a6 10488 symsec = section_headers + relsec->sh_link;
ba5cdace 10489 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10490
41e92641 10491 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10492 {
41e92641
NC		 10493 bfd_vma addend;
10494 unsigned int reloc_type;
10495 unsigned int reloc_size;
91d6fa6a 10496 unsigned char * rloc;
ba5cdace 10497 unsigned long sym_index;
4b78141a 10498
aca88567 10499 reloc_type = get_reloc_type (rp->r_info);
41e92641 10500
98fb390a 10501 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10502 continue;
98fb390a
NC		 10503 else if (is_none_reloc (reloc_type))
10504 continue;
10505 else if (is_32bit_abs_reloc (reloc_type)
10506 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10507 reloc_size = 4;
85acf597
RH		 10508 else if (is_64bit_abs_reloc (reloc_type)
10509 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10510 reloc_size = 8;
4dc3c23d
AM		 10511 else if (is_24bit_abs_reloc (reloc_type))
10512 reloc_size = 3;
aca88567
NC		 10513 else if (is_16bit_abs_reloc (reloc_type))
10514 reloc_size = 2;
10515 else
4b78141a 10516 {
41e92641 10517 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10518 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10519 continue;
10520 }
103f02d3 10521
91d6fa6a 10522 rloc = start + rp->r_offset;
c8da6823 10523 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 10524 {
10525 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10526 (unsigned long) rp->r_offset,
10527 SECTION_NAME (section));
10528 continue;
10529 }
103f02d3 10530
ba5cdace
NC		 10531 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10532 if (sym_index >= num_syms)
10533 {
10534 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10535 sym_index, SECTION_NAME (section));
10536 continue;
10537 }
10538 sym = symtab + sym_index;
41e92641
NC		 10539
10540 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10541 make sure that it is of an appropriate type.
10542
10543 Relocations against symbols without type can happen.
10544 Gcc -feliminate-dwarf2-dups may generate symbols
10545 without type for debug info.
10546
10547 Icc generates relocations against function symbols
10548 instead of local labels.
10549
10550 Relocations against object symbols can happen, eg when
10551 referencing a global array. For an example of this see
10552 the _clz.o binary in libgcc.a. */
aca88567 10553 if (sym != symtab
55f25fc3 10554 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10555 {
41e92641 10556 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10557 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10558 (long int)(rp - relocs),
41e92641 10559 SECTION_NAME (relsec));
aca88567 10560 continue;
5b18a4bc 10561 }
252b5132 10562
4dc3c23d
AM		 10563 addend = 0;
10564 if (is_rela)
10565 addend += rp->r_addend;
c47320c3
AM		 10566 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10567 partial_inplace. */
4dc3c23d
AM		 10568 if (!is_rela
10569 || (elf_header.e_machine == EM_XTENSA
10570 && reloc_type == 1)
10571 || ((elf_header.e_machine == EM_PJ
10572 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10573 && reloc_type == 1)
10574 || ((elf_header.e_machine == EM_D30V
10575 || elf_header.e_machine == EM_CYGNUS_D30V)
10576 && reloc_type == 12))
91d6fa6a 10577 addend += byte_get (rloc, reloc_size);
cb8f3167 10578
85acf597
RH		 10579 if (is_32bit_pcrel_reloc (reloc_type)
10580 || is_64bit_pcrel_reloc (reloc_type))
10581 {
10582 /* On HPPA, all pc-relative relocations are biased by 8. */
10583 if (elf_header.e_machine == EM_PARISC)
10584 addend -= 8;
91d6fa6a 10585 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10586 reloc_size);
10587 }
41e92641 10588 else
91d6fa6a 10589 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10590 }
252b5132 10591
5b18a4bc 10592 free (symtab);
41e92641 10593 free (relocs);
5b18a4bc
NC		 10594 break;
10595 }
5b18a4bc 10596}
103f02d3 10597
cf13d699
NC		 10598#ifdef SUPPORT_DISASSEMBLY
10599static int
10600disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10601{
10602 printf (_("\nAssembly dump of section %s\n"),
10603 SECTION_NAME (section));
10604
10605 /* XXX -- to be done --- XXX */
10606
10607 return 1;
10608}
10609#endif
10610
10611/* Reads in the contents of SECTION from FILE, returning a pointer
10612 to a malloc'ed buffer or NULL if something went wrong. */
10613
10614static char *
10615get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10616{
10617 bfd_size_type num_bytes;
10618
10619 num_bytes = section->sh_size;
10620
10621 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10622 {
10623 printf (_("\nSection '%s' has no data to dump.\n"),
10624 SECTION_NAME (section));
10625 return NULL;
10626 }
10627
3f5e193b
NC		 10628 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10629 _("section contents"));
cf13d699
NC		 10630}
10631
dd24e3da 10632
cf13d699
NC		 10633static void
10634dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10635{
10636 Elf_Internal_Shdr * relsec;
10637 bfd_size_type num_bytes;
cf13d699
NC		 10638 char * data;
10639 char * end;
10640 char * start;
10641 char * name = SECTION_NAME (section);
10642 bfd_boolean some_strings_shown;
10643
10644 start = get_section_contents (section, file);
10645 if (start == NULL)
10646 return;
10647
10648 printf (_("\nString dump of section '%s':\n"), name);
10649
10650 /* If the section being dumped has relocations against it the user might
10651 be expecting these relocations to have been applied. Check for this
10652 case and issue a warning message in order to avoid confusion.
10653 FIXME: Maybe we ought to have an option that dumps a section with
10654 relocs applied ? */
10655 for (relsec = section_headers;
10656 relsec < section_headers + elf_header.e_shnum;
10657 ++relsec)
10658 {
10659 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10660 || relsec->sh_info >= elf_header.e_shnum
10661 || section_headers + relsec->sh_info != section
10662 || relsec->sh_size == 0
10663 || relsec->sh_link >= elf_header.e_shnum)
10664 continue;
10665
10666 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10667 break;
10668 }
10669
10670 num_bytes = section->sh_size;
cf13d699
NC		 10671 data = start;
10672 end = start + num_bytes;
10673 some_strings_shown = FALSE;
10674
10675 while (data < end)
10676 {
10677 while (!ISPRINT (* data))
10678 if (++ data >= end)
10679 break;
10680
10681 if (data < end)
10682 {
10683#ifndef __MSVCRT__
c975cc98
NC		 10684 /* PR 11128: Use two separate invocations in order to work
10685 around bugs in the Solaris 8 implementation of printf. */
10686 printf (" [%6tx] ", data - start);
10687 printf ("%s\n", data);
cf13d699
NC		 10688#else
10689 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10690#endif
10691 data += strlen (data);
10692 some_strings_shown = TRUE;
10693 }
10694 }
10695
10696 if (! some_strings_shown)
10697 printf (_(" No strings found in this section."));
10698
10699 free (start);
10700
10701 putchar ('\n');
10702}
10703
10704static void
10705dump_section_as_bytes (Elf_Internal_Shdr * section,
10706 FILE * file,
10707 bfd_boolean relocate)
10708{
10709 Elf_Internal_Shdr * relsec;
10710 bfd_size_type bytes;
10711 bfd_vma addr;
10712 unsigned char * data;
10713 unsigned char * start;
10714
10715 start = (unsigned char *) get_section_contents (section, file);
10716 if (start == NULL)
10717 return;
10718
10719 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10720
10721 if (relocate)
10722 {
10723 apply_relocations (file, section, start);
10724 }
10725 else
10726 {
10727 /* If the section being dumped has relocations against it the user might
10728 be expecting these relocations to have been applied. Check for this
10729 case and issue a warning message in order to avoid confusion.
10730 FIXME: Maybe we ought to have an option that dumps a section with
10731 relocs applied ? */
10732 for (relsec = section_headers;
10733 relsec < section_headers + elf_header.e_shnum;
10734 ++relsec)
10735 {
10736 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10737 || relsec->sh_info >= elf_header.e_shnum
10738 || section_headers + relsec->sh_info != section
10739 || relsec->sh_size == 0
10740 || relsec->sh_link >= elf_header.e_shnum)
10741 continue;
10742
10743 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10744 break;
10745 }
10746 }
10747
10748 addr = section->sh_addr;
10749 bytes = section->sh_size;
10750 data = start;
10751
10752 while (bytes)
10753 {
10754 int j;
10755 int k;
10756 int lbytes;
10757
10758 lbytes = (bytes > 16 ? 16 : bytes);
10759
10760 printf (" 0x%8.8lx ", (unsigned long) addr);
10761
10762 for (j = 0; j < 16; j++)
10763 {
10764 if (j < lbytes)
10765 printf ("%2.2x", data[j]);
10766 else
10767 printf (" ");
10768
10769 if ((j & 3) == 3)
10770 printf (" ");
10771 }
10772
10773 for (j = 0; j < lbytes; j++)
10774 {
10775 k = data[j];
10776 if (k >= ' ' && k < 0x7f)
10777 printf ("%c", k);
10778 else
10779 printf (".");
10780 }
10781
10782 putchar ('\n');
10783
10784 data += lbytes;
10785 addr += lbytes;
10786 bytes -= lbytes;
10787 }
10788
10789 free (start);
10790
10791 putchar ('\n');
10792}
10793
4a114e3e 10794/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10795
10796static int
d3dbc530
AM		 10797uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10798 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10799{
10800#ifndef HAVE_ZLIB_H
cf13d699
NC		 10801 return FALSE;
10802#else
10803 dwarf_size_type compressed_size = *size;
10804 unsigned char * compressed_buffer = *buffer;
10805 dwarf_size_type uncompressed_size;
10806 unsigned char * uncompressed_buffer;
10807 z_stream strm;
10808 int rc;
10809 dwarf_size_type header_size = 12;
10810
10811 /* Read the zlib header. In this case, it should be "ZLIB" followed
10812 by the uncompressed section size, 8 bytes in big-endian order. */
10813 if (compressed_size < header_size
10814 || ! streq ((char *) compressed_buffer, "ZLIB"))
10815 return 0;
10816
10817 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10818 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10819 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10820 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10821 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10822 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10823 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10824 uncompressed_size += compressed_buffer[11];
10825
10826 /* It is possible the section consists of several compressed
10827 buffers concatenated together, so we uncompress in a loop. */
10828 strm.zalloc = NULL;
10829 strm.zfree = NULL;
10830 strm.opaque = NULL;
10831 strm.avail_in = compressed_size - header_size;
10832 strm.next_in = (Bytef *) compressed_buffer + header_size;
10833 strm.avail_out = uncompressed_size;
3f5e193b 10834 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10835
10836 rc = inflateInit (& strm);
10837 while (strm.avail_in > 0)
10838 {
10839 if (rc != Z_OK)
10840 goto fail;
10841 strm.next_out = ((Bytef *) uncompressed_buffer
10842 + (uncompressed_size - strm.avail_out));
10843 rc = inflate (&strm, Z_FINISH);
10844 if (rc != Z_STREAM_END)
10845 goto fail;
10846 rc = inflateReset (& strm);
10847 }
10848 rc = inflateEnd (& strm);
10849 if (rc != Z_OK
10850 || strm.avail_out != 0)
10851 goto fail;
10852
10853 free (compressed_buffer);
10854 *buffer = uncompressed_buffer;
10855 *size = uncompressed_size;
10856 return 1;
10857
10858 fail:
10859 free (uncompressed_buffer);
4a114e3e
L		 10860 /* Indicate decompression failure. */
10861 *buffer = NULL;
cf13d699
NC		 10862 return 0;
10863#endif /* HAVE_ZLIB_H */
10864}
10865
d966045b
DJ		 10866static int
10867load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10868 Elf_Internal_Shdr * sec, void * file)
1007acb3 10869{
2cf0635d 10870 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10871 char buf [64];
1007acb3 10872
19e6b90e
L		 10873 /* If it is already loaded, do nothing. */
10874 if (section->start != NULL)
10875 return 1;
1007acb3 10876
19e6b90e
L		 10877 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10878 section->address = sec->sh_addr;
3f5e193b
NC		 10879 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10880 sec->sh_offset, 1,
10881 sec->sh_size, buf);
59245841
NC		 10882 if (section->start == NULL)
10883 section->size = 0;
10884 else
10885 {
10886 section->size = sec->sh_size;
10887 if (uncompress_section_contents (&section->start, &section->size))
10888 sec->sh_size = section->size;
10889 }
4a114e3e 10890
1b315056
CS		 10891 if (section->start == NULL)
10892 return 0;
10893
19e6b90e 10894 if (debug_displays [debug].relocate)
3f5e193b 10895 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10896
1b315056 10897 return 1;
1007acb3
L		 10898}
10899
657d0d47
CC		 10900/* If this is not NULL, load_debug_section will only look for sections
10901 within the list of sections given here. */
10902unsigned int *section_subset = NULL;
10903
d966045b 10904int
2cf0635d 10905load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10906{
2cf0635d
NC		 10907 struct dwarf_section * section = &debug_displays [debug].section;
10908 Elf_Internal_Shdr * sec;
d966045b
DJ		 10909
10910 /* Locate the debug section. */
657d0d47 10911 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 10912 if (sec != NULL)
10913 section->name = section->uncompressed_name;
10914 else
10915 {
657d0d47 10916 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 10917 if (sec != NULL)
10918 section->name = section->compressed_name;
10919 }
10920 if (sec == NULL)
10921 return 0;
10922
657d0d47
CC		 10923 /* If we're loading from a subset of sections, and we've loaded
10924 a section matching this name before, it's likely that it's a
10925 different one. */
10926 if (section_subset != NULL)
10927 free_debug_section (debug);
10928
3f5e193b 10929 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10930}
10931
19e6b90e
L		 10932void
10933free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10934{
2cf0635d 10935 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10936
19e6b90e
L		 10937 if (section->start == NULL)
10938 return;
1007acb3 10939
19e6b90e
L		 10940 free ((char *) section->start);
10941 section->start = NULL;
10942 section->address = 0;
10943 section->size = 0;
1007acb3
L		 10944}
10945
1007acb3 10946static int
657d0d47 10947display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 10948{
2cf0635d 10949 char * name = SECTION_NAME (section);
19e6b90e
L		 10950 bfd_size_type length;
10951 int result = 1;
3f5e193b 10952 int i;
1007acb3 10953
19e6b90e
L		 10954 length = section->sh_size;
10955 if (length == 0)
1007acb3 10956 {
19e6b90e
L		 10957 printf (_("\nSection '%s' has no debugging data.\n"), name);
10958 return 0;
1007acb3 10959 }
5dff79d8
NC		 10960 if (section->sh_type == SHT_NOBITS)
10961 {
10962 /* There is no point in dumping the contents of a debugging section
10963 which has the NOBITS type - the bits in the file will be random.
10964 This can happen when a file containing a .eh_frame section is
10965 stripped with the --only-keep-debug command line option. */
10966 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10967 return 0;
10968 }
1007acb3 10969
0112cd26 10970 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10971 name = ".debug_info";
1007acb3 10972
19e6b90e
L		 10973 /* See if we know how to display the contents of this section. */
10974 for (i = 0; i < max; i++)
1b315056 10975 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 10976 || (i == line && const_strneq (name, ".debug_line."))
1b315056 10977 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10978 {
2cf0635d 10979 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10980 int secondary = (section != find_section (name));
10981
10982 if (secondary)
3f5e193b 10983 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10984
b40bf0a2
NC		 10985 if (i == line && const_strneq (name, ".debug_line."))
10986 sec->name = name;
10987 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10988 sec->name = sec->uncompressed_name;
10989 else
10990 sec->name = sec->compressed_name;
3f5e193b
NC		 10991 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10992 section, file))
19e6b90e 10993 {
657d0d47
CC		 10994 /* If this debug section is part of a CU/TU set in a .dwp file,
10995 restrict load_debug_section to the sections in that set. */
10996 section_subset = find_cu_tu_set (file, shndx);
10997
19e6b90e 10998 result &= debug_displays[i].display (sec, file);
1007acb3 10999
657d0d47
CC		 11000 section_subset = NULL;
11001
d966045b 11002 if (secondary || (i != info && i != abbrev))
3f5e193b 11003 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 11004 }
1007acb3 11005
19e6b90e
L		 11006 break;
11007 }
1007acb3 11008
19e6b90e 11009 if (i == max)
1007acb3 11010 {
19e6b90e
L		 11011 printf (_("Unrecognized debug section: %s\n"), name);
11012 result = 0;
1007acb3
L		 11013 }
11014
19e6b90e 11015 return result;
5b18a4bc 11016}
103f02d3 11017
aef1f6d0
DJ		 11018/* Set DUMP_SECTS for all sections where dumps were requested
11019 based on section name. */
11020
11021static void
11022initialise_dumps_byname (void)
11023{
2cf0635d 11024 struct dump_list_entry * cur;
aef1f6d0
DJ		 11025
11026 for (cur = dump_sects_byname; cur; cur = cur->next)
11027 {
11028 unsigned int i;
11029 int any;
11030
11031 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11032 if (streq (SECTION_NAME (section_headers + i), cur->name))
11033 {
09c11c86 11034 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11035 any = 1;
11036 }
11037
11038 if (!any)
11039 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11040 cur->name);
11041 }
11042}
11043
5b18a4bc 11044static void
2cf0635d 11045process_section_contents (FILE * file)
5b18a4bc 11046{
2cf0635d 11047 Elf_Internal_Shdr * section;
19e6b90e 11048 unsigned int i;
103f02d3 11049
19e6b90e
L		 11050 if (! do_dump)
11051 return;
103f02d3 11052
aef1f6d0
DJ		 11053 initialise_dumps_byname ();
11054
19e6b90e
L		 11055 for (i = 0, section = section_headers;
11056 i < elf_header.e_shnum && i < num_dump_sects;
11057 i++, section++)
11058 {
11059#ifdef SUPPORT_DISASSEMBLY
11060 if (dump_sects[i] & DISASS_DUMP)
11061 disassemble_section (section, file);
11062#endif
11063 if (dump_sects[i] & HEX_DUMP)
cf13d699 11064 dump_section_as_bytes (section, file, FALSE);
103f02d3 11065
cf13d699
NC		 11066 if (dump_sects[i] & RELOC_DUMP)
11067 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11068
11069 if (dump_sects[i] & STRING_DUMP)
11070 dump_section_as_strings (section, file);
cf13d699
NC		 11071
11072 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11073 display_debug_section (i, section, file);
5b18a4bc 11074 }
103f02d3 11075
19e6b90e
L		 11076 /* Check to see if the user requested a
11077 dump of a section that does not exist. */
11078 while (i++ < num_dump_sects)
11079 if (dump_sects[i])
11080 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11081}
103f02d3 11082
5b18a4bc 11083static void
19e6b90e 11084process_mips_fpe_exception (int mask)
5b18a4bc 11085{
19e6b90e
L		 11086 if (mask)
11087 {
11088 int first = 1;
11089 if (mask & OEX_FPU_INEX)
11090 fputs ("INEX", stdout), first = 0;
11091 if (mask & OEX_FPU_UFLO)
11092 printf ("%sUFLO", first ? "" : "|"), first = 0;
11093 if (mask & OEX_FPU_OFLO)
11094 printf ("%sOFLO", first ? "" : "|"), first = 0;
11095 if (mask & OEX_FPU_DIV0)
11096 printf ("%sDIV0", first ? "" : "|"), first = 0;
11097 if (mask & OEX_FPU_INVAL)
11098 printf ("%sINVAL", first ? "" : "|");
11099 }
5b18a4bc 11100 else
19e6b90e 11101 fputs ("0", stdout);
5b18a4bc 11102}
103f02d3 11103
f6f0e17b
NC		 11104/* Display's the value of TAG at location P. If TAG is
11105 greater than 0 it is assumed to be an unknown tag, and
11106 a message is printed to this effect. Otherwise it is
11107 assumed that a message has already been printed.
11108
11109 If the bottom bit of TAG is set it assumed to have a
11110 string value, otherwise it is assumed to have an integer
11111 value.
11112
11113 Returns an updated P pointing to the first unread byte
11114 beyond the end of TAG's value.
11115
11116 Reads at or beyond END will not be made. */
11117
11118static unsigned char *
11119display_tag_value (int tag,
11120 unsigned char * p,
11121 const unsigned char * const end)
11122{
11123 unsigned long val;
11124
11125 if (tag > 0)
11126 printf (" Tag_unknown_%d: ", tag);
11127
11128 if (p >= end)
11129 {
11130 warn (_("corrupt tag\n"));
11131 }
11132 else if (tag & 1)
11133 {
11134 /* FIXME: we could read beyond END here. */
11135 printf ("\"%s\"\n", p);
11136 p += strlen ((char *) p) + 1;
11137 }
11138 else
11139 {
11140 unsigned int len;
11141
11142 val = read_uleb128 (p, &len, end);
11143 p += len;
11144 printf ("%ld (0x%lx)\n", val, val);
11145 }
11146
11147 return p;
11148}
11149
11c1ff18
PB		 11150/* ARM EABI attributes section. */
11151typedef struct
11152{
11153 int tag;
2cf0635d 11154 const char * name;
11c1ff18
PB		 11155 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11156 int type;
2cf0635d 11157 const char ** table;
11c1ff18
PB		 11158} arm_attr_public_tag;
11159
2cf0635d 11160static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11161 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11162 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11163static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11164static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11165 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11166static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 11167 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11168 "FP for ARMv8"};
2cf0635d 11169static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11170static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11171 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11172static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11173 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11174 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11175static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11176 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11177static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11178 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11179static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11180 {"Absolute", "PC-relative", "None"};
2cf0635d 11181static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11182 {"None", "direct", "GOT-indirect"};
2cf0635d 11183static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11184 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11185static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11186static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11187 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11188static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11189static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11190static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11191 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11192static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11193 {"Unused", "small", "int", "forced to int"};
2cf0635d 11194static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11195 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11196static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11197 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11198static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11199 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11200static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11201 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11202 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11203static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 11204 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11205 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11206static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11207static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11208 {"Not Allowed", "Allowed"};
2cf0635d 11209static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11210 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11211static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 11212 {"Not Allowed", "Allowed"};
11213static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11214 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11215 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 11216static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11217static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11218 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11219 "TrustZone and Virtualization Extensions"};
dd24e3da 11220static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11221 {"Not Allowed", "Allowed"};
11c1ff18
PB		 11222
11223#define LOOKUP(id, name) \
11224 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11225static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 11226{
11227 {4, "CPU_raw_name", 1, NULL},
11228 {5, "CPU_name", 1, NULL},
11229 LOOKUP(6, CPU_arch),
11230 {7, "CPU_arch_profile", 0, NULL},
11231 LOOKUP(8, ARM_ISA_use),
11232 LOOKUP(9, THUMB_ISA_use),
75375b3e 11233 LOOKUP(10, FP_arch),
11c1ff18 11234 LOOKUP(11, WMMX_arch),
f5f53991
AS		 11235 LOOKUP(12, Advanced_SIMD_arch),
11236 LOOKUP(13, PCS_config),
11c1ff18
PB		 11237 LOOKUP(14, ABI_PCS_R9_use),
11238 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11239 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 11240 LOOKUP(17, ABI_PCS_GOT_use),
11241 LOOKUP(18, ABI_PCS_wchar_t),
11242 LOOKUP(19, ABI_FP_rounding),
11243 LOOKUP(20, ABI_FP_denormal),
11244 LOOKUP(21, ABI_FP_exceptions),
11245 LOOKUP(22, ABI_FP_user_exceptions),
11246 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 11247 {24, "ABI_align_needed", 0, NULL},
11248 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 11249 LOOKUP(26, ABI_enum_size),
11250 LOOKUP(27, ABI_HardFP_use),
11251 LOOKUP(28, ABI_VFP_args),
11252 LOOKUP(29, ABI_WMMX_args),
11253 LOOKUP(30, ABI_optimization_goals),
11254 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11255 {32, "compatibility", 0, NULL},
f5f53991 11256 LOOKUP(34, CPU_unaligned_access),
75375b3e 11257 LOOKUP(36, FP_HP_extension),
8e79c3df 11258 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 11259 LOOKUP(42, MPextension_use),
11260 LOOKUP(44, DIV_use),
f5f53991
AS		 11261 {64, "nodefaults", 0, NULL},
11262 {65, "also_compatible_with", 0, NULL},
11263 LOOKUP(66, T2EE_use),
11264 {67, "conformance", 1, NULL},
11265 LOOKUP(68, Virtualization_use),
cd21e546 11266 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 11267};
11268#undef LOOKUP
11269
11c1ff18 11270static unsigned char *
f6f0e17b
NC		 11271display_arm_attribute (unsigned char * p,
11272 const unsigned char * const end)
11c1ff18
PB		 11273{
11274 int tag;
11275 unsigned int len;
11276 int val;
2cf0635d 11277 arm_attr_public_tag * attr;
11c1ff18
PB		 11278 unsigned i;
11279 int type;
11280
f6f0e17b 11281 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 11282 p += len;
11283 attr = NULL;
2cf0635d 11284 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 11285 {
11286 if (arm_attr_public_tags[i].tag == tag)
11287 {
11288 attr = &arm_attr_public_tags[i];
11289 break;
11290 }
11291 }
11292
11293 if (attr)
11294 {
11295 printf (" Tag_%s: ", attr->name);
11296 switch (attr->type)
11297 {
11298 case 0:
11299 switch (tag)
11300 {
11301 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 11302 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11303 p += len;
11304 switch (val)
11305 {
2b692964
NC		 11306 case 0: printf (_("None\n")); break;
11307 case 'A': printf (_("Application\n")); break;
11308 case 'R': printf (_("Realtime\n")); break;
11309 case 'M': printf (_("Microcontroller\n")); break;
11310 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11311 default: printf ("??? (%d)\n", val); break;
11312 }
11313 break;
11314
75375b3e 11315 case 24: /* Tag_align_needed. */
f6f0e17b 11316 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11317 p += len;
11318 switch (val)
11319 {
2b692964
NC		 11320 case 0: printf (_("None\n")); break;
11321 case 1: printf (_("8-byte\n")); break;
11322 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11323 case 3: printf ("??? 3\n"); break;
11324 default:
11325 if (val <= 12)
dd24e3da 11326 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11327 1 << val);
11328 else
11329 printf ("??? (%d)\n", val);
11330 break;
11331 }
11332 break;
11333
11334 case 25: /* Tag_align_preserved. */
f6f0e17b 11335 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11336 p += len;
11337 switch (val)
11338 {
2b692964
NC		 11339 case 0: printf (_("None\n")); break;
11340 case 1: printf (_("8-byte, except leaf SP\n")); break;
11341 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11342 case 3: printf ("??? 3\n"); break;
11343 default:
11344 if (val <= 12)
dd24e3da 11345 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11346 1 << val);
11347 else
11348 printf ("??? (%d)\n", val);
11349 break;
11350 }
11351 break;
11352
11c1ff18 11353 case 32: /* Tag_compatibility. */
f6f0e17b 11354 val = read_uleb128 (p, &len, end);
11c1ff18 11355 p += len;
2b692964 11356 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11357 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11358 break;
11359
f5f53991
AS		 11360 case 64: /* Tag_nodefaults. */
11361 p++;
2b692964 11362 printf (_("True\n"));
f5f53991
AS		 11363 break;
11364
11365 case 65: /* Tag_also_compatible_with. */
f6f0e17b 11366 val = read_uleb128 (p, &len, end);
f5f53991
AS		 11367 p += len;
11368 if (val == 6 /* Tag_CPU_arch. */)
11369 {
f6f0e17b 11370 val = read_uleb128 (p, &len, end);
f5f53991 11371 p += len;
2cf0635d 11372 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11373 printf ("??? (%d)\n", val);
11374 else
11375 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11376 }
11377 else
11378 printf ("???\n");
11379 while (*(p++) != '\0' /* NUL terminator. */);
11380 break;
11381
11c1ff18 11382 default:
2cf0635d 11383 abort ();
11c1ff18
PB		 11384 }
11385 return p;
11386
11387 case 1:
f6f0e17b 11388 return display_tag_value (-1, p, end);
11c1ff18 11389 case 2:
f6f0e17b 11390 return display_tag_value (0, p, end);
11c1ff18
PB		 11391
11392 default:
11393 assert (attr->type & 0x80);
f6f0e17b 11394 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11395 p += len;
11396 type = attr->type & 0x7f;
11397 if (val >= type)
11398 printf ("??? (%d)\n", val);
11399 else
11400 printf ("%s\n", attr->table[val]);
11401 return p;
11402 }
11403 }
11c1ff18 11404
f6f0e17b 11405 return display_tag_value (tag, p, end);
11c1ff18
PB		 11406}
11407
104d59d1 11408static unsigned char *
60bca95a 11409display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 11410 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11411 const unsigned char * const end)
104d59d1
JM		 11412{
11413 int tag;
11414 unsigned int len;
11415 int val;
104d59d1 11416
f6f0e17b 11417 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 11418 p += len;
11419
11420 /* Tag_compatibility is the only generic GNU attribute defined at
11421 present. */
11422 if (tag == 32)
11423 {
f6f0e17b 11424 val = read_uleb128 (p, &len, end);
104d59d1 11425 p += len;
f6f0e17b
NC		 11426 if (p == end)
11427 {
11428 printf (_("flag = %d, vendor = <corrupt>\n"), val);
11429 warn (_("corrupt vendor attribute\n"));
11430 }
11431 else
11432 {
11433 printf (_("flag = %d, vendor = %s\n"), val, p);
11434 p += strlen ((char *) p) + 1;
11435 }
104d59d1
JM		 11436 return p;
11437 }
11438
11439 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 11440 return display_proc_gnu_attribute (p, tag, end);
104d59d1 11441
f6f0e17b 11442 return display_tag_value (tag, p, end);
104d59d1
JM		 11443}
11444
34c8bcba 11445static unsigned char *
f6f0e17b
NC		 11446display_power_gnu_attribute (unsigned char * p,
11447 int tag,
11448 const unsigned char * const end)
34c8bcba 11449{
34c8bcba
JM		 11450 unsigned int len;
11451 int val;
11452
11453 if (tag == Tag_GNU_Power_ABI_FP)
11454 {
f6f0e17b 11455 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 11456 p += len;
11457 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11458
34c8bcba
JM		 11459 switch (val)
11460 {
11461 case 0:
2b692964 11462 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11463 break;
11464 case 1:
2b692964 11465 printf (_("Hard float\n"));
34c8bcba
JM		 11466 break;
11467 case 2:
2b692964 11468 printf (_("Soft float\n"));
34c8bcba 11469 break;
3c7b9897 11470 case 3:
2b692964 11471 printf (_("Single-precision hard float\n"));
3c7b9897 11472 break;
34c8bcba
JM		 11473 default:
11474 printf ("??? (%d)\n", val);
11475 break;
11476 }
11477 return p;
11478 }
11479
c6e65352
DJ		 11480 if (tag == Tag_GNU_Power_ABI_Vector)
11481 {
f6f0e17b 11482 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 11483 p += len;
11484 printf (" Tag_GNU_Power_ABI_Vector: ");
11485 switch (val)
11486 {
11487 case 0:
2b692964 11488 printf (_("Any\n"));
c6e65352
DJ		 11489 break;
11490 case 1:
2b692964 11491 printf (_("Generic\n"));
c6e65352
DJ		 11492 break;
11493 case 2:
11494 printf ("AltiVec\n");
11495 break;
11496 case 3:
11497 printf ("SPE\n");
11498 break;
11499 default:
11500 printf ("??? (%d)\n", val);
11501 break;
11502 }
11503 return p;
11504 }
11505
f82e0623
NF		 11506 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11507 {
f6f0e17b
NC		 11508 if (p == end)
11509 {
11510 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11511 return p;
11512 }
11513
11514 val = read_uleb128 (p, &len, end);
f82e0623
NF		 11515 p += len;
11516 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11517 switch (val)
11518 {
11519 case 0:
2b692964 11520 printf (_("Any\n"));
f82e0623
NF		 11521 break;
11522 case 1:
11523 printf ("r3/r4\n");
11524 break;
11525 case 2:
2b692964 11526 printf (_("Memory\n"));
f82e0623
NF		 11527 break;
11528 default:
11529 printf ("??? (%d)\n", val);
11530 break;
11531 }
11532 return p;
11533 }
11534
f6f0e17b 11535 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 11536}
11537
9e8c70f9
DM		 11538static void
11539display_sparc_hwcaps (int mask)
11540{
11541 if (mask)
11542 {
11543 int first = 1;
11544 if (mask & ELF_SPARC_HWCAP_MUL32)
11545 fputs ("mul32", stdout), first = 0;
11546 if (mask & ELF_SPARC_HWCAP_DIV32)
11547 printf ("%sdiv32", first ? "" : "|"), first = 0;
11548 if (mask & ELF_SPARC_HWCAP_FSMULD)
11549 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11550 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11551 printf ("%sv8plus", first ? "" : "|"), first = 0;
11552 if (mask & ELF_SPARC_HWCAP_POPC)
11553 printf ("%spopc", first ? "" : "|"), first = 0;
11554 if (mask & ELF_SPARC_HWCAP_VIS)
11555 printf ("%svis", first ? "" : "|"), first = 0;
11556 if (mask & ELF_SPARC_HWCAP_VIS2)
11557 printf ("%svis2", first ? "" : "|"), first = 0;
11558 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11559 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11560 if (mask & ELF_SPARC_HWCAP_FMAF)
11561 printf ("%sfmaf", first ? "" : "|"), first = 0;
11562 if (mask & ELF_SPARC_HWCAP_VIS3)
11563 printf ("%svis3", first ? "" : "|"), first = 0;
11564 if (mask & ELF_SPARC_HWCAP_HPC)
11565 printf ("%shpc", first ? "" : "|"), first = 0;
11566 if (mask & ELF_SPARC_HWCAP_RANDOM)
11567 printf ("%srandom", first ? "" : "|"), first = 0;
11568 if (mask & ELF_SPARC_HWCAP_TRANS)
11569 printf ("%strans", first ? "" : "|"), first = 0;
11570 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11571 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11572 if (mask & ELF_SPARC_HWCAP_IMA)
11573 printf ("%sima", first ? "" : "|"), first = 0;
11574 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11575 printf ("%scspare", first ? "" : "|"), first = 0;
11576 }
11577 else
11578 fputc('0', stdout);
11579 fputc('\n', stdout);
11580}
11581
11582static unsigned char *
f6f0e17b
NC		 11583display_sparc_gnu_attribute (unsigned char * p,
11584 int tag,
11585 const unsigned char * const end)
9e8c70f9 11586{
9e8c70f9
DM		 11587 if (tag == Tag_GNU_Sparc_HWCAPS)
11588 {
f6f0e17b
NC		 11589 unsigned int len;
11590 int val;
11591
11592 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 11593 p += len;
11594 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 11595 display_sparc_hwcaps (val);
11596 return p;
11597 }
11598
f6f0e17b 11599 return display_tag_value (tag, p, end);
9e8c70f9
DM		 11600}
11601
2cf19d5c 11602static unsigned char *
f6f0e17b
NC		 11603display_mips_gnu_attribute (unsigned char * p,
11604 int tag,
11605 const unsigned char * const end)
2cf19d5c 11606{
2cf19d5c
JM		 11607 if (tag == Tag_GNU_MIPS_ABI_FP)
11608 {
f6f0e17b
NC		 11609 unsigned int len;
11610 int val;
11611
11612 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 11613 p += len;
11614 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11615
2cf19d5c
JM		 11616 switch (val)
11617 {
11618 case 0:
2b692964 11619 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11620 break;
11621 case 1:
2b692964 11622 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11623 break;
11624 case 2:
2b692964 11625 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11626 break;
11627 case 3:
2b692964 11628 printf (_("Soft float\n"));
2cf19d5c 11629 break;
42554f6a 11630 case 4:
9eeefea8 11631 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11632 break;
2cf19d5c
JM		 11633 default:
11634 printf ("??? (%d)\n", val);
11635 break;
11636 }
11637 return p;
11638 }
11639
f6f0e17b 11640 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 11641}
11642
59e6276b 11643static unsigned char *
f6f0e17b
NC		 11644display_tic6x_attribute (unsigned char * p,
11645 const unsigned char * const end)
59e6276b
JM		 11646{
11647 int tag;
11648 unsigned int len;
11649 int val;
11650
f6f0e17b 11651 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 11652 p += len;
11653
11654 switch (tag)
11655 {
75fa6dc1 11656 case Tag_ISA:
f6f0e17b 11657 val = read_uleb128 (p, &len, end);
59e6276b 11658 p += len;
75fa6dc1 11659 printf (" Tag_ISA: ");
59e6276b
JM		 11660
11661 switch (val)
11662 {
75fa6dc1 11663 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11664 printf (_("None\n"));
11665 break;
75fa6dc1 11666 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11667 printf ("C62x\n");
11668 break;
75fa6dc1 11669 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11670 printf ("C67x\n");
11671 break;
75fa6dc1 11672 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11673 printf ("C67x+\n");
11674 break;
75fa6dc1 11675 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11676 printf ("C64x\n");
11677 break;
75fa6dc1 11678 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11679 printf ("C64x+\n");
11680 break;
75fa6dc1 11681 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11682 printf ("C674x\n");
11683 break;
11684 default:
11685 printf ("??? (%d)\n", val);
11686 break;
11687 }
11688 return p;
11689
87779176 11690 case Tag_ABI_wchar_t:
f6f0e17b 11691 val = read_uleb128 (p, &len, end);
87779176
JM		 11692 p += len;
11693 printf (" Tag_ABI_wchar_t: ");
11694 switch (val)
11695 {
11696 case 0:
11697 printf (_("Not used\n"));
11698 break;
11699 case 1:
11700 printf (_("2 bytes\n"));
11701 break;
11702 case 2:
11703 printf (_("4 bytes\n"));
11704 break;
11705 default:
11706 printf ("??? (%d)\n", val);
11707 break;
11708 }
11709 return p;
11710
11711 case Tag_ABI_stack_align_needed:
f6f0e17b 11712 val = read_uleb128 (p, &len, end);
87779176
JM		 11713 p += len;
11714 printf (" Tag_ABI_stack_align_needed: ");
11715 switch (val)
11716 {
11717 case 0:
11718 printf (_("8-byte\n"));
11719 break;
11720 case 1:
11721 printf (_("16-byte\n"));
11722 break;
11723 default:
11724 printf ("??? (%d)\n", val);
11725 break;
11726 }
11727 return p;
11728
11729 case Tag_ABI_stack_align_preserved:
f6f0e17b 11730 val = read_uleb128 (p, &len, end);
87779176
JM		 11731 p += len;
11732 printf (" Tag_ABI_stack_align_preserved: ");
11733 switch (val)
11734 {
11735 case 0:
11736 printf (_("8-byte\n"));
11737 break;
11738 case 1:
11739 printf (_("16-byte\n"));
11740 break;
11741 default:
11742 printf ("??? (%d)\n", val);
11743 break;
11744 }
11745 return p;
11746
b5593623 11747 case Tag_ABI_DSBT:
f6f0e17b 11748 val = read_uleb128 (p, &len, end);
b5593623
JM		 11749 p += len;
11750 printf (" Tag_ABI_DSBT: ");
11751 switch (val)
11752 {
11753 case 0:
11754 printf (_("DSBT addressing not used\n"));
11755 break;
11756 case 1:
11757 printf (_("DSBT addressing used\n"));
11758 break;
11759 default:
11760 printf ("??? (%d)\n", val);
11761 break;
11762 }
11763 return p;
11764
87779176 11765 case Tag_ABI_PID:
f6f0e17b 11766 val = read_uleb128 (p, &len, end);
87779176
JM		 11767 p += len;
11768 printf (" Tag_ABI_PID: ");
11769 switch (val)
11770 {
11771 case 0:
11772 printf (_("Data addressing position-dependent\n"));
11773 break;
11774 case 1:
11775 printf (_("Data addressing position-independent, GOT near DP\n"));
11776 break;
11777 case 2:
11778 printf (_("Data addressing position-independent, GOT far from DP\n"));
11779 break;
11780 default:
11781 printf ("??? (%d)\n", val);
11782 break;
11783 }
11784 return p;
11785
11786 case Tag_ABI_PIC:
f6f0e17b 11787 val = read_uleb128 (p, &len, end);
87779176
JM		 11788 p += len;
11789 printf (" Tag_ABI_PIC: ");
11790 switch (val)
11791 {
11792 case 0:
11793 printf (_("Code addressing position-dependent\n"));
11794 break;
11795 case 1:
11796 printf (_("Code addressing position-independent\n"));
11797 break;
11798 default:
11799 printf ("??? (%d)\n", val);
11800 break;
11801 }
11802 return p;
11803
11804 case Tag_ABI_array_object_alignment:
f6f0e17b 11805 val = read_uleb128 (p, &len, end);
87779176
JM		 11806 p += len;
11807 printf (" Tag_ABI_array_object_alignment: ");
11808 switch (val)
11809 {
11810 case 0:
11811 printf (_("8-byte\n"));
11812 break;
11813 case 1:
11814 printf (_("4-byte\n"));
11815 break;
11816 case 2:
11817 printf (_("16-byte\n"));
11818 break;
11819 default:
11820 printf ("??? (%d)\n", val);
11821 break;
11822 }
11823 return p;
11824
11825 case Tag_ABI_array_object_align_expected:
f6f0e17b 11826 val = read_uleb128 (p, &len, end);
87779176
JM		 11827 p += len;
11828 printf (" Tag_ABI_array_object_align_expected: ");
11829 switch (val)
11830 {
11831 case 0:
11832 printf (_("8-byte\n"));
11833 break;
11834 case 1:
11835 printf (_("4-byte\n"));
11836 break;
11837 case 2:
11838 printf (_("16-byte\n"));
11839 break;
11840 default:
11841 printf ("??? (%d)\n", val);
11842 break;
11843 }
11844 return p;
11845
3cbd1c06 11846 case Tag_ABI_compatibility:
f6f0e17b 11847 val = read_uleb128 (p, &len, end);
59e6276b 11848 p += len;
3cbd1c06 11849 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11850 printf (_("flag = %d, vendor = %s\n"), val, p);
11851 p += strlen ((char *) p) + 1;
11852 return p;
87779176
JM		 11853
11854 case Tag_ABI_conformance:
11855 printf (" Tag_ABI_conformance: ");
11856 printf ("\"%s\"\n", p);
11857 p += strlen ((char *) p) + 1;
11858 return p;
59e6276b
JM		 11859 }
11860
f6f0e17b
NC		 11861 return display_tag_value (tag, p, end);
11862}
59e6276b 11863
f6f0e17b
NC		 11864static void
11865display_raw_attribute (unsigned char * p, unsigned char * end)
11866{
11867 unsigned long addr = 0;
11868 size_t bytes = end - p;
11869
11870 while (bytes)
87779176 11871 {
f6f0e17b
NC		 11872 int j;
11873 int k;
11874 int lbytes = (bytes > 16 ? 16 : bytes);
11875
11876 printf (" 0x%8.8lx ", addr);
11877
11878 for (j = 0; j < 16; j++)
11879 {
11880 if (j < lbytes)
11881 printf ("%2.2x", p[j]);
11882 else
11883 printf (" ");
11884
11885 if ((j & 3) == 3)
11886 printf (" ");
11887 }
11888
11889 for (j = 0; j < lbytes; j++)
11890 {
11891 k = p[j];
11892 if (k >= ' ' && k < 0x7f)
11893 printf ("%c", k);
11894 else
11895 printf (".");
11896 }
11897
11898 putchar ('\n');
11899
11900 p += lbytes;
11901 bytes -= lbytes;
11902 addr += lbytes;
87779176 11903 }
59e6276b 11904
f6f0e17b 11905 putchar ('\n');
59e6276b
JM		 11906}
11907
11c1ff18 11908static int
60bca95a
NC		 11909process_attributes (FILE * file,
11910 const char * public_name,
104d59d1 11911 unsigned int proc_type,
f6f0e17b
NC		 11912 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
11913 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 11914{
2cf0635d
NC		 11915 Elf_Internal_Shdr * sect;
11916 unsigned char * contents;
11917 unsigned char * p;
11918 unsigned char * end;
11c1ff18
PB		 11919 bfd_vma section_len;
11920 bfd_vma len;
11921 unsigned i;
11922
11923 /* Find the section header so that we get the size. */
11924 for (i = 0, sect = section_headers;
11925 i < elf_header.e_shnum;
11926 i++, sect++)
11927 {
104d59d1 11928 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11929 continue;
11930
3f5e193b
NC		 11931 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11932 sect->sh_size, _("attributes"));
60bca95a 11933 if (contents == NULL)
11c1ff18 11934 continue;
60bca95a 11935
11c1ff18
PB		 11936 p = contents;
11937 if (*p == 'A')
11938 {
11939 len = sect->sh_size - 1;
11940 p++;
60bca95a 11941
11c1ff18
PB		 11942 while (len > 0)
11943 {
11944 int namelen;
11945 bfd_boolean public_section;
104d59d1 11946 bfd_boolean gnu_section;
11c1ff18
PB		 11947
11948 section_len = byte_get (p, 4);
11949 p += 4;
60bca95a 11950
11c1ff18
PB		 11951 if (section_len > len)
11952 {
11953 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11954 (int) section_len, (int) len);
11c1ff18
PB		 11955 section_len = len;
11956 }
60bca95a 11957
11c1ff18 11958 len -= section_len;
2b692964 11959 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11960
11961 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11962 public_section = TRUE;
11963 else
11964 public_section = FALSE;
60bca95a
NC		 11965
11966 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11967 gnu_section = TRUE;
11968 else
11969 gnu_section = FALSE;
60bca95a
NC		 11970
11971 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11972 p += namelen;
11973 section_len -= namelen + 4;
60bca95a 11974
11c1ff18
PB		 11975 while (section_len > 0)
11976 {
11977 int tag = *(p++);
11978 int val;
11979 bfd_vma size;
60bca95a 11980
11c1ff18
PB		 11981 size = byte_get (p, 4);
11982 if (size > section_len)
11983 {
11984 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11985 (int) size, (int) section_len);
11c1ff18
PB		 11986 size = section_len;
11987 }
60bca95a 11988
11c1ff18
PB		 11989 section_len -= size;
11990 end = p + size - 1;
11991 p += 4;
60bca95a 11992
11c1ff18
PB		 11993 switch (tag)
11994 {
11995 case 1:
2b692964 11996 printf (_("File Attributes\n"));
11c1ff18
PB		 11997 break;
11998 case 2:
2b692964 11999 printf (_("Section Attributes:"));
11c1ff18
PB		 12000 goto do_numlist;
12001 case 3:
2b692964 12002 printf (_("Symbol Attributes:"));
11c1ff18
PB		 12003 do_numlist:
12004 for (;;)
12005 {
91d6fa6a 12006 unsigned int j;
60bca95a 12007
f6f0e17b 12008 val = read_uleb128 (p, &j, end);
91d6fa6a 12009 p += j;
11c1ff18
PB		 12010 if (val == 0)
12011 break;
12012 printf (" %d", val);
12013 }
12014 printf ("\n");
12015 break;
12016 default:
2b692964 12017 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 12018 public_section = FALSE;
12019 break;
12020 }
60bca95a 12021
11c1ff18
PB		 12022 if (public_section)
12023 {
12024 while (p < end)
f6f0e17b 12025 p = display_pub_attribute (p, end);
104d59d1
JM		 12026 }
12027 else if (gnu_section)
12028 {
12029 while (p < end)
12030 p = display_gnu_attribute (p,
f6f0e17b
NC		 12031 display_proc_gnu_attribute,
12032 end);
11c1ff18
PB		 12033 }
12034 else
12035 {
2b692964 12036 printf (_(" Unknown section contexts\n"));
f6f0e17b 12037 display_raw_attribute (p, end);
11c1ff18
PB		 12038 p = end;
12039 }
12040 }
12041 }
12042 }
12043 else
60bca95a 12044 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 12045
60bca95a 12046 free (contents);
11c1ff18
PB		 12047 }
12048 return 1;
12049}
12050
104d59d1 12051static int
2cf0635d 12052process_arm_specific (FILE * file)
104d59d1
JM		 12053{
12054 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12055 display_arm_attribute, NULL);
12056}
12057
34c8bcba 12058static int
2cf0635d 12059process_power_specific (FILE * file)
34c8bcba
JM		 12060{
12061 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12062 display_power_gnu_attribute);
12063}
12064
9e8c70f9
DM		 12065static int
12066process_sparc_specific (FILE * file)
12067{
12068 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12069 display_sparc_gnu_attribute);
12070}
12071
59e6276b
JM		 12072static int
12073process_tic6x_specific (FILE * file)
12074{
12075 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12076 display_tic6x_attribute, NULL);
12077}
12078
ccb4c951
RS		 12079/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12080 Print the Address, Access and Initial fields of an entry at VMA ADDR
12081 and return the VMA of the next entry. */
12082
12083static bfd_vma
2cf0635d 12084print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 12085{
12086 printf (" ");
12087 print_vma (addr, LONG_HEX);
12088 printf (" ");
12089 if (addr < pltgot + 0xfff0)
12090 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12091 else
12092 printf ("%10s", "");
12093 printf (" ");
12094 if (data == NULL)
2b692964 12095 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 12096 else
12097 {
12098 bfd_vma entry;
12099
12100 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12101 print_vma (entry, LONG_HEX);
12102 }
12103 return addr + (is_32bit_elf ? 4 : 8);
12104}
12105
861fb55a
DJ		 12106/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12107 PLTGOT. Print the Address and Initial fields of an entry at VMA
12108 ADDR and return the VMA of the next entry. */
12109
12110static bfd_vma
2cf0635d 12111print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 12112{
12113 printf (" ");
12114 print_vma (addr, LONG_HEX);
12115 printf (" ");
12116 if (data == NULL)
2b692964 12117 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 12118 else
12119 {
12120 bfd_vma entry;
12121
12122 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12123 print_vma (entry, LONG_HEX);
12124 }
12125 return addr + (is_32bit_elf ? 4 : 8);
12126}
12127
19e6b90e 12128static int
2cf0635d 12129process_mips_specific (FILE * file)
5b18a4bc 12130{
2cf0635d 12131 Elf_Internal_Dyn * entry;
19e6b90e
L		 12132 size_t liblist_offset = 0;
12133 size_t liblistno = 0;
12134 size_t conflictsno = 0;
12135 size_t options_offset = 0;
12136 size_t conflicts_offset = 0;
861fb55a
DJ		 12137 size_t pltrelsz = 0;
12138 size_t pltrel = 0;
ccb4c951 12139 bfd_vma pltgot = 0;
861fb55a
DJ		 12140 bfd_vma mips_pltgot = 0;
12141 bfd_vma jmprel = 0;
ccb4c951
RS		 12142 bfd_vma local_gotno = 0;
12143 bfd_vma gotsym = 0;
12144 bfd_vma symtabno = 0;
103f02d3 12145
2cf19d5c
JM		 12146 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12147 display_mips_gnu_attribute);
12148
19e6b90e
L		 12149 /* We have a lot of special sections. Thanks SGI! */
12150 if (dynamic_section == NULL)
12151 /* No information available. */
12152 return 0;
252b5132 12153
b2d38a17 12154 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 12155 switch (entry->d_tag)
12156 {
12157 case DT_MIPS_LIBLIST:
d93f0186
NC		 12158 liblist_offset
12159 = offset_from_vma (file, entry->d_un.d_val,
12160 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 12161 break;
12162 case DT_MIPS_LIBLISTNO:
12163 liblistno = entry->d_un.d_val;
12164 break;
12165 case DT_MIPS_OPTIONS:
d93f0186 12166 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 12167 break;
12168 case DT_MIPS_CONFLICT:
d93f0186
NC		 12169 conflicts_offset
12170 = offset_from_vma (file, entry->d_un.d_val,
12171 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 12172 break;
12173 case DT_MIPS_CONFLICTNO:
12174 conflictsno = entry->d_un.d_val;
12175 break;
ccb4c951 12176 case DT_PLTGOT:
861fb55a
DJ		 12177 pltgot = entry->d_un.d_ptr;
12178 break;
ccb4c951
RS		 12179 case DT_MIPS_LOCAL_GOTNO:
12180 local_gotno = entry->d_un.d_val;
12181 break;
12182 case DT_MIPS_GOTSYM:
12183 gotsym = entry->d_un.d_val;
12184 break;
12185 case DT_MIPS_SYMTABNO:
12186 symtabno = entry->d_un.d_val;
12187 break;
861fb55a
DJ		 12188 case DT_MIPS_PLTGOT:
12189 mips_pltgot = entry->d_un.d_ptr;
12190 break;
12191 case DT_PLTREL:
12192 pltrel = entry->d_un.d_val;
12193 break;
12194 case DT_PLTRELSZ:
12195 pltrelsz = entry->d_un.d_val;
12196 break;
12197 case DT_JMPREL:
12198 jmprel = entry->d_un.d_ptr;
12199 break;
252b5132
RH		 12200 default:
12201 break;
12202 }
12203
12204 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12205 {
2cf0635d 12206 Elf32_External_Lib * elib;
252b5132
RH		 12207 size_t cnt;
12208
3f5e193b
NC		 12209 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12210 liblistno,
12211 sizeof (Elf32_External_Lib),
9cf03b7e 12212 _("liblist section data"));
a6e9f9df 12213 if (elib)
252b5132 12214 {
2b692964 12215 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 12216 (unsigned long) liblistno);
2b692964 12217 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 12218 stdout);
12219
12220 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 12221 {
a6e9f9df 12222 Elf32_Lib liblist;
91d6fa6a 12223 time_t atime;
a6e9f9df 12224 char timebuf[20];
2cf0635d 12225 struct tm * tmp;
a6e9f9df
AM		 12226
12227 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12228 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 12229 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12230 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12231 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12232
91d6fa6a 12233 tmp = gmtime (&atime);
e9e44622
JJ		 12234 snprintf (timebuf, sizeof (timebuf),
12235 "%04u-%02u-%02uT%02u:%02u:%02u",
12236 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12237 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 12238
31104126 12239 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 12240 if (VALID_DYNAMIC_NAME (liblist.l_name))
12241 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12242 else
2b692964 12243 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 12244 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12245 liblist.l_version);
a6e9f9df
AM		 12246
12247 if (liblist.l_flags == 0)
2b692964 12248 puts (_(" NONE"));
a6e9f9df
AM		 12249 else
12250 {
12251 static const struct
252b5132 12252 {
2cf0635d 12253 const char * name;
a6e9f9df 12254 int bit;
252b5132 12255 }
a6e9f9df
AM		 12256 l_flags_vals[] =
12257 {
12258 { " EXACT_MATCH", LL_EXACT_MATCH },
12259 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12260 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12261 { " EXPORTS", LL_EXPORTS },
12262 { " DELAY_LOAD", LL_DELAY_LOAD },
12263 { " DELTA", LL_DELTA }
12264 };
12265 int flags = liblist.l_flags;
12266 size_t fcnt;
12267
60bca95a 12268 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12269 if ((flags & l_flags_vals[fcnt].bit) != 0)
12270 {
12271 fputs (l_flags_vals[fcnt].name, stdout);
12272 flags ^= l_flags_vals[fcnt].bit;
12273 }
12274 if (flags != 0)
12275 printf (" %#x", (unsigned int) flags);
252b5132 12276
a6e9f9df
AM		 12277 puts ("");
12278 }
252b5132 12279 }
252b5132 12280
a6e9f9df
AM		 12281 free (elib);
12282 }
252b5132
RH		 12283 }
12284
12285 if (options_offset != 0)
12286 {
2cf0635d
NC		 12287 Elf_External_Options * eopt;
12288 Elf_Internal_Shdr * sect = section_headers;
12289 Elf_Internal_Options * iopt;
12290 Elf_Internal_Options * option;
252b5132
RH		 12291 size_t offset;
12292 int cnt;
12293
12294 /* Find the section header so that we get the size. */
12295 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12296 ++sect;
252b5132 12297
3f5e193b
NC		 12298 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12299 sect->sh_size, _("options"));
a6e9f9df 12300 if (eopt)
252b5132 12301 {
3f5e193b
NC		 12302 iopt = (Elf_Internal_Options *)
12303 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 12304 if (iopt == NULL)
12305 {
591a748a 12306 error (_("Out of memory\n"));
a6e9f9df
AM		 12307 return 0;
12308 }
76da6bbe 12309
a6e9f9df
AM		 12310 offset = cnt = 0;
12311 option = iopt;
252b5132 12312
a6e9f9df
AM		 12313 while (offset < sect->sh_size)
12314 {
2cf0635d 12315 Elf_External_Options * eoption;
252b5132 12316
a6e9f9df 12317 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12318
a6e9f9df
AM		 12319 option->kind = BYTE_GET (eoption->kind);
12320 option->size = BYTE_GET (eoption->size);
12321 option->section = BYTE_GET (eoption->section);
12322 option->info = BYTE_GET (eoption->info);
76da6bbe 12323
a6e9f9df 12324 offset += option->size;
252b5132 12325
a6e9f9df
AM		 12326 ++option;
12327 ++cnt;
12328 }
252b5132 12329
a6e9f9df
AM		 12330 printf (_("\nSection '%s' contains %d entries:\n"),
12331 SECTION_NAME (sect), cnt);
76da6bbe 12332
a6e9f9df 12333 option = iopt;
252b5132 12334
a6e9f9df 12335 while (cnt-- > 0)
252b5132 12336 {
a6e9f9df
AM		 12337 size_t len;
12338
12339 switch (option->kind)
252b5132 12340 {
a6e9f9df
AM		 12341 case ODK_NULL:
12342 /* This shouldn't happen. */
12343 printf (" NULL %d %lx", option->section, option->info);
12344 break;
12345 case ODK_REGINFO:
12346 printf (" REGINFO ");
12347 if (elf_header.e_machine == EM_MIPS)
12348 {
12349 /* 32bit form. */
2cf0635d 12350 Elf32_External_RegInfo * ereg;
b34976b6 12351 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12352
12353 ereg = (Elf32_External_RegInfo *) (option + 1);
12354 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12355 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12356 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12357 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12358 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12359 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12360
12361 printf ("GPR %08lx GP 0x%lx\n",
12362 reginfo.ri_gprmask,
12363 (unsigned long) reginfo.ri_gp_value);
12364 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12365 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12366 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12367 }
12368 else
12369 {
12370 /* 64 bit form. */
2cf0635d 12371 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12372 Elf64_Internal_RegInfo reginfo;
12373
12374 ereg = (Elf64_External_RegInfo *) (option + 1);
12375 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12376 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12377 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12378 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12379 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12380 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12381
12382 printf ("GPR %08lx GP 0x",
12383 reginfo.ri_gprmask);
12384 printf_vma (reginfo.ri_gp_value);
12385 printf ("\n");
12386
12387 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12388 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12389 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12390 }
12391 ++option;
12392 continue;
12393 case ODK_EXCEPTIONS:
12394 fputs (" EXCEPTIONS fpe_min(", stdout);
12395 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12396 fputs (") fpe_max(", stdout);
12397 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12398 fputs (")", stdout);
12399
12400 if (option->info & OEX_PAGE0)
12401 fputs (" PAGE0", stdout);
12402 if (option->info & OEX_SMM)
12403 fputs (" SMM", stdout);
12404 if (option->info & OEX_FPDBUG)
12405 fputs (" FPDBUG", stdout);
12406 if (option->info & OEX_DISMISS)
12407 fputs (" DISMISS", stdout);
12408 break;
12409 case ODK_PAD:
12410 fputs (" PAD ", stdout);
12411 if (option->info & OPAD_PREFIX)
12412 fputs (" PREFIX", stdout);
12413 if (option->info & OPAD_POSTFIX)
12414 fputs (" POSTFIX", stdout);
12415 if (option->info & OPAD_SYMBOL)
12416 fputs (" SYMBOL", stdout);
12417 break;
12418 case ODK_HWPATCH:
12419 fputs (" HWPATCH ", stdout);
12420 if (option->info & OHW_R4KEOP)
12421 fputs (" R4KEOP", stdout);
12422 if (option->info & OHW_R8KPFETCH)
12423 fputs (" R8KPFETCH", stdout);
12424 if (option->info & OHW_R5KEOP)
12425 fputs (" R5KEOP", stdout);
12426 if (option->info & OHW_R5KCVTL)
12427 fputs (" R5KCVTL", stdout);
12428 break;
12429 case ODK_FILL:
12430 fputs (" FILL ", stdout);
12431 /* XXX Print content of info word? */
12432 break;
12433 case ODK_TAGS:
12434 fputs (" TAGS ", stdout);
12435 /* XXX Print content of info word? */
12436 break;
12437 case ODK_HWAND:
12438 fputs (" HWAND ", stdout);
12439 if (option->info & OHWA0_R4KEOP_CHECKED)
12440 fputs (" R4KEOP_CHECKED", stdout);
12441 if (option->info & OHWA0_R4KEOP_CLEAN)
12442 fputs (" R4KEOP_CLEAN", stdout);
12443 break;
12444 case ODK_HWOR:
12445 fputs (" HWOR ", stdout);
12446 if (option->info & OHWA0_R4KEOP_CHECKED)
12447 fputs (" R4KEOP_CHECKED", stdout);
12448 if (option->info & OHWA0_R4KEOP_CLEAN)
12449 fputs (" R4KEOP_CLEAN", stdout);
12450 break;
12451 case ODK_GP_GROUP:
12452 printf (" GP_GROUP %#06lx self-contained %#06lx",
12453 option->info & OGP_GROUP,
12454 (option->info & OGP_SELF) >> 16);
12455 break;
12456 case ODK_IDENT:
12457 printf (" IDENT %#06lx self-contained %#06lx",
12458 option->info & OGP_GROUP,
12459 (option->info & OGP_SELF) >> 16);
12460 break;
12461 default:
12462 /* This shouldn't happen. */
12463 printf (" %3d ??? %d %lx",
12464 option->kind, option->section, option->info);
12465 break;
252b5132 12466 }
a6e9f9df 12467
2cf0635d 12468 len = sizeof (* eopt);
a6e9f9df
AM		 12469 while (len < option->size)
12470 if (((char *) option)[len] >= ' '
12471 && ((char *) option)[len] < 0x7f)
12472 printf ("%c", ((char *) option)[len++]);
12473 else
12474 printf ("\\%03o", ((char *) option)[len++]);
12475
12476 fputs ("\n", stdout);
252b5132 12477 ++option;
252b5132
RH		 12478 }
12479
a6e9f9df 12480 free (eopt);
252b5132 12481 }
252b5132
RH		 12482 }
12483
12484 if (conflicts_offset != 0 && conflictsno != 0)
12485 {
2cf0635d 12486 Elf32_Conflict * iconf;
252b5132
RH		 12487 size_t cnt;
12488
12489 if (dynamic_symbols == NULL)
12490 {
591a748a 12491 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12492 return 0;
12493 }
12494
3f5e193b 12495 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12496 if (iconf == NULL)
12497 {
591a748a 12498 error (_("Out of memory\n"));
252b5132
RH		 12499 return 0;
12500 }
12501
9ea033b2 12502 if (is_32bit_elf)
252b5132 12503 {
2cf0635d 12504 Elf32_External_Conflict * econf32;
a6e9f9df 12505
3f5e193b
NC		 12506 econf32 = (Elf32_External_Conflict *)
12507 get_data (NULL, file, conflicts_offset, conflictsno,
12508 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12509 if (!econf32)
12510 return 0;
252b5132
RH		 12511
12512 for (cnt = 0; cnt < conflictsno; ++cnt)
12513 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12514
12515 free (econf32);
252b5132
RH		 12516 }
12517 else
12518 {
2cf0635d 12519 Elf64_External_Conflict * econf64;
a6e9f9df 12520
3f5e193b
NC		 12521 econf64 = (Elf64_External_Conflict *)
12522 get_data (NULL, file, conflicts_offset, conflictsno,
12523 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12524 if (!econf64)
12525 return 0;
252b5132
RH		 12526
12527 for (cnt = 0; cnt < conflictsno; ++cnt)
12528 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12529
12530 free (econf64);
252b5132
RH		 12531 }
12532
c7e7ca54
NC		 12533 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12534 (unsigned long) conflictsno);
252b5132
RH		 12535 puts (_(" Num: Index Value Name"));
12536
12537 for (cnt = 0; cnt < conflictsno; ++cnt)
12538 {
2cf0635d 12539 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12540
b34976b6 12541 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12542 print_vma (psym->st_value, FULL_HEX);
31104126 12543 putchar (' ');
d79b3d50
NC		 12544 if (VALID_DYNAMIC_NAME (psym->st_name))
12545 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12546 else
2b692964 12547 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12548 putchar ('\n');
252b5132
RH		 12549 }
12550
252b5132
RH		 12551 free (iconf);
12552 }
12553
ccb4c951
RS		 12554 if (pltgot != 0 && local_gotno != 0)
12555 {
91d6fa6a 12556 bfd_vma ent, local_end, global_end;
bbeee7ea 12557 size_t i, offset;
2cf0635d 12558 unsigned char * data;
bbeee7ea 12559 int addr_size;
ccb4c951 12560
91d6fa6a 12561 ent = pltgot;
ccb4c951
RS		 12562 addr_size = (is_32bit_elf ? 4 : 8);
12563 local_end = pltgot + local_gotno * addr_size;
12564 global_end = local_end + (symtabno - gotsym) * addr_size;
12565
12566 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12567 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 12568 global_end - pltgot, 1,
12569 _("Global Offset Table data"));
59245841
NC		 12570 if (data == NULL)
12571 return 0;
12572
ccb4c951
RS		 12573 printf (_("\nPrimary GOT:\n"));
12574 printf (_(" Canonical gp value: "));
12575 print_vma (pltgot + 0x7ff0, LONG_HEX);
12576 printf ("\n\n");
12577
12578 printf (_(" Reserved entries:\n"));
12579 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12580 addr_size * 2, _("Address"), _("Access"),
12581 addr_size * 2, _("Initial"));
91d6fa6a 12582 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12583 printf (_(" Lazy resolver\n"));
ccb4c951 12584 if (data
91d6fa6a 12585 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12586 >> (addr_size * 8 - 1)) != 0)
12587 {
91d6fa6a 12588 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12589 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12590 }
12591 printf ("\n");
12592
91d6fa6a 12593 if (ent < local_end)
ccb4c951
RS		 12594 {
12595 printf (_(" Local entries:\n"));
cc5914eb 12596 printf (" %*s %10s %*s\n",
2b692964
NC		 12597 addr_size * 2, _("Address"), _("Access"),
12598 addr_size * 2, _("Initial"));
91d6fa6a 12599 while (ent < local_end)
ccb4c951 12600 {
91d6fa6a 12601 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12602 printf ("\n");
12603 }
12604 printf ("\n");
12605 }
12606
12607 if (gotsym < symtabno)
12608 {
12609 int sym_width;
12610
12611 printf (_(" Global entries:\n"));
cc5914eb 12612 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 12613 addr_size * 2, _("Address"),
12614 _("Access"),
2b692964 12615 addr_size * 2, _("Initial"),
9cf03b7e
NC		 12616 addr_size * 2, _("Sym.Val."),
12617 _("Type"),
12618 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12619 _("Ndx"), _("Name"));
12620
ccb4c951
RS		 12621 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12622 for (i = gotsym; i < symtabno; i++)
12623 {
2cf0635d 12624 Elf_Internal_Sym * psym;
ccb4c951
RS		 12625
12626 psym = dynamic_symbols + i;
91d6fa6a 12627 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12628 printf (" ");
12629 print_vma (psym->st_value, LONG_HEX);
12630 printf (" %-7s %3s ",
12631 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12632 get_symbol_index_type (psym->st_shndx));
12633 if (VALID_DYNAMIC_NAME (psym->st_name))
12634 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12635 else
2b692964 12636 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12637 printf ("\n");
12638 }
12639 printf ("\n");
12640 }
12641
12642 if (data)
12643 free (data);
12644 }
12645
861fb55a
DJ		 12646 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12647 {
91d6fa6a 12648 bfd_vma ent, end;
861fb55a
DJ		 12649 size_t offset, rel_offset;
12650 unsigned long count, i;
2cf0635d 12651 unsigned char * data;
861fb55a 12652 int addr_size, sym_width;
2cf0635d 12653 Elf_Internal_Rela * rels;
861fb55a
DJ		 12654
12655 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12656 if (pltrel == DT_RELA)
12657 {
12658 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12659 return 0;
12660 }
12661 else
12662 {
12663 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12664 return 0;
12665 }
12666
91d6fa6a 12667 ent = mips_pltgot;
861fb55a
DJ		 12668 addr_size = (is_32bit_elf ? 4 : 8);
12669 end = mips_pltgot + (2 + count) * addr_size;
12670
12671 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12672 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12673 1, _("Procedure Linkage Table data"));
59245841
NC		 12674 if (data == NULL)
12675 return 0;
12676
9cf03b7e 12677 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 12678 printf (_(" Reserved entries:\n"));
12679 printf (_(" %*s %*s Purpose\n"),
2b692964 12680 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12681 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12682 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12683 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12684 printf (_(" Module pointer\n"));
861fb55a
DJ		 12685 printf ("\n");
12686
12687 printf (_(" Entries:\n"));
cc5914eb 12688 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12689 addr_size * 2, _("Address"),
12690 addr_size * 2, _("Initial"),
12691 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12692 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12693 for (i = 0; i < count; i++)
12694 {
2cf0635d 12695 Elf_Internal_Sym * psym;
861fb55a
DJ		 12696
12697 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12698 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12699 printf (" ");
12700 print_vma (psym->st_value, LONG_HEX);
12701 printf (" %-7s %3s ",
12702 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12703 get_symbol_index_type (psym->st_shndx));
12704 if (VALID_DYNAMIC_NAME (psym->st_name))
12705 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12706 else
2b692964 12707 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12708 printf ("\n");
12709 }
12710 printf ("\n");
12711
12712 if (data)
12713 free (data);
12714 free (rels);
12715 }
12716
252b5132
RH		 12717 return 1;
12718}
12719
047b2264 12720static int
2cf0635d 12721process_gnu_liblist (FILE * file)
047b2264 12722{
2cf0635d
NC		 12723 Elf_Internal_Shdr * section;
12724 Elf_Internal_Shdr * string_sec;
12725 Elf32_External_Lib * elib;
12726 char * strtab;
c256ffe7 12727 size_t strtab_size;
047b2264
JJ		 12728 size_t cnt;
12729 unsigned i;
12730
12731 if (! do_arch)
12732 return 0;
12733
12734 for (i = 0, section = section_headers;
12735 i < elf_header.e_shnum;
b34976b6 12736 i++, section++)
047b2264
JJ		 12737 {
12738 switch (section->sh_type)
12739 {
12740 case SHT_GNU_LIBLIST:
4fbb74a6 12741 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12742 break;
12743
3f5e193b
NC		 12744 elib = (Elf32_External_Lib *)
12745 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 12746 _("liblist section data"));
047b2264
JJ		 12747
12748 if (elib == NULL)
12749 break;
4fbb74a6 12750 string_sec = section_headers + section->sh_link;
047b2264 12751
3f5e193b
NC		 12752 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12753 string_sec->sh_size,
12754 _("liblist string table"));
047b2264
JJ		 12755 if (strtab == NULL
12756 || section->sh_entsize != sizeof (Elf32_External_Lib))
12757 {
12758 free (elib);
2842702f 12759 free (strtab);
047b2264
JJ		 12760 break;
12761 }
59245841 12762 strtab_size = string_sec->sh_size;
047b2264
JJ		 12763
12764 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12765 SECTION_NAME (section),
0af1713e 12766 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12767
2b692964 12768 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12769
12770 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12771 ++cnt)
12772 {
12773 Elf32_Lib liblist;
91d6fa6a 12774 time_t atime;
047b2264 12775 char timebuf[20];
2cf0635d 12776 struct tm * tmp;
047b2264
JJ		 12777
12778 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12779 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12780 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12781 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12782 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12783
91d6fa6a 12784 tmp = gmtime (&atime);
e9e44622
JJ		 12785 snprintf (timebuf, sizeof (timebuf),
12786 "%04u-%02u-%02uT%02u:%02u:%02u",
12787 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12788 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12789
12790 printf ("%3lu: ", (unsigned long) cnt);
12791 if (do_wide)
c256ffe7 12792 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12793 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12794 else
c256ffe7 12795 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12796 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12797 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12798 liblist.l_version, liblist.l_flags);
12799 }
12800
12801 free (elib);
2842702f 12802 free (strtab);
047b2264
JJ		 12803 }
12804 }
12805
12806 return 1;
12807}
12808
9437c45b 12809static const char *
d3ba0551 12810get_note_type (unsigned e_type)
779fe533
NC		 12811{
12812 static char buff[64];
103f02d3 12813
1ec5cd37
NC		 12814 if (elf_header.e_type == ET_CORE)
12815 switch (e_type)
12816 {
57346661 12817 case NT_AUXV:
1ec5cd37 12818 return _("NT_AUXV (auxiliary vector)");
57346661 12819 case NT_PRSTATUS:
1ec5cd37 12820 return _("NT_PRSTATUS (prstatus structure)");
57346661 12821 case NT_FPREGSET:
1ec5cd37 12822 return _("NT_FPREGSET (floating point registers)");
57346661 12823 case NT_PRPSINFO:
1ec5cd37 12824 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12825 case NT_TASKSTRUCT:
1ec5cd37 12826 return _("NT_TASKSTRUCT (task structure)");
57346661 12827 case NT_PRXFPREG:
1ec5cd37 12828 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12829 case NT_PPC_VMX:
12830 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12831 case NT_PPC_VSX:
12832 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 12833 case NT_386_TLS:
12834 return _("NT_386_TLS (x86 TLS information)");
12835 case NT_386_IOPERM:
12836 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 12837 case NT_X86_XSTATE:
12838 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12839 case NT_S390_HIGH_GPRS:
12840 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12841 case NT_S390_TIMER:
12842 return _("NT_S390_TIMER (s390 timer register)");
12843 case NT_S390_TODCMP:
12844 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12845 case NT_S390_TODPREG:
12846 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12847 case NT_S390_CTRS:
12848 return _("NT_S390_CTRS (s390 control registers)");
12849 case NT_S390_PREFIX:
12850 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 12851 case NT_S390_LAST_BREAK:
12852 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
12853 case NT_S390_SYSTEM_CALL:
12854 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 12855 case NT_S390_TDB:
12856 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW		 12857 case NT_ARM_VFP:
12858 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 12859 case NT_ARM_TLS:
12860 return _("NT_ARM_TLS (AArch TLS registers)");
12861 case NT_ARM_HW_BREAK:
12862 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12863 case NT_ARM_HW_WATCH:
12864 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 12865 case NT_PSTATUS:
1ec5cd37 12866 return _("NT_PSTATUS (pstatus structure)");
57346661 12867 case NT_FPREGS:
1ec5cd37 12868 return _("NT_FPREGS (floating point registers)");
57346661 12869 case NT_PSINFO:
1ec5cd37 12870 return _("NT_PSINFO (psinfo structure)");
57346661 12871 case NT_LWPSTATUS:
1ec5cd37 12872 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12873 case NT_LWPSINFO:
1ec5cd37 12874 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12875 case NT_WIN32PSTATUS:
1ec5cd37 12876 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 12877 case NT_SIGINFO:
12878 return _("NT_SIGINFO (siginfo_t data)");
12879 case NT_FILE:
12880 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 12881 default:
12882 break;
12883 }
12884 else
12885 switch (e_type)
12886 {
12887 case NT_VERSION:
12888 return _("NT_VERSION (version)");
12889 case NT_ARCH:
12890 return _("NT_ARCH (architecture)");
12891 default:
12892 break;
12893 }
12894
e9e44622 12895 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12896 return buff;
779fe533
NC		 12897}
12898
9ece1fa9
TT		 12899static int
12900print_core_note (Elf_Internal_Note *pnote)
12901{
12902 unsigned int addr_size = is_32bit_elf ? 4 : 8;
12903 bfd_vma count, page_size;
12904 unsigned char *descdata, *filenames, *descend;
12905
12906 if (pnote->type != NT_FILE)
12907 return 1;
12908
12909#ifndef BFD64
12910 if (!is_32bit_elf)
12911 {
12912 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12913 /* Still "successful". */
12914 return 1;
12915 }
12916#endif
12917
12918 if (pnote->descsz < 2 * addr_size)
12919 {
12920 printf (_(" Malformed note - too short for header\n"));
12921 return 0;
12922 }
12923
12924 descdata = (unsigned char *) pnote->descdata;
12925 descend = descdata + pnote->descsz;
12926
12927 if (descdata[pnote->descsz - 1] != '\0')
12928 {
12929 printf (_(" Malformed note - does not end with \\0\n"));
12930 return 0;
12931 }
12932
12933 count = byte_get (descdata, addr_size);
12934 descdata += addr_size;
12935
12936 page_size = byte_get (descdata, addr_size);
12937 descdata += addr_size;
12938
12939 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12940 {
12941 printf (_(" Malformed note - too short for supplied file count\n"));
12942 return 0;
12943 }
12944
12945 printf (_(" Page size: "));
12946 print_vma (page_size, DEC);
12947 printf ("\n");
12948
12949 printf (_(" %*s%*s%*s\n"),
12950 (int) (2 + 2 * addr_size), _("Start"),
12951 (int) (4 + 2 * addr_size), _("End"),
12952 (int) (4 + 2 * addr_size), _("Page Offset"));
12953 filenames = descdata + count * 3 * addr_size;
12954 while (--count > 0)
12955 {
12956 bfd_vma start, end, file_ofs;
12957
12958 if (filenames == descend)
12959 {
12960 printf (_(" Malformed note - filenames end too early\n"));
12961 return 0;
12962 }
12963
12964 start = byte_get (descdata, addr_size);
12965 descdata += addr_size;
12966 end = byte_get (descdata, addr_size);
12967 descdata += addr_size;
12968 file_ofs = byte_get (descdata, addr_size);
12969 descdata += addr_size;
12970
12971 printf (" ");
12972 print_vma (start, FULL_HEX);
12973 printf (" ");
12974 print_vma (end, FULL_HEX);
12975 printf (" ");
12976 print_vma (file_ofs, FULL_HEX);
12977 printf ("\n %s\n", filenames);
12978
12979 filenames += 1 + strlen ((char *) filenames);
12980 }
12981
12982 return 1;
12983}
12984
1118d252
RM		 12985static const char *
12986get_gnu_elf_note_type (unsigned e_type)
12987{
12988 static char buff[64];
12989
12990 switch (e_type)
12991 {
12992 case NT_GNU_ABI_TAG:
12993 return _("NT_GNU_ABI_TAG (ABI version tag)");
12994 case NT_GNU_HWCAP:
12995 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12996 case NT_GNU_BUILD_ID:
12997 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12998 case NT_GNU_GOLD_VERSION:
12999 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 13000 default:
13001 break;
13002 }
13003
13004 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13005 return buff;
13006}
13007
664f90a3
TT		 13008static int
13009print_gnu_note (Elf_Internal_Note *pnote)
13010{
13011 switch (pnote->type)
13012 {
13013 case NT_GNU_BUILD_ID:
13014 {
13015 unsigned long i;
13016
13017 printf (_(" Build ID: "));
13018 for (i = 0; i < pnote->descsz; ++i)
13019 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 13020 printf ("\n");
664f90a3
TT		 13021 }
13022 break;
13023
13024 case NT_GNU_ABI_TAG:
13025 {
13026 unsigned long os, major, minor, subminor;
13027 const char *osname;
13028
13029 os = byte_get ((unsigned char *) pnote->descdata, 4);
13030 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13031 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13032 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13033
13034 switch (os)
13035 {
13036 case GNU_ABI_TAG_LINUX:
13037 osname = "Linux";
13038 break;
13039 case GNU_ABI_TAG_HURD:
13040 osname = "Hurd";
13041 break;
13042 case GNU_ABI_TAG_SOLARIS:
13043 osname = "Solaris";
13044 break;
13045 case GNU_ABI_TAG_FREEBSD:
13046 osname = "FreeBSD";
13047 break;
13048 case GNU_ABI_TAG_NETBSD:
13049 osname = "NetBSD";
13050 break;
13051 default:
13052 osname = "Unknown";
13053 break;
13054 }
13055
13056 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13057 major, minor, subminor);
13058 }
13059 break;
13060 }
13061
13062 return 1;
13063}
13064
9437c45b 13065static const char *
d3ba0551 13066get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 13067{
13068 static char buff[64];
13069
b4db1224 13070 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 13071 {
13072 /* NetBSD core "procinfo" structure. */
13073 return _("NetBSD procinfo structure");
13074 }
13075
13076 /* As of Jan 2002 there are no other machine-independent notes
13077 defined for NetBSD core files. If the note type is less
13078 than the start of the machine-dependent note types, we don't
13079 understand it. */
13080
b4db1224 13081 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 13082 {
e9e44622 13083 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 13084 return buff;
13085 }
13086
13087 switch (elf_header.e_machine)
13088 {
13089 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13090 and PT_GETFPREGS == mach+2. */
13091
13092 case EM_OLD_ALPHA:
13093 case EM_ALPHA:
13094 case EM_SPARC:
13095 case EM_SPARC32PLUS:
13096 case EM_SPARCV9:
13097 switch (e_type)
13098 {
2b692964 13099 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 13100 return _("PT_GETREGS (reg structure)");
2b692964 13101 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 13102 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13103 default:
13104 break;
13105 }
13106 break;
13107
13108 /* On all other arch's, PT_GETREGS == mach+1 and
13109 PT_GETFPREGS == mach+3. */
13110 default:
13111 switch (e_type)
13112 {
2b692964 13113 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 13114 return _("PT_GETREGS (reg structure)");
2b692964 13115 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 13116 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13117 default:
13118 break;
13119 }
13120 }
13121
9cf03b7e 13122 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 13123 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 13124 return buff;
13125}
13126
70616151
TT		 13127static const char *
13128get_stapsdt_note_type (unsigned e_type)
13129{
13130 static char buff[64];
13131
13132 switch (e_type)
13133 {
13134 case NT_STAPSDT:
13135 return _("NT_STAPSDT (SystemTap probe descriptors)");
13136
13137 default:
13138 break;
13139 }
13140
13141 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13142 return buff;
13143}
13144
c6a9fc58
TT		 13145static int
13146print_stapsdt_note (Elf_Internal_Note *pnote)
13147{
13148 int addr_size = is_32bit_elf ? 4 : 8;
13149 char *data = pnote->descdata;
13150 char *data_end = pnote->descdata + pnote->descsz;
13151 bfd_vma pc, base_addr, semaphore;
13152 char *provider, *probe, *arg_fmt;
13153
13154 pc = byte_get ((unsigned char *) data, addr_size);
13155 data += addr_size;
13156 base_addr = byte_get ((unsigned char *) data, addr_size);
13157 data += addr_size;
13158 semaphore = byte_get ((unsigned char *) data, addr_size);
13159 data += addr_size;
13160
13161 provider = data;
13162 data += strlen (data) + 1;
13163 probe = data;
13164 data += strlen (data) + 1;
13165 arg_fmt = data;
13166 data += strlen (data) + 1;
13167
13168 printf (_(" Provider: %s\n"), provider);
13169 printf (_(" Name: %s\n"), probe);
13170 printf (_(" Location: "));
13171 print_vma (pc, FULL_HEX);
13172 printf (_(", Base: "));
13173 print_vma (base_addr, FULL_HEX);
13174 printf (_(", Semaphore: "));
13175 print_vma (semaphore, FULL_HEX);
9cf03b7e 13176 printf ("\n");
c6a9fc58
TT		 13177 printf (_(" Arguments: %s\n"), arg_fmt);
13178
13179 return data == data_end;
13180}
13181
00e98fc7
TG		 13182static const char *
13183get_ia64_vms_note_type (unsigned e_type)
13184{
13185 static char buff[64];
13186
13187 switch (e_type)
13188 {
13189 case NT_VMS_MHD:
13190 return _("NT_VMS_MHD (module header)");
13191 case NT_VMS_LNM:
13192 return _("NT_VMS_LNM (language name)");
13193 case NT_VMS_SRC:
13194 return _("NT_VMS_SRC (source files)");
13195 case NT_VMS_TITLE:
9cf03b7e 13196 return "NT_VMS_TITLE";
00e98fc7
TG		 13197 case NT_VMS_EIDC:
13198 return _("NT_VMS_EIDC (consistency check)");
13199 case NT_VMS_FPMODE:
13200 return _("NT_VMS_FPMODE (FP mode)");
13201 case NT_VMS_LINKTIME:
9cf03b7e 13202 return "NT_VMS_LINKTIME";
00e98fc7
TG		 13203 case NT_VMS_IMGNAM:
13204 return _("NT_VMS_IMGNAM (image name)");
13205 case NT_VMS_IMGID:
13206 return _("NT_VMS_IMGID (image id)");
13207 case NT_VMS_LINKID:
13208 return _("NT_VMS_LINKID (link id)");
13209 case NT_VMS_IMGBID:
13210 return _("NT_VMS_IMGBID (build id)");
13211 case NT_VMS_GSTNAM:
13212 return _("NT_VMS_GSTNAM (sym table name)");
13213 case NT_VMS_ORIG_DYN:
9cf03b7e 13214 return "NT_VMS_ORIG_DYN";
00e98fc7 13215 case NT_VMS_PATCHTIME:
9cf03b7e 13216 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 13217 default:
13218 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13219 return buff;
13220 }
13221}
13222
13223static int
13224print_ia64_vms_note (Elf_Internal_Note * pnote)
13225{
13226 switch (pnote->type)
13227 {
13228 case NT_VMS_MHD:
13229 if (pnote->descsz > 36)
13230 {
13231 size_t l = strlen (pnote->descdata + 34);
13232 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13233 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13234 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13235 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13236 }
13237 else
13238 printf (_(" Invalid size\n"));
13239 break;
13240 case NT_VMS_LNM:
13241 printf (_(" Language: %s\n"), pnote->descdata);
13242 break;
13243#ifdef BFD64
13244 case NT_VMS_FPMODE:
9cf03b7e 13245 printf (_(" Floating Point mode: "));
4a5cb34f 13246 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13247 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13248 break;
13249 case NT_VMS_LINKTIME:
13250 printf (_(" Link time: "));
13251 print_vms_time
13252 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13253 printf ("\n");
13254 break;
13255 case NT_VMS_PATCHTIME:
13256 printf (_(" Patch time: "));
13257 print_vms_time
13258 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13259 printf ("\n");
13260 break;
13261 case NT_VMS_ORIG_DYN:
13262 printf (_(" Major id: %u, minor id: %u\n"),
13263 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13264 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 13265 printf (_(" Last modified : "));
00e98fc7
TG		 13266 print_vms_time
13267 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 13268 printf (_("\n Link flags : "));
4a5cb34f 13269 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13270 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13271 printf (_(" Header flags: 0x%08x\n"),
13272 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13273 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13274 break;
13275#endif
13276 case NT_VMS_IMGNAM:
13277 printf (_(" Image name: %s\n"), pnote->descdata);
13278 break;
13279 case NT_VMS_GSTNAM:
13280 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13281 break;
13282 case NT_VMS_IMGID:
13283 printf (_(" Image id: %s\n"), pnote->descdata);
13284 break;
13285 case NT_VMS_LINKID:
13286 printf (_(" Linker id: %s\n"), pnote->descdata);
13287 break;
13288 default:
13289 break;
13290 }
13291 return 1;
13292}
13293
6d118b09
NC		 13294/* Note that by the ELF standard, the name field is already null byte
13295 terminated, and namesz includes the terminating null byte.
13296 I.E. the value of namesz for the name "FSF" is 4.
13297
e3c8793a 13298 If the value of namesz is zero, there is no name present. */
779fe533 13299static int
2cf0635d 13300process_note (Elf_Internal_Note * pnote)
779fe533 13301{
2cf0635d
NC		 13302 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13303 const char * nt;
9437c45b
JT		 13304
13305 if (pnote->namesz == 0)
1ec5cd37
NC		 13306 /* If there is no note name, then use the default set of
13307 note type strings. */
13308 nt = get_note_type (pnote->type);
13309
1118d252
RM		 13310 else if (const_strneq (pnote->namedata, "GNU"))
13311 /* GNU-specific object file notes. */
13312 nt = get_gnu_elf_note_type (pnote->type);
13313
0112cd26 13314 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 13315 /* NetBSD-specific core file notes. */
13316 nt = get_netbsd_elfcore_note_type (pnote->type);
13317
b15fa79e
AM		 13318 else if (strneq (pnote->namedata, "SPU/", 4))
13319 {
13320 /* SPU-specific core file notes. */
13321 nt = pnote->namedata + 4;
13322 name = "SPU";
13323 }
13324
00e98fc7
TG		 13325 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13326 /* VMS/ia64-specific file notes. */
13327 nt = get_ia64_vms_note_type (pnote->type);
13328
70616151
TT		 13329 else if (const_strneq (pnote->namedata, "stapsdt"))
13330 nt = get_stapsdt_note_type (pnote->type);
13331
9437c45b 13332 else
1ec5cd37
NC		 13333 /* Don't recognize this note name; just use the default set of
13334 note type strings. */
00e98fc7 13335 nt = get_note_type (pnote->type);
9437c45b 13336
2aee03ae 13337 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 13338
13339 if (const_strneq (pnote->namedata, "IPF/VMS"))
13340 return print_ia64_vms_note (pnote);
664f90a3
TT		 13341 else if (const_strneq (pnote->namedata, "GNU"))
13342 return print_gnu_note (pnote);
c6a9fc58
TT		 13343 else if (const_strneq (pnote->namedata, "stapsdt"))
13344 return print_stapsdt_note (pnote);
9ece1fa9
TT		 13345 else if (const_strneq (pnote->namedata, "CORE"))
13346 return print_core_note (pnote);
00e98fc7
TG		 13347 else
13348 return 1;
779fe533
NC		 13349}
13350
6d118b09 13351
779fe533 13352static int
2cf0635d 13353process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 13354{
2cf0635d
NC		 13355 Elf_External_Note * pnotes;
13356 Elf_External_Note * external;
b34976b6 13357 int res = 1;
103f02d3 13358
779fe533
NC		 13359 if (length <= 0)
13360 return 0;
103f02d3 13361
3f5e193b 13362 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 13363 _("notes"));
dd24e3da 13364 if (pnotes == NULL)
a6e9f9df 13365 return 0;
779fe533 13366
103f02d3 13367 external = pnotes;
103f02d3 13368
9dd3a467 13369 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13370 (unsigned long) offset, (unsigned long) length);
2aee03ae 13371 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13372
15b42fb0 13373 while ((char *) external < (char *) pnotes + length)
779fe533 13374 {
b34976b6 13375 Elf_Internal_Note inote;
15b42fb0
AM		 13376 size_t min_notesz;
13377 char *next;
2cf0635d 13378 char * temp = NULL;
15b42fb0 13379 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 13380
00e98fc7 13381 if (!is_ia64_vms ())
15b42fb0 13382 {
9dd3a467
NC		 13383 /* PR binutils/15191
13384 Make sure that there is enough data to read. */
15b42fb0
AM		 13385 min_notesz = offsetof (Elf_External_Note, name);
13386 if (data_remaining < min_notesz)
9dd3a467
NC		 13387 {
13388 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13389 (int) data_remaining);
13390 break;
13391 }
15b42fb0
AM		 13392 inote.type = BYTE_GET (external->type);
13393 inote.namesz = BYTE_GET (external->namesz);
13394 inote.namedata = external->name;
13395 inote.descsz = BYTE_GET (external->descsz);
13396 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13397 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13398 next = inote.descdata + align_power (inote.descsz, 2);
13399 }
00e98fc7 13400 else
15b42fb0
AM		 13401 {
13402 Elf64_External_VMS_Note *vms_external;
00e98fc7 13403
9dd3a467
NC		 13404 /* PR binutils/15191
13405 Make sure that there is enough data to read. */
15b42fb0
AM		 13406 min_notesz = offsetof (Elf64_External_VMS_Note, name);
13407 if (data_remaining < min_notesz)
9dd3a467
NC		 13408 {
13409 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13410 (int) data_remaining);
13411 break;
13412 }
3e55a963 13413
15b42fb0
AM		 13414 vms_external = (Elf64_External_VMS_Note *) external;
13415 inote.type = BYTE_GET (vms_external->type);
13416 inote.namesz = BYTE_GET (vms_external->namesz);
13417 inote.namedata = vms_external->name;
13418 inote.descsz = BYTE_GET (vms_external->descsz);
13419 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13420 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13421 next = inote.descdata + align_power (inote.descsz, 3);
13422 }
13423
13424 if (inote.descdata < (char *) external + min_notesz
13425 || next < (char *) external + min_notesz
13426 || data_remaining < (size_t)(next - (char *) external))
3e55a963 13427 {
15b42fb0 13428 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 13429 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 13430 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 13431 inote.type, inote.namesz, inote.descsz);
13432 break;
13433 }
13434
15b42fb0 13435 external = (Elf_External_Note *) next;
dd24e3da 13436
6d118b09
NC		 13437 /* Verify that name is null terminated. It appears that at least
13438 one version of Linux (RedHat 6.0) generates corefiles that don't
13439 comply with the ELF spec by failing to include the null byte in
13440 namesz. */
8b971f9f 13441 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13442 {
3f5e193b 13443 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13444
6d118b09
NC		 13445 if (temp == NULL)
13446 {
13447 error (_("Out of memory\n"));
13448 res = 0;
13449 break;
13450 }
76da6bbe 13451
6d118b09
NC		 13452 strncpy (temp, inote.namedata, inote.namesz);
13453 temp[inote.namesz] = 0;
76da6bbe 13454
6d118b09
NC		 13455 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13456 inote.namedata = temp;
13457 }
13458
13459 res &= process_note (& inote);
103f02d3 13460
6d118b09
NC		 13461 if (temp != NULL)
13462 {
13463 free (temp);
13464 temp = NULL;
13465 }
779fe533
NC		 13466 }
13467
13468 free (pnotes);
103f02d3 13469
779fe533
NC		 13470 return res;
13471}
13472
13473static int
2cf0635d 13474process_corefile_note_segments (FILE * file)
779fe533 13475{
2cf0635d 13476 Elf_Internal_Phdr * segment;
b34976b6
AM		 13477 unsigned int i;
13478 int res = 1;
103f02d3 13479
d93f0186 13480 if (! get_program_headers (file))
779fe533 13481 return 0;
103f02d3 13482
779fe533
NC		 13483 for (i = 0, segment = program_headers;
13484 i < elf_header.e_phnum;
b34976b6 13485 i++, segment++)
779fe533
NC		 13486 {
13487 if (segment->p_type == PT_NOTE)
103f02d3 13488 res &= process_corefile_note_segment (file,
30800947
NC		 13489 (bfd_vma) segment->p_offset,
13490 (bfd_vma) segment->p_filesz);
779fe533 13491 }
103f02d3 13492
779fe533
NC		 13493 return res;
13494}
13495
13496static int
2cf0635d 13497process_note_sections (FILE * file)
1ec5cd37 13498{
2cf0635d 13499 Elf_Internal_Shdr * section;
1ec5cd37
NC		 13500 unsigned long i;
13501 int res = 1;
13502
13503 for (i = 0, section = section_headers;
fa1908fd 13504 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 13505 i++, section++)
13506 if (section->sh_type == SHT_NOTE)
13507 res &= process_corefile_note_segment (file,
13508 (bfd_vma) section->sh_offset,
13509 (bfd_vma) section->sh_size);
13510
13511 return res;
13512}
13513
13514static int
2cf0635d 13515process_notes (FILE * file)
779fe533
NC		 13516{
13517 /* If we have not been asked to display the notes then do nothing. */
13518 if (! do_notes)
13519 return 1;
103f02d3 13520
779fe533 13521 if (elf_header.e_type != ET_CORE)
1ec5cd37 13522 return process_note_sections (file);
103f02d3 13523
779fe533 13524 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 13525 if (elf_header.e_phnum > 0)
13526 return process_corefile_note_segments (file);
779fe533 13527
1ec5cd37
NC		 13528 printf (_("No note segments present in the core file.\n"));
13529 return 1;
779fe533
NC		 13530}
13531
252b5132 13532static int
2cf0635d 13533process_arch_specific (FILE * file)
252b5132 13534{
a952a375
NC		 13535 if (! do_arch)
13536 return 1;
13537
252b5132
RH		 13538 switch (elf_header.e_machine)
13539 {
11c1ff18
PB		 13540 case EM_ARM:
13541 return process_arm_specific (file);
252b5132 13542 case EM_MIPS:
4fe85591 13543 case EM_MIPS_RS3_LE:
252b5132
RH		 13544 return process_mips_specific (file);
13545 break;
34c8bcba
JM		 13546 case EM_PPC:
13547 return process_power_specific (file);
13548 break;
9e8c70f9
DM		 13549 case EM_SPARC:
13550 case EM_SPARC32PLUS:
13551 case EM_SPARCV9:
13552 return process_sparc_specific (file);
13553 break;
59e6276b
JM		 13554 case EM_TI_C6000:
13555 return process_tic6x_specific (file);
13556 break;
252b5132
RH		 13557 default:
13558 break;
13559 }
13560 return 1;
13561}
13562
13563static int
2cf0635d 13564get_file_header (FILE * file)
252b5132 13565{
9ea033b2
NC		 13566 /* Read in the identity array. */
13567 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13568 return 0;
13569
9ea033b2 13570 /* Determine how to read the rest of the header. */
b34976b6 13571 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13572 {
13573 default: /* fall through */
13574 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13575 case ELFDATA2LSB:
13576 byte_get = byte_get_little_endian;
13577 byte_put = byte_put_little_endian;
13578 break;
13579 case ELFDATA2MSB:
13580 byte_get = byte_get_big_endian;
13581 byte_put = byte_put_big_endian;
13582 break;
9ea033b2
NC		 13583 }
13584
13585 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13586 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13587
13588 /* Read in the rest of the header. */
13589 if (is_32bit_elf)
13590 {
13591 Elf32_External_Ehdr ehdr32;
252b5132 13592
9ea033b2
NC		 13593 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13594 return 0;
103f02d3 13595
9ea033b2
NC		 13596 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13597 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13598 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13599 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13600 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13601 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13602 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13603 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13604 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13605 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13606 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13607 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13608 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13609 }
252b5132 13610 else
9ea033b2
NC		 13611 {
13612 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13613
13614 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13615 we will not be able to cope with the 64bit data found in
13616 64 ELF files. Detect this now and abort before we start
50c2245b 13617 overwriting things. */
a952a375
NC		 13618 if (sizeof (bfd_vma) < 8)
13619 {
e3c8793a
NC		 13620 error (_("This instance of readelf has been built without support for a\n\
1362164 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13622 return 0;
13623 }
103f02d3 13624
9ea033b2
NC		 13625 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13626 return 0;
103f02d3 13627
9ea033b2
NC		 13628 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13629 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13630 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13631 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13632 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13633 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13634 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13635 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13636 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13637 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13638 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13639 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13640 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13641 }
252b5132 13642
7ece0d85
JJ		 13643 if (elf_header.e_shoff)
13644 {
13645 /* There may be some extensions in the first section header. Don't
13646 bomb if we can't read it. */
13647 if (is_32bit_elf)
13648 get_32bit_section_headers (file, 1);
13649 else
13650 get_64bit_section_headers (file, 1);
13651 }
560f3c1c 13652
252b5132
RH		 13653 return 1;
13654}
13655
fb52b2f4
NC		 13656/* Process one ELF object file according to the command line options.
13657 This file may actually be stored in an archive. The file is
13658 positioned at the start of the ELF object. */
13659
ff78d6d6 13660static int
2cf0635d 13661process_object (char * file_name, FILE * file)
252b5132 13662{
252b5132
RH		 13663 unsigned int i;
13664
252b5132
RH		 13665 if (! get_file_header (file))
13666 {
13667 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13668 return 1;
252b5132
RH		 13669 }
13670
13671 /* Initialise per file variables. */
60bca95a 13672 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13673 version_info[i] = 0;
13674
60bca95a 13675 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13676 dynamic_info[i] = 0;
5115b233 13677 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13678
13679 /* Process the file. */
13680 if (show_name)
13681 printf (_("\nFile: %s\n"), file_name);
13682
18bd398b
NC		 13683 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13684 Note we do this even if cmdline_dump_sects is empty because we
13685 must make sure that the dump_sets array is zeroed out before each
13686 object file is processed. */
13687 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13688 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13689
13690 if (num_cmdline_dump_sects > 0)
13691 {
13692 if (num_dump_sects == 0)
13693 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13694 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13695
13696 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13697 memcpy (dump_sects, cmdline_dump_sects,
13698 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13699 }
d70c5fc7 13700
252b5132 13701 if (! process_file_header ())
fb52b2f4 13702 return 1;
252b5132 13703
d1f5c6e3 13704 if (! process_section_headers (file))
2f62977e 13705 {
d1f5c6e3
L		 13706 /* Without loaded section headers we cannot process lots of
13707 things. */
2f62977e 13708 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13709
2f62977e 13710 if (! do_using_dynamic)
2c610e4b 13711 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13712 }
252b5132 13713
d1f5c6e3
L		 13714 if (! process_section_groups (file))
13715 {
13716 /* Without loaded section groups we cannot process unwind. */
13717 do_unwind = 0;
13718 }
13719
2f62977e 13720 if (process_program_headers (file))
b2d38a17 13721 process_dynamic_section (file);
252b5132
RH		 13722
13723 process_relocs (file);
13724
4d6ed7c8
NC		 13725 process_unwind (file);
13726
252b5132
RH		 13727 process_symbol_table (file);
13728
13729 process_syminfo (file);
13730
13731 process_version_sections (file);
13732
13733 process_section_contents (file);
f5842774 13734
1ec5cd37 13735 process_notes (file);
103f02d3 13736
047b2264
JJ		 13737 process_gnu_liblist (file);
13738
252b5132
RH		 13739 process_arch_specific (file);
13740
d93f0186
NC		 13741 if (program_headers)
13742 {
13743 free (program_headers);
13744 program_headers = NULL;
13745 }
13746
252b5132
RH		 13747 if (section_headers)
13748 {
13749 free (section_headers);
13750 section_headers = NULL;
13751 }
13752
13753 if (string_table)
13754 {
13755 free (string_table);
13756 string_table = NULL;
d40ac9bd 13757 string_table_length = 0;
252b5132
RH		 13758 }
13759
13760 if (dynamic_strings)
13761 {
13762 free (dynamic_strings);
13763 dynamic_strings = NULL;
d79b3d50 13764 dynamic_strings_length = 0;
252b5132
RH		 13765 }
13766
13767 if (dynamic_symbols)
13768 {
13769 free (dynamic_symbols);
13770 dynamic_symbols = NULL;
19936277 13771 num_dynamic_syms = 0;
252b5132
RH		 13772 }
13773
13774 if (dynamic_syminfo)
13775 {
13776 free (dynamic_syminfo);
13777 dynamic_syminfo = NULL;
13778 }
ff78d6d6 13779
293c573e
MR		 13780 if (dynamic_section)
13781 {
13782 free (dynamic_section);
13783 dynamic_section = NULL;
13784 }
13785
e4b17d5c
L		 13786 if (section_headers_groups)
13787 {
13788 free (section_headers_groups);
13789 section_headers_groups = NULL;
13790 }
13791
13792 if (section_groups)
13793 {
2cf0635d
NC		 13794 struct group_list * g;
13795 struct group_list * next;
e4b17d5c
L		 13796
13797 for (i = 0; i < group_count; i++)
13798 {
13799 for (g = section_groups [i].root; g != NULL; g = next)
13800 {
13801 next = g->next;
13802 free (g);
13803 }
13804 }
13805
13806 free (section_groups);
13807 section_groups = NULL;
13808 }
13809
19e6b90e 13810 free_debug_memory ();
18bd398b 13811
ff78d6d6 13812 return 0;
252b5132
RH		 13813}
13814
2cf0635d
NC		 13815/* Process an ELF archive.
13816 On entry the file is positioned just after the ARMAG string. */
13817
13818static int
13819process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13820{
13821 struct archive_info arch;
13822 struct archive_info nested_arch;
13823 size_t got;
2cf0635d
NC		 13824 int ret;
13825
13826 show_name = 1;
13827
13828 /* The ARCH structure is used to hold information about this archive. */
13829 arch.file_name = NULL;
13830 arch.file = NULL;
13831 arch.index_array = NULL;
13832 arch.sym_table = NULL;
13833 arch.longnames = NULL;
13834
13835 /* The NESTED_ARCH structure is used as a single-item cache of information
13836 about a nested archive (when members of a thin archive reside within
13837 another regular archive file). */
13838 nested_arch.file_name = NULL;
13839 nested_arch.file = NULL;
13840 nested_arch.index_array = NULL;
13841 nested_arch.sym_table = NULL;
13842 nested_arch.longnames = NULL;
13843
13844 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13845 {
13846 ret = 1;
13847 goto out;
4145f1d5 13848 }
fb52b2f4 13849
4145f1d5
NC		 13850 if (do_archive_index)
13851 {
2cf0635d 13852 if (arch.sym_table == NULL)
4145f1d5
NC		 13853 error (_("%s: unable to dump the index as none was found\n"), file_name);
13854 else
13855 {
2cf0635d 13856 unsigned int i, l;
4145f1d5
NC		 13857 unsigned long current_pos;
13858
13859 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 13860 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 13861 current_pos = ftell (file);
13862
2cf0635d 13863 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13864 {
2cf0635d
NC		 13865 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13866 {
13867 char * member_name;
4145f1d5 13868
2cf0635d
NC		 13869 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13870
13871 if (member_name != NULL)
13872 {
13873 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13874
13875 if (qualified_name != NULL)
13876 {
c2a7d3f5
NC		 13877 printf (_("Contents of binary %s at offset "), qualified_name);
13878 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13879 putchar ('\n');
2cf0635d
NC		 13880 free (qualified_name);
13881 }
4145f1d5
NC		 13882 }
13883 }
2cf0635d
NC		 13884
13885 if (l >= arch.sym_size)
4145f1d5
NC		 13886 {
13887 error (_("%s: end of the symbol table reached before the end of the index\n"),
13888 file_name);
cb8f3167 13889 break;
4145f1d5 13890 }
2cf0635d
NC		 13891 printf ("\t%s\n", arch.sym_table + l);
13892 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13893 }
13894
c2a7d3f5
NC		 13895 if (arch.uses_64bit_indicies)
13896 l = (l + 7) & ~ 7;
13897 else
13898 l += l & 1;
13899
2cf0635d 13900 if (l < arch.sym_size)
c2a7d3f5
NC		 13901 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13902 file_name, arch.sym_size - l);
4145f1d5 13903
4145f1d5
NC		 13904 if (fseek (file, current_pos, SEEK_SET) != 0)
13905 {
13906 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13907 ret = 1;
13908 goto out;
4145f1d5 13909 }
fb52b2f4 13910 }
4145f1d5
NC		 13911
13912 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13913 && !do_segments && !do_header && !do_dump && !do_version
13914 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13915 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13916 {
13917 ret = 0; /* Archive index only. */
13918 goto out;
13919 }
fb52b2f4
NC		 13920 }
13921
d989285c 13922 ret = 0;
fb52b2f4
NC		 13923
13924 while (1)
13925 {
2cf0635d
NC		 13926 char * name;
13927 size_t namelen;
13928 char * qualified_name;
13929
13930 /* Read the next archive header. */
13931 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13932 {
13933 error (_("%s: failed to seek to next archive header\n"), file_name);
13934 return 1;
13935 }
13936 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13937 if (got != sizeof arch.arhdr)
13938 {
13939 if (got == 0)
13940 break;
13941 error (_("%s: failed to read archive header\n"), file_name);
13942 ret = 1;
13943 break;
13944 }
13945 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13946 {
13947 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13948 ret = 1;
13949 break;
13950 }
13951
13952 arch.next_arhdr_offset += sizeof arch.arhdr;
13953
13954 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13955 if (archive_file_size & 01)
13956 ++archive_file_size;
13957
13958 name = get_archive_member_name (&arch, &nested_arch);
13959 if (name == NULL)
fb52b2f4 13960 {
0fd3a477 13961 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13962 ret = 1;
13963 break;
fb52b2f4 13964 }
2cf0635d 13965 namelen = strlen (name);
fb52b2f4 13966
2cf0635d
NC		 13967 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13968 if (qualified_name == NULL)
fb52b2f4 13969 {
2cf0635d 13970 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13971 ret = 1;
13972 break;
fb52b2f4
NC		 13973 }
13974
2cf0635d
NC		 13975 if (is_thin_archive && arch.nested_member_origin == 0)
13976 {
13977 /* This is a proxy for an external member of a thin archive. */
13978 FILE * member_file;
13979 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13980 if (member_file_name == NULL)
13981 {
13982 ret = 1;
13983 break;
13984 }
13985
13986 member_file = fopen (member_file_name, "rb");
13987 if (member_file == NULL)
13988 {
13989 error (_("Input file '%s' is not readable.\n"), member_file_name);
13990 free (member_file_name);
13991 ret = 1;
13992 break;
13993 }
13994
13995 archive_file_offset = arch.nested_member_origin;
13996
13997 ret |= process_object (qualified_name, member_file);
13998
13999 fclose (member_file);
14000 free (member_file_name);
14001 }
14002 else if (is_thin_archive)
14003 {
a043396b
NC		 14004 /* PR 15140: Allow for corrupt thin archives. */
14005 if (nested_arch.file == NULL)
14006 {
14007 error (_("%s: contains corrupt thin archive: %s\n"),
14008 file_name, name);
14009 ret = 1;
14010 break;
14011 }
14012
2cf0635d
NC		 14013 /* This is a proxy for a member of a nested archive. */
14014 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14015
14016 /* The nested archive file will have been opened and setup by
14017 get_archive_member_name. */
14018 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14019 {
14020 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14021 ret = 1;
14022 break;
14023 }
14024
14025 ret |= process_object (qualified_name, nested_arch.file);
14026 }
14027 else
14028 {
14029 archive_file_offset = arch.next_arhdr_offset;
14030 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 14031
2cf0635d
NC		 14032 ret |= process_object (qualified_name, file);
14033 }
fb52b2f4 14034
2b52916e
L		 14035 if (dump_sects != NULL)
14036 {
14037 free (dump_sects);
14038 dump_sects = NULL;
14039 num_dump_sects = 0;
14040 }
14041
2cf0635d 14042 free (qualified_name);
fb52b2f4
NC		 14043 }
14044
4145f1d5 14045 out:
2cf0635d
NC		 14046 if (nested_arch.file != NULL)
14047 fclose (nested_arch.file);
14048 release_archive (&nested_arch);
14049 release_archive (&arch);
fb52b2f4 14050
d989285c 14051 return ret;
fb52b2f4
NC		 14052}
14053
14054static int
2cf0635d 14055process_file (char * file_name)
fb52b2f4 14056{
2cf0635d 14057 FILE * file;
fb52b2f4
NC		 14058 struct stat statbuf;
14059 char armag[SARMAG];
14060 int ret;
14061
14062 if (stat (file_name, &statbuf) < 0)
14063 {
f24ddbdd
NC		 14064 if (errno == ENOENT)
14065 error (_("'%s': No such file\n"), file_name);
14066 else
14067 error (_("Could not locate '%s'. System error message: %s\n"),
14068 file_name, strerror (errno));
14069 return 1;
14070 }
14071
14072 if (! S_ISREG (statbuf.st_mode))
14073 {
14074 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 14075 return 1;
14076 }
14077
14078 file = fopen (file_name, "rb");
14079 if (file == NULL)
14080 {
f24ddbdd 14081 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 14082 return 1;
14083 }
14084
14085 if (fread (armag, SARMAG, 1, file) != 1)
14086 {
4145f1d5 14087 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 14088 fclose (file);
14089 return 1;
14090 }
14091
14092 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 14093 ret = process_archive (file_name, file, FALSE);
14094 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14095 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 14096 else
14097 {
4145f1d5
NC		 14098 if (do_archive_index)
14099 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14100 file_name);
14101
fb52b2f4
NC		 14102 rewind (file);
14103 archive_file_size = archive_file_offset = 0;
14104 ret = process_object (file_name, file);
14105 }
14106
14107 fclose (file);
14108
14109 return ret;
14110}
14111
252b5132
RH		 14112#ifdef SUPPORT_DISASSEMBLY
14113/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 14114 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 14115 symbols. */
252b5132
RH		 14116
14117void
2cf0635d 14118print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 14119{
14120 fprintf (outfile,"0x%8.8x", addr);
14121}
14122
e3c8793a 14123/* Needed by the i386 disassembler. */
252b5132
RH		 14124void
14125db_task_printsym (unsigned int addr)
14126{
14127 print_address (addr, stderr);
14128}
14129#endif
14130
14131int
2cf0635d 14132main (int argc, char ** argv)
252b5132 14133{
ff78d6d6
L		 14134 int err;
14135
252b5132
RH		 14136#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14137 setlocale (LC_MESSAGES, "");
3882b010
L		 14138#endif
14139#if defined (HAVE_SETLOCALE)
14140 setlocale (LC_CTYPE, "");
252b5132
RH		 14141#endif
14142 bindtextdomain (PACKAGE, LOCALEDIR);
14143 textdomain (PACKAGE);
14144
869b9d07
MM		 14145 expandargv (&argc, &argv);
14146
252b5132
RH		 14147 parse_args (argc, argv);
14148
18bd398b 14149 if (num_dump_sects > 0)
59f14fc0 14150 {
18bd398b 14151 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 14152 cmdline_dump_sects = (dump_type *)
14153 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 14154 if (cmdline_dump_sects == NULL)
591a748a 14155 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 14156 else
14157 {
09c11c86
NC		 14158 memcpy (cmdline_dump_sects, dump_sects,
14159 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 14160 num_cmdline_dump_sects = num_dump_sects;
14161 }
14162 }
14163
18bd398b
NC		 14164 if (optind < (argc - 1))
14165 show_name = 1;
14166
ff78d6d6 14167 err = 0;
252b5132 14168 while (optind < argc)
18bd398b 14169 err |= process_file (argv[optind++]);
252b5132
RH		 14170
14171 if (dump_sects != NULL)
14172 free (dump_sects);
59f14fc0
AS		 14173 if (cmdline_dump_sects != NULL)
14174 free (cmdline_dump_sects);
252b5132 14175
ff78d6d6 14176 return err;
252b5132 14177}
GDB Binutils - Deliverables
This page took 1.820574 seconds and 4 git commands to generate.