]> 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
daily update
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
4b95cf5c 2 Copyright (C) 1998-2014 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"
73589c9d 136#include "elf/or1k.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;
f54498b4 170static bfd_size_type current_file_size;
85b1c36d
BE		 171static unsigned long dynamic_addr;
172static bfd_size_type dynamic_size;
173static unsigned int dynamic_nent;
2cf0635d 174static char * dynamic_strings;
85b1c36d 175static unsigned long dynamic_strings_length;
2cf0635d 176static char * string_table;
85b1c36d
BE		 177static unsigned long string_table_length;
178static unsigned long num_dynamic_syms;
2cf0635d
NC		 179static Elf_Internal_Sym * dynamic_symbols;
180static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 181static unsigned long dynamic_syminfo_offset;
182static unsigned int dynamic_syminfo_nent;
f8eae8b2 183static char program_interpreter[PATH_MAX];
bb8a0291 184static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 185static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 186static bfd_vma version_info[16];
187static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 188static Elf_Internal_Shdr * section_headers;
189static Elf_Internal_Phdr * program_headers;
190static Elf_Internal_Dyn * dynamic_section;
191static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 192static int show_name;
193static int do_dynamic;
194static int do_syms;
2c610e4b 195static int do_dyn_syms;
85b1c36d
BE		 196static int do_reloc;
197static int do_sections;
198static int do_section_groups;
5477e8a0 199static int do_section_details;
85b1c36d
BE		 200static int do_segments;
201static int do_unwind;
202static int do_using_dynamic;
203static int do_header;
204static int do_dump;
205static int do_version;
85b1c36d
BE		 206static int do_histogram;
207static int do_debugging;
85b1c36d
BE		 208static int do_arch;
209static int do_notes;
4145f1d5 210static int do_archive_index;
85b1c36d 211static int is_32bit_elf;
252b5132 212
e4b17d5c
L		 213struct group_list
214{
2cf0635d 215 struct group_list * next;
e4b17d5c
L		 216 unsigned int section_index;
217};
218
219struct group
220{
2cf0635d 221 struct group_list * root;
e4b17d5c
L		 222 unsigned int group_index;
223};
224
85b1c36d 225static size_t group_count;
2cf0635d
NC		 226static struct group * section_groups;
227static struct group ** section_headers_groups;
e4b17d5c 228
09c11c86
NC		 229
230/* Flag bits indicating particular types of dump. */
231#define HEX_DUMP (1 << 0) /* The -x command line switch. */
232#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
233#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
234#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 235#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 236
237typedef unsigned char dump_type;
238
239/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 240struct dump_list_entry
241{
2cf0635d 242 char * name;
09c11c86 243 dump_type type;
2cf0635d 244 struct dump_list_entry * next;
aef1f6d0 245};
2cf0635d 246static struct dump_list_entry * dump_sects_byname;
aef1f6d0 247
09c11c86
NC		 248/* A dynamic array of flags indicating for which sections a dump
249 has been requested via command line switches. */
250static dump_type * cmdline_dump_sects = NULL;
251static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 252
253/* A dynamic array of flags indicating for which sections a dump of
254 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 255 basis and then initialised from the cmdline_dump_sects array,
256 the results of interpreting the -w switch, and the
257 dump_sects_byname list. */
09c11c86
NC		 258static dump_type * dump_sects = NULL;
259static unsigned int num_dump_sects = 0;
252b5132 260
252b5132 261
c256ffe7 262/* How to print a vma value. */
843dd992
NC		 263typedef enum print_mode
264{
265 HEX,
266 DEC,
267 DEC_5,
268 UNSIGNED,
269 PREFIX_HEX,
270 FULL_HEX,
271 LONG_HEX
272}
273print_mode;
274
9c19a809
NC		 275#define UNKNOWN -1
276
2b692964
NC		 277#define SECTION_NAME(X) \
278 ((X) == NULL ? _("<none>") \
279 : string_table == NULL ? _("<no-name>") \
280 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 281 : string_table + (X)->sh_name))
252b5132 282
ee42cf8c 283#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 284
ba5cdace
NC		 285#define GET_ELF_SYMBOLS(file, section, sym_count) \
286 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
287 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 288
d79b3d50
NC		 289#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
290/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
291 already been called and verified that the string exists. */
292#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 293
61865e30
NC		 294#define REMOVE_ARCH_BITS(ADDR) \
295 do \
296 { \
297 if (elf_header.e_machine == EM_ARM) \
298 (ADDR) &= ~1; \
299 } \
300 while (0)
d79b3d50 301\f
59245841
NC		 302/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
303 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
304 using malloc and fill that. In either case return the pointer to the start of
305 the retrieved data or NULL if something went wrong. If something does go wrong
306 emit an error message using REASON as part of the context. */
307
c256ffe7 308static void *
2cf0635d
NC		 309get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
310 const char * reason)
a6e9f9df 311{
2cf0635d 312 void * mvar;
a6e9f9df 313
c256ffe7 314 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 315 return NULL;
316
fb52b2f4 317 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 318 {
049b0c3a
NC		 319 if (reason)
320 error (_("Unable to seek to 0x%lx for %s\n"),
321 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 322 return NULL;
323 }
324
325 mvar = var;
326 if (mvar == NULL)
327 {
c256ffe7
JJ		 328 /* Check for overflow. */
329 if (nmemb < (~(size_t) 0 - 1) / size)
330 /* + 1 so that we can '\0' terminate invalid string table sections. */
331 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 332
333 if (mvar == NULL)
334 {
049b0c3a
NC		 335 if (reason)
336 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
337 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 338 return NULL;
339 }
c256ffe7
JJ		 340
341 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 342 }
343
c256ffe7 344 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 345 {
049b0c3a
NC		 346 if (reason)
347 error (_("Unable to read in 0x%lx bytes of %s\n"),
348 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 349 if (mvar != var)
350 free (mvar);
351 return NULL;
352 }
353
354 return mvar;
355}
356
14a91970 357/* Print a VMA value. */
cb8f3167 358
66543521 359static int
14a91970 360print_vma (bfd_vma vma, print_mode mode)
66543521 361{
66543521
AM		 362 int nc = 0;
363
14a91970 364 switch (mode)
66543521 365 {
14a91970
AM		 366 case FULL_HEX:
367 nc = printf ("0x");
368 /* Drop through. */
66543521 369
14a91970 370 case LONG_HEX:
f7a99963 371#ifdef BFD64
14a91970 372 if (is_32bit_elf)
437c2fb7 373 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 374#endif
14a91970
AM		 375 printf_vma (vma);
376 return nc + 16;
b19aac67 377
14a91970
AM		 378 case DEC_5:
379 if (vma <= 99999)
380 return printf ("%5" BFD_VMA_FMT "d", vma);
381 /* Drop through. */
66543521 382
14a91970
AM		 383 case PREFIX_HEX:
384 nc = printf ("0x");
385 /* Drop through. */
66543521 386
14a91970
AM		 387 case HEX:
388 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 389
14a91970
AM		 390 case DEC:
391 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 392
14a91970
AM		 393 case UNSIGNED:
394 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 395 }
66543521 396 return 0;
f7a99963
NC		 397}
398
7bfd842d 399/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 400 multibye characters (assuming the host environment supports them).
31104126 401
7bfd842d
NC		 402 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
403
404 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
405 padding as necessary.
171191ba
NC		 406
407 Returns the number of emitted characters. */
408
409static unsigned int
7a88bc9c 410print_symbol (int width, const char *symbol)
31104126 411{
171191ba 412 bfd_boolean extra_padding = FALSE;
7bfd842d 413 int num_printed = 0;
3bfcb652 414#ifdef HAVE_MBSTATE_T
7bfd842d 415 mbstate_t state;
3bfcb652 416#endif
7bfd842d 417 int width_remaining;
961c521f 418
7bfd842d 419 if (width < 0)
961c521f 420 {
961c521f
NC		 421 /* Keep the width positive. This also helps. */
422 width = - width;
171191ba 423 extra_padding = TRUE;
0b4362b0 424 }
961c521f 425
7bfd842d
NC		 426 if (do_wide)
427 /* Set the remaining width to a very large value.
428 This simplifies the code below. */
429 width_remaining = INT_MAX;
430 else
431 width_remaining = width;
cb8f3167 432
3bfcb652 433#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 434 /* Initialise the multibyte conversion state. */
435 memset (& state, 0, sizeof (state));
3bfcb652 436#endif
961c521f 437
7bfd842d
NC		 438 while (width_remaining)
439 {
440 size_t n;
7bfd842d 441 const char c = *symbol++;
961c521f 442
7bfd842d 443 if (c == 0)
961c521f
NC		 444 break;
445
7bfd842d
NC		 446 /* Do not print control characters directly as they can affect terminal
447 settings. Such characters usually appear in the names generated
448 by the assembler for local labels. */
449 if (ISCNTRL (c))
961c521f 450 {
7bfd842d 451 if (width_remaining < 2)
961c521f
NC		 452 break;
453
7bfd842d
NC		 454 printf ("^%c", c + 0x40);
455 width_remaining -= 2;
171191ba 456 num_printed += 2;
961c521f 457 }
7bfd842d
NC		 458 else if (ISPRINT (c))
459 {
460 putchar (c);
461 width_remaining --;
462 num_printed ++;
463 }
961c521f
NC		 464 else
465 {
3bfcb652
NC		 466#ifdef HAVE_MBSTATE_T
467 wchar_t w;
468#endif
7bfd842d
NC		 469 /* Let printf do the hard work of displaying multibyte characters. */
470 printf ("%.1s", symbol - 1);
471 width_remaining --;
472 num_printed ++;
473
3bfcb652 474#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 475 /* Try to find out how many bytes made up the character that was
476 just printed. Advance the symbol pointer past the bytes that
477 were displayed. */
478 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 479#else
480 n = 1;
481#endif
7bfd842d
NC		 482 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
483 symbol += (n - 1);
961c521f 484 }
961c521f 485 }
171191ba 486
7bfd842d 487 if (extra_padding && num_printed < width)
171191ba
NC		 488 {
489 /* Fill in the remaining spaces. */
7bfd842d
NC		 490 printf ("%-*s", width - num_printed, " ");
491 num_printed = width;
171191ba
NC		 492 }
493
494 return num_printed;
31104126
NC		 495}
496
89fac5e3
RS		 497/* Return a pointer to section NAME, or NULL if no such section exists. */
498
499static Elf_Internal_Shdr *
2cf0635d 500find_section (const char * name)
89fac5e3
RS		 501{
502 unsigned int i;
503
504 for (i = 0; i < elf_header.e_shnum; i++)
505 if (streq (SECTION_NAME (section_headers + i), name))
506 return section_headers + i;
507
508 return NULL;
509}
510
0b6ae522
DJ		 511/* Return a pointer to a section containing ADDR, or NULL if no such
512 section exists. */
513
514static Elf_Internal_Shdr *
515find_section_by_address (bfd_vma addr)
516{
517 unsigned int i;
518
519 for (i = 0; i < elf_header.e_shnum; i++)
520 {
521 Elf_Internal_Shdr *sec = section_headers + i;
522 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
523 return sec;
524 }
525
526 return NULL;
527}
528
657d0d47
CC		 529/* Return a pointer to section NAME, or NULL if no such section exists,
530 restricted to the list of sections given in SET. */
531
532static Elf_Internal_Shdr *
533find_section_in_set (const char * name, unsigned int * set)
534{
535 unsigned int i;
536
537 if (set != NULL)
538 {
539 while ((i = *set++) > 0)
540 if (streq (SECTION_NAME (section_headers + i), name))
541 return section_headers + i;
542 }
543
544 return find_section (name);
545}
546
0b6ae522
DJ		 547/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
548 bytes read. */
549
f6f0e17b
NC		 550static inline unsigned long
551read_uleb128 (unsigned char *data,
552 unsigned int *length_return,
553 const unsigned char * const end)
0b6ae522 554{
f6f0e17b 555 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 556}
557
28f997cf
TG		 558/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
559 This OS has so many departures from the ELF standard that we test it at
560 many places. */
561
562static inline int
563is_ia64_vms (void)
564{
565 return elf_header.e_machine == EM_IA_64
566 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
567}
568
bcedfee6 569/* Guess the relocation size commonly used by the specific machines. */
252b5132 570
252b5132 571static int
2dc4cec1 572guess_is_rela (unsigned int e_machine)
252b5132 573{
9c19a809 574 switch (e_machine)
252b5132
RH		 575 {
576 /* Targets that use REL relocations. */
252b5132
RH		 577 case EM_386:
578 case EM_486:
63fcb9e9 579 case EM_960:
e9f53129 580 case EM_ARM:
2b0337b0 581 case EM_D10V:
252b5132 582 case EM_CYGNUS_D10V:
e9f53129 583 case EM_DLX:
252b5132 584 case EM_MIPS:
4fe85591 585 case EM_MIPS_RS3_LE:
e9f53129 586 case EM_CYGNUS_M32R:
1c0d3aa6 587 case EM_SCORE:
f6c1a2d5 588 case EM_XGATE:
9c19a809 589 return FALSE;
103f02d3 590
252b5132
RH		 591 /* Targets that use RELA relocations. */
592 case EM_68K:
e9f53129 593 case EM_860:
a06ea964 594 case EM_AARCH64:
cfb8c092 595 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 596 case EM_ALPHA:
597 case EM_ALTERA_NIOS2:
598 case EM_AVR:
599 case EM_AVR_OLD:
600 case EM_BLACKFIN:
60bca95a 601 case EM_CR16:
e9f53129
AM		 602 case EM_CRIS:
603 case EM_CRX:
2b0337b0 604 case EM_D30V:
252b5132 605 case EM_CYGNUS_D30V:
2b0337b0 606 case EM_FR30:
252b5132 607 case EM_CYGNUS_FR30:
5c70f934 608 case EM_CYGNUS_FRV:
e9f53129
AM		 609 case EM_H8S:
610 case EM_H8_300:
611 case EM_H8_300H:
800eeca4 612 case EM_IA_64:
1e4cf259
NC		 613 case EM_IP2K:
614 case EM_IP2K_OLD:
3b36097d 615 case EM_IQ2000:
84e94c90 616 case EM_LATTICEMICO32:
ff7eeb89 617 case EM_M32C_OLD:
49f58d10 618 case EM_M32C:
e9f53129
AM		 619 case EM_M32R:
620 case EM_MCORE:
15ab5209 621 case EM_CYGNUS_MEP:
a3c62988 622 case EM_METAG:
e9f53129
AM		 623 case EM_MMIX:
624 case EM_MN10200:
625 case EM_CYGNUS_MN10200:
626 case EM_MN10300:
627 case EM_CYGNUS_MN10300:
5506d11a 628 case EM_MOXIE:
e9f53129
AM		 629 case EM_MSP430:
630 case EM_MSP430_OLD:
d031aafb 631 case EM_MT:
35c08157 632 case EM_NDS32:
64fd6348 633 case EM_NIOS32:
73589c9d 634 case EM_OR1K:
e9f53129
AM		 635 case EM_PPC64:
636 case EM_PPC:
99c513f6 637 case EM_RL78:
c7927a3c 638 case EM_RX:
e9f53129
AM		 639 case EM_S390:
640 case EM_S390_OLD:
641 case EM_SH:
642 case EM_SPARC:
643 case EM_SPARC32PLUS:
644 case EM_SPARCV9:
645 case EM_SPU:
40b36596 646 case EM_TI_C6000:
aa137e4d
NC		 647 case EM_TILEGX:
648 case EM_TILEPRO:
708e2187 649 case EM_V800:
e9f53129
AM		 650 case EM_V850:
651 case EM_CYGNUS_V850:
652 case EM_VAX:
653 case EM_X86_64:
8a9036a4 654 case EM_L1OM:
7a9068fe 655 case EM_K1OM:
e9f53129
AM		 656 case EM_XSTORMY16:
657 case EM_XTENSA:
658 case EM_XTENSA_OLD:
7ba29e2a
NC		 659 case EM_MICROBLAZE:
660 case EM_MICROBLAZE_OLD:
9c19a809 661 return TRUE;
103f02d3 662
e9f53129
AM		 663 case EM_68HC05:
664 case EM_68HC08:
665 case EM_68HC11:
666 case EM_68HC16:
667 case EM_FX66:
668 case EM_ME16:
d1133906 669 case EM_MMA:
d1133906
NC		 670 case EM_NCPU:
671 case EM_NDR1:
e9f53129 672 case EM_PCP:
d1133906 673 case EM_ST100:
e9f53129 674 case EM_ST19:
d1133906 675 case EM_ST7:
e9f53129
AM		 676 case EM_ST9PLUS:
677 case EM_STARCORE:
d1133906 678 case EM_SVX:
e9f53129 679 case EM_TINYJ:
9c19a809
NC		 680 default:
681 warn (_("Don't know about relocations on this machine architecture\n"));
682 return FALSE;
683 }
684}
252b5132 685
9c19a809 686static int
2cf0635d 687slurp_rela_relocs (FILE * file,
d3ba0551
AM		 688 unsigned long rel_offset,
689 unsigned long rel_size,
2cf0635d
NC		 690 Elf_Internal_Rela ** relasp,
691 unsigned long * nrelasp)
9c19a809 692{
2cf0635d 693 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 694 unsigned long nrelas;
695 unsigned int i;
252b5132 696
4d6ed7c8
NC		 697 if (is_32bit_elf)
698 {
2cf0635d 699 Elf32_External_Rela * erelas;
103f02d3 700
3f5e193b 701 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 702 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 703 if (!erelas)
704 return 0;
252b5132 705
4d6ed7c8 706 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 707
3f5e193b
NC		 708 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
709 sizeof (Elf_Internal_Rela));
103f02d3 710
4d6ed7c8
NC		 711 if (relas == NULL)
712 {
c256ffe7 713 free (erelas);
591a748a 714 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 715 return 0;
716 }
103f02d3 717
4d6ed7c8
NC		 718 for (i = 0; i < nrelas; i++)
719 {
720 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
721 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 722 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 723 }
103f02d3 724
4d6ed7c8
NC		 725 free (erelas);
726 }
727 else
728 {
2cf0635d 729 Elf64_External_Rela * erelas;
103f02d3 730
3f5e193b 731 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 732 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 733 if (!erelas)
734 return 0;
4d6ed7c8
NC		 735
736 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 737
3f5e193b
NC		 738 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
739 sizeof (Elf_Internal_Rela));
103f02d3 740
4d6ed7c8
NC		 741 if (relas == NULL)
742 {
c256ffe7 743 free (erelas);
591a748a 744 error (_("out of memory parsing relocs\n"));
4d6ed7c8 745 return 0;
9c19a809 746 }
4d6ed7c8
NC		 747
748 for (i = 0; i < nrelas; i++)
9c19a809 749 {
66543521
AM		 750 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
751 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 752 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 753
754 /* The #ifdef BFD64 below is to prevent a compile time
755 warning. We know that if we do not have a 64 bit data
756 type that we will never execute this code anyway. */
757#ifdef BFD64
758 if (elf_header.e_machine == EM_MIPS
759 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
760 {
761 /* In little-endian objects, r_info isn't really a
762 64-bit little-endian value: it has a 32-bit
763 little-endian symbol index followed by four
764 individual byte fields. Reorder INFO
765 accordingly. */
91d6fa6a
NC		 766 bfd_vma inf = relas[i].r_info;
767 inf = (((inf & 0xffffffff) << 32)
768 | ((inf >> 56) & 0xff)
769 | ((inf >> 40) & 0xff00)
770 | ((inf >> 24) & 0xff0000)
771 | ((inf >> 8) & 0xff000000));
772 relas[i].r_info = inf;
861fb55a
DJ		 773 }
774#endif /* BFD64 */
4d6ed7c8 775 }
103f02d3 776
4d6ed7c8
NC		 777 free (erelas);
778 }
779 *relasp = relas;
780 *nrelasp = nrelas;
781 return 1;
782}
103f02d3 783
4d6ed7c8 784static int
2cf0635d 785slurp_rel_relocs (FILE * file,
d3ba0551
AM		 786 unsigned long rel_offset,
787 unsigned long rel_size,
2cf0635d
NC		 788 Elf_Internal_Rela ** relsp,
789 unsigned long * nrelsp)
4d6ed7c8 790{
2cf0635d 791 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 792 unsigned long nrels;
793 unsigned int i;
103f02d3 794
4d6ed7c8
NC		 795 if (is_32bit_elf)
796 {
2cf0635d 797 Elf32_External_Rel * erels;
103f02d3 798
3f5e193b 799 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 800 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 801 if (!erels)
802 return 0;
103f02d3 803
4d6ed7c8 804 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 805
3f5e193b 806 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 807
4d6ed7c8
NC		 808 if (rels == NULL)
809 {
c256ffe7 810 free (erels);
591a748a 811 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 812 return 0;
813 }
814
815 for (i = 0; i < nrels; i++)
816 {
817 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
818 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 819 rels[i].r_addend = 0;
9ea033b2 820 }
4d6ed7c8
NC		 821
822 free (erels);
9c19a809
NC		 823 }
824 else
825 {
2cf0635d 826 Elf64_External_Rel * erels;
9ea033b2 827
3f5e193b 828 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 829 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 830 if (!erels)
831 return 0;
103f02d3 832
4d6ed7c8 833 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 834
3f5e193b 835 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 836
4d6ed7c8 837 if (rels == NULL)
9c19a809 838 {
c256ffe7 839 free (erels);
591a748a 840 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 841 return 0;
842 }
103f02d3 843
4d6ed7c8
NC		 844 for (i = 0; i < nrels; i++)
845 {
66543521
AM		 846 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
847 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 848 rels[i].r_addend = 0;
861fb55a
DJ		 849
850 /* The #ifdef BFD64 below is to prevent a compile time
851 warning. We know that if we do not have a 64 bit data
852 type that we will never execute this code anyway. */
853#ifdef BFD64
854 if (elf_header.e_machine == EM_MIPS
855 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
856 {
857 /* In little-endian objects, r_info isn't really a
858 64-bit little-endian value: it has a 32-bit
859 little-endian symbol index followed by four
860 individual byte fields. Reorder INFO
861 accordingly. */
91d6fa6a
NC		 862 bfd_vma inf = rels[i].r_info;
863 inf = (((inf & 0xffffffff) << 32)
864 | ((inf >> 56) & 0xff)
865 | ((inf >> 40) & 0xff00)
866 | ((inf >> 24) & 0xff0000)
867 | ((inf >> 8) & 0xff000000));
868 rels[i].r_info = inf;
861fb55a
DJ		 869 }
870#endif /* BFD64 */
4d6ed7c8 871 }
103f02d3 872
4d6ed7c8
NC		 873 free (erels);
874 }
875 *relsp = rels;
876 *nrelsp = nrels;
877 return 1;
878}
103f02d3 879
aca88567
NC		 880/* Returns the reloc type extracted from the reloc info field. */
881
882static unsigned int
883get_reloc_type (bfd_vma reloc_info)
884{
885 if (is_32bit_elf)
886 return ELF32_R_TYPE (reloc_info);
887
888 switch (elf_header.e_machine)
889 {
890 case EM_MIPS:
891 /* Note: We assume that reloc_info has already been adjusted for us. */
892 return ELF64_MIPS_R_TYPE (reloc_info);
893
894 case EM_SPARCV9:
895 return ELF64_R_TYPE_ID (reloc_info);
896
897 default:
898 return ELF64_R_TYPE (reloc_info);
899 }
900}
901
902/* Return the symbol index extracted from the reloc info field. */
903
904static bfd_vma
905get_reloc_symindex (bfd_vma reloc_info)
906{
907 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
908}
909
13761a11
NC		 910static inline bfd_boolean
911uses_msp430x_relocs (void)
912{
913 return
914 elf_header.e_machine == EM_MSP430 /* Paranoia. */
915 /* GCC uses osabi == ELFOSBI_STANDALONE. */
916 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
917 /* TI compiler uses ELFOSABI_NONE. */
918 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
919}
920
d3ba0551
AM		 921/* Display the contents of the relocation data found at the specified
922 offset. */
ee42cf8c 923
41e92641 924static void
2cf0635d 925dump_relocations (FILE * file,
d3ba0551
AM		 926 unsigned long rel_offset,
927 unsigned long rel_size,
2cf0635d 928 Elf_Internal_Sym * symtab,
d3ba0551 929 unsigned long nsyms,
2cf0635d 930 char * strtab,
d79b3d50 931 unsigned long strtablen,
d3ba0551 932 int is_rela)
4d6ed7c8 933{
b34976b6 934 unsigned int i;
2cf0635d 935 Elf_Internal_Rela * rels;
103f02d3 936
4d6ed7c8
NC		 937 if (is_rela == UNKNOWN)
938 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 939
4d6ed7c8
NC		 940 if (is_rela)
941 {
c8286bd1 942 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 943 return;
4d6ed7c8
NC		 944 }
945 else
946 {
947 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 948 return;
252b5132
RH		 949 }
950
410f7a12
L		 951 if (is_32bit_elf)
952 {
953 if (is_rela)
2c71103e
NC		 954 {
955 if (do_wide)
956 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
957 else
958 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
959 }
410f7a12 960 else
2c71103e
NC		 961 {
962 if (do_wide)
963 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
964 else
965 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
966 }
410f7a12 967 }
252b5132 968 else
410f7a12
L		 969 {
970 if (is_rela)
2c71103e
NC		 971 {
972 if (do_wide)
8beeaeb7 973 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 974 else
975 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
976 }
410f7a12 977 else
2c71103e
NC		 978 {
979 if (do_wide)
8beeaeb7 980 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 981 else
982 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
983 }
410f7a12 984 }
252b5132
RH		 985
986 for (i = 0; i < rel_size; i++)
987 {
2cf0635d 988 const char * rtype;
b34976b6 989 bfd_vma offset;
91d6fa6a 990 bfd_vma inf;
b34976b6
AM		 991 bfd_vma symtab_index;
992 bfd_vma type;
103f02d3 993
b34976b6 994 offset = rels[i].r_offset;
91d6fa6a 995 inf = rels[i].r_info;
103f02d3 996
91d6fa6a
NC		 997 type = get_reloc_type (inf);
998 symtab_index = get_reloc_symindex (inf);
252b5132 999
410f7a12
L		 1000 if (is_32bit_elf)
1001 {
39dbeff8
AM		 1002 printf ("%8.8lx %8.8lx ",
1003 (unsigned long) offset & 0xffffffff,
91d6fa6a 1004 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1005 }
1006 else
1007 {
39dbeff8
AM		 1008#if BFD_HOST_64BIT_LONG
1009 printf (do_wide
1010 ? "%16.16lx %16.16lx "
1011 : "%12.12lx %12.12lx ",
91d6fa6a 1012 offset, inf);
39dbeff8 1013#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1014#ifndef __MSVCRT__
39dbeff8
AM		 1015 printf (do_wide
1016 ? "%16.16llx %16.16llx "
1017 : "%12.12llx %12.12llx ",
91d6fa6a 1018 offset, inf);
6e3d6dc1
NC		 1019#else
1020 printf (do_wide
1021 ? "%16.16I64x %16.16I64x "
1022 : "%12.12I64x %12.12I64x ",
91d6fa6a 1023 offset, inf);
6e3d6dc1 1024#endif
39dbeff8 1025#else
2c71103e
NC		 1026 printf (do_wide
1027 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1028 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1029 _bfd_int64_high (offset),
1030 _bfd_int64_low (offset),
91d6fa6a
NC		 1031 _bfd_int64_high (inf),
1032 _bfd_int64_low (inf));
9ea033b2 1033#endif
410f7a12 1034 }
103f02d3 1035
252b5132
RH		 1036 switch (elf_header.e_machine)
1037 {
1038 default:
1039 rtype = NULL;
1040 break;
1041
a06ea964
NC		 1042 case EM_AARCH64:
1043 rtype = elf_aarch64_reloc_type (type);
1044 break;
1045
2b0337b0 1046 case EM_M32R:
252b5132 1047 case EM_CYGNUS_M32R:
9ea033b2 1048 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1049 break;
1050
1051 case EM_386:
1052 case EM_486:
9ea033b2 1053 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1054 break;
1055
ba2685cc
AM		 1056 case EM_68HC11:
1057 case EM_68HC12:
1058 rtype = elf_m68hc11_reloc_type (type);
1059 break;
75751cd9 1060
252b5132 1061 case EM_68K:
9ea033b2 1062 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1063 break;
1064
63fcb9e9 1065 case EM_960:
9ea033b2 1066 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1067 break;
1068
adde6300 1069 case EM_AVR:
2b0337b0 1070 case EM_AVR_OLD:
adde6300
AM		 1071 rtype = elf_avr_reloc_type (type);
1072 break;
1073
9ea033b2
NC		 1074 case EM_OLD_SPARCV9:
1075 case EM_SPARC32PLUS:
1076 case EM_SPARCV9:
252b5132 1077 case EM_SPARC:
9ea033b2 1078 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1079 break;
1080
e9f53129
AM		 1081 case EM_SPU:
1082 rtype = elf_spu_reloc_type (type);
1083 break;
1084
708e2187
NC		 1085 case EM_V800:
1086 rtype = v800_reloc_type (type);
1087 break;
2b0337b0 1088 case EM_V850:
252b5132 1089 case EM_CYGNUS_V850:
9ea033b2 1090 rtype = v850_reloc_type (type);
252b5132
RH		 1091 break;
1092
2b0337b0 1093 case EM_D10V:
252b5132 1094 case EM_CYGNUS_D10V:
9ea033b2 1095 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1096 break;
1097
2b0337b0 1098 case EM_D30V:
252b5132 1099 case EM_CYGNUS_D30V:
9ea033b2 1100 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1101 break;
1102
d172d4ba
NC		 1103 case EM_DLX:
1104 rtype = elf_dlx_reloc_type (type);
1105 break;
1106
252b5132 1107 case EM_SH:
9ea033b2 1108 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1109 break;
1110
2b0337b0 1111 case EM_MN10300:
252b5132 1112 case EM_CYGNUS_MN10300:
9ea033b2 1113 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1114 break;
1115
2b0337b0 1116 case EM_MN10200:
252b5132 1117 case EM_CYGNUS_MN10200:
9ea033b2 1118 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1119 break;
1120
2b0337b0 1121 case EM_FR30:
252b5132 1122 case EM_CYGNUS_FR30:
9ea033b2 1123 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1124 break;
1125
ba2685cc
AM		 1126 case EM_CYGNUS_FRV:
1127 rtype = elf_frv_reloc_type (type);
1128 break;
5c70f934 1129
252b5132 1130 case EM_MCORE:
9ea033b2 1131 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1132 break;
1133
3c3bdf30
NC		 1134 case EM_MMIX:
1135 rtype = elf_mmix_reloc_type (type);
1136 break;
1137
5506d11a
AM		 1138 case EM_MOXIE:
1139 rtype = elf_moxie_reloc_type (type);
1140 break;
1141
2469cfa2 1142 case EM_MSP430:
13761a11
NC		 1143 if (uses_msp430x_relocs ())
1144 {
1145 rtype = elf_msp430x_reloc_type (type);
1146 break;
1147 }
2469cfa2
NC		 1148 case EM_MSP430_OLD:
1149 rtype = elf_msp430_reloc_type (type);
1150 break;
1151
35c08157
KLC		 1152 case EM_NDS32:
1153 rtype = elf_nds32_reloc_type (type);
1154 break;
1155
252b5132 1156 case EM_PPC:
9ea033b2 1157 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1158 break;
1159
c833c019
AM		 1160 case EM_PPC64:
1161 rtype = elf_ppc64_reloc_type (type);
1162 break;
1163
252b5132 1164 case EM_MIPS:
4fe85591 1165 case EM_MIPS_RS3_LE:
9ea033b2 1166 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1167 break;
1168
1169 case EM_ALPHA:
9ea033b2 1170 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1171 break;
1172
1173 case EM_ARM:
9ea033b2 1174 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1175 break;
1176
584da044 1177 case EM_ARC:
9ea033b2 1178 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1179 break;
1180
1181 case EM_PARISC:
69e617ca 1182 rtype = elf_hppa_reloc_type (type);
252b5132 1183 break;
7d466069 1184
b8720f9d
JL		 1185 case EM_H8_300:
1186 case EM_H8_300H:
1187 case EM_H8S:
1188 rtype = elf_h8_reloc_type (type);
1189 break;
1190
73589c9d
CS		 1191 case EM_OR1K:
1192 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1193 break;
1194
7d466069 1195 case EM_PJ:
2b0337b0 1196 case EM_PJ_OLD:
7d466069
ILT		 1197 rtype = elf_pj_reloc_type (type);
1198 break;
800eeca4
JW		 1199 case EM_IA_64:
1200 rtype = elf_ia64_reloc_type (type);
1201 break;
1b61cf92
HPN		 1202
1203 case EM_CRIS:
1204 rtype = elf_cris_reloc_type (type);
1205 break;
535c37ff
JE		 1206
1207 case EM_860:
1208 rtype = elf_i860_reloc_type (type);
1209 break;
bcedfee6
NC		 1210
1211 case EM_X86_64:
8a9036a4 1212 case EM_L1OM:
7a9068fe 1213 case EM_K1OM:
bcedfee6
NC		 1214 rtype = elf_x86_64_reloc_type (type);
1215 break;
a85d7ed0 1216
35b1837e
AM		 1217 case EM_S370:
1218 rtype = i370_reloc_type (type);
1219 break;
1220
53c7db4b
KH		 1221 case EM_S390_OLD:
1222 case EM_S390:
1223 rtype = elf_s390_reloc_type (type);
1224 break;
93fbbb04 1225
1c0d3aa6
NC		 1226 case EM_SCORE:
1227 rtype = elf_score_reloc_type (type);
1228 break;
1229
93fbbb04
GK		 1230 case EM_XSTORMY16:
1231 rtype = elf_xstormy16_reloc_type (type);
1232 break;
179d3252 1233
1fe1f39c
NC		 1234 case EM_CRX:
1235 rtype = elf_crx_reloc_type (type);
1236 break;
1237
179d3252
JT		 1238 case EM_VAX:
1239 rtype = elf_vax_reloc_type (type);
1240 break;
1e4cf259 1241
cfb8c092
NC		 1242 case EM_ADAPTEVA_EPIPHANY:
1243 rtype = elf_epiphany_reloc_type (type);
1244 break;
1245
1e4cf259
NC		 1246 case EM_IP2K:
1247 case EM_IP2K_OLD:
1248 rtype = elf_ip2k_reloc_type (type);
1249 break;
3b36097d
SC		 1250
1251 case EM_IQ2000:
1252 rtype = elf_iq2000_reloc_type (type);
1253 break;
88da6820
NC		 1254
1255 case EM_XTENSA_OLD:
1256 case EM_XTENSA:
1257 rtype = elf_xtensa_reloc_type (type);
1258 break;
a34e3ecb 1259
84e94c90
NC		 1260 case EM_LATTICEMICO32:
1261 rtype = elf_lm32_reloc_type (type);
1262 break;
1263
ff7eeb89 1264 case EM_M32C_OLD:
49f58d10
JB		 1265 case EM_M32C:
1266 rtype = elf_m32c_reloc_type (type);
1267 break;
1268
d031aafb
NS		 1269 case EM_MT:
1270 rtype = elf_mt_reloc_type (type);
a34e3ecb 1271 break;
1d65ded4
CM		 1272
1273 case EM_BLACKFIN:
1274 rtype = elf_bfin_reloc_type (type);
1275 break;
15ab5209
DB		 1276
1277 case EM_CYGNUS_MEP:
1278 rtype = elf_mep_reloc_type (type);
1279 break;
60bca95a
NC		 1280
1281 case EM_CR16:
1282 rtype = elf_cr16_reloc_type (type);
1283 break;
dd24e3da 1284
7ba29e2a
NC		 1285 case EM_MICROBLAZE:
1286 case EM_MICROBLAZE_OLD:
1287 rtype = elf_microblaze_reloc_type (type);
1288 break;
c7927a3c 1289
99c513f6
DD		 1290 case EM_RL78:
1291 rtype = elf_rl78_reloc_type (type);
1292 break;
1293
c7927a3c
NC		 1294 case EM_RX:
1295 rtype = elf_rx_reloc_type (type);
1296 break;
c29aca4a 1297
a3c62988
NC		 1298 case EM_METAG:
1299 rtype = elf_metag_reloc_type (type);
1300 break;
1301
c29aca4a
NC		 1302 case EM_XC16X:
1303 case EM_C166:
1304 rtype = elf_xc16x_reloc_type (type);
1305 break;
40b36596
JM		 1306
1307 case EM_TI_C6000:
1308 rtype = elf_tic6x_reloc_type (type);
1309 break;
aa137e4d
NC		 1310
1311 case EM_TILEGX:
1312 rtype = elf_tilegx_reloc_type (type);
1313 break;
1314
1315 case EM_TILEPRO:
1316 rtype = elf_tilepro_reloc_type (type);
1317 break;
f6c1a2d5
NC		 1318
1319 case EM_XGATE:
1320 rtype = elf_xgate_reloc_type (type);
1321 break;
36591ba1
SL		 1322
1323 case EM_ALTERA_NIOS2:
1324 rtype = elf_nios2_reloc_type (type);
1325 break;
252b5132
RH		 1326 }
1327
1328 if (rtype == NULL)
39dbeff8 1329 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1330 else
8beeaeb7 1331 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1332
7ace3541 1333 if (elf_header.e_machine == EM_ALPHA
157c2599 1334 && rtype != NULL
7ace3541
RH		 1335 && streq (rtype, "R_ALPHA_LITUSE")
1336 && is_rela)
1337 {
1338 switch (rels[i].r_addend)
1339 {
1340 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1341 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1342 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1343 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1344 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1345 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1346 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1347 default: rtype = NULL;
1348 }
1349 if (rtype)
1350 printf (" (%s)", rtype);
1351 else
1352 {
1353 putchar (' ');
1354 printf (_("<unknown addend: %lx>"),
1355 (unsigned long) rels[i].r_addend);
1356 }
1357 }
1358 else if (symtab_index)
252b5132 1359 {
af3fc3bc 1360 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1361 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1362 else
19936277 1363 {
2cf0635d 1364 Elf_Internal_Sym * psym;
19936277 1365
af3fc3bc 1366 psym = symtab + symtab_index;
103f02d3 1367
af3fc3bc 1368 printf (" ");
171191ba 1369
d8045f23
NC		 1370 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1371 {
1372 const char * name;
1373 unsigned int len;
1374 unsigned int width = is_32bit_elf ? 8 : 14;
1375
1376 /* Relocations against GNU_IFUNC symbols do not use the value
1377 of the symbol as the address to relocate against. Instead
1378 they invoke the function named by the symbol and use its
1379 result as the address for relocation.
1380
1381 To indicate this to the user, do not display the value of
1382 the symbol in the "Symbols's Value" field. Instead show
1383 its name followed by () as a hint that the symbol is
1384 invoked. */
1385
1386 if (strtab == NULL
1387 || psym->st_name == 0
1388 || psym->st_name >= strtablen)
1389 name = "??";
1390 else
1391 name = strtab + psym->st_name;
1392
1393 len = print_symbol (width, name);
1394 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1395 }
1396 else
1397 {
1398 print_vma (psym->st_value, LONG_HEX);
171191ba 1399
d8045f23
NC		 1400 printf (is_32bit_elf ? " " : " ");
1401 }
103f02d3 1402
af3fc3bc 1403 if (psym->st_name == 0)
f1ef08cb 1404 {
2cf0635d 1405 const char * sec_name = "<null>";
f1ef08cb
AM		 1406 char name_buf[40];
1407
1408 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1409 {
4fbb74a6
AM		 1410 if (psym->st_shndx < elf_header.e_shnum)
1411 sec_name
1412 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1413 else if (psym->st_shndx == SHN_ABS)
1414 sec_name = "ABS";
1415 else if (psym->st_shndx == SHN_COMMON)
1416 sec_name = "COMMON";
ac145307
BS		 1417 else if ((elf_header.e_machine == EM_MIPS
1418 && psym->st_shndx == SHN_MIPS_SCOMMON)
1419 || (elf_header.e_machine == EM_TI_C6000
1420 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1421 sec_name = "SCOMMON";
1422 else if (elf_header.e_machine == EM_MIPS
1423 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1424 sec_name = "SUNDEF";
8a9036a4 1425 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1426 || elf_header.e_machine == EM_L1OM
1427 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1428 && psym->st_shndx == SHN_X86_64_LCOMMON)
1429 sec_name = "LARGE_COMMON";
9ce701e2
L		 1430 else if (elf_header.e_machine == EM_IA_64
1431 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1432 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1433 sec_name = "ANSI_COM";
28f997cf 1434 else if (is_ia64_vms ()
148b93f2
NC		 1435 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1436 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1437 else
1438 {
1439 sprintf (name_buf, "<section 0x%x>",
1440 (unsigned int) psym->st_shndx);
1441 sec_name = name_buf;
1442 }
1443 }
1444 print_symbol (22, sec_name);
1445 }
af3fc3bc 1446 else if (strtab == NULL)
d79b3d50 1447 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1448 else if (psym->st_name >= strtablen)
d79b3d50 1449 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1450 else
2c71103e 1451 print_symbol (22, strtab + psym->st_name);
103f02d3 1452
af3fc3bc 1453 if (is_rela)
171191ba 1454 {
598aaa76 1455 bfd_signed_vma off = rels[i].r_addend;
171191ba 1456
91d6fa6a 1457 if (off < 0)
598aaa76 1458 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1459 else
598aaa76 1460 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1461 }
19936277 1462 }
252b5132 1463 }
1b228002 1464 else if (is_rela)
f7a99963 1465 {
e04d7088
L		 1466 bfd_signed_vma off = rels[i].r_addend;
1467
1468 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1469 if (off < 0)
1470 printf ("-%" BFD_VMA_FMT "x", - off);
1471 else
1472 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1473 }
252b5132 1474
157c2599
NC		 1475 if (elf_header.e_machine == EM_SPARCV9
1476 && rtype != NULL
1477 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1478 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1479
252b5132 1480 putchar ('\n');
2c71103e 1481
aca88567 1482#ifdef BFD64
53c7db4b 1483 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1484 {
91d6fa6a
NC		 1485 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1486 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1487 const char * rtype2 = elf_mips_reloc_type (type2);
1488 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1489
2c71103e
NC		 1490 printf (" Type2: ");
1491
1492 if (rtype2 == NULL)
39dbeff8
AM		 1493 printf (_("unrecognized: %-7lx"),
1494 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1495 else
1496 printf ("%-17.17s", rtype2);
1497
18bd398b 1498 printf ("\n Type3: ");
2c71103e
NC		 1499
1500 if (rtype3 == NULL)
39dbeff8
AM		 1501 printf (_("unrecognized: %-7lx"),
1502 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1503 else
1504 printf ("%-17.17s", rtype3);
1505
53c7db4b 1506 putchar ('\n');
2c71103e 1507 }
aca88567 1508#endif /* BFD64 */
252b5132
RH		 1509 }
1510
c8286bd1 1511 free (rels);
252b5132
RH		 1512}
1513
1514static const char *
d3ba0551 1515get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1516{
1517 switch (type)
1518 {
1519 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1520 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1521 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1522 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1523 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1524 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1525 case DT_MIPS_MSYM: return "MIPS_MSYM";
1526 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1527 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1528 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1529 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1530 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1531 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1532 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1533 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1534 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1535 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1536 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1537 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1538 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1539 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1540 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1541 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1542 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1543 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1544 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1545 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1546 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1547 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1548 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1549 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1550 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1551 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1552 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1553 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1554 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1555 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1556 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1557 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1558 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1559 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1560 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1561 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1562 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1563 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1564 default:
1565 return NULL;
1566 }
1567}
1568
9a097730 1569static const char *
d3ba0551 1570get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1571{
1572 switch (type)
1573 {
1574 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1575 default:
1576 return NULL;
1577 }
103f02d3
UD		 1578}
1579
7490d522
AM		 1580static const char *
1581get_ppc_dynamic_type (unsigned long type)
1582{
1583 switch (type)
1584 {
a7f2871e 1585 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1586 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1587 default:
1588 return NULL;
1589 }
1590}
1591
f1cb7e17 1592static const char *
d3ba0551 1593get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1594{
1595 switch (type)
1596 {
a7f2871e
AM		 1597 case DT_PPC64_GLINK: return "PPC64_GLINK";
1598 case DT_PPC64_OPD: return "PPC64_OPD";
1599 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1600 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1601 default:
1602 return NULL;
1603 }
1604}
1605
103f02d3 1606static const char *
d3ba0551 1607get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1608{
1609 switch (type)
1610 {
1611 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1612 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1613 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1614 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1615 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1616 case DT_HP_PREINIT: return "HP_PREINIT";
1617 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1618 case DT_HP_NEEDED: return "HP_NEEDED";
1619 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1620 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1621 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1622 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1623 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1624 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1625 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1626 case DT_HP_FILTERED: return "HP_FILTERED";
1627 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1628 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1629 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1630 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1631 case DT_PLT: return "PLT";
1632 case DT_PLT_SIZE: return "PLT_SIZE";
1633 case DT_DLT: return "DLT";
1634 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1635 default:
1636 return NULL;
1637 }
1638}
9a097730 1639
ecc51f48 1640static const char *
d3ba0551 1641get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1642{
1643 switch (type)
1644 {
148b93f2
NC		 1645 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1646 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1647 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1648 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1649 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1650 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1651 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1652 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1653 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1654 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1655 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1656 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1657 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1658 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1659 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1660 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1661 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1662 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1663 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1664 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1665 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1666 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1667 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1668 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1669 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1670 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1671 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1672 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1673 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1674 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1675 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1676 default:
1677 return NULL;
1678 }
1679}
1680
fabcb361
RH		 1681static const char *
1682get_alpha_dynamic_type (unsigned long type)
1683{
1684 switch (type)
1685 {
1686 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1687 default:
1688 return NULL;
1689 }
1690}
1691
1c0d3aa6
NC		 1692static const char *
1693get_score_dynamic_type (unsigned long type)
1694{
1695 switch (type)
1696 {
1697 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1698 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1699 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1700 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1701 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1702 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1703 default:
1704 return NULL;
1705 }
1706}
1707
40b36596
JM		 1708static const char *
1709get_tic6x_dynamic_type (unsigned long type)
1710{
1711 switch (type)
1712 {
1713 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1714 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1715 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1716 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1717 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1718 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1719 default:
1720 return NULL;
1721 }
1722}
1c0d3aa6 1723
36591ba1
SL		 1724static const char *
1725get_nios2_dynamic_type (unsigned long type)
1726{
1727 switch (type)
1728 {
1729 case DT_NIOS2_GP: return "NIOS2_GP";
1730 default:
1731 return NULL;
1732 }
1733}
1734
252b5132 1735static const char *
d3ba0551 1736get_dynamic_type (unsigned long type)
252b5132 1737{
e9e44622 1738 static char buff[64];
252b5132
RH		 1739
1740 switch (type)
1741 {
1742 case DT_NULL: return "NULL";
1743 case DT_NEEDED: return "NEEDED";
1744 case DT_PLTRELSZ: return "PLTRELSZ";
1745 case DT_PLTGOT: return "PLTGOT";
1746 case DT_HASH: return "HASH";
1747 case DT_STRTAB: return "STRTAB";
1748 case DT_SYMTAB: return "SYMTAB";
1749 case DT_RELA: return "RELA";
1750 case DT_RELASZ: return "RELASZ";
1751 case DT_RELAENT: return "RELAENT";
1752 case DT_STRSZ: return "STRSZ";
1753 case DT_SYMENT: return "SYMENT";
1754 case DT_INIT: return "INIT";
1755 case DT_FINI: return "FINI";
1756 case DT_SONAME: return "SONAME";
1757 case DT_RPATH: return "RPATH";
1758 case DT_SYMBOLIC: return "SYMBOLIC";
1759 case DT_REL: return "REL";
1760 case DT_RELSZ: return "RELSZ";
1761 case DT_RELENT: return "RELENT";
1762 case DT_PLTREL: return "PLTREL";
1763 case DT_DEBUG: return "DEBUG";
1764 case DT_TEXTREL: return "TEXTREL";
1765 case DT_JMPREL: return "JMPREL";
1766 case DT_BIND_NOW: return "BIND_NOW";
1767 case DT_INIT_ARRAY: return "INIT_ARRAY";
1768 case DT_FINI_ARRAY: return "FINI_ARRAY";
1769 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1770 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1771 case DT_RUNPATH: return "RUNPATH";
1772 case DT_FLAGS: return "FLAGS";
2d0e6f43 1773
d1133906
NC		 1774 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1775 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1776
05107a46 1777 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1778 case DT_PLTPADSZ: return "PLTPADSZ";
1779 case DT_MOVEENT: return "MOVEENT";
1780 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1781 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1782 case DT_POSFLAG_1: return "POSFLAG_1";
1783 case DT_SYMINSZ: return "SYMINSZ";
1784 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1785
252b5132 1786 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1787 case DT_CONFIG: return "CONFIG";
1788 case DT_DEPAUDIT: return "DEPAUDIT";
1789 case DT_AUDIT: return "AUDIT";
1790 case DT_PLTPAD: return "PLTPAD";
1791 case DT_MOVETAB: return "MOVETAB";
252b5132 1792 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1793
252b5132 1794 case DT_VERSYM: return "VERSYM";
103f02d3 1795
67a4f2b7
AO		 1796 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1797 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1798 case DT_RELACOUNT: return "RELACOUNT";
1799 case DT_RELCOUNT: return "RELCOUNT";
1800 case DT_FLAGS_1: return "FLAGS_1";
1801 case DT_VERDEF: return "VERDEF";
1802 case DT_VERDEFNUM: return "VERDEFNUM";
1803 case DT_VERNEED: return "VERNEED";
1804 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1805
019148e4 1806 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1807 case DT_USED: return "USED";
1808 case DT_FILTER: return "FILTER";
103f02d3 1809
047b2264
JJ		 1810 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1811 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1812 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1813 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1814 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1815 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1816
252b5132
RH		 1817 default:
1818 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1819 {
2cf0635d 1820 const char * result;
103f02d3 1821
252b5132
RH		 1822 switch (elf_header.e_machine)
1823 {
1824 case EM_MIPS:
4fe85591 1825 case EM_MIPS_RS3_LE:
252b5132
RH		 1826 result = get_mips_dynamic_type (type);
1827 break;
9a097730
RH		 1828 case EM_SPARCV9:
1829 result = get_sparc64_dynamic_type (type);
1830 break;
7490d522
AM		 1831 case EM_PPC:
1832 result = get_ppc_dynamic_type (type);
1833 break;
f1cb7e17
AM		 1834 case EM_PPC64:
1835 result = get_ppc64_dynamic_type (type);
1836 break;
ecc51f48
NC		 1837 case EM_IA_64:
1838 result = get_ia64_dynamic_type (type);
1839 break;
fabcb361
RH		 1840 case EM_ALPHA:
1841 result = get_alpha_dynamic_type (type);
1842 break;
1c0d3aa6
NC		 1843 case EM_SCORE:
1844 result = get_score_dynamic_type (type);
1845 break;
40b36596
JM		 1846 case EM_TI_C6000:
1847 result = get_tic6x_dynamic_type (type);
1848 break;
36591ba1
SL		 1849 case EM_ALTERA_NIOS2:
1850 result = get_nios2_dynamic_type (type);
1851 break;
252b5132
RH		 1852 default:
1853 result = NULL;
1854 break;
1855 }
1856
1857 if (result != NULL)
1858 return result;
1859
e9e44622 1860 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1861 }
eec8f817
DA		 1862 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1863 || (elf_header.e_machine == EM_PARISC
1864 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1865 {
2cf0635d 1866 const char * result;
103f02d3
UD		 1867
1868 switch (elf_header.e_machine)
1869 {
1870 case EM_PARISC:
1871 result = get_parisc_dynamic_type (type);
1872 break;
148b93f2
NC		 1873 case EM_IA_64:
1874 result = get_ia64_dynamic_type (type);
1875 break;
103f02d3
UD		 1876 default:
1877 result = NULL;
1878 break;
1879 }
1880
1881 if (result != NULL)
1882 return result;
1883
e9e44622
JJ		 1884 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1885 type);
103f02d3 1886 }
252b5132 1887 else
e9e44622 1888 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1889
252b5132
RH		 1890 return buff;
1891 }
1892}
1893
1894static char *
d3ba0551 1895get_file_type (unsigned e_type)
252b5132 1896{
b34976b6 1897 static char buff[32];
252b5132
RH		 1898
1899 switch (e_type)
1900 {
1901 case ET_NONE: return _("NONE (None)");
1902 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1903 case ET_EXEC: return _("EXEC (Executable file)");
1904 case ET_DYN: return _("DYN (Shared object file)");
1905 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1906
1907 default:
1908 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1909 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1910 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1911 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1912 else
e9e44622 1913 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1914 return buff;
1915 }
1916}
1917
1918static char *
d3ba0551 1919get_machine_name (unsigned e_machine)
252b5132 1920{
b34976b6 1921 static char buff[64]; /* XXX */
252b5132
RH		 1922
1923 switch (e_machine)
1924 {
c45021f2 1925 case EM_NONE: return _("None");
a06ea964 1926 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1927 case EM_M32: return "WE32100";
1928 case EM_SPARC: return "Sparc";
e9f53129 1929 case EM_SPU: return "SPU";
c45021f2
NC		 1930 case EM_386: return "Intel 80386";
1931 case EM_68K: return "MC68000";
1932 case EM_88K: return "MC88000";
1933 case EM_486: return "Intel 80486";
1934 case EM_860: return "Intel 80860";
1935 case EM_MIPS: return "MIPS R3000";
1936 case EM_S370: return "IBM System/370";
7036c0e1 1937 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1938 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1939 case EM_PARISC: return "HPPA";
252b5132 1940 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1941 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1942 case EM_960: return "Intel 90860";
1943 case EM_PPC: return "PowerPC";
285d1771 1944 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1945 case EM_FR20: return "Fujitsu FR20";
1946 case EM_RH32: return "TRW RH32";
b34976b6 1947 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1948 case EM_ARM: return "ARM";
1949 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1950 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1951 case EM_SPARCV9: return "Sparc v9";
1952 case EM_TRICORE: return "Siemens Tricore";
584da044 1953 case EM_ARC: return "ARC";
c2dcd04e
NC		 1954 case EM_H8_300: return "Renesas H8/300";
1955 case EM_H8_300H: return "Renesas H8/300H";
1956 case EM_H8S: return "Renesas H8S";
1957 case EM_H8_500: return "Renesas H8/500";
30800947 1958 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1959 case EM_MIPS_X: return "Stanford MIPS-X";
1960 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1961 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1962 case EM_CYGNUS_D10V:
1963 case EM_D10V: return "d10v";
1964 case EM_CYGNUS_D30V:
b34976b6 1965 case EM_D30V: return "d30v";
2b0337b0 1966 case EM_CYGNUS_M32R:
26597c86 1967 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1968 case EM_CYGNUS_V850:
708e2187 1969 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 1970 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1971 case EM_CYGNUS_MN10300:
1972 case EM_MN10300: return "mn10300";
1973 case EM_CYGNUS_MN10200:
1974 case EM_MN10200: return "mn10200";
5506d11a 1975 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1976 case EM_CYGNUS_FR30:
1977 case EM_FR30: return "Fujitsu FR30";
b34976b6 1978 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1979 case EM_PJ_OLD:
b34976b6 1980 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1981 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1982 case EM_PCP: return "Siemens PCP";
1983 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1984 case EM_NDR1: return "Denso NDR1 microprocesspr";
1985 case EM_STARCORE: return "Motorola Star*Core processor";
1986 case EM_ME16: return "Toyota ME16 processor";
1987 case EM_ST100: return "STMicroelectronics ST100 processor";
1988 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1989 case EM_PDSP: return "Sony DSP processor";
1990 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1991 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1992 case EM_FX66: return "Siemens FX66 microcontroller";
1993 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1994 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1995 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1996 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1997 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1998 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1999 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2000 case EM_SVX: return "Silicon Graphics SVx";
2001 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2002 case EM_VAX: return "Digital VAX";
2b0337b0 2003 case EM_AVR_OLD:
b34976b6 2004 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2005 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2006 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2007 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2008 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2009 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2010 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2011 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2012 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2013 case EM_L1OM: return "Intel L1OM";
7a9068fe 2014 case EM_K1OM: return "Intel K1OM";
b7498e0e 2015 case EM_S390_OLD:
b34976b6 2016 case EM_S390: return "IBM S/390";
1c0d3aa6 2017 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2018 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2019 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2020 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2021 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2022 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2023 case EM_DLX: return "OpenDLX";
1e4cf259 2024 case EM_IP2K_OLD:
b34976b6 2025 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2026 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2027 case EM_XTENSA_OLD:
2028 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2029 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2030 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2031 case EM_NS32K: return "National Semiconductor 32000 series";
2032 case EM_TPC: return "Tenor Network TPC processor";
2033 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2034 case EM_MAX: return "MAX Processor";
2035 case EM_CR: return "National Semiconductor CompactRISC";
2036 case EM_F2MC16: return "Fujitsu F2MC16";
2037 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2038 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2039 case EM_M32C_OLD:
49f58d10 2040 case EM_M32C: return "Renesas M32c";
d031aafb 2041 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2042 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2043 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2044 case EM_SEP: return "Sharp embedded microprocessor";
2045 case EM_ARCA: return "Arca RISC microprocessor";
2046 case EM_UNICORE: return "Unicore";
2047 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2048 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2049 case EM_NIOS32: return "Altera Nios";
2050 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2051 case EM_C166:
d70c5fc7 2052 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2053 case EM_M16C: return "Renesas M16C series microprocessors";
2054 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2055 case EM_CE: return "Freescale Communication Engine RISC core";
2056 case EM_TSK3000: return "Altium TSK3000 core";
2057 case EM_RS08: return "Freescale RS08 embedded processor";
2058 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2059 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2060 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2061 case EM_SE_C17: return "Seiko Epson C17 family";
2062 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2063 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2064 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2065 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2066 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2067 case EM_R32C: return "Renesas R32C series microprocessors";
2068 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2069 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2070 case EM_8051: return "Intel 8051 and variants";
2071 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2072 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2073 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2074 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2075 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2076 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2077 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2078 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2079 case EM_CR16:
f6c1a2d5 2080 case EM_MICROBLAZE:
7ba29e2a 2081 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2082 case EM_RL78: return "Renesas RL78";
c7927a3c 2083 case EM_RX: return "Renesas RX";
a3c62988 2084 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2085 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2086 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2087 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2088 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2089 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2090 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2091 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2092 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2093 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2094 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2095 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2096 default:
35d9dd2f 2097 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2098 return buff;
2099 }
2100}
2101
f3485b74 2102static void
d3ba0551 2103decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2104{
2105 unsigned eabi;
2106 int unknown = 0;
2107
2108 eabi = EF_ARM_EABI_VERSION (e_flags);
2109 e_flags &= ~ EF_ARM_EABIMASK;
2110
2111 /* Handle "generic" ARM flags. */
2112 if (e_flags & EF_ARM_RELEXEC)
2113 {
2114 strcat (buf, ", relocatable executable");
2115 e_flags &= ~ EF_ARM_RELEXEC;
2116 }
76da6bbe 2117
f3485b74
NC		 2118 if (e_flags & EF_ARM_HASENTRY)
2119 {
2120 strcat (buf, ", has entry point");
2121 e_flags &= ~ EF_ARM_HASENTRY;
2122 }
76da6bbe 2123
f3485b74
NC		 2124 /* Now handle EABI specific flags. */
2125 switch (eabi)
2126 {
2127 default:
2c71103e 2128 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2129 if (e_flags)
2130 unknown = 1;
2131 break;
2132
2133 case EF_ARM_EABI_VER1:
a5bcd848 2134 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2135 while (e_flags)
2136 {
2137 unsigned flag;
76da6bbe 2138
f3485b74
NC		 2139 /* Process flags one bit at a time. */
2140 flag = e_flags & - e_flags;
2141 e_flags &= ~ flag;
76da6bbe 2142
f3485b74
NC		 2143 switch (flag)
2144 {
a5bcd848 2145 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2146 strcat (buf, ", sorted symbol tables");
2147 break;
76da6bbe 2148
f3485b74
NC		 2149 default:
2150 unknown = 1;
2151 break;
2152 }
2153 }
2154 break;
76da6bbe 2155
a5bcd848
PB		 2156 case EF_ARM_EABI_VER2:
2157 strcat (buf, ", Version2 EABI");
2158 while (e_flags)
2159 {
2160 unsigned flag;
2161
2162 /* Process flags one bit at a time. */
2163 flag = e_flags & - e_flags;
2164 e_flags &= ~ flag;
2165
2166 switch (flag)
2167 {
2168 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2169 strcat (buf, ", sorted symbol tables");
2170 break;
2171
2172 case EF_ARM_DYNSYMSUSESEGIDX:
2173 strcat (buf, ", dynamic symbols use segment index");
2174 break;
2175
2176 case EF_ARM_MAPSYMSFIRST:
2177 strcat (buf, ", mapping symbols precede others");
2178 break;
2179
2180 default:
2181 unknown = 1;
2182 break;
2183 }
2184 }
2185 break;
2186
d507cf36
PB		 2187 case EF_ARM_EABI_VER3:
2188 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2189 break;
2190
2191 case EF_ARM_EABI_VER4:
2192 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2193 while (e_flags)
2194 {
2195 unsigned flag;
2196
2197 /* Process flags one bit at a time. */
2198 flag = e_flags & - e_flags;
2199 e_flags &= ~ flag;
2200
2201 switch (flag)
2202 {
2203 case EF_ARM_BE8:
2204 strcat (buf, ", BE8");
2205 break;
2206
2207 case EF_ARM_LE8:
2208 strcat (buf, ", LE8");
2209 break;
2210
2211 default:
2212 unknown = 1;
2213 break;
2214 }
2215 break;
2216 }
2217 break;
3a4a14e9
PB		 2218
2219 case EF_ARM_EABI_VER5:
2220 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2221 while (e_flags)
2222 {
2223 unsigned flag;
2224
2225 /* Process flags one bit at a time. */
2226 flag = e_flags & - e_flags;
2227 e_flags &= ~ flag;
2228
2229 switch (flag)
2230 {
2231 case EF_ARM_BE8:
2232 strcat (buf, ", BE8");
2233 break;
2234
2235 case EF_ARM_LE8:
2236 strcat (buf, ", LE8");
2237 break;
2238
3bfcb652
NC		 2239 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2240 strcat (buf, ", soft-float ABI");
2241 break;
2242
2243 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2244 strcat (buf, ", hard-float ABI");
2245 break;
2246
d507cf36
PB		 2247 default:
2248 unknown = 1;
2249 break;
2250 }
2251 }
2252 break;
2253
f3485b74 2254 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2255 strcat (buf, ", GNU EABI");
f3485b74
NC		 2256 while (e_flags)
2257 {
2258 unsigned flag;
76da6bbe 2259
f3485b74
NC		 2260 /* Process flags one bit at a time. */
2261 flag = e_flags & - e_flags;
2262 e_flags &= ~ flag;
76da6bbe 2263
f3485b74
NC		 2264 switch (flag)
2265 {
a5bcd848 2266 case EF_ARM_INTERWORK:
f3485b74
NC		 2267 strcat (buf, ", interworking enabled");
2268 break;
76da6bbe 2269
a5bcd848 2270 case EF_ARM_APCS_26:
f3485b74
NC		 2271 strcat (buf, ", uses APCS/26");
2272 break;
76da6bbe 2273
a5bcd848 2274 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2275 strcat (buf, ", uses APCS/float");
2276 break;
76da6bbe 2277
a5bcd848 2278 case EF_ARM_PIC:
f3485b74
NC		 2279 strcat (buf, ", position independent");
2280 break;
76da6bbe 2281
a5bcd848 2282 case EF_ARM_ALIGN8:
f3485b74
NC		 2283 strcat (buf, ", 8 bit structure alignment");
2284 break;
76da6bbe 2285
a5bcd848 2286 case EF_ARM_NEW_ABI:
f3485b74
NC		 2287 strcat (buf, ", uses new ABI");
2288 break;
76da6bbe 2289
a5bcd848 2290 case EF_ARM_OLD_ABI:
f3485b74
NC		 2291 strcat (buf, ", uses old ABI");
2292 break;
76da6bbe 2293
a5bcd848 2294 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2295 strcat (buf, ", software FP");
2296 break;
76da6bbe 2297
90e01f86
ILT		 2298 case EF_ARM_VFP_FLOAT:
2299 strcat (buf, ", VFP");
2300 break;
2301
fde78edd
NC		 2302 case EF_ARM_MAVERICK_FLOAT:
2303 strcat (buf, ", Maverick FP");
2304 break;
2305
f3485b74
NC		 2306 default:
2307 unknown = 1;
2308 break;
2309 }
2310 }
2311 }
f3485b74
NC		 2312
2313 if (unknown)
2b692964 2314 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2315}
2316
35c08157
KLC		 2317static void
2318decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2319{
2320 unsigned abi;
2321 unsigned arch;
2322 unsigned config;
2323 unsigned version;
2324 int has_fpu = 0;
2325 int r = 0;
2326
2327 static const char *ABI_STRINGS[] =
2328 {
2329 "ABI v0", /* use r5 as return register; only used in N1213HC */
2330 "ABI v1", /* use r0 as return register */
2331 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2332 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2333 "AABI",
2334 "ABI2 FP+"
35c08157
KLC		 2335 };
2336 static const char *VER_STRINGS[] =
2337 {
2338 "Andes ELF V1.3 or older",
2339 "Andes ELF V1.3.1",
2340 "Andes ELF V1.4"
2341 };
2342 static const char *ARCH_STRINGS[] =
2343 {
2344 "",
2345 "Andes Star v1.0",
2346 "Andes Star v2.0",
2347 "Andes Star v3.0",
2348 "Andes Star v3.0m"
2349 };
2350
2351 abi = EF_NDS_ABI & e_flags;
2352 arch = EF_NDS_ARCH & e_flags;
2353 config = EF_NDS_INST & e_flags;
2354 version = EF_NDS32_ELF_VERSION & e_flags;
2355
2356 memset (buf, 0, size);
2357
2358 switch (abi)
2359 {
2360 case E_NDS_ABI_V0:
2361 case E_NDS_ABI_V1:
2362 case E_NDS_ABI_V2:
2363 case E_NDS_ABI_V2FP:
2364 case E_NDS_ABI_AABI:
40c7a7cb 2365 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2366 /* In case there are holes in the array. */
2367 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2368 break;
2369
2370 default:
2371 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2372 break;
2373 }
2374
2375 switch (version)
2376 {
2377 case E_NDS32_ELF_VER_1_2:
2378 case E_NDS32_ELF_VER_1_3:
2379 case E_NDS32_ELF_VER_1_4:
2380 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2381 break;
2382
2383 default:
2384 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2385 break;
2386 }
2387
2388 if (E_NDS_ABI_V0 == abi)
2389 {
2390 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2391 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2392 if (arch == E_NDS_ARCH_STAR_V1_0)
2393 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2394 return;
2395 }
2396
2397 switch (arch)
2398 {
2399 case E_NDS_ARCH_STAR_V1_0:
2400 case E_NDS_ARCH_STAR_V2_0:
2401 case E_NDS_ARCH_STAR_V3_0:
2402 case E_NDS_ARCH_STAR_V3_M:
2403 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2404 break;
2405
2406 default:
2407 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2408 /* ARCH version determines how the e_flags are interpreted.
2409 If it is unknown, we cannot proceed. */
2410 return;
2411 }
2412
2413 /* Newer ABI; Now handle architecture specific flags. */
2414 if (arch == E_NDS_ARCH_STAR_V1_0)
2415 {
2416 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2417 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2418
2419 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2420 r += snprintf (buf + r, size -r, ", MAC");
2421
2422 if (config & E_NDS32_HAS_DIV_INST)
2423 r += snprintf (buf + r, size -r, ", DIV");
2424
2425 if (config & E_NDS32_HAS_16BIT_INST)
2426 r += snprintf (buf + r, size -r, ", 16b");
2427 }
2428 else
2429 {
2430 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2431 {
2432 if (version <= E_NDS32_ELF_VER_1_3)
2433 r += snprintf (buf + r, size -r, ", [B8]");
2434 else
2435 r += snprintf (buf + r, size -r, ", EX9");
2436 }
2437
2438 if (config & E_NDS32_HAS_MAC_DX_INST)
2439 r += snprintf (buf + r, size -r, ", MAC_DX");
2440
2441 if (config & E_NDS32_HAS_DIV_DX_INST)
2442 r += snprintf (buf + r, size -r, ", DIV_DX");
2443
2444 if (config & E_NDS32_HAS_16BIT_INST)
2445 {
2446 if (version <= E_NDS32_ELF_VER_1_3)
2447 r += snprintf (buf + r, size -r, ", 16b");
2448 else
2449 r += snprintf (buf + r, size -r, ", IFC");
2450 }
2451 }
2452
2453 if (config & E_NDS32_HAS_EXT_INST)
2454 r += snprintf (buf + r, size -r, ", PERF1");
2455
2456 if (config & E_NDS32_HAS_EXT2_INST)
2457 r += snprintf (buf + r, size -r, ", PERF2");
2458
2459 if (config & E_NDS32_HAS_FPU_INST)
2460 {
2461 has_fpu = 1;
2462 r += snprintf (buf + r, size -r, ", FPU_SP");
2463 }
2464
2465 if (config & E_NDS32_HAS_FPU_DP_INST)
2466 {
2467 has_fpu = 1;
2468 r += snprintf (buf + r, size -r, ", FPU_DP");
2469 }
2470
2471 if (config & E_NDS32_HAS_FPU_MAC_INST)
2472 {
2473 has_fpu = 1;
2474 r += snprintf (buf + r, size -r, ", FPU_MAC");
2475 }
2476
2477 if (has_fpu)
2478 {
2479 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2480 {
2481 case E_NDS32_FPU_REG_8SP_4DP:
2482 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2483 break;
2484 case E_NDS32_FPU_REG_16SP_8DP:
2485 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2486 break;
2487 case E_NDS32_FPU_REG_32SP_16DP:
2488 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2489 break;
2490 case E_NDS32_FPU_REG_32SP_32DP:
2491 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2492 break;
2493 }
2494 }
2495
2496 if (config & E_NDS32_HAS_AUDIO_INST)
2497 r += snprintf (buf + r, size -r, ", AUDIO");
2498
2499 if (config & E_NDS32_HAS_STRING_INST)
2500 r += snprintf (buf + r, size -r, ", STR");
2501
2502 if (config & E_NDS32_HAS_REDUCED_REGS)
2503 r += snprintf (buf + r, size -r, ", 16REG");
2504
2505 if (config & E_NDS32_HAS_VIDEO_INST)
2506 {
2507 if (version <= E_NDS32_ELF_VER_1_3)
2508 r += snprintf (buf + r, size -r, ", VIDEO");
2509 else
2510 r += snprintf (buf + r, size -r, ", SATURATION");
2511 }
2512
2513 if (config & E_NDS32_HAS_ENCRIPT_INST)
2514 r += snprintf (buf + r, size -r, ", ENCRP");
2515
2516 if (config & E_NDS32_HAS_L2C_INST)
2517 r += snprintf (buf + r, size -r, ", L2C");
2518}
2519
252b5132 2520static char *
d3ba0551 2521get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2522{
b34976b6 2523 static char buf[1024];
252b5132
RH		 2524
2525 buf[0] = '\0';
76da6bbe 2526
252b5132
RH		 2527 if (e_flags)
2528 {
2529 switch (e_machine)
2530 {
2531 default:
2532 break;
2533
f3485b74
NC		 2534 case EM_ARM:
2535 decode_ARM_machine_flags (e_flags, buf);
2536 break;
76da6bbe 2537
781303ce
MF		 2538 case EM_BLACKFIN:
2539 if (e_flags & EF_BFIN_PIC)
2540 strcat (buf, ", PIC");
2541
2542 if (e_flags & EF_BFIN_FDPIC)
2543 strcat (buf, ", FDPIC");
2544
2545 if (e_flags & EF_BFIN_CODE_IN_L1)
2546 strcat (buf, ", code in L1");
2547
2548 if (e_flags & EF_BFIN_DATA_IN_L1)
2549 strcat (buf, ", data in L1");
2550
2551 break;
2552
ec2dfb42
AO		 2553 case EM_CYGNUS_FRV:
2554 switch (e_flags & EF_FRV_CPU_MASK)
2555 {
2556 case EF_FRV_CPU_GENERIC:
2557 break;
2558
2559 default:
2560 strcat (buf, ", fr???");
2561 break;
57346661 2562
ec2dfb42
AO		 2563 case EF_FRV_CPU_FR300:
2564 strcat (buf, ", fr300");
2565 break;
2566
2567 case EF_FRV_CPU_FR400:
2568 strcat (buf, ", fr400");
2569 break;
2570 case EF_FRV_CPU_FR405:
2571 strcat (buf, ", fr405");
2572 break;
2573
2574 case EF_FRV_CPU_FR450:
2575 strcat (buf, ", fr450");
2576 break;
2577
2578 case EF_FRV_CPU_FR500:
2579 strcat (buf, ", fr500");
2580 break;
2581 case EF_FRV_CPU_FR550:
2582 strcat (buf, ", fr550");
2583 break;
2584
2585 case EF_FRV_CPU_SIMPLE:
2586 strcat (buf, ", simple");
2587 break;
2588 case EF_FRV_CPU_TOMCAT:
2589 strcat (buf, ", tomcat");
2590 break;
2591 }
1c877e87 2592 break;
ec2dfb42 2593
53c7db4b 2594 case EM_68K:
425c6cb0 2595 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2596 strcat (buf, ", m68000");
425c6cb0 2597 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2598 strcat (buf, ", cpu32");
2599 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2600 strcat (buf, ", fido_a");
425c6cb0 2601 else
266abb8f 2602 {
2cf0635d
NC		 2603 char const * isa = _("unknown");
2604 char const * mac = _("unknown mac");
2605 char const * additional = NULL;
0112cd26 2606
c694fd50 2607 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2608 {
c694fd50 2609 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2610 isa = "A";
2611 additional = ", nodiv";
2612 break;
c694fd50 2613 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2614 isa = "A";
2615 break;
c694fd50 2616 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2617 isa = "A+";
2618 break;
c694fd50 2619 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2620 isa = "B";
2621 additional = ", nousp";
2622 break;
c694fd50 2623 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2624 isa = "B";
2625 break;
f608cd77
NS		 2626 case EF_M68K_CF_ISA_C:
2627 isa = "C";
2628 break;
2629 case EF_M68K_CF_ISA_C_NODIV:
2630 isa = "C";
2631 additional = ", nodiv";
2632 break;
266abb8f
NS		 2633 }
2634 strcat (buf, ", cf, isa ");
2635 strcat (buf, isa);
0b2e31dc
NS		 2636 if (additional)
2637 strcat (buf, additional);
c694fd50 2638 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2639 strcat (buf, ", float");
c694fd50 2640 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2641 {
2642 case 0:
2643 mac = NULL;
2644 break;
c694fd50 2645 case EF_M68K_CF_MAC:
266abb8f
NS		 2646 mac = "mac";
2647 break;
c694fd50 2648 case EF_M68K_CF_EMAC:
266abb8f
NS		 2649 mac = "emac";
2650 break;
f608cd77
NS		 2651 case EF_M68K_CF_EMAC_B:
2652 mac = "emac_b";
2653 break;
266abb8f
NS		 2654 }
2655 if (mac)
2656 {
2657 strcat (buf, ", ");
2658 strcat (buf, mac);
2659 }
266abb8f 2660 }
53c7db4b 2661 break;
33c63f9d 2662
252b5132
RH		 2663 case EM_PPC:
2664 if (e_flags & EF_PPC_EMB)
2665 strcat (buf, ", emb");
2666
2667 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2668 strcat (buf, _(", relocatable"));
252b5132
RH		 2669
2670 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2671 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2672 break;
2673
ee67d69a
AM		 2674 case EM_PPC64:
2675 if (e_flags & EF_PPC64_ABI)
2676 {
2677 char abi[] = ", abiv0";
2678
2679 abi[6] += e_flags & EF_PPC64_ABI;
2680 strcat (buf, abi);
2681 }
2682 break;
2683
708e2187
NC		 2684 case EM_V800:
2685 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2686 strcat (buf, ", RH850 ABI");
0b4362b0 2687
708e2187
NC		 2688 if (e_flags & EF_V800_850E3)
2689 strcat (buf, ", V3 architecture");
2690
2691 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2692 strcat (buf, ", FPU not used");
2693
2694 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2695 strcat (buf, ", regmode: COMMON");
2696
2697 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2698 strcat (buf, ", r4 not used");
2699
2700 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2701 strcat (buf, ", r30 not used");
2702
2703 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2704 strcat (buf, ", r5 not used");
2705
2706 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2707 strcat (buf, ", r2 not used");
2708
2709 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2710 {
2711 switch (e_flags & - e_flags)
2712 {
2713 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2714 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2715 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2716 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2717 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2718 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2719 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2720 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2721 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2722 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2723 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2724 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2725 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2726 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2727 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2728 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2729 default: break;
2730 }
2731 }
2732 break;
2733
2b0337b0 2734 case EM_V850:
252b5132
RH		 2735 case EM_CYGNUS_V850:
2736 switch (e_flags & EF_V850_ARCH)
2737 {
78c8d46c
NC		 2738 case E_V850E3V5_ARCH:
2739 strcat (buf, ", v850e3v5");
2740 break;
1cd986c5
NC		 2741 case E_V850E2V3_ARCH:
2742 strcat (buf, ", v850e2v3");
2743 break;
2744 case E_V850E2_ARCH:
2745 strcat (buf, ", v850e2");
2746 break;
2747 case E_V850E1_ARCH:
2748 strcat (buf, ", v850e1");
8ad30312 2749 break;
252b5132
RH		 2750 case E_V850E_ARCH:
2751 strcat (buf, ", v850e");
2752 break;
252b5132
RH		 2753 case E_V850_ARCH:
2754 strcat (buf, ", v850");
2755 break;
2756 default:
2b692964 2757 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2758 break;
2759 }
2760 break;
2761
2b0337b0 2762 case EM_M32R:
252b5132
RH		 2763 case EM_CYGNUS_M32R:
2764 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2765 strcat (buf, ", m32r");
252b5132
RH		 2766 break;
2767
2768 case EM_MIPS:
4fe85591 2769 case EM_MIPS_RS3_LE:
252b5132
RH		 2770 if (e_flags & EF_MIPS_NOREORDER)
2771 strcat (buf, ", noreorder");
2772
2773 if (e_flags & EF_MIPS_PIC)
2774 strcat (buf, ", pic");
2775
2776 if (e_flags & EF_MIPS_CPIC)
2777 strcat (buf, ", cpic");
2778
d1bdd336
TS		 2779 if (e_flags & EF_MIPS_UCODE)
2780 strcat (buf, ", ugen_reserved");
2781
252b5132
RH		 2782 if (e_flags & EF_MIPS_ABI2)
2783 strcat (buf, ", abi2");
2784
43521d43
TS		 2785 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2786 strcat (buf, ", odk first");
2787
a5d22d2a
TS		 2788 if (e_flags & EF_MIPS_32BITMODE)
2789 strcat (buf, ", 32bitmode");
2790
ba92f887
MR		 2791 if (e_flags & EF_MIPS_NAN2008)
2792 strcat (buf, ", nan2008");
2793
fef1b0b3
SE		 2794 if (e_flags & EF_MIPS_FP64)
2795 strcat (buf, ", fp64");
2796
156c2f8b
NC		 2797 switch ((e_flags & EF_MIPS_MACH))
2798 {
2799 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2800 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2801 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2802 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2803 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2804 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2805 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2806 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2807 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2808 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2809 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2810 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2811 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2812 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2813 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 2814 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 2815 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2816 case 0:
2817 /* We simply ignore the field in this case to avoid confusion:
2818 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2819 extension. */
2820 break;
2b692964 2821 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2822 }
43521d43
TS		 2823
2824 switch ((e_flags & EF_MIPS_ABI))
2825 {
2826 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2827 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2828 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2829 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2830 case 0:
2831 /* We simply ignore the field in this case to avoid confusion:
2832 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2833 This means it is likely to be an o32 file, but not for
2834 sure. */
2835 break;
2b692964 2836 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2837 }
2838
2839 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2840 strcat (buf, ", mdmx");
2841
2842 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2843 strcat (buf, ", mips16");
2844
df58fc94
RS		 2845 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2846 strcat (buf, ", micromips");
2847
43521d43
TS		 2848 switch ((e_flags & EF_MIPS_ARCH))
2849 {
2850 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2851 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2852 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2853 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2854 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2855 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2856 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 2857 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 2858 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2859 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 2860 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 2861 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2862 }
252b5132 2863 break;
351b4b40 2864
35c08157
KLC		 2865 case EM_NDS32:
2866 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2867 break;
2868
ccde1100
AO		 2869 case EM_SH:
2870 switch ((e_flags & EF_SH_MACH_MASK))
2871 {
2872 case EF_SH1: strcat (buf, ", sh1"); break;
2873 case EF_SH2: strcat (buf, ", sh2"); break;
2874 case EF_SH3: strcat (buf, ", sh3"); break;
2875 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2876 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2877 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2878 case EF_SH3E: strcat (buf, ", sh3e"); break;
2879 case EF_SH4: strcat (buf, ", sh4"); break;
2880 case EF_SH5: strcat (buf, ", sh5"); break;
2881 case EF_SH2E: strcat (buf, ", sh2e"); break;
2882 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2883 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2884 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2885 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2886 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2887 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2888 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2889 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2890 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2891 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2892 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2893 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2894 }
2895
cec6a5b8
MR		 2896 if (e_flags & EF_SH_PIC)
2897 strcat (buf, ", pic");
2898
2899 if (e_flags & EF_SH_FDPIC)
2900 strcat (buf, ", fdpic");
ccde1100 2901 break;
73589c9d
CS		 2902
2903 case EM_OR1K:
2904 if (e_flags & EF_OR1K_NODELAY)
2905 strcat (buf, ", no delay");
2906 break;
57346661 2907
351b4b40
RH		 2908 case EM_SPARCV9:
2909 if (e_flags & EF_SPARC_32PLUS)
2910 strcat (buf, ", v8+");
2911
2912 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2913 strcat (buf, ", ultrasparcI");
2914
2915 if (e_flags & EF_SPARC_SUN_US3)
2916 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2917
2918 if (e_flags & EF_SPARC_HAL_R1)
2919 strcat (buf, ", halr1");
2920
2921 if (e_flags & EF_SPARC_LEDATA)
2922 strcat (buf, ", ledata");
2923
2924 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2925 strcat (buf, ", tso");
2926
2927 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2928 strcat (buf, ", pso");
2929
2930 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2931 strcat (buf, ", rmo");
2932 break;
7d466069 2933
103f02d3
UD		 2934 case EM_PARISC:
2935 switch (e_flags & EF_PARISC_ARCH)
2936 {
2937 case EFA_PARISC_1_0:
2938 strcpy (buf, ", PA-RISC 1.0");
2939 break;
2940 case EFA_PARISC_1_1:
2941 strcpy (buf, ", PA-RISC 1.1");
2942 break;
2943 case EFA_PARISC_2_0:
2944 strcpy (buf, ", PA-RISC 2.0");
2945 break;
2946 default:
2947 break;
2948 }
2949 if (e_flags & EF_PARISC_TRAPNIL)
2950 strcat (buf, ", trapnil");
2951 if (e_flags & EF_PARISC_EXT)
2952 strcat (buf, ", ext");
2953 if (e_flags & EF_PARISC_LSB)
2954 strcat (buf, ", lsb");
2955 if (e_flags & EF_PARISC_WIDE)
2956 strcat (buf, ", wide");
2957 if (e_flags & EF_PARISC_NO_KABP)
2958 strcat (buf, ", no kabp");
2959 if (e_flags & EF_PARISC_LAZYSWAP)
2960 strcat (buf, ", lazyswap");
30800947 2961 break;
76da6bbe 2962
7d466069 2963 case EM_PJ:
2b0337b0 2964 case EM_PJ_OLD:
7d466069
ILT		 2965 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2966 strcat (buf, ", new calling convention");
2967
2968 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2969 strcat (buf, ", gnu calling convention");
2970 break;
4d6ed7c8
NC		 2971
2972 case EM_IA_64:
2973 if ((e_flags & EF_IA_64_ABI64))
2974 strcat (buf, ", 64-bit");
2975 else
2976 strcat (buf, ", 32-bit");
2977 if ((e_flags & EF_IA_64_REDUCEDFP))
2978 strcat (buf, ", reduced fp model");
2979 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2980 strcat (buf, ", no function descriptors, constant gp");
2981 else if ((e_flags & EF_IA_64_CONS_GP))
2982 strcat (buf, ", constant gp");
2983 if ((e_flags & EF_IA_64_ABSOLUTE))
2984 strcat (buf, ", absolute");
28f997cf
TG		 2985 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2986 {
2987 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2988 strcat (buf, ", vms_linkages");
2989 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2990 {
2991 case EF_IA_64_VMS_COMCOD_SUCCESS:
2992 break;
2993 case EF_IA_64_VMS_COMCOD_WARNING:
2994 strcat (buf, ", warning");
2995 break;
2996 case EF_IA_64_VMS_COMCOD_ERROR:
2997 strcat (buf, ", error");
2998 break;
2999 case EF_IA_64_VMS_COMCOD_ABORT:
3000 strcat (buf, ", abort");
3001 break;
3002 default:
3003 abort ();
3004 }
3005 }
4d6ed7c8 3006 break;
179d3252
JT		 3007
3008 case EM_VAX:
3009 if ((e_flags & EF_VAX_NONPIC))
3010 strcat (buf, ", non-PIC");
3011 if ((e_flags & EF_VAX_DFLOAT))
3012 strcat (buf, ", D-Float");
3013 if ((e_flags & EF_VAX_GFLOAT))
3014 strcat (buf, ", G-Float");
3015 break;
c7927a3c 3016
4046d87a
NC		 3017 case EM_RL78:
3018 if (e_flags & E_FLAG_RL78_G10)
3019 strcat (buf, ", G10");
856ea05c
KP		 3020 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3021 strcat (buf, ", 64-bit doubles");
4046d87a 3022 break;
0b4362b0 3023
c7927a3c
NC		 3024 case EM_RX:
3025 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3026 strcat (buf, ", 64-bit doubles");
3027 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3028 strcat (buf, ", dsp");
d4cb0ea0 3029 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3030 strcat (buf, ", pid");
708e2187
NC		 3031 if (e_flags & E_FLAG_RX_ABI)
3032 strcat (buf, ", RX ABI");
d4cb0ea0 3033 break;
55786da2
AK		 3034
3035 case EM_S390:
3036 if (e_flags & EF_S390_HIGH_GPRS)
3037 strcat (buf, ", highgprs");
d4cb0ea0 3038 break;
40b36596
JM		 3039
3040 case EM_TI_C6000:
3041 if ((e_flags & EF_C6000_REL))
3042 strcat (buf, ", relocatable module");
d4cb0ea0 3043 break;
13761a11
NC		 3044
3045 case EM_MSP430:
3046 strcat (buf, _(": architecture variant: "));
3047 switch (e_flags & EF_MSP430_MACH)
3048 {
3049 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3050 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3051 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3052 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3053 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3054 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3055 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3056 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3057 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3058 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3059 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3060 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3061 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3062 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3063 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3064 default:
3065 strcat (buf, _(": unknown")); break;
3066 }
3067
3068 if (e_flags & ~ EF_MSP430_MACH)
3069 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3070 }
3071 }
3072
3073 return buf;
3074}
3075
252b5132 3076static const char *
d3ba0551
AM		 3077get_osabi_name (unsigned int osabi)
3078{
3079 static char buff[32];
3080
3081 switch (osabi)
3082 {
3083 case ELFOSABI_NONE: return "UNIX - System V";
3084 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3085 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3086 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3087 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3088 case ELFOSABI_AIX: return "UNIX - AIX";
3089 case ELFOSABI_IRIX: return "UNIX - IRIX";
3090 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3091 case ELFOSABI_TRU64: return "UNIX - TRU64";
3092 case ELFOSABI_MODESTO: return "Novell - Modesto";
3093 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3094 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3095 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3096 case ELFOSABI_AROS: return "AROS";
11636f9e 3097 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3098 default:
40b36596
JM		 3099 if (osabi >= 64)
3100 switch (elf_header.e_machine)
3101 {
3102 case EM_ARM:
3103 switch (osabi)
3104 {
3105 case ELFOSABI_ARM: return "ARM";
3106 default:
3107 break;
3108 }
3109 break;
3110
3111 case EM_MSP430:
3112 case EM_MSP430_OLD:
3113 switch (osabi)
3114 {
3115 case ELFOSABI_STANDALONE: return _("Standalone App");
3116 default:
3117 break;
3118 }
3119 break;
3120
3121 case EM_TI_C6000:
3122 switch (osabi)
3123 {
3124 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3125 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3126 default:
3127 break;
3128 }
3129 break;
3130
3131 default:
3132 break;
3133 }
e9e44622 3134 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3135 return buff;
3136 }
3137}
3138
a06ea964
NC		 3139static const char *
3140get_aarch64_segment_type (unsigned long type)
3141{
3142 switch (type)
3143 {
3144 case PT_AARCH64_ARCHEXT:
3145 return "AARCH64_ARCHEXT";
3146 default:
3147 break;
3148 }
3149
3150 return NULL;
3151}
3152
b294bdf8
MM		 3153static const char *
3154get_arm_segment_type (unsigned long type)
3155{
3156 switch (type)
3157 {
3158 case PT_ARM_EXIDX:
3159 return "EXIDX";
3160 default:
3161 break;
3162 }
3163
3164 return NULL;
3165}
3166
d3ba0551
AM		 3167static const char *
3168get_mips_segment_type (unsigned long type)
252b5132
RH		 3169{
3170 switch (type)
3171 {
3172 case PT_MIPS_REGINFO:
3173 return "REGINFO";
3174 case PT_MIPS_RTPROC:
3175 return "RTPROC";
3176 case PT_MIPS_OPTIONS:
3177 return "OPTIONS";
351cdf24
MF		 3178 case PT_MIPS_ABIFLAGS:
3179 return "ABIFLAGS";
252b5132
RH		 3180 default:
3181 break;
3182 }
3183
3184 return NULL;
3185}
3186
103f02d3 3187static const char *
d3ba0551 3188get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3189{
3190 switch (type)
3191 {
3192 case PT_HP_TLS: return "HP_TLS";
3193 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3194 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3195 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3196 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3197 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3198 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3199 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3200 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3201 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3202 case PT_HP_PARALLEL: return "HP_PARALLEL";
3203 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3204 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3205 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3206 case PT_HP_STACK: return "HP_STACK";
3207 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3208 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3209 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3210 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3211 default:
3212 break;
3213 }
3214
3215 return NULL;
3216}
3217
4d6ed7c8 3218static const char *
d3ba0551 3219get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3220{
3221 switch (type)
3222 {
3223 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3224 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3225 case PT_HP_TLS: return "HP_TLS";
3226 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3227 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3228 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3229 default:
3230 break;
3231 }
3232
3233 return NULL;
3234}
3235
40b36596
JM		 3236static const char *
3237get_tic6x_segment_type (unsigned long type)
3238{
3239 switch (type)
3240 {
3241 case PT_C6000_PHATTR: return "C6000_PHATTR";
3242 default:
3243 break;
3244 }
3245
3246 return NULL;
3247}
3248
252b5132 3249static const char *
d3ba0551 3250get_segment_type (unsigned long p_type)
252b5132 3251{
b34976b6 3252 static char buff[32];
252b5132
RH		 3253
3254 switch (p_type)
3255 {
b34976b6
AM		 3256 case PT_NULL: return "NULL";
3257 case PT_LOAD: return "LOAD";
252b5132 3258 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3259 case PT_INTERP: return "INTERP";
3260 case PT_NOTE: return "NOTE";
3261 case PT_SHLIB: return "SHLIB";
3262 case PT_PHDR: return "PHDR";
13ae64f3 3263 case PT_TLS: return "TLS";
252b5132 3264
65765700
JJ		 3265 case PT_GNU_EH_FRAME:
3266 return "GNU_EH_FRAME";
2b05f1b7 3267 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3268 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3269
252b5132
RH		 3270 default:
3271 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3272 {
2cf0635d 3273 const char * result;
103f02d3 3274
252b5132
RH		 3275 switch (elf_header.e_machine)
3276 {
a06ea964
NC		 3277 case EM_AARCH64:
3278 result = get_aarch64_segment_type (p_type);
3279 break;
b294bdf8
MM		 3280 case EM_ARM:
3281 result = get_arm_segment_type (p_type);
3282 break;
252b5132 3283 case EM_MIPS:
4fe85591 3284 case EM_MIPS_RS3_LE:
252b5132
RH		 3285 result = get_mips_segment_type (p_type);
3286 break;
103f02d3
UD		 3287 case EM_PARISC:
3288 result = get_parisc_segment_type (p_type);
3289 break;
4d6ed7c8
NC		 3290 case EM_IA_64:
3291 result = get_ia64_segment_type (p_type);
3292 break;
40b36596
JM		 3293 case EM_TI_C6000:
3294 result = get_tic6x_segment_type (p_type);
3295 break;
252b5132
RH		 3296 default:
3297 result = NULL;
3298 break;
3299 }
103f02d3 3300
252b5132
RH		 3301 if (result != NULL)
3302 return result;
103f02d3 3303
252b5132
RH		 3304 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3305 }
3306 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3307 {
2cf0635d 3308 const char * result;
103f02d3
UD		 3309
3310 switch (elf_header.e_machine)
3311 {
3312 case EM_PARISC:
3313 result = get_parisc_segment_type (p_type);
3314 break;
00428cca
AM		 3315 case EM_IA_64:
3316 result = get_ia64_segment_type (p_type);
3317 break;
103f02d3
UD		 3318 default:
3319 result = NULL;
3320 break;
3321 }
3322
3323 if (result != NULL)
3324 return result;
3325
3326 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3327 }
252b5132 3328 else
e9e44622 3329 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3330
3331 return buff;
3332 }
3333}
3334
3335static const char *
d3ba0551 3336get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3337{
3338 switch (sh_type)
3339 {
b34976b6
AM		 3340 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3341 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3342 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3343 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3344 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3345 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3346 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3347 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3348 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3349 case SHT_MIPS_RELD: return "MIPS_RELD";
3350 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3351 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3352 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3353 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3354 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3355 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3356 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3357 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3358 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3359 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3360 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3361 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3362 case SHT_MIPS_LINE: return "MIPS_LINE";
3363 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3364 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3365 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3366 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3367 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3368 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3369 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3370 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3371 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3372 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3373 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3374 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3375 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3376 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3377 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3378 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3379 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3380 default:
3381 break;
3382 }
3383 return NULL;
3384}
3385
103f02d3 3386static const char *
d3ba0551 3387get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3388{
3389 switch (sh_type)
3390 {
3391 case SHT_PARISC_EXT: return "PARISC_EXT";
3392 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3393 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3394 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3395 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3396 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3397 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3398 default:
3399 break;
3400 }
3401 return NULL;
3402}
3403
4d6ed7c8 3404static const char *
d3ba0551 3405get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3406{
18bd398b 3407 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3408 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3409 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3410
4d6ed7c8
NC		 3411 switch (sh_type)
3412 {
148b93f2
NC		 3413 case SHT_IA_64_EXT: return "IA_64_EXT";
3414 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3415 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3416 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3417 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3418 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3419 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3420 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3421 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3422 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3423 default:
3424 break;
3425 }
3426 return NULL;
3427}
3428
d2b2c203
DJ		 3429static const char *
3430get_x86_64_section_type_name (unsigned int sh_type)
3431{
3432 switch (sh_type)
3433 {
3434 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3435 default:
3436 break;
3437 }
3438 return NULL;
3439}
3440
a06ea964
NC		 3441static const char *
3442get_aarch64_section_type_name (unsigned int sh_type)
3443{
3444 switch (sh_type)
3445 {
3446 case SHT_AARCH64_ATTRIBUTES:
3447 return "AARCH64_ATTRIBUTES";
3448 default:
3449 break;
3450 }
3451 return NULL;
3452}
3453
40a18ebd
NC		 3454static const char *
3455get_arm_section_type_name (unsigned int sh_type)
3456{
3457 switch (sh_type)
3458 {
7f6fed87
NC		 3459 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3460 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3461 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3462 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3463 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3464 default:
3465 break;
3466 }
3467 return NULL;
3468}
3469
40b36596
JM		 3470static const char *
3471get_tic6x_section_type_name (unsigned int sh_type)
3472{
3473 switch (sh_type)
3474 {
3475 case SHT_C6000_UNWIND:
3476 return "C6000_UNWIND";
3477 case SHT_C6000_PREEMPTMAP:
3478 return "C6000_PREEMPTMAP";
3479 case SHT_C6000_ATTRIBUTES:
3480 return "C6000_ATTRIBUTES";
3481 case SHT_TI_ICODE:
3482 return "TI_ICODE";
3483 case SHT_TI_XREF:
3484 return "TI_XREF";
3485 case SHT_TI_HANDLER:
3486 return "TI_HANDLER";
3487 case SHT_TI_INITINFO:
3488 return "TI_INITINFO";
3489 case SHT_TI_PHATTRS:
3490 return "TI_PHATTRS";
3491 default:
3492 break;
3493 }
3494 return NULL;
3495}
3496
13761a11
NC		 3497static const char *
3498get_msp430x_section_type_name (unsigned int sh_type)
3499{
3500 switch (sh_type)
3501 {
3502 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3503 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3504 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3505 default: return NULL;
3506 }
3507}
3508
252b5132 3509static const char *
d3ba0551 3510get_section_type_name (unsigned int sh_type)
252b5132 3511{
b34976b6 3512 static char buff[32];
252b5132
RH		 3513
3514 switch (sh_type)
3515 {
3516 case SHT_NULL: return "NULL";
3517 case SHT_PROGBITS: return "PROGBITS";
3518 case SHT_SYMTAB: return "SYMTAB";
3519 case SHT_STRTAB: return "STRTAB";
3520 case SHT_RELA: return "RELA";
3521 case SHT_HASH: return "HASH";
3522 case SHT_DYNAMIC: return "DYNAMIC";
3523 case SHT_NOTE: return "NOTE";
3524 case SHT_NOBITS: return "NOBITS";
3525 case SHT_REL: return "REL";
3526 case SHT_SHLIB: return "SHLIB";
3527 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3528 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3529 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3530 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3531 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3532 case SHT_GROUP: return "GROUP";
3533 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3534 case SHT_GNU_verdef: return "VERDEF";
3535 case SHT_GNU_verneed: return "VERNEED";
3536 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3537 case 0x6ffffff0: return "VERSYM";
3538 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3539 case 0x7ffffffd: return "AUXILIARY";
3540 case 0x7fffffff: return "FILTER";
047b2264 3541 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3542
3543 default:
3544 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3545 {
2cf0635d 3546 const char * result;
252b5132
RH		 3547
3548 switch (elf_header.e_machine)
3549 {
3550 case EM_MIPS:
4fe85591 3551 case EM_MIPS_RS3_LE:
252b5132
RH		 3552 result = get_mips_section_type_name (sh_type);
3553 break;
103f02d3
UD		 3554 case EM_PARISC:
3555 result = get_parisc_section_type_name (sh_type);
3556 break;
4d6ed7c8
NC		 3557 case EM_IA_64:
3558 result = get_ia64_section_type_name (sh_type);
3559 break;
d2b2c203 3560 case EM_X86_64:
8a9036a4 3561 case EM_L1OM:
7a9068fe 3562 case EM_K1OM:
d2b2c203
DJ		 3563 result = get_x86_64_section_type_name (sh_type);
3564 break;
a06ea964
NC		 3565 case EM_AARCH64:
3566 result = get_aarch64_section_type_name (sh_type);
3567 break;
40a18ebd
NC		 3568 case EM_ARM:
3569 result = get_arm_section_type_name (sh_type);
3570 break;
40b36596
JM		 3571 case EM_TI_C6000:
3572 result = get_tic6x_section_type_name (sh_type);
3573 break;
13761a11
NC		 3574 case EM_MSP430:
3575 result = get_msp430x_section_type_name (sh_type);
3576 break;
252b5132
RH		 3577 default:
3578 result = NULL;
3579 break;
3580 }
3581
3582 if (result != NULL)
3583 return result;
3584
c91d0dfb 3585 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3586 }
3587 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3588 {
2cf0635d 3589 const char * result;
148b93f2
NC		 3590
3591 switch (elf_header.e_machine)
3592 {
3593 case EM_IA_64:
3594 result = get_ia64_section_type_name (sh_type);
3595 break;
3596 default:
3597 result = NULL;
3598 break;
3599 }
3600
3601 if (result != NULL)
3602 return result;
3603
3604 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3605 }
252b5132 3606 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3607 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3608 else
a7dbfd1c
NC		 3609 /* This message is probably going to be displayed in a 15
3610 character wide field, so put the hex value first. */
3611 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3612
252b5132
RH		 3613 return buff;
3614 }
3615}
3616
2979dc34 3617#define OPTION_DEBUG_DUMP 512
2c610e4b 3618#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3619#define OPTION_DWARF_DEPTH 514
3620#define OPTION_DWARF_START 515
4723351a 3621#define OPTION_DWARF_CHECK 516
2979dc34 3622
85b1c36d 3623static struct option options[] =
252b5132 3624{
b34976b6 3625 {"all", no_argument, 0, 'a'},
252b5132
RH		 3626 {"file-header", no_argument, 0, 'h'},
3627 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3628 {"headers", no_argument, 0, 'e'},
3629 {"histogram", no_argument, 0, 'I'},
3630 {"segments", no_argument, 0, 'l'},
3631 {"sections", no_argument, 0, 'S'},
252b5132 3632 {"section-headers", no_argument, 0, 'S'},
f5842774 3633 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3634 {"section-details", no_argument, 0, 't'},
595cf52e 3635 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3636 {"symbols", no_argument, 0, 's'},
3637 {"syms", no_argument, 0, 's'},
2c610e4b 3638 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3639 {"relocs", no_argument, 0, 'r'},
3640 {"notes", no_argument, 0, 'n'},
3641 {"dynamic", no_argument, 0, 'd'},
a952a375 3642 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3643 {"version-info", no_argument, 0, 'V'},
3644 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3645 {"unwind", no_argument, 0, 'u'},
4145f1d5 3646 {"archive-index", no_argument, 0, 'c'},
b34976b6 3647 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3648 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3649 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3650#ifdef SUPPORT_DISASSEMBLY
3651 {"instruction-dump", required_argument, 0, 'i'},
3652#endif
cf13d699 3653 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3654
fd2f0033
TT		 3655 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3656 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3657 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3658
b34976b6
AM		 3659 {"version", no_argument, 0, 'v'},
3660 {"wide", no_argument, 0, 'W'},
3661 {"help", no_argument, 0, 'H'},
3662 {0, no_argument, 0, 0}
252b5132
RH		 3663};
3664
3665static void
2cf0635d 3666usage (FILE * stream)
252b5132 3667{
92f01d61
JM		 3668 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3669 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3670 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3671 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3672 -h --file-header Display the ELF file header\n\
3673 -l --program-headers Display the program headers\n\
3674 --segments An alias for --program-headers\n\
3675 -S --section-headers Display the sections' header\n\
3676 --sections An alias for --section-headers\n\
f5842774 3677 -g --section-groups Display the section groups\n\
5477e8a0 3678 -t --section-details Display the section details\n\
8b53311e
NC		 3679 -e --headers Equivalent to: -h -l -S\n\
3680 -s --syms Display the symbol table\n\
3f08eb35 3681 --symbols An alias for --syms\n\
2c610e4b 3682 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3683 -n --notes Display the core notes (if present)\n\
3684 -r --relocs Display the relocations (if present)\n\
3685 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3686 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3687 -V --version-info Display the version sections (if present)\n\
1b31d05e 3688 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3689 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3690 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3691 -x --hex-dump=<number|name>\n\
3692 Dump the contents of section <number|name> as bytes\n\
3693 -p --string-dump=<number|name>\n\
3694 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3695 -R --relocated-dump=<number|name>\n\
3696 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3697 -w[lLiaprmfFsoRt] or\n\
1ed06042 3698 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3699 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3700 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3701 =addr,=cu_index]\n\
8b53311e 3702 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3703 fprintf (stream, _("\
3704 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3705 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3706 or deeper\n"));
252b5132 3707#ifdef SUPPORT_DISASSEMBLY
92f01d61 3708 fprintf (stream, _("\
09c11c86
NC		 3709 -i --instruction-dump=<number|name>\n\
3710 Disassemble the contents of section <number|name>\n"));
252b5132 3711#endif
92f01d61 3712 fprintf (stream, _("\
8b53311e
NC		 3713 -I --histogram Display histogram of bucket list lengths\n\
3714 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3715 @<file> Read options from <file>\n\
8b53311e
NC		 3716 -H --help Display this information\n\
3717 -v --version Display the version number of readelf\n"));
1118d252 3718
92f01d61
JM		 3719 if (REPORT_BUGS_TO[0] && stream == stdout)
3720 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3721
92f01d61 3722 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3723}
3724
18bd398b
NC		 3725/* Record the fact that the user wants the contents of section number
3726 SECTION to be displayed using the method(s) encoded as flags bits
3727 in TYPE. Note, TYPE can be zero if we are creating the array for
3728 the first time. */
3729
252b5132 3730static void
09c11c86 3731request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3732{
3733 if (section >= num_dump_sects)
3734 {
2cf0635d 3735 dump_type * new_dump_sects;
252b5132 3736
3f5e193b
NC		 3737 new_dump_sects = (dump_type *) calloc (section + 1,
3738 sizeof (* dump_sects));
252b5132
RH		 3739
3740 if (new_dump_sects == NULL)
591a748a 3741 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3742 else
3743 {
3744 /* Copy current flag settings. */
09c11c86 3745 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3746
3747 free (dump_sects);
3748
3749 dump_sects = new_dump_sects;
3750 num_dump_sects = section + 1;
3751 }
3752 }
3753
3754 if (dump_sects)
b34976b6 3755 dump_sects[section] |= type;
252b5132
RH		 3756
3757 return;
3758}
3759
aef1f6d0
DJ		 3760/* Request a dump by section name. */
3761
3762static void
2cf0635d 3763request_dump_byname (const char * section, dump_type type)
aef1f6d0 3764{
2cf0635d 3765 struct dump_list_entry * new_request;
aef1f6d0 3766
3f5e193b
NC		 3767 new_request = (struct dump_list_entry *)
3768 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3769 if (!new_request)
591a748a 3770 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3771
3772 new_request->name = strdup (section);
3773 if (!new_request->name)
591a748a 3774 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3775
3776 new_request->type = type;
3777
3778 new_request->next = dump_sects_byname;
3779 dump_sects_byname = new_request;
3780}
3781
cf13d699
NC		 3782static inline void
3783request_dump (dump_type type)
3784{
3785 int section;
3786 char * cp;
3787
3788 do_dump++;
3789 section = strtoul (optarg, & cp, 0);
3790
3791 if (! *cp && section >= 0)
3792 request_dump_bynumber (section, type);
3793 else
3794 request_dump_byname (optarg, type);
3795}
3796
3797
252b5132 3798static void
2cf0635d 3799parse_args (int argc, char ** argv)
252b5132
RH		 3800{
3801 int c;
3802
3803 if (argc < 2)
92f01d61 3804 usage (stderr);
252b5132
RH		 3805
3806 while ((c = getopt_long
cf13d699 3807 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3808 {
252b5132
RH		 3809 switch (c)
3810 {
3811 case 0:
3812 /* Long options. */
3813 break;
3814 case 'H':
92f01d61 3815 usage (stdout);
252b5132
RH		 3816 break;
3817
3818 case 'a':
b34976b6
AM		 3819 do_syms++;
3820 do_reloc++;
3821 do_unwind++;
3822 do_dynamic++;
3823 do_header++;
3824 do_sections++;
f5842774 3825 do_section_groups++;
b34976b6
AM		 3826 do_segments++;
3827 do_version++;
3828 do_histogram++;
3829 do_arch++;
3830 do_notes++;
252b5132 3831 break;
f5842774
L		 3832 case 'g':
3833 do_section_groups++;
3834 break;
5477e8a0 3835 case 't':
595cf52e 3836 case 'N':
5477e8a0
L		 3837 do_sections++;
3838 do_section_details++;
595cf52e 3839 break;
252b5132 3840 case 'e':
b34976b6
AM		 3841 do_header++;
3842 do_sections++;
3843 do_segments++;
252b5132 3844 break;
a952a375 3845 case 'A':
b34976b6 3846 do_arch++;
a952a375 3847 break;
252b5132 3848 case 'D':
b34976b6 3849 do_using_dynamic++;
252b5132
RH		 3850 break;
3851 case 'r':
b34976b6 3852 do_reloc++;
252b5132 3853 break;
4d6ed7c8 3854 case 'u':
b34976b6 3855 do_unwind++;
4d6ed7c8 3856 break;
252b5132 3857 case 'h':
b34976b6 3858 do_header++;
252b5132
RH		 3859 break;
3860 case 'l':
b34976b6 3861 do_segments++;
252b5132
RH		 3862 break;
3863 case 's':
b34976b6 3864 do_syms++;
252b5132
RH		 3865 break;
3866 case 'S':
b34976b6 3867 do_sections++;
252b5132
RH		 3868 break;
3869 case 'd':
b34976b6 3870 do_dynamic++;
252b5132 3871 break;
a952a375 3872 case 'I':
b34976b6 3873 do_histogram++;
a952a375 3874 break;
779fe533 3875 case 'n':
b34976b6 3876 do_notes++;
779fe533 3877 break;
4145f1d5
NC		 3878 case 'c':
3879 do_archive_index++;
3880 break;
252b5132 3881 case 'x':
cf13d699 3882 request_dump (HEX_DUMP);
aef1f6d0 3883 break;
09c11c86 3884 case 'p':
cf13d699
NC		 3885 request_dump (STRING_DUMP);
3886 break;
3887 case 'R':
3888 request_dump (RELOC_DUMP);
09c11c86 3889 break;
252b5132 3890 case 'w':
b34976b6 3891 do_dump++;
252b5132 3892 if (optarg == 0)
613ff48b
CC		 3893 {
3894 do_debugging = 1;
3895 dwarf_select_sections_all ();
3896 }
252b5132
RH		 3897 else
3898 {
3899 do_debugging = 0;
4cb93e3b 3900 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3901 }
3902 break;
2979dc34 3903 case OPTION_DEBUG_DUMP:
b34976b6 3904 do_dump++;
2979dc34
JJ		 3905 if (optarg == 0)
3906 do_debugging = 1;
3907 else
3908 {
2979dc34 3909 do_debugging = 0;
4cb93e3b 3910 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3911 }
3912 break;
fd2f0033
TT		 3913 case OPTION_DWARF_DEPTH:
3914 {
3915 char *cp;
3916
3917 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3918 }
3919 break;
3920 case OPTION_DWARF_START:
3921 {
3922 char *cp;
3923
3924 dwarf_start_die = strtoul (optarg, & cp, 0);
3925 }
3926 break;
4723351a
CC		 3927 case OPTION_DWARF_CHECK:
3928 dwarf_check = 1;
3929 break;
2c610e4b
L		 3930 case OPTION_DYN_SYMS:
3931 do_dyn_syms++;
3932 break;
252b5132
RH		 3933#ifdef SUPPORT_DISASSEMBLY
3934 case 'i':
cf13d699
NC		 3935 request_dump (DISASS_DUMP);
3936 break;
252b5132
RH		 3937#endif
3938 case 'v':
3939 print_version (program_name);
3940 break;
3941 case 'V':
b34976b6 3942 do_version++;
252b5132 3943 break;
d974e256 3944 case 'W':
b34976b6 3945 do_wide++;
d974e256 3946 break;
252b5132 3947 default:
252b5132
RH		 3948 /* xgettext:c-format */
3949 error (_("Invalid option '-%c'\n"), c);
3950 /* Drop through. */
3951 case '?':
92f01d61 3952 usage (stderr);
252b5132
RH		 3953 }
3954 }
3955
4d6ed7c8 3956 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3957 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3958 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3959 && !do_section_groups && !do_archive_index
3960 && !do_dyn_syms)
92f01d61 3961 usage (stderr);
252b5132
RH		 3962 else if (argc < 3)
3963 {
3964 warn (_("Nothing to do.\n"));
92f01d61 3965 usage (stderr);
252b5132
RH		 3966 }
3967}
3968
3969static const char *
d3ba0551 3970get_elf_class (unsigned int elf_class)
252b5132 3971{
b34976b6 3972 static char buff[32];
103f02d3 3973
252b5132
RH		 3974 switch (elf_class)
3975 {
3976 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3977 case ELFCLASS32: return "ELF32";
3978 case ELFCLASS64: return "ELF64";
ab5e7794 3979 default:
e9e44622 3980 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3981 return buff;
252b5132
RH		 3982 }
3983}
3984
3985static const char *
d3ba0551 3986get_data_encoding (unsigned int encoding)
252b5132 3987{
b34976b6 3988 static char buff[32];
103f02d3 3989
252b5132
RH		 3990 switch (encoding)
3991 {
3992 case ELFDATANONE: return _("none");
33c63f9d
CM		 3993 case ELFDATA2LSB: return _("2's complement, little endian");
3994 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3995 default:
e9e44622 3996 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3997 return buff;
252b5132
RH		 3998 }
3999}
4000
252b5132 4001/* Decode the data held in 'elf_header'. */
ee42cf8c 4002
252b5132 4003static int
d3ba0551 4004process_file_header (void)
252b5132 4005{
b34976b6
AM		 4006 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4007 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4008 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4009 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4010 {
4011 error
4012 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4013 return 0;
4014 }
4015
2dc4cec1
L		 4016 init_dwarf_regnames (elf_header.e_machine);
4017
252b5132
RH		 4018 if (do_header)
4019 {
4020 int i;
4021
4022 printf (_("ELF Header:\n"));
4023 printf (_(" Magic: "));
b34976b6
AM		 4024 for (i = 0; i < EI_NIDENT; i++)
4025 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4026 printf ("\n");
4027 printf (_(" Class: %s\n"),
b34976b6 4028 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4029 printf (_(" Data: %s\n"),
b34976b6 4030 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4031 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4032 elf_header.e_ident[EI_VERSION],
4033 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4034 ? "(current)"
b34976b6 4035 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4036 ? _("<unknown: %lx>")
789be9f7 4037 : "")));
252b5132 4038 printf (_(" OS/ABI: %s\n"),
b34976b6 4039 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4040 printf (_(" ABI Version: %d\n"),
b34976b6 4041 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4042 printf (_(" Type: %s\n"),
4043 get_file_type (elf_header.e_type));
4044 printf (_(" Machine: %s\n"),
4045 get_machine_name (elf_header.e_machine));
4046 printf (_(" Version: 0x%lx\n"),
4047 (unsigned long) elf_header.e_version);
76da6bbe 4048
f7a99963
NC		 4049 printf (_(" Entry point address: "));
4050 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4051 printf (_("\n Start of program headers: "));
4052 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4053 printf (_(" (bytes into file)\n Start of section headers: "));
4054 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4055 printf (_(" (bytes into file)\n"));
76da6bbe 4056
252b5132
RH		 4057 printf (_(" Flags: 0x%lx%s\n"),
4058 (unsigned long) elf_header.e_flags,
4059 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4060 printf (_(" Size of this header: %ld (bytes)\n"),
4061 (long) elf_header.e_ehsize);
4062 printf (_(" Size of program headers: %ld (bytes)\n"),
4063 (long) elf_header.e_phentsize);
2046a35d 4064 printf (_(" Number of program headers: %ld"),
252b5132 4065 (long) elf_header.e_phnum);
2046a35d
AM		 4066 if (section_headers != NULL
4067 && elf_header.e_phnum == PN_XNUM
4068 && section_headers[0].sh_info != 0)
cc5914eb 4069 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4070 putc ('\n', stdout);
252b5132
RH		 4071 printf (_(" Size of section headers: %ld (bytes)\n"),
4072 (long) elf_header.e_shentsize);
560f3c1c 4073 printf (_(" Number of section headers: %ld"),
252b5132 4074 (long) elf_header.e_shnum);
4fbb74a6 4075 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4076 printf (" (%ld)", (long) section_headers[0].sh_size);
4077 putc ('\n', stdout);
4078 printf (_(" Section header string table index: %ld"),
252b5132 4079 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4080 if (section_headers != NULL
4081 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4082 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4083 else if (elf_header.e_shstrndx != SHN_UNDEF
4084 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4085 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4086 putc ('\n', stdout);
4087 }
4088
4089 if (section_headers != NULL)
4090 {
2046a35d
AM		 4091 if (elf_header.e_phnum == PN_XNUM
4092 && section_headers[0].sh_info != 0)
4093 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4094 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4095 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4096 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4097 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4098 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4099 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4100 free (section_headers);
4101 section_headers = NULL;
252b5132 4102 }
103f02d3 4103
9ea033b2
NC		 4104 return 1;
4105}
4106
e0a31db1 4107static bfd_boolean
91d6fa6a 4108get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4109{
2cf0635d
NC		 4110 Elf32_External_Phdr * phdrs;
4111 Elf32_External_Phdr * external;
4112 Elf_Internal_Phdr * internal;
b34976b6 4113 unsigned int i;
e0a31db1
NC		 4114 unsigned int size = elf_header.e_phentsize;
4115 unsigned int num = elf_header.e_phnum;
4116
4117 /* PR binutils/17531: Cope with unexpected section header sizes. */
4118 if (size == 0 || num == 0)
4119 return FALSE;
4120 if (size < sizeof * phdrs)
4121 {
4122 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4123 return FALSE;
4124 }
4125 if (size > sizeof * phdrs)
4126 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4127
3f5e193b 4128 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4129 size, num, _("program headers"));
4130 if (phdrs == NULL)
4131 return FALSE;
9ea033b2 4132
91d6fa6a 4133 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4134 i < elf_header.e_phnum;
b34976b6 4135 i++, internal++, external++)
252b5132 4136 {
9ea033b2
NC		 4137 internal->p_type = BYTE_GET (external->p_type);
4138 internal->p_offset = BYTE_GET (external->p_offset);
4139 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4140 internal->p_paddr = BYTE_GET (external->p_paddr);
4141 internal->p_filesz = BYTE_GET (external->p_filesz);
4142 internal->p_memsz = BYTE_GET (external->p_memsz);
4143 internal->p_flags = BYTE_GET (external->p_flags);
4144 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4145 }
4146
9ea033b2 4147 free (phdrs);
e0a31db1 4148 return TRUE;
252b5132
RH		 4149}
4150
e0a31db1 4151static bfd_boolean
91d6fa6a 4152get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4153{
2cf0635d
NC		 4154 Elf64_External_Phdr * phdrs;
4155 Elf64_External_Phdr * external;
4156 Elf_Internal_Phdr * internal;
b34976b6 4157 unsigned int i;
e0a31db1
NC		 4158 unsigned int size = elf_header.e_phentsize;
4159 unsigned int num = elf_header.e_phnum;
4160
4161 /* PR binutils/17531: Cope with unexpected section header sizes. */
4162 if (size == 0 || num == 0)
4163 return FALSE;
4164 if (size < sizeof * phdrs)
4165 {
4166 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4167 return FALSE;
4168 }
4169 if (size > sizeof * phdrs)
4170 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4171
3f5e193b 4172 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4173 size, num, _("program headers"));
a6e9f9df 4174 if (!phdrs)
e0a31db1 4175 return FALSE;
9ea033b2 4176
91d6fa6a 4177 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4178 i < elf_header.e_phnum;
b34976b6 4179 i++, internal++, external++)
9ea033b2
NC		 4180 {
4181 internal->p_type = BYTE_GET (external->p_type);
4182 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4183 internal->p_offset = BYTE_GET (external->p_offset);
4184 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4185 internal->p_paddr = BYTE_GET (external->p_paddr);
4186 internal->p_filesz = BYTE_GET (external->p_filesz);
4187 internal->p_memsz = BYTE_GET (external->p_memsz);
4188 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4189 }
4190
4191 free (phdrs);
e0a31db1 4192 return TRUE;
9ea033b2 4193}
252b5132 4194
d93f0186
NC		 4195/* Returns 1 if the program headers were read into `program_headers'. */
4196
4197static int
2cf0635d 4198get_program_headers (FILE * file)
d93f0186 4199{
2cf0635d 4200 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4201
4202 /* Check cache of prior read. */
4203 if (program_headers != NULL)
4204 return 1;
4205
3f5e193b
NC		 4206 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4207 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4208
4209 if (phdrs == NULL)
4210 {
4211 error (_("Out of memory\n"));
4212 return 0;
4213 }
4214
4215 if (is_32bit_elf
4216 ? get_32bit_program_headers (file, phdrs)
4217 : get_64bit_program_headers (file, phdrs))
4218 {
4219 program_headers = phdrs;
4220 return 1;
4221 }
4222
4223 free (phdrs);
4224 return 0;
4225}
4226
2f62977e
NC		 4227/* Returns 1 if the program headers were loaded. */
4228
252b5132 4229static int
2cf0635d 4230process_program_headers (FILE * file)
252b5132 4231{
2cf0635d 4232 Elf_Internal_Phdr * segment;
b34976b6 4233 unsigned int i;
252b5132
RH		 4234
4235 if (elf_header.e_phnum == 0)
4236 {
82f2dbf7
NC		 4237 /* PR binutils/12467. */
4238 if (elf_header.e_phoff != 0)
4239 warn (_("possibly corrupt ELF header - it has a non-zero program"
4240 " header offset, but no program headers"));
4241 else if (do_segments)
252b5132 4242 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4243 return 0;
252b5132
RH		 4244 }
4245
4246 if (do_segments && !do_header)
4247 {
f7a99963
NC		 4248 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4249 printf (_("Entry point "));
4250 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4251 printf (_("\nThere are %d program headers, starting at offset "),
4252 elf_header.e_phnum);
4253 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4254 printf ("\n");
252b5132
RH		 4255 }
4256
d93f0186 4257 if (! get_program_headers (file))
252b5132 4258 return 0;
103f02d3 4259
252b5132
RH		 4260 if (do_segments)
4261 {
3a1a2036
NC		 4262 if (elf_header.e_phnum > 1)
4263 printf (_("\nProgram Headers:\n"));
4264 else
4265 printf (_("\nProgram Headers:\n"));
76da6bbe 4266
f7a99963
NC		 4267 if (is_32bit_elf)
4268 printf
4269 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4270 else if (do_wide)
4271 printf
4272 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4273 else
4274 {
4275 printf
4276 (_(" Type Offset VirtAddr PhysAddr\n"));
4277 printf
4278 (_(" FileSiz MemSiz Flags Align\n"));
4279 }
252b5132
RH		 4280 }
4281
252b5132 4282 dynamic_addr = 0;
1b228002 4283 dynamic_size = 0;
252b5132
RH		 4284
4285 for (i = 0, segment = program_headers;
4286 i < elf_header.e_phnum;
b34976b6 4287 i++, segment++)
252b5132
RH		 4288 {
4289 if (do_segments)
4290 {
103f02d3 4291 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4292
4293 if (is_32bit_elf)
4294 {
4295 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4296 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4297 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4298 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4299 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4300 printf ("%c%c%c ",
4301 (segment->p_flags & PF_R ? 'R' : ' '),
4302 (segment->p_flags & PF_W ? 'W' : ' '),
4303 (segment->p_flags & PF_X ? 'E' : ' '));
4304 printf ("%#lx", (unsigned long) segment->p_align);
4305 }
d974e256
JJ		 4306 else if (do_wide)
4307 {
4308 if ((unsigned long) segment->p_offset == segment->p_offset)
4309 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4310 else
4311 {
4312 print_vma (segment->p_offset, FULL_HEX);
4313 putchar (' ');
4314 }
4315
4316 print_vma (segment->p_vaddr, FULL_HEX);
4317 putchar (' ');
4318 print_vma (segment->p_paddr, FULL_HEX);
4319 putchar (' ');
4320
4321 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4322 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4323 else
4324 {
4325 print_vma (segment->p_filesz, FULL_HEX);
4326 putchar (' ');
4327 }
4328
4329 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4330 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4331 else
4332 {
f48e6c45 4333 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4334 }
4335
4336 printf (" %c%c%c ",
4337 (segment->p_flags & PF_R ? 'R' : ' '),
4338 (segment->p_flags & PF_W ? 'W' : ' '),
4339 (segment->p_flags & PF_X ? 'E' : ' '));
4340
4341 if ((unsigned long) segment->p_align == segment->p_align)
4342 printf ("%#lx", (unsigned long) segment->p_align);
4343 else
4344 {
4345 print_vma (segment->p_align, PREFIX_HEX);
4346 }
4347 }
f7a99963
NC		 4348 else
4349 {
4350 print_vma (segment->p_offset, FULL_HEX);
4351 putchar (' ');
4352 print_vma (segment->p_vaddr, FULL_HEX);
4353 putchar (' ');
4354 print_vma (segment->p_paddr, FULL_HEX);
4355 printf ("\n ");
4356 print_vma (segment->p_filesz, FULL_HEX);
4357 putchar (' ');
4358 print_vma (segment->p_memsz, FULL_HEX);
4359 printf (" %c%c%c ",
4360 (segment->p_flags & PF_R ? 'R' : ' '),
4361 (segment->p_flags & PF_W ? 'W' : ' '),
4362 (segment->p_flags & PF_X ? 'E' : ' '));
4363 print_vma (segment->p_align, HEX);
4364 }
252b5132
RH		 4365 }
4366
f54498b4
NC		 4367 if (do_segments)
4368 putc ('\n', stdout);
4369
252b5132
RH		 4370 switch (segment->p_type)
4371 {
252b5132
RH		 4372 case PT_DYNAMIC:
4373 if (dynamic_addr)
4374 error (_("more than one dynamic segment\n"));
4375
20737c13
AM		 4376 /* By default, assume that the .dynamic section is the first
4377 section in the DYNAMIC segment. */
4378 dynamic_addr = segment->p_offset;
4379 dynamic_size = segment->p_filesz;
f54498b4
NC		 4380 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4381 if (dynamic_addr + dynamic_size >= current_file_size)
4382 {
4383 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4384 dynamic_addr = dynamic_size = 0;
4385 }
20737c13 4386
b2d38a17
NC		 4387 /* Try to locate the .dynamic section. If there is
4388 a section header table, we can easily locate it. */
4389 if (section_headers != NULL)
4390 {
2cf0635d 4391 Elf_Internal_Shdr * sec;
b2d38a17 4392
89fac5e3
RS		 4393 sec = find_section (".dynamic");
4394 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4395 {
28f997cf
TG		 4396 /* A corresponding .dynamic section is expected, but on
4397 IA-64/OpenVMS it is OK for it to be missing. */
4398 if (!is_ia64_vms ())
4399 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4400 break;
4401 }
4402
42bb2e33 4403 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4404 {
4405 dynamic_size = 0;
4406 break;
4407 }
42bb2e33 4408
b2d38a17
NC		 4409 dynamic_addr = sec->sh_offset;
4410 dynamic_size = sec->sh_size;
4411
4412 if (dynamic_addr < segment->p_offset
4413 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4414 warn (_("the .dynamic section is not contained"
4415 " within the dynamic segment\n"));
b2d38a17 4416 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4417 warn (_("the .dynamic section is not the first section"
4418 " in the dynamic segment.\n"));
b2d38a17 4419 }
252b5132
RH		 4420 break;
4421
4422 case PT_INTERP:
fb52b2f4
NC		 4423 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4424 SEEK_SET))
252b5132
RH		 4425 error (_("Unable to find program interpreter name\n"));
4426 else
4427 {
f8eae8b2 4428 char fmt [32];
9495b2e6 4429 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4430
4431 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4432 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4433
252b5132 4434 program_interpreter[0] = 0;
7bd7b3ef
AM		 4435 if (fscanf (file, fmt, program_interpreter) <= 0)
4436 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4437
4438 if (do_segments)
f54498b4 4439 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4440 program_interpreter);
4441 }
4442 break;
4443 }
252b5132
RH		 4444 }
4445
c256ffe7 4446 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4447 {
4448 printf (_("\n Section to Segment mapping:\n"));
4449 printf (_(" Segment Sections...\n"));
4450
252b5132
RH		 4451 for (i = 0; i < elf_header.e_phnum; i++)
4452 {
9ad5cbcf 4453 unsigned int j;
2cf0635d 4454 Elf_Internal_Shdr * section;
252b5132
RH		 4455
4456 segment = program_headers + i;
b391a3e3 4457 section = section_headers + 1;
252b5132
RH		 4458
4459 printf (" %2.2d ", i);
4460
b34976b6 4461 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4462 {
f4638467
AM		 4463 if (!ELF_TBSS_SPECIAL (section, segment)
4464 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 4465 printf ("%s ", SECTION_NAME (section));
4466 }
4467
4468 putc ('\n',stdout);
4469 }
4470 }
4471
252b5132
RH		 4472 return 1;
4473}
4474
4475
d93f0186
NC		 4476/* Find the file offset corresponding to VMA by using the program headers. */
4477
4478static long
2cf0635d 4479offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4480{
2cf0635d 4481 Elf_Internal_Phdr * seg;
d93f0186
NC		 4482
4483 if (! get_program_headers (file))
4484 {
4485 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4486 return (long) vma;
4487 }
4488
4489 for (seg = program_headers;
4490 seg < program_headers + elf_header.e_phnum;
4491 ++seg)
4492 {
4493 if (seg->p_type != PT_LOAD)
4494 continue;
4495
4496 if (vma >= (seg->p_vaddr & -seg->p_align)
4497 && vma + size <= seg->p_vaddr + seg->p_filesz)
4498 return vma - seg->p_vaddr + seg->p_offset;
4499 }
4500
4501 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4502 (unsigned long) vma);
d93f0186
NC		 4503 return (long) vma;
4504}
4505
4506
049b0c3a
NC		 4507/* Allocate memory and load the sections headers into the global pointer
4508 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4509 generate any error messages if the load fails. */
4510
4511static bfd_boolean
4512get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4513{
2cf0635d
NC		 4514 Elf32_External_Shdr * shdrs;
4515 Elf_Internal_Shdr * internal;
b34976b6 4516 unsigned int i;
049b0c3a
NC		 4517 unsigned int size = elf_header.e_shentsize;
4518 unsigned int num = probe ? 1 : elf_header.e_shnum;
4519
4520 /* PR binutils/17531: Cope with unexpected section header sizes. */
4521 if (size == 0 || num == 0)
4522 return FALSE;
4523 if (size < sizeof * shdrs)
4524 {
4525 if (! probe)
4526 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4527 return FALSE;
4528 }
4529 if (!probe && size > sizeof * shdrs)
4530 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4531
3f5e193b 4532 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4533 size, num,
4534 probe ? NULL : _("section headers"));
4535 if (shdrs == NULL)
4536 return FALSE;
252b5132 4537
049b0c3a
NC		 4538 if (section_headers != NULL)
4539 free (section_headers);
3f5e193b
NC		 4540 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4541 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4542 if (section_headers == NULL)
4543 {
049b0c3a
NC		 4544 if (!probe)
4545 error (_("Out of memory\n"));
4546 return FALSE;
252b5132
RH		 4547 }
4548
4549 for (i = 0, internal = section_headers;
560f3c1c 4550 i < num;
b34976b6 4551 i++, internal++)
252b5132
RH		 4552 {
4553 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4554 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4555 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4556 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4557 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4558 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4559 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4560 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4561 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4562 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4563 }
4564
4565 free (shdrs);
049b0c3a 4566 return TRUE;
252b5132
RH		 4567}
4568
049b0c3a
NC		 4569static bfd_boolean
4570get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4571{
2cf0635d
NC		 4572 Elf64_External_Shdr * shdrs;
4573 Elf_Internal_Shdr * internal;
b34976b6 4574 unsigned int i;
049b0c3a
NC		 4575 unsigned int size = elf_header.e_shentsize;
4576 unsigned int num = probe ? 1 : elf_header.e_shnum;
4577
4578 /* PR binutils/17531: Cope with unexpected section header sizes. */
4579 if (size == 0 || num == 0)
4580 return FALSE;
4581 if (size < sizeof * shdrs)
4582 {
4583 if (! probe)
4584 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4585 return FALSE;
4586 }
4587 if (! probe && size > sizeof * shdrs)
4588 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4589
3f5e193b 4590 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4591 size, num,
4592 probe ? NULL : _("section headers"));
4593 if (shdrs == NULL)
4594 return FALSE;
9ea033b2 4595
049b0c3a
NC		 4596 if (section_headers != NULL)
4597 free (section_headers);
3f5e193b
NC		 4598 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4599 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4600 if (section_headers == NULL)
4601 {
049b0c3a
NC		 4602 if (! probe)
4603 error (_("Out of memory\n"));
4604 return FALSE;
9ea033b2
NC		 4605 }
4606
4607 for (i = 0, internal = section_headers;
560f3c1c 4608 i < num;
b34976b6 4609 i++, internal++)
9ea033b2
NC		 4610 {
4611 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4612 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4613 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4614 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4615 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4616 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4617 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4618 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4619 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4620 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4621 }
4622
4623 free (shdrs);
049b0c3a 4624 return TRUE;
9ea033b2
NC		 4625}
4626
252b5132 4627static Elf_Internal_Sym *
ba5cdace
NC		 4628get_32bit_elf_symbols (FILE * file,
4629 Elf_Internal_Shdr * section,
4630 unsigned long * num_syms_return)
252b5132 4631{
ba5cdace 4632 unsigned long number = 0;
dd24e3da 4633 Elf32_External_Sym * esyms = NULL;
ba5cdace 4634 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4635 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4636 Elf_Internal_Sym * psym;
b34976b6 4637 unsigned int j;
252b5132 4638
dd24e3da
NC		 4639 /* Run some sanity checks first. */
4640 if (section->sh_entsize == 0)
4641 {
4642 error (_("sh_entsize is zero\n"));
ba5cdace 4643 goto exit_point;
dd24e3da
NC		 4644 }
4645
f54498b4
NC		 4646 if (section->sh_size > current_file_size)
4647 {
4648 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
2a03f307 4649 SECTION_NAME (section), (unsigned long) section->sh_size);
f54498b4
NC		 4650 goto exit_point;
4651 }
4652
dd24e3da
NC		 4653 number = section->sh_size / section->sh_entsize;
4654
4655 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4656 {
4657 error (_("Invalid sh_entsize\n"));
ba5cdace 4658 goto exit_point;
dd24e3da
NC		 4659 }
4660
3f5e193b
NC		 4661 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4662 section->sh_size, _("symbols"));
dd24e3da 4663 if (esyms == NULL)
ba5cdace 4664 goto exit_point;
252b5132 4665
9ad5cbcf
AM		 4666 shndx = NULL;
4667 if (symtab_shndx_hdr != NULL
4668 && (symtab_shndx_hdr->sh_link
4fbb74a6 4669 == (unsigned long) (section - section_headers)))
9ad5cbcf 4670 {
3f5e193b
NC		 4671 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4672 symtab_shndx_hdr->sh_offset,
4673 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4674 _("symbol table section indicies"));
dd24e3da
NC		 4675 if (shndx == NULL)
4676 goto exit_point;
9ad5cbcf
AM		 4677 }
4678
3f5e193b 4679 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4680
4681 if (isyms == NULL)
4682 {
4683 error (_("Out of memory\n"));
dd24e3da 4684 goto exit_point;
252b5132
RH		 4685 }
4686
dd24e3da 4687 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4688 {
4689 psym->st_name = BYTE_GET (esyms[j].st_name);
4690 psym->st_value = BYTE_GET (esyms[j].st_value);
4691 psym->st_size = BYTE_GET (esyms[j].st_size);
4692 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4693 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4694 psym->st_shndx
4695 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4696 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4697 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4698 psym->st_info = BYTE_GET (esyms[j].st_info);
4699 psym->st_other = BYTE_GET (esyms[j].st_other);
4700 }
4701
dd24e3da 4702 exit_point:
ba5cdace 4703 if (shndx != NULL)
9ad5cbcf 4704 free (shndx);
ba5cdace 4705 if (esyms != NULL)
dd24e3da 4706 free (esyms);
252b5132 4707
ba5cdace
NC		 4708 if (num_syms_return != NULL)
4709 * num_syms_return = isyms == NULL ? 0 : number;
4710
252b5132
RH		 4711 return isyms;
4712}
4713
9ea033b2 4714static Elf_Internal_Sym *
ba5cdace
NC		 4715get_64bit_elf_symbols (FILE * file,
4716 Elf_Internal_Shdr * section,
4717 unsigned long * num_syms_return)
9ea033b2 4718{
ba5cdace
NC		 4719 unsigned long number = 0;
4720 Elf64_External_Sym * esyms = NULL;
4721 Elf_External_Sym_Shndx * shndx = NULL;
4722 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4723 Elf_Internal_Sym * psym;
b34976b6 4724 unsigned int j;
9ea033b2 4725
dd24e3da
NC		 4726 /* Run some sanity checks first. */
4727 if (section->sh_entsize == 0)
4728 {
4729 error (_("sh_entsize is zero\n"));
ba5cdace 4730 goto exit_point;
dd24e3da
NC		 4731 }
4732
f54498b4
NC		 4733 if (section->sh_size > current_file_size)
4734 {
4735 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
2a03f307 4736 SECTION_NAME (section), (unsigned long) section->sh_size);
f54498b4
NC		 4737 goto exit_point;
4738 }
4739
dd24e3da
NC		 4740 number = section->sh_size / section->sh_entsize;
4741
4742 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4743 {
4744 error (_("Invalid sh_entsize\n"));
ba5cdace 4745 goto exit_point;
dd24e3da
NC		 4746 }
4747
3f5e193b
NC		 4748 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4749 section->sh_size, _("symbols"));
a6e9f9df 4750 if (!esyms)
ba5cdace 4751 goto exit_point;
9ea033b2 4752
9ad5cbcf
AM		 4753 if (symtab_shndx_hdr != NULL
4754 && (symtab_shndx_hdr->sh_link
4fbb74a6 4755 == (unsigned long) (section - section_headers)))
9ad5cbcf 4756 {
3f5e193b
NC		 4757 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4758 symtab_shndx_hdr->sh_offset,
4759 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4760 _("symbol table section indicies"));
ba5cdace
NC		 4761 if (shndx == NULL)
4762 goto exit_point;
9ad5cbcf
AM		 4763 }
4764
3f5e193b 4765 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4766
4767 if (isyms == NULL)
4768 {
4769 error (_("Out of memory\n"));
ba5cdace 4770 goto exit_point;
9ea033b2
NC		 4771 }
4772
ba5cdace 4773 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4774 {
4775 psym->st_name = BYTE_GET (esyms[j].st_name);
4776 psym->st_info = BYTE_GET (esyms[j].st_info);
4777 psym->st_other = BYTE_GET (esyms[j].st_other);
4778 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4779
4fbb74a6 4780 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4781 psym->st_shndx
4782 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4783 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4784 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4785
66543521
AM		 4786 psym->st_value = BYTE_GET (esyms[j].st_value);
4787 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4788 }
4789
ba5cdace
NC		 4790 exit_point:
4791 if (shndx != NULL)
9ad5cbcf 4792 free (shndx);
ba5cdace
NC		 4793 if (esyms != NULL)
4794 free (esyms);
4795
4796 if (num_syms_return != NULL)
4797 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4798
4799 return isyms;
4800}
4801
d1133906 4802static const char *
d3ba0551 4803get_elf_section_flags (bfd_vma sh_flags)
d1133906 4804{
5477e8a0 4805 static char buff[1024];
2cf0635d 4806 char * p = buff;
8d5ff12c 4807 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4808 int sindex;
4809 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4810 bfd_vma os_flags = 0;
4811 bfd_vma proc_flags = 0;
4812 bfd_vma unknown_flags = 0;
148b93f2 4813 static const struct
5477e8a0 4814 {
2cf0635d 4815 const char * str;
5477e8a0
L		 4816 int len;
4817 }
4818 flags [] =
4819 {
cfcac11d
NC		 4820 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4821 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4822 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4823 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4824 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4825 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4826 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4827 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4828 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4829 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4830 /* IA-64 specific. */
4831 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4832 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4833 /* IA-64 OpenVMS specific. */
4834 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4835 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4836 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4837 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4838 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4839 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4840 /* Generic. */
cfcac11d 4841 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4842 /* SPARC specific. */
cfcac11d 4843 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4844 };
4845
4846 if (do_section_details)
4847 {
8d5ff12c
L		 4848 sprintf (buff, "[%*.*lx]: ",
4849 field_size, field_size, (unsigned long) sh_flags);
4850 p += field_size + 4;
5477e8a0 4851 }
76da6bbe 4852
d1133906
NC		 4853 while (sh_flags)
4854 {
4855 bfd_vma flag;
4856
4857 flag = sh_flags & - sh_flags;
4858 sh_flags &= ~ flag;
76da6bbe 4859
5477e8a0 4860 if (do_section_details)
d1133906 4861 {
5477e8a0
L		 4862 switch (flag)
4863 {
91d6fa6a
NC		 4864 case SHF_WRITE: sindex = 0; break;
4865 case SHF_ALLOC: sindex = 1; break;
4866 case SHF_EXECINSTR: sindex = 2; break;
4867 case SHF_MERGE: sindex = 3; break;
4868 case SHF_STRINGS: sindex = 4; break;
4869 case SHF_INFO_LINK: sindex = 5; break;
4870 case SHF_LINK_ORDER: sindex = 6; break;
4871 case SHF_OS_NONCONFORMING: sindex = 7; break;
4872 case SHF_GROUP: sindex = 8; break;
4873 case SHF_TLS: sindex = 9; break;
18ae9cc1 4874 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4875
5477e8a0 4876 default:
91d6fa6a 4877 sindex = -1;
cfcac11d 4878 switch (elf_header.e_machine)
148b93f2 4879 {
cfcac11d 4880 case EM_IA_64:
148b93f2 4881 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4882 sindex = 10;
148b93f2 4883 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4884 sindex = 11;
148b93f2
NC		 4885#ifdef BFD64
4886 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4887 switch (flag)
4888 {
91d6fa6a
NC		 4889 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4890 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4891 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4892 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4893 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4894 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4895 default: break;
4896 }
4897#endif
cfcac11d
NC		 4898 break;
4899
caa83f8b
NC		 4900 case EM_386:
4901 case EM_486:
4902 case EM_X86_64:
7f502d6c 4903 case EM_L1OM:
7a9068fe 4904 case EM_K1OM:
cfcac11d
NC		 4905 case EM_OLD_SPARCV9:
4906 case EM_SPARC32PLUS:
4907 case EM_SPARCV9:
4908 case EM_SPARC:
18ae9cc1 4909 if (flag == SHF_ORDERED)
91d6fa6a 4910 sindex = 19;
cfcac11d
NC		 4911 break;
4912 default:
4913 break;
148b93f2 4914 }
5477e8a0
L		 4915 }
4916
91d6fa6a 4917 if (sindex != -1)
5477e8a0 4918 {
8d5ff12c
L		 4919 if (p != buff + field_size + 4)
4920 {
4921 if (size < (10 + 2))
4922 abort ();
4923 size -= 2;
4924 *p++ = ',';
4925 *p++ = ' ';
4926 }
4927
91d6fa6a
NC		 4928 size -= flags [sindex].len;
4929 p = stpcpy (p, flags [sindex].str);
5477e8a0 4930 }
3b22753a 4931 else if (flag & SHF_MASKOS)
8d5ff12c 4932 os_flags |= flag;
d1133906 4933 else if (flag & SHF_MASKPROC)
8d5ff12c 4934 proc_flags |= flag;
d1133906 4935 else
8d5ff12c 4936 unknown_flags |= flag;
5477e8a0
L		 4937 }
4938 else
4939 {
4940 switch (flag)
4941 {
4942 case SHF_WRITE: *p = 'W'; break;
4943 case SHF_ALLOC: *p = 'A'; break;
4944 case SHF_EXECINSTR: *p = 'X'; break;
4945 case SHF_MERGE: *p = 'M'; break;
4946 case SHF_STRINGS: *p = 'S'; break;
4947 case SHF_INFO_LINK: *p = 'I'; break;
4948 case SHF_LINK_ORDER: *p = 'L'; break;
4949 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4950 case SHF_GROUP: *p = 'G'; break;
4951 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4952 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4953
4954 default:
8a9036a4 4955 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4956 || elf_header.e_machine == EM_L1OM
4957 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4958 && flag == SHF_X86_64_LARGE)
4959 *p = 'l';
4960 else if (flag & SHF_MASKOS)
4961 {
4962 *p = 'o';
4963 sh_flags &= ~ SHF_MASKOS;
4964 }
4965 else if (flag & SHF_MASKPROC)
4966 {
4967 *p = 'p';
4968 sh_flags &= ~ SHF_MASKPROC;
4969 }
4970 else
4971 *p = 'x';
4972 break;
4973 }
4974 p++;
d1133906
NC		 4975 }
4976 }
76da6bbe 4977
8d5ff12c
L		 4978 if (do_section_details)
4979 {
4980 if (os_flags)
4981 {
4982 size -= 5 + field_size;
4983 if (p != buff + field_size + 4)
4984 {
4985 if (size < (2 + 1))
4986 abort ();
4987 size -= 2;
4988 *p++ = ',';
4989 *p++ = ' ';
4990 }
4991 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4992 (unsigned long) os_flags);
4993 p += 5 + field_size;
4994 }
4995 if (proc_flags)
4996 {
4997 size -= 7 + field_size;
4998 if (p != buff + field_size + 4)
4999 {
5000 if (size < (2 + 1))
5001 abort ();
5002 size -= 2;
5003 *p++ = ',';
5004 *p++ = ' ';
5005 }
5006 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5007 (unsigned long) proc_flags);
5008 p += 7 + field_size;
5009 }
5010 if (unknown_flags)
5011 {
5012 size -= 10 + field_size;
5013 if (p != buff + field_size + 4)
5014 {
5015 if (size < (2 + 1))
5016 abort ();
5017 size -= 2;
5018 *p++ = ',';
5019 *p++ = ' ';
5020 }
2b692964 5021 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5022 (unsigned long) unknown_flags);
5023 p += 10 + field_size;
5024 }
5025 }
5026
e9e44622 5027 *p = '\0';
d1133906
NC		 5028 return buff;
5029}
5030
252b5132 5031static int
2cf0635d 5032process_section_headers (FILE * file)
252b5132 5033{
2cf0635d 5034 Elf_Internal_Shdr * section;
b34976b6 5035 unsigned int i;
252b5132
RH		 5036
5037 section_headers = NULL;
5038
5039 if (elf_header.e_shnum == 0)
5040 {
82f2dbf7
NC		 5041 /* PR binutils/12467. */
5042 if (elf_header.e_shoff != 0)
5043 warn (_("possibly corrupt ELF file header - it has a non-zero"
5044 " section header offset, but no section headers\n"));
5045 else if (do_sections)
252b5132
RH		 5046 printf (_("\nThere are no sections in this file.\n"));
5047
5048 return 1;
5049 }
5050
5051 if (do_sections && !do_header)
9ea033b2 5052 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5053 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5054
9ea033b2
NC		 5055 if (is_32bit_elf)
5056 {
049b0c3a 5057 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5058 return 0;
5059 }
049b0c3a 5060 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5061 return 0;
5062
5063 /* Read in the string table, so that we have names to display. */
0b49d371 5064 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5065 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5066 {
4fbb74a6 5067 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5068
c256ffe7
JJ		 5069 if (section->sh_size != 0)
5070 {
3f5e193b
NC		 5071 string_table = (char *) get_data (NULL, file, section->sh_offset,
5072 1, section->sh_size,
5073 _("string table"));
0de14b54 5074
c256ffe7
JJ		 5075 string_table_length = string_table != NULL ? section->sh_size : 0;
5076 }
252b5132
RH		 5077 }
5078
5079 /* Scan the sections for the dynamic symbol table
e3c8793a 5080 and dynamic string table and debug sections. */
252b5132
RH		 5081 dynamic_symbols = NULL;
5082 dynamic_strings = NULL;
5083 dynamic_syminfo = NULL;
f1ef08cb 5084 symtab_shndx_hdr = NULL;
103f02d3 5085
89fac5e3
RS		 5086 eh_addr_size = is_32bit_elf ? 4 : 8;
5087 switch (elf_header.e_machine)
5088 {
5089 case EM_MIPS:
5090 case EM_MIPS_RS3_LE:
5091 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5092 FDE addresses. However, the ABI also has a semi-official ILP32
5093 variant for which the normal FDE address size rules apply.
5094
5095 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5096 section, where XX is the size of longs in bits. Unfortunately,
5097 earlier compilers provided no way of distinguishing ILP32 objects
5098 from LP64 objects, so if there's any doubt, we should assume that
5099 the official LP64 form is being used. */
5100 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5101 && find_section (".gcc_compiled_long32") == NULL)
5102 eh_addr_size = 8;
5103 break;
0f56a26a
DD		 5104
5105 case EM_H8_300:
5106 case EM_H8_300H:
5107 switch (elf_header.e_flags & EF_H8_MACH)
5108 {
5109 case E_H8_MACH_H8300:
5110 case E_H8_MACH_H8300HN:
5111 case E_H8_MACH_H8300SN:
5112 case E_H8_MACH_H8300SXN:
5113 eh_addr_size = 2;
5114 break;
5115 case E_H8_MACH_H8300H:
5116 case E_H8_MACH_H8300S:
5117 case E_H8_MACH_H8300SX:
5118 eh_addr_size = 4;
5119 break;
5120 }
f4236fe4
DD		 5121 break;
5122
ff7eeb89 5123 case EM_M32C_OLD:
f4236fe4
DD		 5124 case EM_M32C:
5125 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5126 {
5127 case EF_M32C_CPU_M16C:
5128 eh_addr_size = 2;
5129 break;
5130 }
5131 break;
89fac5e3
RS		 5132 }
5133
76ca31c0
NC		 5134#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5135 do \
5136 { \
5137 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5138 if (section->sh_entsize != expected_entsize) \
9dd3a467 5139 { \
76ca31c0
NC		 5140 char buf[40]; \
5141 sprintf_vma (buf, section->sh_entsize); \
5142 /* Note: coded this way so that there is a single string for \
5143 translation. */ \
5144 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5145 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5146 (unsigned) expected_entsize); \
9dd3a467 5147 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5148 } \
5149 } \
08d8fa11 5150 while (0)
9dd3a467
NC		 5151
5152#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5153 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5154 sizeof (Elf64_External_##type))
5155
252b5132
RH		 5156 for (i = 0, section = section_headers;
5157 i < elf_header.e_shnum;
b34976b6 5158 i++, section++)
252b5132 5159 {
2cf0635d 5160 char * name = SECTION_NAME (section);
252b5132
RH		 5161
5162 if (section->sh_type == SHT_DYNSYM)
5163 {
5164 if (dynamic_symbols != NULL)
5165 {
5166 error (_("File contains multiple dynamic symbol tables\n"));
5167 continue;
5168 }
5169
08d8fa11 5170 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5171 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5172 }
5173 else if (section->sh_type == SHT_STRTAB
18bd398b 5174 && streq (name, ".dynstr"))
252b5132
RH		 5175 {
5176 if (dynamic_strings != NULL)
5177 {
5178 error (_("File contains multiple dynamic string tables\n"));
5179 continue;
5180 }
5181
3f5e193b
NC		 5182 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5183 1, section->sh_size,
5184 _("dynamic strings"));
59245841 5185 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5186 }
9ad5cbcf
AM		 5187 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5188 {
5189 if (symtab_shndx_hdr != NULL)
5190 {
5191 error (_("File contains multiple symtab shndx tables\n"));
5192 continue;
5193 }
5194 symtab_shndx_hdr = section;
5195 }
08d8fa11
JJ		 5196 else if (section->sh_type == SHT_SYMTAB)
5197 CHECK_ENTSIZE (section, i, Sym);
5198 else if (section->sh_type == SHT_GROUP)
5199 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5200 else if (section->sh_type == SHT_REL)
5201 CHECK_ENTSIZE (section, i, Rel);
5202 else if (section->sh_type == SHT_RELA)
5203 CHECK_ENTSIZE (section, i, Rela);
252b5132 5204 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5205 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5206 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5207 || do_debug_str || do_debug_loc || do_debug_ranges
5208 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5209 && (const_strneq (name, ".debug_")
5210 || const_strneq (name, ".zdebug_")))
252b5132 5211 {
1b315056
CS		 5212 if (name[1] == 'z')
5213 name += sizeof (".zdebug_") - 1;
5214 else
5215 name += sizeof (".debug_") - 1;
252b5132
RH		 5216
5217 if (do_debugging
4723351a
CC		 5218 || (do_debug_info && const_strneq (name, "info"))
5219 || (do_debug_info && const_strneq (name, "types"))
5220 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5221 || (do_debug_lines && strcmp (name, "line") == 0)
5222 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5223 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5224 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5225 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5226 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5227 || (do_debug_aranges && const_strneq (name, "aranges"))
5228 || (do_debug_ranges && const_strneq (name, "ranges"))
5229 || (do_debug_frames && const_strneq (name, "frame"))
5230 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5231 || (do_debug_macinfo && const_strneq (name, "macro"))
5232 || (do_debug_str && const_strneq (name, "str"))
5233 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5234 || (do_debug_addr && const_strneq (name, "addr"))
5235 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5236 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5237 )
09c11c86 5238 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5239 }
a262ae96 5240 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5241 else if ((do_debugging || do_debug_info)
0112cd26 5242 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5243 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5244 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5245 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5246 else if (do_gdb_index && streq (name, ".gdb_index"))
5247 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5248 /* Trace sections for Itanium VMS. */
5249 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5250 || do_trace_aranges)
5251 && const_strneq (name, ".trace_"))
5252 {
5253 name += sizeof (".trace_") - 1;
5254
5255 if (do_debugging
5256 || (do_trace_info && streq (name, "info"))
5257 || (do_trace_abbrevs && streq (name, "abbrev"))
5258 || (do_trace_aranges && streq (name, "aranges"))
5259 )
5260 request_dump_bynumber (i, DEBUG_DUMP);
5261 }
5262
252b5132
RH		 5263 }
5264
5265 if (! do_sections)
5266 return 1;
5267
3a1a2036
NC		 5268 if (elf_header.e_shnum > 1)
5269 printf (_("\nSection Headers:\n"));
5270 else
5271 printf (_("\nSection Header:\n"));
76da6bbe 5272
f7a99963 5273 if (is_32bit_elf)
595cf52e 5274 {
5477e8a0 5275 if (do_section_details)
595cf52e
L		 5276 {
5277 printf (_(" [Nr] Name\n"));
5477e8a0 5278 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5279 }
5280 else
5281 printf
5282 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5283 }
d974e256 5284 else if (do_wide)
595cf52e 5285 {
5477e8a0 5286 if (do_section_details)
595cf52e
L		 5287 {
5288 printf (_(" [Nr] Name\n"));
5477e8a0 5289 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5290 }
5291 else
5292 printf
5293 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5294 }
f7a99963
NC		 5295 else
5296 {
5477e8a0 5297 if (do_section_details)
595cf52e
L		 5298 {
5299 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5300 printf (_(" Type Address Offset Link\n"));
5301 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5302 }
5303 else
5304 {
5305 printf (_(" [Nr] Name Type Address Offset\n"));
5306 printf (_(" Size EntSize Flags Link Info Align\n"));
5307 }
f7a99963 5308 }
252b5132 5309
5477e8a0
L		 5310 if (do_section_details)
5311 printf (_(" Flags\n"));
5312
252b5132
RH		 5313 for (i = 0, section = section_headers;
5314 i < elf_header.e_shnum;
b34976b6 5315 i++, section++)
252b5132 5316 {
7bfd842d 5317 printf (" [%2u] ", i);
5477e8a0 5318 if (do_section_details)
595cf52e 5319 {
7bfd842d 5320 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 5321 printf ("\n ");
595cf52e
L		 5322 }
5323 else
7bfd842d
NC		 5324 {
5325 print_symbol (-17, SECTION_NAME (section));
7bfd842d 5326 }
0b4362b0 5327
ea52a088
NC		 5328 printf (do_wide ? " %-15s " : " %-15.15s ",
5329 get_section_type_name (section->sh_type));
0b4362b0 5330
f7a99963
NC		 5331 if (is_32bit_elf)
5332 {
cfcac11d
NC		 5333 const char * link_too_big = NULL;
5334
f7a99963 5335 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5336
f7a99963
NC		 5337 printf ( " %6.6lx %6.6lx %2.2lx",
5338 (unsigned long) section->sh_offset,
5339 (unsigned long) section->sh_size,
5340 (unsigned long) section->sh_entsize);
d1133906 5341
5477e8a0
L		 5342 if (do_section_details)
5343 fputs (" ", stdout);
5344 else
5345 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5346
cfcac11d
NC		 5347 if (section->sh_link >= elf_header.e_shnum)
5348 {
5349 link_too_big = "";
5350 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5351 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5352 switch (elf_header.e_machine)
5353 {
caa83f8b
NC		 5354 case EM_386:
5355 case EM_486:
5356 case EM_X86_64:
7f502d6c 5357 case EM_L1OM:
7a9068fe 5358 case EM_K1OM:
cfcac11d
NC		 5359 case EM_OLD_SPARCV9:
5360 case EM_SPARC32PLUS:
5361 case EM_SPARCV9:
5362 case EM_SPARC:
5363 if (section->sh_link == (SHN_BEFORE & 0xffff))
5364 link_too_big = "BEFORE";
5365 else if (section->sh_link == (SHN_AFTER & 0xffff))
5366 link_too_big = "AFTER";
5367 break;
5368 default:
5369 break;
5370 }
5371 }
5372
5373 if (do_section_details)
5374 {
5375 if (link_too_big != NULL && * link_too_big)
5376 printf ("<%s> ", link_too_big);
5377 else
5378 printf ("%2u ", section->sh_link);
5379 printf ("%3u %2lu\n", section->sh_info,
5380 (unsigned long) section->sh_addralign);
5381 }
5382 else
5383 printf ("%2u %3u %2lu\n",
5384 section->sh_link,
5385 section->sh_info,
5386 (unsigned long) section->sh_addralign);
5387
5388 if (link_too_big && ! * link_too_big)
5389 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5390 i, section->sh_link);
f7a99963 5391 }
d974e256
JJ		 5392 else if (do_wide)
5393 {
5394 print_vma (section->sh_addr, LONG_HEX);
5395
5396 if ((long) section->sh_offset == section->sh_offset)
5397 printf (" %6.6lx", (unsigned long) section->sh_offset);
5398 else
5399 {
5400 putchar (' ');
5401 print_vma (section->sh_offset, LONG_HEX);
5402 }
5403
5404 if ((unsigned long) section->sh_size == section->sh_size)
5405 printf (" %6.6lx", (unsigned long) section->sh_size);
5406 else
5407 {
5408 putchar (' ');
5409 print_vma (section->sh_size, LONG_HEX);
5410 }
5411
5412 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5413 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5414 else
5415 {
5416 putchar (' ');
5417 print_vma (section->sh_entsize, LONG_HEX);
5418 }
5419
5477e8a0
L		 5420 if (do_section_details)
5421 fputs (" ", stdout);
5422 else
5423 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5424
72de5009 5425 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5426
5427 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5428 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5429 else
5430 {
5431 print_vma (section->sh_addralign, DEC);
5432 putchar ('\n');
5433 }
5434 }
5477e8a0 5435 else if (do_section_details)
595cf52e 5436 {
5477e8a0 5437 printf (" %-15.15s ",
595cf52e 5438 get_section_type_name (section->sh_type));
595cf52e
L		 5439 print_vma (section->sh_addr, LONG_HEX);
5440 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5441 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5442 else
5443 {
5444 printf (" ");
5445 print_vma (section->sh_offset, LONG_HEX);
5446 }
72de5009 5447 printf (" %u\n ", section->sh_link);
595cf52e 5448 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5449 putchar (' ');
595cf52e
L		 5450 print_vma (section->sh_entsize, LONG_HEX);
5451
72de5009
AM		 5452 printf (" %-16u %lu\n",
5453 section->sh_info,
595cf52e
L		 5454 (unsigned long) section->sh_addralign);
5455 }
f7a99963
NC		 5456 else
5457 {
5458 putchar (' ');
5459 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5460 if ((long) section->sh_offset == section->sh_offset)
5461 printf (" %8.8lx", (unsigned long) section->sh_offset);
5462 else
5463 {
5464 printf (" ");
5465 print_vma (section->sh_offset, LONG_HEX);
5466 }
f7a99963
NC		 5467 printf ("\n ");
5468 print_vma (section->sh_size, LONG_HEX);
5469 printf (" ");
5470 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5471
d1133906 5472 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5473
72de5009
AM		 5474 printf (" %2u %3u %lu\n",
5475 section->sh_link,
5476 section->sh_info,
f7a99963
NC		 5477 (unsigned long) section->sh_addralign);
5478 }
5477e8a0
L		 5479
5480 if (do_section_details)
5481 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5482 }
5483
5477e8a0 5484 if (!do_section_details)
3dbcc61d
NC		 5485 {
5486 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5487 || elf_header.e_machine == EM_L1OM
5488 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5489 printf (_("Key to Flags:\n\
5490 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5491 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5492 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5493 else
5494 printf (_("Key to Flags:\n\
e3c8793a 5495 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5496 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5497 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5498 }
d1133906 5499
252b5132
RH		 5500 return 1;
5501}
5502
f5842774
L		 5503static const char *
5504get_group_flags (unsigned int flags)
5505{
5506 static char buff[32];
5507 switch (flags)
5508 {
220453ec
AM		 5509 case 0:
5510 return "";
5511
f5842774 5512 case GRP_COMDAT:
220453ec 5513 return "COMDAT ";
f5842774
L		 5514
5515 default:
220453ec 5516 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5517 break;
5518 }
5519 return buff;
5520}
5521
5522static int
2cf0635d 5523process_section_groups (FILE * file)
f5842774 5524{
2cf0635d 5525 Elf_Internal_Shdr * section;
f5842774 5526 unsigned int i;
2cf0635d
NC		 5527 struct group * group;
5528 Elf_Internal_Shdr * symtab_sec;
5529 Elf_Internal_Shdr * strtab_sec;
5530 Elf_Internal_Sym * symtab;
ba5cdace 5531 unsigned long num_syms;
2cf0635d 5532 char * strtab;
c256ffe7 5533 size_t strtab_size;
d1f5c6e3
L		 5534
5535 /* Don't process section groups unless needed. */
5536 if (!do_unwind && !do_section_groups)
5537 return 1;
f5842774
L		 5538
5539 if (elf_header.e_shnum == 0)
5540 {
5541 if (do_section_groups)
82f2dbf7 5542 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5543
5544 return 1;
5545 }
5546
5547 if (section_headers == NULL)
5548 {
5549 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5550 /* PR 13622: This can happen with a corrupt ELF header. */
5551 return 0;
f5842774
L		 5552 }
5553
3f5e193b
NC		 5554 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5555 sizeof (struct group *));
e4b17d5c
L		 5556
5557 if (section_headers_groups == NULL)
5558 {
5559 error (_("Out of memory\n"));
5560 return 0;
5561 }
5562
f5842774 5563 /* Scan the sections for the group section. */
d1f5c6e3 5564 group_count = 0;
f5842774
L		 5565 for (i = 0, section = section_headers;
5566 i < elf_header.e_shnum;
5567 i++, section++)
e4b17d5c
L		 5568 if (section->sh_type == SHT_GROUP)
5569 group_count++;
5570
d1f5c6e3
L		 5571 if (group_count == 0)
5572 {
5573 if (do_section_groups)
5574 printf (_("\nThere are no section groups in this file.\n"));
5575
5576 return 1;
5577 }
5578
3f5e193b 5579 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5580
5581 if (section_groups == NULL)
5582 {
5583 error (_("Out of memory\n"));
5584 return 0;
5585 }
5586
d1f5c6e3
L		 5587 symtab_sec = NULL;
5588 strtab_sec = NULL;
5589 symtab = NULL;
ba5cdace 5590 num_syms = 0;
d1f5c6e3 5591 strtab = NULL;
c256ffe7 5592 strtab_size = 0;
e4b17d5c
L		 5593 for (i = 0, section = section_headers, group = section_groups;
5594 i < elf_header.e_shnum;
5595 i++, section++)
f5842774
L		 5596 {
5597 if (section->sh_type == SHT_GROUP)
5598 {
2cf0635d
NC		 5599 char * name = SECTION_NAME (section);
5600 char * group_name;
5601 unsigned char * start;
5602 unsigned char * indices;
f5842774 5603 unsigned int entry, j, size;
2cf0635d
NC		 5604 Elf_Internal_Shdr * sec;
5605 Elf_Internal_Sym * sym;
f5842774
L		 5606
5607 /* Get the symbol table. */
4fbb74a6
AM		 5608 if (section->sh_link >= elf_header.e_shnum
5609 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5610 != SHT_SYMTAB))
f5842774
L		 5611 {
5612 error (_("Bad sh_link in group section `%s'\n"), name);
5613 continue;
5614 }
d1f5c6e3
L		 5615
5616 if (symtab_sec != sec)
5617 {
5618 symtab_sec = sec;
5619 if (symtab)
5620 free (symtab);
ba5cdace 5621 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5622 }
f5842774 5623
dd24e3da
NC		 5624 if (symtab == NULL)
5625 {
5626 error (_("Corrupt header in group section `%s'\n"), name);
5627 continue;
5628 }
5629
ba5cdace
NC		 5630 if (section->sh_info >= num_syms)
5631 {
5632 error (_("Bad sh_info in group section `%s'\n"), name);
5633 continue;
5634 }
5635
f5842774
L		 5636 sym = symtab + section->sh_info;
5637
5638 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5639 {
4fbb74a6
AM		 5640 if (sym->st_shndx == 0
5641 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5642 {
5643 error (_("Bad sh_info in group section `%s'\n"), name);
5644 continue;
5645 }
ba2685cc 5646
4fbb74a6 5647 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5648 strtab_sec = NULL;
5649 if (strtab)
5650 free (strtab);
f5842774 5651 strtab = NULL;
c256ffe7 5652 strtab_size = 0;
f5842774
L		 5653 }
5654 else
5655 {
5656 /* Get the string table. */
4fbb74a6 5657 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5658 {
5659 strtab_sec = NULL;
5660 if (strtab)
5661 free (strtab);
5662 strtab = NULL;
5663 strtab_size = 0;
5664 }
5665 else if (strtab_sec
4fbb74a6 5666 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5667 {
5668 strtab_sec = sec;
5669 if (strtab)
5670 free (strtab);
3f5e193b
NC		 5671 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5672 1, strtab_sec->sh_size,
5673 _("string table"));
c256ffe7 5674 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5675 }
c256ffe7 5676 group_name = sym->st_name < strtab_size
2b692964 5677 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5678 }
5679
3f5e193b
NC		 5680 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5681 1, section->sh_size,
5682 _("section data"));
59245841
NC		 5683 if (start == NULL)
5684 continue;
f5842774
L		 5685
5686 indices = start;
5687 size = (section->sh_size / section->sh_entsize) - 1;
5688 entry = byte_get (indices, 4);
5689 indices += 4;
e4b17d5c
L		 5690
5691 if (do_section_groups)
5692 {
2b692964 5693 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5694 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5695
e4b17d5c
L		 5696 printf (_(" [Index] Name\n"));
5697 }
5698
5699 group->group_index = i;
5700
f5842774
L		 5701 for (j = 0; j < size; j++)
5702 {
2cf0635d 5703 struct group_list * g;
e4b17d5c 5704
f5842774
L		 5705 entry = byte_get (indices, 4);
5706 indices += 4;
5707
4fbb74a6 5708 if (entry >= elf_header.e_shnum)
391cb864
L		 5709 {
5710 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5711 entry, i, elf_header.e_shnum - 1);
5712 continue;
5713 }
391cb864 5714
4fbb74a6 5715 if (section_headers_groups [entry] != NULL)
e4b17d5c 5716 {
d1f5c6e3
L		 5717 if (entry)
5718 {
391cb864
L		 5719 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5720 entry, i,
4fbb74a6 5721 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5722 continue;
5723 }
5724 else
5725 {
5726 /* Intel C/C++ compiler may put section 0 in a
5727 section group. We just warn it the first time
5728 and ignore it afterwards. */
5729 static int warned = 0;
5730 if (!warned)
5731 {
5732 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5733 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5734 warned++;
5735 }
5736 }
e4b17d5c
L		 5737 }
5738
4fbb74a6 5739 section_headers_groups [entry] = group;
e4b17d5c
L		 5740
5741 if (do_section_groups)
5742 {
4fbb74a6 5743 sec = section_headers + entry;
c256ffe7 5744 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5745 }
5746
3f5e193b 5747 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5748 g->section_index = entry;
5749 g->next = group->root;
5750 group->root = g;
f5842774
L		 5751 }
5752
f5842774
L		 5753 if (start)
5754 free (start);
e4b17d5c
L		 5755
5756 group++;
f5842774
L		 5757 }
5758 }
5759
d1f5c6e3
L		 5760 if (symtab)
5761 free (symtab);
5762 if (strtab)
5763 free (strtab);
f5842774
L		 5764 return 1;
5765}
5766
28f997cf
TG		 5767/* Data used to display dynamic fixups. */
5768
5769struct ia64_vms_dynfixup
5770{
5771 bfd_vma needed_ident; /* Library ident number. */
5772 bfd_vma needed; /* Index in the dstrtab of the library name. */
5773 bfd_vma fixup_needed; /* Index of the library. */
5774 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5775 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5776};
5777
5778/* Data used to display dynamic relocations. */
5779
5780struct ia64_vms_dynimgrela
5781{
5782 bfd_vma img_rela_cnt; /* Number of relocations. */
5783 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5784};
5785
5786/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5787 library). */
5788
5789static void
5790dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5791 const char *strtab, unsigned int strtab_sz)
5792{
5793 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5794 long i;
5795 const char *lib_name;
5796
5797 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5798 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5799 _("dynamic section image fixups"));
5800 if (!imfs)
5801 return;
5802
5803 if (fixup->needed < strtab_sz)
5804 lib_name = strtab + fixup->needed;
5805 else
5806 {
5807 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5808 (unsigned long) fixup->needed);
28f997cf
TG		 5809 lib_name = "???";
5810 }
5811 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5812 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5813 printf
5814 (_("Seg Offset Type SymVec DataType\n"));
5815
5816 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5817 {
5818 unsigned int type;
5819 const char *rtype;
5820
5821 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5822 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5823 type = BYTE_GET (imfs [i].type);
5824 rtype = elf_ia64_reloc_type (type);
5825 if (rtype == NULL)
5826 printf (" 0x%08x ", type);
5827 else
5828 printf (" %-32s ", rtype);
5829 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5830 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5831 }
5832
5833 free (imfs);
5834}
5835
5836/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5837
5838static void
5839dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5840{
5841 Elf64_External_VMS_IMAGE_RELA *imrs;
5842 long i;
5843
5844 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5845 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5846 _("dynamic section image relocations"));
28f997cf
TG		 5847 if (!imrs)
5848 return;
5849
5850 printf (_("\nImage relocs\n"));
5851 printf
5852 (_("Seg Offset Type Addend Seg Sym Off\n"));
5853
5854 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5855 {
5856 unsigned int type;
5857 const char *rtype;
5858
5859 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5860 printf ("%08" BFD_VMA_FMT "x ",
5861 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5862 type = BYTE_GET (imrs [i].type);
5863 rtype = elf_ia64_reloc_type (type);
5864 if (rtype == NULL)
5865 printf ("0x%08x ", type);
5866 else
5867 printf ("%-31s ", rtype);
5868 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5869 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5870 printf ("%08" BFD_VMA_FMT "x\n",
5871 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5872 }
5873
5874 free (imrs);
5875}
5876
5877/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5878
5879static int
5880process_ia64_vms_dynamic_relocs (FILE *file)
5881{
5882 struct ia64_vms_dynfixup fixup;
5883 struct ia64_vms_dynimgrela imgrela;
5884 Elf_Internal_Dyn *entry;
5885 int res = 0;
5886 bfd_vma strtab_off = 0;
5887 bfd_vma strtab_sz = 0;
5888 char *strtab = NULL;
5889
5890 memset (&fixup, 0, sizeof (fixup));
5891 memset (&imgrela, 0, sizeof (imgrela));
5892
5893 /* Note: the order of the entries is specified by the OpenVMS specs. */
5894 for (entry = dynamic_section;
5895 entry < dynamic_section + dynamic_nent;
5896 entry++)
5897 {
5898 switch (entry->d_tag)
5899 {
5900 case DT_IA_64_VMS_STRTAB_OFFSET:
5901 strtab_off = entry->d_un.d_val;
5902 break;
5903 case DT_STRSZ:
5904 strtab_sz = entry->d_un.d_val;
5905 if (strtab == NULL)
5906 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5907 1, strtab_sz, _("dynamic string section"));
5908 break;
5909
5910 case DT_IA_64_VMS_NEEDED_IDENT:
5911 fixup.needed_ident = entry->d_un.d_val;
5912 break;
5913 case DT_NEEDED:
5914 fixup.needed = entry->d_un.d_val;
5915 break;
5916 case DT_IA_64_VMS_FIXUP_NEEDED:
5917 fixup.fixup_needed = entry->d_un.d_val;
5918 break;
5919 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5920 fixup.fixup_rela_cnt = entry->d_un.d_val;
5921 break;
5922 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5923 fixup.fixup_rela_off = entry->d_un.d_val;
5924 res++;
5925 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5926 break;
5927
5928 case DT_IA_64_VMS_IMG_RELA_CNT:
5929 imgrela.img_rela_cnt = entry->d_un.d_val;
5930 break;
5931 case DT_IA_64_VMS_IMG_RELA_OFF:
5932 imgrela.img_rela_off = entry->d_un.d_val;
5933 res++;
5934 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5935 break;
5936
5937 default:
5938 break;
5939 }
5940 }
5941
5942 if (strtab != NULL)
5943 free (strtab);
5944
5945 return res;
5946}
5947
85b1c36d 5948static struct
566b0d53 5949{
2cf0635d 5950 const char * name;
566b0d53
L		 5951 int reloc;
5952 int size;
5953 int rela;
5954} dynamic_relocations [] =
5955{
5956 { "REL", DT_REL, DT_RELSZ, FALSE },
5957 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5958 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5959};
5960
252b5132 5961/* Process the reloc section. */
18bd398b 5962
252b5132 5963static int
2cf0635d 5964process_relocs (FILE * file)
252b5132 5965{
b34976b6
AM		 5966 unsigned long rel_size;
5967 unsigned long rel_offset;
252b5132
RH		 5968
5969
5970 if (!do_reloc)
5971 return 1;
5972
5973 if (do_using_dynamic)
5974 {
566b0d53 5975 int is_rela;
2cf0635d 5976 const char * name;
566b0d53
L		 5977 int has_dynamic_reloc;
5978 unsigned int i;
0de14b54 5979
566b0d53 5980 has_dynamic_reloc = 0;
252b5132 5981
566b0d53 5982 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5983 {
566b0d53
L		 5984 is_rela = dynamic_relocations [i].rela;
5985 name = dynamic_relocations [i].name;
5986 rel_size = dynamic_info [dynamic_relocations [i].size];
5987 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5988
566b0d53
L		 5989 has_dynamic_reloc |= rel_size;
5990
5991 if (is_rela == UNKNOWN)
aa903cfb 5992 {
566b0d53
L		 5993 if (dynamic_relocations [i].reloc == DT_JMPREL)
5994 switch (dynamic_info[DT_PLTREL])
5995 {
5996 case DT_REL:
5997 is_rela = FALSE;
5998 break;
5999 case DT_RELA:
6000 is_rela = TRUE;
6001 break;
6002 }
aa903cfb 6003 }
252b5132 6004
566b0d53
L		 6005 if (rel_size)
6006 {
6007 printf
6008 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6009 name, rel_offset, rel_size);
252b5132 6010
d93f0186
NC		 6011 dump_relocations (file,
6012 offset_from_vma (file, rel_offset, rel_size),
6013 rel_size,
566b0d53 6014 dynamic_symbols, num_dynamic_syms,
d79b3d50 6015 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 6016 }
252b5132 6017 }
566b0d53 6018
28f997cf
TG		 6019 if (is_ia64_vms ())
6020 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6021
566b0d53 6022 if (! has_dynamic_reloc)
252b5132
RH		 6023 printf (_("\nThere are no dynamic relocations in this file.\n"));
6024 }
6025 else
6026 {
2cf0635d 6027 Elf_Internal_Shdr * section;
b34976b6
AM		 6028 unsigned long i;
6029 int found = 0;
252b5132
RH		 6030
6031 for (i = 0, section = section_headers;
6032 i < elf_header.e_shnum;
b34976b6 6033 i++, section++)
252b5132
RH		 6034 {
6035 if ( section->sh_type != SHT_RELA
6036 && section->sh_type != SHT_REL)
6037 continue;
6038
6039 rel_offset = section->sh_offset;
6040 rel_size = section->sh_size;
6041
6042 if (rel_size)
6043 {
2cf0635d 6044 Elf_Internal_Shdr * strsec;
b34976b6 6045 int is_rela;
103f02d3 6046
252b5132
RH		 6047 printf (_("\nRelocation section "));
6048
6049 if (string_table == NULL)
19936277 6050 printf ("%d", section->sh_name);
252b5132 6051 else
9cf03b7e 6052 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 6053
6054 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6055 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6056
d79b3d50
NC		 6057 is_rela = section->sh_type == SHT_RELA;
6058
4fbb74a6
AM		 6059 if (section->sh_link != 0
6060 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6061 {
2cf0635d
NC		 6062 Elf_Internal_Shdr * symsec;
6063 Elf_Internal_Sym * symtab;
d79b3d50 6064 unsigned long nsyms;
c256ffe7 6065 unsigned long strtablen = 0;
2cf0635d 6066 char * strtab = NULL;
57346661 6067
4fbb74a6 6068 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6069 if (symsec->sh_type != SHT_SYMTAB
6070 && symsec->sh_type != SHT_DYNSYM)
6071 continue;
6072
ba5cdace 6073 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6074
af3fc3bc
AM		 6075 if (symtab == NULL)
6076 continue;
252b5132 6077
4fbb74a6
AM		 6078 if (symsec->sh_link != 0
6079 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6080 {
4fbb74a6 6081 strsec = section_headers + symsec->sh_link;
103f02d3 6082
3f5e193b
NC		 6083 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6084 1, strsec->sh_size,
6085 _("string table"));
c256ffe7
JJ		 6086 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6087 }
252b5132 6088
d79b3d50
NC		 6089 dump_relocations (file, rel_offset, rel_size,
6090 symtab, nsyms, strtab, strtablen, is_rela);
6091 if (strtab)
6092 free (strtab);
6093 free (symtab);
6094 }
6095 else
6096 dump_relocations (file, rel_offset, rel_size,
6097 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 6098
6099 found = 1;
6100 }
6101 }
6102
6103 if (! found)
6104 printf (_("\nThere are no relocations in this file.\n"));
6105 }
6106
6107 return 1;
6108}
6109
57346661
AM		 6110/* Process the unwind section. */
6111
4d6ed7c8
NC		 6112#include "unwind-ia64.h"
6113
6114/* An absolute address consists of a section and an offset. If the
6115 section is NULL, the offset itself is the address, otherwise, the
6116 address equals to LOAD_ADDRESS(section) + offset. */
6117
6118struct absaddr
6119 {
6120 unsigned short section;
6121 bfd_vma offset;
6122 };
6123
1949de15
L		 6124#define ABSADDR(a) \
6125 ((a).section \
6126 ? section_headers [(a).section].sh_addr + (a).offset \
6127 : (a).offset)
6128
3f5e193b
NC		 6129struct ia64_unw_table_entry
6130 {
6131 struct absaddr start;
6132 struct absaddr end;
6133 struct absaddr info;
6134 };
6135
57346661 6136struct ia64_unw_aux_info
4d6ed7c8 6137 {
3f5e193b
NC		 6138
6139 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 6140 unsigned long table_len; /* Length of unwind table. */
2cf0635d 6141 unsigned char * info; /* Unwind info. */
b34976b6
AM		 6142 unsigned long info_size; /* Size of unwind info. */
6143 bfd_vma info_addr; /* starting address of unwind info. */
6144 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6145 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 6146 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6147 char * strtab; /* The string table. */
b34976b6 6148 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 6149 };
6150
4d6ed7c8 6151static void
2cf0635d 6152find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 6153 unsigned long nsyms,
2cf0635d 6154 const char * strtab,
57346661 6155 unsigned long strtab_size,
d3ba0551 6156 struct absaddr addr,
2cf0635d
NC		 6157 const char ** symname,
6158 bfd_vma * offset)
4d6ed7c8 6159{
d3ba0551 6160 bfd_vma dist = 0x100000;
2cf0635d
NC		 6161 Elf_Internal_Sym * sym;
6162 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 6163 unsigned long i;
6164
0b6ae522
DJ		 6165 REMOVE_ARCH_BITS (addr.offset);
6166
57346661 6167 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 6168 {
0b6ae522
DJ		 6169 bfd_vma value = sym->st_value;
6170
6171 REMOVE_ARCH_BITS (value);
6172
4d6ed7c8
NC		 6173 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6174 && sym->st_name != 0
6175 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6176 && addr.offset >= value
6177 && addr.offset - value < dist)
4d6ed7c8
NC		 6178 {
6179 best = sym;
0b6ae522 6180 dist = addr.offset - value;
4d6ed7c8
NC		 6181 if (!dist)
6182 break;
6183 }
6184 }
1b31d05e 6185
4d6ed7c8
NC		 6186 if (best)
6187 {
57346661 6188 *symname = (best->st_name >= strtab_size
2b692964 6189 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6190 *offset = dist;
6191 return;
6192 }
1b31d05e 6193
4d6ed7c8
NC		 6194 *symname = NULL;
6195 *offset = addr.offset;
6196}
6197
6198static void
2cf0635d 6199dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6200{
2cf0635d 6201 struct ia64_unw_table_entry * tp;
4d6ed7c8 6202 int in_body;
7036c0e1 6203
4d6ed7c8
NC		 6204 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6205 {
6206 bfd_vma stamp;
6207 bfd_vma offset;
2cf0635d
NC		 6208 const unsigned char * dp;
6209 const unsigned char * head;
6210 const char * procname;
4d6ed7c8 6211
57346661
AM		 6212 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6213 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6214
6215 fputs ("\n<", stdout);
6216
6217 if (procname)
6218 {
6219 fputs (procname, stdout);
6220
6221 if (offset)
6222 printf ("+%lx", (unsigned long) offset);
6223 }
6224
6225 fputs (">: [", stdout);
6226 print_vma (tp->start.offset, PREFIX_HEX);
6227 fputc ('-', stdout);
6228 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6229 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6230 (unsigned long) (tp->info.offset - aux->seg_base));
6231
1949de15 6232 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6233 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6234
86f55779 6235 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6236 (unsigned) UNW_VER (stamp),
6237 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6238 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6239 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6240 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6241
6242 if (UNW_VER (stamp) != 1)
6243 {
2b692964 6244 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6245 continue;
6246 }
6247
6248 in_body = 0;
89fac5e3 6249 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 6250 dp = unw_decode (dp, in_body, & in_body);
6251 }
6252}
6253
6254static int
2cf0635d
NC		 6255slurp_ia64_unwind_table (FILE * file,
6256 struct ia64_unw_aux_info * aux,
6257 Elf_Internal_Shdr * sec)
4d6ed7c8 6258{
89fac5e3 6259 unsigned long size, nrelas, i;
2cf0635d
NC		 6260 Elf_Internal_Phdr * seg;
6261 struct ia64_unw_table_entry * tep;
6262 Elf_Internal_Shdr * relsec;
6263 Elf_Internal_Rela * rela;
6264 Elf_Internal_Rela * rp;
6265 unsigned char * table;
6266 unsigned char * tp;
6267 Elf_Internal_Sym * sym;
6268 const char * relname;
4d6ed7c8 6269
4d6ed7c8
NC		 6270 /* First, find the starting address of the segment that includes
6271 this section: */
6272
6273 if (elf_header.e_phnum)
6274 {
d93f0186 6275 if (! get_program_headers (file))
4d6ed7c8 6276 return 0;
4d6ed7c8 6277
d93f0186
NC		 6278 for (seg = program_headers;
6279 seg < program_headers + elf_header.e_phnum;
6280 ++seg)
4d6ed7c8
NC		 6281 {
6282 if (seg->p_type != PT_LOAD)
6283 continue;
6284
6285 if (sec->sh_addr >= seg->p_vaddr
6286 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6287 {
6288 aux->seg_base = seg->p_vaddr;
6289 break;
6290 }
6291 }
4d6ed7c8
NC		 6292 }
6293
6294 /* Second, build the unwind table from the contents of the unwind section: */
6295 size = sec->sh_size;
3f5e193b
NC		 6296 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6297 _("unwind table"));
a6e9f9df
AM		 6298 if (!table)
6299 return 0;
4d6ed7c8 6300
3f5e193b
NC		 6301 aux->table = (struct ia64_unw_table_entry *)
6302 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 6303 tep = aux->table;
c6a0c689 6304 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 6305 {
6306 tep->start.section = SHN_UNDEF;
6307 tep->end.section = SHN_UNDEF;
6308 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6309 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6310 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6311 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6312 tep->start.offset += aux->seg_base;
6313 tep->end.offset += aux->seg_base;
6314 tep->info.offset += aux->seg_base;
6315 }
6316 free (table);
6317
41e92641 6318 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6319 for (relsec = section_headers;
6320 relsec < section_headers + elf_header.e_shnum;
6321 ++relsec)
6322 {
6323 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6324 || relsec->sh_info >= elf_header.e_shnum
6325 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6326 continue;
6327
6328 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6329 & rela, & nrelas))
6330 return 0;
6331
6332 for (rp = rela; rp < rela + nrelas; ++rp)
6333 {
aca88567
NC		 6334 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6335 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6336
0112cd26 6337 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6338 {
e5fb9629 6339 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 6340 continue;
6341 }
6342
89fac5e3 6343 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6344
89fac5e3 6345 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 6346 {
6347 case 0:
6348 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6349 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6350 break;
6351 case 1:
6352 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6353 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6354 break;
6355 case 2:
6356 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6357 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6358 break;
6359 default:
6360 break;
6361 }
6362 }
6363
6364 free (rela);
6365 }
6366
89fac5e3 6367 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 6368 return 1;
6369}
6370
1b31d05e 6371static void
2cf0635d 6372ia64_process_unwind (FILE * file)
4d6ed7c8 6373{
2cf0635d
NC		 6374 Elf_Internal_Shdr * sec;
6375 Elf_Internal_Shdr * unwsec = NULL;
6376 Elf_Internal_Shdr * strsec;
89fac5e3 6377 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6378 struct ia64_unw_aux_info aux;
f1467e33 6379
4d6ed7c8
NC		 6380 memset (& aux, 0, sizeof (aux));
6381
4d6ed7c8
NC		 6382 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6383 {
c256ffe7 6384 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6385 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6386 {
ba5cdace 6387 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6388
4fbb74a6 6389 strsec = section_headers + sec->sh_link;
59245841 6390 assert (aux.strtab == NULL);
3f5e193b
NC		 6391 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6392 1, strsec->sh_size,
6393 _("string table"));
c256ffe7 6394 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6395 }
6396 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6397 unwcount++;
6398 }
6399
6400 if (!unwcount)
6401 printf (_("\nThere are no unwind sections in this file.\n"));
6402
6403 while (unwcount-- > 0)
6404 {
2cf0635d 6405 char * suffix;
579f31ac
JJ		 6406 size_t len, len2;
6407
6408 for (i = unwstart, sec = section_headers + unwstart;
6409 i < elf_header.e_shnum; ++i, ++sec)
6410 if (sec->sh_type == SHT_IA_64_UNWIND)
6411 {
6412 unwsec = sec;
6413 break;
6414 }
6415
6416 unwstart = i + 1;
6417 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6418
e4b17d5c
L		 6419 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6420 {
6421 /* We need to find which section group it is in. */
2cf0635d 6422 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 6423
6424 for (; g != NULL; g = g->next)
6425 {
4fbb74a6 6426 sec = section_headers + g->section_index;
18bd398b
NC		 6427
6428 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6429 break;
e4b17d5c
L		 6430 }
6431
6432 if (g == NULL)
6433 i = elf_header.e_shnum;
6434 }
18bd398b 6435 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6436 {
18bd398b 6437 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6438 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6439 suffix = SECTION_NAME (unwsec) + len;
6440 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6441 ++i, ++sec)
18bd398b
NC		 6442 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6443 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6444 break;
6445 }
6446 else
6447 {
6448 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6449 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6450 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6451 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6452 suffix = "";
18bd398b 6453 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6454 suffix = SECTION_NAME (unwsec) + len;
6455 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6456 ++i, ++sec)
18bd398b
NC		 6457 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6458 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6459 break;
6460 }
6461
6462 if (i == elf_header.e_shnum)
6463 {
6464 printf (_("\nCould not find unwind info section for "));
6465
6466 if (string_table == NULL)
6467 printf ("%d", unwsec->sh_name);
6468 else
3a1a2036 6469 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 6470 }
6471 else
4d6ed7c8 6472 {
4d6ed7c8 6473 aux.info_addr = sec->sh_addr;
3f5e193b 6474 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6475 sec->sh_size,
3f5e193b 6476 _("unwind info"));
59245841 6477 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6478
579f31ac 6479 printf (_("\nUnwind section "));
4d6ed7c8 6480
579f31ac
JJ		 6481 if (string_table == NULL)
6482 printf ("%d", unwsec->sh_name);
6483 else
3a1a2036 6484 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6485
579f31ac 6486 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6487 (unsigned long) unwsec->sh_offset,
89fac5e3 6488 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6489
579f31ac 6490 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6491
579f31ac
JJ		 6492 if (aux.table_len > 0)
6493 dump_ia64_unwind (& aux);
6494
6495 if (aux.table)
6496 free ((char *) aux.table);
6497 if (aux.info)
6498 free ((char *) aux.info);
6499 aux.table = NULL;
6500 aux.info = NULL;
6501 }
4d6ed7c8 6502 }
4d6ed7c8 6503
4d6ed7c8
NC		 6504 if (aux.symtab)
6505 free (aux.symtab);
6506 if (aux.strtab)
6507 free ((char *) aux.strtab);
4d6ed7c8
NC		 6508}
6509
3f5e193b
NC		 6510struct hppa_unw_table_entry
6511 {
6512 struct absaddr start;
6513 struct absaddr end;
6514 unsigned int Cannot_unwind:1; /* 0 */
6515 unsigned int Millicode:1; /* 1 */
6516 unsigned int Millicode_save_sr0:1; /* 2 */
6517 unsigned int Region_description:2; /* 3..4 */
6518 unsigned int reserved1:1; /* 5 */
6519 unsigned int Entry_SR:1; /* 6 */
6520 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6521 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6522 unsigned int Args_stored:1; /* 16 */
6523 unsigned int Variable_Frame:1; /* 17 */
6524 unsigned int Separate_Package_Body:1; /* 18 */
6525 unsigned int Frame_Extension_Millicode:1; /* 19 */
6526 unsigned int Stack_Overflow_Check:1; /* 20 */
6527 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6528 unsigned int Ada_Region:1; /* 22 */
6529 unsigned int cxx_info:1; /* 23 */
6530 unsigned int cxx_try_catch:1; /* 24 */
6531 unsigned int sched_entry_seq:1; /* 25 */
6532 unsigned int reserved2:1; /* 26 */
6533 unsigned int Save_SP:1; /* 27 */
6534 unsigned int Save_RP:1; /* 28 */
6535 unsigned int Save_MRP_in_frame:1; /* 29 */
6536 unsigned int extn_ptr_defined:1; /* 30 */
6537 unsigned int Cleanup_defined:1; /* 31 */
6538
6539 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6540 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6541 unsigned int Large_frame:1; /* 2 */
6542 unsigned int Pseudo_SP_Set:1; /* 3 */
6543 unsigned int reserved4:1; /* 4 */
6544 unsigned int Total_frame_size:27; /* 5..31 */
6545 };
6546
57346661
AM		 6547struct hppa_unw_aux_info
6548 {
3f5e193b 6549 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6550 unsigned long table_len; /* Length of unwind table. */
6551 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6552 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6553 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6554 char * strtab; /* The string table. */
57346661
AM		 6555 unsigned long strtab_size; /* Size of string table. */
6556 };
6557
6558static void
2cf0635d 6559dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6560{
2cf0635d 6561 struct hppa_unw_table_entry * tp;
57346661 6562
57346661
AM		 6563 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6564 {
6565 bfd_vma offset;
2cf0635d 6566 const char * procname;
57346661
AM		 6567
6568 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6569 aux->strtab_size, tp->start, &procname,
6570 &offset);
6571
6572 fputs ("\n<", stdout);
6573
6574 if (procname)
6575 {
6576 fputs (procname, stdout);
6577
6578 if (offset)
6579 printf ("+%lx", (unsigned long) offset);
6580 }
6581
6582 fputs (">: [", stdout);
6583 print_vma (tp->start.offset, PREFIX_HEX);
6584 fputc ('-', stdout);
6585 print_vma (tp->end.offset, PREFIX_HEX);
6586 printf ("]\n\t");
6587
18bd398b
NC		 6588#define PF(_m) if (tp->_m) printf (#_m " ");
6589#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6590 PF(Cannot_unwind);
6591 PF(Millicode);
6592 PF(Millicode_save_sr0);
18bd398b 6593 /* PV(Region_description); */
57346661
AM		 6594 PF(Entry_SR);
6595 PV(Entry_FR);
6596 PV(Entry_GR);
6597 PF(Args_stored);
6598 PF(Variable_Frame);
6599 PF(Separate_Package_Body);
6600 PF(Frame_Extension_Millicode);
6601 PF(Stack_Overflow_Check);
6602 PF(Two_Instruction_SP_Increment);
6603 PF(Ada_Region);
6604 PF(cxx_info);
6605 PF(cxx_try_catch);
6606 PF(sched_entry_seq);
6607 PF(Save_SP);
6608 PF(Save_RP);
6609 PF(Save_MRP_in_frame);
6610 PF(extn_ptr_defined);
6611 PF(Cleanup_defined);
6612 PF(MPE_XL_interrupt_marker);
6613 PF(HP_UX_interrupt_marker);
6614 PF(Large_frame);
6615 PF(Pseudo_SP_Set);
6616 PV(Total_frame_size);
6617#undef PF
6618#undef PV
6619 }
6620
18bd398b 6621 printf ("\n");
57346661
AM		 6622}
6623
6624static int
2cf0635d
NC		 6625slurp_hppa_unwind_table (FILE * file,
6626 struct hppa_unw_aux_info * aux,
6627 Elf_Internal_Shdr * sec)
57346661 6628{
1c0751b2 6629 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6630 Elf_Internal_Phdr * seg;
6631 struct hppa_unw_table_entry * tep;
6632 Elf_Internal_Shdr * relsec;
6633 Elf_Internal_Rela * rela;
6634 Elf_Internal_Rela * rp;
6635 unsigned char * table;
6636 unsigned char * tp;
6637 Elf_Internal_Sym * sym;
6638 const char * relname;
57346661 6639
57346661
AM		 6640 /* First, find the starting address of the segment that includes
6641 this section. */
6642
6643 if (elf_header.e_phnum)
6644 {
6645 if (! get_program_headers (file))
6646 return 0;
6647
6648 for (seg = program_headers;
6649 seg < program_headers + elf_header.e_phnum;
6650 ++seg)
6651 {
6652 if (seg->p_type != PT_LOAD)
6653 continue;
6654
6655 if (sec->sh_addr >= seg->p_vaddr
6656 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6657 {
6658 aux->seg_base = seg->p_vaddr;
6659 break;
6660 }
6661 }
6662 }
6663
6664 /* Second, build the unwind table from the contents of the unwind
6665 section. */
6666 size = sec->sh_size;
3f5e193b
NC		 6667 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6668 _("unwind table"));
57346661
AM		 6669 if (!table)
6670 return 0;
6671
1c0751b2
DA		 6672 unw_ent_size = 16;
6673 nentries = size / unw_ent_size;
6674 size = unw_ent_size * nentries;
57346661 6675
3f5e193b
NC		 6676 tep = aux->table = (struct hppa_unw_table_entry *)
6677 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6678
1c0751b2 6679 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6680 {
6681 unsigned int tmp1, tmp2;
6682
6683 tep->start.section = SHN_UNDEF;
6684 tep->end.section = SHN_UNDEF;
6685
1c0751b2
DA		 6686 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6687 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6688 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6689 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6690
6691 tep->start.offset += aux->seg_base;
6692 tep->end.offset += aux->seg_base;
57346661
AM		 6693
6694 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6695 tep->Millicode = (tmp1 >> 30) & 0x1;
6696 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6697 tep->Region_description = (tmp1 >> 27) & 0x3;
6698 tep->reserved1 = (tmp1 >> 26) & 0x1;
6699 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6700 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6701 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6702 tep->Args_stored = (tmp1 >> 15) & 0x1;
6703 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6704 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6705 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6706 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6707 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6708 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6709 tep->cxx_info = (tmp1 >> 8) & 0x1;
6710 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6711 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6712 tep->reserved2 = (tmp1 >> 5) & 0x1;
6713 tep->Save_SP = (tmp1 >> 4) & 0x1;
6714 tep->Save_RP = (tmp1 >> 3) & 0x1;
6715 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6716 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6717 tep->Cleanup_defined = tmp1 & 0x1;
6718
6719 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6720 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6721 tep->Large_frame = (tmp2 >> 29) & 0x1;
6722 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6723 tep->reserved4 = (tmp2 >> 27) & 0x1;
6724 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6725 }
6726 free (table);
6727
6728 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6729 for (relsec = section_headers;
6730 relsec < section_headers + elf_header.e_shnum;
6731 ++relsec)
6732 {
6733 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6734 || relsec->sh_info >= elf_header.e_shnum
6735 || section_headers + relsec->sh_info != sec)
57346661
AM		 6736 continue;
6737
6738 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6739 & rela, & nrelas))
6740 return 0;
6741
6742 for (rp = rela; rp < rela + nrelas; ++rp)
6743 {
aca88567
NC		 6744 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6745 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6746
6747 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6748 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6749 {
6750 warn (_("Skipping unexpected relocation type %s\n"), relname);
6751 continue;
6752 }
6753
6754 i = rp->r_offset / unw_ent_size;
6755
89fac5e3 6756 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6757 {
6758 case 0:
6759 aux->table[i].start.section = sym->st_shndx;
1e456d54 6760 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6761 break;
6762 case 1:
6763 aux->table[i].end.section = sym->st_shndx;
1e456d54 6764 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6765 break;
6766 default:
6767 break;
6768 }
6769 }
6770
6771 free (rela);
6772 }
6773
1c0751b2 6774 aux->table_len = nentries;
57346661
AM		 6775
6776 return 1;
6777}
6778
1b31d05e 6779static void
2cf0635d 6780hppa_process_unwind (FILE * file)
57346661 6781{
57346661 6782 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6783 Elf_Internal_Shdr * unwsec = NULL;
6784 Elf_Internal_Shdr * strsec;
6785 Elf_Internal_Shdr * sec;
18bd398b 6786 unsigned long i;
57346661 6787
c256ffe7 6788 if (string_table == NULL)
1b31d05e
NC		 6789 return;
6790
6791 memset (& aux, 0, sizeof (aux));
57346661
AM		 6792
6793 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6794 {
c256ffe7 6795 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6796 && sec->sh_link < elf_header.e_shnum)
57346661 6797 {
ba5cdace 6798 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6799
4fbb74a6 6800 strsec = section_headers + sec->sh_link;
59245841 6801 assert (aux.strtab == NULL);
3f5e193b
NC		 6802 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6803 1, strsec->sh_size,
6804 _("string table"));
c256ffe7 6805 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6806 }
18bd398b 6807 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6808 unwsec = sec;
6809 }
6810
6811 if (!unwsec)
6812 printf (_("\nThere are no unwind sections in this file.\n"));
6813
6814 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6815 {
18bd398b 6816 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6817 {
57346661
AM		 6818 printf (_("\nUnwind section "));
6819 printf (_("'%s'"), SECTION_NAME (sec));
6820
6821 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6822 (unsigned long) sec->sh_offset,
89fac5e3 6823 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6824
6825 slurp_hppa_unwind_table (file, &aux, sec);
6826 if (aux.table_len > 0)
6827 dump_hppa_unwind (&aux);
6828
6829 if (aux.table)
6830 free ((char *) aux.table);
6831 aux.table = NULL;
6832 }
6833 }
6834
6835 if (aux.symtab)
6836 free (aux.symtab);
6837 if (aux.strtab)
6838 free ((char *) aux.strtab);
57346661
AM		 6839}
6840
0b6ae522
DJ		 6841struct arm_section
6842{
a734115a
NC		 6843 unsigned char * data; /* The unwind data. */
6844 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6845 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6846 unsigned long nrelas; /* The number of relocations. */
6847 unsigned int rel_type; /* REL or RELA ? */
6848 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6849};
6850
6851struct arm_unw_aux_info
6852{
a734115a
NC		 6853 FILE * file; /* The file containing the unwind sections. */
6854 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6855 unsigned long nsyms; /* Number of symbols. */
6856 char * strtab; /* The file's string table. */
6857 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6858};
6859
6860static const char *
6861arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6862 bfd_vma fn, struct absaddr addr)
6863{
6864 const char *procname;
6865 bfd_vma sym_offset;
6866
6867 if (addr.section == SHN_UNDEF)
6868 addr.offset = fn;
6869
6870 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6871 aux->strtab_size, addr, &procname,
6872 &sym_offset);
6873
6874 print_vma (fn, PREFIX_HEX);
6875
6876 if (procname)
6877 {
6878 fputs (" <", stdout);
6879 fputs (procname, stdout);
6880
6881 if (sym_offset)
6882 printf ("+0x%lx", (unsigned long) sym_offset);
6883 fputc ('>', stdout);
6884 }
6885
6886 return procname;
6887}
6888
6889static void
6890arm_free_section (struct arm_section *arm_sec)
6891{
6892 if (arm_sec->data != NULL)
6893 free (arm_sec->data);
6894
6895 if (arm_sec->rela != NULL)
6896 free (arm_sec->rela);
6897}
6898
a734115a
NC		 6899/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6900 cached section and install SEC instead.
6901 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6902 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6903 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6904 relocation's offset in ADDR.
1b31d05e
NC		 6905 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6906 into the string table of the symbol associated with the reloc. If no
6907 reloc was applied store -1 there.
6908 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6909
6910static bfd_boolean
1b31d05e
NC		 6911get_unwind_section_word (struct arm_unw_aux_info * aux,
6912 struct arm_section * arm_sec,
6913 Elf_Internal_Shdr * sec,
6914 bfd_vma word_offset,
6915 unsigned int * wordp,
6916 struct absaddr * addr,
6917 bfd_vma * sym_name)
0b6ae522
DJ		 6918{
6919 Elf_Internal_Rela *rp;
6920 Elf_Internal_Sym *sym;
6921 const char * relname;
6922 unsigned int word;
6923 bfd_boolean wrapped;
6924
e0a31db1
NC		 6925 if (sec == NULL || arm_sec == NULL)
6926 return FALSE;
6927
0b6ae522
DJ		 6928 addr->section = SHN_UNDEF;
6929 addr->offset = 0;
6930
1b31d05e
NC		 6931 if (sym_name != NULL)
6932 *sym_name = (bfd_vma) -1;
6933
a734115a 6934 /* If necessary, update the section cache. */
0b6ae522
DJ		 6935 if (sec != arm_sec->sec)
6936 {
6937 Elf_Internal_Shdr *relsec;
6938
6939 arm_free_section (arm_sec);
6940
6941 arm_sec->sec = sec;
6942 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6943 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6944 arm_sec->rela = NULL;
6945 arm_sec->nrelas = 0;
6946
6947 for (relsec = section_headers;
6948 relsec < section_headers + elf_header.e_shnum;
6949 ++relsec)
6950 {
6951 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 6952 || section_headers + relsec->sh_info != sec
6953 /* PR 15745: Check the section type as well. */
6954 || (relsec->sh_type != SHT_REL
6955 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 6956 continue;
6957
a734115a 6958 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6959 if (relsec->sh_type == SHT_REL)
6960 {
6961 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6962 relsec->sh_size,
6963 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6964 return FALSE;
0b6ae522 6965 }
1ae40aa4 6966 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 6967 {
6968 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6969 relsec->sh_size,
6970 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6971 return FALSE;
0b6ae522 6972 }
1ae40aa4 6973 break;
0b6ae522
DJ		 6974 }
6975
6976 arm_sec->next_rela = arm_sec->rela;
6977 }
6978
a734115a 6979 /* If there is no unwind data we can do nothing. */
0b6ae522 6980 if (arm_sec->data == NULL)
a734115a 6981 return FALSE;
0b6ae522 6982
e0a31db1
NC		 6983 /* If the offset is invalid then fail. */
6984 if (word_offset > sec->sh_size - 4)
6985 return FALSE;
6986
a734115a 6987 /* Get the word at the required offset. */
0b6ae522
DJ		 6988 word = byte_get (arm_sec->data + word_offset, 4);
6989
a734115a 6990 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6991 wrapped = FALSE;
6992 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6993 {
6994 bfd_vma prelval, offset;
6995
6996 if (rp->r_offset > word_offset && !wrapped)
6997 {
6998 rp = arm_sec->rela;
6999 wrapped = TRUE;
7000 }
7001 if (rp->r_offset > word_offset)
7002 break;
7003
7004 if (rp->r_offset & 3)
7005 {
7006 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7007 (unsigned long) rp->r_offset);
7008 continue;
7009 }
7010
7011 if (rp->r_offset < word_offset)
7012 continue;
7013
0b6ae522
DJ		 7014 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7015
7016 if (arm_sec->rel_type == SHT_REL)
7017 {
7018 offset = word & 0x7fffffff;
7019 if (offset & 0x40000000)
7020 offset |= ~ (bfd_vma) 0x7fffffff;
7021 }
a734115a 7022 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7023 offset = rp->r_addend;
a734115a
NC		 7024 else
7025 abort ();
0b6ae522
DJ		 7026
7027 offset += sym->st_value;
7028 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7029
a734115a
NC		 7030 /* Check that we are processing the expected reloc type. */
7031 if (elf_header.e_machine == EM_ARM)
7032 {
7033 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7034
7035 if (streq (relname, "R_ARM_NONE"))
7036 continue;
0b4362b0 7037
a734115a
NC		 7038 if (! streq (relname, "R_ARM_PREL31"))
7039 {
7040 warn (_("Skipping unexpected relocation type %s\n"), relname);
7041 continue;
7042 }
7043 }
7044 else if (elf_header.e_machine == EM_TI_C6000)
7045 {
7046 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
0b4362b0 7047
a734115a
NC		 7048 if (streq (relname, "R_C6000_NONE"))
7049 continue;
7050
7051 if (! streq (relname, "R_C6000_PREL31"))
7052 {
7053 warn (_("Skipping unexpected relocation type %s\n"), relname);
7054 continue;
7055 }
7056
7057 prelval >>= 1;
7058 }
7059 else
7060 /* This function currently only supports ARM and TI unwinders. */
7061 abort ();
fa197c1c 7062
0b6ae522
DJ		 7063 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7064 addr->section = sym->st_shndx;
7065 addr->offset = offset;
1b31d05e
NC		 7066 if (sym_name)
7067 * sym_name = sym->st_name;
0b6ae522
DJ		 7068 break;
7069 }
7070
7071 *wordp = word;
7072 arm_sec->next_rela = rp;
7073
a734115a 7074 return TRUE;
0b6ae522
DJ		 7075}
7076
a734115a
NC		 7077static const char *tic6x_unwind_regnames[16] =
7078{
0b4362b0
RM		 7079 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7080 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7081 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7082};
fa197c1c 7083
0b6ae522 7084static void
fa197c1c 7085decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7086{
fa197c1c
PB		 7087 int i;
7088
7089 for (i = 12; mask; mask >>= 1, i--)
7090 {
7091 if (mask & 1)
7092 {
7093 fputs (tic6x_unwind_regnames[i], stdout);
7094 if (mask > 1)
7095 fputs (", ", stdout);
7096 }
7097 }
7098}
0b6ae522
DJ		 7099
7100#define ADVANCE \
7101 if (remaining == 0 && more_words) \
7102 { \
7103 data_offset += 4; \
1b31d05e
NC		 7104 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7105 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7106 return; \
7107 remaining = 4; \
7108 more_words--; \
7109 } \
7110
7111#define GET_OP(OP) \
7112 ADVANCE; \
7113 if (remaining) \
7114 { \
7115 remaining--; \
7116 (OP) = word >> 24; \
7117 word <<= 8; \
7118 } \
7119 else \
7120 { \
2b692964 7121 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7122 return; \
7123 } \
cc5914eb 7124 printf ("0x%02x ", OP)
0b6ae522 7125
fa197c1c
PB		 7126static void
7127decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7128 unsigned int word, unsigned int remaining,
7129 unsigned int more_words,
7130 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7131 struct arm_section *data_arm_sec)
7132{
7133 struct absaddr addr;
0b6ae522
DJ		 7134
7135 /* Decode the unwinding instructions. */
7136 while (1)
7137 {
7138 unsigned int op, op2;
7139
7140 ADVANCE;
7141 if (remaining == 0)
7142 break;
7143 remaining--;
7144 op = word >> 24;
7145 word <<= 8;
7146
cc5914eb 7147 printf (" 0x%02x ", op);
0b6ae522
DJ		 7148
7149 if ((op & 0xc0) == 0x00)
7150 {
7151 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7152
cc5914eb 7153 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7154 }
7155 else if ((op & 0xc0) == 0x40)
7156 {
7157 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7158
cc5914eb 7159 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7160 }
7161 else if ((op & 0xf0) == 0x80)
7162 {
7163 GET_OP (op2);
7164 if (op == 0x80 && op2 == 0)
7165 printf (_("Refuse to unwind"));
7166 else
7167 {
7168 unsigned int mask = ((op & 0x0f) << 8) | op2;
7169 int first = 1;
7170 int i;
2b692964 7171
0b6ae522
DJ		 7172 printf ("pop {");
7173 for (i = 0; i < 12; i++)
7174 if (mask & (1 << i))
7175 {
7176 if (first)
7177 first = 0;
7178 else
7179 printf (", ");
7180 printf ("r%d", 4 + i);
7181 }
7182 printf ("}");
7183 }
7184 }
7185 else if ((op & 0xf0) == 0x90)
7186 {
7187 if (op == 0x9d || op == 0x9f)
7188 printf (_(" [Reserved]"));
7189 else
cc5914eb 7190 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7191 }
7192 else if ((op & 0xf0) == 0xa0)
7193 {
7194 int end = 4 + (op & 0x07);
7195 int first = 1;
7196 int i;
61865e30 7197
0b6ae522
DJ		 7198 printf (" pop {");
7199 for (i = 4; i <= end; i++)
7200 {
7201 if (first)
7202 first = 0;
7203 else
7204 printf (", ");
7205 printf ("r%d", i);
7206 }
7207 if (op & 0x08)
7208 {
1b31d05e 7209 if (!first)
0b6ae522
DJ		 7210 printf (", ");
7211 printf ("r14");
7212 }
7213 printf ("}");
7214 }
7215 else if (op == 0xb0)
7216 printf (_(" finish"));
7217 else if (op == 0xb1)
7218 {
7219 GET_OP (op2);
7220 if (op2 == 0 || (op2 & 0xf0) != 0)
7221 printf (_("[Spare]"));
7222 else
7223 {
7224 unsigned int mask = op2 & 0x0f;
7225 int first = 1;
7226 int i;
61865e30 7227
0b6ae522
DJ		 7228 printf ("pop {");
7229 for (i = 0; i < 12; i++)
7230 if (mask & (1 << i))
7231 {
7232 if (first)
7233 first = 0;
7234 else
7235 printf (", ");
7236 printf ("r%d", i);
7237 }
7238 printf ("}");
7239 }
7240 }
7241 else if (op == 0xb2)
7242 {
b115cf96 7243 unsigned char buf[9];
0b6ae522
DJ		 7244 unsigned int i, len;
7245 unsigned long offset;
61865e30 7246
b115cf96 7247 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7248 {
7249 GET_OP (buf[i]);
7250 if ((buf[i] & 0x80) == 0)
7251 break;
7252 }
7253 assert (i < sizeof (buf));
f6f0e17b 7254 offset = read_uleb128 (buf, &len, buf + i + 1);
0b6ae522
DJ		 7255 assert (len == i + 1);
7256 offset = offset * 4 + 0x204;
cc5914eb 7257 printf ("vsp = vsp + %ld", offset);
0b6ae522 7258 }
61865e30 7259 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7260 {
61865e30
NC		 7261 unsigned int first, last;
7262
7263 GET_OP (op2);
7264 first = op2 >> 4;
7265 last = op2 & 0x0f;
7266 if (op == 0xc8)
7267 first = first + 16;
7268 printf ("pop {D%d", first);
7269 if (last)
7270 printf ("-D%d", first + last);
7271 printf ("}");
7272 }
7273 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7274 {
7275 unsigned int count = op & 0x07;
7276
7277 printf ("pop {D8");
7278 if (count)
7279 printf ("-D%d", 8 + count);
7280 printf ("}");
7281 }
7282 else if (op >= 0xc0 && op <= 0xc5)
7283 {
7284 unsigned int count = op & 0x07;
7285
7286 printf (" pop {wR10");
7287 if (count)
7288 printf ("-wR%d", 10 + count);
7289 printf ("}");
7290 }
7291 else if (op == 0xc6)
7292 {
7293 unsigned int first, last;
7294
7295 GET_OP (op2);
7296 first = op2 >> 4;
7297 last = op2 & 0x0f;
7298 printf ("pop {wR%d", first);
7299 if (last)
7300 printf ("-wR%d", first + last);
7301 printf ("}");
7302 }
7303 else if (op == 0xc7)
7304 {
7305 GET_OP (op2);
7306 if (op2 == 0 || (op2 & 0xf0) != 0)
7307 printf (_("[Spare]"));
0b6ae522
DJ		 7308 else
7309 {
61865e30
NC		 7310 unsigned int mask = op2 & 0x0f;
7311 int first = 1;
7312 int i;
7313
7314 printf ("pop {");
7315 for (i = 0; i < 4; i++)
7316 if (mask & (1 << i))
7317 {
7318 if (first)
7319 first = 0;
7320 else
7321 printf (", ");
7322 printf ("wCGR%d", i);
7323 }
7324 printf ("}");
0b6ae522
DJ		 7325 }
7326 }
61865e30
NC		 7327 else
7328 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7329 printf ("\n");
7330 }
fa197c1c
PB		 7331}
7332
7333static void
7334decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7335 unsigned int word, unsigned int remaining,
7336 unsigned int more_words,
7337 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7338 struct arm_section *data_arm_sec)
7339{
7340 struct absaddr addr;
7341
7342 /* Decode the unwinding instructions. */
7343 while (1)
7344 {
7345 unsigned int op, op2;
7346
7347 ADVANCE;
7348 if (remaining == 0)
7349 break;
7350 remaining--;
7351 op = word >> 24;
7352 word <<= 8;
7353
9cf03b7e 7354 printf (" 0x%02x ", op);
fa197c1c
PB		 7355
7356 if ((op & 0xc0) == 0x00)
7357 {
7358 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7359 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7360 }
7361 else if ((op & 0xc0) == 0x80)
7362 {
7363 GET_OP (op2);
7364 if (op == 0x80 && op2 == 0)
7365 printf (_("Refuse to unwind"));
7366 else
7367 {
7368 unsigned int mask = ((op & 0x1f) << 8) | op2;
7369 if (op & 0x20)
7370 printf ("pop compact {");
7371 else
7372 printf ("pop {");
7373
7374 decode_tic6x_unwind_regmask (mask);
7375 printf("}");
7376 }
7377 }
7378 else if ((op & 0xf0) == 0xc0)
7379 {
7380 unsigned int reg;
7381 unsigned int nregs;
7382 unsigned int i;
7383 const char *name;
a734115a
NC		 7384 struct
7385 {
fa197c1c
PB		 7386 unsigned int offset;
7387 unsigned int reg;
7388 } regpos[16];
7389
7390 /* Scan entire instruction first so that GET_OP output is not
7391 interleaved with disassembly. */
7392 nregs = 0;
7393 for (i = 0; nregs < (op & 0xf); i++)
7394 {
7395 GET_OP (op2);
7396 reg = op2 >> 4;
7397 if (reg != 0xf)
7398 {
7399 regpos[nregs].offset = i * 2;
7400 regpos[nregs].reg = reg;
7401 nregs++;
7402 }
7403
7404 reg = op2 & 0xf;
7405 if (reg != 0xf)
7406 {
7407 regpos[nregs].offset = i * 2 + 1;
7408 regpos[nregs].reg = reg;
7409 nregs++;
7410 }
7411 }
7412
7413 printf (_("pop frame {"));
7414 reg = nregs - 1;
7415 for (i = i * 2; i > 0; i--)
7416 {
7417 if (regpos[reg].offset == i - 1)
7418 {
7419 name = tic6x_unwind_regnames[regpos[reg].reg];
7420 if (reg > 0)
7421 reg--;
7422 }
7423 else
7424 name = _("[pad]");
7425
7426 fputs (name, stdout);
7427 if (i > 1)
7428 printf (", ");
7429 }
7430
7431 printf ("}");
7432 }
7433 else if (op == 0xd0)
7434 printf (" MOV FP, SP");
7435 else if (op == 0xd1)
7436 printf (" __c6xabi_pop_rts");
7437 else if (op == 0xd2)
7438 {
7439 unsigned char buf[9];
7440 unsigned int i, len;
7441 unsigned long offset;
a734115a 7442
fa197c1c
PB		 7443 for (i = 0; i < sizeof (buf); i++)
7444 {
7445 GET_OP (buf[i]);
7446 if ((buf[i] & 0x80) == 0)
7447 break;
7448 }
7449 assert (i < sizeof (buf));
f6f0e17b 7450 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7451 assert (len == i + 1);
7452 offset = offset * 8 + 0x408;
7453 printf (_("sp = sp + %ld"), offset);
7454 }
7455 else if ((op & 0xf0) == 0xe0)
7456 {
7457 if ((op & 0x0f) == 7)
7458 printf (" RETURN");
7459 else
7460 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7461 }
7462 else
7463 {
7464 printf (_(" [unsupported opcode]"));
7465 }
7466 putchar ('\n');
7467 }
7468}
7469
7470static bfd_vma
a734115a 7471arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7472{
7473 bfd_vma offset;
7474
7475 offset = word & 0x7fffffff;
7476 if (offset & 0x40000000)
7477 offset |= ~ (bfd_vma) 0x7fffffff;
7478
7479 if (elf_header.e_machine == EM_TI_C6000)
7480 offset <<= 1;
7481
7482 return offset + where;
7483}
7484
7485static void
1b31d05e
NC		 7486decode_arm_unwind (struct arm_unw_aux_info * aux,
7487 unsigned int word,
7488 unsigned int remaining,
7489 bfd_vma data_offset,
7490 Elf_Internal_Shdr * data_sec,
7491 struct arm_section * data_arm_sec)
fa197c1c
PB		 7492{
7493 int per_index;
7494 unsigned int more_words = 0;
37e14bc3 7495 struct absaddr addr;
1b31d05e 7496 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7497
7498 if (remaining == 0)
7499 {
1b31d05e
NC		 7500 /* Fetch the first word.
7501 Note - when decoding an object file the address extracted
7502 here will always be 0. So we also pass in the sym_name
7503 parameter so that we can find the symbol associated with
7504 the personality routine. */
7505 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7506 & word, & addr, & sym_name))
fa197c1c 7507 return;
1b31d05e 7508
fa197c1c
PB		 7509 remaining = 4;
7510 }
7511
7512 if ((word & 0x80000000) == 0)
7513 {
7514 /* Expand prel31 for personality routine. */
7515 bfd_vma fn;
7516 const char *procname;
7517
a734115a 7518 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7519 printf (_(" Personality routine: "));
1b31d05e
NC		 7520 if (fn == 0
7521 && addr.section == SHN_UNDEF && addr.offset == 0
7522 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7523 {
7524 procname = aux->strtab + sym_name;
7525 print_vma (fn, PREFIX_HEX);
7526 if (procname)
7527 {
7528 fputs (" <", stdout);
7529 fputs (procname, stdout);
7530 fputc ('>', stdout);
7531 }
7532 }
7533 else
7534 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7535 fputc ('\n', stdout);
7536
7537 /* The GCC personality routines use the standard compact
7538 encoding, starting with one byte giving the number of
7539 words. */
7540 if (procname != NULL
7541 && (const_strneq (procname, "__gcc_personality_v0")
7542 || const_strneq (procname, "__gxx_personality_v0")
7543 || const_strneq (procname, "__gcj_personality_v0")
7544 || const_strneq (procname, "__gnu_objc_personality_v0")))
7545 {
7546 remaining = 0;
7547 more_words = 1;
7548 ADVANCE;
7549 if (!remaining)
7550 {
7551 printf (_(" [Truncated data]\n"));
7552 return;
7553 }
7554 more_words = word >> 24;
7555 word <<= 8;
7556 remaining--;
7557 per_index = -1;
7558 }
7559 else
7560 return;
7561 }
7562 else
7563 {
1b31d05e 7564 /* ARM EHABI Section 6.3:
0b4362b0 7565
1b31d05e 7566 An exception-handling table entry for the compact model looks like:
0b4362b0 7567
1b31d05e
NC		 7568 31 30-28 27-24 23-0
7569 -- ----- ----- ----
7570 1 0 index Data for personalityRoutine[index] */
7571
7572 if (elf_header.e_machine == EM_ARM
7573 && (word & 0x70000000))
83c257ca 7574 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7575
fa197c1c 7576 per_index = (word >> 24) & 0x7f;
1b31d05e 7577 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7578 if (per_index == 0)
7579 {
7580 more_words = 0;
7581 word <<= 8;
7582 remaining--;
7583 }
7584 else if (per_index < 3)
7585 {
7586 more_words = (word >> 16) & 0xff;
7587 word <<= 16;
7588 remaining -= 2;
7589 }
7590 }
7591
7592 switch (elf_header.e_machine)
7593 {
7594 case EM_ARM:
7595 if (per_index < 3)
7596 {
7597 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7598 data_offset, data_sec, data_arm_sec);
7599 }
7600 else
1b31d05e
NC		 7601 {
7602 warn (_("Unknown ARM compact model index encountered\n"));
7603 printf (_(" [reserved]\n"));
7604 }
fa197c1c
PB		 7605 break;
7606
7607 case EM_TI_C6000:
7608 if (per_index < 3)
7609 {
7610 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7611 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7612 }
7613 else if (per_index < 5)
7614 {
7615 if (((word >> 17) & 0x7f) == 0x7f)
7616 printf (_(" Restore stack from frame pointer\n"));
7617 else
7618 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7619 printf (_(" Registers restored: "));
7620 if (per_index == 4)
7621 printf (" (compact) ");
7622 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7623 putchar ('\n');
7624 printf (_(" Return register: %s\n"),
7625 tic6x_unwind_regnames[word & 0xf]);
7626 }
7627 else
1b31d05e 7628 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7629 break;
7630
7631 default:
1b31d05e
NC		 7632 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7633 elf_header.e_machine);
fa197c1c 7634 }
0b6ae522
DJ		 7635
7636 /* Decode the descriptors. Not implemented. */
7637}
7638
7639static void
7640dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7641{
7642 struct arm_section exidx_arm_sec, extab_arm_sec;
7643 unsigned int i, exidx_len;
7644
7645 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7646 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7647 exidx_len = exidx_sec->sh_size / 8;
7648
7649 for (i = 0; i < exidx_len; i++)
7650 {
7651 unsigned int exidx_fn, exidx_entry;
7652 struct absaddr fn_addr, entry_addr;
7653 bfd_vma fn;
7654
7655 fputc ('\n', stdout);
7656
1b31d05e
NC		 7657 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7658 8 * i, & exidx_fn, & fn_addr, NULL)
7659 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7660 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7661 {
1b31d05e
NC		 7662 arm_free_section (& exidx_arm_sec);
7663 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7664 return;
7665 }
7666
83c257ca
NC		 7667 /* ARM EHABI, Section 5:
7668 An index table entry consists of 2 words.
7669 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7670 if (exidx_fn & 0x80000000)
7671 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7672
a734115a 7673 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7674
a734115a 7675 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7676 fputs (": ", stdout);
7677
7678 if (exidx_entry == 1)
7679 {
7680 print_vma (exidx_entry, PREFIX_HEX);
7681 fputs (" [cantunwind]\n", stdout);
7682 }
7683 else if (exidx_entry & 0x80000000)
7684 {
7685 print_vma (exidx_entry, PREFIX_HEX);
7686 fputc ('\n', stdout);
7687 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7688 }
7689 else
7690 {
8f73510c 7691 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7692 Elf_Internal_Shdr *table_sec;
7693
7694 fputs ("@", stdout);
a734115a 7695 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7696 print_vma (table, PREFIX_HEX);
7697 printf ("\n");
7698
7699 /* Locate the matching .ARM.extab. */
7700 if (entry_addr.section != SHN_UNDEF
7701 && entry_addr.section < elf_header.e_shnum)
7702 {
7703 table_sec = section_headers + entry_addr.section;
7704 table_offset = entry_addr.offset;
7705 }
7706 else
7707 {
7708 table_sec = find_section_by_address (table);
7709 if (table_sec != NULL)
7710 table_offset = table - table_sec->sh_addr;
7711 }
7712 if (table_sec == NULL)
7713 {
7714 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7715 (unsigned long) table);
7716 continue;
7717 }
7718 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7719 &extab_arm_sec);
7720 }
7721 }
7722
7723 printf ("\n");
7724
7725 arm_free_section (&exidx_arm_sec);
7726 arm_free_section (&extab_arm_sec);
7727}
7728
fa197c1c 7729/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7730
7731static void
0b6ae522
DJ		 7732arm_process_unwind (FILE *file)
7733{
7734 struct arm_unw_aux_info aux;
7735 Elf_Internal_Shdr *unwsec = NULL;
7736 Elf_Internal_Shdr *strsec;
7737 Elf_Internal_Shdr *sec;
7738 unsigned long i;
fa197c1c 7739 unsigned int sec_type;
0b6ae522 7740
fa197c1c
PB		 7741 switch (elf_header.e_machine)
7742 {
7743 case EM_ARM:
7744 sec_type = SHT_ARM_EXIDX;
7745 break;
7746
7747 case EM_TI_C6000:
7748 sec_type = SHT_C6000_UNWIND;
7749 break;
7750
0b4362b0 7751 default:
1b31d05e
NC		 7752 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7753 elf_header.e_machine);
7754 return;
fa197c1c
PB		 7755 }
7756
0b6ae522 7757 if (string_table == NULL)
1b31d05e
NC		 7758 return;
7759
7760 memset (& aux, 0, sizeof (aux));
7761 aux.file = file;
0b6ae522
DJ		 7762
7763 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7764 {
7765 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7766 {
ba5cdace 7767 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7768
7769 strsec = section_headers + sec->sh_link;
59245841 7770 assert (aux.strtab == NULL);
0b6ae522
DJ		 7771 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7772 1, strsec->sh_size, _("string table"));
7773 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7774 }
fa197c1c 7775 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7776 unwsec = sec;
7777 }
7778
1b31d05e 7779 if (unwsec == NULL)
0b6ae522 7780 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7781 else
7782 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7783 {
7784 if (sec->sh_type == sec_type)
7785 {
7786 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7787 SECTION_NAME (sec),
7788 (unsigned long) sec->sh_offset,
7789 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7790
1b31d05e
NC		 7791 dump_arm_unwind (&aux, sec);
7792 }
7793 }
0b6ae522
DJ		 7794
7795 if (aux.symtab)
7796 free (aux.symtab);
7797 if (aux.strtab)
7798 free ((char *) aux.strtab);
0b6ae522
DJ		 7799}
7800
1b31d05e 7801static void
2cf0635d 7802process_unwind (FILE * file)
57346661 7803{
2cf0635d
NC		 7804 struct unwind_handler
7805 {
57346661 7806 int machtype;
1b31d05e 7807 void (* handler)(FILE *);
2cf0635d
NC		 7808 } handlers[] =
7809 {
0b6ae522 7810 { EM_ARM, arm_process_unwind },
57346661
AM		 7811 { EM_IA_64, ia64_process_unwind },
7812 { EM_PARISC, hppa_process_unwind },
fa197c1c 7813 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7814 { 0, 0 }
7815 };
7816 int i;
7817
7818 if (!do_unwind)
1b31d05e 7819 return;
57346661
AM		 7820
7821 for (i = 0; handlers[i].handler != NULL; i++)
7822 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 7823 {
7824 handlers[i].handler (file);
7825 return;
7826 }
57346661 7827
1b31d05e
NC		 7828 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7829 get_machine_name (elf_header.e_machine));
57346661
AM		 7830}
7831
252b5132 7832static void
2cf0635d 7833dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7834{
7835 switch (entry->d_tag)
7836 {
7837 case DT_MIPS_FLAGS:
7838 if (entry->d_un.d_val == 0)
4b68bca3 7839 printf (_("NONE"));
252b5132
RH		 7840 else
7841 {
7842 static const char * opts[] =
7843 {
7844 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7845 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7846 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7847 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7848 "RLD_ORDER_SAFE"
7849 };
7850 unsigned int cnt;
7851 int first = 1;
2b692964 7852
60bca95a 7853 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7854 if (entry->d_un.d_val & (1 << cnt))
7855 {
7856 printf ("%s%s", first ? "" : " ", opts[cnt]);
7857 first = 0;
7858 }
252b5132
RH		 7859 }
7860 break;
103f02d3 7861
252b5132 7862 case DT_MIPS_IVERSION:
d79b3d50 7863 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7864 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7865 else
76ca31c0
NC		 7866 {
7867 char buf[40];
7868 sprintf_vma (buf, entry->d_un.d_ptr);
7869 /* Note: coded this way so that there is a single string for translation. */
7870 printf (_("<corrupt: %s>"), buf);
7871 }
252b5132 7872 break;
103f02d3 7873
252b5132
RH		 7874 case DT_MIPS_TIME_STAMP:
7875 {
7876 char timebuf[20];
2cf0635d 7877 struct tm * tmp;
50da7a9c 7878
91d6fa6a
NC		 7879 time_t atime = entry->d_un.d_val;
7880 tmp = gmtime (&atime);
e9e44622
JJ		 7881 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7882 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7883 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7884 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7885 }
7886 break;
103f02d3 7887
252b5132
RH		 7888 case DT_MIPS_RLD_VERSION:
7889 case DT_MIPS_LOCAL_GOTNO:
7890 case DT_MIPS_CONFLICTNO:
7891 case DT_MIPS_LIBLISTNO:
7892 case DT_MIPS_SYMTABNO:
7893 case DT_MIPS_UNREFEXTNO:
7894 case DT_MIPS_HIPAGENO:
7895 case DT_MIPS_DELTA_CLASS_NO:
7896 case DT_MIPS_DELTA_INSTANCE_NO:
7897 case DT_MIPS_DELTA_RELOC_NO:
7898 case DT_MIPS_DELTA_SYM_NO:
7899 case DT_MIPS_DELTA_CLASSSYM_NO:
7900 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7901 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7902 break;
103f02d3
UD		 7903
7904 default:
4b68bca3 7905 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7906 }
4b68bca3 7907 putchar ('\n');
103f02d3
UD		 7908}
7909
103f02d3 7910static void
2cf0635d 7911dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7912{
7913 switch (entry->d_tag)
7914 {
7915 case DT_HP_DLD_FLAGS:
7916 {
7917 static struct
7918 {
7919 long int bit;
2cf0635d 7920 const char * str;
5e220199
NC		 7921 }
7922 flags[] =
7923 {
7924 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7925 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7926 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7927 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7928 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7929 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7930 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7931 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7932 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7933 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7934 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7935 { DT_HP_GST, "HP_GST" },
7936 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7937 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7938 { DT_HP_NODELETE, "HP_NODELETE" },
7939 { DT_HP_GROUP, "HP_GROUP" },
7940 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7941 };
103f02d3 7942 int first = 1;
5e220199 7943 size_t cnt;
f7a99963 7944 bfd_vma val = entry->d_un.d_val;
103f02d3 7945
60bca95a 7946 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7947 if (val & flags[cnt].bit)
30800947
NC		 7948 {
7949 if (! first)
7950 putchar (' ');
7951 fputs (flags[cnt].str, stdout);
7952 first = 0;
7953 val ^= flags[cnt].bit;
7954 }
76da6bbe 7955
103f02d3 7956 if (val != 0 || first)
f7a99963
NC		 7957 {
7958 if (! first)
7959 putchar (' ');
7960 print_vma (val, HEX);
7961 }
103f02d3
UD		 7962 }
7963 break;
76da6bbe 7964
252b5132 7965 default:
f7a99963
NC		 7966 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7967 break;
252b5132 7968 }
35b1837e 7969 putchar ('\n');
252b5132
RH		 7970}
7971
28f997cf
TG		 7972#ifdef BFD64
7973
7974/* VMS vs Unix time offset and factor. */
7975
7976#define VMS_EPOCH_OFFSET 35067168000000000LL
7977#define VMS_GRANULARITY_FACTOR 10000000
7978
7979/* Display a VMS time in a human readable format. */
7980
7981static void
7982print_vms_time (bfd_int64_t vmstime)
7983{
7984 struct tm *tm;
7985 time_t unxtime;
7986
7987 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7988 tm = gmtime (&unxtime);
7989 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7990 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7991 tm->tm_hour, tm->tm_min, tm->tm_sec);
7992}
7993#endif /* BFD64 */
7994
ecc51f48 7995static void
2cf0635d 7996dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7997{
7998 switch (entry->d_tag)
7999 {
0de14b54 8000 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8001 /* First 3 slots reserved. */
ecc51f48
NC		 8002 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8003 printf (" -- ");
8004 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8005 break;
8006
28f997cf
TG		 8007 case DT_IA_64_VMS_LINKTIME:
8008#ifdef BFD64
8009 print_vms_time (entry->d_un.d_val);
8010#endif
8011 break;
8012
8013 case DT_IA_64_VMS_LNKFLAGS:
8014 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8015 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8016 printf (" CALL_DEBUG");
8017 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8018 printf (" NOP0BUFS");
8019 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8020 printf (" P0IMAGE");
8021 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8022 printf (" MKTHREADS");
8023 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8024 printf (" UPCALLS");
8025 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8026 printf (" IMGSTA");
8027 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8028 printf (" INITIALIZE");
8029 if (entry->d_un.d_val & VMS_LF_MAIN)
8030 printf (" MAIN");
8031 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8032 printf (" EXE_INIT");
8033 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8034 printf (" TBK_IN_IMG");
8035 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8036 printf (" DBG_IN_IMG");
8037 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8038 printf (" TBK_IN_DSF");
8039 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8040 printf (" DBG_IN_DSF");
8041 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8042 printf (" SIGNATURES");
8043 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8044 printf (" REL_SEG_OFF");
8045 break;
8046
bdf4d63a
JJ		 8047 default:
8048 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8049 break;
ecc51f48 8050 }
bdf4d63a 8051 putchar ('\n');
ecc51f48
NC		 8052}
8053
252b5132 8054static int
2cf0635d 8055get_32bit_dynamic_section (FILE * file)
252b5132 8056{
2cf0635d
NC		 8057 Elf32_External_Dyn * edyn;
8058 Elf32_External_Dyn * ext;
8059 Elf_Internal_Dyn * entry;
103f02d3 8060
3f5e193b
NC		 8061 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8062 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8063 if (!edyn)
8064 return 0;
103f02d3 8065
ba2685cc
AM		 8066/* SGI's ELF has more than one section in the DYNAMIC segment, and we
8067 might not have the luxury of section headers. Look for the DT_NULL
8068 terminator to determine the number of entries. */
8069 for (ext = edyn, dynamic_nent = 0;
8070 (char *) ext < (char *) edyn + dynamic_size;
8071 ext++)
8072 {
8073 dynamic_nent++;
8074 if (BYTE_GET (ext->d_tag) == DT_NULL)
8075 break;
8076 }
252b5132 8077
3f5e193b
NC		 8078 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8079 sizeof (* entry));
b2d38a17 8080 if (dynamic_section == NULL)
252b5132 8081 {
9ea033b2
NC		 8082 error (_("Out of memory\n"));
8083 free (edyn);
8084 return 0;
8085 }
252b5132 8086
fb514b26 8087 for (ext = edyn, entry = dynamic_section;
ba2685cc 8088 entry < dynamic_section + dynamic_nent;
fb514b26 8089 ext++, entry++)
9ea033b2 8090 {
fb514b26
AM		 8091 entry->d_tag = BYTE_GET (ext->d_tag);
8092 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8093 }
8094
9ea033b2
NC		 8095 free (edyn);
8096
8097 return 1;
8098}
8099
8100static int
2cf0635d 8101get_64bit_dynamic_section (FILE * file)
9ea033b2 8102{
2cf0635d
NC		 8103 Elf64_External_Dyn * edyn;
8104 Elf64_External_Dyn * ext;
8105 Elf_Internal_Dyn * entry;
103f02d3 8106
3f5e193b
NC		 8107 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8108 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8109 if (!edyn)
8110 return 0;
103f02d3 8111
ba2685cc
AM		 8112/* SGI's ELF has more than one section in the DYNAMIC segment, and we
8113 might not have the luxury of section headers. Look for the DT_NULL
8114 terminator to determine the number of entries. */
8115 for (ext = edyn, dynamic_nent = 0;
8116 (char *) ext < (char *) edyn + dynamic_size;
8117 ext++)
8118 {
8119 dynamic_nent++;
66543521 8120 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8121 break;
8122 }
252b5132 8123
3f5e193b
NC		 8124 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8125 sizeof (* entry));
b2d38a17 8126 if (dynamic_section == NULL)
252b5132
RH		 8127 {
8128 error (_("Out of memory\n"));
8129 free (edyn);
8130 return 0;
8131 }
8132
fb514b26 8133 for (ext = edyn, entry = dynamic_section;
ba2685cc 8134 entry < dynamic_section + dynamic_nent;
fb514b26 8135 ext++, entry++)
252b5132 8136 {
66543521
AM		 8137 entry->d_tag = BYTE_GET (ext->d_tag);
8138 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8139 }
8140
8141 free (edyn);
8142
9ea033b2
NC		 8143 return 1;
8144}
8145
e9e44622
JJ		 8146static void
8147print_dynamic_flags (bfd_vma flags)
d1133906 8148{
e9e44622 8149 int first = 1;
13ae64f3 8150
d1133906
NC		 8151 while (flags)
8152 {
8153 bfd_vma flag;
8154
8155 flag = flags & - flags;
8156 flags &= ~ flag;
8157
e9e44622
JJ		 8158 if (first)
8159 first = 0;
8160 else
8161 putc (' ', stdout);
13ae64f3 8162
d1133906
NC		 8163 switch (flag)
8164 {
e9e44622
JJ		 8165 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8166 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8167 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8168 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8169 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8170 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8171 }
8172 }
e9e44622 8173 puts ("");
d1133906
NC		 8174}
8175
b2d38a17
NC		 8176/* Parse and display the contents of the dynamic section. */
8177
9ea033b2 8178static int
2cf0635d 8179process_dynamic_section (FILE * file)
9ea033b2 8180{
2cf0635d 8181 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8182
8183 if (dynamic_size == 0)
8184 {
8185 if (do_dynamic)
b2d38a17 8186 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8187
8188 return 1;
8189 }
8190
8191 if (is_32bit_elf)
8192 {
b2d38a17 8193 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8194 return 0;
8195 }
b2d38a17 8196 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8197 return 0;
8198
252b5132
RH		 8199 /* Find the appropriate symbol table. */
8200 if (dynamic_symbols == NULL)
8201 {
86dba8ee
AM		 8202 for (entry = dynamic_section;
8203 entry < dynamic_section + dynamic_nent;
8204 ++entry)
252b5132 8205 {
c8286bd1 8206 Elf_Internal_Shdr section;
252b5132
RH		 8207
8208 if (entry->d_tag != DT_SYMTAB)
8209 continue;
8210
8211 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8212
8213 /* Since we do not know how big the symbol table is,
8214 we default to reading in the entire file (!) and
8215 processing that. This is overkill, I know, but it
e3c8793a 8216 should work. */
d93f0186 8217 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8218
fb52b2f4
NC		 8219 if (archive_file_offset != 0)
8220 section.sh_size = archive_file_size - section.sh_offset;
8221 else
8222 {
8223 if (fseek (file, 0, SEEK_END))
591a748a 8224 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8225
8226 section.sh_size = ftell (file) - section.sh_offset;
8227 }
252b5132 8228
9ea033b2 8229 if (is_32bit_elf)
9ad5cbcf 8230 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8231 else
9ad5cbcf 8232 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 8233
ba5cdace 8234 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8235 if (num_dynamic_syms < 1)
252b5132
RH		 8236 {
8237 error (_("Unable to determine the number of symbols to load\n"));
8238 continue;
8239 }
252b5132
RH		 8240 }
8241 }
8242
8243 /* Similarly find a string table. */
8244 if (dynamic_strings == NULL)
8245 {
86dba8ee
AM		 8246 for (entry = dynamic_section;
8247 entry < dynamic_section + dynamic_nent;
8248 ++entry)
252b5132
RH		 8249 {
8250 unsigned long offset;
b34976b6 8251 long str_tab_len;
252b5132
RH		 8252
8253 if (entry->d_tag != DT_STRTAB)
8254 continue;
8255
8256 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8257
8258 /* Since we do not know how big the string table is,
8259 we default to reading in the entire file (!) and
8260 processing that. This is overkill, I know, but it
e3c8793a 8261 should work. */
252b5132 8262
d93f0186 8263 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8264
8265 if (archive_file_offset != 0)
8266 str_tab_len = archive_file_size - offset;
8267 else
8268 {
8269 if (fseek (file, 0, SEEK_END))
8270 error (_("Unable to seek to end of file\n"));
8271 str_tab_len = ftell (file) - offset;
8272 }
252b5132
RH		 8273
8274 if (str_tab_len < 1)
8275 {
8276 error
8277 (_("Unable to determine the length of the dynamic string table\n"));
8278 continue;
8279 }
8280
3f5e193b
NC		 8281 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8282 str_tab_len,
8283 _("dynamic string table"));
59245841 8284 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8285 break;
8286 }
8287 }
8288
8289 /* And find the syminfo section if available. */
8290 if (dynamic_syminfo == NULL)
8291 {
3e8bba36 8292 unsigned long syminsz = 0;
252b5132 8293
86dba8ee
AM		 8294 for (entry = dynamic_section;
8295 entry < dynamic_section + dynamic_nent;
8296 ++entry)
252b5132
RH		 8297 {
8298 if (entry->d_tag == DT_SYMINENT)
8299 {
8300 /* Note: these braces are necessary to avoid a syntax
8301 error from the SunOS4 C compiler. */
049b0c3a
NC		 8302 /* PR binutils/17531: A corrupt file can trigger this test.
8303 So do not use an assert, instead generate an error message. */
8304 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8305 error (_("Bad value (%d) for SYMINENT entry"),
8306 (int) entry->d_un.d_val);
252b5132
RH		 8307 }
8308 else if (entry->d_tag == DT_SYMINSZ)
8309 syminsz = entry->d_un.d_val;
8310 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8311 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8312 syminsz);
252b5132
RH		 8313 }
8314
8315 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8316 {
2cf0635d
NC		 8317 Elf_External_Syminfo * extsyminfo;
8318 Elf_External_Syminfo * extsym;
8319 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8320
8321 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8322 extsyminfo = (Elf_External_Syminfo *)
8323 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8324 _("symbol information"));
a6e9f9df
AM		 8325 if (!extsyminfo)
8326 return 0;
252b5132 8327
3f5e193b 8328 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8329 if (dynamic_syminfo == NULL)
8330 {
8331 error (_("Out of memory\n"));
8332 return 0;
8333 }
8334
8335 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8336 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8337 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8338 ++syminfo, ++extsym)
252b5132 8339 {
86dba8ee
AM		 8340 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8341 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8342 }
8343
8344 free (extsyminfo);
8345 }
8346 }
8347
8348 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 8349 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8350 dynamic_addr, dynamic_nent);
252b5132
RH		 8351 if (do_dynamic)
8352 printf (_(" Tag Type Name/Value\n"));
8353
86dba8ee
AM		 8354 for (entry = dynamic_section;
8355 entry < dynamic_section + dynamic_nent;
8356 entry++)
252b5132
RH		 8357 {
8358 if (do_dynamic)
f7a99963 8359 {
2cf0635d 8360 const char * dtype;
e699b9ff 8361
f7a99963
NC		 8362 putchar (' ');
8363 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8364 dtype = get_dynamic_type (entry->d_tag);
8365 printf (" (%s)%*s", dtype,
8366 ((is_32bit_elf ? 27 : 19)
8367 - (int) strlen (dtype)),
f7a99963
NC		 8368 " ");
8369 }
252b5132
RH		 8370
8371 switch (entry->d_tag)
8372 {
d1133906
NC		 8373 case DT_FLAGS:
8374 if (do_dynamic)
e9e44622 8375 print_dynamic_flags (entry->d_un.d_val);
d1133906 8376 break;
76da6bbe 8377
252b5132
RH		 8378 case DT_AUXILIARY:
8379 case DT_FILTER:
019148e4
L		 8380 case DT_CONFIG:
8381 case DT_DEPAUDIT:
8382 case DT_AUDIT:
252b5132
RH		 8383 if (do_dynamic)
8384 {
019148e4 8385 switch (entry->d_tag)
b34976b6 8386 {
019148e4
L		 8387 case DT_AUXILIARY:
8388 printf (_("Auxiliary library"));
8389 break;
8390
8391 case DT_FILTER:
8392 printf (_("Filter library"));
8393 break;
8394
b34976b6 8395 case DT_CONFIG:
019148e4
L		 8396 printf (_("Configuration file"));
8397 break;
8398
8399 case DT_DEPAUDIT:
8400 printf (_("Dependency audit library"));
8401 break;
8402
8403 case DT_AUDIT:
8404 printf (_("Audit library"));
8405 break;
8406 }
252b5132 8407
d79b3d50
NC		 8408 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8409 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8410 else
f7a99963
NC		 8411 {
8412 printf (": ");
8413 print_vma (entry->d_un.d_val, PREFIX_HEX);
8414 putchar ('\n');
8415 }
252b5132
RH		 8416 }
8417 break;
8418
dcefbbbd 8419 case DT_FEATURE:
252b5132
RH		 8420 if (do_dynamic)
8421 {
8422 printf (_("Flags:"));
86f55779 8423
252b5132
RH		 8424 if (entry->d_un.d_val == 0)
8425 printf (_(" None\n"));
8426 else
8427 {
8428 unsigned long int val = entry->d_un.d_val;
86f55779 8429
252b5132
RH		 8430 if (val & DTF_1_PARINIT)
8431 {
8432 printf (" PARINIT");
8433 val ^= DTF_1_PARINIT;
8434 }
dcefbbbd
L		 8435 if (val & DTF_1_CONFEXP)
8436 {
8437 printf (" CONFEXP");
8438 val ^= DTF_1_CONFEXP;
8439 }
252b5132
RH		 8440 if (val != 0)
8441 printf (" %lx", val);
8442 puts ("");
8443 }
8444 }
8445 break;
8446
8447 case DT_POSFLAG_1:
8448 if (do_dynamic)
8449 {
8450 printf (_("Flags:"));
86f55779 8451
252b5132
RH		 8452 if (entry->d_un.d_val == 0)
8453 printf (_(" None\n"));
8454 else
8455 {
8456 unsigned long int val = entry->d_un.d_val;
86f55779 8457
252b5132
RH		 8458 if (val & DF_P1_LAZYLOAD)
8459 {
8460 printf (" LAZYLOAD");
8461 val ^= DF_P1_LAZYLOAD;
8462 }
8463 if (val & DF_P1_GROUPPERM)
8464 {
8465 printf (" GROUPPERM");
8466 val ^= DF_P1_GROUPPERM;
8467 }
8468 if (val != 0)
8469 printf (" %lx", val);
8470 puts ("");
8471 }
8472 }
8473 break;
8474
8475 case DT_FLAGS_1:
8476 if (do_dynamic)
8477 {
8478 printf (_("Flags:"));
8479 if (entry->d_un.d_val == 0)
8480 printf (_(" None\n"));
8481 else
8482 {
8483 unsigned long int val = entry->d_un.d_val;
86f55779 8484
252b5132
RH		 8485 if (val & DF_1_NOW)
8486 {
8487 printf (" NOW");
8488 val ^= DF_1_NOW;
8489 }
8490 if (val & DF_1_GLOBAL)
8491 {
8492 printf (" GLOBAL");
8493 val ^= DF_1_GLOBAL;
8494 }
8495 if (val & DF_1_GROUP)
8496 {
8497 printf (" GROUP");
8498 val ^= DF_1_GROUP;
8499 }
8500 if (val & DF_1_NODELETE)
8501 {
8502 printf (" NODELETE");
8503 val ^= DF_1_NODELETE;
8504 }
8505 if (val & DF_1_LOADFLTR)
8506 {
8507 printf (" LOADFLTR");
8508 val ^= DF_1_LOADFLTR;
8509 }
8510 if (val & DF_1_INITFIRST)
8511 {
8512 printf (" INITFIRST");
8513 val ^= DF_1_INITFIRST;
8514 }
8515 if (val & DF_1_NOOPEN)
8516 {
8517 printf (" NOOPEN");
8518 val ^= DF_1_NOOPEN;
8519 }
8520 if (val & DF_1_ORIGIN)
8521 {
8522 printf (" ORIGIN");
8523 val ^= DF_1_ORIGIN;
8524 }
8525 if (val & DF_1_DIRECT)
8526 {
8527 printf (" DIRECT");
8528 val ^= DF_1_DIRECT;
8529 }
8530 if (val & DF_1_TRANS)
8531 {
8532 printf (" TRANS");
8533 val ^= DF_1_TRANS;
8534 }
8535 if (val & DF_1_INTERPOSE)
8536 {
8537 printf (" INTERPOSE");
8538 val ^= DF_1_INTERPOSE;
8539 }
f7db6139 8540 if (val & DF_1_NODEFLIB)
dcefbbbd 8541 {
f7db6139
L		 8542 printf (" NODEFLIB");
8543 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8544 }
8545 if (val & DF_1_NODUMP)
8546 {
8547 printf (" NODUMP");
8548 val ^= DF_1_NODUMP;
8549 }
34b60028 8550 if (val & DF_1_CONFALT)
dcefbbbd 8551 {
34b60028
L		 8552 printf (" CONFALT");
8553 val ^= DF_1_CONFALT;
8554 }
8555 if (val & DF_1_ENDFILTEE)
8556 {
8557 printf (" ENDFILTEE");
8558 val ^= DF_1_ENDFILTEE;
8559 }
8560 if (val & DF_1_DISPRELDNE)
8561 {
8562 printf (" DISPRELDNE");
8563 val ^= DF_1_DISPRELDNE;
8564 }
8565 if (val & DF_1_DISPRELPND)
8566 {
8567 printf (" DISPRELPND");
8568 val ^= DF_1_DISPRELPND;
8569 }
8570 if (val & DF_1_NODIRECT)
8571 {
8572 printf (" NODIRECT");
8573 val ^= DF_1_NODIRECT;
8574 }
8575 if (val & DF_1_IGNMULDEF)
8576 {
8577 printf (" IGNMULDEF");
8578 val ^= DF_1_IGNMULDEF;
8579 }
8580 if (val & DF_1_NOKSYMS)
8581 {
8582 printf (" NOKSYMS");
8583 val ^= DF_1_NOKSYMS;
8584 }
8585 if (val & DF_1_NOHDR)
8586 {
8587 printf (" NOHDR");
8588 val ^= DF_1_NOHDR;
8589 }
8590 if (val & DF_1_EDITED)
8591 {
8592 printf (" EDITED");
8593 val ^= DF_1_EDITED;
8594 }
8595 if (val & DF_1_NORELOC)
8596 {
8597 printf (" NORELOC");
8598 val ^= DF_1_NORELOC;
8599 }
8600 if (val & DF_1_SYMINTPOSE)
8601 {
8602 printf (" SYMINTPOSE");
8603 val ^= DF_1_SYMINTPOSE;
8604 }
8605 if (val & DF_1_GLOBAUDIT)
8606 {
8607 printf (" GLOBAUDIT");
8608 val ^= DF_1_GLOBAUDIT;
8609 }
8610 if (val & DF_1_SINGLETON)
8611 {
8612 printf (" SINGLETON");
8613 val ^= DF_1_SINGLETON;
dcefbbbd 8614 }
252b5132
RH		 8615 if (val != 0)
8616 printf (" %lx", val);
8617 puts ("");
8618 }
8619 }
8620 break;
8621
8622 case DT_PLTREL:
566b0d53 8623 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8624 if (do_dynamic)
8625 puts (get_dynamic_type (entry->d_un.d_val));
8626 break;
8627
8628 case DT_NULL :
8629 case DT_NEEDED :
8630 case DT_PLTGOT :
8631 case DT_HASH :
8632 case DT_STRTAB :
8633 case DT_SYMTAB :
8634 case DT_RELA :
8635 case DT_INIT :
8636 case DT_FINI :
8637 case DT_SONAME :
8638 case DT_RPATH :
8639 case DT_SYMBOLIC:
8640 case DT_REL :
8641 case DT_DEBUG :
8642 case DT_TEXTREL :
8643 case DT_JMPREL :
019148e4 8644 case DT_RUNPATH :
252b5132
RH		 8645 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8646
8647 if (do_dynamic)
8648 {
2cf0635d 8649 char * name;
252b5132 8650
d79b3d50
NC		 8651 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8652 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8653 else
d79b3d50 8654 name = NULL;
252b5132
RH		 8655
8656 if (name)
8657 {
8658 switch (entry->d_tag)
8659 {
8660 case DT_NEEDED:
8661 printf (_("Shared library: [%s]"), name);
8662
18bd398b 8663 if (streq (name, program_interpreter))
f7a99963 8664 printf (_(" program interpreter"));
252b5132
RH		 8665 break;
8666
8667 case DT_SONAME:
f7a99963 8668 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8669 break;
8670
8671 case DT_RPATH:
f7a99963 8672 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8673 break;
8674
019148e4
L		 8675 case DT_RUNPATH:
8676 printf (_("Library runpath: [%s]"), name);
8677 break;
8678
252b5132 8679 default:
f7a99963
NC		 8680 print_vma (entry->d_un.d_val, PREFIX_HEX);
8681 break;
252b5132
RH		 8682 }
8683 }
8684 else
f7a99963
NC		 8685 print_vma (entry->d_un.d_val, PREFIX_HEX);
8686
8687 putchar ('\n');
252b5132
RH		 8688 }
8689 break;
8690
8691 case DT_PLTRELSZ:
8692 case DT_RELASZ :
8693 case DT_STRSZ :
8694 case DT_RELSZ :
8695 case DT_RELAENT :
8696 case DT_SYMENT :
8697 case DT_RELENT :
566b0d53 8698 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8699 case DT_PLTPADSZ:
8700 case DT_MOVEENT :
8701 case DT_MOVESZ :
8702 case DT_INIT_ARRAYSZ:
8703 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8704 case DT_GNU_CONFLICTSZ:
8705 case DT_GNU_LIBLISTSZ:
252b5132 8706 if (do_dynamic)
f7a99963
NC		 8707 {
8708 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8709 printf (_(" (bytes)\n"));
f7a99963 8710 }
252b5132
RH		 8711 break;
8712
8713 case DT_VERDEFNUM:
8714 case DT_VERNEEDNUM:
8715 case DT_RELACOUNT:
8716 case DT_RELCOUNT:
8717 if (do_dynamic)
f7a99963
NC		 8718 {
8719 print_vma (entry->d_un.d_val, UNSIGNED);
8720 putchar ('\n');
8721 }
252b5132
RH		 8722 break;
8723
8724 case DT_SYMINSZ:
8725 case DT_SYMINENT:
8726 case DT_SYMINFO:
8727 case DT_USED:
8728 case DT_INIT_ARRAY:
8729 case DT_FINI_ARRAY:
8730 if (do_dynamic)
8731 {
d79b3d50
NC		 8732 if (entry->d_tag == DT_USED
8733 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8734 {
2cf0635d 8735 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8736
b34976b6 8737 if (*name)
252b5132
RH		 8738 {
8739 printf (_("Not needed object: [%s]\n"), name);
8740 break;
8741 }
8742 }
103f02d3 8743
f7a99963
NC		 8744 print_vma (entry->d_un.d_val, PREFIX_HEX);
8745 putchar ('\n');
252b5132
RH		 8746 }
8747 break;
8748
8749 case DT_BIND_NOW:
8750 /* The value of this entry is ignored. */
35b1837e
AM		 8751 if (do_dynamic)
8752 putchar ('\n');
252b5132 8753 break;
103f02d3 8754
047b2264
JJ		 8755 case DT_GNU_PRELINKED:
8756 if (do_dynamic)
8757 {
2cf0635d 8758 struct tm * tmp;
91d6fa6a 8759 time_t atime = entry->d_un.d_val;
047b2264 8760
91d6fa6a 8761 tmp = gmtime (&atime);
047b2264
JJ		 8762 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8763 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8764 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8765
8766 }
8767 break;
8768
fdc90cb4
JJ		 8769 case DT_GNU_HASH:
8770 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8771 if (do_dynamic)
8772 {
8773 print_vma (entry->d_un.d_val, PREFIX_HEX);
8774 putchar ('\n');
8775 }
8776 break;
8777
252b5132
RH		 8778 default:
8779 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8780 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8781 entry->d_un.d_val;
8782
8783 if (do_dynamic)
8784 {
8785 switch (elf_header.e_machine)
8786 {
8787 case EM_MIPS:
4fe85591 8788 case EM_MIPS_RS3_LE:
b2d38a17 8789 dynamic_section_mips_val (entry);
252b5132 8790 break;
103f02d3 8791 case EM_PARISC:
b2d38a17 8792 dynamic_section_parisc_val (entry);
103f02d3 8793 break;
ecc51f48 8794 case EM_IA_64:
b2d38a17 8795 dynamic_section_ia64_val (entry);
ecc51f48 8796 break;
252b5132 8797 default:
f7a99963
NC		 8798 print_vma (entry->d_un.d_val, PREFIX_HEX);
8799 putchar ('\n');
252b5132
RH		 8800 }
8801 }
8802 break;
8803 }
8804 }
8805
8806 return 1;
8807}
8808
8809static char *
d3ba0551 8810get_ver_flags (unsigned int flags)
252b5132 8811{
b34976b6 8812 static char buff[32];
252b5132
RH		 8813
8814 buff[0] = 0;
8815
8816 if (flags == 0)
8817 return _("none");
8818
8819 if (flags & VER_FLG_BASE)
8820 strcat (buff, "BASE ");
8821
8822 if (flags & VER_FLG_WEAK)
8823 {
8824 if (flags & VER_FLG_BASE)
8825 strcat (buff, "| ");
8826
8827 strcat (buff, "WEAK ");
8828 }
8829
44ec90b9
RO		 8830 if (flags & VER_FLG_INFO)
8831 {
8832 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8833 strcat (buff, "| ");
8834
8835 strcat (buff, "INFO ");
8836 }
8837
8838 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8839 strcat (buff, _("| <unknown>"));
252b5132
RH		 8840
8841 return buff;
8842}
8843
8844/* Display the contents of the version sections. */
98fb390a 8845
252b5132 8846static int
2cf0635d 8847process_version_sections (FILE * file)
252b5132 8848{
2cf0635d 8849 Elf_Internal_Shdr * section;
b34976b6
AM		 8850 unsigned i;
8851 int found = 0;
252b5132
RH		 8852
8853 if (! do_version)
8854 return 1;
8855
8856 for (i = 0, section = section_headers;
8857 i < elf_header.e_shnum;
b34976b6 8858 i++, section++)
252b5132
RH		 8859 {
8860 switch (section->sh_type)
8861 {
8862 case SHT_GNU_verdef:
8863 {
2cf0635d 8864 Elf_External_Verdef * edefs;
b34976b6
AM		 8865 unsigned int idx;
8866 unsigned int cnt;
2cf0635d 8867 char * endbuf;
252b5132
RH		 8868
8869 found = 1;
8870
8871 printf
72de5009 8872 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8873 SECTION_NAME (section), section->sh_info);
8874
8875 printf (_(" Addr: 0x"));
8876 printf_vma (section->sh_addr);
72de5009 8877 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8878 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8879 section->sh_link < elf_header.e_shnum
8880 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8881 : _("<corrupt>"));
252b5132 8882
3f5e193b
NC		 8883 edefs = (Elf_External_Verdef *)
8884 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8885 _("version definition section"));
a6e9f9df
AM		 8886 if (!edefs)
8887 break;
59245841 8888 endbuf = (char *) edefs + section->sh_size;
252b5132 8889
b34976b6 8890 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8891 {
2cf0635d
NC		 8892 char * vstart;
8893 Elf_External_Verdef * edef;
b34976b6 8894 Elf_Internal_Verdef ent;
2cf0635d 8895 Elf_External_Verdaux * eaux;
b34976b6
AM		 8896 Elf_Internal_Verdaux aux;
8897 int j;
8898 int isum;
103f02d3 8899
7e26601c
NC		 8900 /* Check for very large indicies. */
8901 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 8902 break;
8903
252b5132 8904 vstart = ((char *) edefs) + idx;
54806181
AM		 8905 if (vstart + sizeof (*edef) > endbuf)
8906 break;
252b5132
RH		 8907
8908 edef = (Elf_External_Verdef *) vstart;
8909
8910 ent.vd_version = BYTE_GET (edef->vd_version);
8911 ent.vd_flags = BYTE_GET (edef->vd_flags);
8912 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8913 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8914 ent.vd_hash = BYTE_GET (edef->vd_hash);
8915 ent.vd_aux = BYTE_GET (edef->vd_aux);
8916 ent.vd_next = BYTE_GET (edef->vd_next);
8917
8918 printf (_(" %#06x: Rev: %d Flags: %s"),
8919 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8920
8921 printf (_(" Index: %d Cnt: %d "),
8922 ent.vd_ndx, ent.vd_cnt);
8923
dd24e3da 8924 /* Check for overflow. */
7e26601c 8925 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8926 break;
8927
252b5132
RH		 8928 vstart += ent.vd_aux;
8929
8930 eaux = (Elf_External_Verdaux *) vstart;
8931
8932 aux.vda_name = BYTE_GET (eaux->vda_name);
8933 aux.vda_next = BYTE_GET (eaux->vda_next);
8934
d79b3d50
NC		 8935 if (VALID_DYNAMIC_NAME (aux.vda_name))
8936 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8937 else
8938 printf (_("Name index: %ld\n"), aux.vda_name);
8939
8940 isum = idx + ent.vd_aux;
8941
b34976b6 8942 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8943 {
dd24e3da 8944 /* Check for overflow. */
7e26601c 8945 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8946 break;
8947
252b5132
RH		 8948 isum += aux.vda_next;
8949 vstart += aux.vda_next;
8950
8951 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8952 if (vstart + sizeof (*eaux) > endbuf)
8953 break;
252b5132
RH		 8954
8955 aux.vda_name = BYTE_GET (eaux->vda_name);
8956 aux.vda_next = BYTE_GET (eaux->vda_next);
8957
d79b3d50 8958 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8959 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8960 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8961 else
8962 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8963 isum, j, aux.vda_name);
8964 }
dd24e3da 8965
54806181
AM		 8966 if (j < ent.vd_cnt)
8967 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8968
8969 idx += ent.vd_next;
8970 }
dd24e3da 8971
54806181
AM		 8972 if (cnt < section->sh_info)
8973 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8974
8975 free (edefs);
8976 }
8977 break;
103f02d3 8978
252b5132
RH		 8979 case SHT_GNU_verneed:
8980 {
2cf0635d 8981 Elf_External_Verneed * eneed;
b34976b6
AM		 8982 unsigned int idx;
8983 unsigned int cnt;
2cf0635d 8984 char * endbuf;
252b5132
RH		 8985
8986 found = 1;
8987
72de5009 8988 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8989 SECTION_NAME (section), section->sh_info);
8990
8991 printf (_(" Addr: 0x"));
8992 printf_vma (section->sh_addr);
72de5009 8993 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8994 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8995 section->sh_link < elf_header.e_shnum
8996 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8997 : _("<corrupt>"));
252b5132 8998
3f5e193b
NC		 8999 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9000 section->sh_offset, 1,
9001 section->sh_size,
9cf03b7e 9002 _("Version Needs section"));
a6e9f9df
AM		 9003 if (!eneed)
9004 break;
59245841 9005 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9006
9007 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9008 {
2cf0635d 9009 Elf_External_Verneed * entry;
b34976b6
AM		 9010 Elf_Internal_Verneed ent;
9011 int j;
9012 int isum;
2cf0635d 9013 char * vstart;
252b5132 9014
7e26601c 9015 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9016 break;
9017
252b5132 9018 vstart = ((char *) eneed) + idx;
54806181
AM		 9019 if (vstart + sizeof (*entry) > endbuf)
9020 break;
252b5132
RH		 9021
9022 entry = (Elf_External_Verneed *) vstart;
9023
9024 ent.vn_version = BYTE_GET (entry->vn_version);
9025 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9026 ent.vn_file = BYTE_GET (entry->vn_file);
9027 ent.vn_aux = BYTE_GET (entry->vn_aux);
9028 ent.vn_next = BYTE_GET (entry->vn_next);
9029
9030 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9031
d79b3d50
NC		 9032 if (VALID_DYNAMIC_NAME (ent.vn_file))
9033 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9034 else
9035 printf (_(" File: %lx"), ent.vn_file);
9036
9037 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9038
dd24e3da 9039 /* Check for overflow. */
7e26601c 9040 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9041 break;
9042
252b5132
RH		 9043 vstart += ent.vn_aux;
9044
9045 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9046 {
2cf0635d 9047 Elf_External_Vernaux * eaux;
b34976b6 9048 Elf_Internal_Vernaux aux;
252b5132 9049
54806181
AM		 9050 if (vstart + sizeof (*eaux) > endbuf)
9051 break;
252b5132
RH		 9052 eaux = (Elf_External_Vernaux *) vstart;
9053
9054 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9055 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9056 aux.vna_other = BYTE_GET (eaux->vna_other);
9057 aux.vna_name = BYTE_GET (eaux->vna_name);
9058 aux.vna_next = BYTE_GET (eaux->vna_next);
9059
d79b3d50 9060 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9061 printf (_(" %#06x: Name: %s"),
d79b3d50 9062 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9063 else
ecc2063b 9064 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9065 isum, aux.vna_name);
9066
9067 printf (_(" Flags: %s Version: %d\n"),
9068 get_ver_flags (aux.vna_flags), aux.vna_other);
9069
dd24e3da 9070 /* Check for overflow. */
7e26601c 9071 if (aux.vna_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9072 break;
9073
252b5132
RH		 9074 isum += aux.vna_next;
9075 vstart += aux.vna_next;
9076 }
9cf03b7e 9077
54806181 9078 if (j < ent.vn_cnt)
9cf03b7e 9079 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9080
bcf83b2a 9081 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9082 {
9083 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9084 cnt = section->sh_info;
9085 break;
9086 }
252b5132
RH		 9087 idx += ent.vn_next;
9088 }
9cf03b7e 9089
54806181 9090 if (cnt < section->sh_info)
9cf03b7e 9091 warn (_("Missing Version Needs information\n"));
103f02d3 9092
252b5132
RH		 9093 free (eneed);
9094 }
9095 break;
9096
9097 case SHT_GNU_versym:
9098 {
2cf0635d 9099 Elf_Internal_Shdr * link_section;
b34976b6
AM		 9100 int total;
9101 int cnt;
2cf0635d
NC		 9102 unsigned char * edata;
9103 unsigned short * data;
9104 char * strtab;
9105 Elf_Internal_Sym * symbols;
9106 Elf_Internal_Shdr * string_sec;
ba5cdace 9107 unsigned long num_syms;
d3ba0551 9108 long off;
252b5132 9109
4fbb74a6 9110 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9111 break;
9112
4fbb74a6 9113 link_section = section_headers + section->sh_link;
08d8fa11 9114 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9115
4fbb74a6 9116 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9117 break;
9118
252b5132
RH		 9119 found = 1;
9120
ba5cdace 9121 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9122 if (symbols == NULL)
9123 break;
252b5132 9124
4fbb74a6 9125 string_sec = section_headers + link_section->sh_link;
252b5132 9126
3f5e193b
NC		 9127 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9128 string_sec->sh_size,
9129 _("version string table"));
a6e9f9df 9130 if (!strtab)
0429c154
MS		 9131 {
9132 free (symbols);
9133 break;
9134 }
252b5132
RH		 9135
9136 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9137 SECTION_NAME (section), total);
9138
9139 printf (_(" Addr: "));
9140 printf_vma (section->sh_addr);
72de5009 9141 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9142 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 9143 SECTION_NAME (link_section));
9144
d3ba0551
AM		 9145 off = offset_from_vma (file,
9146 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9147 total * sizeof (short));
3f5e193b
NC		 9148 edata = (unsigned char *) get_data (NULL, file, off, total,
9149 sizeof (short),
9150 _("version symbol data"));
a6e9f9df
AM		 9151 if (!edata)
9152 {
9153 free (strtab);
0429c154 9154 free (symbols);
a6e9f9df
AM		 9155 break;
9156 }
252b5132 9157
3f5e193b 9158 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9159
9160 for (cnt = total; cnt --;)
b34976b6
AM		 9161 data[cnt] = byte_get (edata + cnt * sizeof (short),
9162 sizeof (short));
252b5132
RH		 9163
9164 free (edata);
9165
9166 for (cnt = 0; cnt < total; cnt += 4)
9167 {
9168 int j, nn;
00d93f34 9169 int check_def, check_need;
2cf0635d 9170 char * name;
252b5132
RH		 9171
9172 printf (" %03x:", cnt);
9173
9174 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9175 switch (data[cnt + j])
252b5132
RH		 9176 {
9177 case 0:
9178 fputs (_(" 0 (*local*) "), stdout);
9179 break;
9180
9181 case 1:
9182 fputs (_(" 1 (*global*) "), stdout);
9183 break;
9184
9185 default:
c244d050
NC		 9186 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9187 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9188
dd24e3da 9189 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9190 array, break to avoid an out-of-bounds read. */
9191 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9192 {
9193 warn (_("invalid index into symbol array\n"));
9194 break;
9195 }
9196
00d93f34
JJ		 9197 check_def = 1;
9198 check_need = 1;
4fbb74a6
AM		 9199 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9200 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9201 != SHT_NOBITS)
252b5132 9202 {
b34976b6 9203 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9204 check_def = 0;
9205 else
9206 check_need = 0;
252b5132 9207 }
00d93f34
JJ		 9208
9209 if (check_need
b34976b6 9210 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9211 {
b34976b6
AM		 9212 Elf_Internal_Verneed ivn;
9213 unsigned long offset;
252b5132 9214
d93f0186
NC		 9215 offset = offset_from_vma
9216 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9217 sizeof (Elf_External_Verneed));
252b5132 9218
b34976b6 9219 do
252b5132 9220 {
b34976b6
AM		 9221 Elf_Internal_Vernaux ivna;
9222 Elf_External_Verneed evn;
9223 Elf_External_Vernaux evna;
9224 unsigned long a_off;
252b5132 9225
59245841
NC		 9226 if (get_data (&evn, file, offset, sizeof (evn), 1,
9227 _("version need")) == NULL)
9228 break;
0b4362b0 9229
252b5132
RH		 9230 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9231 ivn.vn_next = BYTE_GET (evn.vn_next);
9232
9233 a_off = offset + ivn.vn_aux;
9234
9235 do
9236 {
59245841
NC		 9237 if (get_data (&evna, file, a_off, sizeof (evna),
9238 1, _("version need aux (2)")) == NULL)
9239 {
9240 ivna.vna_next = 0;
9241 ivna.vna_other = 0;
9242 }
9243 else
9244 {
9245 ivna.vna_next = BYTE_GET (evna.vna_next);
9246 ivna.vna_other = BYTE_GET (evna.vna_other);
9247 }
252b5132
RH		 9248
9249 a_off += ivna.vna_next;
9250 }
b34976b6 9251 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9252 && ivna.vna_next != 0);
9253
b34976b6 9254 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9255 {
9256 ivna.vna_name = BYTE_GET (evna.vna_name);
9257
54806181
AM		 9258 if (ivna.vna_name >= string_sec->sh_size)
9259 name = _("*invalid*");
9260 else
9261 name = strtab + ivna.vna_name;
252b5132 9262 nn += printf ("(%s%-*s",
16062207
ILT		 9263 name,
9264 12 - (int) strlen (name),
252b5132 9265 ")");
00d93f34 9266 check_def = 0;
252b5132
RH		 9267 break;
9268 }
9269
9270 offset += ivn.vn_next;
9271 }
9272 while (ivn.vn_next);
9273 }
00d93f34 9274
b34976b6
AM		 9275 if (check_def && data[cnt + j] != 0x8001
9276 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9277 {
b34976b6
AM		 9278 Elf_Internal_Verdef ivd;
9279 Elf_External_Verdef evd;
9280 unsigned long offset;
252b5132 9281
d93f0186
NC		 9282 offset = offset_from_vma
9283 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9284 sizeof evd);
252b5132
RH		 9285
9286 do
9287 {
59245841
NC		 9288 if (get_data (&evd, file, offset, sizeof (evd), 1,
9289 _("version def")) == NULL)
9290 {
9291 ivd.vd_next = 0;
9292 ivd.vd_ndx = 0;
9293 }
9294 else
9295 {
9296 ivd.vd_next = BYTE_GET (evd.vd_next);
9297 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9298 }
252b5132
RH		 9299
9300 offset += ivd.vd_next;
9301 }
c244d050 9302 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9303 && ivd.vd_next != 0);
9304
c244d050 9305 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9306 {
b34976b6
AM		 9307 Elf_External_Verdaux evda;
9308 Elf_Internal_Verdaux ivda;
252b5132
RH		 9309
9310 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9311
59245841
NC		 9312 if (get_data (&evda, file,
9313 offset - ivd.vd_next + ivd.vd_aux,
9314 sizeof (evda), 1,
9315 _("version def aux")) == NULL)
9316 break;
252b5132
RH		 9317
9318 ivda.vda_name = BYTE_GET (evda.vda_name);
9319
54806181
AM		 9320 if (ivda.vda_name >= string_sec->sh_size)
9321 name = _("*invalid*");
9322 else
9323 name = strtab + ivda.vda_name;
252b5132 9324 nn += printf ("(%s%-*s",
16062207
ILT		 9325 name,
9326 12 - (int) strlen (name),
252b5132
RH		 9327 ")");
9328 }
9329 }
9330
9331 if (nn < 18)
9332 printf ("%*c", 18 - nn, ' ');
9333 }
9334
9335 putchar ('\n');
9336 }
9337
9338 free (data);
9339 free (strtab);
9340 free (symbols);
9341 }
9342 break;
103f02d3 9343
252b5132
RH		 9344 default:
9345 break;
9346 }
9347 }
9348
9349 if (! found)
9350 printf (_("\nNo version information found in this file.\n"));
9351
9352 return 1;
9353}
9354
d1133906 9355static const char *
d3ba0551 9356get_symbol_binding (unsigned int binding)
252b5132 9357{
b34976b6 9358 static char buff[32];
252b5132
RH		 9359
9360 switch (binding)
9361 {
b34976b6
AM		 9362 case STB_LOCAL: return "LOCAL";
9363 case STB_GLOBAL: return "GLOBAL";
9364 case STB_WEAK: return "WEAK";
252b5132
RH		 9365 default:
9366 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9367 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9368 binding);
252b5132 9369 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9370 {
9371 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9372 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9373 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9374 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9375 return "UNIQUE";
9376 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9377 }
252b5132 9378 else
e9e44622 9379 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9380 return buff;
9381 }
9382}
9383
d1133906 9384static const char *
d3ba0551 9385get_symbol_type (unsigned int type)
252b5132 9386{
b34976b6 9387 static char buff[32];
252b5132
RH		 9388
9389 switch (type)
9390 {
b34976b6
AM		 9391 case STT_NOTYPE: return "NOTYPE";
9392 case STT_OBJECT: return "OBJECT";
9393 case STT_FUNC: return "FUNC";
9394 case STT_SECTION: return "SECTION";
9395 case STT_FILE: return "FILE";
9396 case STT_COMMON: return "COMMON";
9397 case STT_TLS: return "TLS";
15ab5209
DB		 9398 case STT_RELC: return "RELC";
9399 case STT_SRELC: return "SRELC";
252b5132
RH		 9400 default:
9401 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9402 {
3510a7b8
NC		 9403 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9404 return "THUMB_FUNC";
103f02d3 9405
351b4b40 9406 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9407 return "REGISTER";
9408
9409 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9410 return "PARISC_MILLI";
9411
e9e44622 9412 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9413 }
252b5132 9414 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9415 {
9416 if (elf_header.e_machine == EM_PARISC)
9417 {
9418 if (type == STT_HP_OPAQUE)
9419 return "HP_OPAQUE";
9420 if (type == STT_HP_STUB)
9421 return "HP_STUB";
9422 }
9423
d8045f23 9424 if (type == STT_GNU_IFUNC
9c55345c 9425 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9426 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9427 /* GNU is still using the default value 0. */
d8045f23
NC		 9428 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9429 return "IFUNC";
9430
e9e44622 9431 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9432 }
252b5132 9433 else
e9e44622 9434 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9435 return buff;
9436 }
9437}
9438
d1133906 9439static const char *
d3ba0551 9440get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9441{
9442 switch (visibility)
9443 {
b34976b6
AM		 9444 case STV_DEFAULT: return "DEFAULT";
9445 case STV_INTERNAL: return "INTERNAL";
9446 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9447 case STV_PROTECTED: return "PROTECTED";
9448 default: abort ();
9449 }
9450}
9451
5e2b0d47
NC		 9452static const char *
9453get_mips_symbol_other (unsigned int other)
9454{
9455 switch (other)
9456 {
df58fc94
RS		 9457 case STO_OPTIONAL:
9458 return "OPTIONAL";
9459 case STO_MIPS_PLT:
9460 return "MIPS PLT";
9461 case STO_MIPS_PIC:
9462 return "MIPS PIC";
9463 case STO_MICROMIPS:
9464 return "MICROMIPS";
9465 case STO_MICROMIPS | STO_MIPS_PIC:
9466 return "MICROMIPS, MIPS PIC";
9467 case STO_MIPS16:
9468 return "MIPS16";
9469 default:
9470 return NULL;
5e2b0d47
NC		 9471 }
9472}
9473
28f997cf
TG		 9474static const char *
9475get_ia64_symbol_other (unsigned int other)
9476{
9477 if (is_ia64_vms ())
9478 {
9479 static char res[32];
9480
9481 res[0] = 0;
9482
9483 /* Function types is for images and .STB files only. */
9484 switch (elf_header.e_type)
9485 {
9486 case ET_DYN:
9487 case ET_EXEC:
9488 switch (VMS_ST_FUNC_TYPE (other))
9489 {
9490 case VMS_SFT_CODE_ADDR:
9491 strcat (res, " CA");
9492 break;
9493 case VMS_SFT_SYMV_IDX:
9494 strcat (res, " VEC");
9495 break;
9496 case VMS_SFT_FD:
9497 strcat (res, " FD");
9498 break;
9499 case VMS_SFT_RESERVE:
9500 strcat (res, " RSV");
9501 break;
9502 default:
9503 abort ();
9504 }
9505 break;
9506 default:
9507 break;
9508 }
9509 switch (VMS_ST_LINKAGE (other))
9510 {
9511 case VMS_STL_IGNORE:
9512 strcat (res, " IGN");
9513 break;
9514 case VMS_STL_RESERVE:
9515 strcat (res, " RSV");
9516 break;
9517 case VMS_STL_STD:
9518 strcat (res, " STD");
9519 break;
9520 case VMS_STL_LNK:
9521 strcat (res, " LNK");
9522 break;
9523 default:
9524 abort ();
9525 }
9526
9527 if (res[0] != 0)
9528 return res + 1;
9529 else
9530 return res;
9531 }
9532 return NULL;
9533}
9534
6911b7dc
AM		 9535static const char *
9536get_ppc64_symbol_other (unsigned int other)
9537{
9538 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9539 {
9540 static char buf[32];
9541 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9542 PPC64_LOCAL_ENTRY_OFFSET (other));
9543 return buf;
9544 }
9545 return NULL;
9546}
9547
5e2b0d47
NC		 9548static const char *
9549get_symbol_other (unsigned int other)
9550{
9551 const char * result = NULL;
9552 static char buff [32];
9553
9554 if (other == 0)
9555 return "";
9556
9557 switch (elf_header.e_machine)
9558 {
9559 case EM_MIPS:
9560 result = get_mips_symbol_other (other);
28f997cf
TG		 9561 break;
9562 case EM_IA_64:
9563 result = get_ia64_symbol_other (other);
9564 break;
6911b7dc
AM		 9565 case EM_PPC64:
9566 result = get_ppc64_symbol_other (other);
9567 break;
5e2b0d47
NC		 9568 default:
9569 break;
9570 }
9571
9572 if (result)
9573 return result;
9574
9575 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9576 return buff;
9577}
9578
d1133906 9579static const char *
d3ba0551 9580get_symbol_index_type (unsigned int type)
252b5132 9581{
b34976b6 9582 static char buff[32];
5cf1065c 9583
252b5132
RH		 9584 switch (type)
9585 {
b34976b6
AM		 9586 case SHN_UNDEF: return "UND";
9587 case SHN_ABS: return "ABS";
9588 case SHN_COMMON: return "COM";
252b5132 9589 default:
9ce701e2
L		 9590 if (type == SHN_IA_64_ANSI_COMMON
9591 && elf_header.e_machine == EM_IA_64
9592 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9593 return "ANSI_COM";
8a9036a4 9594 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9595 || elf_header.e_machine == EM_L1OM
9596 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9597 && type == SHN_X86_64_LCOMMON)
9598 return "LARGE_COM";
ac145307
BS		 9599 else if ((type == SHN_MIPS_SCOMMON
9600 && elf_header.e_machine == EM_MIPS)
9601 || (type == SHN_TIC6X_SCOMMON
9602 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9603 return "SCOM";
9604 else if (type == SHN_MIPS_SUNDEFINED
9605 && elf_header.e_machine == EM_MIPS)
9606 return "SUND";
9ce701e2 9607 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9608 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9609 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9610 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9611 else if (type >= SHN_LORESERVE)
9612 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 9613 else if (type >= elf_header.e_shnum)
e0a31db1 9614 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 9615 else
232e7cb8 9616 sprintf (buff, "%3d", type);
5cf1065c 9617 break;
252b5132 9618 }
5cf1065c
NC		 9619
9620 return buff;
252b5132
RH		 9621}
9622
66543521 9623static bfd_vma *
2cf0635d 9624get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9625{
2cf0635d
NC		 9626 unsigned char * e_data;
9627 bfd_vma * i_data;
252b5132 9628
3f5e193b 9629 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9630
9631 if (e_data == NULL)
9632 {
9633 error (_("Out of memory\n"));
9634 return NULL;
9635 }
9636
66543521 9637 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9638 {
9639 error (_("Unable to read in dynamic data\n"));
9640 return NULL;
9641 }
9642
3f5e193b 9643 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9644
9645 if (i_data == NULL)
9646 {
9647 error (_("Out of memory\n"));
9648 free (e_data);
9649 return NULL;
9650 }
9651
9652 while (number--)
66543521 9653 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9654
9655 free (e_data);
9656
9657 return i_data;
9658}
9659
6bd1a22c
L		 9660static void
9661print_dynamic_symbol (bfd_vma si, unsigned long hn)
9662{
2cf0635d 9663 Elf_Internal_Sym * psym;
6bd1a22c
L		 9664 int n;
9665
6bd1a22c
L		 9666 n = print_vma (si, DEC_5);
9667 if (n < 5)
0b4362b0 9668 fputs (&" "[n], stdout);
6bd1a22c 9669 printf (" %3lu: ", hn);
e0a31db1
NC		 9670
9671 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
9672 {
9673 printf (_("<No info available>\n"));
9674 return;
9675 }
9676
9677 psym = dynamic_symbols + si;
6bd1a22c
L		 9678 print_vma (psym->st_value, LONG_HEX);
9679 putchar (' ');
9680 print_vma (psym->st_size, DEC_5);
9681
f4be36b3
AM		 9682 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9683 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9684 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9685 /* Check to see if any other bits in the st_other field are set.
9686 Note - displaying this information disrupts the layout of the
9687 table being generated, but for the moment this case is very
9688 rare. */
9689 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9690 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9691 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9692 if (VALID_DYNAMIC_NAME (psym->st_name))
9693 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9694 else
2b692964 9695 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9696 putchar ('\n');
9697}
9698
e3c8793a 9699/* Dump the symbol table. */
252b5132 9700static int
2cf0635d 9701process_symbol_table (FILE * file)
252b5132 9702{
2cf0635d 9703 Elf_Internal_Shdr * section;
66543521
AM		 9704 bfd_vma nbuckets = 0;
9705 bfd_vma nchains = 0;
2cf0635d
NC		 9706 bfd_vma * buckets = NULL;
9707 bfd_vma * chains = NULL;
fdc90cb4 9708 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9709 bfd_vma * gnubuckets = NULL;
9710 bfd_vma * gnuchains = NULL;
6bd1a22c 9711 bfd_vma gnusymidx = 0;
252b5132 9712
2c610e4b 9713 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9714 return 1;
9715
6bd1a22c
L		 9716 if (dynamic_info[DT_HASH]
9717 && (do_histogram
2c610e4b
L		 9718 || (do_using_dynamic
9719 && !do_dyn_syms
9720 && dynamic_strings != NULL)))
252b5132 9721 {
66543521
AM		 9722 unsigned char nb[8];
9723 unsigned char nc[8];
9724 int hash_ent_size = 4;
9725
9726 if ((elf_header.e_machine == EM_ALPHA
9727 || elf_header.e_machine == EM_S390
9728 || elf_header.e_machine == EM_S390_OLD)
9729 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9730 hash_ent_size = 8;
9731
fb52b2f4
NC		 9732 if (fseek (file,
9733 (archive_file_offset
9734 + offset_from_vma (file, dynamic_info[DT_HASH],
9735 sizeof nb + sizeof nc)),
d93f0186 9736 SEEK_SET))
252b5132 9737 {
591a748a 9738 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9739 goto no_hash;
252b5132
RH		 9740 }
9741
66543521 9742 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9743 {
9744 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9745 goto no_hash;
252b5132
RH		 9746 }
9747
66543521 9748 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9749 {
9750 error (_("Failed to read in number of chains\n"));
d3a44ec6 9751 goto no_hash;
252b5132
RH		 9752 }
9753
66543521
AM		 9754 nbuckets = byte_get (nb, hash_ent_size);
9755 nchains = byte_get (nc, hash_ent_size);
252b5132 9756
66543521
AM		 9757 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9758 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9759
d3a44ec6 9760 no_hash:
252b5132 9761 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9762 {
9763 if (do_using_dynamic)
9764 return 0;
9765 free (buckets);
9766 free (chains);
9767 buckets = NULL;
9768 chains = NULL;
9769 nbuckets = 0;
9770 nchains = 0;
9771 }
252b5132
RH		 9772 }
9773
6bd1a22c
L		 9774 if (dynamic_info_DT_GNU_HASH
9775 && (do_histogram
2c610e4b
L		 9776 || (do_using_dynamic
9777 && !do_dyn_syms
9778 && dynamic_strings != NULL)))
252b5132 9779 {
6bd1a22c
L		 9780 unsigned char nb[16];
9781 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9782 bfd_vma buckets_vma;
9783
9784 if (fseek (file,
9785 (archive_file_offset
9786 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9787 sizeof nb)),
9788 SEEK_SET))
9789 {
9790 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9791 goto no_gnu_hash;
6bd1a22c 9792 }
252b5132 9793
6bd1a22c
L		 9794 if (fread (nb, 16, 1, file) != 1)
9795 {
9796 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9797 goto no_gnu_hash;
6bd1a22c
L		 9798 }
9799
9800 ngnubuckets = byte_get (nb, 4);
9801 gnusymidx = byte_get (nb + 4, 4);
9802 bitmaskwords = byte_get (nb + 8, 4);
9803 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9804 if (is_32bit_elf)
6bd1a22c 9805 buckets_vma += bitmaskwords * 4;
f7a99963 9806 else
6bd1a22c 9807 buckets_vma += bitmaskwords * 8;
252b5132 9808
6bd1a22c
L		 9809 if (fseek (file,
9810 (archive_file_offset
9811 + offset_from_vma (file, buckets_vma, 4)),
9812 SEEK_SET))
252b5132 9813 {
6bd1a22c 9814 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9815 goto no_gnu_hash;
6bd1a22c
L		 9816 }
9817
9818 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9819
6bd1a22c 9820 if (gnubuckets == NULL)
d3a44ec6 9821 goto no_gnu_hash;
6bd1a22c
L		 9822
9823 for (i = 0; i < ngnubuckets; i++)
9824 if (gnubuckets[i] != 0)
9825 {
9826 if (gnubuckets[i] < gnusymidx)
9827 return 0;
9828
9829 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9830 maxchain = gnubuckets[i];
9831 }
9832
9833 if (maxchain == 0xffffffff)
d3a44ec6 9834 goto no_gnu_hash;
6bd1a22c
L		 9835
9836 maxchain -= gnusymidx;
9837
9838 if (fseek (file,
9839 (archive_file_offset
9840 + offset_from_vma (file, buckets_vma
9841 + 4 * (ngnubuckets + maxchain), 4)),
9842 SEEK_SET))
9843 {
9844 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9845 goto no_gnu_hash;
6bd1a22c
L		 9846 }
9847
9848 do
9849 {
9850 if (fread (nb, 4, 1, file) != 1)
252b5132 9851 {
6bd1a22c 9852 error (_("Failed to determine last chain length\n"));
d3a44ec6 9853 goto no_gnu_hash;
6bd1a22c 9854 }
252b5132 9855
6bd1a22c 9856 if (maxchain + 1 == 0)
d3a44ec6 9857 goto no_gnu_hash;
252b5132 9858
6bd1a22c
L		 9859 ++maxchain;
9860 }
9861 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9862
6bd1a22c
L		 9863 if (fseek (file,
9864 (archive_file_offset
9865 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9866 SEEK_SET))
9867 {
9868 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9869 goto no_gnu_hash;
6bd1a22c
L		 9870 }
9871
9872 gnuchains = get_dynamic_data (file, maxchain, 4);
9873
d3a44ec6 9874 no_gnu_hash:
6bd1a22c 9875 if (gnuchains == NULL)
d3a44ec6
JJ		 9876 {
9877 free (gnubuckets);
d3a44ec6
JJ		 9878 gnubuckets = NULL;
9879 ngnubuckets = 0;
f64fddf1
NC		 9880 if (do_using_dynamic)
9881 return 0;
d3a44ec6 9882 }
6bd1a22c
L		 9883 }
9884
9885 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9886 && do_syms
9887 && do_using_dynamic
9888 && dynamic_strings != NULL)
9889 {
9890 unsigned long hn;
9891
9892 if (dynamic_info[DT_HASH])
9893 {
9894 bfd_vma si;
9895
9896 printf (_("\nSymbol table for image:\n"));
9897 if (is_32bit_elf)
9898 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9899 else
9900 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9901
9902 for (hn = 0; hn < nbuckets; hn++)
9903 {
9904 if (! buckets[hn])
9905 continue;
9906
9907 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9908 print_dynamic_symbol (si, hn);
252b5132
RH		 9909 }
9910 }
6bd1a22c
L		 9911
9912 if (dynamic_info_DT_GNU_HASH)
9913 {
9914 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9915 if (is_32bit_elf)
9916 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9917 else
9918 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9919
9920 for (hn = 0; hn < ngnubuckets; ++hn)
9921 if (gnubuckets[hn] != 0)
9922 {
9923 bfd_vma si = gnubuckets[hn];
9924 bfd_vma off = si - gnusymidx;
9925
9926 do
9927 {
9928 print_dynamic_symbol (si, hn);
9929 si++;
9930 }
9931 while ((gnuchains[off++] & 1) == 0);
9932 }
9933 }
252b5132 9934 }
2c610e4b 9935 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9936 {
b34976b6 9937 unsigned int i;
252b5132
RH		 9938
9939 for (i = 0, section = section_headers;
9940 i < elf_header.e_shnum;
9941 i++, section++)
9942 {
b34976b6 9943 unsigned int si;
2cf0635d 9944 char * strtab = NULL;
c256ffe7 9945 unsigned long int strtab_size = 0;
2cf0635d
NC		 9946 Elf_Internal_Sym * symtab;
9947 Elf_Internal_Sym * psym;
ba5cdace 9948 unsigned long num_syms;
252b5132 9949
2c610e4b
L		 9950 if ((section->sh_type != SHT_SYMTAB
9951 && section->sh_type != SHT_DYNSYM)
9952 || (!do_syms
9953 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9954 continue;
9955
dd24e3da
NC		 9956 if (section->sh_entsize == 0)
9957 {
9958 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9959 SECTION_NAME (section));
9960 continue;
9961 }
9962
252b5132
RH		 9963 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9964 SECTION_NAME (section),
9965 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9966
f7a99963 9967 if (is_32bit_elf)
ca47b30c 9968 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9969 else
ca47b30c 9970 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9971
ba5cdace 9972 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9973 if (symtab == NULL)
9974 continue;
9975
9976 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9977 {
9978 strtab = string_table;
9979 strtab_size = string_table_length;
9980 }
4fbb74a6 9981 else if (section->sh_link < elf_header.e_shnum)
252b5132 9982 {
2cf0635d 9983 Elf_Internal_Shdr * string_sec;
252b5132 9984
4fbb74a6 9985 string_sec = section_headers + section->sh_link;
252b5132 9986
3f5e193b
NC		 9987 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9988 1, string_sec->sh_size,
9989 _("string table"));
c256ffe7 9990 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9991 }
9992
ba5cdace 9993 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9994 {
5e220199 9995 printf ("%6d: ", si);
f7a99963
NC		 9996 print_vma (psym->st_value, LONG_HEX);
9997 putchar (' ');
9998 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9999 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10000 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10001 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10002 /* Check to see if any other bits in the st_other field are set.
10003 Note - displaying this information disrupts the layout of the
10004 table being generated, but for the moment this case is very rare. */
10005 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10006 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10007 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10008 print_symbol (25, psym->st_name < strtab_size
2b692964 10009 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10010
59245841
NC		 10011 if (section->sh_type == SHT_DYNSYM
10012 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 10013 {
b34976b6
AM		 10014 unsigned char data[2];
10015 unsigned short vers_data;
10016 unsigned long offset;
10017 int is_nobits;
10018 int check_def;
252b5132 10019
d93f0186
NC		 10020 offset = offset_from_vma
10021 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10022 sizeof data + si * sizeof (vers_data));
252b5132 10023
59245841
NC		 10024 if (get_data (&data, file, offset + si * sizeof (vers_data),
10025 sizeof (data), 1, _("version data")) == NULL)
10026 break;
252b5132
RH		 10027
10028 vers_data = byte_get (data, 2);
10029
4fbb74a6
AM		 10030 is_nobits = (psym->st_shndx < elf_header.e_shnum
10031 && section_headers[psym->st_shndx].sh_type
c256ffe7 10032 == SHT_NOBITS);
252b5132
RH		 10033
10034 check_def = (psym->st_shndx != SHN_UNDEF);
10035
c244d050 10036 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 10037 {
b34976b6 10038 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 10039 && (is_nobits || ! check_def))
252b5132 10040 {
b34976b6
AM		 10041 Elf_External_Verneed evn;
10042 Elf_Internal_Verneed ivn;
10043 Elf_Internal_Vernaux ivna;
252b5132
RH		 10044
10045 /* We must test both. */
d93f0186
NC		 10046 offset = offset_from_vma
10047 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10048 sizeof evn);
252b5132 10049
252b5132
RH		 10050 do
10051 {
b34976b6 10052 unsigned long vna_off;
252b5132 10053
59245841
NC		 10054 if (get_data (&evn, file, offset, sizeof (evn), 1,
10055 _("version need")) == NULL)
10056 {
10057 ivna.vna_next = 0;
10058 ivna.vna_other = 0;
10059 ivna.vna_name = 0;
10060 break;
10061 }
dd27201e
L		 10062
10063 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10064 ivn.vn_next = BYTE_GET (evn.vn_next);
10065
252b5132
RH		 10066 vna_off = offset + ivn.vn_aux;
10067
10068 do
10069 {
b34976b6 10070 Elf_External_Vernaux evna;
252b5132 10071
59245841
NC		 10072 if (get_data (&evna, file, vna_off,
10073 sizeof (evna), 1,
10074 _("version need aux (3)")) == NULL)
10075 {
10076 ivna.vna_next = 0;
10077 ivna.vna_other = 0;
10078 ivna.vna_name = 0;
10079 }
10080 else
10081 {
10082 ivna.vna_other = BYTE_GET (evna.vna_other);
10083 ivna.vna_next = BYTE_GET (evna.vna_next);
10084 ivna.vna_name = BYTE_GET (evna.vna_name);
10085 }
252b5132
RH		 10086
10087 vna_off += ivna.vna_next;
10088 }
10089 while (ivna.vna_other != vers_data
10090 && ivna.vna_next != 0);
10091
10092 if (ivna.vna_other == vers_data)
10093 break;
10094
10095 offset += ivn.vn_next;
10096 }
10097 while (ivn.vn_next != 0);
10098
10099 if (ivna.vna_other == vers_data)
10100 {
10101 printf ("@%s (%d)",
c256ffe7 10102 ivna.vna_name < strtab_size
2b692964 10103 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 10104 ivna.vna_other);
252b5132
RH		 10105 check_def = 0;
10106 }
10107 else if (! is_nobits)
591a748a 10108 error (_("bad dynamic symbol\n"));
252b5132
RH		 10109 else
10110 check_def = 1;
10111 }
10112
10113 if (check_def)
10114 {
00d93f34 10115 if (vers_data != 0x8001
b34976b6 10116 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10117 {
b34976b6
AM		 10118 Elf_Internal_Verdef ivd;
10119 Elf_Internal_Verdaux ivda;
10120 Elf_External_Verdaux evda;
91d6fa6a 10121 unsigned long off;
252b5132 10122
91d6fa6a 10123 off = offset_from_vma
d93f0186
NC		 10124 (file,
10125 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10126 sizeof (Elf_External_Verdef));
252b5132
RH		 10127
10128 do
10129 {
b34976b6 10130 Elf_External_Verdef evd;
252b5132 10131
59245841
NC		 10132 if (get_data (&evd, file, off, sizeof (evd),
10133 1, _("version def")) == NULL)
10134 {
10135 ivd.vd_ndx = 0;
10136 ivd.vd_aux = 0;
10137 ivd.vd_next = 0;
10138 }
10139 else
10140 {
10141 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10142 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10143 ivd.vd_next = BYTE_GET (evd.vd_next);
10144 }
252b5132 10145
91d6fa6a 10146 off += ivd.vd_next;
252b5132 10147 }
c244d050 10148 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 10149 && ivd.vd_next != 0);
10150
91d6fa6a
NC		 10151 off -= ivd.vd_next;
10152 off += ivd.vd_aux;
252b5132 10153
59245841
NC		 10154 if (get_data (&evda, file, off, sizeof (evda),
10155 1, _("version def aux")) == NULL)
10156 break;
252b5132
RH		 10157
10158 ivda.vda_name = BYTE_GET (evda.vda_name);
10159
10160 if (psym->st_name != ivda.vda_name)
c244d050 10161 printf ((vers_data & VERSYM_HIDDEN)
252b5132 10162 ? "@%s" : "@@%s",
c256ffe7 10163 ivda.vda_name < strtab_size
2b692964 10164 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 10165 }
10166 }
10167 }
10168 }
10169
10170 putchar ('\n');
10171 }
10172
10173 free (symtab);
10174 if (strtab != string_table)
10175 free (strtab);
10176 }
10177 }
10178 else if (do_syms)
10179 printf
10180 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10181
10182 if (do_histogram && buckets != NULL)
10183 {
2cf0635d
NC		 10184 unsigned long * lengths;
10185 unsigned long * counts;
66543521
AM		 10186 unsigned long hn;
10187 bfd_vma si;
10188 unsigned long maxlength = 0;
10189 unsigned long nzero_counts = 0;
10190 unsigned long nsyms = 0;
252b5132 10191
66543521
AM		 10192 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10193 (unsigned long) nbuckets);
252b5132
RH		 10194 printf (_(" Length Number %% of total Coverage\n"));
10195
3f5e193b 10196 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10197 if (lengths == NULL)
10198 {
591a748a 10199 error (_("Out of memory\n"));
252b5132
RH		 10200 return 0;
10201 }
10202 for (hn = 0; hn < nbuckets; ++hn)
10203 {
f7a99963 10204 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 10205 {
b34976b6 10206 ++nsyms;
252b5132 10207 if (maxlength < ++lengths[hn])
b34976b6 10208 ++maxlength;
049b0c3a
NC		 10209
10210 /* PR binutils/17531: A corrupt binary could contain broken
10211 histogram data. Do not go into an infinite loop trying
10212 to process it. */
10213 if (chains[si] == si)
10214 {
10215 error (_("histogram chain links to itself\n"));
10216 break;
10217 }
252b5132
RH		 10218 }
10219 }
10220
3f5e193b 10221 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10222 if (counts == NULL)
10223 {
b2e951ec 10224 free (lengths);
591a748a 10225 error (_("Out of memory\n"));
252b5132
RH		 10226 return 0;
10227 }
10228
10229 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10230 ++counts[lengths[hn]];
252b5132 10231
103f02d3 10232 if (nbuckets > 0)
252b5132 10233 {
66543521
AM		 10234 unsigned long i;
10235 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10236 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10237 for (i = 1; i <= maxlength; ++i)
103f02d3 10238 {
66543521
AM		 10239 nzero_counts += counts[i] * i;
10240 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10241 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10242 (nzero_counts * 100.0) / nsyms);
10243 }
252b5132
RH		 10244 }
10245
10246 free (counts);
10247 free (lengths);
10248 }
10249
10250 if (buckets != NULL)
10251 {
10252 free (buckets);
10253 free (chains);
10254 }
10255
d3a44ec6 10256 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10257 {
2cf0635d
NC		 10258 unsigned long * lengths;
10259 unsigned long * counts;
fdc90cb4
JJ		 10260 unsigned long hn;
10261 unsigned long maxlength = 0;
10262 unsigned long nzero_counts = 0;
10263 unsigned long nsyms = 0;
fdc90cb4 10264
3f5e193b 10265 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10266 if (lengths == NULL)
10267 {
591a748a 10268 error (_("Out of memory\n"));
fdc90cb4
JJ		 10269 return 0;
10270 }
10271
10272 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10273 (unsigned long) ngnubuckets);
10274 printf (_(" Length Number %% of total Coverage\n"));
10275
10276 for (hn = 0; hn < ngnubuckets; ++hn)
10277 if (gnubuckets[hn] != 0)
10278 {
10279 bfd_vma off, length = 1;
10280
6bd1a22c 10281 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 10282 (gnuchains[off] & 1) == 0; ++off)
10283 ++length;
10284 lengths[hn] = length;
10285 if (length > maxlength)
10286 maxlength = length;
10287 nsyms += length;
10288 }
10289
3f5e193b 10290 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10291 if (counts == NULL)
10292 {
b2e951ec 10293 free (lengths);
591a748a 10294 error (_("Out of memory\n"));
fdc90cb4
JJ		 10295 return 0;
10296 }
10297
10298 for (hn = 0; hn < ngnubuckets; ++hn)
10299 ++counts[lengths[hn]];
10300
10301 if (ngnubuckets > 0)
10302 {
10303 unsigned long j;
10304 printf (" 0 %-10lu (%5.1f%%)\n",
10305 counts[0], (counts[0] * 100.0) / ngnubuckets);
10306 for (j = 1; j <= maxlength; ++j)
10307 {
10308 nzero_counts += counts[j] * j;
10309 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10310 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10311 (nzero_counts * 100.0) / nsyms);
10312 }
10313 }
10314
10315 free (counts);
10316 free (lengths);
10317 free (gnubuckets);
10318 free (gnuchains);
10319 }
10320
252b5132
RH		 10321 return 1;
10322}
10323
10324static int
2cf0635d 10325process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10326{
b4c96d0d 10327 unsigned int i;
252b5132
RH		 10328
10329 if (dynamic_syminfo == NULL
10330 || !do_dynamic)
10331 /* No syminfo, this is ok. */
10332 return 1;
10333
10334 /* There better should be a dynamic symbol section. */
10335 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10336 return 0;
10337
10338 if (dynamic_addr)
10339 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10340 dynamic_syminfo_offset, dynamic_syminfo_nent);
10341
10342 printf (_(" Num: Name BoundTo Flags\n"));
10343 for (i = 0; i < dynamic_syminfo_nent; ++i)
10344 {
10345 unsigned short int flags = dynamic_syminfo[i].si_flags;
10346
31104126 10347 printf ("%4d: ", i);
e0a31db1 10348 assert (i < num_dynamic_syms);
d79b3d50
NC		 10349 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10350 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10351 else
2b692964 10352 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10353 putchar (' ');
252b5132
RH		 10354
10355 switch (dynamic_syminfo[i].si_boundto)
10356 {
10357 case SYMINFO_BT_SELF:
10358 fputs ("SELF ", stdout);
10359 break;
10360 case SYMINFO_BT_PARENT:
10361 fputs ("PARENT ", stdout);
10362 break;
10363 default:
10364 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10365 && dynamic_syminfo[i].si_boundto < dynamic_nent
10366 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10367 {
d79b3d50 10368 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10369 putchar (' ' );
10370 }
252b5132
RH		 10371 else
10372 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10373 break;
10374 }
10375
10376 if (flags & SYMINFO_FLG_DIRECT)
10377 printf (" DIRECT");
10378 if (flags & SYMINFO_FLG_PASSTHRU)
10379 printf (" PASSTHRU");
10380 if (flags & SYMINFO_FLG_COPY)
10381 printf (" COPY");
10382 if (flags & SYMINFO_FLG_LAZYLOAD)
10383 printf (" LAZYLOAD");
10384
10385 puts ("");
10386 }
10387
10388 return 1;
10389}
10390
cf13d699
NC		 10391/* Check to see if the given reloc needs to be handled in a target specific
10392 manner. If so then process the reloc and return TRUE otherwise return
10393 FALSE. */
09c11c86 10394
cf13d699
NC		 10395static bfd_boolean
10396target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10397 unsigned char * start,
10398 Elf_Internal_Sym * symtab)
252b5132 10399{
cf13d699 10400 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 10401
cf13d699 10402 switch (elf_header.e_machine)
252b5132 10403 {
13761a11
NC		 10404 case EM_MSP430:
10405 case EM_MSP430_OLD:
10406 {
10407 static Elf_Internal_Sym * saved_sym = NULL;
10408
10409 switch (reloc_type)
10410 {
10411 case 10: /* R_MSP430_SYM_DIFF */
10412 if (uses_msp430x_relocs ())
10413 break;
10414 case 21: /* R_MSP430X_SYM_DIFF */
10415 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10416 return TRUE;
10417
10418 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10419 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10420 goto handle_sym_diff;
0b4362b0 10421
13761a11
NC		 10422 case 5: /* R_MSP430_16_BYTE */
10423 case 9: /* R_MSP430_8 */
10424 if (uses_msp430x_relocs ())
10425 break;
10426 goto handle_sym_diff;
10427
10428 case 2: /* R_MSP430_ABS16 */
10429 case 15: /* R_MSP430X_ABS16 */
10430 if (! uses_msp430x_relocs ())
10431 break;
10432 goto handle_sym_diff;
0b4362b0 10433
13761a11
NC		 10434 handle_sym_diff:
10435 if (saved_sym != NULL)
10436 {
10437 bfd_vma value;
10438
10439 value = reloc->r_addend
10440 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10441 - saved_sym->st_value);
10442
10443 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10444
10445 saved_sym = NULL;
10446 return TRUE;
10447 }
10448 break;
10449
10450 default:
10451 if (saved_sym != NULL)
10452 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10453 break;
10454 }
10455 break;
10456 }
10457
cf13d699
NC		 10458 case EM_MN10300:
10459 case EM_CYGNUS_MN10300:
10460 {
10461 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 10462
cf13d699
NC		 10463 switch (reloc_type)
10464 {
10465 case 34: /* R_MN10300_ALIGN */
10466 return TRUE;
10467 case 33: /* R_MN10300_SYM_DIFF */
10468 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10469 return TRUE;
10470 case 1: /* R_MN10300_32 */
10471 case 2: /* R_MN10300_16 */
10472 if (saved_sym != NULL)
10473 {
10474 bfd_vma value;
252b5132 10475
cf13d699
NC		 10476 value = reloc->r_addend
10477 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10478 - saved_sym->st_value);
252b5132 10479
cf13d699 10480 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 10481
cf13d699
NC		 10482 saved_sym = NULL;
10483 return TRUE;
10484 }
10485 break;
10486 default:
10487 if (saved_sym != NULL)
10488 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10489 break;
10490 }
10491 break;
10492 }
252b5132
RH		 10493 }
10494
cf13d699 10495 return FALSE;
252b5132
RH		 10496}
10497
aca88567
NC		 10498/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10499 DWARF debug sections. This is a target specific test. Note - we do not
10500 go through the whole including-target-headers-multiple-times route, (as
10501 we have already done with <elf/h8.h>) because this would become very
10502 messy and even then this function would have to contain target specific
10503 information (the names of the relocs instead of their numeric values).
10504 FIXME: This is not the correct way to solve this problem. The proper way
10505 is to have target specific reloc sizing and typing functions created by
10506 the reloc-macros.h header, in the same way that it already creates the
10507 reloc naming functions. */
10508
10509static bfd_boolean
10510is_32bit_abs_reloc (unsigned int reloc_type)
10511{
10512 switch (elf_header.e_machine)
10513 {
41e92641
NC		 10514 case EM_386:
10515 case EM_486:
10516 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 10517 case EM_68K:
10518 return reloc_type == 1; /* R_68K_32. */
10519 case EM_860:
10520 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10521 case EM_960:
10522 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10523 case EM_AARCH64:
10524 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10525 case EM_ALPHA:
137b6b5f 10526 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10527 case EM_ARC:
10528 return reloc_type == 1; /* R_ARC_32. */
10529 case EM_ARM:
10530 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10531 case EM_AVR_OLD:
aca88567
NC		 10532 case EM_AVR:
10533 return reloc_type == 1;
cfb8c092
NC		 10534 case EM_ADAPTEVA_EPIPHANY:
10535 return reloc_type == 3;
aca88567
NC		 10536 case EM_BLACKFIN:
10537 return reloc_type == 0x12; /* R_byte4_data. */
10538 case EM_CRIS:
10539 return reloc_type == 3; /* R_CRIS_32. */
10540 case EM_CR16:
10541 return reloc_type == 3; /* R_CR16_NUM32. */
10542 case EM_CRX:
10543 return reloc_type == 15; /* R_CRX_NUM32. */
10544 case EM_CYGNUS_FRV:
10545 return reloc_type == 1;
41e92641
NC		 10546 case EM_CYGNUS_D10V:
10547 case EM_D10V:
10548 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10549 case EM_CYGNUS_D30V:
10550 case EM_D30V:
10551 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10552 case EM_DLX:
10553 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10554 case EM_CYGNUS_FR30:
10555 case EM_FR30:
10556 return reloc_type == 3; /* R_FR30_32. */
10557 case EM_H8S:
10558 case EM_H8_300:
10559 case EM_H8_300H:
10560 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10561 case EM_IA_64:
10562 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10563 case EM_IP2K_OLD:
10564 case EM_IP2K:
10565 return reloc_type == 2; /* R_IP2K_32. */
10566 case EM_IQ2000:
10567 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10568 case EM_LATTICEMICO32:
10569 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10570 case EM_M32C_OLD:
aca88567
NC		 10571 case EM_M32C:
10572 return reloc_type == 3; /* R_M32C_32. */
10573 case EM_M32R:
10574 return reloc_type == 34; /* R_M32R_32_RELA. */
10575 case EM_MCORE:
10576 return reloc_type == 1; /* R_MCORE_ADDR32. */
10577 case EM_CYGNUS_MEP:
10578 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10579 case EM_METAG:
10580 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10581 case EM_MICROBLAZE:
10582 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10583 case EM_MIPS:
10584 return reloc_type == 2; /* R_MIPS_32. */
10585 case EM_MMIX:
10586 return reloc_type == 4; /* R_MMIX_32. */
10587 case EM_CYGNUS_MN10200:
10588 case EM_MN10200:
10589 return reloc_type == 1; /* R_MN10200_32. */
10590 case EM_CYGNUS_MN10300:
10591 case EM_MN10300:
10592 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10593 case EM_MOXIE:
10594 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10595 case EM_MSP430_OLD:
10596 case EM_MSP430:
13761a11 10597 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 10598 case EM_MT:
10599 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 10600 case EM_NDS32:
10601 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 10602 case EM_ALTERA_NIOS2:
36591ba1 10603 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 10604 case EM_NIOS32:
10605 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 10606 case EM_OR1K:
10607 return reloc_type == 1; /* R_OR1K_32. */
aca88567 10608 case EM_PARISC:
5fda8eca
NC		 10609 return (reloc_type == 1 /* R_PARISC_DIR32. */
10610 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10611 case EM_PJ:
10612 case EM_PJ_OLD:
10613 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10614 case EM_PPC64:
10615 return reloc_type == 1; /* R_PPC64_ADDR32. */
10616 case EM_PPC:
10617 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10618 case EM_RL78:
10619 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10620 case EM_RX:
10621 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10622 case EM_S370:
10623 return reloc_type == 1; /* R_I370_ADDR31. */
10624 case EM_S390_OLD:
10625 case EM_S390:
10626 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10627 case EM_SCORE:
10628 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10629 case EM_SH:
10630 return reloc_type == 1; /* R_SH_DIR32. */
10631 case EM_SPARC32PLUS:
10632 case EM_SPARCV9:
10633 case EM_SPARC:
10634 return reloc_type == 3 /* R_SPARC_32. */
10635 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10636 case EM_SPU:
10637 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10638 case EM_TI_C6000:
10639 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10640 case EM_TILEGX:
10641 return reloc_type == 2; /* R_TILEGX_32. */
10642 case EM_TILEPRO:
10643 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10644 case EM_CYGNUS_V850:
10645 case EM_V850:
10646 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10647 case EM_V800:
10648 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10649 case EM_VAX:
10650 return reloc_type == 1; /* R_VAX_32. */
10651 case EM_X86_64:
8a9036a4 10652 case EM_L1OM:
7a9068fe 10653 case EM_K1OM:
aca88567 10654 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10655 case EM_XC16X:
10656 case EM_C166:
10657 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10658 case EM_XGATE:
10659 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10660 case EM_XSTORMY16:
10661 return reloc_type == 1; /* R_XSTROMY16_32. */
10662 case EM_XTENSA_OLD:
10663 case EM_XTENSA:
10664 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10665 default:
10666 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10667 elf_header.e_machine);
10668 abort ();
10669 }
10670}
10671
10672/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10673 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10674
10675static bfd_boolean
10676is_32bit_pcrel_reloc (unsigned int reloc_type)
10677{
10678 switch (elf_header.e_machine)
10679 {
41e92641
NC		 10680 case EM_386:
10681 case EM_486:
3e0873ac 10682 return reloc_type == 2; /* R_386_PC32. */
aca88567 10683 case EM_68K:
3e0873ac 10684 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10685 case EM_AARCH64:
10686 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10687 case EM_ADAPTEVA_EPIPHANY:
10688 return reloc_type == 6;
aca88567
NC		 10689 case EM_ALPHA:
10690 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10691 case EM_ARM:
3e0873ac 10692 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10693 case EM_MICROBLAZE:
10694 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 10695 case EM_OR1K:
10696 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 10697 case EM_PARISC:
85acf597 10698 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10699 case EM_PPC:
10700 return reloc_type == 26; /* R_PPC_REL32. */
10701 case EM_PPC64:
3e0873ac 10702 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10703 case EM_S390_OLD:
10704 case EM_S390:
3e0873ac 10705 return reloc_type == 5; /* R_390_PC32. */
aca88567 10706 case EM_SH:
3e0873ac 10707 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10708 case EM_SPARC32PLUS:
10709 case EM_SPARCV9:
10710 case EM_SPARC:
3e0873ac 10711 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10712 case EM_SPU:
10713 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10714 case EM_TILEGX:
10715 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10716 case EM_TILEPRO:
10717 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10718 case EM_X86_64:
8a9036a4 10719 case EM_L1OM:
7a9068fe 10720 case EM_K1OM:
3e0873ac 10721 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10722 case EM_XTENSA_OLD:
10723 case EM_XTENSA:
10724 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10725 default:
10726 /* Do not abort or issue an error message here. Not all targets use
10727 pc-relative 32-bit relocs in their DWARF debug information and we
10728 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10729 more helpful warning message will be generated by apply_relocations
10730 anyway, so just return. */
aca88567
NC		 10731 return FALSE;
10732 }
10733}
10734
10735/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10736 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10737
10738static bfd_boolean
10739is_64bit_abs_reloc (unsigned int reloc_type)
10740{
10741 switch (elf_header.e_machine)
10742 {
a06ea964
NC		 10743 case EM_AARCH64:
10744 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10745 case EM_ALPHA:
10746 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10747 case EM_IA_64:
10748 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10749 case EM_PARISC:
10750 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10751 case EM_PPC64:
10752 return reloc_type == 38; /* R_PPC64_ADDR64. */
10753 case EM_SPARC32PLUS:
10754 case EM_SPARCV9:
10755 case EM_SPARC:
10756 return reloc_type == 54; /* R_SPARC_UA64. */
10757 case EM_X86_64:
8a9036a4 10758 case EM_L1OM:
7a9068fe 10759 case EM_K1OM:
aca88567 10760 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10761 case EM_S390_OLD:
10762 case EM_S390:
aa137e4d
NC		 10763 return reloc_type == 22; /* R_S390_64. */
10764 case EM_TILEGX:
10765 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10766 case EM_MIPS:
aa137e4d 10767 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10768 default:
10769 return FALSE;
10770 }
10771}
10772
85acf597
RH		 10773/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10774 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10775
10776static bfd_boolean
10777is_64bit_pcrel_reloc (unsigned int reloc_type)
10778{
10779 switch (elf_header.e_machine)
10780 {
a06ea964
NC		 10781 case EM_AARCH64:
10782 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10783 case EM_ALPHA:
aa137e4d 10784 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10785 case EM_IA_64:
aa137e4d 10786 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10787 case EM_PARISC:
aa137e4d 10788 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10789 case EM_PPC64:
aa137e4d 10790 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10791 case EM_SPARC32PLUS:
10792 case EM_SPARCV9:
10793 case EM_SPARC:
aa137e4d 10794 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10795 case EM_X86_64:
8a9036a4 10796 case EM_L1OM:
7a9068fe 10797 case EM_K1OM:
aa137e4d 10798 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10799 case EM_S390_OLD:
10800 case EM_S390:
aa137e4d
NC		 10801 return reloc_type == 23; /* R_S390_PC64. */
10802 case EM_TILEGX:
10803 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10804 default:
10805 return FALSE;
10806 }
10807}
10808
4dc3c23d
AM		 10809/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10810 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10811
10812static bfd_boolean
10813is_24bit_abs_reloc (unsigned int reloc_type)
10814{
10815 switch (elf_header.e_machine)
10816 {
10817 case EM_CYGNUS_MN10200:
10818 case EM_MN10200:
10819 return reloc_type == 4; /* R_MN10200_24. */
10820 default:
10821 return FALSE;
10822 }
10823}
10824
aca88567
NC		 10825/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10826 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10827
10828static bfd_boolean
10829is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10830{
10831 switch (elf_header.e_machine)
10832 {
aca88567
NC		 10833 case EM_AVR_OLD:
10834 case EM_AVR:
10835 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10836 case EM_ADAPTEVA_EPIPHANY:
10837 return reloc_type == 5;
41e92641
NC		 10838 case EM_CYGNUS_D10V:
10839 case EM_D10V:
10840 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10841 case EM_H8S:
10842 case EM_H8_300:
10843 case EM_H8_300H:
aca88567
NC		 10844 return reloc_type == R_H8_DIR16;
10845 case EM_IP2K_OLD:
10846 case EM_IP2K:
10847 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10848 case EM_M32C_OLD:
f4236fe4
DD		 10849 case EM_M32C:
10850 return reloc_type == 1; /* R_M32C_16 */
aca88567 10851 case EM_MSP430:
13761a11
NC		 10852 if (uses_msp430x_relocs ())
10853 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 10854 case EM_MSP430_OLD:
aca88567 10855 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 10856 case EM_NDS32:
10857 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 10858 case EM_ALTERA_NIOS2:
36591ba1 10859 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 10860 case EM_NIOS32:
10861 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 10862 case EM_OR1K:
10863 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 10864 case EM_TI_C6000:
10865 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10866 case EM_XC16X:
10867 case EM_C166:
10868 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10869 case EM_CYGNUS_MN10200:
10870 case EM_MN10200:
10871 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10872 case EM_CYGNUS_MN10300:
10873 case EM_MN10300:
10874 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10875 case EM_XGATE:
10876 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10877 default:
aca88567 10878 return FALSE;
4b78141a
NC		 10879 }
10880}
10881
2a7b2e88
JK		 10882/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10883 relocation entries (possibly formerly used for SHT_GROUP sections). */
10884
10885static bfd_boolean
10886is_none_reloc (unsigned int reloc_type)
10887{
10888 switch (elf_header.e_machine)
10889 {
cb8f3167
NC		 10890 case EM_68K: /* R_68K_NONE. */
10891 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10892 case EM_SPARC32PLUS:
10893 case EM_SPARCV9:
cb8f3167
NC		 10894 case EM_SPARC: /* R_SPARC_NONE. */
10895 case EM_MIPS: /* R_MIPS_NONE. */
10896 case EM_PARISC: /* R_PARISC_NONE. */
10897 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10898 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10899 case EM_PPC: /* R_PPC_NONE. */
10900 case EM_PPC64: /* R_PPC64_NONE. */
10901 case EM_ARM: /* R_ARM_NONE. */
10902 case EM_IA_64: /* R_IA64_NONE. */
10903 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10904 case EM_S390_OLD:
cb8f3167
NC		 10905 case EM_S390: /* R_390_NONE. */
10906 case EM_CRIS: /* R_CRIS_NONE. */
10907 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10908 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10909 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10910 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10911 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10912 case EM_M32R: /* R_M32R_NONE. */
40b36596 10913 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10914 case EM_TILEGX: /* R_TILEGX_NONE. */
10915 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10916 case EM_XC16X:
10917 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 10918 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
10919 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 10920 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 10921 return reloc_type == 0;
a06ea964
NC		 10922 case EM_AARCH64:
10923 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 10924 case EM_NDS32:
10925 return (reloc_type == 0 /* R_XTENSA_NONE. */
10926 || reloc_type == 204 /* R_NDS32_DIFF8. */
10927 || reloc_type == 205 /* R_NDS32_DIFF16. */
10928 || reloc_type == 206 /* R_NDS32_DIFF32. */
10929 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 10930 case EM_XTENSA_OLD:
10931 case EM_XTENSA:
4dc3c23d
AM		 10932 return (reloc_type == 0 /* R_XTENSA_NONE. */
10933 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10934 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10935 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 10936 case EM_METAG:
10937 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 10938 }
10939 return FALSE;
10940}
10941
cf13d699
NC		 10942/* Apply relocations to a section.
10943 Note: So far support has been added only for those relocations
10944 which can be found in debug sections.
10945 FIXME: Add support for more relocations ? */
1b315056 10946
cf13d699
NC		 10947static void
10948apply_relocations (void * file,
10949 Elf_Internal_Shdr * section,
10950 unsigned char * start)
1b315056 10951{
cf13d699
NC		 10952 Elf_Internal_Shdr * relsec;
10953 unsigned char * end = start + section->sh_size;
cb8f3167 10954
cf13d699
NC		 10955 if (elf_header.e_type != ET_REL)
10956 return;
1b315056 10957
cf13d699 10958 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10959 for (relsec = section_headers;
10960 relsec < section_headers + elf_header.e_shnum;
10961 ++relsec)
252b5132 10962 {
41e92641
NC		 10963 bfd_boolean is_rela;
10964 unsigned long num_relocs;
2cf0635d
NC		 10965 Elf_Internal_Rela * relocs;
10966 Elf_Internal_Rela * rp;
10967 Elf_Internal_Shdr * symsec;
10968 Elf_Internal_Sym * symtab;
ba5cdace 10969 unsigned long num_syms;
2cf0635d 10970 Elf_Internal_Sym * sym;
252b5132 10971
41e92641 10972 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10973 || relsec->sh_info >= elf_header.e_shnum
10974 || section_headers + relsec->sh_info != section
c256ffe7 10975 || relsec->sh_size == 0
4fbb74a6 10976 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10977 continue;
428409d5 10978
41e92641
NC		 10979 is_rela = relsec->sh_type == SHT_RELA;
10980
10981 if (is_rela)
10982 {
3f5e193b
NC		 10983 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10984 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10985 return;
10986 }
10987 else
10988 {
3f5e193b
NC		 10989 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10990 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10991 return;
10992 }
10993
10994 /* SH uses RELA but uses in place value instead of the addend field. */
10995 if (elf_header.e_machine == EM_SH)
10996 is_rela = FALSE;
428409d5 10997
4fbb74a6 10998 symsec = section_headers + relsec->sh_link;
ba5cdace 10999 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11000
41e92641 11001 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11002 {
41e92641
NC		 11003 bfd_vma addend;
11004 unsigned int reloc_type;
11005 unsigned int reloc_size;
91d6fa6a 11006 unsigned char * rloc;
ba5cdace 11007 unsigned long sym_index;
4b78141a 11008
aca88567 11009 reloc_type = get_reloc_type (rp->r_info);
41e92641 11010
98fb390a 11011 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11012 continue;
98fb390a
NC		 11013 else if (is_none_reloc (reloc_type))
11014 continue;
11015 else if (is_32bit_abs_reloc (reloc_type)
11016 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11017 reloc_size = 4;
85acf597
RH		 11018 else if (is_64bit_abs_reloc (reloc_type)
11019 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11020 reloc_size = 8;
4dc3c23d
AM		 11021 else if (is_24bit_abs_reloc (reloc_type))
11022 reloc_size = 3;
aca88567
NC		 11023 else if (is_16bit_abs_reloc (reloc_type))
11024 reloc_size = 2;
11025 else
4b78141a 11026 {
41e92641 11027 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 11028 reloc_type, SECTION_NAME (section));
4b78141a
NC		 11029 continue;
11030 }
103f02d3 11031
91d6fa6a 11032 rloc = start + rp->r_offset;
c8da6823 11033 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11034 {
11035 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11036 (unsigned long) rp->r_offset,
11037 SECTION_NAME (section));
11038 continue;
11039 }
103f02d3 11040
ba5cdace
NC		 11041 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11042 if (sym_index >= num_syms)
11043 {
11044 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11045 sym_index, SECTION_NAME (section));
11046 continue;
11047 }
11048 sym = symtab + sym_index;
41e92641
NC		 11049
11050 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11051 make sure that it is of an appropriate type.
11052
11053 Relocations against symbols without type can happen.
11054 Gcc -feliminate-dwarf2-dups may generate symbols
11055 without type for debug info.
11056
11057 Icc generates relocations against function symbols
11058 instead of local labels.
11059
11060 Relocations against object symbols can happen, eg when
11061 referencing a global array. For an example of this see
11062 the _clz.o binary in libgcc.a. */
aca88567 11063 if (sym != symtab
55f25fc3 11064 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11065 {
41e92641 11066 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11067 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11068 (long int)(rp - relocs),
41e92641 11069 SECTION_NAME (relsec));
aca88567 11070 continue;
5b18a4bc 11071 }
252b5132 11072
4dc3c23d
AM		 11073 addend = 0;
11074 if (is_rela)
11075 addend += rp->r_addend;
c47320c3
AM		 11076 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11077 partial_inplace. */
4dc3c23d
AM		 11078 if (!is_rela
11079 || (elf_header.e_machine == EM_XTENSA
11080 && reloc_type == 1)
11081 || ((elf_header.e_machine == EM_PJ
11082 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11083 && reloc_type == 1)
11084 || ((elf_header.e_machine == EM_D30V
11085 || elf_header.e_machine == EM_CYGNUS_D30V)
11086 && reloc_type == 12))
91d6fa6a 11087 addend += byte_get (rloc, reloc_size);
cb8f3167 11088
85acf597
RH		 11089 if (is_32bit_pcrel_reloc (reloc_type)
11090 || is_64bit_pcrel_reloc (reloc_type))
11091 {
11092 /* On HPPA, all pc-relative relocations are biased by 8. */
11093 if (elf_header.e_machine == EM_PARISC)
11094 addend -= 8;
91d6fa6a 11095 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11096 reloc_size);
11097 }
41e92641 11098 else
91d6fa6a 11099 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11100 }
252b5132 11101
5b18a4bc 11102 free (symtab);
41e92641 11103 free (relocs);
5b18a4bc
NC		 11104 break;
11105 }
5b18a4bc 11106}
103f02d3 11107
cf13d699
NC		 11108#ifdef SUPPORT_DISASSEMBLY
11109static int
11110disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11111{
11112 printf (_("\nAssembly dump of section %s\n"),
11113 SECTION_NAME (section));
11114
11115 /* XXX -- to be done --- XXX */
11116
11117 return 1;
11118}
11119#endif
11120
11121/* Reads in the contents of SECTION from FILE, returning a pointer
11122 to a malloc'ed buffer or NULL if something went wrong. */
11123
11124static char *
11125get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11126{
11127 bfd_size_type num_bytes;
11128
11129 num_bytes = section->sh_size;
11130
11131 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11132 {
11133 printf (_("\nSection '%s' has no data to dump.\n"),
11134 SECTION_NAME (section));
11135 return NULL;
11136 }
11137
3f5e193b
NC		 11138 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11139 _("section contents"));
cf13d699
NC		 11140}
11141
dd24e3da 11142
cf13d699
NC		 11143static void
11144dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11145{
11146 Elf_Internal_Shdr * relsec;
11147 bfd_size_type num_bytes;
cf13d699
NC		 11148 char * data;
11149 char * end;
11150 char * start;
11151 char * name = SECTION_NAME (section);
11152 bfd_boolean some_strings_shown;
11153
11154 start = get_section_contents (section, file);
11155 if (start == NULL)
11156 return;
11157
11158 printf (_("\nString dump of section '%s':\n"), name);
11159
11160 /* If the section being dumped has relocations against it the user might
11161 be expecting these relocations to have been applied. Check for this
11162 case and issue a warning message in order to avoid confusion.
11163 FIXME: Maybe we ought to have an option that dumps a section with
11164 relocs applied ? */
11165 for (relsec = section_headers;
11166 relsec < section_headers + elf_header.e_shnum;
11167 ++relsec)
11168 {
11169 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11170 || relsec->sh_info >= elf_header.e_shnum
11171 || section_headers + relsec->sh_info != section
11172 || relsec->sh_size == 0
11173 || relsec->sh_link >= elf_header.e_shnum)
11174 continue;
11175
11176 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11177 break;
11178 }
11179
11180 num_bytes = section->sh_size;
cf13d699
NC		 11181 data = start;
11182 end = start + num_bytes;
11183 some_strings_shown = FALSE;
11184
11185 while (data < end)
11186 {
11187 while (!ISPRINT (* data))
11188 if (++ data >= end)
11189 break;
11190
11191 if (data < end)
11192 {
11193#ifndef __MSVCRT__
c975cc98
NC		 11194 /* PR 11128: Use two separate invocations in order to work
11195 around bugs in the Solaris 8 implementation of printf. */
11196 printf (" [%6tx] ", data - start);
11197 printf ("%s\n", data);
cf13d699
NC		 11198#else
11199 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
11200#endif
11201 data += strlen (data);
11202 some_strings_shown = TRUE;
11203 }
11204 }
11205
11206 if (! some_strings_shown)
11207 printf (_(" No strings found in this section."));
11208
11209 free (start);
11210
11211 putchar ('\n');
11212}
11213
11214static void
11215dump_section_as_bytes (Elf_Internal_Shdr * section,
11216 FILE * file,
11217 bfd_boolean relocate)
11218{
11219 Elf_Internal_Shdr * relsec;
11220 bfd_size_type bytes;
11221 bfd_vma addr;
11222 unsigned char * data;
11223 unsigned char * start;
11224
11225 start = (unsigned char *) get_section_contents (section, file);
11226 if (start == NULL)
11227 return;
11228
11229 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
11230
11231 if (relocate)
11232 {
11233 apply_relocations (file, section, start);
11234 }
11235 else
11236 {
11237 /* If the section being dumped has relocations against it the user might
11238 be expecting these relocations to have been applied. Check for this
11239 case and issue a warning message in order to avoid confusion.
11240 FIXME: Maybe we ought to have an option that dumps a section with
11241 relocs applied ? */
11242 for (relsec = section_headers;
11243 relsec < section_headers + elf_header.e_shnum;
11244 ++relsec)
11245 {
11246 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11247 || relsec->sh_info >= elf_header.e_shnum
11248 || section_headers + relsec->sh_info != section
11249 || relsec->sh_size == 0
11250 || relsec->sh_link >= elf_header.e_shnum)
11251 continue;
11252
11253 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11254 break;
11255 }
11256 }
11257
11258 addr = section->sh_addr;
11259 bytes = section->sh_size;
11260 data = start;
11261
11262 while (bytes)
11263 {
11264 int j;
11265 int k;
11266 int lbytes;
11267
11268 lbytes = (bytes > 16 ? 16 : bytes);
11269
11270 printf (" 0x%8.8lx ", (unsigned long) addr);
11271
11272 for (j = 0; j < 16; j++)
11273 {
11274 if (j < lbytes)
11275 printf ("%2.2x", data[j]);
11276 else
11277 printf (" ");
11278
11279 if ((j & 3) == 3)
11280 printf (" ");
11281 }
11282
11283 for (j = 0; j < lbytes; j++)
11284 {
11285 k = data[j];
11286 if (k >= ' ' && k < 0x7f)
11287 printf ("%c", k);
11288 else
11289 printf (".");
11290 }
11291
11292 putchar ('\n');
11293
11294 data += lbytes;
11295 addr += lbytes;
11296 bytes -= lbytes;
11297 }
11298
11299 free (start);
11300
11301 putchar ('\n');
11302}
11303
4a114e3e 11304/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11305
11306static int
d3dbc530
AM		 11307uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11308 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 11309{
11310#ifndef HAVE_ZLIB_H
cf13d699
NC		 11311 return FALSE;
11312#else
11313 dwarf_size_type compressed_size = *size;
11314 unsigned char * compressed_buffer = *buffer;
11315 dwarf_size_type uncompressed_size;
11316 unsigned char * uncompressed_buffer;
11317 z_stream strm;
11318 int rc;
11319 dwarf_size_type header_size = 12;
11320
11321 /* Read the zlib header. In this case, it should be "ZLIB" followed
11322 by the uncompressed section size, 8 bytes in big-endian order. */
11323 if (compressed_size < header_size
11324 || ! streq ((char *) compressed_buffer, "ZLIB"))
11325 return 0;
11326
11327 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11328 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11329 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11330 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11331 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11332 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11333 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11334 uncompressed_size += compressed_buffer[11];
11335
11336 /* It is possible the section consists of several compressed
11337 buffers concatenated together, so we uncompress in a loop. */
11338 strm.zalloc = NULL;
11339 strm.zfree = NULL;
11340 strm.opaque = NULL;
11341 strm.avail_in = compressed_size - header_size;
11342 strm.next_in = (Bytef *) compressed_buffer + header_size;
11343 strm.avail_out = uncompressed_size;
3f5e193b 11344 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 11345
11346 rc = inflateInit (& strm);
11347 while (strm.avail_in > 0)
11348 {
11349 if (rc != Z_OK)
11350 goto fail;
11351 strm.next_out = ((Bytef *) uncompressed_buffer
11352 + (uncompressed_size - strm.avail_out));
11353 rc = inflate (&strm, Z_FINISH);
11354 if (rc != Z_STREAM_END)
11355 goto fail;
11356 rc = inflateReset (& strm);
11357 }
11358 rc = inflateEnd (& strm);
11359 if (rc != Z_OK
11360 || strm.avail_out != 0)
11361 goto fail;
11362
11363 free (compressed_buffer);
11364 *buffer = uncompressed_buffer;
11365 *size = uncompressed_size;
11366 return 1;
11367
11368 fail:
11369 free (uncompressed_buffer);
4a114e3e
L		 11370 /* Indicate decompression failure. */
11371 *buffer = NULL;
cf13d699
NC		 11372 return 0;
11373#endif /* HAVE_ZLIB_H */
11374}
11375
d966045b
DJ		 11376static int
11377load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 11378 Elf_Internal_Shdr * sec, void * file)
1007acb3 11379{
2cf0635d 11380 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 11381 char buf [64];
1007acb3 11382
19e6b90e
L		 11383 /* If it is already loaded, do nothing. */
11384 if (section->start != NULL)
11385 return 1;
1007acb3 11386
19e6b90e
L		 11387 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11388 section->address = sec->sh_addr;
3f5e193b
NC		 11389 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11390 sec->sh_offset, 1,
11391 sec->sh_size, buf);
59245841
NC		 11392 if (section->start == NULL)
11393 section->size = 0;
11394 else
11395 {
11396 section->size = sec->sh_size;
11397 if (uncompress_section_contents (&section->start, &section->size))
11398 sec->sh_size = section->size;
11399 }
4a114e3e 11400
1b315056
CS		 11401 if (section->start == NULL)
11402 return 0;
11403
19e6b90e 11404 if (debug_displays [debug].relocate)
3f5e193b 11405 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11406
1b315056 11407 return 1;
1007acb3
L		 11408}
11409
657d0d47
CC		 11410/* If this is not NULL, load_debug_section will only look for sections
11411 within the list of sections given here. */
11412unsigned int *section_subset = NULL;
11413
d966045b 11414int
2cf0635d 11415load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11416{
2cf0635d
NC		 11417 struct dwarf_section * section = &debug_displays [debug].section;
11418 Elf_Internal_Shdr * sec;
d966045b
DJ		 11419
11420 /* Locate the debug section. */
657d0d47 11421 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 11422 if (sec != NULL)
11423 section->name = section->uncompressed_name;
11424 else
11425 {
657d0d47 11426 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 11427 if (sec != NULL)
11428 section->name = section->compressed_name;
11429 }
11430 if (sec == NULL)
11431 return 0;
11432
657d0d47
CC		 11433 /* If we're loading from a subset of sections, and we've loaded
11434 a section matching this name before, it's likely that it's a
11435 different one. */
11436 if (section_subset != NULL)
11437 free_debug_section (debug);
11438
3f5e193b 11439 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 11440}
11441
19e6b90e
L		 11442void
11443free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 11444{
2cf0635d 11445 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 11446
19e6b90e
L		 11447 if (section->start == NULL)
11448 return;
1007acb3 11449
19e6b90e
L		 11450 free ((char *) section->start);
11451 section->start = NULL;
11452 section->address = 0;
11453 section->size = 0;
1007acb3
L		 11454}
11455
1007acb3 11456static int
657d0d47 11457display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 11458{
2cf0635d 11459 char * name = SECTION_NAME (section);
19e6b90e
L		 11460 bfd_size_type length;
11461 int result = 1;
3f5e193b 11462 int i;
1007acb3 11463
19e6b90e
L		 11464 length = section->sh_size;
11465 if (length == 0)
1007acb3 11466 {
19e6b90e
L		 11467 printf (_("\nSection '%s' has no debugging data.\n"), name);
11468 return 0;
1007acb3 11469 }
5dff79d8
NC		 11470 if (section->sh_type == SHT_NOBITS)
11471 {
11472 /* There is no point in dumping the contents of a debugging section
11473 which has the NOBITS type - the bits in the file will be random.
11474 This can happen when a file containing a .eh_frame section is
11475 stripped with the --only-keep-debug command line option. */
11476 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11477 return 0;
11478 }
1007acb3 11479
0112cd26 11480 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 11481 name = ".debug_info";
1007acb3 11482
19e6b90e
L		 11483 /* See if we know how to display the contents of this section. */
11484 for (i = 0; i < max; i++)
1b315056 11485 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 11486 || (i == line && const_strneq (name, ".debug_line."))
1b315056 11487 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 11488 {
2cf0635d 11489 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 11490 int secondary = (section != find_section (name));
11491
11492 if (secondary)
3f5e193b 11493 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 11494
b40bf0a2
NC		 11495 if (i == line && const_strneq (name, ".debug_line."))
11496 sec->name = name;
11497 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 11498 sec->name = sec->uncompressed_name;
11499 else
11500 sec->name = sec->compressed_name;
3f5e193b
NC		 11501 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11502 section, file))
19e6b90e 11503 {
657d0d47
CC		 11504 /* If this debug section is part of a CU/TU set in a .dwp file,
11505 restrict load_debug_section to the sections in that set. */
11506 section_subset = find_cu_tu_set (file, shndx);
11507
19e6b90e 11508 result &= debug_displays[i].display (sec, file);
1007acb3 11509
657d0d47
CC		 11510 section_subset = NULL;
11511
d966045b 11512 if (secondary || (i != info && i != abbrev))
3f5e193b 11513 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 11514 }
1007acb3 11515
19e6b90e
L		 11516 break;
11517 }
1007acb3 11518
19e6b90e 11519 if (i == max)
1007acb3 11520 {
19e6b90e
L		 11521 printf (_("Unrecognized debug section: %s\n"), name);
11522 result = 0;
1007acb3
L		 11523 }
11524
19e6b90e 11525 return result;
5b18a4bc 11526}
103f02d3 11527
aef1f6d0
DJ		 11528/* Set DUMP_SECTS for all sections where dumps were requested
11529 based on section name. */
11530
11531static void
11532initialise_dumps_byname (void)
11533{
2cf0635d 11534 struct dump_list_entry * cur;
aef1f6d0
DJ		 11535
11536 for (cur = dump_sects_byname; cur; cur = cur->next)
11537 {
11538 unsigned int i;
11539 int any;
11540
11541 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11542 if (streq (SECTION_NAME (section_headers + i), cur->name))
11543 {
09c11c86 11544 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11545 any = 1;
11546 }
11547
11548 if (!any)
11549 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11550 cur->name);
11551 }
11552}
11553
5b18a4bc 11554static void
2cf0635d 11555process_section_contents (FILE * file)
5b18a4bc 11556{
2cf0635d 11557 Elf_Internal_Shdr * section;
19e6b90e 11558 unsigned int i;
103f02d3 11559
19e6b90e
L		 11560 if (! do_dump)
11561 return;
103f02d3 11562
aef1f6d0
DJ		 11563 initialise_dumps_byname ();
11564
19e6b90e
L		 11565 for (i = 0, section = section_headers;
11566 i < elf_header.e_shnum && i < num_dump_sects;
11567 i++, section++)
11568 {
11569#ifdef SUPPORT_DISASSEMBLY
11570 if (dump_sects[i] & DISASS_DUMP)
11571 disassemble_section (section, file);
11572#endif
11573 if (dump_sects[i] & HEX_DUMP)
cf13d699 11574 dump_section_as_bytes (section, file, FALSE);
103f02d3 11575
cf13d699
NC		 11576 if (dump_sects[i] & RELOC_DUMP)
11577 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11578
11579 if (dump_sects[i] & STRING_DUMP)
11580 dump_section_as_strings (section, file);
cf13d699
NC		 11581
11582 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11583 display_debug_section (i, section, file);
5b18a4bc 11584 }
103f02d3 11585
19e6b90e
L		 11586 /* Check to see if the user requested a
11587 dump of a section that does not exist. */
11588 while (i++ < num_dump_sects)
11589 if (dump_sects[i])
11590 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11591}
103f02d3 11592
5b18a4bc 11593static void
19e6b90e 11594process_mips_fpe_exception (int mask)
5b18a4bc 11595{
19e6b90e
L		 11596 if (mask)
11597 {
11598 int first = 1;
11599 if (mask & OEX_FPU_INEX)
11600 fputs ("INEX", stdout), first = 0;
11601 if (mask & OEX_FPU_UFLO)
11602 printf ("%sUFLO", first ? "" : "|"), first = 0;
11603 if (mask & OEX_FPU_OFLO)
11604 printf ("%sOFLO", first ? "" : "|"), first = 0;
11605 if (mask & OEX_FPU_DIV0)
11606 printf ("%sDIV0", first ? "" : "|"), first = 0;
11607 if (mask & OEX_FPU_INVAL)
11608 printf ("%sINVAL", first ? "" : "|");
11609 }
5b18a4bc 11610 else
19e6b90e 11611 fputs ("0", stdout);
5b18a4bc 11612}
103f02d3 11613
f6f0e17b
NC		 11614/* Display's the value of TAG at location P. If TAG is
11615 greater than 0 it is assumed to be an unknown tag, and
11616 a message is printed to this effect. Otherwise it is
11617 assumed that a message has already been printed.
11618
11619 If the bottom bit of TAG is set it assumed to have a
11620 string value, otherwise it is assumed to have an integer
11621 value.
11622
11623 Returns an updated P pointing to the first unread byte
11624 beyond the end of TAG's value.
11625
11626 Reads at or beyond END will not be made. */
11627
11628static unsigned char *
11629display_tag_value (int tag,
11630 unsigned char * p,
11631 const unsigned char * const end)
11632{
11633 unsigned long val;
11634
11635 if (tag > 0)
11636 printf (" Tag_unknown_%d: ", tag);
11637
11638 if (p >= end)
11639 {
11640 warn (_("corrupt tag\n"));
11641 }
11642 else if (tag & 1)
11643 {
11644 /* FIXME: we could read beyond END here. */
11645 printf ("\"%s\"\n", p);
11646 p += strlen ((char *) p) + 1;
11647 }
11648 else
11649 {
11650 unsigned int len;
11651
11652 val = read_uleb128 (p, &len, end);
11653 p += len;
11654 printf ("%ld (0x%lx)\n", val, val);
11655 }
11656
11657 return p;
11658}
11659
11c1ff18
PB		 11660/* ARM EABI attributes section. */
11661typedef struct
11662{
70e99720 11663 unsigned int tag;
2cf0635d 11664 const char * name;
11c1ff18 11665 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 11666 unsigned int type;
2cf0635d 11667 const char ** table;
11c1ff18
PB		 11668} arm_attr_public_tag;
11669
2cf0635d 11670static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11671 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11672 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11673static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11674static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11675 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11676static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 11677 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11678 "FP for ARMv8"};
2cf0635d 11679static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11680static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11681 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11682static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11683 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11684 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11685static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11686 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11687static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11688 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11689static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11690 {"Absolute", "PC-relative", "None"};
2cf0635d 11691static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11692 {"None", "direct", "GOT-indirect"};
2cf0635d 11693static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11694 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11695static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11696static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11697 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11698static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11699static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11700static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11701 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11702static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11703 {"Unused", "small", "int", "forced to int"};
2cf0635d 11704static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11705 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11706static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11707 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11708static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11709 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11710static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11711 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11712 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11713static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 11714 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11715 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11716static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11717static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11718 {"Not Allowed", "Allowed"};
2cf0635d 11719static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11720 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11721static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 11722 {"Not Allowed", "Allowed"};
11723static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11724 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11725 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 11726static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11727static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11728 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11729 "TrustZone and Virtualization Extensions"};
dd24e3da 11730static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11731 {"Not Allowed", "Allowed"};
11c1ff18
PB		 11732
11733#define LOOKUP(id, name) \
11734 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11735static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 11736{
11737 {4, "CPU_raw_name", 1, NULL},
11738 {5, "CPU_name", 1, NULL},
11739 LOOKUP(6, CPU_arch),
11740 {7, "CPU_arch_profile", 0, NULL},
11741 LOOKUP(8, ARM_ISA_use),
11742 LOOKUP(9, THUMB_ISA_use),
75375b3e 11743 LOOKUP(10, FP_arch),
11c1ff18 11744 LOOKUP(11, WMMX_arch),
f5f53991
AS		 11745 LOOKUP(12, Advanced_SIMD_arch),
11746 LOOKUP(13, PCS_config),
11c1ff18
PB		 11747 LOOKUP(14, ABI_PCS_R9_use),
11748 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11749 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 11750 LOOKUP(17, ABI_PCS_GOT_use),
11751 LOOKUP(18, ABI_PCS_wchar_t),
11752 LOOKUP(19, ABI_FP_rounding),
11753 LOOKUP(20, ABI_FP_denormal),
11754 LOOKUP(21, ABI_FP_exceptions),
11755 LOOKUP(22, ABI_FP_user_exceptions),
11756 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 11757 {24, "ABI_align_needed", 0, NULL},
11758 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 11759 LOOKUP(26, ABI_enum_size),
11760 LOOKUP(27, ABI_HardFP_use),
11761 LOOKUP(28, ABI_VFP_args),
11762 LOOKUP(29, ABI_WMMX_args),
11763 LOOKUP(30, ABI_optimization_goals),
11764 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11765 {32, "compatibility", 0, NULL},
f5f53991 11766 LOOKUP(34, CPU_unaligned_access),
75375b3e 11767 LOOKUP(36, FP_HP_extension),
8e79c3df 11768 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 11769 LOOKUP(42, MPextension_use),
11770 LOOKUP(44, DIV_use),
f5f53991
AS		 11771 {64, "nodefaults", 0, NULL},
11772 {65, "also_compatible_with", 0, NULL},
11773 LOOKUP(66, T2EE_use),
11774 {67, "conformance", 1, NULL},
11775 LOOKUP(68, Virtualization_use),
cd21e546 11776 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 11777};
11778#undef LOOKUP
11779
11c1ff18 11780static unsigned char *
f6f0e17b
NC		 11781display_arm_attribute (unsigned char * p,
11782 const unsigned char * const end)
11c1ff18 11783{
70e99720 11784 unsigned int tag;
11c1ff18 11785 unsigned int len;
70e99720 11786 unsigned int val;
2cf0635d 11787 arm_attr_public_tag * attr;
11c1ff18 11788 unsigned i;
70e99720 11789 unsigned int type;
11c1ff18 11790
f6f0e17b 11791 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 11792 p += len;
11793 attr = NULL;
2cf0635d 11794 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 11795 {
11796 if (arm_attr_public_tags[i].tag == tag)
11797 {
11798 attr = &arm_attr_public_tags[i];
11799 break;
11800 }
11801 }
11802
11803 if (attr)
11804 {
11805 printf (" Tag_%s: ", attr->name);
11806 switch (attr->type)
11807 {
11808 case 0:
11809 switch (tag)
11810 {
11811 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 11812 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11813 p += len;
11814 switch (val)
11815 {
2b692964
NC		 11816 case 0: printf (_("None\n")); break;
11817 case 'A': printf (_("Application\n")); break;
11818 case 'R': printf (_("Realtime\n")); break;
11819 case 'M': printf (_("Microcontroller\n")); break;
11820 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11821 default: printf ("??? (%d)\n", val); break;
11822 }
11823 break;
11824
75375b3e 11825 case 24: /* Tag_align_needed. */
f6f0e17b 11826 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11827 p += len;
11828 switch (val)
11829 {
2b692964
NC		 11830 case 0: printf (_("None\n")); break;
11831 case 1: printf (_("8-byte\n")); break;
11832 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11833 case 3: printf ("??? 3\n"); break;
11834 default:
11835 if (val <= 12)
dd24e3da 11836 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11837 1 << val);
11838 else
11839 printf ("??? (%d)\n", val);
11840 break;
11841 }
11842 break;
11843
11844 case 25: /* Tag_align_preserved. */
f6f0e17b 11845 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11846 p += len;
11847 switch (val)
11848 {
2b692964
NC		 11849 case 0: printf (_("None\n")); break;
11850 case 1: printf (_("8-byte, except leaf SP\n")); break;
11851 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11852 case 3: printf ("??? 3\n"); break;
11853 default:
11854 if (val <= 12)
dd24e3da 11855 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11856 1 << val);
11857 else
11858 printf ("??? (%d)\n", val);
11859 break;
11860 }
11861 break;
11862
11c1ff18 11863 case 32: /* Tag_compatibility. */
f6f0e17b 11864 val = read_uleb128 (p, &len, end);
11c1ff18 11865 p += len;
2b692964 11866 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11867 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11868 break;
11869
f5f53991
AS		 11870 case 64: /* Tag_nodefaults. */
11871 p++;
2b692964 11872 printf (_("True\n"));
f5f53991
AS		 11873 break;
11874
11875 case 65: /* Tag_also_compatible_with. */
f6f0e17b 11876 val = read_uleb128 (p, &len, end);
f5f53991
AS		 11877 p += len;
11878 if (val == 6 /* Tag_CPU_arch. */)
11879 {
f6f0e17b 11880 val = read_uleb128 (p, &len, end);
f5f53991 11881 p += len;
2cf0635d 11882 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11883 printf ("??? (%d)\n", val);
11884 else
11885 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11886 }
11887 else
11888 printf ("???\n");
11889 while (*(p++) != '\0' /* NUL terminator. */);
11890 break;
11891
11c1ff18 11892 default:
2cf0635d 11893 abort ();
11c1ff18
PB		 11894 }
11895 return p;
11896
11897 case 1:
f6f0e17b 11898 return display_tag_value (-1, p, end);
11c1ff18 11899 case 2:
f6f0e17b 11900 return display_tag_value (0, p, end);
11c1ff18
PB		 11901
11902 default:
11903 assert (attr->type & 0x80);
f6f0e17b 11904 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11905 p += len;
11906 type = attr->type & 0x7f;
11907 if (val >= type)
11908 printf ("??? (%d)\n", val);
11909 else
11910 printf ("%s\n", attr->table[val]);
11911 return p;
11912 }
11913 }
11c1ff18 11914
f6f0e17b 11915 return display_tag_value (tag, p, end);
11c1ff18
PB		 11916}
11917
104d59d1 11918static unsigned char *
60bca95a 11919display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 11920 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11921 const unsigned char * const end)
104d59d1
JM		 11922{
11923 int tag;
11924 unsigned int len;
11925 int val;
104d59d1 11926
f6f0e17b 11927 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 11928 p += len;
11929
11930 /* Tag_compatibility is the only generic GNU attribute defined at
11931 present. */
11932 if (tag == 32)
11933 {
f6f0e17b 11934 val = read_uleb128 (p, &len, end);
104d59d1 11935 p += len;
f6f0e17b
NC		 11936 if (p == end)
11937 {
11938 printf (_("flag = %d, vendor = <corrupt>\n"), val);
11939 warn (_("corrupt vendor attribute\n"));
11940 }
11941 else
11942 {
11943 printf (_("flag = %d, vendor = %s\n"), val, p);
11944 p += strlen ((char *) p) + 1;
11945 }
104d59d1
JM		 11946 return p;
11947 }
11948
11949 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 11950 return display_proc_gnu_attribute (p, tag, end);
104d59d1 11951
f6f0e17b 11952 return display_tag_value (tag, p, end);
104d59d1
JM		 11953}
11954
34c8bcba 11955static unsigned char *
f6f0e17b
NC		 11956display_power_gnu_attribute (unsigned char * p,
11957 int tag,
11958 const unsigned char * const end)
34c8bcba 11959{
34c8bcba
JM		 11960 unsigned int len;
11961 int val;
11962
11963 if (tag == Tag_GNU_Power_ABI_FP)
11964 {
f6f0e17b 11965 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 11966 p += len;
11967 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11968
34c8bcba
JM		 11969 switch (val)
11970 {
11971 case 0:
2b692964 11972 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11973 break;
11974 case 1:
2b692964 11975 printf (_("Hard float\n"));
34c8bcba
JM		 11976 break;
11977 case 2:
2b692964 11978 printf (_("Soft float\n"));
34c8bcba 11979 break;
3c7b9897 11980 case 3:
2b692964 11981 printf (_("Single-precision hard float\n"));
3c7b9897 11982 break;
34c8bcba
JM		 11983 default:
11984 printf ("??? (%d)\n", val);
11985 break;
11986 }
11987 return p;
11988 }
11989
c6e65352
DJ		 11990 if (tag == Tag_GNU_Power_ABI_Vector)
11991 {
f6f0e17b 11992 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 11993 p += len;
11994 printf (" Tag_GNU_Power_ABI_Vector: ");
11995 switch (val)
11996 {
11997 case 0:
2b692964 11998 printf (_("Any\n"));
c6e65352
DJ		 11999 break;
12000 case 1:
2b692964 12001 printf (_("Generic\n"));
c6e65352
DJ		 12002 break;
12003 case 2:
12004 printf ("AltiVec\n");
12005 break;
12006 case 3:
12007 printf ("SPE\n");
12008 break;
12009 default:
12010 printf ("??? (%d)\n", val);
12011 break;
12012 }
12013 return p;
12014 }
12015
f82e0623
NF		 12016 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12017 {
f6f0e17b
NC		 12018 if (p == end)
12019 {
12020 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
12021 return p;
12022 }
0b4362b0 12023
f6f0e17b 12024 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12025 p += len;
12026 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12027 switch (val)
12028 {
12029 case 0:
2b692964 12030 printf (_("Any\n"));
f82e0623
NF		 12031 break;
12032 case 1:
12033 printf ("r3/r4\n");
12034 break;
12035 case 2:
2b692964 12036 printf (_("Memory\n"));
f82e0623
NF		 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);
34c8bcba
JM		 12046}
12047
9e8c70f9
DM		 12048static void
12049display_sparc_hwcaps (int mask)
12050{
12051 if (mask)
12052 {
12053 int first = 1;
12054 if (mask & ELF_SPARC_HWCAP_MUL32)
12055 fputs ("mul32", stdout), first = 0;
12056 if (mask & ELF_SPARC_HWCAP_DIV32)
12057 printf ("%sdiv32", first ? "" : "|"), first = 0;
12058 if (mask & ELF_SPARC_HWCAP_FSMULD)
12059 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12060 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12061 printf ("%sv8plus", first ? "" : "|"), first = 0;
12062 if (mask & ELF_SPARC_HWCAP_POPC)
12063 printf ("%spopc", first ? "" : "|"), first = 0;
12064 if (mask & ELF_SPARC_HWCAP_VIS)
12065 printf ("%svis", first ? "" : "|"), first = 0;
12066 if (mask & ELF_SPARC_HWCAP_VIS2)
12067 printf ("%svis2", first ? "" : "|"), first = 0;
12068 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12069 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12070 if (mask & ELF_SPARC_HWCAP_FMAF)
12071 printf ("%sfmaf", first ? "" : "|"), first = 0;
12072 if (mask & ELF_SPARC_HWCAP_VIS3)
12073 printf ("%svis3", first ? "" : "|"), first = 0;
12074 if (mask & ELF_SPARC_HWCAP_HPC)
12075 printf ("%shpc", first ? "" : "|"), first = 0;
12076 if (mask & ELF_SPARC_HWCAP_RANDOM)
12077 printf ("%srandom", first ? "" : "|"), first = 0;
12078 if (mask & ELF_SPARC_HWCAP_TRANS)
12079 printf ("%strans", first ? "" : "|"), first = 0;
12080 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12081 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12082 if (mask & ELF_SPARC_HWCAP_IMA)
12083 printf ("%sima", first ? "" : "|"), first = 0;
12084 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12085 printf ("%scspare", first ? "" : "|"), first = 0;
12086 }
12087 else
12088 fputc('0', stdout);
12089 fputc('\n', stdout);
12090}
12091
3d68f91c
JM		 12092static void
12093display_sparc_hwcaps2 (int mask)
12094{
12095 if (mask)
12096 {
12097 int first = 1;
12098 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12099 fputs ("fjathplus", stdout), first = 0;
12100 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12101 printf ("%svis3b", first ? "" : "|"), first = 0;
12102 if (mask & ELF_SPARC_HWCAP2_ADP)
12103 printf ("%sadp", first ? "" : "|"), first = 0;
12104 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12105 printf ("%ssparc5", first ? "" : "|"), first = 0;
12106 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12107 printf ("%smwait", first ? "" : "|"), first = 0;
12108 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12109 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12110 if (mask & ELF_SPARC_HWCAP2_XMONT)
12111 printf ("%sxmont2", first ? "" : "|"), first = 0;
12112 if (mask & ELF_SPARC_HWCAP2_NSEC)
12113 printf ("%snsec", first ? "" : "|"), first = 0;
12114 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12115 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12116 if (mask & ELF_SPARC_HWCAP2_FJDES)
12117 printf ("%sfjdes", first ? "" : "|"), first = 0;
12118 if (mask & ELF_SPARC_HWCAP2_FJAES)
12119 printf ("%sfjaes", first ? "" : "|"), first = 0;
12120 }
12121 else
12122 fputc('0', stdout);
12123 fputc('\n', stdout);
12124}
12125
9e8c70f9 12126static unsigned char *
f6f0e17b
NC		 12127display_sparc_gnu_attribute (unsigned char * p,
12128 int tag,
12129 const unsigned char * const end)
9e8c70f9 12130{
3d68f91c
JM		 12131 unsigned int len;
12132 int val;
12133
9e8c70f9
DM		 12134 if (tag == Tag_GNU_Sparc_HWCAPS)
12135 {
f6f0e17b 12136 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12137 p += len;
12138 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12139 display_sparc_hwcaps (val);
12140 return p;
3d68f91c
JM		 12141 }
12142 if (tag == Tag_GNU_Sparc_HWCAPS2)
12143 {
12144 val = read_uleb128 (p, &len, end);
12145 p += len;
12146 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12147 display_sparc_hwcaps2 (val);
12148 return p;
12149 }
9e8c70f9 12150
f6f0e17b 12151 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12152}
12153
351cdf24
MF		 12154static void
12155print_mips_fp_abi_value (int val)
12156{
12157 switch (val)
12158 {
12159 case Val_GNU_MIPS_ABI_FP_ANY:
12160 printf (_("Hard or soft float\n"));
12161 break;
12162 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12163 printf (_("Hard float (double precision)\n"));
12164 break;
12165 case Val_GNU_MIPS_ABI_FP_SINGLE:
12166 printf (_("Hard float (single precision)\n"));
12167 break;
12168 case Val_GNU_MIPS_ABI_FP_SOFT:
12169 printf (_("Soft float\n"));
12170 break;
12171 case Val_GNU_MIPS_ABI_FP_OLD_64:
12172 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12173 break;
12174 case Val_GNU_MIPS_ABI_FP_XX:
12175 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12176 break;
12177 case Val_GNU_MIPS_ABI_FP_64:
12178 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12179 break;
12180 case Val_GNU_MIPS_ABI_FP_64A:
12181 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12182 break;
12183 default:
12184 printf ("??? (%d)\n", val);
12185 break;
12186 }
12187}
12188
2cf19d5c 12189static unsigned char *
f6f0e17b
NC		 12190display_mips_gnu_attribute (unsigned char * p,
12191 int tag,
12192 const unsigned char * const end)
2cf19d5c 12193{
2cf19d5c
JM		 12194 if (tag == Tag_GNU_MIPS_ABI_FP)
12195 {
f6f0e17b
NC		 12196 unsigned int len;
12197 int val;
12198
12199 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12200 p += len;
12201 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12202
351cdf24
MF		 12203 print_mips_fp_abi_value (val);
12204
2cf19d5c
JM		 12205 return p;
12206 }
12207
a9f58168
CF		 12208 if (tag == Tag_GNU_MIPS_ABI_MSA)
12209 {
12210 unsigned int len;
12211 int val;
12212
12213 val = read_uleb128 (p, &len, end);
12214 p += len;
12215 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12216
12217 switch (val)
12218 {
12219 case Val_GNU_MIPS_ABI_MSA_ANY:
12220 printf (_("Any MSA or not\n"));
12221 break;
12222 case Val_GNU_MIPS_ABI_MSA_128:
12223 printf (_("128-bit MSA\n"));
12224 break;
12225 default:
12226 printf ("??? (%d)\n", val);
12227 break;
12228 }
12229 return p;
12230 }
12231
f6f0e17b 12232 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12233}
12234
59e6276b 12235static unsigned char *
f6f0e17b
NC		 12236display_tic6x_attribute (unsigned char * p,
12237 const unsigned char * const end)
59e6276b
JM		 12238{
12239 int tag;
12240 unsigned int len;
12241 int val;
12242
f6f0e17b 12243 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12244 p += len;
12245
12246 switch (tag)
12247 {
75fa6dc1 12248 case Tag_ISA:
f6f0e17b 12249 val = read_uleb128 (p, &len, end);
59e6276b 12250 p += len;
75fa6dc1 12251 printf (" Tag_ISA: ");
59e6276b
JM		 12252
12253 switch (val)
12254 {
75fa6dc1 12255 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12256 printf (_("None\n"));
12257 break;
75fa6dc1 12258 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12259 printf ("C62x\n");
12260 break;
75fa6dc1 12261 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12262 printf ("C67x\n");
12263 break;
75fa6dc1 12264 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12265 printf ("C67x+\n");
12266 break;
75fa6dc1 12267 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12268 printf ("C64x\n");
12269 break;
75fa6dc1 12270 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12271 printf ("C64x+\n");
12272 break;
75fa6dc1 12273 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12274 printf ("C674x\n");
12275 break;
12276 default:
12277 printf ("??? (%d)\n", val);
12278 break;
12279 }
12280 return p;
12281
87779176 12282 case Tag_ABI_wchar_t:
f6f0e17b 12283 val = read_uleb128 (p, &len, end);
87779176
JM		 12284 p += len;
12285 printf (" Tag_ABI_wchar_t: ");
12286 switch (val)
12287 {
12288 case 0:
12289 printf (_("Not used\n"));
12290 break;
12291 case 1:
12292 printf (_("2 bytes\n"));
12293 break;
12294 case 2:
12295 printf (_("4 bytes\n"));
12296 break;
12297 default:
12298 printf ("??? (%d)\n", val);
12299 break;
12300 }
12301 return p;
12302
12303 case Tag_ABI_stack_align_needed:
f6f0e17b 12304 val = read_uleb128 (p, &len, end);
87779176
JM		 12305 p += len;
12306 printf (" Tag_ABI_stack_align_needed: ");
12307 switch (val)
12308 {
12309 case 0:
12310 printf (_("8-byte\n"));
12311 break;
12312 case 1:
12313 printf (_("16-byte\n"));
12314 break;
12315 default:
12316 printf ("??? (%d)\n", val);
12317 break;
12318 }
12319 return p;
12320
12321 case Tag_ABI_stack_align_preserved:
f6f0e17b 12322 val = read_uleb128 (p, &len, end);
87779176
JM		 12323 p += len;
12324 printf (" Tag_ABI_stack_align_preserved: ");
12325 switch (val)
12326 {
12327 case 0:
12328 printf (_("8-byte\n"));
12329 break;
12330 case 1:
12331 printf (_("16-byte\n"));
12332 break;
12333 default:
12334 printf ("??? (%d)\n", val);
12335 break;
12336 }
12337 return p;
12338
b5593623 12339 case Tag_ABI_DSBT:
f6f0e17b 12340 val = read_uleb128 (p, &len, end);
b5593623
JM		 12341 p += len;
12342 printf (" Tag_ABI_DSBT: ");
12343 switch (val)
12344 {
12345 case 0:
12346 printf (_("DSBT addressing not used\n"));
12347 break;
12348 case 1:
12349 printf (_("DSBT addressing used\n"));
12350 break;
12351 default:
12352 printf ("??? (%d)\n", val);
12353 break;
12354 }
12355 return p;
12356
87779176 12357 case Tag_ABI_PID:
f6f0e17b 12358 val = read_uleb128 (p, &len, end);
87779176
JM		 12359 p += len;
12360 printf (" Tag_ABI_PID: ");
12361 switch (val)
12362 {
12363 case 0:
12364 printf (_("Data addressing position-dependent\n"));
12365 break;
12366 case 1:
12367 printf (_("Data addressing position-independent, GOT near DP\n"));
12368 break;
12369 case 2:
12370 printf (_("Data addressing position-independent, GOT far from DP\n"));
12371 break;
12372 default:
12373 printf ("??? (%d)\n", val);
12374 break;
12375 }
12376 return p;
12377
12378 case Tag_ABI_PIC:
f6f0e17b 12379 val = read_uleb128 (p, &len, end);
87779176
JM		 12380 p += len;
12381 printf (" Tag_ABI_PIC: ");
12382 switch (val)
12383 {
12384 case 0:
12385 printf (_("Code addressing position-dependent\n"));
12386 break;
12387 case 1:
12388 printf (_("Code addressing position-independent\n"));
12389 break;
12390 default:
12391 printf ("??? (%d)\n", val);
12392 break;
12393 }
12394 return p;
12395
12396 case Tag_ABI_array_object_alignment:
f6f0e17b 12397 val = read_uleb128 (p, &len, end);
87779176
JM		 12398 p += len;
12399 printf (" Tag_ABI_array_object_alignment: ");
12400 switch (val)
12401 {
12402 case 0:
12403 printf (_("8-byte\n"));
12404 break;
12405 case 1:
12406 printf (_("4-byte\n"));
12407 break;
12408 case 2:
12409 printf (_("16-byte\n"));
12410 break;
12411 default:
12412 printf ("??? (%d)\n", val);
12413 break;
12414 }
12415 return p;
12416
12417 case Tag_ABI_array_object_align_expected:
f6f0e17b 12418 val = read_uleb128 (p, &len, end);
87779176
JM		 12419 p += len;
12420 printf (" Tag_ABI_array_object_align_expected: ");
12421 switch (val)
12422 {
12423 case 0:
12424 printf (_("8-byte\n"));
12425 break;
12426 case 1:
12427 printf (_("4-byte\n"));
12428 break;
12429 case 2:
12430 printf (_("16-byte\n"));
12431 break;
12432 default:
12433 printf ("??? (%d)\n", val);
12434 break;
12435 }
12436 return p;
12437
3cbd1c06 12438 case Tag_ABI_compatibility:
f6f0e17b 12439 val = read_uleb128 (p, &len, end);
59e6276b 12440 p += len;
3cbd1c06 12441 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 12442 printf (_("flag = %d, vendor = %s\n"), val, p);
12443 p += strlen ((char *) p) + 1;
12444 return p;
87779176
JM		 12445
12446 case Tag_ABI_conformance:
12447 printf (" Tag_ABI_conformance: ");
12448 printf ("\"%s\"\n", p);
12449 p += strlen ((char *) p) + 1;
12450 return p;
59e6276b
JM		 12451 }
12452
f6f0e17b
NC		 12453 return display_tag_value (tag, p, end);
12454}
59e6276b 12455
f6f0e17b
NC		 12456static void
12457display_raw_attribute (unsigned char * p, unsigned char * end)
12458{
12459 unsigned long addr = 0;
12460 size_t bytes = end - p;
12461
e0a31db1 12462 assert (end > p);
f6f0e17b 12463 while (bytes)
87779176 12464 {
f6f0e17b
NC		 12465 int j;
12466 int k;
12467 int lbytes = (bytes > 16 ? 16 : bytes);
12468
12469 printf (" 0x%8.8lx ", addr);
12470
12471 for (j = 0; j < 16; j++)
12472 {
12473 if (j < lbytes)
12474 printf ("%2.2x", p[j]);
12475 else
12476 printf (" ");
12477
12478 if ((j & 3) == 3)
12479 printf (" ");
12480 }
12481
12482 for (j = 0; j < lbytes; j++)
12483 {
12484 k = p[j];
12485 if (k >= ' ' && k < 0x7f)
12486 printf ("%c", k);
12487 else
12488 printf (".");
12489 }
12490
12491 putchar ('\n');
12492
12493 p += lbytes;
12494 bytes -= lbytes;
12495 addr += lbytes;
87779176 12496 }
59e6276b 12497
f6f0e17b 12498 putchar ('\n');
59e6276b
JM		 12499}
12500
13761a11
NC		 12501static unsigned char *
12502display_msp430x_attribute (unsigned char * p,
12503 const unsigned char * const end)
12504{
12505 unsigned int len;
12506 int val;
12507 int tag;
12508
12509 tag = read_uleb128 (p, & len, end);
12510 p += len;
0b4362b0 12511
13761a11
NC		 12512 switch (tag)
12513 {
12514 case OFBA_MSPABI_Tag_ISA:
12515 val = read_uleb128 (p, &len, end);
12516 p += len;
12517 printf (" Tag_ISA: ");
12518 switch (val)
12519 {
12520 case 0: printf (_("None\n")); break;
12521 case 1: printf (_("MSP430\n")); break;
12522 case 2: printf (_("MSP430X\n")); break;
12523 default: printf ("??? (%d)\n", val); break;
12524 }
12525 break;
12526
12527 case OFBA_MSPABI_Tag_Code_Model:
12528 val = read_uleb128 (p, &len, end);
12529 p += len;
12530 printf (" Tag_Code_Model: ");
12531 switch (val)
12532 {
12533 case 0: printf (_("None\n")); break;
12534 case 1: printf (_("Small\n")); break;
12535 case 2: printf (_("Large\n")); break;
12536 default: printf ("??? (%d)\n", val); break;
12537 }
12538 break;
12539
12540 case OFBA_MSPABI_Tag_Data_Model:
12541 val = read_uleb128 (p, &len, end);
12542 p += len;
12543 printf (" Tag_Data_Model: ");
12544 switch (val)
12545 {
12546 case 0: printf (_("None\n")); break;
12547 case 1: printf (_("Small\n")); break;
12548 case 2: printf (_("Large\n")); break;
12549 case 3: printf (_("Restricted Large\n")); break;
12550 default: printf ("??? (%d)\n", val); break;
12551 }
12552 break;
12553
12554 default:
12555 printf (_(" <unknown tag %d>: "), tag);
12556
12557 if (tag & 1)
12558 {
12559 printf ("\"%s\"\n", p);
12560 p += strlen ((char *) p) + 1;
12561 }
12562 else
12563 {
12564 val = read_uleb128 (p, &len, end);
12565 p += len;
12566 printf ("%d (0x%x)\n", val, val);
12567 }
12568 break;
12569 }
12570
12571 return p;
12572}
12573
11c1ff18 12574static int
60bca95a
NC		 12575process_attributes (FILE * file,
12576 const char * public_name,
104d59d1 12577 unsigned int proc_type,
f6f0e17b
NC		 12578 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12579 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 12580{
2cf0635d
NC		 12581 Elf_Internal_Shdr * sect;
12582 unsigned char * contents;
12583 unsigned char * p;
12584 unsigned char * end;
11c1ff18
PB		 12585 bfd_vma section_len;
12586 bfd_vma len;
12587 unsigned i;
12588
12589 /* Find the section header so that we get the size. */
12590 for (i = 0, sect = section_headers;
12591 i < elf_header.e_shnum;
12592 i++, sect++)
12593 {
104d59d1 12594 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 12595 continue;
12596
3f5e193b
NC		 12597 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12598 sect->sh_size, _("attributes"));
60bca95a 12599 if (contents == NULL)
11c1ff18 12600 continue;
60bca95a 12601
11c1ff18
PB		 12602 p = contents;
12603 if (*p == 'A')
12604 {
12605 len = sect->sh_size - 1;
12606 p++;
60bca95a 12607
11c1ff18
PB		 12608 while (len > 0)
12609 {
e9847026 12610 unsigned int namelen;
11c1ff18 12611 bfd_boolean public_section;
104d59d1 12612 bfd_boolean gnu_section;
11c1ff18 12613
e0a31db1
NC		 12614 if (len <= 4)
12615 {
12616 error (_("Tag section ends prematurely\n"));
12617 break;
12618 }
11c1ff18
PB		 12619 section_len = byte_get (p, 4);
12620 p += 4;
60bca95a 12621
11c1ff18
PB		 12622 if (section_len > len)
12623 {
e9847026
NC		 12624 error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12625 (unsigned) section_len, (unsigned) len);
11c1ff18
PB		 12626 section_len = len;
12627 }
60bca95a 12628
11c1ff18 12629 len -= section_len;
e9847026
NC		 12630 section_len -= 4;
12631
12632 namelen = strnlen ((char *) p, section_len) + 1;
12633 if (namelen == 0 || namelen >= section_len)
12634 {
12635 error (_("Corrupt attribute section name\n"));
12636 break;
12637 }
12638
2b692964 12639 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 12640
12641 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 12642 public_section = TRUE;
12643 else
12644 public_section = FALSE;
60bca95a
NC		 12645
12646 if (streq ((char *) p, "gnu"))
104d59d1
JM		 12647 gnu_section = TRUE;
12648 else
12649 gnu_section = FALSE;
60bca95a 12650
11c1ff18 12651 p += namelen;
e9847026 12652 section_len -= namelen;
e0a31db1 12653
11c1ff18
PB		 12654 while (section_len > 0)
12655 {
e0a31db1 12656 int tag;
11c1ff18
PB		 12657 int val;
12658 bfd_vma size;
60bca95a 12659
e0a31db1
NC		 12660 /* PR binutils/17531: Safe handling of corrupt files. */
12661 if (section_len < 6)
12662 {
12663 error (_("Unused bytes at end of section\n"));
12664 section_len = 0;
12665 break;
12666 }
12667
12668 tag = *(p++);
11c1ff18
PB		 12669 size = byte_get (p, 4);
12670 if (size > section_len)
12671 {
e9847026
NC		 12672 error (_("Bad subsection length (%u > %u)\n"),
12673 (unsigned) size, (unsigned) section_len);
11c1ff18
PB		 12674 size = section_len;
12675 }
e0a31db1
NC		 12676 /* PR binutils/17531: Safe handling of corrupt files. */
12677 if (size < 6)
12678 {
12679 error (_("Bad subsection length (%u < 6)\n"),
12680 (unsigned) size);
12681 section_len = 0;
12682 break;
12683 }
60bca95a 12684
11c1ff18
PB		 12685 section_len -= size;
12686 end = p + size - 1;
12687 p += 4;
60bca95a 12688
11c1ff18
PB		 12689 switch (tag)
12690 {
12691 case 1:
2b692964 12692 printf (_("File Attributes\n"));
11c1ff18
PB		 12693 break;
12694 case 2:
2b692964 12695 printf (_("Section Attributes:"));
11c1ff18
PB		 12696 goto do_numlist;
12697 case 3:
2b692964 12698 printf (_("Symbol Attributes:"));
11c1ff18
PB		 12699 do_numlist:
12700 for (;;)
12701 {
91d6fa6a 12702 unsigned int j;
60bca95a 12703
f6f0e17b 12704 val = read_uleb128 (p, &j, end);
91d6fa6a 12705 p += j;
11c1ff18
PB		 12706 if (val == 0)
12707 break;
12708 printf (" %d", val);
12709 }
12710 printf ("\n");
12711 break;
12712 default:
2b692964 12713 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 12714 public_section = FALSE;
12715 break;
12716 }
60bca95a 12717
11c1ff18
PB		 12718 if (public_section)
12719 {
12720 while (p < end)
f6f0e17b 12721 p = display_pub_attribute (p, end);
104d59d1
JM		 12722 }
12723 else if (gnu_section)
12724 {
12725 while (p < end)
12726 p = display_gnu_attribute (p,
f6f0e17b
NC		 12727 display_proc_gnu_attribute,
12728 end);
11c1ff18
PB		 12729 }
12730 else
12731 {
2b692964 12732 printf (_(" Unknown section contexts\n"));
f6f0e17b 12733 display_raw_attribute (p, end);
11c1ff18
PB		 12734 p = end;
12735 }
12736 }
12737 }
12738 }
12739 else
e9847026 12740 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 12741
60bca95a 12742 free (contents);
11c1ff18
PB		 12743 }
12744 return 1;
12745}
12746
104d59d1 12747static int
2cf0635d 12748process_arm_specific (FILE * file)
104d59d1
JM		 12749{
12750 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12751 display_arm_attribute, NULL);
12752}
12753
34c8bcba 12754static int
2cf0635d 12755process_power_specific (FILE * file)
34c8bcba
JM		 12756{
12757 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12758 display_power_gnu_attribute);
12759}
12760
9e8c70f9
DM		 12761static int
12762process_sparc_specific (FILE * file)
12763{
12764 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12765 display_sparc_gnu_attribute);
12766}
12767
59e6276b
JM		 12768static int
12769process_tic6x_specific (FILE * file)
12770{
12771 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12772 display_tic6x_attribute, NULL);
12773}
12774
13761a11
NC		 12775static int
12776process_msp430x_specific (FILE * file)
12777{
12778 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12779 display_msp430x_attribute, NULL);
12780}
12781
ccb4c951
RS		 12782/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12783 Print the Address, Access and Initial fields of an entry at VMA ADDR
12784 and return the VMA of the next entry. */
12785
12786static bfd_vma
2cf0635d 12787print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 12788{
12789 printf (" ");
12790 print_vma (addr, LONG_HEX);
12791 printf (" ");
12792 if (addr < pltgot + 0xfff0)
12793 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12794 else
12795 printf ("%10s", "");
12796 printf (" ");
12797 if (data == NULL)
2b692964 12798 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 12799 else
12800 {
12801 bfd_vma entry;
12802
12803 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12804 print_vma (entry, LONG_HEX);
12805 }
12806 return addr + (is_32bit_elf ? 4 : 8);
12807}
12808
861fb55a
DJ		 12809/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12810 PLTGOT. Print the Address and Initial fields of an entry at VMA
12811 ADDR and return the VMA of the next entry. */
12812
12813static bfd_vma
2cf0635d 12814print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 12815{
12816 printf (" ");
12817 print_vma (addr, LONG_HEX);
12818 printf (" ");
12819 if (data == NULL)
2b692964 12820 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 12821 else
12822 {
12823 bfd_vma entry;
12824
12825 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12826 print_vma (entry, LONG_HEX);
12827 }
12828 return addr + (is_32bit_elf ? 4 : 8);
12829}
12830
351cdf24
MF		 12831static void
12832print_mips_ases (unsigned int mask)
12833{
12834 if (mask & AFL_ASE_DSP)
12835 fputs ("\n\tDSP ASE", stdout);
12836 if (mask & AFL_ASE_DSPR2)
12837 fputs ("\n\tDSP R2 ASE", stdout);
12838 if (mask & AFL_ASE_EVA)
12839 fputs ("\n\tEnhanced VA Scheme", stdout);
12840 if (mask & AFL_ASE_MCU)
12841 fputs ("\n\tMCU (MicroController) ASE", stdout);
12842 if (mask & AFL_ASE_MDMX)
12843 fputs ("\n\tMDMX ASE", stdout);
12844 if (mask & AFL_ASE_MIPS3D)
12845 fputs ("\n\tMIPS-3D ASE", stdout);
12846 if (mask & AFL_ASE_MT)
12847 fputs ("\n\tMT ASE", stdout);
12848 if (mask & AFL_ASE_SMARTMIPS)
12849 fputs ("\n\tSmartMIPS ASE", stdout);
12850 if (mask & AFL_ASE_VIRT)
12851 fputs ("\n\tVZ ASE", stdout);
12852 if (mask & AFL_ASE_MSA)
12853 fputs ("\n\tMSA ASE", stdout);
12854 if (mask & AFL_ASE_MIPS16)
12855 fputs ("\n\tMIPS16 ASE", stdout);
12856 if (mask & AFL_ASE_MICROMIPS)
12857 fputs ("\n\tMICROMIPS ASE", stdout);
12858 if (mask & AFL_ASE_XPA)
12859 fputs ("\n\tXPA ASE", stdout);
12860 if (mask == 0)
12861 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 12862 else if ((mask & ~AFL_ASE_MASK) != 0)
12863 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 12864}
12865
12866static void
12867print_mips_isa_ext (unsigned int isa_ext)
12868{
12869 switch (isa_ext)
12870 {
12871 case 0:
12872 fputs (_("None"), stdout);
12873 break;
12874 case AFL_EXT_XLR:
12875 fputs ("RMI XLR", stdout);
12876 break;
2c629856
N		 12877 case AFL_EXT_OCTEON3:
12878 fputs ("Cavium Networks Octeon3", stdout);
12879 break;
351cdf24
MF		 12880 case AFL_EXT_OCTEON2:
12881 fputs ("Cavium Networks Octeon2", stdout);
12882 break;
12883 case AFL_EXT_OCTEONP:
12884 fputs ("Cavium Networks OcteonP", stdout);
12885 break;
12886 case AFL_EXT_LOONGSON_3A:
12887 fputs ("Loongson 3A", stdout);
12888 break;
12889 case AFL_EXT_OCTEON:
12890 fputs ("Cavium Networks Octeon", stdout);
12891 break;
12892 case AFL_EXT_5900:
12893 fputs ("Toshiba R5900", stdout);
12894 break;
12895 case AFL_EXT_4650:
12896 fputs ("MIPS R4650", stdout);
12897 break;
12898 case AFL_EXT_4010:
12899 fputs ("LSI R4010", stdout);
12900 break;
12901 case AFL_EXT_4100:
12902 fputs ("NEC VR4100", stdout);
12903 break;
12904 case AFL_EXT_3900:
12905 fputs ("Toshiba R3900", stdout);
12906 break;
12907 case AFL_EXT_10000:
12908 fputs ("MIPS R10000", stdout);
12909 break;
12910 case AFL_EXT_SB1:
12911 fputs ("Broadcom SB-1", stdout);
12912 break;
12913 case AFL_EXT_4111:
12914 fputs ("NEC VR4111/VR4181", stdout);
12915 break;
12916 case AFL_EXT_4120:
12917 fputs ("NEC VR4120", stdout);
12918 break;
12919 case AFL_EXT_5400:
12920 fputs ("NEC VR5400", stdout);
12921 break;
12922 case AFL_EXT_5500:
12923 fputs ("NEC VR5500", stdout);
12924 break;
12925 case AFL_EXT_LOONGSON_2E:
12926 fputs ("ST Microelectronics Loongson 2E", stdout);
12927 break;
12928 case AFL_EXT_LOONGSON_2F:
12929 fputs ("ST Microelectronics Loongson 2F", stdout);
12930 break;
12931 default:
00ac7aa0 12932 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 12933 }
12934}
12935
12936static int
12937get_mips_reg_size (int reg_size)
12938{
12939 return (reg_size == AFL_REG_NONE) ? 0
12940 : (reg_size == AFL_REG_32) ? 32
12941 : (reg_size == AFL_REG_64) ? 64
12942 : (reg_size == AFL_REG_128) ? 128
12943 : -1;
12944}
12945
19e6b90e 12946static int
2cf0635d 12947process_mips_specific (FILE * file)
5b18a4bc 12948{
2cf0635d 12949 Elf_Internal_Dyn * entry;
351cdf24 12950 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 12951 size_t liblist_offset = 0;
12952 size_t liblistno = 0;
12953 size_t conflictsno = 0;
12954 size_t options_offset = 0;
12955 size_t conflicts_offset = 0;
861fb55a
DJ		 12956 size_t pltrelsz = 0;
12957 size_t pltrel = 0;
ccb4c951 12958 bfd_vma pltgot = 0;
861fb55a
DJ		 12959 bfd_vma mips_pltgot = 0;
12960 bfd_vma jmprel = 0;
ccb4c951
RS		 12961 bfd_vma local_gotno = 0;
12962 bfd_vma gotsym = 0;
12963 bfd_vma symtabno = 0;
103f02d3 12964
2cf19d5c
JM		 12965 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12966 display_mips_gnu_attribute);
12967
351cdf24
MF		 12968 sect = find_section (".MIPS.abiflags");
12969
12970 if (sect != NULL)
12971 {
12972 Elf_External_ABIFlags_v0 *abiflags_ext;
12973 Elf_Internal_ABIFlags_v0 abiflags_in;
12974
12975 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
12976 fputs ("\nCorrupt ABI Flags section.\n", stdout);
12977 else
12978 {
12979 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
12980 sect->sh_size, _("MIPS ABI Flags section"));
12981 if (abiflags_ext)
12982 {
12983 abiflags_in.version = BYTE_GET (abiflags_ext->version);
12984 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
12985 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
12986 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
12987 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
12988 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
12989 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
12990 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
12991 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
12992 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
12993 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
12994
12995 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
12996 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
12997 if (abiflags_in.isa_rev > 1)
12998 printf ("r%d", abiflags_in.isa_rev);
12999 printf ("\nGPR size: %d",
13000 get_mips_reg_size (abiflags_in.gpr_size));
13001 printf ("\nCPR1 size: %d",
13002 get_mips_reg_size (abiflags_in.cpr1_size));
13003 printf ("\nCPR2 size: %d",
13004 get_mips_reg_size (abiflags_in.cpr2_size));
13005 fputs ("\nFP ABI: ", stdout);
13006 print_mips_fp_abi_value (abiflags_in.fp_abi);
13007 fputs ("ISA Extension: ", stdout);
13008 print_mips_isa_ext (abiflags_in.isa_ext);
13009 fputs ("\nASEs:", stdout);
13010 print_mips_ases (abiflags_in.ases);
13011 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13012 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13013 fputc ('\n', stdout);
13014 free (abiflags_ext);
13015 }
13016 }
13017 }
13018
19e6b90e
L		 13019 /* We have a lot of special sections. Thanks SGI! */
13020 if (dynamic_section == NULL)
13021 /* No information available. */
13022 return 0;
252b5132 13023
b2d38a17 13024 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 13025 switch (entry->d_tag)
13026 {
13027 case DT_MIPS_LIBLIST:
d93f0186
NC		 13028 liblist_offset
13029 = offset_from_vma (file, entry->d_un.d_val,
13030 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13031 break;
13032 case DT_MIPS_LIBLISTNO:
13033 liblistno = entry->d_un.d_val;
13034 break;
13035 case DT_MIPS_OPTIONS:
d93f0186 13036 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13037 break;
13038 case DT_MIPS_CONFLICT:
d93f0186
NC		 13039 conflicts_offset
13040 = offset_from_vma (file, entry->d_un.d_val,
13041 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13042 break;
13043 case DT_MIPS_CONFLICTNO:
13044 conflictsno = entry->d_un.d_val;
13045 break;
ccb4c951 13046 case DT_PLTGOT:
861fb55a
DJ		 13047 pltgot = entry->d_un.d_ptr;
13048 break;
ccb4c951
RS		 13049 case DT_MIPS_LOCAL_GOTNO:
13050 local_gotno = entry->d_un.d_val;
13051 break;
13052 case DT_MIPS_GOTSYM:
13053 gotsym = entry->d_un.d_val;
13054 break;
13055 case DT_MIPS_SYMTABNO:
13056 symtabno = entry->d_un.d_val;
13057 break;
861fb55a
DJ		 13058 case DT_MIPS_PLTGOT:
13059 mips_pltgot = entry->d_un.d_ptr;
13060 break;
13061 case DT_PLTREL:
13062 pltrel = entry->d_un.d_val;
13063 break;
13064 case DT_PLTRELSZ:
13065 pltrelsz = entry->d_un.d_val;
13066 break;
13067 case DT_JMPREL:
13068 jmprel = entry->d_un.d_ptr;
13069 break;
252b5132
RH		 13070 default:
13071 break;
13072 }
13073
13074 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13075 {
2cf0635d 13076 Elf32_External_Lib * elib;
252b5132
RH		 13077 size_t cnt;
13078
3f5e193b
NC		 13079 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13080 liblistno,
13081 sizeof (Elf32_External_Lib),
9cf03b7e 13082 _("liblist section data"));
a6e9f9df 13083 if (elib)
252b5132 13084 {
2b692964 13085 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13086 (unsigned long) liblistno);
2b692964 13087 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13088 stdout);
13089
13090 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13091 {
a6e9f9df 13092 Elf32_Lib liblist;
91d6fa6a 13093 time_t atime;
a6e9f9df 13094 char timebuf[20];
2cf0635d 13095 struct tm * tmp;
a6e9f9df
AM		 13096
13097 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13098 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13099 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13100 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13101 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13102
91d6fa6a 13103 tmp = gmtime (&atime);
e9e44622
JJ		 13104 snprintf (timebuf, sizeof (timebuf),
13105 "%04u-%02u-%02uT%02u:%02u:%02u",
13106 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13107 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13108
31104126 13109 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13110 if (VALID_DYNAMIC_NAME (liblist.l_name))
13111 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13112 else
2b692964 13113 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13114 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13115 liblist.l_version);
a6e9f9df
AM		 13116
13117 if (liblist.l_flags == 0)
2b692964 13118 puts (_(" NONE"));
a6e9f9df
AM		 13119 else
13120 {
13121 static const struct
252b5132 13122 {
2cf0635d 13123 const char * name;
a6e9f9df 13124 int bit;
252b5132 13125 }
a6e9f9df
AM		 13126 l_flags_vals[] =
13127 {
13128 { " EXACT_MATCH", LL_EXACT_MATCH },
13129 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13130 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13131 { " EXPORTS", LL_EXPORTS },
13132 { " DELAY_LOAD", LL_DELAY_LOAD },
13133 { " DELTA", LL_DELTA }
13134 };
13135 int flags = liblist.l_flags;
13136 size_t fcnt;
13137
60bca95a 13138 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13139 if ((flags & l_flags_vals[fcnt].bit) != 0)
13140 {
13141 fputs (l_flags_vals[fcnt].name, stdout);
13142 flags ^= l_flags_vals[fcnt].bit;
13143 }
13144 if (flags != 0)
13145 printf (" %#x", (unsigned int) flags);
252b5132 13146
a6e9f9df
AM		 13147 puts ("");
13148 }
252b5132 13149 }
252b5132 13150
a6e9f9df
AM		 13151 free (elib);
13152 }
252b5132
RH		 13153 }
13154
13155 if (options_offset != 0)
13156 {
2cf0635d 13157 Elf_External_Options * eopt;
2cf0635d
NC		 13158 Elf_Internal_Options * iopt;
13159 Elf_Internal_Options * option;
252b5132
RH		 13160 size_t offset;
13161 int cnt;
351cdf24 13162 sect = section_headers;
252b5132
RH		 13163
13164 /* Find the section header so that we get the size. */
13165 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 13166 ++sect;
252b5132 13167
3f5e193b
NC		 13168 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13169 sect->sh_size, _("options"));
a6e9f9df 13170 if (eopt)
252b5132 13171 {
3f5e193b
NC		 13172 iopt = (Elf_Internal_Options *)
13173 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13174 if (iopt == NULL)
13175 {
591a748a 13176 error (_("Out of memory\n"));
a6e9f9df
AM		 13177 return 0;
13178 }
76da6bbe 13179
a6e9f9df
AM		 13180 offset = cnt = 0;
13181 option = iopt;
252b5132 13182
a6e9f9df
AM		 13183 while (offset < sect->sh_size)
13184 {
2cf0635d 13185 Elf_External_Options * eoption;
252b5132 13186
a6e9f9df 13187 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13188
a6e9f9df
AM		 13189 option->kind = BYTE_GET (eoption->kind);
13190 option->size = BYTE_GET (eoption->size);
13191 option->section = BYTE_GET (eoption->section);
13192 option->info = BYTE_GET (eoption->info);
76da6bbe 13193
a6e9f9df 13194 offset += option->size;
252b5132 13195
a6e9f9df
AM		 13196 ++option;
13197 ++cnt;
13198 }
252b5132 13199
a6e9f9df
AM		 13200 printf (_("\nSection '%s' contains %d entries:\n"),
13201 SECTION_NAME (sect), cnt);
76da6bbe 13202
a6e9f9df 13203 option = iopt;
252b5132 13204
a6e9f9df 13205 while (cnt-- > 0)
252b5132 13206 {
a6e9f9df
AM		 13207 size_t len;
13208
13209 switch (option->kind)
252b5132 13210 {
a6e9f9df
AM		 13211 case ODK_NULL:
13212 /* This shouldn't happen. */
13213 printf (" NULL %d %lx", option->section, option->info);
13214 break;
13215 case ODK_REGINFO:
13216 printf (" REGINFO ");
13217 if (elf_header.e_machine == EM_MIPS)
13218 {
13219 /* 32bit form. */
2cf0635d 13220 Elf32_External_RegInfo * ereg;
b34976b6 13221 Elf32_RegInfo reginfo;
a6e9f9df
AM		 13222
13223 ereg = (Elf32_External_RegInfo *) (option + 1);
13224 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13225 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13226 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13227 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13228 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13229 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13230
13231 printf ("GPR %08lx GP 0x%lx\n",
13232 reginfo.ri_gprmask,
13233 (unsigned long) reginfo.ri_gp_value);
13234 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13235 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13236 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13237 }
13238 else
13239 {
13240 /* 64 bit form. */
2cf0635d 13241 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 13242 Elf64_Internal_RegInfo reginfo;
13243
13244 ereg = (Elf64_External_RegInfo *) (option + 1);
13245 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13246 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13247 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13248 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13249 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 13250 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 13251
13252 printf ("GPR %08lx GP 0x",
13253 reginfo.ri_gprmask);
13254 printf_vma (reginfo.ri_gp_value);
13255 printf ("\n");
13256
13257 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13258 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13259 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13260 }
13261 ++option;
13262 continue;
13263 case ODK_EXCEPTIONS:
13264 fputs (" EXCEPTIONS fpe_min(", stdout);
13265 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13266 fputs (") fpe_max(", stdout);
13267 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13268 fputs (")", stdout);
13269
13270 if (option->info & OEX_PAGE0)
13271 fputs (" PAGE0", stdout);
13272 if (option->info & OEX_SMM)
13273 fputs (" SMM", stdout);
13274 if (option->info & OEX_FPDBUG)
13275 fputs (" FPDBUG", stdout);
13276 if (option->info & OEX_DISMISS)
13277 fputs (" DISMISS", stdout);
13278 break;
13279 case ODK_PAD:
13280 fputs (" PAD ", stdout);
13281 if (option->info & OPAD_PREFIX)
13282 fputs (" PREFIX", stdout);
13283 if (option->info & OPAD_POSTFIX)
13284 fputs (" POSTFIX", stdout);
13285 if (option->info & OPAD_SYMBOL)
13286 fputs (" SYMBOL", stdout);
13287 break;
13288 case ODK_HWPATCH:
13289 fputs (" HWPATCH ", stdout);
13290 if (option->info & OHW_R4KEOP)
13291 fputs (" R4KEOP", stdout);
13292 if (option->info & OHW_R8KPFETCH)
13293 fputs (" R8KPFETCH", stdout);
13294 if (option->info & OHW_R5KEOP)
13295 fputs (" R5KEOP", stdout);
13296 if (option->info & OHW_R5KCVTL)
13297 fputs (" R5KCVTL", stdout);
13298 break;
13299 case ODK_FILL:
13300 fputs (" FILL ", stdout);
13301 /* XXX Print content of info word? */
13302 break;
13303 case ODK_TAGS:
13304 fputs (" TAGS ", stdout);
13305 /* XXX Print content of info word? */
13306 break;
13307 case ODK_HWAND:
13308 fputs (" HWAND ", stdout);
13309 if (option->info & OHWA0_R4KEOP_CHECKED)
13310 fputs (" R4KEOP_CHECKED", stdout);
13311 if (option->info & OHWA0_R4KEOP_CLEAN)
13312 fputs (" R4KEOP_CLEAN", stdout);
13313 break;
13314 case ODK_HWOR:
13315 fputs (" HWOR ", stdout);
13316 if (option->info & OHWA0_R4KEOP_CHECKED)
13317 fputs (" R4KEOP_CHECKED", stdout);
13318 if (option->info & OHWA0_R4KEOP_CLEAN)
13319 fputs (" R4KEOP_CLEAN", stdout);
13320 break;
13321 case ODK_GP_GROUP:
13322 printf (" GP_GROUP %#06lx self-contained %#06lx",
13323 option->info & OGP_GROUP,
13324 (option->info & OGP_SELF) >> 16);
13325 break;
13326 case ODK_IDENT:
13327 printf (" IDENT %#06lx self-contained %#06lx",
13328 option->info & OGP_GROUP,
13329 (option->info & OGP_SELF) >> 16);
13330 break;
13331 default:
13332 /* This shouldn't happen. */
13333 printf (" %3d ??? %d %lx",
13334 option->kind, option->section, option->info);
13335 break;
252b5132 13336 }
a6e9f9df 13337
2cf0635d 13338 len = sizeof (* eopt);
a6e9f9df
AM		 13339 while (len < option->size)
13340 if (((char *) option)[len] >= ' '
13341 && ((char *) option)[len] < 0x7f)
13342 printf ("%c", ((char *) option)[len++]);
13343 else
13344 printf ("\\%03o", ((char *) option)[len++]);
13345
13346 fputs ("\n", stdout);
252b5132 13347 ++option;
252b5132
RH		 13348 }
13349
a6e9f9df 13350 free (eopt);
252b5132 13351 }
252b5132
RH		 13352 }
13353
13354 if (conflicts_offset != 0 && conflictsno != 0)
13355 {
2cf0635d 13356 Elf32_Conflict * iconf;
252b5132
RH		 13357 size_t cnt;
13358
13359 if (dynamic_symbols == NULL)
13360 {
591a748a 13361 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 13362 return 0;
13363 }
13364
3f5e193b 13365 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 13366 if (iconf == NULL)
13367 {
591a748a 13368 error (_("Out of memory\n"));
252b5132
RH		 13369 return 0;
13370 }
13371
9ea033b2 13372 if (is_32bit_elf)
252b5132 13373 {
2cf0635d 13374 Elf32_External_Conflict * econf32;
a6e9f9df 13375
3f5e193b
NC		 13376 econf32 = (Elf32_External_Conflict *)
13377 get_data (NULL, file, conflicts_offset, conflictsno,
13378 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 13379 if (!econf32)
13380 return 0;
252b5132
RH		 13381
13382 for (cnt = 0; cnt < conflictsno; ++cnt)
13383 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 13384
13385 free (econf32);
252b5132
RH		 13386 }
13387 else
13388 {
2cf0635d 13389 Elf64_External_Conflict * econf64;
a6e9f9df 13390
3f5e193b
NC		 13391 econf64 = (Elf64_External_Conflict *)
13392 get_data (NULL, file, conflicts_offset, conflictsno,
13393 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 13394 if (!econf64)
13395 return 0;
252b5132
RH		 13396
13397 for (cnt = 0; cnt < conflictsno; ++cnt)
13398 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 13399
13400 free (econf64);
252b5132
RH		 13401 }
13402
c7e7ca54
NC		 13403 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13404 (unsigned long) conflictsno);
252b5132
RH		 13405 puts (_(" Num: Index Value Name"));
13406
13407 for (cnt = 0; cnt < conflictsno; ++cnt)
13408 {
b34976b6 13409 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 13410
13411 if (iconf[cnt] >= num_dynamic_syms)
13412 printf (_("<corrupt symbol index>"));
d79b3d50 13413 else
e0a31db1
NC		 13414 {
13415 Elf_Internal_Sym * psym;
13416
13417 psym = & dynamic_symbols[iconf[cnt]];
13418 print_vma (psym->st_value, FULL_HEX);
13419 putchar (' ');
13420 if (VALID_DYNAMIC_NAME (psym->st_name))
13421 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13422 else
13423 printf (_("<corrupt: %14ld>"), psym->st_name);
13424 }
31104126 13425 putchar ('\n');
252b5132
RH		 13426 }
13427
252b5132
RH		 13428 free (iconf);
13429 }
13430
ccb4c951
RS		 13431 if (pltgot != 0 && local_gotno != 0)
13432 {
91d6fa6a 13433 bfd_vma ent, local_end, global_end;
bbeee7ea 13434 size_t i, offset;
2cf0635d 13435 unsigned char * data;
bbeee7ea 13436 int addr_size;
ccb4c951 13437
91d6fa6a 13438 ent = pltgot;
ccb4c951
RS		 13439 addr_size = (is_32bit_elf ? 4 : 8);
13440 local_end = pltgot + local_gotno * addr_size;
13441 global_end = local_end + (symtabno - gotsym) * addr_size;
13442
13443 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 13444 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 13445 global_end - pltgot, 1,
13446 _("Global Offset Table data"));
59245841
NC		 13447 if (data == NULL)
13448 return 0;
13449
ccb4c951
RS		 13450 printf (_("\nPrimary GOT:\n"));
13451 printf (_(" Canonical gp value: "));
13452 print_vma (pltgot + 0x7ff0, LONG_HEX);
13453 printf ("\n\n");
13454
13455 printf (_(" Reserved entries:\n"));
13456 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 13457 addr_size * 2, _("Address"), _("Access"),
13458 addr_size * 2, _("Initial"));
91d6fa6a 13459 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13460 printf (_(" Lazy resolver\n"));
ccb4c951 13461 if (data
91d6fa6a 13462 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 13463 >> (addr_size * 8 - 1)) != 0)
13464 {
91d6fa6a 13465 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13466 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 13467 }
13468 printf ("\n");
13469
91d6fa6a 13470 if (ent < local_end)
ccb4c951
RS		 13471 {
13472 printf (_(" Local entries:\n"));
cc5914eb 13473 printf (" %*s %10s %*s\n",
2b692964
NC		 13474 addr_size * 2, _("Address"), _("Access"),
13475 addr_size * 2, _("Initial"));
91d6fa6a 13476 while (ent < local_end)
ccb4c951 13477 {
91d6fa6a 13478 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 13479 printf ("\n");
13480 }
13481 printf ("\n");
13482 }
13483
13484 if (gotsym < symtabno)
13485 {
13486 int sym_width;
13487
13488 printf (_(" Global entries:\n"));
cc5914eb 13489 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 13490 addr_size * 2, _("Address"),
13491 _("Access"),
2b692964 13492 addr_size * 2, _("Initial"),
9cf03b7e
NC		 13493 addr_size * 2, _("Sym.Val."),
13494 _("Type"),
13495 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13496 _("Ndx"), _("Name"));
0b4362b0 13497
ccb4c951 13498 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 13499
ccb4c951
RS		 13500 for (i = gotsym; i < symtabno; i++)
13501 {
91d6fa6a 13502 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951 13503 printf (" ");
e0a31db1
NC		 13504
13505 if (dynamic_symbols == NULL)
13506 printf (_("<no dynamic symbols>"));
13507 else if (i < num_dynamic_syms)
13508 {
13509 Elf_Internal_Sym * psym = dynamic_symbols + i;
13510
13511 print_vma (psym->st_value, LONG_HEX);
13512 printf (" %-7s %3s ",
13513 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13514 get_symbol_index_type (psym->st_shndx));
13515
13516 if (VALID_DYNAMIC_NAME (psym->st_name))
13517 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13518 else
13519 printf (_("<corrupt: %14ld>"), psym->st_name);
13520 }
ccb4c951 13521 else
e0a31db1
NC		 13522 printf (_("<symbol index %lu exceeds number of dynamic symbols>"), i);
13523
ccb4c951
RS		 13524 printf ("\n");
13525 }
13526 printf ("\n");
13527 }
13528
13529 if (data)
13530 free (data);
13531 }
13532
861fb55a
DJ		 13533 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13534 {
91d6fa6a 13535 bfd_vma ent, end;
861fb55a
DJ		 13536 size_t offset, rel_offset;
13537 unsigned long count, i;
2cf0635d 13538 unsigned char * data;
861fb55a 13539 int addr_size, sym_width;
2cf0635d 13540 Elf_Internal_Rela * rels;
861fb55a
DJ		 13541
13542 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13543 if (pltrel == DT_RELA)
13544 {
13545 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13546 return 0;
13547 }
13548 else
13549 {
13550 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13551 return 0;
13552 }
13553
91d6fa6a 13554 ent = mips_pltgot;
861fb55a
DJ		 13555 addr_size = (is_32bit_elf ? 4 : 8);
13556 end = mips_pltgot + (2 + count) * addr_size;
13557
13558 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 13559 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 13560 1, _("Procedure Linkage Table data"));
59245841
NC		 13561 if (data == NULL)
13562 return 0;
13563
9cf03b7e 13564 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 13565 printf (_(" Reserved entries:\n"));
13566 printf (_(" %*s %*s Purpose\n"),
2b692964 13567 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 13568 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 13569 printf (_(" PLT lazy resolver\n"));
91d6fa6a 13570 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 13571 printf (_(" Module pointer\n"));
861fb55a
DJ		 13572 printf ("\n");
13573
13574 printf (_(" Entries:\n"));
cc5914eb 13575 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 13576 addr_size * 2, _("Address"),
13577 addr_size * 2, _("Initial"),
13578 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 13579 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13580 for (i = 0; i < count; i++)
13581 {
e0a31db1 13582 unsigned long index = get_reloc_symindex (rels[i].r_info);
861fb55a 13583
91d6fa6a 13584 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 13585 printf (" ");
e0a31db1
NC		 13586
13587 if (index >= num_dynamic_syms)
13588 printf (_("<corrupt symbol index: %lu>"), index);
861fb55a 13589 else
e0a31db1
NC		 13590 {
13591 Elf_Internal_Sym * psym = dynamic_symbols + index;
13592
13593 print_vma (psym->st_value, LONG_HEX);
13594 printf (" %-7s %3s ",
13595 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13596 get_symbol_index_type (psym->st_shndx));
13597 if (VALID_DYNAMIC_NAME (psym->st_name))
13598 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13599 else
13600 printf (_("<corrupt: %14ld>"), psym->st_name);
13601 }
861fb55a
DJ		 13602 printf ("\n");
13603 }
13604 printf ("\n");
13605
13606 if (data)
13607 free (data);
13608 free (rels);
13609 }
13610
252b5132
RH		 13611 return 1;
13612}
13613
35c08157
KLC		 13614static int
13615process_nds32_specific (FILE * file)
13616{
13617 Elf_Internal_Shdr *sect = NULL;
13618
13619 sect = find_section (".nds32_e_flags");
13620 if (sect != NULL)
13621 {
13622 unsigned int *flag;
13623
13624 printf ("\nNDS32 elf flags section:\n");
13625 flag = get_data (NULL, file, sect->sh_offset, 1,
13626 sect->sh_size, _("NDS32 elf flags section"));
13627
13628 switch ((*flag) & 0x3)
13629 {
13630 case 0:
13631 printf ("(VEC_SIZE):\tNo entry.\n");
13632 break;
13633 case 1:
13634 printf ("(VEC_SIZE):\t4 bytes\n");
13635 break;
13636 case 2:
13637 printf ("(VEC_SIZE):\t16 bytes\n");
13638 break;
13639 case 3:
13640 printf ("(VEC_SIZE):\treserved\n");
13641 break;
13642 }
13643 }
13644
13645 return TRUE;
13646}
13647
047b2264 13648static int
2cf0635d 13649process_gnu_liblist (FILE * file)
047b2264 13650{
2cf0635d
NC		 13651 Elf_Internal_Shdr * section;
13652 Elf_Internal_Shdr * string_sec;
13653 Elf32_External_Lib * elib;
13654 char * strtab;
c256ffe7 13655 size_t strtab_size;
047b2264
JJ		 13656 size_t cnt;
13657 unsigned i;
13658
13659 if (! do_arch)
13660 return 0;
13661
13662 for (i = 0, section = section_headers;
13663 i < elf_header.e_shnum;
b34976b6 13664 i++, section++)
047b2264
JJ		 13665 {
13666 switch (section->sh_type)
13667 {
13668 case SHT_GNU_LIBLIST:
4fbb74a6 13669 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 13670 break;
13671
3f5e193b
NC		 13672 elib = (Elf32_External_Lib *)
13673 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 13674 _("liblist section data"));
047b2264
JJ		 13675
13676 if (elib == NULL)
13677 break;
4fbb74a6 13678 string_sec = section_headers + section->sh_link;
047b2264 13679
3f5e193b
NC		 13680 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13681 string_sec->sh_size,
13682 _("liblist string table"));
047b2264
JJ		 13683 if (strtab == NULL
13684 || section->sh_entsize != sizeof (Elf32_External_Lib))
13685 {
13686 free (elib);
2842702f 13687 free (strtab);
047b2264
JJ		 13688 break;
13689 }
59245841 13690 strtab_size = string_sec->sh_size;
047b2264
JJ		 13691
13692 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13693 SECTION_NAME (section),
0af1713e 13694 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 13695
2b692964 13696 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 13697
13698 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13699 ++cnt)
13700 {
13701 Elf32_Lib liblist;
91d6fa6a 13702 time_t atime;
047b2264 13703 char timebuf[20];
2cf0635d 13704 struct tm * tmp;
047b2264
JJ		 13705
13706 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13707 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 13708 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13709 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13710 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13711
91d6fa6a 13712 tmp = gmtime (&atime);
e9e44622
JJ		 13713 snprintf (timebuf, sizeof (timebuf),
13714 "%04u-%02u-%02uT%02u:%02u:%02u",
13715 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13716 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 13717
13718 printf ("%3lu: ", (unsigned long) cnt);
13719 if (do_wide)
c256ffe7 13720 printf ("%-20s", liblist.l_name < strtab_size
2b692964 13721 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 13722 else
c256ffe7 13723 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 13724 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 13725 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13726 liblist.l_version, liblist.l_flags);
13727 }
13728
13729 free (elib);
2842702f 13730 free (strtab);
047b2264
JJ		 13731 }
13732 }
13733
13734 return 1;
13735}
13736
9437c45b 13737static const char *
d3ba0551 13738get_note_type (unsigned e_type)
779fe533
NC		 13739{
13740 static char buff[64];
103f02d3 13741
1ec5cd37
NC		 13742 if (elf_header.e_type == ET_CORE)
13743 switch (e_type)
13744 {
57346661 13745 case NT_AUXV:
1ec5cd37 13746 return _("NT_AUXV (auxiliary vector)");
57346661 13747 case NT_PRSTATUS:
1ec5cd37 13748 return _("NT_PRSTATUS (prstatus structure)");
57346661 13749 case NT_FPREGSET:
1ec5cd37 13750 return _("NT_FPREGSET (floating point registers)");
57346661 13751 case NT_PRPSINFO:
1ec5cd37 13752 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 13753 case NT_TASKSTRUCT:
1ec5cd37 13754 return _("NT_TASKSTRUCT (task structure)");
57346661 13755 case NT_PRXFPREG:
1ec5cd37 13756 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 13757 case NT_PPC_VMX:
13758 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 13759 case NT_PPC_VSX:
13760 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 13761 case NT_386_TLS:
13762 return _("NT_386_TLS (x86 TLS information)");
13763 case NT_386_IOPERM:
13764 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 13765 case NT_X86_XSTATE:
13766 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 13767 case NT_S390_HIGH_GPRS:
13768 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 13769 case NT_S390_TIMER:
13770 return _("NT_S390_TIMER (s390 timer register)");
13771 case NT_S390_TODCMP:
13772 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13773 case NT_S390_TODPREG:
13774 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13775 case NT_S390_CTRS:
13776 return _("NT_S390_CTRS (s390 control registers)");
13777 case NT_S390_PREFIX:
13778 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 13779 case NT_S390_LAST_BREAK:
13780 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13781 case NT_S390_SYSTEM_CALL:
13782 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 13783 case NT_S390_TDB:
13784 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW		 13785 case NT_ARM_VFP:
13786 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 13787 case NT_ARM_TLS:
13788 return _("NT_ARM_TLS (AArch TLS registers)");
13789 case NT_ARM_HW_BREAK:
13790 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13791 case NT_ARM_HW_WATCH:
13792 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 13793 case NT_PSTATUS:
1ec5cd37 13794 return _("NT_PSTATUS (pstatus structure)");
57346661 13795 case NT_FPREGS:
1ec5cd37 13796 return _("NT_FPREGS (floating point registers)");
57346661 13797 case NT_PSINFO:
1ec5cd37 13798 return _("NT_PSINFO (psinfo structure)");
57346661 13799 case NT_LWPSTATUS:
1ec5cd37 13800 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 13801 case NT_LWPSINFO:
1ec5cd37 13802 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 13803 case NT_WIN32PSTATUS:
1ec5cd37 13804 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 13805 case NT_SIGINFO:
13806 return _("NT_SIGINFO (siginfo_t data)");
13807 case NT_FILE:
13808 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 13809 default:
13810 break;
13811 }
13812 else
13813 switch (e_type)
13814 {
13815 case NT_VERSION:
13816 return _("NT_VERSION (version)");
13817 case NT_ARCH:
13818 return _("NT_ARCH (architecture)");
13819 default:
13820 break;
13821 }
13822
e9e44622 13823 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 13824 return buff;
779fe533
NC		 13825}
13826
9ece1fa9
TT		 13827static int
13828print_core_note (Elf_Internal_Note *pnote)
13829{
13830 unsigned int addr_size = is_32bit_elf ? 4 : 8;
13831 bfd_vma count, page_size;
13832 unsigned char *descdata, *filenames, *descend;
13833
13834 if (pnote->type != NT_FILE)
13835 return 1;
13836
13837#ifndef BFD64
13838 if (!is_32bit_elf)
13839 {
13840 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13841 /* Still "successful". */
13842 return 1;
13843 }
13844#endif
13845
13846 if (pnote->descsz < 2 * addr_size)
13847 {
13848 printf (_(" Malformed note - too short for header\n"));
13849 return 0;
13850 }
13851
13852 descdata = (unsigned char *) pnote->descdata;
13853 descend = descdata + pnote->descsz;
13854
13855 if (descdata[pnote->descsz - 1] != '\0')
13856 {
13857 printf (_(" Malformed note - does not end with \\0\n"));
13858 return 0;
13859 }
13860
13861 count = byte_get (descdata, addr_size);
13862 descdata += addr_size;
13863
13864 page_size = byte_get (descdata, addr_size);
13865 descdata += addr_size;
13866
13867 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13868 {
13869 printf (_(" Malformed note - too short for supplied file count\n"));
13870 return 0;
13871 }
13872
13873 printf (_(" Page size: "));
13874 print_vma (page_size, DEC);
13875 printf ("\n");
13876
13877 printf (_(" %*s%*s%*s\n"),
13878 (int) (2 + 2 * addr_size), _("Start"),
13879 (int) (4 + 2 * addr_size), _("End"),
13880 (int) (4 + 2 * addr_size), _("Page Offset"));
13881 filenames = descdata + count * 3 * addr_size;
13882 while (--count > 0)
13883 {
13884 bfd_vma start, end, file_ofs;
13885
13886 if (filenames == descend)
13887 {
13888 printf (_(" Malformed note - filenames end too early\n"));
13889 return 0;
13890 }
13891
13892 start = byte_get (descdata, addr_size);
13893 descdata += addr_size;
13894 end = byte_get (descdata, addr_size);
13895 descdata += addr_size;
13896 file_ofs = byte_get (descdata, addr_size);
13897 descdata += addr_size;
13898
13899 printf (" ");
13900 print_vma (start, FULL_HEX);
13901 printf (" ");
13902 print_vma (end, FULL_HEX);
13903 printf (" ");
13904 print_vma (file_ofs, FULL_HEX);
13905 printf ("\n %s\n", filenames);
13906
13907 filenames += 1 + strlen ((char *) filenames);
13908 }
13909
13910 return 1;
13911}
13912
1118d252
RM		 13913static const char *
13914get_gnu_elf_note_type (unsigned e_type)
13915{
13916 static char buff[64];
13917
13918 switch (e_type)
13919 {
13920 case NT_GNU_ABI_TAG:
13921 return _("NT_GNU_ABI_TAG (ABI version tag)");
13922 case NT_GNU_HWCAP:
13923 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13924 case NT_GNU_BUILD_ID:
13925 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 13926 case NT_GNU_GOLD_VERSION:
13927 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 13928 default:
13929 break;
13930 }
13931
13932 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13933 return buff;
13934}
13935
664f90a3
TT		 13936static int
13937print_gnu_note (Elf_Internal_Note *pnote)
13938{
13939 switch (pnote->type)
13940 {
13941 case NT_GNU_BUILD_ID:
13942 {
13943 unsigned long i;
13944
13945 printf (_(" Build ID: "));
13946 for (i = 0; i < pnote->descsz; ++i)
13947 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 13948 printf ("\n");
664f90a3
TT		 13949 }
13950 break;
13951
13952 case NT_GNU_ABI_TAG:
13953 {
13954 unsigned long os, major, minor, subminor;
13955 const char *osname;
13956
13957 os = byte_get ((unsigned char *) pnote->descdata, 4);
13958 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13959 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13960 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13961
13962 switch (os)
13963 {
13964 case GNU_ABI_TAG_LINUX:
13965 osname = "Linux";
13966 break;
13967 case GNU_ABI_TAG_HURD:
13968 osname = "Hurd";
13969 break;
13970 case GNU_ABI_TAG_SOLARIS:
13971 osname = "Solaris";
13972 break;
13973 case GNU_ABI_TAG_FREEBSD:
13974 osname = "FreeBSD";
13975 break;
13976 case GNU_ABI_TAG_NETBSD:
13977 osname = "NetBSD";
13978 break;
13979 default:
13980 osname = "Unknown";
13981 break;
13982 }
13983
13984 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13985 major, minor, subminor);
13986 }
13987 break;
926c5385
CC		 13988
13989 case NT_GNU_GOLD_VERSION:
13990 {
13991 unsigned long i;
13992
13993 printf (_(" Version: "));
13994 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
13995 printf ("%c", pnote->descdata[i]);
13996 printf ("\n");
13997 }
13998 break;
664f90a3
TT		 13999 }
14000
14001 return 1;
14002}
14003
9437c45b 14004static const char *
d3ba0551 14005get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14006{
14007 static char buff[64];
14008
b4db1224 14009 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14010 {
14011 /* NetBSD core "procinfo" structure. */
14012 return _("NetBSD procinfo structure");
14013 }
14014
14015 /* As of Jan 2002 there are no other machine-independent notes
14016 defined for NetBSD core files. If the note type is less
14017 than the start of the machine-dependent note types, we don't
14018 understand it. */
14019
b4db1224 14020 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14021 {
e9e44622 14022 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14023 return buff;
14024 }
14025
14026 switch (elf_header.e_machine)
14027 {
14028 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14029 and PT_GETFPREGS == mach+2. */
14030
14031 case EM_OLD_ALPHA:
14032 case EM_ALPHA:
14033 case EM_SPARC:
14034 case EM_SPARC32PLUS:
14035 case EM_SPARCV9:
14036 switch (e_type)
14037 {
2b692964 14038 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 14039 return _("PT_GETREGS (reg structure)");
2b692964 14040 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 14041 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14042 default:
14043 break;
14044 }
14045 break;
14046
14047 /* On all other arch's, PT_GETREGS == mach+1 and
14048 PT_GETFPREGS == mach+3. */
14049 default:
14050 switch (e_type)
14051 {
2b692964 14052 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 14053 return _("PT_GETREGS (reg structure)");
2b692964 14054 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 14055 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14056 default:
14057 break;
14058 }
14059 }
14060
9cf03b7e 14061 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 14062 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 14063 return buff;
14064}
14065
70616151
TT		 14066static const char *
14067get_stapsdt_note_type (unsigned e_type)
14068{
14069 static char buff[64];
14070
14071 switch (e_type)
14072 {
14073 case NT_STAPSDT:
14074 return _("NT_STAPSDT (SystemTap probe descriptors)");
14075
14076 default:
14077 break;
14078 }
14079
14080 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14081 return buff;
14082}
14083
c6a9fc58
TT		 14084static int
14085print_stapsdt_note (Elf_Internal_Note *pnote)
14086{
14087 int addr_size = is_32bit_elf ? 4 : 8;
14088 char *data = pnote->descdata;
14089 char *data_end = pnote->descdata + pnote->descsz;
14090 bfd_vma pc, base_addr, semaphore;
14091 char *provider, *probe, *arg_fmt;
14092
14093 pc = byte_get ((unsigned char *) data, addr_size);
14094 data += addr_size;
14095 base_addr = byte_get ((unsigned char *) data, addr_size);
14096 data += addr_size;
14097 semaphore = byte_get ((unsigned char *) data, addr_size);
14098 data += addr_size;
14099
14100 provider = data;
14101 data += strlen (data) + 1;
14102 probe = data;
14103 data += strlen (data) + 1;
14104 arg_fmt = data;
14105 data += strlen (data) + 1;
14106
14107 printf (_(" Provider: %s\n"), provider);
14108 printf (_(" Name: %s\n"), probe);
14109 printf (_(" Location: "));
14110 print_vma (pc, FULL_HEX);
14111 printf (_(", Base: "));
14112 print_vma (base_addr, FULL_HEX);
14113 printf (_(", Semaphore: "));
14114 print_vma (semaphore, FULL_HEX);
9cf03b7e 14115 printf ("\n");
c6a9fc58
TT		 14116 printf (_(" Arguments: %s\n"), arg_fmt);
14117
14118 return data == data_end;
14119}
14120
00e98fc7
TG		 14121static const char *
14122get_ia64_vms_note_type (unsigned e_type)
14123{
14124 static char buff[64];
14125
14126 switch (e_type)
14127 {
14128 case NT_VMS_MHD:
14129 return _("NT_VMS_MHD (module header)");
14130 case NT_VMS_LNM:
14131 return _("NT_VMS_LNM (language name)");
14132 case NT_VMS_SRC:
14133 return _("NT_VMS_SRC (source files)");
14134 case NT_VMS_TITLE:
9cf03b7e 14135 return "NT_VMS_TITLE";
00e98fc7
TG		 14136 case NT_VMS_EIDC:
14137 return _("NT_VMS_EIDC (consistency check)");
14138 case NT_VMS_FPMODE:
14139 return _("NT_VMS_FPMODE (FP mode)");
14140 case NT_VMS_LINKTIME:
9cf03b7e 14141 return "NT_VMS_LINKTIME";
00e98fc7
TG		 14142 case NT_VMS_IMGNAM:
14143 return _("NT_VMS_IMGNAM (image name)");
14144 case NT_VMS_IMGID:
14145 return _("NT_VMS_IMGID (image id)");
14146 case NT_VMS_LINKID:
14147 return _("NT_VMS_LINKID (link id)");
14148 case NT_VMS_IMGBID:
14149 return _("NT_VMS_IMGBID (build id)");
14150 case NT_VMS_GSTNAM:
14151 return _("NT_VMS_GSTNAM (sym table name)");
14152 case NT_VMS_ORIG_DYN:
9cf03b7e 14153 return "NT_VMS_ORIG_DYN";
00e98fc7 14154 case NT_VMS_PATCHTIME:
9cf03b7e 14155 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 14156 default:
14157 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14158 return buff;
14159 }
14160}
14161
14162static int
14163print_ia64_vms_note (Elf_Internal_Note * pnote)
14164{
14165 switch (pnote->type)
14166 {
14167 case NT_VMS_MHD:
14168 if (pnote->descsz > 36)
14169 {
14170 size_t l = strlen (pnote->descdata + 34);
14171 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14172 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14173 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14174 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14175 }
14176 else
14177 printf (_(" Invalid size\n"));
14178 break;
14179 case NT_VMS_LNM:
14180 printf (_(" Language: %s\n"), pnote->descdata);
14181 break;
14182#ifdef BFD64
14183 case NT_VMS_FPMODE:
9cf03b7e 14184 printf (_(" Floating Point mode: "));
4a5cb34f 14185 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14186 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14187 break;
14188 case NT_VMS_LINKTIME:
14189 printf (_(" Link time: "));
14190 print_vms_time
14191 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14192 printf ("\n");
14193 break;
14194 case NT_VMS_PATCHTIME:
14195 printf (_(" Patch time: "));
14196 print_vms_time
14197 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14198 printf ("\n");
14199 break;
14200 case NT_VMS_ORIG_DYN:
14201 printf (_(" Major id: %u, minor id: %u\n"),
14202 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14203 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 14204 printf (_(" Last modified : "));
00e98fc7
TG		 14205 print_vms_time
14206 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 14207 printf (_("\n Link flags : "));
4a5cb34f 14208 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14209 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14210 printf (_(" Header flags: 0x%08x\n"),
14211 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14212 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14213 break;
14214#endif
14215 case NT_VMS_IMGNAM:
14216 printf (_(" Image name: %s\n"), pnote->descdata);
14217 break;
14218 case NT_VMS_GSTNAM:
14219 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14220 break;
14221 case NT_VMS_IMGID:
14222 printf (_(" Image id: %s\n"), pnote->descdata);
14223 break;
14224 case NT_VMS_LINKID:
14225 printf (_(" Linker id: %s\n"), pnote->descdata);
14226 break;
14227 default:
14228 break;
14229 }
14230 return 1;
14231}
14232
6d118b09
NC		 14233/* Note that by the ELF standard, the name field is already null byte
14234 terminated, and namesz includes the terminating null byte.
14235 I.E. the value of namesz for the name "FSF" is 4.
14236
e3c8793a 14237 If the value of namesz is zero, there is no name present. */
779fe533 14238static int
2cf0635d 14239process_note (Elf_Internal_Note * pnote)
779fe533 14240{
2cf0635d
NC		 14241 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14242 const char * nt;
9437c45b
JT		 14243
14244 if (pnote->namesz == 0)
1ec5cd37
NC		 14245 /* If there is no note name, then use the default set of
14246 note type strings. */
14247 nt = get_note_type (pnote->type);
14248
1118d252
RM		 14249 else if (const_strneq (pnote->namedata, "GNU"))
14250 /* GNU-specific object file notes. */
14251 nt = get_gnu_elf_note_type (pnote->type);
14252
0112cd26 14253 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 14254 /* NetBSD-specific core file notes. */
14255 nt = get_netbsd_elfcore_note_type (pnote->type);
14256
b15fa79e
AM		 14257 else if (strneq (pnote->namedata, "SPU/", 4))
14258 {
14259 /* SPU-specific core file notes. */
14260 nt = pnote->namedata + 4;
14261 name = "SPU";
14262 }
14263
00e98fc7
TG		 14264 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14265 /* VMS/ia64-specific file notes. */
14266 nt = get_ia64_vms_note_type (pnote->type);
14267
70616151
TT		 14268 else if (const_strneq (pnote->namedata, "stapsdt"))
14269 nt = get_stapsdt_note_type (pnote->type);
14270
9437c45b 14271 else
1ec5cd37
NC		 14272 /* Don't recognize this note name; just use the default set of
14273 note type strings. */
00e98fc7 14274 nt = get_note_type (pnote->type);
9437c45b 14275
2aee03ae 14276 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 14277
14278 if (const_strneq (pnote->namedata, "IPF/VMS"))
14279 return print_ia64_vms_note (pnote);
664f90a3
TT		 14280 else if (const_strneq (pnote->namedata, "GNU"))
14281 return print_gnu_note (pnote);
c6a9fc58
TT		 14282 else if (const_strneq (pnote->namedata, "stapsdt"))
14283 return print_stapsdt_note (pnote);
9ece1fa9
TT		 14284 else if (const_strneq (pnote->namedata, "CORE"))
14285 return print_core_note (pnote);
00e98fc7
TG		 14286 else
14287 return 1;
779fe533
NC		 14288}
14289
6d118b09 14290
779fe533 14291static int
2cf0635d 14292process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 14293{
2cf0635d
NC		 14294 Elf_External_Note * pnotes;
14295 Elf_External_Note * external;
b34976b6 14296 int res = 1;
103f02d3 14297
779fe533
NC		 14298 if (length <= 0)
14299 return 0;
103f02d3 14300
3f5e193b 14301 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 14302 _("notes"));
dd24e3da 14303 if (pnotes == NULL)
a6e9f9df 14304 return 0;
779fe533 14305
103f02d3 14306 external = pnotes;
103f02d3 14307
9dd3a467 14308 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 14309 (unsigned long) offset, (unsigned long) length);
2aee03ae 14310 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 14311
15b42fb0 14312 while ((char *) external < (char *) pnotes + length)
779fe533 14313 {
b34976b6 14314 Elf_Internal_Note inote;
15b42fb0
AM		 14315 size_t min_notesz;
14316 char *next;
2cf0635d 14317 char * temp = NULL;
15b42fb0 14318 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 14319
00e98fc7 14320 if (!is_ia64_vms ())
15b42fb0 14321 {
9dd3a467
NC		 14322 /* PR binutils/15191
14323 Make sure that there is enough data to read. */
15b42fb0
AM		 14324 min_notesz = offsetof (Elf_External_Note, name);
14325 if (data_remaining < min_notesz)
9dd3a467
NC		 14326 {
14327 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14328 (int) data_remaining);
14329 break;
14330 }
15b42fb0
AM		 14331 inote.type = BYTE_GET (external->type);
14332 inote.namesz = BYTE_GET (external->namesz);
14333 inote.namedata = external->name;
14334 inote.descsz = BYTE_GET (external->descsz);
14335 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14336 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14337 next = inote.descdata + align_power (inote.descsz, 2);
14338 }
00e98fc7 14339 else
15b42fb0
AM		 14340 {
14341 Elf64_External_VMS_Note *vms_external;
00e98fc7 14342
9dd3a467
NC		 14343 /* PR binutils/15191
14344 Make sure that there is enough data to read. */
15b42fb0
AM		 14345 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14346 if (data_remaining < min_notesz)
9dd3a467
NC		 14347 {
14348 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14349 (int) data_remaining);
14350 break;
14351 }
3e55a963 14352
15b42fb0
AM		 14353 vms_external = (Elf64_External_VMS_Note *) external;
14354 inote.type = BYTE_GET (vms_external->type);
14355 inote.namesz = BYTE_GET (vms_external->namesz);
14356 inote.namedata = vms_external->name;
14357 inote.descsz = BYTE_GET (vms_external->descsz);
14358 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14359 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14360 next = inote.descdata + align_power (inote.descsz, 3);
14361 }
14362
14363 if (inote.descdata < (char *) external + min_notesz
14364 || next < (char *) external + min_notesz
14365 || data_remaining < (size_t)(next - (char *) external))
3e55a963 14366 {
15b42fb0 14367 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 14368 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 14369 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 14370 inote.type, inote.namesz, inote.descsz);
14371 break;
14372 }
14373
15b42fb0 14374 external = (Elf_External_Note *) next;
dd24e3da 14375
6d118b09
NC		 14376 /* Verify that name is null terminated. It appears that at least
14377 one version of Linux (RedHat 6.0) generates corefiles that don't
14378 comply with the ELF spec by failing to include the null byte in
14379 namesz. */
8b971f9f 14380 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 14381 {
3f5e193b 14382 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 14383
6d118b09
NC		 14384 if (temp == NULL)
14385 {
14386 error (_("Out of memory\n"));
14387 res = 0;
14388 break;
14389 }
76da6bbe 14390
6d118b09
NC		 14391 strncpy (temp, inote.namedata, inote.namesz);
14392 temp[inote.namesz] = 0;
76da6bbe 14393
6d118b09
NC		 14394 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14395 inote.namedata = temp;
14396 }
14397
14398 res &= process_note (& inote);
103f02d3 14399
6d118b09
NC		 14400 if (temp != NULL)
14401 {
14402 free (temp);
14403 temp = NULL;
14404 }
779fe533
NC		 14405 }
14406
14407 free (pnotes);
103f02d3 14408
779fe533
NC		 14409 return res;
14410}
14411
14412static int
2cf0635d 14413process_corefile_note_segments (FILE * file)
779fe533 14414{
2cf0635d 14415 Elf_Internal_Phdr * segment;
b34976b6
AM		 14416 unsigned int i;
14417 int res = 1;
103f02d3 14418
d93f0186 14419 if (! get_program_headers (file))
779fe533 14420 return 0;
103f02d3 14421
779fe533
NC		 14422 for (i = 0, segment = program_headers;
14423 i < elf_header.e_phnum;
b34976b6 14424 i++, segment++)
779fe533
NC		 14425 {
14426 if (segment->p_type == PT_NOTE)
103f02d3 14427 res &= process_corefile_note_segment (file,
30800947
NC		 14428 (bfd_vma) segment->p_offset,
14429 (bfd_vma) segment->p_filesz);
779fe533 14430 }
103f02d3 14431
779fe533
NC		 14432 return res;
14433}
14434
14435static int
2cf0635d 14436process_note_sections (FILE * file)
1ec5cd37 14437{
2cf0635d 14438 Elf_Internal_Shdr * section;
1ec5cd37 14439 unsigned long i;
df565f32 14440 int n = 0;
1ec5cd37
NC		 14441 int res = 1;
14442
14443 for (i = 0, section = section_headers;
fa1908fd 14444 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 14445 i++, section++)
14446 if (section->sh_type == SHT_NOTE)
df565f32
NC		 14447 {
14448 res &= process_corefile_note_segment (file,
14449 (bfd_vma) section->sh_offset,
14450 (bfd_vma) section->sh_size);
14451 n++;
14452 }
14453
14454 if (n == 0)
14455 /* Try processing NOTE segments instead. */
14456 return process_corefile_note_segments (file);
1ec5cd37
NC		 14457
14458 return res;
14459}
14460
14461static int
2cf0635d 14462process_notes (FILE * file)
779fe533
NC		 14463{
14464 /* If we have not been asked to display the notes then do nothing. */
14465 if (! do_notes)
14466 return 1;
103f02d3 14467
779fe533 14468 if (elf_header.e_type != ET_CORE)
1ec5cd37 14469 return process_note_sections (file);
103f02d3 14470
779fe533 14471 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 14472 if (elf_header.e_phnum > 0)
14473 return process_corefile_note_segments (file);
779fe533 14474
1ec5cd37
NC		 14475 printf (_("No note segments present in the core file.\n"));
14476 return 1;
779fe533
NC		 14477}
14478
252b5132 14479static int
2cf0635d 14480process_arch_specific (FILE * file)
252b5132 14481{
a952a375
NC		 14482 if (! do_arch)
14483 return 1;
14484
252b5132
RH		 14485 switch (elf_header.e_machine)
14486 {
11c1ff18
PB		 14487 case EM_ARM:
14488 return process_arm_specific (file);
252b5132 14489 case EM_MIPS:
4fe85591 14490 case EM_MIPS_RS3_LE:
252b5132
RH		 14491 return process_mips_specific (file);
14492 break;
35c08157
KLC		 14493 case EM_NDS32:
14494 return process_nds32_specific (file);
14495 break;
34c8bcba
JM		 14496 case EM_PPC:
14497 return process_power_specific (file);
14498 break;
9e8c70f9
DM		 14499 case EM_SPARC:
14500 case EM_SPARC32PLUS:
14501 case EM_SPARCV9:
14502 return process_sparc_specific (file);
14503 break;
59e6276b
JM		 14504 case EM_TI_C6000:
14505 return process_tic6x_specific (file);
14506 break;
13761a11
NC		 14507 case EM_MSP430:
14508 return process_msp430x_specific (file);
252b5132
RH		 14509 default:
14510 break;
14511 }
14512 return 1;
14513}
14514
14515static int
2cf0635d 14516get_file_header (FILE * file)
252b5132 14517{
9ea033b2
NC		 14518 /* Read in the identity array. */
14519 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 14520 return 0;
14521
9ea033b2 14522 /* Determine how to read the rest of the header. */
b34976b6 14523 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 14524 {
14525 default: /* fall through */
14526 case ELFDATANONE: /* fall through */
adab8cdc
AO		 14527 case ELFDATA2LSB:
14528 byte_get = byte_get_little_endian;
14529 byte_put = byte_put_little_endian;
14530 break;
14531 case ELFDATA2MSB:
14532 byte_get = byte_get_big_endian;
14533 byte_put = byte_put_big_endian;
14534 break;
9ea033b2
NC		 14535 }
14536
14537 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 14538 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 14539
14540 /* Read in the rest of the header. */
14541 if (is_32bit_elf)
14542 {
14543 Elf32_External_Ehdr ehdr32;
252b5132 14544
9ea033b2
NC		 14545 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14546 return 0;
103f02d3 14547
9ea033b2
NC		 14548 elf_header.e_type = BYTE_GET (ehdr32.e_type);
14549 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
14550 elf_header.e_version = BYTE_GET (ehdr32.e_version);
14551 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
14552 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
14553 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
14554 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
14555 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
14556 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14557 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
14558 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14559 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
14560 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
14561 }
252b5132 14562 else
9ea033b2
NC		 14563 {
14564 Elf64_External_Ehdr ehdr64;
a952a375
NC		 14565
14566 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14567 we will not be able to cope with the 64bit data found in
14568 64 ELF files. Detect this now and abort before we start
50c2245b 14569 overwriting things. */
a952a375
NC		 14570 if (sizeof (bfd_vma) < 8)
14571 {
e3c8793a
NC		 14572 error (_("This instance of readelf has been built without support for a\n\
1457364 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 14574 return 0;
14575 }
103f02d3 14576
9ea033b2
NC		 14577 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14578 return 0;
103f02d3 14579
9ea033b2
NC		 14580 elf_header.e_type = BYTE_GET (ehdr64.e_type);
14581 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
14582 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 14583 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
14584 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
14585 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 14586 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
14587 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
14588 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14589 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
14590 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14591 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
14592 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
14593 }
252b5132 14594
7ece0d85
JJ		 14595 if (elf_header.e_shoff)
14596 {
14597 /* There may be some extensions in the first section header. Don't
14598 bomb if we can't read it. */
14599 if (is_32bit_elf)
049b0c3a 14600 get_32bit_section_headers (file, TRUE);
7ece0d85 14601 else
049b0c3a 14602 get_64bit_section_headers (file, TRUE);
7ece0d85 14603 }
560f3c1c 14604
252b5132
RH		 14605 return 1;
14606}
14607
fb52b2f4
NC		 14608/* Process one ELF object file according to the command line options.
14609 This file may actually be stored in an archive. The file is
14610 positioned at the start of the ELF object. */
14611
ff78d6d6 14612static int
2cf0635d 14613process_object (char * file_name, FILE * file)
252b5132 14614{
252b5132
RH		 14615 unsigned int i;
14616
252b5132
RH		 14617 if (! get_file_header (file))
14618 {
14619 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 14620 return 1;
252b5132
RH		 14621 }
14622
14623 /* Initialise per file variables. */
60bca95a 14624 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 14625 version_info[i] = 0;
14626
60bca95a 14627 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 14628 dynamic_info[i] = 0;
5115b233 14629 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 14630
14631 /* Process the file. */
14632 if (show_name)
14633 printf (_("\nFile: %s\n"), file_name);
14634
18bd398b
NC		 14635 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14636 Note we do this even if cmdline_dump_sects is empty because we
14637 must make sure that the dump_sets array is zeroed out before each
14638 object file is processed. */
14639 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 14640 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 14641
14642 if (num_cmdline_dump_sects > 0)
14643 {
14644 if (num_dump_sects == 0)
14645 /* A sneaky way of allocating the dump_sects array. */
09c11c86 14646 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 14647
14648 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 14649 memcpy (dump_sects, cmdline_dump_sects,
14650 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 14651 }
d70c5fc7 14652
252b5132 14653 if (! process_file_header ())
fb52b2f4 14654 return 1;
252b5132 14655
d1f5c6e3 14656 if (! process_section_headers (file))
2f62977e 14657 {
d1f5c6e3
L		 14658 /* Without loaded section headers we cannot process lots of
14659 things. */
2f62977e 14660 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 14661
2f62977e 14662 if (! do_using_dynamic)
2c610e4b 14663 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 14664 }
252b5132 14665
d1f5c6e3
L		 14666 if (! process_section_groups (file))
14667 {
14668 /* Without loaded section groups we cannot process unwind. */
14669 do_unwind = 0;
14670 }
14671
2f62977e 14672 if (process_program_headers (file))
b2d38a17 14673 process_dynamic_section (file);
252b5132
RH		 14674
14675 process_relocs (file);
14676
4d6ed7c8
NC		 14677 process_unwind (file);
14678
252b5132
RH		 14679 process_symbol_table (file);
14680
14681 process_syminfo (file);
14682
14683 process_version_sections (file);
14684
14685 process_section_contents (file);
f5842774 14686
1ec5cd37 14687 process_notes (file);
103f02d3 14688
047b2264
JJ		 14689 process_gnu_liblist (file);
14690
252b5132
RH		 14691 process_arch_specific (file);
14692
d93f0186
NC		 14693 if (program_headers)
14694 {
14695 free (program_headers);
14696 program_headers = NULL;
14697 }
14698
252b5132
RH		 14699 if (section_headers)
14700 {
14701 free (section_headers);
14702 section_headers = NULL;
14703 }
14704
14705 if (string_table)
14706 {
14707 free (string_table);
14708 string_table = NULL;
d40ac9bd 14709 string_table_length = 0;
252b5132
RH		 14710 }
14711
14712 if (dynamic_strings)
14713 {
14714 free (dynamic_strings);
14715 dynamic_strings = NULL;
d79b3d50 14716 dynamic_strings_length = 0;
252b5132
RH		 14717 }
14718
14719 if (dynamic_symbols)
14720 {
14721 free (dynamic_symbols);
14722 dynamic_symbols = NULL;
19936277 14723 num_dynamic_syms = 0;
252b5132
RH		 14724 }
14725
14726 if (dynamic_syminfo)
14727 {
14728 free (dynamic_syminfo);
14729 dynamic_syminfo = NULL;
14730 }
ff78d6d6 14731
293c573e
MR		 14732 if (dynamic_section)
14733 {
14734 free (dynamic_section);
14735 dynamic_section = NULL;
14736 }
14737
e4b17d5c
L		 14738 if (section_headers_groups)
14739 {
14740 free (section_headers_groups);
14741 section_headers_groups = NULL;
14742 }
14743
14744 if (section_groups)
14745 {
2cf0635d
NC		 14746 struct group_list * g;
14747 struct group_list * next;
e4b17d5c
L		 14748
14749 for (i = 0; i < group_count; i++)
14750 {
14751 for (g = section_groups [i].root; g != NULL; g = next)
14752 {
14753 next = g->next;
14754 free (g);
14755 }
14756 }
14757
14758 free (section_groups);
14759 section_groups = NULL;
14760 }
14761
19e6b90e 14762 free_debug_memory ();
18bd398b 14763
ff78d6d6 14764 return 0;
252b5132
RH		 14765}
14766
2cf0635d
NC		 14767/* Process an ELF archive.
14768 On entry the file is positioned just after the ARMAG string. */
14769
14770static int
14771process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14772{
14773 struct archive_info arch;
14774 struct archive_info nested_arch;
14775 size_t got;
2cf0635d
NC		 14776 int ret;
14777
14778 show_name = 1;
14779
14780 /* The ARCH structure is used to hold information about this archive. */
14781 arch.file_name = NULL;
14782 arch.file = NULL;
14783 arch.index_array = NULL;
14784 arch.sym_table = NULL;
14785 arch.longnames = NULL;
14786
14787 /* The NESTED_ARCH structure is used as a single-item cache of information
14788 about a nested archive (when members of a thin archive reside within
14789 another regular archive file). */
14790 nested_arch.file_name = NULL;
14791 nested_arch.file = NULL;
14792 nested_arch.index_array = NULL;
14793 nested_arch.sym_table = NULL;
14794 nested_arch.longnames = NULL;
14795
14796 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14797 {
14798 ret = 1;
14799 goto out;
4145f1d5 14800 }
fb52b2f4 14801
4145f1d5
NC		 14802 if (do_archive_index)
14803 {
2cf0635d 14804 if (arch.sym_table == NULL)
4145f1d5
NC		 14805 error (_("%s: unable to dump the index as none was found\n"), file_name);
14806 else
14807 {
2cf0635d 14808 unsigned int i, l;
4145f1d5
NC		 14809 unsigned long current_pos;
14810
14811 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 14812 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 14813 current_pos = ftell (file);
14814
2cf0635d 14815 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 14816 {
2cf0635d
NC		 14817 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14818 {
14819 char * member_name;
4145f1d5 14820
2cf0635d
NC		 14821 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14822
14823 if (member_name != NULL)
14824 {
14825 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14826
14827 if (qualified_name != NULL)
14828 {
c2a7d3f5
NC		 14829 printf (_("Contents of binary %s at offset "), qualified_name);
14830 (void) print_vma (arch.index_array[i], PREFIX_HEX);
14831 putchar ('\n');
2cf0635d
NC		 14832 free (qualified_name);
14833 }
4145f1d5
NC		 14834 }
14835 }
2cf0635d
NC		 14836
14837 if (l >= arch.sym_size)
4145f1d5
NC		 14838 {
14839 error (_("%s: end of the symbol table reached before the end of the index\n"),
14840 file_name);
cb8f3167 14841 break;
4145f1d5 14842 }
2cf0635d
NC		 14843 printf ("\t%s\n", arch.sym_table + l);
14844 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 14845 }
14846
c2a7d3f5
NC		 14847 if (arch.uses_64bit_indicies)
14848 l = (l + 7) & ~ 7;
14849 else
14850 l += l & 1;
14851
2cf0635d 14852 if (l < arch.sym_size)
c2a7d3f5
NC		 14853 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14854 file_name, arch.sym_size - l);
4145f1d5 14855
4145f1d5
NC		 14856 if (fseek (file, current_pos, SEEK_SET) != 0)
14857 {
14858 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 14859 ret = 1;
14860 goto out;
4145f1d5 14861 }
fb52b2f4 14862 }
4145f1d5
NC		 14863
14864 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14865 && !do_segments && !do_header && !do_dump && !do_version
14866 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 14867 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 14868 {
14869 ret = 0; /* Archive index only. */
14870 goto out;
14871 }
fb52b2f4
NC		 14872 }
14873
d989285c 14874 ret = 0;
fb52b2f4
NC		 14875
14876 while (1)
14877 {
2cf0635d
NC		 14878 char * name;
14879 size_t namelen;
14880 char * qualified_name;
14881
14882 /* Read the next archive header. */
14883 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14884 {
14885 error (_("%s: failed to seek to next archive header\n"), file_name);
14886 return 1;
14887 }
14888 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14889 if (got != sizeof arch.arhdr)
14890 {
14891 if (got == 0)
14892 break;
14893 error (_("%s: failed to read archive header\n"), file_name);
14894 ret = 1;
14895 break;
14896 }
14897 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14898 {
14899 error (_("%s: did not find a valid archive header\n"), arch.file_name);
14900 ret = 1;
14901 break;
14902 }
14903
14904 arch.next_arhdr_offset += sizeof arch.arhdr;
14905
14906 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14907 if (archive_file_size & 01)
14908 ++archive_file_size;
14909
14910 name = get_archive_member_name (&arch, &nested_arch);
14911 if (name == NULL)
fb52b2f4 14912 {
0fd3a477 14913 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 14914 ret = 1;
14915 break;
fb52b2f4 14916 }
2cf0635d 14917 namelen = strlen (name);
fb52b2f4 14918
2cf0635d
NC		 14919 qualified_name = make_qualified_name (&arch, &nested_arch, name);
14920 if (qualified_name == NULL)
fb52b2f4 14921 {
2cf0635d 14922 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 14923 ret = 1;
14924 break;
fb52b2f4
NC		 14925 }
14926
2cf0635d
NC		 14927 if (is_thin_archive && arch.nested_member_origin == 0)
14928 {
14929 /* This is a proxy for an external member of a thin archive. */
14930 FILE * member_file;
14931 char * member_file_name = adjust_relative_path (file_name, name, namelen);
14932 if (member_file_name == NULL)
14933 {
14934 ret = 1;
14935 break;
14936 }
14937
14938 member_file = fopen (member_file_name, "rb");
14939 if (member_file == NULL)
14940 {
14941 error (_("Input file '%s' is not readable.\n"), member_file_name);
14942 free (member_file_name);
14943 ret = 1;
14944 break;
14945 }
14946
14947 archive_file_offset = arch.nested_member_origin;
14948
14949 ret |= process_object (qualified_name, member_file);
14950
14951 fclose (member_file);
14952 free (member_file_name);
14953 }
14954 else if (is_thin_archive)
14955 {
a043396b
NC		 14956 /* PR 15140: Allow for corrupt thin archives. */
14957 if (nested_arch.file == NULL)
14958 {
14959 error (_("%s: contains corrupt thin archive: %s\n"),
14960 file_name, name);
14961 ret = 1;
14962 break;
14963 }
14964
2cf0635d
NC		 14965 /* This is a proxy for a member of a nested archive. */
14966 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14967
14968 /* The nested archive file will have been opened and setup by
14969 get_archive_member_name. */
14970 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14971 {
14972 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14973 ret = 1;
14974 break;
14975 }
14976
14977 ret |= process_object (qualified_name, nested_arch.file);
14978 }
14979 else
14980 {
14981 archive_file_offset = arch.next_arhdr_offset;
14982 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 14983
2cf0635d
NC		 14984 ret |= process_object (qualified_name, file);
14985 }
fb52b2f4 14986
2b52916e
L		 14987 if (dump_sects != NULL)
14988 {
14989 free (dump_sects);
14990 dump_sects = NULL;
14991 num_dump_sects = 0;
14992 }
14993
2cf0635d 14994 free (qualified_name);
fb52b2f4
NC		 14995 }
14996
4145f1d5 14997 out:
2cf0635d
NC		 14998 if (nested_arch.file != NULL)
14999 fclose (nested_arch.file);
15000 release_archive (&nested_arch);
15001 release_archive (&arch);
fb52b2f4 15002
d989285c 15003 return ret;
fb52b2f4
NC		 15004}
15005
15006static int
2cf0635d 15007process_file (char * file_name)
fb52b2f4 15008{
2cf0635d 15009 FILE * file;
fb52b2f4
NC		 15010 struct stat statbuf;
15011 char armag[SARMAG];
15012 int ret;
15013
15014 if (stat (file_name, &statbuf) < 0)
15015 {
f24ddbdd
NC		 15016 if (errno == ENOENT)
15017 error (_("'%s': No such file\n"), file_name);
15018 else
15019 error (_("Could not locate '%s'. System error message: %s\n"),
15020 file_name, strerror (errno));
15021 return 1;
15022 }
15023
15024 if (! S_ISREG (statbuf.st_mode))
15025 {
15026 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 15027 return 1;
15028 }
15029
15030 file = fopen (file_name, "rb");
15031 if (file == NULL)
15032 {
f24ddbdd 15033 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 15034 return 1;
15035 }
15036
15037 if (fread (armag, SARMAG, 1, file) != 1)
15038 {
4145f1d5 15039 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 15040 fclose (file);
15041 return 1;
15042 }
15043
f54498b4
NC		 15044 current_file_size = (bfd_size_type) statbuf.st_size;
15045
fb52b2f4 15046 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 15047 ret = process_archive (file_name, file, FALSE);
15048 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15049 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 15050 else
15051 {
4145f1d5
NC		 15052 if (do_archive_index)
15053 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15054 file_name);
15055
fb52b2f4
NC		 15056 rewind (file);
15057 archive_file_size = archive_file_offset = 0;
15058 ret = process_object (file_name, file);
15059 }
15060
15061 fclose (file);
15062
f54498b4 15063 current_file_size = 0;
fb52b2f4
NC		 15064 return ret;
15065}
15066
252b5132
RH		 15067#ifdef SUPPORT_DISASSEMBLY
15068/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 15069 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 15070 symbols. */
252b5132
RH		 15071
15072void
2cf0635d 15073print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 15074{
15075 fprintf (outfile,"0x%8.8x", addr);
15076}
15077
e3c8793a 15078/* Needed by the i386 disassembler. */
252b5132
RH		 15079void
15080db_task_printsym (unsigned int addr)
15081{
15082 print_address (addr, stderr);
15083}
15084#endif
15085
15086int
2cf0635d 15087main (int argc, char ** argv)
252b5132 15088{
ff78d6d6
L		 15089 int err;
15090
252b5132
RH		 15091#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15092 setlocale (LC_MESSAGES, "");
3882b010
L		 15093#endif
15094#if defined (HAVE_SETLOCALE)
15095 setlocale (LC_CTYPE, "");
252b5132
RH		 15096#endif
15097 bindtextdomain (PACKAGE, LOCALEDIR);
15098 textdomain (PACKAGE);
15099
869b9d07
MM		 15100 expandargv (&argc, &argv);
15101
252b5132
RH		 15102 parse_args (argc, argv);
15103
18bd398b 15104 if (num_dump_sects > 0)
59f14fc0 15105 {
18bd398b 15106 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 15107 cmdline_dump_sects = (dump_type *)
15108 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 15109 if (cmdline_dump_sects == NULL)
591a748a 15110 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 15111 else
15112 {
09c11c86
NC		 15113 memcpy (cmdline_dump_sects, dump_sects,
15114 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 15115 num_cmdline_dump_sects = num_dump_sects;
15116 }
15117 }
15118
18bd398b
NC		 15119 if (optind < (argc - 1))
15120 show_name = 1;
15121
ff78d6d6 15122 err = 0;
252b5132 15123 while (optind < argc)
18bd398b 15124 err |= process_file (argv[optind++]);
252b5132
RH		 15125
15126 if (dump_sects != NULL)
15127 free (dump_sects);
59f14fc0
AS		 15128 if (cmdline_dump_sects != NULL)
15129 free (cmdline_dump_sects);
252b5132 15130
ff78d6d6 15131 return err;
252b5132 15132}
A mirror of the official binutils-gdb repository