]> 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
wrong dimension found in ada-lang.c:ada_array_bound_from_type
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
7e26601c 2 Copyright 1998-2013 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056
CS		 46#ifdef HAVE_ZLIB_H
47#include <zlib.h>
48#endif
3bfcb652 49#ifdef HAVE_WCHAR_H
7bfd842d 50#include <wchar.h>
3bfcb652 51#endif
252b5132 52
a952a375 53#if __GNUC__ >= 2
19936277 54/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 55 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 56 Only do this if we believe that the compiler can support a 64 bit
a952a375 57 data type. For now we only rely on GCC being able to do this. */
19936277 58#define BFD64
a952a375
NC		 59#endif
60
3db64b00
AM		 61#include "bfd.h"
62#include "bucomm.h"
3284fe0c 63#include "elfcomm.h"
19e6b90e 64#include "dwarf.h"
252b5132
RH		 65
66#include "elf/common.h"
67#include "elf/external.h"
68#include "elf/internal.h"
252b5132 69
4b78141a
NC		 70
71/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76#include "elf/h8.h"
77#undef _ELF_H8_H
78
79/* Undo the effects of #including reloc-macros.h. */
80
81#undef START_RELOC_NUMBERS
82#undef RELOC_NUMBER
83#undef FAKE_RELOC
84#undef EMPTY_RELOC
85#undef END_RELOC_NUMBERS
86#undef _RELOC_MACROS_H
87
252b5132
RH		 88/* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92#define RELOC_MACROS_GEN_FUNC
93
a06ea964 94#include "elf/aarch64.h"
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
cfb8c092 106#include "elf/epiphany.h"
252b5132 107#include "elf/fr30.h"
5c70f934 108#include "elf/frv.h"
3b16e843
NC		 109#include "elf/h8.h"
110#include "elf/hppa.h"
111#include "elf/i386.h"
35b1837e 112#include "elf/i370.h"
3b16e843
NC		 113#include "elf/i860.h"
114#include "elf/i960.h"
115#include "elf/ia64.h"
1e4cf259 116#include "elf/ip2k.h"
84e94c90 117#include "elf/lm32.h"
1c0d3aa6 118#include "elf/iq2000.h"
49f58d10 119#include "elf/m32c.h"
3b16e843
NC		 120#include "elf/m32r.h"
121#include "elf/m68k.h"
75751cd9 122#include "elf/m68hc11.h"
252b5132 123#include "elf/mcore.h"
15ab5209 124#include "elf/mep.h"
a3c62988 125#include "elf/metag.h"
7ba29e2a 126#include "elf/microblaze.h"
3b16e843 127#include "elf/mips.h"
3c3bdf30 128#include "elf/mmix.h"
3b16e843
NC		 129#include "elf/mn10200.h"
130#include "elf/mn10300.h"
5506d11a 131#include "elf/moxie.h"
4970f871 132#include "elf/mt.h"
2469cfa2 133#include "elf/msp430.h"
13761a11 134#include "elf/nios2.h"
3b16e843 135#include "elf/or32.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
3b16e843 151#include "elf/x86-64.h"
c29aca4a 152#include "elf/xc16x.h"
f6c1a2d5 153#include "elf/xgate.h"
93fbbb04 154#include "elf/xstormy16.h"
88da6820 155#include "elf/xtensa.h"
252b5132 156
252b5132 157#include "getopt.h"
566b0d53 158#include "libiberty.h"
09c11c86 159#include "safe-ctype.h"
2cf0635d 160#include "filenames.h"
252b5132 161
15b42fb0
AM		 162#ifndef offsetof
163#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
164#endif
165
2cf0635d 166char * program_name = "readelf";
85b1c36d
BE		 167static long archive_file_offset;
168static unsigned long archive_file_size;
169static unsigned long dynamic_addr;
170static bfd_size_type dynamic_size;
171static unsigned int dynamic_nent;
2cf0635d 172static char * dynamic_strings;
85b1c36d 173static unsigned long dynamic_strings_length;
2cf0635d 174static char * string_table;
85b1c36d
BE		 175static unsigned long string_table_length;
176static unsigned long num_dynamic_syms;
2cf0635d
NC		 177static Elf_Internal_Sym * dynamic_symbols;
178static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 179static unsigned long dynamic_syminfo_offset;
180static unsigned int dynamic_syminfo_nent;
f8eae8b2 181static char program_interpreter[PATH_MAX];
bb8a0291 182static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 183static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 184static bfd_vma version_info[16];
185static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 186static Elf_Internal_Shdr * section_headers;
187static Elf_Internal_Phdr * program_headers;
188static Elf_Internal_Dyn * dynamic_section;
189static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 190static int show_name;
191static int do_dynamic;
192static int do_syms;
2c610e4b 193static int do_dyn_syms;
85b1c36d
BE		 194static int do_reloc;
195static int do_sections;
196static int do_section_groups;
5477e8a0 197static int do_section_details;
85b1c36d
BE		 198static int do_segments;
199static int do_unwind;
200static int do_using_dynamic;
201static int do_header;
202static int do_dump;
203static int do_version;
85b1c36d
BE		 204static int do_histogram;
205static int do_debugging;
85b1c36d
BE		 206static int do_arch;
207static int do_notes;
4145f1d5 208static int do_archive_index;
85b1c36d 209static int is_32bit_elf;
252b5132 210
e4b17d5c
L		 211struct group_list
212{
2cf0635d 213 struct group_list * next;
e4b17d5c
L		 214 unsigned int section_index;
215};
216
217struct group
218{
2cf0635d 219 struct group_list * root;
e4b17d5c
L		 220 unsigned int group_index;
221};
222
85b1c36d 223static size_t group_count;
2cf0635d
NC		 224static struct group * section_groups;
225static struct group ** section_headers_groups;
e4b17d5c 226
09c11c86
NC		 227
228/* Flag bits indicating particular types of dump. */
229#define HEX_DUMP (1 << 0) /* The -x command line switch. */
230#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
231#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
232#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 233#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 234
235typedef unsigned char dump_type;
236
237/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 238struct dump_list_entry
239{
2cf0635d 240 char * name;
09c11c86 241 dump_type type;
2cf0635d 242 struct dump_list_entry * next;
aef1f6d0 243};
2cf0635d 244static struct dump_list_entry * dump_sects_byname;
aef1f6d0 245
09c11c86
NC		 246/* A dynamic array of flags indicating for which sections a dump
247 has been requested via command line switches. */
248static dump_type * cmdline_dump_sects = NULL;
249static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 250
251/* A dynamic array of flags indicating for which sections a dump of
252 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 253 basis and then initialised from the cmdline_dump_sects array,
254 the results of interpreting the -w switch, and the
255 dump_sects_byname list. */
09c11c86
NC		 256static dump_type * dump_sects = NULL;
257static unsigned int num_dump_sects = 0;
252b5132 258
252b5132 259
c256ffe7 260/* How to print a vma value. */
843dd992
NC		 261typedef enum print_mode
262{
263 HEX,
264 DEC,
265 DEC_5,
266 UNSIGNED,
267 PREFIX_HEX,
268 FULL_HEX,
269 LONG_HEX
270}
271print_mode;
272
9c19a809
NC		 273#define UNKNOWN -1
274
2b692964
NC		 275#define SECTION_NAME(X) \
276 ((X) == NULL ? _("<none>") \
277 : string_table == NULL ? _("<no-name>") \
278 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 279 : string_table + (X)->sh_name))
252b5132 280
ee42cf8c 281#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 282
ba5cdace
NC		 283#define GET_ELF_SYMBOLS(file, section, sym_count) \
284 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
285 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 286
d79b3d50
NC		 287#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
288/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
289 already been called and verified that the string exists. */
290#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 291
61865e30
NC		 292#define REMOVE_ARCH_BITS(ADDR) \
293 do \
294 { \
295 if (elf_header.e_machine == EM_ARM) \
296 (ADDR) &= ~1; \
297 } \
298 while (0)
d79b3d50 299\f
59245841
NC		 300/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
301 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
302 using malloc and fill that. In either case return the pointer to the start of
303 the retrieved data or NULL if something went wrong. If something does go wrong
304 emit an error message using REASON as part of the context. */
305
c256ffe7 306static void *
2cf0635d
NC		 307get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
308 const char * reason)
a6e9f9df 309{
2cf0635d 310 void * mvar;
a6e9f9df 311
c256ffe7 312 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 313 return NULL;
314
fb52b2f4 315 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 316 {
0fd3a477 317 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 318 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 319 return NULL;
320 }
321
322 mvar = var;
323 if (mvar == NULL)
324 {
c256ffe7
JJ		 325 /* Check for overflow. */
326 if (nmemb < (~(size_t) 0 - 1) / size)
327 /* + 1 so that we can '\0' terminate invalid string table sections. */
328 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 329
330 if (mvar == NULL)
331 {
0fd3a477
JW		 332 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
333 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 334 return NULL;
335 }
c256ffe7
JJ		 336
337 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 338 }
339
c256ffe7 340 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 341 {
0fd3a477
JW		 342 error (_("Unable to read in 0x%lx bytes of %s\n"),
343 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 344 if (mvar != var)
345 free (mvar);
346 return NULL;
347 }
348
349 return mvar;
350}
351
14a91970 352/* Print a VMA value. */
cb8f3167 353
66543521 354static int
14a91970 355print_vma (bfd_vma vma, print_mode mode)
66543521 356{
66543521
AM		 357 int nc = 0;
358
14a91970 359 switch (mode)
66543521 360 {
14a91970
AM		 361 case FULL_HEX:
362 nc = printf ("0x");
363 /* Drop through. */
66543521 364
14a91970 365 case LONG_HEX:
f7a99963 366#ifdef BFD64
14a91970 367 if (is_32bit_elf)
437c2fb7 368 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 369#endif
14a91970
AM		 370 printf_vma (vma);
371 return nc + 16;
b19aac67 372
14a91970
AM		 373 case DEC_5:
374 if (vma <= 99999)
375 return printf ("%5" BFD_VMA_FMT "d", vma);
376 /* Drop through. */
66543521 377
14a91970
AM		 378 case PREFIX_HEX:
379 nc = printf ("0x");
380 /* Drop through. */
66543521 381
14a91970
AM		 382 case HEX:
383 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 384
14a91970
AM		 385 case DEC:
386 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 387
14a91970
AM		 388 case UNSIGNED:
389 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 390 }
66543521 391 return 0;
f7a99963
NC		 392}
393
7bfd842d 394/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 395 multibye characters (assuming the host environment supports them).
31104126 396
7bfd842d
NC		 397 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
398
399 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
400 padding as necessary.
171191ba
NC		 401
402 Returns the number of emitted characters. */
403
404static unsigned int
7a88bc9c 405print_symbol (int width, const char *symbol)
31104126 406{
171191ba 407 bfd_boolean extra_padding = FALSE;
7bfd842d 408 int num_printed = 0;
3bfcb652 409#ifdef HAVE_MBSTATE_T
7bfd842d 410 mbstate_t state;
3bfcb652 411#endif
7bfd842d 412 int width_remaining;
961c521f 413
7bfd842d 414 if (width < 0)
961c521f 415 {
961c521f
NC		 416 /* Keep the width positive. This also helps. */
417 width = - width;
171191ba 418 extra_padding = TRUE;
0b4362b0 419 }
961c521f 420
7bfd842d
NC		 421 if (do_wide)
422 /* Set the remaining width to a very large value.
423 This simplifies the code below. */
424 width_remaining = INT_MAX;
425 else
426 width_remaining = width;
cb8f3167 427
3bfcb652 428#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 429 /* Initialise the multibyte conversion state. */
430 memset (& state, 0, sizeof (state));
3bfcb652 431#endif
961c521f 432
7bfd842d
NC		 433 while (width_remaining)
434 {
435 size_t n;
7bfd842d 436 const char c = *symbol++;
961c521f 437
7bfd842d 438 if (c == 0)
961c521f
NC		 439 break;
440
7bfd842d
NC		 441 /* Do not print control characters directly as they can affect terminal
442 settings. Such characters usually appear in the names generated
443 by the assembler for local labels. */
444 if (ISCNTRL (c))
961c521f 445 {
7bfd842d 446 if (width_remaining < 2)
961c521f
NC		 447 break;
448
7bfd842d
NC		 449 printf ("^%c", c + 0x40);
450 width_remaining -= 2;
171191ba 451 num_printed += 2;
961c521f 452 }
7bfd842d
NC		 453 else if (ISPRINT (c))
454 {
455 putchar (c);
456 width_remaining --;
457 num_printed ++;
458 }
961c521f
NC		 459 else
460 {
3bfcb652
NC		 461#ifdef HAVE_MBSTATE_T
462 wchar_t w;
463#endif
7bfd842d
NC		 464 /* Let printf do the hard work of displaying multibyte characters. */
465 printf ("%.1s", symbol - 1);
466 width_remaining --;
467 num_printed ++;
468
3bfcb652 469#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 470 /* Try to find out how many bytes made up the character that was
471 just printed. Advance the symbol pointer past the bytes that
472 were displayed. */
473 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 474#else
475 n = 1;
476#endif
7bfd842d
NC		 477 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
478 symbol += (n - 1);
961c521f 479 }
961c521f 480 }
171191ba 481
7bfd842d 482 if (extra_padding && num_printed < width)
171191ba
NC		 483 {
484 /* Fill in the remaining spaces. */
7bfd842d
NC		 485 printf ("%-*s", width - num_printed, " ");
486 num_printed = width;
171191ba
NC		 487 }
488
489 return num_printed;
31104126
NC		 490}
491
89fac5e3
RS		 492/* Return a pointer to section NAME, or NULL if no such section exists. */
493
494static Elf_Internal_Shdr *
2cf0635d 495find_section (const char * name)
89fac5e3
RS		 496{
497 unsigned int i;
498
499 for (i = 0; i < elf_header.e_shnum; i++)
500 if (streq (SECTION_NAME (section_headers + i), name))
501 return section_headers + i;
502
503 return NULL;
504}
505
0b6ae522
DJ		 506/* Return a pointer to a section containing ADDR, or NULL if no such
507 section exists. */
508
509static Elf_Internal_Shdr *
510find_section_by_address (bfd_vma addr)
511{
512 unsigned int i;
513
514 for (i = 0; i < elf_header.e_shnum; i++)
515 {
516 Elf_Internal_Shdr *sec = section_headers + i;
517 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
518 return sec;
519 }
520
521 return NULL;
522}
523
657d0d47
CC		 524/* Return a pointer to section NAME, or NULL if no such section exists,
525 restricted to the list of sections given in SET. */
526
527static Elf_Internal_Shdr *
528find_section_in_set (const char * name, unsigned int * set)
529{
530 unsigned int i;
531
532 if (set != NULL)
533 {
534 while ((i = *set++) > 0)
535 if (streq (SECTION_NAME (section_headers + i), name))
536 return section_headers + i;
537 }
538
539 return find_section (name);
540}
541
0b6ae522
DJ		 542/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
543 bytes read. */
544
f6f0e17b
NC		 545static inline unsigned long
546read_uleb128 (unsigned char *data,
547 unsigned int *length_return,
548 const unsigned char * const end)
0b6ae522 549{
f6f0e17b 550 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 551}
552
28f997cf
TG		 553/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
554 This OS has so many departures from the ELF standard that we test it at
555 many places. */
556
557static inline int
558is_ia64_vms (void)
559{
560 return elf_header.e_machine == EM_IA_64
561 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
562}
563
bcedfee6 564/* Guess the relocation size commonly used by the specific machines. */
252b5132 565
252b5132 566static int
2dc4cec1 567guess_is_rela (unsigned int e_machine)
252b5132 568{
9c19a809 569 switch (e_machine)
252b5132
RH		 570 {
571 /* Targets that use REL relocations. */
252b5132
RH		 572 case EM_386:
573 case EM_486:
63fcb9e9 574 case EM_960:
e9f53129 575 case EM_ARM:
2b0337b0 576 case EM_D10V:
252b5132 577 case EM_CYGNUS_D10V:
e9f53129 578 case EM_DLX:
252b5132 579 case EM_MIPS:
4fe85591 580 case EM_MIPS_RS3_LE:
e9f53129
AM		 581 case EM_CYGNUS_M32R:
582 case EM_OPENRISC:
583 case EM_OR32:
1c0d3aa6 584 case EM_SCORE:
f6c1a2d5 585 case EM_XGATE:
9c19a809 586 return FALSE;
103f02d3 587
252b5132
RH		 588 /* Targets that use RELA relocations. */
589 case EM_68K:
e9f53129 590 case EM_860:
a06ea964 591 case EM_AARCH64:
cfb8c092 592 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 593 case EM_ALPHA:
594 case EM_ALTERA_NIOS2:
595 case EM_AVR:
596 case EM_AVR_OLD:
597 case EM_BLACKFIN:
60bca95a 598 case EM_CR16:
e9f53129
AM		 599 case EM_CRIS:
600 case EM_CRX:
2b0337b0 601 case EM_D30V:
252b5132 602 case EM_CYGNUS_D30V:
2b0337b0 603 case EM_FR30:
252b5132 604 case EM_CYGNUS_FR30:
5c70f934 605 case EM_CYGNUS_FRV:
e9f53129
AM		 606 case EM_H8S:
607 case EM_H8_300:
608 case EM_H8_300H:
800eeca4 609 case EM_IA_64:
1e4cf259
NC		 610 case EM_IP2K:
611 case EM_IP2K_OLD:
3b36097d 612 case EM_IQ2000:
84e94c90 613 case EM_LATTICEMICO32:
ff7eeb89 614 case EM_M32C_OLD:
49f58d10 615 case EM_M32C:
e9f53129
AM		 616 case EM_M32R:
617 case EM_MCORE:
15ab5209 618 case EM_CYGNUS_MEP:
a3c62988 619 case EM_METAG:
e9f53129
AM		 620 case EM_MMIX:
621 case EM_MN10200:
622 case EM_CYGNUS_MN10200:
623 case EM_MN10300:
624 case EM_CYGNUS_MN10300:
5506d11a 625 case EM_MOXIE:
e9f53129
AM		 626 case EM_MSP430:
627 case EM_MSP430_OLD:
d031aafb 628 case EM_MT:
64fd6348 629 case EM_NIOS32:
e9f53129
AM		 630 case EM_PPC64:
631 case EM_PPC:
99c513f6 632 case EM_RL78:
c7927a3c 633 case EM_RX:
e9f53129
AM		 634 case EM_S390:
635 case EM_S390_OLD:
636 case EM_SH:
637 case EM_SPARC:
638 case EM_SPARC32PLUS:
639 case EM_SPARCV9:
640 case EM_SPU:
40b36596 641 case EM_TI_C6000:
aa137e4d
NC		 642 case EM_TILEGX:
643 case EM_TILEPRO:
708e2187 644 case EM_V800:
e9f53129
AM		 645 case EM_V850:
646 case EM_CYGNUS_V850:
647 case EM_VAX:
648 case EM_X86_64:
8a9036a4 649 case EM_L1OM:
7a9068fe 650 case EM_K1OM:
e9f53129
AM		 651 case EM_XSTORMY16:
652 case EM_XTENSA:
653 case EM_XTENSA_OLD:
7ba29e2a
NC		 654 case EM_MICROBLAZE:
655 case EM_MICROBLAZE_OLD:
9c19a809 656 return TRUE;
103f02d3 657
e9f53129
AM		 658 case EM_68HC05:
659 case EM_68HC08:
660 case EM_68HC11:
661 case EM_68HC16:
662 case EM_FX66:
663 case EM_ME16:
d1133906 664 case EM_MMA:
d1133906
NC		 665 case EM_NCPU:
666 case EM_NDR1:
e9f53129 667 case EM_PCP:
d1133906 668 case EM_ST100:
e9f53129 669 case EM_ST19:
d1133906 670 case EM_ST7:
e9f53129
AM		 671 case EM_ST9PLUS:
672 case EM_STARCORE:
d1133906 673 case EM_SVX:
e9f53129 674 case EM_TINYJ:
9c19a809
NC		 675 default:
676 warn (_("Don't know about relocations on this machine architecture\n"));
677 return FALSE;
678 }
679}
252b5132 680
9c19a809 681static int
2cf0635d 682slurp_rela_relocs (FILE * file,
d3ba0551
AM		 683 unsigned long rel_offset,
684 unsigned long rel_size,
2cf0635d
NC		 685 Elf_Internal_Rela ** relasp,
686 unsigned long * nrelasp)
9c19a809 687{
2cf0635d 688 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 689 unsigned long nrelas;
690 unsigned int i;
252b5132 691
4d6ed7c8
NC		 692 if (is_32bit_elf)
693 {
2cf0635d 694 Elf32_External_Rela * erelas;
103f02d3 695
3f5e193b 696 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 697 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 698 if (!erelas)
699 return 0;
252b5132 700
4d6ed7c8 701 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 702
3f5e193b
NC		 703 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
704 sizeof (Elf_Internal_Rela));
103f02d3 705
4d6ed7c8
NC		 706 if (relas == NULL)
707 {
c256ffe7 708 free (erelas);
591a748a 709 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 710 return 0;
711 }
103f02d3 712
4d6ed7c8
NC		 713 for (i = 0; i < nrelas; i++)
714 {
715 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
716 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 717 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 718 }
103f02d3 719
4d6ed7c8
NC		 720 free (erelas);
721 }
722 else
723 {
2cf0635d 724 Elf64_External_Rela * erelas;
103f02d3 725
3f5e193b 726 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 727 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 728 if (!erelas)
729 return 0;
4d6ed7c8
NC		 730
731 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 732
3f5e193b
NC		 733 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
734 sizeof (Elf_Internal_Rela));
103f02d3 735
4d6ed7c8
NC		 736 if (relas == NULL)
737 {
c256ffe7 738 free (erelas);
591a748a 739 error (_("out of memory parsing relocs\n"));
4d6ed7c8 740 return 0;
9c19a809 741 }
4d6ed7c8
NC		 742
743 for (i = 0; i < nrelas; i++)
9c19a809 744 {
66543521
AM		 745 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
746 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 747 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 748
749 /* The #ifdef BFD64 below is to prevent a compile time
750 warning. We know that if we do not have a 64 bit data
751 type that we will never execute this code anyway. */
752#ifdef BFD64
753 if (elf_header.e_machine == EM_MIPS
754 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
755 {
756 /* In little-endian objects, r_info isn't really a
757 64-bit little-endian value: it has a 32-bit
758 little-endian symbol index followed by four
759 individual byte fields. Reorder INFO
760 accordingly. */
91d6fa6a
NC		 761 bfd_vma inf = relas[i].r_info;
762 inf = (((inf & 0xffffffff) << 32)
763 | ((inf >> 56) & 0xff)
764 | ((inf >> 40) & 0xff00)
765 | ((inf >> 24) & 0xff0000)
766 | ((inf >> 8) & 0xff000000));
767 relas[i].r_info = inf;
861fb55a
DJ		 768 }
769#endif /* BFD64 */
4d6ed7c8 770 }
103f02d3 771
4d6ed7c8
NC		 772 free (erelas);
773 }
774 *relasp = relas;
775 *nrelasp = nrelas;
776 return 1;
777}
103f02d3 778
4d6ed7c8 779static int
2cf0635d 780slurp_rel_relocs (FILE * file,
d3ba0551
AM		 781 unsigned long rel_offset,
782 unsigned long rel_size,
2cf0635d
NC		 783 Elf_Internal_Rela ** relsp,
784 unsigned long * nrelsp)
4d6ed7c8 785{
2cf0635d 786 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 787 unsigned long nrels;
788 unsigned int i;
103f02d3 789
4d6ed7c8
NC		 790 if (is_32bit_elf)
791 {
2cf0635d 792 Elf32_External_Rel * erels;
103f02d3 793
3f5e193b 794 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 795 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 796 if (!erels)
797 return 0;
103f02d3 798
4d6ed7c8 799 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 800
3f5e193b 801 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 802
4d6ed7c8
NC		 803 if (rels == NULL)
804 {
c256ffe7 805 free (erels);
591a748a 806 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 807 return 0;
808 }
809
810 for (i = 0; i < nrels; i++)
811 {
812 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
813 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 814 rels[i].r_addend = 0;
9ea033b2 815 }
4d6ed7c8
NC		 816
817 free (erels);
9c19a809
NC		 818 }
819 else
820 {
2cf0635d 821 Elf64_External_Rel * erels;
9ea033b2 822
3f5e193b 823 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 824 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 825 if (!erels)
826 return 0;
103f02d3 827
4d6ed7c8 828 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 829
3f5e193b 830 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 831
4d6ed7c8 832 if (rels == NULL)
9c19a809 833 {
c256ffe7 834 free (erels);
591a748a 835 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 836 return 0;
837 }
103f02d3 838
4d6ed7c8
NC		 839 for (i = 0; i < nrels; i++)
840 {
66543521
AM		 841 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
842 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 843 rels[i].r_addend = 0;
861fb55a
DJ		 844
845 /* The #ifdef BFD64 below is to prevent a compile time
846 warning. We know that if we do not have a 64 bit data
847 type that we will never execute this code anyway. */
848#ifdef BFD64
849 if (elf_header.e_machine == EM_MIPS
850 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
851 {
852 /* In little-endian objects, r_info isn't really a
853 64-bit little-endian value: it has a 32-bit
854 little-endian symbol index followed by four
855 individual byte fields. Reorder INFO
856 accordingly. */
91d6fa6a
NC		 857 bfd_vma inf = rels[i].r_info;
858 inf = (((inf & 0xffffffff) << 32)
859 | ((inf >> 56) & 0xff)
860 | ((inf >> 40) & 0xff00)
861 | ((inf >> 24) & 0xff0000)
862 | ((inf >> 8) & 0xff000000));
863 rels[i].r_info = inf;
861fb55a
DJ		 864 }
865#endif /* BFD64 */
4d6ed7c8 866 }
103f02d3 867
4d6ed7c8
NC		 868 free (erels);
869 }
870 *relsp = rels;
871 *nrelsp = nrels;
872 return 1;
873}
103f02d3 874
aca88567
NC		 875/* Returns the reloc type extracted from the reloc info field. */
876
877static unsigned int
878get_reloc_type (bfd_vma reloc_info)
879{
880 if (is_32bit_elf)
881 return ELF32_R_TYPE (reloc_info);
882
883 switch (elf_header.e_machine)
884 {
885 case EM_MIPS:
886 /* Note: We assume that reloc_info has already been adjusted for us. */
887 return ELF64_MIPS_R_TYPE (reloc_info);
888
889 case EM_SPARCV9:
890 return ELF64_R_TYPE_ID (reloc_info);
891
892 default:
893 return ELF64_R_TYPE (reloc_info);
894 }
895}
896
897/* Return the symbol index extracted from the reloc info field. */
898
899static bfd_vma
900get_reloc_symindex (bfd_vma reloc_info)
901{
902 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
903}
904
13761a11
NC		 905static inline bfd_boolean
906uses_msp430x_relocs (void)
907{
908 return
909 elf_header.e_machine == EM_MSP430 /* Paranoia. */
910 /* GCC uses osabi == ELFOSBI_STANDALONE. */
911 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
912 /* TI compiler uses ELFOSABI_NONE. */
913 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
914}
915
d3ba0551
AM		 916/* Display the contents of the relocation data found at the specified
917 offset. */
ee42cf8c 918
41e92641 919static void
2cf0635d 920dump_relocations (FILE * file,
d3ba0551
AM		 921 unsigned long rel_offset,
922 unsigned long rel_size,
2cf0635d 923 Elf_Internal_Sym * symtab,
d3ba0551 924 unsigned long nsyms,
2cf0635d 925 char * strtab,
d79b3d50 926 unsigned long strtablen,
d3ba0551 927 int is_rela)
4d6ed7c8 928{
b34976b6 929 unsigned int i;
2cf0635d 930 Elf_Internal_Rela * rels;
103f02d3 931
4d6ed7c8
NC		 932 if (is_rela == UNKNOWN)
933 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 934
4d6ed7c8
NC		 935 if (is_rela)
936 {
c8286bd1 937 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 938 return;
4d6ed7c8
NC		 939 }
940 else
941 {
942 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 943 return;
252b5132
RH		 944 }
945
410f7a12
L		 946 if (is_32bit_elf)
947 {
948 if (is_rela)
2c71103e
NC		 949 {
950 if (do_wide)
951 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
952 else
953 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
954 }
410f7a12 955 else
2c71103e
NC		 956 {
957 if (do_wide)
958 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
959 else
960 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
961 }
410f7a12 962 }
252b5132 963 else
410f7a12
L		 964 {
965 if (is_rela)
2c71103e
NC		 966 {
967 if (do_wide)
8beeaeb7 968 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 969 else
970 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
971 }
410f7a12 972 else
2c71103e
NC		 973 {
974 if (do_wide)
8beeaeb7 975 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 976 else
977 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
978 }
410f7a12 979 }
252b5132
RH		 980
981 for (i = 0; i < rel_size; i++)
982 {
2cf0635d 983 const char * rtype;
b34976b6 984 bfd_vma offset;
91d6fa6a 985 bfd_vma inf;
b34976b6
AM		 986 bfd_vma symtab_index;
987 bfd_vma type;
103f02d3 988
b34976b6 989 offset = rels[i].r_offset;
91d6fa6a 990 inf = rels[i].r_info;
103f02d3 991
91d6fa6a
NC		 992 type = get_reloc_type (inf);
993 symtab_index = get_reloc_symindex (inf);
252b5132 994
410f7a12
L		 995 if (is_32bit_elf)
996 {
39dbeff8
AM		 997 printf ("%8.8lx %8.8lx ",
998 (unsigned long) offset & 0xffffffff,
91d6fa6a 999 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1000 }
1001 else
1002 {
39dbeff8
AM		 1003#if BFD_HOST_64BIT_LONG
1004 printf (do_wide
1005 ? "%16.16lx %16.16lx "
1006 : "%12.12lx %12.12lx ",
91d6fa6a 1007 offset, inf);
39dbeff8 1008#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1009#ifndef __MSVCRT__
39dbeff8
AM		 1010 printf (do_wide
1011 ? "%16.16llx %16.16llx "
1012 : "%12.12llx %12.12llx ",
91d6fa6a 1013 offset, inf);
6e3d6dc1
NC		 1014#else
1015 printf (do_wide
1016 ? "%16.16I64x %16.16I64x "
1017 : "%12.12I64x %12.12I64x ",
91d6fa6a 1018 offset, inf);
6e3d6dc1 1019#endif
39dbeff8 1020#else
2c71103e
NC		 1021 printf (do_wide
1022 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1023 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1024 _bfd_int64_high (offset),
1025 _bfd_int64_low (offset),
91d6fa6a
NC		 1026 _bfd_int64_high (inf),
1027 _bfd_int64_low (inf));
9ea033b2 1028#endif
410f7a12 1029 }
103f02d3 1030
252b5132
RH		 1031 switch (elf_header.e_machine)
1032 {
1033 default:
1034 rtype = NULL;
1035 break;
1036
a06ea964
NC		 1037 case EM_AARCH64:
1038 rtype = elf_aarch64_reloc_type (type);
1039 break;
1040
2b0337b0 1041 case EM_M32R:
252b5132 1042 case EM_CYGNUS_M32R:
9ea033b2 1043 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1044 break;
1045
1046 case EM_386:
1047 case EM_486:
9ea033b2 1048 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1049 break;
1050
ba2685cc
AM		 1051 case EM_68HC11:
1052 case EM_68HC12:
1053 rtype = elf_m68hc11_reloc_type (type);
1054 break;
75751cd9 1055
252b5132 1056 case EM_68K:
9ea033b2 1057 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1058 break;
1059
63fcb9e9 1060 case EM_960:
9ea033b2 1061 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1062 break;
1063
adde6300 1064 case EM_AVR:
2b0337b0 1065 case EM_AVR_OLD:
adde6300
AM		 1066 rtype = elf_avr_reloc_type (type);
1067 break;
1068
9ea033b2
NC		 1069 case EM_OLD_SPARCV9:
1070 case EM_SPARC32PLUS:
1071 case EM_SPARCV9:
252b5132 1072 case EM_SPARC:
9ea033b2 1073 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1074 break;
1075
e9f53129
AM		 1076 case EM_SPU:
1077 rtype = elf_spu_reloc_type (type);
1078 break;
1079
708e2187
NC		 1080 case EM_V800:
1081 rtype = v800_reloc_type (type);
1082 break;
2b0337b0 1083 case EM_V850:
252b5132 1084 case EM_CYGNUS_V850:
9ea033b2 1085 rtype = v850_reloc_type (type);
252b5132
RH		 1086 break;
1087
2b0337b0 1088 case EM_D10V:
252b5132 1089 case EM_CYGNUS_D10V:
9ea033b2 1090 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1091 break;
1092
2b0337b0 1093 case EM_D30V:
252b5132 1094 case EM_CYGNUS_D30V:
9ea033b2 1095 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1096 break;
1097
d172d4ba
NC		 1098 case EM_DLX:
1099 rtype = elf_dlx_reloc_type (type);
1100 break;
1101
252b5132 1102 case EM_SH:
9ea033b2 1103 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1104 break;
1105
2b0337b0 1106 case EM_MN10300:
252b5132 1107 case EM_CYGNUS_MN10300:
9ea033b2 1108 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1109 break;
1110
2b0337b0 1111 case EM_MN10200:
252b5132 1112 case EM_CYGNUS_MN10200:
9ea033b2 1113 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1114 break;
1115
2b0337b0 1116 case EM_FR30:
252b5132 1117 case EM_CYGNUS_FR30:
9ea033b2 1118 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1119 break;
1120
ba2685cc
AM		 1121 case EM_CYGNUS_FRV:
1122 rtype = elf_frv_reloc_type (type);
1123 break;
5c70f934 1124
252b5132 1125 case EM_MCORE:
9ea033b2 1126 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1127 break;
1128
3c3bdf30
NC		 1129 case EM_MMIX:
1130 rtype = elf_mmix_reloc_type (type);
1131 break;
1132
5506d11a
AM		 1133 case EM_MOXIE:
1134 rtype = elf_moxie_reloc_type (type);
1135 break;
1136
2469cfa2 1137 case EM_MSP430:
13761a11
NC		 1138 if (uses_msp430x_relocs ())
1139 {
1140 rtype = elf_msp430x_reloc_type (type);
1141 break;
1142 }
2469cfa2
NC		 1143 case EM_MSP430_OLD:
1144 rtype = elf_msp430_reloc_type (type);
1145 break;
1146
252b5132 1147 case EM_PPC:
9ea033b2 1148 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1149 break;
1150
c833c019
AM		 1151 case EM_PPC64:
1152 rtype = elf_ppc64_reloc_type (type);
1153 break;
1154
252b5132 1155 case EM_MIPS:
4fe85591 1156 case EM_MIPS_RS3_LE:
9ea033b2 1157 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1158 break;
1159
1160 case EM_ALPHA:
9ea033b2 1161 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1162 break;
1163
1164 case EM_ARM:
9ea033b2 1165 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1166 break;
1167
584da044 1168 case EM_ARC:
9ea033b2 1169 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1170 break;
1171
1172 case EM_PARISC:
69e617ca 1173 rtype = elf_hppa_reloc_type (type);
252b5132 1174 break;
7d466069 1175
b8720f9d
JL		 1176 case EM_H8_300:
1177 case EM_H8_300H:
1178 case EM_H8S:
1179 rtype = elf_h8_reloc_type (type);
1180 break;
1181
3b16e843
NC		 1182 case EM_OPENRISC:
1183 case EM_OR32:
1184 rtype = elf_or32_reloc_type (type);
1185 break;
1186
7d466069 1187 case EM_PJ:
2b0337b0 1188 case EM_PJ_OLD:
7d466069
ILT		 1189 rtype = elf_pj_reloc_type (type);
1190 break;
800eeca4
JW		 1191 case EM_IA_64:
1192 rtype = elf_ia64_reloc_type (type);
1193 break;
1b61cf92
HPN		 1194
1195 case EM_CRIS:
1196 rtype = elf_cris_reloc_type (type);
1197 break;
535c37ff
JE		 1198
1199 case EM_860:
1200 rtype = elf_i860_reloc_type (type);
1201 break;
bcedfee6
NC		 1202
1203 case EM_X86_64:
8a9036a4 1204 case EM_L1OM:
7a9068fe 1205 case EM_K1OM:
bcedfee6
NC		 1206 rtype = elf_x86_64_reloc_type (type);
1207 break;
a85d7ed0 1208
35b1837e
AM		 1209 case EM_S370:
1210 rtype = i370_reloc_type (type);
1211 break;
1212
53c7db4b
KH		 1213 case EM_S390_OLD:
1214 case EM_S390:
1215 rtype = elf_s390_reloc_type (type);
1216 break;
93fbbb04 1217
1c0d3aa6
NC		 1218 case EM_SCORE:
1219 rtype = elf_score_reloc_type (type);
1220 break;
1221
93fbbb04
GK		 1222 case EM_XSTORMY16:
1223 rtype = elf_xstormy16_reloc_type (type);
1224 break;
179d3252 1225
1fe1f39c
NC		 1226 case EM_CRX:
1227 rtype = elf_crx_reloc_type (type);
1228 break;
1229
179d3252
JT		 1230 case EM_VAX:
1231 rtype = elf_vax_reloc_type (type);
1232 break;
1e4cf259 1233
cfb8c092
NC		 1234 case EM_ADAPTEVA_EPIPHANY:
1235 rtype = elf_epiphany_reloc_type (type);
1236 break;
1237
1e4cf259
NC		 1238 case EM_IP2K:
1239 case EM_IP2K_OLD:
1240 rtype = elf_ip2k_reloc_type (type);
1241 break;
3b36097d
SC		 1242
1243 case EM_IQ2000:
1244 rtype = elf_iq2000_reloc_type (type);
1245 break;
88da6820
NC		 1246
1247 case EM_XTENSA_OLD:
1248 case EM_XTENSA:
1249 rtype = elf_xtensa_reloc_type (type);
1250 break;
a34e3ecb 1251
84e94c90
NC		 1252 case EM_LATTICEMICO32:
1253 rtype = elf_lm32_reloc_type (type);
1254 break;
1255
ff7eeb89 1256 case EM_M32C_OLD:
49f58d10
JB		 1257 case EM_M32C:
1258 rtype = elf_m32c_reloc_type (type);
1259 break;
1260
d031aafb
NS		 1261 case EM_MT:
1262 rtype = elf_mt_reloc_type (type);
a34e3ecb 1263 break;
1d65ded4
CM		 1264
1265 case EM_BLACKFIN:
1266 rtype = elf_bfin_reloc_type (type);
1267 break;
15ab5209
DB		 1268
1269 case EM_CYGNUS_MEP:
1270 rtype = elf_mep_reloc_type (type);
1271 break;
60bca95a
NC		 1272
1273 case EM_CR16:
1274 rtype = elf_cr16_reloc_type (type);
1275 break;
dd24e3da 1276
7ba29e2a
NC		 1277 case EM_MICROBLAZE:
1278 case EM_MICROBLAZE_OLD:
1279 rtype = elf_microblaze_reloc_type (type);
1280 break;
c7927a3c 1281
99c513f6
DD		 1282 case EM_RL78:
1283 rtype = elf_rl78_reloc_type (type);
1284 break;
1285
c7927a3c
NC		 1286 case EM_RX:
1287 rtype = elf_rx_reloc_type (type);
1288 break;
c29aca4a 1289
a3c62988
NC		 1290 case EM_METAG:
1291 rtype = elf_metag_reloc_type (type);
1292 break;
1293
c29aca4a
NC		 1294 case EM_XC16X:
1295 case EM_C166:
1296 rtype = elf_xc16x_reloc_type (type);
1297 break;
40b36596
JM		 1298
1299 case EM_TI_C6000:
1300 rtype = elf_tic6x_reloc_type (type);
1301 break;
aa137e4d
NC		 1302
1303 case EM_TILEGX:
1304 rtype = elf_tilegx_reloc_type (type);
1305 break;
1306
1307 case EM_TILEPRO:
1308 rtype = elf_tilepro_reloc_type (type);
1309 break;
f6c1a2d5
NC		 1310
1311 case EM_XGATE:
1312 rtype = elf_xgate_reloc_type (type);
1313 break;
36591ba1
SL		 1314
1315 case EM_ALTERA_NIOS2:
1316 rtype = elf_nios2_reloc_type (type);
1317 break;
252b5132
RH		 1318 }
1319
1320 if (rtype == NULL)
39dbeff8 1321 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1322 else
8beeaeb7 1323 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1324
7ace3541 1325 if (elf_header.e_machine == EM_ALPHA
157c2599 1326 && rtype != NULL
7ace3541
RH		 1327 && streq (rtype, "R_ALPHA_LITUSE")
1328 && is_rela)
1329 {
1330 switch (rels[i].r_addend)
1331 {
1332 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1333 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1334 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1335 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1336 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1337 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1338 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1339 default: rtype = NULL;
1340 }
1341 if (rtype)
1342 printf (" (%s)", rtype);
1343 else
1344 {
1345 putchar (' ');
1346 printf (_("<unknown addend: %lx>"),
1347 (unsigned long) rels[i].r_addend);
1348 }
1349 }
1350 else if (symtab_index)
252b5132 1351 {
af3fc3bc 1352 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1353 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1354 else
19936277 1355 {
2cf0635d 1356 Elf_Internal_Sym * psym;
19936277 1357
af3fc3bc 1358 psym = symtab + symtab_index;
103f02d3 1359
af3fc3bc 1360 printf (" ");
171191ba 1361
d8045f23
NC		 1362 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1363 {
1364 const char * name;
1365 unsigned int len;
1366 unsigned int width = is_32bit_elf ? 8 : 14;
1367
1368 /* Relocations against GNU_IFUNC symbols do not use the value
1369 of the symbol as the address to relocate against. Instead
1370 they invoke the function named by the symbol and use its
1371 result as the address for relocation.
1372
1373 To indicate this to the user, do not display the value of
1374 the symbol in the "Symbols's Value" field. Instead show
1375 its name followed by () as a hint that the symbol is
1376 invoked. */
1377
1378 if (strtab == NULL
1379 || psym->st_name == 0
1380 || psym->st_name >= strtablen)
1381 name = "??";
1382 else
1383 name = strtab + psym->st_name;
1384
1385 len = print_symbol (width, name);
1386 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1387 }
1388 else
1389 {
1390 print_vma (psym->st_value, LONG_HEX);
171191ba 1391
d8045f23
NC		 1392 printf (is_32bit_elf ? " " : " ");
1393 }
103f02d3 1394
af3fc3bc 1395 if (psym->st_name == 0)
f1ef08cb 1396 {
2cf0635d 1397 const char * sec_name = "<null>";
f1ef08cb
AM		 1398 char name_buf[40];
1399
1400 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1401 {
4fbb74a6
AM		 1402 if (psym->st_shndx < elf_header.e_shnum)
1403 sec_name
1404 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1405 else if (psym->st_shndx == SHN_ABS)
1406 sec_name = "ABS";
1407 else if (psym->st_shndx == SHN_COMMON)
1408 sec_name = "COMMON";
ac145307
BS		 1409 else if ((elf_header.e_machine == EM_MIPS
1410 && psym->st_shndx == SHN_MIPS_SCOMMON)
1411 || (elf_header.e_machine == EM_TI_C6000
1412 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1413 sec_name = "SCOMMON";
1414 else if (elf_header.e_machine == EM_MIPS
1415 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1416 sec_name = "SUNDEF";
8a9036a4 1417 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1418 || elf_header.e_machine == EM_L1OM
1419 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1420 && psym->st_shndx == SHN_X86_64_LCOMMON)
1421 sec_name = "LARGE_COMMON";
9ce701e2
L		 1422 else if (elf_header.e_machine == EM_IA_64
1423 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1424 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1425 sec_name = "ANSI_COM";
28f997cf 1426 else if (is_ia64_vms ()
148b93f2
NC		 1427 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1428 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1429 else
1430 {
1431 sprintf (name_buf, "<section 0x%x>",
1432 (unsigned int) psym->st_shndx);
1433 sec_name = name_buf;
1434 }
1435 }
1436 print_symbol (22, sec_name);
1437 }
af3fc3bc 1438 else if (strtab == NULL)
d79b3d50 1439 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1440 else if (psym->st_name >= strtablen)
d79b3d50 1441 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1442 else
2c71103e 1443 print_symbol (22, strtab + psym->st_name);
103f02d3 1444
af3fc3bc 1445 if (is_rela)
171191ba 1446 {
598aaa76 1447 bfd_signed_vma off = rels[i].r_addend;
171191ba 1448
91d6fa6a 1449 if (off < 0)
598aaa76 1450 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1451 else
598aaa76 1452 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1453 }
19936277 1454 }
252b5132 1455 }
1b228002 1456 else if (is_rela)
f7a99963 1457 {
e04d7088
L		 1458 bfd_signed_vma off = rels[i].r_addend;
1459
1460 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1461 if (off < 0)
1462 printf ("-%" BFD_VMA_FMT "x", - off);
1463 else
1464 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1465 }
252b5132 1466
157c2599
NC		 1467 if (elf_header.e_machine == EM_SPARCV9
1468 && rtype != NULL
1469 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1470 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1471
252b5132 1472 putchar ('\n');
2c71103e 1473
aca88567 1474#ifdef BFD64
53c7db4b 1475 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1476 {
91d6fa6a
NC		 1477 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1478 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1479 const char * rtype2 = elf_mips_reloc_type (type2);
1480 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1481
2c71103e
NC		 1482 printf (" Type2: ");
1483
1484 if (rtype2 == NULL)
39dbeff8
AM		 1485 printf (_("unrecognized: %-7lx"),
1486 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1487 else
1488 printf ("%-17.17s", rtype2);
1489
18bd398b 1490 printf ("\n Type3: ");
2c71103e
NC		 1491
1492 if (rtype3 == NULL)
39dbeff8
AM		 1493 printf (_("unrecognized: %-7lx"),
1494 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1495 else
1496 printf ("%-17.17s", rtype3);
1497
53c7db4b 1498 putchar ('\n');
2c71103e 1499 }
aca88567 1500#endif /* BFD64 */
252b5132
RH		 1501 }
1502
c8286bd1 1503 free (rels);
252b5132
RH		 1504}
1505
1506static const char *
d3ba0551 1507get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1508{
1509 switch (type)
1510 {
1511 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1512 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1513 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1514 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1515 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1516 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1517 case DT_MIPS_MSYM: return "MIPS_MSYM";
1518 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1519 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1520 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1521 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1522 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1523 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1524 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1525 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1526 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1527 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1528 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1529 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1530 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1531 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1532 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1533 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1534 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1535 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1536 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1537 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1538 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1539 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1540 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1541 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1542 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1543 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1544 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1545 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1546 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1547 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1548 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1549 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1550 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1551 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1552 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1553 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1554 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1555 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1556 default:
1557 return NULL;
1558 }
1559}
1560
9a097730 1561static const char *
d3ba0551 1562get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1563{
1564 switch (type)
1565 {
1566 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1567 default:
1568 return NULL;
1569 }
103f02d3
UD		 1570}
1571
7490d522
AM		 1572static const char *
1573get_ppc_dynamic_type (unsigned long type)
1574{
1575 switch (type)
1576 {
a7f2871e 1577 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1578 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1579 default:
1580 return NULL;
1581 }
1582}
1583
f1cb7e17 1584static const char *
d3ba0551 1585get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1586{
1587 switch (type)
1588 {
a7f2871e
AM		 1589 case DT_PPC64_GLINK: return "PPC64_GLINK";
1590 case DT_PPC64_OPD: return "PPC64_OPD";
1591 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1592 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1593 default:
1594 return NULL;
1595 }
1596}
1597
103f02d3 1598static const char *
d3ba0551 1599get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1600{
1601 switch (type)
1602 {
1603 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1604 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1605 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1606 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1607 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1608 case DT_HP_PREINIT: return "HP_PREINIT";
1609 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1610 case DT_HP_NEEDED: return "HP_NEEDED";
1611 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1612 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1613 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1614 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1615 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1616 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1617 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1618 case DT_HP_FILTERED: return "HP_FILTERED";
1619 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1620 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1621 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1622 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1623 case DT_PLT: return "PLT";
1624 case DT_PLT_SIZE: return "PLT_SIZE";
1625 case DT_DLT: return "DLT";
1626 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1627 default:
1628 return NULL;
1629 }
1630}
9a097730 1631
ecc51f48 1632static const char *
d3ba0551 1633get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1634{
1635 switch (type)
1636 {
148b93f2
NC		 1637 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1638 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1639 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1640 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1641 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1642 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1643 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1644 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1645 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1646 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1647 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1648 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1649 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1650 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1651 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1652 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1653 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1654 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1655 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1656 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1657 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1658 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1659 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1660 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1661 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1662 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1663 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1664 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1665 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1666 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1667 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1668 default:
1669 return NULL;
1670 }
1671}
1672
fabcb361
RH		 1673static const char *
1674get_alpha_dynamic_type (unsigned long type)
1675{
1676 switch (type)
1677 {
1678 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1679 default:
1680 return NULL;
1681 }
1682}
1683
1c0d3aa6
NC		 1684static const char *
1685get_score_dynamic_type (unsigned long type)
1686{
1687 switch (type)
1688 {
1689 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1690 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1691 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1692 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1693 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1694 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1695 default:
1696 return NULL;
1697 }
1698}
1699
40b36596
JM		 1700static const char *
1701get_tic6x_dynamic_type (unsigned long type)
1702{
1703 switch (type)
1704 {
1705 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1706 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1707 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1708 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1709 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1710 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1711 default:
1712 return NULL;
1713 }
1714}
1c0d3aa6 1715
36591ba1
SL		 1716static const char *
1717get_nios2_dynamic_type (unsigned long type)
1718{
1719 switch (type)
1720 {
1721 case DT_NIOS2_GP: return "NIOS2_GP";
1722 default:
1723 return NULL;
1724 }
1725}
1726
252b5132 1727static const char *
d3ba0551 1728get_dynamic_type (unsigned long type)
252b5132 1729{
e9e44622 1730 static char buff[64];
252b5132
RH		 1731
1732 switch (type)
1733 {
1734 case DT_NULL: return "NULL";
1735 case DT_NEEDED: return "NEEDED";
1736 case DT_PLTRELSZ: return "PLTRELSZ";
1737 case DT_PLTGOT: return "PLTGOT";
1738 case DT_HASH: return "HASH";
1739 case DT_STRTAB: return "STRTAB";
1740 case DT_SYMTAB: return "SYMTAB";
1741 case DT_RELA: return "RELA";
1742 case DT_RELASZ: return "RELASZ";
1743 case DT_RELAENT: return "RELAENT";
1744 case DT_STRSZ: return "STRSZ";
1745 case DT_SYMENT: return "SYMENT";
1746 case DT_INIT: return "INIT";
1747 case DT_FINI: return "FINI";
1748 case DT_SONAME: return "SONAME";
1749 case DT_RPATH: return "RPATH";
1750 case DT_SYMBOLIC: return "SYMBOLIC";
1751 case DT_REL: return "REL";
1752 case DT_RELSZ: return "RELSZ";
1753 case DT_RELENT: return "RELENT";
1754 case DT_PLTREL: return "PLTREL";
1755 case DT_DEBUG: return "DEBUG";
1756 case DT_TEXTREL: return "TEXTREL";
1757 case DT_JMPREL: return "JMPREL";
1758 case DT_BIND_NOW: return "BIND_NOW";
1759 case DT_INIT_ARRAY: return "INIT_ARRAY";
1760 case DT_FINI_ARRAY: return "FINI_ARRAY";
1761 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1762 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1763 case DT_RUNPATH: return "RUNPATH";
1764 case DT_FLAGS: return "FLAGS";
2d0e6f43 1765
d1133906
NC		 1766 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1767 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1768
05107a46 1769 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1770 case DT_PLTPADSZ: return "PLTPADSZ";
1771 case DT_MOVEENT: return "MOVEENT";
1772 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1773 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1774 case DT_POSFLAG_1: return "POSFLAG_1";
1775 case DT_SYMINSZ: return "SYMINSZ";
1776 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1777
252b5132 1778 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1779 case DT_CONFIG: return "CONFIG";
1780 case DT_DEPAUDIT: return "DEPAUDIT";
1781 case DT_AUDIT: return "AUDIT";
1782 case DT_PLTPAD: return "PLTPAD";
1783 case DT_MOVETAB: return "MOVETAB";
252b5132 1784 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1785
252b5132 1786 case DT_VERSYM: return "VERSYM";
103f02d3 1787
67a4f2b7
AO		 1788 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1789 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1790 case DT_RELACOUNT: return "RELACOUNT";
1791 case DT_RELCOUNT: return "RELCOUNT";
1792 case DT_FLAGS_1: return "FLAGS_1";
1793 case DT_VERDEF: return "VERDEF";
1794 case DT_VERDEFNUM: return "VERDEFNUM";
1795 case DT_VERNEED: return "VERNEED";
1796 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1797
019148e4 1798 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1799 case DT_USED: return "USED";
1800 case DT_FILTER: return "FILTER";
103f02d3 1801
047b2264
JJ		 1802 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1803 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1804 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1805 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1806 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1807 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1808
252b5132
RH		 1809 default:
1810 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1811 {
2cf0635d 1812 const char * result;
103f02d3 1813
252b5132
RH		 1814 switch (elf_header.e_machine)
1815 {
1816 case EM_MIPS:
4fe85591 1817 case EM_MIPS_RS3_LE:
252b5132
RH		 1818 result = get_mips_dynamic_type (type);
1819 break;
9a097730
RH		 1820 case EM_SPARCV9:
1821 result = get_sparc64_dynamic_type (type);
1822 break;
7490d522
AM		 1823 case EM_PPC:
1824 result = get_ppc_dynamic_type (type);
1825 break;
f1cb7e17
AM		 1826 case EM_PPC64:
1827 result = get_ppc64_dynamic_type (type);
1828 break;
ecc51f48
NC		 1829 case EM_IA_64:
1830 result = get_ia64_dynamic_type (type);
1831 break;
fabcb361
RH		 1832 case EM_ALPHA:
1833 result = get_alpha_dynamic_type (type);
1834 break;
1c0d3aa6
NC		 1835 case EM_SCORE:
1836 result = get_score_dynamic_type (type);
1837 break;
40b36596
JM		 1838 case EM_TI_C6000:
1839 result = get_tic6x_dynamic_type (type);
1840 break;
36591ba1
SL		 1841 case EM_ALTERA_NIOS2:
1842 result = get_nios2_dynamic_type (type);
1843 break;
252b5132
RH		 1844 default:
1845 result = NULL;
1846 break;
1847 }
1848
1849 if (result != NULL)
1850 return result;
1851
e9e44622 1852 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1853 }
eec8f817
DA		 1854 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1855 || (elf_header.e_machine == EM_PARISC
1856 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1857 {
2cf0635d 1858 const char * result;
103f02d3
UD		 1859
1860 switch (elf_header.e_machine)
1861 {
1862 case EM_PARISC:
1863 result = get_parisc_dynamic_type (type);
1864 break;
148b93f2
NC		 1865 case EM_IA_64:
1866 result = get_ia64_dynamic_type (type);
1867 break;
103f02d3
UD		 1868 default:
1869 result = NULL;
1870 break;
1871 }
1872
1873 if (result != NULL)
1874 return result;
1875
e9e44622
JJ		 1876 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1877 type);
103f02d3 1878 }
252b5132 1879 else
e9e44622 1880 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1881
252b5132
RH		 1882 return buff;
1883 }
1884}
1885
1886static char *
d3ba0551 1887get_file_type (unsigned e_type)
252b5132 1888{
b34976b6 1889 static char buff[32];
252b5132
RH		 1890
1891 switch (e_type)
1892 {
1893 case ET_NONE: return _("NONE (None)");
1894 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1895 case ET_EXEC: return _("EXEC (Executable file)");
1896 case ET_DYN: return _("DYN (Shared object file)");
1897 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1898
1899 default:
1900 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1901 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1902 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1903 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1904 else
e9e44622 1905 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1906 return buff;
1907 }
1908}
1909
1910static char *
d3ba0551 1911get_machine_name (unsigned e_machine)
252b5132 1912{
b34976b6 1913 static char buff[64]; /* XXX */
252b5132
RH		 1914
1915 switch (e_machine)
1916 {
c45021f2 1917 case EM_NONE: return _("None");
a06ea964 1918 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1919 case EM_M32: return "WE32100";
1920 case EM_SPARC: return "Sparc";
e9f53129 1921 case EM_SPU: return "SPU";
c45021f2
NC		 1922 case EM_386: return "Intel 80386";
1923 case EM_68K: return "MC68000";
1924 case EM_88K: return "MC88000";
1925 case EM_486: return "Intel 80486";
1926 case EM_860: return "Intel 80860";
1927 case EM_MIPS: return "MIPS R3000";
1928 case EM_S370: return "IBM System/370";
7036c0e1 1929 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1930 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1931 case EM_PARISC: return "HPPA";
252b5132 1932 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1933 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1934 case EM_960: return "Intel 90860";
1935 case EM_PPC: return "PowerPC";
285d1771 1936 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1937 case EM_FR20: return "Fujitsu FR20";
1938 case EM_RH32: return "TRW RH32";
b34976b6 1939 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1940 case EM_ARM: return "ARM";
1941 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1942 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1943 case EM_SPARCV9: return "Sparc v9";
1944 case EM_TRICORE: return "Siemens Tricore";
584da044 1945 case EM_ARC: return "ARC";
c2dcd04e
NC		 1946 case EM_H8_300: return "Renesas H8/300";
1947 case EM_H8_300H: return "Renesas H8/300H";
1948 case EM_H8S: return "Renesas H8S";
1949 case EM_H8_500: return "Renesas H8/500";
30800947 1950 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1951 case EM_MIPS_X: return "Stanford MIPS-X";
1952 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1953 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1954 case EM_CYGNUS_D10V:
1955 case EM_D10V: return "d10v";
1956 case EM_CYGNUS_D30V:
b34976b6 1957 case EM_D30V: return "d30v";
2b0337b0 1958 case EM_CYGNUS_M32R:
26597c86 1959 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1960 case EM_CYGNUS_V850:
708e2187 1961 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 1962 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1963 case EM_CYGNUS_MN10300:
1964 case EM_MN10300: return "mn10300";
1965 case EM_CYGNUS_MN10200:
1966 case EM_MN10200: return "mn10200";
5506d11a 1967 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1968 case EM_CYGNUS_FR30:
1969 case EM_FR30: return "Fujitsu FR30";
b34976b6 1970 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1971 case EM_PJ_OLD:
b34976b6 1972 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1973 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1974 case EM_PCP: return "Siemens PCP";
1975 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1976 case EM_NDR1: return "Denso NDR1 microprocesspr";
1977 case EM_STARCORE: return "Motorola Star*Core processor";
1978 case EM_ME16: return "Toyota ME16 processor";
1979 case EM_ST100: return "STMicroelectronics ST100 processor";
1980 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1981 case EM_PDSP: return "Sony DSP processor";
1982 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1983 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1984 case EM_FX66: return "Siemens FX66 microcontroller";
1985 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1986 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1987 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1988 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1989 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1990 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1991 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1992 case EM_SVX: return "Silicon Graphics SVx";
1993 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1994 case EM_VAX: return "Digital VAX";
2b0337b0 1995 case EM_AVR_OLD:
b34976b6 1996 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1997 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1998 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1999 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2000 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2001 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2002 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2003 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2004 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2005 case EM_L1OM: return "Intel L1OM";
7a9068fe 2006 case EM_K1OM: return "Intel K1OM";
b7498e0e 2007 case EM_S390_OLD:
b34976b6 2008 case EM_S390: return "IBM S/390";
1c0d3aa6 2009 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2010 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 2011 case EM_OPENRISC:
2012 case EM_OR32: return "OpenRISC";
11636f9e 2013 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2014 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2015 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2016 case EM_DLX: return "OpenDLX";
1e4cf259 2017 case EM_IP2K_OLD:
b34976b6 2018 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2019 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2020 case EM_XTENSA_OLD:
2021 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2022 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2023 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2024 case EM_NS32K: return "National Semiconductor 32000 series";
2025 case EM_TPC: return "Tenor Network TPC processor";
2026 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2027 case EM_MAX: return "MAX Processor";
2028 case EM_CR: return "National Semiconductor CompactRISC";
2029 case EM_F2MC16: return "Fujitsu F2MC16";
2030 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2031 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2032 case EM_M32C_OLD:
49f58d10 2033 case EM_M32C: return "Renesas M32c";
d031aafb 2034 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2035 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2036 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2037 case EM_SEP: return "Sharp embedded microprocessor";
2038 case EM_ARCA: return "Arca RISC microprocessor";
2039 case EM_UNICORE: return "Unicore";
2040 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2041 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2042 case EM_NIOS32: return "Altera Nios";
2043 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2044 case EM_C166:
d70c5fc7 2045 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2046 case EM_M16C: return "Renesas M16C series microprocessors";
2047 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2048 case EM_CE: return "Freescale Communication Engine RISC core";
2049 case EM_TSK3000: return "Altium TSK3000 core";
2050 case EM_RS08: return "Freescale RS08 embedded processor";
2051 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2052 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2053 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2054 case EM_SE_C17: return "Seiko Epson C17 family";
2055 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2056 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2057 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2058 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2059 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2060 case EM_R32C: return "Renesas R32C series microprocessors";
2061 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2062 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2063 case EM_8051: return "Intel 8051 and variants";
2064 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2065 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2066 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2067 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2068 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2069 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2070 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2071 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2072 case EM_CR16:
f6c1a2d5 2073 case EM_MICROBLAZE:
7ba29e2a 2074 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2075 case EM_RL78: return "Renesas RL78";
c7927a3c 2076 case EM_RX: return "Renesas RX";
a3c62988 2077 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2078 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2079 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2080 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2081 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2082 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2083 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2084 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2085 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2086 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2087 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2088 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2089 default:
35d9dd2f 2090 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2091 return buff;
2092 }
2093}
2094
f3485b74 2095static void
d3ba0551 2096decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2097{
2098 unsigned eabi;
2099 int unknown = 0;
2100
2101 eabi = EF_ARM_EABI_VERSION (e_flags);
2102 e_flags &= ~ EF_ARM_EABIMASK;
2103
2104 /* Handle "generic" ARM flags. */
2105 if (e_flags & EF_ARM_RELEXEC)
2106 {
2107 strcat (buf, ", relocatable executable");
2108 e_flags &= ~ EF_ARM_RELEXEC;
2109 }
76da6bbe 2110
f3485b74
NC		 2111 if (e_flags & EF_ARM_HASENTRY)
2112 {
2113 strcat (buf, ", has entry point");
2114 e_flags &= ~ EF_ARM_HASENTRY;
2115 }
76da6bbe 2116
f3485b74
NC		 2117 /* Now handle EABI specific flags. */
2118 switch (eabi)
2119 {
2120 default:
2c71103e 2121 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2122 if (e_flags)
2123 unknown = 1;
2124 break;
2125
2126 case EF_ARM_EABI_VER1:
a5bcd848 2127 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2128 while (e_flags)
2129 {
2130 unsigned flag;
76da6bbe 2131
f3485b74
NC		 2132 /* Process flags one bit at a time. */
2133 flag = e_flags & - e_flags;
2134 e_flags &= ~ flag;
76da6bbe 2135
f3485b74
NC		 2136 switch (flag)
2137 {
a5bcd848 2138 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2139 strcat (buf, ", sorted symbol tables");
2140 break;
76da6bbe 2141
f3485b74
NC		 2142 default:
2143 unknown = 1;
2144 break;
2145 }
2146 }
2147 break;
76da6bbe 2148
a5bcd848
PB		 2149 case EF_ARM_EABI_VER2:
2150 strcat (buf, ", Version2 EABI");
2151 while (e_flags)
2152 {
2153 unsigned flag;
2154
2155 /* Process flags one bit at a time. */
2156 flag = e_flags & - e_flags;
2157 e_flags &= ~ flag;
2158
2159 switch (flag)
2160 {
2161 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2162 strcat (buf, ", sorted symbol tables");
2163 break;
2164
2165 case EF_ARM_DYNSYMSUSESEGIDX:
2166 strcat (buf, ", dynamic symbols use segment index");
2167 break;
2168
2169 case EF_ARM_MAPSYMSFIRST:
2170 strcat (buf, ", mapping symbols precede others");
2171 break;
2172
2173 default:
2174 unknown = 1;
2175 break;
2176 }
2177 }
2178 break;
2179
d507cf36
PB		 2180 case EF_ARM_EABI_VER3:
2181 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2182 break;
2183
2184 case EF_ARM_EABI_VER4:
2185 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2186 while (e_flags)
2187 {
2188 unsigned flag;
2189
2190 /* Process flags one bit at a time. */
2191 flag = e_flags & - e_flags;
2192 e_flags &= ~ flag;
2193
2194 switch (flag)
2195 {
2196 case EF_ARM_BE8:
2197 strcat (buf, ", BE8");
2198 break;
2199
2200 case EF_ARM_LE8:
2201 strcat (buf, ", LE8");
2202 break;
2203
2204 default:
2205 unknown = 1;
2206 break;
2207 }
2208 break;
2209 }
2210 break;
3a4a14e9
PB		 2211
2212 case EF_ARM_EABI_VER5:
2213 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2214 while (e_flags)
2215 {
2216 unsigned flag;
2217
2218 /* Process flags one bit at a time. */
2219 flag = e_flags & - e_flags;
2220 e_flags &= ~ flag;
2221
2222 switch (flag)
2223 {
2224 case EF_ARM_BE8:
2225 strcat (buf, ", BE8");
2226 break;
2227
2228 case EF_ARM_LE8:
2229 strcat (buf, ", LE8");
2230 break;
2231
3bfcb652
NC		 2232 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2233 strcat (buf, ", soft-float ABI");
2234 break;
2235
2236 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2237 strcat (buf, ", hard-float ABI");
2238 break;
2239
d507cf36
PB		 2240 default:
2241 unknown = 1;
2242 break;
2243 }
2244 }
2245 break;
2246
f3485b74 2247 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2248 strcat (buf, ", GNU EABI");
f3485b74
NC		 2249 while (e_flags)
2250 {
2251 unsigned flag;
76da6bbe 2252
f3485b74
NC		 2253 /* Process flags one bit at a time. */
2254 flag = e_flags & - e_flags;
2255 e_flags &= ~ flag;
76da6bbe 2256
f3485b74
NC		 2257 switch (flag)
2258 {
a5bcd848 2259 case EF_ARM_INTERWORK:
f3485b74
NC		 2260 strcat (buf, ", interworking enabled");
2261 break;
76da6bbe 2262
a5bcd848 2263 case EF_ARM_APCS_26:
f3485b74
NC		 2264 strcat (buf, ", uses APCS/26");
2265 break;
76da6bbe 2266
a5bcd848 2267 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2268 strcat (buf, ", uses APCS/float");
2269 break;
76da6bbe 2270
a5bcd848 2271 case EF_ARM_PIC:
f3485b74
NC		 2272 strcat (buf, ", position independent");
2273 break;
76da6bbe 2274
a5bcd848 2275 case EF_ARM_ALIGN8:
f3485b74
NC		 2276 strcat (buf, ", 8 bit structure alignment");
2277 break;
76da6bbe 2278
a5bcd848 2279 case EF_ARM_NEW_ABI:
f3485b74
NC		 2280 strcat (buf, ", uses new ABI");
2281 break;
76da6bbe 2282
a5bcd848 2283 case EF_ARM_OLD_ABI:
f3485b74
NC		 2284 strcat (buf, ", uses old ABI");
2285 break;
76da6bbe 2286
a5bcd848 2287 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2288 strcat (buf, ", software FP");
2289 break;
76da6bbe 2290
90e01f86
ILT		 2291 case EF_ARM_VFP_FLOAT:
2292 strcat (buf, ", VFP");
2293 break;
2294
fde78edd
NC		 2295 case EF_ARM_MAVERICK_FLOAT:
2296 strcat (buf, ", Maverick FP");
2297 break;
2298
f3485b74
NC		 2299 default:
2300 unknown = 1;
2301 break;
2302 }
2303 }
2304 }
f3485b74
NC		 2305
2306 if (unknown)
2b692964 2307 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2308}
2309
252b5132 2310static char *
d3ba0551 2311get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2312{
b34976b6 2313 static char buf[1024];
252b5132
RH		 2314
2315 buf[0] = '\0';
76da6bbe 2316
252b5132
RH		 2317 if (e_flags)
2318 {
2319 switch (e_machine)
2320 {
2321 default:
2322 break;
2323
f3485b74
NC		 2324 case EM_ARM:
2325 decode_ARM_machine_flags (e_flags, buf);
2326 break;
76da6bbe 2327
781303ce
MF		 2328 case EM_BLACKFIN:
2329 if (e_flags & EF_BFIN_PIC)
2330 strcat (buf, ", PIC");
2331
2332 if (e_flags & EF_BFIN_FDPIC)
2333 strcat (buf, ", FDPIC");
2334
2335 if (e_flags & EF_BFIN_CODE_IN_L1)
2336 strcat (buf, ", code in L1");
2337
2338 if (e_flags & EF_BFIN_DATA_IN_L1)
2339 strcat (buf, ", data in L1");
2340
2341 break;
2342
ec2dfb42
AO		 2343 case EM_CYGNUS_FRV:
2344 switch (e_flags & EF_FRV_CPU_MASK)
2345 {
2346 case EF_FRV_CPU_GENERIC:
2347 break;
2348
2349 default:
2350 strcat (buf, ", fr???");
2351 break;
57346661 2352
ec2dfb42
AO		 2353 case EF_FRV_CPU_FR300:
2354 strcat (buf, ", fr300");
2355 break;
2356
2357 case EF_FRV_CPU_FR400:
2358 strcat (buf, ", fr400");
2359 break;
2360 case EF_FRV_CPU_FR405:
2361 strcat (buf, ", fr405");
2362 break;
2363
2364 case EF_FRV_CPU_FR450:
2365 strcat (buf, ", fr450");
2366 break;
2367
2368 case EF_FRV_CPU_FR500:
2369 strcat (buf, ", fr500");
2370 break;
2371 case EF_FRV_CPU_FR550:
2372 strcat (buf, ", fr550");
2373 break;
2374
2375 case EF_FRV_CPU_SIMPLE:
2376 strcat (buf, ", simple");
2377 break;
2378 case EF_FRV_CPU_TOMCAT:
2379 strcat (buf, ", tomcat");
2380 break;
2381 }
1c877e87 2382 break;
ec2dfb42 2383
53c7db4b 2384 case EM_68K:
425c6cb0 2385 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2386 strcat (buf, ", m68000");
425c6cb0 2387 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2388 strcat (buf, ", cpu32");
2389 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2390 strcat (buf, ", fido_a");
425c6cb0 2391 else
266abb8f 2392 {
2cf0635d
NC		 2393 char const * isa = _("unknown");
2394 char const * mac = _("unknown mac");
2395 char const * additional = NULL;
0112cd26 2396
c694fd50 2397 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2398 {
c694fd50 2399 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2400 isa = "A";
2401 additional = ", nodiv";
2402 break;
c694fd50 2403 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2404 isa = "A";
2405 break;
c694fd50 2406 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2407 isa = "A+";
2408 break;
c694fd50 2409 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2410 isa = "B";
2411 additional = ", nousp";
2412 break;
c694fd50 2413 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2414 isa = "B";
2415 break;
f608cd77
NS		 2416 case EF_M68K_CF_ISA_C:
2417 isa = "C";
2418 break;
2419 case EF_M68K_CF_ISA_C_NODIV:
2420 isa = "C";
2421 additional = ", nodiv";
2422 break;
266abb8f
NS		 2423 }
2424 strcat (buf, ", cf, isa ");
2425 strcat (buf, isa);
0b2e31dc
NS		 2426 if (additional)
2427 strcat (buf, additional);
c694fd50 2428 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2429 strcat (buf, ", float");
c694fd50 2430 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2431 {
2432 case 0:
2433 mac = NULL;
2434 break;
c694fd50 2435 case EF_M68K_CF_MAC:
266abb8f
NS		 2436 mac = "mac";
2437 break;
c694fd50 2438 case EF_M68K_CF_EMAC:
266abb8f
NS		 2439 mac = "emac";
2440 break;
f608cd77
NS		 2441 case EF_M68K_CF_EMAC_B:
2442 mac = "emac_b";
2443 break;
266abb8f
NS		 2444 }
2445 if (mac)
2446 {
2447 strcat (buf, ", ");
2448 strcat (buf, mac);
2449 }
266abb8f 2450 }
53c7db4b 2451 break;
33c63f9d 2452
252b5132
RH		 2453 case EM_PPC:
2454 if (e_flags & EF_PPC_EMB)
2455 strcat (buf, ", emb");
2456
2457 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2458 strcat (buf, _(", relocatable"));
252b5132
RH		 2459
2460 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2461 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2462 break;
2463
ee67d69a
AM		 2464 case EM_PPC64:
2465 if (e_flags & EF_PPC64_ABI)
2466 {
2467 char abi[] = ", abiv0";
2468
2469 abi[6] += e_flags & EF_PPC64_ABI;
2470 strcat (buf, abi);
2471 }
2472 break;
2473
708e2187
NC		 2474 case EM_V800:
2475 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2476 strcat (buf, ", RH850 ABI");
0b4362b0 2477
708e2187
NC		 2478 if (e_flags & EF_V800_850E3)
2479 strcat (buf, ", V3 architecture");
2480
2481 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2482 strcat (buf, ", FPU not used");
2483
2484 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2485 strcat (buf, ", regmode: COMMON");
2486
2487 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2488 strcat (buf, ", r4 not used");
2489
2490 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2491 strcat (buf, ", r30 not used");
2492
2493 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2494 strcat (buf, ", r5 not used");
2495
2496 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2497 strcat (buf, ", r2 not used");
2498
2499 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2500 {
2501 switch (e_flags & - e_flags)
2502 {
2503 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2504 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2505 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2506 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2507 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2508 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2509 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2510 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2511 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2512 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2513 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2514 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2515 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2516 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2517 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2518 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2519 default: break;
2520 }
2521 }
2522 break;
2523
2b0337b0 2524 case EM_V850:
252b5132
RH		 2525 case EM_CYGNUS_V850:
2526 switch (e_flags & EF_V850_ARCH)
2527 {
78c8d46c
NC		 2528 case E_V850E3V5_ARCH:
2529 strcat (buf, ", v850e3v5");
2530 break;
1cd986c5
NC		 2531 case E_V850E2V3_ARCH:
2532 strcat (buf, ", v850e2v3");
2533 break;
2534 case E_V850E2_ARCH:
2535 strcat (buf, ", v850e2");
2536 break;
2537 case E_V850E1_ARCH:
2538 strcat (buf, ", v850e1");
8ad30312 2539 break;
252b5132
RH		 2540 case E_V850E_ARCH:
2541 strcat (buf, ", v850e");
2542 break;
252b5132
RH		 2543 case E_V850_ARCH:
2544 strcat (buf, ", v850");
2545 break;
2546 default:
2b692964 2547 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2548 break;
2549 }
2550 break;
2551
2b0337b0 2552 case EM_M32R:
252b5132
RH		 2553 case EM_CYGNUS_M32R:
2554 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2555 strcat (buf, ", m32r");
252b5132
RH		 2556 break;
2557
2558 case EM_MIPS:
4fe85591 2559 case EM_MIPS_RS3_LE:
252b5132
RH		 2560 if (e_flags & EF_MIPS_NOREORDER)
2561 strcat (buf, ", noreorder");
2562
2563 if (e_flags & EF_MIPS_PIC)
2564 strcat (buf, ", pic");
2565
2566 if (e_flags & EF_MIPS_CPIC)
2567 strcat (buf, ", cpic");
2568
d1bdd336
TS		 2569 if (e_flags & EF_MIPS_UCODE)
2570 strcat (buf, ", ugen_reserved");
2571
252b5132
RH		 2572 if (e_flags & EF_MIPS_ABI2)
2573 strcat (buf, ", abi2");
2574
43521d43
TS		 2575 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2576 strcat (buf, ", odk first");
2577
a5d22d2a
TS		 2578 if (e_flags & EF_MIPS_32BITMODE)
2579 strcat (buf, ", 32bitmode");
2580
ba92f887
MR		 2581 if (e_flags & EF_MIPS_NAN2008)
2582 strcat (buf, ", nan2008");
2583
fef1b0b3
SE		 2584 if (e_flags & EF_MIPS_FP64)
2585 strcat (buf, ", fp64");
2586
156c2f8b
NC		 2587 switch ((e_flags & EF_MIPS_MACH))
2588 {
2589 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2590 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2591 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2592 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2593 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2594 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2595 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2596 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2597 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2598 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2599 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2600 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2601 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2602 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2603 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2604 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2605 case 0:
2606 /* We simply ignore the field in this case to avoid confusion:
2607 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2608 extension. */
2609 break;
2b692964 2610 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2611 }
43521d43
TS		 2612
2613 switch ((e_flags & EF_MIPS_ABI))
2614 {
2615 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2616 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2617 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2618 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2619 case 0:
2620 /* We simply ignore the field in this case to avoid confusion:
2621 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2622 This means it is likely to be an o32 file, but not for
2623 sure. */
2624 break;
2b692964 2625 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2626 }
2627
2628 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2629 strcat (buf, ", mdmx");
2630
2631 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2632 strcat (buf, ", mips16");
2633
df58fc94
RS		 2634 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2635 strcat (buf, ", micromips");
2636
43521d43
TS		 2637 switch ((e_flags & EF_MIPS_ARCH))
2638 {
2639 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2640 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2641 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2642 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2643 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2644 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2645 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2646 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2647 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2648 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2649 }
252b5132 2650 break;
351b4b40 2651
ccde1100
AO		 2652 case EM_SH:
2653 switch ((e_flags & EF_SH_MACH_MASK))
2654 {
2655 case EF_SH1: strcat (buf, ", sh1"); break;
2656 case EF_SH2: strcat (buf, ", sh2"); break;
2657 case EF_SH3: strcat (buf, ", sh3"); break;
2658 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2659 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2660 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2661 case EF_SH3E: strcat (buf, ", sh3e"); break;
2662 case EF_SH4: strcat (buf, ", sh4"); break;
2663 case EF_SH5: strcat (buf, ", sh5"); break;
2664 case EF_SH2E: strcat (buf, ", sh2e"); break;
2665 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2666 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2667 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2668 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2669 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2670 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2671 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2672 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2673 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2674 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2675 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2676 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2677 }
2678
cec6a5b8
MR		 2679 if (e_flags & EF_SH_PIC)
2680 strcat (buf, ", pic");
2681
2682 if (e_flags & EF_SH_FDPIC)
2683 strcat (buf, ", fdpic");
ccde1100 2684 break;
57346661 2685
351b4b40
RH		 2686 case EM_SPARCV9:
2687 if (e_flags & EF_SPARC_32PLUS)
2688 strcat (buf, ", v8+");
2689
2690 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2691 strcat (buf, ", ultrasparcI");
2692
2693 if (e_flags & EF_SPARC_SUN_US3)
2694 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2695
2696 if (e_flags & EF_SPARC_HAL_R1)
2697 strcat (buf, ", halr1");
2698
2699 if (e_flags & EF_SPARC_LEDATA)
2700 strcat (buf, ", ledata");
2701
2702 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2703 strcat (buf, ", tso");
2704
2705 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2706 strcat (buf, ", pso");
2707
2708 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2709 strcat (buf, ", rmo");
2710 break;
7d466069 2711
103f02d3
UD		 2712 case EM_PARISC:
2713 switch (e_flags & EF_PARISC_ARCH)
2714 {
2715 case EFA_PARISC_1_0:
2716 strcpy (buf, ", PA-RISC 1.0");
2717 break;
2718 case EFA_PARISC_1_1:
2719 strcpy (buf, ", PA-RISC 1.1");
2720 break;
2721 case EFA_PARISC_2_0:
2722 strcpy (buf, ", PA-RISC 2.0");
2723 break;
2724 default:
2725 break;
2726 }
2727 if (e_flags & EF_PARISC_TRAPNIL)
2728 strcat (buf, ", trapnil");
2729 if (e_flags & EF_PARISC_EXT)
2730 strcat (buf, ", ext");
2731 if (e_flags & EF_PARISC_LSB)
2732 strcat (buf, ", lsb");
2733 if (e_flags & EF_PARISC_WIDE)
2734 strcat (buf, ", wide");
2735 if (e_flags & EF_PARISC_NO_KABP)
2736 strcat (buf, ", no kabp");
2737 if (e_flags & EF_PARISC_LAZYSWAP)
2738 strcat (buf, ", lazyswap");
30800947 2739 break;
76da6bbe 2740
7d466069 2741 case EM_PJ:
2b0337b0 2742 case EM_PJ_OLD:
7d466069
ILT		 2743 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2744 strcat (buf, ", new calling convention");
2745
2746 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2747 strcat (buf, ", gnu calling convention");
2748 break;
4d6ed7c8
NC		 2749
2750 case EM_IA_64:
2751 if ((e_flags & EF_IA_64_ABI64))
2752 strcat (buf, ", 64-bit");
2753 else
2754 strcat (buf, ", 32-bit");
2755 if ((e_flags & EF_IA_64_REDUCEDFP))
2756 strcat (buf, ", reduced fp model");
2757 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2758 strcat (buf, ", no function descriptors, constant gp");
2759 else if ((e_flags & EF_IA_64_CONS_GP))
2760 strcat (buf, ", constant gp");
2761 if ((e_flags & EF_IA_64_ABSOLUTE))
2762 strcat (buf, ", absolute");
28f997cf
TG		 2763 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2764 {
2765 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2766 strcat (buf, ", vms_linkages");
2767 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2768 {
2769 case EF_IA_64_VMS_COMCOD_SUCCESS:
2770 break;
2771 case EF_IA_64_VMS_COMCOD_WARNING:
2772 strcat (buf, ", warning");
2773 break;
2774 case EF_IA_64_VMS_COMCOD_ERROR:
2775 strcat (buf, ", error");
2776 break;
2777 case EF_IA_64_VMS_COMCOD_ABORT:
2778 strcat (buf, ", abort");
2779 break;
2780 default:
2781 abort ();
2782 }
2783 }
4d6ed7c8 2784 break;
179d3252
JT		 2785
2786 case EM_VAX:
2787 if ((e_flags & EF_VAX_NONPIC))
2788 strcat (buf, ", non-PIC");
2789 if ((e_flags & EF_VAX_DFLOAT))
2790 strcat (buf, ", D-Float");
2791 if ((e_flags & EF_VAX_GFLOAT))
2792 strcat (buf, ", G-Float");
2793 break;
c7927a3c 2794
4046d87a
NC		 2795 case EM_RL78:
2796 if (e_flags & E_FLAG_RL78_G10)
2797 strcat (buf, ", G10");
2798 break;
0b4362b0 2799
c7927a3c
NC		 2800 case EM_RX:
2801 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2802 strcat (buf, ", 64-bit doubles");
2803 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2804 strcat (buf, ", dsp");
d4cb0ea0 2805 if (e_flags & E_FLAG_RX_PID)
0b4362b0 2806 strcat (buf, ", pid");
708e2187
NC		 2807 if (e_flags & E_FLAG_RX_ABI)
2808 strcat (buf, ", RX ABI");
d4cb0ea0 2809 break;
55786da2
AK		 2810
2811 case EM_S390:
2812 if (e_flags & EF_S390_HIGH_GPRS)
2813 strcat (buf, ", highgprs");
d4cb0ea0 2814 break;
40b36596
JM		 2815
2816 case EM_TI_C6000:
2817 if ((e_flags & EF_C6000_REL))
2818 strcat (buf, ", relocatable module");
d4cb0ea0 2819 break;
13761a11
NC		 2820
2821 case EM_MSP430:
2822 strcat (buf, _(": architecture variant: "));
2823 switch (e_flags & EF_MSP430_MACH)
2824 {
2825 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
2826 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
2827 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
2828 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
2829 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
2830 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
2831 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
2832 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
2833 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
2834 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
2835 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
2836 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
2837 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
2838 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
2839 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
2840 default:
2841 strcat (buf, _(": unknown")); break;
2842 }
2843
2844 if (e_flags & ~ EF_MSP430_MACH)
2845 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 2846 }
2847 }
2848
2849 return buf;
2850}
2851
252b5132 2852static const char *
d3ba0551
AM		 2853get_osabi_name (unsigned int osabi)
2854{
2855 static char buff[32];
2856
2857 switch (osabi)
2858 {
2859 case ELFOSABI_NONE: return "UNIX - System V";
2860 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2861 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2862 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2863 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2864 case ELFOSABI_AIX: return "UNIX - AIX";
2865 case ELFOSABI_IRIX: return "UNIX - IRIX";
2866 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2867 case ELFOSABI_TRU64: return "UNIX - TRU64";
2868 case ELFOSABI_MODESTO: return "Novell - Modesto";
2869 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2870 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2871 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2872 case ELFOSABI_AROS: return "AROS";
11636f9e 2873 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2874 default:
40b36596
JM		 2875 if (osabi >= 64)
2876 switch (elf_header.e_machine)
2877 {
2878 case EM_ARM:
2879 switch (osabi)
2880 {
2881 case ELFOSABI_ARM: return "ARM";
2882 default:
2883 break;
2884 }
2885 break;
2886
2887 case EM_MSP430:
2888 case EM_MSP430_OLD:
2889 switch (osabi)
2890 {
2891 case ELFOSABI_STANDALONE: return _("Standalone App");
2892 default:
2893 break;
2894 }
2895 break;
2896
2897 case EM_TI_C6000:
2898 switch (osabi)
2899 {
2900 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2901 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2902 default:
2903 break;
2904 }
2905 break;
2906
2907 default:
2908 break;
2909 }
e9e44622 2910 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2911 return buff;
2912 }
2913}
2914
a06ea964
NC		 2915static const char *
2916get_aarch64_segment_type (unsigned long type)
2917{
2918 switch (type)
2919 {
2920 case PT_AARCH64_ARCHEXT:
2921 return "AARCH64_ARCHEXT";
2922 default:
2923 break;
2924 }
2925
2926 return NULL;
2927}
2928
b294bdf8
MM		 2929static const char *
2930get_arm_segment_type (unsigned long type)
2931{
2932 switch (type)
2933 {
2934 case PT_ARM_EXIDX:
2935 return "EXIDX";
2936 default:
2937 break;
2938 }
2939
2940 return NULL;
2941}
2942
d3ba0551
AM		 2943static const char *
2944get_mips_segment_type (unsigned long type)
252b5132
RH		 2945{
2946 switch (type)
2947 {
2948 case PT_MIPS_REGINFO:
2949 return "REGINFO";
2950 case PT_MIPS_RTPROC:
2951 return "RTPROC";
2952 case PT_MIPS_OPTIONS:
2953 return "OPTIONS";
2954 default:
2955 break;
2956 }
2957
2958 return NULL;
2959}
2960
103f02d3 2961static const char *
d3ba0551 2962get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2963{
2964 switch (type)
2965 {
2966 case PT_HP_TLS: return "HP_TLS";
2967 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2968 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2969 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2970 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2971 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2972 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2973 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2974 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2975 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2976 case PT_HP_PARALLEL: return "HP_PARALLEL";
2977 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2978 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2979 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2980 case PT_HP_STACK: return "HP_STACK";
2981 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2982 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2983 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2984 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2985 default:
2986 break;
2987 }
2988
2989 return NULL;
2990}
2991
4d6ed7c8 2992static const char *
d3ba0551 2993get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2994{
2995 switch (type)
2996 {
2997 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2998 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2999 case PT_HP_TLS: return "HP_TLS";
3000 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3001 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3002 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3003 default:
3004 break;
3005 }
3006
3007 return NULL;
3008}
3009
40b36596
JM		 3010static const char *
3011get_tic6x_segment_type (unsigned long type)
3012{
3013 switch (type)
3014 {
3015 case PT_C6000_PHATTR: return "C6000_PHATTR";
3016 default:
3017 break;
3018 }
3019
3020 return NULL;
3021}
3022
252b5132 3023static const char *
d3ba0551 3024get_segment_type (unsigned long p_type)
252b5132 3025{
b34976b6 3026 static char buff[32];
252b5132
RH		 3027
3028 switch (p_type)
3029 {
b34976b6
AM		 3030 case PT_NULL: return "NULL";
3031 case PT_LOAD: return "LOAD";
252b5132 3032 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3033 case PT_INTERP: return "INTERP";
3034 case PT_NOTE: return "NOTE";
3035 case PT_SHLIB: return "SHLIB";
3036 case PT_PHDR: return "PHDR";
13ae64f3 3037 case PT_TLS: return "TLS";
252b5132 3038
65765700
JJ		 3039 case PT_GNU_EH_FRAME:
3040 return "GNU_EH_FRAME";
2b05f1b7 3041 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3042 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3043
252b5132
RH		 3044 default:
3045 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3046 {
2cf0635d 3047 const char * result;
103f02d3 3048
252b5132
RH		 3049 switch (elf_header.e_machine)
3050 {
a06ea964
NC		 3051 case EM_AARCH64:
3052 result = get_aarch64_segment_type (p_type);
3053 break;
b294bdf8
MM		 3054 case EM_ARM:
3055 result = get_arm_segment_type (p_type);
3056 break;
252b5132 3057 case EM_MIPS:
4fe85591 3058 case EM_MIPS_RS3_LE:
252b5132
RH		 3059 result = get_mips_segment_type (p_type);
3060 break;
103f02d3
UD		 3061 case EM_PARISC:
3062 result = get_parisc_segment_type (p_type);
3063 break;
4d6ed7c8
NC		 3064 case EM_IA_64:
3065 result = get_ia64_segment_type (p_type);
3066 break;
40b36596
JM		 3067 case EM_TI_C6000:
3068 result = get_tic6x_segment_type (p_type);
3069 break;
252b5132
RH		 3070 default:
3071 result = NULL;
3072 break;
3073 }
103f02d3 3074
252b5132
RH		 3075 if (result != NULL)
3076 return result;
103f02d3 3077
252b5132
RH		 3078 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3079 }
3080 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3081 {
2cf0635d 3082 const char * result;
103f02d3
UD		 3083
3084 switch (elf_header.e_machine)
3085 {
3086 case EM_PARISC:
3087 result = get_parisc_segment_type (p_type);
3088 break;
00428cca
AM		 3089 case EM_IA_64:
3090 result = get_ia64_segment_type (p_type);
3091 break;
103f02d3
UD		 3092 default:
3093 result = NULL;
3094 break;
3095 }
3096
3097 if (result != NULL)
3098 return result;
3099
3100 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3101 }
252b5132 3102 else
e9e44622 3103 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3104
3105 return buff;
3106 }
3107}
3108
3109static const char *
d3ba0551 3110get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3111{
3112 switch (sh_type)
3113 {
b34976b6
AM		 3114 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3115 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3116 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3117 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3118 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3119 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3120 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3121 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3122 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3123 case SHT_MIPS_RELD: return "MIPS_RELD";
3124 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3125 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3126 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3127 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3128 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3129 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3130 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3131 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3132 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3133 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3134 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3135 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3136 case SHT_MIPS_LINE: return "MIPS_LINE";
3137 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3138 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3139 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3140 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3141 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3142 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3143 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3144 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3145 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3146 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3147 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3148 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3149 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3150 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3151 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 3152 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3153 default:
3154 break;
3155 }
3156 return NULL;
3157}
3158
103f02d3 3159static const char *
d3ba0551 3160get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3161{
3162 switch (sh_type)
3163 {
3164 case SHT_PARISC_EXT: return "PARISC_EXT";
3165 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3166 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3167 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3168 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3169 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3170 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3171 default:
3172 break;
3173 }
3174 return NULL;
3175}
3176
4d6ed7c8 3177static const char *
d3ba0551 3178get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3179{
18bd398b 3180 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3181 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3182 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3183
4d6ed7c8
NC		 3184 switch (sh_type)
3185 {
148b93f2
NC		 3186 case SHT_IA_64_EXT: return "IA_64_EXT";
3187 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3188 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3189 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3190 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3191 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3192 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3193 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3194 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3195 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3196 default:
3197 break;
3198 }
3199 return NULL;
3200}
3201
d2b2c203
DJ		 3202static const char *
3203get_x86_64_section_type_name (unsigned int sh_type)
3204{
3205 switch (sh_type)
3206 {
3207 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3208 default:
3209 break;
3210 }
3211 return NULL;
3212}
3213
a06ea964
NC		 3214static const char *
3215get_aarch64_section_type_name (unsigned int sh_type)
3216{
3217 switch (sh_type)
3218 {
3219 case SHT_AARCH64_ATTRIBUTES:
3220 return "AARCH64_ATTRIBUTES";
3221 default:
3222 break;
3223 }
3224 return NULL;
3225}
3226
40a18ebd
NC		 3227static const char *
3228get_arm_section_type_name (unsigned int sh_type)
3229{
3230 switch (sh_type)
3231 {
7f6fed87
NC		 3232 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3233 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3234 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3235 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3236 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3237 default:
3238 break;
3239 }
3240 return NULL;
3241}
3242
40b36596
JM		 3243static const char *
3244get_tic6x_section_type_name (unsigned int sh_type)
3245{
3246 switch (sh_type)
3247 {
3248 case SHT_C6000_UNWIND:
3249 return "C6000_UNWIND";
3250 case SHT_C6000_PREEMPTMAP:
3251 return "C6000_PREEMPTMAP";
3252 case SHT_C6000_ATTRIBUTES:
3253 return "C6000_ATTRIBUTES";
3254 case SHT_TI_ICODE:
3255 return "TI_ICODE";
3256 case SHT_TI_XREF:
3257 return "TI_XREF";
3258 case SHT_TI_HANDLER:
3259 return "TI_HANDLER";
3260 case SHT_TI_INITINFO:
3261 return "TI_INITINFO";
3262 case SHT_TI_PHATTRS:
3263 return "TI_PHATTRS";
3264 default:
3265 break;
3266 }
3267 return NULL;
3268}
3269
13761a11
NC		 3270static const char *
3271get_msp430x_section_type_name (unsigned int sh_type)
3272{
3273 switch (sh_type)
3274 {
3275 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3276 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3277 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3278 default: return NULL;
3279 }
3280}
3281
252b5132 3282static const char *
d3ba0551 3283get_section_type_name (unsigned int sh_type)
252b5132 3284{
b34976b6 3285 static char buff[32];
252b5132
RH		 3286
3287 switch (sh_type)
3288 {
3289 case SHT_NULL: return "NULL";
3290 case SHT_PROGBITS: return "PROGBITS";
3291 case SHT_SYMTAB: return "SYMTAB";
3292 case SHT_STRTAB: return "STRTAB";
3293 case SHT_RELA: return "RELA";
3294 case SHT_HASH: return "HASH";
3295 case SHT_DYNAMIC: return "DYNAMIC";
3296 case SHT_NOTE: return "NOTE";
3297 case SHT_NOBITS: return "NOBITS";
3298 case SHT_REL: return "REL";
3299 case SHT_SHLIB: return "SHLIB";
3300 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3301 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3302 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3303 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3304 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3305 case SHT_GROUP: return "GROUP";
3306 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3307 case SHT_GNU_verdef: return "VERDEF";
3308 case SHT_GNU_verneed: return "VERNEED";
3309 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3310 case 0x6ffffff0: return "VERSYM";
3311 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3312 case 0x7ffffffd: return "AUXILIARY";
3313 case 0x7fffffff: return "FILTER";
047b2264 3314 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3315
3316 default:
3317 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3318 {
2cf0635d 3319 const char * result;
252b5132
RH		 3320
3321 switch (elf_header.e_machine)
3322 {
3323 case EM_MIPS:
4fe85591 3324 case EM_MIPS_RS3_LE:
252b5132
RH		 3325 result = get_mips_section_type_name (sh_type);
3326 break;
103f02d3
UD		 3327 case EM_PARISC:
3328 result = get_parisc_section_type_name (sh_type);
3329 break;
4d6ed7c8
NC		 3330 case EM_IA_64:
3331 result = get_ia64_section_type_name (sh_type);
3332 break;
d2b2c203 3333 case EM_X86_64:
8a9036a4 3334 case EM_L1OM:
7a9068fe 3335 case EM_K1OM:
d2b2c203
DJ		 3336 result = get_x86_64_section_type_name (sh_type);
3337 break;
a06ea964
NC		 3338 case EM_AARCH64:
3339 result = get_aarch64_section_type_name (sh_type);
3340 break;
40a18ebd
NC		 3341 case EM_ARM:
3342 result = get_arm_section_type_name (sh_type);
3343 break;
40b36596
JM		 3344 case EM_TI_C6000:
3345 result = get_tic6x_section_type_name (sh_type);
3346 break;
13761a11
NC		 3347 case EM_MSP430:
3348 result = get_msp430x_section_type_name (sh_type);
3349 break;
252b5132
RH		 3350 default:
3351 result = NULL;
3352 break;
3353 }
3354
3355 if (result != NULL)
3356 return result;
3357
c91d0dfb 3358 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3359 }
3360 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3361 {
2cf0635d 3362 const char * result;
148b93f2
NC		 3363
3364 switch (elf_header.e_machine)
3365 {
3366 case EM_IA_64:
3367 result = get_ia64_section_type_name (sh_type);
3368 break;
3369 default:
3370 result = NULL;
3371 break;
3372 }
3373
3374 if (result != NULL)
3375 return result;
3376
3377 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3378 }
252b5132 3379 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3380 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3381 else
a7dbfd1c
NC		 3382 /* This message is probably going to be displayed in a 15
3383 character wide field, so put the hex value first. */
3384 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3385
252b5132
RH		 3386 return buff;
3387 }
3388}
3389
2979dc34 3390#define OPTION_DEBUG_DUMP 512
2c610e4b 3391#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3392#define OPTION_DWARF_DEPTH 514
3393#define OPTION_DWARF_START 515
4723351a 3394#define OPTION_DWARF_CHECK 516
2979dc34 3395
85b1c36d 3396static struct option options[] =
252b5132 3397{
b34976b6 3398 {"all", no_argument, 0, 'a'},
252b5132
RH		 3399 {"file-header", no_argument, 0, 'h'},
3400 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3401 {"headers", no_argument, 0, 'e'},
3402 {"histogram", no_argument, 0, 'I'},
3403 {"segments", no_argument, 0, 'l'},
3404 {"sections", no_argument, 0, 'S'},
252b5132 3405 {"section-headers", no_argument, 0, 'S'},
f5842774 3406 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3407 {"section-details", no_argument, 0, 't'},
595cf52e 3408 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3409 {"symbols", no_argument, 0, 's'},
3410 {"syms", no_argument, 0, 's'},
2c610e4b 3411 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3412 {"relocs", no_argument, 0, 'r'},
3413 {"notes", no_argument, 0, 'n'},
3414 {"dynamic", no_argument, 0, 'd'},
a952a375 3415 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3416 {"version-info", no_argument, 0, 'V'},
3417 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3418 {"unwind", no_argument, 0, 'u'},
4145f1d5 3419 {"archive-index", no_argument, 0, 'c'},
b34976b6 3420 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3421 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3422 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3423#ifdef SUPPORT_DISASSEMBLY
3424 {"instruction-dump", required_argument, 0, 'i'},
3425#endif
cf13d699 3426 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3427
fd2f0033
TT		 3428 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3429 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3430 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3431
b34976b6
AM		 3432 {"version", no_argument, 0, 'v'},
3433 {"wide", no_argument, 0, 'W'},
3434 {"help", no_argument, 0, 'H'},
3435 {0, no_argument, 0, 0}
252b5132
RH		 3436};
3437
3438static void
2cf0635d 3439usage (FILE * stream)
252b5132 3440{
92f01d61
JM		 3441 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3442 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3443 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3444 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3445 -h --file-header Display the ELF file header\n\
3446 -l --program-headers Display the program headers\n\
3447 --segments An alias for --program-headers\n\
3448 -S --section-headers Display the sections' header\n\
3449 --sections An alias for --section-headers\n\
f5842774 3450 -g --section-groups Display the section groups\n\
5477e8a0 3451 -t --section-details Display the section details\n\
8b53311e
NC		 3452 -e --headers Equivalent to: -h -l -S\n\
3453 -s --syms Display the symbol table\n\
3f08eb35 3454 --symbols An alias for --syms\n\
2c610e4b 3455 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3456 -n --notes Display the core notes (if present)\n\
3457 -r --relocs Display the relocations (if present)\n\
3458 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3459 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3460 -V --version-info Display the version sections (if present)\n\
1b31d05e 3461 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3462 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3463 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3464 -x --hex-dump=<number|name>\n\
3465 Dump the contents of section <number|name> as bytes\n\
3466 -p --string-dump=<number|name>\n\
3467 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3468 -R --relocated-dump=<number|name>\n\
3469 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3470 -w[lLiaprmfFsoRt] or\n\
1ed06042 3471 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3472 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3473 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3474 =addr,=cu_index]\n\
8b53311e 3475 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3476 fprintf (stream, _("\
3477 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3478 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3479 or deeper\n"));
252b5132 3480#ifdef SUPPORT_DISASSEMBLY
92f01d61 3481 fprintf (stream, _("\
09c11c86
NC		 3482 -i --instruction-dump=<number|name>\n\
3483 Disassemble the contents of section <number|name>\n"));
252b5132 3484#endif
92f01d61 3485 fprintf (stream, _("\
8b53311e
NC		 3486 -I --histogram Display histogram of bucket list lengths\n\
3487 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3488 @<file> Read options from <file>\n\
8b53311e
NC		 3489 -H --help Display this information\n\
3490 -v --version Display the version number of readelf\n"));
1118d252 3491
92f01d61
JM		 3492 if (REPORT_BUGS_TO[0] && stream == stdout)
3493 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3494
92f01d61 3495 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3496}
3497
18bd398b
NC		 3498/* Record the fact that the user wants the contents of section number
3499 SECTION to be displayed using the method(s) encoded as flags bits
3500 in TYPE. Note, TYPE can be zero if we are creating the array for
3501 the first time. */
3502
252b5132 3503static void
09c11c86 3504request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3505{
3506 if (section >= num_dump_sects)
3507 {
2cf0635d 3508 dump_type * new_dump_sects;
252b5132 3509
3f5e193b
NC		 3510 new_dump_sects = (dump_type *) calloc (section + 1,
3511 sizeof (* dump_sects));
252b5132
RH		 3512
3513 if (new_dump_sects == NULL)
591a748a 3514 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3515 else
3516 {
3517 /* Copy current flag settings. */
09c11c86 3518 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3519
3520 free (dump_sects);
3521
3522 dump_sects = new_dump_sects;
3523 num_dump_sects = section + 1;
3524 }
3525 }
3526
3527 if (dump_sects)
b34976b6 3528 dump_sects[section] |= type;
252b5132
RH		 3529
3530 return;
3531}
3532
aef1f6d0
DJ		 3533/* Request a dump by section name. */
3534
3535static void
2cf0635d 3536request_dump_byname (const char * section, dump_type type)
aef1f6d0 3537{
2cf0635d 3538 struct dump_list_entry * new_request;
aef1f6d0 3539
3f5e193b
NC		 3540 new_request = (struct dump_list_entry *)
3541 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3542 if (!new_request)
591a748a 3543 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3544
3545 new_request->name = strdup (section);
3546 if (!new_request->name)
591a748a 3547 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3548
3549 new_request->type = type;
3550
3551 new_request->next = dump_sects_byname;
3552 dump_sects_byname = new_request;
3553}
3554
cf13d699
NC		 3555static inline void
3556request_dump (dump_type type)
3557{
3558 int section;
3559 char * cp;
3560
3561 do_dump++;
3562 section = strtoul (optarg, & cp, 0);
3563
3564 if (! *cp && section >= 0)
3565 request_dump_bynumber (section, type);
3566 else
3567 request_dump_byname (optarg, type);
3568}
3569
3570
252b5132 3571static void
2cf0635d 3572parse_args (int argc, char ** argv)
252b5132
RH		 3573{
3574 int c;
3575
3576 if (argc < 2)
92f01d61 3577 usage (stderr);
252b5132
RH		 3578
3579 while ((c = getopt_long
cf13d699 3580 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3581 {
252b5132
RH		 3582 switch (c)
3583 {
3584 case 0:
3585 /* Long options. */
3586 break;
3587 case 'H':
92f01d61 3588 usage (stdout);
252b5132
RH		 3589 break;
3590
3591 case 'a':
b34976b6
AM		 3592 do_syms++;
3593 do_reloc++;
3594 do_unwind++;
3595 do_dynamic++;
3596 do_header++;
3597 do_sections++;
f5842774 3598 do_section_groups++;
b34976b6
AM		 3599 do_segments++;
3600 do_version++;
3601 do_histogram++;
3602 do_arch++;
3603 do_notes++;
252b5132 3604 break;
f5842774
L		 3605 case 'g':
3606 do_section_groups++;
3607 break;
5477e8a0 3608 case 't':
595cf52e 3609 case 'N':
5477e8a0
L		 3610 do_sections++;
3611 do_section_details++;
595cf52e 3612 break;
252b5132 3613 case 'e':
b34976b6
AM		 3614 do_header++;
3615 do_sections++;
3616 do_segments++;
252b5132 3617 break;
a952a375 3618 case 'A':
b34976b6 3619 do_arch++;
a952a375 3620 break;
252b5132 3621 case 'D':
b34976b6 3622 do_using_dynamic++;
252b5132
RH		 3623 break;
3624 case 'r':
b34976b6 3625 do_reloc++;
252b5132 3626 break;
4d6ed7c8 3627 case 'u':
b34976b6 3628 do_unwind++;
4d6ed7c8 3629 break;
252b5132 3630 case 'h':
b34976b6 3631 do_header++;
252b5132
RH		 3632 break;
3633 case 'l':
b34976b6 3634 do_segments++;
252b5132
RH		 3635 break;
3636 case 's':
b34976b6 3637 do_syms++;
252b5132
RH		 3638 break;
3639 case 'S':
b34976b6 3640 do_sections++;
252b5132
RH		 3641 break;
3642 case 'd':
b34976b6 3643 do_dynamic++;
252b5132 3644 break;
a952a375 3645 case 'I':
b34976b6 3646 do_histogram++;
a952a375 3647 break;
779fe533 3648 case 'n':
b34976b6 3649 do_notes++;
779fe533 3650 break;
4145f1d5
NC		 3651 case 'c':
3652 do_archive_index++;
3653 break;
252b5132 3654 case 'x':
cf13d699 3655 request_dump (HEX_DUMP);
aef1f6d0 3656 break;
09c11c86 3657 case 'p':
cf13d699
NC		 3658 request_dump (STRING_DUMP);
3659 break;
3660 case 'R':
3661 request_dump (RELOC_DUMP);
09c11c86 3662 break;
252b5132 3663 case 'w':
b34976b6 3664 do_dump++;
252b5132 3665 if (optarg == 0)
613ff48b
CC		 3666 {
3667 do_debugging = 1;
3668 dwarf_select_sections_all ();
3669 }
252b5132
RH		 3670 else
3671 {
3672 do_debugging = 0;
4cb93e3b 3673 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3674 }
3675 break;
2979dc34 3676 case OPTION_DEBUG_DUMP:
b34976b6 3677 do_dump++;
2979dc34
JJ		 3678 if (optarg == 0)
3679 do_debugging = 1;
3680 else
3681 {
2979dc34 3682 do_debugging = 0;
4cb93e3b 3683 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3684 }
3685 break;
fd2f0033
TT		 3686 case OPTION_DWARF_DEPTH:
3687 {
3688 char *cp;
3689
3690 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3691 }
3692 break;
3693 case OPTION_DWARF_START:
3694 {
3695 char *cp;
3696
3697 dwarf_start_die = strtoul (optarg, & cp, 0);
3698 }
3699 break;
4723351a
CC		 3700 case OPTION_DWARF_CHECK:
3701 dwarf_check = 1;
3702 break;
2c610e4b
L		 3703 case OPTION_DYN_SYMS:
3704 do_dyn_syms++;
3705 break;
252b5132
RH		 3706#ifdef SUPPORT_DISASSEMBLY
3707 case 'i':
cf13d699
NC		 3708 request_dump (DISASS_DUMP);
3709 break;
252b5132
RH		 3710#endif
3711 case 'v':
3712 print_version (program_name);
3713 break;
3714 case 'V':
b34976b6 3715 do_version++;
252b5132 3716 break;
d974e256 3717 case 'W':
b34976b6 3718 do_wide++;
d974e256 3719 break;
252b5132 3720 default:
252b5132
RH		 3721 /* xgettext:c-format */
3722 error (_("Invalid option '-%c'\n"), c);
3723 /* Drop through. */
3724 case '?':
92f01d61 3725 usage (stderr);
252b5132
RH		 3726 }
3727 }
3728
4d6ed7c8 3729 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3730 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3731 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3732 && !do_section_groups && !do_archive_index
3733 && !do_dyn_syms)
92f01d61 3734 usage (stderr);
252b5132
RH		 3735 else if (argc < 3)
3736 {
3737 warn (_("Nothing to do.\n"));
92f01d61 3738 usage (stderr);
252b5132
RH		 3739 }
3740}
3741
3742static const char *
d3ba0551 3743get_elf_class (unsigned int elf_class)
252b5132 3744{
b34976b6 3745 static char buff[32];
103f02d3 3746
252b5132
RH		 3747 switch (elf_class)
3748 {
3749 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3750 case ELFCLASS32: return "ELF32";
3751 case ELFCLASS64: return "ELF64";
ab5e7794 3752 default:
e9e44622 3753 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3754 return buff;
252b5132
RH		 3755 }
3756}
3757
3758static const char *
d3ba0551 3759get_data_encoding (unsigned int encoding)
252b5132 3760{
b34976b6 3761 static char buff[32];
103f02d3 3762
252b5132
RH		 3763 switch (encoding)
3764 {
3765 case ELFDATANONE: return _("none");
33c63f9d
CM		 3766 case ELFDATA2LSB: return _("2's complement, little endian");
3767 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3768 default:
e9e44622 3769 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3770 return buff;
252b5132
RH		 3771 }
3772}
3773
252b5132 3774/* Decode the data held in 'elf_header'. */
ee42cf8c 3775
252b5132 3776static int
d3ba0551 3777process_file_header (void)
252b5132 3778{
b34976b6
AM		 3779 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3780 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3781 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3782 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3783 {
3784 error
3785 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3786 return 0;
3787 }
3788
2dc4cec1
L		 3789 init_dwarf_regnames (elf_header.e_machine);
3790
252b5132
RH		 3791 if (do_header)
3792 {
3793 int i;
3794
3795 printf (_("ELF Header:\n"));
3796 printf (_(" Magic: "));
b34976b6
AM		 3797 for (i = 0; i < EI_NIDENT; i++)
3798 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3799 printf ("\n");
3800 printf (_(" Class: %s\n"),
b34976b6 3801 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3802 printf (_(" Data: %s\n"),
b34976b6 3803 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3804 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3805 elf_header.e_ident[EI_VERSION],
3806 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3807 ? "(current)"
b34976b6 3808 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3809 ? _("<unknown: %lx>")
789be9f7 3810 : "")));
252b5132 3811 printf (_(" OS/ABI: %s\n"),
b34976b6 3812 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3813 printf (_(" ABI Version: %d\n"),
b34976b6 3814 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3815 printf (_(" Type: %s\n"),
3816 get_file_type (elf_header.e_type));
3817 printf (_(" Machine: %s\n"),
3818 get_machine_name (elf_header.e_machine));
3819 printf (_(" Version: 0x%lx\n"),
3820 (unsigned long) elf_header.e_version);
76da6bbe 3821
f7a99963
NC		 3822 printf (_(" Entry point address: "));
3823 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3824 printf (_("\n Start of program headers: "));
3825 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3826 printf (_(" (bytes into file)\n Start of section headers: "));
3827 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3828 printf (_(" (bytes into file)\n"));
76da6bbe 3829
252b5132
RH		 3830 printf (_(" Flags: 0x%lx%s\n"),
3831 (unsigned long) elf_header.e_flags,
3832 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3833 printf (_(" Size of this header: %ld (bytes)\n"),
3834 (long) elf_header.e_ehsize);
3835 printf (_(" Size of program headers: %ld (bytes)\n"),
3836 (long) elf_header.e_phentsize);
2046a35d 3837 printf (_(" Number of program headers: %ld"),
252b5132 3838 (long) elf_header.e_phnum);
2046a35d
AM		 3839 if (section_headers != NULL
3840 && elf_header.e_phnum == PN_XNUM
3841 && section_headers[0].sh_info != 0)
cc5914eb 3842 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3843 putc ('\n', stdout);
252b5132
RH		 3844 printf (_(" Size of section headers: %ld (bytes)\n"),
3845 (long) elf_header.e_shentsize);
560f3c1c 3846 printf (_(" Number of section headers: %ld"),
252b5132 3847 (long) elf_header.e_shnum);
4fbb74a6 3848 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3849 printf (" (%ld)", (long) section_headers[0].sh_size);
3850 putc ('\n', stdout);
3851 printf (_(" Section header string table index: %ld"),
252b5132 3852 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3853 if (section_headers != NULL
3854 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3855 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3856 else if (elf_header.e_shstrndx != SHN_UNDEF
3857 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3858 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3859 putc ('\n', stdout);
3860 }
3861
3862 if (section_headers != NULL)
3863 {
2046a35d
AM		 3864 if (elf_header.e_phnum == PN_XNUM
3865 && section_headers[0].sh_info != 0)
3866 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3867 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3868 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3869 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3870 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3871 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3872 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3873 free (section_headers);
3874 section_headers = NULL;
252b5132 3875 }
103f02d3 3876
9ea033b2
NC		 3877 return 1;
3878}
3879
252b5132 3880
9ea033b2 3881static int
91d6fa6a 3882get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3883{
2cf0635d
NC		 3884 Elf32_External_Phdr * phdrs;
3885 Elf32_External_Phdr * external;
3886 Elf_Internal_Phdr * internal;
b34976b6 3887 unsigned int i;
103f02d3 3888
3f5e193b
NC		 3889 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3890 elf_header.e_phentsize,
3891 elf_header.e_phnum,
3892 _("program headers"));
a6e9f9df
AM		 3893 if (!phdrs)
3894 return 0;
9ea033b2 3895
91d6fa6a 3896 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3897 i < elf_header.e_phnum;
b34976b6 3898 i++, internal++, external++)
252b5132 3899 {
9ea033b2
NC		 3900 internal->p_type = BYTE_GET (external->p_type);
3901 internal->p_offset = BYTE_GET (external->p_offset);
3902 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3903 internal->p_paddr = BYTE_GET (external->p_paddr);
3904 internal->p_filesz = BYTE_GET (external->p_filesz);
3905 internal->p_memsz = BYTE_GET (external->p_memsz);
3906 internal->p_flags = BYTE_GET (external->p_flags);
3907 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3908 }
3909
9ea033b2
NC		 3910 free (phdrs);
3911
252b5132
RH		 3912 return 1;
3913}
3914
9ea033b2 3915static int
91d6fa6a 3916get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3917{
2cf0635d
NC		 3918 Elf64_External_Phdr * phdrs;
3919 Elf64_External_Phdr * external;
3920 Elf_Internal_Phdr * internal;
b34976b6 3921 unsigned int i;
103f02d3 3922
3f5e193b
NC		 3923 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3924 elf_header.e_phentsize,
3925 elf_header.e_phnum,
3926 _("program headers"));
a6e9f9df
AM		 3927 if (!phdrs)
3928 return 0;
9ea033b2 3929
91d6fa6a 3930 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3931 i < elf_header.e_phnum;
b34976b6 3932 i++, internal++, external++)
9ea033b2
NC		 3933 {
3934 internal->p_type = BYTE_GET (external->p_type);
3935 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3936 internal->p_offset = BYTE_GET (external->p_offset);
3937 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3938 internal->p_paddr = BYTE_GET (external->p_paddr);
3939 internal->p_filesz = BYTE_GET (external->p_filesz);
3940 internal->p_memsz = BYTE_GET (external->p_memsz);
3941 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3942 }
3943
3944 free (phdrs);
3945
3946 return 1;
3947}
252b5132 3948
d93f0186
NC		 3949/* Returns 1 if the program headers were read into `program_headers'. */
3950
3951static int
2cf0635d 3952get_program_headers (FILE * file)
d93f0186 3953{
2cf0635d 3954 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3955
3956 /* Check cache of prior read. */
3957 if (program_headers != NULL)
3958 return 1;
3959
3f5e193b
NC		 3960 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3961 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3962
3963 if (phdrs == NULL)
3964 {
3965 error (_("Out of memory\n"));
3966 return 0;
3967 }
3968
3969 if (is_32bit_elf
3970 ? get_32bit_program_headers (file, phdrs)
3971 : get_64bit_program_headers (file, phdrs))
3972 {
3973 program_headers = phdrs;
3974 return 1;
3975 }
3976
3977 free (phdrs);
3978 return 0;
3979}
3980
2f62977e
NC		 3981/* Returns 1 if the program headers were loaded. */
3982
252b5132 3983static int
2cf0635d 3984process_program_headers (FILE * file)
252b5132 3985{
2cf0635d 3986 Elf_Internal_Phdr * segment;
b34976b6 3987 unsigned int i;
252b5132
RH		 3988
3989 if (elf_header.e_phnum == 0)
3990 {
82f2dbf7
NC		 3991 /* PR binutils/12467. */
3992 if (elf_header.e_phoff != 0)
3993 warn (_("possibly corrupt ELF header - it has a non-zero program"
3994 " header offset, but no program headers"));
3995 else if (do_segments)
252b5132 3996 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3997 return 0;
252b5132
RH		 3998 }
3999
4000 if (do_segments && !do_header)
4001 {
f7a99963
NC		 4002 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4003 printf (_("Entry point "));
4004 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4005 printf (_("\nThere are %d program headers, starting at offset "),
4006 elf_header.e_phnum);
4007 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4008 printf ("\n");
252b5132
RH		 4009 }
4010
d93f0186 4011 if (! get_program_headers (file))
252b5132 4012 return 0;
103f02d3 4013
252b5132
RH		 4014 if (do_segments)
4015 {
3a1a2036
NC		 4016 if (elf_header.e_phnum > 1)
4017 printf (_("\nProgram Headers:\n"));
4018 else
4019 printf (_("\nProgram Headers:\n"));
76da6bbe 4020
f7a99963
NC		 4021 if (is_32bit_elf)
4022 printf
4023 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4024 else if (do_wide)
4025 printf
4026 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4027 else
4028 {
4029 printf
4030 (_(" Type Offset VirtAddr PhysAddr\n"));
4031 printf
4032 (_(" FileSiz MemSiz Flags Align\n"));
4033 }
252b5132
RH		 4034 }
4035
252b5132 4036 dynamic_addr = 0;
1b228002 4037 dynamic_size = 0;
252b5132
RH		 4038
4039 for (i = 0, segment = program_headers;
4040 i < elf_header.e_phnum;
b34976b6 4041 i++, segment++)
252b5132
RH		 4042 {
4043 if (do_segments)
4044 {
103f02d3 4045 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4046
4047 if (is_32bit_elf)
4048 {
4049 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4050 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4051 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4052 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4053 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4054 printf ("%c%c%c ",
4055 (segment->p_flags & PF_R ? 'R' : ' '),
4056 (segment->p_flags & PF_W ? 'W' : ' '),
4057 (segment->p_flags & PF_X ? 'E' : ' '));
4058 printf ("%#lx", (unsigned long) segment->p_align);
4059 }
d974e256
JJ		 4060 else if (do_wide)
4061 {
4062 if ((unsigned long) segment->p_offset == segment->p_offset)
4063 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4064 else
4065 {
4066 print_vma (segment->p_offset, FULL_HEX);
4067 putchar (' ');
4068 }
4069
4070 print_vma (segment->p_vaddr, FULL_HEX);
4071 putchar (' ');
4072 print_vma (segment->p_paddr, FULL_HEX);
4073 putchar (' ');
4074
4075 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4076 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4077 else
4078 {
4079 print_vma (segment->p_filesz, FULL_HEX);
4080 putchar (' ');
4081 }
4082
4083 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4084 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4085 else
4086 {
f48e6c45 4087 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4088 }
4089
4090 printf (" %c%c%c ",
4091 (segment->p_flags & PF_R ? 'R' : ' '),
4092 (segment->p_flags & PF_W ? 'W' : ' '),
4093 (segment->p_flags & PF_X ? 'E' : ' '));
4094
4095 if ((unsigned long) segment->p_align == segment->p_align)
4096 printf ("%#lx", (unsigned long) segment->p_align);
4097 else
4098 {
4099 print_vma (segment->p_align, PREFIX_HEX);
4100 }
4101 }
f7a99963
NC		 4102 else
4103 {
4104 print_vma (segment->p_offset, FULL_HEX);
4105 putchar (' ');
4106 print_vma (segment->p_vaddr, FULL_HEX);
4107 putchar (' ');
4108 print_vma (segment->p_paddr, FULL_HEX);
4109 printf ("\n ");
4110 print_vma (segment->p_filesz, FULL_HEX);
4111 putchar (' ');
4112 print_vma (segment->p_memsz, FULL_HEX);
4113 printf (" %c%c%c ",
4114 (segment->p_flags & PF_R ? 'R' : ' '),
4115 (segment->p_flags & PF_W ? 'W' : ' '),
4116 (segment->p_flags & PF_X ? 'E' : ' '));
4117 print_vma (segment->p_align, HEX);
4118 }
252b5132
RH		 4119 }
4120
4121 switch (segment->p_type)
4122 {
252b5132
RH		 4123 case PT_DYNAMIC:
4124 if (dynamic_addr)
4125 error (_("more than one dynamic segment\n"));
4126
20737c13
AM		 4127 /* By default, assume that the .dynamic section is the first
4128 section in the DYNAMIC segment. */
4129 dynamic_addr = segment->p_offset;
4130 dynamic_size = segment->p_filesz;
4131
b2d38a17
NC		 4132 /* Try to locate the .dynamic section. If there is
4133 a section header table, we can easily locate it. */
4134 if (section_headers != NULL)
4135 {
2cf0635d 4136 Elf_Internal_Shdr * sec;
b2d38a17 4137
89fac5e3
RS		 4138 sec = find_section (".dynamic");
4139 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4140 {
28f997cf
TG		 4141 /* A corresponding .dynamic section is expected, but on
4142 IA-64/OpenVMS it is OK for it to be missing. */
4143 if (!is_ia64_vms ())
4144 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4145 break;
4146 }
4147
42bb2e33 4148 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4149 {
4150 dynamic_size = 0;
4151 break;
4152 }
42bb2e33 4153
b2d38a17
NC		 4154 dynamic_addr = sec->sh_offset;
4155 dynamic_size = sec->sh_size;
4156
4157 if (dynamic_addr < segment->p_offset
4158 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4159 warn (_("the .dynamic section is not contained"
4160 " within the dynamic segment\n"));
b2d38a17 4161 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4162 warn (_("the .dynamic section is not the first section"
4163 " in the dynamic segment.\n"));
b2d38a17 4164 }
252b5132
RH		 4165 break;
4166
4167 case PT_INTERP:
fb52b2f4
NC		 4168 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4169 SEEK_SET))
252b5132
RH		 4170 error (_("Unable to find program interpreter name\n"));
4171 else
4172 {
f8eae8b2
L		 4173 char fmt [32];
4174 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4175
4176 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4177 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4178
252b5132 4179 program_interpreter[0] = 0;
7bd7b3ef
AM		 4180 if (fscanf (file, fmt, program_interpreter) <= 0)
4181 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4182
4183 if (do_segments)
4184 printf (_("\n [Requesting program interpreter: %s]"),
4185 program_interpreter);
4186 }
4187 break;
4188 }
4189
4190 if (do_segments)
4191 putc ('\n', stdout);
4192 }
4193
c256ffe7 4194 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4195 {
4196 printf (_("\n Section to Segment mapping:\n"));
4197 printf (_(" Segment Sections...\n"));
4198
252b5132
RH		 4199 for (i = 0; i < elf_header.e_phnum; i++)
4200 {
9ad5cbcf 4201 unsigned int j;
2cf0635d 4202 Elf_Internal_Shdr * section;
252b5132
RH		 4203
4204 segment = program_headers + i;
b391a3e3 4205 section = section_headers + 1;
252b5132
RH		 4206
4207 printf (" %2.2d ", i);
4208
b34976b6 4209 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4210 {
f4638467
AM		 4211 if (!ELF_TBSS_SPECIAL (section, segment)
4212 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 4213 printf ("%s ", SECTION_NAME (section));
4214 }
4215
4216 putc ('\n',stdout);
4217 }
4218 }
4219
252b5132
RH		 4220 return 1;
4221}
4222
4223
d93f0186
NC		 4224/* Find the file offset corresponding to VMA by using the program headers. */
4225
4226static long
2cf0635d 4227offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4228{
2cf0635d 4229 Elf_Internal_Phdr * seg;
d93f0186
NC		 4230
4231 if (! get_program_headers (file))
4232 {
4233 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4234 return (long) vma;
4235 }
4236
4237 for (seg = program_headers;
4238 seg < program_headers + elf_header.e_phnum;
4239 ++seg)
4240 {
4241 if (seg->p_type != PT_LOAD)
4242 continue;
4243
4244 if (vma >= (seg->p_vaddr & -seg->p_align)
4245 && vma + size <= seg->p_vaddr + seg->p_filesz)
4246 return vma - seg->p_vaddr + seg->p_offset;
4247 }
4248
4249 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4250 (unsigned long) vma);
d93f0186
NC		 4251 return (long) vma;
4252}
4253
4254
252b5132 4255static int
2cf0635d 4256get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4257{
2cf0635d
NC		 4258 Elf32_External_Shdr * shdrs;
4259 Elf_Internal_Shdr * internal;
b34976b6 4260 unsigned int i;
252b5132 4261
3f5e193b
NC		 4262 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4263 elf_header.e_shentsize, num,
4264 _("section headers"));
a6e9f9df
AM		 4265 if (!shdrs)
4266 return 0;
252b5132 4267
3f5e193b
NC		 4268 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4269 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4270
4271 if (section_headers == NULL)
4272 {
4273 error (_("Out of memory\n"));
4274 return 0;
4275 }
4276
4277 for (i = 0, internal = section_headers;
560f3c1c 4278 i < num;
b34976b6 4279 i++, internal++)
252b5132
RH		 4280 {
4281 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4282 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4283 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4284 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4285 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4286 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4287 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4288 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4289 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4290 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4291 }
4292
4293 free (shdrs);
4294
4295 return 1;
4296}
4297
9ea033b2 4298static int
2cf0635d 4299get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4300{
2cf0635d
NC		 4301 Elf64_External_Shdr * shdrs;
4302 Elf_Internal_Shdr * internal;
b34976b6 4303 unsigned int i;
9ea033b2 4304
3f5e193b
NC		 4305 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4306 elf_header.e_shentsize, num,
4307 _("section headers"));
a6e9f9df
AM		 4308 if (!shdrs)
4309 return 0;
9ea033b2 4310
3f5e193b
NC		 4311 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4312 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4313
4314 if (section_headers == NULL)
4315 {
4316 error (_("Out of memory\n"));
4317 return 0;
4318 }
4319
4320 for (i = 0, internal = section_headers;
560f3c1c 4321 i < num;
b34976b6 4322 i++, internal++)
9ea033b2
NC		 4323 {
4324 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4325 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4326 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4327 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4328 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4329 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4330 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4331 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4332 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4333 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4334 }
4335
4336 free (shdrs);
4337
4338 return 1;
4339}
4340
252b5132 4341static Elf_Internal_Sym *
ba5cdace
NC		 4342get_32bit_elf_symbols (FILE * file,
4343 Elf_Internal_Shdr * section,
4344 unsigned long * num_syms_return)
252b5132 4345{
ba5cdace 4346 unsigned long number = 0;
dd24e3da 4347 Elf32_External_Sym * esyms = NULL;
ba5cdace 4348 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4349 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4350 Elf_Internal_Sym * psym;
b34976b6 4351 unsigned int j;
252b5132 4352
dd24e3da
NC		 4353 /* Run some sanity checks first. */
4354 if (section->sh_entsize == 0)
4355 {
4356 error (_("sh_entsize is zero\n"));
ba5cdace 4357 goto exit_point;
dd24e3da
NC		 4358 }
4359
4360 number = section->sh_size / section->sh_entsize;
4361
4362 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4363 {
4364 error (_("Invalid sh_entsize\n"));
ba5cdace 4365 goto exit_point;
dd24e3da
NC		 4366 }
4367
3f5e193b
NC		 4368 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4369 section->sh_size, _("symbols"));
dd24e3da 4370 if (esyms == NULL)
ba5cdace 4371 goto exit_point;
252b5132 4372
9ad5cbcf
AM		 4373 shndx = NULL;
4374 if (symtab_shndx_hdr != NULL
4375 && (symtab_shndx_hdr->sh_link
4fbb74a6 4376 == (unsigned long) (section - section_headers)))
9ad5cbcf 4377 {
3f5e193b
NC		 4378 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4379 symtab_shndx_hdr->sh_offset,
4380 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4381 _("symbol table section indicies"));
dd24e3da
NC		 4382 if (shndx == NULL)
4383 goto exit_point;
9ad5cbcf
AM		 4384 }
4385
3f5e193b 4386 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4387
4388 if (isyms == NULL)
4389 {
4390 error (_("Out of memory\n"));
dd24e3da 4391 goto exit_point;
252b5132
RH		 4392 }
4393
dd24e3da 4394 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4395 {
4396 psym->st_name = BYTE_GET (esyms[j].st_name);
4397 psym->st_value = BYTE_GET (esyms[j].st_value);
4398 psym->st_size = BYTE_GET (esyms[j].st_size);
4399 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4400 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4401 psym->st_shndx
4402 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4403 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4404 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4405 psym->st_info = BYTE_GET (esyms[j].st_info);
4406 psym->st_other = BYTE_GET (esyms[j].st_other);
4407 }
4408
dd24e3da 4409 exit_point:
ba5cdace 4410 if (shndx != NULL)
9ad5cbcf 4411 free (shndx);
ba5cdace 4412 if (esyms != NULL)
dd24e3da 4413 free (esyms);
252b5132 4414
ba5cdace
NC		 4415 if (num_syms_return != NULL)
4416 * num_syms_return = isyms == NULL ? 0 : number;
4417
252b5132
RH		 4418 return isyms;
4419}
4420
9ea033b2 4421static Elf_Internal_Sym *
ba5cdace
NC		 4422get_64bit_elf_symbols (FILE * file,
4423 Elf_Internal_Shdr * section,
4424 unsigned long * num_syms_return)
9ea033b2 4425{
ba5cdace
NC		 4426 unsigned long number = 0;
4427 Elf64_External_Sym * esyms = NULL;
4428 Elf_External_Sym_Shndx * shndx = NULL;
4429 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4430 Elf_Internal_Sym * psym;
b34976b6 4431 unsigned int j;
9ea033b2 4432
dd24e3da
NC		 4433 /* Run some sanity checks first. */
4434 if (section->sh_entsize == 0)
4435 {
4436 error (_("sh_entsize is zero\n"));
ba5cdace 4437 goto exit_point;
dd24e3da
NC		 4438 }
4439
4440 number = section->sh_size / section->sh_entsize;
4441
4442 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4443 {
4444 error (_("Invalid sh_entsize\n"));
ba5cdace 4445 goto exit_point;
dd24e3da
NC		 4446 }
4447
3f5e193b
NC		 4448 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4449 section->sh_size, _("symbols"));
a6e9f9df 4450 if (!esyms)
ba5cdace 4451 goto exit_point;
9ea033b2 4452
9ad5cbcf
AM		 4453 if (symtab_shndx_hdr != NULL
4454 && (symtab_shndx_hdr->sh_link
4fbb74a6 4455 == (unsigned long) (section - section_headers)))
9ad5cbcf 4456 {
3f5e193b
NC		 4457 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4458 symtab_shndx_hdr->sh_offset,
4459 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4460 _("symbol table section indicies"));
ba5cdace
NC		 4461 if (shndx == NULL)
4462 goto exit_point;
9ad5cbcf
AM		 4463 }
4464
3f5e193b 4465 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4466
4467 if (isyms == NULL)
4468 {
4469 error (_("Out of memory\n"));
ba5cdace 4470 goto exit_point;
9ea033b2
NC		 4471 }
4472
ba5cdace 4473 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4474 {
4475 psym->st_name = BYTE_GET (esyms[j].st_name);
4476 psym->st_info = BYTE_GET (esyms[j].st_info);
4477 psym->st_other = BYTE_GET (esyms[j].st_other);
4478 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4479
4fbb74a6 4480 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4481 psym->st_shndx
4482 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4483 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4484 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4485
66543521
AM		 4486 psym->st_value = BYTE_GET (esyms[j].st_value);
4487 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4488 }
4489
ba5cdace
NC		 4490 exit_point:
4491 if (shndx != NULL)
9ad5cbcf 4492 free (shndx);
ba5cdace
NC		 4493 if (esyms != NULL)
4494 free (esyms);
4495
4496 if (num_syms_return != NULL)
4497 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4498
4499 return isyms;
4500}
4501
d1133906 4502static const char *
d3ba0551 4503get_elf_section_flags (bfd_vma sh_flags)
d1133906 4504{
5477e8a0 4505 static char buff[1024];
2cf0635d 4506 char * p = buff;
8d5ff12c 4507 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4508 int sindex;
4509 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4510 bfd_vma os_flags = 0;
4511 bfd_vma proc_flags = 0;
4512 bfd_vma unknown_flags = 0;
148b93f2 4513 static const struct
5477e8a0 4514 {
2cf0635d 4515 const char * str;
5477e8a0
L		 4516 int len;
4517 }
4518 flags [] =
4519 {
cfcac11d
NC		 4520 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4521 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4522 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4523 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4524 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4525 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4526 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4527 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4528 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4529 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4530 /* IA-64 specific. */
4531 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4532 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4533 /* IA-64 OpenVMS specific. */
4534 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4535 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4536 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4537 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4538 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4539 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4540 /* Generic. */
cfcac11d 4541 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4542 /* SPARC specific. */
cfcac11d 4543 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4544 };
4545
4546 if (do_section_details)
4547 {
8d5ff12c
L		 4548 sprintf (buff, "[%*.*lx]: ",
4549 field_size, field_size, (unsigned long) sh_flags);
4550 p += field_size + 4;
5477e8a0 4551 }
76da6bbe 4552
d1133906
NC		 4553 while (sh_flags)
4554 {
4555 bfd_vma flag;
4556
4557 flag = sh_flags & - sh_flags;
4558 sh_flags &= ~ flag;
76da6bbe 4559
5477e8a0 4560 if (do_section_details)
d1133906 4561 {
5477e8a0
L		 4562 switch (flag)
4563 {
91d6fa6a
NC		 4564 case SHF_WRITE: sindex = 0; break;
4565 case SHF_ALLOC: sindex = 1; break;
4566 case SHF_EXECINSTR: sindex = 2; break;
4567 case SHF_MERGE: sindex = 3; break;
4568 case SHF_STRINGS: sindex = 4; break;
4569 case SHF_INFO_LINK: sindex = 5; break;
4570 case SHF_LINK_ORDER: sindex = 6; break;
4571 case SHF_OS_NONCONFORMING: sindex = 7; break;
4572 case SHF_GROUP: sindex = 8; break;
4573 case SHF_TLS: sindex = 9; break;
18ae9cc1 4574 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4575
5477e8a0 4576 default:
91d6fa6a 4577 sindex = -1;
cfcac11d 4578 switch (elf_header.e_machine)
148b93f2 4579 {
cfcac11d 4580 case EM_IA_64:
148b93f2 4581 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4582 sindex = 10;
148b93f2 4583 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4584 sindex = 11;
148b93f2
NC		 4585#ifdef BFD64
4586 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4587 switch (flag)
4588 {
91d6fa6a
NC		 4589 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4590 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4591 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4592 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4593 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4594 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4595 default: break;
4596 }
4597#endif
cfcac11d
NC		 4598 break;
4599
caa83f8b
NC		 4600 case EM_386:
4601 case EM_486:
4602 case EM_X86_64:
7f502d6c 4603 case EM_L1OM:
7a9068fe 4604 case EM_K1OM:
cfcac11d
NC		 4605 case EM_OLD_SPARCV9:
4606 case EM_SPARC32PLUS:
4607 case EM_SPARCV9:
4608 case EM_SPARC:
18ae9cc1 4609 if (flag == SHF_ORDERED)
91d6fa6a 4610 sindex = 19;
cfcac11d
NC		 4611 break;
4612 default:
4613 break;
148b93f2 4614 }
5477e8a0
L		 4615 }
4616
91d6fa6a 4617 if (sindex != -1)
5477e8a0 4618 {
8d5ff12c
L		 4619 if (p != buff + field_size + 4)
4620 {
4621 if (size < (10 + 2))
4622 abort ();
4623 size -= 2;
4624 *p++ = ',';
4625 *p++ = ' ';
4626 }
4627
91d6fa6a
NC		 4628 size -= flags [sindex].len;
4629 p = stpcpy (p, flags [sindex].str);
5477e8a0 4630 }
3b22753a 4631 else if (flag & SHF_MASKOS)
8d5ff12c 4632 os_flags |= flag;
d1133906 4633 else if (flag & SHF_MASKPROC)
8d5ff12c 4634 proc_flags |= flag;
d1133906 4635 else
8d5ff12c 4636 unknown_flags |= flag;
5477e8a0
L		 4637 }
4638 else
4639 {
4640 switch (flag)
4641 {
4642 case SHF_WRITE: *p = 'W'; break;
4643 case SHF_ALLOC: *p = 'A'; break;
4644 case SHF_EXECINSTR: *p = 'X'; break;
4645 case SHF_MERGE: *p = 'M'; break;
4646 case SHF_STRINGS: *p = 'S'; break;
4647 case SHF_INFO_LINK: *p = 'I'; break;
4648 case SHF_LINK_ORDER: *p = 'L'; break;
4649 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4650 case SHF_GROUP: *p = 'G'; break;
4651 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4652 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4653
4654 default:
8a9036a4 4655 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4656 || elf_header.e_machine == EM_L1OM
4657 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4658 && flag == SHF_X86_64_LARGE)
4659 *p = 'l';
4660 else if (flag & SHF_MASKOS)
4661 {
4662 *p = 'o';
4663 sh_flags &= ~ SHF_MASKOS;
4664 }
4665 else if (flag & SHF_MASKPROC)
4666 {
4667 *p = 'p';
4668 sh_flags &= ~ SHF_MASKPROC;
4669 }
4670 else
4671 *p = 'x';
4672 break;
4673 }
4674 p++;
d1133906
NC		 4675 }
4676 }
76da6bbe 4677
8d5ff12c
L		 4678 if (do_section_details)
4679 {
4680 if (os_flags)
4681 {
4682 size -= 5 + field_size;
4683 if (p != buff + field_size + 4)
4684 {
4685 if (size < (2 + 1))
4686 abort ();
4687 size -= 2;
4688 *p++ = ',';
4689 *p++ = ' ';
4690 }
4691 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4692 (unsigned long) os_flags);
4693 p += 5 + field_size;
4694 }
4695 if (proc_flags)
4696 {
4697 size -= 7 + field_size;
4698 if (p != buff + field_size + 4)
4699 {
4700 if (size < (2 + 1))
4701 abort ();
4702 size -= 2;
4703 *p++ = ',';
4704 *p++ = ' ';
4705 }
4706 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4707 (unsigned long) proc_flags);
4708 p += 7 + field_size;
4709 }
4710 if (unknown_flags)
4711 {
4712 size -= 10 + field_size;
4713 if (p != buff + field_size + 4)
4714 {
4715 if (size < (2 + 1))
4716 abort ();
4717 size -= 2;
4718 *p++ = ',';
4719 *p++ = ' ';
4720 }
2b692964 4721 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4722 (unsigned long) unknown_flags);
4723 p += 10 + field_size;
4724 }
4725 }
4726
e9e44622 4727 *p = '\0';
d1133906
NC		 4728 return buff;
4729}
4730
252b5132 4731static int
2cf0635d 4732process_section_headers (FILE * file)
252b5132 4733{
2cf0635d 4734 Elf_Internal_Shdr * section;
b34976b6 4735 unsigned int i;
252b5132
RH		 4736
4737 section_headers = NULL;
4738
4739 if (elf_header.e_shnum == 0)
4740 {
82f2dbf7
NC		 4741 /* PR binutils/12467. */
4742 if (elf_header.e_shoff != 0)
4743 warn (_("possibly corrupt ELF file header - it has a non-zero"
4744 " section header offset, but no section headers\n"));
4745 else if (do_sections)
252b5132
RH		 4746 printf (_("\nThere are no sections in this file.\n"));
4747
4748 return 1;
4749 }
4750
4751 if (do_sections && !do_header)
9ea033b2 4752 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4753 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4754
9ea033b2
NC		 4755 if (is_32bit_elf)
4756 {
560f3c1c 4757 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4758 return 0;
4759 }
560f3c1c 4760 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4761 return 0;
4762
4763 /* Read in the string table, so that we have names to display. */
0b49d371 4764 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4765 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4766 {
4fbb74a6 4767 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4768
c256ffe7
JJ		 4769 if (section->sh_size != 0)
4770 {
3f5e193b
NC		 4771 string_table = (char *) get_data (NULL, file, section->sh_offset,
4772 1, section->sh_size,
4773 _("string table"));
0de14b54 4774
c256ffe7
JJ		 4775 string_table_length = string_table != NULL ? section->sh_size : 0;
4776 }
252b5132
RH		 4777 }
4778
4779 /* Scan the sections for the dynamic symbol table
e3c8793a 4780 and dynamic string table and debug sections. */
252b5132
RH		 4781 dynamic_symbols = NULL;
4782 dynamic_strings = NULL;
4783 dynamic_syminfo = NULL;
f1ef08cb 4784 symtab_shndx_hdr = NULL;
103f02d3 4785
89fac5e3
RS		 4786 eh_addr_size = is_32bit_elf ? 4 : 8;
4787 switch (elf_header.e_machine)
4788 {
4789 case EM_MIPS:
4790 case EM_MIPS_RS3_LE:
4791 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4792 FDE addresses. However, the ABI also has a semi-official ILP32
4793 variant for which the normal FDE address size rules apply.
4794
4795 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4796 section, where XX is the size of longs in bits. Unfortunately,
4797 earlier compilers provided no way of distinguishing ILP32 objects
4798 from LP64 objects, so if there's any doubt, we should assume that
4799 the official LP64 form is being used. */
4800 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4801 && find_section (".gcc_compiled_long32") == NULL)
4802 eh_addr_size = 8;
4803 break;
0f56a26a
DD		 4804
4805 case EM_H8_300:
4806 case EM_H8_300H:
4807 switch (elf_header.e_flags & EF_H8_MACH)
4808 {
4809 case E_H8_MACH_H8300:
4810 case E_H8_MACH_H8300HN:
4811 case E_H8_MACH_H8300SN:
4812 case E_H8_MACH_H8300SXN:
4813 eh_addr_size = 2;
4814 break;
4815 case E_H8_MACH_H8300H:
4816 case E_H8_MACH_H8300S:
4817 case E_H8_MACH_H8300SX:
4818 eh_addr_size = 4;
4819 break;
4820 }
f4236fe4
DD		 4821 break;
4822
ff7eeb89 4823 case EM_M32C_OLD:
f4236fe4
DD		 4824 case EM_M32C:
4825 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4826 {
4827 case EF_M32C_CPU_M16C:
4828 eh_addr_size = 2;
4829 break;
4830 }
4831 break;
89fac5e3
RS		 4832 }
4833
08d8fa11
JJ		 4834#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4835 do \
4836 { \
9dd3a467 4837 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
08d8fa11 4838 if (section->sh_entsize != expected_entsize) \
9dd3a467 4839 { \
15b42fb0 4840 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
9dd3a467
NC		 4841 i, section->sh_entsize); \
4842 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
4843 (int) expected_entsize); \
4844 section->sh_entsize = expected_entsize; \
4845 } \
08d8fa11
JJ		 4846 } \
4847 while (0)
9dd3a467
NC		 4848
4849#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 4850 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4851 sizeof (Elf64_External_##type))
4852
252b5132
RH		 4853 for (i = 0, section = section_headers;
4854 i < elf_header.e_shnum;
b34976b6 4855 i++, section++)
252b5132 4856 {
2cf0635d 4857 char * name = SECTION_NAME (section);
252b5132
RH		 4858
4859 if (section->sh_type == SHT_DYNSYM)
4860 {
4861 if (dynamic_symbols != NULL)
4862 {
4863 error (_("File contains multiple dynamic symbol tables\n"));
4864 continue;
4865 }
4866
08d8fa11 4867 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4868 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 4869 }
4870 else if (section->sh_type == SHT_STRTAB
18bd398b 4871 && streq (name, ".dynstr"))
252b5132
RH		 4872 {
4873 if (dynamic_strings != NULL)
4874 {
4875 error (_("File contains multiple dynamic string tables\n"));
4876 continue;
4877 }
4878
3f5e193b
NC		 4879 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4880 1, section->sh_size,
4881 _("dynamic strings"));
59245841 4882 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4883 }
9ad5cbcf
AM		 4884 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4885 {
4886 if (symtab_shndx_hdr != NULL)
4887 {
4888 error (_("File contains multiple symtab shndx tables\n"));
4889 continue;
4890 }
4891 symtab_shndx_hdr = section;
4892 }
08d8fa11
JJ		 4893 else if (section->sh_type == SHT_SYMTAB)
4894 CHECK_ENTSIZE (section, i, Sym);
4895 else if (section->sh_type == SHT_GROUP)
4896 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4897 else if (section->sh_type == SHT_REL)
4898 CHECK_ENTSIZE (section, i, Rel);
4899 else if (section->sh_type == SHT_RELA)
4900 CHECK_ENTSIZE (section, i, Rela);
252b5132 4901 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4902 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4903 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 4904 || do_debug_str || do_debug_loc || do_debug_ranges
4905 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 4906 && (const_strneq (name, ".debug_")
4907 || const_strneq (name, ".zdebug_")))
252b5132 4908 {
1b315056
CS		 4909 if (name[1] == 'z')
4910 name += sizeof (".zdebug_") - 1;
4911 else
4912 name += sizeof (".debug_") - 1;
252b5132
RH		 4913
4914 if (do_debugging
4723351a
CC		 4915 || (do_debug_info && const_strneq (name, "info"))
4916 || (do_debug_info && const_strneq (name, "types"))
4917 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 4918 || (do_debug_lines && strcmp (name, "line") == 0)
4919 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 4920 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4921 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 4922 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
4923 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 4924 || (do_debug_aranges && const_strneq (name, "aranges"))
4925 || (do_debug_ranges && const_strneq (name, "ranges"))
4926 || (do_debug_frames && const_strneq (name, "frame"))
4927 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4928 || (do_debug_macinfo && const_strneq (name, "macro"))
4929 || (do_debug_str && const_strneq (name, "str"))
4930 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 4931 || (do_debug_addr && const_strneq (name, "addr"))
4932 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4933 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 4934 )
09c11c86 4935 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4936 }
a262ae96 4937 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4938 else if ((do_debugging || do_debug_info)
0112cd26 4939 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4940 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4941 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4942 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4943 else if (do_gdb_index && streq (name, ".gdb_index"))
4944 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4945 /* Trace sections for Itanium VMS. */
4946 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4947 || do_trace_aranges)
4948 && const_strneq (name, ".trace_"))
4949 {
4950 name += sizeof (".trace_") - 1;
4951
4952 if (do_debugging
4953 || (do_trace_info && streq (name, "info"))
4954 || (do_trace_abbrevs && streq (name, "abbrev"))
4955 || (do_trace_aranges && streq (name, "aranges"))
4956 )
4957 request_dump_bynumber (i, DEBUG_DUMP);
4958 }
4959
252b5132
RH		 4960 }
4961
4962 if (! do_sections)
4963 return 1;
4964
3a1a2036
NC		 4965 if (elf_header.e_shnum > 1)
4966 printf (_("\nSection Headers:\n"));
4967 else
4968 printf (_("\nSection Header:\n"));
76da6bbe 4969
f7a99963 4970 if (is_32bit_elf)
595cf52e 4971 {
5477e8a0 4972 if (do_section_details)
595cf52e
L		 4973 {
4974 printf (_(" [Nr] Name\n"));
5477e8a0 4975 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4976 }
4977 else
4978 printf
4979 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4980 }
d974e256 4981 else if (do_wide)
595cf52e 4982 {
5477e8a0 4983 if (do_section_details)
595cf52e
L		 4984 {
4985 printf (_(" [Nr] Name\n"));
5477e8a0 4986 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4987 }
4988 else
4989 printf
4990 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4991 }
f7a99963
NC		 4992 else
4993 {
5477e8a0 4994 if (do_section_details)
595cf52e
L		 4995 {
4996 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4997 printf (_(" Type Address Offset Link\n"));
4998 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4999 }
5000 else
5001 {
5002 printf (_(" [Nr] Name Type Address Offset\n"));
5003 printf (_(" Size EntSize Flags Link Info Align\n"));
5004 }
f7a99963 5005 }
252b5132 5006
5477e8a0
L		 5007 if (do_section_details)
5008 printf (_(" Flags\n"));
5009
252b5132
RH		 5010 for (i = 0, section = section_headers;
5011 i < elf_header.e_shnum;
b34976b6 5012 i++, section++)
252b5132 5013 {
7bfd842d 5014 printf (" [%2u] ", i);
5477e8a0 5015 if (do_section_details)
595cf52e 5016 {
7bfd842d 5017 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 5018 printf ("\n ");
595cf52e
L		 5019 }
5020 else
7bfd842d
NC		 5021 {
5022 print_symbol (-17, SECTION_NAME (section));
7bfd842d 5023 }
0b4362b0 5024
ea52a088
NC		 5025 printf (do_wide ? " %-15s " : " %-15.15s ",
5026 get_section_type_name (section->sh_type));
0b4362b0 5027
f7a99963
NC		 5028 if (is_32bit_elf)
5029 {
cfcac11d
NC		 5030 const char * link_too_big = NULL;
5031
f7a99963 5032 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5033
f7a99963
NC		 5034 printf ( " %6.6lx %6.6lx %2.2lx",
5035 (unsigned long) section->sh_offset,
5036 (unsigned long) section->sh_size,
5037 (unsigned long) section->sh_entsize);
d1133906 5038
5477e8a0
L		 5039 if (do_section_details)
5040 fputs (" ", stdout);
5041 else
5042 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5043
cfcac11d
NC		 5044 if (section->sh_link >= elf_header.e_shnum)
5045 {
5046 link_too_big = "";
5047 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5048 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5049 switch (elf_header.e_machine)
5050 {
caa83f8b
NC		 5051 case EM_386:
5052 case EM_486:
5053 case EM_X86_64:
7f502d6c 5054 case EM_L1OM:
7a9068fe 5055 case EM_K1OM:
cfcac11d
NC		 5056 case EM_OLD_SPARCV9:
5057 case EM_SPARC32PLUS:
5058 case EM_SPARCV9:
5059 case EM_SPARC:
5060 if (section->sh_link == (SHN_BEFORE & 0xffff))
5061 link_too_big = "BEFORE";
5062 else if (section->sh_link == (SHN_AFTER & 0xffff))
5063 link_too_big = "AFTER";
5064 break;
5065 default:
5066 break;
5067 }
5068 }
5069
5070 if (do_section_details)
5071 {
5072 if (link_too_big != NULL && * link_too_big)
5073 printf ("<%s> ", link_too_big);
5074 else
5075 printf ("%2u ", section->sh_link);
5076 printf ("%3u %2lu\n", section->sh_info,
5077 (unsigned long) section->sh_addralign);
5078 }
5079 else
5080 printf ("%2u %3u %2lu\n",
5081 section->sh_link,
5082 section->sh_info,
5083 (unsigned long) section->sh_addralign);
5084
5085 if (link_too_big && ! * link_too_big)
5086 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5087 i, section->sh_link);
f7a99963 5088 }
d974e256
JJ		 5089 else if (do_wide)
5090 {
5091 print_vma (section->sh_addr, LONG_HEX);
5092
5093 if ((long) section->sh_offset == section->sh_offset)
5094 printf (" %6.6lx", (unsigned long) section->sh_offset);
5095 else
5096 {
5097 putchar (' ');
5098 print_vma (section->sh_offset, LONG_HEX);
5099 }
5100
5101 if ((unsigned long) section->sh_size == section->sh_size)
5102 printf (" %6.6lx", (unsigned long) section->sh_size);
5103 else
5104 {
5105 putchar (' ');
5106 print_vma (section->sh_size, LONG_HEX);
5107 }
5108
5109 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5110 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5111 else
5112 {
5113 putchar (' ');
5114 print_vma (section->sh_entsize, LONG_HEX);
5115 }
5116
5477e8a0
L		 5117 if (do_section_details)
5118 fputs (" ", stdout);
5119 else
5120 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5121
72de5009 5122 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5123
5124 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5125 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5126 else
5127 {
5128 print_vma (section->sh_addralign, DEC);
5129 putchar ('\n');
5130 }
5131 }
5477e8a0 5132 else if (do_section_details)
595cf52e 5133 {
5477e8a0 5134 printf (" %-15.15s ",
595cf52e 5135 get_section_type_name (section->sh_type));
595cf52e
L		 5136 print_vma (section->sh_addr, LONG_HEX);
5137 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5138 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5139 else
5140 {
5141 printf (" ");
5142 print_vma (section->sh_offset, LONG_HEX);
5143 }
72de5009 5144 printf (" %u\n ", section->sh_link);
595cf52e 5145 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5146 putchar (' ');
595cf52e
L		 5147 print_vma (section->sh_entsize, LONG_HEX);
5148
72de5009
AM		 5149 printf (" %-16u %lu\n",
5150 section->sh_info,
595cf52e
L		 5151 (unsigned long) section->sh_addralign);
5152 }
f7a99963
NC		 5153 else
5154 {
5155 putchar (' ');
5156 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5157 if ((long) section->sh_offset == section->sh_offset)
5158 printf (" %8.8lx", (unsigned long) section->sh_offset);
5159 else
5160 {
5161 printf (" ");
5162 print_vma (section->sh_offset, LONG_HEX);
5163 }
f7a99963
NC		 5164 printf ("\n ");
5165 print_vma (section->sh_size, LONG_HEX);
5166 printf (" ");
5167 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5168
d1133906 5169 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5170
72de5009
AM		 5171 printf (" %2u %3u %lu\n",
5172 section->sh_link,
5173 section->sh_info,
f7a99963
NC		 5174 (unsigned long) section->sh_addralign);
5175 }
5477e8a0
L		 5176
5177 if (do_section_details)
5178 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5179 }
5180
5477e8a0 5181 if (!do_section_details)
3dbcc61d
NC		 5182 {
5183 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5184 || elf_header.e_machine == EM_L1OM
5185 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5186 printf (_("Key to Flags:\n\
5187 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5188 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5189 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5190 else
5191 printf (_("Key to Flags:\n\
e3c8793a 5192 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5193 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5194 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5195 }
d1133906 5196
252b5132
RH		 5197 return 1;
5198}
5199
f5842774
L		 5200static const char *
5201get_group_flags (unsigned int flags)
5202{
5203 static char buff[32];
5204 switch (flags)
5205 {
220453ec
AM		 5206 case 0:
5207 return "";
5208
f5842774 5209 case GRP_COMDAT:
220453ec 5210 return "COMDAT ";
f5842774
L		 5211
5212 default:
220453ec 5213 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5214 break;
5215 }
5216 return buff;
5217}
5218
5219static int
2cf0635d 5220process_section_groups (FILE * file)
f5842774 5221{
2cf0635d 5222 Elf_Internal_Shdr * section;
f5842774 5223 unsigned int i;
2cf0635d
NC		 5224 struct group * group;
5225 Elf_Internal_Shdr * symtab_sec;
5226 Elf_Internal_Shdr * strtab_sec;
5227 Elf_Internal_Sym * symtab;
ba5cdace 5228 unsigned long num_syms;
2cf0635d 5229 char * strtab;
c256ffe7 5230 size_t strtab_size;
d1f5c6e3
L		 5231
5232 /* Don't process section groups unless needed. */
5233 if (!do_unwind && !do_section_groups)
5234 return 1;
f5842774
L		 5235
5236 if (elf_header.e_shnum == 0)
5237 {
5238 if (do_section_groups)
82f2dbf7 5239 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5240
5241 return 1;
5242 }
5243
5244 if (section_headers == NULL)
5245 {
5246 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5247 /* PR 13622: This can happen with a corrupt ELF header. */
5248 return 0;
f5842774
L		 5249 }
5250
3f5e193b
NC		 5251 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5252 sizeof (struct group *));
e4b17d5c
L		 5253
5254 if (section_headers_groups == NULL)
5255 {
5256 error (_("Out of memory\n"));
5257 return 0;
5258 }
5259
f5842774 5260 /* Scan the sections for the group section. */
d1f5c6e3 5261 group_count = 0;
f5842774
L		 5262 for (i = 0, section = section_headers;
5263 i < elf_header.e_shnum;
5264 i++, section++)
e4b17d5c
L		 5265 if (section->sh_type == SHT_GROUP)
5266 group_count++;
5267
d1f5c6e3
L		 5268 if (group_count == 0)
5269 {
5270 if (do_section_groups)
5271 printf (_("\nThere are no section groups in this file.\n"));
5272
5273 return 1;
5274 }
5275
3f5e193b 5276 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5277
5278 if (section_groups == NULL)
5279 {
5280 error (_("Out of memory\n"));
5281 return 0;
5282 }
5283
d1f5c6e3
L		 5284 symtab_sec = NULL;
5285 strtab_sec = NULL;
5286 symtab = NULL;
ba5cdace 5287 num_syms = 0;
d1f5c6e3 5288 strtab = NULL;
c256ffe7 5289 strtab_size = 0;
e4b17d5c
L		 5290 for (i = 0, section = section_headers, group = section_groups;
5291 i < elf_header.e_shnum;
5292 i++, section++)
f5842774
L		 5293 {
5294 if (section->sh_type == SHT_GROUP)
5295 {
2cf0635d
NC		 5296 char * name = SECTION_NAME (section);
5297 char * group_name;
5298 unsigned char * start;
5299 unsigned char * indices;
f5842774 5300 unsigned int entry, j, size;
2cf0635d
NC		 5301 Elf_Internal_Shdr * sec;
5302 Elf_Internal_Sym * sym;
f5842774
L		 5303
5304 /* Get the symbol table. */
4fbb74a6
AM		 5305 if (section->sh_link >= elf_header.e_shnum
5306 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5307 != SHT_SYMTAB))
f5842774
L		 5308 {
5309 error (_("Bad sh_link in group section `%s'\n"), name);
5310 continue;
5311 }
d1f5c6e3
L		 5312
5313 if (symtab_sec != sec)
5314 {
5315 symtab_sec = sec;
5316 if (symtab)
5317 free (symtab);
ba5cdace 5318 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5319 }
f5842774 5320
dd24e3da
NC		 5321 if (symtab == NULL)
5322 {
5323 error (_("Corrupt header in group section `%s'\n"), name);
5324 continue;
5325 }
5326
ba5cdace
NC		 5327 if (section->sh_info >= num_syms)
5328 {
5329 error (_("Bad sh_info in group section `%s'\n"), name);
5330 continue;
5331 }
5332
f5842774
L		 5333 sym = symtab + section->sh_info;
5334
5335 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5336 {
4fbb74a6
AM		 5337 if (sym->st_shndx == 0
5338 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5339 {
5340 error (_("Bad sh_info in group section `%s'\n"), name);
5341 continue;
5342 }
ba2685cc 5343
4fbb74a6 5344 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5345 strtab_sec = NULL;
5346 if (strtab)
5347 free (strtab);
f5842774 5348 strtab = NULL;
c256ffe7 5349 strtab_size = 0;
f5842774
L		 5350 }
5351 else
5352 {
5353 /* Get the string table. */
4fbb74a6 5354 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5355 {
5356 strtab_sec = NULL;
5357 if (strtab)
5358 free (strtab);
5359 strtab = NULL;
5360 strtab_size = 0;
5361 }
5362 else if (strtab_sec
4fbb74a6 5363 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5364 {
5365 strtab_sec = sec;
5366 if (strtab)
5367 free (strtab);
3f5e193b
NC		 5368 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5369 1, strtab_sec->sh_size,
5370 _("string table"));
c256ffe7 5371 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5372 }
c256ffe7 5373 group_name = sym->st_name < strtab_size
2b692964 5374 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5375 }
5376
3f5e193b
NC		 5377 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5378 1, section->sh_size,
5379 _("section data"));
59245841
NC		 5380 if (start == NULL)
5381 continue;
f5842774
L		 5382
5383 indices = start;
5384 size = (section->sh_size / section->sh_entsize) - 1;
5385 entry = byte_get (indices, 4);
5386 indices += 4;
e4b17d5c
L		 5387
5388 if (do_section_groups)
5389 {
2b692964 5390 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5391 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5392
e4b17d5c
L		 5393 printf (_(" [Index] Name\n"));
5394 }
5395
5396 group->group_index = i;
5397
f5842774
L		 5398 for (j = 0; j < size; j++)
5399 {
2cf0635d 5400 struct group_list * g;
e4b17d5c 5401
f5842774
L		 5402 entry = byte_get (indices, 4);
5403 indices += 4;
5404
4fbb74a6 5405 if (entry >= elf_header.e_shnum)
391cb864
L		 5406 {
5407 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5408 entry, i, elf_header.e_shnum - 1);
5409 continue;
5410 }
391cb864 5411
4fbb74a6 5412 if (section_headers_groups [entry] != NULL)
e4b17d5c 5413 {
d1f5c6e3
L		 5414 if (entry)
5415 {
391cb864
L		 5416 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5417 entry, i,
4fbb74a6 5418 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5419 continue;
5420 }
5421 else
5422 {
5423 /* Intel C/C++ compiler may put section 0 in a
5424 section group. We just warn it the first time
5425 and ignore it afterwards. */
5426 static int warned = 0;
5427 if (!warned)
5428 {
5429 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5430 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5431 warned++;
5432 }
5433 }
e4b17d5c
L		 5434 }
5435
4fbb74a6 5436 section_headers_groups [entry] = group;
e4b17d5c
L		 5437
5438 if (do_section_groups)
5439 {
4fbb74a6 5440 sec = section_headers + entry;
c256ffe7 5441 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5442 }
5443
3f5e193b 5444 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5445 g->section_index = entry;
5446 g->next = group->root;
5447 group->root = g;
f5842774
L		 5448 }
5449
f5842774
L		 5450 if (start)
5451 free (start);
e4b17d5c
L		 5452
5453 group++;
f5842774
L		 5454 }
5455 }
5456
d1f5c6e3
L		 5457 if (symtab)
5458 free (symtab);
5459 if (strtab)
5460 free (strtab);
f5842774
L		 5461 return 1;
5462}
5463
28f997cf
TG		 5464/* Data used to display dynamic fixups. */
5465
5466struct ia64_vms_dynfixup
5467{
5468 bfd_vma needed_ident; /* Library ident number. */
5469 bfd_vma needed; /* Index in the dstrtab of the library name. */
5470 bfd_vma fixup_needed; /* Index of the library. */
5471 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5472 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5473};
5474
5475/* Data used to display dynamic relocations. */
5476
5477struct ia64_vms_dynimgrela
5478{
5479 bfd_vma img_rela_cnt; /* Number of relocations. */
5480 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5481};
5482
5483/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5484 library). */
5485
5486static void
5487dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5488 const char *strtab, unsigned int strtab_sz)
5489{
5490 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5491 long i;
5492 const char *lib_name;
5493
5494 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5495 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5496 _("dynamic section image fixups"));
5497 if (!imfs)
5498 return;
5499
5500 if (fixup->needed < strtab_sz)
5501 lib_name = strtab + fixup->needed;
5502 else
5503 {
5504 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5505 (unsigned long) fixup->needed);
28f997cf
TG		 5506 lib_name = "???";
5507 }
5508 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5509 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5510 printf
5511 (_("Seg Offset Type SymVec DataType\n"));
5512
5513 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5514 {
5515 unsigned int type;
5516 const char *rtype;
5517
5518 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5519 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5520 type = BYTE_GET (imfs [i].type);
5521 rtype = elf_ia64_reloc_type (type);
5522 if (rtype == NULL)
5523 printf (" 0x%08x ", type);
5524 else
5525 printf (" %-32s ", rtype);
5526 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5527 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5528 }
5529
5530 free (imfs);
5531}
5532
5533/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5534
5535static void
5536dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5537{
5538 Elf64_External_VMS_IMAGE_RELA *imrs;
5539 long i;
5540
5541 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5542 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5543 _("dynamic section image relocations"));
28f997cf
TG		 5544 if (!imrs)
5545 return;
5546
5547 printf (_("\nImage relocs\n"));
5548 printf
5549 (_("Seg Offset Type Addend Seg Sym Off\n"));
5550
5551 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5552 {
5553 unsigned int type;
5554 const char *rtype;
5555
5556 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5557 printf ("%08" BFD_VMA_FMT "x ",
5558 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5559 type = BYTE_GET (imrs [i].type);
5560 rtype = elf_ia64_reloc_type (type);
5561 if (rtype == NULL)
5562 printf ("0x%08x ", type);
5563 else
5564 printf ("%-31s ", rtype);
5565 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5566 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5567 printf ("%08" BFD_VMA_FMT "x\n",
5568 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5569 }
5570
5571 free (imrs);
5572}
5573
5574/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5575
5576static int
5577process_ia64_vms_dynamic_relocs (FILE *file)
5578{
5579 struct ia64_vms_dynfixup fixup;
5580 struct ia64_vms_dynimgrela imgrela;
5581 Elf_Internal_Dyn *entry;
5582 int res = 0;
5583 bfd_vma strtab_off = 0;
5584 bfd_vma strtab_sz = 0;
5585 char *strtab = NULL;
5586
5587 memset (&fixup, 0, sizeof (fixup));
5588 memset (&imgrela, 0, sizeof (imgrela));
5589
5590 /* Note: the order of the entries is specified by the OpenVMS specs. */
5591 for (entry = dynamic_section;
5592 entry < dynamic_section + dynamic_nent;
5593 entry++)
5594 {
5595 switch (entry->d_tag)
5596 {
5597 case DT_IA_64_VMS_STRTAB_OFFSET:
5598 strtab_off = entry->d_un.d_val;
5599 break;
5600 case DT_STRSZ:
5601 strtab_sz = entry->d_un.d_val;
5602 if (strtab == NULL)
5603 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5604 1, strtab_sz, _("dynamic string section"));
5605 break;
5606
5607 case DT_IA_64_VMS_NEEDED_IDENT:
5608 fixup.needed_ident = entry->d_un.d_val;
5609 break;
5610 case DT_NEEDED:
5611 fixup.needed = entry->d_un.d_val;
5612 break;
5613 case DT_IA_64_VMS_FIXUP_NEEDED:
5614 fixup.fixup_needed = entry->d_un.d_val;
5615 break;
5616 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5617 fixup.fixup_rela_cnt = entry->d_un.d_val;
5618 break;
5619 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5620 fixup.fixup_rela_off = entry->d_un.d_val;
5621 res++;
5622 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5623 break;
5624
5625 case DT_IA_64_VMS_IMG_RELA_CNT:
5626 imgrela.img_rela_cnt = entry->d_un.d_val;
5627 break;
5628 case DT_IA_64_VMS_IMG_RELA_OFF:
5629 imgrela.img_rela_off = entry->d_un.d_val;
5630 res++;
5631 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5632 break;
5633
5634 default:
5635 break;
5636 }
5637 }
5638
5639 if (strtab != NULL)
5640 free (strtab);
5641
5642 return res;
5643}
5644
85b1c36d 5645static struct
566b0d53 5646{
2cf0635d 5647 const char * name;
566b0d53
L		 5648 int reloc;
5649 int size;
5650 int rela;
5651} dynamic_relocations [] =
5652{
5653 { "REL", DT_REL, DT_RELSZ, FALSE },
5654 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5655 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5656};
5657
252b5132 5658/* Process the reloc section. */
18bd398b 5659
252b5132 5660static int
2cf0635d 5661process_relocs (FILE * file)
252b5132 5662{
b34976b6
AM		 5663 unsigned long rel_size;
5664 unsigned long rel_offset;
252b5132
RH		 5665
5666
5667 if (!do_reloc)
5668 return 1;
5669
5670 if (do_using_dynamic)
5671 {
566b0d53 5672 int is_rela;
2cf0635d 5673 const char * name;
566b0d53
L		 5674 int has_dynamic_reloc;
5675 unsigned int i;
0de14b54 5676
566b0d53 5677 has_dynamic_reloc = 0;
252b5132 5678
566b0d53 5679 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5680 {
566b0d53
L		 5681 is_rela = dynamic_relocations [i].rela;
5682 name = dynamic_relocations [i].name;
5683 rel_size = dynamic_info [dynamic_relocations [i].size];
5684 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5685
566b0d53
L		 5686 has_dynamic_reloc |= rel_size;
5687
5688 if (is_rela == UNKNOWN)
aa903cfb 5689 {
566b0d53
L		 5690 if (dynamic_relocations [i].reloc == DT_JMPREL)
5691 switch (dynamic_info[DT_PLTREL])
5692 {
5693 case DT_REL:
5694 is_rela = FALSE;
5695 break;
5696 case DT_RELA:
5697 is_rela = TRUE;
5698 break;
5699 }
aa903cfb 5700 }
252b5132 5701
566b0d53
L		 5702 if (rel_size)
5703 {
5704 printf
5705 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5706 name, rel_offset, rel_size);
252b5132 5707
d93f0186
NC		 5708 dump_relocations (file,
5709 offset_from_vma (file, rel_offset, rel_size),
5710 rel_size,
566b0d53 5711 dynamic_symbols, num_dynamic_syms,
d79b3d50 5712 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5713 }
252b5132 5714 }
566b0d53 5715
28f997cf
TG		 5716 if (is_ia64_vms ())
5717 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5718
566b0d53 5719 if (! has_dynamic_reloc)
252b5132
RH		 5720 printf (_("\nThere are no dynamic relocations in this file.\n"));
5721 }
5722 else
5723 {
2cf0635d 5724 Elf_Internal_Shdr * section;
b34976b6
AM		 5725 unsigned long i;
5726 int found = 0;
252b5132
RH		 5727
5728 for (i = 0, section = section_headers;
5729 i < elf_header.e_shnum;
b34976b6 5730 i++, section++)
252b5132
RH		 5731 {
5732 if ( section->sh_type != SHT_RELA
5733 && section->sh_type != SHT_REL)
5734 continue;
5735
5736 rel_offset = section->sh_offset;
5737 rel_size = section->sh_size;
5738
5739 if (rel_size)
5740 {
2cf0635d 5741 Elf_Internal_Shdr * strsec;
b34976b6 5742 int is_rela;
103f02d3 5743
252b5132
RH		 5744 printf (_("\nRelocation section "));
5745
5746 if (string_table == NULL)
19936277 5747 printf ("%d", section->sh_name);
252b5132 5748 else
9cf03b7e 5749 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5750
5751 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5752 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5753
d79b3d50
NC		 5754 is_rela = section->sh_type == SHT_RELA;
5755
4fbb74a6
AM		 5756 if (section->sh_link != 0
5757 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5758 {
2cf0635d
NC		 5759 Elf_Internal_Shdr * symsec;
5760 Elf_Internal_Sym * symtab;
d79b3d50 5761 unsigned long nsyms;
c256ffe7 5762 unsigned long strtablen = 0;
2cf0635d 5763 char * strtab = NULL;
57346661 5764
4fbb74a6 5765 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5766 if (symsec->sh_type != SHT_SYMTAB
5767 && symsec->sh_type != SHT_DYNSYM)
5768 continue;
5769
ba5cdace 5770 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5771
af3fc3bc
AM		 5772 if (symtab == NULL)
5773 continue;
252b5132 5774
4fbb74a6
AM		 5775 if (symsec->sh_link != 0
5776 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5777 {
4fbb74a6 5778 strsec = section_headers + symsec->sh_link;
103f02d3 5779
3f5e193b
NC		 5780 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5781 1, strsec->sh_size,
5782 _("string table"));
c256ffe7
JJ		 5783 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5784 }
252b5132 5785
d79b3d50
NC		 5786 dump_relocations (file, rel_offset, rel_size,
5787 symtab, nsyms, strtab, strtablen, is_rela);
5788 if (strtab)
5789 free (strtab);
5790 free (symtab);
5791 }
5792 else
5793 dump_relocations (file, rel_offset, rel_size,
5794 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5795
5796 found = 1;
5797 }
5798 }
5799
5800 if (! found)
5801 printf (_("\nThere are no relocations in this file.\n"));
5802 }
5803
5804 return 1;
5805}
5806
57346661
AM		 5807/* Process the unwind section. */
5808
4d6ed7c8
NC		 5809#include "unwind-ia64.h"
5810
5811/* An absolute address consists of a section and an offset. If the
5812 section is NULL, the offset itself is the address, otherwise, the
5813 address equals to LOAD_ADDRESS(section) + offset. */
5814
5815struct absaddr
5816 {
5817 unsigned short section;
5818 bfd_vma offset;
5819 };
5820
1949de15
L		 5821#define ABSADDR(a) \
5822 ((a).section \
5823 ? section_headers [(a).section].sh_addr + (a).offset \
5824 : (a).offset)
5825
3f5e193b
NC		 5826struct ia64_unw_table_entry
5827 {
5828 struct absaddr start;
5829 struct absaddr end;
5830 struct absaddr info;
5831 };
5832
57346661 5833struct ia64_unw_aux_info
4d6ed7c8 5834 {
3f5e193b
NC		 5835
5836 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5837 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5838 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5839 unsigned long info_size; /* Size of unwind info. */
5840 bfd_vma info_addr; /* starting address of unwind info. */
5841 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5842 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5843 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5844 char * strtab; /* The string table. */
b34976b6 5845 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5846 };
5847
4d6ed7c8 5848static void
2cf0635d 5849find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5850 unsigned long nsyms,
2cf0635d 5851 const char * strtab,
57346661 5852 unsigned long strtab_size,
d3ba0551 5853 struct absaddr addr,
2cf0635d
NC		 5854 const char ** symname,
5855 bfd_vma * offset)
4d6ed7c8 5856{
d3ba0551 5857 bfd_vma dist = 0x100000;
2cf0635d
NC		 5858 Elf_Internal_Sym * sym;
5859 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5860 unsigned long i;
5861
0b6ae522
DJ		 5862 REMOVE_ARCH_BITS (addr.offset);
5863
57346661 5864 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5865 {
0b6ae522
DJ		 5866 bfd_vma value = sym->st_value;
5867
5868 REMOVE_ARCH_BITS (value);
5869
4d6ed7c8
NC		 5870 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5871 && sym->st_name != 0
5872 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5873 && addr.offset >= value
5874 && addr.offset - value < dist)
4d6ed7c8
NC		 5875 {
5876 best = sym;
0b6ae522 5877 dist = addr.offset - value;
4d6ed7c8
NC		 5878 if (!dist)
5879 break;
5880 }
5881 }
1b31d05e 5882
4d6ed7c8
NC		 5883 if (best)
5884 {
57346661 5885 *symname = (best->st_name >= strtab_size
2b692964 5886 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5887 *offset = dist;
5888 return;
5889 }
1b31d05e 5890
4d6ed7c8
NC		 5891 *symname = NULL;
5892 *offset = addr.offset;
5893}
5894
5895static void
2cf0635d 5896dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5897{
2cf0635d 5898 struct ia64_unw_table_entry * tp;
4d6ed7c8 5899 int in_body;
7036c0e1 5900
4d6ed7c8
NC		 5901 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5902 {
5903 bfd_vma stamp;
5904 bfd_vma offset;
2cf0635d
NC		 5905 const unsigned char * dp;
5906 const unsigned char * head;
5907 const char * procname;
4d6ed7c8 5908
57346661
AM		 5909 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5910 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5911
5912 fputs ("\n<", stdout);
5913
5914 if (procname)
5915 {
5916 fputs (procname, stdout);
5917
5918 if (offset)
5919 printf ("+%lx", (unsigned long) offset);
5920 }
5921
5922 fputs (">: [", stdout);
5923 print_vma (tp->start.offset, PREFIX_HEX);
5924 fputc ('-', stdout);
5925 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5926 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5927 (unsigned long) (tp->info.offset - aux->seg_base));
5928
1949de15 5929 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5930 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5931
86f55779 5932 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5933 (unsigned) UNW_VER (stamp),
5934 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5935 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5936 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5937 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5938
5939 if (UNW_VER (stamp) != 1)
5940 {
2b692964 5941 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5942 continue;
5943 }
5944
5945 in_body = 0;
89fac5e3 5946 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5947 dp = unw_decode (dp, in_body, & in_body);
5948 }
5949}
5950
5951static int
2cf0635d
NC		 5952slurp_ia64_unwind_table (FILE * file,
5953 struct ia64_unw_aux_info * aux,
5954 Elf_Internal_Shdr * sec)
4d6ed7c8 5955{
89fac5e3 5956 unsigned long size, nrelas, i;
2cf0635d
NC		 5957 Elf_Internal_Phdr * seg;
5958 struct ia64_unw_table_entry * tep;
5959 Elf_Internal_Shdr * relsec;
5960 Elf_Internal_Rela * rela;
5961 Elf_Internal_Rela * rp;
5962 unsigned char * table;
5963 unsigned char * tp;
5964 Elf_Internal_Sym * sym;
5965 const char * relname;
4d6ed7c8 5966
4d6ed7c8
NC		 5967 /* First, find the starting address of the segment that includes
5968 this section: */
5969
5970 if (elf_header.e_phnum)
5971 {
d93f0186 5972 if (! get_program_headers (file))
4d6ed7c8 5973 return 0;
4d6ed7c8 5974
d93f0186
NC		 5975 for (seg = program_headers;
5976 seg < program_headers + elf_header.e_phnum;
5977 ++seg)
4d6ed7c8
NC		 5978 {
5979 if (seg->p_type != PT_LOAD)
5980 continue;
5981
5982 if (sec->sh_addr >= seg->p_vaddr
5983 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5984 {
5985 aux->seg_base = seg->p_vaddr;
5986 break;
5987 }
5988 }
4d6ed7c8
NC		 5989 }
5990
5991 /* Second, build the unwind table from the contents of the unwind section: */
5992 size = sec->sh_size;
3f5e193b
NC		 5993 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5994 _("unwind table"));
a6e9f9df
AM		 5995 if (!table)
5996 return 0;
4d6ed7c8 5997
3f5e193b
NC		 5998 aux->table = (struct ia64_unw_table_entry *)
5999 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 6000 tep = aux->table;
c6a0c689 6001 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 6002 {
6003 tep->start.section = SHN_UNDEF;
6004 tep->end.section = SHN_UNDEF;
6005 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6006 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6007 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6008 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6009 tep->start.offset += aux->seg_base;
6010 tep->end.offset += aux->seg_base;
6011 tep->info.offset += aux->seg_base;
6012 }
6013 free (table);
6014
41e92641 6015 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6016 for (relsec = section_headers;
6017 relsec < section_headers + elf_header.e_shnum;
6018 ++relsec)
6019 {
6020 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6021 || relsec->sh_info >= elf_header.e_shnum
6022 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6023 continue;
6024
6025 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6026 & rela, & nrelas))
6027 return 0;
6028
6029 for (rp = rela; rp < rela + nrelas; ++rp)
6030 {
aca88567
NC		 6031 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6032 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6033
0112cd26 6034 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6035 {
e5fb9629 6036 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 6037 continue;
6038 }
6039
89fac5e3 6040 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6041
89fac5e3 6042 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 6043 {
6044 case 0:
6045 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6046 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6047 break;
6048 case 1:
6049 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6050 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6051 break;
6052 case 2:
6053 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6054 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6055 break;
6056 default:
6057 break;
6058 }
6059 }
6060
6061 free (rela);
6062 }
6063
89fac5e3 6064 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 6065 return 1;
6066}
6067
1b31d05e 6068static void
2cf0635d 6069ia64_process_unwind (FILE * file)
4d6ed7c8 6070{
2cf0635d
NC		 6071 Elf_Internal_Shdr * sec;
6072 Elf_Internal_Shdr * unwsec = NULL;
6073 Elf_Internal_Shdr * strsec;
89fac5e3 6074 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6075 struct ia64_unw_aux_info aux;
f1467e33 6076
4d6ed7c8
NC		 6077 memset (& aux, 0, sizeof (aux));
6078
4d6ed7c8
NC		 6079 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6080 {
c256ffe7 6081 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6082 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6083 {
ba5cdace 6084 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6085
4fbb74a6 6086 strsec = section_headers + sec->sh_link;
59245841 6087 assert (aux.strtab == NULL);
3f5e193b
NC		 6088 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6089 1, strsec->sh_size,
6090 _("string table"));
c256ffe7 6091 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6092 }
6093 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6094 unwcount++;
6095 }
6096
6097 if (!unwcount)
6098 printf (_("\nThere are no unwind sections in this file.\n"));
6099
6100 while (unwcount-- > 0)
6101 {
2cf0635d 6102 char * suffix;
579f31ac
JJ		 6103 size_t len, len2;
6104
6105 for (i = unwstart, sec = section_headers + unwstart;
6106 i < elf_header.e_shnum; ++i, ++sec)
6107 if (sec->sh_type == SHT_IA_64_UNWIND)
6108 {
6109 unwsec = sec;
6110 break;
6111 }
6112
6113 unwstart = i + 1;
6114 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6115
e4b17d5c
L		 6116 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6117 {
6118 /* We need to find which section group it is in. */
2cf0635d 6119 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 6120
6121 for (; g != NULL; g = g->next)
6122 {
4fbb74a6 6123 sec = section_headers + g->section_index;
18bd398b
NC		 6124
6125 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6126 break;
e4b17d5c
L		 6127 }
6128
6129 if (g == NULL)
6130 i = elf_header.e_shnum;
6131 }
18bd398b 6132 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6133 {
18bd398b 6134 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6135 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6136 suffix = SECTION_NAME (unwsec) + len;
6137 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6138 ++i, ++sec)
18bd398b
NC		 6139 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6140 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6141 break;
6142 }
6143 else
6144 {
6145 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6146 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6147 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6148 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6149 suffix = "";
18bd398b 6150 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6151 suffix = SECTION_NAME (unwsec) + len;
6152 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6153 ++i, ++sec)
18bd398b
NC		 6154 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6155 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6156 break;
6157 }
6158
6159 if (i == elf_header.e_shnum)
6160 {
6161 printf (_("\nCould not find unwind info section for "));
6162
6163 if (string_table == NULL)
6164 printf ("%d", unwsec->sh_name);
6165 else
3a1a2036 6166 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 6167 }
6168 else
4d6ed7c8 6169 {
4d6ed7c8 6170 aux.info_addr = sec->sh_addr;
3f5e193b 6171 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6172 sec->sh_size,
3f5e193b 6173 _("unwind info"));
59245841 6174 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6175
579f31ac 6176 printf (_("\nUnwind section "));
4d6ed7c8 6177
579f31ac
JJ		 6178 if (string_table == NULL)
6179 printf ("%d", unwsec->sh_name);
6180 else
3a1a2036 6181 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6182
579f31ac 6183 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6184 (unsigned long) unwsec->sh_offset,
89fac5e3 6185 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6186
579f31ac 6187 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6188
579f31ac
JJ		 6189 if (aux.table_len > 0)
6190 dump_ia64_unwind (& aux);
6191
6192 if (aux.table)
6193 free ((char *) aux.table);
6194 if (aux.info)
6195 free ((char *) aux.info);
6196 aux.table = NULL;
6197 aux.info = NULL;
6198 }
4d6ed7c8 6199 }
4d6ed7c8 6200
4d6ed7c8
NC		 6201 if (aux.symtab)
6202 free (aux.symtab);
6203 if (aux.strtab)
6204 free ((char *) aux.strtab);
4d6ed7c8
NC		 6205}
6206
3f5e193b
NC		 6207struct hppa_unw_table_entry
6208 {
6209 struct absaddr start;
6210 struct absaddr end;
6211 unsigned int Cannot_unwind:1; /* 0 */
6212 unsigned int Millicode:1; /* 1 */
6213 unsigned int Millicode_save_sr0:1; /* 2 */
6214 unsigned int Region_description:2; /* 3..4 */
6215 unsigned int reserved1:1; /* 5 */
6216 unsigned int Entry_SR:1; /* 6 */
6217 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6218 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6219 unsigned int Args_stored:1; /* 16 */
6220 unsigned int Variable_Frame:1; /* 17 */
6221 unsigned int Separate_Package_Body:1; /* 18 */
6222 unsigned int Frame_Extension_Millicode:1; /* 19 */
6223 unsigned int Stack_Overflow_Check:1; /* 20 */
6224 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6225 unsigned int Ada_Region:1; /* 22 */
6226 unsigned int cxx_info:1; /* 23 */
6227 unsigned int cxx_try_catch:1; /* 24 */
6228 unsigned int sched_entry_seq:1; /* 25 */
6229 unsigned int reserved2:1; /* 26 */
6230 unsigned int Save_SP:1; /* 27 */
6231 unsigned int Save_RP:1; /* 28 */
6232 unsigned int Save_MRP_in_frame:1; /* 29 */
6233 unsigned int extn_ptr_defined:1; /* 30 */
6234 unsigned int Cleanup_defined:1; /* 31 */
6235
6236 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6237 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6238 unsigned int Large_frame:1; /* 2 */
6239 unsigned int Pseudo_SP_Set:1; /* 3 */
6240 unsigned int reserved4:1; /* 4 */
6241 unsigned int Total_frame_size:27; /* 5..31 */
6242 };
6243
57346661
AM		 6244struct hppa_unw_aux_info
6245 {
3f5e193b 6246 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6247 unsigned long table_len; /* Length of unwind table. */
6248 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6249 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6250 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6251 char * strtab; /* The string table. */
57346661
AM		 6252 unsigned long strtab_size; /* Size of string table. */
6253 };
6254
6255static void
2cf0635d 6256dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6257{
2cf0635d 6258 struct hppa_unw_table_entry * tp;
57346661 6259
57346661
AM		 6260 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6261 {
6262 bfd_vma offset;
2cf0635d 6263 const char * procname;
57346661
AM		 6264
6265 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6266 aux->strtab_size, tp->start, &procname,
6267 &offset);
6268
6269 fputs ("\n<", stdout);
6270
6271 if (procname)
6272 {
6273 fputs (procname, stdout);
6274
6275 if (offset)
6276 printf ("+%lx", (unsigned long) offset);
6277 }
6278
6279 fputs (">: [", stdout);
6280 print_vma (tp->start.offset, PREFIX_HEX);
6281 fputc ('-', stdout);
6282 print_vma (tp->end.offset, PREFIX_HEX);
6283 printf ("]\n\t");
6284
18bd398b
NC		 6285#define PF(_m) if (tp->_m) printf (#_m " ");
6286#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6287 PF(Cannot_unwind);
6288 PF(Millicode);
6289 PF(Millicode_save_sr0);
18bd398b 6290 /* PV(Region_description); */
57346661
AM		 6291 PF(Entry_SR);
6292 PV(Entry_FR);
6293 PV(Entry_GR);
6294 PF(Args_stored);
6295 PF(Variable_Frame);
6296 PF(Separate_Package_Body);
6297 PF(Frame_Extension_Millicode);
6298 PF(Stack_Overflow_Check);
6299 PF(Two_Instruction_SP_Increment);
6300 PF(Ada_Region);
6301 PF(cxx_info);
6302 PF(cxx_try_catch);
6303 PF(sched_entry_seq);
6304 PF(Save_SP);
6305 PF(Save_RP);
6306 PF(Save_MRP_in_frame);
6307 PF(extn_ptr_defined);
6308 PF(Cleanup_defined);
6309 PF(MPE_XL_interrupt_marker);
6310 PF(HP_UX_interrupt_marker);
6311 PF(Large_frame);
6312 PF(Pseudo_SP_Set);
6313 PV(Total_frame_size);
6314#undef PF
6315#undef PV
6316 }
6317
18bd398b 6318 printf ("\n");
57346661
AM		 6319}
6320
6321static int
2cf0635d
NC		 6322slurp_hppa_unwind_table (FILE * file,
6323 struct hppa_unw_aux_info * aux,
6324 Elf_Internal_Shdr * sec)
57346661 6325{
1c0751b2 6326 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6327 Elf_Internal_Phdr * seg;
6328 struct hppa_unw_table_entry * tep;
6329 Elf_Internal_Shdr * relsec;
6330 Elf_Internal_Rela * rela;
6331 Elf_Internal_Rela * rp;
6332 unsigned char * table;
6333 unsigned char * tp;
6334 Elf_Internal_Sym * sym;
6335 const char * relname;
57346661 6336
57346661
AM		 6337 /* First, find the starting address of the segment that includes
6338 this section. */
6339
6340 if (elf_header.e_phnum)
6341 {
6342 if (! get_program_headers (file))
6343 return 0;
6344
6345 for (seg = program_headers;
6346 seg < program_headers + elf_header.e_phnum;
6347 ++seg)
6348 {
6349 if (seg->p_type != PT_LOAD)
6350 continue;
6351
6352 if (sec->sh_addr >= seg->p_vaddr
6353 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6354 {
6355 aux->seg_base = seg->p_vaddr;
6356 break;
6357 }
6358 }
6359 }
6360
6361 /* Second, build the unwind table from the contents of the unwind
6362 section. */
6363 size = sec->sh_size;
3f5e193b
NC		 6364 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6365 _("unwind table"));
57346661
AM		 6366 if (!table)
6367 return 0;
6368
1c0751b2
DA		 6369 unw_ent_size = 16;
6370 nentries = size / unw_ent_size;
6371 size = unw_ent_size * nentries;
57346661 6372
3f5e193b
NC		 6373 tep = aux->table = (struct hppa_unw_table_entry *)
6374 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6375
1c0751b2 6376 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6377 {
6378 unsigned int tmp1, tmp2;
6379
6380 tep->start.section = SHN_UNDEF;
6381 tep->end.section = SHN_UNDEF;
6382
1c0751b2
DA		 6383 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6384 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6385 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6386 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6387
6388 tep->start.offset += aux->seg_base;
6389 tep->end.offset += aux->seg_base;
57346661
AM		 6390
6391 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6392 tep->Millicode = (tmp1 >> 30) & 0x1;
6393 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6394 tep->Region_description = (tmp1 >> 27) & 0x3;
6395 tep->reserved1 = (tmp1 >> 26) & 0x1;
6396 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6397 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6398 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6399 tep->Args_stored = (tmp1 >> 15) & 0x1;
6400 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6401 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6402 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6403 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6404 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6405 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6406 tep->cxx_info = (tmp1 >> 8) & 0x1;
6407 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6408 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6409 tep->reserved2 = (tmp1 >> 5) & 0x1;
6410 tep->Save_SP = (tmp1 >> 4) & 0x1;
6411 tep->Save_RP = (tmp1 >> 3) & 0x1;
6412 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6413 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6414 tep->Cleanup_defined = tmp1 & 0x1;
6415
6416 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6417 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6418 tep->Large_frame = (tmp2 >> 29) & 0x1;
6419 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6420 tep->reserved4 = (tmp2 >> 27) & 0x1;
6421 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6422 }
6423 free (table);
6424
6425 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6426 for (relsec = section_headers;
6427 relsec < section_headers + elf_header.e_shnum;
6428 ++relsec)
6429 {
6430 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6431 || relsec->sh_info >= elf_header.e_shnum
6432 || section_headers + relsec->sh_info != sec)
57346661
AM		 6433 continue;
6434
6435 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6436 & rela, & nrelas))
6437 return 0;
6438
6439 for (rp = rela; rp < rela + nrelas; ++rp)
6440 {
aca88567
NC		 6441 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6442 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6443
6444 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6445 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6446 {
6447 warn (_("Skipping unexpected relocation type %s\n"), relname);
6448 continue;
6449 }
6450
6451 i = rp->r_offset / unw_ent_size;
6452
89fac5e3 6453 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6454 {
6455 case 0:
6456 aux->table[i].start.section = sym->st_shndx;
1e456d54 6457 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6458 break;
6459 case 1:
6460 aux->table[i].end.section = sym->st_shndx;
1e456d54 6461 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6462 break;
6463 default:
6464 break;
6465 }
6466 }
6467
6468 free (rela);
6469 }
6470
1c0751b2 6471 aux->table_len = nentries;
57346661
AM		 6472
6473 return 1;
6474}
6475
1b31d05e 6476static void
2cf0635d 6477hppa_process_unwind (FILE * file)
57346661 6478{
57346661 6479 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6480 Elf_Internal_Shdr * unwsec = NULL;
6481 Elf_Internal_Shdr * strsec;
6482 Elf_Internal_Shdr * sec;
18bd398b 6483 unsigned long i;
57346661 6484
c256ffe7 6485 if (string_table == NULL)
1b31d05e
NC		 6486 return;
6487
6488 memset (& aux, 0, sizeof (aux));
57346661
AM		 6489
6490 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6491 {
c256ffe7 6492 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6493 && sec->sh_link < elf_header.e_shnum)
57346661 6494 {
ba5cdace 6495 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6496
4fbb74a6 6497 strsec = section_headers + sec->sh_link;
59245841 6498 assert (aux.strtab == NULL);
3f5e193b
NC		 6499 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6500 1, strsec->sh_size,
6501 _("string table"));
c256ffe7 6502 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6503 }
18bd398b 6504 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6505 unwsec = sec;
6506 }
6507
6508 if (!unwsec)
6509 printf (_("\nThere are no unwind sections in this file.\n"));
6510
6511 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6512 {
18bd398b 6513 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6514 {
57346661
AM		 6515 printf (_("\nUnwind section "));
6516 printf (_("'%s'"), SECTION_NAME (sec));
6517
6518 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6519 (unsigned long) sec->sh_offset,
89fac5e3 6520 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6521
6522 slurp_hppa_unwind_table (file, &aux, sec);
6523 if (aux.table_len > 0)
6524 dump_hppa_unwind (&aux);
6525
6526 if (aux.table)
6527 free ((char *) aux.table);
6528 aux.table = NULL;
6529 }
6530 }
6531
6532 if (aux.symtab)
6533 free (aux.symtab);
6534 if (aux.strtab)
6535 free ((char *) aux.strtab);
57346661
AM		 6536}
6537
0b6ae522
DJ		 6538struct arm_section
6539{
a734115a
NC		 6540 unsigned char * data; /* The unwind data. */
6541 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6542 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6543 unsigned long nrelas; /* The number of relocations. */
6544 unsigned int rel_type; /* REL or RELA ? */
6545 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6546};
6547
6548struct arm_unw_aux_info
6549{
a734115a
NC		 6550 FILE * file; /* The file containing the unwind sections. */
6551 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6552 unsigned long nsyms; /* Number of symbols. */
6553 char * strtab; /* The file's string table. */
6554 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6555};
6556
6557static const char *
6558arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6559 bfd_vma fn, struct absaddr addr)
6560{
6561 const char *procname;
6562 bfd_vma sym_offset;
6563
6564 if (addr.section == SHN_UNDEF)
6565 addr.offset = fn;
6566
6567 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6568 aux->strtab_size, addr, &procname,
6569 &sym_offset);
6570
6571 print_vma (fn, PREFIX_HEX);
6572
6573 if (procname)
6574 {
6575 fputs (" <", stdout);
6576 fputs (procname, stdout);
6577
6578 if (sym_offset)
6579 printf ("+0x%lx", (unsigned long) sym_offset);
6580 fputc ('>', stdout);
6581 }
6582
6583 return procname;
6584}
6585
6586static void
6587arm_free_section (struct arm_section *arm_sec)
6588{
6589 if (arm_sec->data != NULL)
6590 free (arm_sec->data);
6591
6592 if (arm_sec->rela != NULL)
6593 free (arm_sec->rela);
6594}
6595
a734115a
NC		 6596/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6597 cached section and install SEC instead.
6598 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6599 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6600 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6601 relocation's offset in ADDR.
1b31d05e
NC		 6602 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6603 into the string table of the symbol associated with the reloc. If no
6604 reloc was applied store -1 there.
6605 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6606
6607static bfd_boolean
1b31d05e
NC		 6608get_unwind_section_word (struct arm_unw_aux_info * aux,
6609 struct arm_section * arm_sec,
6610 Elf_Internal_Shdr * sec,
6611 bfd_vma word_offset,
6612 unsigned int * wordp,
6613 struct absaddr * addr,
6614 bfd_vma * sym_name)
0b6ae522
DJ		 6615{
6616 Elf_Internal_Rela *rp;
6617 Elf_Internal_Sym *sym;
6618 const char * relname;
6619 unsigned int word;
6620 bfd_boolean wrapped;
6621
6622 addr->section = SHN_UNDEF;
6623 addr->offset = 0;
6624
1b31d05e
NC		 6625 if (sym_name != NULL)
6626 *sym_name = (bfd_vma) -1;
6627
a734115a 6628 /* If necessary, update the section cache. */
0b6ae522
DJ		 6629 if (sec != arm_sec->sec)
6630 {
6631 Elf_Internal_Shdr *relsec;
6632
6633 arm_free_section (arm_sec);
6634
6635 arm_sec->sec = sec;
6636 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6637 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6638 arm_sec->rela = NULL;
6639 arm_sec->nrelas = 0;
6640
6641 for (relsec = section_headers;
6642 relsec < section_headers + elf_header.e_shnum;
6643 ++relsec)
6644 {
6645 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 6646 || section_headers + relsec->sh_info != sec
6647 /* PR 15745: Check the section type as well. */
6648 || (relsec->sh_type != SHT_REL
6649 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 6650 continue;
6651
a734115a 6652 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6653 if (relsec->sh_type == SHT_REL)
6654 {
6655 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6656 relsec->sh_size,
6657 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6658 return FALSE;
0b6ae522 6659 }
1ae40aa4 6660 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 6661 {
6662 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6663 relsec->sh_size,
6664 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6665 return FALSE;
0b6ae522 6666 }
1ae40aa4 6667 break;
0b6ae522
DJ		 6668 }
6669
6670 arm_sec->next_rela = arm_sec->rela;
6671 }
6672
a734115a 6673 /* If there is no unwind data we can do nothing. */
0b6ae522 6674 if (arm_sec->data == NULL)
a734115a 6675 return FALSE;
0b6ae522 6676
a734115a 6677 /* Get the word at the required offset. */
0b6ae522
DJ		 6678 word = byte_get (arm_sec->data + word_offset, 4);
6679
a734115a 6680 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6681 wrapped = FALSE;
6682 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6683 {
6684 bfd_vma prelval, offset;
6685
6686 if (rp->r_offset > word_offset && !wrapped)
6687 {
6688 rp = arm_sec->rela;
6689 wrapped = TRUE;
6690 }
6691 if (rp->r_offset > word_offset)
6692 break;
6693
6694 if (rp->r_offset & 3)
6695 {
6696 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6697 (unsigned long) rp->r_offset);
6698 continue;
6699 }
6700
6701 if (rp->r_offset < word_offset)
6702 continue;
6703
0b6ae522
DJ		 6704 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6705
6706 if (arm_sec->rel_type == SHT_REL)
6707 {
6708 offset = word & 0x7fffffff;
6709 if (offset & 0x40000000)
6710 offset |= ~ (bfd_vma) 0x7fffffff;
6711 }
a734115a 6712 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6713 offset = rp->r_addend;
a734115a
NC		 6714 else
6715 abort ();
0b6ae522
DJ		 6716
6717 offset += sym->st_value;
6718 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6719
a734115a
NC		 6720 /* Check that we are processing the expected reloc type. */
6721 if (elf_header.e_machine == EM_ARM)
6722 {
6723 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6724
6725 if (streq (relname, "R_ARM_NONE"))
6726 continue;
0b4362b0 6727
a734115a
NC		 6728 if (! streq (relname, "R_ARM_PREL31"))
6729 {
6730 warn (_("Skipping unexpected relocation type %s\n"), relname);
6731 continue;
6732 }
6733 }
6734 else if (elf_header.e_machine == EM_TI_C6000)
6735 {
6736 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
0b4362b0 6737
a734115a
NC		 6738 if (streq (relname, "R_C6000_NONE"))
6739 continue;
6740
6741 if (! streq (relname, "R_C6000_PREL31"))
6742 {
6743 warn (_("Skipping unexpected relocation type %s\n"), relname);
6744 continue;
6745 }
6746
6747 prelval >>= 1;
6748 }
6749 else
6750 /* This function currently only supports ARM and TI unwinders. */
6751 abort ();
fa197c1c 6752
0b6ae522
DJ		 6753 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6754 addr->section = sym->st_shndx;
6755 addr->offset = offset;
1b31d05e
NC		 6756 if (sym_name)
6757 * sym_name = sym->st_name;
0b6ae522
DJ		 6758 break;
6759 }
6760
6761 *wordp = word;
6762 arm_sec->next_rela = rp;
6763
a734115a 6764 return TRUE;
0b6ae522
DJ		 6765}
6766
a734115a
NC		 6767static const char *tic6x_unwind_regnames[16] =
6768{
0b4362b0
RM		 6769 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6770 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 6771 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6772};
fa197c1c 6773
0b6ae522 6774static void
fa197c1c 6775decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6776{
fa197c1c
PB		 6777 int i;
6778
6779 for (i = 12; mask; mask >>= 1, i--)
6780 {
6781 if (mask & 1)
6782 {
6783 fputs (tic6x_unwind_regnames[i], stdout);
6784 if (mask > 1)
6785 fputs (", ", stdout);
6786 }
6787 }
6788}
0b6ae522
DJ		 6789
6790#define ADVANCE \
6791 if (remaining == 0 && more_words) \
6792 { \
6793 data_offset += 4; \
1b31d05e
NC		 6794 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6795 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 6796 return; \
6797 remaining = 4; \
6798 more_words--; \
6799 } \
6800
6801#define GET_OP(OP) \
6802 ADVANCE; \
6803 if (remaining) \
6804 { \
6805 remaining--; \
6806 (OP) = word >> 24; \
6807 word <<= 8; \
6808 } \
6809 else \
6810 { \
2b692964 6811 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6812 return; \
6813 } \
cc5914eb 6814 printf ("0x%02x ", OP)
0b6ae522 6815
fa197c1c
PB		 6816static void
6817decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6818 unsigned int word, unsigned int remaining,
6819 unsigned int more_words,
6820 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6821 struct arm_section *data_arm_sec)
6822{
6823 struct absaddr addr;
0b6ae522
DJ		 6824
6825 /* Decode the unwinding instructions. */
6826 while (1)
6827 {
6828 unsigned int op, op2;
6829
6830 ADVANCE;
6831 if (remaining == 0)
6832 break;
6833 remaining--;
6834 op = word >> 24;
6835 word <<= 8;
6836
cc5914eb 6837 printf (" 0x%02x ", op);
0b6ae522
DJ		 6838
6839 if ((op & 0xc0) == 0x00)
6840 {
6841 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6842
cc5914eb 6843 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6844 }
6845 else if ((op & 0xc0) == 0x40)
6846 {
6847 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6848
cc5914eb 6849 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6850 }
6851 else if ((op & 0xf0) == 0x80)
6852 {
6853 GET_OP (op2);
6854 if (op == 0x80 && op2 == 0)
6855 printf (_("Refuse to unwind"));
6856 else
6857 {
6858 unsigned int mask = ((op & 0x0f) << 8) | op2;
6859 int first = 1;
6860 int i;
2b692964 6861
0b6ae522
DJ		 6862 printf ("pop {");
6863 for (i = 0; i < 12; i++)
6864 if (mask & (1 << i))
6865 {
6866 if (first)
6867 first = 0;
6868 else
6869 printf (", ");
6870 printf ("r%d", 4 + i);
6871 }
6872 printf ("}");
6873 }
6874 }
6875 else if ((op & 0xf0) == 0x90)
6876 {
6877 if (op == 0x9d || op == 0x9f)
6878 printf (_(" [Reserved]"));
6879 else
cc5914eb 6880 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6881 }
6882 else if ((op & 0xf0) == 0xa0)
6883 {
6884 int end = 4 + (op & 0x07);
6885 int first = 1;
6886 int i;
61865e30 6887
0b6ae522
DJ		 6888 printf (" pop {");
6889 for (i = 4; i <= end; i++)
6890 {
6891 if (first)
6892 first = 0;
6893 else
6894 printf (", ");
6895 printf ("r%d", i);
6896 }
6897 if (op & 0x08)
6898 {
1b31d05e 6899 if (!first)
0b6ae522
DJ		 6900 printf (", ");
6901 printf ("r14");
6902 }
6903 printf ("}");
6904 }
6905 else if (op == 0xb0)
6906 printf (_(" finish"));
6907 else if (op == 0xb1)
6908 {
6909 GET_OP (op2);
6910 if (op2 == 0 || (op2 & 0xf0) != 0)
6911 printf (_("[Spare]"));
6912 else
6913 {
6914 unsigned int mask = op2 & 0x0f;
6915 int first = 1;
6916 int i;
61865e30 6917
0b6ae522
DJ		 6918 printf ("pop {");
6919 for (i = 0; i < 12; i++)
6920 if (mask & (1 << i))
6921 {
6922 if (first)
6923 first = 0;
6924 else
6925 printf (", ");
6926 printf ("r%d", i);
6927 }
6928 printf ("}");
6929 }
6930 }
6931 else if (op == 0xb2)
6932 {
b115cf96 6933 unsigned char buf[9];
0b6ae522
DJ		 6934 unsigned int i, len;
6935 unsigned long offset;
61865e30 6936
b115cf96 6937 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6938 {
6939 GET_OP (buf[i]);
6940 if ((buf[i] & 0x80) == 0)
6941 break;
6942 }
6943 assert (i < sizeof (buf));
f6f0e17b 6944 offset = read_uleb128 (buf, &len, buf + i + 1);
0b6ae522
DJ		 6945 assert (len == i + 1);
6946 offset = offset * 4 + 0x204;
cc5914eb 6947 printf ("vsp = vsp + %ld", offset);
0b6ae522 6948 }
61865e30 6949 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6950 {
61865e30
NC		 6951 unsigned int first, last;
6952
6953 GET_OP (op2);
6954 first = op2 >> 4;
6955 last = op2 & 0x0f;
6956 if (op == 0xc8)
6957 first = first + 16;
6958 printf ("pop {D%d", first);
6959 if (last)
6960 printf ("-D%d", first + last);
6961 printf ("}");
6962 }
6963 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6964 {
6965 unsigned int count = op & 0x07;
6966
6967 printf ("pop {D8");
6968 if (count)
6969 printf ("-D%d", 8 + count);
6970 printf ("}");
6971 }
6972 else if (op >= 0xc0 && op <= 0xc5)
6973 {
6974 unsigned int count = op & 0x07;
6975
6976 printf (" pop {wR10");
6977 if (count)
6978 printf ("-wR%d", 10 + count);
6979 printf ("}");
6980 }
6981 else if (op == 0xc6)
6982 {
6983 unsigned int first, last;
6984
6985 GET_OP (op2);
6986 first = op2 >> 4;
6987 last = op2 & 0x0f;
6988 printf ("pop {wR%d", first);
6989 if (last)
6990 printf ("-wR%d", first + last);
6991 printf ("}");
6992 }
6993 else if (op == 0xc7)
6994 {
6995 GET_OP (op2);
6996 if (op2 == 0 || (op2 & 0xf0) != 0)
6997 printf (_("[Spare]"));
0b6ae522
DJ		 6998 else
6999 {
61865e30
NC		 7000 unsigned int mask = op2 & 0x0f;
7001 int first = 1;
7002 int i;
7003
7004 printf ("pop {");
7005 for (i = 0; i < 4; i++)
7006 if (mask & (1 << i))
7007 {
7008 if (first)
7009 first = 0;
7010 else
7011 printf (", ");
7012 printf ("wCGR%d", i);
7013 }
7014 printf ("}");
0b6ae522
DJ		 7015 }
7016 }
61865e30
NC		 7017 else
7018 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7019 printf ("\n");
7020 }
fa197c1c
PB		 7021}
7022
7023static void
7024decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7025 unsigned int word, unsigned int remaining,
7026 unsigned int more_words,
7027 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7028 struct arm_section *data_arm_sec)
7029{
7030 struct absaddr addr;
7031
7032 /* Decode the unwinding instructions. */
7033 while (1)
7034 {
7035 unsigned int op, op2;
7036
7037 ADVANCE;
7038 if (remaining == 0)
7039 break;
7040 remaining--;
7041 op = word >> 24;
7042 word <<= 8;
7043
9cf03b7e 7044 printf (" 0x%02x ", op);
fa197c1c
PB		 7045
7046 if ((op & 0xc0) == 0x00)
7047 {
7048 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7049 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7050 }
7051 else if ((op & 0xc0) == 0x80)
7052 {
7053 GET_OP (op2);
7054 if (op == 0x80 && op2 == 0)
7055 printf (_("Refuse to unwind"));
7056 else
7057 {
7058 unsigned int mask = ((op & 0x1f) << 8) | op2;
7059 if (op & 0x20)
7060 printf ("pop compact {");
7061 else
7062 printf ("pop {");
7063
7064 decode_tic6x_unwind_regmask (mask);
7065 printf("}");
7066 }
7067 }
7068 else if ((op & 0xf0) == 0xc0)
7069 {
7070 unsigned int reg;
7071 unsigned int nregs;
7072 unsigned int i;
7073 const char *name;
a734115a
NC		 7074 struct
7075 {
fa197c1c
PB		 7076 unsigned int offset;
7077 unsigned int reg;
7078 } regpos[16];
7079
7080 /* Scan entire instruction first so that GET_OP output is not
7081 interleaved with disassembly. */
7082 nregs = 0;
7083 for (i = 0; nregs < (op & 0xf); i++)
7084 {
7085 GET_OP (op2);
7086 reg = op2 >> 4;
7087 if (reg != 0xf)
7088 {
7089 regpos[nregs].offset = i * 2;
7090 regpos[nregs].reg = reg;
7091 nregs++;
7092 }
7093
7094 reg = op2 & 0xf;
7095 if (reg != 0xf)
7096 {
7097 regpos[nregs].offset = i * 2 + 1;
7098 regpos[nregs].reg = reg;
7099 nregs++;
7100 }
7101 }
7102
7103 printf (_("pop frame {"));
7104 reg = nregs - 1;
7105 for (i = i * 2; i > 0; i--)
7106 {
7107 if (regpos[reg].offset == i - 1)
7108 {
7109 name = tic6x_unwind_regnames[regpos[reg].reg];
7110 if (reg > 0)
7111 reg--;
7112 }
7113 else
7114 name = _("[pad]");
7115
7116 fputs (name, stdout);
7117 if (i > 1)
7118 printf (", ");
7119 }
7120
7121 printf ("}");
7122 }
7123 else if (op == 0xd0)
7124 printf (" MOV FP, SP");
7125 else if (op == 0xd1)
7126 printf (" __c6xabi_pop_rts");
7127 else if (op == 0xd2)
7128 {
7129 unsigned char buf[9];
7130 unsigned int i, len;
7131 unsigned long offset;
a734115a 7132
fa197c1c
PB		 7133 for (i = 0; i < sizeof (buf); i++)
7134 {
7135 GET_OP (buf[i]);
7136 if ((buf[i] & 0x80) == 0)
7137 break;
7138 }
7139 assert (i < sizeof (buf));
f6f0e17b 7140 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7141 assert (len == i + 1);
7142 offset = offset * 8 + 0x408;
7143 printf (_("sp = sp + %ld"), offset);
7144 }
7145 else if ((op & 0xf0) == 0xe0)
7146 {
7147 if ((op & 0x0f) == 7)
7148 printf (" RETURN");
7149 else
7150 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7151 }
7152 else
7153 {
7154 printf (_(" [unsupported opcode]"));
7155 }
7156 putchar ('\n');
7157 }
7158}
7159
7160static bfd_vma
a734115a 7161arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7162{
7163 bfd_vma offset;
7164
7165 offset = word & 0x7fffffff;
7166 if (offset & 0x40000000)
7167 offset |= ~ (bfd_vma) 0x7fffffff;
7168
7169 if (elf_header.e_machine == EM_TI_C6000)
7170 offset <<= 1;
7171
7172 return offset + where;
7173}
7174
7175static void
1b31d05e
NC		 7176decode_arm_unwind (struct arm_unw_aux_info * aux,
7177 unsigned int word,
7178 unsigned int remaining,
7179 bfd_vma data_offset,
7180 Elf_Internal_Shdr * data_sec,
7181 struct arm_section * data_arm_sec)
fa197c1c
PB		 7182{
7183 int per_index;
7184 unsigned int more_words = 0;
37e14bc3 7185 struct absaddr addr;
1b31d05e 7186 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7187
7188 if (remaining == 0)
7189 {
1b31d05e
NC		 7190 /* Fetch the first word.
7191 Note - when decoding an object file the address extracted
7192 here will always be 0. So we also pass in the sym_name
7193 parameter so that we can find the symbol associated with
7194 the personality routine. */
7195 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7196 & word, & addr, & sym_name))
fa197c1c 7197 return;
1b31d05e 7198
fa197c1c
PB		 7199 remaining = 4;
7200 }
7201
7202 if ((word & 0x80000000) == 0)
7203 {
7204 /* Expand prel31 for personality routine. */
7205 bfd_vma fn;
7206 const char *procname;
7207
a734115a 7208 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7209 printf (_(" Personality routine: "));
1b31d05e
NC		 7210 if (fn == 0
7211 && addr.section == SHN_UNDEF && addr.offset == 0
7212 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7213 {
7214 procname = aux->strtab + sym_name;
7215 print_vma (fn, PREFIX_HEX);
7216 if (procname)
7217 {
7218 fputs (" <", stdout);
7219 fputs (procname, stdout);
7220 fputc ('>', stdout);
7221 }
7222 }
7223 else
7224 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7225 fputc ('\n', stdout);
7226
7227 /* The GCC personality routines use the standard compact
7228 encoding, starting with one byte giving the number of
7229 words. */
7230 if (procname != NULL
7231 && (const_strneq (procname, "__gcc_personality_v0")
7232 || const_strneq (procname, "__gxx_personality_v0")
7233 || const_strneq (procname, "__gcj_personality_v0")
7234 || const_strneq (procname, "__gnu_objc_personality_v0")))
7235 {
7236 remaining = 0;
7237 more_words = 1;
7238 ADVANCE;
7239 if (!remaining)
7240 {
7241 printf (_(" [Truncated data]\n"));
7242 return;
7243 }
7244 more_words = word >> 24;
7245 word <<= 8;
7246 remaining--;
7247 per_index = -1;
7248 }
7249 else
7250 return;
7251 }
7252 else
7253 {
1b31d05e 7254 /* ARM EHABI Section 6.3:
0b4362b0 7255
1b31d05e 7256 An exception-handling table entry for the compact model looks like:
0b4362b0 7257
1b31d05e
NC		 7258 31 30-28 27-24 23-0
7259 -- ----- ----- ----
7260 1 0 index Data for personalityRoutine[index] */
7261
7262 if (elf_header.e_machine == EM_ARM
7263 && (word & 0x70000000))
83c257ca 7264 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7265
fa197c1c 7266 per_index = (word >> 24) & 0x7f;
1b31d05e 7267 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7268 if (per_index == 0)
7269 {
7270 more_words = 0;
7271 word <<= 8;
7272 remaining--;
7273 }
7274 else if (per_index < 3)
7275 {
7276 more_words = (word >> 16) & 0xff;
7277 word <<= 16;
7278 remaining -= 2;
7279 }
7280 }
7281
7282 switch (elf_header.e_machine)
7283 {
7284 case EM_ARM:
7285 if (per_index < 3)
7286 {
7287 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7288 data_offset, data_sec, data_arm_sec);
7289 }
7290 else
1b31d05e
NC		 7291 {
7292 warn (_("Unknown ARM compact model index encountered\n"));
7293 printf (_(" [reserved]\n"));
7294 }
fa197c1c
PB		 7295 break;
7296
7297 case EM_TI_C6000:
7298 if (per_index < 3)
7299 {
7300 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7301 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7302 }
7303 else if (per_index < 5)
7304 {
7305 if (((word >> 17) & 0x7f) == 0x7f)
7306 printf (_(" Restore stack from frame pointer\n"));
7307 else
7308 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7309 printf (_(" Registers restored: "));
7310 if (per_index == 4)
7311 printf (" (compact) ");
7312 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7313 putchar ('\n');
7314 printf (_(" Return register: %s\n"),
7315 tic6x_unwind_regnames[word & 0xf]);
7316 }
7317 else
1b31d05e 7318 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7319 break;
7320
7321 default:
1b31d05e
NC		 7322 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7323 elf_header.e_machine);
fa197c1c 7324 }
0b6ae522
DJ		 7325
7326 /* Decode the descriptors. Not implemented. */
7327}
7328
7329static void
7330dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7331{
7332 struct arm_section exidx_arm_sec, extab_arm_sec;
7333 unsigned int i, exidx_len;
7334
7335 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7336 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7337 exidx_len = exidx_sec->sh_size / 8;
7338
7339 for (i = 0; i < exidx_len; i++)
7340 {
7341 unsigned int exidx_fn, exidx_entry;
7342 struct absaddr fn_addr, entry_addr;
7343 bfd_vma fn;
7344
7345 fputc ('\n', stdout);
7346
1b31d05e
NC		 7347 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7348 8 * i, & exidx_fn, & fn_addr, NULL)
7349 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7350 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7351 {
1b31d05e
NC		 7352 arm_free_section (& exidx_arm_sec);
7353 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7354 return;
7355 }
7356
83c257ca
NC		 7357 /* ARM EHABI, Section 5:
7358 An index table entry consists of 2 words.
7359 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7360 if (exidx_fn & 0x80000000)
7361 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7362
a734115a 7363 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7364
a734115a 7365 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7366 fputs (": ", stdout);
7367
7368 if (exidx_entry == 1)
7369 {
7370 print_vma (exidx_entry, PREFIX_HEX);
7371 fputs (" [cantunwind]\n", stdout);
7372 }
7373 else if (exidx_entry & 0x80000000)
7374 {
7375 print_vma (exidx_entry, PREFIX_HEX);
7376 fputc ('\n', stdout);
7377 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7378 }
7379 else
7380 {
8f73510c 7381 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7382 Elf_Internal_Shdr *table_sec;
7383
7384 fputs ("@", stdout);
a734115a 7385 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7386 print_vma (table, PREFIX_HEX);
7387 printf ("\n");
7388
7389 /* Locate the matching .ARM.extab. */
7390 if (entry_addr.section != SHN_UNDEF
7391 && entry_addr.section < elf_header.e_shnum)
7392 {
7393 table_sec = section_headers + entry_addr.section;
7394 table_offset = entry_addr.offset;
7395 }
7396 else
7397 {
7398 table_sec = find_section_by_address (table);
7399 if (table_sec != NULL)
7400 table_offset = table - table_sec->sh_addr;
7401 }
7402 if (table_sec == NULL)
7403 {
7404 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7405 (unsigned long) table);
7406 continue;
7407 }
7408 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7409 &extab_arm_sec);
7410 }
7411 }
7412
7413 printf ("\n");
7414
7415 arm_free_section (&exidx_arm_sec);
7416 arm_free_section (&extab_arm_sec);
7417}
7418
fa197c1c 7419/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7420
7421static void
0b6ae522
DJ		 7422arm_process_unwind (FILE *file)
7423{
7424 struct arm_unw_aux_info aux;
7425 Elf_Internal_Shdr *unwsec = NULL;
7426 Elf_Internal_Shdr *strsec;
7427 Elf_Internal_Shdr *sec;
7428 unsigned long i;
fa197c1c 7429 unsigned int sec_type;
0b6ae522 7430
fa197c1c
PB		 7431 switch (elf_header.e_machine)
7432 {
7433 case EM_ARM:
7434 sec_type = SHT_ARM_EXIDX;
7435 break;
7436
7437 case EM_TI_C6000:
7438 sec_type = SHT_C6000_UNWIND;
7439 break;
7440
0b4362b0 7441 default:
1b31d05e
NC		 7442 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7443 elf_header.e_machine);
7444 return;
fa197c1c
PB		 7445 }
7446
0b6ae522 7447 if (string_table == NULL)
1b31d05e
NC		 7448 return;
7449
7450 memset (& aux, 0, sizeof (aux));
7451 aux.file = file;
0b6ae522
DJ		 7452
7453 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7454 {
7455 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7456 {
ba5cdace 7457 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7458
7459 strsec = section_headers + sec->sh_link;
59245841 7460 assert (aux.strtab == NULL);
0b6ae522
DJ		 7461 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7462 1, strsec->sh_size, _("string table"));
7463 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7464 }
fa197c1c 7465 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7466 unwsec = sec;
7467 }
7468
1b31d05e 7469 if (unwsec == NULL)
0b6ae522 7470 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7471 else
7472 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7473 {
7474 if (sec->sh_type == sec_type)
7475 {
7476 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7477 SECTION_NAME (sec),
7478 (unsigned long) sec->sh_offset,
7479 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7480
1b31d05e
NC		 7481 dump_arm_unwind (&aux, sec);
7482 }
7483 }
0b6ae522
DJ		 7484
7485 if (aux.symtab)
7486 free (aux.symtab);
7487 if (aux.strtab)
7488 free ((char *) aux.strtab);
0b6ae522
DJ		 7489}
7490
1b31d05e 7491static void
2cf0635d 7492process_unwind (FILE * file)
57346661 7493{
2cf0635d
NC		 7494 struct unwind_handler
7495 {
57346661 7496 int machtype;
1b31d05e 7497 void (* handler)(FILE *);
2cf0635d
NC		 7498 } handlers[] =
7499 {
0b6ae522 7500 { EM_ARM, arm_process_unwind },
57346661
AM		 7501 { EM_IA_64, ia64_process_unwind },
7502 { EM_PARISC, hppa_process_unwind },
fa197c1c 7503 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7504 { 0, 0 }
7505 };
7506 int i;
7507
7508 if (!do_unwind)
1b31d05e 7509 return;
57346661
AM		 7510
7511 for (i = 0; handlers[i].handler != NULL; i++)
7512 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 7513 {
7514 handlers[i].handler (file);
7515 return;
7516 }
57346661 7517
1b31d05e
NC		 7518 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7519 get_machine_name (elf_header.e_machine));
57346661
AM		 7520}
7521
252b5132 7522static void
2cf0635d 7523dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7524{
7525 switch (entry->d_tag)
7526 {
7527 case DT_MIPS_FLAGS:
7528 if (entry->d_un.d_val == 0)
4b68bca3 7529 printf (_("NONE"));
252b5132
RH		 7530 else
7531 {
7532 static const char * opts[] =
7533 {
7534 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7535 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7536 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7537 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7538 "RLD_ORDER_SAFE"
7539 };
7540 unsigned int cnt;
7541 int first = 1;
2b692964 7542
60bca95a 7543 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7544 if (entry->d_un.d_val & (1 << cnt))
7545 {
7546 printf ("%s%s", first ? "" : " ", opts[cnt]);
7547 first = 0;
7548 }
252b5132
RH		 7549 }
7550 break;
103f02d3 7551
252b5132 7552 case DT_MIPS_IVERSION:
d79b3d50 7553 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7554 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7555 else
4b68bca3 7556 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7557 break;
103f02d3 7558
252b5132
RH		 7559 case DT_MIPS_TIME_STAMP:
7560 {
7561 char timebuf[20];
2cf0635d 7562 struct tm * tmp;
50da7a9c 7563
91d6fa6a
NC		 7564 time_t atime = entry->d_un.d_val;
7565 tmp = gmtime (&atime);
e9e44622
JJ		 7566 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7567 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7568 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7569 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7570 }
7571 break;
103f02d3 7572
252b5132
RH		 7573 case DT_MIPS_RLD_VERSION:
7574 case DT_MIPS_LOCAL_GOTNO:
7575 case DT_MIPS_CONFLICTNO:
7576 case DT_MIPS_LIBLISTNO:
7577 case DT_MIPS_SYMTABNO:
7578 case DT_MIPS_UNREFEXTNO:
7579 case DT_MIPS_HIPAGENO:
7580 case DT_MIPS_DELTA_CLASS_NO:
7581 case DT_MIPS_DELTA_INSTANCE_NO:
7582 case DT_MIPS_DELTA_RELOC_NO:
7583 case DT_MIPS_DELTA_SYM_NO:
7584 case DT_MIPS_DELTA_CLASSSYM_NO:
7585 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7586 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7587 break;
103f02d3
UD		 7588
7589 default:
4b68bca3 7590 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7591 }
4b68bca3 7592 putchar ('\n');
103f02d3
UD		 7593}
7594
103f02d3 7595static void
2cf0635d 7596dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7597{
7598 switch (entry->d_tag)
7599 {
7600 case DT_HP_DLD_FLAGS:
7601 {
7602 static struct
7603 {
7604 long int bit;
2cf0635d 7605 const char * str;
5e220199
NC		 7606 }
7607 flags[] =
7608 {
7609 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7610 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7611 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7612 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7613 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7614 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7615 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7616 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7617 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7618 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7619 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7620 { DT_HP_GST, "HP_GST" },
7621 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7622 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7623 { DT_HP_NODELETE, "HP_NODELETE" },
7624 { DT_HP_GROUP, "HP_GROUP" },
7625 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7626 };
103f02d3 7627 int first = 1;
5e220199 7628 size_t cnt;
f7a99963 7629 bfd_vma val = entry->d_un.d_val;
103f02d3 7630
60bca95a 7631 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7632 if (val & flags[cnt].bit)
30800947
NC		 7633 {
7634 if (! first)
7635 putchar (' ');
7636 fputs (flags[cnt].str, stdout);
7637 first = 0;
7638 val ^= flags[cnt].bit;
7639 }
76da6bbe 7640
103f02d3 7641 if (val != 0 || first)
f7a99963
NC		 7642 {
7643 if (! first)
7644 putchar (' ');
7645 print_vma (val, HEX);
7646 }
103f02d3
UD		 7647 }
7648 break;
76da6bbe 7649
252b5132 7650 default:
f7a99963
NC		 7651 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7652 break;
252b5132 7653 }
35b1837e 7654 putchar ('\n');
252b5132
RH		 7655}
7656
28f997cf
TG		 7657#ifdef BFD64
7658
7659/* VMS vs Unix time offset and factor. */
7660
7661#define VMS_EPOCH_OFFSET 35067168000000000LL
7662#define VMS_GRANULARITY_FACTOR 10000000
7663
7664/* Display a VMS time in a human readable format. */
7665
7666static void
7667print_vms_time (bfd_int64_t vmstime)
7668{
7669 struct tm *tm;
7670 time_t unxtime;
7671
7672 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7673 tm = gmtime (&unxtime);
7674 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7675 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7676 tm->tm_hour, tm->tm_min, tm->tm_sec);
7677}
7678#endif /* BFD64 */
7679
ecc51f48 7680static void
2cf0635d 7681dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7682{
7683 switch (entry->d_tag)
7684 {
0de14b54 7685 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7686 /* First 3 slots reserved. */
ecc51f48
NC		 7687 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7688 printf (" -- ");
7689 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7690 break;
7691
28f997cf
TG		 7692 case DT_IA_64_VMS_LINKTIME:
7693#ifdef BFD64
7694 print_vms_time (entry->d_un.d_val);
7695#endif
7696 break;
7697
7698 case DT_IA_64_VMS_LNKFLAGS:
7699 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7700 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7701 printf (" CALL_DEBUG");
7702 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7703 printf (" NOP0BUFS");
7704 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7705 printf (" P0IMAGE");
7706 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7707 printf (" MKTHREADS");
7708 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7709 printf (" UPCALLS");
7710 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7711 printf (" IMGSTA");
7712 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7713 printf (" INITIALIZE");
7714 if (entry->d_un.d_val & VMS_LF_MAIN)
7715 printf (" MAIN");
7716 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7717 printf (" EXE_INIT");
7718 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7719 printf (" TBK_IN_IMG");
7720 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7721 printf (" DBG_IN_IMG");
7722 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7723 printf (" TBK_IN_DSF");
7724 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7725 printf (" DBG_IN_DSF");
7726 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7727 printf (" SIGNATURES");
7728 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7729 printf (" REL_SEG_OFF");
7730 break;
7731
bdf4d63a
JJ		 7732 default:
7733 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7734 break;
ecc51f48 7735 }
bdf4d63a 7736 putchar ('\n');
ecc51f48
NC		 7737}
7738
252b5132 7739static int
2cf0635d 7740get_32bit_dynamic_section (FILE * file)
252b5132 7741{
2cf0635d
NC		 7742 Elf32_External_Dyn * edyn;
7743 Elf32_External_Dyn * ext;
7744 Elf_Internal_Dyn * entry;
103f02d3 7745
3f5e193b
NC		 7746 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7747 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7748 if (!edyn)
7749 return 0;
103f02d3 7750
ba2685cc
AM		 7751/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7752 might not have the luxury of section headers. Look for the DT_NULL
7753 terminator to determine the number of entries. */
7754 for (ext = edyn, dynamic_nent = 0;
7755 (char *) ext < (char *) edyn + dynamic_size;
7756 ext++)
7757 {
7758 dynamic_nent++;
7759 if (BYTE_GET (ext->d_tag) == DT_NULL)
7760 break;
7761 }
252b5132 7762
3f5e193b
NC		 7763 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7764 sizeof (* entry));
b2d38a17 7765 if (dynamic_section == NULL)
252b5132 7766 {
9ea033b2
NC		 7767 error (_("Out of memory\n"));
7768 free (edyn);
7769 return 0;
7770 }
252b5132 7771
fb514b26 7772 for (ext = edyn, entry = dynamic_section;
ba2685cc 7773 entry < dynamic_section + dynamic_nent;
fb514b26 7774 ext++, entry++)
9ea033b2 7775 {
fb514b26
AM		 7776 entry->d_tag = BYTE_GET (ext->d_tag);
7777 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7778 }
7779
9ea033b2
NC		 7780 free (edyn);
7781
7782 return 1;
7783}
7784
7785static int
2cf0635d 7786get_64bit_dynamic_section (FILE * file)
9ea033b2 7787{
2cf0635d
NC		 7788 Elf64_External_Dyn * edyn;
7789 Elf64_External_Dyn * ext;
7790 Elf_Internal_Dyn * entry;
103f02d3 7791
3f5e193b
NC		 7792 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7793 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7794 if (!edyn)
7795 return 0;
103f02d3 7796
ba2685cc
AM		 7797/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7798 might not have the luxury of section headers. Look for the DT_NULL
7799 terminator to determine the number of entries. */
7800 for (ext = edyn, dynamic_nent = 0;
7801 (char *) ext < (char *) edyn + dynamic_size;
7802 ext++)
7803 {
7804 dynamic_nent++;
66543521 7805 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7806 break;
7807 }
252b5132 7808
3f5e193b
NC		 7809 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7810 sizeof (* entry));
b2d38a17 7811 if (dynamic_section == NULL)
252b5132
RH		 7812 {
7813 error (_("Out of memory\n"));
7814 free (edyn);
7815 return 0;
7816 }
7817
fb514b26 7818 for (ext = edyn, entry = dynamic_section;
ba2685cc 7819 entry < dynamic_section + dynamic_nent;
fb514b26 7820 ext++, entry++)
252b5132 7821 {
66543521
AM		 7822 entry->d_tag = BYTE_GET (ext->d_tag);
7823 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7824 }
7825
7826 free (edyn);
7827
9ea033b2
NC		 7828 return 1;
7829}
7830
e9e44622
JJ		 7831static void
7832print_dynamic_flags (bfd_vma flags)
d1133906 7833{
e9e44622 7834 int first = 1;
13ae64f3 7835
d1133906
NC		 7836 while (flags)
7837 {
7838 bfd_vma flag;
7839
7840 flag = flags & - flags;
7841 flags &= ~ flag;
7842
e9e44622
JJ		 7843 if (first)
7844 first = 0;
7845 else
7846 putc (' ', stdout);
13ae64f3 7847
d1133906
NC		 7848 switch (flag)
7849 {
e9e44622
JJ		 7850 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7851 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7852 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7853 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7854 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7855 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7856 }
7857 }
e9e44622 7858 puts ("");
d1133906
NC		 7859}
7860
b2d38a17
NC		 7861/* Parse and display the contents of the dynamic section. */
7862
9ea033b2 7863static int
2cf0635d 7864process_dynamic_section (FILE * file)
9ea033b2 7865{
2cf0635d 7866 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7867
7868 if (dynamic_size == 0)
7869 {
7870 if (do_dynamic)
b2d38a17 7871 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7872
7873 return 1;
7874 }
7875
7876 if (is_32bit_elf)
7877 {
b2d38a17 7878 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7879 return 0;
7880 }
b2d38a17 7881 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7882 return 0;
7883
252b5132
RH		 7884 /* Find the appropriate symbol table. */
7885 if (dynamic_symbols == NULL)
7886 {
86dba8ee
AM		 7887 for (entry = dynamic_section;
7888 entry < dynamic_section + dynamic_nent;
7889 ++entry)
252b5132 7890 {
c8286bd1 7891 Elf_Internal_Shdr section;
252b5132
RH		 7892
7893 if (entry->d_tag != DT_SYMTAB)
7894 continue;
7895
7896 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7897
7898 /* Since we do not know how big the symbol table is,
7899 we default to reading in the entire file (!) and
7900 processing that. This is overkill, I know, but it
e3c8793a 7901 should work. */
d93f0186 7902 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7903
fb52b2f4
NC		 7904 if (archive_file_offset != 0)
7905 section.sh_size = archive_file_size - section.sh_offset;
7906 else
7907 {
7908 if (fseek (file, 0, SEEK_END))
591a748a 7909 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7910
7911 section.sh_size = ftell (file) - section.sh_offset;
7912 }
252b5132 7913
9ea033b2 7914 if (is_32bit_elf)
9ad5cbcf 7915 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7916 else
9ad5cbcf 7917 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7918
ba5cdace 7919 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7920 if (num_dynamic_syms < 1)
252b5132
RH		 7921 {
7922 error (_("Unable to determine the number of symbols to load\n"));
7923 continue;
7924 }
252b5132
RH		 7925 }
7926 }
7927
7928 /* Similarly find a string table. */
7929 if (dynamic_strings == NULL)
7930 {
86dba8ee
AM		 7931 for (entry = dynamic_section;
7932 entry < dynamic_section + dynamic_nent;
7933 ++entry)
252b5132
RH		 7934 {
7935 unsigned long offset;
b34976b6 7936 long str_tab_len;
252b5132
RH		 7937
7938 if (entry->d_tag != DT_STRTAB)
7939 continue;
7940
7941 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7942
7943 /* Since we do not know how big the string table is,
7944 we default to reading in the entire file (!) and
7945 processing that. This is overkill, I know, but it
e3c8793a 7946 should work. */
252b5132 7947
d93f0186 7948 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7949
7950 if (archive_file_offset != 0)
7951 str_tab_len = archive_file_size - offset;
7952 else
7953 {
7954 if (fseek (file, 0, SEEK_END))
7955 error (_("Unable to seek to end of file\n"));
7956 str_tab_len = ftell (file) - offset;
7957 }
252b5132
RH		 7958
7959 if (str_tab_len < 1)
7960 {
7961 error
7962 (_("Unable to determine the length of the dynamic string table\n"));
7963 continue;
7964 }
7965
3f5e193b
NC		 7966 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7967 str_tab_len,
7968 _("dynamic string table"));
59245841 7969 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7970 break;
7971 }
7972 }
7973
7974 /* And find the syminfo section if available. */
7975 if (dynamic_syminfo == NULL)
7976 {
3e8bba36 7977 unsigned long syminsz = 0;
252b5132 7978
86dba8ee
AM		 7979 for (entry = dynamic_section;
7980 entry < dynamic_section + dynamic_nent;
7981 ++entry)
252b5132
RH		 7982 {
7983 if (entry->d_tag == DT_SYMINENT)
7984 {
7985 /* Note: these braces are necessary to avoid a syntax
7986 error from the SunOS4 C compiler. */
7987 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7988 }
7989 else if (entry->d_tag == DT_SYMINSZ)
7990 syminsz = entry->d_un.d_val;
7991 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7992 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7993 syminsz);
252b5132
RH		 7994 }
7995
7996 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7997 {
2cf0635d
NC		 7998 Elf_External_Syminfo * extsyminfo;
7999 Elf_External_Syminfo * extsym;
8000 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8001
8002 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8003 extsyminfo = (Elf_External_Syminfo *)
8004 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8005 _("symbol information"));
a6e9f9df
AM		 8006 if (!extsyminfo)
8007 return 0;
252b5132 8008
3f5e193b 8009 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8010 if (dynamic_syminfo == NULL)
8011 {
8012 error (_("Out of memory\n"));
8013 return 0;
8014 }
8015
8016 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8017 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8018 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8019 ++syminfo, ++extsym)
252b5132 8020 {
86dba8ee
AM		 8021 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8022 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8023 }
8024
8025 free (extsyminfo);
8026 }
8027 }
8028
8029 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 8030 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8031 dynamic_addr, dynamic_nent);
252b5132
RH		 8032 if (do_dynamic)
8033 printf (_(" Tag Type Name/Value\n"));
8034
86dba8ee
AM		 8035 for (entry = dynamic_section;
8036 entry < dynamic_section + dynamic_nent;
8037 entry++)
252b5132
RH		 8038 {
8039 if (do_dynamic)
f7a99963 8040 {
2cf0635d 8041 const char * dtype;
e699b9ff 8042
f7a99963
NC		 8043 putchar (' ');
8044 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8045 dtype = get_dynamic_type (entry->d_tag);
8046 printf (" (%s)%*s", dtype,
8047 ((is_32bit_elf ? 27 : 19)
8048 - (int) strlen (dtype)),
f7a99963
NC		 8049 " ");
8050 }
252b5132
RH		 8051
8052 switch (entry->d_tag)
8053 {
d1133906
NC		 8054 case DT_FLAGS:
8055 if (do_dynamic)
e9e44622 8056 print_dynamic_flags (entry->d_un.d_val);
d1133906 8057 break;
76da6bbe 8058
252b5132
RH		 8059 case DT_AUXILIARY:
8060 case DT_FILTER:
019148e4
L		 8061 case DT_CONFIG:
8062 case DT_DEPAUDIT:
8063 case DT_AUDIT:
252b5132
RH		 8064 if (do_dynamic)
8065 {
019148e4 8066 switch (entry->d_tag)
b34976b6 8067 {
019148e4
L		 8068 case DT_AUXILIARY:
8069 printf (_("Auxiliary library"));
8070 break;
8071
8072 case DT_FILTER:
8073 printf (_("Filter library"));
8074 break;
8075
b34976b6 8076 case DT_CONFIG:
019148e4
L		 8077 printf (_("Configuration file"));
8078 break;
8079
8080 case DT_DEPAUDIT:
8081 printf (_("Dependency audit library"));
8082 break;
8083
8084 case DT_AUDIT:
8085 printf (_("Audit library"));
8086 break;
8087 }
252b5132 8088
d79b3d50
NC		 8089 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8090 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8091 else
f7a99963
NC		 8092 {
8093 printf (": ");
8094 print_vma (entry->d_un.d_val, PREFIX_HEX);
8095 putchar ('\n');
8096 }
252b5132
RH		 8097 }
8098 break;
8099
dcefbbbd 8100 case DT_FEATURE:
252b5132
RH		 8101 if (do_dynamic)
8102 {
8103 printf (_("Flags:"));
86f55779 8104
252b5132
RH		 8105 if (entry->d_un.d_val == 0)
8106 printf (_(" None\n"));
8107 else
8108 {
8109 unsigned long int val = entry->d_un.d_val;
86f55779 8110
252b5132
RH		 8111 if (val & DTF_1_PARINIT)
8112 {
8113 printf (" PARINIT");
8114 val ^= DTF_1_PARINIT;
8115 }
dcefbbbd
L		 8116 if (val & DTF_1_CONFEXP)
8117 {
8118 printf (" CONFEXP");
8119 val ^= DTF_1_CONFEXP;
8120 }
252b5132
RH		 8121 if (val != 0)
8122 printf (" %lx", val);
8123 puts ("");
8124 }
8125 }
8126 break;
8127
8128 case DT_POSFLAG_1:
8129 if (do_dynamic)
8130 {
8131 printf (_("Flags:"));
86f55779 8132
252b5132
RH		 8133 if (entry->d_un.d_val == 0)
8134 printf (_(" None\n"));
8135 else
8136 {
8137 unsigned long int val = entry->d_un.d_val;
86f55779 8138
252b5132
RH		 8139 if (val & DF_P1_LAZYLOAD)
8140 {
8141 printf (" LAZYLOAD");
8142 val ^= DF_P1_LAZYLOAD;
8143 }
8144 if (val & DF_P1_GROUPPERM)
8145 {
8146 printf (" GROUPPERM");
8147 val ^= DF_P1_GROUPPERM;
8148 }
8149 if (val != 0)
8150 printf (" %lx", val);
8151 puts ("");
8152 }
8153 }
8154 break;
8155
8156 case DT_FLAGS_1:
8157 if (do_dynamic)
8158 {
8159 printf (_("Flags:"));
8160 if (entry->d_un.d_val == 0)
8161 printf (_(" None\n"));
8162 else
8163 {
8164 unsigned long int val = entry->d_un.d_val;
86f55779 8165
252b5132
RH		 8166 if (val & DF_1_NOW)
8167 {
8168 printf (" NOW");
8169 val ^= DF_1_NOW;
8170 }
8171 if (val & DF_1_GLOBAL)
8172 {
8173 printf (" GLOBAL");
8174 val ^= DF_1_GLOBAL;
8175 }
8176 if (val & DF_1_GROUP)
8177 {
8178 printf (" GROUP");
8179 val ^= DF_1_GROUP;
8180 }
8181 if (val & DF_1_NODELETE)
8182 {
8183 printf (" NODELETE");
8184 val ^= DF_1_NODELETE;
8185 }
8186 if (val & DF_1_LOADFLTR)
8187 {
8188 printf (" LOADFLTR");
8189 val ^= DF_1_LOADFLTR;
8190 }
8191 if (val & DF_1_INITFIRST)
8192 {
8193 printf (" INITFIRST");
8194 val ^= DF_1_INITFIRST;
8195 }
8196 if (val & DF_1_NOOPEN)
8197 {
8198 printf (" NOOPEN");
8199 val ^= DF_1_NOOPEN;
8200 }
8201 if (val & DF_1_ORIGIN)
8202 {
8203 printf (" ORIGIN");
8204 val ^= DF_1_ORIGIN;
8205 }
8206 if (val & DF_1_DIRECT)
8207 {
8208 printf (" DIRECT");
8209 val ^= DF_1_DIRECT;
8210 }
8211 if (val & DF_1_TRANS)
8212 {
8213 printf (" TRANS");
8214 val ^= DF_1_TRANS;
8215 }
8216 if (val & DF_1_INTERPOSE)
8217 {
8218 printf (" INTERPOSE");
8219 val ^= DF_1_INTERPOSE;
8220 }
f7db6139 8221 if (val & DF_1_NODEFLIB)
dcefbbbd 8222 {
f7db6139
L		 8223 printf (" NODEFLIB");
8224 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8225 }
8226 if (val & DF_1_NODUMP)
8227 {
8228 printf (" NODUMP");
8229 val ^= DF_1_NODUMP;
8230 }
34b60028 8231 if (val & DF_1_CONFALT)
dcefbbbd 8232 {
34b60028
L		 8233 printf (" CONFALT");
8234 val ^= DF_1_CONFALT;
8235 }
8236 if (val & DF_1_ENDFILTEE)
8237 {
8238 printf (" ENDFILTEE");
8239 val ^= DF_1_ENDFILTEE;
8240 }
8241 if (val & DF_1_DISPRELDNE)
8242 {
8243 printf (" DISPRELDNE");
8244 val ^= DF_1_DISPRELDNE;
8245 }
8246 if (val & DF_1_DISPRELPND)
8247 {
8248 printf (" DISPRELPND");
8249 val ^= DF_1_DISPRELPND;
8250 }
8251 if (val & DF_1_NODIRECT)
8252 {
8253 printf (" NODIRECT");
8254 val ^= DF_1_NODIRECT;
8255 }
8256 if (val & DF_1_IGNMULDEF)
8257 {
8258 printf (" IGNMULDEF");
8259 val ^= DF_1_IGNMULDEF;
8260 }
8261 if (val & DF_1_NOKSYMS)
8262 {
8263 printf (" NOKSYMS");
8264 val ^= DF_1_NOKSYMS;
8265 }
8266 if (val & DF_1_NOHDR)
8267 {
8268 printf (" NOHDR");
8269 val ^= DF_1_NOHDR;
8270 }
8271 if (val & DF_1_EDITED)
8272 {
8273 printf (" EDITED");
8274 val ^= DF_1_EDITED;
8275 }
8276 if (val & DF_1_NORELOC)
8277 {
8278 printf (" NORELOC");
8279 val ^= DF_1_NORELOC;
8280 }
8281 if (val & DF_1_SYMINTPOSE)
8282 {
8283 printf (" SYMINTPOSE");
8284 val ^= DF_1_SYMINTPOSE;
8285 }
8286 if (val & DF_1_GLOBAUDIT)
8287 {
8288 printf (" GLOBAUDIT");
8289 val ^= DF_1_GLOBAUDIT;
8290 }
8291 if (val & DF_1_SINGLETON)
8292 {
8293 printf (" SINGLETON");
8294 val ^= DF_1_SINGLETON;
dcefbbbd 8295 }
252b5132
RH		 8296 if (val != 0)
8297 printf (" %lx", val);
8298 puts ("");
8299 }
8300 }
8301 break;
8302
8303 case DT_PLTREL:
566b0d53 8304 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8305 if (do_dynamic)
8306 puts (get_dynamic_type (entry->d_un.d_val));
8307 break;
8308
8309 case DT_NULL :
8310 case DT_NEEDED :
8311 case DT_PLTGOT :
8312 case DT_HASH :
8313 case DT_STRTAB :
8314 case DT_SYMTAB :
8315 case DT_RELA :
8316 case DT_INIT :
8317 case DT_FINI :
8318 case DT_SONAME :
8319 case DT_RPATH :
8320 case DT_SYMBOLIC:
8321 case DT_REL :
8322 case DT_DEBUG :
8323 case DT_TEXTREL :
8324 case DT_JMPREL :
019148e4 8325 case DT_RUNPATH :
252b5132
RH		 8326 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8327
8328 if (do_dynamic)
8329 {
2cf0635d 8330 char * name;
252b5132 8331
d79b3d50
NC		 8332 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8333 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8334 else
d79b3d50 8335 name = NULL;
252b5132
RH		 8336
8337 if (name)
8338 {
8339 switch (entry->d_tag)
8340 {
8341 case DT_NEEDED:
8342 printf (_("Shared library: [%s]"), name);
8343
18bd398b 8344 if (streq (name, program_interpreter))
f7a99963 8345 printf (_(" program interpreter"));
252b5132
RH		 8346 break;
8347
8348 case DT_SONAME:
f7a99963 8349 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8350 break;
8351
8352 case DT_RPATH:
f7a99963 8353 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8354 break;
8355
019148e4
L		 8356 case DT_RUNPATH:
8357 printf (_("Library runpath: [%s]"), name);
8358 break;
8359
252b5132 8360 default:
f7a99963
NC		 8361 print_vma (entry->d_un.d_val, PREFIX_HEX);
8362 break;
252b5132
RH		 8363 }
8364 }
8365 else
f7a99963
NC		 8366 print_vma (entry->d_un.d_val, PREFIX_HEX);
8367
8368 putchar ('\n');
252b5132
RH		 8369 }
8370 break;
8371
8372 case DT_PLTRELSZ:
8373 case DT_RELASZ :
8374 case DT_STRSZ :
8375 case DT_RELSZ :
8376 case DT_RELAENT :
8377 case DT_SYMENT :
8378 case DT_RELENT :
566b0d53 8379 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8380 case DT_PLTPADSZ:
8381 case DT_MOVEENT :
8382 case DT_MOVESZ :
8383 case DT_INIT_ARRAYSZ:
8384 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8385 case DT_GNU_CONFLICTSZ:
8386 case DT_GNU_LIBLISTSZ:
252b5132 8387 if (do_dynamic)
f7a99963
NC		 8388 {
8389 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8390 printf (_(" (bytes)\n"));
f7a99963 8391 }
252b5132
RH		 8392 break;
8393
8394 case DT_VERDEFNUM:
8395 case DT_VERNEEDNUM:
8396 case DT_RELACOUNT:
8397 case DT_RELCOUNT:
8398 if (do_dynamic)
f7a99963
NC		 8399 {
8400 print_vma (entry->d_un.d_val, UNSIGNED);
8401 putchar ('\n');
8402 }
252b5132
RH		 8403 break;
8404
8405 case DT_SYMINSZ:
8406 case DT_SYMINENT:
8407 case DT_SYMINFO:
8408 case DT_USED:
8409 case DT_INIT_ARRAY:
8410 case DT_FINI_ARRAY:
8411 if (do_dynamic)
8412 {
d79b3d50
NC		 8413 if (entry->d_tag == DT_USED
8414 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8415 {
2cf0635d 8416 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8417
b34976b6 8418 if (*name)
252b5132
RH		 8419 {
8420 printf (_("Not needed object: [%s]\n"), name);
8421 break;
8422 }
8423 }
103f02d3 8424
f7a99963
NC		 8425 print_vma (entry->d_un.d_val, PREFIX_HEX);
8426 putchar ('\n');
252b5132
RH		 8427 }
8428 break;
8429
8430 case DT_BIND_NOW:
8431 /* The value of this entry is ignored. */
35b1837e
AM		 8432 if (do_dynamic)
8433 putchar ('\n');
252b5132 8434 break;
103f02d3 8435
047b2264
JJ		 8436 case DT_GNU_PRELINKED:
8437 if (do_dynamic)
8438 {
2cf0635d 8439 struct tm * tmp;
91d6fa6a 8440 time_t atime = entry->d_un.d_val;
047b2264 8441
91d6fa6a 8442 tmp = gmtime (&atime);
047b2264
JJ		 8443 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8444 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8445 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8446
8447 }
8448 break;
8449
fdc90cb4
JJ		 8450 case DT_GNU_HASH:
8451 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8452 if (do_dynamic)
8453 {
8454 print_vma (entry->d_un.d_val, PREFIX_HEX);
8455 putchar ('\n');
8456 }
8457 break;
8458
252b5132
RH		 8459 default:
8460 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8461 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8462 entry->d_un.d_val;
8463
8464 if (do_dynamic)
8465 {
8466 switch (elf_header.e_machine)
8467 {
8468 case EM_MIPS:
4fe85591 8469 case EM_MIPS_RS3_LE:
b2d38a17 8470 dynamic_section_mips_val (entry);
252b5132 8471 break;
103f02d3 8472 case EM_PARISC:
b2d38a17 8473 dynamic_section_parisc_val (entry);
103f02d3 8474 break;
ecc51f48 8475 case EM_IA_64:
b2d38a17 8476 dynamic_section_ia64_val (entry);
ecc51f48 8477 break;
252b5132 8478 default:
f7a99963
NC		 8479 print_vma (entry->d_un.d_val, PREFIX_HEX);
8480 putchar ('\n');
252b5132
RH		 8481 }
8482 }
8483 break;
8484 }
8485 }
8486
8487 return 1;
8488}
8489
8490static char *
d3ba0551 8491get_ver_flags (unsigned int flags)
252b5132 8492{
b34976b6 8493 static char buff[32];
252b5132
RH		 8494
8495 buff[0] = 0;
8496
8497 if (flags == 0)
8498 return _("none");
8499
8500 if (flags & VER_FLG_BASE)
8501 strcat (buff, "BASE ");
8502
8503 if (flags & VER_FLG_WEAK)
8504 {
8505 if (flags & VER_FLG_BASE)
8506 strcat (buff, "| ");
8507
8508 strcat (buff, "WEAK ");
8509 }
8510
44ec90b9
RO		 8511 if (flags & VER_FLG_INFO)
8512 {
8513 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8514 strcat (buff, "| ");
8515
8516 strcat (buff, "INFO ");
8517 }
8518
8519 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8520 strcat (buff, _("| <unknown>"));
252b5132
RH		 8521
8522 return buff;
8523}
8524
8525/* Display the contents of the version sections. */
98fb390a 8526
252b5132 8527static int
2cf0635d 8528process_version_sections (FILE * file)
252b5132 8529{
2cf0635d 8530 Elf_Internal_Shdr * section;
b34976b6
AM		 8531 unsigned i;
8532 int found = 0;
252b5132
RH		 8533
8534 if (! do_version)
8535 return 1;
8536
8537 for (i = 0, section = section_headers;
8538 i < elf_header.e_shnum;
b34976b6 8539 i++, section++)
252b5132
RH		 8540 {
8541 switch (section->sh_type)
8542 {
8543 case SHT_GNU_verdef:
8544 {
2cf0635d 8545 Elf_External_Verdef * edefs;
b34976b6
AM		 8546 unsigned int idx;
8547 unsigned int cnt;
2cf0635d 8548 char * endbuf;
252b5132
RH		 8549
8550 found = 1;
8551
8552 printf
72de5009 8553 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8554 SECTION_NAME (section), section->sh_info);
8555
8556 printf (_(" Addr: 0x"));
8557 printf_vma (section->sh_addr);
72de5009 8558 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8559 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8560 section->sh_link < elf_header.e_shnum
8561 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8562 : _("<corrupt>"));
252b5132 8563
3f5e193b
NC		 8564 edefs = (Elf_External_Verdef *)
8565 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8566 _("version definition section"));
a6e9f9df
AM		 8567 if (!edefs)
8568 break;
59245841 8569 endbuf = (char *) edefs + section->sh_size;
252b5132 8570
b34976b6 8571 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8572 {
2cf0635d
NC		 8573 char * vstart;
8574 Elf_External_Verdef * edef;
b34976b6 8575 Elf_Internal_Verdef ent;
2cf0635d 8576 Elf_External_Verdaux * eaux;
b34976b6
AM		 8577 Elf_Internal_Verdaux aux;
8578 int j;
8579 int isum;
103f02d3 8580
7e26601c
NC		 8581 /* Check for very large indicies. */
8582 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 8583 break;
8584
252b5132 8585 vstart = ((char *) edefs) + idx;
54806181
AM		 8586 if (vstart + sizeof (*edef) > endbuf)
8587 break;
252b5132
RH		 8588
8589 edef = (Elf_External_Verdef *) vstart;
8590
8591 ent.vd_version = BYTE_GET (edef->vd_version);
8592 ent.vd_flags = BYTE_GET (edef->vd_flags);
8593 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8594 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8595 ent.vd_hash = BYTE_GET (edef->vd_hash);
8596 ent.vd_aux = BYTE_GET (edef->vd_aux);
8597 ent.vd_next = BYTE_GET (edef->vd_next);
8598
8599 printf (_(" %#06x: Rev: %d Flags: %s"),
8600 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8601
8602 printf (_(" Index: %d Cnt: %d "),
8603 ent.vd_ndx, ent.vd_cnt);
8604
dd24e3da 8605 /* Check for overflow. */
7e26601c 8606 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8607 break;
8608
252b5132
RH		 8609 vstart += ent.vd_aux;
8610
8611 eaux = (Elf_External_Verdaux *) vstart;
8612
8613 aux.vda_name = BYTE_GET (eaux->vda_name);
8614 aux.vda_next = BYTE_GET (eaux->vda_next);
8615
d79b3d50
NC		 8616 if (VALID_DYNAMIC_NAME (aux.vda_name))
8617 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8618 else
8619 printf (_("Name index: %ld\n"), aux.vda_name);
8620
8621 isum = idx + ent.vd_aux;
8622
b34976b6 8623 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8624 {
dd24e3da 8625 /* Check for overflow. */
7e26601c 8626 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8627 break;
8628
252b5132
RH		 8629 isum += aux.vda_next;
8630 vstart += aux.vda_next;
8631
8632 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8633 if (vstart + sizeof (*eaux) > endbuf)
8634 break;
252b5132
RH		 8635
8636 aux.vda_name = BYTE_GET (eaux->vda_name);
8637 aux.vda_next = BYTE_GET (eaux->vda_next);
8638
d79b3d50 8639 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8640 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8641 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8642 else
8643 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8644 isum, j, aux.vda_name);
8645 }
dd24e3da 8646
54806181
AM		 8647 if (j < ent.vd_cnt)
8648 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8649
8650 idx += ent.vd_next;
8651 }
dd24e3da 8652
54806181
AM		 8653 if (cnt < section->sh_info)
8654 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8655
8656 free (edefs);
8657 }
8658 break;
103f02d3 8659
252b5132
RH		 8660 case SHT_GNU_verneed:
8661 {
2cf0635d 8662 Elf_External_Verneed * eneed;
b34976b6
AM		 8663 unsigned int idx;
8664 unsigned int cnt;
2cf0635d 8665 char * endbuf;
252b5132
RH		 8666
8667 found = 1;
8668
72de5009 8669 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8670 SECTION_NAME (section), section->sh_info);
8671
8672 printf (_(" Addr: 0x"));
8673 printf_vma (section->sh_addr);
72de5009 8674 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8675 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8676 section->sh_link < elf_header.e_shnum
8677 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8678 : _("<corrupt>"));
252b5132 8679
3f5e193b
NC		 8680 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8681 section->sh_offset, 1,
8682 section->sh_size,
9cf03b7e 8683 _("Version Needs section"));
a6e9f9df
AM		 8684 if (!eneed)
8685 break;
59245841 8686 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8687
8688 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8689 {
2cf0635d 8690 Elf_External_Verneed * entry;
b34976b6
AM		 8691 Elf_Internal_Verneed ent;
8692 int j;
8693 int isum;
2cf0635d 8694 char * vstart;
252b5132 8695
7e26601c 8696 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 8697 break;
8698
252b5132 8699 vstart = ((char *) eneed) + idx;
54806181
AM		 8700 if (vstart + sizeof (*entry) > endbuf)
8701 break;
252b5132
RH		 8702
8703 entry = (Elf_External_Verneed *) vstart;
8704
8705 ent.vn_version = BYTE_GET (entry->vn_version);
8706 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8707 ent.vn_file = BYTE_GET (entry->vn_file);
8708 ent.vn_aux = BYTE_GET (entry->vn_aux);
8709 ent.vn_next = BYTE_GET (entry->vn_next);
8710
8711 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8712
d79b3d50
NC		 8713 if (VALID_DYNAMIC_NAME (ent.vn_file))
8714 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8715 else
8716 printf (_(" File: %lx"), ent.vn_file);
8717
8718 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8719
dd24e3da 8720 /* Check for overflow. */
7e26601c 8721 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8722 break;
8723
252b5132
RH		 8724 vstart += ent.vn_aux;
8725
8726 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8727 {
2cf0635d 8728 Elf_External_Vernaux * eaux;
b34976b6 8729 Elf_Internal_Vernaux aux;
252b5132 8730
54806181
AM		 8731 if (vstart + sizeof (*eaux) > endbuf)
8732 break;
252b5132
RH		 8733 eaux = (Elf_External_Vernaux *) vstart;
8734
8735 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8736 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8737 aux.vna_other = BYTE_GET (eaux->vna_other);
8738 aux.vna_name = BYTE_GET (eaux->vna_name);
8739 aux.vna_next = BYTE_GET (eaux->vna_next);
8740
d79b3d50 8741 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8742 printf (_(" %#06x: Name: %s"),
d79b3d50 8743 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8744 else
ecc2063b 8745 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8746 isum, aux.vna_name);
8747
8748 printf (_(" Flags: %s Version: %d\n"),
8749 get_ver_flags (aux.vna_flags), aux.vna_other);
8750
dd24e3da 8751 /* Check for overflow. */
7e26601c 8752 if (aux.vna_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8753 break;
8754
252b5132
RH		 8755 isum += aux.vna_next;
8756 vstart += aux.vna_next;
8757 }
9cf03b7e 8758
54806181 8759 if (j < ent.vn_cnt)
9cf03b7e 8760 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8761
8762 idx += ent.vn_next;
8763 }
9cf03b7e 8764
54806181 8765 if (cnt < section->sh_info)
9cf03b7e 8766 warn (_("Missing Version Needs information\n"));
103f02d3 8767
252b5132
RH		 8768 free (eneed);
8769 }
8770 break;
8771
8772 case SHT_GNU_versym:
8773 {
2cf0635d 8774 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8775 int total;
8776 int cnt;
2cf0635d
NC		 8777 unsigned char * edata;
8778 unsigned short * data;
8779 char * strtab;
8780 Elf_Internal_Sym * symbols;
8781 Elf_Internal_Shdr * string_sec;
ba5cdace 8782 unsigned long num_syms;
d3ba0551 8783 long off;
252b5132 8784
4fbb74a6 8785 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8786 break;
8787
4fbb74a6 8788 link_section = section_headers + section->sh_link;
08d8fa11 8789 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8790
4fbb74a6 8791 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8792 break;
8793
252b5132
RH		 8794 found = 1;
8795
ba5cdace 8796 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 8797 if (symbols == NULL)
8798 break;
252b5132 8799
4fbb74a6 8800 string_sec = section_headers + link_section->sh_link;
252b5132 8801
3f5e193b
NC		 8802 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8803 string_sec->sh_size,
8804 _("version string table"));
a6e9f9df 8805 if (!strtab)
0429c154
MS		 8806 {
8807 free (symbols);
8808 break;
8809 }
252b5132
RH		 8810
8811 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8812 SECTION_NAME (section), total);
8813
8814 printf (_(" Addr: "));
8815 printf_vma (section->sh_addr);
72de5009 8816 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8817 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8818 SECTION_NAME (link_section));
8819
d3ba0551
AM		 8820 off = offset_from_vma (file,
8821 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8822 total * sizeof (short));
3f5e193b
NC		 8823 edata = (unsigned char *) get_data (NULL, file, off, total,
8824 sizeof (short),
8825 _("version symbol data"));
a6e9f9df
AM		 8826 if (!edata)
8827 {
8828 free (strtab);
0429c154 8829 free (symbols);
a6e9f9df
AM		 8830 break;
8831 }
252b5132 8832
3f5e193b 8833 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8834
8835 for (cnt = total; cnt --;)
b34976b6
AM		 8836 data[cnt] = byte_get (edata + cnt * sizeof (short),
8837 sizeof (short));
252b5132
RH		 8838
8839 free (edata);
8840
8841 for (cnt = 0; cnt < total; cnt += 4)
8842 {
8843 int j, nn;
00d93f34 8844 int check_def, check_need;
2cf0635d 8845 char * name;
252b5132
RH		 8846
8847 printf (" %03x:", cnt);
8848
8849 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8850 switch (data[cnt + j])
252b5132
RH		 8851 {
8852 case 0:
8853 fputs (_(" 0 (*local*) "), stdout);
8854 break;
8855
8856 case 1:
8857 fputs (_(" 1 (*global*) "), stdout);
8858 break;
8859
8860 default:
c244d050
NC		 8861 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8862 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8863
dd24e3da 8864 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 8865 array, break to avoid an out-of-bounds read. */
8866 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 8867 {
8868 warn (_("invalid index into symbol array\n"));
8869 break;
8870 }
8871
00d93f34
JJ		 8872 check_def = 1;
8873 check_need = 1;
4fbb74a6
AM		 8874 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8875 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8876 != SHT_NOBITS)
252b5132 8877 {
b34976b6 8878 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8879 check_def = 0;
8880 else
8881 check_need = 0;
252b5132 8882 }
00d93f34
JJ		 8883
8884 if (check_need
b34976b6 8885 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8886 {
b34976b6
AM		 8887 Elf_Internal_Verneed ivn;
8888 unsigned long offset;
252b5132 8889
d93f0186
NC		 8890 offset = offset_from_vma
8891 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8892 sizeof (Elf_External_Verneed));
252b5132 8893
b34976b6 8894 do
252b5132 8895 {
b34976b6
AM		 8896 Elf_Internal_Vernaux ivna;
8897 Elf_External_Verneed evn;
8898 Elf_External_Vernaux evna;
8899 unsigned long a_off;
252b5132 8900
59245841
NC		 8901 if (get_data (&evn, file, offset, sizeof (evn), 1,
8902 _("version need")) == NULL)
8903 break;
0b4362b0 8904
252b5132
RH		 8905 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8906 ivn.vn_next = BYTE_GET (evn.vn_next);
8907
8908 a_off = offset + ivn.vn_aux;
8909
8910 do
8911 {
59245841
NC		 8912 if (get_data (&evna, file, a_off, sizeof (evna),
8913 1, _("version need aux (2)")) == NULL)
8914 {
8915 ivna.vna_next = 0;
8916 ivna.vna_other = 0;
8917 }
8918 else
8919 {
8920 ivna.vna_next = BYTE_GET (evna.vna_next);
8921 ivna.vna_other = BYTE_GET (evna.vna_other);
8922 }
252b5132
RH		 8923
8924 a_off += ivna.vna_next;
8925 }
b34976b6 8926 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8927 && ivna.vna_next != 0);
8928
b34976b6 8929 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8930 {
8931 ivna.vna_name = BYTE_GET (evna.vna_name);
8932
54806181
AM		 8933 if (ivna.vna_name >= string_sec->sh_size)
8934 name = _("*invalid*");
8935 else
8936 name = strtab + ivna.vna_name;
252b5132 8937 nn += printf ("(%s%-*s",
16062207
ILT		 8938 name,
8939 12 - (int) strlen (name),
252b5132 8940 ")");
00d93f34 8941 check_def = 0;
252b5132
RH		 8942 break;
8943 }
8944
8945 offset += ivn.vn_next;
8946 }
8947 while (ivn.vn_next);
8948 }
00d93f34 8949
b34976b6
AM		 8950 if (check_def && data[cnt + j] != 0x8001
8951 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8952 {
b34976b6
AM		 8953 Elf_Internal_Verdef ivd;
8954 Elf_External_Verdef evd;
8955 unsigned long offset;
252b5132 8956
d93f0186
NC		 8957 offset = offset_from_vma
8958 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8959 sizeof evd);
252b5132
RH		 8960
8961 do
8962 {
59245841
NC		 8963 if (get_data (&evd, file, offset, sizeof (evd), 1,
8964 _("version def")) == NULL)
8965 {
8966 ivd.vd_next = 0;
8967 ivd.vd_ndx = 0;
8968 }
8969 else
8970 {
8971 ivd.vd_next = BYTE_GET (evd.vd_next);
8972 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8973 }
252b5132
RH		 8974
8975 offset += ivd.vd_next;
8976 }
c244d050 8977 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8978 && ivd.vd_next != 0);
8979
c244d050 8980 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8981 {
b34976b6
AM		 8982 Elf_External_Verdaux evda;
8983 Elf_Internal_Verdaux ivda;
252b5132
RH		 8984
8985 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8986
59245841
NC		 8987 if (get_data (&evda, file,
8988 offset - ivd.vd_next + ivd.vd_aux,
8989 sizeof (evda), 1,
8990 _("version def aux")) == NULL)
8991 break;
252b5132
RH		 8992
8993 ivda.vda_name = BYTE_GET (evda.vda_name);
8994
54806181
AM		 8995 if (ivda.vda_name >= string_sec->sh_size)
8996 name = _("*invalid*");
8997 else
8998 name = strtab + ivda.vda_name;
252b5132 8999 nn += printf ("(%s%-*s",
16062207
ILT		 9000 name,
9001 12 - (int) strlen (name),
252b5132
RH		 9002 ")");
9003 }
9004 }
9005
9006 if (nn < 18)
9007 printf ("%*c", 18 - nn, ' ');
9008 }
9009
9010 putchar ('\n');
9011 }
9012
9013 free (data);
9014 free (strtab);
9015 free (symbols);
9016 }
9017 break;
103f02d3 9018
252b5132
RH		 9019 default:
9020 break;
9021 }
9022 }
9023
9024 if (! found)
9025 printf (_("\nNo version information found in this file.\n"));
9026
9027 return 1;
9028}
9029
d1133906 9030static const char *
d3ba0551 9031get_symbol_binding (unsigned int binding)
252b5132 9032{
b34976b6 9033 static char buff[32];
252b5132
RH		 9034
9035 switch (binding)
9036 {
b34976b6
AM		 9037 case STB_LOCAL: return "LOCAL";
9038 case STB_GLOBAL: return "GLOBAL";
9039 case STB_WEAK: return "WEAK";
252b5132
RH		 9040 default:
9041 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9042 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9043 binding);
252b5132 9044 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9045 {
9046 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9047 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9048 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9049 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9050 return "UNIQUE";
9051 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9052 }
252b5132 9053 else
e9e44622 9054 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9055 return buff;
9056 }
9057}
9058
d1133906 9059static const char *
d3ba0551 9060get_symbol_type (unsigned int type)
252b5132 9061{
b34976b6 9062 static char buff[32];
252b5132
RH		 9063
9064 switch (type)
9065 {
b34976b6
AM		 9066 case STT_NOTYPE: return "NOTYPE";
9067 case STT_OBJECT: return "OBJECT";
9068 case STT_FUNC: return "FUNC";
9069 case STT_SECTION: return "SECTION";
9070 case STT_FILE: return "FILE";
9071 case STT_COMMON: return "COMMON";
9072 case STT_TLS: return "TLS";
15ab5209
DB		 9073 case STT_RELC: return "RELC";
9074 case STT_SRELC: return "SRELC";
252b5132
RH		 9075 default:
9076 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9077 {
13761a11
NC		 9078 if (elf_header.e_machine == EM_ARM)
9079 {
9080 if (type == STT_ARM_TFUNC)
9081 return "THUMB_FUNC";
9082 if (type == STT_ARM_16BIT)
9083 return "THUMB_LABEL";
9084 }
103f02d3 9085
351b4b40 9086 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9087 return "REGISTER";
9088
9089 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9090 return "PARISC_MILLI";
9091
e9e44622 9092 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9093 }
252b5132 9094 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9095 {
9096 if (elf_header.e_machine == EM_PARISC)
9097 {
9098 if (type == STT_HP_OPAQUE)
9099 return "HP_OPAQUE";
9100 if (type == STT_HP_STUB)
9101 return "HP_STUB";
9102 }
9103
d8045f23 9104 if (type == STT_GNU_IFUNC
9c55345c 9105 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9106 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9107 /* GNU is still using the default value 0. */
d8045f23
NC		 9108 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9109 return "IFUNC";
9110
e9e44622 9111 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9112 }
252b5132 9113 else
e9e44622 9114 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9115 return buff;
9116 }
9117}
9118
d1133906 9119static const char *
d3ba0551 9120get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9121{
9122 switch (visibility)
9123 {
b34976b6
AM		 9124 case STV_DEFAULT: return "DEFAULT";
9125 case STV_INTERNAL: return "INTERNAL";
9126 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9127 case STV_PROTECTED: return "PROTECTED";
9128 default: abort ();
9129 }
9130}
9131
5e2b0d47
NC		 9132static const char *
9133get_mips_symbol_other (unsigned int other)
9134{
9135 switch (other)
9136 {
df58fc94
RS		 9137 case STO_OPTIONAL:
9138 return "OPTIONAL";
9139 case STO_MIPS_PLT:
9140 return "MIPS PLT";
9141 case STO_MIPS_PIC:
9142 return "MIPS PIC";
9143 case STO_MICROMIPS:
9144 return "MICROMIPS";
9145 case STO_MICROMIPS | STO_MIPS_PIC:
9146 return "MICROMIPS, MIPS PIC";
9147 case STO_MIPS16:
9148 return "MIPS16";
9149 default:
9150 return NULL;
5e2b0d47
NC		 9151 }
9152}
9153
28f997cf
TG		 9154static const char *
9155get_ia64_symbol_other (unsigned int other)
9156{
9157 if (is_ia64_vms ())
9158 {
9159 static char res[32];
9160
9161 res[0] = 0;
9162
9163 /* Function types is for images and .STB files only. */
9164 switch (elf_header.e_type)
9165 {
9166 case ET_DYN:
9167 case ET_EXEC:
9168 switch (VMS_ST_FUNC_TYPE (other))
9169 {
9170 case VMS_SFT_CODE_ADDR:
9171 strcat (res, " CA");
9172 break;
9173 case VMS_SFT_SYMV_IDX:
9174 strcat (res, " VEC");
9175 break;
9176 case VMS_SFT_FD:
9177 strcat (res, " FD");
9178 break;
9179 case VMS_SFT_RESERVE:
9180 strcat (res, " RSV");
9181 break;
9182 default:
9183 abort ();
9184 }
9185 break;
9186 default:
9187 break;
9188 }
9189 switch (VMS_ST_LINKAGE (other))
9190 {
9191 case VMS_STL_IGNORE:
9192 strcat (res, " IGN");
9193 break;
9194 case VMS_STL_RESERVE:
9195 strcat (res, " RSV");
9196 break;
9197 case VMS_STL_STD:
9198 strcat (res, " STD");
9199 break;
9200 case VMS_STL_LNK:
9201 strcat (res, " LNK");
9202 break;
9203 default:
9204 abort ();
9205 }
9206
9207 if (res[0] != 0)
9208 return res + 1;
9209 else
9210 return res;
9211 }
9212 return NULL;
9213}
9214
6911b7dc
AM		 9215static const char *
9216get_ppc64_symbol_other (unsigned int other)
9217{
9218 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9219 {
9220 static char buf[32];
9221 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9222 PPC64_LOCAL_ENTRY_OFFSET (other));
9223 return buf;
9224 }
9225 return NULL;
9226}
9227
5e2b0d47
NC		 9228static const char *
9229get_symbol_other (unsigned int other)
9230{
9231 const char * result = NULL;
9232 static char buff [32];
9233
9234 if (other == 0)
9235 return "";
9236
9237 switch (elf_header.e_machine)
9238 {
9239 case EM_MIPS:
9240 result = get_mips_symbol_other (other);
28f997cf
TG		 9241 break;
9242 case EM_IA_64:
9243 result = get_ia64_symbol_other (other);
9244 break;
6911b7dc
AM		 9245 case EM_PPC64:
9246 result = get_ppc64_symbol_other (other);
9247 break;
5e2b0d47
NC		 9248 default:
9249 break;
9250 }
9251
9252 if (result)
9253 return result;
9254
9255 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9256 return buff;
9257}
9258
d1133906 9259static const char *
d3ba0551 9260get_symbol_index_type (unsigned int type)
252b5132 9261{
b34976b6 9262 static char buff[32];
5cf1065c 9263
252b5132
RH		 9264 switch (type)
9265 {
b34976b6
AM		 9266 case SHN_UNDEF: return "UND";
9267 case SHN_ABS: return "ABS";
9268 case SHN_COMMON: return "COM";
252b5132 9269 default:
9ce701e2
L		 9270 if (type == SHN_IA_64_ANSI_COMMON
9271 && elf_header.e_machine == EM_IA_64
9272 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9273 return "ANSI_COM";
8a9036a4 9274 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9275 || elf_header.e_machine == EM_L1OM
9276 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9277 && type == SHN_X86_64_LCOMMON)
9278 return "LARGE_COM";
ac145307
BS		 9279 else if ((type == SHN_MIPS_SCOMMON
9280 && elf_header.e_machine == EM_MIPS)
9281 || (type == SHN_TIC6X_SCOMMON
9282 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9283 return "SCOM";
9284 else if (type == SHN_MIPS_SUNDEFINED
9285 && elf_header.e_machine == EM_MIPS)
9286 return "SUND";
9ce701e2 9287 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9288 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9289 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9290 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9291 else if (type >= SHN_LORESERVE)
9292 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L		 9293 else if (type >= elf_header.e_shnum)
9294 sprintf (buff, "bad section index[%3d]", type);
252b5132 9295 else
232e7cb8 9296 sprintf (buff, "%3d", type);
5cf1065c 9297 break;
252b5132 9298 }
5cf1065c
NC		 9299
9300 return buff;
252b5132
RH		 9301}
9302
66543521 9303static bfd_vma *
2cf0635d 9304get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9305{
2cf0635d
NC		 9306 unsigned char * e_data;
9307 bfd_vma * i_data;
252b5132 9308
3f5e193b 9309 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9310
9311 if (e_data == NULL)
9312 {
9313 error (_("Out of memory\n"));
9314 return NULL;
9315 }
9316
66543521 9317 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9318 {
9319 error (_("Unable to read in dynamic data\n"));
9320 return NULL;
9321 }
9322
3f5e193b 9323 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9324
9325 if (i_data == NULL)
9326 {
9327 error (_("Out of memory\n"));
9328 free (e_data);
9329 return NULL;
9330 }
9331
9332 while (number--)
66543521 9333 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9334
9335 free (e_data);
9336
9337 return i_data;
9338}
9339
6bd1a22c
L		 9340static void
9341print_dynamic_symbol (bfd_vma si, unsigned long hn)
9342{
2cf0635d 9343 Elf_Internal_Sym * psym;
6bd1a22c
L		 9344 int n;
9345
9346 psym = dynamic_symbols + si;
9347
9348 n = print_vma (si, DEC_5);
9349 if (n < 5)
0b4362b0 9350 fputs (&" "[n], stdout);
6bd1a22c
L		 9351 printf (" %3lu: ", hn);
9352 print_vma (psym->st_value, LONG_HEX);
9353 putchar (' ');
9354 print_vma (psym->st_size, DEC_5);
9355
f4be36b3
AM		 9356 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9357 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9358 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9359 /* Check to see if any other bits in the st_other field are set.
9360 Note - displaying this information disrupts the layout of the
9361 table being generated, but for the moment this case is very
9362 rare. */
9363 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9364 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9365 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9366 if (VALID_DYNAMIC_NAME (psym->st_name))
9367 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9368 else
2b692964 9369 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9370 putchar ('\n');
9371}
9372
e3c8793a 9373/* Dump the symbol table. */
252b5132 9374static int
2cf0635d 9375process_symbol_table (FILE * file)
252b5132 9376{
2cf0635d 9377 Elf_Internal_Shdr * section;
66543521
AM		 9378 bfd_vma nbuckets = 0;
9379 bfd_vma nchains = 0;
2cf0635d
NC		 9380 bfd_vma * buckets = NULL;
9381 bfd_vma * chains = NULL;
fdc90cb4 9382 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9383 bfd_vma * gnubuckets = NULL;
9384 bfd_vma * gnuchains = NULL;
6bd1a22c 9385 bfd_vma gnusymidx = 0;
252b5132 9386
2c610e4b 9387 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9388 return 1;
9389
6bd1a22c
L		 9390 if (dynamic_info[DT_HASH]
9391 && (do_histogram
2c610e4b
L		 9392 || (do_using_dynamic
9393 && !do_dyn_syms
9394 && dynamic_strings != NULL)))
252b5132 9395 {
66543521
AM		 9396 unsigned char nb[8];
9397 unsigned char nc[8];
9398 int hash_ent_size = 4;
9399
9400 if ((elf_header.e_machine == EM_ALPHA
9401 || elf_header.e_machine == EM_S390
9402 || elf_header.e_machine == EM_S390_OLD)
9403 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9404 hash_ent_size = 8;
9405
fb52b2f4
NC		 9406 if (fseek (file,
9407 (archive_file_offset
9408 + offset_from_vma (file, dynamic_info[DT_HASH],
9409 sizeof nb + sizeof nc)),
d93f0186 9410 SEEK_SET))
252b5132 9411 {
591a748a 9412 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9413 goto no_hash;
252b5132
RH		 9414 }
9415
66543521 9416 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9417 {
9418 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9419 goto no_hash;
252b5132
RH		 9420 }
9421
66543521 9422 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9423 {
9424 error (_("Failed to read in number of chains\n"));
d3a44ec6 9425 goto no_hash;
252b5132
RH		 9426 }
9427
66543521
AM		 9428 nbuckets = byte_get (nb, hash_ent_size);
9429 nchains = byte_get (nc, hash_ent_size);
252b5132 9430
66543521
AM		 9431 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9432 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9433
d3a44ec6 9434 no_hash:
252b5132 9435 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9436 {
9437 if (do_using_dynamic)
9438 return 0;
9439 free (buckets);
9440 free (chains);
9441 buckets = NULL;
9442 chains = NULL;
9443 nbuckets = 0;
9444 nchains = 0;
9445 }
252b5132
RH		 9446 }
9447
6bd1a22c
L		 9448 if (dynamic_info_DT_GNU_HASH
9449 && (do_histogram
2c610e4b
L		 9450 || (do_using_dynamic
9451 && !do_dyn_syms
9452 && dynamic_strings != NULL)))
252b5132 9453 {
6bd1a22c
L		 9454 unsigned char nb[16];
9455 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9456 bfd_vma buckets_vma;
9457
9458 if (fseek (file,
9459 (archive_file_offset
9460 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9461 sizeof nb)),
9462 SEEK_SET))
9463 {
9464 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9465 goto no_gnu_hash;
6bd1a22c 9466 }
252b5132 9467
6bd1a22c
L		 9468 if (fread (nb, 16, 1, file) != 1)
9469 {
9470 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9471 goto no_gnu_hash;
6bd1a22c
L		 9472 }
9473
9474 ngnubuckets = byte_get (nb, 4);
9475 gnusymidx = byte_get (nb + 4, 4);
9476 bitmaskwords = byte_get (nb + 8, 4);
9477 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9478 if (is_32bit_elf)
6bd1a22c 9479 buckets_vma += bitmaskwords * 4;
f7a99963 9480 else
6bd1a22c 9481 buckets_vma += bitmaskwords * 8;
252b5132 9482
6bd1a22c
L		 9483 if (fseek (file,
9484 (archive_file_offset
9485 + offset_from_vma (file, buckets_vma, 4)),
9486 SEEK_SET))
252b5132 9487 {
6bd1a22c 9488 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9489 goto no_gnu_hash;
6bd1a22c
L		 9490 }
9491
9492 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9493
6bd1a22c 9494 if (gnubuckets == NULL)
d3a44ec6 9495 goto no_gnu_hash;
6bd1a22c
L		 9496
9497 for (i = 0; i < ngnubuckets; i++)
9498 if (gnubuckets[i] != 0)
9499 {
9500 if (gnubuckets[i] < gnusymidx)
9501 return 0;
9502
9503 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9504 maxchain = gnubuckets[i];
9505 }
9506
9507 if (maxchain == 0xffffffff)
d3a44ec6 9508 goto no_gnu_hash;
6bd1a22c
L		 9509
9510 maxchain -= gnusymidx;
9511
9512 if (fseek (file,
9513 (archive_file_offset
9514 + offset_from_vma (file, buckets_vma
9515 + 4 * (ngnubuckets + maxchain), 4)),
9516 SEEK_SET))
9517 {
9518 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9519 goto no_gnu_hash;
6bd1a22c
L		 9520 }
9521
9522 do
9523 {
9524 if (fread (nb, 4, 1, file) != 1)
252b5132 9525 {
6bd1a22c 9526 error (_("Failed to determine last chain length\n"));
d3a44ec6 9527 goto no_gnu_hash;
6bd1a22c 9528 }
252b5132 9529
6bd1a22c 9530 if (maxchain + 1 == 0)
d3a44ec6 9531 goto no_gnu_hash;
252b5132 9532
6bd1a22c
L		 9533 ++maxchain;
9534 }
9535 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9536
6bd1a22c
L		 9537 if (fseek (file,
9538 (archive_file_offset
9539 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9540 SEEK_SET))
9541 {
9542 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9543 goto no_gnu_hash;
6bd1a22c
L		 9544 }
9545
9546 gnuchains = get_dynamic_data (file, maxchain, 4);
9547
d3a44ec6 9548 no_gnu_hash:
6bd1a22c 9549 if (gnuchains == NULL)
d3a44ec6
JJ		 9550 {
9551 free (gnubuckets);
d3a44ec6
JJ		 9552 gnubuckets = NULL;
9553 ngnubuckets = 0;
f64fddf1
NC		 9554 if (do_using_dynamic)
9555 return 0;
d3a44ec6 9556 }
6bd1a22c
L		 9557 }
9558
9559 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9560 && do_syms
9561 && do_using_dynamic
9562 && dynamic_strings != NULL)
9563 {
9564 unsigned long hn;
9565
9566 if (dynamic_info[DT_HASH])
9567 {
9568 bfd_vma si;
9569
9570 printf (_("\nSymbol table for image:\n"));
9571 if (is_32bit_elf)
9572 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9573 else
9574 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9575
9576 for (hn = 0; hn < nbuckets; hn++)
9577 {
9578 if (! buckets[hn])
9579 continue;
9580
9581 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9582 print_dynamic_symbol (si, hn);
252b5132
RH		 9583 }
9584 }
6bd1a22c
L		 9585
9586 if (dynamic_info_DT_GNU_HASH)
9587 {
9588 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9589 if (is_32bit_elf)
9590 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9591 else
9592 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9593
9594 for (hn = 0; hn < ngnubuckets; ++hn)
9595 if (gnubuckets[hn] != 0)
9596 {
9597 bfd_vma si = gnubuckets[hn];
9598 bfd_vma off = si - gnusymidx;
9599
9600 do
9601 {
9602 print_dynamic_symbol (si, hn);
9603 si++;
9604 }
9605 while ((gnuchains[off++] & 1) == 0);
9606 }
9607 }
252b5132 9608 }
2c610e4b 9609 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9610 {
b34976b6 9611 unsigned int i;
252b5132
RH		 9612
9613 for (i = 0, section = section_headers;
9614 i < elf_header.e_shnum;
9615 i++, section++)
9616 {
b34976b6 9617 unsigned int si;
2cf0635d 9618 char * strtab = NULL;
c256ffe7 9619 unsigned long int strtab_size = 0;
2cf0635d
NC		 9620 Elf_Internal_Sym * symtab;
9621 Elf_Internal_Sym * psym;
ba5cdace 9622 unsigned long num_syms;
252b5132 9623
2c610e4b
L		 9624 if ((section->sh_type != SHT_SYMTAB
9625 && section->sh_type != SHT_DYNSYM)
9626 || (!do_syms
9627 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9628 continue;
9629
dd24e3da
NC		 9630 if (section->sh_entsize == 0)
9631 {
9632 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9633 SECTION_NAME (section));
9634 continue;
9635 }
9636
252b5132
RH		 9637 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9638 SECTION_NAME (section),
9639 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9640
f7a99963 9641 if (is_32bit_elf)
ca47b30c 9642 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9643 else
ca47b30c 9644 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9645
ba5cdace 9646 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9647 if (symtab == NULL)
9648 continue;
9649
9650 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9651 {
9652 strtab = string_table;
9653 strtab_size = string_table_length;
9654 }
4fbb74a6 9655 else if (section->sh_link < elf_header.e_shnum)
252b5132 9656 {
2cf0635d 9657 Elf_Internal_Shdr * string_sec;
252b5132 9658
4fbb74a6 9659 string_sec = section_headers + section->sh_link;
252b5132 9660
3f5e193b
NC		 9661 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9662 1, string_sec->sh_size,
9663 _("string table"));
c256ffe7 9664 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9665 }
9666
ba5cdace 9667 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9668 {
5e220199 9669 printf ("%6d: ", si);
f7a99963
NC		 9670 print_vma (psym->st_value, LONG_HEX);
9671 putchar (' ');
9672 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9673 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9674 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9675 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9676 /* Check to see if any other bits in the st_other field are set.
9677 Note - displaying this information disrupts the layout of the
9678 table being generated, but for the moment this case is very rare. */
9679 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9680 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9681 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9682 print_symbol (25, psym->st_name < strtab_size
2b692964 9683 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9684
59245841
NC		 9685 if (section->sh_type == SHT_DYNSYM
9686 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9687 {
b34976b6
AM		 9688 unsigned char data[2];
9689 unsigned short vers_data;
9690 unsigned long offset;
9691 int is_nobits;
9692 int check_def;
252b5132 9693
d93f0186
NC		 9694 offset = offset_from_vma
9695 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9696 sizeof data + si * sizeof (vers_data));
252b5132 9697
59245841
NC		 9698 if (get_data (&data, file, offset + si * sizeof (vers_data),
9699 sizeof (data), 1, _("version data")) == NULL)
9700 break;
252b5132
RH		 9701
9702 vers_data = byte_get (data, 2);
9703
4fbb74a6
AM		 9704 is_nobits = (psym->st_shndx < elf_header.e_shnum
9705 && section_headers[psym->st_shndx].sh_type
c256ffe7 9706 == SHT_NOBITS);
252b5132
RH		 9707
9708 check_def = (psym->st_shndx != SHN_UNDEF);
9709
c244d050 9710 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9711 {
b34976b6 9712 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9713 && (is_nobits || ! check_def))
252b5132 9714 {
b34976b6
AM		 9715 Elf_External_Verneed evn;
9716 Elf_Internal_Verneed ivn;
9717 Elf_Internal_Vernaux ivna;
252b5132
RH		 9718
9719 /* We must test both. */
d93f0186
NC		 9720 offset = offset_from_vma
9721 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9722 sizeof evn);
252b5132 9723
252b5132
RH		 9724 do
9725 {
b34976b6 9726 unsigned long vna_off;
252b5132 9727
59245841
NC		 9728 if (get_data (&evn, file, offset, sizeof (evn), 1,
9729 _("version need")) == NULL)
9730 {
9731 ivna.vna_next = 0;
9732 ivna.vna_other = 0;
9733 ivna.vna_name = 0;
9734 break;
9735 }
dd27201e
L		 9736
9737 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9738 ivn.vn_next = BYTE_GET (evn.vn_next);
9739
252b5132
RH		 9740 vna_off = offset + ivn.vn_aux;
9741
9742 do
9743 {
b34976b6 9744 Elf_External_Vernaux evna;
252b5132 9745
59245841
NC		 9746 if (get_data (&evna, file, vna_off,
9747 sizeof (evna), 1,
9748 _("version need aux (3)")) == NULL)
9749 {
9750 ivna.vna_next = 0;
9751 ivna.vna_other = 0;
9752 ivna.vna_name = 0;
9753 }
9754 else
9755 {
9756 ivna.vna_other = BYTE_GET (evna.vna_other);
9757 ivna.vna_next = BYTE_GET (evna.vna_next);
9758 ivna.vna_name = BYTE_GET (evna.vna_name);
9759 }
252b5132
RH		 9760
9761 vna_off += ivna.vna_next;
9762 }
9763 while (ivna.vna_other != vers_data
9764 && ivna.vna_next != 0);
9765
9766 if (ivna.vna_other == vers_data)
9767 break;
9768
9769 offset += ivn.vn_next;
9770 }
9771 while (ivn.vn_next != 0);
9772
9773 if (ivna.vna_other == vers_data)
9774 {
9775 printf ("@%s (%d)",
c256ffe7 9776 ivna.vna_name < strtab_size
2b692964 9777 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9778 ivna.vna_other);
252b5132
RH		 9779 check_def = 0;
9780 }
9781 else if (! is_nobits)
591a748a 9782 error (_("bad dynamic symbol\n"));
252b5132
RH		 9783 else
9784 check_def = 1;
9785 }
9786
9787 if (check_def)
9788 {
00d93f34 9789 if (vers_data != 0x8001
b34976b6 9790 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9791 {
b34976b6
AM		 9792 Elf_Internal_Verdef ivd;
9793 Elf_Internal_Verdaux ivda;
9794 Elf_External_Verdaux evda;
91d6fa6a 9795 unsigned long off;
252b5132 9796
91d6fa6a 9797 off = offset_from_vma
d93f0186
NC		 9798 (file,
9799 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9800 sizeof (Elf_External_Verdef));
252b5132
RH		 9801
9802 do
9803 {
b34976b6 9804 Elf_External_Verdef evd;
252b5132 9805
59245841
NC		 9806 if (get_data (&evd, file, off, sizeof (evd),
9807 1, _("version def")) == NULL)
9808 {
9809 ivd.vd_ndx = 0;
9810 ivd.vd_aux = 0;
9811 ivd.vd_next = 0;
9812 }
9813 else
9814 {
9815 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9816 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9817 ivd.vd_next = BYTE_GET (evd.vd_next);
9818 }
252b5132 9819
91d6fa6a 9820 off += ivd.vd_next;
252b5132 9821 }
c244d050 9822 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9823 && ivd.vd_next != 0);
9824
91d6fa6a
NC		 9825 off -= ivd.vd_next;
9826 off += ivd.vd_aux;
252b5132 9827
59245841
NC		 9828 if (get_data (&evda, file, off, sizeof (evda),
9829 1, _("version def aux")) == NULL)
9830 break;
252b5132
RH		 9831
9832 ivda.vda_name = BYTE_GET (evda.vda_name);
9833
9834 if (psym->st_name != ivda.vda_name)
c244d050 9835 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9836 ? "@%s" : "@@%s",
c256ffe7 9837 ivda.vda_name < strtab_size
2b692964 9838 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9839 }
9840 }
9841 }
9842 }
9843
9844 putchar ('\n');
9845 }
9846
9847 free (symtab);
9848 if (strtab != string_table)
9849 free (strtab);
9850 }
9851 }
9852 else if (do_syms)
9853 printf
9854 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9855
9856 if (do_histogram && buckets != NULL)
9857 {
2cf0635d
NC		 9858 unsigned long * lengths;
9859 unsigned long * counts;
66543521
AM		 9860 unsigned long hn;
9861 bfd_vma si;
9862 unsigned long maxlength = 0;
9863 unsigned long nzero_counts = 0;
9864 unsigned long nsyms = 0;
252b5132 9865
66543521
AM		 9866 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9867 (unsigned long) nbuckets);
252b5132
RH		 9868 printf (_(" Length Number %% of total Coverage\n"));
9869
3f5e193b 9870 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9871 if (lengths == NULL)
9872 {
591a748a 9873 error (_("Out of memory\n"));
252b5132
RH		 9874 return 0;
9875 }
9876 for (hn = 0; hn < nbuckets; ++hn)
9877 {
f7a99963 9878 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9879 {
b34976b6 9880 ++nsyms;
252b5132 9881 if (maxlength < ++lengths[hn])
b34976b6 9882 ++maxlength;
252b5132
RH		 9883 }
9884 }
9885
3f5e193b 9886 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9887 if (counts == NULL)
9888 {
b2e951ec 9889 free (lengths);
591a748a 9890 error (_("Out of memory\n"));
252b5132
RH		 9891 return 0;
9892 }
9893
9894 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9895 ++counts[lengths[hn]];
252b5132 9896
103f02d3 9897 if (nbuckets > 0)
252b5132 9898 {
66543521
AM		 9899 unsigned long i;
9900 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9901 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9902 for (i = 1; i <= maxlength; ++i)
103f02d3 9903 {
66543521
AM		 9904 nzero_counts += counts[i] * i;
9905 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9906 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9907 (nzero_counts * 100.0) / nsyms);
9908 }
252b5132
RH		 9909 }
9910
9911 free (counts);
9912 free (lengths);
9913 }
9914
9915 if (buckets != NULL)
9916 {
9917 free (buckets);
9918 free (chains);
9919 }
9920
d3a44ec6 9921 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9922 {
2cf0635d
NC		 9923 unsigned long * lengths;
9924 unsigned long * counts;
fdc90cb4
JJ		 9925 unsigned long hn;
9926 unsigned long maxlength = 0;
9927 unsigned long nzero_counts = 0;
9928 unsigned long nsyms = 0;
fdc90cb4 9929
3f5e193b 9930 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9931 if (lengths == NULL)
9932 {
591a748a 9933 error (_("Out of memory\n"));
fdc90cb4
JJ		 9934 return 0;
9935 }
9936
9937 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9938 (unsigned long) ngnubuckets);
9939 printf (_(" Length Number %% of total Coverage\n"));
9940
9941 for (hn = 0; hn < ngnubuckets; ++hn)
9942 if (gnubuckets[hn] != 0)
9943 {
9944 bfd_vma off, length = 1;
9945
6bd1a22c 9946 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9947 (gnuchains[off] & 1) == 0; ++off)
9948 ++length;
9949 lengths[hn] = length;
9950 if (length > maxlength)
9951 maxlength = length;
9952 nsyms += length;
9953 }
9954
3f5e193b 9955 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9956 if (counts == NULL)
9957 {
b2e951ec 9958 free (lengths);
591a748a 9959 error (_("Out of memory\n"));
fdc90cb4
JJ		 9960 return 0;
9961 }
9962
9963 for (hn = 0; hn < ngnubuckets; ++hn)
9964 ++counts[lengths[hn]];
9965
9966 if (ngnubuckets > 0)
9967 {
9968 unsigned long j;
9969 printf (" 0 %-10lu (%5.1f%%)\n",
9970 counts[0], (counts[0] * 100.0) / ngnubuckets);
9971 for (j = 1; j <= maxlength; ++j)
9972 {
9973 nzero_counts += counts[j] * j;
9974 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9975 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9976 (nzero_counts * 100.0) / nsyms);
9977 }
9978 }
9979
9980 free (counts);
9981 free (lengths);
9982 free (gnubuckets);
9983 free (gnuchains);
9984 }
9985
252b5132
RH		 9986 return 1;
9987}
9988
9989static int
2cf0635d 9990process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9991{
b4c96d0d 9992 unsigned int i;
252b5132
RH		 9993
9994 if (dynamic_syminfo == NULL
9995 || !do_dynamic)
9996 /* No syminfo, this is ok. */
9997 return 1;
9998
9999 /* There better should be a dynamic symbol section. */
10000 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10001 return 0;
10002
10003 if (dynamic_addr)
10004 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10005 dynamic_syminfo_offset, dynamic_syminfo_nent);
10006
10007 printf (_(" Num: Name BoundTo Flags\n"));
10008 for (i = 0; i < dynamic_syminfo_nent; ++i)
10009 {
10010 unsigned short int flags = dynamic_syminfo[i].si_flags;
10011
31104126 10012 printf ("%4d: ", i);
d79b3d50
NC		 10013 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10014 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10015 else
2b692964 10016 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10017 putchar (' ');
252b5132
RH		 10018
10019 switch (dynamic_syminfo[i].si_boundto)
10020 {
10021 case SYMINFO_BT_SELF:
10022 fputs ("SELF ", stdout);
10023 break;
10024 case SYMINFO_BT_PARENT:
10025 fputs ("PARENT ", stdout);
10026 break;
10027 default:
10028 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10029 && dynamic_syminfo[i].si_boundto < dynamic_nent
10030 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10031 {
d79b3d50 10032 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10033 putchar (' ' );
10034 }
252b5132
RH		 10035 else
10036 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10037 break;
10038 }
10039
10040 if (flags & SYMINFO_FLG_DIRECT)
10041 printf (" DIRECT");
10042 if (flags & SYMINFO_FLG_PASSTHRU)
10043 printf (" PASSTHRU");
10044 if (flags & SYMINFO_FLG_COPY)
10045 printf (" COPY");
10046 if (flags & SYMINFO_FLG_LAZYLOAD)
10047 printf (" LAZYLOAD");
10048
10049 puts ("");
10050 }
10051
10052 return 1;
10053}
10054
cf13d699
NC		 10055/* Check to see if the given reloc needs to be handled in a target specific
10056 manner. If so then process the reloc and return TRUE otherwise return
10057 FALSE. */
09c11c86 10058
cf13d699
NC		 10059static bfd_boolean
10060target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10061 unsigned char * start,
10062 Elf_Internal_Sym * symtab)
252b5132 10063{
cf13d699 10064 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 10065
cf13d699 10066 switch (elf_header.e_machine)
252b5132 10067 {
13761a11
NC		 10068 case EM_MSP430:
10069 case EM_MSP430_OLD:
10070 {
10071 static Elf_Internal_Sym * saved_sym = NULL;
10072
10073 switch (reloc_type)
10074 {
10075 case 10: /* R_MSP430_SYM_DIFF */
10076 if (uses_msp430x_relocs ())
10077 break;
10078 case 21: /* R_MSP430X_SYM_DIFF */
10079 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10080 return TRUE;
10081
10082 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10083 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10084 goto handle_sym_diff;
0b4362b0 10085
13761a11
NC		 10086 case 5: /* R_MSP430_16_BYTE */
10087 case 9: /* R_MSP430_8 */
10088 if (uses_msp430x_relocs ())
10089 break;
10090 goto handle_sym_diff;
10091
10092 case 2: /* R_MSP430_ABS16 */
10093 case 15: /* R_MSP430X_ABS16 */
10094 if (! uses_msp430x_relocs ())
10095 break;
10096 goto handle_sym_diff;
0b4362b0 10097
13761a11
NC		 10098 handle_sym_diff:
10099 if (saved_sym != NULL)
10100 {
10101 bfd_vma value;
10102
10103 value = reloc->r_addend
10104 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10105 - saved_sym->st_value);
10106
10107 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10108
10109 saved_sym = NULL;
10110 return TRUE;
10111 }
10112 break;
10113
10114 default:
10115 if (saved_sym != NULL)
10116 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10117 break;
10118 }
10119 break;
10120 }
10121
cf13d699
NC		 10122 case EM_MN10300:
10123 case EM_CYGNUS_MN10300:
10124 {
10125 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 10126
cf13d699
NC		 10127 switch (reloc_type)
10128 {
10129 case 34: /* R_MN10300_ALIGN */
10130 return TRUE;
10131 case 33: /* R_MN10300_SYM_DIFF */
10132 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10133 return TRUE;
10134 case 1: /* R_MN10300_32 */
10135 case 2: /* R_MN10300_16 */
10136 if (saved_sym != NULL)
10137 {
10138 bfd_vma value;
252b5132 10139
cf13d699
NC		 10140 value = reloc->r_addend
10141 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10142 - saved_sym->st_value);
252b5132 10143
cf13d699 10144 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 10145
cf13d699
NC		 10146 saved_sym = NULL;
10147 return TRUE;
10148 }
10149 break;
10150 default:
10151 if (saved_sym != NULL)
10152 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10153 break;
10154 }
10155 break;
10156 }
252b5132
RH		 10157 }
10158
cf13d699 10159 return FALSE;
252b5132
RH		 10160}
10161
aca88567
NC		 10162/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10163 DWARF debug sections. This is a target specific test. Note - we do not
10164 go through the whole including-target-headers-multiple-times route, (as
10165 we have already done with <elf/h8.h>) because this would become very
10166 messy and even then this function would have to contain target specific
10167 information (the names of the relocs instead of their numeric values).
10168 FIXME: This is not the correct way to solve this problem. The proper way
10169 is to have target specific reloc sizing and typing functions created by
10170 the reloc-macros.h header, in the same way that it already creates the
10171 reloc naming functions. */
10172
10173static bfd_boolean
10174is_32bit_abs_reloc (unsigned int reloc_type)
10175{
10176 switch (elf_header.e_machine)
10177 {
41e92641
NC		 10178 case EM_386:
10179 case EM_486:
10180 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 10181 case EM_68K:
10182 return reloc_type == 1; /* R_68K_32. */
10183 case EM_860:
10184 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10185 case EM_960:
10186 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10187 case EM_AARCH64:
10188 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10189 case EM_ALPHA:
137b6b5f 10190 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10191 case EM_ARC:
10192 return reloc_type == 1; /* R_ARC_32. */
10193 case EM_ARM:
10194 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10195 case EM_AVR_OLD:
aca88567
NC		 10196 case EM_AVR:
10197 return reloc_type == 1;
cfb8c092
NC		 10198 case EM_ADAPTEVA_EPIPHANY:
10199 return reloc_type == 3;
aca88567
NC		 10200 case EM_BLACKFIN:
10201 return reloc_type == 0x12; /* R_byte4_data. */
10202 case EM_CRIS:
10203 return reloc_type == 3; /* R_CRIS_32. */
10204 case EM_CR16:
10205 return reloc_type == 3; /* R_CR16_NUM32. */
10206 case EM_CRX:
10207 return reloc_type == 15; /* R_CRX_NUM32. */
10208 case EM_CYGNUS_FRV:
10209 return reloc_type == 1;
41e92641
NC		 10210 case EM_CYGNUS_D10V:
10211 case EM_D10V:
10212 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10213 case EM_CYGNUS_D30V:
10214 case EM_D30V:
10215 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10216 case EM_DLX:
10217 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10218 case EM_CYGNUS_FR30:
10219 case EM_FR30:
10220 return reloc_type == 3; /* R_FR30_32. */
10221 case EM_H8S:
10222 case EM_H8_300:
10223 case EM_H8_300H:
10224 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10225 case EM_IA_64:
10226 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10227 case EM_IP2K_OLD:
10228 case EM_IP2K:
10229 return reloc_type == 2; /* R_IP2K_32. */
10230 case EM_IQ2000:
10231 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10232 case EM_LATTICEMICO32:
10233 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10234 case EM_M32C_OLD:
aca88567
NC		 10235 case EM_M32C:
10236 return reloc_type == 3; /* R_M32C_32. */
10237 case EM_M32R:
10238 return reloc_type == 34; /* R_M32R_32_RELA. */
10239 case EM_MCORE:
10240 return reloc_type == 1; /* R_MCORE_ADDR32. */
10241 case EM_CYGNUS_MEP:
10242 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10243 case EM_METAG:
10244 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10245 case EM_MICROBLAZE:
10246 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10247 case EM_MIPS:
10248 return reloc_type == 2; /* R_MIPS_32. */
10249 case EM_MMIX:
10250 return reloc_type == 4; /* R_MMIX_32. */
10251 case EM_CYGNUS_MN10200:
10252 case EM_MN10200:
10253 return reloc_type == 1; /* R_MN10200_32. */
10254 case EM_CYGNUS_MN10300:
10255 case EM_MN10300:
10256 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10257 case EM_MOXIE:
10258 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10259 case EM_MSP430_OLD:
10260 case EM_MSP430:
13761a11 10261 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 10262 case EM_MT:
10263 return reloc_type == 2; /* R_MT_32. */
3e0873ac 10264 case EM_ALTERA_NIOS2:
36591ba1 10265 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 10266 case EM_NIOS32:
10267 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 10268 case EM_OPENRISC:
10269 case EM_OR32:
10270 return reloc_type == 1; /* R_OR32_32. */
aca88567 10271 case EM_PARISC:
5fda8eca
NC		 10272 return (reloc_type == 1 /* R_PARISC_DIR32. */
10273 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10274 case EM_PJ:
10275 case EM_PJ_OLD:
10276 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10277 case EM_PPC64:
10278 return reloc_type == 1; /* R_PPC64_ADDR32. */
10279 case EM_PPC:
10280 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10281 case EM_RL78:
10282 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10283 case EM_RX:
10284 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10285 case EM_S370:
10286 return reloc_type == 1; /* R_I370_ADDR31. */
10287 case EM_S390_OLD:
10288 case EM_S390:
10289 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10290 case EM_SCORE:
10291 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10292 case EM_SH:
10293 return reloc_type == 1; /* R_SH_DIR32. */
10294 case EM_SPARC32PLUS:
10295 case EM_SPARCV9:
10296 case EM_SPARC:
10297 return reloc_type == 3 /* R_SPARC_32. */
10298 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10299 case EM_SPU:
10300 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10301 case EM_TI_C6000:
10302 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10303 case EM_TILEGX:
10304 return reloc_type == 2; /* R_TILEGX_32. */
10305 case EM_TILEPRO:
10306 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10307 case EM_CYGNUS_V850:
10308 case EM_V850:
10309 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10310 case EM_V800:
10311 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10312 case EM_VAX:
10313 return reloc_type == 1; /* R_VAX_32. */
10314 case EM_X86_64:
8a9036a4 10315 case EM_L1OM:
7a9068fe 10316 case EM_K1OM:
aca88567 10317 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10318 case EM_XC16X:
10319 case EM_C166:
10320 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10321 case EM_XGATE:
10322 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10323 case EM_XSTORMY16:
10324 return reloc_type == 1; /* R_XSTROMY16_32. */
10325 case EM_XTENSA_OLD:
10326 case EM_XTENSA:
10327 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10328 default:
10329 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10330 elf_header.e_machine);
10331 abort ();
10332 }
10333}
10334
10335/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10336 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10337
10338static bfd_boolean
10339is_32bit_pcrel_reloc (unsigned int reloc_type)
10340{
10341 switch (elf_header.e_machine)
10342 {
41e92641
NC		 10343 case EM_386:
10344 case EM_486:
3e0873ac 10345 return reloc_type == 2; /* R_386_PC32. */
aca88567 10346 case EM_68K:
3e0873ac 10347 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10348 case EM_AARCH64:
10349 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10350 case EM_ADAPTEVA_EPIPHANY:
10351 return reloc_type == 6;
aca88567
NC		 10352 case EM_ALPHA:
10353 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10354 case EM_ARM:
3e0873ac 10355 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10356 case EM_MICROBLAZE:
10357 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 10358 case EM_PARISC:
85acf597 10359 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10360 case EM_PPC:
10361 return reloc_type == 26; /* R_PPC_REL32. */
10362 case EM_PPC64:
3e0873ac 10363 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10364 case EM_S390_OLD:
10365 case EM_S390:
3e0873ac 10366 return reloc_type == 5; /* R_390_PC32. */
aca88567 10367 case EM_SH:
3e0873ac 10368 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10369 case EM_SPARC32PLUS:
10370 case EM_SPARCV9:
10371 case EM_SPARC:
3e0873ac 10372 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10373 case EM_SPU:
10374 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10375 case EM_TILEGX:
10376 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10377 case EM_TILEPRO:
10378 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10379 case EM_X86_64:
8a9036a4 10380 case EM_L1OM:
7a9068fe 10381 case EM_K1OM:
3e0873ac 10382 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10383 case EM_XTENSA_OLD:
10384 case EM_XTENSA:
10385 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10386 default:
10387 /* Do not abort or issue an error message here. Not all targets use
10388 pc-relative 32-bit relocs in their DWARF debug information and we
10389 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10390 more helpful warning message will be generated by apply_relocations
10391 anyway, so just return. */
aca88567
NC		 10392 return FALSE;
10393 }
10394}
10395
10396/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10397 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10398
10399static bfd_boolean
10400is_64bit_abs_reloc (unsigned int reloc_type)
10401{
10402 switch (elf_header.e_machine)
10403 {
a06ea964
NC		 10404 case EM_AARCH64:
10405 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10406 case EM_ALPHA:
10407 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10408 case EM_IA_64:
10409 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10410 case EM_PARISC:
10411 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10412 case EM_PPC64:
10413 return reloc_type == 38; /* R_PPC64_ADDR64. */
10414 case EM_SPARC32PLUS:
10415 case EM_SPARCV9:
10416 case EM_SPARC:
10417 return reloc_type == 54; /* R_SPARC_UA64. */
10418 case EM_X86_64:
8a9036a4 10419 case EM_L1OM:
7a9068fe 10420 case EM_K1OM:
aca88567 10421 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10422 case EM_S390_OLD:
10423 case EM_S390:
aa137e4d
NC		 10424 return reloc_type == 22; /* R_S390_64. */
10425 case EM_TILEGX:
10426 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10427 case EM_MIPS:
aa137e4d 10428 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10429 default:
10430 return FALSE;
10431 }
10432}
10433
85acf597
RH		 10434/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10435 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10436
10437static bfd_boolean
10438is_64bit_pcrel_reloc (unsigned int reloc_type)
10439{
10440 switch (elf_header.e_machine)
10441 {
a06ea964
NC		 10442 case EM_AARCH64:
10443 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10444 case EM_ALPHA:
aa137e4d 10445 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10446 case EM_IA_64:
aa137e4d 10447 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10448 case EM_PARISC:
aa137e4d 10449 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10450 case EM_PPC64:
aa137e4d 10451 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10452 case EM_SPARC32PLUS:
10453 case EM_SPARCV9:
10454 case EM_SPARC:
aa137e4d 10455 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10456 case EM_X86_64:
8a9036a4 10457 case EM_L1OM:
7a9068fe 10458 case EM_K1OM:
aa137e4d 10459 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10460 case EM_S390_OLD:
10461 case EM_S390:
aa137e4d
NC		 10462 return reloc_type == 23; /* R_S390_PC64. */
10463 case EM_TILEGX:
10464 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10465 default:
10466 return FALSE;
10467 }
10468}
10469
4dc3c23d
AM		 10470/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10471 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10472
10473static bfd_boolean
10474is_24bit_abs_reloc (unsigned int reloc_type)
10475{
10476 switch (elf_header.e_machine)
10477 {
10478 case EM_CYGNUS_MN10200:
10479 case EM_MN10200:
10480 return reloc_type == 4; /* R_MN10200_24. */
10481 default:
10482 return FALSE;
10483 }
10484}
10485
aca88567
NC		 10486/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10487 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10488
10489static bfd_boolean
10490is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10491{
10492 switch (elf_header.e_machine)
10493 {
aca88567
NC		 10494 case EM_AVR_OLD:
10495 case EM_AVR:
10496 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10497 case EM_ADAPTEVA_EPIPHANY:
10498 return reloc_type == 5;
41e92641
NC		 10499 case EM_CYGNUS_D10V:
10500 case EM_D10V:
10501 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10502 case EM_H8S:
10503 case EM_H8_300:
10504 case EM_H8_300H:
aca88567
NC		 10505 return reloc_type == R_H8_DIR16;
10506 case EM_IP2K_OLD:
10507 case EM_IP2K:
10508 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10509 case EM_M32C_OLD:
f4236fe4
DD		 10510 case EM_M32C:
10511 return reloc_type == 1; /* R_M32C_16 */
aca88567 10512 case EM_MSP430:
13761a11
NC		 10513 if (uses_msp430x_relocs ())
10514 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 10515 case EM_MSP430_OLD:
aca88567 10516 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac 10517 case EM_ALTERA_NIOS2:
36591ba1 10518 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 10519 case EM_NIOS32:
10520 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10521 case EM_TI_C6000:
10522 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10523 case EM_XC16X:
10524 case EM_C166:
10525 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10526 case EM_CYGNUS_MN10200:
10527 case EM_MN10200:
10528 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10529 case EM_CYGNUS_MN10300:
10530 case EM_MN10300:
10531 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10532 case EM_XGATE:
10533 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10534 default:
aca88567 10535 return FALSE;
4b78141a
NC		 10536 }
10537}
10538
2a7b2e88
JK		 10539/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10540 relocation entries (possibly formerly used for SHT_GROUP sections). */
10541
10542static bfd_boolean
10543is_none_reloc (unsigned int reloc_type)
10544{
10545 switch (elf_header.e_machine)
10546 {
cb8f3167
NC		 10547 case EM_68K: /* R_68K_NONE. */
10548 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10549 case EM_SPARC32PLUS:
10550 case EM_SPARCV9:
cb8f3167
NC		 10551 case EM_SPARC: /* R_SPARC_NONE. */
10552 case EM_MIPS: /* R_MIPS_NONE. */
10553 case EM_PARISC: /* R_PARISC_NONE. */
10554 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10555 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10556 case EM_PPC: /* R_PPC_NONE. */
10557 case EM_PPC64: /* R_PPC64_NONE. */
10558 case EM_ARM: /* R_ARM_NONE. */
10559 case EM_IA_64: /* R_IA64_NONE. */
10560 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10561 case EM_S390_OLD:
cb8f3167
NC		 10562 case EM_S390: /* R_390_NONE. */
10563 case EM_CRIS: /* R_CRIS_NONE. */
10564 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10565 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10566 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10567 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10568 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10569 case EM_M32R: /* R_M32R_NONE. */
40b36596 10570 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10571 case EM_TILEGX: /* R_TILEGX_NONE. */
10572 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10573 case EM_XC16X:
10574 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 10575 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
10576 case EM_NIOS32: /* R_NIOS_NONE. */
cb8f3167 10577 return reloc_type == 0;
a06ea964
NC		 10578 case EM_AARCH64:
10579 return reloc_type == 0 || reloc_type == 256;
58332dda
JK		 10580 case EM_XTENSA_OLD:
10581 case EM_XTENSA:
4dc3c23d
AM		 10582 return (reloc_type == 0 /* R_XTENSA_NONE. */
10583 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10584 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10585 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 10586 case EM_METAG:
10587 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 10588 }
10589 return FALSE;
10590}
10591
cf13d699
NC		 10592/* Apply relocations to a section.
10593 Note: So far support has been added only for those relocations
10594 which can be found in debug sections.
10595 FIXME: Add support for more relocations ? */
1b315056 10596
cf13d699
NC		 10597static void
10598apply_relocations (void * file,
10599 Elf_Internal_Shdr * section,
10600 unsigned char * start)
1b315056 10601{
cf13d699
NC		 10602 Elf_Internal_Shdr * relsec;
10603 unsigned char * end = start + section->sh_size;
cb8f3167 10604
cf13d699
NC		 10605 if (elf_header.e_type != ET_REL)
10606 return;
1b315056 10607
cf13d699 10608 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10609 for (relsec = section_headers;
10610 relsec < section_headers + elf_header.e_shnum;
10611 ++relsec)
252b5132 10612 {
41e92641
NC		 10613 bfd_boolean is_rela;
10614 unsigned long num_relocs;
2cf0635d
NC		 10615 Elf_Internal_Rela * relocs;
10616 Elf_Internal_Rela * rp;
10617 Elf_Internal_Shdr * symsec;
10618 Elf_Internal_Sym * symtab;
ba5cdace 10619 unsigned long num_syms;
2cf0635d 10620 Elf_Internal_Sym * sym;
252b5132 10621
41e92641 10622 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10623 || relsec->sh_info >= elf_header.e_shnum
10624 || section_headers + relsec->sh_info != section
c256ffe7 10625 || relsec->sh_size == 0
4fbb74a6 10626 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10627 continue;
428409d5 10628
41e92641
NC		 10629 is_rela = relsec->sh_type == SHT_RELA;
10630
10631 if (is_rela)
10632 {
3f5e193b
NC		 10633 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10634 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10635 return;
10636 }
10637 else
10638 {
3f5e193b
NC		 10639 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10640 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10641 return;
10642 }
10643
10644 /* SH uses RELA but uses in place value instead of the addend field. */
10645 if (elf_header.e_machine == EM_SH)
10646 is_rela = FALSE;
428409d5 10647
4fbb74a6 10648 symsec = section_headers + relsec->sh_link;
ba5cdace 10649 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10650
41e92641 10651 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10652 {
41e92641
NC		 10653 bfd_vma addend;
10654 unsigned int reloc_type;
10655 unsigned int reloc_size;
91d6fa6a 10656 unsigned char * rloc;
ba5cdace 10657 unsigned long sym_index;
4b78141a 10658
aca88567 10659 reloc_type = get_reloc_type (rp->r_info);
41e92641 10660
98fb390a 10661 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10662 continue;
98fb390a
NC		 10663 else if (is_none_reloc (reloc_type))
10664 continue;
10665 else if (is_32bit_abs_reloc (reloc_type)
10666 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10667 reloc_size = 4;
85acf597
RH		 10668 else if (is_64bit_abs_reloc (reloc_type)
10669 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10670 reloc_size = 8;
4dc3c23d
AM		 10671 else if (is_24bit_abs_reloc (reloc_type))
10672 reloc_size = 3;
aca88567
NC		 10673 else if (is_16bit_abs_reloc (reloc_type))
10674 reloc_size = 2;
10675 else
4b78141a 10676 {
41e92641 10677 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10678 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10679 continue;
10680 }
103f02d3 10681
91d6fa6a 10682 rloc = start + rp->r_offset;
c8da6823 10683 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 10684 {
10685 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10686 (unsigned long) rp->r_offset,
10687 SECTION_NAME (section));
10688 continue;
10689 }
103f02d3 10690
ba5cdace
NC		 10691 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10692 if (sym_index >= num_syms)
10693 {
10694 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10695 sym_index, SECTION_NAME (section));
10696 continue;
10697 }
10698 sym = symtab + sym_index;
41e92641
NC		 10699
10700 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10701 make sure that it is of an appropriate type.
10702
10703 Relocations against symbols without type can happen.
10704 Gcc -feliminate-dwarf2-dups may generate symbols
10705 without type for debug info.
10706
10707 Icc generates relocations against function symbols
10708 instead of local labels.
10709
10710 Relocations against object symbols can happen, eg when
10711 referencing a global array. For an example of this see
10712 the _clz.o binary in libgcc.a. */
aca88567 10713 if (sym != symtab
55f25fc3 10714 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10715 {
41e92641 10716 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10717 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10718 (long int)(rp - relocs),
41e92641 10719 SECTION_NAME (relsec));
aca88567 10720 continue;
5b18a4bc 10721 }
252b5132 10722
4dc3c23d
AM		 10723 addend = 0;
10724 if (is_rela)
10725 addend += rp->r_addend;
c47320c3
AM		 10726 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10727 partial_inplace. */
4dc3c23d
AM		 10728 if (!is_rela
10729 || (elf_header.e_machine == EM_XTENSA
10730 && reloc_type == 1)
10731 || ((elf_header.e_machine == EM_PJ
10732 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10733 && reloc_type == 1)
10734 || ((elf_header.e_machine == EM_D30V
10735 || elf_header.e_machine == EM_CYGNUS_D30V)
10736 && reloc_type == 12))
91d6fa6a 10737 addend += byte_get (rloc, reloc_size);
cb8f3167 10738
85acf597
RH		 10739 if (is_32bit_pcrel_reloc (reloc_type)
10740 || is_64bit_pcrel_reloc (reloc_type))
10741 {
10742 /* On HPPA, all pc-relative relocations are biased by 8. */
10743 if (elf_header.e_machine == EM_PARISC)
10744 addend -= 8;
91d6fa6a 10745 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10746 reloc_size);
10747 }
41e92641 10748 else
91d6fa6a 10749 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10750 }
252b5132 10751
5b18a4bc 10752 free (symtab);
41e92641 10753 free (relocs);
5b18a4bc
NC		 10754 break;
10755 }
5b18a4bc 10756}
103f02d3 10757
cf13d699
NC		 10758#ifdef SUPPORT_DISASSEMBLY
10759static int
10760disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10761{
10762 printf (_("\nAssembly dump of section %s\n"),
10763 SECTION_NAME (section));
10764
10765 /* XXX -- to be done --- XXX */
10766
10767 return 1;
10768}
10769#endif
10770
10771/* Reads in the contents of SECTION from FILE, returning a pointer
10772 to a malloc'ed buffer or NULL if something went wrong. */
10773
10774static char *
10775get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10776{
10777 bfd_size_type num_bytes;
10778
10779 num_bytes = section->sh_size;
10780
10781 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10782 {
10783 printf (_("\nSection '%s' has no data to dump.\n"),
10784 SECTION_NAME (section));
10785 return NULL;
10786 }
10787
3f5e193b
NC		 10788 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10789 _("section contents"));
cf13d699
NC		 10790}
10791
dd24e3da 10792
cf13d699
NC		 10793static void
10794dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10795{
10796 Elf_Internal_Shdr * relsec;
10797 bfd_size_type num_bytes;
cf13d699
NC		 10798 char * data;
10799 char * end;
10800 char * start;
10801 char * name = SECTION_NAME (section);
10802 bfd_boolean some_strings_shown;
10803
10804 start = get_section_contents (section, file);
10805 if (start == NULL)
10806 return;
10807
10808 printf (_("\nString dump of section '%s':\n"), name);
10809
10810 /* If the section being dumped has relocations against it the user might
10811 be expecting these relocations to have been applied. Check for this
10812 case and issue a warning message in order to avoid confusion.
10813 FIXME: Maybe we ought to have an option that dumps a section with
10814 relocs applied ? */
10815 for (relsec = section_headers;
10816 relsec < section_headers + elf_header.e_shnum;
10817 ++relsec)
10818 {
10819 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10820 || relsec->sh_info >= elf_header.e_shnum
10821 || section_headers + relsec->sh_info != section
10822 || relsec->sh_size == 0
10823 || relsec->sh_link >= elf_header.e_shnum)
10824 continue;
10825
10826 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10827 break;
10828 }
10829
10830 num_bytes = section->sh_size;
cf13d699
NC		 10831 data = start;
10832 end = start + num_bytes;
10833 some_strings_shown = FALSE;
10834
10835 while (data < end)
10836 {
10837 while (!ISPRINT (* data))
10838 if (++ data >= end)
10839 break;
10840
10841 if (data < end)
10842 {
10843#ifndef __MSVCRT__
c975cc98
NC		 10844 /* PR 11128: Use two separate invocations in order to work
10845 around bugs in the Solaris 8 implementation of printf. */
10846 printf (" [%6tx] ", data - start);
10847 printf ("%s\n", data);
cf13d699
NC		 10848#else
10849 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10850#endif
10851 data += strlen (data);
10852 some_strings_shown = TRUE;
10853 }
10854 }
10855
10856 if (! some_strings_shown)
10857 printf (_(" No strings found in this section."));
10858
10859 free (start);
10860
10861 putchar ('\n');
10862}
10863
10864static void
10865dump_section_as_bytes (Elf_Internal_Shdr * section,
10866 FILE * file,
10867 bfd_boolean relocate)
10868{
10869 Elf_Internal_Shdr * relsec;
10870 bfd_size_type bytes;
10871 bfd_vma addr;
10872 unsigned char * data;
10873 unsigned char * start;
10874
10875 start = (unsigned char *) get_section_contents (section, file);
10876 if (start == NULL)
10877 return;
10878
10879 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10880
10881 if (relocate)
10882 {
10883 apply_relocations (file, section, start);
10884 }
10885 else
10886 {
10887 /* If the section being dumped has relocations against it the user might
10888 be expecting these relocations to have been applied. Check for this
10889 case and issue a warning message in order to avoid confusion.
10890 FIXME: Maybe we ought to have an option that dumps a section with
10891 relocs applied ? */
10892 for (relsec = section_headers;
10893 relsec < section_headers + elf_header.e_shnum;
10894 ++relsec)
10895 {
10896 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10897 || relsec->sh_info >= elf_header.e_shnum
10898 || section_headers + relsec->sh_info != section
10899 || relsec->sh_size == 0
10900 || relsec->sh_link >= elf_header.e_shnum)
10901 continue;
10902
10903 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10904 break;
10905 }
10906 }
10907
10908 addr = section->sh_addr;
10909 bytes = section->sh_size;
10910 data = start;
10911
10912 while (bytes)
10913 {
10914 int j;
10915 int k;
10916 int lbytes;
10917
10918 lbytes = (bytes > 16 ? 16 : bytes);
10919
10920 printf (" 0x%8.8lx ", (unsigned long) addr);
10921
10922 for (j = 0; j < 16; j++)
10923 {
10924 if (j < lbytes)
10925 printf ("%2.2x", data[j]);
10926 else
10927 printf (" ");
10928
10929 if ((j & 3) == 3)
10930 printf (" ");
10931 }
10932
10933 for (j = 0; j < lbytes; j++)
10934 {
10935 k = data[j];
10936 if (k >= ' ' && k < 0x7f)
10937 printf ("%c", k);
10938 else
10939 printf (".");
10940 }
10941
10942 putchar ('\n');
10943
10944 data += lbytes;
10945 addr += lbytes;
10946 bytes -= lbytes;
10947 }
10948
10949 free (start);
10950
10951 putchar ('\n');
10952}
10953
4a114e3e 10954/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10955
10956static int
d3dbc530
AM		 10957uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10958 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10959{
10960#ifndef HAVE_ZLIB_H
cf13d699
NC		 10961 return FALSE;
10962#else
10963 dwarf_size_type compressed_size = *size;
10964 unsigned char * compressed_buffer = *buffer;
10965 dwarf_size_type uncompressed_size;
10966 unsigned char * uncompressed_buffer;
10967 z_stream strm;
10968 int rc;
10969 dwarf_size_type header_size = 12;
10970
10971 /* Read the zlib header. In this case, it should be "ZLIB" followed
10972 by the uncompressed section size, 8 bytes in big-endian order. */
10973 if (compressed_size < header_size
10974 || ! streq ((char *) compressed_buffer, "ZLIB"))
10975 return 0;
10976
10977 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10978 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10979 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10980 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10981 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10982 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10983 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10984 uncompressed_size += compressed_buffer[11];
10985
10986 /* It is possible the section consists of several compressed
10987 buffers concatenated together, so we uncompress in a loop. */
10988 strm.zalloc = NULL;
10989 strm.zfree = NULL;
10990 strm.opaque = NULL;
10991 strm.avail_in = compressed_size - header_size;
10992 strm.next_in = (Bytef *) compressed_buffer + header_size;
10993 strm.avail_out = uncompressed_size;
3f5e193b 10994 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10995
10996 rc = inflateInit (& strm);
10997 while (strm.avail_in > 0)
10998 {
10999 if (rc != Z_OK)
11000 goto fail;
11001 strm.next_out = ((Bytef *) uncompressed_buffer
11002 + (uncompressed_size - strm.avail_out));
11003 rc = inflate (&strm, Z_FINISH);
11004 if (rc != Z_STREAM_END)
11005 goto fail;
11006 rc = inflateReset (& strm);
11007 }
11008 rc = inflateEnd (& strm);
11009 if (rc != Z_OK
11010 || strm.avail_out != 0)
11011 goto fail;
11012
11013 free (compressed_buffer);
11014 *buffer = uncompressed_buffer;
11015 *size = uncompressed_size;
11016 return 1;
11017
11018 fail:
11019 free (uncompressed_buffer);
4a114e3e
L		 11020 /* Indicate decompression failure. */
11021 *buffer = NULL;
cf13d699
NC		 11022 return 0;
11023#endif /* HAVE_ZLIB_H */
11024}
11025
d966045b
DJ		 11026static int
11027load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 11028 Elf_Internal_Shdr * sec, void * file)
1007acb3 11029{
2cf0635d 11030 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 11031 char buf [64];
1007acb3 11032
19e6b90e
L		 11033 /* If it is already loaded, do nothing. */
11034 if (section->start != NULL)
11035 return 1;
1007acb3 11036
19e6b90e
L		 11037 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11038 section->address = sec->sh_addr;
3f5e193b
NC		 11039 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11040 sec->sh_offset, 1,
11041 sec->sh_size, buf);
59245841
NC		 11042 if (section->start == NULL)
11043 section->size = 0;
11044 else
11045 {
11046 section->size = sec->sh_size;
11047 if (uncompress_section_contents (&section->start, &section->size))
11048 sec->sh_size = section->size;
11049 }
4a114e3e 11050
1b315056
CS		 11051 if (section->start == NULL)
11052 return 0;
11053
19e6b90e 11054 if (debug_displays [debug].relocate)
3f5e193b 11055 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11056
1b315056 11057 return 1;
1007acb3
L		 11058}
11059
657d0d47
CC		 11060/* If this is not NULL, load_debug_section will only look for sections
11061 within the list of sections given here. */
11062unsigned int *section_subset = NULL;
11063
d966045b 11064int
2cf0635d 11065load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11066{
2cf0635d
NC		 11067 struct dwarf_section * section = &debug_displays [debug].section;
11068 Elf_Internal_Shdr * sec;
d966045b
DJ		 11069
11070 /* Locate the debug section. */
657d0d47 11071 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 11072 if (sec != NULL)
11073 section->name = section->uncompressed_name;
11074 else
11075 {
657d0d47 11076 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 11077 if (sec != NULL)
11078 section->name = section->compressed_name;
11079 }
11080 if (sec == NULL)
11081 return 0;
11082
657d0d47
CC		 11083 /* If we're loading from a subset of sections, and we've loaded
11084 a section matching this name before, it's likely that it's a
11085 different one. */
11086 if (section_subset != NULL)
11087 free_debug_section (debug);
11088
3f5e193b 11089 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 11090}
11091
19e6b90e
L		 11092void
11093free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 11094{
2cf0635d 11095 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 11096
19e6b90e
L		 11097 if (section->start == NULL)
11098 return;
1007acb3 11099
19e6b90e
L		 11100 free ((char *) section->start);
11101 section->start = NULL;
11102 section->address = 0;
11103 section->size = 0;
1007acb3
L		 11104}
11105
1007acb3 11106static int
657d0d47 11107display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 11108{
2cf0635d 11109 char * name = SECTION_NAME (section);
19e6b90e
L		 11110 bfd_size_type length;
11111 int result = 1;
3f5e193b 11112 int i;
1007acb3 11113
19e6b90e
L		 11114 length = section->sh_size;
11115 if (length == 0)
1007acb3 11116 {
19e6b90e
L		 11117 printf (_("\nSection '%s' has no debugging data.\n"), name);
11118 return 0;
1007acb3 11119 }
5dff79d8
NC		 11120 if (section->sh_type == SHT_NOBITS)
11121 {
11122 /* There is no point in dumping the contents of a debugging section
11123 which has the NOBITS type - the bits in the file will be random.
11124 This can happen when a file containing a .eh_frame section is
11125 stripped with the --only-keep-debug command line option. */
11126 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11127 return 0;
11128 }
1007acb3 11129
0112cd26 11130 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 11131 name = ".debug_info";
1007acb3 11132
19e6b90e
L		 11133 /* See if we know how to display the contents of this section. */
11134 for (i = 0; i < max; i++)
1b315056 11135 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 11136 || (i == line && const_strneq (name, ".debug_line."))
1b315056 11137 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 11138 {
2cf0635d 11139 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 11140 int secondary = (section != find_section (name));
11141
11142 if (secondary)
3f5e193b 11143 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 11144
b40bf0a2
NC		 11145 if (i == line && const_strneq (name, ".debug_line."))
11146 sec->name = name;
11147 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 11148 sec->name = sec->uncompressed_name;
11149 else
11150 sec->name = sec->compressed_name;
3f5e193b
NC		 11151 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11152 section, file))
19e6b90e 11153 {
657d0d47
CC		 11154 /* If this debug section is part of a CU/TU set in a .dwp file,
11155 restrict load_debug_section to the sections in that set. */
11156 section_subset = find_cu_tu_set (file, shndx);
11157
19e6b90e 11158 result &= debug_displays[i].display (sec, file);
1007acb3 11159
657d0d47
CC		 11160 section_subset = NULL;
11161
d966045b 11162 if (secondary || (i != info && i != abbrev))
3f5e193b 11163 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 11164 }
1007acb3 11165
19e6b90e
L		 11166 break;
11167 }
1007acb3 11168
19e6b90e 11169 if (i == max)
1007acb3 11170 {
19e6b90e
L		 11171 printf (_("Unrecognized debug section: %s\n"), name);
11172 result = 0;
1007acb3
L		 11173 }
11174
19e6b90e 11175 return result;
5b18a4bc 11176}
103f02d3 11177
aef1f6d0
DJ		 11178/* Set DUMP_SECTS for all sections where dumps were requested
11179 based on section name. */
11180
11181static void
11182initialise_dumps_byname (void)
11183{
2cf0635d 11184 struct dump_list_entry * cur;
aef1f6d0
DJ		 11185
11186 for (cur = dump_sects_byname; cur; cur = cur->next)
11187 {
11188 unsigned int i;
11189 int any;
11190
11191 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11192 if (streq (SECTION_NAME (section_headers + i), cur->name))
11193 {
09c11c86 11194 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11195 any = 1;
11196 }
11197
11198 if (!any)
11199 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11200 cur->name);
11201 }
11202}
11203
5b18a4bc 11204static void
2cf0635d 11205process_section_contents (FILE * file)
5b18a4bc 11206{
2cf0635d 11207 Elf_Internal_Shdr * section;
19e6b90e 11208 unsigned int i;
103f02d3 11209
19e6b90e
L		 11210 if (! do_dump)
11211 return;
103f02d3 11212
aef1f6d0
DJ		 11213 initialise_dumps_byname ();
11214
19e6b90e
L		 11215 for (i = 0, section = section_headers;
11216 i < elf_header.e_shnum && i < num_dump_sects;
11217 i++, section++)
11218 {
11219#ifdef SUPPORT_DISASSEMBLY
11220 if (dump_sects[i] & DISASS_DUMP)
11221 disassemble_section (section, file);
11222#endif
11223 if (dump_sects[i] & HEX_DUMP)
cf13d699 11224 dump_section_as_bytes (section, file, FALSE);
103f02d3 11225
cf13d699
NC		 11226 if (dump_sects[i] & RELOC_DUMP)
11227 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11228
11229 if (dump_sects[i] & STRING_DUMP)
11230 dump_section_as_strings (section, file);
cf13d699
NC		 11231
11232 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11233 display_debug_section (i, section, file);
5b18a4bc 11234 }
103f02d3 11235
19e6b90e
L		 11236 /* Check to see if the user requested a
11237 dump of a section that does not exist. */
11238 while (i++ < num_dump_sects)
11239 if (dump_sects[i])
11240 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11241}
103f02d3 11242
5b18a4bc 11243static void
19e6b90e 11244process_mips_fpe_exception (int mask)
5b18a4bc 11245{
19e6b90e
L		 11246 if (mask)
11247 {
11248 int first = 1;
11249 if (mask & OEX_FPU_INEX)
11250 fputs ("INEX", stdout), first = 0;
11251 if (mask & OEX_FPU_UFLO)
11252 printf ("%sUFLO", first ? "" : "|"), first = 0;
11253 if (mask & OEX_FPU_OFLO)
11254 printf ("%sOFLO", first ? "" : "|"), first = 0;
11255 if (mask & OEX_FPU_DIV0)
11256 printf ("%sDIV0", first ? "" : "|"), first = 0;
11257 if (mask & OEX_FPU_INVAL)
11258 printf ("%sINVAL", first ? "" : "|");
11259 }
5b18a4bc 11260 else
19e6b90e 11261 fputs ("0", stdout);
5b18a4bc 11262}
103f02d3 11263
f6f0e17b
NC		 11264/* Display's the value of TAG at location P. If TAG is
11265 greater than 0 it is assumed to be an unknown tag, and
11266 a message is printed to this effect. Otherwise it is
11267 assumed that a message has already been printed.
11268
11269 If the bottom bit of TAG is set it assumed to have a
11270 string value, otherwise it is assumed to have an integer
11271 value.
11272
11273 Returns an updated P pointing to the first unread byte
11274 beyond the end of TAG's value.
11275
11276 Reads at or beyond END will not be made. */
11277
11278static unsigned char *
11279display_tag_value (int tag,
11280 unsigned char * p,
11281 const unsigned char * const end)
11282{
11283 unsigned long val;
11284
11285 if (tag > 0)
11286 printf (" Tag_unknown_%d: ", tag);
11287
11288 if (p >= end)
11289 {
11290 warn (_("corrupt tag\n"));
11291 }
11292 else if (tag & 1)
11293 {
11294 /* FIXME: we could read beyond END here. */
11295 printf ("\"%s\"\n", p);
11296 p += strlen ((char *) p) + 1;
11297 }
11298 else
11299 {
11300 unsigned int len;
11301
11302 val = read_uleb128 (p, &len, end);
11303 p += len;
11304 printf ("%ld (0x%lx)\n", val, val);
11305 }
11306
11307 return p;
11308}
11309
11c1ff18
PB		 11310/* ARM EABI attributes section. */
11311typedef struct
11312{
11313 int tag;
2cf0635d 11314 const char * name;
11c1ff18
PB		 11315 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11316 int type;
2cf0635d 11317 const char ** table;
11c1ff18
PB		 11318} arm_attr_public_tag;
11319
2cf0635d 11320static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11321 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11322 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11323static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11324static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11325 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11326static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 11327 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11328 "FP for ARMv8"};
2cf0635d 11329static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11330static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11331 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11332static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11333 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11334 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11335static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11336 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11337static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11338 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11339static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11340 {"Absolute", "PC-relative", "None"};
2cf0635d 11341static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11342 {"None", "direct", "GOT-indirect"};
2cf0635d 11343static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11344 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11345static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11346static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11347 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11348static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11349static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11350static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11351 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11352static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11353 {"Unused", "small", "int", "forced to int"};
2cf0635d 11354static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11355 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11356static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11357 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11358static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11359 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11360static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11361 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11362 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11363static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 11364 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11365 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11366static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11367static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11368 {"Not Allowed", "Allowed"};
2cf0635d 11369static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11370 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11371static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 11372 {"Not Allowed", "Allowed"};
11373static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11374 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11375 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 11376static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11377static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11378 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11379 "TrustZone and Virtualization Extensions"};
dd24e3da 11380static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11381 {"Not Allowed", "Allowed"};
11c1ff18
PB		 11382
11383#define LOOKUP(id, name) \
11384 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11385static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 11386{
11387 {4, "CPU_raw_name", 1, NULL},
11388 {5, "CPU_name", 1, NULL},
11389 LOOKUP(6, CPU_arch),
11390 {7, "CPU_arch_profile", 0, NULL},
11391 LOOKUP(8, ARM_ISA_use),
11392 LOOKUP(9, THUMB_ISA_use),
75375b3e 11393 LOOKUP(10, FP_arch),
11c1ff18 11394 LOOKUP(11, WMMX_arch),
f5f53991
AS		 11395 LOOKUP(12, Advanced_SIMD_arch),
11396 LOOKUP(13, PCS_config),
11c1ff18
PB		 11397 LOOKUP(14, ABI_PCS_R9_use),
11398 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11399 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 11400 LOOKUP(17, ABI_PCS_GOT_use),
11401 LOOKUP(18, ABI_PCS_wchar_t),
11402 LOOKUP(19, ABI_FP_rounding),
11403 LOOKUP(20, ABI_FP_denormal),
11404 LOOKUP(21, ABI_FP_exceptions),
11405 LOOKUP(22, ABI_FP_user_exceptions),
11406 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 11407 {24, "ABI_align_needed", 0, NULL},
11408 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 11409 LOOKUP(26, ABI_enum_size),
11410 LOOKUP(27, ABI_HardFP_use),
11411 LOOKUP(28, ABI_VFP_args),
11412 LOOKUP(29, ABI_WMMX_args),
11413 LOOKUP(30, ABI_optimization_goals),
11414 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11415 {32, "compatibility", 0, NULL},
f5f53991 11416 LOOKUP(34, CPU_unaligned_access),
75375b3e 11417 LOOKUP(36, FP_HP_extension),
8e79c3df 11418 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 11419 LOOKUP(42, MPextension_use),
11420 LOOKUP(44, DIV_use),
f5f53991
AS		 11421 {64, "nodefaults", 0, NULL},
11422 {65, "also_compatible_with", 0, NULL},
11423 LOOKUP(66, T2EE_use),
11424 {67, "conformance", 1, NULL},
11425 LOOKUP(68, Virtualization_use),
cd21e546 11426 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 11427};
11428#undef LOOKUP
11429
11c1ff18 11430static unsigned char *
f6f0e17b
NC		 11431display_arm_attribute (unsigned char * p,
11432 const unsigned char * const end)
11c1ff18
PB		 11433{
11434 int tag;
11435 unsigned int len;
11436 int val;
2cf0635d 11437 arm_attr_public_tag * attr;
11c1ff18
PB		 11438 unsigned i;
11439 int type;
11440
f6f0e17b 11441 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 11442 p += len;
11443 attr = NULL;
2cf0635d 11444 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 11445 {
11446 if (arm_attr_public_tags[i].tag == tag)
11447 {
11448 attr = &arm_attr_public_tags[i];
11449 break;
11450 }
11451 }
11452
11453 if (attr)
11454 {
11455 printf (" Tag_%s: ", attr->name);
11456 switch (attr->type)
11457 {
11458 case 0:
11459 switch (tag)
11460 {
11461 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 11462 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11463 p += len;
11464 switch (val)
11465 {
2b692964
NC		 11466 case 0: printf (_("None\n")); break;
11467 case 'A': printf (_("Application\n")); break;
11468 case 'R': printf (_("Realtime\n")); break;
11469 case 'M': printf (_("Microcontroller\n")); break;
11470 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11471 default: printf ("??? (%d)\n", val); break;
11472 }
11473 break;
11474
75375b3e 11475 case 24: /* Tag_align_needed. */
f6f0e17b 11476 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11477 p += len;
11478 switch (val)
11479 {
2b692964
NC		 11480 case 0: printf (_("None\n")); break;
11481 case 1: printf (_("8-byte\n")); break;
11482 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11483 case 3: printf ("??? 3\n"); break;
11484 default:
11485 if (val <= 12)
dd24e3da 11486 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11487 1 << val);
11488 else
11489 printf ("??? (%d)\n", val);
11490 break;
11491 }
11492 break;
11493
11494 case 25: /* Tag_align_preserved. */
f6f0e17b 11495 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11496 p += len;
11497 switch (val)
11498 {
2b692964
NC		 11499 case 0: printf (_("None\n")); break;
11500 case 1: printf (_("8-byte, except leaf SP\n")); break;
11501 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11502 case 3: printf ("??? 3\n"); break;
11503 default:
11504 if (val <= 12)
dd24e3da 11505 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11506 1 << val);
11507 else
11508 printf ("??? (%d)\n", val);
11509 break;
11510 }
11511 break;
11512
11c1ff18 11513 case 32: /* Tag_compatibility. */
f6f0e17b 11514 val = read_uleb128 (p, &len, end);
11c1ff18 11515 p += len;
2b692964 11516 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11517 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11518 break;
11519
f5f53991
AS		 11520 case 64: /* Tag_nodefaults. */
11521 p++;
2b692964 11522 printf (_("True\n"));
f5f53991
AS		 11523 break;
11524
11525 case 65: /* Tag_also_compatible_with. */
f6f0e17b 11526 val = read_uleb128 (p, &len, end);
f5f53991
AS		 11527 p += len;
11528 if (val == 6 /* Tag_CPU_arch. */)
11529 {
f6f0e17b 11530 val = read_uleb128 (p, &len, end);
f5f53991 11531 p += len;
2cf0635d 11532 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11533 printf ("??? (%d)\n", val);
11534 else
11535 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11536 }
11537 else
11538 printf ("???\n");
11539 while (*(p++) != '\0' /* NUL terminator. */);
11540 break;
11541
11c1ff18 11542 default:
2cf0635d 11543 abort ();
11c1ff18
PB		 11544 }
11545 return p;
11546
11547 case 1:
f6f0e17b 11548 return display_tag_value (-1, p, end);
11c1ff18 11549 case 2:
f6f0e17b 11550 return display_tag_value (0, p, end);
11c1ff18
PB		 11551
11552 default:
11553 assert (attr->type & 0x80);
f6f0e17b 11554 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11555 p += len;
11556 type = attr->type & 0x7f;
11557 if (val >= type)
11558 printf ("??? (%d)\n", val);
11559 else
11560 printf ("%s\n", attr->table[val]);
11561 return p;
11562 }
11563 }
11c1ff18 11564
f6f0e17b 11565 return display_tag_value (tag, p, end);
11c1ff18
PB		 11566}
11567
104d59d1 11568static unsigned char *
60bca95a 11569display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 11570 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11571 const unsigned char * const end)
104d59d1
JM		 11572{
11573 int tag;
11574 unsigned int len;
11575 int val;
104d59d1 11576
f6f0e17b 11577 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 11578 p += len;
11579
11580 /* Tag_compatibility is the only generic GNU attribute defined at
11581 present. */
11582 if (tag == 32)
11583 {
f6f0e17b 11584 val = read_uleb128 (p, &len, end);
104d59d1 11585 p += len;
f6f0e17b
NC		 11586 if (p == end)
11587 {
11588 printf (_("flag = %d, vendor = <corrupt>\n"), val);
11589 warn (_("corrupt vendor attribute\n"));
11590 }
11591 else
11592 {
11593 printf (_("flag = %d, vendor = %s\n"), val, p);
11594 p += strlen ((char *) p) + 1;
11595 }
104d59d1
JM		 11596 return p;
11597 }
11598
11599 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 11600 return display_proc_gnu_attribute (p, tag, end);
104d59d1 11601
f6f0e17b 11602 return display_tag_value (tag, p, end);
104d59d1
JM		 11603}
11604
34c8bcba 11605static unsigned char *
f6f0e17b
NC		 11606display_power_gnu_attribute (unsigned char * p,
11607 int tag,
11608 const unsigned char * const end)
34c8bcba 11609{
34c8bcba
JM		 11610 unsigned int len;
11611 int val;
11612
11613 if (tag == Tag_GNU_Power_ABI_FP)
11614 {
f6f0e17b 11615 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 11616 p += len;
11617 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11618
34c8bcba
JM		 11619 switch (val)
11620 {
11621 case 0:
2b692964 11622 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11623 break;
11624 case 1:
2b692964 11625 printf (_("Hard float\n"));
34c8bcba
JM		 11626 break;
11627 case 2:
2b692964 11628 printf (_("Soft float\n"));
34c8bcba 11629 break;
3c7b9897 11630 case 3:
2b692964 11631 printf (_("Single-precision hard float\n"));
3c7b9897 11632 break;
34c8bcba
JM		 11633 default:
11634 printf ("??? (%d)\n", val);
11635 break;
11636 }
11637 return p;
11638 }
11639
c6e65352
DJ		 11640 if (tag == Tag_GNU_Power_ABI_Vector)
11641 {
f6f0e17b 11642 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 11643 p += len;
11644 printf (" Tag_GNU_Power_ABI_Vector: ");
11645 switch (val)
11646 {
11647 case 0:
2b692964 11648 printf (_("Any\n"));
c6e65352
DJ		 11649 break;
11650 case 1:
2b692964 11651 printf (_("Generic\n"));
c6e65352
DJ		 11652 break;
11653 case 2:
11654 printf ("AltiVec\n");
11655 break;
11656 case 3:
11657 printf ("SPE\n");
11658 break;
11659 default:
11660 printf ("??? (%d)\n", val);
11661 break;
11662 }
11663 return p;
11664 }
11665
f82e0623
NF		 11666 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11667 {
f6f0e17b
NC		 11668 if (p == end)
11669 {
11670 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11671 return p;
11672 }
0b4362b0 11673
f6f0e17b 11674 val = read_uleb128 (p, &len, end);
f82e0623
NF		 11675 p += len;
11676 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11677 switch (val)
11678 {
11679 case 0:
2b692964 11680 printf (_("Any\n"));
f82e0623
NF		 11681 break;
11682 case 1:
11683 printf ("r3/r4\n");
11684 break;
11685 case 2:
2b692964 11686 printf (_("Memory\n"));
f82e0623
NF		 11687 break;
11688 default:
11689 printf ("??? (%d)\n", val);
11690 break;
11691 }
11692 return p;
11693 }
11694
f6f0e17b 11695 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 11696}
11697
9e8c70f9
DM		 11698static void
11699display_sparc_hwcaps (int mask)
11700{
11701 if (mask)
11702 {
11703 int first = 1;
11704 if (mask & ELF_SPARC_HWCAP_MUL32)
11705 fputs ("mul32", stdout), first = 0;
11706 if (mask & ELF_SPARC_HWCAP_DIV32)
11707 printf ("%sdiv32", first ? "" : "|"), first = 0;
11708 if (mask & ELF_SPARC_HWCAP_FSMULD)
11709 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11710 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11711 printf ("%sv8plus", first ? "" : "|"), first = 0;
11712 if (mask & ELF_SPARC_HWCAP_POPC)
11713 printf ("%spopc", first ? "" : "|"), first = 0;
11714 if (mask & ELF_SPARC_HWCAP_VIS)
11715 printf ("%svis", first ? "" : "|"), first = 0;
11716 if (mask & ELF_SPARC_HWCAP_VIS2)
11717 printf ("%svis2", first ? "" : "|"), first = 0;
11718 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11719 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11720 if (mask & ELF_SPARC_HWCAP_FMAF)
11721 printf ("%sfmaf", first ? "" : "|"), first = 0;
11722 if (mask & ELF_SPARC_HWCAP_VIS3)
11723 printf ("%svis3", first ? "" : "|"), first = 0;
11724 if (mask & ELF_SPARC_HWCAP_HPC)
11725 printf ("%shpc", first ? "" : "|"), first = 0;
11726 if (mask & ELF_SPARC_HWCAP_RANDOM)
11727 printf ("%srandom", first ? "" : "|"), first = 0;
11728 if (mask & ELF_SPARC_HWCAP_TRANS)
11729 printf ("%strans", first ? "" : "|"), first = 0;
11730 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11731 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11732 if (mask & ELF_SPARC_HWCAP_IMA)
11733 printf ("%sima", first ? "" : "|"), first = 0;
11734 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11735 printf ("%scspare", first ? "" : "|"), first = 0;
11736 }
11737 else
11738 fputc('0', stdout);
11739 fputc('\n', stdout);
11740}
11741
11742static unsigned char *
f6f0e17b
NC		 11743display_sparc_gnu_attribute (unsigned char * p,
11744 int tag,
11745 const unsigned char * const end)
9e8c70f9 11746{
9e8c70f9
DM		 11747 if (tag == Tag_GNU_Sparc_HWCAPS)
11748 {
f6f0e17b
NC		 11749 unsigned int len;
11750 int val;
11751
11752 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 11753 p += len;
11754 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 11755 display_sparc_hwcaps (val);
11756 return p;
11757 }
11758
f6f0e17b 11759 return display_tag_value (tag, p, end);
9e8c70f9
DM		 11760}
11761
2cf19d5c 11762static unsigned char *
f6f0e17b
NC		 11763display_mips_gnu_attribute (unsigned char * p,
11764 int tag,
11765 const unsigned char * const end)
2cf19d5c 11766{
2cf19d5c
JM		 11767 if (tag == Tag_GNU_MIPS_ABI_FP)
11768 {
f6f0e17b
NC		 11769 unsigned int len;
11770 int val;
11771
11772 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 11773 p += len;
11774 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11775
2cf19d5c
JM		 11776 switch (val)
11777 {
d929bc19 11778 case Val_GNU_MIPS_ABI_FP_ANY:
2b692964 11779 printf (_("Hard or soft float\n"));
2cf19d5c 11780 break;
d929bc19 11781 case Val_GNU_MIPS_ABI_FP_DOUBLE:
2b692964 11782 printf (_("Hard float (double precision)\n"));
2cf19d5c 11783 break;
d929bc19 11784 case Val_GNU_MIPS_ABI_FP_SINGLE:
2b692964 11785 printf (_("Hard float (single precision)\n"));
2cf19d5c 11786 break;
d929bc19 11787 case Val_GNU_MIPS_ABI_FP_SOFT:
2b692964 11788 printf (_("Soft float\n"));
2cf19d5c 11789 break;
d929bc19 11790 case Val_GNU_MIPS_ABI_FP_64:
9eeefea8 11791 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11792 break;
2cf19d5c
JM		 11793 default:
11794 printf ("??? (%d)\n", val);
11795 break;
11796 }
11797 return p;
11798 }
11799
a9f58168
CF		 11800 if (tag == Tag_GNU_MIPS_ABI_MSA)
11801 {
11802 unsigned int len;
11803 int val;
11804
11805 val = read_uleb128 (p, &len, end);
11806 p += len;
11807 printf (" Tag_GNU_MIPS_ABI_MSA: ");
11808
11809 switch (val)
11810 {
11811 case Val_GNU_MIPS_ABI_MSA_ANY:
11812 printf (_("Any MSA or not\n"));
11813 break;
11814 case Val_GNU_MIPS_ABI_MSA_128:
11815 printf (_("128-bit MSA\n"));
11816 break;
11817 default:
11818 printf ("??? (%d)\n", val);
11819 break;
11820 }
11821 return p;
11822 }
11823
f6f0e17b 11824 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 11825}
11826
59e6276b 11827static unsigned char *
f6f0e17b
NC		 11828display_tic6x_attribute (unsigned char * p,
11829 const unsigned char * const end)
59e6276b
JM		 11830{
11831 int tag;
11832 unsigned int len;
11833 int val;
11834
f6f0e17b 11835 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 11836 p += len;
11837
11838 switch (tag)
11839 {
75fa6dc1 11840 case Tag_ISA:
f6f0e17b 11841 val = read_uleb128 (p, &len, end);
59e6276b 11842 p += len;
75fa6dc1 11843 printf (" Tag_ISA: ");
59e6276b
JM		 11844
11845 switch (val)
11846 {
75fa6dc1 11847 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11848 printf (_("None\n"));
11849 break;
75fa6dc1 11850 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11851 printf ("C62x\n");
11852 break;
75fa6dc1 11853 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11854 printf ("C67x\n");
11855 break;
75fa6dc1 11856 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11857 printf ("C67x+\n");
11858 break;
75fa6dc1 11859 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11860 printf ("C64x\n");
11861 break;
75fa6dc1 11862 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11863 printf ("C64x+\n");
11864 break;
75fa6dc1 11865 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11866 printf ("C674x\n");
11867 break;
11868 default:
11869 printf ("??? (%d)\n", val);
11870 break;
11871 }
11872 return p;
11873
87779176 11874 case Tag_ABI_wchar_t:
f6f0e17b 11875 val = read_uleb128 (p, &len, end);
87779176
JM		 11876 p += len;
11877 printf (" Tag_ABI_wchar_t: ");
11878 switch (val)
11879 {
11880 case 0:
11881 printf (_("Not used\n"));
11882 break;
11883 case 1:
11884 printf (_("2 bytes\n"));
11885 break;
11886 case 2:
11887 printf (_("4 bytes\n"));
11888 break;
11889 default:
11890 printf ("??? (%d)\n", val);
11891 break;
11892 }
11893 return p;
11894
11895 case Tag_ABI_stack_align_needed:
f6f0e17b 11896 val = read_uleb128 (p, &len, end);
87779176
JM		 11897 p += len;
11898 printf (" Tag_ABI_stack_align_needed: ");
11899 switch (val)
11900 {
11901 case 0:
11902 printf (_("8-byte\n"));
11903 break;
11904 case 1:
11905 printf (_("16-byte\n"));
11906 break;
11907 default:
11908 printf ("??? (%d)\n", val);
11909 break;
11910 }
11911 return p;
11912
11913 case Tag_ABI_stack_align_preserved:
f6f0e17b 11914 val = read_uleb128 (p, &len, end);
87779176
JM		 11915 p += len;
11916 printf (" Tag_ABI_stack_align_preserved: ");
11917 switch (val)
11918 {
11919 case 0:
11920 printf (_("8-byte\n"));
11921 break;
11922 case 1:
11923 printf (_("16-byte\n"));
11924 break;
11925 default:
11926 printf ("??? (%d)\n", val);
11927 break;
11928 }
11929 return p;
11930
b5593623 11931 case Tag_ABI_DSBT:
f6f0e17b 11932 val = read_uleb128 (p, &len, end);
b5593623
JM		 11933 p += len;
11934 printf (" Tag_ABI_DSBT: ");
11935 switch (val)
11936 {
11937 case 0:
11938 printf (_("DSBT addressing not used\n"));
11939 break;
11940 case 1:
11941 printf (_("DSBT addressing used\n"));
11942 break;
11943 default:
11944 printf ("??? (%d)\n", val);
11945 break;
11946 }
11947 return p;
11948
87779176 11949 case Tag_ABI_PID:
f6f0e17b 11950 val = read_uleb128 (p, &len, end);
87779176
JM		 11951 p += len;
11952 printf (" Tag_ABI_PID: ");
11953 switch (val)
11954 {
11955 case 0:
11956 printf (_("Data addressing position-dependent\n"));
11957 break;
11958 case 1:
11959 printf (_("Data addressing position-independent, GOT near DP\n"));
11960 break;
11961 case 2:
11962 printf (_("Data addressing position-independent, GOT far from DP\n"));
11963 break;
11964 default:
11965 printf ("??? (%d)\n", val);
11966 break;
11967 }
11968 return p;
11969
11970 case Tag_ABI_PIC:
f6f0e17b 11971 val = read_uleb128 (p, &len, end);
87779176
JM		 11972 p += len;
11973 printf (" Tag_ABI_PIC: ");
11974 switch (val)
11975 {
11976 case 0:
11977 printf (_("Code addressing position-dependent\n"));
11978 break;
11979 case 1:
11980 printf (_("Code addressing position-independent\n"));
11981 break;
11982 default:
11983 printf ("??? (%d)\n", val);
11984 break;
11985 }
11986 return p;
11987
11988 case Tag_ABI_array_object_alignment:
f6f0e17b 11989 val = read_uleb128 (p, &len, end);
87779176
JM		 11990 p += len;
11991 printf (" Tag_ABI_array_object_alignment: ");
11992 switch (val)
11993 {
11994 case 0:
11995 printf (_("8-byte\n"));
11996 break;
11997 case 1:
11998 printf (_("4-byte\n"));
11999 break;
12000 case 2:
12001 printf (_("16-byte\n"));
12002 break;
12003 default:
12004 printf ("??? (%d)\n", val);
12005 break;
12006 }
12007 return p;
12008
12009 case Tag_ABI_array_object_align_expected:
f6f0e17b 12010 val = read_uleb128 (p, &len, end);
87779176
JM		 12011 p += len;
12012 printf (" Tag_ABI_array_object_align_expected: ");
12013 switch (val)
12014 {
12015 case 0:
12016 printf (_("8-byte\n"));
12017 break;
12018 case 1:
12019 printf (_("4-byte\n"));
12020 break;
12021 case 2:
12022 printf (_("16-byte\n"));
12023 break;
12024 default:
12025 printf ("??? (%d)\n", val);
12026 break;
12027 }
12028 return p;
12029
3cbd1c06 12030 case Tag_ABI_compatibility:
f6f0e17b 12031 val = read_uleb128 (p, &len, end);
59e6276b 12032 p += len;
3cbd1c06 12033 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 12034 printf (_("flag = %d, vendor = %s\n"), val, p);
12035 p += strlen ((char *) p) + 1;
12036 return p;
87779176
JM		 12037
12038 case Tag_ABI_conformance:
12039 printf (" Tag_ABI_conformance: ");
12040 printf ("\"%s\"\n", p);
12041 p += strlen ((char *) p) + 1;
12042 return p;
59e6276b
JM		 12043 }
12044
f6f0e17b
NC		 12045 return display_tag_value (tag, p, end);
12046}
59e6276b 12047
f6f0e17b
NC		 12048static void
12049display_raw_attribute (unsigned char * p, unsigned char * end)
12050{
12051 unsigned long addr = 0;
12052 size_t bytes = end - p;
12053
12054 while (bytes)
87779176 12055 {
f6f0e17b
NC		 12056 int j;
12057 int k;
12058 int lbytes = (bytes > 16 ? 16 : bytes);
12059
12060 printf (" 0x%8.8lx ", addr);
12061
12062 for (j = 0; j < 16; j++)
12063 {
12064 if (j < lbytes)
12065 printf ("%2.2x", p[j]);
12066 else
12067 printf (" ");
12068
12069 if ((j & 3) == 3)
12070 printf (" ");
12071 }
12072
12073 for (j = 0; j < lbytes; j++)
12074 {
12075 k = p[j];
12076 if (k >= ' ' && k < 0x7f)
12077 printf ("%c", k);
12078 else
12079 printf (".");
12080 }
12081
12082 putchar ('\n');
12083
12084 p += lbytes;
12085 bytes -= lbytes;
12086 addr += lbytes;
87779176 12087 }
59e6276b 12088
f6f0e17b 12089 putchar ('\n');
59e6276b
JM		 12090}
12091
13761a11
NC		 12092static unsigned char *
12093display_msp430x_attribute (unsigned char * p,
12094 const unsigned char * const end)
12095{
12096 unsigned int len;
12097 int val;
12098 int tag;
12099
12100 tag = read_uleb128 (p, & len, end);
12101 p += len;
0b4362b0 12102
13761a11
NC		 12103 switch (tag)
12104 {
12105 case OFBA_MSPABI_Tag_ISA:
12106 val = read_uleb128 (p, &len, end);
12107 p += len;
12108 printf (" Tag_ISA: ");
12109 switch (val)
12110 {
12111 case 0: printf (_("None\n")); break;
12112 case 1: printf (_("MSP430\n")); break;
12113 case 2: printf (_("MSP430X\n")); break;
12114 default: printf ("??? (%d)\n", val); break;
12115 }
12116 break;
12117
12118 case OFBA_MSPABI_Tag_Code_Model:
12119 val = read_uleb128 (p, &len, end);
12120 p += len;
12121 printf (" Tag_Code_Model: ");
12122 switch (val)
12123 {
12124 case 0: printf (_("None\n")); break;
12125 case 1: printf (_("Small\n")); break;
12126 case 2: printf (_("Large\n")); break;
12127 default: printf ("??? (%d)\n", val); break;
12128 }
12129 break;
12130
12131 case OFBA_MSPABI_Tag_Data_Model:
12132 val = read_uleb128 (p, &len, end);
12133 p += len;
12134 printf (" Tag_Data_Model: ");
12135 switch (val)
12136 {
12137 case 0: printf (_("None\n")); break;
12138 case 1: printf (_("Small\n")); break;
12139 case 2: printf (_("Large\n")); break;
12140 case 3: printf (_("Restricted Large\n")); break;
12141 default: printf ("??? (%d)\n", val); break;
12142 }
12143 break;
12144
12145 default:
12146 printf (_(" <unknown tag %d>: "), tag);
12147
12148 if (tag & 1)
12149 {
12150 printf ("\"%s\"\n", p);
12151 p += strlen ((char *) p) + 1;
12152 }
12153 else
12154 {
12155 val = read_uleb128 (p, &len, end);
12156 p += len;
12157 printf ("%d (0x%x)\n", val, val);
12158 }
12159 break;
12160 }
12161
12162 return p;
12163}
12164
11c1ff18 12165static int
60bca95a
NC		 12166process_attributes (FILE * file,
12167 const char * public_name,
104d59d1 12168 unsigned int proc_type,
f6f0e17b
NC		 12169 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12170 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 12171{
2cf0635d
NC		 12172 Elf_Internal_Shdr * sect;
12173 unsigned char * contents;
12174 unsigned char * p;
12175 unsigned char * end;
11c1ff18
PB		 12176 bfd_vma section_len;
12177 bfd_vma len;
12178 unsigned i;
12179
12180 /* Find the section header so that we get the size. */
12181 for (i = 0, sect = section_headers;
12182 i < elf_header.e_shnum;
12183 i++, sect++)
12184 {
104d59d1 12185 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 12186 continue;
12187
3f5e193b
NC		 12188 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12189 sect->sh_size, _("attributes"));
60bca95a 12190 if (contents == NULL)
11c1ff18 12191 continue;
60bca95a 12192
11c1ff18
PB		 12193 p = contents;
12194 if (*p == 'A')
12195 {
12196 len = sect->sh_size - 1;
12197 p++;
60bca95a 12198
11c1ff18
PB		 12199 while (len > 0)
12200 {
12201 int namelen;
12202 bfd_boolean public_section;
104d59d1 12203 bfd_boolean gnu_section;
11c1ff18
PB		 12204
12205 section_len = byte_get (p, 4);
12206 p += 4;
60bca95a 12207
11c1ff18
PB		 12208 if (section_len > len)
12209 {
12210 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 12211 (int) section_len, (int) len);
11c1ff18
PB		 12212 section_len = len;
12213 }
60bca95a 12214
11c1ff18 12215 len -= section_len;
2b692964 12216 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 12217
12218 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 12219 public_section = TRUE;
12220 else
12221 public_section = FALSE;
60bca95a
NC		 12222
12223 if (streq ((char *) p, "gnu"))
104d59d1
JM		 12224 gnu_section = TRUE;
12225 else
12226 gnu_section = FALSE;
60bca95a
NC		 12227
12228 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 12229 p += namelen;
12230 section_len -= namelen + 4;
60bca95a 12231
11c1ff18
PB		 12232 while (section_len > 0)
12233 {
12234 int tag = *(p++);
12235 int val;
12236 bfd_vma size;
60bca95a 12237
11c1ff18
PB		 12238 size = byte_get (p, 4);
12239 if (size > section_len)
12240 {
12241 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 12242 (int) size, (int) section_len);
11c1ff18
PB		 12243 size = section_len;
12244 }
60bca95a 12245
11c1ff18
PB		 12246 section_len -= size;
12247 end = p + size - 1;
12248 p += 4;
60bca95a 12249
11c1ff18
PB		 12250 switch (tag)
12251 {
12252 case 1:
2b692964 12253 printf (_("File Attributes\n"));
11c1ff18
PB		 12254 break;
12255 case 2:
2b692964 12256 printf (_("Section Attributes:"));
11c1ff18
PB		 12257 goto do_numlist;
12258 case 3:
2b692964 12259 printf (_("Symbol Attributes:"));
11c1ff18
PB		 12260 do_numlist:
12261 for (;;)
12262 {
91d6fa6a 12263 unsigned int j;
60bca95a 12264
f6f0e17b 12265 val = read_uleb128 (p, &j, end);
91d6fa6a 12266 p += j;
11c1ff18
PB		 12267 if (val == 0)
12268 break;
12269 printf (" %d", val);
12270 }
12271 printf ("\n");
12272 break;
12273 default:
2b692964 12274 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 12275 public_section = FALSE;
12276 break;
12277 }
60bca95a 12278
11c1ff18
PB		 12279 if (public_section)
12280 {
12281 while (p < end)
f6f0e17b 12282 p = display_pub_attribute (p, end);
104d59d1
JM		 12283 }
12284 else if (gnu_section)
12285 {
12286 while (p < end)
12287 p = display_gnu_attribute (p,
f6f0e17b
NC		 12288 display_proc_gnu_attribute,
12289 end);
11c1ff18
PB		 12290 }
12291 else
12292 {
2b692964 12293 printf (_(" Unknown section contexts\n"));
f6f0e17b 12294 display_raw_attribute (p, end);
11c1ff18
PB		 12295 p = end;
12296 }
12297 }
12298 }
12299 }
12300 else
60bca95a 12301 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 12302
60bca95a 12303 free (contents);
11c1ff18
PB		 12304 }
12305 return 1;
12306}
12307
104d59d1 12308static int
2cf0635d 12309process_arm_specific (FILE * file)
104d59d1
JM		 12310{
12311 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12312 display_arm_attribute, NULL);
12313}
12314
34c8bcba 12315static int
2cf0635d 12316process_power_specific (FILE * file)
34c8bcba
JM		 12317{
12318 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12319 display_power_gnu_attribute);
12320}
12321
9e8c70f9
DM		 12322static int
12323process_sparc_specific (FILE * file)
12324{
12325 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12326 display_sparc_gnu_attribute);
12327}
12328
59e6276b
JM		 12329static int
12330process_tic6x_specific (FILE * file)
12331{
12332 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12333 display_tic6x_attribute, NULL);
12334}
12335
13761a11
NC		 12336static int
12337process_msp430x_specific (FILE * file)
12338{
12339 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12340 display_msp430x_attribute, NULL);
12341}
12342
ccb4c951
RS		 12343/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12344 Print the Address, Access and Initial fields of an entry at VMA ADDR
12345 and return the VMA of the next entry. */
12346
12347static bfd_vma
2cf0635d 12348print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 12349{
12350 printf (" ");
12351 print_vma (addr, LONG_HEX);
12352 printf (" ");
12353 if (addr < pltgot + 0xfff0)
12354 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12355 else
12356 printf ("%10s", "");
12357 printf (" ");
12358 if (data == NULL)
2b692964 12359 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 12360 else
12361 {
12362 bfd_vma entry;
12363
12364 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12365 print_vma (entry, LONG_HEX);
12366 }
12367 return addr + (is_32bit_elf ? 4 : 8);
12368}
12369
861fb55a
DJ		 12370/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12371 PLTGOT. Print the Address and Initial fields of an entry at VMA
12372 ADDR and return the VMA of the next entry. */
12373
12374static bfd_vma
2cf0635d 12375print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 12376{
12377 printf (" ");
12378 print_vma (addr, LONG_HEX);
12379 printf (" ");
12380 if (data == NULL)
2b692964 12381 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 12382 else
12383 {
12384 bfd_vma entry;
12385
12386 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12387 print_vma (entry, LONG_HEX);
12388 }
12389 return addr + (is_32bit_elf ? 4 : 8);
12390}
12391
19e6b90e 12392static int
2cf0635d 12393process_mips_specific (FILE * file)
5b18a4bc 12394{
2cf0635d 12395 Elf_Internal_Dyn * entry;
19e6b90e
L		 12396 size_t liblist_offset = 0;
12397 size_t liblistno = 0;
12398 size_t conflictsno = 0;
12399 size_t options_offset = 0;
12400 size_t conflicts_offset = 0;
861fb55a
DJ		 12401 size_t pltrelsz = 0;
12402 size_t pltrel = 0;
ccb4c951 12403 bfd_vma pltgot = 0;
861fb55a
DJ		 12404 bfd_vma mips_pltgot = 0;
12405 bfd_vma jmprel = 0;
ccb4c951
RS		 12406 bfd_vma local_gotno = 0;
12407 bfd_vma gotsym = 0;
12408 bfd_vma symtabno = 0;
103f02d3 12409
2cf19d5c
JM		 12410 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12411 display_mips_gnu_attribute);
12412
19e6b90e
L		 12413 /* We have a lot of special sections. Thanks SGI! */
12414 if (dynamic_section == NULL)
12415 /* No information available. */
12416 return 0;
252b5132 12417
b2d38a17 12418 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 12419 switch (entry->d_tag)
12420 {
12421 case DT_MIPS_LIBLIST:
d93f0186
NC		 12422 liblist_offset
12423 = offset_from_vma (file, entry->d_un.d_val,
12424 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 12425 break;
12426 case DT_MIPS_LIBLISTNO:
12427 liblistno = entry->d_un.d_val;
12428 break;
12429 case DT_MIPS_OPTIONS:
d93f0186 12430 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 12431 break;
12432 case DT_MIPS_CONFLICT:
d93f0186
NC		 12433 conflicts_offset
12434 = offset_from_vma (file, entry->d_un.d_val,
12435 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 12436 break;
12437 case DT_MIPS_CONFLICTNO:
12438 conflictsno = entry->d_un.d_val;
12439 break;
ccb4c951 12440 case DT_PLTGOT:
861fb55a
DJ		 12441 pltgot = entry->d_un.d_ptr;
12442 break;
ccb4c951
RS		 12443 case DT_MIPS_LOCAL_GOTNO:
12444 local_gotno = entry->d_un.d_val;
12445 break;
12446 case DT_MIPS_GOTSYM:
12447 gotsym = entry->d_un.d_val;
12448 break;
12449 case DT_MIPS_SYMTABNO:
12450 symtabno = entry->d_un.d_val;
12451 break;
861fb55a
DJ		 12452 case DT_MIPS_PLTGOT:
12453 mips_pltgot = entry->d_un.d_ptr;
12454 break;
12455 case DT_PLTREL:
12456 pltrel = entry->d_un.d_val;
12457 break;
12458 case DT_PLTRELSZ:
12459 pltrelsz = entry->d_un.d_val;
12460 break;
12461 case DT_JMPREL:
12462 jmprel = entry->d_un.d_ptr;
12463 break;
252b5132
RH		 12464 default:
12465 break;
12466 }
12467
12468 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12469 {
2cf0635d 12470 Elf32_External_Lib * elib;
252b5132
RH		 12471 size_t cnt;
12472
3f5e193b
NC		 12473 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12474 liblistno,
12475 sizeof (Elf32_External_Lib),
9cf03b7e 12476 _("liblist section data"));
a6e9f9df 12477 if (elib)
252b5132 12478 {
2b692964 12479 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 12480 (unsigned long) liblistno);
2b692964 12481 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 12482 stdout);
12483
12484 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 12485 {
a6e9f9df 12486 Elf32_Lib liblist;
91d6fa6a 12487 time_t atime;
a6e9f9df 12488 char timebuf[20];
2cf0635d 12489 struct tm * tmp;
a6e9f9df
AM		 12490
12491 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12492 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 12493 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12494 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12495 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12496
91d6fa6a 12497 tmp = gmtime (&atime);
e9e44622
JJ		 12498 snprintf (timebuf, sizeof (timebuf),
12499 "%04u-%02u-%02uT%02u:%02u:%02u",
12500 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12501 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 12502
31104126 12503 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 12504 if (VALID_DYNAMIC_NAME (liblist.l_name))
12505 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12506 else
2b692964 12507 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 12508 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12509 liblist.l_version);
a6e9f9df
AM		 12510
12511 if (liblist.l_flags == 0)
2b692964 12512 puts (_(" NONE"));
a6e9f9df
AM		 12513 else
12514 {
12515 static const struct
252b5132 12516 {
2cf0635d 12517 const char * name;
a6e9f9df 12518 int bit;
252b5132 12519 }
a6e9f9df
AM		 12520 l_flags_vals[] =
12521 {
12522 { " EXACT_MATCH", LL_EXACT_MATCH },
12523 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12524 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12525 { " EXPORTS", LL_EXPORTS },
12526 { " DELAY_LOAD", LL_DELAY_LOAD },
12527 { " DELTA", LL_DELTA }
12528 };
12529 int flags = liblist.l_flags;
12530 size_t fcnt;
12531
60bca95a 12532 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12533 if ((flags & l_flags_vals[fcnt].bit) != 0)
12534 {
12535 fputs (l_flags_vals[fcnt].name, stdout);
12536 flags ^= l_flags_vals[fcnt].bit;
12537 }
12538 if (flags != 0)
12539 printf (" %#x", (unsigned int) flags);
252b5132 12540
a6e9f9df
AM		 12541 puts ("");
12542 }
252b5132 12543 }
252b5132 12544
a6e9f9df
AM		 12545 free (elib);
12546 }
252b5132
RH		 12547 }
12548
12549 if (options_offset != 0)
12550 {
2cf0635d
NC		 12551 Elf_External_Options * eopt;
12552 Elf_Internal_Shdr * sect = section_headers;
12553 Elf_Internal_Options * iopt;
12554 Elf_Internal_Options * option;
252b5132
RH		 12555 size_t offset;
12556 int cnt;
12557
12558 /* Find the section header so that we get the size. */
12559 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12560 ++sect;
252b5132 12561
3f5e193b
NC		 12562 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12563 sect->sh_size, _("options"));
a6e9f9df 12564 if (eopt)
252b5132 12565 {
3f5e193b
NC		 12566 iopt = (Elf_Internal_Options *)
12567 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 12568 if (iopt == NULL)
12569 {
591a748a 12570 error (_("Out of memory\n"));
a6e9f9df
AM		 12571 return 0;
12572 }
76da6bbe 12573
a6e9f9df
AM		 12574 offset = cnt = 0;
12575 option = iopt;
252b5132 12576
a6e9f9df
AM		 12577 while (offset < sect->sh_size)
12578 {
2cf0635d 12579 Elf_External_Options * eoption;
252b5132 12580
a6e9f9df 12581 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12582
a6e9f9df
AM		 12583 option->kind = BYTE_GET (eoption->kind);
12584 option->size = BYTE_GET (eoption->size);
12585 option->section = BYTE_GET (eoption->section);
12586 option->info = BYTE_GET (eoption->info);
76da6bbe 12587
a6e9f9df 12588 offset += option->size;
252b5132 12589
a6e9f9df
AM		 12590 ++option;
12591 ++cnt;
12592 }
252b5132 12593
a6e9f9df
AM		 12594 printf (_("\nSection '%s' contains %d entries:\n"),
12595 SECTION_NAME (sect), cnt);
76da6bbe 12596
a6e9f9df 12597 option = iopt;
252b5132 12598
a6e9f9df 12599 while (cnt-- > 0)
252b5132 12600 {
a6e9f9df
AM		 12601 size_t len;
12602
12603 switch (option->kind)
252b5132 12604 {
a6e9f9df
AM		 12605 case ODK_NULL:
12606 /* This shouldn't happen. */
12607 printf (" NULL %d %lx", option->section, option->info);
12608 break;
12609 case ODK_REGINFO:
12610 printf (" REGINFO ");
12611 if (elf_header.e_machine == EM_MIPS)
12612 {
12613 /* 32bit form. */
2cf0635d 12614 Elf32_External_RegInfo * ereg;
b34976b6 12615 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12616
12617 ereg = (Elf32_External_RegInfo *) (option + 1);
12618 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12619 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12620 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12621 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12622 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12623 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12624
12625 printf ("GPR %08lx GP 0x%lx\n",
12626 reginfo.ri_gprmask,
12627 (unsigned long) reginfo.ri_gp_value);
12628 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12629 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12630 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12631 }
12632 else
12633 {
12634 /* 64 bit form. */
2cf0635d 12635 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12636 Elf64_Internal_RegInfo reginfo;
12637
12638 ereg = (Elf64_External_RegInfo *) (option + 1);
12639 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12640 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12641 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12642 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12643 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12644 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12645
12646 printf ("GPR %08lx GP 0x",
12647 reginfo.ri_gprmask);
12648 printf_vma (reginfo.ri_gp_value);
12649 printf ("\n");
12650
12651 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12652 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12653 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12654 }
12655 ++option;
12656 continue;
12657 case ODK_EXCEPTIONS:
12658 fputs (" EXCEPTIONS fpe_min(", stdout);
12659 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12660 fputs (") fpe_max(", stdout);
12661 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12662 fputs (")", stdout);
12663
12664 if (option->info & OEX_PAGE0)
12665 fputs (" PAGE0", stdout);
12666 if (option->info & OEX_SMM)
12667 fputs (" SMM", stdout);
12668 if (option->info & OEX_FPDBUG)
12669 fputs (" FPDBUG", stdout);
12670 if (option->info & OEX_DISMISS)
12671 fputs (" DISMISS", stdout);
12672 break;
12673 case ODK_PAD:
12674 fputs (" PAD ", stdout);
12675 if (option->info & OPAD_PREFIX)
12676 fputs (" PREFIX", stdout);
12677 if (option->info & OPAD_POSTFIX)
12678 fputs (" POSTFIX", stdout);
12679 if (option->info & OPAD_SYMBOL)
12680 fputs (" SYMBOL", stdout);
12681 break;
12682 case ODK_HWPATCH:
12683 fputs (" HWPATCH ", stdout);
12684 if (option->info & OHW_R4KEOP)
12685 fputs (" R4KEOP", stdout);
12686 if (option->info & OHW_R8KPFETCH)
12687 fputs (" R8KPFETCH", stdout);
12688 if (option->info & OHW_R5KEOP)
12689 fputs (" R5KEOP", stdout);
12690 if (option->info & OHW_R5KCVTL)
12691 fputs (" R5KCVTL", stdout);
12692 break;
12693 case ODK_FILL:
12694 fputs (" FILL ", stdout);
12695 /* XXX Print content of info word? */
12696 break;
12697 case ODK_TAGS:
12698 fputs (" TAGS ", stdout);
12699 /* XXX Print content of info word? */
12700 break;
12701 case ODK_HWAND:
12702 fputs (" HWAND ", stdout);
12703 if (option->info & OHWA0_R4KEOP_CHECKED)
12704 fputs (" R4KEOP_CHECKED", stdout);
12705 if (option->info & OHWA0_R4KEOP_CLEAN)
12706 fputs (" R4KEOP_CLEAN", stdout);
12707 break;
12708 case ODK_HWOR:
12709 fputs (" HWOR ", stdout);
12710 if (option->info & OHWA0_R4KEOP_CHECKED)
12711 fputs (" R4KEOP_CHECKED", stdout);
12712 if (option->info & OHWA0_R4KEOP_CLEAN)
12713 fputs (" R4KEOP_CLEAN", stdout);
12714 break;
12715 case ODK_GP_GROUP:
12716 printf (" GP_GROUP %#06lx self-contained %#06lx",
12717 option->info & OGP_GROUP,
12718 (option->info & OGP_SELF) >> 16);
12719 break;
12720 case ODK_IDENT:
12721 printf (" IDENT %#06lx self-contained %#06lx",
12722 option->info & OGP_GROUP,
12723 (option->info & OGP_SELF) >> 16);
12724 break;
12725 default:
12726 /* This shouldn't happen. */
12727 printf (" %3d ??? %d %lx",
12728 option->kind, option->section, option->info);
12729 break;
252b5132 12730 }
a6e9f9df 12731
2cf0635d 12732 len = sizeof (* eopt);
a6e9f9df
AM		 12733 while (len < option->size)
12734 if (((char *) option)[len] >= ' '
12735 && ((char *) option)[len] < 0x7f)
12736 printf ("%c", ((char *) option)[len++]);
12737 else
12738 printf ("\\%03o", ((char *) option)[len++]);
12739
12740 fputs ("\n", stdout);
252b5132 12741 ++option;
252b5132
RH		 12742 }
12743
a6e9f9df 12744 free (eopt);
252b5132 12745 }
252b5132
RH		 12746 }
12747
12748 if (conflicts_offset != 0 && conflictsno != 0)
12749 {
2cf0635d 12750 Elf32_Conflict * iconf;
252b5132
RH		 12751 size_t cnt;
12752
12753 if (dynamic_symbols == NULL)
12754 {
591a748a 12755 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12756 return 0;
12757 }
12758
3f5e193b 12759 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12760 if (iconf == NULL)
12761 {
591a748a 12762 error (_("Out of memory\n"));
252b5132
RH		 12763 return 0;
12764 }
12765
9ea033b2 12766 if (is_32bit_elf)
252b5132 12767 {
2cf0635d 12768 Elf32_External_Conflict * econf32;
a6e9f9df 12769
3f5e193b
NC		 12770 econf32 = (Elf32_External_Conflict *)
12771 get_data (NULL, file, conflicts_offset, conflictsno,
12772 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12773 if (!econf32)
12774 return 0;
252b5132
RH		 12775
12776 for (cnt = 0; cnt < conflictsno; ++cnt)
12777 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12778
12779 free (econf32);
252b5132
RH		 12780 }
12781 else
12782 {
2cf0635d 12783 Elf64_External_Conflict * econf64;
a6e9f9df 12784
3f5e193b
NC		 12785 econf64 = (Elf64_External_Conflict *)
12786 get_data (NULL, file, conflicts_offset, conflictsno,
12787 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12788 if (!econf64)
12789 return 0;
252b5132
RH		 12790
12791 for (cnt = 0; cnt < conflictsno; ++cnt)
12792 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12793
12794 free (econf64);
252b5132
RH		 12795 }
12796
c7e7ca54
NC		 12797 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12798 (unsigned long) conflictsno);
252b5132
RH		 12799 puts (_(" Num: Index Value Name"));
12800
12801 for (cnt = 0; cnt < conflictsno; ++cnt)
12802 {
2cf0635d 12803 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12804
b34976b6 12805 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12806 print_vma (psym->st_value, FULL_HEX);
31104126 12807 putchar (' ');
d79b3d50
NC		 12808 if (VALID_DYNAMIC_NAME (psym->st_name))
12809 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12810 else
2b692964 12811 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12812 putchar ('\n');
252b5132
RH		 12813 }
12814
252b5132
RH		 12815 free (iconf);
12816 }
12817
ccb4c951
RS		 12818 if (pltgot != 0 && local_gotno != 0)
12819 {
91d6fa6a 12820 bfd_vma ent, local_end, global_end;
bbeee7ea 12821 size_t i, offset;
2cf0635d 12822 unsigned char * data;
bbeee7ea 12823 int addr_size;
ccb4c951 12824
91d6fa6a 12825 ent = pltgot;
ccb4c951
RS		 12826 addr_size = (is_32bit_elf ? 4 : 8);
12827 local_end = pltgot + local_gotno * addr_size;
12828 global_end = local_end + (symtabno - gotsym) * addr_size;
12829
12830 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12831 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 12832 global_end - pltgot, 1,
12833 _("Global Offset Table data"));
59245841
NC		 12834 if (data == NULL)
12835 return 0;
12836
ccb4c951
RS		 12837 printf (_("\nPrimary GOT:\n"));
12838 printf (_(" Canonical gp value: "));
12839 print_vma (pltgot + 0x7ff0, LONG_HEX);
12840 printf ("\n\n");
12841
12842 printf (_(" Reserved entries:\n"));
12843 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12844 addr_size * 2, _("Address"), _("Access"),
12845 addr_size * 2, _("Initial"));
91d6fa6a 12846 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12847 printf (_(" Lazy resolver\n"));
ccb4c951 12848 if (data
91d6fa6a 12849 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12850 >> (addr_size * 8 - 1)) != 0)
12851 {
91d6fa6a 12852 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12853 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12854 }
12855 printf ("\n");
12856
91d6fa6a 12857 if (ent < local_end)
ccb4c951
RS		 12858 {
12859 printf (_(" Local entries:\n"));
cc5914eb 12860 printf (" %*s %10s %*s\n",
2b692964
NC		 12861 addr_size * 2, _("Address"), _("Access"),
12862 addr_size * 2, _("Initial"));
91d6fa6a 12863 while (ent < local_end)
ccb4c951 12864 {
91d6fa6a 12865 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12866 printf ("\n");
12867 }
12868 printf ("\n");
12869 }
12870
12871 if (gotsym < symtabno)
12872 {
12873 int sym_width;
12874
12875 printf (_(" Global entries:\n"));
cc5914eb 12876 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 12877 addr_size * 2, _("Address"),
12878 _("Access"),
2b692964 12879 addr_size * 2, _("Initial"),
9cf03b7e
NC		 12880 addr_size * 2, _("Sym.Val."),
12881 _("Type"),
12882 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12883 _("Ndx"), _("Name"));
0b4362b0 12884
ccb4c951
RS		 12885 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12886 for (i = gotsym; i < symtabno; i++)
12887 {
2cf0635d 12888 Elf_Internal_Sym * psym;
ccb4c951
RS		 12889
12890 psym = dynamic_symbols + i;
91d6fa6a 12891 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12892 printf (" ");
12893 print_vma (psym->st_value, LONG_HEX);
12894 printf (" %-7s %3s ",
12895 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12896 get_symbol_index_type (psym->st_shndx));
12897 if (VALID_DYNAMIC_NAME (psym->st_name))
12898 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12899 else
2b692964 12900 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12901 printf ("\n");
12902 }
12903 printf ("\n");
12904 }
12905
12906 if (data)
12907 free (data);
12908 }
12909
861fb55a
DJ		 12910 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12911 {
91d6fa6a 12912 bfd_vma ent, end;
861fb55a
DJ		 12913 size_t offset, rel_offset;
12914 unsigned long count, i;
2cf0635d 12915 unsigned char * data;
861fb55a 12916 int addr_size, sym_width;
2cf0635d 12917 Elf_Internal_Rela * rels;
861fb55a
DJ		 12918
12919 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12920 if (pltrel == DT_RELA)
12921 {
12922 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12923 return 0;
12924 }
12925 else
12926 {
12927 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12928 return 0;
12929 }
12930
91d6fa6a 12931 ent = mips_pltgot;
861fb55a
DJ		 12932 addr_size = (is_32bit_elf ? 4 : 8);
12933 end = mips_pltgot + (2 + count) * addr_size;
12934
12935 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12936 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12937 1, _("Procedure Linkage Table data"));
59245841
NC		 12938 if (data == NULL)
12939 return 0;
12940
9cf03b7e 12941 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 12942 printf (_(" Reserved entries:\n"));
12943 printf (_(" %*s %*s Purpose\n"),
2b692964 12944 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12945 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12946 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12947 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12948 printf (_(" Module pointer\n"));
861fb55a
DJ		 12949 printf ("\n");
12950
12951 printf (_(" Entries:\n"));
cc5914eb 12952 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12953 addr_size * 2, _("Address"),
12954 addr_size * 2, _("Initial"),
12955 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12956 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12957 for (i = 0; i < count; i++)
12958 {
2cf0635d 12959 Elf_Internal_Sym * psym;
861fb55a
DJ		 12960
12961 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12962 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12963 printf (" ");
12964 print_vma (psym->st_value, LONG_HEX);
12965 printf (" %-7s %3s ",
12966 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12967 get_symbol_index_type (psym->st_shndx));
12968 if (VALID_DYNAMIC_NAME (psym->st_name))
12969 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12970 else
2b692964 12971 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12972 printf ("\n");
12973 }
12974 printf ("\n");
12975
12976 if (data)
12977 free (data);
12978 free (rels);
12979 }
12980
252b5132
RH		 12981 return 1;
12982}
12983
047b2264 12984static int
2cf0635d 12985process_gnu_liblist (FILE * file)
047b2264 12986{
2cf0635d
NC		 12987 Elf_Internal_Shdr * section;
12988 Elf_Internal_Shdr * string_sec;
12989 Elf32_External_Lib * elib;
12990 char * strtab;
c256ffe7 12991 size_t strtab_size;
047b2264
JJ		 12992 size_t cnt;
12993 unsigned i;
12994
12995 if (! do_arch)
12996 return 0;
12997
12998 for (i = 0, section = section_headers;
12999 i < elf_header.e_shnum;
b34976b6 13000 i++, section++)
047b2264
JJ		 13001 {
13002 switch (section->sh_type)
13003 {
13004 case SHT_GNU_LIBLIST:
4fbb74a6 13005 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 13006 break;
13007
3f5e193b
NC		 13008 elib = (Elf32_External_Lib *)
13009 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 13010 _("liblist section data"));
047b2264
JJ		 13011
13012 if (elib == NULL)
13013 break;
4fbb74a6 13014 string_sec = section_headers + section->sh_link;
047b2264 13015
3f5e193b
NC		 13016 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13017 string_sec->sh_size,
13018 _("liblist string table"));
047b2264
JJ		 13019 if (strtab == NULL
13020 || section->sh_entsize != sizeof (Elf32_External_Lib))
13021 {
13022 free (elib);
2842702f 13023 free (strtab);
047b2264
JJ		 13024 break;
13025 }
59245841 13026 strtab_size = string_sec->sh_size;
047b2264
JJ		 13027
13028 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13029 SECTION_NAME (section),
0af1713e 13030 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 13031
2b692964 13032 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 13033
13034 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13035 ++cnt)
13036 {
13037 Elf32_Lib liblist;
91d6fa6a 13038 time_t atime;
047b2264 13039 char timebuf[20];
2cf0635d 13040 struct tm * tmp;
047b2264
JJ		 13041
13042 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13043 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 13044 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13045 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13046 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13047
91d6fa6a 13048 tmp = gmtime (&atime);
e9e44622
JJ		 13049 snprintf (timebuf, sizeof (timebuf),
13050 "%04u-%02u-%02uT%02u:%02u:%02u",
13051 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13052 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 13053
13054 printf ("%3lu: ", (unsigned long) cnt);
13055 if (do_wide)
c256ffe7 13056 printf ("%-20s", liblist.l_name < strtab_size
2b692964 13057 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 13058 else
c256ffe7 13059 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 13060 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 13061 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13062 liblist.l_version, liblist.l_flags);
13063 }
13064
13065 free (elib);
2842702f 13066 free (strtab);
047b2264
JJ		 13067 }
13068 }
13069
13070 return 1;
13071}
13072
9437c45b 13073static const char *
d3ba0551 13074get_note_type (unsigned e_type)
779fe533
NC		 13075{
13076 static char buff[64];
103f02d3 13077
1ec5cd37
NC		 13078 if (elf_header.e_type == ET_CORE)
13079 switch (e_type)
13080 {
57346661 13081 case NT_AUXV:
1ec5cd37 13082 return _("NT_AUXV (auxiliary vector)");
57346661 13083 case NT_PRSTATUS:
1ec5cd37 13084 return _("NT_PRSTATUS (prstatus structure)");
57346661 13085 case NT_FPREGSET:
1ec5cd37 13086 return _("NT_FPREGSET (floating point registers)");
57346661 13087 case NT_PRPSINFO:
1ec5cd37 13088 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 13089 case NT_TASKSTRUCT:
1ec5cd37 13090 return _("NT_TASKSTRUCT (task structure)");
57346661 13091 case NT_PRXFPREG:
1ec5cd37 13092 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 13093 case NT_PPC_VMX:
13094 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 13095 case NT_PPC_VSX:
13096 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 13097 case NT_386_TLS:
13098 return _("NT_386_TLS (x86 TLS information)");
13099 case NT_386_IOPERM:
13100 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 13101 case NT_X86_XSTATE:
13102 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 13103 case NT_S390_HIGH_GPRS:
13104 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 13105 case NT_S390_TIMER:
13106 return _("NT_S390_TIMER (s390 timer register)");
13107 case NT_S390_TODCMP:
13108 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13109 case NT_S390_TODPREG:
13110 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13111 case NT_S390_CTRS:
13112 return _("NT_S390_CTRS (s390 control registers)");
13113 case NT_S390_PREFIX:
13114 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 13115 case NT_S390_LAST_BREAK:
13116 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13117 case NT_S390_SYSTEM_CALL:
13118 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 13119 case NT_S390_TDB:
13120 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW		 13121 case NT_ARM_VFP:
13122 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 13123 case NT_ARM_TLS:
13124 return _("NT_ARM_TLS (AArch TLS registers)");
13125 case NT_ARM_HW_BREAK:
13126 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13127 case NT_ARM_HW_WATCH:
13128 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 13129 case NT_PSTATUS:
1ec5cd37 13130 return _("NT_PSTATUS (pstatus structure)");
57346661 13131 case NT_FPREGS:
1ec5cd37 13132 return _("NT_FPREGS (floating point registers)");
57346661 13133 case NT_PSINFO:
1ec5cd37 13134 return _("NT_PSINFO (psinfo structure)");
57346661 13135 case NT_LWPSTATUS:
1ec5cd37 13136 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 13137 case NT_LWPSINFO:
1ec5cd37 13138 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 13139 case NT_WIN32PSTATUS:
1ec5cd37 13140 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 13141 case NT_SIGINFO:
13142 return _("NT_SIGINFO (siginfo_t data)");
13143 case NT_FILE:
13144 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 13145 default:
13146 break;
13147 }
13148 else
13149 switch (e_type)
13150 {
13151 case NT_VERSION:
13152 return _("NT_VERSION (version)");
13153 case NT_ARCH:
13154 return _("NT_ARCH (architecture)");
13155 default:
13156 break;
13157 }
13158
e9e44622 13159 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 13160 return buff;
779fe533
NC		 13161}
13162
9ece1fa9
TT		 13163static int
13164print_core_note (Elf_Internal_Note *pnote)
13165{
13166 unsigned int addr_size = is_32bit_elf ? 4 : 8;
13167 bfd_vma count, page_size;
13168 unsigned char *descdata, *filenames, *descend;
13169
13170 if (pnote->type != NT_FILE)
13171 return 1;
13172
13173#ifndef BFD64
13174 if (!is_32bit_elf)
13175 {
13176 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13177 /* Still "successful". */
13178 return 1;
13179 }
13180#endif
13181
13182 if (pnote->descsz < 2 * addr_size)
13183 {
13184 printf (_(" Malformed note - too short for header\n"));
13185 return 0;
13186 }
13187
13188 descdata = (unsigned char *) pnote->descdata;
13189 descend = descdata + pnote->descsz;
13190
13191 if (descdata[pnote->descsz - 1] != '\0')
13192 {
13193 printf (_(" Malformed note - does not end with \\0\n"));
13194 return 0;
13195 }
13196
13197 count = byte_get (descdata, addr_size);
13198 descdata += addr_size;
13199
13200 page_size = byte_get (descdata, addr_size);
13201 descdata += addr_size;
13202
13203 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13204 {
13205 printf (_(" Malformed note - too short for supplied file count\n"));
13206 return 0;
13207 }
13208
13209 printf (_(" Page size: "));
13210 print_vma (page_size, DEC);
13211 printf ("\n");
13212
13213 printf (_(" %*s%*s%*s\n"),
13214 (int) (2 + 2 * addr_size), _("Start"),
13215 (int) (4 + 2 * addr_size), _("End"),
13216 (int) (4 + 2 * addr_size), _("Page Offset"));
13217 filenames = descdata + count * 3 * addr_size;
13218 while (--count > 0)
13219 {
13220 bfd_vma start, end, file_ofs;
13221
13222 if (filenames == descend)
13223 {
13224 printf (_(" Malformed note - filenames end too early\n"));
13225 return 0;
13226 }
13227
13228 start = byte_get (descdata, addr_size);
13229 descdata += addr_size;
13230 end = byte_get (descdata, addr_size);
13231 descdata += addr_size;
13232 file_ofs = byte_get (descdata, addr_size);
13233 descdata += addr_size;
13234
13235 printf (" ");
13236 print_vma (start, FULL_HEX);
13237 printf (" ");
13238 print_vma (end, FULL_HEX);
13239 printf (" ");
13240 print_vma (file_ofs, FULL_HEX);
13241 printf ("\n %s\n", filenames);
13242
13243 filenames += 1 + strlen ((char *) filenames);
13244 }
13245
13246 return 1;
13247}
13248
1118d252
RM		 13249static const char *
13250get_gnu_elf_note_type (unsigned e_type)
13251{
13252 static char buff[64];
13253
13254 switch (e_type)
13255 {
13256 case NT_GNU_ABI_TAG:
13257 return _("NT_GNU_ABI_TAG (ABI version tag)");
13258 case NT_GNU_HWCAP:
13259 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13260 case NT_GNU_BUILD_ID:
13261 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 13262 case NT_GNU_GOLD_VERSION:
13263 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 13264 default:
13265 break;
13266 }
13267
13268 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13269 return buff;
13270}
13271
664f90a3
TT		 13272static int
13273print_gnu_note (Elf_Internal_Note *pnote)
13274{
13275 switch (pnote->type)
13276 {
13277 case NT_GNU_BUILD_ID:
13278 {
13279 unsigned long i;
13280
13281 printf (_(" Build ID: "));
13282 for (i = 0; i < pnote->descsz; ++i)
13283 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 13284 printf ("\n");
664f90a3
TT		 13285 }
13286 break;
13287
13288 case NT_GNU_ABI_TAG:
13289 {
13290 unsigned long os, major, minor, subminor;
13291 const char *osname;
13292
13293 os = byte_get ((unsigned char *) pnote->descdata, 4);
13294 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13295 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13296 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13297
13298 switch (os)
13299 {
13300 case GNU_ABI_TAG_LINUX:
13301 osname = "Linux";
13302 break;
13303 case GNU_ABI_TAG_HURD:
13304 osname = "Hurd";
13305 break;
13306 case GNU_ABI_TAG_SOLARIS:
13307 osname = "Solaris";
13308 break;
13309 case GNU_ABI_TAG_FREEBSD:
13310 osname = "FreeBSD";
13311 break;
13312 case GNU_ABI_TAG_NETBSD:
13313 osname = "NetBSD";
13314 break;
13315 default:
13316 osname = "Unknown";
13317 break;
13318 }
13319
13320 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13321 major, minor, subminor);
13322 }
13323 break;
13324 }
13325
13326 return 1;
13327}
13328
9437c45b 13329static const char *
d3ba0551 13330get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 13331{
13332 static char buff[64];
13333
b4db1224 13334 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 13335 {
13336 /* NetBSD core "procinfo" structure. */
13337 return _("NetBSD procinfo structure");
13338 }
13339
13340 /* As of Jan 2002 there are no other machine-independent notes
13341 defined for NetBSD core files. If the note type is less
13342 than the start of the machine-dependent note types, we don't
13343 understand it. */
13344
b4db1224 13345 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 13346 {
e9e44622 13347 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 13348 return buff;
13349 }
13350
13351 switch (elf_header.e_machine)
13352 {
13353 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13354 and PT_GETFPREGS == mach+2. */
13355
13356 case EM_OLD_ALPHA:
13357 case EM_ALPHA:
13358 case EM_SPARC:
13359 case EM_SPARC32PLUS:
13360 case EM_SPARCV9:
13361 switch (e_type)
13362 {
2b692964 13363 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 13364 return _("PT_GETREGS (reg structure)");
2b692964 13365 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 13366 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13367 default:
13368 break;
13369 }
13370 break;
13371
13372 /* On all other arch's, PT_GETREGS == mach+1 and
13373 PT_GETFPREGS == mach+3. */
13374 default:
13375 switch (e_type)
13376 {
2b692964 13377 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 13378 return _("PT_GETREGS (reg structure)");
2b692964 13379 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 13380 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13381 default:
13382 break;
13383 }
13384 }
13385
9cf03b7e 13386 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 13387 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 13388 return buff;
13389}
13390
70616151
TT		 13391static const char *
13392get_stapsdt_note_type (unsigned e_type)
13393{
13394 static char buff[64];
13395
13396 switch (e_type)
13397 {
13398 case NT_STAPSDT:
13399 return _("NT_STAPSDT (SystemTap probe descriptors)");
13400
13401 default:
13402 break;
13403 }
13404
13405 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13406 return buff;
13407}
13408
c6a9fc58
TT		 13409static int
13410print_stapsdt_note (Elf_Internal_Note *pnote)
13411{
13412 int addr_size = is_32bit_elf ? 4 : 8;
13413 char *data = pnote->descdata;
13414 char *data_end = pnote->descdata + pnote->descsz;
13415 bfd_vma pc, base_addr, semaphore;
13416 char *provider, *probe, *arg_fmt;
13417
13418 pc = byte_get ((unsigned char *) data, addr_size);
13419 data += addr_size;
13420 base_addr = byte_get ((unsigned char *) data, addr_size);
13421 data += addr_size;
13422 semaphore = byte_get ((unsigned char *) data, addr_size);
13423 data += addr_size;
13424
13425 provider = data;
13426 data += strlen (data) + 1;
13427 probe = data;
13428 data += strlen (data) + 1;
13429 arg_fmt = data;
13430 data += strlen (data) + 1;
13431
13432 printf (_(" Provider: %s\n"), provider);
13433 printf (_(" Name: %s\n"), probe);
13434 printf (_(" Location: "));
13435 print_vma (pc, FULL_HEX);
13436 printf (_(", Base: "));
13437 print_vma (base_addr, FULL_HEX);
13438 printf (_(", Semaphore: "));
13439 print_vma (semaphore, FULL_HEX);
9cf03b7e 13440 printf ("\n");
c6a9fc58
TT		 13441 printf (_(" Arguments: %s\n"), arg_fmt);
13442
13443 return data == data_end;
13444}
13445
00e98fc7
TG		 13446static const char *
13447get_ia64_vms_note_type (unsigned e_type)
13448{
13449 static char buff[64];
13450
13451 switch (e_type)
13452 {
13453 case NT_VMS_MHD:
13454 return _("NT_VMS_MHD (module header)");
13455 case NT_VMS_LNM:
13456 return _("NT_VMS_LNM (language name)");
13457 case NT_VMS_SRC:
13458 return _("NT_VMS_SRC (source files)");
13459 case NT_VMS_TITLE:
9cf03b7e 13460 return "NT_VMS_TITLE";
00e98fc7
TG		 13461 case NT_VMS_EIDC:
13462 return _("NT_VMS_EIDC (consistency check)");
13463 case NT_VMS_FPMODE:
13464 return _("NT_VMS_FPMODE (FP mode)");
13465 case NT_VMS_LINKTIME:
9cf03b7e 13466 return "NT_VMS_LINKTIME";
00e98fc7
TG		 13467 case NT_VMS_IMGNAM:
13468 return _("NT_VMS_IMGNAM (image name)");
13469 case NT_VMS_IMGID:
13470 return _("NT_VMS_IMGID (image id)");
13471 case NT_VMS_LINKID:
13472 return _("NT_VMS_LINKID (link id)");
13473 case NT_VMS_IMGBID:
13474 return _("NT_VMS_IMGBID (build id)");
13475 case NT_VMS_GSTNAM:
13476 return _("NT_VMS_GSTNAM (sym table name)");
13477 case NT_VMS_ORIG_DYN:
9cf03b7e 13478 return "NT_VMS_ORIG_DYN";
00e98fc7 13479 case NT_VMS_PATCHTIME:
9cf03b7e 13480 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 13481 default:
13482 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13483 return buff;
13484 }
13485}
13486
13487static int
13488print_ia64_vms_note (Elf_Internal_Note * pnote)
13489{
13490 switch (pnote->type)
13491 {
13492 case NT_VMS_MHD:
13493 if (pnote->descsz > 36)
13494 {
13495 size_t l = strlen (pnote->descdata + 34);
13496 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13497 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13498 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13499 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13500 }
13501 else
13502 printf (_(" Invalid size\n"));
13503 break;
13504 case NT_VMS_LNM:
13505 printf (_(" Language: %s\n"), pnote->descdata);
13506 break;
13507#ifdef BFD64
13508 case NT_VMS_FPMODE:
9cf03b7e 13509 printf (_(" Floating Point mode: "));
4a5cb34f 13510 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13511 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13512 break;
13513 case NT_VMS_LINKTIME:
13514 printf (_(" Link time: "));
13515 print_vms_time
13516 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13517 printf ("\n");
13518 break;
13519 case NT_VMS_PATCHTIME:
13520 printf (_(" Patch time: "));
13521 print_vms_time
13522 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13523 printf ("\n");
13524 break;
13525 case NT_VMS_ORIG_DYN:
13526 printf (_(" Major id: %u, minor id: %u\n"),
13527 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13528 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 13529 printf (_(" Last modified : "));
00e98fc7
TG		 13530 print_vms_time
13531 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 13532 printf (_("\n Link flags : "));
4a5cb34f 13533 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13534 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13535 printf (_(" Header flags: 0x%08x\n"),
13536 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13537 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13538 break;
13539#endif
13540 case NT_VMS_IMGNAM:
13541 printf (_(" Image name: %s\n"), pnote->descdata);
13542 break;
13543 case NT_VMS_GSTNAM:
13544 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13545 break;
13546 case NT_VMS_IMGID:
13547 printf (_(" Image id: %s\n"), pnote->descdata);
13548 break;
13549 case NT_VMS_LINKID:
13550 printf (_(" Linker id: %s\n"), pnote->descdata);
13551 break;
13552 default:
13553 break;
13554 }
13555 return 1;
13556}
13557
6d118b09
NC		 13558/* Note that by the ELF standard, the name field is already null byte
13559 terminated, and namesz includes the terminating null byte.
13560 I.E. the value of namesz for the name "FSF" is 4.
13561
e3c8793a 13562 If the value of namesz is zero, there is no name present. */
779fe533 13563static int
2cf0635d 13564process_note (Elf_Internal_Note * pnote)
779fe533 13565{
2cf0635d
NC		 13566 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13567 const char * nt;
9437c45b
JT		 13568
13569 if (pnote->namesz == 0)
1ec5cd37
NC		 13570 /* If there is no note name, then use the default set of
13571 note type strings. */
13572 nt = get_note_type (pnote->type);
13573
1118d252
RM		 13574 else if (const_strneq (pnote->namedata, "GNU"))
13575 /* GNU-specific object file notes. */
13576 nt = get_gnu_elf_note_type (pnote->type);
13577
0112cd26 13578 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 13579 /* NetBSD-specific core file notes. */
13580 nt = get_netbsd_elfcore_note_type (pnote->type);
13581
b15fa79e
AM		 13582 else if (strneq (pnote->namedata, "SPU/", 4))
13583 {
13584 /* SPU-specific core file notes. */
13585 nt = pnote->namedata + 4;
13586 name = "SPU";
13587 }
13588
00e98fc7
TG		 13589 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13590 /* VMS/ia64-specific file notes. */
13591 nt = get_ia64_vms_note_type (pnote->type);
13592
70616151
TT		 13593 else if (const_strneq (pnote->namedata, "stapsdt"))
13594 nt = get_stapsdt_note_type (pnote->type);
13595
9437c45b 13596 else
1ec5cd37
NC		 13597 /* Don't recognize this note name; just use the default set of
13598 note type strings. */
00e98fc7 13599 nt = get_note_type (pnote->type);
9437c45b 13600
2aee03ae 13601 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 13602
13603 if (const_strneq (pnote->namedata, "IPF/VMS"))
13604 return print_ia64_vms_note (pnote);
664f90a3
TT		 13605 else if (const_strneq (pnote->namedata, "GNU"))
13606 return print_gnu_note (pnote);
c6a9fc58
TT		 13607 else if (const_strneq (pnote->namedata, "stapsdt"))
13608 return print_stapsdt_note (pnote);
9ece1fa9
TT		 13609 else if (const_strneq (pnote->namedata, "CORE"))
13610 return print_core_note (pnote);
00e98fc7
TG		 13611 else
13612 return 1;
779fe533
NC		 13613}
13614
6d118b09 13615
779fe533 13616static int
2cf0635d 13617process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 13618{
2cf0635d
NC		 13619 Elf_External_Note * pnotes;
13620 Elf_External_Note * external;
b34976b6 13621 int res = 1;
103f02d3 13622
779fe533
NC		 13623 if (length <= 0)
13624 return 0;
103f02d3 13625
3f5e193b 13626 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 13627 _("notes"));
dd24e3da 13628 if (pnotes == NULL)
a6e9f9df 13629 return 0;
779fe533 13630
103f02d3 13631 external = pnotes;
103f02d3 13632
9dd3a467 13633 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13634 (unsigned long) offset, (unsigned long) length);
2aee03ae 13635 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13636
15b42fb0 13637 while ((char *) external < (char *) pnotes + length)
779fe533 13638 {
b34976b6 13639 Elf_Internal_Note inote;
15b42fb0
AM		 13640 size_t min_notesz;
13641 char *next;
2cf0635d 13642 char * temp = NULL;
15b42fb0 13643 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 13644
00e98fc7 13645 if (!is_ia64_vms ())
15b42fb0 13646 {
9dd3a467
NC		 13647 /* PR binutils/15191
13648 Make sure that there is enough data to read. */
15b42fb0
AM		 13649 min_notesz = offsetof (Elf_External_Note, name);
13650 if (data_remaining < min_notesz)
9dd3a467
NC		 13651 {
13652 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13653 (int) data_remaining);
13654 break;
13655 }
15b42fb0
AM		 13656 inote.type = BYTE_GET (external->type);
13657 inote.namesz = BYTE_GET (external->namesz);
13658 inote.namedata = external->name;
13659 inote.descsz = BYTE_GET (external->descsz);
13660 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13661 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13662 next = inote.descdata + align_power (inote.descsz, 2);
13663 }
00e98fc7 13664 else
15b42fb0
AM		 13665 {
13666 Elf64_External_VMS_Note *vms_external;
00e98fc7 13667
9dd3a467
NC		 13668 /* PR binutils/15191
13669 Make sure that there is enough data to read. */
15b42fb0
AM		 13670 min_notesz = offsetof (Elf64_External_VMS_Note, name);
13671 if (data_remaining < min_notesz)
9dd3a467
NC		 13672 {
13673 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13674 (int) data_remaining);
13675 break;
13676 }
3e55a963 13677
15b42fb0
AM		 13678 vms_external = (Elf64_External_VMS_Note *) external;
13679 inote.type = BYTE_GET (vms_external->type);
13680 inote.namesz = BYTE_GET (vms_external->namesz);
13681 inote.namedata = vms_external->name;
13682 inote.descsz = BYTE_GET (vms_external->descsz);
13683 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13684 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13685 next = inote.descdata + align_power (inote.descsz, 3);
13686 }
13687
13688 if (inote.descdata < (char *) external + min_notesz
13689 || next < (char *) external + min_notesz
13690 || data_remaining < (size_t)(next - (char *) external))
3e55a963 13691 {
15b42fb0 13692 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 13693 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 13694 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 13695 inote.type, inote.namesz, inote.descsz);
13696 break;
13697 }
13698
15b42fb0 13699 external = (Elf_External_Note *) next;
dd24e3da 13700
6d118b09
NC		 13701 /* Verify that name is null terminated. It appears that at least
13702 one version of Linux (RedHat 6.0) generates corefiles that don't
13703 comply with the ELF spec by failing to include the null byte in
13704 namesz. */
8b971f9f 13705 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13706 {
3f5e193b 13707 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13708
6d118b09
NC		 13709 if (temp == NULL)
13710 {
13711 error (_("Out of memory\n"));
13712 res = 0;
13713 break;
13714 }
76da6bbe 13715
6d118b09
NC		 13716 strncpy (temp, inote.namedata, inote.namesz);
13717 temp[inote.namesz] = 0;
76da6bbe 13718
6d118b09
NC		 13719 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13720 inote.namedata = temp;
13721 }
13722
13723 res &= process_note (& inote);
103f02d3 13724
6d118b09
NC		 13725 if (temp != NULL)
13726 {
13727 free (temp);
13728 temp = NULL;
13729 }
779fe533
NC		 13730 }
13731
13732 free (pnotes);
103f02d3 13733
779fe533
NC		 13734 return res;
13735}
13736
13737static int
2cf0635d 13738process_corefile_note_segments (FILE * file)
779fe533 13739{
2cf0635d 13740 Elf_Internal_Phdr * segment;
b34976b6
AM		 13741 unsigned int i;
13742 int res = 1;
103f02d3 13743
d93f0186 13744 if (! get_program_headers (file))
779fe533 13745 return 0;
103f02d3 13746
779fe533
NC		 13747 for (i = 0, segment = program_headers;
13748 i < elf_header.e_phnum;
b34976b6 13749 i++, segment++)
779fe533
NC		 13750 {
13751 if (segment->p_type == PT_NOTE)
103f02d3 13752 res &= process_corefile_note_segment (file,
30800947
NC		 13753 (bfd_vma) segment->p_offset,
13754 (bfd_vma) segment->p_filesz);
779fe533 13755 }
103f02d3 13756
779fe533
NC		 13757 return res;
13758}
13759
13760static int
2cf0635d 13761process_note_sections (FILE * file)
1ec5cd37 13762{
2cf0635d 13763 Elf_Internal_Shdr * section;
1ec5cd37
NC		 13764 unsigned long i;
13765 int res = 1;
13766
13767 for (i = 0, section = section_headers;
fa1908fd 13768 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 13769 i++, section++)
13770 if (section->sh_type == SHT_NOTE)
13771 res &= process_corefile_note_segment (file,
13772 (bfd_vma) section->sh_offset,
13773 (bfd_vma) section->sh_size);
13774
13775 return res;
13776}
13777
13778static int
2cf0635d 13779process_notes (FILE * file)
779fe533
NC		 13780{
13781 /* If we have not been asked to display the notes then do nothing. */
13782 if (! do_notes)
13783 return 1;
103f02d3 13784
779fe533 13785 if (elf_header.e_type != ET_CORE)
1ec5cd37 13786 return process_note_sections (file);
103f02d3 13787
779fe533 13788 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 13789 if (elf_header.e_phnum > 0)
13790 return process_corefile_note_segments (file);
779fe533 13791
1ec5cd37
NC		 13792 printf (_("No note segments present in the core file.\n"));
13793 return 1;
779fe533
NC		 13794}
13795
252b5132 13796static int
2cf0635d 13797process_arch_specific (FILE * file)
252b5132 13798{
a952a375
NC		 13799 if (! do_arch)
13800 return 1;
13801
252b5132
RH		 13802 switch (elf_header.e_machine)
13803 {
11c1ff18
PB		 13804 case EM_ARM:
13805 return process_arm_specific (file);
252b5132 13806 case EM_MIPS:
4fe85591 13807 case EM_MIPS_RS3_LE:
252b5132
RH		 13808 return process_mips_specific (file);
13809 break;
34c8bcba
JM		 13810 case EM_PPC:
13811 return process_power_specific (file);
13812 break;
9e8c70f9
DM		 13813 case EM_SPARC:
13814 case EM_SPARC32PLUS:
13815 case EM_SPARCV9:
13816 return process_sparc_specific (file);
13817 break;
59e6276b
JM		 13818 case EM_TI_C6000:
13819 return process_tic6x_specific (file);
13820 break;
13761a11
NC		 13821 case EM_MSP430:
13822 return process_msp430x_specific (file);
252b5132
RH		 13823 default:
13824 break;
13825 }
13826 return 1;
13827}
13828
13829static int
2cf0635d 13830get_file_header (FILE * file)
252b5132 13831{
9ea033b2
NC		 13832 /* Read in the identity array. */
13833 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13834 return 0;
13835
9ea033b2 13836 /* Determine how to read the rest of the header. */
b34976b6 13837 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13838 {
13839 default: /* fall through */
13840 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13841 case ELFDATA2LSB:
13842 byte_get = byte_get_little_endian;
13843 byte_put = byte_put_little_endian;
13844 break;
13845 case ELFDATA2MSB:
13846 byte_get = byte_get_big_endian;
13847 byte_put = byte_put_big_endian;
13848 break;
9ea033b2
NC		 13849 }
13850
13851 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13852 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13853
13854 /* Read in the rest of the header. */
13855 if (is_32bit_elf)
13856 {
13857 Elf32_External_Ehdr ehdr32;
252b5132 13858
9ea033b2
NC		 13859 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13860 return 0;
103f02d3 13861
9ea033b2
NC		 13862 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13863 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13864 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13865 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13866 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13867 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13868 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13869 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13870 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13871 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13872 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13873 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13874 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13875 }
252b5132 13876 else
9ea033b2
NC		 13877 {
13878 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13879
13880 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13881 we will not be able to cope with the 64bit data found in
13882 64 ELF files. Detect this now and abort before we start
50c2245b 13883 overwriting things. */
a952a375
NC		 13884 if (sizeof (bfd_vma) < 8)
13885 {
e3c8793a
NC		 13886 error (_("This instance of readelf has been built without support for a\n\
1388764 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13888 return 0;
13889 }
103f02d3 13890
9ea033b2
NC		 13891 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13892 return 0;
103f02d3 13893
9ea033b2
NC		 13894 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13895 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13896 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13897 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13898 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13899 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13900 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13901 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13902 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13903 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13904 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13905 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13906 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13907 }
252b5132 13908
7ece0d85
JJ		 13909 if (elf_header.e_shoff)
13910 {
13911 /* There may be some extensions in the first section header. Don't
13912 bomb if we can't read it. */
13913 if (is_32bit_elf)
13914 get_32bit_section_headers (file, 1);
13915 else
13916 get_64bit_section_headers (file, 1);
13917 }
560f3c1c 13918
252b5132
RH		 13919 return 1;
13920}
13921
fb52b2f4
NC		 13922/* Process one ELF object file according to the command line options.
13923 This file may actually be stored in an archive. The file is
13924 positioned at the start of the ELF object. */
13925
ff78d6d6 13926static int
2cf0635d 13927process_object (char * file_name, FILE * file)
252b5132 13928{
252b5132
RH		 13929 unsigned int i;
13930
252b5132
RH		 13931 if (! get_file_header (file))
13932 {
13933 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13934 return 1;
252b5132
RH		 13935 }
13936
13937 /* Initialise per file variables. */
60bca95a 13938 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13939 version_info[i] = 0;
13940
60bca95a 13941 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13942 dynamic_info[i] = 0;
5115b233 13943 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13944
13945 /* Process the file. */
13946 if (show_name)
13947 printf (_("\nFile: %s\n"), file_name);
13948
18bd398b
NC		 13949 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13950 Note we do this even if cmdline_dump_sects is empty because we
13951 must make sure that the dump_sets array is zeroed out before each
13952 object file is processed. */
13953 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13954 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13955
13956 if (num_cmdline_dump_sects > 0)
13957 {
13958 if (num_dump_sects == 0)
13959 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13960 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13961
13962 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13963 memcpy (dump_sects, cmdline_dump_sects,
13964 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13965 }
d70c5fc7 13966
252b5132 13967 if (! process_file_header ())
fb52b2f4 13968 return 1;
252b5132 13969
d1f5c6e3 13970 if (! process_section_headers (file))
2f62977e 13971 {
d1f5c6e3
L		 13972 /* Without loaded section headers we cannot process lots of
13973 things. */
2f62977e 13974 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13975
2f62977e 13976 if (! do_using_dynamic)
2c610e4b 13977 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13978 }
252b5132 13979
d1f5c6e3
L		 13980 if (! process_section_groups (file))
13981 {
13982 /* Without loaded section groups we cannot process unwind. */
13983 do_unwind = 0;
13984 }
13985
2f62977e 13986 if (process_program_headers (file))
b2d38a17 13987 process_dynamic_section (file);
252b5132
RH		 13988
13989 process_relocs (file);
13990
4d6ed7c8
NC		 13991 process_unwind (file);
13992
252b5132
RH		 13993 process_symbol_table (file);
13994
13995 process_syminfo (file);
13996
13997 process_version_sections (file);
13998
13999 process_section_contents (file);
f5842774 14000
1ec5cd37 14001 process_notes (file);
103f02d3 14002
047b2264
JJ		 14003 process_gnu_liblist (file);
14004
252b5132
RH		 14005 process_arch_specific (file);
14006
d93f0186
NC		 14007 if (program_headers)
14008 {
14009 free (program_headers);
14010 program_headers = NULL;
14011 }
14012
252b5132
RH		 14013 if (section_headers)
14014 {
14015 free (section_headers);
14016 section_headers = NULL;
14017 }
14018
14019 if (string_table)
14020 {
14021 free (string_table);
14022 string_table = NULL;
d40ac9bd 14023 string_table_length = 0;
252b5132
RH		 14024 }
14025
14026 if (dynamic_strings)
14027 {
14028 free (dynamic_strings);
14029 dynamic_strings = NULL;
d79b3d50 14030 dynamic_strings_length = 0;
252b5132
RH		 14031 }
14032
14033 if (dynamic_symbols)
14034 {
14035 free (dynamic_symbols);
14036 dynamic_symbols = NULL;
19936277 14037 num_dynamic_syms = 0;
252b5132
RH		 14038 }
14039
14040 if (dynamic_syminfo)
14041 {
14042 free (dynamic_syminfo);
14043 dynamic_syminfo = NULL;
14044 }
ff78d6d6 14045
293c573e
MR		 14046 if (dynamic_section)
14047 {
14048 free (dynamic_section);
14049 dynamic_section = NULL;
14050 }
14051
e4b17d5c
L		 14052 if (section_headers_groups)
14053 {
14054 free (section_headers_groups);
14055 section_headers_groups = NULL;
14056 }
14057
14058 if (section_groups)
14059 {
2cf0635d
NC		 14060 struct group_list * g;
14061 struct group_list * next;
e4b17d5c
L		 14062
14063 for (i = 0; i < group_count; i++)
14064 {
14065 for (g = section_groups [i].root; g != NULL; g = next)
14066 {
14067 next = g->next;
14068 free (g);
14069 }
14070 }
14071
14072 free (section_groups);
14073 section_groups = NULL;
14074 }
14075
19e6b90e 14076 free_debug_memory ();
18bd398b 14077
ff78d6d6 14078 return 0;
252b5132
RH		 14079}
14080
2cf0635d
NC		 14081/* Process an ELF archive.
14082 On entry the file is positioned just after the ARMAG string. */
14083
14084static int
14085process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14086{
14087 struct archive_info arch;
14088 struct archive_info nested_arch;
14089 size_t got;
2cf0635d
NC		 14090 int ret;
14091
14092 show_name = 1;
14093
14094 /* The ARCH structure is used to hold information about this archive. */
14095 arch.file_name = NULL;
14096 arch.file = NULL;
14097 arch.index_array = NULL;
14098 arch.sym_table = NULL;
14099 arch.longnames = NULL;
14100
14101 /* The NESTED_ARCH structure is used as a single-item cache of information
14102 about a nested archive (when members of a thin archive reside within
14103 another regular archive file). */
14104 nested_arch.file_name = NULL;
14105 nested_arch.file = NULL;
14106 nested_arch.index_array = NULL;
14107 nested_arch.sym_table = NULL;
14108 nested_arch.longnames = NULL;
14109
14110 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14111 {
14112 ret = 1;
14113 goto out;
4145f1d5 14114 }
fb52b2f4 14115
4145f1d5
NC		 14116 if (do_archive_index)
14117 {
2cf0635d 14118 if (arch.sym_table == NULL)
4145f1d5
NC		 14119 error (_("%s: unable to dump the index as none was found\n"), file_name);
14120 else
14121 {
2cf0635d 14122 unsigned int i, l;
4145f1d5
NC		 14123 unsigned long current_pos;
14124
14125 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 14126 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 14127 current_pos = ftell (file);
14128
2cf0635d 14129 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 14130 {
2cf0635d
NC		 14131 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14132 {
14133 char * member_name;
4145f1d5 14134
2cf0635d
NC		 14135 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14136
14137 if (member_name != NULL)
14138 {
14139 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14140
14141 if (qualified_name != NULL)
14142 {
c2a7d3f5
NC		 14143 printf (_("Contents of binary %s at offset "), qualified_name);
14144 (void) print_vma (arch.index_array[i], PREFIX_HEX);
14145 putchar ('\n');
2cf0635d
NC		 14146 free (qualified_name);
14147 }
4145f1d5
NC		 14148 }
14149 }
2cf0635d
NC		 14150
14151 if (l >= arch.sym_size)
4145f1d5
NC		 14152 {
14153 error (_("%s: end of the symbol table reached before the end of the index\n"),
14154 file_name);
cb8f3167 14155 break;
4145f1d5 14156 }
2cf0635d
NC		 14157 printf ("\t%s\n", arch.sym_table + l);
14158 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 14159 }
14160
c2a7d3f5
NC		 14161 if (arch.uses_64bit_indicies)
14162 l = (l + 7) & ~ 7;
14163 else
14164 l += l & 1;
14165
2cf0635d 14166 if (l < arch.sym_size)
c2a7d3f5
NC		 14167 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14168 file_name, arch.sym_size - l);
4145f1d5 14169
4145f1d5
NC		 14170 if (fseek (file, current_pos, SEEK_SET) != 0)
14171 {
14172 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 14173 ret = 1;
14174 goto out;
4145f1d5 14175 }
fb52b2f4 14176 }
4145f1d5
NC		 14177
14178 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14179 && !do_segments && !do_header && !do_dump && !do_version
14180 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 14181 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 14182 {
14183 ret = 0; /* Archive index only. */
14184 goto out;
14185 }
fb52b2f4
NC		 14186 }
14187
d989285c 14188 ret = 0;
fb52b2f4
NC		 14189
14190 while (1)
14191 {
2cf0635d
NC		 14192 char * name;
14193 size_t namelen;
14194 char * qualified_name;
14195
14196 /* Read the next archive header. */
14197 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14198 {
14199 error (_("%s: failed to seek to next archive header\n"), file_name);
14200 return 1;
14201 }
14202 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14203 if (got != sizeof arch.arhdr)
14204 {
14205 if (got == 0)
14206 break;
14207 error (_("%s: failed to read archive header\n"), file_name);
14208 ret = 1;
14209 break;
14210 }
14211 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14212 {
14213 error (_("%s: did not find a valid archive header\n"), arch.file_name);
14214 ret = 1;
14215 break;
14216 }
14217
14218 arch.next_arhdr_offset += sizeof arch.arhdr;
14219
14220 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14221 if (archive_file_size & 01)
14222 ++archive_file_size;
14223
14224 name = get_archive_member_name (&arch, &nested_arch);
14225 if (name == NULL)
fb52b2f4 14226 {
0fd3a477 14227 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 14228 ret = 1;
14229 break;
fb52b2f4 14230 }
2cf0635d 14231 namelen = strlen (name);
fb52b2f4 14232
2cf0635d
NC		 14233 qualified_name = make_qualified_name (&arch, &nested_arch, name);
14234 if (qualified_name == NULL)
fb52b2f4 14235 {
2cf0635d 14236 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 14237 ret = 1;
14238 break;
fb52b2f4
NC		 14239 }
14240
2cf0635d
NC		 14241 if (is_thin_archive && arch.nested_member_origin == 0)
14242 {
14243 /* This is a proxy for an external member of a thin archive. */
14244 FILE * member_file;
14245 char * member_file_name = adjust_relative_path (file_name, name, namelen);
14246 if (member_file_name == NULL)
14247 {
14248 ret = 1;
14249 break;
14250 }
14251
14252 member_file = fopen (member_file_name, "rb");
14253 if (member_file == NULL)
14254 {
14255 error (_("Input file '%s' is not readable.\n"), member_file_name);
14256 free (member_file_name);
14257 ret = 1;
14258 break;
14259 }
14260
14261 archive_file_offset = arch.nested_member_origin;
14262
14263 ret |= process_object (qualified_name, member_file);
14264
14265 fclose (member_file);
14266 free (member_file_name);
14267 }
14268 else if (is_thin_archive)
14269 {
a043396b
NC		 14270 /* PR 15140: Allow for corrupt thin archives. */
14271 if (nested_arch.file == NULL)
14272 {
14273 error (_("%s: contains corrupt thin archive: %s\n"),
14274 file_name, name);
14275 ret = 1;
14276 break;
14277 }
14278
2cf0635d
NC		 14279 /* This is a proxy for a member of a nested archive. */
14280 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14281
14282 /* The nested archive file will have been opened and setup by
14283 get_archive_member_name. */
14284 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14285 {
14286 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14287 ret = 1;
14288 break;
14289 }
14290
14291 ret |= process_object (qualified_name, nested_arch.file);
14292 }
14293 else
14294 {
14295 archive_file_offset = arch.next_arhdr_offset;
14296 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 14297
2cf0635d
NC		 14298 ret |= process_object (qualified_name, file);
14299 }
fb52b2f4 14300
2b52916e
L		 14301 if (dump_sects != NULL)
14302 {
14303 free (dump_sects);
14304 dump_sects = NULL;
14305 num_dump_sects = 0;
14306 }
14307
2cf0635d 14308 free (qualified_name);
fb52b2f4
NC		 14309 }
14310
4145f1d5 14311 out:
2cf0635d
NC		 14312 if (nested_arch.file != NULL)
14313 fclose (nested_arch.file);
14314 release_archive (&nested_arch);
14315 release_archive (&arch);
fb52b2f4 14316
d989285c 14317 return ret;
fb52b2f4
NC		 14318}
14319
14320static int
2cf0635d 14321process_file (char * file_name)
fb52b2f4 14322{
2cf0635d 14323 FILE * file;
fb52b2f4
NC		 14324 struct stat statbuf;
14325 char armag[SARMAG];
14326 int ret;
14327
14328 if (stat (file_name, &statbuf) < 0)
14329 {
f24ddbdd
NC		 14330 if (errno == ENOENT)
14331 error (_("'%s': No such file\n"), file_name);
14332 else
14333 error (_("Could not locate '%s'. System error message: %s\n"),
14334 file_name, strerror (errno));
14335 return 1;
14336 }
14337
14338 if (! S_ISREG (statbuf.st_mode))
14339 {
14340 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 14341 return 1;
14342 }
14343
14344 file = fopen (file_name, "rb");
14345 if (file == NULL)
14346 {
f24ddbdd 14347 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 14348 return 1;
14349 }
14350
14351 if (fread (armag, SARMAG, 1, file) != 1)
14352 {
4145f1d5 14353 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 14354 fclose (file);
14355 return 1;
14356 }
14357
14358 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 14359 ret = process_archive (file_name, file, FALSE);
14360 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14361 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 14362 else
14363 {
4145f1d5
NC		 14364 if (do_archive_index)
14365 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14366 file_name);
14367
fb52b2f4
NC		 14368 rewind (file);
14369 archive_file_size = archive_file_offset = 0;
14370 ret = process_object (file_name, file);
14371 }
14372
14373 fclose (file);
14374
14375 return ret;
14376}
14377
252b5132
RH		 14378#ifdef SUPPORT_DISASSEMBLY
14379/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 14380 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 14381 symbols. */
252b5132
RH		 14382
14383void
2cf0635d 14384print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 14385{
14386 fprintf (outfile,"0x%8.8x", addr);
14387}
14388
e3c8793a 14389/* Needed by the i386 disassembler. */
252b5132
RH		 14390void
14391db_task_printsym (unsigned int addr)
14392{
14393 print_address (addr, stderr);
14394}
14395#endif
14396
14397int
2cf0635d 14398main (int argc, char ** argv)
252b5132 14399{
ff78d6d6
L		 14400 int err;
14401
252b5132
RH		 14402#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14403 setlocale (LC_MESSAGES, "");
3882b010
L		 14404#endif
14405#if defined (HAVE_SETLOCALE)
14406 setlocale (LC_CTYPE, "");
252b5132
RH		 14407#endif
14408 bindtextdomain (PACKAGE, LOCALEDIR);
14409 textdomain (PACKAGE);
14410
869b9d07
MM		 14411 expandargv (&argc, &argv);
14412
252b5132
RH		 14413 parse_args (argc, argv);
14414
18bd398b 14415 if (num_dump_sects > 0)
59f14fc0 14416 {
18bd398b 14417 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 14418 cmdline_dump_sects = (dump_type *)
14419 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 14420 if (cmdline_dump_sects == NULL)
591a748a 14421 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 14422 else
14423 {
09c11c86
NC		 14424 memcpy (cmdline_dump_sects, dump_sects,
14425 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 14426 num_cmdline_dump_sects = num_dump_sects;
14427 }
14428 }
14429
18bd398b
NC		 14430 if (optind < (argc - 1))
14431 show_name = 1;
14432
ff78d6d6 14433 err = 0;
252b5132 14434 while (optind < argc)
18bd398b 14435 err |= process_file (argv[optind++]);
252b5132
RH		 14436
14437 if (dump_sects != NULL)
14438 free (dump_sects);
59f14fc0
AS		 14439 if (cmdline_dump_sects != NULL)
14440 free (cmdline_dump_sects);
252b5132 14441
ff78d6d6 14442 return err;
252b5132 14443}
A mirror of the official binutils-gdb repository