]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
indentation fixlet in gdbserver/Makefile.in.
[thirdparty/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"
35c08157 134#include "elf/nds32.h"
13761a11 135#include "elf/nios2.h"
3b16e843 136#include "elf/or32.h"
7d466069 137#include "elf/pj.h"
3b16e843 138#include "elf/ppc.h"
c833c019 139#include "elf/ppc64.h"
99c513f6 140#include "elf/rl78.h"
c7927a3c 141#include "elf/rx.h"
a85d7ed0 142#include "elf/s390.h"
1c0d3aa6 143#include "elf/score.h"
3b16e843
NC		 144#include "elf/sh.h"
145#include "elf/sparc.h"
e9f53129 146#include "elf/spu.h"
40b36596 147#include "elf/tic6x.h"
aa137e4d
NC		 148#include "elf/tilegx.h"
149#include "elf/tilepro.h"
3b16e843 150#include "elf/v850.h"
179d3252 151#include "elf/vax.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
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;
0b4362b0 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:
35c08157 630 case EM_NDS32:
64fd6348 631 case EM_NIOS32:
e9f53129
AM		 632 case EM_PPC64:
633 case EM_PPC:
99c513f6 634 case EM_RL78:
c7927a3c 635 case EM_RX:
e9f53129
AM		 636 case EM_S390:
637 case EM_S390_OLD:
638 case EM_SH:
639 case EM_SPARC:
640 case EM_SPARC32PLUS:
641 case EM_SPARCV9:
642 case EM_SPU:
40b36596 643 case EM_TI_C6000:
aa137e4d
NC		 644 case EM_TILEGX:
645 case EM_TILEPRO:
708e2187 646 case EM_V800:
e9f53129
AM		 647 case EM_V850:
648 case EM_CYGNUS_V850:
649 case EM_VAX:
650 case EM_X86_64:
8a9036a4 651 case EM_L1OM:
7a9068fe 652 case EM_K1OM:
e9f53129
AM		 653 case EM_XSTORMY16:
654 case EM_XTENSA:
655 case EM_XTENSA_OLD:
7ba29e2a
NC		 656 case EM_MICROBLAZE:
657 case EM_MICROBLAZE_OLD:
9c19a809 658 return TRUE;
103f02d3 659
e9f53129
AM		 660 case EM_68HC05:
661 case EM_68HC08:
662 case EM_68HC11:
663 case EM_68HC16:
664 case EM_FX66:
665 case EM_ME16:
d1133906 666 case EM_MMA:
d1133906
NC		 667 case EM_NCPU:
668 case EM_NDR1:
e9f53129 669 case EM_PCP:
d1133906 670 case EM_ST100:
e9f53129 671 case EM_ST19:
d1133906 672 case EM_ST7:
e9f53129
AM		 673 case EM_ST9PLUS:
674 case EM_STARCORE:
d1133906 675 case EM_SVX:
e9f53129 676 case EM_TINYJ:
9c19a809
NC		 677 default:
678 warn (_("Don't know about relocations on this machine architecture\n"));
679 return FALSE;
680 }
681}
252b5132 682
9c19a809 683static int
2cf0635d 684slurp_rela_relocs (FILE * file,
d3ba0551
AM		 685 unsigned long rel_offset,
686 unsigned long rel_size,
2cf0635d
NC		 687 Elf_Internal_Rela ** relasp,
688 unsigned long * nrelasp)
9c19a809 689{
2cf0635d 690 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 691 unsigned long nrelas;
692 unsigned int i;
252b5132 693
4d6ed7c8
NC		 694 if (is_32bit_elf)
695 {
2cf0635d 696 Elf32_External_Rela * erelas;
103f02d3 697
3f5e193b 698 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 699 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 700 if (!erelas)
701 return 0;
252b5132 702
4d6ed7c8 703 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 704
3f5e193b
NC		 705 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
706 sizeof (Elf_Internal_Rela));
103f02d3 707
4d6ed7c8
NC		 708 if (relas == NULL)
709 {
c256ffe7 710 free (erelas);
591a748a 711 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 712 return 0;
713 }
103f02d3 714
4d6ed7c8
NC		 715 for (i = 0; i < nrelas; i++)
716 {
717 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
718 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 719 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 720 }
103f02d3 721
4d6ed7c8
NC		 722 free (erelas);
723 }
724 else
725 {
2cf0635d 726 Elf64_External_Rela * erelas;
103f02d3 727
3f5e193b 728 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 729 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 730 if (!erelas)
731 return 0;
4d6ed7c8
NC		 732
733 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 734
3f5e193b
NC		 735 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
736 sizeof (Elf_Internal_Rela));
103f02d3 737
4d6ed7c8
NC		 738 if (relas == NULL)
739 {
c256ffe7 740 free (erelas);
591a748a 741 error (_("out of memory parsing relocs\n"));
4d6ed7c8 742 return 0;
9c19a809 743 }
4d6ed7c8
NC		 744
745 for (i = 0; i < nrelas; i++)
9c19a809 746 {
66543521
AM		 747 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
748 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 749 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 750
751 /* The #ifdef BFD64 below is to prevent a compile time
752 warning. We know that if we do not have a 64 bit data
753 type that we will never execute this code anyway. */
754#ifdef BFD64
755 if (elf_header.e_machine == EM_MIPS
756 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
757 {
758 /* In little-endian objects, r_info isn't really a
759 64-bit little-endian value: it has a 32-bit
760 little-endian symbol index followed by four
761 individual byte fields. Reorder INFO
762 accordingly. */
91d6fa6a
NC		 763 bfd_vma inf = relas[i].r_info;
764 inf = (((inf & 0xffffffff) << 32)
765 | ((inf >> 56) & 0xff)
766 | ((inf >> 40) & 0xff00)
767 | ((inf >> 24) & 0xff0000)
768 | ((inf >> 8) & 0xff000000));
769 relas[i].r_info = inf;
861fb55a
DJ		 770 }
771#endif /* BFD64 */
4d6ed7c8 772 }
103f02d3 773
4d6ed7c8
NC		 774 free (erelas);
775 }
776 *relasp = relas;
777 *nrelasp = nrelas;
778 return 1;
779}
103f02d3 780
4d6ed7c8 781static int
2cf0635d 782slurp_rel_relocs (FILE * file,
d3ba0551
AM		 783 unsigned long rel_offset,
784 unsigned long rel_size,
2cf0635d
NC		 785 Elf_Internal_Rela ** relsp,
786 unsigned long * nrelsp)
4d6ed7c8 787{
2cf0635d 788 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 789 unsigned long nrels;
790 unsigned int i;
103f02d3 791
4d6ed7c8
NC		 792 if (is_32bit_elf)
793 {
2cf0635d 794 Elf32_External_Rel * erels;
103f02d3 795
3f5e193b 796 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 797 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 798 if (!erels)
799 return 0;
103f02d3 800
4d6ed7c8 801 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 802
3f5e193b 803 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 804
4d6ed7c8
NC		 805 if (rels == NULL)
806 {
c256ffe7 807 free (erels);
591a748a 808 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 809 return 0;
810 }
811
812 for (i = 0; i < nrels; i++)
813 {
814 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
815 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 816 rels[i].r_addend = 0;
9ea033b2 817 }
4d6ed7c8
NC		 818
819 free (erels);
9c19a809
NC		 820 }
821 else
822 {
2cf0635d 823 Elf64_External_Rel * erels;
9ea033b2 824
3f5e193b 825 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 826 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 827 if (!erels)
828 return 0;
103f02d3 829
4d6ed7c8 830 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 831
3f5e193b 832 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 833
4d6ed7c8 834 if (rels == NULL)
9c19a809 835 {
c256ffe7 836 free (erels);
591a748a 837 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 838 return 0;
839 }
103f02d3 840
4d6ed7c8
NC		 841 for (i = 0; i < nrels; i++)
842 {
66543521
AM		 843 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
844 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 845 rels[i].r_addend = 0;
861fb55a
DJ		 846
847 /* The #ifdef BFD64 below is to prevent a compile time
848 warning. We know that if we do not have a 64 bit data
849 type that we will never execute this code anyway. */
850#ifdef BFD64
851 if (elf_header.e_machine == EM_MIPS
852 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
853 {
854 /* In little-endian objects, r_info isn't really a
855 64-bit little-endian value: it has a 32-bit
856 little-endian symbol index followed by four
857 individual byte fields. Reorder INFO
858 accordingly. */
91d6fa6a
NC		 859 bfd_vma inf = rels[i].r_info;
860 inf = (((inf & 0xffffffff) << 32)
861 | ((inf >> 56) & 0xff)
862 | ((inf >> 40) & 0xff00)
863 | ((inf >> 24) & 0xff0000)
864 | ((inf >> 8) & 0xff000000));
865 rels[i].r_info = inf;
861fb55a
DJ		 866 }
867#endif /* BFD64 */
4d6ed7c8 868 }
103f02d3 869
4d6ed7c8
NC		 870 free (erels);
871 }
872 *relsp = rels;
873 *nrelsp = nrels;
874 return 1;
875}
103f02d3 876
aca88567
NC		 877/* Returns the reloc type extracted from the reloc info field. */
878
879static unsigned int
880get_reloc_type (bfd_vma reloc_info)
881{
882 if (is_32bit_elf)
883 return ELF32_R_TYPE (reloc_info);
884
885 switch (elf_header.e_machine)
886 {
887 case EM_MIPS:
888 /* Note: We assume that reloc_info has already been adjusted for us. */
889 return ELF64_MIPS_R_TYPE (reloc_info);
890
891 case EM_SPARCV9:
892 return ELF64_R_TYPE_ID (reloc_info);
893
894 default:
895 return ELF64_R_TYPE (reloc_info);
896 }
897}
898
899/* Return the symbol index extracted from the reloc info field. */
900
901static bfd_vma
902get_reloc_symindex (bfd_vma reloc_info)
903{
904 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
905}
906
13761a11
NC		 907static inline bfd_boolean
908uses_msp430x_relocs (void)
909{
910 return
911 elf_header.e_machine == EM_MSP430 /* Paranoia. */
912 /* GCC uses osabi == ELFOSBI_STANDALONE. */
913 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
914 /* TI compiler uses ELFOSABI_NONE. */
915 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
916}
917
d3ba0551
AM		 918/* Display the contents of the relocation data found at the specified
919 offset. */
ee42cf8c 920
41e92641 921static void
2cf0635d 922dump_relocations (FILE * file,
d3ba0551
AM		 923 unsigned long rel_offset,
924 unsigned long rel_size,
2cf0635d 925 Elf_Internal_Sym * symtab,
d3ba0551 926 unsigned long nsyms,
2cf0635d 927 char * strtab,
d79b3d50 928 unsigned long strtablen,
d3ba0551 929 int is_rela)
4d6ed7c8 930{
b34976b6 931 unsigned int i;
2cf0635d 932 Elf_Internal_Rela * rels;
103f02d3 933
4d6ed7c8
NC		 934 if (is_rela == UNKNOWN)
935 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 936
4d6ed7c8
NC		 937 if (is_rela)
938 {
c8286bd1 939 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 940 return;
4d6ed7c8
NC		 941 }
942 else
943 {
944 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 945 return;
252b5132
RH		 946 }
947
410f7a12
L		 948 if (is_32bit_elf)
949 {
950 if (is_rela)
2c71103e
NC		 951 {
952 if (do_wide)
953 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
954 else
955 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
956 }
410f7a12 957 else
2c71103e
NC		 958 {
959 if (do_wide)
960 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
961 else
962 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
963 }
410f7a12 964 }
252b5132 965 else
410f7a12
L		 966 {
967 if (is_rela)
2c71103e
NC		 968 {
969 if (do_wide)
8beeaeb7 970 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 971 else
972 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
973 }
410f7a12 974 else
2c71103e
NC		 975 {
976 if (do_wide)
8beeaeb7 977 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 978 else
979 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
980 }
410f7a12 981 }
252b5132
RH		 982
983 for (i = 0; i < rel_size; i++)
984 {
2cf0635d 985 const char * rtype;
b34976b6 986 bfd_vma offset;
91d6fa6a 987 bfd_vma inf;
b34976b6
AM		 988 bfd_vma symtab_index;
989 bfd_vma type;
103f02d3 990
b34976b6 991 offset = rels[i].r_offset;
91d6fa6a 992 inf = rels[i].r_info;
103f02d3 993
91d6fa6a
NC		 994 type = get_reloc_type (inf);
995 symtab_index = get_reloc_symindex (inf);
252b5132 996
410f7a12
L		 997 if (is_32bit_elf)
998 {
39dbeff8
AM		 999 printf ("%8.8lx %8.8lx ",
1000 (unsigned long) offset & 0xffffffff,
91d6fa6a 1001 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1002 }
1003 else
1004 {
39dbeff8
AM		 1005#if BFD_HOST_64BIT_LONG
1006 printf (do_wide
1007 ? "%16.16lx %16.16lx "
1008 : "%12.12lx %12.12lx ",
91d6fa6a 1009 offset, inf);
39dbeff8 1010#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1011#ifndef __MSVCRT__
39dbeff8
AM		 1012 printf (do_wide
1013 ? "%16.16llx %16.16llx "
1014 : "%12.12llx %12.12llx ",
91d6fa6a 1015 offset, inf);
6e3d6dc1
NC		 1016#else
1017 printf (do_wide
1018 ? "%16.16I64x %16.16I64x "
1019 : "%12.12I64x %12.12I64x ",
91d6fa6a 1020 offset, inf);
6e3d6dc1 1021#endif
39dbeff8 1022#else
2c71103e
NC		 1023 printf (do_wide
1024 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1025 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1026 _bfd_int64_high (offset),
1027 _bfd_int64_low (offset),
91d6fa6a
NC		 1028 _bfd_int64_high (inf),
1029 _bfd_int64_low (inf));
9ea033b2 1030#endif
410f7a12 1031 }
103f02d3 1032
252b5132
RH		 1033 switch (elf_header.e_machine)
1034 {
1035 default:
1036 rtype = NULL;
1037 break;
1038
a06ea964
NC		 1039 case EM_AARCH64:
1040 rtype = elf_aarch64_reloc_type (type);
1041 break;
1042
2b0337b0 1043 case EM_M32R:
252b5132 1044 case EM_CYGNUS_M32R:
9ea033b2 1045 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1046 break;
1047
1048 case EM_386:
1049 case EM_486:
9ea033b2 1050 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1051 break;
1052
ba2685cc
AM		 1053 case EM_68HC11:
1054 case EM_68HC12:
1055 rtype = elf_m68hc11_reloc_type (type);
1056 break;
75751cd9 1057
252b5132 1058 case EM_68K:
9ea033b2 1059 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1060 break;
1061
63fcb9e9 1062 case EM_960:
9ea033b2 1063 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1064 break;
1065
adde6300 1066 case EM_AVR:
2b0337b0 1067 case EM_AVR_OLD:
adde6300
AM		 1068 rtype = elf_avr_reloc_type (type);
1069 break;
1070
9ea033b2
NC		 1071 case EM_OLD_SPARCV9:
1072 case EM_SPARC32PLUS:
1073 case EM_SPARCV9:
252b5132 1074 case EM_SPARC:
9ea033b2 1075 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1076 break;
1077
e9f53129
AM		 1078 case EM_SPU:
1079 rtype = elf_spu_reloc_type (type);
1080 break;
1081
708e2187
NC		 1082 case EM_V800:
1083 rtype = v800_reloc_type (type);
1084 break;
2b0337b0 1085 case EM_V850:
252b5132 1086 case EM_CYGNUS_V850:
9ea033b2 1087 rtype = v850_reloc_type (type);
252b5132
RH		 1088 break;
1089
2b0337b0 1090 case EM_D10V:
252b5132 1091 case EM_CYGNUS_D10V:
9ea033b2 1092 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1093 break;
1094
2b0337b0 1095 case EM_D30V:
252b5132 1096 case EM_CYGNUS_D30V:
9ea033b2 1097 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1098 break;
1099
d172d4ba
NC		 1100 case EM_DLX:
1101 rtype = elf_dlx_reloc_type (type);
1102 break;
1103
252b5132 1104 case EM_SH:
9ea033b2 1105 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1106 break;
1107
2b0337b0 1108 case EM_MN10300:
252b5132 1109 case EM_CYGNUS_MN10300:
9ea033b2 1110 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1111 break;
1112
2b0337b0 1113 case EM_MN10200:
252b5132 1114 case EM_CYGNUS_MN10200:
9ea033b2 1115 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1116 break;
1117
2b0337b0 1118 case EM_FR30:
252b5132 1119 case EM_CYGNUS_FR30:
9ea033b2 1120 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1121 break;
1122
ba2685cc
AM		 1123 case EM_CYGNUS_FRV:
1124 rtype = elf_frv_reloc_type (type);
1125 break;
5c70f934 1126
252b5132 1127 case EM_MCORE:
9ea033b2 1128 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1129 break;
1130
3c3bdf30
NC		 1131 case EM_MMIX:
1132 rtype = elf_mmix_reloc_type (type);
1133 break;
1134
5506d11a
AM		 1135 case EM_MOXIE:
1136 rtype = elf_moxie_reloc_type (type);
1137 break;
1138
2469cfa2 1139 case EM_MSP430:
13761a11
NC		 1140 if (uses_msp430x_relocs ())
1141 {
1142 rtype = elf_msp430x_reloc_type (type);
1143 break;
1144 }
2469cfa2
NC		 1145 case EM_MSP430_OLD:
1146 rtype = elf_msp430_reloc_type (type);
1147 break;
1148
35c08157
KLC		 1149 case EM_NDS32:
1150 rtype = elf_nds32_reloc_type (type);
1151 break;
1152
252b5132 1153 case EM_PPC:
9ea033b2 1154 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1155 break;
1156
c833c019
AM		 1157 case EM_PPC64:
1158 rtype = elf_ppc64_reloc_type (type);
1159 break;
1160
252b5132 1161 case EM_MIPS:
4fe85591 1162 case EM_MIPS_RS3_LE:
9ea033b2 1163 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1164 break;
1165
1166 case EM_ALPHA:
9ea033b2 1167 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1168 break;
1169
1170 case EM_ARM:
9ea033b2 1171 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1172 break;
1173
584da044 1174 case EM_ARC:
9ea033b2 1175 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1176 break;
1177
1178 case EM_PARISC:
69e617ca 1179 rtype = elf_hppa_reloc_type (type);
252b5132 1180 break;
7d466069 1181
b8720f9d
JL		 1182 case EM_H8_300:
1183 case EM_H8_300H:
1184 case EM_H8S:
1185 rtype = elf_h8_reloc_type (type);
1186 break;
1187
3b16e843
NC		 1188 case EM_OPENRISC:
1189 case EM_OR32:
1190 rtype = elf_or32_reloc_type (type);
1191 break;
1192
7d466069 1193 case EM_PJ:
2b0337b0 1194 case EM_PJ_OLD:
7d466069
ILT		 1195 rtype = elf_pj_reloc_type (type);
1196 break;
800eeca4
JW		 1197 case EM_IA_64:
1198 rtype = elf_ia64_reloc_type (type);
1199 break;
1b61cf92
HPN		 1200
1201 case EM_CRIS:
1202 rtype = elf_cris_reloc_type (type);
1203 break;
535c37ff
JE		 1204
1205 case EM_860:
1206 rtype = elf_i860_reloc_type (type);
1207 break;
bcedfee6
NC		 1208
1209 case EM_X86_64:
8a9036a4 1210 case EM_L1OM:
7a9068fe 1211 case EM_K1OM:
bcedfee6
NC		 1212 rtype = elf_x86_64_reloc_type (type);
1213 break;
a85d7ed0 1214
35b1837e
AM		 1215 case EM_S370:
1216 rtype = i370_reloc_type (type);
1217 break;
1218
53c7db4b
KH		 1219 case EM_S390_OLD:
1220 case EM_S390:
1221 rtype = elf_s390_reloc_type (type);
1222 break;
93fbbb04 1223
1c0d3aa6
NC		 1224 case EM_SCORE:
1225 rtype = elf_score_reloc_type (type);
1226 break;
1227
93fbbb04
GK		 1228 case EM_XSTORMY16:
1229 rtype = elf_xstormy16_reloc_type (type);
1230 break;
179d3252 1231
1fe1f39c
NC		 1232 case EM_CRX:
1233 rtype = elf_crx_reloc_type (type);
1234 break;
1235
179d3252
JT		 1236 case EM_VAX:
1237 rtype = elf_vax_reloc_type (type);
1238 break;
1e4cf259 1239
cfb8c092
NC		 1240 case EM_ADAPTEVA_EPIPHANY:
1241 rtype = elf_epiphany_reloc_type (type);
1242 break;
1243
1e4cf259
NC		 1244 case EM_IP2K:
1245 case EM_IP2K_OLD:
1246 rtype = elf_ip2k_reloc_type (type);
1247 break;
3b36097d
SC		 1248
1249 case EM_IQ2000:
1250 rtype = elf_iq2000_reloc_type (type);
1251 break;
88da6820
NC		 1252
1253 case EM_XTENSA_OLD:
1254 case EM_XTENSA:
1255 rtype = elf_xtensa_reloc_type (type);
1256 break;
a34e3ecb 1257
84e94c90
NC		 1258 case EM_LATTICEMICO32:
1259 rtype = elf_lm32_reloc_type (type);
1260 break;
1261
ff7eeb89 1262 case EM_M32C_OLD:
49f58d10
JB		 1263 case EM_M32C:
1264 rtype = elf_m32c_reloc_type (type);
1265 break;
1266
d031aafb
NS		 1267 case EM_MT:
1268 rtype = elf_mt_reloc_type (type);
a34e3ecb 1269 break;
1d65ded4
CM		 1270
1271 case EM_BLACKFIN:
1272 rtype = elf_bfin_reloc_type (type);
1273 break;
15ab5209
DB		 1274
1275 case EM_CYGNUS_MEP:
1276 rtype = elf_mep_reloc_type (type);
1277 break;
60bca95a
NC		 1278
1279 case EM_CR16:
1280 rtype = elf_cr16_reloc_type (type);
1281 break;
dd24e3da 1282
7ba29e2a
NC		 1283 case EM_MICROBLAZE:
1284 case EM_MICROBLAZE_OLD:
1285 rtype = elf_microblaze_reloc_type (type);
1286 break;
c7927a3c 1287
99c513f6
DD		 1288 case EM_RL78:
1289 rtype = elf_rl78_reloc_type (type);
1290 break;
1291
c7927a3c
NC		 1292 case EM_RX:
1293 rtype = elf_rx_reloc_type (type);
1294 break;
c29aca4a 1295
a3c62988
NC		 1296 case EM_METAG:
1297 rtype = elf_metag_reloc_type (type);
1298 break;
1299
c29aca4a
NC		 1300 case EM_XC16X:
1301 case EM_C166:
1302 rtype = elf_xc16x_reloc_type (type);
1303 break;
40b36596
JM		 1304
1305 case EM_TI_C6000:
1306 rtype = elf_tic6x_reloc_type (type);
1307 break;
aa137e4d
NC		 1308
1309 case EM_TILEGX:
1310 rtype = elf_tilegx_reloc_type (type);
1311 break;
1312
1313 case EM_TILEPRO:
1314 rtype = elf_tilepro_reloc_type (type);
1315 break;
f6c1a2d5
NC		 1316
1317 case EM_XGATE:
1318 rtype = elf_xgate_reloc_type (type);
1319 break;
36591ba1
SL		 1320
1321 case EM_ALTERA_NIOS2:
1322 rtype = elf_nios2_reloc_type (type);
1323 break;
252b5132
RH		 1324 }
1325
1326 if (rtype == NULL)
39dbeff8 1327 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1328 else
8beeaeb7 1329 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1330
7ace3541 1331 if (elf_header.e_machine == EM_ALPHA
157c2599 1332 && rtype != NULL
7ace3541
RH		 1333 && streq (rtype, "R_ALPHA_LITUSE")
1334 && is_rela)
1335 {
1336 switch (rels[i].r_addend)
1337 {
1338 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1339 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1340 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1341 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1342 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1343 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1344 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1345 default: rtype = NULL;
1346 }
1347 if (rtype)
1348 printf (" (%s)", rtype);
1349 else
1350 {
1351 putchar (' ');
1352 printf (_("<unknown addend: %lx>"),
1353 (unsigned long) rels[i].r_addend);
1354 }
1355 }
1356 else if (symtab_index)
252b5132 1357 {
af3fc3bc 1358 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1359 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1360 else
19936277 1361 {
2cf0635d 1362 Elf_Internal_Sym * psym;
19936277 1363
af3fc3bc 1364 psym = symtab + symtab_index;
103f02d3 1365
af3fc3bc 1366 printf (" ");
171191ba 1367
d8045f23
NC		 1368 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1369 {
1370 const char * name;
1371 unsigned int len;
1372 unsigned int width = is_32bit_elf ? 8 : 14;
1373
1374 /* Relocations against GNU_IFUNC symbols do not use the value
1375 of the symbol as the address to relocate against. Instead
1376 they invoke the function named by the symbol and use its
1377 result as the address for relocation.
1378
1379 To indicate this to the user, do not display the value of
1380 the symbol in the "Symbols's Value" field. Instead show
1381 its name followed by () as a hint that the symbol is
1382 invoked. */
1383
1384 if (strtab == NULL
1385 || psym->st_name == 0
1386 || psym->st_name >= strtablen)
1387 name = "??";
1388 else
1389 name = strtab + psym->st_name;
1390
1391 len = print_symbol (width, name);
1392 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1393 }
1394 else
1395 {
1396 print_vma (psym->st_value, LONG_HEX);
171191ba 1397
d8045f23
NC		 1398 printf (is_32bit_elf ? " " : " ");
1399 }
103f02d3 1400
af3fc3bc 1401 if (psym->st_name == 0)
f1ef08cb 1402 {
2cf0635d 1403 const char * sec_name = "<null>";
f1ef08cb
AM		 1404 char name_buf[40];
1405
1406 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1407 {
4fbb74a6
AM		 1408 if (psym->st_shndx < elf_header.e_shnum)
1409 sec_name
1410 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1411 else if (psym->st_shndx == SHN_ABS)
1412 sec_name = "ABS";
1413 else if (psym->st_shndx == SHN_COMMON)
1414 sec_name = "COMMON";
ac145307
BS		 1415 else if ((elf_header.e_machine == EM_MIPS
1416 && psym->st_shndx == SHN_MIPS_SCOMMON)
1417 || (elf_header.e_machine == EM_TI_C6000
1418 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1419 sec_name = "SCOMMON";
1420 else if (elf_header.e_machine == EM_MIPS
1421 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1422 sec_name = "SUNDEF";
8a9036a4 1423 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1424 || elf_header.e_machine == EM_L1OM
1425 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1426 && psym->st_shndx == SHN_X86_64_LCOMMON)
1427 sec_name = "LARGE_COMMON";
9ce701e2
L		 1428 else if (elf_header.e_machine == EM_IA_64
1429 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1430 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1431 sec_name = "ANSI_COM";
28f997cf 1432 else if (is_ia64_vms ()
148b93f2
NC		 1433 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1434 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1435 else
1436 {
1437 sprintf (name_buf, "<section 0x%x>",
1438 (unsigned int) psym->st_shndx);
1439 sec_name = name_buf;
1440 }
1441 }
1442 print_symbol (22, sec_name);
1443 }
af3fc3bc 1444 else if (strtab == NULL)
d79b3d50 1445 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1446 else if (psym->st_name >= strtablen)
d79b3d50 1447 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1448 else
2c71103e 1449 print_symbol (22, strtab + psym->st_name);
103f02d3 1450
af3fc3bc 1451 if (is_rela)
171191ba 1452 {
598aaa76 1453 bfd_signed_vma off = rels[i].r_addend;
171191ba 1454
91d6fa6a 1455 if (off < 0)
598aaa76 1456 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1457 else
598aaa76 1458 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1459 }
19936277 1460 }
252b5132 1461 }
1b228002 1462 else if (is_rela)
f7a99963 1463 {
e04d7088
L		 1464 bfd_signed_vma off = rels[i].r_addend;
1465
1466 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1467 if (off < 0)
1468 printf ("-%" BFD_VMA_FMT "x", - off);
1469 else
1470 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1471 }
252b5132 1472
157c2599
NC		 1473 if (elf_header.e_machine == EM_SPARCV9
1474 && rtype != NULL
1475 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1476 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1477
252b5132 1478 putchar ('\n');
2c71103e 1479
aca88567 1480#ifdef BFD64
53c7db4b 1481 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1482 {
91d6fa6a
NC		 1483 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1484 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1485 const char * rtype2 = elf_mips_reloc_type (type2);
1486 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1487
2c71103e
NC		 1488 printf (" Type2: ");
1489
1490 if (rtype2 == NULL)
39dbeff8
AM		 1491 printf (_("unrecognized: %-7lx"),
1492 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1493 else
1494 printf ("%-17.17s", rtype2);
1495
18bd398b 1496 printf ("\n Type3: ");
2c71103e
NC		 1497
1498 if (rtype3 == NULL)
39dbeff8
AM		 1499 printf (_("unrecognized: %-7lx"),
1500 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1501 else
1502 printf ("%-17.17s", rtype3);
1503
53c7db4b 1504 putchar ('\n');
2c71103e 1505 }
aca88567 1506#endif /* BFD64 */
252b5132
RH		 1507 }
1508
c8286bd1 1509 free (rels);
252b5132
RH		 1510}
1511
1512static const char *
d3ba0551 1513get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1514{
1515 switch (type)
1516 {
1517 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1518 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1519 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1520 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1521 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1522 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1523 case DT_MIPS_MSYM: return "MIPS_MSYM";
1524 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1525 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1526 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1527 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1528 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1529 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1530 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1531 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1532 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1533 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1534 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1535 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1536 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1537 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1538 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1539 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1540 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1541 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1542 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1543 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1544 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1545 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1546 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1547 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1548 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1549 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1550 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1551 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1552 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1553 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1554 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1555 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1556 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1557 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1558 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1559 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1560 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1561 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1562 default:
1563 return NULL;
1564 }
1565}
1566
9a097730 1567static const char *
d3ba0551 1568get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1569{
1570 switch (type)
1571 {
1572 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1573 default:
1574 return NULL;
1575 }
103f02d3
UD		 1576}
1577
7490d522
AM		 1578static const char *
1579get_ppc_dynamic_type (unsigned long type)
1580{
1581 switch (type)
1582 {
a7f2871e 1583 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1584 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1585 default:
1586 return NULL;
1587 }
1588}
1589
f1cb7e17 1590static const char *
d3ba0551 1591get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1592{
1593 switch (type)
1594 {
a7f2871e
AM		 1595 case DT_PPC64_GLINK: return "PPC64_GLINK";
1596 case DT_PPC64_OPD: return "PPC64_OPD";
1597 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1598 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1599 default:
1600 return NULL;
1601 }
1602}
1603
103f02d3 1604static const char *
d3ba0551 1605get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1606{
1607 switch (type)
1608 {
1609 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1610 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1611 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1612 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1613 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1614 case DT_HP_PREINIT: return "HP_PREINIT";
1615 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1616 case DT_HP_NEEDED: return "HP_NEEDED";
1617 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1618 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1619 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1620 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1621 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1622 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1623 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1624 case DT_HP_FILTERED: return "HP_FILTERED";
1625 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1626 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1627 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1628 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1629 case DT_PLT: return "PLT";
1630 case DT_PLT_SIZE: return "PLT_SIZE";
1631 case DT_DLT: return "DLT";
1632 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1633 default:
1634 return NULL;
1635 }
1636}
9a097730 1637
ecc51f48 1638static const char *
d3ba0551 1639get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1640{
1641 switch (type)
1642 {
148b93f2
NC		 1643 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1644 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1645 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1646 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1647 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1648 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1649 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1650 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1651 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1652 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1653 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1654 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1655 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1656 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1657 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1658 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1659 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1660 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1661 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1662 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1663 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1664 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1665 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1666 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1667 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1668 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1669 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1670 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1671 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1672 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1673 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1674 default:
1675 return NULL;
1676 }
1677}
1678
fabcb361
RH		 1679static const char *
1680get_alpha_dynamic_type (unsigned long type)
1681{
1682 switch (type)
1683 {
1684 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1685 default:
1686 return NULL;
1687 }
1688}
1689
1c0d3aa6
NC		 1690static const char *
1691get_score_dynamic_type (unsigned long type)
1692{
1693 switch (type)
1694 {
1695 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1696 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1697 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1698 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1699 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1700 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1701 default:
1702 return NULL;
1703 }
1704}
1705
40b36596
JM		 1706static const char *
1707get_tic6x_dynamic_type (unsigned long type)
1708{
1709 switch (type)
1710 {
1711 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1712 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1713 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1714 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1715 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1716 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1717 default:
1718 return NULL;
1719 }
1720}
1c0d3aa6 1721
36591ba1
SL		 1722static const char *
1723get_nios2_dynamic_type (unsigned long type)
1724{
1725 switch (type)
1726 {
1727 case DT_NIOS2_GP: return "NIOS2_GP";
1728 default:
1729 return NULL;
1730 }
1731}
1732
252b5132 1733static const char *
d3ba0551 1734get_dynamic_type (unsigned long type)
252b5132 1735{
e9e44622 1736 static char buff[64];
252b5132
RH		 1737
1738 switch (type)
1739 {
1740 case DT_NULL: return "NULL";
1741 case DT_NEEDED: return "NEEDED";
1742 case DT_PLTRELSZ: return "PLTRELSZ";
1743 case DT_PLTGOT: return "PLTGOT";
1744 case DT_HASH: return "HASH";
1745 case DT_STRTAB: return "STRTAB";
1746 case DT_SYMTAB: return "SYMTAB";
1747 case DT_RELA: return "RELA";
1748 case DT_RELASZ: return "RELASZ";
1749 case DT_RELAENT: return "RELAENT";
1750 case DT_STRSZ: return "STRSZ";
1751 case DT_SYMENT: return "SYMENT";
1752 case DT_INIT: return "INIT";
1753 case DT_FINI: return "FINI";
1754 case DT_SONAME: return "SONAME";
1755 case DT_RPATH: return "RPATH";
1756 case DT_SYMBOLIC: return "SYMBOLIC";
1757 case DT_REL: return "REL";
1758 case DT_RELSZ: return "RELSZ";
1759 case DT_RELENT: return "RELENT";
1760 case DT_PLTREL: return "PLTREL";
1761 case DT_DEBUG: return "DEBUG";
1762 case DT_TEXTREL: return "TEXTREL";
1763 case DT_JMPREL: return "JMPREL";
1764 case DT_BIND_NOW: return "BIND_NOW";
1765 case DT_INIT_ARRAY: return "INIT_ARRAY";
1766 case DT_FINI_ARRAY: return "FINI_ARRAY";
1767 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1768 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1769 case DT_RUNPATH: return "RUNPATH";
1770 case DT_FLAGS: return "FLAGS";
2d0e6f43 1771
d1133906
NC		 1772 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1773 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1774
05107a46 1775 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1776 case DT_PLTPADSZ: return "PLTPADSZ";
1777 case DT_MOVEENT: return "MOVEENT";
1778 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1779 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1780 case DT_POSFLAG_1: return "POSFLAG_1";
1781 case DT_SYMINSZ: return "SYMINSZ";
1782 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1783
252b5132 1784 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1785 case DT_CONFIG: return "CONFIG";
1786 case DT_DEPAUDIT: return "DEPAUDIT";
1787 case DT_AUDIT: return "AUDIT";
1788 case DT_PLTPAD: return "PLTPAD";
1789 case DT_MOVETAB: return "MOVETAB";
252b5132 1790 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1791
252b5132 1792 case DT_VERSYM: return "VERSYM";
103f02d3 1793
67a4f2b7
AO		 1794 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1795 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1796 case DT_RELACOUNT: return "RELACOUNT";
1797 case DT_RELCOUNT: return "RELCOUNT";
1798 case DT_FLAGS_1: return "FLAGS_1";
1799 case DT_VERDEF: return "VERDEF";
1800 case DT_VERDEFNUM: return "VERDEFNUM";
1801 case DT_VERNEED: return "VERNEED";
1802 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1803
019148e4 1804 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1805 case DT_USED: return "USED";
1806 case DT_FILTER: return "FILTER";
103f02d3 1807
047b2264
JJ		 1808 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1809 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1810 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1811 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1812 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1813 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1814
252b5132
RH		 1815 default:
1816 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1817 {
2cf0635d 1818 const char * result;
103f02d3 1819
252b5132
RH		 1820 switch (elf_header.e_machine)
1821 {
1822 case EM_MIPS:
4fe85591 1823 case EM_MIPS_RS3_LE:
252b5132
RH		 1824 result = get_mips_dynamic_type (type);
1825 break;
9a097730
RH		 1826 case EM_SPARCV9:
1827 result = get_sparc64_dynamic_type (type);
1828 break;
7490d522
AM		 1829 case EM_PPC:
1830 result = get_ppc_dynamic_type (type);
1831 break;
f1cb7e17
AM		 1832 case EM_PPC64:
1833 result = get_ppc64_dynamic_type (type);
1834 break;
ecc51f48
NC		 1835 case EM_IA_64:
1836 result = get_ia64_dynamic_type (type);
1837 break;
fabcb361
RH		 1838 case EM_ALPHA:
1839 result = get_alpha_dynamic_type (type);
1840 break;
1c0d3aa6
NC		 1841 case EM_SCORE:
1842 result = get_score_dynamic_type (type);
1843 break;
40b36596
JM		 1844 case EM_TI_C6000:
1845 result = get_tic6x_dynamic_type (type);
1846 break;
36591ba1
SL		 1847 case EM_ALTERA_NIOS2:
1848 result = get_nios2_dynamic_type (type);
1849 break;
252b5132
RH		 1850 default:
1851 result = NULL;
1852 break;
1853 }
1854
1855 if (result != NULL)
1856 return result;
1857
e9e44622 1858 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1859 }
eec8f817
DA		 1860 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1861 || (elf_header.e_machine == EM_PARISC
1862 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1863 {
2cf0635d 1864 const char * result;
103f02d3
UD		 1865
1866 switch (elf_header.e_machine)
1867 {
1868 case EM_PARISC:
1869 result = get_parisc_dynamic_type (type);
1870 break;
148b93f2
NC		 1871 case EM_IA_64:
1872 result = get_ia64_dynamic_type (type);
1873 break;
103f02d3
UD		 1874 default:
1875 result = NULL;
1876 break;
1877 }
1878
1879 if (result != NULL)
1880 return result;
1881
e9e44622
JJ		 1882 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1883 type);
103f02d3 1884 }
252b5132 1885 else
e9e44622 1886 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1887
252b5132
RH		 1888 return buff;
1889 }
1890}
1891
1892static char *
d3ba0551 1893get_file_type (unsigned e_type)
252b5132 1894{
b34976b6 1895 static char buff[32];
252b5132
RH		 1896
1897 switch (e_type)
1898 {
1899 case ET_NONE: return _("NONE (None)");
1900 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1901 case ET_EXEC: return _("EXEC (Executable file)");
1902 case ET_DYN: return _("DYN (Shared object file)");
1903 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1904
1905 default:
1906 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1907 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1908 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1909 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1910 else
e9e44622 1911 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1912 return buff;
1913 }
1914}
1915
1916static char *
d3ba0551 1917get_machine_name (unsigned e_machine)
252b5132 1918{
b34976b6 1919 static char buff[64]; /* XXX */
252b5132
RH		 1920
1921 switch (e_machine)
1922 {
c45021f2 1923 case EM_NONE: return _("None");
a06ea964 1924 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1925 case EM_M32: return "WE32100";
1926 case EM_SPARC: return "Sparc";
e9f53129 1927 case EM_SPU: return "SPU";
c45021f2
NC		 1928 case EM_386: return "Intel 80386";
1929 case EM_68K: return "MC68000";
1930 case EM_88K: return "MC88000";
1931 case EM_486: return "Intel 80486";
1932 case EM_860: return "Intel 80860";
1933 case EM_MIPS: return "MIPS R3000";
1934 case EM_S370: return "IBM System/370";
7036c0e1 1935 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1936 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1937 case EM_PARISC: return "HPPA";
252b5132 1938 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1939 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1940 case EM_960: return "Intel 90860";
1941 case EM_PPC: return "PowerPC";
285d1771 1942 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1943 case EM_FR20: return "Fujitsu FR20";
1944 case EM_RH32: return "TRW RH32";
b34976b6 1945 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1946 case EM_ARM: return "ARM";
1947 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1948 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1949 case EM_SPARCV9: return "Sparc v9";
1950 case EM_TRICORE: return "Siemens Tricore";
584da044 1951 case EM_ARC: return "ARC";
c2dcd04e
NC		 1952 case EM_H8_300: return "Renesas H8/300";
1953 case EM_H8_300H: return "Renesas H8/300H";
1954 case EM_H8S: return "Renesas H8S";
1955 case EM_H8_500: return "Renesas H8/500";
30800947 1956 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1957 case EM_MIPS_X: return "Stanford MIPS-X";
1958 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1959 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1960 case EM_CYGNUS_D10V:
1961 case EM_D10V: return "d10v";
1962 case EM_CYGNUS_D30V:
b34976b6 1963 case EM_D30V: return "d30v";
2b0337b0 1964 case EM_CYGNUS_M32R:
26597c86 1965 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1966 case EM_CYGNUS_V850:
708e2187 1967 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 1968 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1969 case EM_CYGNUS_MN10300:
1970 case EM_MN10300: return "mn10300";
1971 case EM_CYGNUS_MN10200:
1972 case EM_MN10200: return "mn10200";
5506d11a 1973 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1974 case EM_CYGNUS_FR30:
1975 case EM_FR30: return "Fujitsu FR30";
b34976b6 1976 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1977 case EM_PJ_OLD:
b34976b6 1978 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1979 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1980 case EM_PCP: return "Siemens PCP";
1981 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1982 case EM_NDR1: return "Denso NDR1 microprocesspr";
1983 case EM_STARCORE: return "Motorola Star*Core processor";
1984 case EM_ME16: return "Toyota ME16 processor";
1985 case EM_ST100: return "STMicroelectronics ST100 processor";
1986 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1987 case EM_PDSP: return "Sony DSP processor";
1988 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1989 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1990 case EM_FX66: return "Siemens FX66 microcontroller";
1991 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1992 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1993 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1994 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1995 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1996 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1997 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1998 case EM_SVX: return "Silicon Graphics SVx";
1999 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2000 case EM_VAX: return "Digital VAX";
2b0337b0 2001 case EM_AVR_OLD:
b34976b6 2002 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2003 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2004 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2005 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2006 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2007 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2008 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2009 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2010 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2011 case EM_L1OM: return "Intel L1OM";
7a9068fe 2012 case EM_K1OM: return "Intel K1OM";
b7498e0e 2013 case EM_S390_OLD:
b34976b6 2014 case EM_S390: return "IBM S/390";
1c0d3aa6 2015 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2016 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 2017 case EM_OPENRISC:
2018 case EM_OR32: return "OpenRISC";
11636f9e 2019 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2020 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2021 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2022 case EM_DLX: return "OpenDLX";
1e4cf259 2023 case EM_IP2K_OLD:
b34976b6 2024 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2025 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2026 case EM_XTENSA_OLD:
2027 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2028 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2029 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2030 case EM_NS32K: return "National Semiconductor 32000 series";
2031 case EM_TPC: return "Tenor Network TPC processor";
2032 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2033 case EM_MAX: return "MAX Processor";
2034 case EM_CR: return "National Semiconductor CompactRISC";
2035 case EM_F2MC16: return "Fujitsu F2MC16";
2036 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2037 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2038 case EM_M32C_OLD:
49f58d10 2039 case EM_M32C: return "Renesas M32c";
d031aafb 2040 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2041 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2042 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2043 case EM_SEP: return "Sharp embedded microprocessor";
2044 case EM_ARCA: return "Arca RISC microprocessor";
2045 case EM_UNICORE: return "Unicore";
2046 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2047 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2048 case EM_NIOS32: return "Altera Nios";
2049 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2050 case EM_C166:
d70c5fc7 2051 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2052 case EM_M16C: return "Renesas M16C series microprocessors";
2053 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2054 case EM_CE: return "Freescale Communication Engine RISC core";
2055 case EM_TSK3000: return "Altium TSK3000 core";
2056 case EM_RS08: return "Freescale RS08 embedded processor";
2057 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2058 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2059 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2060 case EM_SE_C17: return "Seiko Epson C17 family";
2061 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2062 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2063 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2064 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2065 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2066 case EM_R32C: return "Renesas R32C series microprocessors";
2067 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2068 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2069 case EM_8051: return "Intel 8051 and variants";
2070 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2071 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2072 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2073 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2074 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2075 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2076 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2077 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2078 case EM_CR16:
f6c1a2d5 2079 case EM_MICROBLAZE:
7ba29e2a 2080 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2081 case EM_RL78: return "Renesas RL78";
c7927a3c 2082 case EM_RX: return "Renesas RX";
a3c62988 2083 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2084 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2085 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2086 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2087 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2088 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2089 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2090 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2091 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2092 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2093 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2094 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2095 default:
35d9dd2f 2096 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2097 return buff;
2098 }
2099}
2100
f3485b74 2101static void
d3ba0551 2102decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2103{
2104 unsigned eabi;
2105 int unknown = 0;
2106
2107 eabi = EF_ARM_EABI_VERSION (e_flags);
2108 e_flags &= ~ EF_ARM_EABIMASK;
2109
2110 /* Handle "generic" ARM flags. */
2111 if (e_flags & EF_ARM_RELEXEC)
2112 {
2113 strcat (buf, ", relocatable executable");
2114 e_flags &= ~ EF_ARM_RELEXEC;
2115 }
76da6bbe 2116
f3485b74
NC		 2117 if (e_flags & EF_ARM_HASENTRY)
2118 {
2119 strcat (buf, ", has entry point");
2120 e_flags &= ~ EF_ARM_HASENTRY;
2121 }
76da6bbe 2122
f3485b74
NC		 2123 /* Now handle EABI specific flags. */
2124 switch (eabi)
2125 {
2126 default:
2c71103e 2127 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2128 if (e_flags)
2129 unknown = 1;
2130 break;
2131
2132 case EF_ARM_EABI_VER1:
a5bcd848 2133 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2134 while (e_flags)
2135 {
2136 unsigned flag;
76da6bbe 2137
f3485b74
NC		 2138 /* Process flags one bit at a time. */
2139 flag = e_flags & - e_flags;
2140 e_flags &= ~ flag;
76da6bbe 2141
f3485b74
NC		 2142 switch (flag)
2143 {
a5bcd848 2144 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2145 strcat (buf, ", sorted symbol tables");
2146 break;
76da6bbe 2147
f3485b74
NC		 2148 default:
2149 unknown = 1;
2150 break;
2151 }
2152 }
2153 break;
76da6bbe 2154
a5bcd848
PB		 2155 case EF_ARM_EABI_VER2:
2156 strcat (buf, ", Version2 EABI");
2157 while (e_flags)
2158 {
2159 unsigned flag;
2160
2161 /* Process flags one bit at a time. */
2162 flag = e_flags & - e_flags;
2163 e_flags &= ~ flag;
2164
2165 switch (flag)
2166 {
2167 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2168 strcat (buf, ", sorted symbol tables");
2169 break;
2170
2171 case EF_ARM_DYNSYMSUSESEGIDX:
2172 strcat (buf, ", dynamic symbols use segment index");
2173 break;
2174
2175 case EF_ARM_MAPSYMSFIRST:
2176 strcat (buf, ", mapping symbols precede others");
2177 break;
2178
2179 default:
2180 unknown = 1;
2181 break;
2182 }
2183 }
2184 break;
2185
d507cf36
PB		 2186 case EF_ARM_EABI_VER3:
2187 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2188 break;
2189
2190 case EF_ARM_EABI_VER4:
2191 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2192 while (e_flags)
2193 {
2194 unsigned flag;
2195
2196 /* Process flags one bit at a time. */
2197 flag = e_flags & - e_flags;
2198 e_flags &= ~ flag;
2199
2200 switch (flag)
2201 {
2202 case EF_ARM_BE8:
2203 strcat (buf, ", BE8");
2204 break;
2205
2206 case EF_ARM_LE8:
2207 strcat (buf, ", LE8");
2208 break;
2209
2210 default:
2211 unknown = 1;
2212 break;
2213 }
2214 break;
2215 }
2216 break;
3a4a14e9
PB		 2217
2218 case EF_ARM_EABI_VER5:
2219 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2220 while (e_flags)
2221 {
2222 unsigned flag;
2223
2224 /* Process flags one bit at a time. */
2225 flag = e_flags & - e_flags;
2226 e_flags &= ~ flag;
2227
2228 switch (flag)
2229 {
2230 case EF_ARM_BE8:
2231 strcat (buf, ", BE8");
2232 break;
2233
2234 case EF_ARM_LE8:
2235 strcat (buf, ", LE8");
2236 break;
2237
3bfcb652
NC		 2238 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2239 strcat (buf, ", soft-float ABI");
2240 break;
2241
2242 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2243 strcat (buf, ", hard-float ABI");
2244 break;
2245
d507cf36
PB		 2246 default:
2247 unknown = 1;
2248 break;
2249 }
2250 }
2251 break;
2252
f3485b74 2253 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2254 strcat (buf, ", GNU EABI");
f3485b74
NC		 2255 while (e_flags)
2256 {
2257 unsigned flag;
76da6bbe 2258
f3485b74
NC		 2259 /* Process flags one bit at a time. */
2260 flag = e_flags & - e_flags;
2261 e_flags &= ~ flag;
76da6bbe 2262
f3485b74
NC		 2263 switch (flag)
2264 {
a5bcd848 2265 case EF_ARM_INTERWORK:
f3485b74
NC		 2266 strcat (buf, ", interworking enabled");
2267 break;
76da6bbe 2268
a5bcd848 2269 case EF_ARM_APCS_26:
f3485b74
NC		 2270 strcat (buf, ", uses APCS/26");
2271 break;
76da6bbe 2272
a5bcd848 2273 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2274 strcat (buf, ", uses APCS/float");
2275 break;
76da6bbe 2276
a5bcd848 2277 case EF_ARM_PIC:
f3485b74
NC		 2278 strcat (buf, ", position independent");
2279 break;
76da6bbe 2280
a5bcd848 2281 case EF_ARM_ALIGN8:
f3485b74
NC		 2282 strcat (buf, ", 8 bit structure alignment");
2283 break;
76da6bbe 2284
a5bcd848 2285 case EF_ARM_NEW_ABI:
f3485b74
NC		 2286 strcat (buf, ", uses new ABI");
2287 break;
76da6bbe 2288
a5bcd848 2289 case EF_ARM_OLD_ABI:
f3485b74
NC		 2290 strcat (buf, ", uses old ABI");
2291 break;
76da6bbe 2292
a5bcd848 2293 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2294 strcat (buf, ", software FP");
2295 break;
76da6bbe 2296
90e01f86
ILT		 2297 case EF_ARM_VFP_FLOAT:
2298 strcat (buf, ", VFP");
2299 break;
2300
fde78edd
NC		 2301 case EF_ARM_MAVERICK_FLOAT:
2302 strcat (buf, ", Maverick FP");
2303 break;
2304
f3485b74
NC		 2305 default:
2306 unknown = 1;
2307 break;
2308 }
2309 }
2310 }
f3485b74
NC		 2311
2312 if (unknown)
2b692964 2313 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2314}
2315
35c08157
KLC		 2316static void
2317decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2318{
2319 unsigned abi;
2320 unsigned arch;
2321 unsigned config;
2322 unsigned version;
2323 int has_fpu = 0;
2324 int r = 0;
2325
2326 static const char *ABI_STRINGS[] =
2327 {
2328 "ABI v0", /* use r5 as return register; only used in N1213HC */
2329 "ABI v1", /* use r0 as return register */
2330 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2331 "ABI v2fp", /* for FPU */
2332 "AABI"
2333 };
2334 static const char *VER_STRINGS[] =
2335 {
2336 "Andes ELF V1.3 or older",
2337 "Andes ELF V1.3.1",
2338 "Andes ELF V1.4"
2339 };
2340 static const char *ARCH_STRINGS[] =
2341 {
2342 "",
2343 "Andes Star v1.0",
2344 "Andes Star v2.0",
2345 "Andes Star v3.0",
2346 "Andes Star v3.0m"
2347 };
2348
2349 abi = EF_NDS_ABI & e_flags;
2350 arch = EF_NDS_ARCH & e_flags;
2351 config = EF_NDS_INST & e_flags;
2352 version = EF_NDS32_ELF_VERSION & e_flags;
2353
2354 memset (buf, 0, size);
2355
2356 switch (abi)
2357 {
2358 case E_NDS_ABI_V0:
2359 case E_NDS_ABI_V1:
2360 case E_NDS_ABI_V2:
2361 case E_NDS_ABI_V2FP:
2362 case E_NDS_ABI_AABI:
2363 /* In case there are holes in the array. */
2364 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2365 break;
2366
2367 default:
2368 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2369 break;
2370 }
2371
2372 switch (version)
2373 {
2374 case E_NDS32_ELF_VER_1_2:
2375 case E_NDS32_ELF_VER_1_3:
2376 case E_NDS32_ELF_VER_1_4:
2377 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2378 break;
2379
2380 default:
2381 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2382 break;
2383 }
2384
2385 if (E_NDS_ABI_V0 == abi)
2386 {
2387 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2388 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2389 if (arch == E_NDS_ARCH_STAR_V1_0)
2390 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2391 return;
2392 }
2393
2394 switch (arch)
2395 {
2396 case E_NDS_ARCH_STAR_V1_0:
2397 case E_NDS_ARCH_STAR_V2_0:
2398 case E_NDS_ARCH_STAR_V3_0:
2399 case E_NDS_ARCH_STAR_V3_M:
2400 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2401 break;
2402
2403 default:
2404 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2405 /* ARCH version determines how the e_flags are interpreted.
2406 If it is unknown, we cannot proceed. */
2407 return;
2408 }
2409
2410 /* Newer ABI; Now handle architecture specific flags. */
2411 if (arch == E_NDS_ARCH_STAR_V1_0)
2412 {
2413 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2414 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2415
2416 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2417 r += snprintf (buf + r, size -r, ", MAC");
2418
2419 if (config & E_NDS32_HAS_DIV_INST)
2420 r += snprintf (buf + r, size -r, ", DIV");
2421
2422 if (config & E_NDS32_HAS_16BIT_INST)
2423 r += snprintf (buf + r, size -r, ", 16b");
2424 }
2425 else
2426 {
2427 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2428 {
2429 if (version <= E_NDS32_ELF_VER_1_3)
2430 r += snprintf (buf + r, size -r, ", [B8]");
2431 else
2432 r += snprintf (buf + r, size -r, ", EX9");
2433 }
2434
2435 if (config & E_NDS32_HAS_MAC_DX_INST)
2436 r += snprintf (buf + r, size -r, ", MAC_DX");
2437
2438 if (config & E_NDS32_HAS_DIV_DX_INST)
2439 r += snprintf (buf + r, size -r, ", DIV_DX");
2440
2441 if (config & E_NDS32_HAS_16BIT_INST)
2442 {
2443 if (version <= E_NDS32_ELF_VER_1_3)
2444 r += snprintf (buf + r, size -r, ", 16b");
2445 else
2446 r += snprintf (buf + r, size -r, ", IFC");
2447 }
2448 }
2449
2450 if (config & E_NDS32_HAS_EXT_INST)
2451 r += snprintf (buf + r, size -r, ", PERF1");
2452
2453 if (config & E_NDS32_HAS_EXT2_INST)
2454 r += snprintf (buf + r, size -r, ", PERF2");
2455
2456 if (config & E_NDS32_HAS_FPU_INST)
2457 {
2458 has_fpu = 1;
2459 r += snprintf (buf + r, size -r, ", FPU_SP");
2460 }
2461
2462 if (config & E_NDS32_HAS_FPU_DP_INST)
2463 {
2464 has_fpu = 1;
2465 r += snprintf (buf + r, size -r, ", FPU_DP");
2466 }
2467
2468 if (config & E_NDS32_HAS_FPU_MAC_INST)
2469 {
2470 has_fpu = 1;
2471 r += snprintf (buf + r, size -r, ", FPU_MAC");
2472 }
2473
2474 if (has_fpu)
2475 {
2476 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2477 {
2478 case E_NDS32_FPU_REG_8SP_4DP:
2479 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2480 break;
2481 case E_NDS32_FPU_REG_16SP_8DP:
2482 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2483 break;
2484 case E_NDS32_FPU_REG_32SP_16DP:
2485 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2486 break;
2487 case E_NDS32_FPU_REG_32SP_32DP:
2488 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2489 break;
2490 }
2491 }
2492
2493 if (config & E_NDS32_HAS_AUDIO_INST)
2494 r += snprintf (buf + r, size -r, ", AUDIO");
2495
2496 if (config & E_NDS32_HAS_STRING_INST)
2497 r += snprintf (buf + r, size -r, ", STR");
2498
2499 if (config & E_NDS32_HAS_REDUCED_REGS)
2500 r += snprintf (buf + r, size -r, ", 16REG");
2501
2502 if (config & E_NDS32_HAS_VIDEO_INST)
2503 {
2504 if (version <= E_NDS32_ELF_VER_1_3)
2505 r += snprintf (buf + r, size -r, ", VIDEO");
2506 else
2507 r += snprintf (buf + r, size -r, ", SATURATION");
2508 }
2509
2510 if (config & E_NDS32_HAS_ENCRIPT_INST)
2511 r += snprintf (buf + r, size -r, ", ENCRP");
2512
2513 if (config & E_NDS32_HAS_L2C_INST)
2514 r += snprintf (buf + r, size -r, ", L2C");
2515}
2516
252b5132 2517static char *
d3ba0551 2518get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2519{
b34976b6 2520 static char buf[1024];
252b5132
RH		 2521
2522 buf[0] = '\0';
76da6bbe 2523
252b5132
RH		 2524 if (e_flags)
2525 {
2526 switch (e_machine)
2527 {
2528 default:
2529 break;
2530
f3485b74
NC		 2531 case EM_ARM:
2532 decode_ARM_machine_flags (e_flags, buf);
2533 break;
76da6bbe 2534
781303ce
MF		 2535 case EM_BLACKFIN:
2536 if (e_flags & EF_BFIN_PIC)
2537 strcat (buf, ", PIC");
2538
2539 if (e_flags & EF_BFIN_FDPIC)
2540 strcat (buf, ", FDPIC");
2541
2542 if (e_flags & EF_BFIN_CODE_IN_L1)
2543 strcat (buf, ", code in L1");
2544
2545 if (e_flags & EF_BFIN_DATA_IN_L1)
2546 strcat (buf, ", data in L1");
2547
2548 break;
2549
ec2dfb42
AO		 2550 case EM_CYGNUS_FRV:
2551 switch (e_flags & EF_FRV_CPU_MASK)
2552 {
2553 case EF_FRV_CPU_GENERIC:
2554 break;
2555
2556 default:
2557 strcat (buf, ", fr???");
2558 break;
57346661 2559
ec2dfb42
AO		 2560 case EF_FRV_CPU_FR300:
2561 strcat (buf, ", fr300");
2562 break;
2563
2564 case EF_FRV_CPU_FR400:
2565 strcat (buf, ", fr400");
2566 break;
2567 case EF_FRV_CPU_FR405:
2568 strcat (buf, ", fr405");
2569 break;
2570
2571 case EF_FRV_CPU_FR450:
2572 strcat (buf, ", fr450");
2573 break;
2574
2575 case EF_FRV_CPU_FR500:
2576 strcat (buf, ", fr500");
2577 break;
2578 case EF_FRV_CPU_FR550:
2579 strcat (buf, ", fr550");
2580 break;
2581
2582 case EF_FRV_CPU_SIMPLE:
2583 strcat (buf, ", simple");
2584 break;
2585 case EF_FRV_CPU_TOMCAT:
2586 strcat (buf, ", tomcat");
2587 break;
2588 }
1c877e87 2589 break;
ec2dfb42 2590
53c7db4b 2591 case EM_68K:
425c6cb0 2592 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2593 strcat (buf, ", m68000");
425c6cb0 2594 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2595 strcat (buf, ", cpu32");
2596 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2597 strcat (buf, ", fido_a");
425c6cb0 2598 else
266abb8f 2599 {
2cf0635d
NC		 2600 char const * isa = _("unknown");
2601 char const * mac = _("unknown mac");
2602 char const * additional = NULL;
0112cd26 2603
c694fd50 2604 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2605 {
c694fd50 2606 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2607 isa = "A";
2608 additional = ", nodiv";
2609 break;
c694fd50 2610 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2611 isa = "A";
2612 break;
c694fd50 2613 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2614 isa = "A+";
2615 break;
c694fd50 2616 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2617 isa = "B";
2618 additional = ", nousp";
2619 break;
c694fd50 2620 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2621 isa = "B";
2622 break;
f608cd77
NS		 2623 case EF_M68K_CF_ISA_C:
2624 isa = "C";
2625 break;
2626 case EF_M68K_CF_ISA_C_NODIV:
2627 isa = "C";
2628 additional = ", nodiv";
2629 break;
266abb8f
NS		 2630 }
2631 strcat (buf, ", cf, isa ");
2632 strcat (buf, isa);
0b2e31dc
NS		 2633 if (additional)
2634 strcat (buf, additional);
c694fd50 2635 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2636 strcat (buf, ", float");
c694fd50 2637 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2638 {
2639 case 0:
2640 mac = NULL;
2641 break;
c694fd50 2642 case EF_M68K_CF_MAC:
266abb8f
NS		 2643 mac = "mac";
2644 break;
c694fd50 2645 case EF_M68K_CF_EMAC:
266abb8f
NS		 2646 mac = "emac";
2647 break;
f608cd77
NS		 2648 case EF_M68K_CF_EMAC_B:
2649 mac = "emac_b";
2650 break;
266abb8f
NS		 2651 }
2652 if (mac)
2653 {
2654 strcat (buf, ", ");
2655 strcat (buf, mac);
2656 }
266abb8f 2657 }
53c7db4b 2658 break;
33c63f9d 2659
252b5132
RH		 2660 case EM_PPC:
2661 if (e_flags & EF_PPC_EMB)
2662 strcat (buf, ", emb");
2663
2664 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2665 strcat (buf, _(", relocatable"));
252b5132
RH		 2666
2667 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2668 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2669 break;
2670
ee67d69a
AM		 2671 case EM_PPC64:
2672 if (e_flags & EF_PPC64_ABI)
2673 {
2674 char abi[] = ", abiv0";
2675
2676 abi[6] += e_flags & EF_PPC64_ABI;
2677 strcat (buf, abi);
2678 }
2679 break;
2680
708e2187
NC		 2681 case EM_V800:
2682 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2683 strcat (buf, ", RH850 ABI");
0b4362b0 2684
708e2187
NC		 2685 if (e_flags & EF_V800_850E3)
2686 strcat (buf, ", V3 architecture");
2687
2688 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2689 strcat (buf, ", FPU not used");
2690
2691 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2692 strcat (buf, ", regmode: COMMON");
2693
2694 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2695 strcat (buf, ", r4 not used");
2696
2697 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2698 strcat (buf, ", r30 not used");
2699
2700 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2701 strcat (buf, ", r5 not used");
2702
2703 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2704 strcat (buf, ", r2 not used");
2705
2706 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2707 {
2708 switch (e_flags & - e_flags)
2709 {
2710 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2711 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2712 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2713 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2714 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2715 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2716 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2717 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2718 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2719 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2720 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2721 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2722 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2723 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2724 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2725 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2726 default: break;
2727 }
2728 }
2729 break;
2730
2b0337b0 2731 case EM_V850:
252b5132
RH		 2732 case EM_CYGNUS_V850:
2733 switch (e_flags & EF_V850_ARCH)
2734 {
78c8d46c
NC		 2735 case E_V850E3V5_ARCH:
2736 strcat (buf, ", v850e3v5");
2737 break;
1cd986c5
NC		 2738 case E_V850E2V3_ARCH:
2739 strcat (buf, ", v850e2v3");
2740 break;
2741 case E_V850E2_ARCH:
2742 strcat (buf, ", v850e2");
2743 break;
2744 case E_V850E1_ARCH:
2745 strcat (buf, ", v850e1");
8ad30312 2746 break;
252b5132
RH		 2747 case E_V850E_ARCH:
2748 strcat (buf, ", v850e");
2749 break;
252b5132
RH		 2750 case E_V850_ARCH:
2751 strcat (buf, ", v850");
2752 break;
2753 default:
2b692964 2754 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2755 break;
2756 }
2757 break;
2758
2b0337b0 2759 case EM_M32R:
252b5132
RH		 2760 case EM_CYGNUS_M32R:
2761 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2762 strcat (buf, ", m32r");
252b5132
RH		 2763 break;
2764
2765 case EM_MIPS:
4fe85591 2766 case EM_MIPS_RS3_LE:
252b5132
RH		 2767 if (e_flags & EF_MIPS_NOREORDER)
2768 strcat (buf, ", noreorder");
2769
2770 if (e_flags & EF_MIPS_PIC)
2771 strcat (buf, ", pic");
2772
2773 if (e_flags & EF_MIPS_CPIC)
2774 strcat (buf, ", cpic");
2775
d1bdd336
TS		 2776 if (e_flags & EF_MIPS_UCODE)
2777 strcat (buf, ", ugen_reserved");
2778
252b5132
RH		 2779 if (e_flags & EF_MIPS_ABI2)
2780 strcat (buf, ", abi2");
2781
43521d43
TS		 2782 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2783 strcat (buf, ", odk first");
2784
a5d22d2a
TS		 2785 if (e_flags & EF_MIPS_32BITMODE)
2786 strcat (buf, ", 32bitmode");
2787
ba92f887
MR		 2788 if (e_flags & EF_MIPS_NAN2008)
2789 strcat (buf, ", nan2008");
2790
fef1b0b3
SE		 2791 if (e_flags & EF_MIPS_FP64)
2792 strcat (buf, ", fp64");
2793
156c2f8b
NC		 2794 switch ((e_flags & EF_MIPS_MACH))
2795 {
2796 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2797 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2798 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2799 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2800 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2801 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2802 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2803 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2804 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2805 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2806 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2807 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2808 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2809 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2810 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2811 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2812 case 0:
2813 /* We simply ignore the field in this case to avoid confusion:
2814 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2815 extension. */
2816 break;
2b692964 2817 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2818 }
43521d43
TS		 2819
2820 switch ((e_flags & EF_MIPS_ABI))
2821 {
2822 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2823 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2824 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2825 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2826 case 0:
2827 /* We simply ignore the field in this case to avoid confusion:
2828 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2829 This means it is likely to be an o32 file, but not for
2830 sure. */
2831 break;
2b692964 2832 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2833 }
2834
2835 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2836 strcat (buf, ", mdmx");
2837
2838 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2839 strcat (buf, ", mips16");
2840
df58fc94
RS		 2841 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2842 strcat (buf, ", micromips");
2843
43521d43
TS		 2844 switch ((e_flags & EF_MIPS_ARCH))
2845 {
2846 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2847 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2848 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2849 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2850 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2851 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2852 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2853 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2854 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2855 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2856 }
252b5132 2857 break;
351b4b40 2858
35c08157
KLC		 2859 case EM_NDS32:
2860 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2861 break;
2862
ccde1100
AO		 2863 case EM_SH:
2864 switch ((e_flags & EF_SH_MACH_MASK))
2865 {
2866 case EF_SH1: strcat (buf, ", sh1"); break;
2867 case EF_SH2: strcat (buf, ", sh2"); break;
2868 case EF_SH3: strcat (buf, ", sh3"); break;
2869 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2870 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2871 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2872 case EF_SH3E: strcat (buf, ", sh3e"); break;
2873 case EF_SH4: strcat (buf, ", sh4"); break;
2874 case EF_SH5: strcat (buf, ", sh5"); break;
2875 case EF_SH2E: strcat (buf, ", sh2e"); break;
2876 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2877 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2878 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2879 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2880 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2881 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2882 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2883 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2884 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2885 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2886 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2887 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2888 }
2889
cec6a5b8
MR		 2890 if (e_flags & EF_SH_PIC)
2891 strcat (buf, ", pic");
2892
2893 if (e_flags & EF_SH_FDPIC)
2894 strcat (buf, ", fdpic");
ccde1100 2895 break;
57346661 2896
351b4b40
RH		 2897 case EM_SPARCV9:
2898 if (e_flags & EF_SPARC_32PLUS)
2899 strcat (buf, ", v8+");
2900
2901 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2902 strcat (buf, ", ultrasparcI");
2903
2904 if (e_flags & EF_SPARC_SUN_US3)
2905 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2906
2907 if (e_flags & EF_SPARC_HAL_R1)
2908 strcat (buf, ", halr1");
2909
2910 if (e_flags & EF_SPARC_LEDATA)
2911 strcat (buf, ", ledata");
2912
2913 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2914 strcat (buf, ", tso");
2915
2916 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2917 strcat (buf, ", pso");
2918
2919 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2920 strcat (buf, ", rmo");
2921 break;
7d466069 2922
103f02d3
UD		 2923 case EM_PARISC:
2924 switch (e_flags & EF_PARISC_ARCH)
2925 {
2926 case EFA_PARISC_1_0:
2927 strcpy (buf, ", PA-RISC 1.0");
2928 break;
2929 case EFA_PARISC_1_1:
2930 strcpy (buf, ", PA-RISC 1.1");
2931 break;
2932 case EFA_PARISC_2_0:
2933 strcpy (buf, ", PA-RISC 2.0");
2934 break;
2935 default:
2936 break;
2937 }
2938 if (e_flags & EF_PARISC_TRAPNIL)
2939 strcat (buf, ", trapnil");
2940 if (e_flags & EF_PARISC_EXT)
2941 strcat (buf, ", ext");
2942 if (e_flags & EF_PARISC_LSB)
2943 strcat (buf, ", lsb");
2944 if (e_flags & EF_PARISC_WIDE)
2945 strcat (buf, ", wide");
2946 if (e_flags & EF_PARISC_NO_KABP)
2947 strcat (buf, ", no kabp");
2948 if (e_flags & EF_PARISC_LAZYSWAP)
2949 strcat (buf, ", lazyswap");
30800947 2950 break;
76da6bbe 2951
7d466069 2952 case EM_PJ:
2b0337b0 2953 case EM_PJ_OLD:
7d466069
ILT		 2954 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2955 strcat (buf, ", new calling convention");
2956
2957 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2958 strcat (buf, ", gnu calling convention");
2959 break;
4d6ed7c8
NC		 2960
2961 case EM_IA_64:
2962 if ((e_flags & EF_IA_64_ABI64))
2963 strcat (buf, ", 64-bit");
2964 else
2965 strcat (buf, ", 32-bit");
2966 if ((e_flags & EF_IA_64_REDUCEDFP))
2967 strcat (buf, ", reduced fp model");
2968 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2969 strcat (buf, ", no function descriptors, constant gp");
2970 else if ((e_flags & EF_IA_64_CONS_GP))
2971 strcat (buf, ", constant gp");
2972 if ((e_flags & EF_IA_64_ABSOLUTE))
2973 strcat (buf, ", absolute");
28f997cf
TG		 2974 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2975 {
2976 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2977 strcat (buf, ", vms_linkages");
2978 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2979 {
2980 case EF_IA_64_VMS_COMCOD_SUCCESS:
2981 break;
2982 case EF_IA_64_VMS_COMCOD_WARNING:
2983 strcat (buf, ", warning");
2984 break;
2985 case EF_IA_64_VMS_COMCOD_ERROR:
2986 strcat (buf, ", error");
2987 break;
2988 case EF_IA_64_VMS_COMCOD_ABORT:
2989 strcat (buf, ", abort");
2990 break;
2991 default:
2992 abort ();
2993 }
2994 }
4d6ed7c8 2995 break;
179d3252
JT		 2996
2997 case EM_VAX:
2998 if ((e_flags & EF_VAX_NONPIC))
2999 strcat (buf, ", non-PIC");
3000 if ((e_flags & EF_VAX_DFLOAT))
3001 strcat (buf, ", D-Float");
3002 if ((e_flags & EF_VAX_GFLOAT))
3003 strcat (buf, ", G-Float");
3004 break;
c7927a3c 3005
4046d87a
NC		 3006 case EM_RL78:
3007 if (e_flags & E_FLAG_RL78_G10)
3008 strcat (buf, ", G10");
3009 break;
0b4362b0 3010
c7927a3c
NC		 3011 case EM_RX:
3012 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3013 strcat (buf, ", 64-bit doubles");
3014 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3015 strcat (buf, ", dsp");
d4cb0ea0 3016 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3017 strcat (buf, ", pid");
708e2187
NC		 3018 if (e_flags & E_FLAG_RX_ABI)
3019 strcat (buf, ", RX ABI");
d4cb0ea0 3020 break;
55786da2
AK		 3021
3022 case EM_S390:
3023 if (e_flags & EF_S390_HIGH_GPRS)
3024 strcat (buf, ", highgprs");
d4cb0ea0 3025 break;
40b36596
JM		 3026
3027 case EM_TI_C6000:
3028 if ((e_flags & EF_C6000_REL))
3029 strcat (buf, ", relocatable module");
d4cb0ea0 3030 break;
13761a11
NC		 3031
3032 case EM_MSP430:
3033 strcat (buf, _(": architecture variant: "));
3034 switch (e_flags & EF_MSP430_MACH)
3035 {
3036 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3037 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3038 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3039 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3040 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3041 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3042 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3043 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3044 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3045 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3046 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3047 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3048 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3049 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3050 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3051 default:
3052 strcat (buf, _(": unknown")); break;
3053 }
3054
3055 if (e_flags & ~ EF_MSP430_MACH)
3056 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3057 }
3058 }
3059
3060 return buf;
3061}
3062
252b5132 3063static const char *
d3ba0551
AM		 3064get_osabi_name (unsigned int osabi)
3065{
3066 static char buff[32];
3067
3068 switch (osabi)
3069 {
3070 case ELFOSABI_NONE: return "UNIX - System V";
3071 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3072 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3073 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3074 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3075 case ELFOSABI_AIX: return "UNIX - AIX";
3076 case ELFOSABI_IRIX: return "UNIX - IRIX";
3077 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3078 case ELFOSABI_TRU64: return "UNIX - TRU64";
3079 case ELFOSABI_MODESTO: return "Novell - Modesto";
3080 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3081 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3082 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3083 case ELFOSABI_AROS: return "AROS";
11636f9e 3084 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3085 default:
40b36596
JM		 3086 if (osabi >= 64)
3087 switch (elf_header.e_machine)
3088 {
3089 case EM_ARM:
3090 switch (osabi)
3091 {
3092 case ELFOSABI_ARM: return "ARM";
3093 default:
3094 break;
3095 }
3096 break;
3097
3098 case EM_MSP430:
3099 case EM_MSP430_OLD:
3100 switch (osabi)
3101 {
3102 case ELFOSABI_STANDALONE: return _("Standalone App");
3103 default:
3104 break;
3105 }
3106 break;
3107
3108 case EM_TI_C6000:
3109 switch (osabi)
3110 {
3111 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3112 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3113 default:
3114 break;
3115 }
3116 break;
3117
3118 default:
3119 break;
3120 }
e9e44622 3121 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3122 return buff;
3123 }
3124}
3125
a06ea964
NC		 3126static const char *
3127get_aarch64_segment_type (unsigned long type)
3128{
3129 switch (type)
3130 {
3131 case PT_AARCH64_ARCHEXT:
3132 return "AARCH64_ARCHEXT";
3133 default:
3134 break;
3135 }
3136
3137 return NULL;
3138}
3139
b294bdf8
MM		 3140static const char *
3141get_arm_segment_type (unsigned long type)
3142{
3143 switch (type)
3144 {
3145 case PT_ARM_EXIDX:
3146 return "EXIDX";
3147 default:
3148 break;
3149 }
3150
3151 return NULL;
3152}
3153
d3ba0551
AM		 3154static const char *
3155get_mips_segment_type (unsigned long type)
252b5132
RH		 3156{
3157 switch (type)
3158 {
3159 case PT_MIPS_REGINFO:
3160 return "REGINFO";
3161 case PT_MIPS_RTPROC:
3162 return "RTPROC";
3163 case PT_MIPS_OPTIONS:
3164 return "OPTIONS";
3165 default:
3166 break;
3167 }
3168
3169 return NULL;
3170}
3171
103f02d3 3172static const char *
d3ba0551 3173get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3174{
3175 switch (type)
3176 {
3177 case PT_HP_TLS: return "HP_TLS";
3178 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3179 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3180 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3181 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3182 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3183 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3184 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3185 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3186 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3187 case PT_HP_PARALLEL: return "HP_PARALLEL";
3188 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3189 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3190 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3191 case PT_HP_STACK: return "HP_STACK";
3192 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3193 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3194 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3195 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3196 default:
3197 break;
3198 }
3199
3200 return NULL;
3201}
3202
4d6ed7c8 3203static const char *
d3ba0551 3204get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3205{
3206 switch (type)
3207 {
3208 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3209 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3210 case PT_HP_TLS: return "HP_TLS";
3211 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3212 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3213 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3214 default:
3215 break;
3216 }
3217
3218 return NULL;
3219}
3220
40b36596
JM		 3221static const char *
3222get_tic6x_segment_type (unsigned long type)
3223{
3224 switch (type)
3225 {
3226 case PT_C6000_PHATTR: return "C6000_PHATTR";
3227 default:
3228 break;
3229 }
3230
3231 return NULL;
3232}
3233
252b5132 3234static const char *
d3ba0551 3235get_segment_type (unsigned long p_type)
252b5132 3236{
b34976b6 3237 static char buff[32];
252b5132
RH		 3238
3239 switch (p_type)
3240 {
b34976b6
AM		 3241 case PT_NULL: return "NULL";
3242 case PT_LOAD: return "LOAD";
252b5132 3243 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3244 case PT_INTERP: return "INTERP";
3245 case PT_NOTE: return "NOTE";
3246 case PT_SHLIB: return "SHLIB";
3247 case PT_PHDR: return "PHDR";
13ae64f3 3248 case PT_TLS: return "TLS";
252b5132 3249
65765700
JJ		 3250 case PT_GNU_EH_FRAME:
3251 return "GNU_EH_FRAME";
2b05f1b7 3252 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3253 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3254
252b5132
RH		 3255 default:
3256 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3257 {
2cf0635d 3258 const char * result;
103f02d3 3259
252b5132
RH		 3260 switch (elf_header.e_machine)
3261 {
a06ea964
NC		 3262 case EM_AARCH64:
3263 result = get_aarch64_segment_type (p_type);
3264 break;
b294bdf8
MM		 3265 case EM_ARM:
3266 result = get_arm_segment_type (p_type);
3267 break;
252b5132 3268 case EM_MIPS:
4fe85591 3269 case EM_MIPS_RS3_LE:
252b5132
RH		 3270 result = get_mips_segment_type (p_type);
3271 break;
103f02d3
UD		 3272 case EM_PARISC:
3273 result = get_parisc_segment_type (p_type);
3274 break;
4d6ed7c8
NC		 3275 case EM_IA_64:
3276 result = get_ia64_segment_type (p_type);
3277 break;
40b36596
JM		 3278 case EM_TI_C6000:
3279 result = get_tic6x_segment_type (p_type);
3280 break;
252b5132
RH		 3281 default:
3282 result = NULL;
3283 break;
3284 }
103f02d3 3285
252b5132
RH		 3286 if (result != NULL)
3287 return result;
103f02d3 3288
252b5132
RH		 3289 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3290 }
3291 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3292 {
2cf0635d 3293 const char * result;
103f02d3
UD		 3294
3295 switch (elf_header.e_machine)
3296 {
3297 case EM_PARISC:
3298 result = get_parisc_segment_type (p_type);
3299 break;
00428cca
AM		 3300 case EM_IA_64:
3301 result = get_ia64_segment_type (p_type);
3302 break;
103f02d3
UD		 3303 default:
3304 result = NULL;
3305 break;
3306 }
3307
3308 if (result != NULL)
3309 return result;
3310
3311 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3312 }
252b5132 3313 else
e9e44622 3314 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3315
3316 return buff;
3317 }
3318}
3319
3320static const char *
d3ba0551 3321get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3322{
3323 switch (sh_type)
3324 {
b34976b6
AM		 3325 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3326 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3327 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3328 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3329 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3330 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3331 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3332 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3333 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3334 case SHT_MIPS_RELD: return "MIPS_RELD";
3335 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3336 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3337 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3338 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3339 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3340 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3341 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3342 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3343 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3344 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3345 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3346 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3347 case SHT_MIPS_LINE: return "MIPS_LINE";
3348 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3349 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3350 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3351 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3352 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3353 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3354 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3355 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3356 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3357 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3358 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3359 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3360 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3361 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3362 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 3363 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3364 default:
3365 break;
3366 }
3367 return NULL;
3368}
3369
103f02d3 3370static const char *
d3ba0551 3371get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3372{
3373 switch (sh_type)
3374 {
3375 case SHT_PARISC_EXT: return "PARISC_EXT";
3376 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3377 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3378 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3379 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3380 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3381 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3382 default:
3383 break;
3384 }
3385 return NULL;
3386}
3387
4d6ed7c8 3388static const char *
d3ba0551 3389get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3390{
18bd398b 3391 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3392 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3393 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3394
4d6ed7c8
NC		 3395 switch (sh_type)
3396 {
148b93f2
NC		 3397 case SHT_IA_64_EXT: return "IA_64_EXT";
3398 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3399 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3400 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3401 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3402 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3403 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3404 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3405 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3406 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3407 default:
3408 break;
3409 }
3410 return NULL;
3411}
3412
d2b2c203
DJ		 3413static const char *
3414get_x86_64_section_type_name (unsigned int sh_type)
3415{
3416 switch (sh_type)
3417 {
3418 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3419 default:
3420 break;
3421 }
3422 return NULL;
3423}
3424
a06ea964
NC		 3425static const char *
3426get_aarch64_section_type_name (unsigned int sh_type)
3427{
3428 switch (sh_type)
3429 {
3430 case SHT_AARCH64_ATTRIBUTES:
3431 return "AARCH64_ATTRIBUTES";
3432 default:
3433 break;
3434 }
3435 return NULL;
3436}
3437
40a18ebd
NC		 3438static const char *
3439get_arm_section_type_name (unsigned int sh_type)
3440{
3441 switch (sh_type)
3442 {
7f6fed87
NC		 3443 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3444 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3445 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3446 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3447 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3448 default:
3449 break;
3450 }
3451 return NULL;
3452}
3453
40b36596
JM		 3454static const char *
3455get_tic6x_section_type_name (unsigned int sh_type)
3456{
3457 switch (sh_type)
3458 {
3459 case SHT_C6000_UNWIND:
3460 return "C6000_UNWIND";
3461 case SHT_C6000_PREEMPTMAP:
3462 return "C6000_PREEMPTMAP";
3463 case SHT_C6000_ATTRIBUTES:
3464 return "C6000_ATTRIBUTES";
3465 case SHT_TI_ICODE:
3466 return "TI_ICODE";
3467 case SHT_TI_XREF:
3468 return "TI_XREF";
3469 case SHT_TI_HANDLER:
3470 return "TI_HANDLER";
3471 case SHT_TI_INITINFO:
3472 return "TI_INITINFO";
3473 case SHT_TI_PHATTRS:
3474 return "TI_PHATTRS";
3475 default:
3476 break;
3477 }
3478 return NULL;
3479}
3480
13761a11
NC		 3481static const char *
3482get_msp430x_section_type_name (unsigned int sh_type)
3483{
3484 switch (sh_type)
3485 {
3486 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3487 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3488 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3489 default: return NULL;
3490 }
3491}
3492
252b5132 3493static const char *
d3ba0551 3494get_section_type_name (unsigned int sh_type)
252b5132 3495{
b34976b6 3496 static char buff[32];
252b5132
RH		 3497
3498 switch (sh_type)
3499 {
3500 case SHT_NULL: return "NULL";
3501 case SHT_PROGBITS: return "PROGBITS";
3502 case SHT_SYMTAB: return "SYMTAB";
3503 case SHT_STRTAB: return "STRTAB";
3504 case SHT_RELA: return "RELA";
3505 case SHT_HASH: return "HASH";
3506 case SHT_DYNAMIC: return "DYNAMIC";
3507 case SHT_NOTE: return "NOTE";
3508 case SHT_NOBITS: return "NOBITS";
3509 case SHT_REL: return "REL";
3510 case SHT_SHLIB: return "SHLIB";
3511 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3512 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3513 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3514 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3515 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3516 case SHT_GROUP: return "GROUP";
3517 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3518 case SHT_GNU_verdef: return "VERDEF";
3519 case SHT_GNU_verneed: return "VERNEED";
3520 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3521 case 0x6ffffff0: return "VERSYM";
3522 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3523 case 0x7ffffffd: return "AUXILIARY";
3524 case 0x7fffffff: return "FILTER";
047b2264 3525 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3526
3527 default:
3528 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3529 {
2cf0635d 3530 const char * result;
252b5132
RH		 3531
3532 switch (elf_header.e_machine)
3533 {
3534 case EM_MIPS:
4fe85591 3535 case EM_MIPS_RS3_LE:
252b5132
RH		 3536 result = get_mips_section_type_name (sh_type);
3537 break;
103f02d3
UD		 3538 case EM_PARISC:
3539 result = get_parisc_section_type_name (sh_type);
3540 break;
4d6ed7c8
NC		 3541 case EM_IA_64:
3542 result = get_ia64_section_type_name (sh_type);
3543 break;
d2b2c203 3544 case EM_X86_64:
8a9036a4 3545 case EM_L1OM:
7a9068fe 3546 case EM_K1OM:
d2b2c203
DJ		 3547 result = get_x86_64_section_type_name (sh_type);
3548 break;
a06ea964
NC		 3549 case EM_AARCH64:
3550 result = get_aarch64_section_type_name (sh_type);
3551 break;
40a18ebd
NC		 3552 case EM_ARM:
3553 result = get_arm_section_type_name (sh_type);
3554 break;
40b36596
JM		 3555 case EM_TI_C6000:
3556 result = get_tic6x_section_type_name (sh_type);
3557 break;
13761a11
NC		 3558 case EM_MSP430:
3559 result = get_msp430x_section_type_name (sh_type);
3560 break;
252b5132
RH		 3561 default:
3562 result = NULL;
3563 break;
3564 }
3565
3566 if (result != NULL)
3567 return result;
3568
c91d0dfb 3569 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3570 }
3571 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3572 {
2cf0635d 3573 const char * result;
148b93f2
NC		 3574
3575 switch (elf_header.e_machine)
3576 {
3577 case EM_IA_64:
3578 result = get_ia64_section_type_name (sh_type);
3579 break;
3580 default:
3581 result = NULL;
3582 break;
3583 }
3584
3585 if (result != NULL)
3586 return result;
3587
3588 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3589 }
252b5132 3590 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3591 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3592 else
a7dbfd1c
NC		 3593 /* This message is probably going to be displayed in a 15
3594 character wide field, so put the hex value first. */
3595 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3596
252b5132
RH		 3597 return buff;
3598 }
3599}
3600
2979dc34 3601#define OPTION_DEBUG_DUMP 512
2c610e4b 3602#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3603#define OPTION_DWARF_DEPTH 514
3604#define OPTION_DWARF_START 515
4723351a 3605#define OPTION_DWARF_CHECK 516
2979dc34 3606
85b1c36d 3607static struct option options[] =
252b5132 3608{
b34976b6 3609 {"all", no_argument, 0, 'a'},
252b5132
RH		 3610 {"file-header", no_argument, 0, 'h'},
3611 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3612 {"headers", no_argument, 0, 'e'},
3613 {"histogram", no_argument, 0, 'I'},
3614 {"segments", no_argument, 0, 'l'},
3615 {"sections", no_argument, 0, 'S'},
252b5132 3616 {"section-headers", no_argument, 0, 'S'},
f5842774 3617 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3618 {"section-details", no_argument, 0, 't'},
595cf52e 3619 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3620 {"symbols", no_argument, 0, 's'},
3621 {"syms", no_argument, 0, 's'},
2c610e4b 3622 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3623 {"relocs", no_argument, 0, 'r'},
3624 {"notes", no_argument, 0, 'n'},
3625 {"dynamic", no_argument, 0, 'd'},
a952a375 3626 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3627 {"version-info", no_argument, 0, 'V'},
3628 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3629 {"unwind", no_argument, 0, 'u'},
4145f1d5 3630 {"archive-index", no_argument, 0, 'c'},
b34976b6 3631 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3632 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3633 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3634#ifdef SUPPORT_DISASSEMBLY
3635 {"instruction-dump", required_argument, 0, 'i'},
3636#endif
cf13d699 3637 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3638
fd2f0033
TT		 3639 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3640 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3641 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3642
b34976b6
AM		 3643 {"version", no_argument, 0, 'v'},
3644 {"wide", no_argument, 0, 'W'},
3645 {"help", no_argument, 0, 'H'},
3646 {0, no_argument, 0, 0}
252b5132
RH		 3647};
3648
3649static void
2cf0635d 3650usage (FILE * stream)
252b5132 3651{
92f01d61
JM		 3652 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3653 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3654 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3655 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3656 -h --file-header Display the ELF file header\n\
3657 -l --program-headers Display the program headers\n\
3658 --segments An alias for --program-headers\n\
3659 -S --section-headers Display the sections' header\n\
3660 --sections An alias for --section-headers\n\
f5842774 3661 -g --section-groups Display the section groups\n\
5477e8a0 3662 -t --section-details Display the section details\n\
8b53311e
NC		 3663 -e --headers Equivalent to: -h -l -S\n\
3664 -s --syms Display the symbol table\n\
3f08eb35 3665 --symbols An alias for --syms\n\
2c610e4b 3666 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3667 -n --notes Display the core notes (if present)\n\
3668 -r --relocs Display the relocations (if present)\n\
3669 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3670 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3671 -V --version-info Display the version sections (if present)\n\
1b31d05e 3672 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3673 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3674 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3675 -x --hex-dump=<number|name>\n\
3676 Dump the contents of section <number|name> as bytes\n\
3677 -p --string-dump=<number|name>\n\
3678 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3679 -R --relocated-dump=<number|name>\n\
3680 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3681 -w[lLiaprmfFsoRt] or\n\
1ed06042 3682 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3683 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3684 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3685 =addr,=cu_index]\n\
8b53311e 3686 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3687 fprintf (stream, _("\
3688 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3689 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3690 or deeper\n"));
252b5132 3691#ifdef SUPPORT_DISASSEMBLY
92f01d61 3692 fprintf (stream, _("\
09c11c86
NC		 3693 -i --instruction-dump=<number|name>\n\
3694 Disassemble the contents of section <number|name>\n"));
252b5132 3695#endif
92f01d61 3696 fprintf (stream, _("\
8b53311e
NC		 3697 -I --histogram Display histogram of bucket list lengths\n\
3698 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3699 @<file> Read options from <file>\n\
8b53311e
NC		 3700 -H --help Display this information\n\
3701 -v --version Display the version number of readelf\n"));
1118d252 3702
92f01d61
JM		 3703 if (REPORT_BUGS_TO[0] && stream == stdout)
3704 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3705
92f01d61 3706 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3707}
3708
18bd398b
NC		 3709/* Record the fact that the user wants the contents of section number
3710 SECTION to be displayed using the method(s) encoded as flags bits
3711 in TYPE. Note, TYPE can be zero if we are creating the array for
3712 the first time. */
3713
252b5132 3714static void
09c11c86 3715request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3716{
3717 if (section >= num_dump_sects)
3718 {
2cf0635d 3719 dump_type * new_dump_sects;
252b5132 3720
3f5e193b
NC		 3721 new_dump_sects = (dump_type *) calloc (section + 1,
3722 sizeof (* dump_sects));
252b5132
RH		 3723
3724 if (new_dump_sects == NULL)
591a748a 3725 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3726 else
3727 {
3728 /* Copy current flag settings. */
09c11c86 3729 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3730
3731 free (dump_sects);
3732
3733 dump_sects = new_dump_sects;
3734 num_dump_sects = section + 1;
3735 }
3736 }
3737
3738 if (dump_sects)
b34976b6 3739 dump_sects[section] |= type;
252b5132
RH		 3740
3741 return;
3742}
3743
aef1f6d0
DJ		 3744/* Request a dump by section name. */
3745
3746static void
2cf0635d 3747request_dump_byname (const char * section, dump_type type)
aef1f6d0 3748{
2cf0635d 3749 struct dump_list_entry * new_request;
aef1f6d0 3750
3f5e193b
NC		 3751 new_request = (struct dump_list_entry *)
3752 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3753 if (!new_request)
591a748a 3754 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3755
3756 new_request->name = strdup (section);
3757 if (!new_request->name)
591a748a 3758 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3759
3760 new_request->type = type;
3761
3762 new_request->next = dump_sects_byname;
3763 dump_sects_byname = new_request;
3764}
3765
cf13d699
NC		 3766static inline void
3767request_dump (dump_type type)
3768{
3769 int section;
3770 char * cp;
3771
3772 do_dump++;
3773 section = strtoul (optarg, & cp, 0);
3774
3775 if (! *cp && section >= 0)
3776 request_dump_bynumber (section, type);
3777 else
3778 request_dump_byname (optarg, type);
3779}
3780
3781
252b5132 3782static void
2cf0635d 3783parse_args (int argc, char ** argv)
252b5132
RH		 3784{
3785 int c;
3786
3787 if (argc < 2)
92f01d61 3788 usage (stderr);
252b5132
RH		 3789
3790 while ((c = getopt_long
cf13d699 3791 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3792 {
252b5132
RH		 3793 switch (c)
3794 {
3795 case 0:
3796 /* Long options. */
3797 break;
3798 case 'H':
92f01d61 3799 usage (stdout);
252b5132
RH		 3800 break;
3801
3802 case 'a':
b34976b6
AM		 3803 do_syms++;
3804 do_reloc++;
3805 do_unwind++;
3806 do_dynamic++;
3807 do_header++;
3808 do_sections++;
f5842774 3809 do_section_groups++;
b34976b6
AM		 3810 do_segments++;
3811 do_version++;
3812 do_histogram++;
3813 do_arch++;
3814 do_notes++;
252b5132 3815 break;
f5842774
L		 3816 case 'g':
3817 do_section_groups++;
3818 break;
5477e8a0 3819 case 't':
595cf52e 3820 case 'N':
5477e8a0
L		 3821 do_sections++;
3822 do_section_details++;
595cf52e 3823 break;
252b5132 3824 case 'e':
b34976b6
AM		 3825 do_header++;
3826 do_sections++;
3827 do_segments++;
252b5132 3828 break;
a952a375 3829 case 'A':
b34976b6 3830 do_arch++;
a952a375 3831 break;
252b5132 3832 case 'D':
b34976b6 3833 do_using_dynamic++;
252b5132
RH		 3834 break;
3835 case 'r':
b34976b6 3836 do_reloc++;
252b5132 3837 break;
4d6ed7c8 3838 case 'u':
b34976b6 3839 do_unwind++;
4d6ed7c8 3840 break;
252b5132 3841 case 'h':
b34976b6 3842 do_header++;
252b5132
RH		 3843 break;
3844 case 'l':
b34976b6 3845 do_segments++;
252b5132
RH		 3846 break;
3847 case 's':
b34976b6 3848 do_syms++;
252b5132
RH		 3849 break;
3850 case 'S':
b34976b6 3851 do_sections++;
252b5132
RH		 3852 break;
3853 case 'd':
b34976b6 3854 do_dynamic++;
252b5132 3855 break;
a952a375 3856 case 'I':
b34976b6 3857 do_histogram++;
a952a375 3858 break;
779fe533 3859 case 'n':
b34976b6 3860 do_notes++;
779fe533 3861 break;
4145f1d5
NC		 3862 case 'c':
3863 do_archive_index++;
3864 break;
252b5132 3865 case 'x':
cf13d699 3866 request_dump (HEX_DUMP);
aef1f6d0 3867 break;
09c11c86 3868 case 'p':
cf13d699
NC		 3869 request_dump (STRING_DUMP);
3870 break;
3871 case 'R':
3872 request_dump (RELOC_DUMP);
09c11c86 3873 break;
252b5132 3874 case 'w':
b34976b6 3875 do_dump++;
252b5132 3876 if (optarg == 0)
613ff48b
CC		 3877 {
3878 do_debugging = 1;
3879 dwarf_select_sections_all ();
3880 }
252b5132
RH		 3881 else
3882 {
3883 do_debugging = 0;
4cb93e3b 3884 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3885 }
3886 break;
2979dc34 3887 case OPTION_DEBUG_DUMP:
b34976b6 3888 do_dump++;
2979dc34
JJ		 3889 if (optarg == 0)
3890 do_debugging = 1;
3891 else
3892 {
2979dc34 3893 do_debugging = 0;
4cb93e3b 3894 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3895 }
3896 break;
fd2f0033
TT		 3897 case OPTION_DWARF_DEPTH:
3898 {
3899 char *cp;
3900
3901 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3902 }
3903 break;
3904 case OPTION_DWARF_START:
3905 {
3906 char *cp;
3907
3908 dwarf_start_die = strtoul (optarg, & cp, 0);
3909 }
3910 break;
4723351a
CC		 3911 case OPTION_DWARF_CHECK:
3912 dwarf_check = 1;
3913 break;
2c610e4b
L		 3914 case OPTION_DYN_SYMS:
3915 do_dyn_syms++;
3916 break;
252b5132
RH		 3917#ifdef SUPPORT_DISASSEMBLY
3918 case 'i':
cf13d699
NC		 3919 request_dump (DISASS_DUMP);
3920 break;
252b5132
RH		 3921#endif
3922 case 'v':
3923 print_version (program_name);
3924 break;
3925 case 'V':
b34976b6 3926 do_version++;
252b5132 3927 break;
d974e256 3928 case 'W':
b34976b6 3929 do_wide++;
d974e256 3930 break;
252b5132 3931 default:
252b5132
RH		 3932 /* xgettext:c-format */
3933 error (_("Invalid option '-%c'\n"), c);
3934 /* Drop through. */
3935 case '?':
92f01d61 3936 usage (stderr);
252b5132
RH		 3937 }
3938 }
3939
4d6ed7c8 3940 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3941 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3942 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3943 && !do_section_groups && !do_archive_index
3944 && !do_dyn_syms)
92f01d61 3945 usage (stderr);
252b5132
RH		 3946 else if (argc < 3)
3947 {
3948 warn (_("Nothing to do.\n"));
92f01d61 3949 usage (stderr);
252b5132
RH		 3950 }
3951}
3952
3953static const char *
d3ba0551 3954get_elf_class (unsigned int elf_class)
252b5132 3955{
b34976b6 3956 static char buff[32];
103f02d3 3957
252b5132
RH		 3958 switch (elf_class)
3959 {
3960 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3961 case ELFCLASS32: return "ELF32";
3962 case ELFCLASS64: return "ELF64";
ab5e7794 3963 default:
e9e44622 3964 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3965 return buff;
252b5132
RH		 3966 }
3967}
3968
3969static const char *
d3ba0551 3970get_data_encoding (unsigned int encoding)
252b5132 3971{
b34976b6 3972 static char buff[32];
103f02d3 3973
252b5132
RH		 3974 switch (encoding)
3975 {
3976 case ELFDATANONE: return _("none");
33c63f9d
CM		 3977 case ELFDATA2LSB: return _("2's complement, little endian");
3978 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3979 default:
e9e44622 3980 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3981 return buff;
252b5132
RH		 3982 }
3983}
3984
252b5132 3985/* Decode the data held in 'elf_header'. */
ee42cf8c 3986
252b5132 3987static int
d3ba0551 3988process_file_header (void)
252b5132 3989{
b34976b6
AM		 3990 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3991 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3992 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3993 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3994 {
3995 error
3996 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3997 return 0;
3998 }
3999
2dc4cec1
L		 4000 init_dwarf_regnames (elf_header.e_machine);
4001
252b5132
RH		 4002 if (do_header)
4003 {
4004 int i;
4005
4006 printf (_("ELF Header:\n"));
4007 printf (_(" Magic: "));
b34976b6
AM		 4008 for (i = 0; i < EI_NIDENT; i++)
4009 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4010 printf ("\n");
4011 printf (_(" Class: %s\n"),
b34976b6 4012 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4013 printf (_(" Data: %s\n"),
b34976b6 4014 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4015 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4016 elf_header.e_ident[EI_VERSION],
4017 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4018 ? "(current)"
b34976b6 4019 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4020 ? _("<unknown: %lx>")
789be9f7 4021 : "")));
252b5132 4022 printf (_(" OS/ABI: %s\n"),
b34976b6 4023 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4024 printf (_(" ABI Version: %d\n"),
b34976b6 4025 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4026 printf (_(" Type: %s\n"),
4027 get_file_type (elf_header.e_type));
4028 printf (_(" Machine: %s\n"),
4029 get_machine_name (elf_header.e_machine));
4030 printf (_(" Version: 0x%lx\n"),
4031 (unsigned long) elf_header.e_version);
76da6bbe 4032
f7a99963
NC		 4033 printf (_(" Entry point address: "));
4034 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4035 printf (_("\n Start of program headers: "));
4036 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4037 printf (_(" (bytes into file)\n Start of section headers: "));
4038 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4039 printf (_(" (bytes into file)\n"));
76da6bbe 4040
252b5132
RH		 4041 printf (_(" Flags: 0x%lx%s\n"),
4042 (unsigned long) elf_header.e_flags,
4043 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4044 printf (_(" Size of this header: %ld (bytes)\n"),
4045 (long) elf_header.e_ehsize);
4046 printf (_(" Size of program headers: %ld (bytes)\n"),
4047 (long) elf_header.e_phentsize);
2046a35d 4048 printf (_(" Number of program headers: %ld"),
252b5132 4049 (long) elf_header.e_phnum);
2046a35d
AM		 4050 if (section_headers != NULL
4051 && elf_header.e_phnum == PN_XNUM
4052 && section_headers[0].sh_info != 0)
cc5914eb 4053 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4054 putc ('\n', stdout);
252b5132
RH		 4055 printf (_(" Size of section headers: %ld (bytes)\n"),
4056 (long) elf_header.e_shentsize);
560f3c1c 4057 printf (_(" Number of section headers: %ld"),
252b5132 4058 (long) elf_header.e_shnum);
4fbb74a6 4059 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4060 printf (" (%ld)", (long) section_headers[0].sh_size);
4061 putc ('\n', stdout);
4062 printf (_(" Section header string table index: %ld"),
252b5132 4063 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4064 if (section_headers != NULL
4065 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4066 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4067 else if (elf_header.e_shstrndx != SHN_UNDEF
4068 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4069 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4070 putc ('\n', stdout);
4071 }
4072
4073 if (section_headers != NULL)
4074 {
2046a35d
AM		 4075 if (elf_header.e_phnum == PN_XNUM
4076 && section_headers[0].sh_info != 0)
4077 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4078 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4079 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4080 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4081 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4082 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4083 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4084 free (section_headers);
4085 section_headers = NULL;
252b5132 4086 }
103f02d3 4087
9ea033b2
NC		 4088 return 1;
4089}
4090
252b5132 4091
9ea033b2 4092static int
91d6fa6a 4093get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4094{
2cf0635d
NC		 4095 Elf32_External_Phdr * phdrs;
4096 Elf32_External_Phdr * external;
4097 Elf_Internal_Phdr * internal;
b34976b6 4098 unsigned int i;
103f02d3 4099
3f5e193b
NC		 4100 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4101 elf_header.e_phentsize,
4102 elf_header.e_phnum,
4103 _("program headers"));
a6e9f9df
AM		 4104 if (!phdrs)
4105 return 0;
9ea033b2 4106
91d6fa6a 4107 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4108 i < elf_header.e_phnum;
b34976b6 4109 i++, internal++, external++)
252b5132 4110 {
9ea033b2
NC		 4111 internal->p_type = BYTE_GET (external->p_type);
4112 internal->p_offset = BYTE_GET (external->p_offset);
4113 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4114 internal->p_paddr = BYTE_GET (external->p_paddr);
4115 internal->p_filesz = BYTE_GET (external->p_filesz);
4116 internal->p_memsz = BYTE_GET (external->p_memsz);
4117 internal->p_flags = BYTE_GET (external->p_flags);
4118 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4119 }
4120
9ea033b2
NC		 4121 free (phdrs);
4122
252b5132
RH		 4123 return 1;
4124}
4125
9ea033b2 4126static int
91d6fa6a 4127get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4128{
2cf0635d
NC		 4129 Elf64_External_Phdr * phdrs;
4130 Elf64_External_Phdr * external;
4131 Elf_Internal_Phdr * internal;
b34976b6 4132 unsigned int i;
103f02d3 4133
3f5e193b
NC		 4134 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4135 elf_header.e_phentsize,
4136 elf_header.e_phnum,
4137 _("program headers"));
a6e9f9df
AM		 4138 if (!phdrs)
4139 return 0;
9ea033b2 4140
91d6fa6a 4141 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4142 i < elf_header.e_phnum;
b34976b6 4143 i++, internal++, external++)
9ea033b2
NC		 4144 {
4145 internal->p_type = BYTE_GET (external->p_type);
4146 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4147 internal->p_offset = BYTE_GET (external->p_offset);
4148 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4149 internal->p_paddr = BYTE_GET (external->p_paddr);
4150 internal->p_filesz = BYTE_GET (external->p_filesz);
4151 internal->p_memsz = BYTE_GET (external->p_memsz);
4152 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4153 }
4154
4155 free (phdrs);
4156
4157 return 1;
4158}
252b5132 4159
d93f0186
NC		 4160/* Returns 1 if the program headers were read into `program_headers'. */
4161
4162static int
2cf0635d 4163get_program_headers (FILE * file)
d93f0186 4164{
2cf0635d 4165 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4166
4167 /* Check cache of prior read. */
4168 if (program_headers != NULL)
4169 return 1;
4170
3f5e193b
NC		 4171 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4172 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4173
4174 if (phdrs == NULL)
4175 {
4176 error (_("Out of memory\n"));
4177 return 0;
4178 }
4179
4180 if (is_32bit_elf
4181 ? get_32bit_program_headers (file, phdrs)
4182 : get_64bit_program_headers (file, phdrs))
4183 {
4184 program_headers = phdrs;
4185 return 1;
4186 }
4187
4188 free (phdrs);
4189 return 0;
4190}
4191
2f62977e
NC		 4192/* Returns 1 if the program headers were loaded. */
4193
252b5132 4194static int
2cf0635d 4195process_program_headers (FILE * file)
252b5132 4196{
2cf0635d 4197 Elf_Internal_Phdr * segment;
b34976b6 4198 unsigned int i;
252b5132
RH		 4199
4200 if (elf_header.e_phnum == 0)
4201 {
82f2dbf7
NC		 4202 /* PR binutils/12467. */
4203 if (elf_header.e_phoff != 0)
4204 warn (_("possibly corrupt ELF header - it has a non-zero program"
4205 " header offset, but no program headers"));
4206 else if (do_segments)
252b5132 4207 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4208 return 0;
252b5132
RH		 4209 }
4210
4211 if (do_segments && !do_header)
4212 {
f7a99963
NC		 4213 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4214 printf (_("Entry point "));
4215 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4216 printf (_("\nThere are %d program headers, starting at offset "),
4217 elf_header.e_phnum);
4218 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4219 printf ("\n");
252b5132
RH		 4220 }
4221
d93f0186 4222 if (! get_program_headers (file))
252b5132 4223 return 0;
103f02d3 4224
252b5132
RH		 4225 if (do_segments)
4226 {
3a1a2036
NC		 4227 if (elf_header.e_phnum > 1)
4228 printf (_("\nProgram Headers:\n"));
4229 else
4230 printf (_("\nProgram Headers:\n"));
76da6bbe 4231
f7a99963
NC		 4232 if (is_32bit_elf)
4233 printf
4234 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4235 else if (do_wide)
4236 printf
4237 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4238 else
4239 {
4240 printf
4241 (_(" Type Offset VirtAddr PhysAddr\n"));
4242 printf
4243 (_(" FileSiz MemSiz Flags Align\n"));
4244 }
252b5132
RH		 4245 }
4246
252b5132 4247 dynamic_addr = 0;
1b228002 4248 dynamic_size = 0;
252b5132
RH		 4249
4250 for (i = 0, segment = program_headers;
4251 i < elf_header.e_phnum;
b34976b6 4252 i++, segment++)
252b5132
RH		 4253 {
4254 if (do_segments)
4255 {
103f02d3 4256 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4257
4258 if (is_32bit_elf)
4259 {
4260 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4261 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4262 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4263 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4264 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4265 printf ("%c%c%c ",
4266 (segment->p_flags & PF_R ? 'R' : ' '),
4267 (segment->p_flags & PF_W ? 'W' : ' '),
4268 (segment->p_flags & PF_X ? 'E' : ' '));
4269 printf ("%#lx", (unsigned long) segment->p_align);
4270 }
d974e256
JJ		 4271 else if (do_wide)
4272 {
4273 if ((unsigned long) segment->p_offset == segment->p_offset)
4274 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4275 else
4276 {
4277 print_vma (segment->p_offset, FULL_HEX);
4278 putchar (' ');
4279 }
4280
4281 print_vma (segment->p_vaddr, FULL_HEX);
4282 putchar (' ');
4283 print_vma (segment->p_paddr, FULL_HEX);
4284 putchar (' ');
4285
4286 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4287 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4288 else
4289 {
4290 print_vma (segment->p_filesz, FULL_HEX);
4291 putchar (' ');
4292 }
4293
4294 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4295 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4296 else
4297 {
f48e6c45 4298 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4299 }
4300
4301 printf (" %c%c%c ",
4302 (segment->p_flags & PF_R ? 'R' : ' '),
4303 (segment->p_flags & PF_W ? 'W' : ' '),
4304 (segment->p_flags & PF_X ? 'E' : ' '));
4305
4306 if ((unsigned long) segment->p_align == segment->p_align)
4307 printf ("%#lx", (unsigned long) segment->p_align);
4308 else
4309 {
4310 print_vma (segment->p_align, PREFIX_HEX);
4311 }
4312 }
f7a99963
NC		 4313 else
4314 {
4315 print_vma (segment->p_offset, FULL_HEX);
4316 putchar (' ');
4317 print_vma (segment->p_vaddr, FULL_HEX);
4318 putchar (' ');
4319 print_vma (segment->p_paddr, FULL_HEX);
4320 printf ("\n ");
4321 print_vma (segment->p_filesz, FULL_HEX);
4322 putchar (' ');
4323 print_vma (segment->p_memsz, FULL_HEX);
4324 printf (" %c%c%c ",
4325 (segment->p_flags & PF_R ? 'R' : ' '),
4326 (segment->p_flags & PF_W ? 'W' : ' '),
4327 (segment->p_flags & PF_X ? 'E' : ' '));
4328 print_vma (segment->p_align, HEX);
4329 }
252b5132
RH		 4330 }
4331
4332 switch (segment->p_type)
4333 {
252b5132
RH		 4334 case PT_DYNAMIC:
4335 if (dynamic_addr)
4336 error (_("more than one dynamic segment\n"));
4337
20737c13
AM		 4338 /* By default, assume that the .dynamic section is the first
4339 section in the DYNAMIC segment. */
4340 dynamic_addr = segment->p_offset;
4341 dynamic_size = segment->p_filesz;
4342
b2d38a17
NC		 4343 /* Try to locate the .dynamic section. If there is
4344 a section header table, we can easily locate it. */
4345 if (section_headers != NULL)
4346 {
2cf0635d 4347 Elf_Internal_Shdr * sec;
b2d38a17 4348
89fac5e3
RS		 4349 sec = find_section (".dynamic");
4350 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4351 {
28f997cf
TG		 4352 /* A corresponding .dynamic section is expected, but on
4353 IA-64/OpenVMS it is OK for it to be missing. */
4354 if (!is_ia64_vms ())
4355 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4356 break;
4357 }
4358
42bb2e33 4359 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4360 {
4361 dynamic_size = 0;
4362 break;
4363 }
42bb2e33 4364
b2d38a17
NC		 4365 dynamic_addr = sec->sh_offset;
4366 dynamic_size = sec->sh_size;
4367
4368 if (dynamic_addr < segment->p_offset
4369 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4370 warn (_("the .dynamic section is not contained"
4371 " within the dynamic segment\n"));
b2d38a17 4372 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4373 warn (_("the .dynamic section is not the first section"
4374 " in the dynamic segment.\n"));
b2d38a17 4375 }
252b5132
RH		 4376 break;
4377
4378 case PT_INTERP:
fb52b2f4
NC		 4379 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4380 SEEK_SET))
252b5132
RH		 4381 error (_("Unable to find program interpreter name\n"));
4382 else
4383 {
f8eae8b2
L		 4384 char fmt [32];
4385 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4386
4387 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4388 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4389
252b5132 4390 program_interpreter[0] = 0;
7bd7b3ef
AM		 4391 if (fscanf (file, fmt, program_interpreter) <= 0)
4392 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4393
4394 if (do_segments)
4395 printf (_("\n [Requesting program interpreter: %s]"),
4396 program_interpreter);
4397 }
4398 break;
4399 }
4400
4401 if (do_segments)
4402 putc ('\n', stdout);
4403 }
4404
c256ffe7 4405 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4406 {
4407 printf (_("\n Section to Segment mapping:\n"));
4408 printf (_(" Segment Sections...\n"));
4409
252b5132
RH		 4410 for (i = 0; i < elf_header.e_phnum; i++)
4411 {
9ad5cbcf 4412 unsigned int j;
2cf0635d 4413 Elf_Internal_Shdr * section;
252b5132
RH		 4414
4415 segment = program_headers + i;
b391a3e3 4416 section = section_headers + 1;
252b5132
RH		 4417
4418 printf (" %2.2d ", i);
4419
b34976b6 4420 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4421 {
f4638467
AM		 4422 if (!ELF_TBSS_SPECIAL (section, segment)
4423 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 4424 printf ("%s ", SECTION_NAME (section));
4425 }
4426
4427 putc ('\n',stdout);
4428 }
4429 }
4430
252b5132
RH		 4431 return 1;
4432}
4433
4434
d93f0186
NC		 4435/* Find the file offset corresponding to VMA by using the program headers. */
4436
4437static long
2cf0635d 4438offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4439{
2cf0635d 4440 Elf_Internal_Phdr * seg;
d93f0186
NC		 4441
4442 if (! get_program_headers (file))
4443 {
4444 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4445 return (long) vma;
4446 }
4447
4448 for (seg = program_headers;
4449 seg < program_headers + elf_header.e_phnum;
4450 ++seg)
4451 {
4452 if (seg->p_type != PT_LOAD)
4453 continue;
4454
4455 if (vma >= (seg->p_vaddr & -seg->p_align)
4456 && vma + size <= seg->p_vaddr + seg->p_filesz)
4457 return vma - seg->p_vaddr + seg->p_offset;
4458 }
4459
4460 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4461 (unsigned long) vma);
d93f0186
NC		 4462 return (long) vma;
4463}
4464
4465
252b5132 4466static int
2cf0635d 4467get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4468{
2cf0635d
NC		 4469 Elf32_External_Shdr * shdrs;
4470 Elf_Internal_Shdr * internal;
b34976b6 4471 unsigned int i;
252b5132 4472
3f5e193b
NC		 4473 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4474 elf_header.e_shentsize, num,
4475 _("section headers"));
a6e9f9df
AM		 4476 if (!shdrs)
4477 return 0;
252b5132 4478
3f5e193b
NC		 4479 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4480 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4481
4482 if (section_headers == NULL)
4483 {
4484 error (_("Out of memory\n"));
4485 return 0;
4486 }
4487
4488 for (i = 0, internal = section_headers;
560f3c1c 4489 i < num;
b34976b6 4490 i++, internal++)
252b5132
RH		 4491 {
4492 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4493 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4494 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4495 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4496 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4497 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4498 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4499 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4500 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4501 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4502 }
4503
4504 free (shdrs);
4505
4506 return 1;
4507}
4508
9ea033b2 4509static int
2cf0635d 4510get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4511{
2cf0635d
NC		 4512 Elf64_External_Shdr * shdrs;
4513 Elf_Internal_Shdr * internal;
b34976b6 4514 unsigned int i;
9ea033b2 4515
3f5e193b
NC		 4516 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4517 elf_header.e_shentsize, num,
4518 _("section headers"));
a6e9f9df
AM		 4519 if (!shdrs)
4520 return 0;
9ea033b2 4521
3f5e193b
NC		 4522 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4523 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4524
4525 if (section_headers == NULL)
4526 {
4527 error (_("Out of memory\n"));
4528 return 0;
4529 }
4530
4531 for (i = 0, internal = section_headers;
560f3c1c 4532 i < num;
b34976b6 4533 i++, internal++)
9ea033b2
NC		 4534 {
4535 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4536 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4537 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4538 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4539 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4540 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4541 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4542 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4543 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4544 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4545 }
4546
4547 free (shdrs);
4548
4549 return 1;
4550}
4551
252b5132 4552static Elf_Internal_Sym *
ba5cdace
NC		 4553get_32bit_elf_symbols (FILE * file,
4554 Elf_Internal_Shdr * section,
4555 unsigned long * num_syms_return)
252b5132 4556{
ba5cdace 4557 unsigned long number = 0;
dd24e3da 4558 Elf32_External_Sym * esyms = NULL;
ba5cdace 4559 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4560 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4561 Elf_Internal_Sym * psym;
b34976b6 4562 unsigned int j;
252b5132 4563
dd24e3da
NC		 4564 /* Run some sanity checks first. */
4565 if (section->sh_entsize == 0)
4566 {
4567 error (_("sh_entsize is zero\n"));
ba5cdace 4568 goto exit_point;
dd24e3da
NC		 4569 }
4570
4571 number = section->sh_size / section->sh_entsize;
4572
4573 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4574 {
4575 error (_("Invalid sh_entsize\n"));
ba5cdace 4576 goto exit_point;
dd24e3da
NC		 4577 }
4578
3f5e193b
NC		 4579 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4580 section->sh_size, _("symbols"));
dd24e3da 4581 if (esyms == NULL)
ba5cdace 4582 goto exit_point;
252b5132 4583
9ad5cbcf
AM		 4584 shndx = NULL;
4585 if (symtab_shndx_hdr != NULL
4586 && (symtab_shndx_hdr->sh_link
4fbb74a6 4587 == (unsigned long) (section - section_headers)))
9ad5cbcf 4588 {
3f5e193b
NC		 4589 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4590 symtab_shndx_hdr->sh_offset,
4591 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4592 _("symbol table section indicies"));
dd24e3da
NC		 4593 if (shndx == NULL)
4594 goto exit_point;
9ad5cbcf
AM		 4595 }
4596
3f5e193b 4597 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4598
4599 if (isyms == NULL)
4600 {
4601 error (_("Out of memory\n"));
dd24e3da 4602 goto exit_point;
252b5132
RH		 4603 }
4604
dd24e3da 4605 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4606 {
4607 psym->st_name = BYTE_GET (esyms[j].st_name);
4608 psym->st_value = BYTE_GET (esyms[j].st_value);
4609 psym->st_size = BYTE_GET (esyms[j].st_size);
4610 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4611 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4612 psym->st_shndx
4613 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4614 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4615 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4616 psym->st_info = BYTE_GET (esyms[j].st_info);
4617 psym->st_other = BYTE_GET (esyms[j].st_other);
4618 }
4619
dd24e3da 4620 exit_point:
ba5cdace 4621 if (shndx != NULL)
9ad5cbcf 4622 free (shndx);
ba5cdace 4623 if (esyms != NULL)
dd24e3da 4624 free (esyms);
252b5132 4625
ba5cdace
NC		 4626 if (num_syms_return != NULL)
4627 * num_syms_return = isyms == NULL ? 0 : number;
4628
252b5132
RH		 4629 return isyms;
4630}
4631
9ea033b2 4632static Elf_Internal_Sym *
ba5cdace
NC		 4633get_64bit_elf_symbols (FILE * file,
4634 Elf_Internal_Shdr * section,
4635 unsigned long * num_syms_return)
9ea033b2 4636{
ba5cdace
NC		 4637 unsigned long number = 0;
4638 Elf64_External_Sym * esyms = NULL;
4639 Elf_External_Sym_Shndx * shndx = NULL;
4640 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4641 Elf_Internal_Sym * psym;
b34976b6 4642 unsigned int j;
9ea033b2 4643
dd24e3da
NC		 4644 /* Run some sanity checks first. */
4645 if (section->sh_entsize == 0)
4646 {
4647 error (_("sh_entsize is zero\n"));
ba5cdace 4648 goto exit_point;
dd24e3da
NC		 4649 }
4650
4651 number = section->sh_size / section->sh_entsize;
4652
4653 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4654 {
4655 error (_("Invalid sh_entsize\n"));
ba5cdace 4656 goto exit_point;
dd24e3da
NC		 4657 }
4658
3f5e193b
NC		 4659 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4660 section->sh_size, _("symbols"));
a6e9f9df 4661 if (!esyms)
ba5cdace 4662 goto exit_point;
9ea033b2 4663
9ad5cbcf
AM		 4664 if (symtab_shndx_hdr != NULL
4665 && (symtab_shndx_hdr->sh_link
4fbb74a6 4666 == (unsigned long) (section - section_headers)))
9ad5cbcf 4667 {
3f5e193b
NC		 4668 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4669 symtab_shndx_hdr->sh_offset,
4670 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4671 _("symbol table section indicies"));
ba5cdace
NC		 4672 if (shndx == NULL)
4673 goto exit_point;
9ad5cbcf
AM		 4674 }
4675
3f5e193b 4676 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4677
4678 if (isyms == NULL)
4679 {
4680 error (_("Out of memory\n"));
ba5cdace 4681 goto exit_point;
9ea033b2
NC		 4682 }
4683
ba5cdace 4684 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4685 {
4686 psym->st_name = BYTE_GET (esyms[j].st_name);
4687 psym->st_info = BYTE_GET (esyms[j].st_info);
4688 psym->st_other = BYTE_GET (esyms[j].st_other);
4689 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4690
4fbb74a6 4691 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4692 psym->st_shndx
4693 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4694 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4695 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4696
66543521
AM		 4697 psym->st_value = BYTE_GET (esyms[j].st_value);
4698 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4699 }
4700
ba5cdace
NC		 4701 exit_point:
4702 if (shndx != NULL)
9ad5cbcf 4703 free (shndx);
ba5cdace
NC		 4704 if (esyms != NULL)
4705 free (esyms);
4706
4707 if (num_syms_return != NULL)
4708 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4709
4710 return isyms;
4711}
4712
d1133906 4713static const char *
d3ba0551 4714get_elf_section_flags (bfd_vma sh_flags)
d1133906 4715{
5477e8a0 4716 static char buff[1024];
2cf0635d 4717 char * p = buff;
8d5ff12c 4718 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4719 int sindex;
4720 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4721 bfd_vma os_flags = 0;
4722 bfd_vma proc_flags = 0;
4723 bfd_vma unknown_flags = 0;
148b93f2 4724 static const struct
5477e8a0 4725 {
2cf0635d 4726 const char * str;
5477e8a0
L		 4727 int len;
4728 }
4729 flags [] =
4730 {
cfcac11d
NC		 4731 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4732 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4733 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4734 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4735 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4736 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4737 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4738 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4739 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4740 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4741 /* IA-64 specific. */
4742 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4743 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4744 /* IA-64 OpenVMS specific. */
4745 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4746 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4747 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4748 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4749 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4750 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4751 /* Generic. */
cfcac11d 4752 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4753 /* SPARC specific. */
cfcac11d 4754 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4755 };
4756
4757 if (do_section_details)
4758 {
8d5ff12c
L		 4759 sprintf (buff, "[%*.*lx]: ",
4760 field_size, field_size, (unsigned long) sh_flags);
4761 p += field_size + 4;
5477e8a0 4762 }
76da6bbe 4763
d1133906
NC		 4764 while (sh_flags)
4765 {
4766 bfd_vma flag;
4767
4768 flag = sh_flags & - sh_flags;
4769 sh_flags &= ~ flag;
76da6bbe 4770
5477e8a0 4771 if (do_section_details)
d1133906 4772 {
5477e8a0
L		 4773 switch (flag)
4774 {
91d6fa6a
NC		 4775 case SHF_WRITE: sindex = 0; break;
4776 case SHF_ALLOC: sindex = 1; break;
4777 case SHF_EXECINSTR: sindex = 2; break;
4778 case SHF_MERGE: sindex = 3; break;
4779 case SHF_STRINGS: sindex = 4; break;
4780 case SHF_INFO_LINK: sindex = 5; break;
4781 case SHF_LINK_ORDER: sindex = 6; break;
4782 case SHF_OS_NONCONFORMING: sindex = 7; break;
4783 case SHF_GROUP: sindex = 8; break;
4784 case SHF_TLS: sindex = 9; break;
18ae9cc1 4785 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4786
5477e8a0 4787 default:
91d6fa6a 4788 sindex = -1;
cfcac11d 4789 switch (elf_header.e_machine)
148b93f2 4790 {
cfcac11d 4791 case EM_IA_64:
148b93f2 4792 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4793 sindex = 10;
148b93f2 4794 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4795 sindex = 11;
148b93f2
NC		 4796#ifdef BFD64
4797 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4798 switch (flag)
4799 {
91d6fa6a
NC		 4800 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4801 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4802 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4803 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4804 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4805 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4806 default: break;
4807 }
4808#endif
cfcac11d
NC		 4809 break;
4810
caa83f8b
NC		 4811 case EM_386:
4812 case EM_486:
4813 case EM_X86_64:
7f502d6c 4814 case EM_L1OM:
7a9068fe 4815 case EM_K1OM:
cfcac11d
NC		 4816 case EM_OLD_SPARCV9:
4817 case EM_SPARC32PLUS:
4818 case EM_SPARCV9:
4819 case EM_SPARC:
18ae9cc1 4820 if (flag == SHF_ORDERED)
91d6fa6a 4821 sindex = 19;
cfcac11d
NC		 4822 break;
4823 default:
4824 break;
148b93f2 4825 }
5477e8a0
L		 4826 }
4827
91d6fa6a 4828 if (sindex != -1)
5477e8a0 4829 {
8d5ff12c
L		 4830 if (p != buff + field_size + 4)
4831 {
4832 if (size < (10 + 2))
4833 abort ();
4834 size -= 2;
4835 *p++ = ',';
4836 *p++ = ' ';
4837 }
4838
91d6fa6a
NC		 4839 size -= flags [sindex].len;
4840 p = stpcpy (p, flags [sindex].str);
5477e8a0 4841 }
3b22753a 4842 else if (flag & SHF_MASKOS)
8d5ff12c 4843 os_flags |= flag;
d1133906 4844 else if (flag & SHF_MASKPROC)
8d5ff12c 4845 proc_flags |= flag;
d1133906 4846 else
8d5ff12c 4847 unknown_flags |= flag;
5477e8a0
L		 4848 }
4849 else
4850 {
4851 switch (flag)
4852 {
4853 case SHF_WRITE: *p = 'W'; break;
4854 case SHF_ALLOC: *p = 'A'; break;
4855 case SHF_EXECINSTR: *p = 'X'; break;
4856 case SHF_MERGE: *p = 'M'; break;
4857 case SHF_STRINGS: *p = 'S'; break;
4858 case SHF_INFO_LINK: *p = 'I'; break;
4859 case SHF_LINK_ORDER: *p = 'L'; break;
4860 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4861 case SHF_GROUP: *p = 'G'; break;
4862 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4863 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4864
4865 default:
8a9036a4 4866 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4867 || elf_header.e_machine == EM_L1OM
4868 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4869 && flag == SHF_X86_64_LARGE)
4870 *p = 'l';
4871 else if (flag & SHF_MASKOS)
4872 {
4873 *p = 'o';
4874 sh_flags &= ~ SHF_MASKOS;
4875 }
4876 else if (flag & SHF_MASKPROC)
4877 {
4878 *p = 'p';
4879 sh_flags &= ~ SHF_MASKPROC;
4880 }
4881 else
4882 *p = 'x';
4883 break;
4884 }
4885 p++;
d1133906
NC		 4886 }
4887 }
76da6bbe 4888
8d5ff12c
L		 4889 if (do_section_details)
4890 {
4891 if (os_flags)
4892 {
4893 size -= 5 + field_size;
4894 if (p != buff + field_size + 4)
4895 {
4896 if (size < (2 + 1))
4897 abort ();
4898 size -= 2;
4899 *p++ = ',';
4900 *p++ = ' ';
4901 }
4902 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4903 (unsigned long) os_flags);
4904 p += 5 + field_size;
4905 }
4906 if (proc_flags)
4907 {
4908 size -= 7 + field_size;
4909 if (p != buff + field_size + 4)
4910 {
4911 if (size < (2 + 1))
4912 abort ();
4913 size -= 2;
4914 *p++ = ',';
4915 *p++ = ' ';
4916 }
4917 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4918 (unsigned long) proc_flags);
4919 p += 7 + field_size;
4920 }
4921 if (unknown_flags)
4922 {
4923 size -= 10 + field_size;
4924 if (p != buff + field_size + 4)
4925 {
4926 if (size < (2 + 1))
4927 abort ();
4928 size -= 2;
4929 *p++ = ',';
4930 *p++ = ' ';
4931 }
2b692964 4932 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4933 (unsigned long) unknown_flags);
4934 p += 10 + field_size;
4935 }
4936 }
4937
e9e44622 4938 *p = '\0';
d1133906
NC		 4939 return buff;
4940}
4941
252b5132 4942static int
2cf0635d 4943process_section_headers (FILE * file)
252b5132 4944{
2cf0635d 4945 Elf_Internal_Shdr * section;
b34976b6 4946 unsigned int i;
252b5132
RH		 4947
4948 section_headers = NULL;
4949
4950 if (elf_header.e_shnum == 0)
4951 {
82f2dbf7
NC		 4952 /* PR binutils/12467. */
4953 if (elf_header.e_shoff != 0)
4954 warn (_("possibly corrupt ELF file header - it has a non-zero"
4955 " section header offset, but no section headers\n"));
4956 else if (do_sections)
252b5132
RH		 4957 printf (_("\nThere are no sections in this file.\n"));
4958
4959 return 1;
4960 }
4961
4962 if (do_sections && !do_header)
9ea033b2 4963 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4964 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4965
9ea033b2
NC		 4966 if (is_32bit_elf)
4967 {
560f3c1c 4968 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4969 return 0;
4970 }
560f3c1c 4971 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4972 return 0;
4973
4974 /* Read in the string table, so that we have names to display. */
0b49d371 4975 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4976 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4977 {
4fbb74a6 4978 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4979
c256ffe7
JJ		 4980 if (section->sh_size != 0)
4981 {
3f5e193b
NC		 4982 string_table = (char *) get_data (NULL, file, section->sh_offset,
4983 1, section->sh_size,
4984 _("string table"));
0de14b54 4985
c256ffe7
JJ		 4986 string_table_length = string_table != NULL ? section->sh_size : 0;
4987 }
252b5132
RH		 4988 }
4989
4990 /* Scan the sections for the dynamic symbol table
e3c8793a 4991 and dynamic string table and debug sections. */
252b5132
RH		 4992 dynamic_symbols = NULL;
4993 dynamic_strings = NULL;
4994 dynamic_syminfo = NULL;
f1ef08cb 4995 symtab_shndx_hdr = NULL;
103f02d3 4996
89fac5e3
RS		 4997 eh_addr_size = is_32bit_elf ? 4 : 8;
4998 switch (elf_header.e_machine)
4999 {
5000 case EM_MIPS:
5001 case EM_MIPS_RS3_LE:
5002 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5003 FDE addresses. However, the ABI also has a semi-official ILP32
5004 variant for which the normal FDE address size rules apply.
5005
5006 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5007 section, where XX is the size of longs in bits. Unfortunately,
5008 earlier compilers provided no way of distinguishing ILP32 objects
5009 from LP64 objects, so if there's any doubt, we should assume that
5010 the official LP64 form is being used. */
5011 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5012 && find_section (".gcc_compiled_long32") == NULL)
5013 eh_addr_size = 8;
5014 break;
0f56a26a
DD		 5015
5016 case EM_H8_300:
5017 case EM_H8_300H:
5018 switch (elf_header.e_flags & EF_H8_MACH)
5019 {
5020 case E_H8_MACH_H8300:
5021 case E_H8_MACH_H8300HN:
5022 case E_H8_MACH_H8300SN:
5023 case E_H8_MACH_H8300SXN:
5024 eh_addr_size = 2;
5025 break;
5026 case E_H8_MACH_H8300H:
5027 case E_H8_MACH_H8300S:
5028 case E_H8_MACH_H8300SX:
5029 eh_addr_size = 4;
5030 break;
5031 }
f4236fe4
DD		 5032 break;
5033
ff7eeb89 5034 case EM_M32C_OLD:
f4236fe4
DD		 5035 case EM_M32C:
5036 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5037 {
5038 case EF_M32C_CPU_M16C:
5039 eh_addr_size = 2;
5040 break;
5041 }
5042 break;
89fac5e3
RS		 5043 }
5044
08d8fa11
JJ		 5045#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5046 do \
5047 { \
9dd3a467 5048 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
08d8fa11 5049 if (section->sh_entsize != expected_entsize) \
9dd3a467 5050 { \
15b42fb0 5051 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
9dd3a467
NC		 5052 i, section->sh_entsize); \
5053 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
5054 (int) expected_entsize); \
5055 section->sh_entsize = expected_entsize; \
5056 } \
08d8fa11
JJ		 5057 } \
5058 while (0)
9dd3a467
NC		 5059
5060#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5061 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5062 sizeof (Elf64_External_##type))
5063
252b5132
RH		 5064 for (i = 0, section = section_headers;
5065 i < elf_header.e_shnum;
b34976b6 5066 i++, section++)
252b5132 5067 {
2cf0635d 5068 char * name = SECTION_NAME (section);
252b5132
RH		 5069
5070 if (section->sh_type == SHT_DYNSYM)
5071 {
5072 if (dynamic_symbols != NULL)
5073 {
5074 error (_("File contains multiple dynamic symbol tables\n"));
5075 continue;
5076 }
5077
08d8fa11 5078 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5079 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5080 }
5081 else if (section->sh_type == SHT_STRTAB
18bd398b 5082 && streq (name, ".dynstr"))
252b5132
RH		 5083 {
5084 if (dynamic_strings != NULL)
5085 {
5086 error (_("File contains multiple dynamic string tables\n"));
5087 continue;
5088 }
5089
3f5e193b
NC		 5090 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5091 1, section->sh_size,
5092 _("dynamic strings"));
59245841 5093 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5094 }
9ad5cbcf
AM		 5095 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5096 {
5097 if (symtab_shndx_hdr != NULL)
5098 {
5099 error (_("File contains multiple symtab shndx tables\n"));
5100 continue;
5101 }
5102 symtab_shndx_hdr = section;
5103 }
08d8fa11
JJ		 5104 else if (section->sh_type == SHT_SYMTAB)
5105 CHECK_ENTSIZE (section, i, Sym);
5106 else if (section->sh_type == SHT_GROUP)
5107 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5108 else if (section->sh_type == SHT_REL)
5109 CHECK_ENTSIZE (section, i, Rel);
5110 else if (section->sh_type == SHT_RELA)
5111 CHECK_ENTSIZE (section, i, Rela);
252b5132 5112 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5113 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5114 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5115 || do_debug_str || do_debug_loc || do_debug_ranges
5116 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5117 && (const_strneq (name, ".debug_")
5118 || const_strneq (name, ".zdebug_")))
252b5132 5119 {
1b315056
CS		 5120 if (name[1] == 'z')
5121 name += sizeof (".zdebug_") - 1;
5122 else
5123 name += sizeof (".debug_") - 1;
252b5132
RH		 5124
5125 if (do_debugging
4723351a
CC		 5126 || (do_debug_info && const_strneq (name, "info"))
5127 || (do_debug_info && const_strneq (name, "types"))
5128 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5129 || (do_debug_lines && strcmp (name, "line") == 0)
5130 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5131 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5132 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5133 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5134 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5135 || (do_debug_aranges && const_strneq (name, "aranges"))
5136 || (do_debug_ranges && const_strneq (name, "ranges"))
5137 || (do_debug_frames && const_strneq (name, "frame"))
5138 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5139 || (do_debug_macinfo && const_strneq (name, "macro"))
5140 || (do_debug_str && const_strneq (name, "str"))
5141 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5142 || (do_debug_addr && const_strneq (name, "addr"))
5143 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5144 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5145 )
09c11c86 5146 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5147 }
a262ae96 5148 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5149 else if ((do_debugging || do_debug_info)
0112cd26 5150 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5151 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5152 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5153 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5154 else if (do_gdb_index && streq (name, ".gdb_index"))
5155 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5156 /* Trace sections for Itanium VMS. */
5157 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5158 || do_trace_aranges)
5159 && const_strneq (name, ".trace_"))
5160 {
5161 name += sizeof (".trace_") - 1;
5162
5163 if (do_debugging
5164 || (do_trace_info && streq (name, "info"))
5165 || (do_trace_abbrevs && streq (name, "abbrev"))
5166 || (do_trace_aranges && streq (name, "aranges"))
5167 )
5168 request_dump_bynumber (i, DEBUG_DUMP);
5169 }
5170
252b5132
RH		 5171 }
5172
5173 if (! do_sections)
5174 return 1;
5175
3a1a2036
NC		 5176 if (elf_header.e_shnum > 1)
5177 printf (_("\nSection Headers:\n"));
5178 else
5179 printf (_("\nSection Header:\n"));
76da6bbe 5180
f7a99963 5181 if (is_32bit_elf)
595cf52e 5182 {
5477e8a0 5183 if (do_section_details)
595cf52e
L		 5184 {
5185 printf (_(" [Nr] Name\n"));
5477e8a0 5186 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5187 }
5188 else
5189 printf
5190 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5191 }
d974e256 5192 else if (do_wide)
595cf52e 5193 {
5477e8a0 5194 if (do_section_details)
595cf52e
L		 5195 {
5196 printf (_(" [Nr] Name\n"));
5477e8a0 5197 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5198 }
5199 else
5200 printf
5201 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5202 }
f7a99963
NC		 5203 else
5204 {
5477e8a0 5205 if (do_section_details)
595cf52e
L		 5206 {
5207 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5208 printf (_(" Type Address Offset Link\n"));
5209 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5210 }
5211 else
5212 {
5213 printf (_(" [Nr] Name Type Address Offset\n"));
5214 printf (_(" Size EntSize Flags Link Info Align\n"));
5215 }
f7a99963 5216 }
252b5132 5217
5477e8a0
L		 5218 if (do_section_details)
5219 printf (_(" Flags\n"));
5220
252b5132
RH		 5221 for (i = 0, section = section_headers;
5222 i < elf_header.e_shnum;
b34976b6 5223 i++, section++)
252b5132 5224 {
7bfd842d 5225 printf (" [%2u] ", i);
5477e8a0 5226 if (do_section_details)
595cf52e 5227 {
7bfd842d 5228 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 5229 printf ("\n ");
595cf52e
L		 5230 }
5231 else
7bfd842d
NC		 5232 {
5233 print_symbol (-17, SECTION_NAME (section));
7bfd842d 5234 }
0b4362b0 5235
ea52a088
NC		 5236 printf (do_wide ? " %-15s " : " %-15.15s ",
5237 get_section_type_name (section->sh_type));
0b4362b0 5238
f7a99963
NC		 5239 if (is_32bit_elf)
5240 {
cfcac11d
NC		 5241 const char * link_too_big = NULL;
5242
f7a99963 5243 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5244
f7a99963
NC		 5245 printf ( " %6.6lx %6.6lx %2.2lx",
5246 (unsigned long) section->sh_offset,
5247 (unsigned long) section->sh_size,
5248 (unsigned long) section->sh_entsize);
d1133906 5249
5477e8a0
L		 5250 if (do_section_details)
5251 fputs (" ", stdout);
5252 else
5253 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5254
cfcac11d
NC		 5255 if (section->sh_link >= elf_header.e_shnum)
5256 {
5257 link_too_big = "";
5258 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5259 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5260 switch (elf_header.e_machine)
5261 {
caa83f8b
NC		 5262 case EM_386:
5263 case EM_486:
5264 case EM_X86_64:
7f502d6c 5265 case EM_L1OM:
7a9068fe 5266 case EM_K1OM:
cfcac11d
NC		 5267 case EM_OLD_SPARCV9:
5268 case EM_SPARC32PLUS:
5269 case EM_SPARCV9:
5270 case EM_SPARC:
5271 if (section->sh_link == (SHN_BEFORE & 0xffff))
5272 link_too_big = "BEFORE";
5273 else if (section->sh_link == (SHN_AFTER & 0xffff))
5274 link_too_big = "AFTER";
5275 break;
5276 default:
5277 break;
5278 }
5279 }
5280
5281 if (do_section_details)
5282 {
5283 if (link_too_big != NULL && * link_too_big)
5284 printf ("<%s> ", link_too_big);
5285 else
5286 printf ("%2u ", section->sh_link);
5287 printf ("%3u %2lu\n", section->sh_info,
5288 (unsigned long) section->sh_addralign);
5289 }
5290 else
5291 printf ("%2u %3u %2lu\n",
5292 section->sh_link,
5293 section->sh_info,
5294 (unsigned long) section->sh_addralign);
5295
5296 if (link_too_big && ! * link_too_big)
5297 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5298 i, section->sh_link);
f7a99963 5299 }
d974e256
JJ		 5300 else if (do_wide)
5301 {
5302 print_vma (section->sh_addr, LONG_HEX);
5303
5304 if ((long) section->sh_offset == section->sh_offset)
5305 printf (" %6.6lx", (unsigned long) section->sh_offset);
5306 else
5307 {
5308 putchar (' ');
5309 print_vma (section->sh_offset, LONG_HEX);
5310 }
5311
5312 if ((unsigned long) section->sh_size == section->sh_size)
5313 printf (" %6.6lx", (unsigned long) section->sh_size);
5314 else
5315 {
5316 putchar (' ');
5317 print_vma (section->sh_size, LONG_HEX);
5318 }
5319
5320 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5321 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5322 else
5323 {
5324 putchar (' ');
5325 print_vma (section->sh_entsize, LONG_HEX);
5326 }
5327
5477e8a0
L		 5328 if (do_section_details)
5329 fputs (" ", stdout);
5330 else
5331 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5332
72de5009 5333 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5334
5335 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5336 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5337 else
5338 {
5339 print_vma (section->sh_addralign, DEC);
5340 putchar ('\n');
5341 }
5342 }
5477e8a0 5343 else if (do_section_details)
595cf52e 5344 {
5477e8a0 5345 printf (" %-15.15s ",
595cf52e 5346 get_section_type_name (section->sh_type));
595cf52e
L		 5347 print_vma (section->sh_addr, LONG_HEX);
5348 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5349 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5350 else
5351 {
5352 printf (" ");
5353 print_vma (section->sh_offset, LONG_HEX);
5354 }
72de5009 5355 printf (" %u\n ", section->sh_link);
595cf52e 5356 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5357 putchar (' ');
595cf52e
L		 5358 print_vma (section->sh_entsize, LONG_HEX);
5359
72de5009
AM		 5360 printf (" %-16u %lu\n",
5361 section->sh_info,
595cf52e
L		 5362 (unsigned long) section->sh_addralign);
5363 }
f7a99963
NC		 5364 else
5365 {
5366 putchar (' ');
5367 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5368 if ((long) section->sh_offset == section->sh_offset)
5369 printf (" %8.8lx", (unsigned long) section->sh_offset);
5370 else
5371 {
5372 printf (" ");
5373 print_vma (section->sh_offset, LONG_HEX);
5374 }
f7a99963
NC		 5375 printf ("\n ");
5376 print_vma (section->sh_size, LONG_HEX);
5377 printf (" ");
5378 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5379
d1133906 5380 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5381
72de5009
AM		 5382 printf (" %2u %3u %lu\n",
5383 section->sh_link,
5384 section->sh_info,
f7a99963
NC		 5385 (unsigned long) section->sh_addralign);
5386 }
5477e8a0
L		 5387
5388 if (do_section_details)
5389 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5390 }
5391
5477e8a0 5392 if (!do_section_details)
3dbcc61d
NC		 5393 {
5394 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5395 || elf_header.e_machine == EM_L1OM
5396 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5397 printf (_("Key to Flags:\n\
5398 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5399 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5400 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5401 else
5402 printf (_("Key to Flags:\n\
e3c8793a 5403 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5404 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5405 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5406 }
d1133906 5407
252b5132
RH		 5408 return 1;
5409}
5410
f5842774
L		 5411static const char *
5412get_group_flags (unsigned int flags)
5413{
5414 static char buff[32];
5415 switch (flags)
5416 {
220453ec
AM		 5417 case 0:
5418 return "";
5419
f5842774 5420 case GRP_COMDAT:
220453ec 5421 return "COMDAT ";
f5842774
L		 5422
5423 default:
220453ec 5424 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5425 break;
5426 }
5427 return buff;
5428}
5429
5430static int
2cf0635d 5431process_section_groups (FILE * file)
f5842774 5432{
2cf0635d 5433 Elf_Internal_Shdr * section;
f5842774 5434 unsigned int i;
2cf0635d
NC		 5435 struct group * group;
5436 Elf_Internal_Shdr * symtab_sec;
5437 Elf_Internal_Shdr * strtab_sec;
5438 Elf_Internal_Sym * symtab;
ba5cdace 5439 unsigned long num_syms;
2cf0635d 5440 char * strtab;
c256ffe7 5441 size_t strtab_size;
d1f5c6e3
L		 5442
5443 /* Don't process section groups unless needed. */
5444 if (!do_unwind && !do_section_groups)
5445 return 1;
f5842774
L		 5446
5447 if (elf_header.e_shnum == 0)
5448 {
5449 if (do_section_groups)
82f2dbf7 5450 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5451
5452 return 1;
5453 }
5454
5455 if (section_headers == NULL)
5456 {
5457 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5458 /* PR 13622: This can happen with a corrupt ELF header. */
5459 return 0;
f5842774
L		 5460 }
5461
3f5e193b
NC		 5462 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5463 sizeof (struct group *));
e4b17d5c
L		 5464
5465 if (section_headers_groups == NULL)
5466 {
5467 error (_("Out of memory\n"));
5468 return 0;
5469 }
5470
f5842774 5471 /* Scan the sections for the group section. */
d1f5c6e3 5472 group_count = 0;
f5842774
L		 5473 for (i = 0, section = section_headers;
5474 i < elf_header.e_shnum;
5475 i++, section++)
e4b17d5c
L		 5476 if (section->sh_type == SHT_GROUP)
5477 group_count++;
5478
d1f5c6e3
L		 5479 if (group_count == 0)
5480 {
5481 if (do_section_groups)
5482 printf (_("\nThere are no section groups in this file.\n"));
5483
5484 return 1;
5485 }
5486
3f5e193b 5487 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5488
5489 if (section_groups == NULL)
5490 {
5491 error (_("Out of memory\n"));
5492 return 0;
5493 }
5494
d1f5c6e3
L		 5495 symtab_sec = NULL;
5496 strtab_sec = NULL;
5497 symtab = NULL;
ba5cdace 5498 num_syms = 0;
d1f5c6e3 5499 strtab = NULL;
c256ffe7 5500 strtab_size = 0;
e4b17d5c
L		 5501 for (i = 0, section = section_headers, group = section_groups;
5502 i < elf_header.e_shnum;
5503 i++, section++)
f5842774
L		 5504 {
5505 if (section->sh_type == SHT_GROUP)
5506 {
2cf0635d
NC		 5507 char * name = SECTION_NAME (section);
5508 char * group_name;
5509 unsigned char * start;
5510 unsigned char * indices;
f5842774 5511 unsigned int entry, j, size;
2cf0635d
NC		 5512 Elf_Internal_Shdr * sec;
5513 Elf_Internal_Sym * sym;
f5842774
L		 5514
5515 /* Get the symbol table. */
4fbb74a6
AM		 5516 if (section->sh_link >= elf_header.e_shnum
5517 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5518 != SHT_SYMTAB))
f5842774
L		 5519 {
5520 error (_("Bad sh_link in group section `%s'\n"), name);
5521 continue;
5522 }
d1f5c6e3
L		 5523
5524 if (symtab_sec != sec)
5525 {
5526 symtab_sec = sec;
5527 if (symtab)
5528 free (symtab);
ba5cdace 5529 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5530 }
f5842774 5531
dd24e3da
NC		 5532 if (symtab == NULL)
5533 {
5534 error (_("Corrupt header in group section `%s'\n"), name);
5535 continue;
5536 }
5537
ba5cdace
NC		 5538 if (section->sh_info >= num_syms)
5539 {
5540 error (_("Bad sh_info in group section `%s'\n"), name);
5541 continue;
5542 }
5543
f5842774
L		 5544 sym = symtab + section->sh_info;
5545
5546 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5547 {
4fbb74a6
AM		 5548 if (sym->st_shndx == 0
5549 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5550 {
5551 error (_("Bad sh_info in group section `%s'\n"), name);
5552 continue;
5553 }
ba2685cc 5554
4fbb74a6 5555 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5556 strtab_sec = NULL;
5557 if (strtab)
5558 free (strtab);
f5842774 5559 strtab = NULL;
c256ffe7 5560 strtab_size = 0;
f5842774
L		 5561 }
5562 else
5563 {
5564 /* Get the string table. */
4fbb74a6 5565 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5566 {
5567 strtab_sec = NULL;
5568 if (strtab)
5569 free (strtab);
5570 strtab = NULL;
5571 strtab_size = 0;
5572 }
5573 else if (strtab_sec
4fbb74a6 5574 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5575 {
5576 strtab_sec = sec;
5577 if (strtab)
5578 free (strtab);
3f5e193b
NC		 5579 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5580 1, strtab_sec->sh_size,
5581 _("string table"));
c256ffe7 5582 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5583 }
c256ffe7 5584 group_name = sym->st_name < strtab_size
2b692964 5585 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5586 }
5587
3f5e193b
NC		 5588 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5589 1, section->sh_size,
5590 _("section data"));
59245841
NC		 5591 if (start == NULL)
5592 continue;
f5842774
L		 5593
5594 indices = start;
5595 size = (section->sh_size / section->sh_entsize) - 1;
5596 entry = byte_get (indices, 4);
5597 indices += 4;
e4b17d5c
L		 5598
5599 if (do_section_groups)
5600 {
2b692964 5601 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5602 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5603
e4b17d5c
L		 5604 printf (_(" [Index] Name\n"));
5605 }
5606
5607 group->group_index = i;
5608
f5842774
L		 5609 for (j = 0; j < size; j++)
5610 {
2cf0635d 5611 struct group_list * g;
e4b17d5c 5612
f5842774
L		 5613 entry = byte_get (indices, 4);
5614 indices += 4;
5615
4fbb74a6 5616 if (entry >= elf_header.e_shnum)
391cb864
L		 5617 {
5618 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5619 entry, i, elf_header.e_shnum - 1);
5620 continue;
5621 }
391cb864 5622
4fbb74a6 5623 if (section_headers_groups [entry] != NULL)
e4b17d5c 5624 {
d1f5c6e3
L		 5625 if (entry)
5626 {
391cb864
L		 5627 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5628 entry, i,
4fbb74a6 5629 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5630 continue;
5631 }
5632 else
5633 {
5634 /* Intel C/C++ compiler may put section 0 in a
5635 section group. We just warn it the first time
5636 and ignore it afterwards. */
5637 static int warned = 0;
5638 if (!warned)
5639 {
5640 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5641 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5642 warned++;
5643 }
5644 }
e4b17d5c
L		 5645 }
5646
4fbb74a6 5647 section_headers_groups [entry] = group;
e4b17d5c
L		 5648
5649 if (do_section_groups)
5650 {
4fbb74a6 5651 sec = section_headers + entry;
c256ffe7 5652 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5653 }
5654
3f5e193b 5655 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5656 g->section_index = entry;
5657 g->next = group->root;
5658 group->root = g;
f5842774
L		 5659 }
5660
f5842774
L		 5661 if (start)
5662 free (start);
e4b17d5c
L		 5663
5664 group++;
f5842774
L		 5665 }
5666 }
5667
d1f5c6e3
L		 5668 if (symtab)
5669 free (symtab);
5670 if (strtab)
5671 free (strtab);
f5842774
L		 5672 return 1;
5673}
5674
28f997cf
TG		 5675/* Data used to display dynamic fixups. */
5676
5677struct ia64_vms_dynfixup
5678{
5679 bfd_vma needed_ident; /* Library ident number. */
5680 bfd_vma needed; /* Index in the dstrtab of the library name. */
5681 bfd_vma fixup_needed; /* Index of the library. */
5682 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5683 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5684};
5685
5686/* Data used to display dynamic relocations. */
5687
5688struct ia64_vms_dynimgrela
5689{
5690 bfd_vma img_rela_cnt; /* Number of relocations. */
5691 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5692};
5693
5694/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5695 library). */
5696
5697static void
5698dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5699 const char *strtab, unsigned int strtab_sz)
5700{
5701 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5702 long i;
5703 const char *lib_name;
5704
5705 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5706 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5707 _("dynamic section image fixups"));
5708 if (!imfs)
5709 return;
5710
5711 if (fixup->needed < strtab_sz)
5712 lib_name = strtab + fixup->needed;
5713 else
5714 {
5715 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5716 (unsigned long) fixup->needed);
28f997cf
TG		 5717 lib_name = "???";
5718 }
5719 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5720 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5721 printf
5722 (_("Seg Offset Type SymVec DataType\n"));
5723
5724 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5725 {
5726 unsigned int type;
5727 const char *rtype;
5728
5729 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5730 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5731 type = BYTE_GET (imfs [i].type);
5732 rtype = elf_ia64_reloc_type (type);
5733 if (rtype == NULL)
5734 printf (" 0x%08x ", type);
5735 else
5736 printf (" %-32s ", rtype);
5737 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5738 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5739 }
5740
5741 free (imfs);
5742}
5743
5744/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5745
5746static void
5747dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5748{
5749 Elf64_External_VMS_IMAGE_RELA *imrs;
5750 long i;
5751
5752 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5753 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5754 _("dynamic section image relocations"));
28f997cf
TG		 5755 if (!imrs)
5756 return;
5757
5758 printf (_("\nImage relocs\n"));
5759 printf
5760 (_("Seg Offset Type Addend Seg Sym Off\n"));
5761
5762 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5763 {
5764 unsigned int type;
5765 const char *rtype;
5766
5767 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5768 printf ("%08" BFD_VMA_FMT "x ",
5769 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5770 type = BYTE_GET (imrs [i].type);
5771 rtype = elf_ia64_reloc_type (type);
5772 if (rtype == NULL)
5773 printf ("0x%08x ", type);
5774 else
5775 printf ("%-31s ", rtype);
5776 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5777 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5778 printf ("%08" BFD_VMA_FMT "x\n",
5779 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5780 }
5781
5782 free (imrs);
5783}
5784
5785/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5786
5787static int
5788process_ia64_vms_dynamic_relocs (FILE *file)
5789{
5790 struct ia64_vms_dynfixup fixup;
5791 struct ia64_vms_dynimgrela imgrela;
5792 Elf_Internal_Dyn *entry;
5793 int res = 0;
5794 bfd_vma strtab_off = 0;
5795 bfd_vma strtab_sz = 0;
5796 char *strtab = NULL;
5797
5798 memset (&fixup, 0, sizeof (fixup));
5799 memset (&imgrela, 0, sizeof (imgrela));
5800
5801 /* Note: the order of the entries is specified by the OpenVMS specs. */
5802 for (entry = dynamic_section;
5803 entry < dynamic_section + dynamic_nent;
5804 entry++)
5805 {
5806 switch (entry->d_tag)
5807 {
5808 case DT_IA_64_VMS_STRTAB_OFFSET:
5809 strtab_off = entry->d_un.d_val;
5810 break;
5811 case DT_STRSZ:
5812 strtab_sz = entry->d_un.d_val;
5813 if (strtab == NULL)
5814 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5815 1, strtab_sz, _("dynamic string section"));
5816 break;
5817
5818 case DT_IA_64_VMS_NEEDED_IDENT:
5819 fixup.needed_ident = entry->d_un.d_val;
5820 break;
5821 case DT_NEEDED:
5822 fixup.needed = entry->d_un.d_val;
5823 break;
5824 case DT_IA_64_VMS_FIXUP_NEEDED:
5825 fixup.fixup_needed = entry->d_un.d_val;
5826 break;
5827 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5828 fixup.fixup_rela_cnt = entry->d_un.d_val;
5829 break;
5830 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5831 fixup.fixup_rela_off = entry->d_un.d_val;
5832 res++;
5833 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5834 break;
5835
5836 case DT_IA_64_VMS_IMG_RELA_CNT:
5837 imgrela.img_rela_cnt = entry->d_un.d_val;
5838 break;
5839 case DT_IA_64_VMS_IMG_RELA_OFF:
5840 imgrela.img_rela_off = entry->d_un.d_val;
5841 res++;
5842 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5843 break;
5844
5845 default:
5846 break;
5847 }
5848 }
5849
5850 if (strtab != NULL)
5851 free (strtab);
5852
5853 return res;
5854}
5855
85b1c36d 5856static struct
566b0d53 5857{
2cf0635d 5858 const char * name;
566b0d53
L		 5859 int reloc;
5860 int size;
5861 int rela;
5862} dynamic_relocations [] =
5863{
5864 { "REL", DT_REL, DT_RELSZ, FALSE },
5865 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5866 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5867};
5868
252b5132 5869/* Process the reloc section. */
18bd398b 5870
252b5132 5871static int
2cf0635d 5872process_relocs (FILE * file)
252b5132 5873{
b34976b6
AM		 5874 unsigned long rel_size;
5875 unsigned long rel_offset;
252b5132
RH		 5876
5877
5878 if (!do_reloc)
5879 return 1;
5880
5881 if (do_using_dynamic)
5882 {
566b0d53 5883 int is_rela;
2cf0635d 5884 const char * name;
566b0d53
L		 5885 int has_dynamic_reloc;
5886 unsigned int i;
0de14b54 5887
566b0d53 5888 has_dynamic_reloc = 0;
252b5132 5889
566b0d53 5890 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5891 {
566b0d53
L		 5892 is_rela = dynamic_relocations [i].rela;
5893 name = dynamic_relocations [i].name;
5894 rel_size = dynamic_info [dynamic_relocations [i].size];
5895 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5896
566b0d53
L		 5897 has_dynamic_reloc |= rel_size;
5898
5899 if (is_rela == UNKNOWN)
aa903cfb 5900 {
566b0d53
L		 5901 if (dynamic_relocations [i].reloc == DT_JMPREL)
5902 switch (dynamic_info[DT_PLTREL])
5903 {
5904 case DT_REL:
5905 is_rela = FALSE;
5906 break;
5907 case DT_RELA:
5908 is_rela = TRUE;
5909 break;
5910 }
aa903cfb 5911 }
252b5132 5912
566b0d53
L		 5913 if (rel_size)
5914 {
5915 printf
5916 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5917 name, rel_offset, rel_size);
252b5132 5918
d93f0186
NC		 5919 dump_relocations (file,
5920 offset_from_vma (file, rel_offset, rel_size),
5921 rel_size,
566b0d53 5922 dynamic_symbols, num_dynamic_syms,
d79b3d50 5923 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5924 }
252b5132 5925 }
566b0d53 5926
28f997cf
TG		 5927 if (is_ia64_vms ())
5928 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5929
566b0d53 5930 if (! has_dynamic_reloc)
252b5132
RH		 5931 printf (_("\nThere are no dynamic relocations in this file.\n"));
5932 }
5933 else
5934 {
2cf0635d 5935 Elf_Internal_Shdr * section;
b34976b6
AM		 5936 unsigned long i;
5937 int found = 0;
252b5132
RH		 5938
5939 for (i = 0, section = section_headers;
5940 i < elf_header.e_shnum;
b34976b6 5941 i++, section++)
252b5132
RH		 5942 {
5943 if ( section->sh_type != SHT_RELA
5944 && section->sh_type != SHT_REL)
5945 continue;
5946
5947 rel_offset = section->sh_offset;
5948 rel_size = section->sh_size;
5949
5950 if (rel_size)
5951 {
2cf0635d 5952 Elf_Internal_Shdr * strsec;
b34976b6 5953 int is_rela;
103f02d3 5954
252b5132
RH		 5955 printf (_("\nRelocation section "));
5956
5957 if (string_table == NULL)
19936277 5958 printf ("%d", section->sh_name);
252b5132 5959 else
9cf03b7e 5960 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5961
5962 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5963 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5964
d79b3d50
NC		 5965 is_rela = section->sh_type == SHT_RELA;
5966
4fbb74a6
AM		 5967 if (section->sh_link != 0
5968 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5969 {
2cf0635d
NC		 5970 Elf_Internal_Shdr * symsec;
5971 Elf_Internal_Sym * symtab;
d79b3d50 5972 unsigned long nsyms;
c256ffe7 5973 unsigned long strtablen = 0;
2cf0635d 5974 char * strtab = NULL;
57346661 5975
4fbb74a6 5976 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5977 if (symsec->sh_type != SHT_SYMTAB
5978 && symsec->sh_type != SHT_DYNSYM)
5979 continue;
5980
ba5cdace 5981 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5982
af3fc3bc
AM		 5983 if (symtab == NULL)
5984 continue;
252b5132 5985
4fbb74a6
AM		 5986 if (symsec->sh_link != 0
5987 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5988 {
4fbb74a6 5989 strsec = section_headers + symsec->sh_link;
103f02d3 5990
3f5e193b
NC		 5991 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5992 1, strsec->sh_size,
5993 _("string table"));
c256ffe7
JJ		 5994 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5995 }
252b5132 5996
d79b3d50
NC		 5997 dump_relocations (file, rel_offset, rel_size,
5998 symtab, nsyms, strtab, strtablen, is_rela);
5999 if (strtab)
6000 free (strtab);
6001 free (symtab);
6002 }
6003 else
6004 dump_relocations (file, rel_offset, rel_size,
6005 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 6006
6007 found = 1;
6008 }
6009 }
6010
6011 if (! found)
6012 printf (_("\nThere are no relocations in this file.\n"));
6013 }
6014
6015 return 1;
6016}
6017
57346661
AM		 6018/* Process the unwind section. */
6019
4d6ed7c8
NC		 6020#include "unwind-ia64.h"
6021
6022/* An absolute address consists of a section and an offset. If the
6023 section is NULL, the offset itself is the address, otherwise, the
6024 address equals to LOAD_ADDRESS(section) + offset. */
6025
6026struct absaddr
6027 {
6028 unsigned short section;
6029 bfd_vma offset;
6030 };
6031
1949de15
L		 6032#define ABSADDR(a) \
6033 ((a).section \
6034 ? section_headers [(a).section].sh_addr + (a).offset \
6035 : (a).offset)
6036
3f5e193b
NC		 6037struct ia64_unw_table_entry
6038 {
6039 struct absaddr start;
6040 struct absaddr end;
6041 struct absaddr info;
6042 };
6043
57346661 6044struct ia64_unw_aux_info
4d6ed7c8 6045 {
3f5e193b
NC		 6046
6047 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 6048 unsigned long table_len; /* Length of unwind table. */
2cf0635d 6049 unsigned char * info; /* Unwind info. */
b34976b6
AM		 6050 unsigned long info_size; /* Size of unwind info. */
6051 bfd_vma info_addr; /* starting address of unwind info. */
6052 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6053 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 6054 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6055 char * strtab; /* The string table. */
b34976b6 6056 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 6057 };
6058
4d6ed7c8 6059static void
2cf0635d 6060find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 6061 unsigned long nsyms,
2cf0635d 6062 const char * strtab,
57346661 6063 unsigned long strtab_size,
d3ba0551 6064 struct absaddr addr,
2cf0635d
NC		 6065 const char ** symname,
6066 bfd_vma * offset)
4d6ed7c8 6067{
d3ba0551 6068 bfd_vma dist = 0x100000;
2cf0635d
NC		 6069 Elf_Internal_Sym * sym;
6070 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 6071 unsigned long i;
6072
0b6ae522
DJ		 6073 REMOVE_ARCH_BITS (addr.offset);
6074
57346661 6075 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 6076 {
0b6ae522
DJ		 6077 bfd_vma value = sym->st_value;
6078
6079 REMOVE_ARCH_BITS (value);
6080
4d6ed7c8
NC		 6081 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6082 && sym->st_name != 0
6083 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6084 && addr.offset >= value
6085 && addr.offset - value < dist)
4d6ed7c8
NC		 6086 {
6087 best = sym;
0b6ae522 6088 dist = addr.offset - value;
4d6ed7c8
NC		 6089 if (!dist)
6090 break;
6091 }
6092 }
1b31d05e 6093
4d6ed7c8
NC		 6094 if (best)
6095 {
57346661 6096 *symname = (best->st_name >= strtab_size
2b692964 6097 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6098 *offset = dist;
6099 return;
6100 }
1b31d05e 6101
4d6ed7c8
NC		 6102 *symname = NULL;
6103 *offset = addr.offset;
6104}
6105
6106static void
2cf0635d 6107dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6108{
2cf0635d 6109 struct ia64_unw_table_entry * tp;
4d6ed7c8 6110 int in_body;
7036c0e1 6111
4d6ed7c8
NC		 6112 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6113 {
6114 bfd_vma stamp;
6115 bfd_vma offset;
2cf0635d
NC		 6116 const unsigned char * dp;
6117 const unsigned char * head;
6118 const char * procname;
4d6ed7c8 6119
57346661
AM		 6120 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6121 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6122
6123 fputs ("\n<", stdout);
6124
6125 if (procname)
6126 {
6127 fputs (procname, stdout);
6128
6129 if (offset)
6130 printf ("+%lx", (unsigned long) offset);
6131 }
6132
6133 fputs (">: [", stdout);
6134 print_vma (tp->start.offset, PREFIX_HEX);
6135 fputc ('-', stdout);
6136 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6137 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6138 (unsigned long) (tp->info.offset - aux->seg_base));
6139
1949de15 6140 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6141 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6142
86f55779 6143 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6144 (unsigned) UNW_VER (stamp),
6145 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6146 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6147 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6148 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6149
6150 if (UNW_VER (stamp) != 1)
6151 {
2b692964 6152 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6153 continue;
6154 }
6155
6156 in_body = 0;
89fac5e3 6157 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 6158 dp = unw_decode (dp, in_body, & in_body);
6159 }
6160}
6161
6162static int
2cf0635d
NC		 6163slurp_ia64_unwind_table (FILE * file,
6164 struct ia64_unw_aux_info * aux,
6165 Elf_Internal_Shdr * sec)
4d6ed7c8 6166{
89fac5e3 6167 unsigned long size, nrelas, i;
2cf0635d
NC		 6168 Elf_Internal_Phdr * seg;
6169 struct ia64_unw_table_entry * tep;
6170 Elf_Internal_Shdr * relsec;
6171 Elf_Internal_Rela * rela;
6172 Elf_Internal_Rela * rp;
6173 unsigned char * table;
6174 unsigned char * tp;
6175 Elf_Internal_Sym * sym;
6176 const char * relname;
4d6ed7c8 6177
4d6ed7c8
NC		 6178 /* First, find the starting address of the segment that includes
6179 this section: */
6180
6181 if (elf_header.e_phnum)
6182 {
d93f0186 6183 if (! get_program_headers (file))
4d6ed7c8 6184 return 0;
4d6ed7c8 6185
d93f0186
NC		 6186 for (seg = program_headers;
6187 seg < program_headers + elf_header.e_phnum;
6188 ++seg)
4d6ed7c8
NC		 6189 {
6190 if (seg->p_type != PT_LOAD)
6191 continue;
6192
6193 if (sec->sh_addr >= seg->p_vaddr
6194 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6195 {
6196 aux->seg_base = seg->p_vaddr;
6197 break;
6198 }
6199 }
4d6ed7c8
NC		 6200 }
6201
6202 /* Second, build the unwind table from the contents of the unwind section: */
6203 size = sec->sh_size;
3f5e193b
NC		 6204 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6205 _("unwind table"));
a6e9f9df
AM		 6206 if (!table)
6207 return 0;
4d6ed7c8 6208
3f5e193b
NC		 6209 aux->table = (struct ia64_unw_table_entry *)
6210 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 6211 tep = aux->table;
c6a0c689 6212 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 6213 {
6214 tep->start.section = SHN_UNDEF;
6215 tep->end.section = SHN_UNDEF;
6216 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6217 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6218 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6219 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6220 tep->start.offset += aux->seg_base;
6221 tep->end.offset += aux->seg_base;
6222 tep->info.offset += aux->seg_base;
6223 }
6224 free (table);
6225
41e92641 6226 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6227 for (relsec = section_headers;
6228 relsec < section_headers + elf_header.e_shnum;
6229 ++relsec)
6230 {
6231 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6232 || relsec->sh_info >= elf_header.e_shnum
6233 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6234 continue;
6235
6236 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6237 & rela, & nrelas))
6238 return 0;
6239
6240 for (rp = rela; rp < rela + nrelas; ++rp)
6241 {
aca88567
NC		 6242 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6243 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6244
0112cd26 6245 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6246 {
e5fb9629 6247 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 6248 continue;
6249 }
6250
89fac5e3 6251 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6252
89fac5e3 6253 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 6254 {
6255 case 0:
6256 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6257 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6258 break;
6259 case 1:
6260 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6261 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6262 break;
6263 case 2:
6264 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6265 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6266 break;
6267 default:
6268 break;
6269 }
6270 }
6271
6272 free (rela);
6273 }
6274
89fac5e3 6275 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 6276 return 1;
6277}
6278
1b31d05e 6279static void
2cf0635d 6280ia64_process_unwind (FILE * file)
4d6ed7c8 6281{
2cf0635d
NC		 6282 Elf_Internal_Shdr * sec;
6283 Elf_Internal_Shdr * unwsec = NULL;
6284 Elf_Internal_Shdr * strsec;
89fac5e3 6285 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6286 struct ia64_unw_aux_info aux;
f1467e33 6287
4d6ed7c8
NC		 6288 memset (& aux, 0, sizeof (aux));
6289
4d6ed7c8
NC		 6290 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6291 {
c256ffe7 6292 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6293 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6294 {
ba5cdace 6295 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6296
4fbb74a6 6297 strsec = section_headers + sec->sh_link;
59245841 6298 assert (aux.strtab == NULL);
3f5e193b
NC		 6299 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6300 1, strsec->sh_size,
6301 _("string table"));
c256ffe7 6302 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6303 }
6304 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6305 unwcount++;
6306 }
6307
6308 if (!unwcount)
6309 printf (_("\nThere are no unwind sections in this file.\n"));
6310
6311 while (unwcount-- > 0)
6312 {
2cf0635d 6313 char * suffix;
579f31ac
JJ		 6314 size_t len, len2;
6315
6316 for (i = unwstart, sec = section_headers + unwstart;
6317 i < elf_header.e_shnum; ++i, ++sec)
6318 if (sec->sh_type == SHT_IA_64_UNWIND)
6319 {
6320 unwsec = sec;
6321 break;
6322 }
6323
6324 unwstart = i + 1;
6325 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6326
e4b17d5c
L		 6327 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6328 {
6329 /* We need to find which section group it is in. */
2cf0635d 6330 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 6331
6332 for (; g != NULL; g = g->next)
6333 {
4fbb74a6 6334 sec = section_headers + g->section_index;
18bd398b
NC		 6335
6336 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6337 break;
e4b17d5c
L		 6338 }
6339
6340 if (g == NULL)
6341 i = elf_header.e_shnum;
6342 }
18bd398b 6343 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6344 {
18bd398b 6345 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6346 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6347 suffix = SECTION_NAME (unwsec) + len;
6348 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6349 ++i, ++sec)
18bd398b
NC		 6350 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6351 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6352 break;
6353 }
6354 else
6355 {
6356 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6357 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6358 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6359 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6360 suffix = "";
18bd398b 6361 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6362 suffix = SECTION_NAME (unwsec) + len;
6363 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6364 ++i, ++sec)
18bd398b
NC		 6365 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6366 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6367 break;
6368 }
6369
6370 if (i == elf_header.e_shnum)
6371 {
6372 printf (_("\nCould not find unwind info section for "));
6373
6374 if (string_table == NULL)
6375 printf ("%d", unwsec->sh_name);
6376 else
3a1a2036 6377 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 6378 }
6379 else
4d6ed7c8 6380 {
4d6ed7c8 6381 aux.info_addr = sec->sh_addr;
3f5e193b 6382 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6383 sec->sh_size,
3f5e193b 6384 _("unwind info"));
59245841 6385 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6386
579f31ac 6387 printf (_("\nUnwind section "));
4d6ed7c8 6388
579f31ac
JJ		 6389 if (string_table == NULL)
6390 printf ("%d", unwsec->sh_name);
6391 else
3a1a2036 6392 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6393
579f31ac 6394 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6395 (unsigned long) unwsec->sh_offset,
89fac5e3 6396 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6397
579f31ac 6398 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6399
579f31ac
JJ		 6400 if (aux.table_len > 0)
6401 dump_ia64_unwind (& aux);
6402
6403 if (aux.table)
6404 free ((char *) aux.table);
6405 if (aux.info)
6406 free ((char *) aux.info);
6407 aux.table = NULL;
6408 aux.info = NULL;
6409 }
4d6ed7c8 6410 }
4d6ed7c8 6411
4d6ed7c8
NC		 6412 if (aux.symtab)
6413 free (aux.symtab);
6414 if (aux.strtab)
6415 free ((char *) aux.strtab);
4d6ed7c8
NC		 6416}
6417
3f5e193b
NC		 6418struct hppa_unw_table_entry
6419 {
6420 struct absaddr start;
6421 struct absaddr end;
6422 unsigned int Cannot_unwind:1; /* 0 */
6423 unsigned int Millicode:1; /* 1 */
6424 unsigned int Millicode_save_sr0:1; /* 2 */
6425 unsigned int Region_description:2; /* 3..4 */
6426 unsigned int reserved1:1; /* 5 */
6427 unsigned int Entry_SR:1; /* 6 */
6428 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6429 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6430 unsigned int Args_stored:1; /* 16 */
6431 unsigned int Variable_Frame:1; /* 17 */
6432 unsigned int Separate_Package_Body:1; /* 18 */
6433 unsigned int Frame_Extension_Millicode:1; /* 19 */
6434 unsigned int Stack_Overflow_Check:1; /* 20 */
6435 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6436 unsigned int Ada_Region:1; /* 22 */
6437 unsigned int cxx_info:1; /* 23 */
6438 unsigned int cxx_try_catch:1; /* 24 */
6439 unsigned int sched_entry_seq:1; /* 25 */
6440 unsigned int reserved2:1; /* 26 */
6441 unsigned int Save_SP:1; /* 27 */
6442 unsigned int Save_RP:1; /* 28 */
6443 unsigned int Save_MRP_in_frame:1; /* 29 */
6444 unsigned int extn_ptr_defined:1; /* 30 */
6445 unsigned int Cleanup_defined:1; /* 31 */
6446
6447 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6448 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6449 unsigned int Large_frame:1; /* 2 */
6450 unsigned int Pseudo_SP_Set:1; /* 3 */
6451 unsigned int reserved4:1; /* 4 */
6452 unsigned int Total_frame_size:27; /* 5..31 */
6453 };
6454
57346661
AM		 6455struct hppa_unw_aux_info
6456 {
3f5e193b 6457 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6458 unsigned long table_len; /* Length of unwind table. */
6459 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6460 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6461 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6462 char * strtab; /* The string table. */
57346661
AM		 6463 unsigned long strtab_size; /* Size of string table. */
6464 };
6465
6466static void
2cf0635d 6467dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6468{
2cf0635d 6469 struct hppa_unw_table_entry * tp;
57346661 6470
57346661
AM		 6471 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6472 {
6473 bfd_vma offset;
2cf0635d 6474 const char * procname;
57346661
AM		 6475
6476 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6477 aux->strtab_size, tp->start, &procname,
6478 &offset);
6479
6480 fputs ("\n<", stdout);
6481
6482 if (procname)
6483 {
6484 fputs (procname, stdout);
6485
6486 if (offset)
6487 printf ("+%lx", (unsigned long) offset);
6488 }
6489
6490 fputs (">: [", stdout);
6491 print_vma (tp->start.offset, PREFIX_HEX);
6492 fputc ('-', stdout);
6493 print_vma (tp->end.offset, PREFIX_HEX);
6494 printf ("]\n\t");
6495
18bd398b
NC		 6496#define PF(_m) if (tp->_m) printf (#_m " ");
6497#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6498 PF(Cannot_unwind);
6499 PF(Millicode);
6500 PF(Millicode_save_sr0);
18bd398b 6501 /* PV(Region_description); */
57346661
AM		 6502 PF(Entry_SR);
6503 PV(Entry_FR);
6504 PV(Entry_GR);
6505 PF(Args_stored);
6506 PF(Variable_Frame);
6507 PF(Separate_Package_Body);
6508 PF(Frame_Extension_Millicode);
6509 PF(Stack_Overflow_Check);
6510 PF(Two_Instruction_SP_Increment);
6511 PF(Ada_Region);
6512 PF(cxx_info);
6513 PF(cxx_try_catch);
6514 PF(sched_entry_seq);
6515 PF(Save_SP);
6516 PF(Save_RP);
6517 PF(Save_MRP_in_frame);
6518 PF(extn_ptr_defined);
6519 PF(Cleanup_defined);
6520 PF(MPE_XL_interrupt_marker);
6521 PF(HP_UX_interrupt_marker);
6522 PF(Large_frame);
6523 PF(Pseudo_SP_Set);
6524 PV(Total_frame_size);
6525#undef PF
6526#undef PV
6527 }
6528
18bd398b 6529 printf ("\n");
57346661
AM		 6530}
6531
6532static int
2cf0635d
NC		 6533slurp_hppa_unwind_table (FILE * file,
6534 struct hppa_unw_aux_info * aux,
6535 Elf_Internal_Shdr * sec)
57346661 6536{
1c0751b2 6537 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6538 Elf_Internal_Phdr * seg;
6539 struct hppa_unw_table_entry * tep;
6540 Elf_Internal_Shdr * relsec;
6541 Elf_Internal_Rela * rela;
6542 Elf_Internal_Rela * rp;
6543 unsigned char * table;
6544 unsigned char * tp;
6545 Elf_Internal_Sym * sym;
6546 const char * relname;
57346661 6547
57346661
AM		 6548 /* First, find the starting address of the segment that includes
6549 this section. */
6550
6551 if (elf_header.e_phnum)
6552 {
6553 if (! get_program_headers (file))
6554 return 0;
6555
6556 for (seg = program_headers;
6557 seg < program_headers + elf_header.e_phnum;
6558 ++seg)
6559 {
6560 if (seg->p_type != PT_LOAD)
6561 continue;
6562
6563 if (sec->sh_addr >= seg->p_vaddr
6564 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6565 {
6566 aux->seg_base = seg->p_vaddr;
6567 break;
6568 }
6569 }
6570 }
6571
6572 /* Second, build the unwind table from the contents of the unwind
6573 section. */
6574 size = sec->sh_size;
3f5e193b
NC		 6575 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6576 _("unwind table"));
57346661
AM		 6577 if (!table)
6578 return 0;
6579
1c0751b2
DA		 6580 unw_ent_size = 16;
6581 nentries = size / unw_ent_size;
6582 size = unw_ent_size * nentries;
57346661 6583
3f5e193b
NC		 6584 tep = aux->table = (struct hppa_unw_table_entry *)
6585 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6586
1c0751b2 6587 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6588 {
6589 unsigned int tmp1, tmp2;
6590
6591 tep->start.section = SHN_UNDEF;
6592 tep->end.section = SHN_UNDEF;
6593
1c0751b2
DA		 6594 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6595 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6596 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6597 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6598
6599 tep->start.offset += aux->seg_base;
6600 tep->end.offset += aux->seg_base;
57346661
AM		 6601
6602 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6603 tep->Millicode = (tmp1 >> 30) & 0x1;
6604 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6605 tep->Region_description = (tmp1 >> 27) & 0x3;
6606 tep->reserved1 = (tmp1 >> 26) & 0x1;
6607 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6608 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6609 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6610 tep->Args_stored = (tmp1 >> 15) & 0x1;
6611 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6612 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6613 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6614 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6615 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6616 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6617 tep->cxx_info = (tmp1 >> 8) & 0x1;
6618 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6619 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6620 tep->reserved2 = (tmp1 >> 5) & 0x1;
6621 tep->Save_SP = (tmp1 >> 4) & 0x1;
6622 tep->Save_RP = (tmp1 >> 3) & 0x1;
6623 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6624 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6625 tep->Cleanup_defined = tmp1 & 0x1;
6626
6627 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6628 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6629 tep->Large_frame = (tmp2 >> 29) & 0x1;
6630 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6631 tep->reserved4 = (tmp2 >> 27) & 0x1;
6632 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6633 }
6634 free (table);
6635
6636 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6637 for (relsec = section_headers;
6638 relsec < section_headers + elf_header.e_shnum;
6639 ++relsec)
6640 {
6641 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6642 || relsec->sh_info >= elf_header.e_shnum
6643 || section_headers + relsec->sh_info != sec)
57346661
AM		 6644 continue;
6645
6646 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6647 & rela, & nrelas))
6648 return 0;
6649
6650 for (rp = rela; rp < rela + nrelas; ++rp)
6651 {
aca88567
NC		 6652 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6653 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6654
6655 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6656 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6657 {
6658 warn (_("Skipping unexpected relocation type %s\n"), relname);
6659 continue;
6660 }
6661
6662 i = rp->r_offset / unw_ent_size;
6663
89fac5e3 6664 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6665 {
6666 case 0:
6667 aux->table[i].start.section = sym->st_shndx;
1e456d54 6668 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6669 break;
6670 case 1:
6671 aux->table[i].end.section = sym->st_shndx;
1e456d54 6672 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6673 break;
6674 default:
6675 break;
6676 }
6677 }
6678
6679 free (rela);
6680 }
6681
1c0751b2 6682 aux->table_len = nentries;
57346661
AM		 6683
6684 return 1;
6685}
6686
1b31d05e 6687static void
2cf0635d 6688hppa_process_unwind (FILE * file)
57346661 6689{
57346661 6690 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6691 Elf_Internal_Shdr * unwsec = NULL;
6692 Elf_Internal_Shdr * strsec;
6693 Elf_Internal_Shdr * sec;
18bd398b 6694 unsigned long i;
57346661 6695
c256ffe7 6696 if (string_table == NULL)
1b31d05e
NC		 6697 return;
6698
6699 memset (& aux, 0, sizeof (aux));
57346661
AM		 6700
6701 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6702 {
c256ffe7 6703 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6704 && sec->sh_link < elf_header.e_shnum)
57346661 6705 {
ba5cdace 6706 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6707
4fbb74a6 6708 strsec = section_headers + sec->sh_link;
59245841 6709 assert (aux.strtab == NULL);
3f5e193b
NC		 6710 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6711 1, strsec->sh_size,
6712 _("string table"));
c256ffe7 6713 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6714 }
18bd398b 6715 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6716 unwsec = sec;
6717 }
6718
6719 if (!unwsec)
6720 printf (_("\nThere are no unwind sections in this file.\n"));
6721
6722 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6723 {
18bd398b 6724 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6725 {
57346661
AM		 6726 printf (_("\nUnwind section "));
6727 printf (_("'%s'"), SECTION_NAME (sec));
6728
6729 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6730 (unsigned long) sec->sh_offset,
89fac5e3 6731 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6732
6733 slurp_hppa_unwind_table (file, &aux, sec);
6734 if (aux.table_len > 0)
6735 dump_hppa_unwind (&aux);
6736
6737 if (aux.table)
6738 free ((char *) aux.table);
6739 aux.table = NULL;
6740 }
6741 }
6742
6743 if (aux.symtab)
6744 free (aux.symtab);
6745 if (aux.strtab)
6746 free ((char *) aux.strtab);
57346661
AM		 6747}
6748
0b6ae522
DJ		 6749struct arm_section
6750{
a734115a
NC		 6751 unsigned char * data; /* The unwind data. */
6752 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6753 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6754 unsigned long nrelas; /* The number of relocations. */
6755 unsigned int rel_type; /* REL or RELA ? */
6756 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6757};
6758
6759struct arm_unw_aux_info
6760{
a734115a
NC		 6761 FILE * file; /* The file containing the unwind sections. */
6762 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6763 unsigned long nsyms; /* Number of symbols. */
6764 char * strtab; /* The file's string table. */
6765 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6766};
6767
6768static const char *
6769arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6770 bfd_vma fn, struct absaddr addr)
6771{
6772 const char *procname;
6773 bfd_vma sym_offset;
6774
6775 if (addr.section == SHN_UNDEF)
6776 addr.offset = fn;
6777
6778 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6779 aux->strtab_size, addr, &procname,
6780 &sym_offset);
6781
6782 print_vma (fn, PREFIX_HEX);
6783
6784 if (procname)
6785 {
6786 fputs (" <", stdout);
6787 fputs (procname, stdout);
6788
6789 if (sym_offset)
6790 printf ("+0x%lx", (unsigned long) sym_offset);
6791 fputc ('>', stdout);
6792 }
6793
6794 return procname;
6795}
6796
6797static void
6798arm_free_section (struct arm_section *arm_sec)
6799{
6800 if (arm_sec->data != NULL)
6801 free (arm_sec->data);
6802
6803 if (arm_sec->rela != NULL)
6804 free (arm_sec->rela);
6805}
6806
a734115a
NC		 6807/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6808 cached section and install SEC instead.
6809 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6810 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6811 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6812 relocation's offset in ADDR.
1b31d05e
NC		 6813 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6814 into the string table of the symbol associated with the reloc. If no
6815 reloc was applied store -1 there.
6816 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6817
6818static bfd_boolean
1b31d05e
NC		 6819get_unwind_section_word (struct arm_unw_aux_info * aux,
6820 struct arm_section * arm_sec,
6821 Elf_Internal_Shdr * sec,
6822 bfd_vma word_offset,
6823 unsigned int * wordp,
6824 struct absaddr * addr,
6825 bfd_vma * sym_name)
0b6ae522
DJ		 6826{
6827 Elf_Internal_Rela *rp;
6828 Elf_Internal_Sym *sym;
6829 const char * relname;
6830 unsigned int word;
6831 bfd_boolean wrapped;
6832
6833 addr->section = SHN_UNDEF;
6834 addr->offset = 0;
6835
1b31d05e
NC		 6836 if (sym_name != NULL)
6837 *sym_name = (bfd_vma) -1;
6838
a734115a 6839 /* If necessary, update the section cache. */
0b6ae522
DJ		 6840 if (sec != arm_sec->sec)
6841 {
6842 Elf_Internal_Shdr *relsec;
6843
6844 arm_free_section (arm_sec);
6845
6846 arm_sec->sec = sec;
6847 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6848 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6849 arm_sec->rela = NULL;
6850 arm_sec->nrelas = 0;
6851
6852 for (relsec = section_headers;
6853 relsec < section_headers + elf_header.e_shnum;
6854 ++relsec)
6855 {
6856 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 6857 || section_headers + relsec->sh_info != sec
6858 /* PR 15745: Check the section type as well. */
6859 || (relsec->sh_type != SHT_REL
6860 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 6861 continue;
6862
a734115a 6863 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6864 if (relsec->sh_type == SHT_REL)
6865 {
6866 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6867 relsec->sh_size,
6868 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6869 return FALSE;
0b6ae522 6870 }
1ae40aa4 6871 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 6872 {
6873 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6874 relsec->sh_size,
6875 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6876 return FALSE;
0b6ae522 6877 }
1ae40aa4 6878 break;
0b6ae522
DJ		 6879 }
6880
6881 arm_sec->next_rela = arm_sec->rela;
6882 }
6883
a734115a 6884 /* If there is no unwind data we can do nothing. */
0b6ae522 6885 if (arm_sec->data == NULL)
a734115a 6886 return FALSE;
0b6ae522 6887
a734115a 6888 /* Get the word at the required offset. */
0b6ae522
DJ		 6889 word = byte_get (arm_sec->data + word_offset, 4);
6890
a734115a 6891 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6892 wrapped = FALSE;
6893 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6894 {
6895 bfd_vma prelval, offset;
6896
6897 if (rp->r_offset > word_offset && !wrapped)
6898 {
6899 rp = arm_sec->rela;
6900 wrapped = TRUE;
6901 }
6902 if (rp->r_offset > word_offset)
6903 break;
6904
6905 if (rp->r_offset & 3)
6906 {
6907 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6908 (unsigned long) rp->r_offset);
6909 continue;
6910 }
6911
6912 if (rp->r_offset < word_offset)
6913 continue;
6914
0b6ae522
DJ		 6915 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6916
6917 if (arm_sec->rel_type == SHT_REL)
6918 {
6919 offset = word & 0x7fffffff;
6920 if (offset & 0x40000000)
6921 offset |= ~ (bfd_vma) 0x7fffffff;
6922 }
a734115a 6923 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6924 offset = rp->r_addend;
a734115a
NC		 6925 else
6926 abort ();
0b6ae522
DJ		 6927
6928 offset += sym->st_value;
6929 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6930
a734115a
NC		 6931 /* Check that we are processing the expected reloc type. */
6932 if (elf_header.e_machine == EM_ARM)
6933 {
6934 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6935
6936 if (streq (relname, "R_ARM_NONE"))
6937 continue;
0b4362b0 6938
a734115a
NC		 6939 if (! streq (relname, "R_ARM_PREL31"))
6940 {
6941 warn (_("Skipping unexpected relocation type %s\n"), relname);
6942 continue;
6943 }
6944 }
6945 else if (elf_header.e_machine == EM_TI_C6000)
6946 {
6947 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
0b4362b0 6948
a734115a
NC		 6949 if (streq (relname, "R_C6000_NONE"))
6950 continue;
6951
6952 if (! streq (relname, "R_C6000_PREL31"))
6953 {
6954 warn (_("Skipping unexpected relocation type %s\n"), relname);
6955 continue;
6956 }
6957
6958 prelval >>= 1;
6959 }
6960 else
6961 /* This function currently only supports ARM and TI unwinders. */
6962 abort ();
fa197c1c 6963
0b6ae522
DJ		 6964 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6965 addr->section = sym->st_shndx;
6966 addr->offset = offset;
1b31d05e
NC		 6967 if (sym_name)
6968 * sym_name = sym->st_name;
0b6ae522
DJ		 6969 break;
6970 }
6971
6972 *wordp = word;
6973 arm_sec->next_rela = rp;
6974
a734115a 6975 return TRUE;
0b6ae522
DJ		 6976}
6977
a734115a
NC		 6978static const char *tic6x_unwind_regnames[16] =
6979{
0b4362b0
RM		 6980 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6981 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 6982 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6983};
fa197c1c 6984
0b6ae522 6985static void
fa197c1c 6986decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6987{
fa197c1c
PB		 6988 int i;
6989
6990 for (i = 12; mask; mask >>= 1, i--)
6991 {
6992 if (mask & 1)
6993 {
6994 fputs (tic6x_unwind_regnames[i], stdout);
6995 if (mask > 1)
6996 fputs (", ", stdout);
6997 }
6998 }
6999}
0b6ae522
DJ		 7000
7001#define ADVANCE \
7002 if (remaining == 0 && more_words) \
7003 { \
7004 data_offset += 4; \
1b31d05e
NC		 7005 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7006 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7007 return; \
7008 remaining = 4; \
7009 more_words--; \
7010 } \
7011
7012#define GET_OP(OP) \
7013 ADVANCE; \
7014 if (remaining) \
7015 { \
7016 remaining--; \
7017 (OP) = word >> 24; \
7018 word <<= 8; \
7019 } \
7020 else \
7021 { \
2b692964 7022 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7023 return; \
7024 } \
cc5914eb 7025 printf ("0x%02x ", OP)
0b6ae522 7026
fa197c1c
PB		 7027static void
7028decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7029 unsigned int word, unsigned int remaining,
7030 unsigned int more_words,
7031 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7032 struct arm_section *data_arm_sec)
7033{
7034 struct absaddr addr;
0b6ae522
DJ		 7035
7036 /* Decode the unwinding instructions. */
7037 while (1)
7038 {
7039 unsigned int op, op2;
7040
7041 ADVANCE;
7042 if (remaining == 0)
7043 break;
7044 remaining--;
7045 op = word >> 24;
7046 word <<= 8;
7047
cc5914eb 7048 printf (" 0x%02x ", op);
0b6ae522
DJ		 7049
7050 if ((op & 0xc0) == 0x00)
7051 {
7052 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7053
cc5914eb 7054 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7055 }
7056 else if ((op & 0xc0) == 0x40)
7057 {
7058 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7059
cc5914eb 7060 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7061 }
7062 else if ((op & 0xf0) == 0x80)
7063 {
7064 GET_OP (op2);
7065 if (op == 0x80 && op2 == 0)
7066 printf (_("Refuse to unwind"));
7067 else
7068 {
7069 unsigned int mask = ((op & 0x0f) << 8) | op2;
7070 int first = 1;
7071 int i;
2b692964 7072
0b6ae522
DJ		 7073 printf ("pop {");
7074 for (i = 0; i < 12; i++)
7075 if (mask & (1 << i))
7076 {
7077 if (first)
7078 first = 0;
7079 else
7080 printf (", ");
7081 printf ("r%d", 4 + i);
7082 }
7083 printf ("}");
7084 }
7085 }
7086 else if ((op & 0xf0) == 0x90)
7087 {
7088 if (op == 0x9d || op == 0x9f)
7089 printf (_(" [Reserved]"));
7090 else
cc5914eb 7091 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7092 }
7093 else if ((op & 0xf0) == 0xa0)
7094 {
7095 int end = 4 + (op & 0x07);
7096 int first = 1;
7097 int i;
61865e30 7098
0b6ae522
DJ		 7099 printf (" pop {");
7100 for (i = 4; i <= end; i++)
7101 {
7102 if (first)
7103 first = 0;
7104 else
7105 printf (", ");
7106 printf ("r%d", i);
7107 }
7108 if (op & 0x08)
7109 {
1b31d05e 7110 if (!first)
0b6ae522
DJ		 7111 printf (", ");
7112 printf ("r14");
7113 }
7114 printf ("}");
7115 }
7116 else if (op == 0xb0)
7117 printf (_(" finish"));
7118 else if (op == 0xb1)
7119 {
7120 GET_OP (op2);
7121 if (op2 == 0 || (op2 & 0xf0) != 0)
7122 printf (_("[Spare]"));
7123 else
7124 {
7125 unsigned int mask = op2 & 0x0f;
7126 int first = 1;
7127 int i;
61865e30 7128
0b6ae522
DJ		 7129 printf ("pop {");
7130 for (i = 0; i < 12; i++)
7131 if (mask & (1 << i))
7132 {
7133 if (first)
7134 first = 0;
7135 else
7136 printf (", ");
7137 printf ("r%d", i);
7138 }
7139 printf ("}");
7140 }
7141 }
7142 else if (op == 0xb2)
7143 {
b115cf96 7144 unsigned char buf[9];
0b6ae522
DJ		 7145 unsigned int i, len;
7146 unsigned long offset;
61865e30 7147
b115cf96 7148 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7149 {
7150 GET_OP (buf[i]);
7151 if ((buf[i] & 0x80) == 0)
7152 break;
7153 }
7154 assert (i < sizeof (buf));
f6f0e17b 7155 offset = read_uleb128 (buf, &len, buf + i + 1);
0b6ae522
DJ		 7156 assert (len == i + 1);
7157 offset = offset * 4 + 0x204;
cc5914eb 7158 printf ("vsp = vsp + %ld", offset);
0b6ae522 7159 }
61865e30 7160 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7161 {
61865e30
NC		 7162 unsigned int first, last;
7163
7164 GET_OP (op2);
7165 first = op2 >> 4;
7166 last = op2 & 0x0f;
7167 if (op == 0xc8)
7168 first = first + 16;
7169 printf ("pop {D%d", first);
7170 if (last)
7171 printf ("-D%d", first + last);
7172 printf ("}");
7173 }
7174 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7175 {
7176 unsigned int count = op & 0x07;
7177
7178 printf ("pop {D8");
7179 if (count)
7180 printf ("-D%d", 8 + count);
7181 printf ("}");
7182 }
7183 else if (op >= 0xc0 && op <= 0xc5)
7184 {
7185 unsigned int count = op & 0x07;
7186
7187 printf (" pop {wR10");
7188 if (count)
7189 printf ("-wR%d", 10 + count);
7190 printf ("}");
7191 }
7192 else if (op == 0xc6)
7193 {
7194 unsigned int first, last;
7195
7196 GET_OP (op2);
7197 first = op2 >> 4;
7198 last = op2 & 0x0f;
7199 printf ("pop {wR%d", first);
7200 if (last)
7201 printf ("-wR%d", first + last);
7202 printf ("}");
7203 }
7204 else if (op == 0xc7)
7205 {
7206 GET_OP (op2);
7207 if (op2 == 0 || (op2 & 0xf0) != 0)
7208 printf (_("[Spare]"));
0b6ae522
DJ		 7209 else
7210 {
61865e30
NC		 7211 unsigned int mask = op2 & 0x0f;
7212 int first = 1;
7213 int i;
7214
7215 printf ("pop {");
7216 for (i = 0; i < 4; i++)
7217 if (mask & (1 << i))
7218 {
7219 if (first)
7220 first = 0;
7221 else
7222 printf (", ");
7223 printf ("wCGR%d", i);
7224 }
7225 printf ("}");
0b6ae522
DJ		 7226 }
7227 }
61865e30
NC		 7228 else
7229 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7230 printf ("\n");
7231 }
fa197c1c
PB		 7232}
7233
7234static void
7235decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7236 unsigned int word, unsigned int remaining,
7237 unsigned int more_words,
7238 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7239 struct arm_section *data_arm_sec)
7240{
7241 struct absaddr addr;
7242
7243 /* Decode the unwinding instructions. */
7244 while (1)
7245 {
7246 unsigned int op, op2;
7247
7248 ADVANCE;
7249 if (remaining == 0)
7250 break;
7251 remaining--;
7252 op = word >> 24;
7253 word <<= 8;
7254
9cf03b7e 7255 printf (" 0x%02x ", op);
fa197c1c
PB		 7256
7257 if ((op & 0xc0) == 0x00)
7258 {
7259 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7260 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7261 }
7262 else if ((op & 0xc0) == 0x80)
7263 {
7264 GET_OP (op2);
7265 if (op == 0x80 && op2 == 0)
7266 printf (_("Refuse to unwind"));
7267 else
7268 {
7269 unsigned int mask = ((op & 0x1f) << 8) | op2;
7270 if (op & 0x20)
7271 printf ("pop compact {");
7272 else
7273 printf ("pop {");
7274
7275 decode_tic6x_unwind_regmask (mask);
7276 printf("}");
7277 }
7278 }
7279 else if ((op & 0xf0) == 0xc0)
7280 {
7281 unsigned int reg;
7282 unsigned int nregs;
7283 unsigned int i;
7284 const char *name;
a734115a
NC		 7285 struct
7286 {
fa197c1c
PB		 7287 unsigned int offset;
7288 unsigned int reg;
7289 } regpos[16];
7290
7291 /* Scan entire instruction first so that GET_OP output is not
7292 interleaved with disassembly. */
7293 nregs = 0;
7294 for (i = 0; nregs < (op & 0xf); i++)
7295 {
7296 GET_OP (op2);
7297 reg = op2 >> 4;
7298 if (reg != 0xf)
7299 {
7300 regpos[nregs].offset = i * 2;
7301 regpos[nregs].reg = reg;
7302 nregs++;
7303 }
7304
7305 reg = op2 & 0xf;
7306 if (reg != 0xf)
7307 {
7308 regpos[nregs].offset = i * 2 + 1;
7309 regpos[nregs].reg = reg;
7310 nregs++;
7311 }
7312 }
7313
7314 printf (_("pop frame {"));
7315 reg = nregs - 1;
7316 for (i = i * 2; i > 0; i--)
7317 {
7318 if (regpos[reg].offset == i - 1)
7319 {
7320 name = tic6x_unwind_regnames[regpos[reg].reg];
7321 if (reg > 0)
7322 reg--;
7323 }
7324 else
7325 name = _("[pad]");
7326
7327 fputs (name, stdout);
7328 if (i > 1)
7329 printf (", ");
7330 }
7331
7332 printf ("}");
7333 }
7334 else if (op == 0xd0)
7335 printf (" MOV FP, SP");
7336 else if (op == 0xd1)
7337 printf (" __c6xabi_pop_rts");
7338 else if (op == 0xd2)
7339 {
7340 unsigned char buf[9];
7341 unsigned int i, len;
7342 unsigned long offset;
a734115a 7343
fa197c1c
PB		 7344 for (i = 0; i < sizeof (buf); i++)
7345 {
7346 GET_OP (buf[i]);
7347 if ((buf[i] & 0x80) == 0)
7348 break;
7349 }
7350 assert (i < sizeof (buf));
f6f0e17b 7351 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7352 assert (len == i + 1);
7353 offset = offset * 8 + 0x408;
7354 printf (_("sp = sp + %ld"), offset);
7355 }
7356 else if ((op & 0xf0) == 0xe0)
7357 {
7358 if ((op & 0x0f) == 7)
7359 printf (" RETURN");
7360 else
7361 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7362 }
7363 else
7364 {
7365 printf (_(" [unsupported opcode]"));
7366 }
7367 putchar ('\n');
7368 }
7369}
7370
7371static bfd_vma
a734115a 7372arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7373{
7374 bfd_vma offset;
7375
7376 offset = word & 0x7fffffff;
7377 if (offset & 0x40000000)
7378 offset |= ~ (bfd_vma) 0x7fffffff;
7379
7380 if (elf_header.e_machine == EM_TI_C6000)
7381 offset <<= 1;
7382
7383 return offset + where;
7384}
7385
7386static void
1b31d05e
NC		 7387decode_arm_unwind (struct arm_unw_aux_info * aux,
7388 unsigned int word,
7389 unsigned int remaining,
7390 bfd_vma data_offset,
7391 Elf_Internal_Shdr * data_sec,
7392 struct arm_section * data_arm_sec)
fa197c1c
PB		 7393{
7394 int per_index;
7395 unsigned int more_words = 0;
37e14bc3 7396 struct absaddr addr;
1b31d05e 7397 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7398
7399 if (remaining == 0)
7400 {
1b31d05e
NC		 7401 /* Fetch the first word.
7402 Note - when decoding an object file the address extracted
7403 here will always be 0. So we also pass in the sym_name
7404 parameter so that we can find the symbol associated with
7405 the personality routine. */
7406 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7407 & word, & addr, & sym_name))
fa197c1c 7408 return;
1b31d05e 7409
fa197c1c
PB		 7410 remaining = 4;
7411 }
7412
7413 if ((word & 0x80000000) == 0)
7414 {
7415 /* Expand prel31 for personality routine. */
7416 bfd_vma fn;
7417 const char *procname;
7418
a734115a 7419 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7420 printf (_(" Personality routine: "));
1b31d05e
NC		 7421 if (fn == 0
7422 && addr.section == SHN_UNDEF && addr.offset == 0
7423 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7424 {
7425 procname = aux->strtab + sym_name;
7426 print_vma (fn, PREFIX_HEX);
7427 if (procname)
7428 {
7429 fputs (" <", stdout);
7430 fputs (procname, stdout);
7431 fputc ('>', stdout);
7432 }
7433 }
7434 else
7435 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7436 fputc ('\n', stdout);
7437
7438 /* The GCC personality routines use the standard compact
7439 encoding, starting with one byte giving the number of
7440 words. */
7441 if (procname != NULL
7442 && (const_strneq (procname, "__gcc_personality_v0")
7443 || const_strneq (procname, "__gxx_personality_v0")
7444 || const_strneq (procname, "__gcj_personality_v0")
7445 || const_strneq (procname, "__gnu_objc_personality_v0")))
7446 {
7447 remaining = 0;
7448 more_words = 1;
7449 ADVANCE;
7450 if (!remaining)
7451 {
7452 printf (_(" [Truncated data]\n"));
7453 return;
7454 }
7455 more_words = word >> 24;
7456 word <<= 8;
7457 remaining--;
7458 per_index = -1;
7459 }
7460 else
7461 return;
7462 }
7463 else
7464 {
1b31d05e 7465 /* ARM EHABI Section 6.3:
0b4362b0 7466
1b31d05e 7467 An exception-handling table entry for the compact model looks like:
0b4362b0 7468
1b31d05e
NC		 7469 31 30-28 27-24 23-0
7470 -- ----- ----- ----
7471 1 0 index Data for personalityRoutine[index] */
7472
7473 if (elf_header.e_machine == EM_ARM
7474 && (word & 0x70000000))
83c257ca 7475 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7476
fa197c1c 7477 per_index = (word >> 24) & 0x7f;
1b31d05e 7478 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7479 if (per_index == 0)
7480 {
7481 more_words = 0;
7482 word <<= 8;
7483 remaining--;
7484 }
7485 else if (per_index < 3)
7486 {
7487 more_words = (word >> 16) & 0xff;
7488 word <<= 16;
7489 remaining -= 2;
7490 }
7491 }
7492
7493 switch (elf_header.e_machine)
7494 {
7495 case EM_ARM:
7496 if (per_index < 3)
7497 {
7498 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7499 data_offset, data_sec, data_arm_sec);
7500 }
7501 else
1b31d05e
NC		 7502 {
7503 warn (_("Unknown ARM compact model index encountered\n"));
7504 printf (_(" [reserved]\n"));
7505 }
fa197c1c
PB		 7506 break;
7507
7508 case EM_TI_C6000:
7509 if (per_index < 3)
7510 {
7511 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7512 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7513 }
7514 else if (per_index < 5)
7515 {
7516 if (((word >> 17) & 0x7f) == 0x7f)
7517 printf (_(" Restore stack from frame pointer\n"));
7518 else
7519 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7520 printf (_(" Registers restored: "));
7521 if (per_index == 4)
7522 printf (" (compact) ");
7523 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7524 putchar ('\n');
7525 printf (_(" Return register: %s\n"),
7526 tic6x_unwind_regnames[word & 0xf]);
7527 }
7528 else
1b31d05e 7529 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7530 break;
7531
7532 default:
1b31d05e
NC		 7533 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7534 elf_header.e_machine);
fa197c1c 7535 }
0b6ae522
DJ		 7536
7537 /* Decode the descriptors. Not implemented. */
7538}
7539
7540static void
7541dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7542{
7543 struct arm_section exidx_arm_sec, extab_arm_sec;
7544 unsigned int i, exidx_len;
7545
7546 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7547 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7548 exidx_len = exidx_sec->sh_size / 8;
7549
7550 for (i = 0; i < exidx_len; i++)
7551 {
7552 unsigned int exidx_fn, exidx_entry;
7553 struct absaddr fn_addr, entry_addr;
7554 bfd_vma fn;
7555
7556 fputc ('\n', stdout);
7557
1b31d05e
NC		 7558 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7559 8 * i, & exidx_fn, & fn_addr, NULL)
7560 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7561 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7562 {
1b31d05e
NC		 7563 arm_free_section (& exidx_arm_sec);
7564 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7565 return;
7566 }
7567
83c257ca
NC		 7568 /* ARM EHABI, Section 5:
7569 An index table entry consists of 2 words.
7570 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7571 if (exidx_fn & 0x80000000)
7572 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7573
a734115a 7574 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7575
a734115a 7576 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7577 fputs (": ", stdout);
7578
7579 if (exidx_entry == 1)
7580 {
7581 print_vma (exidx_entry, PREFIX_HEX);
7582 fputs (" [cantunwind]\n", stdout);
7583 }
7584 else if (exidx_entry & 0x80000000)
7585 {
7586 print_vma (exidx_entry, PREFIX_HEX);
7587 fputc ('\n', stdout);
7588 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7589 }
7590 else
7591 {
8f73510c 7592 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7593 Elf_Internal_Shdr *table_sec;
7594
7595 fputs ("@", stdout);
a734115a 7596 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7597 print_vma (table, PREFIX_HEX);
7598 printf ("\n");
7599
7600 /* Locate the matching .ARM.extab. */
7601 if (entry_addr.section != SHN_UNDEF
7602 && entry_addr.section < elf_header.e_shnum)
7603 {
7604 table_sec = section_headers + entry_addr.section;
7605 table_offset = entry_addr.offset;
7606 }
7607 else
7608 {
7609 table_sec = find_section_by_address (table);
7610 if (table_sec != NULL)
7611 table_offset = table - table_sec->sh_addr;
7612 }
7613 if (table_sec == NULL)
7614 {
7615 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7616 (unsigned long) table);
7617 continue;
7618 }
7619 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7620 &extab_arm_sec);
7621 }
7622 }
7623
7624 printf ("\n");
7625
7626 arm_free_section (&exidx_arm_sec);
7627 arm_free_section (&extab_arm_sec);
7628}
7629
fa197c1c 7630/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7631
7632static void
0b6ae522
DJ		 7633arm_process_unwind (FILE *file)
7634{
7635 struct arm_unw_aux_info aux;
7636 Elf_Internal_Shdr *unwsec = NULL;
7637 Elf_Internal_Shdr *strsec;
7638 Elf_Internal_Shdr *sec;
7639 unsigned long i;
fa197c1c 7640 unsigned int sec_type;
0b6ae522 7641
fa197c1c
PB		 7642 switch (elf_header.e_machine)
7643 {
7644 case EM_ARM:
7645 sec_type = SHT_ARM_EXIDX;
7646 break;
7647
7648 case EM_TI_C6000:
7649 sec_type = SHT_C6000_UNWIND;
7650 break;
7651
0b4362b0 7652 default:
1b31d05e
NC		 7653 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7654 elf_header.e_machine);
7655 return;
fa197c1c
PB		 7656 }
7657
0b6ae522 7658 if (string_table == NULL)
1b31d05e
NC		 7659 return;
7660
7661 memset (& aux, 0, sizeof (aux));
7662 aux.file = file;
0b6ae522
DJ		 7663
7664 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7665 {
7666 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7667 {
ba5cdace 7668 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7669
7670 strsec = section_headers + sec->sh_link;
59245841 7671 assert (aux.strtab == NULL);
0b6ae522
DJ		 7672 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7673 1, strsec->sh_size, _("string table"));
7674 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7675 }
fa197c1c 7676 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7677 unwsec = sec;
7678 }
7679
1b31d05e 7680 if (unwsec == NULL)
0b6ae522 7681 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7682 else
7683 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7684 {
7685 if (sec->sh_type == sec_type)
7686 {
7687 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7688 SECTION_NAME (sec),
7689 (unsigned long) sec->sh_offset,
7690 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7691
1b31d05e
NC		 7692 dump_arm_unwind (&aux, sec);
7693 }
7694 }
0b6ae522
DJ		 7695
7696 if (aux.symtab)
7697 free (aux.symtab);
7698 if (aux.strtab)
7699 free ((char *) aux.strtab);
0b6ae522
DJ		 7700}
7701
1b31d05e 7702static void
2cf0635d 7703process_unwind (FILE * file)
57346661 7704{
2cf0635d
NC		 7705 struct unwind_handler
7706 {
57346661 7707 int machtype;
1b31d05e 7708 void (* handler)(FILE *);
2cf0635d
NC		 7709 } handlers[] =
7710 {
0b6ae522 7711 { EM_ARM, arm_process_unwind },
57346661
AM		 7712 { EM_IA_64, ia64_process_unwind },
7713 { EM_PARISC, hppa_process_unwind },
fa197c1c 7714 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7715 { 0, 0 }
7716 };
7717 int i;
7718
7719 if (!do_unwind)
1b31d05e 7720 return;
57346661
AM		 7721
7722 for (i = 0; handlers[i].handler != NULL; i++)
7723 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 7724 {
7725 handlers[i].handler (file);
7726 return;
7727 }
57346661 7728
1b31d05e
NC		 7729 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7730 get_machine_name (elf_header.e_machine));
57346661
AM		 7731}
7732
252b5132 7733static void
2cf0635d 7734dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7735{
7736 switch (entry->d_tag)
7737 {
7738 case DT_MIPS_FLAGS:
7739 if (entry->d_un.d_val == 0)
4b68bca3 7740 printf (_("NONE"));
252b5132
RH		 7741 else
7742 {
7743 static const char * opts[] =
7744 {
7745 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7746 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7747 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7748 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7749 "RLD_ORDER_SAFE"
7750 };
7751 unsigned int cnt;
7752 int first = 1;
2b692964 7753
60bca95a 7754 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7755 if (entry->d_un.d_val & (1 << cnt))
7756 {
7757 printf ("%s%s", first ? "" : " ", opts[cnt]);
7758 first = 0;
7759 }
252b5132
RH		 7760 }
7761 break;
103f02d3 7762
252b5132 7763 case DT_MIPS_IVERSION:
d79b3d50 7764 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7765 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7766 else
4b68bca3 7767 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7768 break;
103f02d3 7769
252b5132
RH		 7770 case DT_MIPS_TIME_STAMP:
7771 {
7772 char timebuf[20];
2cf0635d 7773 struct tm * tmp;
50da7a9c 7774
91d6fa6a
NC		 7775 time_t atime = entry->d_un.d_val;
7776 tmp = gmtime (&atime);
e9e44622
JJ		 7777 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7778 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7779 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7780 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7781 }
7782 break;
103f02d3 7783
252b5132
RH		 7784 case DT_MIPS_RLD_VERSION:
7785 case DT_MIPS_LOCAL_GOTNO:
7786 case DT_MIPS_CONFLICTNO:
7787 case DT_MIPS_LIBLISTNO:
7788 case DT_MIPS_SYMTABNO:
7789 case DT_MIPS_UNREFEXTNO:
7790 case DT_MIPS_HIPAGENO:
7791 case DT_MIPS_DELTA_CLASS_NO:
7792 case DT_MIPS_DELTA_INSTANCE_NO:
7793 case DT_MIPS_DELTA_RELOC_NO:
7794 case DT_MIPS_DELTA_SYM_NO:
7795 case DT_MIPS_DELTA_CLASSSYM_NO:
7796 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7797 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7798 break;
103f02d3
UD		 7799
7800 default:
4b68bca3 7801 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7802 }
4b68bca3 7803 putchar ('\n');
103f02d3
UD		 7804}
7805
103f02d3 7806static void
2cf0635d 7807dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7808{
7809 switch (entry->d_tag)
7810 {
7811 case DT_HP_DLD_FLAGS:
7812 {
7813 static struct
7814 {
7815 long int bit;
2cf0635d 7816 const char * str;
5e220199
NC		 7817 }
7818 flags[] =
7819 {
7820 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7821 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7822 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7823 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7824 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7825 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7826 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7827 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7828 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7829 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7830 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7831 { DT_HP_GST, "HP_GST" },
7832 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7833 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7834 { DT_HP_NODELETE, "HP_NODELETE" },
7835 { DT_HP_GROUP, "HP_GROUP" },
7836 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7837 };
103f02d3 7838 int first = 1;
5e220199 7839 size_t cnt;
f7a99963 7840 bfd_vma val = entry->d_un.d_val;
103f02d3 7841
60bca95a 7842 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7843 if (val & flags[cnt].bit)
30800947
NC		 7844 {
7845 if (! first)
7846 putchar (' ');
7847 fputs (flags[cnt].str, stdout);
7848 first = 0;
7849 val ^= flags[cnt].bit;
7850 }
76da6bbe 7851
103f02d3 7852 if (val != 0 || first)
f7a99963
NC		 7853 {
7854 if (! first)
7855 putchar (' ');
7856 print_vma (val, HEX);
7857 }
103f02d3
UD		 7858 }
7859 break;
76da6bbe 7860
252b5132 7861 default:
f7a99963
NC		 7862 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7863 break;
252b5132 7864 }
35b1837e 7865 putchar ('\n');
252b5132
RH		 7866}
7867
28f997cf
TG		 7868#ifdef BFD64
7869
7870/* VMS vs Unix time offset and factor. */
7871
7872#define VMS_EPOCH_OFFSET 35067168000000000LL
7873#define VMS_GRANULARITY_FACTOR 10000000
7874
7875/* Display a VMS time in a human readable format. */
7876
7877static void
7878print_vms_time (bfd_int64_t vmstime)
7879{
7880 struct tm *tm;
7881 time_t unxtime;
7882
7883 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7884 tm = gmtime (&unxtime);
7885 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7886 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7887 tm->tm_hour, tm->tm_min, tm->tm_sec);
7888}
7889#endif /* BFD64 */
7890
ecc51f48 7891static void
2cf0635d 7892dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7893{
7894 switch (entry->d_tag)
7895 {
0de14b54 7896 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7897 /* First 3 slots reserved. */
ecc51f48
NC		 7898 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7899 printf (" -- ");
7900 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7901 break;
7902
28f997cf
TG		 7903 case DT_IA_64_VMS_LINKTIME:
7904#ifdef BFD64
7905 print_vms_time (entry->d_un.d_val);
7906#endif
7907 break;
7908
7909 case DT_IA_64_VMS_LNKFLAGS:
7910 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7911 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7912 printf (" CALL_DEBUG");
7913 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7914 printf (" NOP0BUFS");
7915 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7916 printf (" P0IMAGE");
7917 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7918 printf (" MKTHREADS");
7919 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7920 printf (" UPCALLS");
7921 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7922 printf (" IMGSTA");
7923 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7924 printf (" INITIALIZE");
7925 if (entry->d_un.d_val & VMS_LF_MAIN)
7926 printf (" MAIN");
7927 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7928 printf (" EXE_INIT");
7929 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7930 printf (" TBK_IN_IMG");
7931 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7932 printf (" DBG_IN_IMG");
7933 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7934 printf (" TBK_IN_DSF");
7935 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7936 printf (" DBG_IN_DSF");
7937 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7938 printf (" SIGNATURES");
7939 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7940 printf (" REL_SEG_OFF");
7941 break;
7942
bdf4d63a
JJ		 7943 default:
7944 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7945 break;
ecc51f48 7946 }
bdf4d63a 7947 putchar ('\n');
ecc51f48
NC		 7948}
7949
252b5132 7950static int
2cf0635d 7951get_32bit_dynamic_section (FILE * file)
252b5132 7952{
2cf0635d
NC		 7953 Elf32_External_Dyn * edyn;
7954 Elf32_External_Dyn * ext;
7955 Elf_Internal_Dyn * entry;
103f02d3 7956
3f5e193b
NC		 7957 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7958 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7959 if (!edyn)
7960 return 0;
103f02d3 7961
ba2685cc
AM		 7962/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7963 might not have the luxury of section headers. Look for the DT_NULL
7964 terminator to determine the number of entries. */
7965 for (ext = edyn, dynamic_nent = 0;
7966 (char *) ext < (char *) edyn + dynamic_size;
7967 ext++)
7968 {
7969 dynamic_nent++;
7970 if (BYTE_GET (ext->d_tag) == DT_NULL)
7971 break;
7972 }
252b5132 7973
3f5e193b
NC		 7974 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7975 sizeof (* entry));
b2d38a17 7976 if (dynamic_section == NULL)
252b5132 7977 {
9ea033b2
NC		 7978 error (_("Out of memory\n"));
7979 free (edyn);
7980 return 0;
7981 }
252b5132 7982
fb514b26 7983 for (ext = edyn, entry = dynamic_section;
ba2685cc 7984 entry < dynamic_section + dynamic_nent;
fb514b26 7985 ext++, entry++)
9ea033b2 7986 {
fb514b26
AM		 7987 entry->d_tag = BYTE_GET (ext->d_tag);
7988 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7989 }
7990
9ea033b2
NC		 7991 free (edyn);
7992
7993 return 1;
7994}
7995
7996static int
2cf0635d 7997get_64bit_dynamic_section (FILE * file)
9ea033b2 7998{
2cf0635d
NC		 7999 Elf64_External_Dyn * edyn;
8000 Elf64_External_Dyn * ext;
8001 Elf_Internal_Dyn * entry;
103f02d3 8002
3f5e193b
NC		 8003 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8004 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8005 if (!edyn)
8006 return 0;
103f02d3 8007
ba2685cc
AM		 8008/* SGI's ELF has more than one section in the DYNAMIC segment, and we
8009 might not have the luxury of section headers. Look for the DT_NULL
8010 terminator to determine the number of entries. */
8011 for (ext = edyn, dynamic_nent = 0;
8012 (char *) ext < (char *) edyn + dynamic_size;
8013 ext++)
8014 {
8015 dynamic_nent++;
66543521 8016 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8017 break;
8018 }
252b5132 8019
3f5e193b
NC		 8020 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8021 sizeof (* entry));
b2d38a17 8022 if (dynamic_section == NULL)
252b5132
RH		 8023 {
8024 error (_("Out of memory\n"));
8025 free (edyn);
8026 return 0;
8027 }
8028
fb514b26 8029 for (ext = edyn, entry = dynamic_section;
ba2685cc 8030 entry < dynamic_section + dynamic_nent;
fb514b26 8031 ext++, entry++)
252b5132 8032 {
66543521
AM		 8033 entry->d_tag = BYTE_GET (ext->d_tag);
8034 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8035 }
8036
8037 free (edyn);
8038
9ea033b2
NC		 8039 return 1;
8040}
8041
e9e44622
JJ		 8042static void
8043print_dynamic_flags (bfd_vma flags)
d1133906 8044{
e9e44622 8045 int first = 1;
13ae64f3 8046
d1133906
NC		 8047 while (flags)
8048 {
8049 bfd_vma flag;
8050
8051 flag = flags & - flags;
8052 flags &= ~ flag;
8053
e9e44622
JJ		 8054 if (first)
8055 first = 0;
8056 else
8057 putc (' ', stdout);
13ae64f3 8058
d1133906
NC		 8059 switch (flag)
8060 {
e9e44622
JJ		 8061 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8062 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8063 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8064 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8065 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8066 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8067 }
8068 }
e9e44622 8069 puts ("");
d1133906
NC		 8070}
8071
b2d38a17
NC		 8072/* Parse and display the contents of the dynamic section. */
8073
9ea033b2 8074static int
2cf0635d 8075process_dynamic_section (FILE * file)
9ea033b2 8076{
2cf0635d 8077 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8078
8079 if (dynamic_size == 0)
8080 {
8081 if (do_dynamic)
b2d38a17 8082 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8083
8084 return 1;
8085 }
8086
8087 if (is_32bit_elf)
8088 {
b2d38a17 8089 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8090 return 0;
8091 }
b2d38a17 8092 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8093 return 0;
8094
252b5132
RH		 8095 /* Find the appropriate symbol table. */
8096 if (dynamic_symbols == NULL)
8097 {
86dba8ee
AM		 8098 for (entry = dynamic_section;
8099 entry < dynamic_section + dynamic_nent;
8100 ++entry)
252b5132 8101 {
c8286bd1 8102 Elf_Internal_Shdr section;
252b5132
RH		 8103
8104 if (entry->d_tag != DT_SYMTAB)
8105 continue;
8106
8107 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8108
8109 /* Since we do not know how big the symbol table is,
8110 we default to reading in the entire file (!) and
8111 processing that. This is overkill, I know, but it
e3c8793a 8112 should work. */
d93f0186 8113 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8114
fb52b2f4
NC		 8115 if (archive_file_offset != 0)
8116 section.sh_size = archive_file_size - section.sh_offset;
8117 else
8118 {
8119 if (fseek (file, 0, SEEK_END))
591a748a 8120 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8121
8122 section.sh_size = ftell (file) - section.sh_offset;
8123 }
252b5132 8124
9ea033b2 8125 if (is_32bit_elf)
9ad5cbcf 8126 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8127 else
9ad5cbcf 8128 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 8129
ba5cdace 8130 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8131 if (num_dynamic_syms < 1)
252b5132
RH		 8132 {
8133 error (_("Unable to determine the number of symbols to load\n"));
8134 continue;
8135 }
252b5132
RH		 8136 }
8137 }
8138
8139 /* Similarly find a string table. */
8140 if (dynamic_strings == NULL)
8141 {
86dba8ee
AM		 8142 for (entry = dynamic_section;
8143 entry < dynamic_section + dynamic_nent;
8144 ++entry)
252b5132
RH		 8145 {
8146 unsigned long offset;
b34976b6 8147 long str_tab_len;
252b5132
RH		 8148
8149 if (entry->d_tag != DT_STRTAB)
8150 continue;
8151
8152 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8153
8154 /* Since we do not know how big the string table is,
8155 we default to reading in the entire file (!) and
8156 processing that. This is overkill, I know, but it
e3c8793a 8157 should work. */
252b5132 8158
d93f0186 8159 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8160
8161 if (archive_file_offset != 0)
8162 str_tab_len = archive_file_size - offset;
8163 else
8164 {
8165 if (fseek (file, 0, SEEK_END))
8166 error (_("Unable to seek to end of file\n"));
8167 str_tab_len = ftell (file) - offset;
8168 }
252b5132
RH		 8169
8170 if (str_tab_len < 1)
8171 {
8172 error
8173 (_("Unable to determine the length of the dynamic string table\n"));
8174 continue;
8175 }
8176
3f5e193b
NC		 8177 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8178 str_tab_len,
8179 _("dynamic string table"));
59245841 8180 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8181 break;
8182 }
8183 }
8184
8185 /* And find the syminfo section if available. */
8186 if (dynamic_syminfo == NULL)
8187 {
3e8bba36 8188 unsigned long syminsz = 0;
252b5132 8189
86dba8ee
AM		 8190 for (entry = dynamic_section;
8191 entry < dynamic_section + dynamic_nent;
8192 ++entry)
252b5132
RH		 8193 {
8194 if (entry->d_tag == DT_SYMINENT)
8195 {
8196 /* Note: these braces are necessary to avoid a syntax
8197 error from the SunOS4 C compiler. */
8198 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
8199 }
8200 else if (entry->d_tag == DT_SYMINSZ)
8201 syminsz = entry->d_un.d_val;
8202 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8203 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8204 syminsz);
252b5132
RH		 8205 }
8206
8207 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8208 {
2cf0635d
NC		 8209 Elf_External_Syminfo * extsyminfo;
8210 Elf_External_Syminfo * extsym;
8211 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8212
8213 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8214 extsyminfo = (Elf_External_Syminfo *)
8215 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8216 _("symbol information"));
a6e9f9df
AM		 8217 if (!extsyminfo)
8218 return 0;
252b5132 8219
3f5e193b 8220 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8221 if (dynamic_syminfo == NULL)
8222 {
8223 error (_("Out of memory\n"));
8224 return 0;
8225 }
8226
8227 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8228 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8229 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8230 ++syminfo, ++extsym)
252b5132 8231 {
86dba8ee
AM		 8232 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8233 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8234 }
8235
8236 free (extsyminfo);
8237 }
8238 }
8239
8240 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 8241 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8242 dynamic_addr, dynamic_nent);
252b5132
RH		 8243 if (do_dynamic)
8244 printf (_(" Tag Type Name/Value\n"));
8245
86dba8ee
AM		 8246 for (entry = dynamic_section;
8247 entry < dynamic_section + dynamic_nent;
8248 entry++)
252b5132
RH		 8249 {
8250 if (do_dynamic)
f7a99963 8251 {
2cf0635d 8252 const char * dtype;
e699b9ff 8253
f7a99963
NC		 8254 putchar (' ');
8255 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8256 dtype = get_dynamic_type (entry->d_tag);
8257 printf (" (%s)%*s", dtype,
8258 ((is_32bit_elf ? 27 : 19)
8259 - (int) strlen (dtype)),
f7a99963
NC		 8260 " ");
8261 }
252b5132
RH		 8262
8263 switch (entry->d_tag)
8264 {
d1133906
NC		 8265 case DT_FLAGS:
8266 if (do_dynamic)
e9e44622 8267 print_dynamic_flags (entry->d_un.d_val);
d1133906 8268 break;
76da6bbe 8269
252b5132
RH		 8270 case DT_AUXILIARY:
8271 case DT_FILTER:
019148e4
L		 8272 case DT_CONFIG:
8273 case DT_DEPAUDIT:
8274 case DT_AUDIT:
252b5132
RH		 8275 if (do_dynamic)
8276 {
019148e4 8277 switch (entry->d_tag)
b34976b6 8278 {
019148e4
L		 8279 case DT_AUXILIARY:
8280 printf (_("Auxiliary library"));
8281 break;
8282
8283 case DT_FILTER:
8284 printf (_("Filter library"));
8285 break;
8286
b34976b6 8287 case DT_CONFIG:
019148e4
L		 8288 printf (_("Configuration file"));
8289 break;
8290
8291 case DT_DEPAUDIT:
8292 printf (_("Dependency audit library"));
8293 break;
8294
8295 case DT_AUDIT:
8296 printf (_("Audit library"));
8297 break;
8298 }
252b5132 8299
d79b3d50
NC		 8300 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8301 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8302 else
f7a99963
NC		 8303 {
8304 printf (": ");
8305 print_vma (entry->d_un.d_val, PREFIX_HEX);
8306 putchar ('\n');
8307 }
252b5132
RH		 8308 }
8309 break;
8310
dcefbbbd 8311 case DT_FEATURE:
252b5132
RH		 8312 if (do_dynamic)
8313 {
8314 printf (_("Flags:"));
86f55779 8315
252b5132
RH		 8316 if (entry->d_un.d_val == 0)
8317 printf (_(" None\n"));
8318 else
8319 {
8320 unsigned long int val = entry->d_un.d_val;
86f55779 8321
252b5132
RH		 8322 if (val & DTF_1_PARINIT)
8323 {
8324 printf (" PARINIT");
8325 val ^= DTF_1_PARINIT;
8326 }
dcefbbbd
L		 8327 if (val & DTF_1_CONFEXP)
8328 {
8329 printf (" CONFEXP");
8330 val ^= DTF_1_CONFEXP;
8331 }
252b5132
RH		 8332 if (val != 0)
8333 printf (" %lx", val);
8334 puts ("");
8335 }
8336 }
8337 break;
8338
8339 case DT_POSFLAG_1:
8340 if (do_dynamic)
8341 {
8342 printf (_("Flags:"));
86f55779 8343
252b5132
RH		 8344 if (entry->d_un.d_val == 0)
8345 printf (_(" None\n"));
8346 else
8347 {
8348 unsigned long int val = entry->d_un.d_val;
86f55779 8349
252b5132
RH		 8350 if (val & DF_P1_LAZYLOAD)
8351 {
8352 printf (" LAZYLOAD");
8353 val ^= DF_P1_LAZYLOAD;
8354 }
8355 if (val & DF_P1_GROUPPERM)
8356 {
8357 printf (" GROUPPERM");
8358 val ^= DF_P1_GROUPPERM;
8359 }
8360 if (val != 0)
8361 printf (" %lx", val);
8362 puts ("");
8363 }
8364 }
8365 break;
8366
8367 case DT_FLAGS_1:
8368 if (do_dynamic)
8369 {
8370 printf (_("Flags:"));
8371 if (entry->d_un.d_val == 0)
8372 printf (_(" None\n"));
8373 else
8374 {
8375 unsigned long int val = entry->d_un.d_val;
86f55779 8376
252b5132
RH		 8377 if (val & DF_1_NOW)
8378 {
8379 printf (" NOW");
8380 val ^= DF_1_NOW;
8381 }
8382 if (val & DF_1_GLOBAL)
8383 {
8384 printf (" GLOBAL");
8385 val ^= DF_1_GLOBAL;
8386 }
8387 if (val & DF_1_GROUP)
8388 {
8389 printf (" GROUP");
8390 val ^= DF_1_GROUP;
8391 }
8392 if (val & DF_1_NODELETE)
8393 {
8394 printf (" NODELETE");
8395 val ^= DF_1_NODELETE;
8396 }
8397 if (val & DF_1_LOADFLTR)
8398 {
8399 printf (" LOADFLTR");
8400 val ^= DF_1_LOADFLTR;
8401 }
8402 if (val & DF_1_INITFIRST)
8403 {
8404 printf (" INITFIRST");
8405 val ^= DF_1_INITFIRST;
8406 }
8407 if (val & DF_1_NOOPEN)
8408 {
8409 printf (" NOOPEN");
8410 val ^= DF_1_NOOPEN;
8411 }
8412 if (val & DF_1_ORIGIN)
8413 {
8414 printf (" ORIGIN");
8415 val ^= DF_1_ORIGIN;
8416 }
8417 if (val & DF_1_DIRECT)
8418 {
8419 printf (" DIRECT");
8420 val ^= DF_1_DIRECT;
8421 }
8422 if (val & DF_1_TRANS)
8423 {
8424 printf (" TRANS");
8425 val ^= DF_1_TRANS;
8426 }
8427 if (val & DF_1_INTERPOSE)
8428 {
8429 printf (" INTERPOSE");
8430 val ^= DF_1_INTERPOSE;
8431 }
f7db6139 8432 if (val & DF_1_NODEFLIB)
dcefbbbd 8433 {
f7db6139
L		 8434 printf (" NODEFLIB");
8435 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8436 }
8437 if (val & DF_1_NODUMP)
8438 {
8439 printf (" NODUMP");
8440 val ^= DF_1_NODUMP;
8441 }
34b60028 8442 if (val & DF_1_CONFALT)
dcefbbbd 8443 {
34b60028
L		 8444 printf (" CONFALT");
8445 val ^= DF_1_CONFALT;
8446 }
8447 if (val & DF_1_ENDFILTEE)
8448 {
8449 printf (" ENDFILTEE");
8450 val ^= DF_1_ENDFILTEE;
8451 }
8452 if (val & DF_1_DISPRELDNE)
8453 {
8454 printf (" DISPRELDNE");
8455 val ^= DF_1_DISPRELDNE;
8456 }
8457 if (val & DF_1_DISPRELPND)
8458 {
8459 printf (" DISPRELPND");
8460 val ^= DF_1_DISPRELPND;
8461 }
8462 if (val & DF_1_NODIRECT)
8463 {
8464 printf (" NODIRECT");
8465 val ^= DF_1_NODIRECT;
8466 }
8467 if (val & DF_1_IGNMULDEF)
8468 {
8469 printf (" IGNMULDEF");
8470 val ^= DF_1_IGNMULDEF;
8471 }
8472 if (val & DF_1_NOKSYMS)
8473 {
8474 printf (" NOKSYMS");
8475 val ^= DF_1_NOKSYMS;
8476 }
8477 if (val & DF_1_NOHDR)
8478 {
8479 printf (" NOHDR");
8480 val ^= DF_1_NOHDR;
8481 }
8482 if (val & DF_1_EDITED)
8483 {
8484 printf (" EDITED");
8485 val ^= DF_1_EDITED;
8486 }
8487 if (val & DF_1_NORELOC)
8488 {
8489 printf (" NORELOC");
8490 val ^= DF_1_NORELOC;
8491 }
8492 if (val & DF_1_SYMINTPOSE)
8493 {
8494 printf (" SYMINTPOSE");
8495 val ^= DF_1_SYMINTPOSE;
8496 }
8497 if (val & DF_1_GLOBAUDIT)
8498 {
8499 printf (" GLOBAUDIT");
8500 val ^= DF_1_GLOBAUDIT;
8501 }
8502 if (val & DF_1_SINGLETON)
8503 {
8504 printf (" SINGLETON");
8505 val ^= DF_1_SINGLETON;
dcefbbbd 8506 }
252b5132
RH		 8507 if (val != 0)
8508 printf (" %lx", val);
8509 puts ("");
8510 }
8511 }
8512 break;
8513
8514 case DT_PLTREL:
566b0d53 8515 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8516 if (do_dynamic)
8517 puts (get_dynamic_type (entry->d_un.d_val));
8518 break;
8519
8520 case DT_NULL :
8521 case DT_NEEDED :
8522 case DT_PLTGOT :
8523 case DT_HASH :
8524 case DT_STRTAB :
8525 case DT_SYMTAB :
8526 case DT_RELA :
8527 case DT_INIT :
8528 case DT_FINI :
8529 case DT_SONAME :
8530 case DT_RPATH :
8531 case DT_SYMBOLIC:
8532 case DT_REL :
8533 case DT_DEBUG :
8534 case DT_TEXTREL :
8535 case DT_JMPREL :
019148e4 8536 case DT_RUNPATH :
252b5132
RH		 8537 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8538
8539 if (do_dynamic)
8540 {
2cf0635d 8541 char * name;
252b5132 8542
d79b3d50
NC		 8543 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8544 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8545 else
d79b3d50 8546 name = NULL;
252b5132
RH		 8547
8548 if (name)
8549 {
8550 switch (entry->d_tag)
8551 {
8552 case DT_NEEDED:
8553 printf (_("Shared library: [%s]"), name);
8554
18bd398b 8555 if (streq (name, program_interpreter))
f7a99963 8556 printf (_(" program interpreter"));
252b5132
RH		 8557 break;
8558
8559 case DT_SONAME:
f7a99963 8560 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8561 break;
8562
8563 case DT_RPATH:
f7a99963 8564 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8565 break;
8566
019148e4
L		 8567 case DT_RUNPATH:
8568 printf (_("Library runpath: [%s]"), name);
8569 break;
8570
252b5132 8571 default:
f7a99963
NC		 8572 print_vma (entry->d_un.d_val, PREFIX_HEX);
8573 break;
252b5132
RH		 8574 }
8575 }
8576 else
f7a99963
NC		 8577 print_vma (entry->d_un.d_val, PREFIX_HEX);
8578
8579 putchar ('\n');
252b5132
RH		 8580 }
8581 break;
8582
8583 case DT_PLTRELSZ:
8584 case DT_RELASZ :
8585 case DT_STRSZ :
8586 case DT_RELSZ :
8587 case DT_RELAENT :
8588 case DT_SYMENT :
8589 case DT_RELENT :
566b0d53 8590 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8591 case DT_PLTPADSZ:
8592 case DT_MOVEENT :
8593 case DT_MOVESZ :
8594 case DT_INIT_ARRAYSZ:
8595 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8596 case DT_GNU_CONFLICTSZ:
8597 case DT_GNU_LIBLISTSZ:
252b5132 8598 if (do_dynamic)
f7a99963
NC		 8599 {
8600 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8601 printf (_(" (bytes)\n"));
f7a99963 8602 }
252b5132
RH		 8603 break;
8604
8605 case DT_VERDEFNUM:
8606 case DT_VERNEEDNUM:
8607 case DT_RELACOUNT:
8608 case DT_RELCOUNT:
8609 if (do_dynamic)
f7a99963
NC		 8610 {
8611 print_vma (entry->d_un.d_val, UNSIGNED);
8612 putchar ('\n');
8613 }
252b5132
RH		 8614 break;
8615
8616 case DT_SYMINSZ:
8617 case DT_SYMINENT:
8618 case DT_SYMINFO:
8619 case DT_USED:
8620 case DT_INIT_ARRAY:
8621 case DT_FINI_ARRAY:
8622 if (do_dynamic)
8623 {
d79b3d50
NC		 8624 if (entry->d_tag == DT_USED
8625 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8626 {
2cf0635d 8627 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8628
b34976b6 8629 if (*name)
252b5132
RH		 8630 {
8631 printf (_("Not needed object: [%s]\n"), name);
8632 break;
8633 }
8634 }
103f02d3 8635
f7a99963
NC		 8636 print_vma (entry->d_un.d_val, PREFIX_HEX);
8637 putchar ('\n');
252b5132
RH		 8638 }
8639 break;
8640
8641 case DT_BIND_NOW:
8642 /* The value of this entry is ignored. */
35b1837e
AM		 8643 if (do_dynamic)
8644 putchar ('\n');
252b5132 8645 break;
103f02d3 8646
047b2264
JJ		 8647 case DT_GNU_PRELINKED:
8648 if (do_dynamic)
8649 {
2cf0635d 8650 struct tm * tmp;
91d6fa6a 8651 time_t atime = entry->d_un.d_val;
047b2264 8652
91d6fa6a 8653 tmp = gmtime (&atime);
047b2264
JJ		 8654 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8655 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8656 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8657
8658 }
8659 break;
8660
fdc90cb4
JJ		 8661 case DT_GNU_HASH:
8662 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8663 if (do_dynamic)
8664 {
8665 print_vma (entry->d_un.d_val, PREFIX_HEX);
8666 putchar ('\n');
8667 }
8668 break;
8669
252b5132
RH		 8670 default:
8671 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8672 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8673 entry->d_un.d_val;
8674
8675 if (do_dynamic)
8676 {
8677 switch (elf_header.e_machine)
8678 {
8679 case EM_MIPS:
4fe85591 8680 case EM_MIPS_RS3_LE:
b2d38a17 8681 dynamic_section_mips_val (entry);
252b5132 8682 break;
103f02d3 8683 case EM_PARISC:
b2d38a17 8684 dynamic_section_parisc_val (entry);
103f02d3 8685 break;
ecc51f48 8686 case EM_IA_64:
b2d38a17 8687 dynamic_section_ia64_val (entry);
ecc51f48 8688 break;
252b5132 8689 default:
f7a99963
NC		 8690 print_vma (entry->d_un.d_val, PREFIX_HEX);
8691 putchar ('\n');
252b5132
RH		 8692 }
8693 }
8694 break;
8695 }
8696 }
8697
8698 return 1;
8699}
8700
8701static char *
d3ba0551 8702get_ver_flags (unsigned int flags)
252b5132 8703{
b34976b6 8704 static char buff[32];
252b5132
RH		 8705
8706 buff[0] = 0;
8707
8708 if (flags == 0)
8709 return _("none");
8710
8711 if (flags & VER_FLG_BASE)
8712 strcat (buff, "BASE ");
8713
8714 if (flags & VER_FLG_WEAK)
8715 {
8716 if (flags & VER_FLG_BASE)
8717 strcat (buff, "| ");
8718
8719 strcat (buff, "WEAK ");
8720 }
8721
44ec90b9
RO		 8722 if (flags & VER_FLG_INFO)
8723 {
8724 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8725 strcat (buff, "| ");
8726
8727 strcat (buff, "INFO ");
8728 }
8729
8730 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8731 strcat (buff, _("| <unknown>"));
252b5132
RH		 8732
8733 return buff;
8734}
8735
8736/* Display the contents of the version sections. */
98fb390a 8737
252b5132 8738static int
2cf0635d 8739process_version_sections (FILE * file)
252b5132 8740{
2cf0635d 8741 Elf_Internal_Shdr * section;
b34976b6
AM		 8742 unsigned i;
8743 int found = 0;
252b5132
RH		 8744
8745 if (! do_version)
8746 return 1;
8747
8748 for (i = 0, section = section_headers;
8749 i < elf_header.e_shnum;
b34976b6 8750 i++, section++)
252b5132
RH		 8751 {
8752 switch (section->sh_type)
8753 {
8754 case SHT_GNU_verdef:
8755 {
2cf0635d 8756 Elf_External_Verdef * edefs;
b34976b6
AM		 8757 unsigned int idx;
8758 unsigned int cnt;
2cf0635d 8759 char * endbuf;
252b5132
RH		 8760
8761 found = 1;
8762
8763 printf
72de5009 8764 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8765 SECTION_NAME (section), section->sh_info);
8766
8767 printf (_(" Addr: 0x"));
8768 printf_vma (section->sh_addr);
72de5009 8769 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8770 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8771 section->sh_link < elf_header.e_shnum
8772 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8773 : _("<corrupt>"));
252b5132 8774
3f5e193b
NC		 8775 edefs = (Elf_External_Verdef *)
8776 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8777 _("version definition section"));
a6e9f9df
AM		 8778 if (!edefs)
8779 break;
59245841 8780 endbuf = (char *) edefs + section->sh_size;
252b5132 8781
b34976b6 8782 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8783 {
2cf0635d
NC		 8784 char * vstart;
8785 Elf_External_Verdef * edef;
b34976b6 8786 Elf_Internal_Verdef ent;
2cf0635d 8787 Elf_External_Verdaux * eaux;
b34976b6
AM		 8788 Elf_Internal_Verdaux aux;
8789 int j;
8790 int isum;
103f02d3 8791
7e26601c
NC		 8792 /* Check for very large indicies. */
8793 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 8794 break;
8795
252b5132 8796 vstart = ((char *) edefs) + idx;
54806181
AM		 8797 if (vstart + sizeof (*edef) > endbuf)
8798 break;
252b5132
RH		 8799
8800 edef = (Elf_External_Verdef *) vstart;
8801
8802 ent.vd_version = BYTE_GET (edef->vd_version);
8803 ent.vd_flags = BYTE_GET (edef->vd_flags);
8804 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8805 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8806 ent.vd_hash = BYTE_GET (edef->vd_hash);
8807 ent.vd_aux = BYTE_GET (edef->vd_aux);
8808 ent.vd_next = BYTE_GET (edef->vd_next);
8809
8810 printf (_(" %#06x: Rev: %d Flags: %s"),
8811 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8812
8813 printf (_(" Index: %d Cnt: %d "),
8814 ent.vd_ndx, ent.vd_cnt);
8815
dd24e3da 8816 /* Check for overflow. */
7e26601c 8817 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8818 break;
8819
252b5132
RH		 8820 vstart += ent.vd_aux;
8821
8822 eaux = (Elf_External_Verdaux *) vstart;
8823
8824 aux.vda_name = BYTE_GET (eaux->vda_name);
8825 aux.vda_next = BYTE_GET (eaux->vda_next);
8826
d79b3d50
NC		 8827 if (VALID_DYNAMIC_NAME (aux.vda_name))
8828 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8829 else
8830 printf (_("Name index: %ld\n"), aux.vda_name);
8831
8832 isum = idx + ent.vd_aux;
8833
b34976b6 8834 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8835 {
dd24e3da 8836 /* Check for overflow. */
7e26601c 8837 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8838 break;
8839
252b5132
RH		 8840 isum += aux.vda_next;
8841 vstart += aux.vda_next;
8842
8843 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8844 if (vstart + sizeof (*eaux) > endbuf)
8845 break;
252b5132
RH		 8846
8847 aux.vda_name = BYTE_GET (eaux->vda_name);
8848 aux.vda_next = BYTE_GET (eaux->vda_next);
8849
d79b3d50 8850 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8851 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8852 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8853 else
8854 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8855 isum, j, aux.vda_name);
8856 }
dd24e3da 8857
54806181
AM		 8858 if (j < ent.vd_cnt)
8859 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8860
8861 idx += ent.vd_next;
8862 }
dd24e3da 8863
54806181
AM		 8864 if (cnt < section->sh_info)
8865 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8866
8867 free (edefs);
8868 }
8869 break;
103f02d3 8870
252b5132
RH		 8871 case SHT_GNU_verneed:
8872 {
2cf0635d 8873 Elf_External_Verneed * eneed;
b34976b6
AM		 8874 unsigned int idx;
8875 unsigned int cnt;
2cf0635d 8876 char * endbuf;
252b5132
RH		 8877
8878 found = 1;
8879
72de5009 8880 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8881 SECTION_NAME (section), section->sh_info);
8882
8883 printf (_(" Addr: 0x"));
8884 printf_vma (section->sh_addr);
72de5009 8885 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8886 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8887 section->sh_link < elf_header.e_shnum
8888 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8889 : _("<corrupt>"));
252b5132 8890
3f5e193b
NC		 8891 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8892 section->sh_offset, 1,
8893 section->sh_size,
9cf03b7e 8894 _("Version Needs section"));
a6e9f9df
AM		 8895 if (!eneed)
8896 break;
59245841 8897 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8898
8899 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8900 {
2cf0635d 8901 Elf_External_Verneed * entry;
b34976b6
AM		 8902 Elf_Internal_Verneed ent;
8903 int j;
8904 int isum;
2cf0635d 8905 char * vstart;
252b5132 8906
7e26601c 8907 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 8908 break;
8909
252b5132 8910 vstart = ((char *) eneed) + idx;
54806181
AM		 8911 if (vstart + sizeof (*entry) > endbuf)
8912 break;
252b5132
RH		 8913
8914 entry = (Elf_External_Verneed *) vstart;
8915
8916 ent.vn_version = BYTE_GET (entry->vn_version);
8917 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8918 ent.vn_file = BYTE_GET (entry->vn_file);
8919 ent.vn_aux = BYTE_GET (entry->vn_aux);
8920 ent.vn_next = BYTE_GET (entry->vn_next);
8921
8922 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8923
d79b3d50
NC		 8924 if (VALID_DYNAMIC_NAME (ent.vn_file))
8925 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8926 else
8927 printf (_(" File: %lx"), ent.vn_file);
8928
8929 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8930
dd24e3da 8931 /* Check for overflow. */
7e26601c 8932 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8933 break;
8934
252b5132
RH		 8935 vstart += ent.vn_aux;
8936
8937 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8938 {
2cf0635d 8939 Elf_External_Vernaux * eaux;
b34976b6 8940 Elf_Internal_Vernaux aux;
252b5132 8941
54806181
AM		 8942 if (vstart + sizeof (*eaux) > endbuf)
8943 break;
252b5132
RH		 8944 eaux = (Elf_External_Vernaux *) vstart;
8945
8946 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8947 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8948 aux.vna_other = BYTE_GET (eaux->vna_other);
8949 aux.vna_name = BYTE_GET (eaux->vna_name);
8950 aux.vna_next = BYTE_GET (eaux->vna_next);
8951
d79b3d50 8952 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8953 printf (_(" %#06x: Name: %s"),
d79b3d50 8954 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8955 else
ecc2063b 8956 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8957 isum, aux.vna_name);
8958
8959 printf (_(" Flags: %s Version: %d\n"),
8960 get_ver_flags (aux.vna_flags), aux.vna_other);
8961
dd24e3da 8962 /* Check for overflow. */
7e26601c 8963 if (aux.vna_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8964 break;
8965
252b5132
RH		 8966 isum += aux.vna_next;
8967 vstart += aux.vna_next;
8968 }
9cf03b7e 8969
54806181 8970 if (j < ent.vn_cnt)
9cf03b7e 8971 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8972
8973 idx += ent.vn_next;
8974 }
9cf03b7e 8975
54806181 8976 if (cnt < section->sh_info)
9cf03b7e 8977 warn (_("Missing Version Needs information\n"));
103f02d3 8978
252b5132
RH		 8979 free (eneed);
8980 }
8981 break;
8982
8983 case SHT_GNU_versym:
8984 {
2cf0635d 8985 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8986 int total;
8987 int cnt;
2cf0635d
NC		 8988 unsigned char * edata;
8989 unsigned short * data;
8990 char * strtab;
8991 Elf_Internal_Sym * symbols;
8992 Elf_Internal_Shdr * string_sec;
ba5cdace 8993 unsigned long num_syms;
d3ba0551 8994 long off;
252b5132 8995
4fbb74a6 8996 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8997 break;
8998
4fbb74a6 8999 link_section = section_headers + section->sh_link;
08d8fa11 9000 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9001
4fbb74a6 9002 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9003 break;
9004
252b5132
RH		 9005 found = 1;
9006
ba5cdace 9007 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9008 if (symbols == NULL)
9009 break;
252b5132 9010
4fbb74a6 9011 string_sec = section_headers + link_section->sh_link;
252b5132 9012
3f5e193b
NC		 9013 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9014 string_sec->sh_size,
9015 _("version string table"));
a6e9f9df 9016 if (!strtab)
0429c154
MS		 9017 {
9018 free (symbols);
9019 break;
9020 }
252b5132
RH		 9021
9022 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9023 SECTION_NAME (section), total);
9024
9025 printf (_(" Addr: "));
9026 printf_vma (section->sh_addr);
72de5009 9027 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9028 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 9029 SECTION_NAME (link_section));
9030
d3ba0551
AM		 9031 off = offset_from_vma (file,
9032 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9033 total * sizeof (short));
3f5e193b
NC		 9034 edata = (unsigned char *) get_data (NULL, file, off, total,
9035 sizeof (short),
9036 _("version symbol data"));
a6e9f9df
AM		 9037 if (!edata)
9038 {
9039 free (strtab);
0429c154 9040 free (symbols);
a6e9f9df
AM		 9041 break;
9042 }
252b5132 9043
3f5e193b 9044 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9045
9046 for (cnt = total; cnt --;)
b34976b6
AM		 9047 data[cnt] = byte_get (edata + cnt * sizeof (short),
9048 sizeof (short));
252b5132
RH		 9049
9050 free (edata);
9051
9052 for (cnt = 0; cnt < total; cnt += 4)
9053 {
9054 int j, nn;
00d93f34 9055 int check_def, check_need;
2cf0635d 9056 char * name;
252b5132
RH		 9057
9058 printf (" %03x:", cnt);
9059
9060 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9061 switch (data[cnt + j])
252b5132
RH		 9062 {
9063 case 0:
9064 fputs (_(" 0 (*local*) "), stdout);
9065 break;
9066
9067 case 1:
9068 fputs (_(" 1 (*global*) "), stdout);
9069 break;
9070
9071 default:
c244d050
NC		 9072 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9073 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9074
dd24e3da 9075 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9076 array, break to avoid an out-of-bounds read. */
9077 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9078 {
9079 warn (_("invalid index into symbol array\n"));
9080 break;
9081 }
9082
00d93f34
JJ		 9083 check_def = 1;
9084 check_need = 1;
4fbb74a6
AM		 9085 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9086 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9087 != SHT_NOBITS)
252b5132 9088 {
b34976b6 9089 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9090 check_def = 0;
9091 else
9092 check_need = 0;
252b5132 9093 }
00d93f34
JJ		 9094
9095 if (check_need
b34976b6 9096 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9097 {
b34976b6
AM		 9098 Elf_Internal_Verneed ivn;
9099 unsigned long offset;
252b5132 9100
d93f0186
NC		 9101 offset = offset_from_vma
9102 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9103 sizeof (Elf_External_Verneed));
252b5132 9104
b34976b6 9105 do
252b5132 9106 {
b34976b6
AM		 9107 Elf_Internal_Vernaux ivna;
9108 Elf_External_Verneed evn;
9109 Elf_External_Vernaux evna;
9110 unsigned long a_off;
252b5132 9111
59245841
NC		 9112 if (get_data (&evn, file, offset, sizeof (evn), 1,
9113 _("version need")) == NULL)
9114 break;
0b4362b0 9115
252b5132
RH		 9116 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9117 ivn.vn_next = BYTE_GET (evn.vn_next);
9118
9119 a_off = offset + ivn.vn_aux;
9120
9121 do
9122 {
59245841
NC		 9123 if (get_data (&evna, file, a_off, sizeof (evna),
9124 1, _("version need aux (2)")) == NULL)
9125 {
9126 ivna.vna_next = 0;
9127 ivna.vna_other = 0;
9128 }
9129 else
9130 {
9131 ivna.vna_next = BYTE_GET (evna.vna_next);
9132 ivna.vna_other = BYTE_GET (evna.vna_other);
9133 }
252b5132
RH		 9134
9135 a_off += ivna.vna_next;
9136 }
b34976b6 9137 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9138 && ivna.vna_next != 0);
9139
b34976b6 9140 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9141 {
9142 ivna.vna_name = BYTE_GET (evna.vna_name);
9143
54806181
AM		 9144 if (ivna.vna_name >= string_sec->sh_size)
9145 name = _("*invalid*");
9146 else
9147 name = strtab + ivna.vna_name;
252b5132 9148 nn += printf ("(%s%-*s",
16062207
ILT		 9149 name,
9150 12 - (int) strlen (name),
252b5132 9151 ")");
00d93f34 9152 check_def = 0;
252b5132
RH		 9153 break;
9154 }
9155
9156 offset += ivn.vn_next;
9157 }
9158 while (ivn.vn_next);
9159 }
00d93f34 9160
b34976b6
AM		 9161 if (check_def && data[cnt + j] != 0x8001
9162 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9163 {
b34976b6
AM		 9164 Elf_Internal_Verdef ivd;
9165 Elf_External_Verdef evd;
9166 unsigned long offset;
252b5132 9167
d93f0186
NC		 9168 offset = offset_from_vma
9169 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9170 sizeof evd);
252b5132
RH		 9171
9172 do
9173 {
59245841
NC		 9174 if (get_data (&evd, file, offset, sizeof (evd), 1,
9175 _("version def")) == NULL)
9176 {
9177 ivd.vd_next = 0;
9178 ivd.vd_ndx = 0;
9179 }
9180 else
9181 {
9182 ivd.vd_next = BYTE_GET (evd.vd_next);
9183 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9184 }
252b5132
RH		 9185
9186 offset += ivd.vd_next;
9187 }
c244d050 9188 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9189 && ivd.vd_next != 0);
9190
c244d050 9191 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9192 {
b34976b6
AM		 9193 Elf_External_Verdaux evda;
9194 Elf_Internal_Verdaux ivda;
252b5132
RH		 9195
9196 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9197
59245841
NC		 9198 if (get_data (&evda, file,
9199 offset - ivd.vd_next + ivd.vd_aux,
9200 sizeof (evda), 1,
9201 _("version def aux")) == NULL)
9202 break;
252b5132
RH		 9203
9204 ivda.vda_name = BYTE_GET (evda.vda_name);
9205
54806181
AM		 9206 if (ivda.vda_name >= string_sec->sh_size)
9207 name = _("*invalid*");
9208 else
9209 name = strtab + ivda.vda_name;
252b5132 9210 nn += printf ("(%s%-*s",
16062207
ILT		 9211 name,
9212 12 - (int) strlen (name),
252b5132
RH		 9213 ")");
9214 }
9215 }
9216
9217 if (nn < 18)
9218 printf ("%*c", 18 - nn, ' ');
9219 }
9220
9221 putchar ('\n');
9222 }
9223
9224 free (data);
9225 free (strtab);
9226 free (symbols);
9227 }
9228 break;
103f02d3 9229
252b5132
RH		 9230 default:
9231 break;
9232 }
9233 }
9234
9235 if (! found)
9236 printf (_("\nNo version information found in this file.\n"));
9237
9238 return 1;
9239}
9240
d1133906 9241static const char *
d3ba0551 9242get_symbol_binding (unsigned int binding)
252b5132 9243{
b34976b6 9244 static char buff[32];
252b5132
RH		 9245
9246 switch (binding)
9247 {
b34976b6
AM		 9248 case STB_LOCAL: return "LOCAL";
9249 case STB_GLOBAL: return "GLOBAL";
9250 case STB_WEAK: return "WEAK";
252b5132
RH		 9251 default:
9252 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9253 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9254 binding);
252b5132 9255 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9256 {
9257 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9258 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9259 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9260 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9261 return "UNIQUE";
9262 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9263 }
252b5132 9264 else
e9e44622 9265 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9266 return buff;
9267 }
9268}
9269
d1133906 9270static const char *
d3ba0551 9271get_symbol_type (unsigned int type)
252b5132 9272{
b34976b6 9273 static char buff[32];
252b5132
RH		 9274
9275 switch (type)
9276 {
b34976b6
AM		 9277 case STT_NOTYPE: return "NOTYPE";
9278 case STT_OBJECT: return "OBJECT";
9279 case STT_FUNC: return "FUNC";
9280 case STT_SECTION: return "SECTION";
9281 case STT_FILE: return "FILE";
9282 case STT_COMMON: return "COMMON";
9283 case STT_TLS: return "TLS";
15ab5209
DB		 9284 case STT_RELC: return "RELC";
9285 case STT_SRELC: return "SRELC";
252b5132
RH		 9286 default:
9287 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9288 {
13761a11
NC		 9289 if (elf_header.e_machine == EM_ARM)
9290 {
9291 if (type == STT_ARM_TFUNC)
9292 return "THUMB_FUNC";
9293 if (type == STT_ARM_16BIT)
9294 return "THUMB_LABEL";
9295 }
103f02d3 9296
351b4b40 9297 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9298 return "REGISTER";
9299
9300 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9301 return "PARISC_MILLI";
9302
e9e44622 9303 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9304 }
252b5132 9305 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9306 {
9307 if (elf_header.e_machine == EM_PARISC)
9308 {
9309 if (type == STT_HP_OPAQUE)
9310 return "HP_OPAQUE";
9311 if (type == STT_HP_STUB)
9312 return "HP_STUB";
9313 }
9314
d8045f23 9315 if (type == STT_GNU_IFUNC
9c55345c 9316 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9317 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9318 /* GNU is still using the default value 0. */
d8045f23
NC		 9319 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9320 return "IFUNC";
9321
e9e44622 9322 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9323 }
252b5132 9324 else
e9e44622 9325 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9326 return buff;
9327 }
9328}
9329
d1133906 9330static const char *
d3ba0551 9331get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9332{
9333 switch (visibility)
9334 {
b34976b6
AM		 9335 case STV_DEFAULT: return "DEFAULT";
9336 case STV_INTERNAL: return "INTERNAL";
9337 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9338 case STV_PROTECTED: return "PROTECTED";
9339 default: abort ();
9340 }
9341}
9342
5e2b0d47
NC		 9343static const char *
9344get_mips_symbol_other (unsigned int other)
9345{
9346 switch (other)
9347 {
df58fc94
RS		 9348 case STO_OPTIONAL:
9349 return "OPTIONAL";
9350 case STO_MIPS_PLT:
9351 return "MIPS PLT";
9352 case STO_MIPS_PIC:
9353 return "MIPS PIC";
9354 case STO_MICROMIPS:
9355 return "MICROMIPS";
9356 case STO_MICROMIPS | STO_MIPS_PIC:
9357 return "MICROMIPS, MIPS PIC";
9358 case STO_MIPS16:
9359 return "MIPS16";
9360 default:
9361 return NULL;
5e2b0d47
NC		 9362 }
9363}
9364
28f997cf
TG		 9365static const char *
9366get_ia64_symbol_other (unsigned int other)
9367{
9368 if (is_ia64_vms ())
9369 {
9370 static char res[32];
9371
9372 res[0] = 0;
9373
9374 /* Function types is for images and .STB files only. */
9375 switch (elf_header.e_type)
9376 {
9377 case ET_DYN:
9378 case ET_EXEC:
9379 switch (VMS_ST_FUNC_TYPE (other))
9380 {
9381 case VMS_SFT_CODE_ADDR:
9382 strcat (res, " CA");
9383 break;
9384 case VMS_SFT_SYMV_IDX:
9385 strcat (res, " VEC");
9386 break;
9387 case VMS_SFT_FD:
9388 strcat (res, " FD");
9389 break;
9390 case VMS_SFT_RESERVE:
9391 strcat (res, " RSV");
9392 break;
9393 default:
9394 abort ();
9395 }
9396 break;
9397 default:
9398 break;
9399 }
9400 switch (VMS_ST_LINKAGE (other))
9401 {
9402 case VMS_STL_IGNORE:
9403 strcat (res, " IGN");
9404 break;
9405 case VMS_STL_RESERVE:
9406 strcat (res, " RSV");
9407 break;
9408 case VMS_STL_STD:
9409 strcat (res, " STD");
9410 break;
9411 case VMS_STL_LNK:
9412 strcat (res, " LNK");
9413 break;
9414 default:
9415 abort ();
9416 }
9417
9418 if (res[0] != 0)
9419 return res + 1;
9420 else
9421 return res;
9422 }
9423 return NULL;
9424}
9425
6911b7dc
AM		 9426static const char *
9427get_ppc64_symbol_other (unsigned int other)
9428{
9429 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9430 {
9431 static char buf[32];
9432 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9433 PPC64_LOCAL_ENTRY_OFFSET (other));
9434 return buf;
9435 }
9436 return NULL;
9437}
9438
5e2b0d47
NC		 9439static const char *
9440get_symbol_other (unsigned int other)
9441{
9442 const char * result = NULL;
9443 static char buff [32];
9444
9445 if (other == 0)
9446 return "";
9447
9448 switch (elf_header.e_machine)
9449 {
9450 case EM_MIPS:
9451 result = get_mips_symbol_other (other);
28f997cf
TG		 9452 break;
9453 case EM_IA_64:
9454 result = get_ia64_symbol_other (other);
9455 break;
6911b7dc
AM		 9456 case EM_PPC64:
9457 result = get_ppc64_symbol_other (other);
9458 break;
5e2b0d47
NC		 9459 default:
9460 break;
9461 }
9462
9463 if (result)
9464 return result;
9465
9466 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9467 return buff;
9468}
9469
d1133906 9470static const char *
d3ba0551 9471get_symbol_index_type (unsigned int type)
252b5132 9472{
b34976b6 9473 static char buff[32];
5cf1065c 9474
252b5132
RH		 9475 switch (type)
9476 {
b34976b6
AM		 9477 case SHN_UNDEF: return "UND";
9478 case SHN_ABS: return "ABS";
9479 case SHN_COMMON: return "COM";
252b5132 9480 default:
9ce701e2
L		 9481 if (type == SHN_IA_64_ANSI_COMMON
9482 && elf_header.e_machine == EM_IA_64
9483 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9484 return "ANSI_COM";
8a9036a4 9485 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9486 || elf_header.e_machine == EM_L1OM
9487 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9488 && type == SHN_X86_64_LCOMMON)
9489 return "LARGE_COM";
ac145307
BS		 9490 else if ((type == SHN_MIPS_SCOMMON
9491 && elf_header.e_machine == EM_MIPS)
9492 || (type == SHN_TIC6X_SCOMMON
9493 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9494 return "SCOM";
9495 else if (type == SHN_MIPS_SUNDEFINED
9496 && elf_header.e_machine == EM_MIPS)
9497 return "SUND";
9ce701e2 9498 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9499 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9500 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9501 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9502 else if (type >= SHN_LORESERVE)
9503 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L		 9504 else if (type >= elf_header.e_shnum)
9505 sprintf (buff, "bad section index[%3d]", type);
252b5132 9506 else
232e7cb8 9507 sprintf (buff, "%3d", type);
5cf1065c 9508 break;
252b5132 9509 }
5cf1065c
NC		 9510
9511 return buff;
252b5132
RH		 9512}
9513
66543521 9514static bfd_vma *
2cf0635d 9515get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9516{
2cf0635d
NC		 9517 unsigned char * e_data;
9518 bfd_vma * i_data;
252b5132 9519
3f5e193b 9520 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9521
9522 if (e_data == NULL)
9523 {
9524 error (_("Out of memory\n"));
9525 return NULL;
9526 }
9527
66543521 9528 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9529 {
9530 error (_("Unable to read in dynamic data\n"));
9531 return NULL;
9532 }
9533
3f5e193b 9534 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9535
9536 if (i_data == NULL)
9537 {
9538 error (_("Out of memory\n"));
9539 free (e_data);
9540 return NULL;
9541 }
9542
9543 while (number--)
66543521 9544 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9545
9546 free (e_data);
9547
9548 return i_data;
9549}
9550
6bd1a22c
L		 9551static void
9552print_dynamic_symbol (bfd_vma si, unsigned long hn)
9553{
2cf0635d 9554 Elf_Internal_Sym * psym;
6bd1a22c
L		 9555 int n;
9556
9557 psym = dynamic_symbols + si;
9558
9559 n = print_vma (si, DEC_5);
9560 if (n < 5)
0b4362b0 9561 fputs (&" "[n], stdout);
6bd1a22c
L		 9562 printf (" %3lu: ", hn);
9563 print_vma (psym->st_value, LONG_HEX);
9564 putchar (' ');
9565 print_vma (psym->st_size, DEC_5);
9566
f4be36b3
AM		 9567 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9568 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9569 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9570 /* Check to see if any other bits in the st_other field are set.
9571 Note - displaying this information disrupts the layout of the
9572 table being generated, but for the moment this case is very
9573 rare. */
9574 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9575 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9576 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9577 if (VALID_DYNAMIC_NAME (psym->st_name))
9578 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9579 else
2b692964 9580 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9581 putchar ('\n');
9582}
9583
e3c8793a 9584/* Dump the symbol table. */
252b5132 9585static int
2cf0635d 9586process_symbol_table (FILE * file)
252b5132 9587{
2cf0635d 9588 Elf_Internal_Shdr * section;
66543521
AM		 9589 bfd_vma nbuckets = 0;
9590 bfd_vma nchains = 0;
2cf0635d
NC		 9591 bfd_vma * buckets = NULL;
9592 bfd_vma * chains = NULL;
fdc90cb4 9593 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9594 bfd_vma * gnubuckets = NULL;
9595 bfd_vma * gnuchains = NULL;
6bd1a22c 9596 bfd_vma gnusymidx = 0;
252b5132 9597
2c610e4b 9598 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9599 return 1;
9600
6bd1a22c
L		 9601 if (dynamic_info[DT_HASH]
9602 && (do_histogram
2c610e4b
L		 9603 || (do_using_dynamic
9604 && !do_dyn_syms
9605 && dynamic_strings != NULL)))
252b5132 9606 {
66543521
AM		 9607 unsigned char nb[8];
9608 unsigned char nc[8];
9609 int hash_ent_size = 4;
9610
9611 if ((elf_header.e_machine == EM_ALPHA
9612 || elf_header.e_machine == EM_S390
9613 || elf_header.e_machine == EM_S390_OLD)
9614 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9615 hash_ent_size = 8;
9616
fb52b2f4
NC		 9617 if (fseek (file,
9618 (archive_file_offset
9619 + offset_from_vma (file, dynamic_info[DT_HASH],
9620 sizeof nb + sizeof nc)),
d93f0186 9621 SEEK_SET))
252b5132 9622 {
591a748a 9623 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9624 goto no_hash;
252b5132
RH		 9625 }
9626
66543521 9627 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9628 {
9629 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9630 goto no_hash;
252b5132
RH		 9631 }
9632
66543521 9633 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9634 {
9635 error (_("Failed to read in number of chains\n"));
d3a44ec6 9636 goto no_hash;
252b5132
RH		 9637 }
9638
66543521
AM		 9639 nbuckets = byte_get (nb, hash_ent_size);
9640 nchains = byte_get (nc, hash_ent_size);
252b5132 9641
66543521
AM		 9642 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9643 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9644
d3a44ec6 9645 no_hash:
252b5132 9646 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9647 {
9648 if (do_using_dynamic)
9649 return 0;
9650 free (buckets);
9651 free (chains);
9652 buckets = NULL;
9653 chains = NULL;
9654 nbuckets = 0;
9655 nchains = 0;
9656 }
252b5132
RH		 9657 }
9658
6bd1a22c
L		 9659 if (dynamic_info_DT_GNU_HASH
9660 && (do_histogram
2c610e4b
L		 9661 || (do_using_dynamic
9662 && !do_dyn_syms
9663 && dynamic_strings != NULL)))
252b5132 9664 {
6bd1a22c
L		 9665 unsigned char nb[16];
9666 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9667 bfd_vma buckets_vma;
9668
9669 if (fseek (file,
9670 (archive_file_offset
9671 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9672 sizeof nb)),
9673 SEEK_SET))
9674 {
9675 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9676 goto no_gnu_hash;
6bd1a22c 9677 }
252b5132 9678
6bd1a22c
L		 9679 if (fread (nb, 16, 1, file) != 1)
9680 {
9681 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9682 goto no_gnu_hash;
6bd1a22c
L		 9683 }
9684
9685 ngnubuckets = byte_get (nb, 4);
9686 gnusymidx = byte_get (nb + 4, 4);
9687 bitmaskwords = byte_get (nb + 8, 4);
9688 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9689 if (is_32bit_elf)
6bd1a22c 9690 buckets_vma += bitmaskwords * 4;
f7a99963 9691 else
6bd1a22c 9692 buckets_vma += bitmaskwords * 8;
252b5132 9693
6bd1a22c
L		 9694 if (fseek (file,
9695 (archive_file_offset
9696 + offset_from_vma (file, buckets_vma, 4)),
9697 SEEK_SET))
252b5132 9698 {
6bd1a22c 9699 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9700 goto no_gnu_hash;
6bd1a22c
L		 9701 }
9702
9703 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9704
6bd1a22c 9705 if (gnubuckets == NULL)
d3a44ec6 9706 goto no_gnu_hash;
6bd1a22c
L		 9707
9708 for (i = 0; i < ngnubuckets; i++)
9709 if (gnubuckets[i] != 0)
9710 {
9711 if (gnubuckets[i] < gnusymidx)
9712 return 0;
9713
9714 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9715 maxchain = gnubuckets[i];
9716 }
9717
9718 if (maxchain == 0xffffffff)
d3a44ec6 9719 goto no_gnu_hash;
6bd1a22c
L		 9720
9721 maxchain -= gnusymidx;
9722
9723 if (fseek (file,
9724 (archive_file_offset
9725 + offset_from_vma (file, buckets_vma
9726 + 4 * (ngnubuckets + maxchain), 4)),
9727 SEEK_SET))
9728 {
9729 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9730 goto no_gnu_hash;
6bd1a22c
L		 9731 }
9732
9733 do
9734 {
9735 if (fread (nb, 4, 1, file) != 1)
252b5132 9736 {
6bd1a22c 9737 error (_("Failed to determine last chain length\n"));
d3a44ec6 9738 goto no_gnu_hash;
6bd1a22c 9739 }
252b5132 9740
6bd1a22c 9741 if (maxchain + 1 == 0)
d3a44ec6 9742 goto no_gnu_hash;
252b5132 9743
6bd1a22c
L		 9744 ++maxchain;
9745 }
9746 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9747
6bd1a22c
L		 9748 if (fseek (file,
9749 (archive_file_offset
9750 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9751 SEEK_SET))
9752 {
9753 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9754 goto no_gnu_hash;
6bd1a22c
L		 9755 }
9756
9757 gnuchains = get_dynamic_data (file, maxchain, 4);
9758
d3a44ec6 9759 no_gnu_hash:
6bd1a22c 9760 if (gnuchains == NULL)
d3a44ec6
JJ		 9761 {
9762 free (gnubuckets);
d3a44ec6
JJ		 9763 gnubuckets = NULL;
9764 ngnubuckets = 0;
f64fddf1
NC		 9765 if (do_using_dynamic)
9766 return 0;
d3a44ec6 9767 }
6bd1a22c
L		 9768 }
9769
9770 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9771 && do_syms
9772 && do_using_dynamic
9773 && dynamic_strings != NULL)
9774 {
9775 unsigned long hn;
9776
9777 if (dynamic_info[DT_HASH])
9778 {
9779 bfd_vma si;
9780
9781 printf (_("\nSymbol table for image:\n"));
9782 if (is_32bit_elf)
9783 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9784 else
9785 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9786
9787 for (hn = 0; hn < nbuckets; hn++)
9788 {
9789 if (! buckets[hn])
9790 continue;
9791
9792 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9793 print_dynamic_symbol (si, hn);
252b5132
RH		 9794 }
9795 }
6bd1a22c
L		 9796
9797 if (dynamic_info_DT_GNU_HASH)
9798 {
9799 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9800 if (is_32bit_elf)
9801 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9802 else
9803 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9804
9805 for (hn = 0; hn < ngnubuckets; ++hn)
9806 if (gnubuckets[hn] != 0)
9807 {
9808 bfd_vma si = gnubuckets[hn];
9809 bfd_vma off = si - gnusymidx;
9810
9811 do
9812 {
9813 print_dynamic_symbol (si, hn);
9814 si++;
9815 }
9816 while ((gnuchains[off++] & 1) == 0);
9817 }
9818 }
252b5132 9819 }
2c610e4b 9820 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9821 {
b34976b6 9822 unsigned int i;
252b5132
RH		 9823
9824 for (i = 0, section = section_headers;
9825 i < elf_header.e_shnum;
9826 i++, section++)
9827 {
b34976b6 9828 unsigned int si;
2cf0635d 9829 char * strtab = NULL;
c256ffe7 9830 unsigned long int strtab_size = 0;
2cf0635d
NC		 9831 Elf_Internal_Sym * symtab;
9832 Elf_Internal_Sym * psym;
ba5cdace 9833 unsigned long num_syms;
252b5132 9834
2c610e4b
L		 9835 if ((section->sh_type != SHT_SYMTAB
9836 && section->sh_type != SHT_DYNSYM)
9837 || (!do_syms
9838 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9839 continue;
9840
dd24e3da
NC		 9841 if (section->sh_entsize == 0)
9842 {
9843 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9844 SECTION_NAME (section));
9845 continue;
9846 }
9847
252b5132
RH		 9848 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9849 SECTION_NAME (section),
9850 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9851
f7a99963 9852 if (is_32bit_elf)
ca47b30c 9853 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9854 else
ca47b30c 9855 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9856
ba5cdace 9857 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9858 if (symtab == NULL)
9859 continue;
9860
9861 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9862 {
9863 strtab = string_table;
9864 strtab_size = string_table_length;
9865 }
4fbb74a6 9866 else if (section->sh_link < elf_header.e_shnum)
252b5132 9867 {
2cf0635d 9868 Elf_Internal_Shdr * string_sec;
252b5132 9869
4fbb74a6 9870 string_sec = section_headers + section->sh_link;
252b5132 9871
3f5e193b
NC		 9872 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9873 1, string_sec->sh_size,
9874 _("string table"));
c256ffe7 9875 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9876 }
9877
ba5cdace 9878 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9879 {
5e220199 9880 printf ("%6d: ", si);
f7a99963
NC		 9881 print_vma (psym->st_value, LONG_HEX);
9882 putchar (' ');
9883 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9884 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9885 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9886 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9887 /* Check to see if any other bits in the st_other field are set.
9888 Note - displaying this information disrupts the layout of the
9889 table being generated, but for the moment this case is very rare. */
9890 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9891 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9892 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9893 print_symbol (25, psym->st_name < strtab_size
2b692964 9894 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9895
59245841
NC		 9896 if (section->sh_type == SHT_DYNSYM
9897 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9898 {
b34976b6
AM		 9899 unsigned char data[2];
9900 unsigned short vers_data;
9901 unsigned long offset;
9902 int is_nobits;
9903 int check_def;
252b5132 9904
d93f0186
NC		 9905 offset = offset_from_vma
9906 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9907 sizeof data + si * sizeof (vers_data));
252b5132 9908
59245841
NC		 9909 if (get_data (&data, file, offset + si * sizeof (vers_data),
9910 sizeof (data), 1, _("version data")) == NULL)
9911 break;
252b5132
RH		 9912
9913 vers_data = byte_get (data, 2);
9914
4fbb74a6
AM		 9915 is_nobits = (psym->st_shndx < elf_header.e_shnum
9916 && section_headers[psym->st_shndx].sh_type
c256ffe7 9917 == SHT_NOBITS);
252b5132
RH		 9918
9919 check_def = (psym->st_shndx != SHN_UNDEF);
9920
c244d050 9921 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9922 {
b34976b6 9923 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9924 && (is_nobits || ! check_def))
252b5132 9925 {
b34976b6
AM		 9926 Elf_External_Verneed evn;
9927 Elf_Internal_Verneed ivn;
9928 Elf_Internal_Vernaux ivna;
252b5132
RH		 9929
9930 /* We must test both. */
d93f0186
NC		 9931 offset = offset_from_vma
9932 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9933 sizeof evn);
252b5132 9934
252b5132
RH		 9935 do
9936 {
b34976b6 9937 unsigned long vna_off;
252b5132 9938
59245841
NC		 9939 if (get_data (&evn, file, offset, sizeof (evn), 1,
9940 _("version need")) == NULL)
9941 {
9942 ivna.vna_next = 0;
9943 ivna.vna_other = 0;
9944 ivna.vna_name = 0;
9945 break;
9946 }
dd27201e
L		 9947
9948 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9949 ivn.vn_next = BYTE_GET (evn.vn_next);
9950
252b5132
RH		 9951 vna_off = offset + ivn.vn_aux;
9952
9953 do
9954 {
b34976b6 9955 Elf_External_Vernaux evna;
252b5132 9956
59245841
NC		 9957 if (get_data (&evna, file, vna_off,
9958 sizeof (evna), 1,
9959 _("version need aux (3)")) == NULL)
9960 {
9961 ivna.vna_next = 0;
9962 ivna.vna_other = 0;
9963 ivna.vna_name = 0;
9964 }
9965 else
9966 {
9967 ivna.vna_other = BYTE_GET (evna.vna_other);
9968 ivna.vna_next = BYTE_GET (evna.vna_next);
9969 ivna.vna_name = BYTE_GET (evna.vna_name);
9970 }
252b5132
RH		 9971
9972 vna_off += ivna.vna_next;
9973 }
9974 while (ivna.vna_other != vers_data
9975 && ivna.vna_next != 0);
9976
9977 if (ivna.vna_other == vers_data)
9978 break;
9979
9980 offset += ivn.vn_next;
9981 }
9982 while (ivn.vn_next != 0);
9983
9984 if (ivna.vna_other == vers_data)
9985 {
9986 printf ("@%s (%d)",
c256ffe7 9987 ivna.vna_name < strtab_size
2b692964 9988 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9989 ivna.vna_other);
252b5132
RH		 9990 check_def = 0;
9991 }
9992 else if (! is_nobits)
591a748a 9993 error (_("bad dynamic symbol\n"));
252b5132
RH		 9994 else
9995 check_def = 1;
9996 }
9997
9998 if (check_def)
9999 {
00d93f34 10000 if (vers_data != 0x8001
b34976b6 10001 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10002 {
b34976b6
AM		 10003 Elf_Internal_Verdef ivd;
10004 Elf_Internal_Verdaux ivda;
10005 Elf_External_Verdaux evda;
91d6fa6a 10006 unsigned long off;
252b5132 10007
91d6fa6a 10008 off = offset_from_vma
d93f0186
NC		 10009 (file,
10010 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10011 sizeof (Elf_External_Verdef));
252b5132
RH		 10012
10013 do
10014 {
b34976b6 10015 Elf_External_Verdef evd;
252b5132 10016
59245841
NC		 10017 if (get_data (&evd, file, off, sizeof (evd),
10018 1, _("version def")) == NULL)
10019 {
10020 ivd.vd_ndx = 0;
10021 ivd.vd_aux = 0;
10022 ivd.vd_next = 0;
10023 }
10024 else
10025 {
10026 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10027 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10028 ivd.vd_next = BYTE_GET (evd.vd_next);
10029 }
252b5132 10030
91d6fa6a 10031 off += ivd.vd_next;
252b5132 10032 }
c244d050 10033 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 10034 && ivd.vd_next != 0);
10035
91d6fa6a
NC		 10036 off -= ivd.vd_next;
10037 off += ivd.vd_aux;
252b5132 10038
59245841
NC		 10039 if (get_data (&evda, file, off, sizeof (evda),
10040 1, _("version def aux")) == NULL)
10041 break;
252b5132
RH		 10042
10043 ivda.vda_name = BYTE_GET (evda.vda_name);
10044
10045 if (psym->st_name != ivda.vda_name)
c244d050 10046 printf ((vers_data & VERSYM_HIDDEN)
252b5132 10047 ? "@%s" : "@@%s",
c256ffe7 10048 ivda.vda_name < strtab_size
2b692964 10049 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 10050 }
10051 }
10052 }
10053 }
10054
10055 putchar ('\n');
10056 }
10057
10058 free (symtab);
10059 if (strtab != string_table)
10060 free (strtab);
10061 }
10062 }
10063 else if (do_syms)
10064 printf
10065 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10066
10067 if (do_histogram && buckets != NULL)
10068 {
2cf0635d
NC		 10069 unsigned long * lengths;
10070 unsigned long * counts;
66543521
AM		 10071 unsigned long hn;
10072 bfd_vma si;
10073 unsigned long maxlength = 0;
10074 unsigned long nzero_counts = 0;
10075 unsigned long nsyms = 0;
252b5132 10076
66543521
AM		 10077 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10078 (unsigned long) nbuckets);
252b5132
RH		 10079 printf (_(" Length Number %% of total Coverage\n"));
10080
3f5e193b 10081 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10082 if (lengths == NULL)
10083 {
591a748a 10084 error (_("Out of memory\n"));
252b5132
RH		 10085 return 0;
10086 }
10087 for (hn = 0; hn < nbuckets; ++hn)
10088 {
f7a99963 10089 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 10090 {
b34976b6 10091 ++nsyms;
252b5132 10092 if (maxlength < ++lengths[hn])
b34976b6 10093 ++maxlength;
252b5132
RH		 10094 }
10095 }
10096
3f5e193b 10097 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10098 if (counts == NULL)
10099 {
b2e951ec 10100 free (lengths);
591a748a 10101 error (_("Out of memory\n"));
252b5132
RH		 10102 return 0;
10103 }
10104
10105 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10106 ++counts[lengths[hn]];
252b5132 10107
103f02d3 10108 if (nbuckets > 0)
252b5132 10109 {
66543521
AM		 10110 unsigned long i;
10111 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10112 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10113 for (i = 1; i <= maxlength; ++i)
103f02d3 10114 {
66543521
AM		 10115 nzero_counts += counts[i] * i;
10116 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10117 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10118 (nzero_counts * 100.0) / nsyms);
10119 }
252b5132
RH		 10120 }
10121
10122 free (counts);
10123 free (lengths);
10124 }
10125
10126 if (buckets != NULL)
10127 {
10128 free (buckets);
10129 free (chains);
10130 }
10131
d3a44ec6 10132 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10133 {
2cf0635d
NC		 10134 unsigned long * lengths;
10135 unsigned long * counts;
fdc90cb4
JJ		 10136 unsigned long hn;
10137 unsigned long maxlength = 0;
10138 unsigned long nzero_counts = 0;
10139 unsigned long nsyms = 0;
fdc90cb4 10140
3f5e193b 10141 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10142 if (lengths == NULL)
10143 {
591a748a 10144 error (_("Out of memory\n"));
fdc90cb4
JJ		 10145 return 0;
10146 }
10147
10148 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10149 (unsigned long) ngnubuckets);
10150 printf (_(" Length Number %% of total Coverage\n"));
10151
10152 for (hn = 0; hn < ngnubuckets; ++hn)
10153 if (gnubuckets[hn] != 0)
10154 {
10155 bfd_vma off, length = 1;
10156
6bd1a22c 10157 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 10158 (gnuchains[off] & 1) == 0; ++off)
10159 ++length;
10160 lengths[hn] = length;
10161 if (length > maxlength)
10162 maxlength = length;
10163 nsyms += length;
10164 }
10165
3f5e193b 10166 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10167 if (counts == NULL)
10168 {
b2e951ec 10169 free (lengths);
591a748a 10170 error (_("Out of memory\n"));
fdc90cb4
JJ		 10171 return 0;
10172 }
10173
10174 for (hn = 0; hn < ngnubuckets; ++hn)
10175 ++counts[lengths[hn]];
10176
10177 if (ngnubuckets > 0)
10178 {
10179 unsigned long j;
10180 printf (" 0 %-10lu (%5.1f%%)\n",
10181 counts[0], (counts[0] * 100.0) / ngnubuckets);
10182 for (j = 1; j <= maxlength; ++j)
10183 {
10184 nzero_counts += counts[j] * j;
10185 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10186 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10187 (nzero_counts * 100.0) / nsyms);
10188 }
10189 }
10190
10191 free (counts);
10192 free (lengths);
10193 free (gnubuckets);
10194 free (gnuchains);
10195 }
10196
252b5132
RH		 10197 return 1;
10198}
10199
10200static int
2cf0635d 10201process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10202{
b4c96d0d 10203 unsigned int i;
252b5132
RH		 10204
10205 if (dynamic_syminfo == NULL
10206 || !do_dynamic)
10207 /* No syminfo, this is ok. */
10208 return 1;
10209
10210 /* There better should be a dynamic symbol section. */
10211 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10212 return 0;
10213
10214 if (dynamic_addr)
10215 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10216 dynamic_syminfo_offset, dynamic_syminfo_nent);
10217
10218 printf (_(" Num: Name BoundTo Flags\n"));
10219 for (i = 0; i < dynamic_syminfo_nent; ++i)
10220 {
10221 unsigned short int flags = dynamic_syminfo[i].si_flags;
10222
31104126 10223 printf ("%4d: ", i);
d79b3d50
NC		 10224 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10225 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10226 else
2b692964 10227 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10228 putchar (' ');
252b5132
RH		 10229
10230 switch (dynamic_syminfo[i].si_boundto)
10231 {
10232 case SYMINFO_BT_SELF:
10233 fputs ("SELF ", stdout);
10234 break;
10235 case SYMINFO_BT_PARENT:
10236 fputs ("PARENT ", stdout);
10237 break;
10238 default:
10239 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10240 && dynamic_syminfo[i].si_boundto < dynamic_nent
10241 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10242 {
d79b3d50 10243 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10244 putchar (' ' );
10245 }
252b5132
RH		 10246 else
10247 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10248 break;
10249 }
10250
10251 if (flags & SYMINFO_FLG_DIRECT)
10252 printf (" DIRECT");
10253 if (flags & SYMINFO_FLG_PASSTHRU)
10254 printf (" PASSTHRU");
10255 if (flags & SYMINFO_FLG_COPY)
10256 printf (" COPY");
10257 if (flags & SYMINFO_FLG_LAZYLOAD)
10258 printf (" LAZYLOAD");
10259
10260 puts ("");
10261 }
10262
10263 return 1;
10264}
10265
cf13d699
NC		 10266/* Check to see if the given reloc needs to be handled in a target specific
10267 manner. If so then process the reloc and return TRUE otherwise return
10268 FALSE. */
09c11c86 10269
cf13d699
NC		 10270static bfd_boolean
10271target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10272 unsigned char * start,
10273 Elf_Internal_Sym * symtab)
252b5132 10274{
cf13d699 10275 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 10276
cf13d699 10277 switch (elf_header.e_machine)
252b5132 10278 {
13761a11
NC		 10279 case EM_MSP430:
10280 case EM_MSP430_OLD:
10281 {
10282 static Elf_Internal_Sym * saved_sym = NULL;
10283
10284 switch (reloc_type)
10285 {
10286 case 10: /* R_MSP430_SYM_DIFF */
10287 if (uses_msp430x_relocs ())
10288 break;
10289 case 21: /* R_MSP430X_SYM_DIFF */
10290 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10291 return TRUE;
10292
10293 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10294 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10295 goto handle_sym_diff;
0b4362b0 10296
13761a11
NC		 10297 case 5: /* R_MSP430_16_BYTE */
10298 case 9: /* R_MSP430_8 */
10299 if (uses_msp430x_relocs ())
10300 break;
10301 goto handle_sym_diff;
10302
10303 case 2: /* R_MSP430_ABS16 */
10304 case 15: /* R_MSP430X_ABS16 */
10305 if (! uses_msp430x_relocs ())
10306 break;
10307 goto handle_sym_diff;
0b4362b0 10308
13761a11
NC		 10309 handle_sym_diff:
10310 if (saved_sym != NULL)
10311 {
10312 bfd_vma value;
10313
10314 value = reloc->r_addend
10315 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10316 - saved_sym->st_value);
10317
10318 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10319
10320 saved_sym = NULL;
10321 return TRUE;
10322 }
10323 break;
10324
10325 default:
10326 if (saved_sym != NULL)
10327 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10328 break;
10329 }
10330 break;
10331 }
10332
cf13d699
NC		 10333 case EM_MN10300:
10334 case EM_CYGNUS_MN10300:
10335 {
10336 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 10337
cf13d699
NC		 10338 switch (reloc_type)
10339 {
10340 case 34: /* R_MN10300_ALIGN */
10341 return TRUE;
10342 case 33: /* R_MN10300_SYM_DIFF */
10343 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10344 return TRUE;
10345 case 1: /* R_MN10300_32 */
10346 case 2: /* R_MN10300_16 */
10347 if (saved_sym != NULL)
10348 {
10349 bfd_vma value;
252b5132 10350
cf13d699
NC		 10351 value = reloc->r_addend
10352 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10353 - saved_sym->st_value);
252b5132 10354
cf13d699 10355 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 10356
cf13d699
NC		 10357 saved_sym = NULL;
10358 return TRUE;
10359 }
10360 break;
10361 default:
10362 if (saved_sym != NULL)
10363 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10364 break;
10365 }
10366 break;
10367 }
252b5132
RH		 10368 }
10369
cf13d699 10370 return FALSE;
252b5132
RH		 10371}
10372
aca88567
NC		 10373/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10374 DWARF debug sections. This is a target specific test. Note - we do not
10375 go through the whole including-target-headers-multiple-times route, (as
10376 we have already done with <elf/h8.h>) because this would become very
10377 messy and even then this function would have to contain target specific
10378 information (the names of the relocs instead of their numeric values).
10379 FIXME: This is not the correct way to solve this problem. The proper way
10380 is to have target specific reloc sizing and typing functions created by
10381 the reloc-macros.h header, in the same way that it already creates the
10382 reloc naming functions. */
10383
10384static bfd_boolean
10385is_32bit_abs_reloc (unsigned int reloc_type)
10386{
10387 switch (elf_header.e_machine)
10388 {
41e92641
NC		 10389 case EM_386:
10390 case EM_486:
10391 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 10392 case EM_68K:
10393 return reloc_type == 1; /* R_68K_32. */
10394 case EM_860:
10395 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10396 case EM_960:
10397 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10398 case EM_AARCH64:
10399 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10400 case EM_ALPHA:
137b6b5f 10401 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10402 case EM_ARC:
10403 return reloc_type == 1; /* R_ARC_32. */
10404 case EM_ARM:
10405 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10406 case EM_AVR_OLD:
aca88567
NC		 10407 case EM_AVR:
10408 return reloc_type == 1;
cfb8c092
NC		 10409 case EM_ADAPTEVA_EPIPHANY:
10410 return reloc_type == 3;
aca88567
NC		 10411 case EM_BLACKFIN:
10412 return reloc_type == 0x12; /* R_byte4_data. */
10413 case EM_CRIS:
10414 return reloc_type == 3; /* R_CRIS_32. */
10415 case EM_CR16:
10416 return reloc_type == 3; /* R_CR16_NUM32. */
10417 case EM_CRX:
10418 return reloc_type == 15; /* R_CRX_NUM32. */
10419 case EM_CYGNUS_FRV:
10420 return reloc_type == 1;
41e92641
NC		 10421 case EM_CYGNUS_D10V:
10422 case EM_D10V:
10423 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10424 case EM_CYGNUS_D30V:
10425 case EM_D30V:
10426 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10427 case EM_DLX:
10428 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10429 case EM_CYGNUS_FR30:
10430 case EM_FR30:
10431 return reloc_type == 3; /* R_FR30_32. */
10432 case EM_H8S:
10433 case EM_H8_300:
10434 case EM_H8_300H:
10435 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10436 case EM_IA_64:
10437 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10438 case EM_IP2K_OLD:
10439 case EM_IP2K:
10440 return reloc_type == 2; /* R_IP2K_32. */
10441 case EM_IQ2000:
10442 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10443 case EM_LATTICEMICO32:
10444 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10445 case EM_M32C_OLD:
aca88567
NC		 10446 case EM_M32C:
10447 return reloc_type == 3; /* R_M32C_32. */
10448 case EM_M32R:
10449 return reloc_type == 34; /* R_M32R_32_RELA. */
10450 case EM_MCORE:
10451 return reloc_type == 1; /* R_MCORE_ADDR32. */
10452 case EM_CYGNUS_MEP:
10453 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10454 case EM_METAG:
10455 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10456 case EM_MICROBLAZE:
10457 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10458 case EM_MIPS:
10459 return reloc_type == 2; /* R_MIPS_32. */
10460 case EM_MMIX:
10461 return reloc_type == 4; /* R_MMIX_32. */
10462 case EM_CYGNUS_MN10200:
10463 case EM_MN10200:
10464 return reloc_type == 1; /* R_MN10200_32. */
10465 case EM_CYGNUS_MN10300:
10466 case EM_MN10300:
10467 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10468 case EM_MOXIE:
10469 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10470 case EM_MSP430_OLD:
10471 case EM_MSP430:
13761a11 10472 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 10473 case EM_MT:
10474 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 10475 case EM_NDS32:
10476 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 10477 case EM_ALTERA_NIOS2:
36591ba1 10478 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 10479 case EM_NIOS32:
10480 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 10481 case EM_OPENRISC:
10482 case EM_OR32:
10483 return reloc_type == 1; /* R_OR32_32. */
aca88567 10484 case EM_PARISC:
5fda8eca
NC		 10485 return (reloc_type == 1 /* R_PARISC_DIR32. */
10486 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10487 case EM_PJ:
10488 case EM_PJ_OLD:
10489 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10490 case EM_PPC64:
10491 return reloc_type == 1; /* R_PPC64_ADDR32. */
10492 case EM_PPC:
10493 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10494 case EM_RL78:
10495 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10496 case EM_RX:
10497 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10498 case EM_S370:
10499 return reloc_type == 1; /* R_I370_ADDR31. */
10500 case EM_S390_OLD:
10501 case EM_S390:
10502 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10503 case EM_SCORE:
10504 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10505 case EM_SH:
10506 return reloc_type == 1; /* R_SH_DIR32. */
10507 case EM_SPARC32PLUS:
10508 case EM_SPARCV9:
10509 case EM_SPARC:
10510 return reloc_type == 3 /* R_SPARC_32. */
10511 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10512 case EM_SPU:
10513 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10514 case EM_TI_C6000:
10515 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10516 case EM_TILEGX:
10517 return reloc_type == 2; /* R_TILEGX_32. */
10518 case EM_TILEPRO:
10519 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10520 case EM_CYGNUS_V850:
10521 case EM_V850:
10522 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10523 case EM_V800:
10524 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10525 case EM_VAX:
10526 return reloc_type == 1; /* R_VAX_32. */
10527 case EM_X86_64:
8a9036a4 10528 case EM_L1OM:
7a9068fe 10529 case EM_K1OM:
aca88567 10530 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10531 case EM_XC16X:
10532 case EM_C166:
10533 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10534 case EM_XGATE:
10535 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10536 case EM_XSTORMY16:
10537 return reloc_type == 1; /* R_XSTROMY16_32. */
10538 case EM_XTENSA_OLD:
10539 case EM_XTENSA:
10540 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10541 default:
10542 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10543 elf_header.e_machine);
10544 abort ();
10545 }
10546}
10547
10548/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10549 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10550
10551static bfd_boolean
10552is_32bit_pcrel_reloc (unsigned int reloc_type)
10553{
10554 switch (elf_header.e_machine)
10555 {
41e92641
NC		 10556 case EM_386:
10557 case EM_486:
3e0873ac 10558 return reloc_type == 2; /* R_386_PC32. */
aca88567 10559 case EM_68K:
3e0873ac 10560 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10561 case EM_AARCH64:
10562 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10563 case EM_ADAPTEVA_EPIPHANY:
10564 return reloc_type == 6;
aca88567
NC		 10565 case EM_ALPHA:
10566 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10567 case EM_ARM:
3e0873ac 10568 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10569 case EM_MICROBLAZE:
10570 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 10571 case EM_PARISC:
85acf597 10572 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10573 case EM_PPC:
10574 return reloc_type == 26; /* R_PPC_REL32. */
10575 case EM_PPC64:
3e0873ac 10576 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10577 case EM_S390_OLD:
10578 case EM_S390:
3e0873ac 10579 return reloc_type == 5; /* R_390_PC32. */
aca88567 10580 case EM_SH:
3e0873ac 10581 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10582 case EM_SPARC32PLUS:
10583 case EM_SPARCV9:
10584 case EM_SPARC:
3e0873ac 10585 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10586 case EM_SPU:
10587 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10588 case EM_TILEGX:
10589 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10590 case EM_TILEPRO:
10591 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10592 case EM_X86_64:
8a9036a4 10593 case EM_L1OM:
7a9068fe 10594 case EM_K1OM:
3e0873ac 10595 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10596 case EM_XTENSA_OLD:
10597 case EM_XTENSA:
10598 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10599 default:
10600 /* Do not abort or issue an error message here. Not all targets use
10601 pc-relative 32-bit relocs in their DWARF debug information and we
10602 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10603 more helpful warning message will be generated by apply_relocations
10604 anyway, so just return. */
aca88567
NC		 10605 return FALSE;
10606 }
10607}
10608
10609/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10610 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10611
10612static bfd_boolean
10613is_64bit_abs_reloc (unsigned int reloc_type)
10614{
10615 switch (elf_header.e_machine)
10616 {
a06ea964
NC		 10617 case EM_AARCH64:
10618 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10619 case EM_ALPHA:
10620 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10621 case EM_IA_64:
10622 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10623 case EM_PARISC:
10624 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10625 case EM_PPC64:
10626 return reloc_type == 38; /* R_PPC64_ADDR64. */
10627 case EM_SPARC32PLUS:
10628 case EM_SPARCV9:
10629 case EM_SPARC:
10630 return reloc_type == 54; /* R_SPARC_UA64. */
10631 case EM_X86_64:
8a9036a4 10632 case EM_L1OM:
7a9068fe 10633 case EM_K1OM:
aca88567 10634 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10635 case EM_S390_OLD:
10636 case EM_S390:
aa137e4d
NC		 10637 return reloc_type == 22; /* R_S390_64. */
10638 case EM_TILEGX:
10639 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10640 case EM_MIPS:
aa137e4d 10641 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10642 default:
10643 return FALSE;
10644 }
10645}
10646
85acf597
RH		 10647/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10648 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10649
10650static bfd_boolean
10651is_64bit_pcrel_reloc (unsigned int reloc_type)
10652{
10653 switch (elf_header.e_machine)
10654 {
a06ea964
NC		 10655 case EM_AARCH64:
10656 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10657 case EM_ALPHA:
aa137e4d 10658 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10659 case EM_IA_64:
aa137e4d 10660 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10661 case EM_PARISC:
aa137e4d 10662 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10663 case EM_PPC64:
aa137e4d 10664 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10665 case EM_SPARC32PLUS:
10666 case EM_SPARCV9:
10667 case EM_SPARC:
aa137e4d 10668 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10669 case EM_X86_64:
8a9036a4 10670 case EM_L1OM:
7a9068fe 10671 case EM_K1OM:
aa137e4d 10672 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10673 case EM_S390_OLD:
10674 case EM_S390:
aa137e4d
NC		 10675 return reloc_type == 23; /* R_S390_PC64. */
10676 case EM_TILEGX:
10677 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10678 default:
10679 return FALSE;
10680 }
10681}
10682
4dc3c23d
AM		 10683/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10684 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10685
10686static bfd_boolean
10687is_24bit_abs_reloc (unsigned int reloc_type)
10688{
10689 switch (elf_header.e_machine)
10690 {
10691 case EM_CYGNUS_MN10200:
10692 case EM_MN10200:
10693 return reloc_type == 4; /* R_MN10200_24. */
10694 default:
10695 return FALSE;
10696 }
10697}
10698
aca88567
NC		 10699/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10700 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10701
10702static bfd_boolean
10703is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10704{
10705 switch (elf_header.e_machine)
10706 {
aca88567
NC		 10707 case EM_AVR_OLD:
10708 case EM_AVR:
10709 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10710 case EM_ADAPTEVA_EPIPHANY:
10711 return reloc_type == 5;
41e92641
NC		 10712 case EM_CYGNUS_D10V:
10713 case EM_D10V:
10714 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10715 case EM_H8S:
10716 case EM_H8_300:
10717 case EM_H8_300H:
aca88567
NC		 10718 return reloc_type == R_H8_DIR16;
10719 case EM_IP2K_OLD:
10720 case EM_IP2K:
10721 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10722 case EM_M32C_OLD:
f4236fe4
DD		 10723 case EM_M32C:
10724 return reloc_type == 1; /* R_M32C_16 */
aca88567 10725 case EM_MSP430:
13761a11
NC		 10726 if (uses_msp430x_relocs ())
10727 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 10728 case EM_MSP430_OLD:
aca88567 10729 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 10730 case EM_NDS32:
10731 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 10732 case EM_ALTERA_NIOS2:
36591ba1 10733 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 10734 case EM_NIOS32:
10735 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10736 case EM_TI_C6000:
10737 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10738 case EM_XC16X:
10739 case EM_C166:
10740 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10741 case EM_CYGNUS_MN10200:
10742 case EM_MN10200:
10743 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10744 case EM_CYGNUS_MN10300:
10745 case EM_MN10300:
10746 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10747 case EM_XGATE:
10748 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10749 default:
aca88567 10750 return FALSE;
4b78141a
NC		 10751 }
10752}
10753
2a7b2e88
JK		 10754/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10755 relocation entries (possibly formerly used for SHT_GROUP sections). */
10756
10757static bfd_boolean
10758is_none_reloc (unsigned int reloc_type)
10759{
10760 switch (elf_header.e_machine)
10761 {
cb8f3167
NC		 10762 case EM_68K: /* R_68K_NONE. */
10763 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10764 case EM_SPARC32PLUS:
10765 case EM_SPARCV9:
cb8f3167
NC		 10766 case EM_SPARC: /* R_SPARC_NONE. */
10767 case EM_MIPS: /* R_MIPS_NONE. */
10768 case EM_PARISC: /* R_PARISC_NONE. */
10769 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10770 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10771 case EM_PPC: /* R_PPC_NONE. */
10772 case EM_PPC64: /* R_PPC64_NONE. */
10773 case EM_ARM: /* R_ARM_NONE. */
10774 case EM_IA_64: /* R_IA64_NONE. */
10775 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10776 case EM_S390_OLD:
cb8f3167
NC		 10777 case EM_S390: /* R_390_NONE. */
10778 case EM_CRIS: /* R_CRIS_NONE. */
10779 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10780 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10781 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10782 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10783 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10784 case EM_M32R: /* R_M32R_NONE. */
40b36596 10785 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10786 case EM_TILEGX: /* R_TILEGX_NONE. */
10787 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10788 case EM_XC16X:
10789 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 10790 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
10791 case EM_NIOS32: /* R_NIOS_NONE. */
cb8f3167 10792 return reloc_type == 0;
a06ea964
NC		 10793 case EM_AARCH64:
10794 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 10795 case EM_NDS32:
10796 return (reloc_type == 0 /* R_XTENSA_NONE. */
10797 || reloc_type == 204 /* R_NDS32_DIFF8. */
10798 || reloc_type == 205 /* R_NDS32_DIFF16. */
10799 || reloc_type == 206 /* R_NDS32_DIFF32. */
10800 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 10801 case EM_XTENSA_OLD:
10802 case EM_XTENSA:
4dc3c23d
AM		 10803 return (reloc_type == 0 /* R_XTENSA_NONE. */
10804 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10805 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10806 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 10807 case EM_METAG:
10808 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 10809 }
10810 return FALSE;
10811}
10812
cf13d699
NC		 10813/* Apply relocations to a section.
10814 Note: So far support has been added only for those relocations
10815 which can be found in debug sections.
10816 FIXME: Add support for more relocations ? */
1b315056 10817
cf13d699
NC		 10818static void
10819apply_relocations (void * file,
10820 Elf_Internal_Shdr * section,
10821 unsigned char * start)
1b315056 10822{
cf13d699
NC		 10823 Elf_Internal_Shdr * relsec;
10824 unsigned char * end = start + section->sh_size;
cb8f3167 10825
cf13d699
NC		 10826 if (elf_header.e_type != ET_REL)
10827 return;
1b315056 10828
cf13d699 10829 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10830 for (relsec = section_headers;
10831 relsec < section_headers + elf_header.e_shnum;
10832 ++relsec)
252b5132 10833 {
41e92641
NC		 10834 bfd_boolean is_rela;
10835 unsigned long num_relocs;
2cf0635d
NC		 10836 Elf_Internal_Rela * relocs;
10837 Elf_Internal_Rela * rp;
10838 Elf_Internal_Shdr * symsec;
10839 Elf_Internal_Sym * symtab;
ba5cdace 10840 unsigned long num_syms;
2cf0635d 10841 Elf_Internal_Sym * sym;
252b5132 10842
41e92641 10843 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10844 || relsec->sh_info >= elf_header.e_shnum
10845 || section_headers + relsec->sh_info != section
c256ffe7 10846 || relsec->sh_size == 0
4fbb74a6 10847 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10848 continue;
428409d5 10849
41e92641
NC		 10850 is_rela = relsec->sh_type == SHT_RELA;
10851
10852 if (is_rela)
10853 {
3f5e193b
NC		 10854 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10855 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10856 return;
10857 }
10858 else
10859 {
3f5e193b
NC		 10860 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10861 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10862 return;
10863 }
10864
10865 /* SH uses RELA but uses in place value instead of the addend field. */
10866 if (elf_header.e_machine == EM_SH)
10867 is_rela = FALSE;
428409d5 10868
4fbb74a6 10869 symsec = section_headers + relsec->sh_link;
ba5cdace 10870 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10871
41e92641 10872 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10873 {
41e92641
NC		 10874 bfd_vma addend;
10875 unsigned int reloc_type;
10876 unsigned int reloc_size;
91d6fa6a 10877 unsigned char * rloc;
ba5cdace 10878 unsigned long sym_index;
4b78141a 10879
aca88567 10880 reloc_type = get_reloc_type (rp->r_info);
41e92641 10881
98fb390a 10882 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10883 continue;
98fb390a
NC		 10884 else if (is_none_reloc (reloc_type))
10885 continue;
10886 else if (is_32bit_abs_reloc (reloc_type)
10887 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10888 reloc_size = 4;
85acf597
RH		 10889 else if (is_64bit_abs_reloc (reloc_type)
10890 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10891 reloc_size = 8;
4dc3c23d
AM		 10892 else if (is_24bit_abs_reloc (reloc_type))
10893 reloc_size = 3;
aca88567
NC		 10894 else if (is_16bit_abs_reloc (reloc_type))
10895 reloc_size = 2;
10896 else
4b78141a 10897 {
41e92641 10898 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10899 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10900 continue;
10901 }
103f02d3 10902
91d6fa6a 10903 rloc = start + rp->r_offset;
c8da6823 10904 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 10905 {
10906 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10907 (unsigned long) rp->r_offset,
10908 SECTION_NAME (section));
10909 continue;
10910 }
103f02d3 10911
ba5cdace
NC		 10912 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10913 if (sym_index >= num_syms)
10914 {
10915 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10916 sym_index, SECTION_NAME (section));
10917 continue;
10918 }
10919 sym = symtab + sym_index;
41e92641
NC		 10920
10921 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10922 make sure that it is of an appropriate type.
10923
10924 Relocations against symbols without type can happen.
10925 Gcc -feliminate-dwarf2-dups may generate symbols
10926 without type for debug info.
10927
10928 Icc generates relocations against function symbols
10929 instead of local labels.
10930
10931 Relocations against object symbols can happen, eg when
10932 referencing a global array. For an example of this see
10933 the _clz.o binary in libgcc.a. */
aca88567 10934 if (sym != symtab
55f25fc3 10935 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10936 {
41e92641 10937 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10938 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10939 (long int)(rp - relocs),
41e92641 10940 SECTION_NAME (relsec));
aca88567 10941 continue;
5b18a4bc 10942 }
252b5132 10943
4dc3c23d
AM		 10944 addend = 0;
10945 if (is_rela)
10946 addend += rp->r_addend;
c47320c3
AM		 10947 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10948 partial_inplace. */
4dc3c23d
AM		 10949 if (!is_rela
10950 || (elf_header.e_machine == EM_XTENSA
10951 && reloc_type == 1)
10952 || ((elf_header.e_machine == EM_PJ
10953 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10954 && reloc_type == 1)
10955 || ((elf_header.e_machine == EM_D30V
10956 || elf_header.e_machine == EM_CYGNUS_D30V)
10957 && reloc_type == 12))
91d6fa6a 10958 addend += byte_get (rloc, reloc_size);
cb8f3167 10959
85acf597
RH		 10960 if (is_32bit_pcrel_reloc (reloc_type)
10961 || is_64bit_pcrel_reloc (reloc_type))
10962 {
10963 /* On HPPA, all pc-relative relocations are biased by 8. */
10964 if (elf_header.e_machine == EM_PARISC)
10965 addend -= 8;
91d6fa6a 10966 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10967 reloc_size);
10968 }
41e92641 10969 else
91d6fa6a 10970 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10971 }
252b5132 10972
5b18a4bc 10973 free (symtab);
41e92641 10974 free (relocs);
5b18a4bc
NC		 10975 break;
10976 }
5b18a4bc 10977}
103f02d3 10978
cf13d699
NC		 10979#ifdef SUPPORT_DISASSEMBLY
10980static int
10981disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10982{
10983 printf (_("\nAssembly dump of section %s\n"),
10984 SECTION_NAME (section));
10985
10986 /* XXX -- to be done --- XXX */
10987
10988 return 1;
10989}
10990#endif
10991
10992/* Reads in the contents of SECTION from FILE, returning a pointer
10993 to a malloc'ed buffer or NULL if something went wrong. */
10994
10995static char *
10996get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10997{
10998 bfd_size_type num_bytes;
10999
11000 num_bytes = section->sh_size;
11001
11002 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11003 {
11004 printf (_("\nSection '%s' has no data to dump.\n"),
11005 SECTION_NAME (section));
11006 return NULL;
11007 }
11008
3f5e193b
NC		 11009 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11010 _("section contents"));
cf13d699
NC		 11011}
11012
dd24e3da 11013
cf13d699
NC		 11014static void
11015dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11016{
11017 Elf_Internal_Shdr * relsec;
11018 bfd_size_type num_bytes;
cf13d699
NC		 11019 char * data;
11020 char * end;
11021 char * start;
11022 char * name = SECTION_NAME (section);
11023 bfd_boolean some_strings_shown;
11024
11025 start = get_section_contents (section, file);
11026 if (start == NULL)
11027 return;
11028
11029 printf (_("\nString dump of section '%s':\n"), name);
11030
11031 /* If the section being dumped has relocations against it the user might
11032 be expecting these relocations to have been applied. Check for this
11033 case and issue a warning message in order to avoid confusion.
11034 FIXME: Maybe we ought to have an option that dumps a section with
11035 relocs applied ? */
11036 for (relsec = section_headers;
11037 relsec < section_headers + elf_header.e_shnum;
11038 ++relsec)
11039 {
11040 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11041 || relsec->sh_info >= elf_header.e_shnum
11042 || section_headers + relsec->sh_info != section
11043 || relsec->sh_size == 0
11044 || relsec->sh_link >= elf_header.e_shnum)
11045 continue;
11046
11047 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11048 break;
11049 }
11050
11051 num_bytes = section->sh_size;
cf13d699
NC		 11052 data = start;
11053 end = start + num_bytes;
11054 some_strings_shown = FALSE;
11055
11056 while (data < end)
11057 {
11058 while (!ISPRINT (* data))
11059 if (++ data >= end)
11060 break;
11061
11062 if (data < end)
11063 {
11064#ifndef __MSVCRT__
c975cc98
NC		 11065 /* PR 11128: Use two separate invocations in order to work
11066 around bugs in the Solaris 8 implementation of printf. */
11067 printf (" [%6tx] ", data - start);
11068 printf ("%s\n", data);
cf13d699
NC		 11069#else
11070 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
11071#endif
11072 data += strlen (data);
11073 some_strings_shown = TRUE;
11074 }
11075 }
11076
11077 if (! some_strings_shown)
11078 printf (_(" No strings found in this section."));
11079
11080 free (start);
11081
11082 putchar ('\n');
11083}
11084
11085static void
11086dump_section_as_bytes (Elf_Internal_Shdr * section,
11087 FILE * file,
11088 bfd_boolean relocate)
11089{
11090 Elf_Internal_Shdr * relsec;
11091 bfd_size_type bytes;
11092 bfd_vma addr;
11093 unsigned char * data;
11094 unsigned char * start;
11095
11096 start = (unsigned char *) get_section_contents (section, file);
11097 if (start == NULL)
11098 return;
11099
11100 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
11101
11102 if (relocate)
11103 {
11104 apply_relocations (file, section, start);
11105 }
11106 else
11107 {
11108 /* If the section being dumped has relocations against it the user might
11109 be expecting these relocations to have been applied. Check for this
11110 case and issue a warning message in order to avoid confusion.
11111 FIXME: Maybe we ought to have an option that dumps a section with
11112 relocs applied ? */
11113 for (relsec = section_headers;
11114 relsec < section_headers + elf_header.e_shnum;
11115 ++relsec)
11116 {
11117 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11118 || relsec->sh_info >= elf_header.e_shnum
11119 || section_headers + relsec->sh_info != section
11120 || relsec->sh_size == 0
11121 || relsec->sh_link >= elf_header.e_shnum)
11122 continue;
11123
11124 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11125 break;
11126 }
11127 }
11128
11129 addr = section->sh_addr;
11130 bytes = section->sh_size;
11131 data = start;
11132
11133 while (bytes)
11134 {
11135 int j;
11136 int k;
11137 int lbytes;
11138
11139 lbytes = (bytes > 16 ? 16 : bytes);
11140
11141 printf (" 0x%8.8lx ", (unsigned long) addr);
11142
11143 for (j = 0; j < 16; j++)
11144 {
11145 if (j < lbytes)
11146 printf ("%2.2x", data[j]);
11147 else
11148 printf (" ");
11149
11150 if ((j & 3) == 3)
11151 printf (" ");
11152 }
11153
11154 for (j = 0; j < lbytes; j++)
11155 {
11156 k = data[j];
11157 if (k >= ' ' && k < 0x7f)
11158 printf ("%c", k);
11159 else
11160 printf (".");
11161 }
11162
11163 putchar ('\n');
11164
11165 data += lbytes;
11166 addr += lbytes;
11167 bytes -= lbytes;
11168 }
11169
11170 free (start);
11171
11172 putchar ('\n');
11173}
11174
4a114e3e 11175/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11176
11177static int
d3dbc530
AM		 11178uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11179 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 11180{
11181#ifndef HAVE_ZLIB_H
cf13d699
NC		 11182 return FALSE;
11183#else
11184 dwarf_size_type compressed_size = *size;
11185 unsigned char * compressed_buffer = *buffer;
11186 dwarf_size_type uncompressed_size;
11187 unsigned char * uncompressed_buffer;
11188 z_stream strm;
11189 int rc;
11190 dwarf_size_type header_size = 12;
11191
11192 /* Read the zlib header. In this case, it should be "ZLIB" followed
11193 by the uncompressed section size, 8 bytes in big-endian order. */
11194 if (compressed_size < header_size
11195 || ! streq ((char *) compressed_buffer, "ZLIB"))
11196 return 0;
11197
11198 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11199 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11200 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11201 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11202 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11203 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11204 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11205 uncompressed_size += compressed_buffer[11];
11206
11207 /* It is possible the section consists of several compressed
11208 buffers concatenated together, so we uncompress in a loop. */
11209 strm.zalloc = NULL;
11210 strm.zfree = NULL;
11211 strm.opaque = NULL;
11212 strm.avail_in = compressed_size - header_size;
11213 strm.next_in = (Bytef *) compressed_buffer + header_size;
11214 strm.avail_out = uncompressed_size;
3f5e193b 11215 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 11216
11217 rc = inflateInit (& strm);
11218 while (strm.avail_in > 0)
11219 {
11220 if (rc != Z_OK)
11221 goto fail;
11222 strm.next_out = ((Bytef *) uncompressed_buffer
11223 + (uncompressed_size - strm.avail_out));
11224 rc = inflate (&strm, Z_FINISH);
11225 if (rc != Z_STREAM_END)
11226 goto fail;
11227 rc = inflateReset (& strm);
11228 }
11229 rc = inflateEnd (& strm);
11230 if (rc != Z_OK
11231 || strm.avail_out != 0)
11232 goto fail;
11233
11234 free (compressed_buffer);
11235 *buffer = uncompressed_buffer;
11236 *size = uncompressed_size;
11237 return 1;
11238
11239 fail:
11240 free (uncompressed_buffer);
4a114e3e
L		 11241 /* Indicate decompression failure. */
11242 *buffer = NULL;
cf13d699
NC		 11243 return 0;
11244#endif /* HAVE_ZLIB_H */
11245}
11246
d966045b
DJ		 11247static int
11248load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 11249 Elf_Internal_Shdr * sec, void * file)
1007acb3 11250{
2cf0635d 11251 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 11252 char buf [64];
1007acb3 11253
19e6b90e
L		 11254 /* If it is already loaded, do nothing. */
11255 if (section->start != NULL)
11256 return 1;
1007acb3 11257
19e6b90e
L		 11258 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11259 section->address = sec->sh_addr;
3f5e193b
NC		 11260 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11261 sec->sh_offset, 1,
11262 sec->sh_size, buf);
59245841
NC		 11263 if (section->start == NULL)
11264 section->size = 0;
11265 else
11266 {
11267 section->size = sec->sh_size;
11268 if (uncompress_section_contents (&section->start, &section->size))
11269 sec->sh_size = section->size;
11270 }
4a114e3e 11271
1b315056
CS		 11272 if (section->start == NULL)
11273 return 0;
11274
19e6b90e 11275 if (debug_displays [debug].relocate)
3f5e193b 11276 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11277
1b315056 11278 return 1;
1007acb3
L		 11279}
11280
657d0d47
CC		 11281/* If this is not NULL, load_debug_section will only look for sections
11282 within the list of sections given here. */
11283unsigned int *section_subset = NULL;
11284
d966045b 11285int
2cf0635d 11286load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11287{
2cf0635d
NC		 11288 struct dwarf_section * section = &debug_displays [debug].section;
11289 Elf_Internal_Shdr * sec;
d966045b
DJ		 11290
11291 /* Locate the debug section. */
657d0d47 11292 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 11293 if (sec != NULL)
11294 section->name = section->uncompressed_name;
11295 else
11296 {
657d0d47 11297 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 11298 if (sec != NULL)
11299 section->name = section->compressed_name;
11300 }
11301 if (sec == NULL)
11302 return 0;
11303
657d0d47
CC		 11304 /* If we're loading from a subset of sections, and we've loaded
11305 a section matching this name before, it's likely that it's a
11306 different one. */
11307 if (section_subset != NULL)
11308 free_debug_section (debug);
11309
3f5e193b 11310 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 11311}
11312
19e6b90e
L		 11313void
11314free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 11315{
2cf0635d 11316 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 11317
19e6b90e
L		 11318 if (section->start == NULL)
11319 return;
1007acb3 11320
19e6b90e
L		 11321 free ((char *) section->start);
11322 section->start = NULL;
11323 section->address = 0;
11324 section->size = 0;
1007acb3
L		 11325}
11326
1007acb3 11327static int
657d0d47 11328display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 11329{
2cf0635d 11330 char * name = SECTION_NAME (section);
19e6b90e
L		 11331 bfd_size_type length;
11332 int result = 1;
3f5e193b 11333 int i;
1007acb3 11334
19e6b90e
L		 11335 length = section->sh_size;
11336 if (length == 0)
1007acb3 11337 {
19e6b90e
L		 11338 printf (_("\nSection '%s' has no debugging data.\n"), name);
11339 return 0;
1007acb3 11340 }
5dff79d8
NC		 11341 if (section->sh_type == SHT_NOBITS)
11342 {
11343 /* There is no point in dumping the contents of a debugging section
11344 which has the NOBITS type - the bits in the file will be random.
11345 This can happen when a file containing a .eh_frame section is
11346 stripped with the --only-keep-debug command line option. */
11347 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11348 return 0;
11349 }
1007acb3 11350
0112cd26 11351 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 11352 name = ".debug_info";
1007acb3 11353
19e6b90e
L		 11354 /* See if we know how to display the contents of this section. */
11355 for (i = 0; i < max; i++)
1b315056 11356 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 11357 || (i == line && const_strneq (name, ".debug_line."))
1b315056 11358 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 11359 {
2cf0635d 11360 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 11361 int secondary = (section != find_section (name));
11362
11363 if (secondary)
3f5e193b 11364 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 11365
b40bf0a2
NC		 11366 if (i == line && const_strneq (name, ".debug_line."))
11367 sec->name = name;
11368 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 11369 sec->name = sec->uncompressed_name;
11370 else
11371 sec->name = sec->compressed_name;
3f5e193b
NC		 11372 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11373 section, file))
19e6b90e 11374 {
657d0d47
CC		 11375 /* If this debug section is part of a CU/TU set in a .dwp file,
11376 restrict load_debug_section to the sections in that set. */
11377 section_subset = find_cu_tu_set (file, shndx);
11378
19e6b90e 11379 result &= debug_displays[i].display (sec, file);
1007acb3 11380
657d0d47
CC		 11381 section_subset = NULL;
11382
d966045b 11383 if (secondary || (i != info && i != abbrev))
3f5e193b 11384 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 11385 }
1007acb3 11386
19e6b90e
L		 11387 break;
11388 }
1007acb3 11389
19e6b90e 11390 if (i == max)
1007acb3 11391 {
19e6b90e
L		 11392 printf (_("Unrecognized debug section: %s\n"), name);
11393 result = 0;
1007acb3
L		 11394 }
11395
19e6b90e 11396 return result;
5b18a4bc 11397}
103f02d3 11398
aef1f6d0
DJ		 11399/* Set DUMP_SECTS for all sections where dumps were requested
11400 based on section name. */
11401
11402static void
11403initialise_dumps_byname (void)
11404{
2cf0635d 11405 struct dump_list_entry * cur;
aef1f6d0
DJ		 11406
11407 for (cur = dump_sects_byname; cur; cur = cur->next)
11408 {
11409 unsigned int i;
11410 int any;
11411
11412 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11413 if (streq (SECTION_NAME (section_headers + i), cur->name))
11414 {
09c11c86 11415 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11416 any = 1;
11417 }
11418
11419 if (!any)
11420 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11421 cur->name);
11422 }
11423}
11424
5b18a4bc 11425static void
2cf0635d 11426process_section_contents (FILE * file)
5b18a4bc 11427{
2cf0635d 11428 Elf_Internal_Shdr * section;
19e6b90e 11429 unsigned int i;
103f02d3 11430
19e6b90e
L		 11431 if (! do_dump)
11432 return;
103f02d3 11433
aef1f6d0
DJ		 11434 initialise_dumps_byname ();
11435
19e6b90e
L		 11436 for (i = 0, section = section_headers;
11437 i < elf_header.e_shnum && i < num_dump_sects;
11438 i++, section++)
11439 {
11440#ifdef SUPPORT_DISASSEMBLY
11441 if (dump_sects[i] & DISASS_DUMP)
11442 disassemble_section (section, file);
11443#endif
11444 if (dump_sects[i] & HEX_DUMP)
cf13d699 11445 dump_section_as_bytes (section, file, FALSE);
103f02d3 11446
cf13d699
NC		 11447 if (dump_sects[i] & RELOC_DUMP)
11448 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11449
11450 if (dump_sects[i] & STRING_DUMP)
11451 dump_section_as_strings (section, file);
cf13d699
NC		 11452
11453 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11454 display_debug_section (i, section, file);
5b18a4bc 11455 }
103f02d3 11456
19e6b90e
L		 11457 /* Check to see if the user requested a
11458 dump of a section that does not exist. */
11459 while (i++ < num_dump_sects)
11460 if (dump_sects[i])
11461 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11462}
103f02d3 11463
5b18a4bc 11464static void
19e6b90e 11465process_mips_fpe_exception (int mask)
5b18a4bc 11466{
19e6b90e
L		 11467 if (mask)
11468 {
11469 int first = 1;
11470 if (mask & OEX_FPU_INEX)
11471 fputs ("INEX", stdout), first = 0;
11472 if (mask & OEX_FPU_UFLO)
11473 printf ("%sUFLO", first ? "" : "|"), first = 0;
11474 if (mask & OEX_FPU_OFLO)
11475 printf ("%sOFLO", first ? "" : "|"), first = 0;
11476 if (mask & OEX_FPU_DIV0)
11477 printf ("%sDIV0", first ? "" : "|"), first = 0;
11478 if (mask & OEX_FPU_INVAL)
11479 printf ("%sINVAL", first ? "" : "|");
11480 }
5b18a4bc 11481 else
19e6b90e 11482 fputs ("0", stdout);
5b18a4bc 11483}
103f02d3 11484
f6f0e17b
NC		 11485/* Display's the value of TAG at location P. If TAG is
11486 greater than 0 it is assumed to be an unknown tag, and
11487 a message is printed to this effect. Otherwise it is
11488 assumed that a message has already been printed.
11489
11490 If the bottom bit of TAG is set it assumed to have a
11491 string value, otherwise it is assumed to have an integer
11492 value.
11493
11494 Returns an updated P pointing to the first unread byte
11495 beyond the end of TAG's value.
11496
11497 Reads at or beyond END will not be made. */
11498
11499static unsigned char *
11500display_tag_value (int tag,
11501 unsigned char * p,
11502 const unsigned char * const end)
11503{
11504 unsigned long val;
11505
11506 if (tag > 0)
11507 printf (" Tag_unknown_%d: ", tag);
11508
11509 if (p >= end)
11510 {
11511 warn (_("corrupt tag\n"));
11512 }
11513 else if (tag & 1)
11514 {
11515 /* FIXME: we could read beyond END here. */
11516 printf ("\"%s\"\n", p);
11517 p += strlen ((char *) p) + 1;
11518 }
11519 else
11520 {
11521 unsigned int len;
11522
11523 val = read_uleb128 (p, &len, end);
11524 p += len;
11525 printf ("%ld (0x%lx)\n", val, val);
11526 }
11527
11528 return p;
11529}
11530
11c1ff18
PB		 11531/* ARM EABI attributes section. */
11532typedef struct
11533{
11534 int tag;
2cf0635d 11535 const char * name;
11c1ff18
PB		 11536 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11537 int type;
2cf0635d 11538 const char ** table;
11c1ff18
PB		 11539} arm_attr_public_tag;
11540
2cf0635d 11541static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11542 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11543 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11544static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11545static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11546 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11547static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 11548 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11549 "FP for ARMv8"};
2cf0635d 11550static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11551static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11552 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11553static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11554 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11555 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11556static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11557 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11558static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11559 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11560static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11561 {"Absolute", "PC-relative", "None"};
2cf0635d 11562static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11563 {"None", "direct", "GOT-indirect"};
2cf0635d 11564static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11565 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11566static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11567static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11568 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11569static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11570static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11571static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11572 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11573static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11574 {"Unused", "small", "int", "forced to int"};
2cf0635d 11575static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11576 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11577static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11578 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11579static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11580 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11581static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11582 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11583 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11584static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 11585 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11586 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11587static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11588static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11589 {"Not Allowed", "Allowed"};
2cf0635d 11590static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11591 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11592static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 11593 {"Not Allowed", "Allowed"};
11594static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11595 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11596 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 11597static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11598static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11599 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11600 "TrustZone and Virtualization Extensions"};
dd24e3da 11601static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11602 {"Not Allowed", "Allowed"};
11c1ff18
PB		 11603
11604#define LOOKUP(id, name) \
11605 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11606static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 11607{
11608 {4, "CPU_raw_name", 1, NULL},
11609 {5, "CPU_name", 1, NULL},
11610 LOOKUP(6, CPU_arch),
11611 {7, "CPU_arch_profile", 0, NULL},
11612 LOOKUP(8, ARM_ISA_use),
11613 LOOKUP(9, THUMB_ISA_use),
75375b3e 11614 LOOKUP(10, FP_arch),
11c1ff18 11615 LOOKUP(11, WMMX_arch),
f5f53991
AS		 11616 LOOKUP(12, Advanced_SIMD_arch),
11617 LOOKUP(13, PCS_config),
11c1ff18
PB		 11618 LOOKUP(14, ABI_PCS_R9_use),
11619 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11620 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 11621 LOOKUP(17, ABI_PCS_GOT_use),
11622 LOOKUP(18, ABI_PCS_wchar_t),
11623 LOOKUP(19, ABI_FP_rounding),
11624 LOOKUP(20, ABI_FP_denormal),
11625 LOOKUP(21, ABI_FP_exceptions),
11626 LOOKUP(22, ABI_FP_user_exceptions),
11627 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 11628 {24, "ABI_align_needed", 0, NULL},
11629 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 11630 LOOKUP(26, ABI_enum_size),
11631 LOOKUP(27, ABI_HardFP_use),
11632 LOOKUP(28, ABI_VFP_args),
11633 LOOKUP(29, ABI_WMMX_args),
11634 LOOKUP(30, ABI_optimization_goals),
11635 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11636 {32, "compatibility", 0, NULL},
f5f53991 11637 LOOKUP(34, CPU_unaligned_access),
75375b3e 11638 LOOKUP(36, FP_HP_extension),
8e79c3df 11639 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 11640 LOOKUP(42, MPextension_use),
11641 LOOKUP(44, DIV_use),
f5f53991
AS		 11642 {64, "nodefaults", 0, NULL},
11643 {65, "also_compatible_with", 0, NULL},
11644 LOOKUP(66, T2EE_use),
11645 {67, "conformance", 1, NULL},
11646 LOOKUP(68, Virtualization_use),
cd21e546 11647 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 11648};
11649#undef LOOKUP
11650
11c1ff18 11651static unsigned char *
f6f0e17b
NC		 11652display_arm_attribute (unsigned char * p,
11653 const unsigned char * const end)
11c1ff18
PB		 11654{
11655 int tag;
11656 unsigned int len;
11657 int val;
2cf0635d 11658 arm_attr_public_tag * attr;
11c1ff18
PB		 11659 unsigned i;
11660 int type;
11661
f6f0e17b 11662 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 11663 p += len;
11664 attr = NULL;
2cf0635d 11665 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 11666 {
11667 if (arm_attr_public_tags[i].tag == tag)
11668 {
11669 attr = &arm_attr_public_tags[i];
11670 break;
11671 }
11672 }
11673
11674 if (attr)
11675 {
11676 printf (" Tag_%s: ", attr->name);
11677 switch (attr->type)
11678 {
11679 case 0:
11680 switch (tag)
11681 {
11682 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 11683 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11684 p += len;
11685 switch (val)
11686 {
2b692964
NC		 11687 case 0: printf (_("None\n")); break;
11688 case 'A': printf (_("Application\n")); break;
11689 case 'R': printf (_("Realtime\n")); break;
11690 case 'M': printf (_("Microcontroller\n")); break;
11691 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11692 default: printf ("??? (%d)\n", val); break;
11693 }
11694 break;
11695
75375b3e 11696 case 24: /* Tag_align_needed. */
f6f0e17b 11697 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11698 p += len;
11699 switch (val)
11700 {
2b692964
NC		 11701 case 0: printf (_("None\n")); break;
11702 case 1: printf (_("8-byte\n")); break;
11703 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11704 case 3: printf ("??? 3\n"); break;
11705 default:
11706 if (val <= 12)
dd24e3da 11707 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11708 1 << val);
11709 else
11710 printf ("??? (%d)\n", val);
11711 break;
11712 }
11713 break;
11714
11715 case 25: /* Tag_align_preserved. */
f6f0e17b 11716 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11717 p += len;
11718 switch (val)
11719 {
2b692964
NC		 11720 case 0: printf (_("None\n")); break;
11721 case 1: printf (_("8-byte, except leaf SP\n")); break;
11722 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11723 case 3: printf ("??? 3\n"); break;
11724 default:
11725 if (val <= 12)
dd24e3da 11726 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11727 1 << val);
11728 else
11729 printf ("??? (%d)\n", val);
11730 break;
11731 }
11732 break;
11733
11c1ff18 11734 case 32: /* Tag_compatibility. */
f6f0e17b 11735 val = read_uleb128 (p, &len, end);
11c1ff18 11736 p += len;
2b692964 11737 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11738 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11739 break;
11740
f5f53991
AS		 11741 case 64: /* Tag_nodefaults. */
11742 p++;
2b692964 11743 printf (_("True\n"));
f5f53991
AS		 11744 break;
11745
11746 case 65: /* Tag_also_compatible_with. */
f6f0e17b 11747 val = read_uleb128 (p, &len, end);
f5f53991
AS		 11748 p += len;
11749 if (val == 6 /* Tag_CPU_arch. */)
11750 {
f6f0e17b 11751 val = read_uleb128 (p, &len, end);
f5f53991 11752 p += len;
2cf0635d 11753 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11754 printf ("??? (%d)\n", val);
11755 else
11756 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11757 }
11758 else
11759 printf ("???\n");
11760 while (*(p++) != '\0' /* NUL terminator. */);
11761 break;
11762
11c1ff18 11763 default:
2cf0635d 11764 abort ();
11c1ff18
PB		 11765 }
11766 return p;
11767
11768 case 1:
f6f0e17b 11769 return display_tag_value (-1, p, end);
11c1ff18 11770 case 2:
f6f0e17b 11771 return display_tag_value (0, p, end);
11c1ff18
PB		 11772
11773 default:
11774 assert (attr->type & 0x80);
f6f0e17b 11775 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11776 p += len;
11777 type = attr->type & 0x7f;
11778 if (val >= type)
11779 printf ("??? (%d)\n", val);
11780 else
11781 printf ("%s\n", attr->table[val]);
11782 return p;
11783 }
11784 }
11c1ff18 11785
f6f0e17b 11786 return display_tag_value (tag, p, end);
11c1ff18
PB		 11787}
11788
104d59d1 11789static unsigned char *
60bca95a 11790display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 11791 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11792 const unsigned char * const end)
104d59d1
JM		 11793{
11794 int tag;
11795 unsigned int len;
11796 int val;
104d59d1 11797
f6f0e17b 11798 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 11799 p += len;
11800
11801 /* Tag_compatibility is the only generic GNU attribute defined at
11802 present. */
11803 if (tag == 32)
11804 {
f6f0e17b 11805 val = read_uleb128 (p, &len, end);
104d59d1 11806 p += len;
f6f0e17b
NC		 11807 if (p == end)
11808 {
11809 printf (_("flag = %d, vendor = <corrupt>\n"), val);
11810 warn (_("corrupt vendor attribute\n"));
11811 }
11812 else
11813 {
11814 printf (_("flag = %d, vendor = %s\n"), val, p);
11815 p += strlen ((char *) p) + 1;
11816 }
104d59d1
JM		 11817 return p;
11818 }
11819
11820 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 11821 return display_proc_gnu_attribute (p, tag, end);
104d59d1 11822
f6f0e17b 11823 return display_tag_value (tag, p, end);
104d59d1
JM		 11824}
11825
34c8bcba 11826static unsigned char *
f6f0e17b
NC		 11827display_power_gnu_attribute (unsigned char * p,
11828 int tag,
11829 const unsigned char * const end)
34c8bcba 11830{
34c8bcba
JM		 11831 unsigned int len;
11832 int val;
11833
11834 if (tag == Tag_GNU_Power_ABI_FP)
11835 {
f6f0e17b 11836 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 11837 p += len;
11838 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11839
34c8bcba
JM		 11840 switch (val)
11841 {
11842 case 0:
2b692964 11843 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11844 break;
11845 case 1:
2b692964 11846 printf (_("Hard float\n"));
34c8bcba
JM		 11847 break;
11848 case 2:
2b692964 11849 printf (_("Soft float\n"));
34c8bcba 11850 break;
3c7b9897 11851 case 3:
2b692964 11852 printf (_("Single-precision hard float\n"));
3c7b9897 11853 break;
34c8bcba
JM		 11854 default:
11855 printf ("??? (%d)\n", val);
11856 break;
11857 }
11858 return p;
11859 }
11860
c6e65352
DJ		 11861 if (tag == Tag_GNU_Power_ABI_Vector)
11862 {
f6f0e17b 11863 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 11864 p += len;
11865 printf (" Tag_GNU_Power_ABI_Vector: ");
11866 switch (val)
11867 {
11868 case 0:
2b692964 11869 printf (_("Any\n"));
c6e65352
DJ		 11870 break;
11871 case 1:
2b692964 11872 printf (_("Generic\n"));
c6e65352
DJ		 11873 break;
11874 case 2:
11875 printf ("AltiVec\n");
11876 break;
11877 case 3:
11878 printf ("SPE\n");
11879 break;
11880 default:
11881 printf ("??? (%d)\n", val);
11882 break;
11883 }
11884 return p;
11885 }
11886
f82e0623
NF		 11887 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11888 {
f6f0e17b
NC		 11889 if (p == end)
11890 {
11891 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11892 return p;
11893 }
0b4362b0 11894
f6f0e17b 11895 val = read_uleb128 (p, &len, end);
f82e0623
NF		 11896 p += len;
11897 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11898 switch (val)
11899 {
11900 case 0:
2b692964 11901 printf (_("Any\n"));
f82e0623
NF		 11902 break;
11903 case 1:
11904 printf ("r3/r4\n");
11905 break;
11906 case 2:
2b692964 11907 printf (_("Memory\n"));
f82e0623
NF		 11908 break;
11909 default:
11910 printf ("??? (%d)\n", val);
11911 break;
11912 }
11913 return p;
11914 }
11915
f6f0e17b 11916 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 11917}
11918
9e8c70f9
DM		 11919static void
11920display_sparc_hwcaps (int mask)
11921{
11922 if (mask)
11923 {
11924 int first = 1;
11925 if (mask & ELF_SPARC_HWCAP_MUL32)
11926 fputs ("mul32", stdout), first = 0;
11927 if (mask & ELF_SPARC_HWCAP_DIV32)
11928 printf ("%sdiv32", first ? "" : "|"), first = 0;
11929 if (mask & ELF_SPARC_HWCAP_FSMULD)
11930 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11931 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11932 printf ("%sv8plus", first ? "" : "|"), first = 0;
11933 if (mask & ELF_SPARC_HWCAP_POPC)
11934 printf ("%spopc", first ? "" : "|"), first = 0;
11935 if (mask & ELF_SPARC_HWCAP_VIS)
11936 printf ("%svis", first ? "" : "|"), first = 0;
11937 if (mask & ELF_SPARC_HWCAP_VIS2)
11938 printf ("%svis2", first ? "" : "|"), first = 0;
11939 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11940 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11941 if (mask & ELF_SPARC_HWCAP_FMAF)
11942 printf ("%sfmaf", first ? "" : "|"), first = 0;
11943 if (mask & ELF_SPARC_HWCAP_VIS3)
11944 printf ("%svis3", first ? "" : "|"), first = 0;
11945 if (mask & ELF_SPARC_HWCAP_HPC)
11946 printf ("%shpc", first ? "" : "|"), first = 0;
11947 if (mask & ELF_SPARC_HWCAP_RANDOM)
11948 printf ("%srandom", first ? "" : "|"), first = 0;
11949 if (mask & ELF_SPARC_HWCAP_TRANS)
11950 printf ("%strans", first ? "" : "|"), first = 0;
11951 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11952 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11953 if (mask & ELF_SPARC_HWCAP_IMA)
11954 printf ("%sima", first ? "" : "|"), first = 0;
11955 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11956 printf ("%scspare", first ? "" : "|"), first = 0;
11957 }
11958 else
11959 fputc('0', stdout);
11960 fputc('\n', stdout);
11961}
11962
11963static unsigned char *
f6f0e17b
NC		 11964display_sparc_gnu_attribute (unsigned char * p,
11965 int tag,
11966 const unsigned char * const end)
9e8c70f9 11967{
9e8c70f9
DM		 11968 if (tag == Tag_GNU_Sparc_HWCAPS)
11969 {
f6f0e17b
NC		 11970 unsigned int len;
11971 int val;
11972
11973 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 11974 p += len;
11975 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 11976 display_sparc_hwcaps (val);
11977 return p;
11978 }
11979
f6f0e17b 11980 return display_tag_value (tag, p, end);
9e8c70f9
DM		 11981}
11982
2cf19d5c 11983static unsigned char *
f6f0e17b
NC		 11984display_mips_gnu_attribute (unsigned char * p,
11985 int tag,
11986 const unsigned char * const end)
2cf19d5c 11987{
2cf19d5c
JM		 11988 if (tag == Tag_GNU_MIPS_ABI_FP)
11989 {
f6f0e17b
NC		 11990 unsigned int len;
11991 int val;
11992
11993 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 11994 p += len;
11995 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11996
2cf19d5c
JM		 11997 switch (val)
11998 {
d929bc19 11999 case Val_GNU_MIPS_ABI_FP_ANY:
2b692964 12000 printf (_("Hard or soft float\n"));
2cf19d5c 12001 break;
d929bc19 12002 case Val_GNU_MIPS_ABI_FP_DOUBLE:
2b692964 12003 printf (_("Hard float (double precision)\n"));
2cf19d5c 12004 break;
d929bc19 12005 case Val_GNU_MIPS_ABI_FP_SINGLE:
2b692964 12006 printf (_("Hard float (single precision)\n"));
2cf19d5c 12007 break;
d929bc19 12008 case Val_GNU_MIPS_ABI_FP_SOFT:
2b692964 12009 printf (_("Soft float\n"));
2cf19d5c 12010 break;
d929bc19 12011 case Val_GNU_MIPS_ABI_FP_64:
9eeefea8 12012 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 12013 break;
2cf19d5c
JM		 12014 default:
12015 printf ("??? (%d)\n", val);
12016 break;
12017 }
12018 return p;
12019 }
12020
a9f58168
CF		 12021 if (tag == Tag_GNU_MIPS_ABI_MSA)
12022 {
12023 unsigned int len;
12024 int val;
12025
12026 val = read_uleb128 (p, &len, end);
12027 p += len;
12028 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12029
12030 switch (val)
12031 {
12032 case Val_GNU_MIPS_ABI_MSA_ANY:
12033 printf (_("Any MSA or not\n"));
12034 break;
12035 case Val_GNU_MIPS_ABI_MSA_128:
12036 printf (_("128-bit MSA\n"));
12037 break;
12038 default:
12039 printf ("??? (%d)\n", val);
12040 break;
12041 }
12042 return p;
12043 }
12044
f6f0e17b 12045 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12046}
12047
59e6276b 12048static unsigned char *
f6f0e17b
NC		 12049display_tic6x_attribute (unsigned char * p,
12050 const unsigned char * const end)
59e6276b
JM		 12051{
12052 int tag;
12053 unsigned int len;
12054 int val;
12055
f6f0e17b 12056 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12057 p += len;
12058
12059 switch (tag)
12060 {
75fa6dc1 12061 case Tag_ISA:
f6f0e17b 12062 val = read_uleb128 (p, &len, end);
59e6276b 12063 p += len;
75fa6dc1 12064 printf (" Tag_ISA: ");
59e6276b
JM		 12065
12066 switch (val)
12067 {
75fa6dc1 12068 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12069 printf (_("None\n"));
12070 break;
75fa6dc1 12071 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12072 printf ("C62x\n");
12073 break;
75fa6dc1 12074 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12075 printf ("C67x\n");
12076 break;
75fa6dc1 12077 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12078 printf ("C67x+\n");
12079 break;
75fa6dc1 12080 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12081 printf ("C64x\n");
12082 break;
75fa6dc1 12083 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12084 printf ("C64x+\n");
12085 break;
75fa6dc1 12086 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12087 printf ("C674x\n");
12088 break;
12089 default:
12090 printf ("??? (%d)\n", val);
12091 break;
12092 }
12093 return p;
12094
87779176 12095 case Tag_ABI_wchar_t:
f6f0e17b 12096 val = read_uleb128 (p, &len, end);
87779176
JM		 12097 p += len;
12098 printf (" Tag_ABI_wchar_t: ");
12099 switch (val)
12100 {
12101 case 0:
12102 printf (_("Not used\n"));
12103 break;
12104 case 1:
12105 printf (_("2 bytes\n"));
12106 break;
12107 case 2:
12108 printf (_("4 bytes\n"));
12109 break;
12110 default:
12111 printf ("??? (%d)\n", val);
12112 break;
12113 }
12114 return p;
12115
12116 case Tag_ABI_stack_align_needed:
f6f0e17b 12117 val = read_uleb128 (p, &len, end);
87779176
JM		 12118 p += len;
12119 printf (" Tag_ABI_stack_align_needed: ");
12120 switch (val)
12121 {
12122 case 0:
12123 printf (_("8-byte\n"));
12124 break;
12125 case 1:
12126 printf (_("16-byte\n"));
12127 break;
12128 default:
12129 printf ("??? (%d)\n", val);
12130 break;
12131 }
12132 return p;
12133
12134 case Tag_ABI_stack_align_preserved:
f6f0e17b 12135 val = read_uleb128 (p, &len, end);
87779176
JM		 12136 p += len;
12137 printf (" Tag_ABI_stack_align_preserved: ");
12138 switch (val)
12139 {
12140 case 0:
12141 printf (_("8-byte\n"));
12142 break;
12143 case 1:
12144 printf (_("16-byte\n"));
12145 break;
12146 default:
12147 printf ("??? (%d)\n", val);
12148 break;
12149 }
12150 return p;
12151
b5593623 12152 case Tag_ABI_DSBT:
f6f0e17b 12153 val = read_uleb128 (p, &len, end);
b5593623
JM		 12154 p += len;
12155 printf (" Tag_ABI_DSBT: ");
12156 switch (val)
12157 {
12158 case 0:
12159 printf (_("DSBT addressing not used\n"));
12160 break;
12161 case 1:
12162 printf (_("DSBT addressing used\n"));
12163 break;
12164 default:
12165 printf ("??? (%d)\n", val);
12166 break;
12167 }
12168 return p;
12169
87779176 12170 case Tag_ABI_PID:
f6f0e17b 12171 val = read_uleb128 (p, &len, end);
87779176
JM		 12172 p += len;
12173 printf (" Tag_ABI_PID: ");
12174 switch (val)
12175 {
12176 case 0:
12177 printf (_("Data addressing position-dependent\n"));
12178 break;
12179 case 1:
12180 printf (_("Data addressing position-independent, GOT near DP\n"));
12181 break;
12182 case 2:
12183 printf (_("Data addressing position-independent, GOT far from DP\n"));
12184 break;
12185 default:
12186 printf ("??? (%d)\n", val);
12187 break;
12188 }
12189 return p;
12190
12191 case Tag_ABI_PIC:
f6f0e17b 12192 val = read_uleb128 (p, &len, end);
87779176
JM		 12193 p += len;
12194 printf (" Tag_ABI_PIC: ");
12195 switch (val)
12196 {
12197 case 0:
12198 printf (_("Code addressing position-dependent\n"));
12199 break;
12200 case 1:
12201 printf (_("Code addressing position-independent\n"));
12202 break;
12203 default:
12204 printf ("??? (%d)\n", val);
12205 break;
12206 }
12207 return p;
12208
12209 case Tag_ABI_array_object_alignment:
f6f0e17b 12210 val = read_uleb128 (p, &len, end);
87779176
JM		 12211 p += len;
12212 printf (" Tag_ABI_array_object_alignment: ");
12213 switch (val)
12214 {
12215 case 0:
12216 printf (_("8-byte\n"));
12217 break;
12218 case 1:
12219 printf (_("4-byte\n"));
12220 break;
12221 case 2:
12222 printf (_("16-byte\n"));
12223 break;
12224 default:
12225 printf ("??? (%d)\n", val);
12226 break;
12227 }
12228 return p;
12229
12230 case Tag_ABI_array_object_align_expected:
f6f0e17b 12231 val = read_uleb128 (p, &len, end);
87779176
JM		 12232 p += len;
12233 printf (" Tag_ABI_array_object_align_expected: ");
12234 switch (val)
12235 {
12236 case 0:
12237 printf (_("8-byte\n"));
12238 break;
12239 case 1:
12240 printf (_("4-byte\n"));
12241 break;
12242 case 2:
12243 printf (_("16-byte\n"));
12244 break;
12245 default:
12246 printf ("??? (%d)\n", val);
12247 break;
12248 }
12249 return p;
12250
3cbd1c06 12251 case Tag_ABI_compatibility:
f6f0e17b 12252 val = read_uleb128 (p, &len, end);
59e6276b 12253 p += len;
3cbd1c06 12254 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 12255 printf (_("flag = %d, vendor = %s\n"), val, p);
12256 p += strlen ((char *) p) + 1;
12257 return p;
87779176
JM		 12258
12259 case Tag_ABI_conformance:
12260 printf (" Tag_ABI_conformance: ");
12261 printf ("\"%s\"\n", p);
12262 p += strlen ((char *) p) + 1;
12263 return p;
59e6276b
JM		 12264 }
12265
f6f0e17b
NC		 12266 return display_tag_value (tag, p, end);
12267}
59e6276b 12268
f6f0e17b
NC		 12269static void
12270display_raw_attribute (unsigned char * p, unsigned char * end)
12271{
12272 unsigned long addr = 0;
12273 size_t bytes = end - p;
12274
12275 while (bytes)
87779176 12276 {
f6f0e17b
NC		 12277 int j;
12278 int k;
12279 int lbytes = (bytes > 16 ? 16 : bytes);
12280
12281 printf (" 0x%8.8lx ", addr);
12282
12283 for (j = 0; j < 16; j++)
12284 {
12285 if (j < lbytes)
12286 printf ("%2.2x", p[j]);
12287 else
12288 printf (" ");
12289
12290 if ((j & 3) == 3)
12291 printf (" ");
12292 }
12293
12294 for (j = 0; j < lbytes; j++)
12295 {
12296 k = p[j];
12297 if (k >= ' ' && k < 0x7f)
12298 printf ("%c", k);
12299 else
12300 printf (".");
12301 }
12302
12303 putchar ('\n');
12304
12305 p += lbytes;
12306 bytes -= lbytes;
12307 addr += lbytes;
87779176 12308 }
59e6276b 12309
f6f0e17b 12310 putchar ('\n');
59e6276b
JM		 12311}
12312
13761a11
NC		 12313static unsigned char *
12314display_msp430x_attribute (unsigned char * p,
12315 const unsigned char * const end)
12316{
12317 unsigned int len;
12318 int val;
12319 int tag;
12320
12321 tag = read_uleb128 (p, & len, end);
12322 p += len;
0b4362b0 12323
13761a11
NC		 12324 switch (tag)
12325 {
12326 case OFBA_MSPABI_Tag_ISA:
12327 val = read_uleb128 (p, &len, end);
12328 p += len;
12329 printf (" Tag_ISA: ");
12330 switch (val)
12331 {
12332 case 0: printf (_("None\n")); break;
12333 case 1: printf (_("MSP430\n")); break;
12334 case 2: printf (_("MSP430X\n")); break;
12335 default: printf ("??? (%d)\n", val); break;
12336 }
12337 break;
12338
12339 case OFBA_MSPABI_Tag_Code_Model:
12340 val = read_uleb128 (p, &len, end);
12341 p += len;
12342 printf (" Tag_Code_Model: ");
12343 switch (val)
12344 {
12345 case 0: printf (_("None\n")); break;
12346 case 1: printf (_("Small\n")); break;
12347 case 2: printf (_("Large\n")); break;
12348 default: printf ("??? (%d)\n", val); break;
12349 }
12350 break;
12351
12352 case OFBA_MSPABI_Tag_Data_Model:
12353 val = read_uleb128 (p, &len, end);
12354 p += len;
12355 printf (" Tag_Data_Model: ");
12356 switch (val)
12357 {
12358 case 0: printf (_("None\n")); break;
12359 case 1: printf (_("Small\n")); break;
12360 case 2: printf (_("Large\n")); break;
12361 case 3: printf (_("Restricted Large\n")); break;
12362 default: printf ("??? (%d)\n", val); break;
12363 }
12364 break;
12365
12366 default:
12367 printf (_(" <unknown tag %d>: "), tag);
12368
12369 if (tag & 1)
12370 {
12371 printf ("\"%s\"\n", p);
12372 p += strlen ((char *) p) + 1;
12373 }
12374 else
12375 {
12376 val = read_uleb128 (p, &len, end);
12377 p += len;
12378 printf ("%d (0x%x)\n", val, val);
12379 }
12380 break;
12381 }
12382
12383 return p;
12384}
12385
11c1ff18 12386static int
60bca95a
NC		 12387process_attributes (FILE * file,
12388 const char * public_name,
104d59d1 12389 unsigned int proc_type,
f6f0e17b
NC		 12390 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12391 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 12392{
2cf0635d
NC		 12393 Elf_Internal_Shdr * sect;
12394 unsigned char * contents;
12395 unsigned char * p;
12396 unsigned char * end;
11c1ff18
PB		 12397 bfd_vma section_len;
12398 bfd_vma len;
12399 unsigned i;
12400
12401 /* Find the section header so that we get the size. */
12402 for (i = 0, sect = section_headers;
12403 i < elf_header.e_shnum;
12404 i++, sect++)
12405 {
104d59d1 12406 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 12407 continue;
12408
3f5e193b
NC		 12409 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12410 sect->sh_size, _("attributes"));
60bca95a 12411 if (contents == NULL)
11c1ff18 12412 continue;
60bca95a 12413
11c1ff18
PB		 12414 p = contents;
12415 if (*p == 'A')
12416 {
12417 len = sect->sh_size - 1;
12418 p++;
60bca95a 12419
11c1ff18
PB		 12420 while (len > 0)
12421 {
12422 int namelen;
12423 bfd_boolean public_section;
104d59d1 12424 bfd_boolean gnu_section;
11c1ff18
PB		 12425
12426 section_len = byte_get (p, 4);
12427 p += 4;
60bca95a 12428
11c1ff18
PB		 12429 if (section_len > len)
12430 {
12431 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 12432 (int) section_len, (int) len);
11c1ff18
PB		 12433 section_len = len;
12434 }
60bca95a 12435
11c1ff18 12436 len -= section_len;
2b692964 12437 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 12438
12439 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 12440 public_section = TRUE;
12441 else
12442 public_section = FALSE;
60bca95a
NC		 12443
12444 if (streq ((char *) p, "gnu"))
104d59d1
JM		 12445 gnu_section = TRUE;
12446 else
12447 gnu_section = FALSE;
60bca95a
NC		 12448
12449 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 12450 p += namelen;
12451 section_len -= namelen + 4;
60bca95a 12452
11c1ff18
PB		 12453 while (section_len > 0)
12454 {
12455 int tag = *(p++);
12456 int val;
12457 bfd_vma size;
60bca95a 12458
11c1ff18
PB		 12459 size = byte_get (p, 4);
12460 if (size > section_len)
12461 {
12462 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 12463 (int) size, (int) section_len);
11c1ff18
PB		 12464 size = section_len;
12465 }
60bca95a 12466
11c1ff18
PB		 12467 section_len -= size;
12468 end = p + size - 1;
12469 p += 4;
60bca95a 12470
11c1ff18
PB		 12471 switch (tag)
12472 {
12473 case 1:
2b692964 12474 printf (_("File Attributes\n"));
11c1ff18
PB		 12475 break;
12476 case 2:
2b692964 12477 printf (_("Section Attributes:"));
11c1ff18
PB		 12478 goto do_numlist;
12479 case 3:
2b692964 12480 printf (_("Symbol Attributes:"));
11c1ff18
PB		 12481 do_numlist:
12482 for (;;)
12483 {
91d6fa6a 12484 unsigned int j;
60bca95a 12485
f6f0e17b 12486 val = read_uleb128 (p, &j, end);
91d6fa6a 12487 p += j;
11c1ff18
PB		 12488 if (val == 0)
12489 break;
12490 printf (" %d", val);
12491 }
12492 printf ("\n");
12493 break;
12494 default:
2b692964 12495 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 12496 public_section = FALSE;
12497 break;
12498 }
60bca95a 12499
11c1ff18
PB		 12500 if (public_section)
12501 {
12502 while (p < end)
f6f0e17b 12503 p = display_pub_attribute (p, end);
104d59d1
JM		 12504 }
12505 else if (gnu_section)
12506 {
12507 while (p < end)
12508 p = display_gnu_attribute (p,
f6f0e17b
NC		 12509 display_proc_gnu_attribute,
12510 end);
11c1ff18
PB		 12511 }
12512 else
12513 {
2b692964 12514 printf (_(" Unknown section contexts\n"));
f6f0e17b 12515 display_raw_attribute (p, end);
11c1ff18
PB		 12516 p = end;
12517 }
12518 }
12519 }
12520 }
12521 else
60bca95a 12522 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 12523
60bca95a 12524 free (contents);
11c1ff18
PB		 12525 }
12526 return 1;
12527}
12528
104d59d1 12529static int
2cf0635d 12530process_arm_specific (FILE * file)
104d59d1
JM		 12531{
12532 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12533 display_arm_attribute, NULL);
12534}
12535
34c8bcba 12536static int
2cf0635d 12537process_power_specific (FILE * file)
34c8bcba
JM		 12538{
12539 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12540 display_power_gnu_attribute);
12541}
12542
9e8c70f9
DM		 12543static int
12544process_sparc_specific (FILE * file)
12545{
12546 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12547 display_sparc_gnu_attribute);
12548}
12549
59e6276b
JM		 12550static int
12551process_tic6x_specific (FILE * file)
12552{
12553 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12554 display_tic6x_attribute, NULL);
12555}
12556
13761a11
NC		 12557static int
12558process_msp430x_specific (FILE * file)
12559{
12560 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12561 display_msp430x_attribute, NULL);
12562}
12563
ccb4c951
RS		 12564/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12565 Print the Address, Access and Initial fields of an entry at VMA ADDR
12566 and return the VMA of the next entry. */
12567
12568static bfd_vma
2cf0635d 12569print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 12570{
12571 printf (" ");
12572 print_vma (addr, LONG_HEX);
12573 printf (" ");
12574 if (addr < pltgot + 0xfff0)
12575 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12576 else
12577 printf ("%10s", "");
12578 printf (" ");
12579 if (data == NULL)
2b692964 12580 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 12581 else
12582 {
12583 bfd_vma entry;
12584
12585 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12586 print_vma (entry, LONG_HEX);
12587 }
12588 return addr + (is_32bit_elf ? 4 : 8);
12589}
12590
861fb55a
DJ		 12591/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12592 PLTGOT. Print the Address and Initial fields of an entry at VMA
12593 ADDR and return the VMA of the next entry. */
12594
12595static bfd_vma
2cf0635d 12596print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 12597{
12598 printf (" ");
12599 print_vma (addr, LONG_HEX);
12600 printf (" ");
12601 if (data == NULL)
2b692964 12602 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 12603 else
12604 {
12605 bfd_vma entry;
12606
12607 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12608 print_vma (entry, LONG_HEX);
12609 }
12610 return addr + (is_32bit_elf ? 4 : 8);
12611}
12612
19e6b90e 12613static int
2cf0635d 12614process_mips_specific (FILE * file)
5b18a4bc 12615{
2cf0635d 12616 Elf_Internal_Dyn * entry;
19e6b90e
L		 12617 size_t liblist_offset = 0;
12618 size_t liblistno = 0;
12619 size_t conflictsno = 0;
12620 size_t options_offset = 0;
12621 size_t conflicts_offset = 0;
861fb55a
DJ		 12622 size_t pltrelsz = 0;
12623 size_t pltrel = 0;
ccb4c951 12624 bfd_vma pltgot = 0;
861fb55a
DJ		 12625 bfd_vma mips_pltgot = 0;
12626 bfd_vma jmprel = 0;
ccb4c951
RS		 12627 bfd_vma local_gotno = 0;
12628 bfd_vma gotsym = 0;
12629 bfd_vma symtabno = 0;
103f02d3 12630
2cf19d5c
JM		 12631 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12632 display_mips_gnu_attribute);
12633
19e6b90e
L		 12634 /* We have a lot of special sections. Thanks SGI! */
12635 if (dynamic_section == NULL)
12636 /* No information available. */
12637 return 0;
252b5132 12638
b2d38a17 12639 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 12640 switch (entry->d_tag)
12641 {
12642 case DT_MIPS_LIBLIST:
d93f0186
NC		 12643 liblist_offset
12644 = offset_from_vma (file, entry->d_un.d_val,
12645 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 12646 break;
12647 case DT_MIPS_LIBLISTNO:
12648 liblistno = entry->d_un.d_val;
12649 break;
12650 case DT_MIPS_OPTIONS:
d93f0186 12651 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 12652 break;
12653 case DT_MIPS_CONFLICT:
d93f0186
NC		 12654 conflicts_offset
12655 = offset_from_vma (file, entry->d_un.d_val,
12656 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 12657 break;
12658 case DT_MIPS_CONFLICTNO:
12659 conflictsno = entry->d_un.d_val;
12660 break;
ccb4c951 12661 case DT_PLTGOT:
861fb55a
DJ		 12662 pltgot = entry->d_un.d_ptr;
12663 break;
ccb4c951
RS		 12664 case DT_MIPS_LOCAL_GOTNO:
12665 local_gotno = entry->d_un.d_val;
12666 break;
12667 case DT_MIPS_GOTSYM:
12668 gotsym = entry->d_un.d_val;
12669 break;
12670 case DT_MIPS_SYMTABNO:
12671 symtabno = entry->d_un.d_val;
12672 break;
861fb55a
DJ		 12673 case DT_MIPS_PLTGOT:
12674 mips_pltgot = entry->d_un.d_ptr;
12675 break;
12676 case DT_PLTREL:
12677 pltrel = entry->d_un.d_val;
12678 break;
12679 case DT_PLTRELSZ:
12680 pltrelsz = entry->d_un.d_val;
12681 break;
12682 case DT_JMPREL:
12683 jmprel = entry->d_un.d_ptr;
12684 break;
252b5132
RH		 12685 default:
12686 break;
12687 }
12688
12689 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12690 {
2cf0635d 12691 Elf32_External_Lib * elib;
252b5132
RH		 12692 size_t cnt;
12693
3f5e193b
NC		 12694 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12695 liblistno,
12696 sizeof (Elf32_External_Lib),
9cf03b7e 12697 _("liblist section data"));
a6e9f9df 12698 if (elib)
252b5132 12699 {
2b692964 12700 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 12701 (unsigned long) liblistno);
2b692964 12702 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 12703 stdout);
12704
12705 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 12706 {
a6e9f9df 12707 Elf32_Lib liblist;
91d6fa6a 12708 time_t atime;
a6e9f9df 12709 char timebuf[20];
2cf0635d 12710 struct tm * tmp;
a6e9f9df
AM		 12711
12712 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12713 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 12714 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12715 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12716 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12717
91d6fa6a 12718 tmp = gmtime (&atime);
e9e44622
JJ		 12719 snprintf (timebuf, sizeof (timebuf),
12720 "%04u-%02u-%02uT%02u:%02u:%02u",
12721 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12722 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 12723
31104126 12724 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 12725 if (VALID_DYNAMIC_NAME (liblist.l_name))
12726 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12727 else
2b692964 12728 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 12729 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12730 liblist.l_version);
a6e9f9df
AM		 12731
12732 if (liblist.l_flags == 0)
2b692964 12733 puts (_(" NONE"));
a6e9f9df
AM		 12734 else
12735 {
12736 static const struct
252b5132 12737 {
2cf0635d 12738 const char * name;
a6e9f9df 12739 int bit;
252b5132 12740 }
a6e9f9df
AM		 12741 l_flags_vals[] =
12742 {
12743 { " EXACT_MATCH", LL_EXACT_MATCH },
12744 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12745 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12746 { " EXPORTS", LL_EXPORTS },
12747 { " DELAY_LOAD", LL_DELAY_LOAD },
12748 { " DELTA", LL_DELTA }
12749 };
12750 int flags = liblist.l_flags;
12751 size_t fcnt;
12752
60bca95a 12753 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12754 if ((flags & l_flags_vals[fcnt].bit) != 0)
12755 {
12756 fputs (l_flags_vals[fcnt].name, stdout);
12757 flags ^= l_flags_vals[fcnt].bit;
12758 }
12759 if (flags != 0)
12760 printf (" %#x", (unsigned int) flags);
252b5132 12761
a6e9f9df
AM		 12762 puts ("");
12763 }
252b5132 12764 }
252b5132 12765
a6e9f9df
AM		 12766 free (elib);
12767 }
252b5132
RH		 12768 }
12769
12770 if (options_offset != 0)
12771 {
2cf0635d
NC		 12772 Elf_External_Options * eopt;
12773 Elf_Internal_Shdr * sect = section_headers;
12774 Elf_Internal_Options * iopt;
12775 Elf_Internal_Options * option;
252b5132
RH		 12776 size_t offset;
12777 int cnt;
12778
12779 /* Find the section header so that we get the size. */
12780 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12781 ++sect;
252b5132 12782
3f5e193b
NC		 12783 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12784 sect->sh_size, _("options"));
a6e9f9df 12785 if (eopt)
252b5132 12786 {
3f5e193b
NC		 12787 iopt = (Elf_Internal_Options *)
12788 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 12789 if (iopt == NULL)
12790 {
591a748a 12791 error (_("Out of memory\n"));
a6e9f9df
AM		 12792 return 0;
12793 }
76da6bbe 12794
a6e9f9df
AM		 12795 offset = cnt = 0;
12796 option = iopt;
252b5132 12797
a6e9f9df
AM		 12798 while (offset < sect->sh_size)
12799 {
2cf0635d 12800 Elf_External_Options * eoption;
252b5132 12801
a6e9f9df 12802 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12803
a6e9f9df
AM		 12804 option->kind = BYTE_GET (eoption->kind);
12805 option->size = BYTE_GET (eoption->size);
12806 option->section = BYTE_GET (eoption->section);
12807 option->info = BYTE_GET (eoption->info);
76da6bbe 12808
a6e9f9df 12809 offset += option->size;
252b5132 12810
a6e9f9df
AM		 12811 ++option;
12812 ++cnt;
12813 }
252b5132 12814
a6e9f9df
AM		 12815 printf (_("\nSection '%s' contains %d entries:\n"),
12816 SECTION_NAME (sect), cnt);
76da6bbe 12817
a6e9f9df 12818 option = iopt;
252b5132 12819
a6e9f9df 12820 while (cnt-- > 0)
252b5132 12821 {
a6e9f9df
AM		 12822 size_t len;
12823
12824 switch (option->kind)
252b5132 12825 {
a6e9f9df
AM		 12826 case ODK_NULL:
12827 /* This shouldn't happen. */
12828 printf (" NULL %d %lx", option->section, option->info);
12829 break;
12830 case ODK_REGINFO:
12831 printf (" REGINFO ");
12832 if (elf_header.e_machine == EM_MIPS)
12833 {
12834 /* 32bit form. */
2cf0635d 12835 Elf32_External_RegInfo * ereg;
b34976b6 12836 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12837
12838 ereg = (Elf32_External_RegInfo *) (option + 1);
12839 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12840 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12841 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12842 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12843 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12844 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12845
12846 printf ("GPR %08lx GP 0x%lx\n",
12847 reginfo.ri_gprmask,
12848 (unsigned long) reginfo.ri_gp_value);
12849 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12850 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12851 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12852 }
12853 else
12854 {
12855 /* 64 bit form. */
2cf0635d 12856 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12857 Elf64_Internal_RegInfo reginfo;
12858
12859 ereg = (Elf64_External_RegInfo *) (option + 1);
12860 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12861 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12862 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12863 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12864 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12865 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12866
12867 printf ("GPR %08lx GP 0x",
12868 reginfo.ri_gprmask);
12869 printf_vma (reginfo.ri_gp_value);
12870 printf ("\n");
12871
12872 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12873 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12874 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12875 }
12876 ++option;
12877 continue;
12878 case ODK_EXCEPTIONS:
12879 fputs (" EXCEPTIONS fpe_min(", stdout);
12880 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12881 fputs (") fpe_max(", stdout);
12882 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12883 fputs (")", stdout);
12884
12885 if (option->info & OEX_PAGE0)
12886 fputs (" PAGE0", stdout);
12887 if (option->info & OEX_SMM)
12888 fputs (" SMM", stdout);
12889 if (option->info & OEX_FPDBUG)
12890 fputs (" FPDBUG", stdout);
12891 if (option->info & OEX_DISMISS)
12892 fputs (" DISMISS", stdout);
12893 break;
12894 case ODK_PAD:
12895 fputs (" PAD ", stdout);
12896 if (option->info & OPAD_PREFIX)
12897 fputs (" PREFIX", stdout);
12898 if (option->info & OPAD_POSTFIX)
12899 fputs (" POSTFIX", stdout);
12900 if (option->info & OPAD_SYMBOL)
12901 fputs (" SYMBOL", stdout);
12902 break;
12903 case ODK_HWPATCH:
12904 fputs (" HWPATCH ", stdout);
12905 if (option->info & OHW_R4KEOP)
12906 fputs (" R4KEOP", stdout);
12907 if (option->info & OHW_R8KPFETCH)
12908 fputs (" R8KPFETCH", stdout);
12909 if (option->info & OHW_R5KEOP)
12910 fputs (" R5KEOP", stdout);
12911 if (option->info & OHW_R5KCVTL)
12912 fputs (" R5KCVTL", stdout);
12913 break;
12914 case ODK_FILL:
12915 fputs (" FILL ", stdout);
12916 /* XXX Print content of info word? */
12917 break;
12918 case ODK_TAGS:
12919 fputs (" TAGS ", stdout);
12920 /* XXX Print content of info word? */
12921 break;
12922 case ODK_HWAND:
12923 fputs (" HWAND ", stdout);
12924 if (option->info & OHWA0_R4KEOP_CHECKED)
12925 fputs (" R4KEOP_CHECKED", stdout);
12926 if (option->info & OHWA0_R4KEOP_CLEAN)
12927 fputs (" R4KEOP_CLEAN", stdout);
12928 break;
12929 case ODK_HWOR:
12930 fputs (" HWOR ", stdout);
12931 if (option->info & OHWA0_R4KEOP_CHECKED)
12932 fputs (" R4KEOP_CHECKED", stdout);
12933 if (option->info & OHWA0_R4KEOP_CLEAN)
12934 fputs (" R4KEOP_CLEAN", stdout);
12935 break;
12936 case ODK_GP_GROUP:
12937 printf (" GP_GROUP %#06lx self-contained %#06lx",
12938 option->info & OGP_GROUP,
12939 (option->info & OGP_SELF) >> 16);
12940 break;
12941 case ODK_IDENT:
12942 printf (" IDENT %#06lx self-contained %#06lx",
12943 option->info & OGP_GROUP,
12944 (option->info & OGP_SELF) >> 16);
12945 break;
12946 default:
12947 /* This shouldn't happen. */
12948 printf (" %3d ??? %d %lx",
12949 option->kind, option->section, option->info);
12950 break;
252b5132 12951 }
a6e9f9df 12952
2cf0635d 12953 len = sizeof (* eopt);
a6e9f9df
AM		 12954 while (len < option->size)
12955 if (((char *) option)[len] >= ' '
12956 && ((char *) option)[len] < 0x7f)
12957 printf ("%c", ((char *) option)[len++]);
12958 else
12959 printf ("\\%03o", ((char *) option)[len++]);
12960
12961 fputs ("\n", stdout);
252b5132 12962 ++option;
252b5132
RH		 12963 }
12964
a6e9f9df 12965 free (eopt);
252b5132 12966 }
252b5132
RH		 12967 }
12968
12969 if (conflicts_offset != 0 && conflictsno != 0)
12970 {
2cf0635d 12971 Elf32_Conflict * iconf;
252b5132
RH		 12972 size_t cnt;
12973
12974 if (dynamic_symbols == NULL)
12975 {
591a748a 12976 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12977 return 0;
12978 }
12979
3f5e193b 12980 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12981 if (iconf == NULL)
12982 {
591a748a 12983 error (_("Out of memory\n"));
252b5132
RH		 12984 return 0;
12985 }
12986
9ea033b2 12987 if (is_32bit_elf)
252b5132 12988 {
2cf0635d 12989 Elf32_External_Conflict * econf32;
a6e9f9df 12990
3f5e193b
NC		 12991 econf32 = (Elf32_External_Conflict *)
12992 get_data (NULL, file, conflicts_offset, conflictsno,
12993 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12994 if (!econf32)
12995 return 0;
252b5132
RH		 12996
12997 for (cnt = 0; cnt < conflictsno; ++cnt)
12998 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12999
13000 free (econf32);
252b5132
RH		 13001 }
13002 else
13003 {
2cf0635d 13004 Elf64_External_Conflict * econf64;
a6e9f9df 13005
3f5e193b
NC		 13006 econf64 = (Elf64_External_Conflict *)
13007 get_data (NULL, file, conflicts_offset, conflictsno,
13008 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 13009 if (!econf64)
13010 return 0;
252b5132
RH		 13011
13012 for (cnt = 0; cnt < conflictsno; ++cnt)
13013 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 13014
13015 free (econf64);
252b5132
RH		 13016 }
13017
c7e7ca54
NC		 13018 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13019 (unsigned long) conflictsno);
252b5132
RH		 13020 puts (_(" Num: Index Value Name"));
13021
13022 for (cnt = 0; cnt < conflictsno; ++cnt)
13023 {
2cf0635d 13024 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 13025
b34976b6 13026 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 13027 print_vma (psym->st_value, FULL_HEX);
31104126 13028 putchar (' ');
d79b3d50
NC		 13029 if (VALID_DYNAMIC_NAME (psym->st_name))
13030 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13031 else
2b692964 13032 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 13033 putchar ('\n');
252b5132
RH		 13034 }
13035
252b5132
RH		 13036 free (iconf);
13037 }
13038
ccb4c951
RS		 13039 if (pltgot != 0 && local_gotno != 0)
13040 {
91d6fa6a 13041 bfd_vma ent, local_end, global_end;
bbeee7ea 13042 size_t i, offset;
2cf0635d 13043 unsigned char * data;
bbeee7ea 13044 int addr_size;
ccb4c951 13045
91d6fa6a 13046 ent = pltgot;
ccb4c951
RS		 13047 addr_size = (is_32bit_elf ? 4 : 8);
13048 local_end = pltgot + local_gotno * addr_size;
13049 global_end = local_end + (symtabno - gotsym) * addr_size;
13050
13051 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 13052 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 13053 global_end - pltgot, 1,
13054 _("Global Offset Table data"));
59245841
NC		 13055 if (data == NULL)
13056 return 0;
13057
ccb4c951
RS		 13058 printf (_("\nPrimary GOT:\n"));
13059 printf (_(" Canonical gp value: "));
13060 print_vma (pltgot + 0x7ff0, LONG_HEX);
13061 printf ("\n\n");
13062
13063 printf (_(" Reserved entries:\n"));
13064 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 13065 addr_size * 2, _("Address"), _("Access"),
13066 addr_size * 2, _("Initial"));
91d6fa6a 13067 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13068 printf (_(" Lazy resolver\n"));
ccb4c951 13069 if (data
91d6fa6a 13070 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 13071 >> (addr_size * 8 - 1)) != 0)
13072 {
91d6fa6a 13073 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13074 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 13075 }
13076 printf ("\n");
13077
91d6fa6a 13078 if (ent < local_end)
ccb4c951
RS		 13079 {
13080 printf (_(" Local entries:\n"));
cc5914eb 13081 printf (" %*s %10s %*s\n",
2b692964
NC		 13082 addr_size * 2, _("Address"), _("Access"),
13083 addr_size * 2, _("Initial"));
91d6fa6a 13084 while (ent < local_end)
ccb4c951 13085 {
91d6fa6a 13086 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 13087 printf ("\n");
13088 }
13089 printf ("\n");
13090 }
13091
13092 if (gotsym < symtabno)
13093 {
13094 int sym_width;
13095
13096 printf (_(" Global entries:\n"));
cc5914eb 13097 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 13098 addr_size * 2, _("Address"),
13099 _("Access"),
2b692964 13100 addr_size * 2, _("Initial"),
9cf03b7e
NC		 13101 addr_size * 2, _("Sym.Val."),
13102 _("Type"),
13103 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13104 _("Ndx"), _("Name"));
0b4362b0 13105
ccb4c951
RS		 13106 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13107 for (i = gotsym; i < symtabno; i++)
13108 {
2cf0635d 13109 Elf_Internal_Sym * psym;
ccb4c951
RS		 13110
13111 psym = dynamic_symbols + i;
91d6fa6a 13112 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 13113 printf (" ");
13114 print_vma (psym->st_value, LONG_HEX);
13115 printf (" %-7s %3s ",
13116 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13117 get_symbol_index_type (psym->st_shndx));
13118 if (VALID_DYNAMIC_NAME (psym->st_name))
13119 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13120 else
2b692964 13121 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 13122 printf ("\n");
13123 }
13124 printf ("\n");
13125 }
13126
13127 if (data)
13128 free (data);
13129 }
13130
861fb55a
DJ		 13131 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13132 {
91d6fa6a 13133 bfd_vma ent, end;
861fb55a
DJ		 13134 size_t offset, rel_offset;
13135 unsigned long count, i;
2cf0635d 13136 unsigned char * data;
861fb55a 13137 int addr_size, sym_width;
2cf0635d 13138 Elf_Internal_Rela * rels;
861fb55a
DJ		 13139
13140 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13141 if (pltrel == DT_RELA)
13142 {
13143 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13144 return 0;
13145 }
13146 else
13147 {
13148 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13149 return 0;
13150 }
13151
91d6fa6a 13152 ent = mips_pltgot;
861fb55a
DJ		 13153 addr_size = (is_32bit_elf ? 4 : 8);
13154 end = mips_pltgot + (2 + count) * addr_size;
13155
13156 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 13157 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 13158 1, _("Procedure Linkage Table data"));
59245841
NC		 13159 if (data == NULL)
13160 return 0;
13161
9cf03b7e 13162 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 13163 printf (_(" Reserved entries:\n"));
13164 printf (_(" %*s %*s Purpose\n"),
2b692964 13165 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 13166 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 13167 printf (_(" PLT lazy resolver\n"));
91d6fa6a 13168 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 13169 printf (_(" Module pointer\n"));
861fb55a
DJ		 13170 printf ("\n");
13171
13172 printf (_(" Entries:\n"));
cc5914eb 13173 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 13174 addr_size * 2, _("Address"),
13175 addr_size * 2, _("Initial"),
13176 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 13177 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13178 for (i = 0; i < count; i++)
13179 {
2cf0635d 13180 Elf_Internal_Sym * psym;
861fb55a
DJ		 13181
13182 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 13183 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 13184 printf (" ");
13185 print_vma (psym->st_value, LONG_HEX);
13186 printf (" %-7s %3s ",
13187 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13188 get_symbol_index_type (psym->st_shndx));
13189 if (VALID_DYNAMIC_NAME (psym->st_name))
13190 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13191 else
2b692964 13192 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 13193 printf ("\n");
13194 }
13195 printf ("\n");
13196
13197 if (data)
13198 free (data);
13199 free (rels);
13200 }
13201
252b5132
RH		 13202 return 1;
13203}
13204
35c08157
KLC		 13205static int
13206process_nds32_specific (FILE * file)
13207{
13208 Elf_Internal_Shdr *sect = NULL;
13209
13210 sect = find_section (".nds32_e_flags");
13211 if (sect != NULL)
13212 {
13213 unsigned int *flag;
13214
13215 printf ("\nNDS32 elf flags section:\n");
13216 flag = get_data (NULL, file, sect->sh_offset, 1,
13217 sect->sh_size, _("NDS32 elf flags section"));
13218
13219 switch ((*flag) & 0x3)
13220 {
13221 case 0:
13222 printf ("(VEC_SIZE):\tNo entry.\n");
13223 break;
13224 case 1:
13225 printf ("(VEC_SIZE):\t4 bytes\n");
13226 break;
13227 case 2:
13228 printf ("(VEC_SIZE):\t16 bytes\n");
13229 break;
13230 case 3:
13231 printf ("(VEC_SIZE):\treserved\n");
13232 break;
13233 }
13234 }
13235
13236 return TRUE;
13237}
13238
047b2264 13239static int
2cf0635d 13240process_gnu_liblist (FILE * file)
047b2264 13241{
2cf0635d
NC		 13242 Elf_Internal_Shdr * section;
13243 Elf_Internal_Shdr * string_sec;
13244 Elf32_External_Lib * elib;
13245 char * strtab;
c256ffe7 13246 size_t strtab_size;
047b2264
JJ		 13247 size_t cnt;
13248 unsigned i;
13249
13250 if (! do_arch)
13251 return 0;
13252
13253 for (i = 0, section = section_headers;
13254 i < elf_header.e_shnum;
b34976b6 13255 i++, section++)
047b2264
JJ		 13256 {
13257 switch (section->sh_type)
13258 {
13259 case SHT_GNU_LIBLIST:
4fbb74a6 13260 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 13261 break;
13262
3f5e193b
NC		 13263 elib = (Elf32_External_Lib *)
13264 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 13265 _("liblist section data"));
047b2264
JJ		 13266
13267 if (elib == NULL)
13268 break;
4fbb74a6 13269 string_sec = section_headers + section->sh_link;
047b2264 13270
3f5e193b
NC		 13271 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13272 string_sec->sh_size,
13273 _("liblist string table"));
047b2264
JJ		 13274 if (strtab == NULL
13275 || section->sh_entsize != sizeof (Elf32_External_Lib))
13276 {
13277 free (elib);
2842702f 13278 free (strtab);
047b2264
JJ		 13279 break;
13280 }
59245841 13281 strtab_size = string_sec->sh_size;
047b2264
JJ		 13282
13283 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13284 SECTION_NAME (section),
0af1713e 13285 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 13286
2b692964 13287 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 13288
13289 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13290 ++cnt)
13291 {
13292 Elf32_Lib liblist;
91d6fa6a 13293 time_t atime;
047b2264 13294 char timebuf[20];
2cf0635d 13295 struct tm * tmp;
047b2264
JJ		 13296
13297 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13298 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 13299 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13300 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13301 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13302
91d6fa6a 13303 tmp = gmtime (&atime);
e9e44622
JJ		 13304 snprintf (timebuf, sizeof (timebuf),
13305 "%04u-%02u-%02uT%02u:%02u:%02u",
13306 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13307 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 13308
13309 printf ("%3lu: ", (unsigned long) cnt);
13310 if (do_wide)
c256ffe7 13311 printf ("%-20s", liblist.l_name < strtab_size
2b692964 13312 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 13313 else
c256ffe7 13314 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 13315 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 13316 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13317 liblist.l_version, liblist.l_flags);
13318 }
13319
13320 free (elib);
2842702f 13321 free (strtab);
047b2264
JJ		 13322 }
13323 }
13324
13325 return 1;
13326}
13327
9437c45b 13328static const char *
d3ba0551 13329get_note_type (unsigned e_type)
779fe533
NC		 13330{
13331 static char buff[64];
103f02d3 13332
1ec5cd37
NC		 13333 if (elf_header.e_type == ET_CORE)
13334 switch (e_type)
13335 {
57346661 13336 case NT_AUXV:
1ec5cd37 13337 return _("NT_AUXV (auxiliary vector)");
57346661 13338 case NT_PRSTATUS:
1ec5cd37 13339 return _("NT_PRSTATUS (prstatus structure)");
57346661 13340 case NT_FPREGSET:
1ec5cd37 13341 return _("NT_FPREGSET (floating point registers)");
57346661 13342 case NT_PRPSINFO:
1ec5cd37 13343 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 13344 case NT_TASKSTRUCT:
1ec5cd37 13345 return _("NT_TASKSTRUCT (task structure)");
57346661 13346 case NT_PRXFPREG:
1ec5cd37 13347 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 13348 case NT_PPC_VMX:
13349 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 13350 case NT_PPC_VSX:
13351 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 13352 case NT_386_TLS:
13353 return _("NT_386_TLS (x86 TLS information)");
13354 case NT_386_IOPERM:
13355 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 13356 case NT_X86_XSTATE:
13357 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 13358 case NT_S390_HIGH_GPRS:
13359 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 13360 case NT_S390_TIMER:
13361 return _("NT_S390_TIMER (s390 timer register)");
13362 case NT_S390_TODCMP:
13363 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13364 case NT_S390_TODPREG:
13365 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13366 case NT_S390_CTRS:
13367 return _("NT_S390_CTRS (s390 control registers)");
13368 case NT_S390_PREFIX:
13369 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 13370 case NT_S390_LAST_BREAK:
13371 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13372 case NT_S390_SYSTEM_CALL:
13373 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 13374 case NT_S390_TDB:
13375 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW		 13376 case NT_ARM_VFP:
13377 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 13378 case NT_ARM_TLS:
13379 return _("NT_ARM_TLS (AArch TLS registers)");
13380 case NT_ARM_HW_BREAK:
13381 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13382 case NT_ARM_HW_WATCH:
13383 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 13384 case NT_PSTATUS:
1ec5cd37 13385 return _("NT_PSTATUS (pstatus structure)");
57346661 13386 case NT_FPREGS:
1ec5cd37 13387 return _("NT_FPREGS (floating point registers)");
57346661 13388 case NT_PSINFO:
1ec5cd37 13389 return _("NT_PSINFO (psinfo structure)");
57346661 13390 case NT_LWPSTATUS:
1ec5cd37 13391 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 13392 case NT_LWPSINFO:
1ec5cd37 13393 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 13394 case NT_WIN32PSTATUS:
1ec5cd37 13395 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 13396 case NT_SIGINFO:
13397 return _("NT_SIGINFO (siginfo_t data)");
13398 case NT_FILE:
13399 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 13400 default:
13401 break;
13402 }
13403 else
13404 switch (e_type)
13405 {
13406 case NT_VERSION:
13407 return _("NT_VERSION (version)");
13408 case NT_ARCH:
13409 return _("NT_ARCH (architecture)");
13410 default:
13411 break;
13412 }
13413
e9e44622 13414 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 13415 return buff;
779fe533
NC		 13416}
13417
9ece1fa9
TT		 13418static int
13419print_core_note (Elf_Internal_Note *pnote)
13420{
13421 unsigned int addr_size = is_32bit_elf ? 4 : 8;
13422 bfd_vma count, page_size;
13423 unsigned char *descdata, *filenames, *descend;
13424
13425 if (pnote->type != NT_FILE)
13426 return 1;
13427
13428#ifndef BFD64
13429 if (!is_32bit_elf)
13430 {
13431 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13432 /* Still "successful". */
13433 return 1;
13434 }
13435#endif
13436
13437 if (pnote->descsz < 2 * addr_size)
13438 {
13439 printf (_(" Malformed note - too short for header\n"));
13440 return 0;
13441 }
13442
13443 descdata = (unsigned char *) pnote->descdata;
13444 descend = descdata + pnote->descsz;
13445
13446 if (descdata[pnote->descsz - 1] != '\0')
13447 {
13448 printf (_(" Malformed note - does not end with \\0\n"));
13449 return 0;
13450 }
13451
13452 count = byte_get (descdata, addr_size);
13453 descdata += addr_size;
13454
13455 page_size = byte_get (descdata, addr_size);
13456 descdata += addr_size;
13457
13458 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13459 {
13460 printf (_(" Malformed note - too short for supplied file count\n"));
13461 return 0;
13462 }
13463
13464 printf (_(" Page size: "));
13465 print_vma (page_size, DEC);
13466 printf ("\n");
13467
13468 printf (_(" %*s%*s%*s\n"),
13469 (int) (2 + 2 * addr_size), _("Start"),
13470 (int) (4 + 2 * addr_size), _("End"),
13471 (int) (4 + 2 * addr_size), _("Page Offset"));
13472 filenames = descdata + count * 3 * addr_size;
13473 while (--count > 0)
13474 {
13475 bfd_vma start, end, file_ofs;
13476
13477 if (filenames == descend)
13478 {
13479 printf (_(" Malformed note - filenames end too early\n"));
13480 return 0;
13481 }
13482
13483 start = byte_get (descdata, addr_size);
13484 descdata += addr_size;
13485 end = byte_get (descdata, addr_size);
13486 descdata += addr_size;
13487 file_ofs = byte_get (descdata, addr_size);
13488 descdata += addr_size;
13489
13490 printf (" ");
13491 print_vma (start, FULL_HEX);
13492 printf (" ");
13493 print_vma (end, FULL_HEX);
13494 printf (" ");
13495 print_vma (file_ofs, FULL_HEX);
13496 printf ("\n %s\n", filenames);
13497
13498 filenames += 1 + strlen ((char *) filenames);
13499 }
13500
13501 return 1;
13502}
13503
1118d252
RM		 13504static const char *
13505get_gnu_elf_note_type (unsigned e_type)
13506{
13507 static char buff[64];
13508
13509 switch (e_type)
13510 {
13511 case NT_GNU_ABI_TAG:
13512 return _("NT_GNU_ABI_TAG (ABI version tag)");
13513 case NT_GNU_HWCAP:
13514 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13515 case NT_GNU_BUILD_ID:
13516 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 13517 case NT_GNU_GOLD_VERSION:
13518 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 13519 default:
13520 break;
13521 }
13522
13523 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13524 return buff;
13525}
13526
664f90a3
TT		 13527static int
13528print_gnu_note (Elf_Internal_Note *pnote)
13529{
13530 switch (pnote->type)
13531 {
13532 case NT_GNU_BUILD_ID:
13533 {
13534 unsigned long i;
13535
13536 printf (_(" Build ID: "));
13537 for (i = 0; i < pnote->descsz; ++i)
13538 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 13539 printf ("\n");
664f90a3
TT		 13540 }
13541 break;
13542
13543 case NT_GNU_ABI_TAG:
13544 {
13545 unsigned long os, major, minor, subminor;
13546 const char *osname;
13547
13548 os = byte_get ((unsigned char *) pnote->descdata, 4);
13549 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13550 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13551 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13552
13553 switch (os)
13554 {
13555 case GNU_ABI_TAG_LINUX:
13556 osname = "Linux";
13557 break;
13558 case GNU_ABI_TAG_HURD:
13559 osname = "Hurd";
13560 break;
13561 case GNU_ABI_TAG_SOLARIS:
13562 osname = "Solaris";
13563 break;
13564 case GNU_ABI_TAG_FREEBSD:
13565 osname = "FreeBSD";
13566 break;
13567 case GNU_ABI_TAG_NETBSD:
13568 osname = "NetBSD";
13569 break;
13570 default:
13571 osname = "Unknown";
13572 break;
13573 }
13574
13575 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13576 major, minor, subminor);
13577 }
13578 break;
926c5385
CC		 13579
13580 case NT_GNU_GOLD_VERSION:
13581 {
13582 unsigned long i;
13583
13584 printf (_(" Version: "));
13585 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
13586 printf ("%c", pnote->descdata[i]);
13587 printf ("\n");
13588 }
13589 break;
664f90a3
TT		 13590 }
13591
13592 return 1;
13593}
13594
9437c45b 13595static const char *
d3ba0551 13596get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 13597{
13598 static char buff[64];
13599
b4db1224 13600 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 13601 {
13602 /* NetBSD core "procinfo" structure. */
13603 return _("NetBSD procinfo structure");
13604 }
13605
13606 /* As of Jan 2002 there are no other machine-independent notes
13607 defined for NetBSD core files. If the note type is less
13608 than the start of the machine-dependent note types, we don't
13609 understand it. */
13610
b4db1224 13611 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 13612 {
e9e44622 13613 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 13614 return buff;
13615 }
13616
13617 switch (elf_header.e_machine)
13618 {
13619 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13620 and PT_GETFPREGS == mach+2. */
13621
13622 case EM_OLD_ALPHA:
13623 case EM_ALPHA:
13624 case EM_SPARC:
13625 case EM_SPARC32PLUS:
13626 case EM_SPARCV9:
13627 switch (e_type)
13628 {
2b692964 13629 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 13630 return _("PT_GETREGS (reg structure)");
2b692964 13631 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 13632 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13633 default:
13634 break;
13635 }
13636 break;
13637
13638 /* On all other arch's, PT_GETREGS == mach+1 and
13639 PT_GETFPREGS == mach+3. */
13640 default:
13641 switch (e_type)
13642 {
2b692964 13643 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 13644 return _("PT_GETREGS (reg structure)");
2b692964 13645 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 13646 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13647 default:
13648 break;
13649 }
13650 }
13651
9cf03b7e 13652 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 13653 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 13654 return buff;
13655}
13656
70616151
TT		 13657static const char *
13658get_stapsdt_note_type (unsigned e_type)
13659{
13660 static char buff[64];
13661
13662 switch (e_type)
13663 {
13664 case NT_STAPSDT:
13665 return _("NT_STAPSDT (SystemTap probe descriptors)");
13666
13667 default:
13668 break;
13669 }
13670
13671 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13672 return buff;
13673}
13674
c6a9fc58
TT		 13675static int
13676print_stapsdt_note (Elf_Internal_Note *pnote)
13677{
13678 int addr_size = is_32bit_elf ? 4 : 8;
13679 char *data = pnote->descdata;
13680 char *data_end = pnote->descdata + pnote->descsz;
13681 bfd_vma pc, base_addr, semaphore;
13682 char *provider, *probe, *arg_fmt;
13683
13684 pc = byte_get ((unsigned char *) data, addr_size);
13685 data += addr_size;
13686 base_addr = byte_get ((unsigned char *) data, addr_size);
13687 data += addr_size;
13688 semaphore = byte_get ((unsigned char *) data, addr_size);
13689 data += addr_size;
13690
13691 provider = data;
13692 data += strlen (data) + 1;
13693 probe = data;
13694 data += strlen (data) + 1;
13695 arg_fmt = data;
13696 data += strlen (data) + 1;
13697
13698 printf (_(" Provider: %s\n"), provider);
13699 printf (_(" Name: %s\n"), probe);
13700 printf (_(" Location: "));
13701 print_vma (pc, FULL_HEX);
13702 printf (_(", Base: "));
13703 print_vma (base_addr, FULL_HEX);
13704 printf (_(", Semaphore: "));
13705 print_vma (semaphore, FULL_HEX);
9cf03b7e 13706 printf ("\n");
c6a9fc58
TT		 13707 printf (_(" Arguments: %s\n"), arg_fmt);
13708
13709 return data == data_end;
13710}
13711
00e98fc7
TG		 13712static const char *
13713get_ia64_vms_note_type (unsigned e_type)
13714{
13715 static char buff[64];
13716
13717 switch (e_type)
13718 {
13719 case NT_VMS_MHD:
13720 return _("NT_VMS_MHD (module header)");
13721 case NT_VMS_LNM:
13722 return _("NT_VMS_LNM (language name)");
13723 case NT_VMS_SRC:
13724 return _("NT_VMS_SRC (source files)");
13725 case NT_VMS_TITLE:
9cf03b7e 13726 return "NT_VMS_TITLE";
00e98fc7
TG		 13727 case NT_VMS_EIDC:
13728 return _("NT_VMS_EIDC (consistency check)");
13729 case NT_VMS_FPMODE:
13730 return _("NT_VMS_FPMODE (FP mode)");
13731 case NT_VMS_LINKTIME:
9cf03b7e 13732 return "NT_VMS_LINKTIME";
00e98fc7
TG		 13733 case NT_VMS_IMGNAM:
13734 return _("NT_VMS_IMGNAM (image name)");
13735 case NT_VMS_IMGID:
13736 return _("NT_VMS_IMGID (image id)");
13737 case NT_VMS_LINKID:
13738 return _("NT_VMS_LINKID (link id)");
13739 case NT_VMS_IMGBID:
13740 return _("NT_VMS_IMGBID (build id)");
13741 case NT_VMS_GSTNAM:
13742 return _("NT_VMS_GSTNAM (sym table name)");
13743 case NT_VMS_ORIG_DYN:
9cf03b7e 13744 return "NT_VMS_ORIG_DYN";
00e98fc7 13745 case NT_VMS_PATCHTIME:
9cf03b7e 13746 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 13747 default:
13748 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13749 return buff;
13750 }
13751}
13752
13753static int
13754print_ia64_vms_note (Elf_Internal_Note * pnote)
13755{
13756 switch (pnote->type)
13757 {
13758 case NT_VMS_MHD:
13759 if (pnote->descsz > 36)
13760 {
13761 size_t l = strlen (pnote->descdata + 34);
13762 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13763 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13764 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13765 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13766 }
13767 else
13768 printf (_(" Invalid size\n"));
13769 break;
13770 case NT_VMS_LNM:
13771 printf (_(" Language: %s\n"), pnote->descdata);
13772 break;
13773#ifdef BFD64
13774 case NT_VMS_FPMODE:
9cf03b7e 13775 printf (_(" Floating Point mode: "));
4a5cb34f 13776 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13777 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13778 break;
13779 case NT_VMS_LINKTIME:
13780 printf (_(" Link time: "));
13781 print_vms_time
13782 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13783 printf ("\n");
13784 break;
13785 case NT_VMS_PATCHTIME:
13786 printf (_(" Patch time: "));
13787 print_vms_time
13788 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13789 printf ("\n");
13790 break;
13791 case NT_VMS_ORIG_DYN:
13792 printf (_(" Major id: %u, minor id: %u\n"),
13793 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13794 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 13795 printf (_(" Last modified : "));
00e98fc7
TG		 13796 print_vms_time
13797 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 13798 printf (_("\n Link flags : "));
4a5cb34f 13799 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13800 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13801 printf (_(" Header flags: 0x%08x\n"),
13802 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13803 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13804 break;
13805#endif
13806 case NT_VMS_IMGNAM:
13807 printf (_(" Image name: %s\n"), pnote->descdata);
13808 break;
13809 case NT_VMS_GSTNAM:
13810 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13811 break;
13812 case NT_VMS_IMGID:
13813 printf (_(" Image id: %s\n"), pnote->descdata);
13814 break;
13815 case NT_VMS_LINKID:
13816 printf (_(" Linker id: %s\n"), pnote->descdata);
13817 break;
13818 default:
13819 break;
13820 }
13821 return 1;
13822}
13823
6d118b09
NC		 13824/* Note that by the ELF standard, the name field is already null byte
13825 terminated, and namesz includes the terminating null byte.
13826 I.E. the value of namesz for the name "FSF" is 4.
13827
e3c8793a 13828 If the value of namesz is zero, there is no name present. */
779fe533 13829static int
2cf0635d 13830process_note (Elf_Internal_Note * pnote)
779fe533 13831{
2cf0635d
NC		 13832 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13833 const char * nt;
9437c45b
JT		 13834
13835 if (pnote->namesz == 0)
1ec5cd37
NC		 13836 /* If there is no note name, then use the default set of
13837 note type strings. */
13838 nt = get_note_type (pnote->type);
13839
1118d252
RM		 13840 else if (const_strneq (pnote->namedata, "GNU"))
13841 /* GNU-specific object file notes. */
13842 nt = get_gnu_elf_note_type (pnote->type);
13843
0112cd26 13844 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 13845 /* NetBSD-specific core file notes. */
13846 nt = get_netbsd_elfcore_note_type (pnote->type);
13847
b15fa79e
AM		 13848 else if (strneq (pnote->namedata, "SPU/", 4))
13849 {
13850 /* SPU-specific core file notes. */
13851 nt = pnote->namedata + 4;
13852 name = "SPU";
13853 }
13854
00e98fc7
TG		 13855 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13856 /* VMS/ia64-specific file notes. */
13857 nt = get_ia64_vms_note_type (pnote->type);
13858
70616151
TT		 13859 else if (const_strneq (pnote->namedata, "stapsdt"))
13860 nt = get_stapsdt_note_type (pnote->type);
13861
9437c45b 13862 else
1ec5cd37
NC		 13863 /* Don't recognize this note name; just use the default set of
13864 note type strings. */
00e98fc7 13865 nt = get_note_type (pnote->type);
9437c45b 13866
2aee03ae 13867 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 13868
13869 if (const_strneq (pnote->namedata, "IPF/VMS"))
13870 return print_ia64_vms_note (pnote);
664f90a3
TT		 13871 else if (const_strneq (pnote->namedata, "GNU"))
13872 return print_gnu_note (pnote);
c6a9fc58
TT		 13873 else if (const_strneq (pnote->namedata, "stapsdt"))
13874 return print_stapsdt_note (pnote);
9ece1fa9
TT		 13875 else if (const_strneq (pnote->namedata, "CORE"))
13876 return print_core_note (pnote);
00e98fc7
TG		 13877 else
13878 return 1;
779fe533
NC		 13879}
13880
6d118b09 13881
779fe533 13882static int
2cf0635d 13883process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 13884{
2cf0635d
NC		 13885 Elf_External_Note * pnotes;
13886 Elf_External_Note * external;
b34976b6 13887 int res = 1;
103f02d3 13888
779fe533
NC		 13889 if (length <= 0)
13890 return 0;
103f02d3 13891
3f5e193b 13892 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 13893 _("notes"));
dd24e3da 13894 if (pnotes == NULL)
a6e9f9df 13895 return 0;
779fe533 13896
103f02d3 13897 external = pnotes;
103f02d3 13898
9dd3a467 13899 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13900 (unsigned long) offset, (unsigned long) length);
2aee03ae 13901 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13902
15b42fb0 13903 while ((char *) external < (char *) pnotes + length)
779fe533 13904 {
b34976b6 13905 Elf_Internal_Note inote;
15b42fb0
AM		 13906 size_t min_notesz;
13907 char *next;
2cf0635d 13908 char * temp = NULL;
15b42fb0 13909 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 13910
00e98fc7 13911 if (!is_ia64_vms ())
15b42fb0 13912 {
9dd3a467
NC		 13913 /* PR binutils/15191
13914 Make sure that there is enough data to read. */
15b42fb0
AM		 13915 min_notesz = offsetof (Elf_External_Note, name);
13916 if (data_remaining < min_notesz)
9dd3a467
NC		 13917 {
13918 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13919 (int) data_remaining);
13920 break;
13921 }
15b42fb0
AM		 13922 inote.type = BYTE_GET (external->type);
13923 inote.namesz = BYTE_GET (external->namesz);
13924 inote.namedata = external->name;
13925 inote.descsz = BYTE_GET (external->descsz);
13926 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13927 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13928 next = inote.descdata + align_power (inote.descsz, 2);
13929 }
00e98fc7 13930 else
15b42fb0
AM		 13931 {
13932 Elf64_External_VMS_Note *vms_external;
00e98fc7 13933
9dd3a467
NC		 13934 /* PR binutils/15191
13935 Make sure that there is enough data to read. */
15b42fb0
AM		 13936 min_notesz = offsetof (Elf64_External_VMS_Note, name);
13937 if (data_remaining < min_notesz)
9dd3a467
NC		 13938 {
13939 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13940 (int) data_remaining);
13941 break;
13942 }
3e55a963 13943
15b42fb0
AM		 13944 vms_external = (Elf64_External_VMS_Note *) external;
13945 inote.type = BYTE_GET (vms_external->type);
13946 inote.namesz = BYTE_GET (vms_external->namesz);
13947 inote.namedata = vms_external->name;
13948 inote.descsz = BYTE_GET (vms_external->descsz);
13949 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13950 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13951 next = inote.descdata + align_power (inote.descsz, 3);
13952 }
13953
13954 if (inote.descdata < (char *) external + min_notesz
13955 || next < (char *) external + min_notesz
13956 || data_remaining < (size_t)(next - (char *) external))
3e55a963 13957 {
15b42fb0 13958 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 13959 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 13960 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 13961 inote.type, inote.namesz, inote.descsz);
13962 break;
13963 }
13964
15b42fb0 13965 external = (Elf_External_Note *) next;
dd24e3da 13966
6d118b09
NC		 13967 /* Verify that name is null terminated. It appears that at least
13968 one version of Linux (RedHat 6.0) generates corefiles that don't
13969 comply with the ELF spec by failing to include the null byte in
13970 namesz. */
8b971f9f 13971 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13972 {
3f5e193b 13973 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13974
6d118b09
NC		 13975 if (temp == NULL)
13976 {
13977 error (_("Out of memory\n"));
13978 res = 0;
13979 break;
13980 }
76da6bbe 13981
6d118b09
NC		 13982 strncpy (temp, inote.namedata, inote.namesz);
13983 temp[inote.namesz] = 0;
76da6bbe 13984
6d118b09
NC		 13985 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13986 inote.namedata = temp;
13987 }
13988
13989 res &= process_note (& inote);
103f02d3 13990
6d118b09
NC		 13991 if (temp != NULL)
13992 {
13993 free (temp);
13994 temp = NULL;
13995 }
779fe533
NC		 13996 }
13997
13998 free (pnotes);
103f02d3 13999
779fe533
NC		 14000 return res;
14001}
14002
14003static int
2cf0635d 14004process_corefile_note_segments (FILE * file)
779fe533 14005{
2cf0635d 14006 Elf_Internal_Phdr * segment;
b34976b6
AM		 14007 unsigned int i;
14008 int res = 1;
103f02d3 14009
d93f0186 14010 if (! get_program_headers (file))
779fe533 14011 return 0;
103f02d3 14012
779fe533
NC		 14013 for (i = 0, segment = program_headers;
14014 i < elf_header.e_phnum;
b34976b6 14015 i++, segment++)
779fe533
NC		 14016 {
14017 if (segment->p_type == PT_NOTE)
103f02d3 14018 res &= process_corefile_note_segment (file,
30800947
NC		 14019 (bfd_vma) segment->p_offset,
14020 (bfd_vma) segment->p_filesz);
779fe533 14021 }
103f02d3 14022
779fe533
NC		 14023 return res;
14024}
14025
14026static int
2cf0635d 14027process_note_sections (FILE * file)
1ec5cd37 14028{
2cf0635d 14029 Elf_Internal_Shdr * section;
1ec5cd37
NC		 14030 unsigned long i;
14031 int res = 1;
14032
14033 for (i = 0, section = section_headers;
fa1908fd 14034 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 14035 i++, section++)
14036 if (section->sh_type == SHT_NOTE)
14037 res &= process_corefile_note_segment (file,
14038 (bfd_vma) section->sh_offset,
14039 (bfd_vma) section->sh_size);
14040
14041 return res;
14042}
14043
14044static int
2cf0635d 14045process_notes (FILE * file)
779fe533
NC		 14046{
14047 /* If we have not been asked to display the notes then do nothing. */
14048 if (! do_notes)
14049 return 1;
103f02d3 14050
779fe533 14051 if (elf_header.e_type != ET_CORE)
1ec5cd37 14052 return process_note_sections (file);
103f02d3 14053
779fe533 14054 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 14055 if (elf_header.e_phnum > 0)
14056 return process_corefile_note_segments (file);
779fe533 14057
1ec5cd37
NC		 14058 printf (_("No note segments present in the core file.\n"));
14059 return 1;
779fe533
NC		 14060}
14061
252b5132 14062static int
2cf0635d 14063process_arch_specific (FILE * file)
252b5132 14064{
a952a375
NC		 14065 if (! do_arch)
14066 return 1;
14067
252b5132
RH		 14068 switch (elf_header.e_machine)
14069 {
11c1ff18
PB		 14070 case EM_ARM:
14071 return process_arm_specific (file);
252b5132 14072 case EM_MIPS:
4fe85591 14073 case EM_MIPS_RS3_LE:
252b5132
RH		 14074 return process_mips_specific (file);
14075 break;
35c08157
KLC		 14076 case EM_NDS32:
14077 return process_nds32_specific (file);
14078 break;
34c8bcba
JM		 14079 case EM_PPC:
14080 return process_power_specific (file);
14081 break;
9e8c70f9
DM		 14082 case EM_SPARC:
14083 case EM_SPARC32PLUS:
14084 case EM_SPARCV9:
14085 return process_sparc_specific (file);
14086 break;
59e6276b
JM		 14087 case EM_TI_C6000:
14088 return process_tic6x_specific (file);
14089 break;
13761a11
NC		 14090 case EM_MSP430:
14091 return process_msp430x_specific (file);
252b5132
RH		 14092 default:
14093 break;
14094 }
14095 return 1;
14096}
14097
14098static int
2cf0635d 14099get_file_header (FILE * file)
252b5132 14100{
9ea033b2
NC		 14101 /* Read in the identity array. */
14102 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 14103 return 0;
14104
9ea033b2 14105 /* Determine how to read the rest of the header. */
b34976b6 14106 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 14107 {
14108 default: /* fall through */
14109 case ELFDATANONE: /* fall through */
adab8cdc
AO		 14110 case ELFDATA2LSB:
14111 byte_get = byte_get_little_endian;
14112 byte_put = byte_put_little_endian;
14113 break;
14114 case ELFDATA2MSB:
14115 byte_get = byte_get_big_endian;
14116 byte_put = byte_put_big_endian;
14117 break;
9ea033b2
NC		 14118 }
14119
14120 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 14121 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 14122
14123 /* Read in the rest of the header. */
14124 if (is_32bit_elf)
14125 {
14126 Elf32_External_Ehdr ehdr32;
252b5132 14127
9ea033b2
NC		 14128 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14129 return 0;
103f02d3 14130
9ea033b2
NC		 14131 elf_header.e_type = BYTE_GET (ehdr32.e_type);
14132 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
14133 elf_header.e_version = BYTE_GET (ehdr32.e_version);
14134 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
14135 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
14136 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
14137 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
14138 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
14139 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14140 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
14141 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14142 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
14143 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
14144 }
252b5132 14145 else
9ea033b2
NC		 14146 {
14147 Elf64_External_Ehdr ehdr64;
a952a375
NC		 14148
14149 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14150 we will not be able to cope with the 64bit data found in
14151 64 ELF files. Detect this now and abort before we start
50c2245b 14152 overwriting things. */
a952a375
NC		 14153 if (sizeof (bfd_vma) < 8)
14154 {
e3c8793a
NC		 14155 error (_("This instance of readelf has been built without support for a\n\
1415664 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 14157 return 0;
14158 }
103f02d3 14159
9ea033b2
NC		 14160 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14161 return 0;
103f02d3 14162
9ea033b2
NC		 14163 elf_header.e_type = BYTE_GET (ehdr64.e_type);
14164 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
14165 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 14166 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
14167 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
14168 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 14169 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
14170 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
14171 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14172 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
14173 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14174 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
14175 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
14176 }
252b5132 14177
7ece0d85
JJ		 14178 if (elf_header.e_shoff)
14179 {
14180 /* There may be some extensions in the first section header. Don't
14181 bomb if we can't read it. */
14182 if (is_32bit_elf)
14183 get_32bit_section_headers (file, 1);
14184 else
14185 get_64bit_section_headers (file, 1);
14186 }
560f3c1c 14187
252b5132
RH		 14188 return 1;
14189}
14190
fb52b2f4
NC		 14191/* Process one ELF object file according to the command line options.
14192 This file may actually be stored in an archive. The file is
14193 positioned at the start of the ELF object. */
14194
ff78d6d6 14195static int
2cf0635d 14196process_object (char * file_name, FILE * file)
252b5132 14197{
252b5132
RH		 14198 unsigned int i;
14199
252b5132
RH		 14200 if (! get_file_header (file))
14201 {
14202 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 14203 return 1;
252b5132
RH		 14204 }
14205
14206 /* Initialise per file variables. */
60bca95a 14207 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 14208 version_info[i] = 0;
14209
60bca95a 14210 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 14211 dynamic_info[i] = 0;
5115b233 14212 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 14213
14214 /* Process the file. */
14215 if (show_name)
14216 printf (_("\nFile: %s\n"), file_name);
14217
18bd398b
NC		 14218 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14219 Note we do this even if cmdline_dump_sects is empty because we
14220 must make sure that the dump_sets array is zeroed out before each
14221 object file is processed. */
14222 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 14223 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 14224
14225 if (num_cmdline_dump_sects > 0)
14226 {
14227 if (num_dump_sects == 0)
14228 /* A sneaky way of allocating the dump_sects array. */
09c11c86 14229 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 14230
14231 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 14232 memcpy (dump_sects, cmdline_dump_sects,
14233 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 14234 }
d70c5fc7 14235
252b5132 14236 if (! process_file_header ())
fb52b2f4 14237 return 1;
252b5132 14238
d1f5c6e3 14239 if (! process_section_headers (file))
2f62977e 14240 {
d1f5c6e3
L		 14241 /* Without loaded section headers we cannot process lots of
14242 things. */
2f62977e 14243 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 14244
2f62977e 14245 if (! do_using_dynamic)
2c610e4b 14246 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 14247 }
252b5132 14248
d1f5c6e3
L		 14249 if (! process_section_groups (file))
14250 {
14251 /* Without loaded section groups we cannot process unwind. */
14252 do_unwind = 0;
14253 }
14254
2f62977e 14255 if (process_program_headers (file))
b2d38a17 14256 process_dynamic_section (file);
252b5132
RH		 14257
14258 process_relocs (file);
14259
4d6ed7c8
NC		 14260 process_unwind (file);
14261
252b5132
RH		 14262 process_symbol_table (file);
14263
14264 process_syminfo (file);
14265
14266 process_version_sections (file);
14267
14268 process_section_contents (file);
f5842774 14269
1ec5cd37 14270 process_notes (file);
103f02d3 14271
047b2264
JJ		 14272 process_gnu_liblist (file);
14273
252b5132
RH		 14274 process_arch_specific (file);
14275
d93f0186
NC		 14276 if (program_headers)
14277 {
14278 free (program_headers);
14279 program_headers = NULL;
14280 }
14281
252b5132
RH		 14282 if (section_headers)
14283 {
14284 free (section_headers);
14285 section_headers = NULL;
14286 }
14287
14288 if (string_table)
14289 {
14290 free (string_table);
14291 string_table = NULL;
d40ac9bd 14292 string_table_length = 0;
252b5132
RH		 14293 }
14294
14295 if (dynamic_strings)
14296 {
14297 free (dynamic_strings);
14298 dynamic_strings = NULL;
d79b3d50 14299 dynamic_strings_length = 0;
252b5132
RH		 14300 }
14301
14302 if (dynamic_symbols)
14303 {
14304 free (dynamic_symbols);
14305 dynamic_symbols = NULL;
19936277 14306 num_dynamic_syms = 0;
252b5132
RH		 14307 }
14308
14309 if (dynamic_syminfo)
14310 {
14311 free (dynamic_syminfo);
14312 dynamic_syminfo = NULL;
14313 }
ff78d6d6 14314
293c573e
MR		 14315 if (dynamic_section)
14316 {
14317 free (dynamic_section);
14318 dynamic_section = NULL;
14319 }
14320
e4b17d5c
L		 14321 if (section_headers_groups)
14322 {
14323 free (section_headers_groups);
14324 section_headers_groups = NULL;
14325 }
14326
14327 if (section_groups)
14328 {
2cf0635d
NC		 14329 struct group_list * g;
14330 struct group_list * next;
e4b17d5c
L		 14331
14332 for (i = 0; i < group_count; i++)
14333 {
14334 for (g = section_groups [i].root; g != NULL; g = next)
14335 {
14336 next = g->next;
14337 free (g);
14338 }
14339 }
14340
14341 free (section_groups);
14342 section_groups = NULL;
14343 }
14344
19e6b90e 14345 free_debug_memory ();
18bd398b 14346
ff78d6d6 14347 return 0;
252b5132
RH		 14348}
14349
2cf0635d
NC		 14350/* Process an ELF archive.
14351 On entry the file is positioned just after the ARMAG string. */
14352
14353static int
14354process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14355{
14356 struct archive_info arch;
14357 struct archive_info nested_arch;
14358 size_t got;
2cf0635d
NC		 14359 int ret;
14360
14361 show_name = 1;
14362
14363 /* The ARCH structure is used to hold information about this archive. */
14364 arch.file_name = NULL;
14365 arch.file = NULL;
14366 arch.index_array = NULL;
14367 arch.sym_table = NULL;
14368 arch.longnames = NULL;
14369
14370 /* The NESTED_ARCH structure is used as a single-item cache of information
14371 about a nested archive (when members of a thin archive reside within
14372 another regular archive file). */
14373 nested_arch.file_name = NULL;
14374 nested_arch.file = NULL;
14375 nested_arch.index_array = NULL;
14376 nested_arch.sym_table = NULL;
14377 nested_arch.longnames = NULL;
14378
14379 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14380 {
14381 ret = 1;
14382 goto out;
4145f1d5 14383 }
fb52b2f4 14384
4145f1d5
NC		 14385 if (do_archive_index)
14386 {
2cf0635d 14387 if (arch.sym_table == NULL)
4145f1d5
NC		 14388 error (_("%s: unable to dump the index as none was found\n"), file_name);
14389 else
14390 {
2cf0635d 14391 unsigned int i, l;
4145f1d5
NC		 14392 unsigned long current_pos;
14393
14394 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 14395 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 14396 current_pos = ftell (file);
14397
2cf0635d 14398 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 14399 {
2cf0635d
NC		 14400 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14401 {
14402 char * member_name;
4145f1d5 14403
2cf0635d
NC		 14404 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14405
14406 if (member_name != NULL)
14407 {
14408 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14409
14410 if (qualified_name != NULL)
14411 {
c2a7d3f5
NC		 14412 printf (_("Contents of binary %s at offset "), qualified_name);
14413 (void) print_vma (arch.index_array[i], PREFIX_HEX);
14414 putchar ('\n');
2cf0635d
NC		 14415 free (qualified_name);
14416 }
4145f1d5
NC		 14417 }
14418 }
2cf0635d
NC		 14419
14420 if (l >= arch.sym_size)
4145f1d5
NC		 14421 {
14422 error (_("%s: end of the symbol table reached before the end of the index\n"),
14423 file_name);
cb8f3167 14424 break;
4145f1d5 14425 }
2cf0635d
NC		 14426 printf ("\t%s\n", arch.sym_table + l);
14427 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 14428 }
14429
c2a7d3f5
NC		 14430 if (arch.uses_64bit_indicies)
14431 l = (l + 7) & ~ 7;
14432 else
14433 l += l & 1;
14434
2cf0635d 14435 if (l < arch.sym_size)
c2a7d3f5
NC		 14436 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14437 file_name, arch.sym_size - l);
4145f1d5 14438
4145f1d5
NC		 14439 if (fseek (file, current_pos, SEEK_SET) != 0)
14440 {
14441 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 14442 ret = 1;
14443 goto out;
4145f1d5 14444 }
fb52b2f4 14445 }
4145f1d5
NC		 14446
14447 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14448 && !do_segments && !do_header && !do_dump && !do_version
14449 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 14450 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 14451 {
14452 ret = 0; /* Archive index only. */
14453 goto out;
14454 }
fb52b2f4
NC		 14455 }
14456
d989285c 14457 ret = 0;
fb52b2f4
NC		 14458
14459 while (1)
14460 {
2cf0635d
NC		 14461 char * name;
14462 size_t namelen;
14463 char * qualified_name;
14464
14465 /* Read the next archive header. */
14466 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14467 {
14468 error (_("%s: failed to seek to next archive header\n"), file_name);
14469 return 1;
14470 }
14471 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14472 if (got != sizeof arch.arhdr)
14473 {
14474 if (got == 0)
14475 break;
14476 error (_("%s: failed to read archive header\n"), file_name);
14477 ret = 1;
14478 break;
14479 }
14480 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14481 {
14482 error (_("%s: did not find a valid archive header\n"), arch.file_name);
14483 ret = 1;
14484 break;
14485 }
14486
14487 arch.next_arhdr_offset += sizeof arch.arhdr;
14488
14489 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14490 if (archive_file_size & 01)
14491 ++archive_file_size;
14492
14493 name = get_archive_member_name (&arch, &nested_arch);
14494 if (name == NULL)
fb52b2f4 14495 {
0fd3a477 14496 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 14497 ret = 1;
14498 break;
fb52b2f4 14499 }
2cf0635d 14500 namelen = strlen (name);
fb52b2f4 14501
2cf0635d
NC		 14502 qualified_name = make_qualified_name (&arch, &nested_arch, name);
14503 if (qualified_name == NULL)
fb52b2f4 14504 {
2cf0635d 14505 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 14506 ret = 1;
14507 break;
fb52b2f4
NC		 14508 }
14509
2cf0635d
NC		 14510 if (is_thin_archive && arch.nested_member_origin == 0)
14511 {
14512 /* This is a proxy for an external member of a thin archive. */
14513 FILE * member_file;
14514 char * member_file_name = adjust_relative_path (file_name, name, namelen);
14515 if (member_file_name == NULL)
14516 {
14517 ret = 1;
14518 break;
14519 }
14520
14521 member_file = fopen (member_file_name, "rb");
14522 if (member_file == NULL)
14523 {
14524 error (_("Input file '%s' is not readable.\n"), member_file_name);
14525 free (member_file_name);
14526 ret = 1;
14527 break;
14528 }
14529
14530 archive_file_offset = arch.nested_member_origin;
14531
14532 ret |= process_object (qualified_name, member_file);
14533
14534 fclose (member_file);
14535 free (member_file_name);
14536 }
14537 else if (is_thin_archive)
14538 {
a043396b
NC		 14539 /* PR 15140: Allow for corrupt thin archives. */
14540 if (nested_arch.file == NULL)
14541 {
14542 error (_("%s: contains corrupt thin archive: %s\n"),
14543 file_name, name);
14544 ret = 1;
14545 break;
14546 }
14547
2cf0635d
NC		 14548 /* This is a proxy for a member of a nested archive. */
14549 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14550
14551 /* The nested archive file will have been opened and setup by
14552 get_archive_member_name. */
14553 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14554 {
14555 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14556 ret = 1;
14557 break;
14558 }
14559
14560 ret |= process_object (qualified_name, nested_arch.file);
14561 }
14562 else
14563 {
14564 archive_file_offset = arch.next_arhdr_offset;
14565 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 14566
2cf0635d
NC		 14567 ret |= process_object (qualified_name, file);
14568 }
fb52b2f4 14569
2b52916e
L		 14570 if (dump_sects != NULL)
14571 {
14572 free (dump_sects);
14573 dump_sects = NULL;
14574 num_dump_sects = 0;
14575 }
14576
2cf0635d 14577 free (qualified_name);
fb52b2f4
NC		 14578 }
14579
4145f1d5 14580 out:
2cf0635d
NC		 14581 if (nested_arch.file != NULL)
14582 fclose (nested_arch.file);
14583 release_archive (&nested_arch);
14584 release_archive (&arch);
fb52b2f4 14585
d989285c 14586 return ret;
fb52b2f4
NC		 14587}
14588
14589static int
2cf0635d 14590process_file (char * file_name)
fb52b2f4 14591{
2cf0635d 14592 FILE * file;
fb52b2f4
NC		 14593 struct stat statbuf;
14594 char armag[SARMAG];
14595 int ret;
14596
14597 if (stat (file_name, &statbuf) < 0)
14598 {
f24ddbdd
NC		 14599 if (errno == ENOENT)
14600 error (_("'%s': No such file\n"), file_name);
14601 else
14602 error (_("Could not locate '%s'. System error message: %s\n"),
14603 file_name, strerror (errno));
14604 return 1;
14605 }
14606
14607 if (! S_ISREG (statbuf.st_mode))
14608 {
14609 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 14610 return 1;
14611 }
14612
14613 file = fopen (file_name, "rb");
14614 if (file == NULL)
14615 {
f24ddbdd 14616 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 14617 return 1;
14618 }
14619
14620 if (fread (armag, SARMAG, 1, file) != 1)
14621 {
4145f1d5 14622 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 14623 fclose (file);
14624 return 1;
14625 }
14626
14627 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 14628 ret = process_archive (file_name, file, FALSE);
14629 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14630 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 14631 else
14632 {
4145f1d5
NC		 14633 if (do_archive_index)
14634 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14635 file_name);
14636
fb52b2f4
NC		 14637 rewind (file);
14638 archive_file_size = archive_file_offset = 0;
14639 ret = process_object (file_name, file);
14640 }
14641
14642 fclose (file);
14643
14644 return ret;
14645}
14646
252b5132
RH		 14647#ifdef SUPPORT_DISASSEMBLY
14648/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 14649 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 14650 symbols. */
252b5132
RH		 14651
14652void
2cf0635d 14653print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 14654{
14655 fprintf (outfile,"0x%8.8x", addr);
14656}
14657
e3c8793a 14658/* Needed by the i386 disassembler. */
252b5132
RH		 14659void
14660db_task_printsym (unsigned int addr)
14661{
14662 print_address (addr, stderr);
14663}
14664#endif
14665
14666int
2cf0635d 14667main (int argc, char ** argv)
252b5132 14668{
ff78d6d6
L		 14669 int err;
14670
252b5132
RH		 14671#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14672 setlocale (LC_MESSAGES, "");
3882b010
L		 14673#endif
14674#if defined (HAVE_SETLOCALE)
14675 setlocale (LC_CTYPE, "");
252b5132
RH		 14676#endif
14677 bindtextdomain (PACKAGE, LOCALEDIR);
14678 textdomain (PACKAGE);
14679
869b9d07
MM		 14680 expandargv (&argc, &argv);
14681
252b5132
RH		 14682 parse_args (argc, argv);
14683
18bd398b 14684 if (num_dump_sects > 0)
59f14fc0 14685 {
18bd398b 14686 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 14687 cmdline_dump_sects = (dump_type *)
14688 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 14689 if (cmdline_dump_sects == NULL)
591a748a 14690 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 14691 else
14692 {
09c11c86
NC		 14693 memcpy (cmdline_dump_sects, dump_sects,
14694 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 14695 num_cmdline_dump_sects = num_dump_sects;
14696 }
14697 }
14698
18bd398b
NC		 14699 if (optind < (argc - 1))
14700 show_name = 1;
14701
ff78d6d6 14702 err = 0;
252b5132 14703 while (optind < argc)
18bd398b 14704 err |= process_file (argv[optind++]);
252b5132
RH		 14705
14706 if (dump_sects != NULL)
14707 free (dump_sects);
59f14fc0
AS		 14708 if (cmdline_dump_sects != NULL)
14709 free (cmdline_dump_sects);
252b5132 14710
ff78d6d6 14711 return err;
252b5132 14712}
A mirror of the official binutils-gdb repository