]> 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
* objcopy.c (copy_main): Initialize context variable.
[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"
3b16e843 134#include "elf/or32.h"
7d466069 135#include "elf/pj.h"
3b16e843 136#include "elf/ppc.h"
c833c019 137#include "elf/ppc64.h"
99c513f6 138#include "elf/rl78.h"
c7927a3c 139#include "elf/rx.h"
a85d7ed0 140#include "elf/s390.h"
1c0d3aa6 141#include "elf/score.h"
3b16e843
NC		 142#include "elf/sh.h"
143#include "elf/sparc.h"
e9f53129 144#include "elf/spu.h"
40b36596 145#include "elf/tic6x.h"
aa137e4d
NC		 146#include "elf/tilegx.h"
147#include "elf/tilepro.h"
3b16e843 148#include "elf/v850.h"
179d3252 149#include "elf/vax.h"
3b16e843 150#include "elf/x86-64.h"
c29aca4a 151#include "elf/xc16x.h"
f6c1a2d5 152#include "elf/xgate.h"
93fbbb04 153#include "elf/xstormy16.h"
88da6820 154#include "elf/xtensa.h"
252b5132 155
36591ba1
SL		 156#include "elf/nios2.h"
157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
2cf0635d 163char * program_name = "readelf";
85b1c36d
BE		 164static long archive_file_offset;
165static unsigned long archive_file_size;
166static unsigned long dynamic_addr;
167static bfd_size_type dynamic_size;
168static unsigned int dynamic_nent;
2cf0635d 169static char * dynamic_strings;
85b1c36d 170static unsigned long dynamic_strings_length;
2cf0635d 171static char * string_table;
85b1c36d
BE		 172static unsigned long string_table_length;
173static unsigned long num_dynamic_syms;
2cf0635d
NC		 174static Elf_Internal_Sym * dynamic_symbols;
175static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 176static unsigned long dynamic_syminfo_offset;
177static unsigned int dynamic_syminfo_nent;
f8eae8b2 178static char program_interpreter[PATH_MAX];
bb8a0291 179static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 180static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 181static bfd_vma version_info[16];
182static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 183static Elf_Internal_Shdr * section_headers;
184static Elf_Internal_Phdr * program_headers;
185static Elf_Internal_Dyn * dynamic_section;
186static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 187static int show_name;
188static int do_dynamic;
189static int do_syms;
2c610e4b 190static int do_dyn_syms;
85b1c36d
BE		 191static int do_reloc;
192static int do_sections;
193static int do_section_groups;
5477e8a0 194static int do_section_details;
85b1c36d
BE		 195static int do_segments;
196static int do_unwind;
197static int do_using_dynamic;
198static int do_header;
199static int do_dump;
200static int do_version;
85b1c36d
BE		 201static int do_histogram;
202static int do_debugging;
85b1c36d
BE		 203static int do_arch;
204static int do_notes;
4145f1d5 205static int do_archive_index;
85b1c36d 206static int is_32bit_elf;
252b5132 207
e4b17d5c
L		 208struct group_list
209{
2cf0635d 210 struct group_list * next;
e4b17d5c
L		 211 unsigned int section_index;
212};
213
214struct group
215{
2cf0635d 216 struct group_list * root;
e4b17d5c
L		 217 unsigned int group_index;
218};
219
85b1c36d 220static size_t group_count;
2cf0635d
NC		 221static struct group * section_groups;
222static struct group ** section_headers_groups;
e4b17d5c 223
09c11c86
NC		 224
225/* Flag bits indicating particular types of dump. */
226#define HEX_DUMP (1 << 0) /* The -x command line switch. */
227#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
228#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
229#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 230#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 231
232typedef unsigned char dump_type;
233
234/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 235struct dump_list_entry
236{
2cf0635d 237 char * name;
09c11c86 238 dump_type type;
2cf0635d 239 struct dump_list_entry * next;
aef1f6d0 240};
2cf0635d 241static struct dump_list_entry * dump_sects_byname;
aef1f6d0 242
09c11c86
NC		 243/* A dynamic array of flags indicating for which sections a dump
244 has been requested via command line switches. */
245static dump_type * cmdline_dump_sects = NULL;
246static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 247
248/* A dynamic array of flags indicating for which sections a dump of
249 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 250 basis and then initialised from the cmdline_dump_sects array,
251 the results of interpreting the -w switch, and the
252 dump_sects_byname list. */
09c11c86
NC		 253static dump_type * dump_sects = NULL;
254static unsigned int num_dump_sects = 0;
252b5132 255
252b5132 256
c256ffe7 257/* How to print a vma value. */
843dd992
NC		 258typedef enum print_mode
259{
260 HEX,
261 DEC,
262 DEC_5,
263 UNSIGNED,
264 PREFIX_HEX,
265 FULL_HEX,
266 LONG_HEX
267}
268print_mode;
269
9c19a809
NC		 270#define UNKNOWN -1
271
2b692964
NC		 272#define SECTION_NAME(X) \
273 ((X) == NULL ? _("<none>") \
274 : string_table == NULL ? _("<no-name>") \
275 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 276 : string_table + (X)->sh_name))
252b5132 277
ee42cf8c 278#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 279
ba5cdace
NC		 280#define GET_ELF_SYMBOLS(file, section, sym_count) \
281 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
282 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 283
d79b3d50
NC		 284#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
285/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
286 already been called and verified that the string exists. */
287#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 288
61865e30
NC		 289#define REMOVE_ARCH_BITS(ADDR) \
290 do \
291 { \
292 if (elf_header.e_machine == EM_ARM) \
293 (ADDR) &= ~1; \
294 } \
295 while (0)
d79b3d50 296\f
59245841
NC		 297/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
298 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
299 using malloc and fill that. In either case return the pointer to the start of
300 the retrieved data or NULL if something went wrong. If something does go wrong
301 emit an error message using REASON as part of the context. */
302
c256ffe7 303static void *
2cf0635d
NC		 304get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
305 const char * reason)
a6e9f9df 306{
2cf0635d 307 void * mvar;
a6e9f9df 308
c256ffe7 309 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 310 return NULL;
311
fb52b2f4 312 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 313 {
0fd3a477 314 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 315 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 316 return NULL;
317 }
318
319 mvar = var;
320 if (mvar == NULL)
321 {
c256ffe7
JJ		 322 /* Check for overflow. */
323 if (nmemb < (~(size_t) 0 - 1) / size)
324 /* + 1 so that we can '\0' terminate invalid string table sections. */
325 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 326
327 if (mvar == NULL)
328 {
0fd3a477
JW		 329 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
330 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 331 return NULL;
332 }
c256ffe7
JJ		 333
334 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 335 }
336
c256ffe7 337 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 338 {
0fd3a477
JW		 339 error (_("Unable to read in 0x%lx bytes of %s\n"),
340 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 341 if (mvar != var)
342 free (mvar);
343 return NULL;
344 }
345
346 return mvar;
347}
348
14a91970 349/* Print a VMA value. */
cb8f3167 350
66543521 351static int
14a91970 352print_vma (bfd_vma vma, print_mode mode)
66543521 353{
66543521
AM		 354 int nc = 0;
355
14a91970 356 switch (mode)
66543521 357 {
14a91970
AM		 358 case FULL_HEX:
359 nc = printf ("0x");
360 /* Drop through. */
66543521 361
14a91970 362 case LONG_HEX:
f7a99963 363#ifdef BFD64
14a91970 364 if (is_32bit_elf)
437c2fb7 365 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 366#endif
14a91970
AM		 367 printf_vma (vma);
368 return nc + 16;
b19aac67 369
14a91970
AM		 370 case DEC_5:
371 if (vma <= 99999)
372 return printf ("%5" BFD_VMA_FMT "d", vma);
373 /* Drop through. */
66543521 374
14a91970
AM		 375 case PREFIX_HEX:
376 nc = printf ("0x");
377 /* Drop through. */
66543521 378
14a91970
AM		 379 case HEX:
380 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 381
14a91970
AM		 382 case DEC:
383 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 384
14a91970
AM		 385 case UNSIGNED:
386 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 387 }
66543521 388 return 0;
f7a99963
NC		 389}
390
7bfd842d 391/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 392 multibye characters (assuming the host environment supports them).
31104126 393
7bfd842d
NC		 394 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
395
396 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
397 padding as necessary.
171191ba
NC		 398
399 Returns the number of emitted characters. */
400
401static unsigned int
7a88bc9c 402print_symbol (int width, const char *symbol)
31104126 403{
171191ba 404 bfd_boolean extra_padding = FALSE;
7bfd842d 405 int num_printed = 0;
3bfcb652 406#ifdef HAVE_MBSTATE_T
7bfd842d 407 mbstate_t state;
3bfcb652 408#endif
7bfd842d 409 int width_remaining;
961c521f 410
7bfd842d 411 if (width < 0)
961c521f 412 {
961c521f
NC		 413 /* Keep the width positive. This also helps. */
414 width = - width;
171191ba 415 extra_padding = TRUE;
7bfd842d 416 }
961c521f 417
7bfd842d
NC		 418 if (do_wide)
419 /* Set the remaining width to a very large value.
420 This simplifies the code below. */
421 width_remaining = INT_MAX;
422 else
423 width_remaining = width;
cb8f3167 424
3bfcb652 425#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 426 /* Initialise the multibyte conversion state. */
427 memset (& state, 0, sizeof (state));
3bfcb652 428#endif
961c521f 429
7bfd842d
NC		 430 while (width_remaining)
431 {
432 size_t n;
7bfd842d 433 const char c = *symbol++;
961c521f 434
7bfd842d 435 if (c == 0)
961c521f
NC		 436 break;
437
7bfd842d
NC		 438 /* Do not print control characters directly as they can affect terminal
439 settings. Such characters usually appear in the names generated
440 by the assembler for local labels. */
441 if (ISCNTRL (c))
961c521f 442 {
7bfd842d 443 if (width_remaining < 2)
961c521f
NC		 444 break;
445
7bfd842d
NC		 446 printf ("^%c", c + 0x40);
447 width_remaining -= 2;
171191ba 448 num_printed += 2;
961c521f 449 }
7bfd842d
NC		 450 else if (ISPRINT (c))
451 {
452 putchar (c);
453 width_remaining --;
454 num_printed ++;
455 }
961c521f
NC		 456 else
457 {
3bfcb652
NC		 458#ifdef HAVE_MBSTATE_T
459 wchar_t w;
460#endif
7bfd842d
NC		 461 /* Let printf do the hard work of displaying multibyte characters. */
462 printf ("%.1s", symbol - 1);
463 width_remaining --;
464 num_printed ++;
465
3bfcb652 466#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 467 /* Try to find out how many bytes made up the character that was
468 just printed. Advance the symbol pointer past the bytes that
469 were displayed. */
470 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 471#else
472 n = 1;
473#endif
7bfd842d
NC		 474 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
475 symbol += (n - 1);
961c521f 476 }
961c521f 477 }
171191ba 478
7bfd842d 479 if (extra_padding && num_printed < width)
171191ba
NC		 480 {
481 /* Fill in the remaining spaces. */
7bfd842d
NC		 482 printf ("%-*s", width - num_printed, " ");
483 num_printed = width;
171191ba
NC		 484 }
485
486 return num_printed;
31104126
NC		 487}
488
89fac5e3
RS		 489/* Return a pointer to section NAME, or NULL if no such section exists. */
490
491static Elf_Internal_Shdr *
2cf0635d 492find_section (const char * name)
89fac5e3
RS		 493{
494 unsigned int i;
495
496 for (i = 0; i < elf_header.e_shnum; i++)
497 if (streq (SECTION_NAME (section_headers + i), name))
498 return section_headers + i;
499
500 return NULL;
501}
502
0b6ae522
DJ		 503/* Return a pointer to a section containing ADDR, or NULL if no such
504 section exists. */
505
506static Elf_Internal_Shdr *
507find_section_by_address (bfd_vma addr)
508{
509 unsigned int i;
510
511 for (i = 0; i < elf_header.e_shnum; i++)
512 {
513 Elf_Internal_Shdr *sec = section_headers + i;
514 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
515 return sec;
516 }
517
518 return NULL;
519}
520
657d0d47
CC		 521/* Return a pointer to section NAME, or NULL if no such section exists,
522 restricted to the list of sections given in SET. */
523
524static Elf_Internal_Shdr *
525find_section_in_set (const char * name, unsigned int * set)
526{
527 unsigned int i;
528
529 if (set != NULL)
530 {
531 while ((i = *set++) > 0)
532 if (streq (SECTION_NAME (section_headers + i), name))
533 return section_headers + i;
534 }
535
536 return find_section (name);
537}
538
0b6ae522
DJ		 539/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
540 bytes read. */
541
542static unsigned long
543read_uleb128 (unsigned char *data, unsigned int *length_return)
544{
545 return read_leb128 (data, length_return, 0);
546}
547
28f997cf
TG		 548/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
549 This OS has so many departures from the ELF standard that we test it at
550 many places. */
551
552static inline int
553is_ia64_vms (void)
554{
555 return elf_header.e_machine == EM_IA_64
556 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
557}
558
bcedfee6 559/* Guess the relocation size commonly used by the specific machines. */
252b5132 560
252b5132 561static int
2dc4cec1 562guess_is_rela (unsigned int e_machine)
252b5132 563{
9c19a809 564 switch (e_machine)
252b5132
RH		 565 {
566 /* Targets that use REL relocations. */
252b5132
RH		 567 case EM_386:
568 case EM_486:
63fcb9e9 569 case EM_960:
e9f53129 570 case EM_ARM:
2b0337b0 571 case EM_D10V:
252b5132 572 case EM_CYGNUS_D10V:
e9f53129 573 case EM_DLX:
252b5132 574 case EM_MIPS:
4fe85591 575 case EM_MIPS_RS3_LE:
e9f53129
AM		 576 case EM_CYGNUS_M32R:
577 case EM_OPENRISC:
578 case EM_OR32:
1c0d3aa6 579 case EM_SCORE:
f6c1a2d5 580 case EM_XGATE:
9c19a809 581 return FALSE;
103f02d3 582
252b5132
RH		 583 /* Targets that use RELA relocations. */
584 case EM_68K:
e9f53129 585 case EM_860:
a06ea964 586 case EM_AARCH64:
cfb8c092 587 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 588 case EM_ALPHA:
589 case EM_ALTERA_NIOS2:
590 case EM_AVR:
591 case EM_AVR_OLD:
592 case EM_BLACKFIN:
60bca95a 593 case EM_CR16:
e9f53129
AM		 594 case EM_CRIS:
595 case EM_CRX:
2b0337b0 596 case EM_D30V:
252b5132 597 case EM_CYGNUS_D30V:
2b0337b0 598 case EM_FR30:
252b5132 599 case EM_CYGNUS_FR30:
5c70f934 600 case EM_CYGNUS_FRV:
e9f53129
AM		 601 case EM_H8S:
602 case EM_H8_300:
603 case EM_H8_300H:
800eeca4 604 case EM_IA_64:
1e4cf259
NC		 605 case EM_IP2K:
606 case EM_IP2K_OLD:
3b36097d 607 case EM_IQ2000:
84e94c90 608 case EM_LATTICEMICO32:
ff7eeb89 609 case EM_M32C_OLD:
49f58d10 610 case EM_M32C:
e9f53129
AM		 611 case EM_M32R:
612 case EM_MCORE:
15ab5209 613 case EM_CYGNUS_MEP:
a3c62988 614 case EM_METAG:
e9f53129
AM		 615 case EM_MMIX:
616 case EM_MN10200:
617 case EM_CYGNUS_MN10200:
618 case EM_MN10300:
619 case EM_CYGNUS_MN10300:
5506d11a 620 case EM_MOXIE:
e9f53129
AM		 621 case EM_MSP430:
622 case EM_MSP430_OLD:
d031aafb 623 case EM_MT:
64fd6348 624 case EM_NIOS32:
e9f53129
AM		 625 case EM_PPC64:
626 case EM_PPC:
99c513f6 627 case EM_RL78:
c7927a3c 628 case EM_RX:
e9f53129
AM		 629 case EM_S390:
630 case EM_S390_OLD:
631 case EM_SH:
632 case EM_SPARC:
633 case EM_SPARC32PLUS:
634 case EM_SPARCV9:
635 case EM_SPU:
40b36596 636 case EM_TI_C6000:
aa137e4d
NC		 637 case EM_TILEGX:
638 case EM_TILEPRO:
708e2187 639 case EM_V800:
e9f53129
AM		 640 case EM_V850:
641 case EM_CYGNUS_V850:
642 case EM_VAX:
643 case EM_X86_64:
8a9036a4 644 case EM_L1OM:
7a9068fe 645 case EM_K1OM:
e9f53129
AM		 646 case EM_XSTORMY16:
647 case EM_XTENSA:
648 case EM_XTENSA_OLD:
7ba29e2a
NC		 649 case EM_MICROBLAZE:
650 case EM_MICROBLAZE_OLD:
9c19a809 651 return TRUE;
103f02d3 652
e9f53129
AM		 653 case EM_68HC05:
654 case EM_68HC08:
655 case EM_68HC11:
656 case EM_68HC16:
657 case EM_FX66:
658 case EM_ME16:
d1133906 659 case EM_MMA:
d1133906
NC		 660 case EM_NCPU:
661 case EM_NDR1:
e9f53129 662 case EM_PCP:
d1133906 663 case EM_ST100:
e9f53129 664 case EM_ST19:
d1133906 665 case EM_ST7:
e9f53129
AM		 666 case EM_ST9PLUS:
667 case EM_STARCORE:
d1133906 668 case EM_SVX:
e9f53129 669 case EM_TINYJ:
9c19a809
NC		 670 default:
671 warn (_("Don't know about relocations on this machine architecture\n"));
672 return FALSE;
673 }
674}
252b5132 675
9c19a809 676static int
2cf0635d 677slurp_rela_relocs (FILE * file,
d3ba0551
AM		 678 unsigned long rel_offset,
679 unsigned long rel_size,
2cf0635d
NC		 680 Elf_Internal_Rela ** relasp,
681 unsigned long * nrelasp)
9c19a809 682{
2cf0635d 683 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 684 unsigned long nrelas;
685 unsigned int i;
252b5132 686
4d6ed7c8
NC		 687 if (is_32bit_elf)
688 {
2cf0635d 689 Elf32_External_Rela * erelas;
103f02d3 690
3f5e193b 691 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 692 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 693 if (!erelas)
694 return 0;
252b5132 695
4d6ed7c8 696 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 697
3f5e193b
NC		 698 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
699 sizeof (Elf_Internal_Rela));
103f02d3 700
4d6ed7c8
NC		 701 if (relas == NULL)
702 {
c256ffe7 703 free (erelas);
591a748a 704 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 705 return 0;
706 }
103f02d3 707
4d6ed7c8
NC		 708 for (i = 0; i < nrelas; i++)
709 {
710 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
711 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 712 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 713 }
103f02d3 714
4d6ed7c8
NC		 715 free (erelas);
716 }
717 else
718 {
2cf0635d 719 Elf64_External_Rela * erelas;
103f02d3 720
3f5e193b 721 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 722 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 723 if (!erelas)
724 return 0;
4d6ed7c8
NC		 725
726 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 727
3f5e193b
NC		 728 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
729 sizeof (Elf_Internal_Rela));
103f02d3 730
4d6ed7c8
NC		 731 if (relas == NULL)
732 {
c256ffe7 733 free (erelas);
591a748a 734 error (_("out of memory parsing relocs\n"));
4d6ed7c8 735 return 0;
9c19a809 736 }
4d6ed7c8
NC		 737
738 for (i = 0; i < nrelas; i++)
9c19a809 739 {
66543521
AM		 740 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
741 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 742 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 743
744 /* The #ifdef BFD64 below is to prevent a compile time
745 warning. We know that if we do not have a 64 bit data
746 type that we will never execute this code anyway. */
747#ifdef BFD64
748 if (elf_header.e_machine == EM_MIPS
749 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
750 {
751 /* In little-endian objects, r_info isn't really a
752 64-bit little-endian value: it has a 32-bit
753 little-endian symbol index followed by four
754 individual byte fields. Reorder INFO
755 accordingly. */
91d6fa6a
NC		 756 bfd_vma inf = relas[i].r_info;
757 inf = (((inf & 0xffffffff) << 32)
758 | ((inf >> 56) & 0xff)
759 | ((inf >> 40) & 0xff00)
760 | ((inf >> 24) & 0xff0000)
761 | ((inf >> 8) & 0xff000000));
762 relas[i].r_info = inf;
861fb55a
DJ		 763 }
764#endif /* BFD64 */
4d6ed7c8 765 }
103f02d3 766
4d6ed7c8
NC		 767 free (erelas);
768 }
769 *relasp = relas;
770 *nrelasp = nrelas;
771 return 1;
772}
103f02d3 773
4d6ed7c8 774static int
2cf0635d 775slurp_rel_relocs (FILE * file,
d3ba0551
AM		 776 unsigned long rel_offset,
777 unsigned long rel_size,
2cf0635d
NC		 778 Elf_Internal_Rela ** relsp,
779 unsigned long * nrelsp)
4d6ed7c8 780{
2cf0635d 781 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 782 unsigned long nrels;
783 unsigned int i;
103f02d3 784
4d6ed7c8
NC		 785 if (is_32bit_elf)
786 {
2cf0635d 787 Elf32_External_Rel * erels;
103f02d3 788
3f5e193b 789 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 790 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 791 if (!erels)
792 return 0;
103f02d3 793
4d6ed7c8 794 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 795
3f5e193b 796 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 797
4d6ed7c8
NC		 798 if (rels == NULL)
799 {
c256ffe7 800 free (erels);
591a748a 801 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 802 return 0;
803 }
804
805 for (i = 0; i < nrels; i++)
806 {
807 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
808 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 809 rels[i].r_addend = 0;
9ea033b2 810 }
4d6ed7c8
NC		 811
812 free (erels);
9c19a809
NC		 813 }
814 else
815 {
2cf0635d 816 Elf64_External_Rel * erels;
9ea033b2 817
3f5e193b 818 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 819 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 820 if (!erels)
821 return 0;
103f02d3 822
4d6ed7c8 823 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 824
3f5e193b 825 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 826
4d6ed7c8 827 if (rels == NULL)
9c19a809 828 {
c256ffe7 829 free (erels);
591a748a 830 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 831 return 0;
832 }
103f02d3 833
4d6ed7c8
NC		 834 for (i = 0; i < nrels; i++)
835 {
66543521
AM		 836 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
837 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 838 rels[i].r_addend = 0;
861fb55a
DJ		 839
840 /* The #ifdef BFD64 below is to prevent a compile time
841 warning. We know that if we do not have a 64 bit data
842 type that we will never execute this code anyway. */
843#ifdef BFD64
844 if (elf_header.e_machine == EM_MIPS
845 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
846 {
847 /* In little-endian objects, r_info isn't really a
848 64-bit little-endian value: it has a 32-bit
849 little-endian symbol index followed by four
850 individual byte fields. Reorder INFO
851 accordingly. */
91d6fa6a
NC		 852 bfd_vma inf = rels[i].r_info;
853 inf = (((inf & 0xffffffff) << 32)
854 | ((inf >> 56) & 0xff)
855 | ((inf >> 40) & 0xff00)
856 | ((inf >> 24) & 0xff0000)
857 | ((inf >> 8) & 0xff000000));
858 rels[i].r_info = inf;
861fb55a
DJ		 859 }
860#endif /* BFD64 */
4d6ed7c8 861 }
103f02d3 862
4d6ed7c8
NC		 863 free (erels);
864 }
865 *relsp = rels;
866 *nrelsp = nrels;
867 return 1;
868}
103f02d3 869
aca88567
NC		 870/* Returns the reloc type extracted from the reloc info field. */
871
872static unsigned int
873get_reloc_type (bfd_vma reloc_info)
874{
875 if (is_32bit_elf)
876 return ELF32_R_TYPE (reloc_info);
877
878 switch (elf_header.e_machine)
879 {
880 case EM_MIPS:
881 /* Note: We assume that reloc_info has already been adjusted for us. */
882 return ELF64_MIPS_R_TYPE (reloc_info);
883
884 case EM_SPARCV9:
885 return ELF64_R_TYPE_ID (reloc_info);
886
887 default:
888 return ELF64_R_TYPE (reloc_info);
889 }
890}
891
892/* Return the symbol index extracted from the reloc info field. */
893
894static bfd_vma
895get_reloc_symindex (bfd_vma reloc_info)
896{
897 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
898}
899
d3ba0551
AM		 900/* Display the contents of the relocation data found at the specified
901 offset. */
ee42cf8c 902
41e92641 903static void
2cf0635d 904dump_relocations (FILE * file,
d3ba0551
AM		 905 unsigned long rel_offset,
906 unsigned long rel_size,
2cf0635d 907 Elf_Internal_Sym * symtab,
d3ba0551 908 unsigned long nsyms,
2cf0635d 909 char * strtab,
d79b3d50 910 unsigned long strtablen,
d3ba0551 911 int is_rela)
4d6ed7c8 912{
b34976b6 913 unsigned int i;
2cf0635d 914 Elf_Internal_Rela * rels;
103f02d3 915
4d6ed7c8
NC		 916 if (is_rela == UNKNOWN)
917 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 918
4d6ed7c8
NC		 919 if (is_rela)
920 {
c8286bd1 921 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 922 return;
4d6ed7c8
NC		 923 }
924 else
925 {
926 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 927 return;
252b5132
RH		 928 }
929
410f7a12
L		 930 if (is_32bit_elf)
931 {
932 if (is_rela)
2c71103e
NC		 933 {
934 if (do_wide)
935 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
936 else
937 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
938 }
410f7a12 939 else
2c71103e
NC		 940 {
941 if (do_wide)
942 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
943 else
944 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
945 }
410f7a12 946 }
252b5132 947 else
410f7a12
L		 948 {
949 if (is_rela)
2c71103e
NC		 950 {
951 if (do_wide)
8beeaeb7 952 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 953 else
954 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
955 }
410f7a12 956 else
2c71103e
NC		 957 {
958 if (do_wide)
8beeaeb7 959 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 960 else
961 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
962 }
410f7a12 963 }
252b5132
RH		 964
965 for (i = 0; i < rel_size; i++)
966 {
2cf0635d 967 const char * rtype;
b34976b6 968 bfd_vma offset;
91d6fa6a 969 bfd_vma inf;
b34976b6
AM		 970 bfd_vma symtab_index;
971 bfd_vma type;
103f02d3 972
b34976b6 973 offset = rels[i].r_offset;
91d6fa6a 974 inf = rels[i].r_info;
103f02d3 975
91d6fa6a
NC		 976 type = get_reloc_type (inf);
977 symtab_index = get_reloc_symindex (inf);
252b5132 978
410f7a12
L		 979 if (is_32bit_elf)
980 {
39dbeff8
AM		 981 printf ("%8.8lx %8.8lx ",
982 (unsigned long) offset & 0xffffffff,
91d6fa6a 983 (unsigned long) inf & 0xffffffff);
410f7a12
L		 984 }
985 else
986 {
39dbeff8
AM		 987#if BFD_HOST_64BIT_LONG
988 printf (do_wide
989 ? "%16.16lx %16.16lx "
990 : "%12.12lx %12.12lx ",
91d6fa6a 991 offset, inf);
39dbeff8 992#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 993#ifndef __MSVCRT__
39dbeff8
AM		 994 printf (do_wide
995 ? "%16.16llx %16.16llx "
996 : "%12.12llx %12.12llx ",
91d6fa6a 997 offset, inf);
6e3d6dc1
NC		 998#else
999 printf (do_wide
1000 ? "%16.16I64x %16.16I64x "
1001 : "%12.12I64x %12.12I64x ",
91d6fa6a 1002 offset, inf);
6e3d6dc1 1003#endif
39dbeff8 1004#else
2c71103e
NC		 1005 printf (do_wide
1006 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1007 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1008 _bfd_int64_high (offset),
1009 _bfd_int64_low (offset),
91d6fa6a
NC		 1010 _bfd_int64_high (inf),
1011 _bfd_int64_low (inf));
9ea033b2 1012#endif
410f7a12 1013 }
103f02d3 1014
252b5132
RH		 1015 switch (elf_header.e_machine)
1016 {
1017 default:
1018 rtype = NULL;
1019 break;
1020
a06ea964
NC		 1021 case EM_AARCH64:
1022 rtype = elf_aarch64_reloc_type (type);
1023 break;
1024
2b0337b0 1025 case EM_M32R:
252b5132 1026 case EM_CYGNUS_M32R:
9ea033b2 1027 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1028 break;
1029
1030 case EM_386:
1031 case EM_486:
9ea033b2 1032 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1033 break;
1034
ba2685cc
AM		 1035 case EM_68HC11:
1036 case EM_68HC12:
1037 rtype = elf_m68hc11_reloc_type (type);
1038 break;
75751cd9 1039
252b5132 1040 case EM_68K:
9ea033b2 1041 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1042 break;
1043
63fcb9e9 1044 case EM_960:
9ea033b2 1045 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1046 break;
1047
adde6300 1048 case EM_AVR:
2b0337b0 1049 case EM_AVR_OLD:
adde6300
AM		 1050 rtype = elf_avr_reloc_type (type);
1051 break;
1052
9ea033b2
NC		 1053 case EM_OLD_SPARCV9:
1054 case EM_SPARC32PLUS:
1055 case EM_SPARCV9:
252b5132 1056 case EM_SPARC:
9ea033b2 1057 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1058 break;
1059
e9f53129
AM		 1060 case EM_SPU:
1061 rtype = elf_spu_reloc_type (type);
1062 break;
1063
708e2187
NC		 1064 case EM_V800:
1065 rtype = v800_reloc_type (type);
1066 break;
2b0337b0 1067 case EM_V850:
252b5132 1068 case EM_CYGNUS_V850:
9ea033b2 1069 rtype = v850_reloc_type (type);
252b5132
RH		 1070 break;
1071
2b0337b0 1072 case EM_D10V:
252b5132 1073 case EM_CYGNUS_D10V:
9ea033b2 1074 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1075 break;
1076
2b0337b0 1077 case EM_D30V:
252b5132 1078 case EM_CYGNUS_D30V:
9ea033b2 1079 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1080 break;
1081
d172d4ba
NC		 1082 case EM_DLX:
1083 rtype = elf_dlx_reloc_type (type);
1084 break;
1085
252b5132 1086 case EM_SH:
9ea033b2 1087 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1088 break;
1089
2b0337b0 1090 case EM_MN10300:
252b5132 1091 case EM_CYGNUS_MN10300:
9ea033b2 1092 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1093 break;
1094
2b0337b0 1095 case EM_MN10200:
252b5132 1096 case EM_CYGNUS_MN10200:
9ea033b2 1097 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1098 break;
1099
2b0337b0 1100 case EM_FR30:
252b5132 1101 case EM_CYGNUS_FR30:
9ea033b2 1102 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1103 break;
1104
ba2685cc
AM		 1105 case EM_CYGNUS_FRV:
1106 rtype = elf_frv_reloc_type (type);
1107 break;
5c70f934 1108
252b5132 1109 case EM_MCORE:
9ea033b2 1110 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1111 break;
1112
3c3bdf30
NC		 1113 case EM_MMIX:
1114 rtype = elf_mmix_reloc_type (type);
1115 break;
1116
5506d11a
AM		 1117 case EM_MOXIE:
1118 rtype = elf_moxie_reloc_type (type);
1119 break;
1120
2469cfa2
NC		 1121 case EM_MSP430:
1122 case EM_MSP430_OLD:
1123 rtype = elf_msp430_reloc_type (type);
1124 break;
1125
252b5132 1126 case EM_PPC:
9ea033b2 1127 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1128 break;
1129
c833c019
AM		 1130 case EM_PPC64:
1131 rtype = elf_ppc64_reloc_type (type);
1132 break;
1133
252b5132 1134 case EM_MIPS:
4fe85591 1135 case EM_MIPS_RS3_LE:
9ea033b2 1136 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1137 break;
1138
1139 case EM_ALPHA:
9ea033b2 1140 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1141 break;
1142
1143 case EM_ARM:
9ea033b2 1144 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1145 break;
1146
584da044 1147 case EM_ARC:
9ea033b2 1148 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1149 break;
1150
1151 case EM_PARISC:
69e617ca 1152 rtype = elf_hppa_reloc_type (type);
252b5132 1153 break;
7d466069 1154
b8720f9d
JL		 1155 case EM_H8_300:
1156 case EM_H8_300H:
1157 case EM_H8S:
1158 rtype = elf_h8_reloc_type (type);
1159 break;
1160
3b16e843
NC		 1161 case EM_OPENRISC:
1162 case EM_OR32:
1163 rtype = elf_or32_reloc_type (type);
1164 break;
1165
7d466069 1166 case EM_PJ:
2b0337b0 1167 case EM_PJ_OLD:
7d466069
ILT		 1168 rtype = elf_pj_reloc_type (type);
1169 break;
800eeca4
JW		 1170 case EM_IA_64:
1171 rtype = elf_ia64_reloc_type (type);
1172 break;
1b61cf92
HPN		 1173
1174 case EM_CRIS:
1175 rtype = elf_cris_reloc_type (type);
1176 break;
535c37ff
JE		 1177
1178 case EM_860:
1179 rtype = elf_i860_reloc_type (type);
1180 break;
bcedfee6
NC		 1181
1182 case EM_X86_64:
8a9036a4 1183 case EM_L1OM:
7a9068fe 1184 case EM_K1OM:
bcedfee6
NC		 1185 rtype = elf_x86_64_reloc_type (type);
1186 break;
a85d7ed0 1187
35b1837e
AM		 1188 case EM_S370:
1189 rtype = i370_reloc_type (type);
1190 break;
1191
53c7db4b
KH		 1192 case EM_S390_OLD:
1193 case EM_S390:
1194 rtype = elf_s390_reloc_type (type);
1195 break;
93fbbb04 1196
1c0d3aa6
NC		 1197 case EM_SCORE:
1198 rtype = elf_score_reloc_type (type);
1199 break;
1200
93fbbb04
GK		 1201 case EM_XSTORMY16:
1202 rtype = elf_xstormy16_reloc_type (type);
1203 break;
179d3252 1204
1fe1f39c
NC		 1205 case EM_CRX:
1206 rtype = elf_crx_reloc_type (type);
1207 break;
1208
179d3252
JT		 1209 case EM_VAX:
1210 rtype = elf_vax_reloc_type (type);
1211 break;
1e4cf259 1212
cfb8c092
NC		 1213 case EM_ADAPTEVA_EPIPHANY:
1214 rtype = elf_epiphany_reloc_type (type);
1215 break;
1216
1e4cf259
NC		 1217 case EM_IP2K:
1218 case EM_IP2K_OLD:
1219 rtype = elf_ip2k_reloc_type (type);
1220 break;
3b36097d
SC		 1221
1222 case EM_IQ2000:
1223 rtype = elf_iq2000_reloc_type (type);
1224 break;
88da6820
NC		 1225
1226 case EM_XTENSA_OLD:
1227 case EM_XTENSA:
1228 rtype = elf_xtensa_reloc_type (type);
1229 break;
a34e3ecb 1230
84e94c90
NC		 1231 case EM_LATTICEMICO32:
1232 rtype = elf_lm32_reloc_type (type);
1233 break;
1234
ff7eeb89 1235 case EM_M32C_OLD:
49f58d10
JB		 1236 case EM_M32C:
1237 rtype = elf_m32c_reloc_type (type);
1238 break;
1239
d031aafb
NS		 1240 case EM_MT:
1241 rtype = elf_mt_reloc_type (type);
a34e3ecb 1242 break;
1d65ded4
CM		 1243
1244 case EM_BLACKFIN:
1245 rtype = elf_bfin_reloc_type (type);
1246 break;
15ab5209
DB		 1247
1248 case EM_CYGNUS_MEP:
1249 rtype = elf_mep_reloc_type (type);
1250 break;
60bca95a
NC		 1251
1252 case EM_CR16:
1253 rtype = elf_cr16_reloc_type (type);
1254 break;
dd24e3da 1255
7ba29e2a
NC		 1256 case EM_MICROBLAZE:
1257 case EM_MICROBLAZE_OLD:
1258 rtype = elf_microblaze_reloc_type (type);
1259 break;
c7927a3c 1260
99c513f6
DD		 1261 case EM_RL78:
1262 rtype = elf_rl78_reloc_type (type);
1263 break;
1264
c7927a3c
NC		 1265 case EM_RX:
1266 rtype = elf_rx_reloc_type (type);
1267 break;
c29aca4a 1268
a3c62988
NC		 1269 case EM_METAG:
1270 rtype = elf_metag_reloc_type (type);
1271 break;
1272
c29aca4a
NC		 1273 case EM_XC16X:
1274 case EM_C166:
1275 rtype = elf_xc16x_reloc_type (type);
1276 break;
40b36596
JM		 1277
1278 case EM_TI_C6000:
1279 rtype = elf_tic6x_reloc_type (type);
1280 break;
aa137e4d
NC		 1281
1282 case EM_TILEGX:
1283 rtype = elf_tilegx_reloc_type (type);
1284 break;
1285
1286 case EM_TILEPRO:
1287 rtype = elf_tilepro_reloc_type (type);
1288 break;
f6c1a2d5
NC		 1289
1290 case EM_XGATE:
1291 rtype = elf_xgate_reloc_type (type);
1292 break;
36591ba1
SL		 1293
1294 case EM_ALTERA_NIOS2:
1295 rtype = elf_nios2_reloc_type (type);
1296 break;
252b5132
RH		 1297 }
1298
1299 if (rtype == NULL)
39dbeff8 1300 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1301 else
8beeaeb7 1302 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1303
7ace3541 1304 if (elf_header.e_machine == EM_ALPHA
157c2599 1305 && rtype != NULL
7ace3541
RH		 1306 && streq (rtype, "R_ALPHA_LITUSE")
1307 && is_rela)
1308 {
1309 switch (rels[i].r_addend)
1310 {
1311 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1312 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1313 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1314 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1315 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1316 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1317 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1318 default: rtype = NULL;
1319 }
1320 if (rtype)
1321 printf (" (%s)", rtype);
1322 else
1323 {
1324 putchar (' ');
1325 printf (_("<unknown addend: %lx>"),
1326 (unsigned long) rels[i].r_addend);
1327 }
1328 }
1329 else if (symtab_index)
252b5132 1330 {
af3fc3bc 1331 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1332 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1333 else
19936277 1334 {
2cf0635d 1335 Elf_Internal_Sym * psym;
19936277 1336
af3fc3bc 1337 psym = symtab + symtab_index;
103f02d3 1338
af3fc3bc 1339 printf (" ");
171191ba 1340
d8045f23
NC		 1341 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1342 {
1343 const char * name;
1344 unsigned int len;
1345 unsigned int width = is_32bit_elf ? 8 : 14;
1346
1347 /* Relocations against GNU_IFUNC symbols do not use the value
1348 of the symbol as the address to relocate against. Instead
1349 they invoke the function named by the symbol and use its
1350 result as the address for relocation.
1351
1352 To indicate this to the user, do not display the value of
1353 the symbol in the "Symbols's Value" field. Instead show
1354 its name followed by () as a hint that the symbol is
1355 invoked. */
1356
1357 if (strtab == NULL
1358 || psym->st_name == 0
1359 || psym->st_name >= strtablen)
1360 name = "??";
1361 else
1362 name = strtab + psym->st_name;
1363
1364 len = print_symbol (width, name);
1365 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1366 }
1367 else
1368 {
1369 print_vma (psym->st_value, LONG_HEX);
171191ba 1370
d8045f23
NC		 1371 printf (is_32bit_elf ? " " : " ");
1372 }
103f02d3 1373
af3fc3bc 1374 if (psym->st_name == 0)
f1ef08cb 1375 {
2cf0635d 1376 const char * sec_name = "<null>";
f1ef08cb
AM		 1377 char name_buf[40];
1378
1379 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1380 {
4fbb74a6
AM		 1381 if (psym->st_shndx < elf_header.e_shnum)
1382 sec_name
1383 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1384 else if (psym->st_shndx == SHN_ABS)
1385 sec_name = "ABS";
1386 else if (psym->st_shndx == SHN_COMMON)
1387 sec_name = "COMMON";
ac145307
BS		 1388 else if ((elf_header.e_machine == EM_MIPS
1389 && psym->st_shndx == SHN_MIPS_SCOMMON)
1390 || (elf_header.e_machine == EM_TI_C6000
1391 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1392 sec_name = "SCOMMON";
1393 else if (elf_header.e_machine == EM_MIPS
1394 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1395 sec_name = "SUNDEF";
8a9036a4 1396 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1397 || elf_header.e_machine == EM_L1OM
1398 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1399 && psym->st_shndx == SHN_X86_64_LCOMMON)
1400 sec_name = "LARGE_COMMON";
9ce701e2
L		 1401 else if (elf_header.e_machine == EM_IA_64
1402 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1403 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1404 sec_name = "ANSI_COM";
28f997cf 1405 else if (is_ia64_vms ()
148b93f2
NC		 1406 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1407 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1408 else
1409 {
1410 sprintf (name_buf, "<section 0x%x>",
1411 (unsigned int) psym->st_shndx);
1412 sec_name = name_buf;
1413 }
1414 }
1415 print_symbol (22, sec_name);
1416 }
af3fc3bc 1417 else if (strtab == NULL)
d79b3d50 1418 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1419 else if (psym->st_name >= strtablen)
d79b3d50 1420 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1421 else
2c71103e 1422 print_symbol (22, strtab + psym->st_name);
103f02d3 1423
af3fc3bc 1424 if (is_rela)
171191ba 1425 {
598aaa76 1426 bfd_signed_vma off = rels[i].r_addend;
171191ba 1427
91d6fa6a 1428 if (off < 0)
598aaa76 1429 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1430 else
598aaa76 1431 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1432 }
19936277 1433 }
252b5132 1434 }
1b228002 1435 else if (is_rela)
f7a99963 1436 {
e04d7088
L		 1437 bfd_signed_vma off = rels[i].r_addend;
1438
1439 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1440 if (off < 0)
1441 printf ("-%" BFD_VMA_FMT "x", - off);
1442 else
1443 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1444 }
252b5132 1445
157c2599
NC		 1446 if (elf_header.e_machine == EM_SPARCV9
1447 && rtype != NULL
1448 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1449 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1450
252b5132 1451 putchar ('\n');
2c71103e 1452
aca88567 1453#ifdef BFD64
53c7db4b 1454 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1455 {
91d6fa6a
NC		 1456 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1457 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1458 const char * rtype2 = elf_mips_reloc_type (type2);
1459 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1460
2c71103e
NC		 1461 printf (" Type2: ");
1462
1463 if (rtype2 == NULL)
39dbeff8
AM		 1464 printf (_("unrecognized: %-7lx"),
1465 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1466 else
1467 printf ("%-17.17s", rtype2);
1468
18bd398b 1469 printf ("\n Type3: ");
2c71103e
NC		 1470
1471 if (rtype3 == NULL)
39dbeff8
AM		 1472 printf (_("unrecognized: %-7lx"),
1473 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1474 else
1475 printf ("%-17.17s", rtype3);
1476
53c7db4b 1477 putchar ('\n');
2c71103e 1478 }
aca88567 1479#endif /* BFD64 */
252b5132
RH		 1480 }
1481
c8286bd1 1482 free (rels);
252b5132
RH		 1483}
1484
1485static const char *
d3ba0551 1486get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1487{
1488 switch (type)
1489 {
1490 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1491 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1492 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1493 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1494 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1495 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1496 case DT_MIPS_MSYM: return "MIPS_MSYM";
1497 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1498 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1499 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1500 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1501 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1502 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1503 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1504 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1505 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1506 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1507 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1508 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1509 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1510 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1511 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1512 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1513 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1514 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1515 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1516 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1517 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1518 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1519 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1520 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1521 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1522 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1523 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1524 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1525 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1526 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1527 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1528 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1529 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1530 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1531 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1532 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1533 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1534 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1535 default:
1536 return NULL;
1537 }
1538}
1539
9a097730 1540static const char *
d3ba0551 1541get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1542{
1543 switch (type)
1544 {
1545 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1546 default:
1547 return NULL;
1548 }
103f02d3
UD		 1549}
1550
7490d522
AM		 1551static const char *
1552get_ppc_dynamic_type (unsigned long type)
1553{
1554 switch (type)
1555 {
a7f2871e
AM		 1556 case DT_PPC_GOT: return "PPC_GOT";
1557 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1558 default:
1559 return NULL;
1560 }
1561}
1562
f1cb7e17 1563static const char *
d3ba0551 1564get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1565{
1566 switch (type)
1567 {
a7f2871e
AM		 1568 case DT_PPC64_GLINK: return "PPC64_GLINK";
1569 case DT_PPC64_OPD: return "PPC64_OPD";
1570 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1571 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1572 default:
1573 return NULL;
1574 }
1575}
1576
103f02d3 1577static const char *
d3ba0551 1578get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1579{
1580 switch (type)
1581 {
1582 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1583 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1584 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1585 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1586 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1587 case DT_HP_PREINIT: return "HP_PREINIT";
1588 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1589 case DT_HP_NEEDED: return "HP_NEEDED";
1590 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1591 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1592 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1593 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1594 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1595 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1596 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1597 case DT_HP_FILTERED: return "HP_FILTERED";
1598 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1599 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1600 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1601 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1602 case DT_PLT: return "PLT";
1603 case DT_PLT_SIZE: return "PLT_SIZE";
1604 case DT_DLT: return "DLT";
1605 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1606 default:
1607 return NULL;
1608 }
1609}
9a097730 1610
ecc51f48 1611static const char *
d3ba0551 1612get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1613{
1614 switch (type)
1615 {
148b93f2
NC		 1616 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1617 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1618 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1619 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1620 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1621 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1622 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1623 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1624 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1625 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1626 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1627 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1628 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1629 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1630 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1631 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1632 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1633 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1634 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1635 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1636 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1637 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1638 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1639 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1640 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1641 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1642 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1643 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1644 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1645 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1646 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1647 default:
1648 return NULL;
1649 }
1650}
1651
fabcb361
RH		 1652static const char *
1653get_alpha_dynamic_type (unsigned long type)
1654{
1655 switch (type)
1656 {
1657 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1658 default:
1659 return NULL;
1660 }
1661}
1662
1c0d3aa6
NC		 1663static const char *
1664get_score_dynamic_type (unsigned long type)
1665{
1666 switch (type)
1667 {
1668 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1669 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1670 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1671 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1672 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1673 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1674 default:
1675 return NULL;
1676 }
1677}
1678
40b36596
JM		 1679static const char *
1680get_tic6x_dynamic_type (unsigned long type)
1681{
1682 switch (type)
1683 {
1684 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1685 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1686 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1687 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1688 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1689 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1690 default:
1691 return NULL;
1692 }
1693}
1c0d3aa6 1694
36591ba1
SL		 1695static const char *
1696get_nios2_dynamic_type (unsigned long type)
1697{
1698 switch (type)
1699 {
1700 case DT_NIOS2_GP: return "NIOS2_GP";
1701 default:
1702 return NULL;
1703 }
1704}
1705
252b5132 1706static const char *
d3ba0551 1707get_dynamic_type (unsigned long type)
252b5132 1708{
e9e44622 1709 static char buff[64];
252b5132
RH		 1710
1711 switch (type)
1712 {
1713 case DT_NULL: return "NULL";
1714 case DT_NEEDED: return "NEEDED";
1715 case DT_PLTRELSZ: return "PLTRELSZ";
1716 case DT_PLTGOT: return "PLTGOT";
1717 case DT_HASH: return "HASH";
1718 case DT_STRTAB: return "STRTAB";
1719 case DT_SYMTAB: return "SYMTAB";
1720 case DT_RELA: return "RELA";
1721 case DT_RELASZ: return "RELASZ";
1722 case DT_RELAENT: return "RELAENT";
1723 case DT_STRSZ: return "STRSZ";
1724 case DT_SYMENT: return "SYMENT";
1725 case DT_INIT: return "INIT";
1726 case DT_FINI: return "FINI";
1727 case DT_SONAME: return "SONAME";
1728 case DT_RPATH: return "RPATH";
1729 case DT_SYMBOLIC: return "SYMBOLIC";
1730 case DT_REL: return "REL";
1731 case DT_RELSZ: return "RELSZ";
1732 case DT_RELENT: return "RELENT";
1733 case DT_PLTREL: return "PLTREL";
1734 case DT_DEBUG: return "DEBUG";
1735 case DT_TEXTREL: return "TEXTREL";
1736 case DT_JMPREL: return "JMPREL";
1737 case DT_BIND_NOW: return "BIND_NOW";
1738 case DT_INIT_ARRAY: return "INIT_ARRAY";
1739 case DT_FINI_ARRAY: return "FINI_ARRAY";
1740 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1741 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1742 case DT_RUNPATH: return "RUNPATH";
1743 case DT_FLAGS: return "FLAGS";
2d0e6f43 1744
d1133906
NC		 1745 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1746 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1747
05107a46 1748 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1749 case DT_PLTPADSZ: return "PLTPADSZ";
1750 case DT_MOVEENT: return "MOVEENT";
1751 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1752 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1753 case DT_POSFLAG_1: return "POSFLAG_1";
1754 case DT_SYMINSZ: return "SYMINSZ";
1755 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1756
252b5132 1757 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1758 case DT_CONFIG: return "CONFIG";
1759 case DT_DEPAUDIT: return "DEPAUDIT";
1760 case DT_AUDIT: return "AUDIT";
1761 case DT_PLTPAD: return "PLTPAD";
1762 case DT_MOVETAB: return "MOVETAB";
252b5132 1763 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1764
252b5132 1765 case DT_VERSYM: return "VERSYM";
103f02d3 1766
67a4f2b7
AO		 1767 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1768 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1769 case DT_RELACOUNT: return "RELACOUNT";
1770 case DT_RELCOUNT: return "RELCOUNT";
1771 case DT_FLAGS_1: return "FLAGS_1";
1772 case DT_VERDEF: return "VERDEF";
1773 case DT_VERDEFNUM: return "VERDEFNUM";
1774 case DT_VERNEED: return "VERNEED";
1775 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1776
019148e4 1777 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1778 case DT_USED: return "USED";
1779 case DT_FILTER: return "FILTER";
103f02d3 1780
047b2264
JJ		 1781 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1782 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1783 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1784 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1785 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1786 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1787
252b5132
RH		 1788 default:
1789 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1790 {
2cf0635d 1791 const char * result;
103f02d3 1792
252b5132
RH		 1793 switch (elf_header.e_machine)
1794 {
1795 case EM_MIPS:
4fe85591 1796 case EM_MIPS_RS3_LE:
252b5132
RH		 1797 result = get_mips_dynamic_type (type);
1798 break;
9a097730
RH		 1799 case EM_SPARCV9:
1800 result = get_sparc64_dynamic_type (type);
1801 break;
7490d522
AM		 1802 case EM_PPC:
1803 result = get_ppc_dynamic_type (type);
1804 break;
f1cb7e17
AM		 1805 case EM_PPC64:
1806 result = get_ppc64_dynamic_type (type);
1807 break;
ecc51f48
NC		 1808 case EM_IA_64:
1809 result = get_ia64_dynamic_type (type);
1810 break;
fabcb361
RH		 1811 case EM_ALPHA:
1812 result = get_alpha_dynamic_type (type);
1813 break;
1c0d3aa6
NC		 1814 case EM_SCORE:
1815 result = get_score_dynamic_type (type);
1816 break;
40b36596
JM		 1817 case EM_TI_C6000:
1818 result = get_tic6x_dynamic_type (type);
1819 break;
36591ba1
SL		 1820 case EM_ALTERA_NIOS2:
1821 result = get_nios2_dynamic_type (type);
1822 break;
252b5132
RH		 1823 default:
1824 result = NULL;
1825 break;
1826 }
1827
1828 if (result != NULL)
1829 return result;
1830
e9e44622 1831 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1832 }
eec8f817
DA		 1833 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1834 || (elf_header.e_machine == EM_PARISC
1835 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1836 {
2cf0635d 1837 const char * result;
103f02d3
UD		 1838
1839 switch (elf_header.e_machine)
1840 {
1841 case EM_PARISC:
1842 result = get_parisc_dynamic_type (type);
1843 break;
148b93f2
NC		 1844 case EM_IA_64:
1845 result = get_ia64_dynamic_type (type);
1846 break;
103f02d3
UD		 1847 default:
1848 result = NULL;
1849 break;
1850 }
1851
1852 if (result != NULL)
1853 return result;
1854
e9e44622
JJ		 1855 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1856 type);
103f02d3 1857 }
252b5132 1858 else
e9e44622 1859 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1860
252b5132
RH		 1861 return buff;
1862 }
1863}
1864
1865static char *
d3ba0551 1866get_file_type (unsigned e_type)
252b5132 1867{
b34976b6 1868 static char buff[32];
252b5132
RH		 1869
1870 switch (e_type)
1871 {
1872 case ET_NONE: return _("NONE (None)");
1873 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1874 case ET_EXEC: return _("EXEC (Executable file)");
1875 case ET_DYN: return _("DYN (Shared object file)");
1876 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1877
1878 default:
1879 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1880 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1881 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1882 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1883 else
e9e44622 1884 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1885 return buff;
1886 }
1887}
1888
1889static char *
d3ba0551 1890get_machine_name (unsigned e_machine)
252b5132 1891{
b34976b6 1892 static char buff[64]; /* XXX */
252b5132
RH		 1893
1894 switch (e_machine)
1895 {
c45021f2 1896 case EM_NONE: return _("None");
a06ea964 1897 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1898 case EM_M32: return "WE32100";
1899 case EM_SPARC: return "Sparc";
e9f53129 1900 case EM_SPU: return "SPU";
c45021f2
NC		 1901 case EM_386: return "Intel 80386";
1902 case EM_68K: return "MC68000";
1903 case EM_88K: return "MC88000";
1904 case EM_486: return "Intel 80486";
1905 case EM_860: return "Intel 80860";
1906 case EM_MIPS: return "MIPS R3000";
1907 case EM_S370: return "IBM System/370";
7036c0e1 1908 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1909 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1910 case EM_PARISC: return "HPPA";
252b5132 1911 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1912 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1913 case EM_960: return "Intel 90860";
1914 case EM_PPC: return "PowerPC";
285d1771 1915 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1916 case EM_FR20: return "Fujitsu FR20";
1917 case EM_RH32: return "TRW RH32";
b34976b6 1918 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1919 case EM_ARM: return "ARM";
1920 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1921 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1922 case EM_SPARCV9: return "Sparc v9";
1923 case EM_TRICORE: return "Siemens Tricore";
584da044 1924 case EM_ARC: return "ARC";
c2dcd04e
NC		 1925 case EM_H8_300: return "Renesas H8/300";
1926 case EM_H8_300H: return "Renesas H8/300H";
1927 case EM_H8S: return "Renesas H8S";
1928 case EM_H8_500: return "Renesas H8/500";
30800947 1929 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1930 case EM_MIPS_X: return "Stanford MIPS-X";
1931 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1932 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1933 case EM_CYGNUS_D10V:
1934 case EM_D10V: return "d10v";
1935 case EM_CYGNUS_D30V:
b34976b6 1936 case EM_D30V: return "d30v";
2b0337b0 1937 case EM_CYGNUS_M32R:
26597c86 1938 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1939 case EM_CYGNUS_V850:
708e2187 1940 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 1941 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1942 case EM_CYGNUS_MN10300:
1943 case EM_MN10300: return "mn10300";
1944 case EM_CYGNUS_MN10200:
1945 case EM_MN10200: return "mn10200";
5506d11a 1946 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1947 case EM_CYGNUS_FR30:
1948 case EM_FR30: return "Fujitsu FR30";
b34976b6 1949 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1950 case EM_PJ_OLD:
b34976b6 1951 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1952 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1953 case EM_PCP: return "Siemens PCP";
1954 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1955 case EM_NDR1: return "Denso NDR1 microprocesspr";
1956 case EM_STARCORE: return "Motorola Star*Core processor";
1957 case EM_ME16: return "Toyota ME16 processor";
1958 case EM_ST100: return "STMicroelectronics ST100 processor";
1959 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1960 case EM_PDSP: return "Sony DSP processor";
1961 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1962 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1963 case EM_FX66: return "Siemens FX66 microcontroller";
1964 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1965 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1966 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1967 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1968 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1969 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1970 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1971 case EM_SVX: return "Silicon Graphics SVx";
1972 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1973 case EM_VAX: return "Digital VAX";
2b0337b0 1974 case EM_AVR_OLD:
b34976b6 1975 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1976 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1977 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1978 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1979 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1980 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1981 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1982 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1983 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1984 case EM_L1OM: return "Intel L1OM";
7a9068fe 1985 case EM_K1OM: return "Intel K1OM";
b7498e0e 1986 case EM_S390_OLD:
b34976b6 1987 case EM_S390: return "IBM S/390";
1c0d3aa6 1988 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1989 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1990 case EM_OPENRISC:
1991 case EM_OR32: return "OpenRISC";
11636f9e 1992 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1993 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 1994 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 1995 case EM_DLX: return "OpenDLX";
1e4cf259 1996 case EM_IP2K_OLD:
b34976b6 1997 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1998 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1999 case EM_XTENSA_OLD:
2000 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2001 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2002 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2003 case EM_NS32K: return "National Semiconductor 32000 series";
2004 case EM_TPC: return "Tenor Network TPC processor";
2005 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2006 case EM_MAX: return "MAX Processor";
2007 case EM_CR: return "National Semiconductor CompactRISC";
2008 case EM_F2MC16: return "Fujitsu F2MC16";
2009 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2010 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2011 case EM_M32C_OLD:
49f58d10 2012 case EM_M32C: return "Renesas M32c";
d031aafb 2013 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2014 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2015 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2016 case EM_SEP: return "Sharp embedded microprocessor";
2017 case EM_ARCA: return "Arca RISC microprocessor";
2018 case EM_UNICORE: return "Unicore";
2019 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2020 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2021 case EM_NIOS32: return "Altera Nios";
2022 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2023 case EM_C166:
d70c5fc7 2024 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2025 case EM_M16C: return "Renesas M16C series microprocessors";
2026 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2027 case EM_CE: return "Freescale Communication Engine RISC core";
2028 case EM_TSK3000: return "Altium TSK3000 core";
2029 case EM_RS08: return "Freescale RS08 embedded processor";
2030 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2031 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2032 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2033 case EM_SE_C17: return "Seiko Epson C17 family";
2034 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2035 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2036 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2037 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2038 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2039 case EM_R32C: return "Renesas R32C series microprocessors";
2040 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2041 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2042 case EM_8051: return "Intel 8051 and variants";
2043 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2044 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2045 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2046 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2047 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2048 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2049 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2050 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2051 case EM_CR16:
f6c1a2d5 2052 case EM_MICROBLAZE:
7ba29e2a 2053 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2054 case EM_RL78: return "Renesas RL78";
c7927a3c 2055 case EM_RX: return "Renesas RX";
a3c62988 2056 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2057 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2058 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2059 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2060 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2061 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2062 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2063 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2064 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2065 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2066 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2067 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2068 default:
35d9dd2f 2069 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2070 return buff;
2071 }
2072}
2073
f3485b74 2074static void
d3ba0551 2075decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2076{
2077 unsigned eabi;
2078 int unknown = 0;
2079
2080 eabi = EF_ARM_EABI_VERSION (e_flags);
2081 e_flags &= ~ EF_ARM_EABIMASK;
2082
2083 /* Handle "generic" ARM flags. */
2084 if (e_flags & EF_ARM_RELEXEC)
2085 {
2086 strcat (buf, ", relocatable executable");
2087 e_flags &= ~ EF_ARM_RELEXEC;
2088 }
76da6bbe 2089
f3485b74
NC		 2090 if (e_flags & EF_ARM_HASENTRY)
2091 {
2092 strcat (buf, ", has entry point");
2093 e_flags &= ~ EF_ARM_HASENTRY;
2094 }
76da6bbe 2095
f3485b74
NC		 2096 /* Now handle EABI specific flags. */
2097 switch (eabi)
2098 {
2099 default:
2c71103e 2100 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2101 if (e_flags)
2102 unknown = 1;
2103 break;
2104
2105 case EF_ARM_EABI_VER1:
a5bcd848 2106 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2107 while (e_flags)
2108 {
2109 unsigned flag;
76da6bbe 2110
f3485b74
NC		 2111 /* Process flags one bit at a time. */
2112 flag = e_flags & - e_flags;
2113 e_flags &= ~ flag;
76da6bbe 2114
f3485b74
NC		 2115 switch (flag)
2116 {
a5bcd848 2117 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2118 strcat (buf, ", sorted symbol tables");
2119 break;
76da6bbe 2120
f3485b74
NC		 2121 default:
2122 unknown = 1;
2123 break;
2124 }
2125 }
2126 break;
76da6bbe 2127
a5bcd848
PB		 2128 case EF_ARM_EABI_VER2:
2129 strcat (buf, ", Version2 EABI");
2130 while (e_flags)
2131 {
2132 unsigned flag;
2133
2134 /* Process flags one bit at a time. */
2135 flag = e_flags & - e_flags;
2136 e_flags &= ~ flag;
2137
2138 switch (flag)
2139 {
2140 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2141 strcat (buf, ", sorted symbol tables");
2142 break;
2143
2144 case EF_ARM_DYNSYMSUSESEGIDX:
2145 strcat (buf, ", dynamic symbols use segment index");
2146 break;
2147
2148 case EF_ARM_MAPSYMSFIRST:
2149 strcat (buf, ", mapping symbols precede others");
2150 break;
2151
2152 default:
2153 unknown = 1;
2154 break;
2155 }
2156 }
2157 break;
2158
d507cf36
PB		 2159 case EF_ARM_EABI_VER3:
2160 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2161 break;
2162
2163 case EF_ARM_EABI_VER4:
2164 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2165 while (e_flags)
2166 {
2167 unsigned flag;
2168
2169 /* Process flags one bit at a time. */
2170 flag = e_flags & - e_flags;
2171 e_flags &= ~ flag;
2172
2173 switch (flag)
2174 {
2175 case EF_ARM_BE8:
2176 strcat (buf, ", BE8");
2177 break;
2178
2179 case EF_ARM_LE8:
2180 strcat (buf, ", LE8");
2181 break;
2182
2183 default:
2184 unknown = 1;
2185 break;
2186 }
2187 break;
2188 }
2189 break;
3a4a14e9
PB		 2190
2191 case EF_ARM_EABI_VER5:
2192 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2193 while (e_flags)
2194 {
2195 unsigned flag;
2196
2197 /* Process flags one bit at a time. */
2198 flag = e_flags & - e_flags;
2199 e_flags &= ~ flag;
2200
2201 switch (flag)
2202 {
2203 case EF_ARM_BE8:
2204 strcat (buf, ", BE8");
2205 break;
2206
2207 case EF_ARM_LE8:
2208 strcat (buf, ", LE8");
2209 break;
2210
3bfcb652
NC		 2211 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2212 strcat (buf, ", soft-float ABI");
2213 break;
2214
2215 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2216 strcat (buf, ", hard-float ABI");
2217 break;
2218
d507cf36
PB		 2219 default:
2220 unknown = 1;
2221 break;
2222 }
2223 }
2224 break;
2225
f3485b74 2226 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2227 strcat (buf, ", GNU EABI");
f3485b74
NC		 2228 while (e_flags)
2229 {
2230 unsigned flag;
76da6bbe 2231
f3485b74
NC		 2232 /* Process flags one bit at a time. */
2233 flag = e_flags & - e_flags;
2234 e_flags &= ~ flag;
76da6bbe 2235
f3485b74
NC		 2236 switch (flag)
2237 {
a5bcd848 2238 case EF_ARM_INTERWORK:
f3485b74
NC		 2239 strcat (buf, ", interworking enabled");
2240 break;
76da6bbe 2241
a5bcd848 2242 case EF_ARM_APCS_26:
f3485b74
NC		 2243 strcat (buf, ", uses APCS/26");
2244 break;
76da6bbe 2245
a5bcd848 2246 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2247 strcat (buf, ", uses APCS/float");
2248 break;
76da6bbe 2249
a5bcd848 2250 case EF_ARM_PIC:
f3485b74
NC		 2251 strcat (buf, ", position independent");
2252 break;
76da6bbe 2253
a5bcd848 2254 case EF_ARM_ALIGN8:
f3485b74
NC		 2255 strcat (buf, ", 8 bit structure alignment");
2256 break;
76da6bbe 2257
a5bcd848 2258 case EF_ARM_NEW_ABI:
f3485b74
NC		 2259 strcat (buf, ", uses new ABI");
2260 break;
76da6bbe 2261
a5bcd848 2262 case EF_ARM_OLD_ABI:
f3485b74
NC		 2263 strcat (buf, ", uses old ABI");
2264 break;
76da6bbe 2265
a5bcd848 2266 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2267 strcat (buf, ", software FP");
2268 break;
76da6bbe 2269
90e01f86
ILT		 2270 case EF_ARM_VFP_FLOAT:
2271 strcat (buf, ", VFP");
2272 break;
2273
fde78edd
NC		 2274 case EF_ARM_MAVERICK_FLOAT:
2275 strcat (buf, ", Maverick FP");
2276 break;
2277
f3485b74
NC		 2278 default:
2279 unknown = 1;
2280 break;
2281 }
2282 }
2283 }
f3485b74
NC		 2284
2285 if (unknown)
2b692964 2286 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2287}
2288
252b5132 2289static char *
d3ba0551 2290get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2291{
b34976b6 2292 static char buf[1024];
252b5132
RH		 2293
2294 buf[0] = '\0';
76da6bbe 2295
252b5132
RH		 2296 if (e_flags)
2297 {
2298 switch (e_machine)
2299 {
2300 default:
2301 break;
2302
f3485b74
NC		 2303 case EM_ARM:
2304 decode_ARM_machine_flags (e_flags, buf);
2305 break;
76da6bbe 2306
781303ce
MF		 2307 case EM_BLACKFIN:
2308 if (e_flags & EF_BFIN_PIC)
2309 strcat (buf, ", PIC");
2310
2311 if (e_flags & EF_BFIN_FDPIC)
2312 strcat (buf, ", FDPIC");
2313
2314 if (e_flags & EF_BFIN_CODE_IN_L1)
2315 strcat (buf, ", code in L1");
2316
2317 if (e_flags & EF_BFIN_DATA_IN_L1)
2318 strcat (buf, ", data in L1");
2319
2320 break;
2321
ec2dfb42
AO		 2322 case EM_CYGNUS_FRV:
2323 switch (e_flags & EF_FRV_CPU_MASK)
2324 {
2325 case EF_FRV_CPU_GENERIC:
2326 break;
2327
2328 default:
2329 strcat (buf, ", fr???");
2330 break;
57346661 2331
ec2dfb42
AO		 2332 case EF_FRV_CPU_FR300:
2333 strcat (buf, ", fr300");
2334 break;
2335
2336 case EF_FRV_CPU_FR400:
2337 strcat (buf, ", fr400");
2338 break;
2339 case EF_FRV_CPU_FR405:
2340 strcat (buf, ", fr405");
2341 break;
2342
2343 case EF_FRV_CPU_FR450:
2344 strcat (buf, ", fr450");
2345 break;
2346
2347 case EF_FRV_CPU_FR500:
2348 strcat (buf, ", fr500");
2349 break;
2350 case EF_FRV_CPU_FR550:
2351 strcat (buf, ", fr550");
2352 break;
2353
2354 case EF_FRV_CPU_SIMPLE:
2355 strcat (buf, ", simple");
2356 break;
2357 case EF_FRV_CPU_TOMCAT:
2358 strcat (buf, ", tomcat");
2359 break;
2360 }
1c877e87 2361 break;
ec2dfb42 2362
53c7db4b 2363 case EM_68K:
425c6cb0 2364 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2365 strcat (buf, ", m68000");
425c6cb0 2366 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2367 strcat (buf, ", cpu32");
2368 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2369 strcat (buf, ", fido_a");
425c6cb0 2370 else
266abb8f 2371 {
2cf0635d
NC		 2372 char const * isa = _("unknown");
2373 char const * mac = _("unknown mac");
2374 char const * additional = NULL;
0112cd26 2375
c694fd50 2376 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2377 {
c694fd50 2378 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2379 isa = "A";
2380 additional = ", nodiv";
2381 break;
c694fd50 2382 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2383 isa = "A";
2384 break;
c694fd50 2385 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2386 isa = "A+";
2387 break;
c694fd50 2388 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2389 isa = "B";
2390 additional = ", nousp";
2391 break;
c694fd50 2392 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2393 isa = "B";
2394 break;
f608cd77
NS		 2395 case EF_M68K_CF_ISA_C:
2396 isa = "C";
2397 break;
2398 case EF_M68K_CF_ISA_C_NODIV:
2399 isa = "C";
2400 additional = ", nodiv";
2401 break;
266abb8f
NS		 2402 }
2403 strcat (buf, ", cf, isa ");
2404 strcat (buf, isa);
0b2e31dc
NS		 2405 if (additional)
2406 strcat (buf, additional);
c694fd50 2407 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2408 strcat (buf, ", float");
c694fd50 2409 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2410 {
2411 case 0:
2412 mac = NULL;
2413 break;
c694fd50 2414 case EF_M68K_CF_MAC:
266abb8f
NS		 2415 mac = "mac";
2416 break;
c694fd50 2417 case EF_M68K_CF_EMAC:
266abb8f
NS		 2418 mac = "emac";
2419 break;
f608cd77
NS		 2420 case EF_M68K_CF_EMAC_B:
2421 mac = "emac_b";
2422 break;
266abb8f
NS		 2423 }
2424 if (mac)
2425 {
2426 strcat (buf, ", ");
2427 strcat (buf, mac);
2428 }
266abb8f 2429 }
53c7db4b 2430 break;
33c63f9d 2431
252b5132
RH		 2432 case EM_PPC:
2433 if (e_flags & EF_PPC_EMB)
2434 strcat (buf, ", emb");
2435
2436 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2437 strcat (buf, _(", relocatable"));
252b5132
RH		 2438
2439 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2440 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2441 break;
2442
708e2187
NC		 2443 case EM_V800:
2444 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2445 strcat (buf, ", RH850 ABI");
2446
2447 if (e_flags & EF_V800_850E3)
2448 strcat (buf, ", V3 architecture");
2449
2450 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2451 strcat (buf, ", FPU not used");
2452
2453 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2454 strcat (buf, ", regmode: COMMON");
2455
2456 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2457 strcat (buf, ", r4 not used");
2458
2459 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2460 strcat (buf, ", r30 not used");
2461
2462 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2463 strcat (buf, ", r5 not used");
2464
2465 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2466 strcat (buf, ", r2 not used");
2467
2468 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2469 {
2470 switch (e_flags & - e_flags)
2471 {
2472 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2473 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2474 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2475 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2476 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2477 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2478 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2479 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2480 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2481 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2482 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2483 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2484 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2485 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2486 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2487 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2488 default: break;
2489 }
2490 }
2491 break;
2492
2b0337b0 2493 case EM_V850:
252b5132
RH		 2494 case EM_CYGNUS_V850:
2495 switch (e_flags & EF_V850_ARCH)
2496 {
78c8d46c
NC		 2497 case E_V850E3V5_ARCH:
2498 strcat (buf, ", v850e3v5");
2499 break;
1cd986c5
NC		 2500 case E_V850E2V3_ARCH:
2501 strcat (buf, ", v850e2v3");
2502 break;
2503 case E_V850E2_ARCH:
2504 strcat (buf, ", v850e2");
2505 break;
2506 case E_V850E1_ARCH:
2507 strcat (buf, ", v850e1");
8ad30312 2508 break;
252b5132
RH		 2509 case E_V850E_ARCH:
2510 strcat (buf, ", v850e");
2511 break;
252b5132
RH		 2512 case E_V850_ARCH:
2513 strcat (buf, ", v850");
2514 break;
2515 default:
2b692964 2516 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2517 break;
2518 }
2519 break;
2520
2b0337b0 2521 case EM_M32R:
252b5132
RH		 2522 case EM_CYGNUS_M32R:
2523 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2524 strcat (buf, ", m32r");
252b5132
RH		 2525 break;
2526
2527 case EM_MIPS:
4fe85591 2528 case EM_MIPS_RS3_LE:
252b5132
RH		 2529 if (e_flags & EF_MIPS_NOREORDER)
2530 strcat (buf, ", noreorder");
2531
2532 if (e_flags & EF_MIPS_PIC)
2533 strcat (buf, ", pic");
2534
2535 if (e_flags & EF_MIPS_CPIC)
2536 strcat (buf, ", cpic");
2537
d1bdd336
TS		 2538 if (e_flags & EF_MIPS_UCODE)
2539 strcat (buf, ", ugen_reserved");
2540
252b5132
RH		 2541 if (e_flags & EF_MIPS_ABI2)
2542 strcat (buf, ", abi2");
2543
43521d43
TS		 2544 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2545 strcat (buf, ", odk first");
2546
a5d22d2a
TS		 2547 if (e_flags & EF_MIPS_32BITMODE)
2548 strcat (buf, ", 32bitmode");
2549
156c2f8b
NC		 2550 switch ((e_flags & EF_MIPS_MACH))
2551 {
2552 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2553 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2554 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2555 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2556 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2557 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2558 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2559 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2560 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2561 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2562 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2563 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2564 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2565 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2566 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2567 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2568 case 0:
2569 /* We simply ignore the field in this case to avoid confusion:
2570 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2571 extension. */
2572 break;
2b692964 2573 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2574 }
43521d43
TS		 2575
2576 switch ((e_flags & EF_MIPS_ABI))
2577 {
2578 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2579 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2580 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2581 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2582 case 0:
2583 /* We simply ignore the field in this case to avoid confusion:
2584 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2585 This means it is likely to be an o32 file, but not for
2586 sure. */
2587 break;
2b692964 2588 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2589 }
2590
2591 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2592 strcat (buf, ", mdmx");
2593
2594 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2595 strcat (buf, ", mips16");
2596
df58fc94
RS		 2597 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2598 strcat (buf, ", micromips");
2599
43521d43
TS		 2600 switch ((e_flags & EF_MIPS_ARCH))
2601 {
2602 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2603 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2604 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2605 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2606 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2607 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2608 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2609 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2610 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2611 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2612 }
252b5132 2613 break;
351b4b40 2614
ccde1100
AO		 2615 case EM_SH:
2616 switch ((e_flags & EF_SH_MACH_MASK))
2617 {
2618 case EF_SH1: strcat (buf, ", sh1"); break;
2619 case EF_SH2: strcat (buf, ", sh2"); break;
2620 case EF_SH3: strcat (buf, ", sh3"); break;
2621 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2622 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2623 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2624 case EF_SH3E: strcat (buf, ", sh3e"); break;
2625 case EF_SH4: strcat (buf, ", sh4"); break;
2626 case EF_SH5: strcat (buf, ", sh5"); break;
2627 case EF_SH2E: strcat (buf, ", sh2e"); break;
2628 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2629 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2630 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2631 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2632 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2633 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2634 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2635 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2636 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2637 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2638 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2639 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2640 }
2641
cec6a5b8
MR		 2642 if (e_flags & EF_SH_PIC)
2643 strcat (buf, ", pic");
2644
2645 if (e_flags & EF_SH_FDPIC)
2646 strcat (buf, ", fdpic");
ccde1100 2647 break;
57346661 2648
351b4b40
RH		 2649 case EM_SPARCV9:
2650 if (e_flags & EF_SPARC_32PLUS)
2651 strcat (buf, ", v8+");
2652
2653 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2654 strcat (buf, ", ultrasparcI");
2655
2656 if (e_flags & EF_SPARC_SUN_US3)
2657 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2658
2659 if (e_flags & EF_SPARC_HAL_R1)
2660 strcat (buf, ", halr1");
2661
2662 if (e_flags & EF_SPARC_LEDATA)
2663 strcat (buf, ", ledata");
2664
2665 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2666 strcat (buf, ", tso");
2667
2668 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2669 strcat (buf, ", pso");
2670
2671 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2672 strcat (buf, ", rmo");
2673 break;
7d466069 2674
103f02d3
UD		 2675 case EM_PARISC:
2676 switch (e_flags & EF_PARISC_ARCH)
2677 {
2678 case EFA_PARISC_1_0:
2679 strcpy (buf, ", PA-RISC 1.0");
2680 break;
2681 case EFA_PARISC_1_1:
2682 strcpy (buf, ", PA-RISC 1.1");
2683 break;
2684 case EFA_PARISC_2_0:
2685 strcpy (buf, ", PA-RISC 2.0");
2686 break;
2687 default:
2688 break;
2689 }
2690 if (e_flags & EF_PARISC_TRAPNIL)
2691 strcat (buf, ", trapnil");
2692 if (e_flags & EF_PARISC_EXT)
2693 strcat (buf, ", ext");
2694 if (e_flags & EF_PARISC_LSB)
2695 strcat (buf, ", lsb");
2696 if (e_flags & EF_PARISC_WIDE)
2697 strcat (buf, ", wide");
2698 if (e_flags & EF_PARISC_NO_KABP)
2699 strcat (buf, ", no kabp");
2700 if (e_flags & EF_PARISC_LAZYSWAP)
2701 strcat (buf, ", lazyswap");
30800947 2702 break;
76da6bbe 2703
7d466069 2704 case EM_PJ:
2b0337b0 2705 case EM_PJ_OLD:
7d466069
ILT		 2706 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2707 strcat (buf, ", new calling convention");
2708
2709 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2710 strcat (buf, ", gnu calling convention");
2711 break;
4d6ed7c8
NC		 2712
2713 case EM_IA_64:
2714 if ((e_flags & EF_IA_64_ABI64))
2715 strcat (buf, ", 64-bit");
2716 else
2717 strcat (buf, ", 32-bit");
2718 if ((e_flags & EF_IA_64_REDUCEDFP))
2719 strcat (buf, ", reduced fp model");
2720 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2721 strcat (buf, ", no function descriptors, constant gp");
2722 else if ((e_flags & EF_IA_64_CONS_GP))
2723 strcat (buf, ", constant gp");
2724 if ((e_flags & EF_IA_64_ABSOLUTE))
2725 strcat (buf, ", absolute");
28f997cf
TG		 2726 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2727 {
2728 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2729 strcat (buf, ", vms_linkages");
2730 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2731 {
2732 case EF_IA_64_VMS_COMCOD_SUCCESS:
2733 break;
2734 case EF_IA_64_VMS_COMCOD_WARNING:
2735 strcat (buf, ", warning");
2736 break;
2737 case EF_IA_64_VMS_COMCOD_ERROR:
2738 strcat (buf, ", error");
2739 break;
2740 case EF_IA_64_VMS_COMCOD_ABORT:
2741 strcat (buf, ", abort");
2742 break;
2743 default:
2744 abort ();
2745 }
2746 }
4d6ed7c8 2747 break;
179d3252
JT		 2748
2749 case EM_VAX:
2750 if ((e_flags & EF_VAX_NONPIC))
2751 strcat (buf, ", non-PIC");
2752 if ((e_flags & EF_VAX_DFLOAT))
2753 strcat (buf, ", D-Float");
2754 if ((e_flags & EF_VAX_GFLOAT))
2755 strcat (buf, ", G-Float");
2756 break;
c7927a3c
NC		 2757
2758 case EM_RX:
2759 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2760 strcat (buf, ", 64-bit doubles");
2761 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2762 strcat (buf, ", dsp");
d4cb0ea0
NC		 2763 if (e_flags & E_FLAG_RX_PID)
2764 strcat (buf, ", pid");
708e2187
NC		 2765 if (e_flags & E_FLAG_RX_ABI)
2766 strcat (buf, ", RX ABI");
d4cb0ea0 2767 break;
55786da2
AK		 2768
2769 case EM_S390:
2770 if (e_flags & EF_S390_HIGH_GPRS)
2771 strcat (buf, ", highgprs");
d4cb0ea0 2772 break;
40b36596
JM		 2773
2774 case EM_TI_C6000:
2775 if ((e_flags & EF_C6000_REL))
2776 strcat (buf, ", relocatable module");
d4cb0ea0 2777 break;
252b5132
RH		 2778 }
2779 }
2780
2781 return buf;
2782}
2783
252b5132 2784static const char *
d3ba0551
AM		 2785get_osabi_name (unsigned int osabi)
2786{
2787 static char buff[32];
2788
2789 switch (osabi)
2790 {
2791 case ELFOSABI_NONE: return "UNIX - System V";
2792 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2793 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2794 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2795 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2796 case ELFOSABI_AIX: return "UNIX - AIX";
2797 case ELFOSABI_IRIX: return "UNIX - IRIX";
2798 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2799 case ELFOSABI_TRU64: return "UNIX - TRU64";
2800 case ELFOSABI_MODESTO: return "Novell - Modesto";
2801 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2802 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2803 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2804 case ELFOSABI_AROS: return "AROS";
11636f9e 2805 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2806 default:
40b36596
JM		 2807 if (osabi >= 64)
2808 switch (elf_header.e_machine)
2809 {
2810 case EM_ARM:
2811 switch (osabi)
2812 {
2813 case ELFOSABI_ARM: return "ARM";
2814 default:
2815 break;
2816 }
2817 break;
2818
2819 case EM_MSP430:
2820 case EM_MSP430_OLD:
2821 switch (osabi)
2822 {
2823 case ELFOSABI_STANDALONE: return _("Standalone App");
2824 default:
2825 break;
2826 }
2827 break;
2828
2829 case EM_TI_C6000:
2830 switch (osabi)
2831 {
2832 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2833 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2834 default:
2835 break;
2836 }
2837 break;
2838
2839 default:
2840 break;
2841 }
e9e44622 2842 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2843 return buff;
2844 }
2845}
2846
a06ea964
NC		 2847static const char *
2848get_aarch64_segment_type (unsigned long type)
2849{
2850 switch (type)
2851 {
2852 case PT_AARCH64_ARCHEXT:
2853 return "AARCH64_ARCHEXT";
2854 default:
2855 break;
2856 }
2857
2858 return NULL;
2859}
2860
b294bdf8
MM		 2861static const char *
2862get_arm_segment_type (unsigned long type)
2863{
2864 switch (type)
2865 {
2866 case PT_ARM_EXIDX:
2867 return "EXIDX";
2868 default:
2869 break;
2870 }
2871
2872 return NULL;
2873}
2874
d3ba0551
AM		 2875static const char *
2876get_mips_segment_type (unsigned long type)
252b5132
RH		 2877{
2878 switch (type)
2879 {
2880 case PT_MIPS_REGINFO:
2881 return "REGINFO";
2882 case PT_MIPS_RTPROC:
2883 return "RTPROC";
2884 case PT_MIPS_OPTIONS:
2885 return "OPTIONS";
2886 default:
2887 break;
2888 }
2889
2890 return NULL;
2891}
2892
103f02d3 2893static const char *
d3ba0551 2894get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2895{
2896 switch (type)
2897 {
2898 case PT_HP_TLS: return "HP_TLS";
2899 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2900 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2901 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2902 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2903 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2904 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2905 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2906 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2907 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2908 case PT_HP_PARALLEL: return "HP_PARALLEL";
2909 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2910 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2911 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2912 case PT_HP_STACK: return "HP_STACK";
2913 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2914 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2915 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2916 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2917 default:
2918 break;
2919 }
2920
2921 return NULL;
2922}
2923
4d6ed7c8 2924static const char *
d3ba0551 2925get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2926{
2927 switch (type)
2928 {
2929 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2930 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2931 case PT_HP_TLS: return "HP_TLS";
2932 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2933 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2934 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2935 default:
2936 break;
2937 }
2938
2939 return NULL;
2940}
2941
40b36596
JM		 2942static const char *
2943get_tic6x_segment_type (unsigned long type)
2944{
2945 switch (type)
2946 {
2947 case PT_C6000_PHATTR: return "C6000_PHATTR";
2948 default:
2949 break;
2950 }
2951
2952 return NULL;
2953}
2954
252b5132 2955static const char *
d3ba0551 2956get_segment_type (unsigned long p_type)
252b5132 2957{
b34976b6 2958 static char buff[32];
252b5132
RH		 2959
2960 switch (p_type)
2961 {
b34976b6
AM		 2962 case PT_NULL: return "NULL";
2963 case PT_LOAD: return "LOAD";
252b5132 2964 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2965 case PT_INTERP: return "INTERP";
2966 case PT_NOTE: return "NOTE";
2967 case PT_SHLIB: return "SHLIB";
2968 case PT_PHDR: return "PHDR";
13ae64f3 2969 case PT_TLS: return "TLS";
252b5132 2970
65765700
JJ		 2971 case PT_GNU_EH_FRAME:
2972 return "GNU_EH_FRAME";
2b05f1b7 2973 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2974 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2975
252b5132
RH		 2976 default:
2977 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2978 {
2cf0635d 2979 const char * result;
103f02d3 2980
252b5132
RH		 2981 switch (elf_header.e_machine)
2982 {
a06ea964
NC		 2983 case EM_AARCH64:
2984 result = get_aarch64_segment_type (p_type);
2985 break;
b294bdf8
MM		 2986 case EM_ARM:
2987 result = get_arm_segment_type (p_type);
2988 break;
252b5132 2989 case EM_MIPS:
4fe85591 2990 case EM_MIPS_RS3_LE:
252b5132
RH		 2991 result = get_mips_segment_type (p_type);
2992 break;
103f02d3
UD		 2993 case EM_PARISC:
2994 result = get_parisc_segment_type (p_type);
2995 break;
4d6ed7c8
NC		 2996 case EM_IA_64:
2997 result = get_ia64_segment_type (p_type);
2998 break;
40b36596
JM		 2999 case EM_TI_C6000:
3000 result = get_tic6x_segment_type (p_type);
3001 break;
252b5132
RH		 3002 default:
3003 result = NULL;
3004 break;
3005 }
103f02d3 3006
252b5132
RH		 3007 if (result != NULL)
3008 return result;
103f02d3 3009
252b5132
RH		 3010 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3011 }
3012 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3013 {
2cf0635d 3014 const char * result;
103f02d3
UD		 3015
3016 switch (elf_header.e_machine)
3017 {
3018 case EM_PARISC:
3019 result = get_parisc_segment_type (p_type);
3020 break;
00428cca
AM		 3021 case EM_IA_64:
3022 result = get_ia64_segment_type (p_type);
3023 break;
103f02d3
UD		 3024 default:
3025 result = NULL;
3026 break;
3027 }
3028
3029 if (result != NULL)
3030 return result;
3031
3032 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3033 }
252b5132 3034 else
e9e44622 3035 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3036
3037 return buff;
3038 }
3039}
3040
3041static const char *
d3ba0551 3042get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3043{
3044 switch (sh_type)
3045 {
b34976b6
AM		 3046 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3047 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3048 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3049 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3050 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3051 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3052 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3053 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3054 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3055 case SHT_MIPS_RELD: return "MIPS_RELD";
3056 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3057 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3058 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3059 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3060 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3061 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3062 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3063 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3064 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3065 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3066 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3067 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3068 case SHT_MIPS_LINE: return "MIPS_LINE";
3069 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3070 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3071 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3072 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3073 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3074 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3075 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3076 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3077 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3078 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3079 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3080 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3081 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3082 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3083 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 3084 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3085 default:
3086 break;
3087 }
3088 return NULL;
3089}
3090
103f02d3 3091static const char *
d3ba0551 3092get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3093{
3094 switch (sh_type)
3095 {
3096 case SHT_PARISC_EXT: return "PARISC_EXT";
3097 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3098 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3099 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3100 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3101 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3102 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3103 default:
3104 break;
3105 }
3106 return NULL;
3107}
3108
4d6ed7c8 3109static const char *
d3ba0551 3110get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3111{
18bd398b 3112 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3113 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3114 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3115
4d6ed7c8
NC		 3116 switch (sh_type)
3117 {
148b93f2
NC		 3118 case SHT_IA_64_EXT: return "IA_64_EXT";
3119 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3120 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3121 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3122 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3123 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3124 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3125 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3126 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3127 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3128 default:
3129 break;
3130 }
3131 return NULL;
3132}
3133
d2b2c203
DJ		 3134static const char *
3135get_x86_64_section_type_name (unsigned int sh_type)
3136{
3137 switch (sh_type)
3138 {
3139 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3140 default:
3141 break;
3142 }
3143 return NULL;
3144}
3145
a06ea964
NC		 3146static const char *
3147get_aarch64_section_type_name (unsigned int sh_type)
3148{
3149 switch (sh_type)
3150 {
3151 case SHT_AARCH64_ATTRIBUTES:
3152 return "AARCH64_ATTRIBUTES";
3153 default:
3154 break;
3155 }
3156 return NULL;
3157}
3158
40a18ebd
NC		 3159static const char *
3160get_arm_section_type_name (unsigned int sh_type)
3161{
3162 switch (sh_type)
3163 {
7f6fed87
NC		 3164 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3165 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3166 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3167 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3168 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3169 default:
3170 break;
3171 }
3172 return NULL;
3173}
3174
40b36596
JM		 3175static const char *
3176get_tic6x_section_type_name (unsigned int sh_type)
3177{
3178 switch (sh_type)
3179 {
3180 case SHT_C6000_UNWIND:
3181 return "C6000_UNWIND";
3182 case SHT_C6000_PREEMPTMAP:
3183 return "C6000_PREEMPTMAP";
3184 case SHT_C6000_ATTRIBUTES:
3185 return "C6000_ATTRIBUTES";
3186 case SHT_TI_ICODE:
3187 return "TI_ICODE";
3188 case SHT_TI_XREF:
3189 return "TI_XREF";
3190 case SHT_TI_HANDLER:
3191 return "TI_HANDLER";
3192 case SHT_TI_INITINFO:
3193 return "TI_INITINFO";
3194 case SHT_TI_PHATTRS:
3195 return "TI_PHATTRS";
3196 default:
3197 break;
3198 }
3199 return NULL;
3200}
3201
252b5132 3202static const char *
d3ba0551 3203get_section_type_name (unsigned int sh_type)
252b5132 3204{
b34976b6 3205 static char buff[32];
252b5132
RH		 3206
3207 switch (sh_type)
3208 {
3209 case SHT_NULL: return "NULL";
3210 case SHT_PROGBITS: return "PROGBITS";
3211 case SHT_SYMTAB: return "SYMTAB";
3212 case SHT_STRTAB: return "STRTAB";
3213 case SHT_RELA: return "RELA";
3214 case SHT_HASH: return "HASH";
3215 case SHT_DYNAMIC: return "DYNAMIC";
3216 case SHT_NOTE: return "NOTE";
3217 case SHT_NOBITS: return "NOBITS";
3218 case SHT_REL: return "REL";
3219 case SHT_SHLIB: return "SHLIB";
3220 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3221 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3222 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3223 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3224 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3225 case SHT_GROUP: return "GROUP";
3226 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3227 case SHT_GNU_verdef: return "VERDEF";
3228 case SHT_GNU_verneed: return "VERNEED";
3229 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3230 case 0x6ffffff0: return "VERSYM";
3231 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3232 case 0x7ffffffd: return "AUXILIARY";
3233 case 0x7fffffff: return "FILTER";
047b2264 3234 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3235
3236 default:
3237 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3238 {
2cf0635d 3239 const char * result;
252b5132
RH		 3240
3241 switch (elf_header.e_machine)
3242 {
3243 case EM_MIPS:
4fe85591 3244 case EM_MIPS_RS3_LE:
252b5132
RH		 3245 result = get_mips_section_type_name (sh_type);
3246 break;
103f02d3
UD		 3247 case EM_PARISC:
3248 result = get_parisc_section_type_name (sh_type);
3249 break;
4d6ed7c8
NC		 3250 case EM_IA_64:
3251 result = get_ia64_section_type_name (sh_type);
3252 break;
d2b2c203 3253 case EM_X86_64:
8a9036a4 3254 case EM_L1OM:
7a9068fe 3255 case EM_K1OM:
d2b2c203
DJ		 3256 result = get_x86_64_section_type_name (sh_type);
3257 break;
a06ea964
NC		 3258 case EM_AARCH64:
3259 result = get_aarch64_section_type_name (sh_type);
3260 break;
40a18ebd
NC		 3261 case EM_ARM:
3262 result = get_arm_section_type_name (sh_type);
3263 break;
40b36596
JM		 3264 case EM_TI_C6000:
3265 result = get_tic6x_section_type_name (sh_type);
3266 break;
252b5132
RH		 3267 default:
3268 result = NULL;
3269 break;
3270 }
3271
3272 if (result != NULL)
3273 return result;
3274
c91d0dfb 3275 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3276 }
3277 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3278 {
2cf0635d 3279 const char * result;
148b93f2
NC		 3280
3281 switch (elf_header.e_machine)
3282 {
3283 case EM_IA_64:
3284 result = get_ia64_section_type_name (sh_type);
3285 break;
3286 default:
3287 result = NULL;
3288 break;
3289 }
3290
3291 if (result != NULL)
3292 return result;
3293
3294 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3295 }
252b5132 3296 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3297 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3298 else
a7dbfd1c
NC		 3299 /* This message is probably going to be displayed in a 15
3300 character wide field, so put the hex value first. */
3301 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3302
252b5132
RH		 3303 return buff;
3304 }
3305}
3306
2979dc34 3307#define OPTION_DEBUG_DUMP 512
2c610e4b 3308#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3309#define OPTION_DWARF_DEPTH 514
3310#define OPTION_DWARF_START 515
4723351a 3311#define OPTION_DWARF_CHECK 516
2979dc34 3312
85b1c36d 3313static struct option options[] =
252b5132 3314{
b34976b6 3315 {"all", no_argument, 0, 'a'},
252b5132
RH		 3316 {"file-header", no_argument, 0, 'h'},
3317 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3318 {"headers", no_argument, 0, 'e'},
3319 {"histogram", no_argument, 0, 'I'},
3320 {"segments", no_argument, 0, 'l'},
3321 {"sections", no_argument, 0, 'S'},
252b5132 3322 {"section-headers", no_argument, 0, 'S'},
f5842774 3323 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3324 {"section-details", no_argument, 0, 't'},
595cf52e 3325 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3326 {"symbols", no_argument, 0, 's'},
3327 {"syms", no_argument, 0, 's'},
2c610e4b 3328 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3329 {"relocs", no_argument, 0, 'r'},
3330 {"notes", no_argument, 0, 'n'},
3331 {"dynamic", no_argument, 0, 'd'},
a952a375 3332 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3333 {"version-info", no_argument, 0, 'V'},
3334 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3335 {"unwind", no_argument, 0, 'u'},
4145f1d5 3336 {"archive-index", no_argument, 0, 'c'},
b34976b6 3337 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3338 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3339 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3340#ifdef SUPPORT_DISASSEMBLY
3341 {"instruction-dump", required_argument, 0, 'i'},
3342#endif
cf13d699 3343 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3344
fd2f0033
TT		 3345 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3346 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3347 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3348
b34976b6
AM		 3349 {"version", no_argument, 0, 'v'},
3350 {"wide", no_argument, 0, 'W'},
3351 {"help", no_argument, 0, 'H'},
3352 {0, no_argument, 0, 0}
252b5132
RH		 3353};
3354
3355static void
2cf0635d 3356usage (FILE * stream)
252b5132 3357{
92f01d61
JM		 3358 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3359 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3360 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3361 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3362 -h --file-header Display the ELF file header\n\
3363 -l --program-headers Display the program headers\n\
3364 --segments An alias for --program-headers\n\
3365 -S --section-headers Display the sections' header\n\
3366 --sections An alias for --section-headers\n\
f5842774 3367 -g --section-groups Display the section groups\n\
5477e8a0 3368 -t --section-details Display the section details\n\
8b53311e
NC		 3369 -e --headers Equivalent to: -h -l -S\n\
3370 -s --syms Display the symbol table\n\
3f08eb35 3371 --symbols An alias for --syms\n\
2c610e4b 3372 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3373 -n --notes Display the core notes (if present)\n\
3374 -r --relocs Display the relocations (if present)\n\
3375 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3376 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3377 -V --version-info Display the version sections (if present)\n\
1b31d05e 3378 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3379 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3380 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3381 -x --hex-dump=<number|name>\n\
3382 Dump the contents of section <number|name> as bytes\n\
3383 -p --string-dump=<number|name>\n\
3384 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3385 -R --relocated-dump=<number|name>\n\
3386 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3387 -w[lLiaprmfFsoRt] or\n\
1ed06042 3388 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3389 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3390 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3391 =addr,=cu_index]\n\
8b53311e 3392 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3393 fprintf (stream, _("\
3394 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3395 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3396 or deeper\n"));
252b5132 3397#ifdef SUPPORT_DISASSEMBLY
92f01d61 3398 fprintf (stream, _("\
09c11c86
NC		 3399 -i --instruction-dump=<number|name>\n\
3400 Disassemble the contents of section <number|name>\n"));
252b5132 3401#endif
92f01d61 3402 fprintf (stream, _("\
8b53311e
NC		 3403 -I --histogram Display histogram of bucket list lengths\n\
3404 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3405 @<file> Read options from <file>\n\
8b53311e
NC		 3406 -H --help Display this information\n\
3407 -v --version Display the version number of readelf\n"));
1118d252 3408
92f01d61
JM		 3409 if (REPORT_BUGS_TO[0] && stream == stdout)
3410 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3411
92f01d61 3412 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3413}
3414
18bd398b
NC		 3415/* Record the fact that the user wants the contents of section number
3416 SECTION to be displayed using the method(s) encoded as flags bits
3417 in TYPE. Note, TYPE can be zero if we are creating the array for
3418 the first time. */
3419
252b5132 3420static void
09c11c86 3421request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3422{
3423 if (section >= num_dump_sects)
3424 {
2cf0635d 3425 dump_type * new_dump_sects;
252b5132 3426
3f5e193b
NC		 3427 new_dump_sects = (dump_type *) calloc (section + 1,
3428 sizeof (* dump_sects));
252b5132
RH		 3429
3430 if (new_dump_sects == NULL)
591a748a 3431 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3432 else
3433 {
3434 /* Copy current flag settings. */
09c11c86 3435 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3436
3437 free (dump_sects);
3438
3439 dump_sects = new_dump_sects;
3440 num_dump_sects = section + 1;
3441 }
3442 }
3443
3444 if (dump_sects)
b34976b6 3445 dump_sects[section] |= type;
252b5132
RH		 3446
3447 return;
3448}
3449
aef1f6d0
DJ		 3450/* Request a dump by section name. */
3451
3452static void
2cf0635d 3453request_dump_byname (const char * section, dump_type type)
aef1f6d0 3454{
2cf0635d 3455 struct dump_list_entry * new_request;
aef1f6d0 3456
3f5e193b
NC		 3457 new_request = (struct dump_list_entry *)
3458 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3459 if (!new_request)
591a748a 3460 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3461
3462 new_request->name = strdup (section);
3463 if (!new_request->name)
591a748a 3464 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3465
3466 new_request->type = type;
3467
3468 new_request->next = dump_sects_byname;
3469 dump_sects_byname = new_request;
3470}
3471
cf13d699
NC		 3472static inline void
3473request_dump (dump_type type)
3474{
3475 int section;
3476 char * cp;
3477
3478 do_dump++;
3479 section = strtoul (optarg, & cp, 0);
3480
3481 if (! *cp && section >= 0)
3482 request_dump_bynumber (section, type);
3483 else
3484 request_dump_byname (optarg, type);
3485}
3486
3487
252b5132 3488static void
2cf0635d 3489parse_args (int argc, char ** argv)
252b5132
RH		 3490{
3491 int c;
3492
3493 if (argc < 2)
92f01d61 3494 usage (stderr);
252b5132
RH		 3495
3496 while ((c = getopt_long
cf13d699 3497 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3498 {
252b5132
RH		 3499 switch (c)
3500 {
3501 case 0:
3502 /* Long options. */
3503 break;
3504 case 'H':
92f01d61 3505 usage (stdout);
252b5132
RH		 3506 break;
3507
3508 case 'a':
b34976b6
AM		 3509 do_syms++;
3510 do_reloc++;
3511 do_unwind++;
3512 do_dynamic++;
3513 do_header++;
3514 do_sections++;
f5842774 3515 do_section_groups++;
b34976b6
AM		 3516 do_segments++;
3517 do_version++;
3518 do_histogram++;
3519 do_arch++;
3520 do_notes++;
252b5132 3521 break;
f5842774
L		 3522 case 'g':
3523 do_section_groups++;
3524 break;
5477e8a0 3525 case 't':
595cf52e 3526 case 'N':
5477e8a0
L		 3527 do_sections++;
3528 do_section_details++;
595cf52e 3529 break;
252b5132 3530 case 'e':
b34976b6
AM		 3531 do_header++;
3532 do_sections++;
3533 do_segments++;
252b5132 3534 break;
a952a375 3535 case 'A':
b34976b6 3536 do_arch++;
a952a375 3537 break;
252b5132 3538 case 'D':
b34976b6 3539 do_using_dynamic++;
252b5132
RH		 3540 break;
3541 case 'r':
b34976b6 3542 do_reloc++;
252b5132 3543 break;
4d6ed7c8 3544 case 'u':
b34976b6 3545 do_unwind++;
4d6ed7c8 3546 break;
252b5132 3547 case 'h':
b34976b6 3548 do_header++;
252b5132
RH		 3549 break;
3550 case 'l':
b34976b6 3551 do_segments++;
252b5132
RH		 3552 break;
3553 case 's':
b34976b6 3554 do_syms++;
252b5132
RH		 3555 break;
3556 case 'S':
b34976b6 3557 do_sections++;
252b5132
RH		 3558 break;
3559 case 'd':
b34976b6 3560 do_dynamic++;
252b5132 3561 break;
a952a375 3562 case 'I':
b34976b6 3563 do_histogram++;
a952a375 3564 break;
779fe533 3565 case 'n':
b34976b6 3566 do_notes++;
779fe533 3567 break;
4145f1d5
NC		 3568 case 'c':
3569 do_archive_index++;
3570 break;
252b5132 3571 case 'x':
cf13d699 3572 request_dump (HEX_DUMP);
aef1f6d0 3573 break;
09c11c86 3574 case 'p':
cf13d699
NC		 3575 request_dump (STRING_DUMP);
3576 break;
3577 case 'R':
3578 request_dump (RELOC_DUMP);
09c11c86 3579 break;
252b5132 3580 case 'w':
b34976b6 3581 do_dump++;
252b5132 3582 if (optarg == 0)
613ff48b
CC		 3583 {
3584 do_debugging = 1;
3585 dwarf_select_sections_all ();
3586 }
252b5132
RH		 3587 else
3588 {
3589 do_debugging = 0;
4cb93e3b 3590 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3591 }
3592 break;
2979dc34 3593 case OPTION_DEBUG_DUMP:
b34976b6 3594 do_dump++;
2979dc34
JJ		 3595 if (optarg == 0)
3596 do_debugging = 1;
3597 else
3598 {
2979dc34 3599 do_debugging = 0;
4cb93e3b 3600 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3601 }
3602 break;
fd2f0033
TT		 3603 case OPTION_DWARF_DEPTH:
3604 {
3605 char *cp;
3606
3607 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3608 }
3609 break;
3610 case OPTION_DWARF_START:
3611 {
3612 char *cp;
3613
3614 dwarf_start_die = strtoul (optarg, & cp, 0);
3615 }
3616 break;
4723351a
CC		 3617 case OPTION_DWARF_CHECK:
3618 dwarf_check = 1;
3619 break;
2c610e4b
L		 3620 case OPTION_DYN_SYMS:
3621 do_dyn_syms++;
3622 break;
252b5132
RH		 3623#ifdef SUPPORT_DISASSEMBLY
3624 case 'i':
cf13d699
NC		 3625 request_dump (DISASS_DUMP);
3626 break;
252b5132
RH		 3627#endif
3628 case 'v':
3629 print_version (program_name);
3630 break;
3631 case 'V':
b34976b6 3632 do_version++;
252b5132 3633 break;
d974e256 3634 case 'W':
b34976b6 3635 do_wide++;
d974e256 3636 break;
252b5132 3637 default:
252b5132
RH		 3638 /* xgettext:c-format */
3639 error (_("Invalid option '-%c'\n"), c);
3640 /* Drop through. */
3641 case '?':
92f01d61 3642 usage (stderr);
252b5132
RH		 3643 }
3644 }
3645
4d6ed7c8 3646 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3647 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3648 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3649 && !do_section_groups && !do_archive_index
3650 && !do_dyn_syms)
92f01d61 3651 usage (stderr);
252b5132
RH		 3652 else if (argc < 3)
3653 {
3654 warn (_("Nothing to do.\n"));
92f01d61 3655 usage (stderr);
252b5132
RH		 3656 }
3657}
3658
3659static const char *
d3ba0551 3660get_elf_class (unsigned int elf_class)
252b5132 3661{
b34976b6 3662 static char buff[32];
103f02d3 3663
252b5132
RH		 3664 switch (elf_class)
3665 {
3666 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3667 case ELFCLASS32: return "ELF32";
3668 case ELFCLASS64: return "ELF64";
ab5e7794 3669 default:
e9e44622 3670 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3671 return buff;
252b5132
RH		 3672 }
3673}
3674
3675static const char *
d3ba0551 3676get_data_encoding (unsigned int encoding)
252b5132 3677{
b34976b6 3678 static char buff[32];
103f02d3 3679
252b5132
RH		 3680 switch (encoding)
3681 {
3682 case ELFDATANONE: return _("none");
33c63f9d
CM		 3683 case ELFDATA2LSB: return _("2's complement, little endian");
3684 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3685 default:
e9e44622 3686 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3687 return buff;
252b5132
RH		 3688 }
3689}
3690
252b5132 3691/* Decode the data held in 'elf_header'. */
ee42cf8c 3692
252b5132 3693static int
d3ba0551 3694process_file_header (void)
252b5132 3695{
b34976b6
AM		 3696 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3697 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3698 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3699 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3700 {
3701 error
3702 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3703 return 0;
3704 }
3705
2dc4cec1
L		 3706 init_dwarf_regnames (elf_header.e_machine);
3707
252b5132
RH		 3708 if (do_header)
3709 {
3710 int i;
3711
3712 printf (_("ELF Header:\n"));
3713 printf (_(" Magic: "));
b34976b6
AM		 3714 for (i = 0; i < EI_NIDENT; i++)
3715 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3716 printf ("\n");
3717 printf (_(" Class: %s\n"),
b34976b6 3718 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3719 printf (_(" Data: %s\n"),
b34976b6 3720 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3721 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3722 elf_header.e_ident[EI_VERSION],
3723 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3724 ? "(current)"
b34976b6 3725 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3726 ? _("<unknown: %lx>")
789be9f7 3727 : "")));
252b5132 3728 printf (_(" OS/ABI: %s\n"),
b34976b6 3729 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3730 printf (_(" ABI Version: %d\n"),
b34976b6 3731 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3732 printf (_(" Type: %s\n"),
3733 get_file_type (elf_header.e_type));
3734 printf (_(" Machine: %s\n"),
3735 get_machine_name (elf_header.e_machine));
3736 printf (_(" Version: 0x%lx\n"),
3737 (unsigned long) elf_header.e_version);
76da6bbe 3738
f7a99963
NC		 3739 printf (_(" Entry point address: "));
3740 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3741 printf (_("\n Start of program headers: "));
3742 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3743 printf (_(" (bytes into file)\n Start of section headers: "));
3744 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3745 printf (_(" (bytes into file)\n"));
76da6bbe 3746
252b5132
RH		 3747 printf (_(" Flags: 0x%lx%s\n"),
3748 (unsigned long) elf_header.e_flags,
3749 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3750 printf (_(" Size of this header: %ld (bytes)\n"),
3751 (long) elf_header.e_ehsize);
3752 printf (_(" Size of program headers: %ld (bytes)\n"),
3753 (long) elf_header.e_phentsize);
2046a35d 3754 printf (_(" Number of program headers: %ld"),
252b5132 3755 (long) elf_header.e_phnum);
2046a35d
AM		 3756 if (section_headers != NULL
3757 && elf_header.e_phnum == PN_XNUM
3758 && section_headers[0].sh_info != 0)
cc5914eb 3759 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3760 putc ('\n', stdout);
252b5132
RH		 3761 printf (_(" Size of section headers: %ld (bytes)\n"),
3762 (long) elf_header.e_shentsize);
560f3c1c 3763 printf (_(" Number of section headers: %ld"),
252b5132 3764 (long) elf_header.e_shnum);
4fbb74a6 3765 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3766 printf (" (%ld)", (long) section_headers[0].sh_size);
3767 putc ('\n', stdout);
3768 printf (_(" Section header string table index: %ld"),
252b5132 3769 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3770 if (section_headers != NULL
3771 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3772 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3773 else if (elf_header.e_shstrndx != SHN_UNDEF
3774 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3775 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3776 putc ('\n', stdout);
3777 }
3778
3779 if (section_headers != NULL)
3780 {
2046a35d
AM		 3781 if (elf_header.e_phnum == PN_XNUM
3782 && section_headers[0].sh_info != 0)
3783 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3784 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3785 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3786 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3787 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3788 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3789 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3790 free (section_headers);
3791 section_headers = NULL;
252b5132 3792 }
103f02d3 3793
9ea033b2
NC		 3794 return 1;
3795}
3796
252b5132 3797
9ea033b2 3798static int
91d6fa6a 3799get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3800{
2cf0635d
NC		 3801 Elf32_External_Phdr * phdrs;
3802 Elf32_External_Phdr * external;
3803 Elf_Internal_Phdr * internal;
b34976b6 3804 unsigned int i;
103f02d3 3805
3f5e193b
NC		 3806 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3807 elf_header.e_phentsize,
3808 elf_header.e_phnum,
3809 _("program headers"));
a6e9f9df
AM		 3810 if (!phdrs)
3811 return 0;
9ea033b2 3812
91d6fa6a 3813 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3814 i < elf_header.e_phnum;
b34976b6 3815 i++, internal++, external++)
252b5132 3816 {
9ea033b2
NC		 3817 internal->p_type = BYTE_GET (external->p_type);
3818 internal->p_offset = BYTE_GET (external->p_offset);
3819 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3820 internal->p_paddr = BYTE_GET (external->p_paddr);
3821 internal->p_filesz = BYTE_GET (external->p_filesz);
3822 internal->p_memsz = BYTE_GET (external->p_memsz);
3823 internal->p_flags = BYTE_GET (external->p_flags);
3824 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3825 }
3826
9ea033b2
NC		 3827 free (phdrs);
3828
252b5132
RH		 3829 return 1;
3830}
3831
9ea033b2 3832static int
91d6fa6a 3833get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3834{
2cf0635d
NC		 3835 Elf64_External_Phdr * phdrs;
3836 Elf64_External_Phdr * external;
3837 Elf_Internal_Phdr * internal;
b34976b6 3838 unsigned int i;
103f02d3 3839
3f5e193b
NC		 3840 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3841 elf_header.e_phentsize,
3842 elf_header.e_phnum,
3843 _("program headers"));
a6e9f9df
AM		 3844 if (!phdrs)
3845 return 0;
9ea033b2 3846
91d6fa6a 3847 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3848 i < elf_header.e_phnum;
b34976b6 3849 i++, internal++, external++)
9ea033b2
NC		 3850 {
3851 internal->p_type = BYTE_GET (external->p_type);
3852 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3853 internal->p_offset = BYTE_GET (external->p_offset);
3854 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3855 internal->p_paddr = BYTE_GET (external->p_paddr);
3856 internal->p_filesz = BYTE_GET (external->p_filesz);
3857 internal->p_memsz = BYTE_GET (external->p_memsz);
3858 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3859 }
3860
3861 free (phdrs);
3862
3863 return 1;
3864}
252b5132 3865
d93f0186
NC		 3866/* Returns 1 if the program headers were read into `program_headers'. */
3867
3868static int
2cf0635d 3869get_program_headers (FILE * file)
d93f0186 3870{
2cf0635d 3871 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3872
3873 /* Check cache of prior read. */
3874 if (program_headers != NULL)
3875 return 1;
3876
3f5e193b
NC		 3877 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3878 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3879
3880 if (phdrs == NULL)
3881 {
3882 error (_("Out of memory\n"));
3883 return 0;
3884 }
3885
3886 if (is_32bit_elf
3887 ? get_32bit_program_headers (file, phdrs)
3888 : get_64bit_program_headers (file, phdrs))
3889 {
3890 program_headers = phdrs;
3891 return 1;
3892 }
3893
3894 free (phdrs);
3895 return 0;
3896}
3897
2f62977e
NC		 3898/* Returns 1 if the program headers were loaded. */
3899
252b5132 3900static int
2cf0635d 3901process_program_headers (FILE * file)
252b5132 3902{
2cf0635d 3903 Elf_Internal_Phdr * segment;
b34976b6 3904 unsigned int i;
252b5132
RH		 3905
3906 if (elf_header.e_phnum == 0)
3907 {
82f2dbf7
NC		 3908 /* PR binutils/12467. */
3909 if (elf_header.e_phoff != 0)
3910 warn (_("possibly corrupt ELF header - it has a non-zero program"
3911 " header offset, but no program headers"));
3912 else if (do_segments)
252b5132 3913 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3914 return 0;
252b5132
RH		 3915 }
3916
3917 if (do_segments && !do_header)
3918 {
f7a99963
NC		 3919 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3920 printf (_("Entry point "));
3921 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3922 printf (_("\nThere are %d program headers, starting at offset "),
3923 elf_header.e_phnum);
3924 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3925 printf ("\n");
252b5132
RH		 3926 }
3927
d93f0186 3928 if (! get_program_headers (file))
252b5132 3929 return 0;
103f02d3 3930
252b5132
RH		 3931 if (do_segments)
3932 {
3a1a2036
NC		 3933 if (elf_header.e_phnum > 1)
3934 printf (_("\nProgram Headers:\n"));
3935 else
3936 printf (_("\nProgram Headers:\n"));
76da6bbe 3937
f7a99963
NC		 3938 if (is_32bit_elf)
3939 printf
3940 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3941 else if (do_wide)
3942 printf
3943 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3944 else
3945 {
3946 printf
3947 (_(" Type Offset VirtAddr PhysAddr\n"));
3948 printf
3949 (_(" FileSiz MemSiz Flags Align\n"));
3950 }
252b5132
RH		 3951 }
3952
252b5132 3953 dynamic_addr = 0;
1b228002 3954 dynamic_size = 0;
252b5132
RH		 3955
3956 for (i = 0, segment = program_headers;
3957 i < elf_header.e_phnum;
b34976b6 3958 i++, segment++)
252b5132
RH		 3959 {
3960 if (do_segments)
3961 {
103f02d3 3962 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3963
3964 if (is_32bit_elf)
3965 {
3966 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3967 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3968 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3969 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3970 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3971 printf ("%c%c%c ",
3972 (segment->p_flags & PF_R ? 'R' : ' '),
3973 (segment->p_flags & PF_W ? 'W' : ' '),
3974 (segment->p_flags & PF_X ? 'E' : ' '));
3975 printf ("%#lx", (unsigned long) segment->p_align);
3976 }
d974e256
JJ		 3977 else if (do_wide)
3978 {
3979 if ((unsigned long) segment->p_offset == segment->p_offset)
3980 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3981 else
3982 {
3983 print_vma (segment->p_offset, FULL_HEX);
3984 putchar (' ');
3985 }
3986
3987 print_vma (segment->p_vaddr, FULL_HEX);
3988 putchar (' ');
3989 print_vma (segment->p_paddr, FULL_HEX);
3990 putchar (' ');
3991
3992 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3993 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3994 else
3995 {
3996 print_vma (segment->p_filesz, FULL_HEX);
3997 putchar (' ');
3998 }
3999
4000 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4001 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4002 else
4003 {
f48e6c45 4004 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4005 }
4006
4007 printf (" %c%c%c ",
4008 (segment->p_flags & PF_R ? 'R' : ' '),
4009 (segment->p_flags & PF_W ? 'W' : ' '),
4010 (segment->p_flags & PF_X ? 'E' : ' '));
4011
4012 if ((unsigned long) segment->p_align == segment->p_align)
4013 printf ("%#lx", (unsigned long) segment->p_align);
4014 else
4015 {
4016 print_vma (segment->p_align, PREFIX_HEX);
4017 }
4018 }
f7a99963
NC		 4019 else
4020 {
4021 print_vma (segment->p_offset, FULL_HEX);
4022 putchar (' ');
4023 print_vma (segment->p_vaddr, FULL_HEX);
4024 putchar (' ');
4025 print_vma (segment->p_paddr, FULL_HEX);
4026 printf ("\n ");
4027 print_vma (segment->p_filesz, FULL_HEX);
4028 putchar (' ');
4029 print_vma (segment->p_memsz, FULL_HEX);
4030 printf (" %c%c%c ",
4031 (segment->p_flags & PF_R ? 'R' : ' '),
4032 (segment->p_flags & PF_W ? 'W' : ' '),
4033 (segment->p_flags & PF_X ? 'E' : ' '));
4034 print_vma (segment->p_align, HEX);
4035 }
252b5132
RH		 4036 }
4037
4038 switch (segment->p_type)
4039 {
252b5132
RH		 4040 case PT_DYNAMIC:
4041 if (dynamic_addr)
4042 error (_("more than one dynamic segment\n"));
4043
20737c13
AM		 4044 /* By default, assume that the .dynamic section is the first
4045 section in the DYNAMIC segment. */
4046 dynamic_addr = segment->p_offset;
4047 dynamic_size = segment->p_filesz;
4048
b2d38a17
NC		 4049 /* Try to locate the .dynamic section. If there is
4050 a section header table, we can easily locate it. */
4051 if (section_headers != NULL)
4052 {
2cf0635d 4053 Elf_Internal_Shdr * sec;
b2d38a17 4054
89fac5e3
RS		 4055 sec = find_section (".dynamic");
4056 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4057 {
28f997cf
TG		 4058 /* A corresponding .dynamic section is expected, but on
4059 IA-64/OpenVMS it is OK for it to be missing. */
4060 if (!is_ia64_vms ())
4061 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4062 break;
4063 }
4064
42bb2e33 4065 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4066 {
4067 dynamic_size = 0;
4068 break;
4069 }
42bb2e33 4070
b2d38a17
NC		 4071 dynamic_addr = sec->sh_offset;
4072 dynamic_size = sec->sh_size;
4073
4074 if (dynamic_addr < segment->p_offset
4075 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4076 warn (_("the .dynamic section is not contained"
4077 " within the dynamic segment\n"));
b2d38a17 4078 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4079 warn (_("the .dynamic section is not the first section"
4080 " in the dynamic segment.\n"));
b2d38a17 4081 }
252b5132
RH		 4082 break;
4083
4084 case PT_INTERP:
fb52b2f4
NC		 4085 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4086 SEEK_SET))
252b5132
RH		 4087 error (_("Unable to find program interpreter name\n"));
4088 else
4089 {
f8eae8b2
L		 4090 char fmt [32];
4091 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4092
4093 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4094 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4095
252b5132 4096 program_interpreter[0] = 0;
7bd7b3ef
AM		 4097 if (fscanf (file, fmt, program_interpreter) <= 0)
4098 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4099
4100 if (do_segments)
4101 printf (_("\n [Requesting program interpreter: %s]"),
4102 program_interpreter);
4103 }
4104 break;
4105 }
4106
4107 if (do_segments)
4108 putc ('\n', stdout);
4109 }
4110
c256ffe7 4111 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4112 {
4113 printf (_("\n Section to Segment mapping:\n"));
4114 printf (_(" Segment Sections...\n"));
4115
252b5132
RH		 4116 for (i = 0; i < elf_header.e_phnum; i++)
4117 {
9ad5cbcf 4118 unsigned int j;
2cf0635d 4119 Elf_Internal_Shdr * section;
252b5132
RH		 4120
4121 segment = program_headers + i;
b391a3e3 4122 section = section_headers + 1;
252b5132
RH		 4123
4124 printf (" %2.2d ", i);
4125
b34976b6 4126 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4127 {
f4638467
AM		 4128 if (!ELF_TBSS_SPECIAL (section, segment)
4129 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 4130 printf ("%s ", SECTION_NAME (section));
4131 }
4132
4133 putc ('\n',stdout);
4134 }
4135 }
4136
252b5132
RH		 4137 return 1;
4138}
4139
4140
d93f0186
NC		 4141/* Find the file offset corresponding to VMA by using the program headers. */
4142
4143static long
2cf0635d 4144offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4145{
2cf0635d 4146 Elf_Internal_Phdr * seg;
d93f0186
NC		 4147
4148 if (! get_program_headers (file))
4149 {
4150 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4151 return (long) vma;
4152 }
4153
4154 for (seg = program_headers;
4155 seg < program_headers + elf_header.e_phnum;
4156 ++seg)
4157 {
4158 if (seg->p_type != PT_LOAD)
4159 continue;
4160
4161 if (vma >= (seg->p_vaddr & -seg->p_align)
4162 && vma + size <= seg->p_vaddr + seg->p_filesz)
4163 return vma - seg->p_vaddr + seg->p_offset;
4164 }
4165
4166 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4167 (unsigned long) vma);
d93f0186
NC		 4168 return (long) vma;
4169}
4170
4171
252b5132 4172static int
2cf0635d 4173get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4174{
2cf0635d
NC		 4175 Elf32_External_Shdr * shdrs;
4176 Elf_Internal_Shdr * internal;
b34976b6 4177 unsigned int i;
252b5132 4178
3f5e193b
NC		 4179 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4180 elf_header.e_shentsize, num,
4181 _("section headers"));
a6e9f9df
AM		 4182 if (!shdrs)
4183 return 0;
252b5132 4184
3f5e193b
NC		 4185 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4186 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4187
4188 if (section_headers == NULL)
4189 {
4190 error (_("Out of memory\n"));
4191 return 0;
4192 }
4193
4194 for (i = 0, internal = section_headers;
560f3c1c 4195 i < num;
b34976b6 4196 i++, internal++)
252b5132
RH		 4197 {
4198 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4199 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4200 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4201 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4202 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4203 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4204 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4205 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4206 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4207 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4208 }
4209
4210 free (shdrs);
4211
4212 return 1;
4213}
4214
9ea033b2 4215static int
2cf0635d 4216get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4217{
2cf0635d
NC		 4218 Elf64_External_Shdr * shdrs;
4219 Elf_Internal_Shdr * internal;
b34976b6 4220 unsigned int i;
9ea033b2 4221
3f5e193b
NC		 4222 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4223 elf_header.e_shentsize, num,
4224 _("section headers"));
a6e9f9df
AM		 4225 if (!shdrs)
4226 return 0;
9ea033b2 4227
3f5e193b
NC		 4228 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4229 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4230
4231 if (section_headers == NULL)
4232 {
4233 error (_("Out of memory\n"));
4234 return 0;
4235 }
4236
4237 for (i = 0, internal = section_headers;
560f3c1c 4238 i < num;
b34976b6 4239 i++, internal++)
9ea033b2
NC		 4240 {
4241 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4242 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4243 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4244 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4245 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4246 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4247 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4248 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4249 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4250 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4251 }
4252
4253 free (shdrs);
4254
4255 return 1;
4256}
4257
252b5132 4258static Elf_Internal_Sym *
ba5cdace
NC		 4259get_32bit_elf_symbols (FILE * file,
4260 Elf_Internal_Shdr * section,
4261 unsigned long * num_syms_return)
252b5132 4262{
ba5cdace 4263 unsigned long number = 0;
dd24e3da 4264 Elf32_External_Sym * esyms = NULL;
ba5cdace 4265 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4266 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4267 Elf_Internal_Sym * psym;
b34976b6 4268 unsigned int j;
252b5132 4269
dd24e3da
NC		 4270 /* Run some sanity checks first. */
4271 if (section->sh_entsize == 0)
4272 {
4273 error (_("sh_entsize is zero\n"));
ba5cdace 4274 goto exit_point;
dd24e3da
NC		 4275 }
4276
4277 number = section->sh_size / section->sh_entsize;
4278
4279 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4280 {
4281 error (_("Invalid sh_entsize\n"));
ba5cdace 4282 goto exit_point;
dd24e3da
NC		 4283 }
4284
3f5e193b
NC		 4285 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4286 section->sh_size, _("symbols"));
dd24e3da 4287 if (esyms == NULL)
ba5cdace 4288 goto exit_point;
252b5132 4289
9ad5cbcf
AM		 4290 shndx = NULL;
4291 if (symtab_shndx_hdr != NULL
4292 && (symtab_shndx_hdr->sh_link
4fbb74a6 4293 == (unsigned long) (section - section_headers)))
9ad5cbcf 4294 {
3f5e193b
NC		 4295 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4296 symtab_shndx_hdr->sh_offset,
4297 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4298 _("symbol table section indicies"));
dd24e3da
NC		 4299 if (shndx == NULL)
4300 goto exit_point;
9ad5cbcf
AM		 4301 }
4302
3f5e193b 4303 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4304
4305 if (isyms == NULL)
4306 {
4307 error (_("Out of memory\n"));
dd24e3da 4308 goto exit_point;
252b5132
RH		 4309 }
4310
dd24e3da 4311 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4312 {
4313 psym->st_name = BYTE_GET (esyms[j].st_name);
4314 psym->st_value = BYTE_GET (esyms[j].st_value);
4315 psym->st_size = BYTE_GET (esyms[j].st_size);
4316 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4317 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4318 psym->st_shndx
4319 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4320 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4321 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4322 psym->st_info = BYTE_GET (esyms[j].st_info);
4323 psym->st_other = BYTE_GET (esyms[j].st_other);
4324 }
4325
dd24e3da 4326 exit_point:
ba5cdace 4327 if (shndx != NULL)
9ad5cbcf 4328 free (shndx);
ba5cdace 4329 if (esyms != NULL)
dd24e3da 4330 free (esyms);
252b5132 4331
ba5cdace
NC		 4332 if (num_syms_return != NULL)
4333 * num_syms_return = isyms == NULL ? 0 : number;
4334
252b5132
RH		 4335 return isyms;
4336}
4337
9ea033b2 4338static Elf_Internal_Sym *
ba5cdace
NC		 4339get_64bit_elf_symbols (FILE * file,
4340 Elf_Internal_Shdr * section,
4341 unsigned long * num_syms_return)
9ea033b2 4342{
ba5cdace
NC		 4343 unsigned long number = 0;
4344 Elf64_External_Sym * esyms = NULL;
4345 Elf_External_Sym_Shndx * shndx = NULL;
4346 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4347 Elf_Internal_Sym * psym;
b34976b6 4348 unsigned int j;
9ea033b2 4349
dd24e3da
NC		 4350 /* Run some sanity checks first. */
4351 if (section->sh_entsize == 0)
4352 {
4353 error (_("sh_entsize is zero\n"));
ba5cdace 4354 goto exit_point;
dd24e3da
NC		 4355 }
4356
4357 number = section->sh_size / section->sh_entsize;
4358
4359 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4360 {
4361 error (_("Invalid sh_entsize\n"));
ba5cdace 4362 goto exit_point;
dd24e3da
NC		 4363 }
4364
3f5e193b
NC		 4365 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4366 section->sh_size, _("symbols"));
a6e9f9df 4367 if (!esyms)
ba5cdace 4368 goto exit_point;
9ea033b2 4369
9ad5cbcf
AM		 4370 if (symtab_shndx_hdr != NULL
4371 && (symtab_shndx_hdr->sh_link
4fbb74a6 4372 == (unsigned long) (section - section_headers)))
9ad5cbcf 4373 {
3f5e193b
NC		 4374 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4375 symtab_shndx_hdr->sh_offset,
4376 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4377 _("symbol table section indicies"));
ba5cdace
NC		 4378 if (shndx == NULL)
4379 goto exit_point;
9ad5cbcf
AM		 4380 }
4381
3f5e193b 4382 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4383
4384 if (isyms == NULL)
4385 {
4386 error (_("Out of memory\n"));
ba5cdace 4387 goto exit_point;
9ea033b2
NC		 4388 }
4389
ba5cdace 4390 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4391 {
4392 psym->st_name = BYTE_GET (esyms[j].st_name);
4393 psym->st_info = BYTE_GET (esyms[j].st_info);
4394 psym->st_other = BYTE_GET (esyms[j].st_other);
4395 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4396
4fbb74a6 4397 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4398 psym->st_shndx
4399 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4400 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4401 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4402
66543521
AM		 4403 psym->st_value = BYTE_GET (esyms[j].st_value);
4404 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4405 }
4406
ba5cdace
NC		 4407 exit_point:
4408 if (shndx != NULL)
9ad5cbcf 4409 free (shndx);
ba5cdace
NC		 4410 if (esyms != NULL)
4411 free (esyms);
4412
4413 if (num_syms_return != NULL)
4414 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4415
4416 return isyms;
4417}
4418
d1133906 4419static const char *
d3ba0551 4420get_elf_section_flags (bfd_vma sh_flags)
d1133906 4421{
5477e8a0 4422 static char buff[1024];
2cf0635d 4423 char * p = buff;
8d5ff12c 4424 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4425 int sindex;
4426 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4427 bfd_vma os_flags = 0;
4428 bfd_vma proc_flags = 0;
4429 bfd_vma unknown_flags = 0;
148b93f2 4430 static const struct
5477e8a0 4431 {
2cf0635d 4432 const char * str;
5477e8a0
L		 4433 int len;
4434 }
4435 flags [] =
4436 {
cfcac11d
NC		 4437 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4438 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4439 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4440 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4441 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4442 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4443 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4444 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4445 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4446 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4447 /* IA-64 specific. */
4448 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4449 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4450 /* IA-64 OpenVMS specific. */
4451 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4452 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4453 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4454 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4455 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4456 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4457 /* Generic. */
cfcac11d 4458 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4459 /* SPARC specific. */
cfcac11d 4460 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4461 };
4462
4463 if (do_section_details)
4464 {
8d5ff12c
L		 4465 sprintf (buff, "[%*.*lx]: ",
4466 field_size, field_size, (unsigned long) sh_flags);
4467 p += field_size + 4;
5477e8a0 4468 }
76da6bbe 4469
d1133906
NC		 4470 while (sh_flags)
4471 {
4472 bfd_vma flag;
4473
4474 flag = sh_flags & - sh_flags;
4475 sh_flags &= ~ flag;
76da6bbe 4476
5477e8a0 4477 if (do_section_details)
d1133906 4478 {
5477e8a0
L		 4479 switch (flag)
4480 {
91d6fa6a
NC		 4481 case SHF_WRITE: sindex = 0; break;
4482 case SHF_ALLOC: sindex = 1; break;
4483 case SHF_EXECINSTR: sindex = 2; break;
4484 case SHF_MERGE: sindex = 3; break;
4485 case SHF_STRINGS: sindex = 4; break;
4486 case SHF_INFO_LINK: sindex = 5; break;
4487 case SHF_LINK_ORDER: sindex = 6; break;
4488 case SHF_OS_NONCONFORMING: sindex = 7; break;
4489 case SHF_GROUP: sindex = 8; break;
4490 case SHF_TLS: sindex = 9; break;
18ae9cc1 4491 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4492
5477e8a0 4493 default:
91d6fa6a 4494 sindex = -1;
cfcac11d 4495 switch (elf_header.e_machine)
148b93f2 4496 {
cfcac11d 4497 case EM_IA_64:
148b93f2 4498 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4499 sindex = 10;
148b93f2 4500 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4501 sindex = 11;
148b93f2
NC		 4502#ifdef BFD64
4503 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4504 switch (flag)
4505 {
91d6fa6a
NC		 4506 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4507 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4508 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4509 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4510 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4511 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4512 default: break;
4513 }
4514#endif
cfcac11d
NC		 4515 break;
4516
caa83f8b
NC		 4517 case EM_386:
4518 case EM_486:
4519 case EM_X86_64:
7f502d6c 4520 case EM_L1OM:
7a9068fe 4521 case EM_K1OM:
cfcac11d
NC		 4522 case EM_OLD_SPARCV9:
4523 case EM_SPARC32PLUS:
4524 case EM_SPARCV9:
4525 case EM_SPARC:
18ae9cc1 4526 if (flag == SHF_ORDERED)
91d6fa6a 4527 sindex = 19;
cfcac11d
NC		 4528 break;
4529 default:
4530 break;
148b93f2 4531 }
5477e8a0
L		 4532 }
4533
91d6fa6a 4534 if (sindex != -1)
5477e8a0 4535 {
8d5ff12c
L		 4536 if (p != buff + field_size + 4)
4537 {
4538 if (size < (10 + 2))
4539 abort ();
4540 size -= 2;
4541 *p++ = ',';
4542 *p++ = ' ';
4543 }
4544
91d6fa6a
NC		 4545 size -= flags [sindex].len;
4546 p = stpcpy (p, flags [sindex].str);
5477e8a0 4547 }
3b22753a 4548 else if (flag & SHF_MASKOS)
8d5ff12c 4549 os_flags |= flag;
d1133906 4550 else if (flag & SHF_MASKPROC)
8d5ff12c 4551 proc_flags |= flag;
d1133906 4552 else
8d5ff12c 4553 unknown_flags |= flag;
5477e8a0
L		 4554 }
4555 else
4556 {
4557 switch (flag)
4558 {
4559 case SHF_WRITE: *p = 'W'; break;
4560 case SHF_ALLOC: *p = 'A'; break;
4561 case SHF_EXECINSTR: *p = 'X'; break;
4562 case SHF_MERGE: *p = 'M'; break;
4563 case SHF_STRINGS: *p = 'S'; break;
4564 case SHF_INFO_LINK: *p = 'I'; break;
4565 case SHF_LINK_ORDER: *p = 'L'; break;
4566 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4567 case SHF_GROUP: *p = 'G'; break;
4568 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4569 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4570
4571 default:
8a9036a4 4572 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4573 || elf_header.e_machine == EM_L1OM
4574 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4575 && flag == SHF_X86_64_LARGE)
4576 *p = 'l';
4577 else if (flag & SHF_MASKOS)
4578 {
4579 *p = 'o';
4580 sh_flags &= ~ SHF_MASKOS;
4581 }
4582 else if (flag & SHF_MASKPROC)
4583 {
4584 *p = 'p';
4585 sh_flags &= ~ SHF_MASKPROC;
4586 }
4587 else
4588 *p = 'x';
4589 break;
4590 }
4591 p++;
d1133906
NC		 4592 }
4593 }
76da6bbe 4594
8d5ff12c
L		 4595 if (do_section_details)
4596 {
4597 if (os_flags)
4598 {
4599 size -= 5 + field_size;
4600 if (p != buff + field_size + 4)
4601 {
4602 if (size < (2 + 1))
4603 abort ();
4604 size -= 2;
4605 *p++ = ',';
4606 *p++ = ' ';
4607 }
4608 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4609 (unsigned long) os_flags);
4610 p += 5 + field_size;
4611 }
4612 if (proc_flags)
4613 {
4614 size -= 7 + field_size;
4615 if (p != buff + field_size + 4)
4616 {
4617 if (size < (2 + 1))
4618 abort ();
4619 size -= 2;
4620 *p++ = ',';
4621 *p++ = ' ';
4622 }
4623 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4624 (unsigned long) proc_flags);
4625 p += 7 + field_size;
4626 }
4627 if (unknown_flags)
4628 {
4629 size -= 10 + field_size;
4630 if (p != buff + field_size + 4)
4631 {
4632 if (size < (2 + 1))
4633 abort ();
4634 size -= 2;
4635 *p++ = ',';
4636 *p++ = ' ';
4637 }
2b692964 4638 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4639 (unsigned long) unknown_flags);
4640 p += 10 + field_size;
4641 }
4642 }
4643
e9e44622 4644 *p = '\0';
d1133906
NC		 4645 return buff;
4646}
4647
252b5132 4648static int
2cf0635d 4649process_section_headers (FILE * file)
252b5132 4650{
2cf0635d 4651 Elf_Internal_Shdr * section;
b34976b6 4652 unsigned int i;
252b5132
RH		 4653
4654 section_headers = NULL;
4655
4656 if (elf_header.e_shnum == 0)
4657 {
82f2dbf7
NC		 4658 /* PR binutils/12467. */
4659 if (elf_header.e_shoff != 0)
4660 warn (_("possibly corrupt ELF file header - it has a non-zero"
4661 " section header offset, but no section headers\n"));
4662 else if (do_sections)
252b5132
RH		 4663 printf (_("\nThere are no sections in this file.\n"));
4664
4665 return 1;
4666 }
4667
4668 if (do_sections && !do_header)
9ea033b2 4669 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4670 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4671
9ea033b2
NC		 4672 if (is_32bit_elf)
4673 {
560f3c1c 4674 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4675 return 0;
4676 }
560f3c1c 4677 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4678 return 0;
4679
4680 /* Read in the string table, so that we have names to display. */
0b49d371 4681 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4682 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4683 {
4fbb74a6 4684 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4685
c256ffe7
JJ		 4686 if (section->sh_size != 0)
4687 {
3f5e193b
NC		 4688 string_table = (char *) get_data (NULL, file, section->sh_offset,
4689 1, section->sh_size,
4690 _("string table"));
0de14b54 4691
c256ffe7
JJ		 4692 string_table_length = string_table != NULL ? section->sh_size : 0;
4693 }
252b5132
RH		 4694 }
4695
4696 /* Scan the sections for the dynamic symbol table
e3c8793a 4697 and dynamic string table and debug sections. */
252b5132
RH		 4698 dynamic_symbols = NULL;
4699 dynamic_strings = NULL;
4700 dynamic_syminfo = NULL;
f1ef08cb 4701 symtab_shndx_hdr = NULL;
103f02d3 4702
89fac5e3
RS		 4703 eh_addr_size = is_32bit_elf ? 4 : 8;
4704 switch (elf_header.e_machine)
4705 {
4706 case EM_MIPS:
4707 case EM_MIPS_RS3_LE:
4708 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4709 FDE addresses. However, the ABI also has a semi-official ILP32
4710 variant for which the normal FDE address size rules apply.
4711
4712 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4713 section, where XX is the size of longs in bits. Unfortunately,
4714 earlier compilers provided no way of distinguishing ILP32 objects
4715 from LP64 objects, so if there's any doubt, we should assume that
4716 the official LP64 form is being used. */
4717 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4718 && find_section (".gcc_compiled_long32") == NULL)
4719 eh_addr_size = 8;
4720 break;
0f56a26a
DD		 4721
4722 case EM_H8_300:
4723 case EM_H8_300H:
4724 switch (elf_header.e_flags & EF_H8_MACH)
4725 {
4726 case E_H8_MACH_H8300:
4727 case E_H8_MACH_H8300HN:
4728 case E_H8_MACH_H8300SN:
4729 case E_H8_MACH_H8300SXN:
4730 eh_addr_size = 2;
4731 break;
4732 case E_H8_MACH_H8300H:
4733 case E_H8_MACH_H8300S:
4734 case E_H8_MACH_H8300SX:
4735 eh_addr_size = 4;
4736 break;
4737 }
f4236fe4
DD		 4738 break;
4739
ff7eeb89 4740 case EM_M32C_OLD:
f4236fe4
DD		 4741 case EM_M32C:
4742 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4743 {
4744 case EF_M32C_CPU_M16C:
4745 eh_addr_size = 2;
4746 break;
4747 }
4748 break;
89fac5e3
RS		 4749 }
4750
08d8fa11
JJ		 4751#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4752 do \
4753 { \
4754 size_t expected_entsize \
4755 = is_32bit_elf ? size32 : size64; \
4756 if (section->sh_entsize != expected_entsize) \
4757 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4758 i, (unsigned long int) section->sh_entsize, \
4759 (unsigned long int) expected_entsize); \
4760 section->sh_entsize = expected_entsize; \
4761 } \
4762 while (0)
4763#define CHECK_ENTSIZE(section, i, type) \
4764 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4765 sizeof (Elf64_External_##type))
4766
252b5132
RH		 4767 for (i = 0, section = section_headers;
4768 i < elf_header.e_shnum;
b34976b6 4769 i++, section++)
252b5132 4770 {
2cf0635d 4771 char * name = SECTION_NAME (section);
252b5132
RH		 4772
4773 if (section->sh_type == SHT_DYNSYM)
4774 {
4775 if (dynamic_symbols != NULL)
4776 {
4777 error (_("File contains multiple dynamic symbol tables\n"));
4778 continue;
4779 }
4780
08d8fa11 4781 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4782 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 4783 }
4784 else if (section->sh_type == SHT_STRTAB
18bd398b 4785 && streq (name, ".dynstr"))
252b5132
RH		 4786 {
4787 if (dynamic_strings != NULL)
4788 {
4789 error (_("File contains multiple dynamic string tables\n"));
4790 continue;
4791 }
4792
3f5e193b
NC		 4793 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4794 1, section->sh_size,
4795 _("dynamic strings"));
59245841 4796 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4797 }
9ad5cbcf
AM		 4798 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4799 {
4800 if (symtab_shndx_hdr != NULL)
4801 {
4802 error (_("File contains multiple symtab shndx tables\n"));
4803 continue;
4804 }
4805 symtab_shndx_hdr = section;
4806 }
08d8fa11
JJ		 4807 else if (section->sh_type == SHT_SYMTAB)
4808 CHECK_ENTSIZE (section, i, Sym);
4809 else if (section->sh_type == SHT_GROUP)
4810 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4811 else if (section->sh_type == SHT_REL)
4812 CHECK_ENTSIZE (section, i, Rel);
4813 else if (section->sh_type == SHT_RELA)
4814 CHECK_ENTSIZE (section, i, Rela);
252b5132 4815 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4816 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4817 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 4818 || do_debug_str || do_debug_loc || do_debug_ranges
4819 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 4820 && (const_strneq (name, ".debug_")
4821 || const_strneq (name, ".zdebug_")))
252b5132 4822 {
1b315056
CS		 4823 if (name[1] == 'z')
4824 name += sizeof (".zdebug_") - 1;
4825 else
4826 name += sizeof (".debug_") - 1;
252b5132
RH		 4827
4828 if (do_debugging
4723351a
CC		 4829 || (do_debug_info && const_strneq (name, "info"))
4830 || (do_debug_info && const_strneq (name, "types"))
4831 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4832 || (do_debug_lines && const_strneq (name, "line"))
4833 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4834 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4835 || (do_debug_aranges && const_strneq (name, "aranges"))
4836 || (do_debug_ranges && const_strneq (name, "ranges"))
4837 || (do_debug_frames && const_strneq (name, "frame"))
4838 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4839 || (do_debug_macinfo && const_strneq (name, "macro"))
4840 || (do_debug_str && const_strneq (name, "str"))
4841 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 4842 || (do_debug_addr && const_strneq (name, "addr"))
4843 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4844 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 4845 )
09c11c86 4846 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4847 }
a262ae96 4848 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4849 else if ((do_debugging || do_debug_info)
0112cd26 4850 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4851 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4852 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4853 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4854 else if (do_gdb_index && streq (name, ".gdb_index"))
4855 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4856 /* Trace sections for Itanium VMS. */
4857 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4858 || do_trace_aranges)
4859 && const_strneq (name, ".trace_"))
4860 {
4861 name += sizeof (".trace_") - 1;
4862
4863 if (do_debugging
4864 || (do_trace_info && streq (name, "info"))
4865 || (do_trace_abbrevs && streq (name, "abbrev"))
4866 || (do_trace_aranges && streq (name, "aranges"))
4867 )
4868 request_dump_bynumber (i, DEBUG_DUMP);
4869 }
4870
252b5132
RH		 4871 }
4872
4873 if (! do_sections)
4874 return 1;
4875
3a1a2036
NC		 4876 if (elf_header.e_shnum > 1)
4877 printf (_("\nSection Headers:\n"));
4878 else
4879 printf (_("\nSection Header:\n"));
76da6bbe 4880
f7a99963 4881 if (is_32bit_elf)
595cf52e 4882 {
5477e8a0 4883 if (do_section_details)
595cf52e
L		 4884 {
4885 printf (_(" [Nr] Name\n"));
5477e8a0 4886 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4887 }
4888 else
4889 printf
4890 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4891 }
d974e256 4892 else if (do_wide)
595cf52e 4893 {
5477e8a0 4894 if (do_section_details)
595cf52e
L		 4895 {
4896 printf (_(" [Nr] Name\n"));
5477e8a0 4897 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4898 }
4899 else
4900 printf
4901 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4902 }
f7a99963
NC		 4903 else
4904 {
5477e8a0 4905 if (do_section_details)
595cf52e
L		 4906 {
4907 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4908 printf (_(" Type Address Offset Link\n"));
4909 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4910 }
4911 else
4912 {
4913 printf (_(" [Nr] Name Type Address Offset\n"));
4914 printf (_(" Size EntSize Flags Link Info Align\n"));
4915 }
f7a99963 4916 }
252b5132 4917
5477e8a0
L		 4918 if (do_section_details)
4919 printf (_(" Flags\n"));
4920
252b5132
RH		 4921 for (i = 0, section = section_headers;
4922 i < elf_header.e_shnum;
b34976b6 4923 i++, section++)
252b5132 4924 {
7bfd842d 4925 printf (" [%2u] ", i);
5477e8a0 4926 if (do_section_details)
595cf52e 4927 {
7bfd842d 4928 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 4929 printf ("\n ");
595cf52e
L		 4930 }
4931 else
7bfd842d
NC		 4932 {
4933 print_symbol (-17, SECTION_NAME (section));
7bfd842d 4934 }
ea52a088
NC		 4935
4936 printf (do_wide ? " %-15s " : " %-15.15s ",
4937 get_section_type_name (section->sh_type));
4938
f7a99963
NC		 4939 if (is_32bit_elf)
4940 {
cfcac11d
NC		 4941 const char * link_too_big = NULL;
4942
f7a99963 4943 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4944
f7a99963
NC		 4945 printf ( " %6.6lx %6.6lx %2.2lx",
4946 (unsigned long) section->sh_offset,
4947 (unsigned long) section->sh_size,
4948 (unsigned long) section->sh_entsize);
d1133906 4949
5477e8a0
L		 4950 if (do_section_details)
4951 fputs (" ", stdout);
4952 else
4953 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4954
cfcac11d
NC		 4955 if (section->sh_link >= elf_header.e_shnum)
4956 {
4957 link_too_big = "";
4958 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4959 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4960 switch (elf_header.e_machine)
4961 {
caa83f8b
NC		 4962 case EM_386:
4963 case EM_486:
4964 case EM_X86_64:
7f502d6c 4965 case EM_L1OM:
7a9068fe 4966 case EM_K1OM:
cfcac11d
NC		 4967 case EM_OLD_SPARCV9:
4968 case EM_SPARC32PLUS:
4969 case EM_SPARCV9:
4970 case EM_SPARC:
4971 if (section->sh_link == (SHN_BEFORE & 0xffff))
4972 link_too_big = "BEFORE";
4973 else if (section->sh_link == (SHN_AFTER & 0xffff))
4974 link_too_big = "AFTER";
4975 break;
4976 default:
4977 break;
4978 }
4979 }
4980
4981 if (do_section_details)
4982 {
4983 if (link_too_big != NULL && * link_too_big)
4984 printf ("<%s> ", link_too_big);
4985 else
4986 printf ("%2u ", section->sh_link);
4987 printf ("%3u %2lu\n", section->sh_info,
4988 (unsigned long) section->sh_addralign);
4989 }
4990 else
4991 printf ("%2u %3u %2lu\n",
4992 section->sh_link,
4993 section->sh_info,
4994 (unsigned long) section->sh_addralign);
4995
4996 if (link_too_big && ! * link_too_big)
4997 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4998 i, section->sh_link);
f7a99963 4999 }
d974e256
JJ		 5000 else if (do_wide)
5001 {
5002 print_vma (section->sh_addr, LONG_HEX);
5003
5004 if ((long) section->sh_offset == section->sh_offset)
5005 printf (" %6.6lx", (unsigned long) section->sh_offset);
5006 else
5007 {
5008 putchar (' ');
5009 print_vma (section->sh_offset, LONG_HEX);
5010 }
5011
5012 if ((unsigned long) section->sh_size == section->sh_size)
5013 printf (" %6.6lx", (unsigned long) section->sh_size);
5014 else
5015 {
5016 putchar (' ');
5017 print_vma (section->sh_size, LONG_HEX);
5018 }
5019
5020 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5021 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5022 else
5023 {
5024 putchar (' ');
5025 print_vma (section->sh_entsize, LONG_HEX);
5026 }
5027
5477e8a0
L		 5028 if (do_section_details)
5029 fputs (" ", stdout);
5030 else
5031 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5032
72de5009 5033 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5034
5035 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5036 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5037 else
5038 {
5039 print_vma (section->sh_addralign, DEC);
5040 putchar ('\n');
5041 }
5042 }
5477e8a0 5043 else if (do_section_details)
595cf52e 5044 {
5477e8a0 5045 printf (" %-15.15s ",
595cf52e 5046 get_section_type_name (section->sh_type));
595cf52e
L		 5047 print_vma (section->sh_addr, LONG_HEX);
5048 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5049 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5050 else
5051 {
5052 printf (" ");
5053 print_vma (section->sh_offset, LONG_HEX);
5054 }
72de5009 5055 printf (" %u\n ", section->sh_link);
595cf52e 5056 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5057 putchar (' ');
595cf52e
L		 5058 print_vma (section->sh_entsize, LONG_HEX);
5059
72de5009
AM		 5060 printf (" %-16u %lu\n",
5061 section->sh_info,
595cf52e
L		 5062 (unsigned long) section->sh_addralign);
5063 }
f7a99963
NC		 5064 else
5065 {
5066 putchar (' ');
5067 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5068 if ((long) section->sh_offset == section->sh_offset)
5069 printf (" %8.8lx", (unsigned long) section->sh_offset);
5070 else
5071 {
5072 printf (" ");
5073 print_vma (section->sh_offset, LONG_HEX);
5074 }
f7a99963
NC		 5075 printf ("\n ");
5076 print_vma (section->sh_size, LONG_HEX);
5077 printf (" ");
5078 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5079
d1133906 5080 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5081
72de5009
AM		 5082 printf (" %2u %3u %lu\n",
5083 section->sh_link,
5084 section->sh_info,
f7a99963
NC		 5085 (unsigned long) section->sh_addralign);
5086 }
5477e8a0
L		 5087
5088 if (do_section_details)
5089 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5090 }
5091
5477e8a0 5092 if (!do_section_details)
3dbcc61d
NC		 5093 {
5094 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5095 || elf_header.e_machine == EM_L1OM
5096 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5097 printf (_("Key to Flags:\n\
5098 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5099 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5100 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5101 else
5102 printf (_("Key to Flags:\n\
e3c8793a 5103 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5104 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5105 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 5106 }
d1133906 5107
252b5132
RH		 5108 return 1;
5109}
5110
f5842774
L		 5111static const char *
5112get_group_flags (unsigned int flags)
5113{
5114 static char buff[32];
5115 switch (flags)
5116 {
220453ec
AM		 5117 case 0:
5118 return "";
5119
f5842774 5120 case GRP_COMDAT:
220453ec 5121 return "COMDAT ";
f5842774
L		 5122
5123 default:
220453ec 5124 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5125 break;
5126 }
5127 return buff;
5128}
5129
5130static int
2cf0635d 5131process_section_groups (FILE * file)
f5842774 5132{
2cf0635d 5133 Elf_Internal_Shdr * section;
f5842774 5134 unsigned int i;
2cf0635d
NC		 5135 struct group * group;
5136 Elf_Internal_Shdr * symtab_sec;
5137 Elf_Internal_Shdr * strtab_sec;
5138 Elf_Internal_Sym * symtab;
ba5cdace 5139 unsigned long num_syms;
2cf0635d 5140 char * strtab;
c256ffe7 5141 size_t strtab_size;
d1f5c6e3
L		 5142
5143 /* Don't process section groups unless needed. */
5144 if (!do_unwind && !do_section_groups)
5145 return 1;
f5842774
L		 5146
5147 if (elf_header.e_shnum == 0)
5148 {
5149 if (do_section_groups)
82f2dbf7 5150 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5151
5152 return 1;
5153 }
5154
5155 if (section_headers == NULL)
5156 {
5157 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5158 /* PR 13622: This can happen with a corrupt ELF header. */
5159 return 0;
f5842774
L		 5160 }
5161
3f5e193b
NC		 5162 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5163 sizeof (struct group *));
e4b17d5c
L		 5164
5165 if (section_headers_groups == NULL)
5166 {
5167 error (_("Out of memory\n"));
5168 return 0;
5169 }
5170
f5842774 5171 /* Scan the sections for the group section. */
d1f5c6e3 5172 group_count = 0;
f5842774
L		 5173 for (i = 0, section = section_headers;
5174 i < elf_header.e_shnum;
5175 i++, section++)
e4b17d5c
L		 5176 if (section->sh_type == SHT_GROUP)
5177 group_count++;
5178
d1f5c6e3
L		 5179 if (group_count == 0)
5180 {
5181 if (do_section_groups)
5182 printf (_("\nThere are no section groups in this file.\n"));
5183
5184 return 1;
5185 }
5186
3f5e193b 5187 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5188
5189 if (section_groups == NULL)
5190 {
5191 error (_("Out of memory\n"));
5192 return 0;
5193 }
5194
d1f5c6e3
L		 5195 symtab_sec = NULL;
5196 strtab_sec = NULL;
5197 symtab = NULL;
ba5cdace 5198 num_syms = 0;
d1f5c6e3 5199 strtab = NULL;
c256ffe7 5200 strtab_size = 0;
e4b17d5c
L		 5201 for (i = 0, section = section_headers, group = section_groups;
5202 i < elf_header.e_shnum;
5203 i++, section++)
f5842774
L		 5204 {
5205 if (section->sh_type == SHT_GROUP)
5206 {
2cf0635d
NC		 5207 char * name = SECTION_NAME (section);
5208 char * group_name;
5209 unsigned char * start;
5210 unsigned char * indices;
f5842774 5211 unsigned int entry, j, size;
2cf0635d
NC		 5212 Elf_Internal_Shdr * sec;
5213 Elf_Internal_Sym * sym;
f5842774
L		 5214
5215 /* Get the symbol table. */
4fbb74a6
AM		 5216 if (section->sh_link >= elf_header.e_shnum
5217 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5218 != SHT_SYMTAB))
f5842774
L		 5219 {
5220 error (_("Bad sh_link in group section `%s'\n"), name);
5221 continue;
5222 }
d1f5c6e3
L		 5223
5224 if (symtab_sec != sec)
5225 {
5226 symtab_sec = sec;
5227 if (symtab)
5228 free (symtab);
ba5cdace 5229 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5230 }
f5842774 5231
dd24e3da
NC		 5232 if (symtab == NULL)
5233 {
5234 error (_("Corrupt header in group section `%s'\n"), name);
5235 continue;
5236 }
5237
ba5cdace
NC		 5238 if (section->sh_info >= num_syms)
5239 {
5240 error (_("Bad sh_info in group section `%s'\n"), name);
5241 continue;
5242 }
5243
f5842774
L		 5244 sym = symtab + section->sh_info;
5245
5246 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5247 {
4fbb74a6
AM		 5248 if (sym->st_shndx == 0
5249 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5250 {
5251 error (_("Bad sh_info in group section `%s'\n"), name);
5252 continue;
5253 }
ba2685cc 5254
4fbb74a6 5255 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5256 strtab_sec = NULL;
5257 if (strtab)
5258 free (strtab);
f5842774 5259 strtab = NULL;
c256ffe7 5260 strtab_size = 0;
f5842774
L		 5261 }
5262 else
5263 {
5264 /* Get the string table. */
4fbb74a6 5265 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5266 {
5267 strtab_sec = NULL;
5268 if (strtab)
5269 free (strtab);
5270 strtab = NULL;
5271 strtab_size = 0;
5272 }
5273 else if (strtab_sec
4fbb74a6 5274 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5275 {
5276 strtab_sec = sec;
5277 if (strtab)
5278 free (strtab);
3f5e193b
NC		 5279 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5280 1, strtab_sec->sh_size,
5281 _("string table"));
c256ffe7 5282 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5283 }
c256ffe7 5284 group_name = sym->st_name < strtab_size
2b692964 5285 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5286 }
5287
3f5e193b
NC		 5288 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5289 1, section->sh_size,
5290 _("section data"));
59245841
NC		 5291 if (start == NULL)
5292 continue;
f5842774
L		 5293
5294 indices = start;
5295 size = (section->sh_size / section->sh_entsize) - 1;
5296 entry = byte_get (indices, 4);
5297 indices += 4;
e4b17d5c
L		 5298
5299 if (do_section_groups)
5300 {
2b692964 5301 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5302 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5303
e4b17d5c
L		 5304 printf (_(" [Index] Name\n"));
5305 }
5306
5307 group->group_index = i;
5308
f5842774
L		 5309 for (j = 0; j < size; j++)
5310 {
2cf0635d 5311 struct group_list * g;
e4b17d5c 5312
f5842774
L		 5313 entry = byte_get (indices, 4);
5314 indices += 4;
5315
4fbb74a6 5316 if (entry >= elf_header.e_shnum)
391cb864
L		 5317 {
5318 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5319 entry, i, elf_header.e_shnum - 1);
5320 continue;
5321 }
391cb864 5322
4fbb74a6 5323 if (section_headers_groups [entry] != NULL)
e4b17d5c 5324 {
d1f5c6e3
L		 5325 if (entry)
5326 {
391cb864
L		 5327 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5328 entry, i,
4fbb74a6 5329 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5330 continue;
5331 }
5332 else
5333 {
5334 /* Intel C/C++ compiler may put section 0 in a
5335 section group. We just warn it the first time
5336 and ignore it afterwards. */
5337 static int warned = 0;
5338 if (!warned)
5339 {
5340 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5341 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5342 warned++;
5343 }
5344 }
e4b17d5c
L		 5345 }
5346
4fbb74a6 5347 section_headers_groups [entry] = group;
e4b17d5c
L		 5348
5349 if (do_section_groups)
5350 {
4fbb74a6 5351 sec = section_headers + entry;
c256ffe7 5352 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5353 }
5354
3f5e193b 5355 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5356 g->section_index = entry;
5357 g->next = group->root;
5358 group->root = g;
f5842774
L		 5359 }
5360
f5842774
L		 5361 if (start)
5362 free (start);
e4b17d5c
L		 5363
5364 group++;
f5842774
L		 5365 }
5366 }
5367
d1f5c6e3
L		 5368 if (symtab)
5369 free (symtab);
5370 if (strtab)
5371 free (strtab);
f5842774
L		 5372 return 1;
5373}
5374
28f997cf
TG		 5375/* Data used to display dynamic fixups. */
5376
5377struct ia64_vms_dynfixup
5378{
5379 bfd_vma needed_ident; /* Library ident number. */
5380 bfd_vma needed; /* Index in the dstrtab of the library name. */
5381 bfd_vma fixup_needed; /* Index of the library. */
5382 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5383 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5384};
5385
5386/* Data used to display dynamic relocations. */
5387
5388struct ia64_vms_dynimgrela
5389{
5390 bfd_vma img_rela_cnt; /* Number of relocations. */
5391 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5392};
5393
5394/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5395 library). */
5396
5397static void
5398dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5399 const char *strtab, unsigned int strtab_sz)
5400{
5401 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5402 long i;
5403 const char *lib_name;
5404
5405 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5406 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5407 _("dynamic section image fixups"));
5408 if (!imfs)
5409 return;
5410
5411 if (fixup->needed < strtab_sz)
5412 lib_name = strtab + fixup->needed;
5413 else
5414 {
5415 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5416 (unsigned long) fixup->needed);
28f997cf
TG		 5417 lib_name = "???";
5418 }
5419 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5420 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5421 printf
5422 (_("Seg Offset Type SymVec DataType\n"));
5423
5424 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5425 {
5426 unsigned int type;
5427 const char *rtype;
5428
5429 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5430 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5431 type = BYTE_GET (imfs [i].type);
5432 rtype = elf_ia64_reloc_type (type);
5433 if (rtype == NULL)
5434 printf (" 0x%08x ", type);
5435 else
5436 printf (" %-32s ", rtype);
5437 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5438 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5439 }
5440
5441 free (imfs);
5442}
5443
5444/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5445
5446static void
5447dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5448{
5449 Elf64_External_VMS_IMAGE_RELA *imrs;
5450 long i;
5451
5452 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5453 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5454 _("dynamic section image relocations"));
28f997cf
TG		 5455 if (!imrs)
5456 return;
5457
5458 printf (_("\nImage relocs\n"));
5459 printf
5460 (_("Seg Offset Type Addend Seg Sym Off\n"));
5461
5462 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5463 {
5464 unsigned int type;
5465 const char *rtype;
5466
5467 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5468 printf ("%08" BFD_VMA_FMT "x ",
5469 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5470 type = BYTE_GET (imrs [i].type);
5471 rtype = elf_ia64_reloc_type (type);
5472 if (rtype == NULL)
5473 printf ("0x%08x ", type);
5474 else
5475 printf ("%-31s ", rtype);
5476 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5477 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5478 printf ("%08" BFD_VMA_FMT "x\n",
5479 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5480 }
5481
5482 free (imrs);
5483}
5484
5485/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5486
5487static int
5488process_ia64_vms_dynamic_relocs (FILE *file)
5489{
5490 struct ia64_vms_dynfixup fixup;
5491 struct ia64_vms_dynimgrela imgrela;
5492 Elf_Internal_Dyn *entry;
5493 int res = 0;
5494 bfd_vma strtab_off = 0;
5495 bfd_vma strtab_sz = 0;
5496 char *strtab = NULL;
5497
5498 memset (&fixup, 0, sizeof (fixup));
5499 memset (&imgrela, 0, sizeof (imgrela));
5500
5501 /* Note: the order of the entries is specified by the OpenVMS specs. */
5502 for (entry = dynamic_section;
5503 entry < dynamic_section + dynamic_nent;
5504 entry++)
5505 {
5506 switch (entry->d_tag)
5507 {
5508 case DT_IA_64_VMS_STRTAB_OFFSET:
5509 strtab_off = entry->d_un.d_val;
5510 break;
5511 case DT_STRSZ:
5512 strtab_sz = entry->d_un.d_val;
5513 if (strtab == NULL)
5514 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5515 1, strtab_sz, _("dynamic string section"));
5516 break;
5517
5518 case DT_IA_64_VMS_NEEDED_IDENT:
5519 fixup.needed_ident = entry->d_un.d_val;
5520 break;
5521 case DT_NEEDED:
5522 fixup.needed = entry->d_un.d_val;
5523 break;
5524 case DT_IA_64_VMS_FIXUP_NEEDED:
5525 fixup.fixup_needed = entry->d_un.d_val;
5526 break;
5527 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5528 fixup.fixup_rela_cnt = entry->d_un.d_val;
5529 break;
5530 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5531 fixup.fixup_rela_off = entry->d_un.d_val;
5532 res++;
5533 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5534 break;
5535
5536 case DT_IA_64_VMS_IMG_RELA_CNT:
5537 imgrela.img_rela_cnt = entry->d_un.d_val;
5538 break;
5539 case DT_IA_64_VMS_IMG_RELA_OFF:
5540 imgrela.img_rela_off = entry->d_un.d_val;
5541 res++;
5542 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5543 break;
5544
5545 default:
5546 break;
5547 }
5548 }
5549
5550 if (strtab != NULL)
5551 free (strtab);
5552
5553 return res;
5554}
5555
85b1c36d 5556static struct
566b0d53 5557{
2cf0635d 5558 const char * name;
566b0d53
L		 5559 int reloc;
5560 int size;
5561 int rela;
5562} dynamic_relocations [] =
5563{
5564 { "REL", DT_REL, DT_RELSZ, FALSE },
5565 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5566 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5567};
5568
252b5132 5569/* Process the reloc section. */
18bd398b 5570
252b5132 5571static int
2cf0635d 5572process_relocs (FILE * file)
252b5132 5573{
b34976b6
AM		 5574 unsigned long rel_size;
5575 unsigned long rel_offset;
252b5132
RH		 5576
5577
5578 if (!do_reloc)
5579 return 1;
5580
5581 if (do_using_dynamic)
5582 {
566b0d53 5583 int is_rela;
2cf0635d 5584 const char * name;
566b0d53
L		 5585 int has_dynamic_reloc;
5586 unsigned int i;
0de14b54 5587
566b0d53 5588 has_dynamic_reloc = 0;
252b5132 5589
566b0d53 5590 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5591 {
566b0d53
L		 5592 is_rela = dynamic_relocations [i].rela;
5593 name = dynamic_relocations [i].name;
5594 rel_size = dynamic_info [dynamic_relocations [i].size];
5595 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5596
566b0d53
L		 5597 has_dynamic_reloc |= rel_size;
5598
5599 if (is_rela == UNKNOWN)
aa903cfb 5600 {
566b0d53
L		 5601 if (dynamic_relocations [i].reloc == DT_JMPREL)
5602 switch (dynamic_info[DT_PLTREL])
5603 {
5604 case DT_REL:
5605 is_rela = FALSE;
5606 break;
5607 case DT_RELA:
5608 is_rela = TRUE;
5609 break;
5610 }
aa903cfb 5611 }
252b5132 5612
566b0d53
L		 5613 if (rel_size)
5614 {
5615 printf
5616 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5617 name, rel_offset, rel_size);
252b5132 5618
d93f0186
NC		 5619 dump_relocations (file,
5620 offset_from_vma (file, rel_offset, rel_size),
5621 rel_size,
566b0d53 5622 dynamic_symbols, num_dynamic_syms,
d79b3d50 5623 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5624 }
252b5132 5625 }
566b0d53 5626
28f997cf
TG		 5627 if (is_ia64_vms ())
5628 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5629
566b0d53 5630 if (! has_dynamic_reloc)
252b5132
RH		 5631 printf (_("\nThere are no dynamic relocations in this file.\n"));
5632 }
5633 else
5634 {
2cf0635d 5635 Elf_Internal_Shdr * section;
b34976b6
AM		 5636 unsigned long i;
5637 int found = 0;
252b5132
RH		 5638
5639 for (i = 0, section = section_headers;
5640 i < elf_header.e_shnum;
b34976b6 5641 i++, section++)
252b5132
RH		 5642 {
5643 if ( section->sh_type != SHT_RELA
5644 && section->sh_type != SHT_REL)
5645 continue;
5646
5647 rel_offset = section->sh_offset;
5648 rel_size = section->sh_size;
5649
5650 if (rel_size)
5651 {
2cf0635d 5652 Elf_Internal_Shdr * strsec;
b34976b6 5653 int is_rela;
103f02d3 5654
252b5132
RH		 5655 printf (_("\nRelocation section "));
5656
5657 if (string_table == NULL)
19936277 5658 printf ("%d", section->sh_name);
252b5132 5659 else
9cf03b7e 5660 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5661
5662 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5663 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5664
d79b3d50
NC		 5665 is_rela = section->sh_type == SHT_RELA;
5666
4fbb74a6
AM		 5667 if (section->sh_link != 0
5668 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5669 {
2cf0635d
NC		 5670 Elf_Internal_Shdr * symsec;
5671 Elf_Internal_Sym * symtab;
d79b3d50 5672 unsigned long nsyms;
c256ffe7 5673 unsigned long strtablen = 0;
2cf0635d 5674 char * strtab = NULL;
57346661 5675
4fbb74a6 5676 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5677 if (symsec->sh_type != SHT_SYMTAB
5678 && symsec->sh_type != SHT_DYNSYM)
5679 continue;
5680
ba5cdace 5681 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5682
af3fc3bc
AM		 5683 if (symtab == NULL)
5684 continue;
252b5132 5685
4fbb74a6
AM		 5686 if (symsec->sh_link != 0
5687 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5688 {
4fbb74a6 5689 strsec = section_headers + symsec->sh_link;
103f02d3 5690
3f5e193b
NC		 5691 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5692 1, strsec->sh_size,
5693 _("string table"));
c256ffe7
JJ		 5694 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5695 }
252b5132 5696
d79b3d50
NC		 5697 dump_relocations (file, rel_offset, rel_size,
5698 symtab, nsyms, strtab, strtablen, is_rela);
5699 if (strtab)
5700 free (strtab);
5701 free (symtab);
5702 }
5703 else
5704 dump_relocations (file, rel_offset, rel_size,
5705 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5706
5707 found = 1;
5708 }
5709 }
5710
5711 if (! found)
5712 printf (_("\nThere are no relocations in this file.\n"));
5713 }
5714
5715 return 1;
5716}
5717
57346661
AM		 5718/* Process the unwind section. */
5719
4d6ed7c8
NC		 5720#include "unwind-ia64.h"
5721
5722/* An absolute address consists of a section and an offset. If the
5723 section is NULL, the offset itself is the address, otherwise, the
5724 address equals to LOAD_ADDRESS(section) + offset. */
5725
5726struct absaddr
5727 {
5728 unsigned short section;
5729 bfd_vma offset;
5730 };
5731
1949de15
L		 5732#define ABSADDR(a) \
5733 ((a).section \
5734 ? section_headers [(a).section].sh_addr + (a).offset \
5735 : (a).offset)
5736
3f5e193b
NC		 5737struct ia64_unw_table_entry
5738 {
5739 struct absaddr start;
5740 struct absaddr end;
5741 struct absaddr info;
5742 };
5743
57346661 5744struct ia64_unw_aux_info
4d6ed7c8 5745 {
3f5e193b
NC		 5746
5747 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5748 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5749 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5750 unsigned long info_size; /* Size of unwind info. */
5751 bfd_vma info_addr; /* starting address of unwind info. */
5752 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5753 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5754 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5755 char * strtab; /* The string table. */
b34976b6 5756 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5757 };
5758
4d6ed7c8 5759static void
2cf0635d 5760find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5761 unsigned long nsyms,
2cf0635d 5762 const char * strtab,
57346661 5763 unsigned long strtab_size,
d3ba0551 5764 struct absaddr addr,
2cf0635d
NC		 5765 const char ** symname,
5766 bfd_vma * offset)
4d6ed7c8 5767{
d3ba0551 5768 bfd_vma dist = 0x100000;
2cf0635d
NC		 5769 Elf_Internal_Sym * sym;
5770 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5771 unsigned long i;
5772
0b6ae522
DJ		 5773 REMOVE_ARCH_BITS (addr.offset);
5774
57346661 5775 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5776 {
0b6ae522
DJ		 5777 bfd_vma value = sym->st_value;
5778
5779 REMOVE_ARCH_BITS (value);
5780
4d6ed7c8
NC		 5781 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5782 && sym->st_name != 0
5783 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5784 && addr.offset >= value
5785 && addr.offset - value < dist)
4d6ed7c8
NC		 5786 {
5787 best = sym;
0b6ae522 5788 dist = addr.offset - value;
4d6ed7c8
NC		 5789 if (!dist)
5790 break;
5791 }
5792 }
1b31d05e 5793
4d6ed7c8
NC		 5794 if (best)
5795 {
57346661 5796 *symname = (best->st_name >= strtab_size
2b692964 5797 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5798 *offset = dist;
5799 return;
5800 }
1b31d05e 5801
4d6ed7c8
NC		 5802 *symname = NULL;
5803 *offset = addr.offset;
5804}
5805
5806static void
2cf0635d 5807dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5808{
2cf0635d 5809 struct ia64_unw_table_entry * tp;
4d6ed7c8 5810 int in_body;
7036c0e1 5811
4d6ed7c8
NC		 5812 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5813 {
5814 bfd_vma stamp;
5815 bfd_vma offset;
2cf0635d
NC		 5816 const unsigned char * dp;
5817 const unsigned char * head;
5818 const char * procname;
4d6ed7c8 5819
57346661
AM		 5820 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5821 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5822
5823 fputs ("\n<", stdout);
5824
5825 if (procname)
5826 {
5827 fputs (procname, stdout);
5828
5829 if (offset)
5830 printf ("+%lx", (unsigned long) offset);
5831 }
5832
5833 fputs (">: [", stdout);
5834 print_vma (tp->start.offset, PREFIX_HEX);
5835 fputc ('-', stdout);
5836 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5837 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5838 (unsigned long) (tp->info.offset - aux->seg_base));
5839
1949de15 5840 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5841 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5842
86f55779 5843 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5844 (unsigned) UNW_VER (stamp),
5845 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5846 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5847 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5848 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5849
5850 if (UNW_VER (stamp) != 1)
5851 {
2b692964 5852 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5853 continue;
5854 }
5855
5856 in_body = 0;
89fac5e3 5857 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5858 dp = unw_decode (dp, in_body, & in_body);
5859 }
5860}
5861
5862static int
2cf0635d
NC		 5863slurp_ia64_unwind_table (FILE * file,
5864 struct ia64_unw_aux_info * aux,
5865 Elf_Internal_Shdr * sec)
4d6ed7c8 5866{
89fac5e3 5867 unsigned long size, nrelas, i;
2cf0635d
NC		 5868 Elf_Internal_Phdr * seg;
5869 struct ia64_unw_table_entry * tep;
5870 Elf_Internal_Shdr * relsec;
5871 Elf_Internal_Rela * rela;
5872 Elf_Internal_Rela * rp;
5873 unsigned char * table;
5874 unsigned char * tp;
5875 Elf_Internal_Sym * sym;
5876 const char * relname;
4d6ed7c8 5877
4d6ed7c8
NC		 5878 /* First, find the starting address of the segment that includes
5879 this section: */
5880
5881 if (elf_header.e_phnum)
5882 {
d93f0186 5883 if (! get_program_headers (file))
4d6ed7c8 5884 return 0;
4d6ed7c8 5885
d93f0186
NC		 5886 for (seg = program_headers;
5887 seg < program_headers + elf_header.e_phnum;
5888 ++seg)
4d6ed7c8
NC		 5889 {
5890 if (seg->p_type != PT_LOAD)
5891 continue;
5892
5893 if (sec->sh_addr >= seg->p_vaddr
5894 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5895 {
5896 aux->seg_base = seg->p_vaddr;
5897 break;
5898 }
5899 }
4d6ed7c8
NC		 5900 }
5901
5902 /* Second, build the unwind table from the contents of the unwind section: */
5903 size = sec->sh_size;
3f5e193b
NC		 5904 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5905 _("unwind table"));
a6e9f9df
AM		 5906 if (!table)
5907 return 0;
4d6ed7c8 5908
3f5e193b
NC		 5909 aux->table = (struct ia64_unw_table_entry *)
5910 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5911 tep = aux->table;
c6a0c689 5912 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5913 {
5914 tep->start.section = SHN_UNDEF;
5915 tep->end.section = SHN_UNDEF;
5916 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5917 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5918 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5919 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5920 tep->start.offset += aux->seg_base;
5921 tep->end.offset += aux->seg_base;
5922 tep->info.offset += aux->seg_base;
5923 }
5924 free (table);
5925
41e92641 5926 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5927 for (relsec = section_headers;
5928 relsec < section_headers + elf_header.e_shnum;
5929 ++relsec)
5930 {
5931 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5932 || relsec->sh_info >= elf_header.e_shnum
5933 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5934 continue;
5935
5936 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5937 & rela, & nrelas))
5938 return 0;
5939
5940 for (rp = rela; rp < rela + nrelas; ++rp)
5941 {
aca88567
NC		 5942 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5943 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5944
0112cd26 5945 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5946 {
e5fb9629 5947 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5948 continue;
5949 }
5950
89fac5e3 5951 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5952
89fac5e3 5953 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5954 {
5955 case 0:
5956 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5957 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5958 break;
5959 case 1:
5960 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5961 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5962 break;
5963 case 2:
5964 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5965 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5966 break;
5967 default:
5968 break;
5969 }
5970 }
5971
5972 free (rela);
5973 }
5974
89fac5e3 5975 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5976 return 1;
5977}
5978
1b31d05e 5979static void
2cf0635d 5980ia64_process_unwind (FILE * file)
4d6ed7c8 5981{
2cf0635d
NC		 5982 Elf_Internal_Shdr * sec;
5983 Elf_Internal_Shdr * unwsec = NULL;
5984 Elf_Internal_Shdr * strsec;
89fac5e3 5985 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5986 struct ia64_unw_aux_info aux;
f1467e33 5987
4d6ed7c8
NC		 5988 memset (& aux, 0, sizeof (aux));
5989
4d6ed7c8
NC		 5990 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5991 {
c256ffe7 5992 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5993 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 5994 {
ba5cdace 5995 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 5996
4fbb74a6 5997 strsec = section_headers + sec->sh_link;
59245841 5998 assert (aux.strtab == NULL);
3f5e193b
NC		 5999 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6000 1, strsec->sh_size,
6001 _("string table"));
c256ffe7 6002 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6003 }
6004 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6005 unwcount++;
6006 }
6007
6008 if (!unwcount)
6009 printf (_("\nThere are no unwind sections in this file.\n"));
6010
6011 while (unwcount-- > 0)
6012 {
2cf0635d 6013 char * suffix;
579f31ac
JJ		 6014 size_t len, len2;
6015
6016 for (i = unwstart, sec = section_headers + unwstart;
6017 i < elf_header.e_shnum; ++i, ++sec)
6018 if (sec->sh_type == SHT_IA_64_UNWIND)
6019 {
6020 unwsec = sec;
6021 break;
6022 }
6023
6024 unwstart = i + 1;
6025 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6026
e4b17d5c
L		 6027 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6028 {
6029 /* We need to find which section group it is in. */
2cf0635d 6030 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 6031
6032 for (; g != NULL; g = g->next)
6033 {
4fbb74a6 6034 sec = section_headers + g->section_index;
18bd398b
NC		 6035
6036 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6037 break;
e4b17d5c
L		 6038 }
6039
6040 if (g == NULL)
6041 i = elf_header.e_shnum;
6042 }
18bd398b 6043 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6044 {
18bd398b 6045 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6046 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6047 suffix = SECTION_NAME (unwsec) + len;
6048 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6049 ++i, ++sec)
18bd398b
NC		 6050 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6051 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6052 break;
6053 }
6054 else
6055 {
6056 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6057 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6058 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6059 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6060 suffix = "";
18bd398b 6061 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6062 suffix = SECTION_NAME (unwsec) + len;
6063 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6064 ++i, ++sec)
18bd398b
NC		 6065 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6066 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6067 break;
6068 }
6069
6070 if (i == elf_header.e_shnum)
6071 {
6072 printf (_("\nCould not find unwind info section for "));
6073
6074 if (string_table == NULL)
6075 printf ("%d", unwsec->sh_name);
6076 else
3a1a2036 6077 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 6078 }
6079 else
4d6ed7c8 6080 {
4d6ed7c8 6081 aux.info_addr = sec->sh_addr;
3f5e193b 6082 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6083 sec->sh_size,
3f5e193b 6084 _("unwind info"));
59245841 6085 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6086
579f31ac 6087 printf (_("\nUnwind section "));
4d6ed7c8 6088
579f31ac
JJ		 6089 if (string_table == NULL)
6090 printf ("%d", unwsec->sh_name);
6091 else
3a1a2036 6092 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6093
579f31ac 6094 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6095 (unsigned long) unwsec->sh_offset,
89fac5e3 6096 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6097
579f31ac 6098 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6099
579f31ac
JJ		 6100 if (aux.table_len > 0)
6101 dump_ia64_unwind (& aux);
6102
6103 if (aux.table)
6104 free ((char *) aux.table);
6105 if (aux.info)
6106 free ((char *) aux.info);
6107 aux.table = NULL;
6108 aux.info = NULL;
6109 }
4d6ed7c8 6110 }
4d6ed7c8 6111
4d6ed7c8
NC		 6112 if (aux.symtab)
6113 free (aux.symtab);
6114 if (aux.strtab)
6115 free ((char *) aux.strtab);
4d6ed7c8
NC		 6116}
6117
3f5e193b
NC		 6118struct hppa_unw_table_entry
6119 {
6120 struct absaddr start;
6121 struct absaddr end;
6122 unsigned int Cannot_unwind:1; /* 0 */
6123 unsigned int Millicode:1; /* 1 */
6124 unsigned int Millicode_save_sr0:1; /* 2 */
6125 unsigned int Region_description:2; /* 3..4 */
6126 unsigned int reserved1:1; /* 5 */
6127 unsigned int Entry_SR:1; /* 6 */
6128 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6129 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6130 unsigned int Args_stored:1; /* 16 */
6131 unsigned int Variable_Frame:1; /* 17 */
6132 unsigned int Separate_Package_Body:1; /* 18 */
6133 unsigned int Frame_Extension_Millicode:1; /* 19 */
6134 unsigned int Stack_Overflow_Check:1; /* 20 */
6135 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6136 unsigned int Ada_Region:1; /* 22 */
6137 unsigned int cxx_info:1; /* 23 */
6138 unsigned int cxx_try_catch:1; /* 24 */
6139 unsigned int sched_entry_seq:1; /* 25 */
6140 unsigned int reserved2:1; /* 26 */
6141 unsigned int Save_SP:1; /* 27 */
6142 unsigned int Save_RP:1; /* 28 */
6143 unsigned int Save_MRP_in_frame:1; /* 29 */
6144 unsigned int extn_ptr_defined:1; /* 30 */
6145 unsigned int Cleanup_defined:1; /* 31 */
6146
6147 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6148 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6149 unsigned int Large_frame:1; /* 2 */
6150 unsigned int Pseudo_SP_Set:1; /* 3 */
6151 unsigned int reserved4:1; /* 4 */
6152 unsigned int Total_frame_size:27; /* 5..31 */
6153 };
6154
57346661
AM		 6155struct hppa_unw_aux_info
6156 {
3f5e193b 6157 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6158 unsigned long table_len; /* Length of unwind table. */
6159 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6160 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6161 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6162 char * strtab; /* The string table. */
57346661
AM		 6163 unsigned long strtab_size; /* Size of string table. */
6164 };
6165
6166static void
2cf0635d 6167dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6168{
2cf0635d 6169 struct hppa_unw_table_entry * tp;
57346661 6170
57346661
AM		 6171 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6172 {
6173 bfd_vma offset;
2cf0635d 6174 const char * procname;
57346661
AM		 6175
6176 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6177 aux->strtab_size, tp->start, &procname,
6178 &offset);
6179
6180 fputs ("\n<", stdout);
6181
6182 if (procname)
6183 {
6184 fputs (procname, stdout);
6185
6186 if (offset)
6187 printf ("+%lx", (unsigned long) offset);
6188 }
6189
6190 fputs (">: [", stdout);
6191 print_vma (tp->start.offset, PREFIX_HEX);
6192 fputc ('-', stdout);
6193 print_vma (tp->end.offset, PREFIX_HEX);
6194 printf ("]\n\t");
6195
18bd398b
NC		 6196#define PF(_m) if (tp->_m) printf (#_m " ");
6197#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6198 PF(Cannot_unwind);
6199 PF(Millicode);
6200 PF(Millicode_save_sr0);
18bd398b 6201 /* PV(Region_description); */
57346661
AM		 6202 PF(Entry_SR);
6203 PV(Entry_FR);
6204 PV(Entry_GR);
6205 PF(Args_stored);
6206 PF(Variable_Frame);
6207 PF(Separate_Package_Body);
6208 PF(Frame_Extension_Millicode);
6209 PF(Stack_Overflow_Check);
6210 PF(Two_Instruction_SP_Increment);
6211 PF(Ada_Region);
6212 PF(cxx_info);
6213 PF(cxx_try_catch);
6214 PF(sched_entry_seq);
6215 PF(Save_SP);
6216 PF(Save_RP);
6217 PF(Save_MRP_in_frame);
6218 PF(extn_ptr_defined);
6219 PF(Cleanup_defined);
6220 PF(MPE_XL_interrupt_marker);
6221 PF(HP_UX_interrupt_marker);
6222 PF(Large_frame);
6223 PF(Pseudo_SP_Set);
6224 PV(Total_frame_size);
6225#undef PF
6226#undef PV
6227 }
6228
18bd398b 6229 printf ("\n");
57346661
AM		 6230}
6231
6232static int
2cf0635d
NC		 6233slurp_hppa_unwind_table (FILE * file,
6234 struct hppa_unw_aux_info * aux,
6235 Elf_Internal_Shdr * sec)
57346661 6236{
1c0751b2 6237 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6238 Elf_Internal_Phdr * seg;
6239 struct hppa_unw_table_entry * tep;
6240 Elf_Internal_Shdr * relsec;
6241 Elf_Internal_Rela * rela;
6242 Elf_Internal_Rela * rp;
6243 unsigned char * table;
6244 unsigned char * tp;
6245 Elf_Internal_Sym * sym;
6246 const char * relname;
57346661 6247
57346661
AM		 6248 /* First, find the starting address of the segment that includes
6249 this section. */
6250
6251 if (elf_header.e_phnum)
6252 {
6253 if (! get_program_headers (file))
6254 return 0;
6255
6256 for (seg = program_headers;
6257 seg < program_headers + elf_header.e_phnum;
6258 ++seg)
6259 {
6260 if (seg->p_type != PT_LOAD)
6261 continue;
6262
6263 if (sec->sh_addr >= seg->p_vaddr
6264 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6265 {
6266 aux->seg_base = seg->p_vaddr;
6267 break;
6268 }
6269 }
6270 }
6271
6272 /* Second, build the unwind table from the contents of the unwind
6273 section. */
6274 size = sec->sh_size;
3f5e193b
NC		 6275 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6276 _("unwind table"));
57346661
AM		 6277 if (!table)
6278 return 0;
6279
1c0751b2
DA		 6280 unw_ent_size = 16;
6281 nentries = size / unw_ent_size;
6282 size = unw_ent_size * nentries;
57346661 6283
3f5e193b
NC		 6284 tep = aux->table = (struct hppa_unw_table_entry *)
6285 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6286
1c0751b2 6287 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6288 {
6289 unsigned int tmp1, tmp2;
6290
6291 tep->start.section = SHN_UNDEF;
6292 tep->end.section = SHN_UNDEF;
6293
1c0751b2
DA		 6294 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6295 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6296 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6297 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6298
6299 tep->start.offset += aux->seg_base;
6300 tep->end.offset += aux->seg_base;
57346661
AM		 6301
6302 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6303 tep->Millicode = (tmp1 >> 30) & 0x1;
6304 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6305 tep->Region_description = (tmp1 >> 27) & 0x3;
6306 tep->reserved1 = (tmp1 >> 26) & 0x1;
6307 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6308 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6309 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6310 tep->Args_stored = (tmp1 >> 15) & 0x1;
6311 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6312 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6313 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6314 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6315 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6316 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6317 tep->cxx_info = (tmp1 >> 8) & 0x1;
6318 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6319 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6320 tep->reserved2 = (tmp1 >> 5) & 0x1;
6321 tep->Save_SP = (tmp1 >> 4) & 0x1;
6322 tep->Save_RP = (tmp1 >> 3) & 0x1;
6323 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6324 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6325 tep->Cleanup_defined = tmp1 & 0x1;
6326
6327 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6328 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6329 tep->Large_frame = (tmp2 >> 29) & 0x1;
6330 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6331 tep->reserved4 = (tmp2 >> 27) & 0x1;
6332 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6333 }
6334 free (table);
6335
6336 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6337 for (relsec = section_headers;
6338 relsec < section_headers + elf_header.e_shnum;
6339 ++relsec)
6340 {
6341 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6342 || relsec->sh_info >= elf_header.e_shnum
6343 || section_headers + relsec->sh_info != sec)
57346661
AM		 6344 continue;
6345
6346 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6347 & rela, & nrelas))
6348 return 0;
6349
6350 for (rp = rela; rp < rela + nrelas; ++rp)
6351 {
aca88567
NC		 6352 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6353 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6354
6355 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6356 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6357 {
6358 warn (_("Skipping unexpected relocation type %s\n"), relname);
6359 continue;
6360 }
6361
6362 i = rp->r_offset / unw_ent_size;
6363
89fac5e3 6364 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6365 {
6366 case 0:
6367 aux->table[i].start.section = sym->st_shndx;
1e456d54 6368 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6369 break;
6370 case 1:
6371 aux->table[i].end.section = sym->st_shndx;
1e456d54 6372 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6373 break;
6374 default:
6375 break;
6376 }
6377 }
6378
6379 free (rela);
6380 }
6381
1c0751b2 6382 aux->table_len = nentries;
57346661
AM		 6383
6384 return 1;
6385}
6386
1b31d05e 6387static void
2cf0635d 6388hppa_process_unwind (FILE * file)
57346661 6389{
57346661 6390 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6391 Elf_Internal_Shdr * unwsec = NULL;
6392 Elf_Internal_Shdr * strsec;
6393 Elf_Internal_Shdr * sec;
18bd398b 6394 unsigned long i;
57346661 6395
c256ffe7 6396 if (string_table == NULL)
1b31d05e
NC		 6397 return;
6398
6399 memset (& aux, 0, sizeof (aux));
57346661
AM		 6400
6401 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6402 {
c256ffe7 6403 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6404 && sec->sh_link < elf_header.e_shnum)
57346661 6405 {
ba5cdace 6406 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6407
4fbb74a6 6408 strsec = section_headers + sec->sh_link;
59245841 6409 assert (aux.strtab == NULL);
3f5e193b
NC		 6410 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6411 1, strsec->sh_size,
6412 _("string table"));
c256ffe7 6413 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6414 }
18bd398b 6415 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6416 unwsec = sec;
6417 }
6418
6419 if (!unwsec)
6420 printf (_("\nThere are no unwind sections in this file.\n"));
6421
6422 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6423 {
18bd398b 6424 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6425 {
57346661
AM		 6426 printf (_("\nUnwind section "));
6427 printf (_("'%s'"), SECTION_NAME (sec));
6428
6429 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6430 (unsigned long) sec->sh_offset,
89fac5e3 6431 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6432
6433 slurp_hppa_unwind_table (file, &aux, sec);
6434 if (aux.table_len > 0)
6435 dump_hppa_unwind (&aux);
6436
6437 if (aux.table)
6438 free ((char *) aux.table);
6439 aux.table = NULL;
6440 }
6441 }
6442
6443 if (aux.symtab)
6444 free (aux.symtab);
6445 if (aux.strtab)
6446 free ((char *) aux.strtab);
57346661
AM		 6447}
6448
0b6ae522
DJ		 6449struct arm_section
6450{
a734115a
NC		 6451 unsigned char * data; /* The unwind data. */
6452 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6453 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6454 unsigned long nrelas; /* The number of relocations. */
6455 unsigned int rel_type; /* REL or RELA ? */
6456 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6457};
6458
6459struct arm_unw_aux_info
6460{
a734115a
NC		 6461 FILE * file; /* The file containing the unwind sections. */
6462 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6463 unsigned long nsyms; /* Number of symbols. */
6464 char * strtab; /* The file's string table. */
6465 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6466};
6467
6468static const char *
6469arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6470 bfd_vma fn, struct absaddr addr)
6471{
6472 const char *procname;
6473 bfd_vma sym_offset;
6474
6475 if (addr.section == SHN_UNDEF)
6476 addr.offset = fn;
6477
6478 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6479 aux->strtab_size, addr, &procname,
6480 &sym_offset);
6481
6482 print_vma (fn, PREFIX_HEX);
6483
6484 if (procname)
6485 {
6486 fputs (" <", stdout);
6487 fputs (procname, stdout);
6488
6489 if (sym_offset)
6490 printf ("+0x%lx", (unsigned long) sym_offset);
6491 fputc ('>', stdout);
6492 }
6493
6494 return procname;
6495}
6496
6497static void
6498arm_free_section (struct arm_section *arm_sec)
6499{
6500 if (arm_sec->data != NULL)
6501 free (arm_sec->data);
6502
6503 if (arm_sec->rela != NULL)
6504 free (arm_sec->rela);
6505}
6506
a734115a
NC		 6507/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6508 cached section and install SEC instead.
6509 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6510 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6511 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6512 relocation's offset in ADDR.
1b31d05e
NC		 6513 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6514 into the string table of the symbol associated with the reloc. If no
6515 reloc was applied store -1 there.
6516 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6517
6518static bfd_boolean
1b31d05e
NC		 6519get_unwind_section_word (struct arm_unw_aux_info * aux,
6520 struct arm_section * arm_sec,
6521 Elf_Internal_Shdr * sec,
6522 bfd_vma word_offset,
6523 unsigned int * wordp,
6524 struct absaddr * addr,
6525 bfd_vma * sym_name)
0b6ae522
DJ		 6526{
6527 Elf_Internal_Rela *rp;
6528 Elf_Internal_Sym *sym;
6529 const char * relname;
6530 unsigned int word;
6531 bfd_boolean wrapped;
6532
6533 addr->section = SHN_UNDEF;
6534 addr->offset = 0;
6535
1b31d05e
NC		 6536 if (sym_name != NULL)
6537 *sym_name = (bfd_vma) -1;
6538
a734115a 6539 /* If necessary, update the section cache. */
0b6ae522
DJ		 6540 if (sec != arm_sec->sec)
6541 {
6542 Elf_Internal_Shdr *relsec;
6543
6544 arm_free_section (arm_sec);
6545
6546 arm_sec->sec = sec;
6547 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6548 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6549 arm_sec->rela = NULL;
6550 arm_sec->nrelas = 0;
6551
6552 for (relsec = section_headers;
6553 relsec < section_headers + elf_header.e_shnum;
6554 ++relsec)
6555 {
6556 if (relsec->sh_info >= elf_header.e_shnum
6557 || section_headers + relsec->sh_info != sec)
6558 continue;
6559
a734115a 6560 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6561 if (relsec->sh_type == SHT_REL)
6562 {
6563 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6564 relsec->sh_size,
6565 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6566 return FALSE;
0b6ae522
DJ		 6567 break;
6568 }
6569 else if (relsec->sh_type == SHT_RELA)
6570 {
6571 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6572 relsec->sh_size,
6573 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6574 return FALSE;
0b6ae522
DJ		 6575 break;
6576 }
a734115a
NC		 6577 else
6578 warn (_("unexpected relocation type (%d) for section %d"),
6579 relsec->sh_type, relsec->sh_info);
0b6ae522
DJ		 6580 }
6581
6582 arm_sec->next_rela = arm_sec->rela;
6583 }
6584
a734115a 6585 /* If there is no unwind data we can do nothing. */
0b6ae522 6586 if (arm_sec->data == NULL)
a734115a 6587 return FALSE;
0b6ae522 6588
a734115a 6589 /* Get the word at the required offset. */
0b6ae522
DJ		 6590 word = byte_get (arm_sec->data + word_offset, 4);
6591
a734115a 6592 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6593 wrapped = FALSE;
6594 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6595 {
6596 bfd_vma prelval, offset;
6597
6598 if (rp->r_offset > word_offset && !wrapped)
6599 {
6600 rp = arm_sec->rela;
6601 wrapped = TRUE;
6602 }
6603 if (rp->r_offset > word_offset)
6604 break;
6605
6606 if (rp->r_offset & 3)
6607 {
6608 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6609 (unsigned long) rp->r_offset);
6610 continue;
6611 }
6612
6613 if (rp->r_offset < word_offset)
6614 continue;
6615
0b6ae522
DJ		 6616 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6617
6618 if (arm_sec->rel_type == SHT_REL)
6619 {
6620 offset = word & 0x7fffffff;
6621 if (offset & 0x40000000)
6622 offset |= ~ (bfd_vma) 0x7fffffff;
6623 }
a734115a 6624 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6625 offset = rp->r_addend;
a734115a
NC		 6626 else
6627 abort ();
0b6ae522
DJ		 6628
6629 offset += sym->st_value;
6630 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6631
a734115a
NC		 6632 /* Check that we are processing the expected reloc type. */
6633 if (elf_header.e_machine == EM_ARM)
6634 {
6635 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6636
6637 if (streq (relname, "R_ARM_NONE"))
6638 continue;
6639
6640 if (! streq (relname, "R_ARM_PREL31"))
6641 {
6642 warn (_("Skipping unexpected relocation type %s\n"), relname);
6643 continue;
6644 }
6645 }
6646 else if (elf_header.e_machine == EM_TI_C6000)
6647 {
6648 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6649
6650 if (streq (relname, "R_C6000_NONE"))
6651 continue;
6652
6653 if (! streq (relname, "R_C6000_PREL31"))
6654 {
6655 warn (_("Skipping unexpected relocation type %s\n"), relname);
6656 continue;
6657 }
6658
6659 prelval >>= 1;
6660 }
6661 else
6662 /* This function currently only supports ARM and TI unwinders. */
6663 abort ();
fa197c1c 6664
0b6ae522
DJ		 6665 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6666 addr->section = sym->st_shndx;
6667 addr->offset = offset;
1b31d05e
NC		 6668 if (sym_name)
6669 * sym_name = sym->st_name;
0b6ae522
DJ		 6670 break;
6671 }
6672
6673 *wordp = word;
6674 arm_sec->next_rela = rp;
6675
a734115a 6676 return TRUE;
0b6ae522
DJ		 6677}
6678
a734115a
NC		 6679static const char *tic6x_unwind_regnames[16] =
6680{
6681 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6682 "A14", "A13", "A12", "A11", "A10",
6683 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6684};
fa197c1c 6685
0b6ae522 6686static void
fa197c1c 6687decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6688{
fa197c1c
PB		 6689 int i;
6690
6691 for (i = 12; mask; mask >>= 1, i--)
6692 {
6693 if (mask & 1)
6694 {
6695 fputs (tic6x_unwind_regnames[i], stdout);
6696 if (mask > 1)
6697 fputs (", ", stdout);
6698 }
6699 }
6700}
0b6ae522
DJ		 6701
6702#define ADVANCE \
6703 if (remaining == 0 && more_words) \
6704 { \
6705 data_offset += 4; \
1b31d05e
NC		 6706 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6707 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 6708 return; \
6709 remaining = 4; \
6710 more_words--; \
6711 } \
6712
6713#define GET_OP(OP) \
6714 ADVANCE; \
6715 if (remaining) \
6716 { \
6717 remaining--; \
6718 (OP) = word >> 24; \
6719 word <<= 8; \
6720 } \
6721 else \
6722 { \
2b692964 6723 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6724 return; \
6725 } \
cc5914eb 6726 printf ("0x%02x ", OP)
0b6ae522 6727
fa197c1c
PB		 6728static void
6729decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6730 unsigned int word, unsigned int remaining,
6731 unsigned int more_words,
6732 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6733 struct arm_section *data_arm_sec)
6734{
6735 struct absaddr addr;
0b6ae522
DJ		 6736
6737 /* Decode the unwinding instructions. */
6738 while (1)
6739 {
6740 unsigned int op, op2;
6741
6742 ADVANCE;
6743 if (remaining == 0)
6744 break;
6745 remaining--;
6746 op = word >> 24;
6747 word <<= 8;
6748
cc5914eb 6749 printf (" 0x%02x ", op);
0b6ae522
DJ		 6750
6751 if ((op & 0xc0) == 0x00)
6752 {
6753 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6754
cc5914eb 6755 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6756 }
6757 else if ((op & 0xc0) == 0x40)
6758 {
6759 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6760
cc5914eb 6761 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6762 }
6763 else if ((op & 0xf0) == 0x80)
6764 {
6765 GET_OP (op2);
6766 if (op == 0x80 && op2 == 0)
6767 printf (_("Refuse to unwind"));
6768 else
6769 {
6770 unsigned int mask = ((op & 0x0f) << 8) | op2;
6771 int first = 1;
6772 int i;
2b692964 6773
0b6ae522
DJ		 6774 printf ("pop {");
6775 for (i = 0; i < 12; i++)
6776 if (mask & (1 << i))
6777 {
6778 if (first)
6779 first = 0;
6780 else
6781 printf (", ");
6782 printf ("r%d", 4 + i);
6783 }
6784 printf ("}");
6785 }
6786 }
6787 else if ((op & 0xf0) == 0x90)
6788 {
6789 if (op == 0x9d || op == 0x9f)
6790 printf (_(" [Reserved]"));
6791 else
cc5914eb 6792 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6793 }
6794 else if ((op & 0xf0) == 0xa0)
6795 {
6796 int end = 4 + (op & 0x07);
6797 int first = 1;
6798 int i;
61865e30 6799
0b6ae522
DJ		 6800 printf (" pop {");
6801 for (i = 4; i <= end; i++)
6802 {
6803 if (first)
6804 first = 0;
6805 else
6806 printf (", ");
6807 printf ("r%d", i);
6808 }
6809 if (op & 0x08)
6810 {
1b31d05e 6811 if (!first)
0b6ae522
DJ		 6812 printf (", ");
6813 printf ("r14");
6814 }
6815 printf ("}");
6816 }
6817 else if (op == 0xb0)
6818 printf (_(" finish"));
6819 else if (op == 0xb1)
6820 {
6821 GET_OP (op2);
6822 if (op2 == 0 || (op2 & 0xf0) != 0)
6823 printf (_("[Spare]"));
6824 else
6825 {
6826 unsigned int mask = op2 & 0x0f;
6827 int first = 1;
6828 int i;
61865e30 6829
0b6ae522
DJ		 6830 printf ("pop {");
6831 for (i = 0; i < 12; i++)
6832 if (mask & (1 << i))
6833 {
6834 if (first)
6835 first = 0;
6836 else
6837 printf (", ");
6838 printf ("r%d", i);
6839 }
6840 printf ("}");
6841 }
6842 }
6843 else if (op == 0xb2)
6844 {
b115cf96 6845 unsigned char buf[9];
0b6ae522
DJ		 6846 unsigned int i, len;
6847 unsigned long offset;
61865e30 6848
b115cf96 6849 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6850 {
6851 GET_OP (buf[i]);
6852 if ((buf[i] & 0x80) == 0)
6853 break;
6854 }
6855 assert (i < sizeof (buf));
6856 offset = read_uleb128 (buf, &len);
6857 assert (len == i + 1);
6858 offset = offset * 4 + 0x204;
cc5914eb 6859 printf ("vsp = vsp + %ld", offset);
0b6ae522 6860 }
61865e30 6861 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6862 {
61865e30
NC		 6863 unsigned int first, last;
6864
6865 GET_OP (op2);
6866 first = op2 >> 4;
6867 last = op2 & 0x0f;
6868 if (op == 0xc8)
6869 first = first + 16;
6870 printf ("pop {D%d", first);
6871 if (last)
6872 printf ("-D%d", first + last);
6873 printf ("}");
6874 }
6875 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6876 {
6877 unsigned int count = op & 0x07;
6878
6879 printf ("pop {D8");
6880 if (count)
6881 printf ("-D%d", 8 + count);
6882 printf ("}");
6883 }
6884 else if (op >= 0xc0 && op <= 0xc5)
6885 {
6886 unsigned int count = op & 0x07;
6887
6888 printf (" pop {wR10");
6889 if (count)
6890 printf ("-wR%d", 10 + count);
6891 printf ("}");
6892 }
6893 else if (op == 0xc6)
6894 {
6895 unsigned int first, last;
6896
6897 GET_OP (op2);
6898 first = op2 >> 4;
6899 last = op2 & 0x0f;
6900 printf ("pop {wR%d", first);
6901 if (last)
6902 printf ("-wR%d", first + last);
6903 printf ("}");
6904 }
6905 else if (op == 0xc7)
6906 {
6907 GET_OP (op2);
6908 if (op2 == 0 || (op2 & 0xf0) != 0)
6909 printf (_("[Spare]"));
0b6ae522
DJ		 6910 else
6911 {
61865e30
NC		 6912 unsigned int mask = op2 & 0x0f;
6913 int first = 1;
6914 int i;
6915
6916 printf ("pop {");
6917 for (i = 0; i < 4; i++)
6918 if (mask & (1 << i))
6919 {
6920 if (first)
6921 first = 0;
6922 else
6923 printf (", ");
6924 printf ("wCGR%d", i);
6925 }
6926 printf ("}");
0b6ae522
DJ		 6927 }
6928 }
61865e30
NC		 6929 else
6930 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6931 printf ("\n");
6932 }
fa197c1c
PB		 6933}
6934
6935static void
6936decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6937 unsigned int word, unsigned int remaining,
6938 unsigned int more_words,
6939 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6940 struct arm_section *data_arm_sec)
6941{
6942 struct absaddr addr;
6943
6944 /* Decode the unwinding instructions. */
6945 while (1)
6946 {
6947 unsigned int op, op2;
6948
6949 ADVANCE;
6950 if (remaining == 0)
6951 break;
6952 remaining--;
6953 op = word >> 24;
6954 word <<= 8;
6955
9cf03b7e 6956 printf (" 0x%02x ", op);
fa197c1c
PB		 6957
6958 if ((op & 0xc0) == 0x00)
6959 {
6960 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 6961 printf (" sp = sp + %d", offset);
fa197c1c
PB		 6962 }
6963 else if ((op & 0xc0) == 0x80)
6964 {
6965 GET_OP (op2);
6966 if (op == 0x80 && op2 == 0)
6967 printf (_("Refuse to unwind"));
6968 else
6969 {
6970 unsigned int mask = ((op & 0x1f) << 8) | op2;
6971 if (op & 0x20)
6972 printf ("pop compact {");
6973 else
6974 printf ("pop {");
6975
6976 decode_tic6x_unwind_regmask (mask);
6977 printf("}");
6978 }
6979 }
6980 else if ((op & 0xf0) == 0xc0)
6981 {
6982 unsigned int reg;
6983 unsigned int nregs;
6984 unsigned int i;
6985 const char *name;
a734115a
NC		 6986 struct
6987 {
fa197c1c
PB		 6988 unsigned int offset;
6989 unsigned int reg;
6990 } regpos[16];
6991
6992 /* Scan entire instruction first so that GET_OP output is not
6993 interleaved with disassembly. */
6994 nregs = 0;
6995 for (i = 0; nregs < (op & 0xf); i++)
6996 {
6997 GET_OP (op2);
6998 reg = op2 >> 4;
6999 if (reg != 0xf)
7000 {
7001 regpos[nregs].offset = i * 2;
7002 regpos[nregs].reg = reg;
7003 nregs++;
7004 }
7005
7006 reg = op2 & 0xf;
7007 if (reg != 0xf)
7008 {
7009 regpos[nregs].offset = i * 2 + 1;
7010 regpos[nregs].reg = reg;
7011 nregs++;
7012 }
7013 }
7014
7015 printf (_("pop frame {"));
7016 reg = nregs - 1;
7017 for (i = i * 2; i > 0; i--)
7018 {
7019 if (regpos[reg].offset == i - 1)
7020 {
7021 name = tic6x_unwind_regnames[regpos[reg].reg];
7022 if (reg > 0)
7023 reg--;
7024 }
7025 else
7026 name = _("[pad]");
7027
7028 fputs (name, stdout);
7029 if (i > 1)
7030 printf (", ");
7031 }
7032
7033 printf ("}");
7034 }
7035 else if (op == 0xd0)
7036 printf (" MOV FP, SP");
7037 else if (op == 0xd1)
7038 printf (" __c6xabi_pop_rts");
7039 else if (op == 0xd2)
7040 {
7041 unsigned char buf[9];
7042 unsigned int i, len;
7043 unsigned long offset;
a734115a 7044
fa197c1c
PB		 7045 for (i = 0; i < sizeof (buf); i++)
7046 {
7047 GET_OP (buf[i]);
7048 if ((buf[i] & 0x80) == 0)
7049 break;
7050 }
7051 assert (i < sizeof (buf));
7052 offset = read_uleb128 (buf, &len);
7053 assert (len == i + 1);
7054 offset = offset * 8 + 0x408;
7055 printf (_("sp = sp + %ld"), offset);
7056 }
7057 else if ((op & 0xf0) == 0xe0)
7058 {
7059 if ((op & 0x0f) == 7)
7060 printf (" RETURN");
7061 else
7062 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7063 }
7064 else
7065 {
7066 printf (_(" [unsupported opcode]"));
7067 }
7068 putchar ('\n');
7069 }
7070}
7071
7072static bfd_vma
a734115a 7073arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7074{
7075 bfd_vma offset;
7076
7077 offset = word & 0x7fffffff;
7078 if (offset & 0x40000000)
7079 offset |= ~ (bfd_vma) 0x7fffffff;
7080
7081 if (elf_header.e_machine == EM_TI_C6000)
7082 offset <<= 1;
7083
7084 return offset + where;
7085}
7086
7087static void
1b31d05e
NC		 7088decode_arm_unwind (struct arm_unw_aux_info * aux,
7089 unsigned int word,
7090 unsigned int remaining,
7091 bfd_vma data_offset,
7092 Elf_Internal_Shdr * data_sec,
7093 struct arm_section * data_arm_sec)
fa197c1c
PB		 7094{
7095 int per_index;
7096 unsigned int more_words = 0;
7097 struct absaddr addr;
1b31d05e 7098 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7099
7100 if (remaining == 0)
7101 {
1b31d05e
NC		 7102 /* Fetch the first word.
7103 Note - when decoding an object file the address extracted
7104 here will always be 0. So we also pass in the sym_name
7105 parameter so that we can find the symbol associated with
7106 the personality routine. */
7107 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7108 & word, & addr, & sym_name))
fa197c1c 7109 return;
1b31d05e 7110
fa197c1c
PB		 7111 remaining = 4;
7112 }
7113
7114 if ((word & 0x80000000) == 0)
7115 {
7116 /* Expand prel31 for personality routine. */
7117 bfd_vma fn;
7118 const char *procname;
7119
a734115a 7120 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7121 printf (_(" Personality routine: "));
1b31d05e
NC		 7122 if (fn == 0
7123 && addr.section == SHN_UNDEF && addr.offset == 0
7124 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7125 {
7126 procname = aux->strtab + sym_name;
7127 print_vma (fn, PREFIX_HEX);
7128 if (procname)
7129 {
7130 fputs (" <", stdout);
7131 fputs (procname, stdout);
7132 fputc ('>', stdout);
7133 }
7134 }
7135 else
7136 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7137 fputc ('\n', stdout);
7138
7139 /* The GCC personality routines use the standard compact
7140 encoding, starting with one byte giving the number of
7141 words. */
7142 if (procname != NULL
7143 && (const_strneq (procname, "__gcc_personality_v0")
7144 || const_strneq (procname, "__gxx_personality_v0")
7145 || const_strneq (procname, "__gcj_personality_v0")
7146 || const_strneq (procname, "__gnu_objc_personality_v0")))
7147 {
7148 remaining = 0;
7149 more_words = 1;
7150 ADVANCE;
7151 if (!remaining)
7152 {
7153 printf (_(" [Truncated data]\n"));
7154 return;
7155 }
7156 more_words = word >> 24;
7157 word <<= 8;
7158 remaining--;
7159 per_index = -1;
7160 }
7161 else
7162 return;
7163 }
7164 else
7165 {
1b31d05e
NC		 7166 /* ARM EHABI Section 6.3:
7167
7168 An exception-handling table entry for the compact model looks like:
7169
7170 31 30-28 27-24 23-0
7171 -- ----- ----- ----
7172 1 0 index Data for personalityRoutine[index] */
7173
7174 if (elf_header.e_machine == EM_ARM
7175 && (word & 0x70000000))
83c257ca 7176 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7177
fa197c1c 7178 per_index = (word >> 24) & 0x7f;
1b31d05e 7179 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7180 if (per_index == 0)
7181 {
7182 more_words = 0;
7183 word <<= 8;
7184 remaining--;
7185 }
7186 else if (per_index < 3)
7187 {
7188 more_words = (word >> 16) & 0xff;
7189 word <<= 16;
7190 remaining -= 2;
7191 }
7192 }
7193
7194 switch (elf_header.e_machine)
7195 {
7196 case EM_ARM:
7197 if (per_index < 3)
7198 {
7199 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7200 data_offset, data_sec, data_arm_sec);
7201 }
7202 else
1b31d05e
NC		 7203 {
7204 warn (_("Unknown ARM compact model index encountered\n"));
7205 printf (_(" [reserved]\n"));
7206 }
fa197c1c
PB		 7207 break;
7208
7209 case EM_TI_C6000:
7210 if (per_index < 3)
7211 {
7212 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7213 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7214 }
7215 else if (per_index < 5)
7216 {
7217 if (((word >> 17) & 0x7f) == 0x7f)
7218 printf (_(" Restore stack from frame pointer\n"));
7219 else
7220 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7221 printf (_(" Registers restored: "));
7222 if (per_index == 4)
7223 printf (" (compact) ");
7224 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7225 putchar ('\n');
7226 printf (_(" Return register: %s\n"),
7227 tic6x_unwind_regnames[word & 0xf]);
7228 }
7229 else
1b31d05e 7230 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7231 break;
7232
7233 default:
1b31d05e
NC		 7234 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7235 elf_header.e_machine);
fa197c1c 7236 }
0b6ae522
DJ		 7237
7238 /* Decode the descriptors. Not implemented. */
7239}
7240
7241static void
7242dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7243{
7244 struct arm_section exidx_arm_sec, extab_arm_sec;
7245 unsigned int i, exidx_len;
7246
7247 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7248 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7249 exidx_len = exidx_sec->sh_size / 8;
7250
7251 for (i = 0; i < exidx_len; i++)
7252 {
7253 unsigned int exidx_fn, exidx_entry;
7254 struct absaddr fn_addr, entry_addr;
7255 bfd_vma fn;
7256
7257 fputc ('\n', stdout);
7258
1b31d05e
NC		 7259 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7260 8 * i, & exidx_fn, & fn_addr, NULL)
7261 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7262 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7263 {
1b31d05e
NC		 7264 arm_free_section (& exidx_arm_sec);
7265 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7266 return;
7267 }
7268
83c257ca
NC		 7269 /* ARM EHABI, Section 5:
7270 An index table entry consists of 2 words.
7271 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7272 if (exidx_fn & 0x80000000)
7273 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7274
a734115a 7275 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7276
a734115a 7277 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7278 fputs (": ", stdout);
7279
7280 if (exidx_entry == 1)
7281 {
7282 print_vma (exidx_entry, PREFIX_HEX);
7283 fputs (" [cantunwind]\n", stdout);
7284 }
7285 else if (exidx_entry & 0x80000000)
7286 {
7287 print_vma (exidx_entry, PREFIX_HEX);
7288 fputc ('\n', stdout);
7289 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7290 }
7291 else
7292 {
8f73510c 7293 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7294 Elf_Internal_Shdr *table_sec;
7295
7296 fputs ("@", stdout);
a734115a 7297 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7298 print_vma (table, PREFIX_HEX);
7299 printf ("\n");
7300
7301 /* Locate the matching .ARM.extab. */
7302 if (entry_addr.section != SHN_UNDEF
7303 && entry_addr.section < elf_header.e_shnum)
7304 {
7305 table_sec = section_headers + entry_addr.section;
7306 table_offset = entry_addr.offset;
7307 }
7308 else
7309 {
7310 table_sec = find_section_by_address (table);
7311 if (table_sec != NULL)
7312 table_offset = table - table_sec->sh_addr;
7313 }
7314 if (table_sec == NULL)
7315 {
7316 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7317 (unsigned long) table);
7318 continue;
7319 }
7320 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7321 &extab_arm_sec);
7322 }
7323 }
7324
7325 printf ("\n");
7326
7327 arm_free_section (&exidx_arm_sec);
7328 arm_free_section (&extab_arm_sec);
7329}
7330
fa197c1c 7331/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7332
7333static void
0b6ae522
DJ		 7334arm_process_unwind (FILE *file)
7335{
7336 struct arm_unw_aux_info aux;
7337 Elf_Internal_Shdr *unwsec = NULL;
7338 Elf_Internal_Shdr *strsec;
7339 Elf_Internal_Shdr *sec;
7340 unsigned long i;
fa197c1c 7341 unsigned int sec_type;
0b6ae522 7342
fa197c1c
PB		 7343 switch (elf_header.e_machine)
7344 {
7345 case EM_ARM:
7346 sec_type = SHT_ARM_EXIDX;
7347 break;
7348
7349 case EM_TI_C6000:
7350 sec_type = SHT_C6000_UNWIND;
7351 break;
7352
1b31d05e
NC		 7353 default:
7354 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7355 elf_header.e_machine);
7356 return;
fa197c1c
PB		 7357 }
7358
0b6ae522 7359 if (string_table == NULL)
1b31d05e
NC		 7360 return;
7361
7362 memset (& aux, 0, sizeof (aux));
7363 aux.file = file;
0b6ae522
DJ		 7364
7365 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7366 {
7367 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7368 {
ba5cdace 7369 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7370
7371 strsec = section_headers + sec->sh_link;
59245841 7372 assert (aux.strtab == NULL);
0b6ae522
DJ		 7373 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7374 1, strsec->sh_size, _("string table"));
7375 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7376 }
fa197c1c 7377 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7378 unwsec = sec;
7379 }
7380
1b31d05e 7381 if (unwsec == NULL)
0b6ae522 7382 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7383 else
7384 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7385 {
7386 if (sec->sh_type == sec_type)
7387 {
7388 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7389 SECTION_NAME (sec),
7390 (unsigned long) sec->sh_offset,
7391 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7392
1b31d05e
NC		 7393 dump_arm_unwind (&aux, sec);
7394 }
7395 }
0b6ae522
DJ		 7396
7397 if (aux.symtab)
7398 free (aux.symtab);
7399 if (aux.strtab)
7400 free ((char *) aux.strtab);
0b6ae522
DJ		 7401}
7402
1b31d05e 7403static void
2cf0635d 7404process_unwind (FILE * file)
57346661 7405{
2cf0635d
NC		 7406 struct unwind_handler
7407 {
57346661 7408 int machtype;
1b31d05e 7409 void (* handler)(FILE *);
2cf0635d
NC		 7410 } handlers[] =
7411 {
0b6ae522 7412 { EM_ARM, arm_process_unwind },
57346661
AM		 7413 { EM_IA_64, ia64_process_unwind },
7414 { EM_PARISC, hppa_process_unwind },
fa197c1c 7415 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7416 { 0, 0 }
7417 };
7418 int i;
7419
7420 if (!do_unwind)
1b31d05e 7421 return;
57346661
AM		 7422
7423 for (i = 0; handlers[i].handler != NULL; i++)
7424 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7425 return handlers[i].handler (file);
57346661 7426
1b31d05e
NC		 7427 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7428 get_machine_name (elf_header.e_machine));
57346661
AM		 7429}
7430
252b5132 7431static void
2cf0635d 7432dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7433{
7434 switch (entry->d_tag)
7435 {
7436 case DT_MIPS_FLAGS:
7437 if (entry->d_un.d_val == 0)
4b68bca3 7438 printf (_("NONE"));
252b5132
RH		 7439 else
7440 {
7441 static const char * opts[] =
7442 {
7443 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7444 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7445 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7446 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7447 "RLD_ORDER_SAFE"
7448 };
7449 unsigned int cnt;
7450 int first = 1;
2b692964 7451
60bca95a 7452 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7453 if (entry->d_un.d_val & (1 << cnt))
7454 {
7455 printf ("%s%s", first ? "" : " ", opts[cnt]);
7456 first = 0;
7457 }
252b5132
RH		 7458 }
7459 break;
103f02d3 7460
252b5132 7461 case DT_MIPS_IVERSION:
d79b3d50 7462 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7463 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7464 else
4b68bca3 7465 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7466 break;
103f02d3 7467
252b5132
RH		 7468 case DT_MIPS_TIME_STAMP:
7469 {
7470 char timebuf[20];
2cf0635d 7471 struct tm * tmp;
50da7a9c 7472
91d6fa6a
NC		 7473 time_t atime = entry->d_un.d_val;
7474 tmp = gmtime (&atime);
e9e44622
JJ		 7475 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7476 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7477 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7478 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7479 }
7480 break;
103f02d3 7481
252b5132
RH		 7482 case DT_MIPS_RLD_VERSION:
7483 case DT_MIPS_LOCAL_GOTNO:
7484 case DT_MIPS_CONFLICTNO:
7485 case DT_MIPS_LIBLISTNO:
7486 case DT_MIPS_SYMTABNO:
7487 case DT_MIPS_UNREFEXTNO:
7488 case DT_MIPS_HIPAGENO:
7489 case DT_MIPS_DELTA_CLASS_NO:
7490 case DT_MIPS_DELTA_INSTANCE_NO:
7491 case DT_MIPS_DELTA_RELOC_NO:
7492 case DT_MIPS_DELTA_SYM_NO:
7493 case DT_MIPS_DELTA_CLASSSYM_NO:
7494 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7495 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7496 break;
103f02d3
UD		 7497
7498 default:
4b68bca3 7499 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7500 }
4b68bca3 7501 putchar ('\n');
103f02d3
UD		 7502}
7503
103f02d3 7504static void
2cf0635d 7505dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7506{
7507 switch (entry->d_tag)
7508 {
7509 case DT_HP_DLD_FLAGS:
7510 {
7511 static struct
7512 {
7513 long int bit;
2cf0635d 7514 const char * str;
5e220199
NC		 7515 }
7516 flags[] =
7517 {
7518 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7519 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7520 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7521 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7522 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7523 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7524 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7525 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7526 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7527 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7528 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7529 { DT_HP_GST, "HP_GST" },
7530 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7531 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7532 { DT_HP_NODELETE, "HP_NODELETE" },
7533 { DT_HP_GROUP, "HP_GROUP" },
7534 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7535 };
103f02d3 7536 int first = 1;
5e220199 7537 size_t cnt;
f7a99963 7538 bfd_vma val = entry->d_un.d_val;
103f02d3 7539
60bca95a 7540 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7541 if (val & flags[cnt].bit)
30800947
NC		 7542 {
7543 if (! first)
7544 putchar (' ');
7545 fputs (flags[cnt].str, stdout);
7546 first = 0;
7547 val ^= flags[cnt].bit;
7548 }
76da6bbe 7549
103f02d3 7550 if (val != 0 || first)
f7a99963
NC		 7551 {
7552 if (! first)
7553 putchar (' ');
7554 print_vma (val, HEX);
7555 }
103f02d3
UD		 7556 }
7557 break;
76da6bbe 7558
252b5132 7559 default:
f7a99963
NC		 7560 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7561 break;
252b5132 7562 }
35b1837e 7563 putchar ('\n');
252b5132
RH		 7564}
7565
28f997cf
TG		 7566#ifdef BFD64
7567
7568/* VMS vs Unix time offset and factor. */
7569
7570#define VMS_EPOCH_OFFSET 35067168000000000LL
7571#define VMS_GRANULARITY_FACTOR 10000000
7572
7573/* Display a VMS time in a human readable format. */
7574
7575static void
7576print_vms_time (bfd_int64_t vmstime)
7577{
7578 struct tm *tm;
7579 time_t unxtime;
7580
7581 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7582 tm = gmtime (&unxtime);
7583 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7584 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7585 tm->tm_hour, tm->tm_min, tm->tm_sec);
7586}
7587#endif /* BFD64 */
7588
ecc51f48 7589static void
2cf0635d 7590dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7591{
7592 switch (entry->d_tag)
7593 {
0de14b54 7594 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7595 /* First 3 slots reserved. */
ecc51f48
NC		 7596 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7597 printf (" -- ");
7598 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7599 break;
7600
28f997cf
TG		 7601 case DT_IA_64_VMS_LINKTIME:
7602#ifdef BFD64
7603 print_vms_time (entry->d_un.d_val);
7604#endif
7605 break;
7606
7607 case DT_IA_64_VMS_LNKFLAGS:
7608 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7609 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7610 printf (" CALL_DEBUG");
7611 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7612 printf (" NOP0BUFS");
7613 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7614 printf (" P0IMAGE");
7615 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7616 printf (" MKTHREADS");
7617 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7618 printf (" UPCALLS");
7619 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7620 printf (" IMGSTA");
7621 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7622 printf (" INITIALIZE");
7623 if (entry->d_un.d_val & VMS_LF_MAIN)
7624 printf (" MAIN");
7625 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7626 printf (" EXE_INIT");
7627 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7628 printf (" TBK_IN_IMG");
7629 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7630 printf (" DBG_IN_IMG");
7631 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7632 printf (" TBK_IN_DSF");
7633 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7634 printf (" DBG_IN_DSF");
7635 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7636 printf (" SIGNATURES");
7637 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7638 printf (" REL_SEG_OFF");
7639 break;
7640
bdf4d63a
JJ		 7641 default:
7642 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7643 break;
ecc51f48 7644 }
bdf4d63a 7645 putchar ('\n');
ecc51f48
NC		 7646}
7647
252b5132 7648static int
2cf0635d 7649get_32bit_dynamic_section (FILE * file)
252b5132 7650{
2cf0635d
NC		 7651 Elf32_External_Dyn * edyn;
7652 Elf32_External_Dyn * ext;
7653 Elf_Internal_Dyn * entry;
103f02d3 7654
3f5e193b
NC		 7655 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7656 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7657 if (!edyn)
7658 return 0;
103f02d3 7659
ba2685cc
AM		 7660/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7661 might not have the luxury of section headers. Look for the DT_NULL
7662 terminator to determine the number of entries. */
7663 for (ext = edyn, dynamic_nent = 0;
7664 (char *) ext < (char *) edyn + dynamic_size;
7665 ext++)
7666 {
7667 dynamic_nent++;
7668 if (BYTE_GET (ext->d_tag) == DT_NULL)
7669 break;
7670 }
252b5132 7671
3f5e193b
NC		 7672 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7673 sizeof (* entry));
b2d38a17 7674 if (dynamic_section == NULL)
252b5132 7675 {
9ea033b2
NC		 7676 error (_("Out of memory\n"));
7677 free (edyn);
7678 return 0;
7679 }
252b5132 7680
fb514b26 7681 for (ext = edyn, entry = dynamic_section;
ba2685cc 7682 entry < dynamic_section + dynamic_nent;
fb514b26 7683 ext++, entry++)
9ea033b2 7684 {
fb514b26
AM		 7685 entry->d_tag = BYTE_GET (ext->d_tag);
7686 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7687 }
7688
9ea033b2
NC		 7689 free (edyn);
7690
7691 return 1;
7692}
7693
7694static int
2cf0635d 7695get_64bit_dynamic_section (FILE * file)
9ea033b2 7696{
2cf0635d
NC		 7697 Elf64_External_Dyn * edyn;
7698 Elf64_External_Dyn * ext;
7699 Elf_Internal_Dyn * entry;
103f02d3 7700
3f5e193b
NC		 7701 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7702 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7703 if (!edyn)
7704 return 0;
103f02d3 7705
ba2685cc
AM		 7706/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7707 might not have the luxury of section headers. Look for the DT_NULL
7708 terminator to determine the number of entries. */
7709 for (ext = edyn, dynamic_nent = 0;
7710 (char *) ext < (char *) edyn + dynamic_size;
7711 ext++)
7712 {
7713 dynamic_nent++;
66543521 7714 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7715 break;
7716 }
252b5132 7717
3f5e193b
NC		 7718 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7719 sizeof (* entry));
b2d38a17 7720 if (dynamic_section == NULL)
252b5132
RH		 7721 {
7722 error (_("Out of memory\n"));
7723 free (edyn);
7724 return 0;
7725 }
7726
fb514b26 7727 for (ext = edyn, entry = dynamic_section;
ba2685cc 7728 entry < dynamic_section + dynamic_nent;
fb514b26 7729 ext++, entry++)
252b5132 7730 {
66543521
AM		 7731 entry->d_tag = BYTE_GET (ext->d_tag);
7732 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7733 }
7734
7735 free (edyn);
7736
9ea033b2
NC		 7737 return 1;
7738}
7739
e9e44622
JJ		 7740static void
7741print_dynamic_flags (bfd_vma flags)
d1133906 7742{
e9e44622 7743 int first = 1;
13ae64f3 7744
d1133906
NC		 7745 while (flags)
7746 {
7747 bfd_vma flag;
7748
7749 flag = flags & - flags;
7750 flags &= ~ flag;
7751
e9e44622
JJ		 7752 if (first)
7753 first = 0;
7754 else
7755 putc (' ', stdout);
13ae64f3 7756
d1133906
NC		 7757 switch (flag)
7758 {
e9e44622
JJ		 7759 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7760 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7761 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7762 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7763 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7764 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7765 }
7766 }
e9e44622 7767 puts ("");
d1133906
NC		 7768}
7769
b2d38a17
NC		 7770/* Parse and display the contents of the dynamic section. */
7771
9ea033b2 7772static int
2cf0635d 7773process_dynamic_section (FILE * file)
9ea033b2 7774{
2cf0635d 7775 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7776
7777 if (dynamic_size == 0)
7778 {
7779 if (do_dynamic)
b2d38a17 7780 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7781
7782 return 1;
7783 }
7784
7785 if (is_32bit_elf)
7786 {
b2d38a17 7787 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7788 return 0;
7789 }
b2d38a17 7790 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7791 return 0;
7792
252b5132
RH		 7793 /* Find the appropriate symbol table. */
7794 if (dynamic_symbols == NULL)
7795 {
86dba8ee
AM		 7796 for (entry = dynamic_section;
7797 entry < dynamic_section + dynamic_nent;
7798 ++entry)
252b5132 7799 {
c8286bd1 7800 Elf_Internal_Shdr section;
252b5132
RH		 7801
7802 if (entry->d_tag != DT_SYMTAB)
7803 continue;
7804
7805 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7806
7807 /* Since we do not know how big the symbol table is,
7808 we default to reading in the entire file (!) and
7809 processing that. This is overkill, I know, but it
e3c8793a 7810 should work. */
d93f0186 7811 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7812
fb52b2f4
NC		 7813 if (archive_file_offset != 0)
7814 section.sh_size = archive_file_size - section.sh_offset;
7815 else
7816 {
7817 if (fseek (file, 0, SEEK_END))
591a748a 7818 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7819
7820 section.sh_size = ftell (file) - section.sh_offset;
7821 }
252b5132 7822
9ea033b2 7823 if (is_32bit_elf)
9ad5cbcf 7824 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7825 else
9ad5cbcf 7826 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7827
ba5cdace 7828 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7829 if (num_dynamic_syms < 1)
252b5132
RH		 7830 {
7831 error (_("Unable to determine the number of symbols to load\n"));
7832 continue;
7833 }
252b5132
RH		 7834 }
7835 }
7836
7837 /* Similarly find a string table. */
7838 if (dynamic_strings == NULL)
7839 {
86dba8ee
AM		 7840 for (entry = dynamic_section;
7841 entry < dynamic_section + dynamic_nent;
7842 ++entry)
252b5132
RH		 7843 {
7844 unsigned long offset;
b34976b6 7845 long str_tab_len;
252b5132
RH		 7846
7847 if (entry->d_tag != DT_STRTAB)
7848 continue;
7849
7850 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7851
7852 /* Since we do not know how big the string table is,
7853 we default to reading in the entire file (!) and
7854 processing that. This is overkill, I know, but it
e3c8793a 7855 should work. */
252b5132 7856
d93f0186 7857 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7858
7859 if (archive_file_offset != 0)
7860 str_tab_len = archive_file_size - offset;
7861 else
7862 {
7863 if (fseek (file, 0, SEEK_END))
7864 error (_("Unable to seek to end of file\n"));
7865 str_tab_len = ftell (file) - offset;
7866 }
252b5132
RH		 7867
7868 if (str_tab_len < 1)
7869 {
7870 error
7871 (_("Unable to determine the length of the dynamic string table\n"));
7872 continue;
7873 }
7874
3f5e193b
NC		 7875 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7876 str_tab_len,
7877 _("dynamic string table"));
59245841 7878 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7879 break;
7880 }
7881 }
7882
7883 /* And find the syminfo section if available. */
7884 if (dynamic_syminfo == NULL)
7885 {
3e8bba36 7886 unsigned long syminsz = 0;
252b5132 7887
86dba8ee
AM		 7888 for (entry = dynamic_section;
7889 entry < dynamic_section + dynamic_nent;
7890 ++entry)
252b5132
RH		 7891 {
7892 if (entry->d_tag == DT_SYMINENT)
7893 {
7894 /* Note: these braces are necessary to avoid a syntax
7895 error from the SunOS4 C compiler. */
7896 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7897 }
7898 else if (entry->d_tag == DT_SYMINSZ)
7899 syminsz = entry->d_un.d_val;
7900 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7901 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7902 syminsz);
252b5132
RH		 7903 }
7904
7905 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7906 {
2cf0635d
NC		 7907 Elf_External_Syminfo * extsyminfo;
7908 Elf_External_Syminfo * extsym;
7909 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7910
7911 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7912 extsyminfo = (Elf_External_Syminfo *)
7913 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7914 _("symbol information"));
a6e9f9df
AM		 7915 if (!extsyminfo)
7916 return 0;
252b5132 7917
3f5e193b 7918 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7919 if (dynamic_syminfo == NULL)
7920 {
7921 error (_("Out of memory\n"));
7922 return 0;
7923 }
7924
7925 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7926 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7927 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7928 ++syminfo, ++extsym)
252b5132 7929 {
86dba8ee
AM		 7930 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7931 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7932 }
7933
7934 free (extsyminfo);
7935 }
7936 }
7937
7938 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7939 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7940 dynamic_addr, dynamic_nent);
252b5132
RH		 7941 if (do_dynamic)
7942 printf (_(" Tag Type Name/Value\n"));
7943
86dba8ee
AM		 7944 for (entry = dynamic_section;
7945 entry < dynamic_section + dynamic_nent;
7946 entry++)
252b5132
RH		 7947 {
7948 if (do_dynamic)
f7a99963 7949 {
2cf0635d 7950 const char * dtype;
e699b9ff 7951
f7a99963
NC		 7952 putchar (' ');
7953 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7954 dtype = get_dynamic_type (entry->d_tag);
7955 printf (" (%s)%*s", dtype,
7956 ((is_32bit_elf ? 27 : 19)
7957 - (int) strlen (dtype)),
f7a99963
NC		 7958 " ");
7959 }
252b5132
RH		 7960
7961 switch (entry->d_tag)
7962 {
d1133906
NC		 7963 case DT_FLAGS:
7964 if (do_dynamic)
e9e44622 7965 print_dynamic_flags (entry->d_un.d_val);
d1133906 7966 break;
76da6bbe 7967
252b5132
RH		 7968 case DT_AUXILIARY:
7969 case DT_FILTER:
019148e4
L		 7970 case DT_CONFIG:
7971 case DT_DEPAUDIT:
7972 case DT_AUDIT:
252b5132
RH		 7973 if (do_dynamic)
7974 {
019148e4 7975 switch (entry->d_tag)
b34976b6 7976 {
019148e4
L		 7977 case DT_AUXILIARY:
7978 printf (_("Auxiliary library"));
7979 break;
7980
7981 case DT_FILTER:
7982 printf (_("Filter library"));
7983 break;
7984
b34976b6 7985 case DT_CONFIG:
019148e4
L		 7986 printf (_("Configuration file"));
7987 break;
7988
7989 case DT_DEPAUDIT:
7990 printf (_("Dependency audit library"));
7991 break;
7992
7993 case DT_AUDIT:
7994 printf (_("Audit library"));
7995 break;
7996 }
252b5132 7997
d79b3d50
NC		 7998 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7999 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8000 else
f7a99963
NC		 8001 {
8002 printf (": ");
8003 print_vma (entry->d_un.d_val, PREFIX_HEX);
8004 putchar ('\n');
8005 }
252b5132
RH		 8006 }
8007 break;
8008
dcefbbbd 8009 case DT_FEATURE:
252b5132
RH		 8010 if (do_dynamic)
8011 {
8012 printf (_("Flags:"));
86f55779 8013
252b5132
RH		 8014 if (entry->d_un.d_val == 0)
8015 printf (_(" None\n"));
8016 else
8017 {
8018 unsigned long int val = entry->d_un.d_val;
86f55779 8019
252b5132
RH		 8020 if (val & DTF_1_PARINIT)
8021 {
8022 printf (" PARINIT");
8023 val ^= DTF_1_PARINIT;
8024 }
dcefbbbd
L		 8025 if (val & DTF_1_CONFEXP)
8026 {
8027 printf (" CONFEXP");
8028 val ^= DTF_1_CONFEXP;
8029 }
252b5132
RH		 8030 if (val != 0)
8031 printf (" %lx", val);
8032 puts ("");
8033 }
8034 }
8035 break;
8036
8037 case DT_POSFLAG_1:
8038 if (do_dynamic)
8039 {
8040 printf (_("Flags:"));
86f55779 8041
252b5132
RH		 8042 if (entry->d_un.d_val == 0)
8043 printf (_(" None\n"));
8044 else
8045 {
8046 unsigned long int val = entry->d_un.d_val;
86f55779 8047
252b5132
RH		 8048 if (val & DF_P1_LAZYLOAD)
8049 {
8050 printf (" LAZYLOAD");
8051 val ^= DF_P1_LAZYLOAD;
8052 }
8053 if (val & DF_P1_GROUPPERM)
8054 {
8055 printf (" GROUPPERM");
8056 val ^= DF_P1_GROUPPERM;
8057 }
8058 if (val != 0)
8059 printf (" %lx", val);
8060 puts ("");
8061 }
8062 }
8063 break;
8064
8065 case DT_FLAGS_1:
8066 if (do_dynamic)
8067 {
8068 printf (_("Flags:"));
8069 if (entry->d_un.d_val == 0)
8070 printf (_(" None\n"));
8071 else
8072 {
8073 unsigned long int val = entry->d_un.d_val;
86f55779 8074
252b5132
RH		 8075 if (val & DF_1_NOW)
8076 {
8077 printf (" NOW");
8078 val ^= DF_1_NOW;
8079 }
8080 if (val & DF_1_GLOBAL)
8081 {
8082 printf (" GLOBAL");
8083 val ^= DF_1_GLOBAL;
8084 }
8085 if (val & DF_1_GROUP)
8086 {
8087 printf (" GROUP");
8088 val ^= DF_1_GROUP;
8089 }
8090 if (val & DF_1_NODELETE)
8091 {
8092 printf (" NODELETE");
8093 val ^= DF_1_NODELETE;
8094 }
8095 if (val & DF_1_LOADFLTR)
8096 {
8097 printf (" LOADFLTR");
8098 val ^= DF_1_LOADFLTR;
8099 }
8100 if (val & DF_1_INITFIRST)
8101 {
8102 printf (" INITFIRST");
8103 val ^= DF_1_INITFIRST;
8104 }
8105 if (val & DF_1_NOOPEN)
8106 {
8107 printf (" NOOPEN");
8108 val ^= DF_1_NOOPEN;
8109 }
8110 if (val & DF_1_ORIGIN)
8111 {
8112 printf (" ORIGIN");
8113 val ^= DF_1_ORIGIN;
8114 }
8115 if (val & DF_1_DIRECT)
8116 {
8117 printf (" DIRECT");
8118 val ^= DF_1_DIRECT;
8119 }
8120 if (val & DF_1_TRANS)
8121 {
8122 printf (" TRANS");
8123 val ^= DF_1_TRANS;
8124 }
8125 if (val & DF_1_INTERPOSE)
8126 {
8127 printf (" INTERPOSE");
8128 val ^= DF_1_INTERPOSE;
8129 }
f7db6139 8130 if (val & DF_1_NODEFLIB)
dcefbbbd 8131 {
f7db6139
L		 8132 printf (" NODEFLIB");
8133 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8134 }
8135 if (val & DF_1_NODUMP)
8136 {
8137 printf (" NODUMP");
8138 val ^= DF_1_NODUMP;
8139 }
34b60028 8140 if (val & DF_1_CONFALT)
dcefbbbd 8141 {
34b60028
L		 8142 printf (" CONFALT");
8143 val ^= DF_1_CONFALT;
8144 }
8145 if (val & DF_1_ENDFILTEE)
8146 {
8147 printf (" ENDFILTEE");
8148 val ^= DF_1_ENDFILTEE;
8149 }
8150 if (val & DF_1_DISPRELDNE)
8151 {
8152 printf (" DISPRELDNE");
8153 val ^= DF_1_DISPRELDNE;
8154 }
8155 if (val & DF_1_DISPRELPND)
8156 {
8157 printf (" DISPRELPND");
8158 val ^= DF_1_DISPRELPND;
8159 }
8160 if (val & DF_1_NODIRECT)
8161 {
8162 printf (" NODIRECT");
8163 val ^= DF_1_NODIRECT;
8164 }
8165 if (val & DF_1_IGNMULDEF)
8166 {
8167 printf (" IGNMULDEF");
8168 val ^= DF_1_IGNMULDEF;
8169 }
8170 if (val & DF_1_NOKSYMS)
8171 {
8172 printf (" NOKSYMS");
8173 val ^= DF_1_NOKSYMS;
8174 }
8175 if (val & DF_1_NOHDR)
8176 {
8177 printf (" NOHDR");
8178 val ^= DF_1_NOHDR;
8179 }
8180 if (val & DF_1_EDITED)
8181 {
8182 printf (" EDITED");
8183 val ^= DF_1_EDITED;
8184 }
8185 if (val & DF_1_NORELOC)
8186 {
8187 printf (" NORELOC");
8188 val ^= DF_1_NORELOC;
8189 }
8190 if (val & DF_1_SYMINTPOSE)
8191 {
8192 printf (" SYMINTPOSE");
8193 val ^= DF_1_SYMINTPOSE;
8194 }
8195 if (val & DF_1_GLOBAUDIT)
8196 {
8197 printf (" GLOBAUDIT");
8198 val ^= DF_1_GLOBAUDIT;
8199 }
8200 if (val & DF_1_SINGLETON)
8201 {
8202 printf (" SINGLETON");
8203 val ^= DF_1_SINGLETON;
dcefbbbd 8204 }
252b5132
RH		 8205 if (val != 0)
8206 printf (" %lx", val);
8207 puts ("");
8208 }
8209 }
8210 break;
8211
8212 case DT_PLTREL:
566b0d53 8213 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8214 if (do_dynamic)
8215 puts (get_dynamic_type (entry->d_un.d_val));
8216 break;
8217
8218 case DT_NULL :
8219 case DT_NEEDED :
8220 case DT_PLTGOT :
8221 case DT_HASH :
8222 case DT_STRTAB :
8223 case DT_SYMTAB :
8224 case DT_RELA :
8225 case DT_INIT :
8226 case DT_FINI :
8227 case DT_SONAME :
8228 case DT_RPATH :
8229 case DT_SYMBOLIC:
8230 case DT_REL :
8231 case DT_DEBUG :
8232 case DT_TEXTREL :
8233 case DT_JMPREL :
019148e4 8234 case DT_RUNPATH :
252b5132
RH		 8235 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8236
8237 if (do_dynamic)
8238 {
2cf0635d 8239 char * name;
252b5132 8240
d79b3d50
NC		 8241 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8242 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8243 else
d79b3d50 8244 name = NULL;
252b5132
RH		 8245
8246 if (name)
8247 {
8248 switch (entry->d_tag)
8249 {
8250 case DT_NEEDED:
8251 printf (_("Shared library: [%s]"), name);
8252
18bd398b 8253 if (streq (name, program_interpreter))
f7a99963 8254 printf (_(" program interpreter"));
252b5132
RH		 8255 break;
8256
8257 case DT_SONAME:
f7a99963 8258 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8259 break;
8260
8261 case DT_RPATH:
f7a99963 8262 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8263 break;
8264
019148e4
L		 8265 case DT_RUNPATH:
8266 printf (_("Library runpath: [%s]"), name);
8267 break;
8268
252b5132 8269 default:
f7a99963
NC		 8270 print_vma (entry->d_un.d_val, PREFIX_HEX);
8271 break;
252b5132
RH		 8272 }
8273 }
8274 else
f7a99963
NC		 8275 print_vma (entry->d_un.d_val, PREFIX_HEX);
8276
8277 putchar ('\n');
252b5132
RH		 8278 }
8279 break;
8280
8281 case DT_PLTRELSZ:
8282 case DT_RELASZ :
8283 case DT_STRSZ :
8284 case DT_RELSZ :
8285 case DT_RELAENT :
8286 case DT_SYMENT :
8287 case DT_RELENT :
566b0d53 8288 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8289 case DT_PLTPADSZ:
8290 case DT_MOVEENT :
8291 case DT_MOVESZ :
8292 case DT_INIT_ARRAYSZ:
8293 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8294 case DT_GNU_CONFLICTSZ:
8295 case DT_GNU_LIBLISTSZ:
252b5132 8296 if (do_dynamic)
f7a99963
NC		 8297 {
8298 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8299 printf (_(" (bytes)\n"));
f7a99963 8300 }
252b5132
RH		 8301 break;
8302
8303 case DT_VERDEFNUM:
8304 case DT_VERNEEDNUM:
8305 case DT_RELACOUNT:
8306 case DT_RELCOUNT:
8307 if (do_dynamic)
f7a99963
NC		 8308 {
8309 print_vma (entry->d_un.d_val, UNSIGNED);
8310 putchar ('\n');
8311 }
252b5132
RH		 8312 break;
8313
8314 case DT_SYMINSZ:
8315 case DT_SYMINENT:
8316 case DT_SYMINFO:
8317 case DT_USED:
8318 case DT_INIT_ARRAY:
8319 case DT_FINI_ARRAY:
8320 if (do_dynamic)
8321 {
d79b3d50
NC		 8322 if (entry->d_tag == DT_USED
8323 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8324 {
2cf0635d 8325 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8326
b34976b6 8327 if (*name)
252b5132
RH		 8328 {
8329 printf (_("Not needed object: [%s]\n"), name);
8330 break;
8331 }
8332 }
103f02d3 8333
f7a99963
NC		 8334 print_vma (entry->d_un.d_val, PREFIX_HEX);
8335 putchar ('\n');
252b5132
RH		 8336 }
8337 break;
8338
8339 case DT_BIND_NOW:
8340 /* The value of this entry is ignored. */
35b1837e
AM		 8341 if (do_dynamic)
8342 putchar ('\n');
252b5132 8343 break;
103f02d3 8344
047b2264
JJ		 8345 case DT_GNU_PRELINKED:
8346 if (do_dynamic)
8347 {
2cf0635d 8348 struct tm * tmp;
91d6fa6a 8349 time_t atime = entry->d_un.d_val;
047b2264 8350
91d6fa6a 8351 tmp = gmtime (&atime);
047b2264
JJ		 8352 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8353 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8354 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8355
8356 }
8357 break;
8358
fdc90cb4
JJ		 8359 case DT_GNU_HASH:
8360 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8361 if (do_dynamic)
8362 {
8363 print_vma (entry->d_un.d_val, PREFIX_HEX);
8364 putchar ('\n');
8365 }
8366 break;
8367
252b5132
RH		 8368 default:
8369 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8370 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8371 entry->d_un.d_val;
8372
8373 if (do_dynamic)
8374 {
8375 switch (elf_header.e_machine)
8376 {
8377 case EM_MIPS:
4fe85591 8378 case EM_MIPS_RS3_LE:
b2d38a17 8379 dynamic_section_mips_val (entry);
252b5132 8380 break;
103f02d3 8381 case EM_PARISC:
b2d38a17 8382 dynamic_section_parisc_val (entry);
103f02d3 8383 break;
ecc51f48 8384 case EM_IA_64:
b2d38a17 8385 dynamic_section_ia64_val (entry);
ecc51f48 8386 break;
252b5132 8387 default:
f7a99963
NC		 8388 print_vma (entry->d_un.d_val, PREFIX_HEX);
8389 putchar ('\n');
252b5132
RH		 8390 }
8391 }
8392 break;
8393 }
8394 }
8395
8396 return 1;
8397}
8398
8399static char *
d3ba0551 8400get_ver_flags (unsigned int flags)
252b5132 8401{
b34976b6 8402 static char buff[32];
252b5132
RH		 8403
8404 buff[0] = 0;
8405
8406 if (flags == 0)
8407 return _("none");
8408
8409 if (flags & VER_FLG_BASE)
8410 strcat (buff, "BASE ");
8411
8412 if (flags & VER_FLG_WEAK)
8413 {
8414 if (flags & VER_FLG_BASE)
8415 strcat (buff, "| ");
8416
8417 strcat (buff, "WEAK ");
8418 }
8419
44ec90b9
RO		 8420 if (flags & VER_FLG_INFO)
8421 {
8422 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8423 strcat (buff, "| ");
8424
8425 strcat (buff, "INFO ");
8426 }
8427
8428 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8429 strcat (buff, _("| <unknown>"));
252b5132
RH		 8430
8431 return buff;
8432}
8433
8434/* Display the contents of the version sections. */
98fb390a 8435
252b5132 8436static int
2cf0635d 8437process_version_sections (FILE * file)
252b5132 8438{
2cf0635d 8439 Elf_Internal_Shdr * section;
b34976b6
AM		 8440 unsigned i;
8441 int found = 0;
252b5132
RH		 8442
8443 if (! do_version)
8444 return 1;
8445
8446 for (i = 0, section = section_headers;
8447 i < elf_header.e_shnum;
b34976b6 8448 i++, section++)
252b5132
RH		 8449 {
8450 switch (section->sh_type)
8451 {
8452 case SHT_GNU_verdef:
8453 {
2cf0635d 8454 Elf_External_Verdef * edefs;
b34976b6
AM		 8455 unsigned int idx;
8456 unsigned int cnt;
2cf0635d 8457 char * endbuf;
252b5132
RH		 8458
8459 found = 1;
8460
8461 printf
72de5009 8462 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8463 SECTION_NAME (section), section->sh_info);
8464
8465 printf (_(" Addr: 0x"));
8466 printf_vma (section->sh_addr);
72de5009 8467 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8468 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8469 section->sh_link < elf_header.e_shnum
8470 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8471 : _("<corrupt>"));
252b5132 8472
3f5e193b
NC		 8473 edefs = (Elf_External_Verdef *)
8474 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8475 _("version definition section"));
a6e9f9df
AM		 8476 if (!edefs)
8477 break;
59245841 8478 endbuf = (char *) edefs + section->sh_size;
252b5132 8479
b34976b6 8480 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8481 {
2cf0635d
NC		 8482 char * vstart;
8483 Elf_External_Verdef * edef;
b34976b6 8484 Elf_Internal_Verdef ent;
2cf0635d 8485 Elf_External_Verdaux * eaux;
b34976b6
AM		 8486 Elf_Internal_Verdaux aux;
8487 int j;
8488 int isum;
103f02d3 8489
7e26601c
NC		 8490 /* Check for very large indicies. */
8491 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 8492 break;
8493
252b5132 8494 vstart = ((char *) edefs) + idx;
54806181
AM		 8495 if (vstart + sizeof (*edef) > endbuf)
8496 break;
252b5132
RH		 8497
8498 edef = (Elf_External_Verdef *) vstart;
8499
8500 ent.vd_version = BYTE_GET (edef->vd_version);
8501 ent.vd_flags = BYTE_GET (edef->vd_flags);
8502 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8503 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8504 ent.vd_hash = BYTE_GET (edef->vd_hash);
8505 ent.vd_aux = BYTE_GET (edef->vd_aux);
8506 ent.vd_next = BYTE_GET (edef->vd_next);
8507
8508 printf (_(" %#06x: Rev: %d Flags: %s"),
8509 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8510
8511 printf (_(" Index: %d Cnt: %d "),
8512 ent.vd_ndx, ent.vd_cnt);
8513
dd24e3da 8514 /* Check for overflow. */
7e26601c 8515 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8516 break;
8517
252b5132
RH		 8518 vstart += ent.vd_aux;
8519
8520 eaux = (Elf_External_Verdaux *) vstart;
8521
8522 aux.vda_name = BYTE_GET (eaux->vda_name);
8523 aux.vda_next = BYTE_GET (eaux->vda_next);
8524
d79b3d50
NC		 8525 if (VALID_DYNAMIC_NAME (aux.vda_name))
8526 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8527 else
8528 printf (_("Name index: %ld\n"), aux.vda_name);
8529
8530 isum = idx + ent.vd_aux;
8531
b34976b6 8532 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8533 {
dd24e3da 8534 /* Check for overflow. */
7e26601c 8535 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8536 break;
8537
252b5132
RH		 8538 isum += aux.vda_next;
8539 vstart += aux.vda_next;
8540
8541 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8542 if (vstart + sizeof (*eaux) > endbuf)
8543 break;
252b5132
RH		 8544
8545 aux.vda_name = BYTE_GET (eaux->vda_name);
8546 aux.vda_next = BYTE_GET (eaux->vda_next);
8547
d79b3d50 8548 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8549 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8550 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8551 else
8552 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8553 isum, j, aux.vda_name);
8554 }
dd24e3da 8555
54806181
AM		 8556 if (j < ent.vd_cnt)
8557 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8558
8559 idx += ent.vd_next;
8560 }
dd24e3da 8561
54806181
AM		 8562 if (cnt < section->sh_info)
8563 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8564
8565 free (edefs);
8566 }
8567 break;
103f02d3 8568
252b5132
RH		 8569 case SHT_GNU_verneed:
8570 {
2cf0635d 8571 Elf_External_Verneed * eneed;
b34976b6
AM		 8572 unsigned int idx;
8573 unsigned int cnt;
2cf0635d 8574 char * endbuf;
252b5132
RH		 8575
8576 found = 1;
8577
72de5009 8578 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8579 SECTION_NAME (section), section->sh_info);
8580
8581 printf (_(" Addr: 0x"));
8582 printf_vma (section->sh_addr);
72de5009 8583 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8584 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8585 section->sh_link < elf_header.e_shnum
8586 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8587 : _("<corrupt>"));
252b5132 8588
3f5e193b
NC		 8589 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8590 section->sh_offset, 1,
8591 section->sh_size,
9cf03b7e 8592 _("Version Needs section"));
a6e9f9df
AM		 8593 if (!eneed)
8594 break;
59245841 8595 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8596
8597 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8598 {
2cf0635d 8599 Elf_External_Verneed * entry;
b34976b6
AM		 8600 Elf_Internal_Verneed ent;
8601 int j;
8602 int isum;
2cf0635d 8603 char * vstart;
252b5132 8604
7e26601c 8605 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 8606 break;
8607
252b5132 8608 vstart = ((char *) eneed) + idx;
54806181
AM		 8609 if (vstart + sizeof (*entry) > endbuf)
8610 break;
252b5132
RH		 8611
8612 entry = (Elf_External_Verneed *) vstart;
8613
8614 ent.vn_version = BYTE_GET (entry->vn_version);
8615 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8616 ent.vn_file = BYTE_GET (entry->vn_file);
8617 ent.vn_aux = BYTE_GET (entry->vn_aux);
8618 ent.vn_next = BYTE_GET (entry->vn_next);
8619
8620 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8621
d79b3d50
NC		 8622 if (VALID_DYNAMIC_NAME (ent.vn_file))
8623 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8624 else
8625 printf (_(" File: %lx"), ent.vn_file);
8626
8627 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8628
dd24e3da 8629 /* Check for overflow. */
7e26601c 8630 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8631 break;
8632
252b5132
RH		 8633 vstart += ent.vn_aux;
8634
8635 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8636 {
2cf0635d 8637 Elf_External_Vernaux * eaux;
b34976b6 8638 Elf_Internal_Vernaux aux;
252b5132 8639
54806181
AM		 8640 if (vstart + sizeof (*eaux) > endbuf)
8641 break;
252b5132
RH		 8642 eaux = (Elf_External_Vernaux *) vstart;
8643
8644 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8645 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8646 aux.vna_other = BYTE_GET (eaux->vna_other);
8647 aux.vna_name = BYTE_GET (eaux->vna_name);
8648 aux.vna_next = BYTE_GET (eaux->vna_next);
8649
d79b3d50 8650 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8651 printf (_(" %#06x: Name: %s"),
d79b3d50 8652 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8653 else
ecc2063b 8654 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8655 isum, aux.vna_name);
8656
8657 printf (_(" Flags: %s Version: %d\n"),
8658 get_ver_flags (aux.vna_flags), aux.vna_other);
8659
dd24e3da 8660 /* Check for overflow. */
7e26601c 8661 if (aux.vna_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8662 break;
8663
252b5132
RH		 8664 isum += aux.vna_next;
8665 vstart += aux.vna_next;
8666 }
9cf03b7e 8667
54806181 8668 if (j < ent.vn_cnt)
9cf03b7e 8669 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8670
8671 idx += ent.vn_next;
8672 }
9cf03b7e 8673
54806181 8674 if (cnt < section->sh_info)
9cf03b7e 8675 warn (_("Missing Version Needs information\n"));
103f02d3 8676
252b5132
RH		 8677 free (eneed);
8678 }
8679 break;
8680
8681 case SHT_GNU_versym:
8682 {
2cf0635d 8683 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8684 int total;
8685 int cnt;
2cf0635d
NC		 8686 unsigned char * edata;
8687 unsigned short * data;
8688 char * strtab;
8689 Elf_Internal_Sym * symbols;
8690 Elf_Internal_Shdr * string_sec;
ba5cdace 8691 unsigned long num_syms;
d3ba0551 8692 long off;
252b5132 8693
4fbb74a6 8694 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8695 break;
8696
4fbb74a6 8697 link_section = section_headers + section->sh_link;
08d8fa11 8698 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8699
4fbb74a6 8700 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8701 break;
8702
252b5132
RH		 8703 found = 1;
8704
ba5cdace 8705 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 8706 if (symbols == NULL)
8707 break;
252b5132 8708
4fbb74a6 8709 string_sec = section_headers + link_section->sh_link;
252b5132 8710
3f5e193b
NC		 8711 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8712 string_sec->sh_size,
8713 _("version string table"));
a6e9f9df 8714 if (!strtab)
0429c154
MS		 8715 {
8716 free (symbols);
8717 break;
8718 }
252b5132
RH		 8719
8720 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8721 SECTION_NAME (section), total);
8722
8723 printf (_(" Addr: "));
8724 printf_vma (section->sh_addr);
72de5009 8725 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8726 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8727 SECTION_NAME (link_section));
8728
d3ba0551
AM		 8729 off = offset_from_vma (file,
8730 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8731 total * sizeof (short));
3f5e193b
NC		 8732 edata = (unsigned char *) get_data (NULL, file, off, total,
8733 sizeof (short),
8734 _("version symbol data"));
a6e9f9df
AM		 8735 if (!edata)
8736 {
8737 free (strtab);
0429c154 8738 free (symbols);
a6e9f9df
AM		 8739 break;
8740 }
252b5132 8741
3f5e193b 8742 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8743
8744 for (cnt = total; cnt --;)
b34976b6
AM		 8745 data[cnt] = byte_get (edata + cnt * sizeof (short),
8746 sizeof (short));
252b5132
RH		 8747
8748 free (edata);
8749
8750 for (cnt = 0; cnt < total; cnt += 4)
8751 {
8752 int j, nn;
00d93f34 8753 int check_def, check_need;
2cf0635d 8754 char * name;
252b5132
RH		 8755
8756 printf (" %03x:", cnt);
8757
8758 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8759 switch (data[cnt + j])
252b5132
RH		 8760 {
8761 case 0:
8762 fputs (_(" 0 (*local*) "), stdout);
8763 break;
8764
8765 case 1:
8766 fputs (_(" 1 (*global*) "), stdout);
8767 break;
8768
8769 default:
c244d050
NC		 8770 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8771 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8772
dd24e3da 8773 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 8774 array, break to avoid an out-of-bounds read. */
8775 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 8776 {
8777 warn (_("invalid index into symbol array\n"));
8778 break;
8779 }
8780
00d93f34
JJ		 8781 check_def = 1;
8782 check_need = 1;
4fbb74a6
AM		 8783 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8784 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8785 != SHT_NOBITS)
252b5132 8786 {
b34976b6 8787 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8788 check_def = 0;
8789 else
8790 check_need = 0;
252b5132 8791 }
00d93f34
JJ		 8792
8793 if (check_need
b34976b6 8794 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8795 {
b34976b6
AM		 8796 Elf_Internal_Verneed ivn;
8797 unsigned long offset;
252b5132 8798
d93f0186
NC		 8799 offset = offset_from_vma
8800 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8801 sizeof (Elf_External_Verneed));
252b5132 8802
b34976b6 8803 do
252b5132 8804 {
b34976b6
AM		 8805 Elf_Internal_Vernaux ivna;
8806 Elf_External_Verneed evn;
8807 Elf_External_Vernaux evna;
8808 unsigned long a_off;
252b5132 8809
59245841
NC		 8810 if (get_data (&evn, file, offset, sizeof (evn), 1,
8811 _("version need")) == NULL)
8812 break;
8813
252b5132
RH		 8814 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8815 ivn.vn_next = BYTE_GET (evn.vn_next);
8816
8817 a_off = offset + ivn.vn_aux;
8818
8819 do
8820 {
59245841
NC		 8821 if (get_data (&evna, file, a_off, sizeof (evna),
8822 1, _("version need aux (2)")) == NULL)
8823 {
8824 ivna.vna_next = 0;
8825 ivna.vna_other = 0;
8826 }
8827 else
8828 {
8829 ivna.vna_next = BYTE_GET (evna.vna_next);
8830 ivna.vna_other = BYTE_GET (evna.vna_other);
8831 }
252b5132
RH		 8832
8833 a_off += ivna.vna_next;
8834 }
b34976b6 8835 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8836 && ivna.vna_next != 0);
8837
b34976b6 8838 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8839 {
8840 ivna.vna_name = BYTE_GET (evna.vna_name);
8841
54806181
AM		 8842 if (ivna.vna_name >= string_sec->sh_size)
8843 name = _("*invalid*");
8844 else
8845 name = strtab + ivna.vna_name;
252b5132 8846 nn += printf ("(%s%-*s",
16062207
ILT		 8847 name,
8848 12 - (int) strlen (name),
252b5132 8849 ")");
00d93f34 8850 check_def = 0;
252b5132
RH		 8851 break;
8852 }
8853
8854 offset += ivn.vn_next;
8855 }
8856 while (ivn.vn_next);
8857 }
00d93f34 8858
b34976b6
AM		 8859 if (check_def && data[cnt + j] != 0x8001
8860 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8861 {
b34976b6
AM		 8862 Elf_Internal_Verdef ivd;
8863 Elf_External_Verdef evd;
8864 unsigned long offset;
252b5132 8865
d93f0186
NC		 8866 offset = offset_from_vma
8867 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8868 sizeof evd);
252b5132
RH		 8869
8870 do
8871 {
59245841
NC		 8872 if (get_data (&evd, file, offset, sizeof (evd), 1,
8873 _("version def")) == NULL)
8874 {
8875 ivd.vd_next = 0;
8876 ivd.vd_ndx = 0;
8877 }
8878 else
8879 {
8880 ivd.vd_next = BYTE_GET (evd.vd_next);
8881 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8882 }
252b5132
RH		 8883
8884 offset += ivd.vd_next;
8885 }
c244d050 8886 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8887 && ivd.vd_next != 0);
8888
c244d050 8889 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8890 {
b34976b6
AM		 8891 Elf_External_Verdaux evda;
8892 Elf_Internal_Verdaux ivda;
252b5132
RH		 8893
8894 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8895
59245841
NC		 8896 if (get_data (&evda, file,
8897 offset - ivd.vd_next + ivd.vd_aux,
8898 sizeof (evda), 1,
8899 _("version def aux")) == NULL)
8900 break;
252b5132
RH		 8901
8902 ivda.vda_name = BYTE_GET (evda.vda_name);
8903
54806181
AM		 8904 if (ivda.vda_name >= string_sec->sh_size)
8905 name = _("*invalid*");
8906 else
8907 name = strtab + ivda.vda_name;
252b5132 8908 nn += printf ("(%s%-*s",
16062207
ILT		 8909 name,
8910 12 - (int) strlen (name),
252b5132
RH		 8911 ")");
8912 }
8913 }
8914
8915 if (nn < 18)
8916 printf ("%*c", 18 - nn, ' ');
8917 }
8918
8919 putchar ('\n');
8920 }
8921
8922 free (data);
8923 free (strtab);
8924 free (symbols);
8925 }
8926 break;
103f02d3 8927
252b5132
RH		 8928 default:
8929 break;
8930 }
8931 }
8932
8933 if (! found)
8934 printf (_("\nNo version information found in this file.\n"));
8935
8936 return 1;
8937}
8938
d1133906 8939static const char *
d3ba0551 8940get_symbol_binding (unsigned int binding)
252b5132 8941{
b34976b6 8942 static char buff[32];
252b5132
RH		 8943
8944 switch (binding)
8945 {
b34976b6
AM		 8946 case STB_LOCAL: return "LOCAL";
8947 case STB_GLOBAL: return "GLOBAL";
8948 case STB_WEAK: return "WEAK";
252b5132
RH		 8949 default:
8950 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8951 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8952 binding);
252b5132 8953 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8954 {
8955 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8956 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8957 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8958 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8959 return "UNIQUE";
8960 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8961 }
252b5132 8962 else
e9e44622 8963 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8964 return buff;
8965 }
8966}
8967
d1133906 8968static const char *
d3ba0551 8969get_symbol_type (unsigned int type)
252b5132 8970{
b34976b6 8971 static char buff[32];
252b5132
RH		 8972
8973 switch (type)
8974 {
b34976b6
AM		 8975 case STT_NOTYPE: return "NOTYPE";
8976 case STT_OBJECT: return "OBJECT";
8977 case STT_FUNC: return "FUNC";
8978 case STT_SECTION: return "SECTION";
8979 case STT_FILE: return "FILE";
8980 case STT_COMMON: return "COMMON";
8981 case STT_TLS: return "TLS";
15ab5209
DB		 8982 case STT_RELC: return "RELC";
8983 case STT_SRELC: return "SRELC";
252b5132
RH		 8984 default:
8985 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8986 {
8987 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8988 return "THUMB_FUNC";
8989
351b4b40 8990 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8991 return "REGISTER";
8992
8993 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8994 return "PARISC_MILLI";
8995
e9e44622 8996 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8997 }
252b5132 8998 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8999 {
9000 if (elf_header.e_machine == EM_PARISC)
9001 {
9002 if (type == STT_HP_OPAQUE)
9003 return "HP_OPAQUE";
9004 if (type == STT_HP_STUB)
9005 return "HP_STUB";
9006 }
9007
d8045f23 9008 if (type == STT_GNU_IFUNC
9c55345c 9009 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9010 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9011 /* GNU is still using the default value 0. */
d8045f23
NC		 9012 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9013 return "IFUNC";
9014
e9e44622 9015 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9016 }
252b5132 9017 else
e9e44622 9018 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9019 return buff;
9020 }
9021}
9022
d1133906 9023static const char *
d3ba0551 9024get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9025{
9026 switch (visibility)
9027 {
b34976b6
AM		 9028 case STV_DEFAULT: return "DEFAULT";
9029 case STV_INTERNAL: return "INTERNAL";
9030 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9031 case STV_PROTECTED: return "PROTECTED";
9032 default: abort ();
9033 }
9034}
9035
5e2b0d47
NC		 9036static const char *
9037get_mips_symbol_other (unsigned int other)
9038{
9039 switch (other)
9040 {
df58fc94
RS		 9041 case STO_OPTIONAL:
9042 return "OPTIONAL";
9043 case STO_MIPS_PLT:
9044 return "MIPS PLT";
9045 case STO_MIPS_PIC:
9046 return "MIPS PIC";
9047 case STO_MICROMIPS:
9048 return "MICROMIPS";
9049 case STO_MICROMIPS | STO_MIPS_PIC:
9050 return "MICROMIPS, MIPS PIC";
9051 case STO_MIPS16:
9052 return "MIPS16";
9053 default:
9054 return NULL;
5e2b0d47
NC		 9055 }
9056}
9057
28f997cf
TG		 9058static const char *
9059get_ia64_symbol_other (unsigned int other)
9060{
9061 if (is_ia64_vms ())
9062 {
9063 static char res[32];
9064
9065 res[0] = 0;
9066
9067 /* Function types is for images and .STB files only. */
9068 switch (elf_header.e_type)
9069 {
9070 case ET_DYN:
9071 case ET_EXEC:
9072 switch (VMS_ST_FUNC_TYPE (other))
9073 {
9074 case VMS_SFT_CODE_ADDR:
9075 strcat (res, " CA");
9076 break;
9077 case VMS_SFT_SYMV_IDX:
9078 strcat (res, " VEC");
9079 break;
9080 case VMS_SFT_FD:
9081 strcat (res, " FD");
9082 break;
9083 case VMS_SFT_RESERVE:
9084 strcat (res, " RSV");
9085 break;
9086 default:
9087 abort ();
9088 }
9089 break;
9090 default:
9091 break;
9092 }
9093 switch (VMS_ST_LINKAGE (other))
9094 {
9095 case VMS_STL_IGNORE:
9096 strcat (res, " IGN");
9097 break;
9098 case VMS_STL_RESERVE:
9099 strcat (res, " RSV");
9100 break;
9101 case VMS_STL_STD:
9102 strcat (res, " STD");
9103 break;
9104 case VMS_STL_LNK:
9105 strcat (res, " LNK");
9106 break;
9107 default:
9108 abort ();
9109 }
9110
9111 if (res[0] != 0)
9112 return res + 1;
9113 else
9114 return res;
9115 }
9116 return NULL;
9117}
9118
5e2b0d47
NC		 9119static const char *
9120get_symbol_other (unsigned int other)
9121{
9122 const char * result = NULL;
9123 static char buff [32];
9124
9125 if (other == 0)
9126 return "";
9127
9128 switch (elf_header.e_machine)
9129 {
9130 case EM_MIPS:
9131 result = get_mips_symbol_other (other);
28f997cf
TG		 9132 break;
9133 case EM_IA_64:
9134 result = get_ia64_symbol_other (other);
9135 break;
5e2b0d47
NC		 9136 default:
9137 break;
9138 }
9139
9140 if (result)
9141 return result;
9142
9143 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9144 return buff;
9145}
9146
d1133906 9147static const char *
d3ba0551 9148get_symbol_index_type (unsigned int type)
252b5132 9149{
b34976b6 9150 static char buff[32];
5cf1065c 9151
252b5132
RH		 9152 switch (type)
9153 {
b34976b6
AM		 9154 case SHN_UNDEF: return "UND";
9155 case SHN_ABS: return "ABS";
9156 case SHN_COMMON: return "COM";
252b5132 9157 default:
9ce701e2
L		 9158 if (type == SHN_IA_64_ANSI_COMMON
9159 && elf_header.e_machine == EM_IA_64
9160 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9161 return "ANSI_COM";
8a9036a4 9162 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9163 || elf_header.e_machine == EM_L1OM
9164 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9165 && type == SHN_X86_64_LCOMMON)
9166 return "LARGE_COM";
ac145307
BS		 9167 else if ((type == SHN_MIPS_SCOMMON
9168 && elf_header.e_machine == EM_MIPS)
9169 || (type == SHN_TIC6X_SCOMMON
9170 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9171 return "SCOM";
9172 else if (type == SHN_MIPS_SUNDEFINED
9173 && elf_header.e_machine == EM_MIPS)
9174 return "SUND";
9ce701e2 9175 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9176 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9177 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9178 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9179 else if (type >= SHN_LORESERVE)
9180 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L		 9181 else if (type >= elf_header.e_shnum)
9182 sprintf (buff, "bad section index[%3d]", type);
252b5132 9183 else
232e7cb8 9184 sprintf (buff, "%3d", type);
5cf1065c 9185 break;
252b5132 9186 }
5cf1065c
NC		 9187
9188 return buff;
252b5132
RH		 9189}
9190
66543521 9191static bfd_vma *
2cf0635d 9192get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9193{
2cf0635d
NC		 9194 unsigned char * e_data;
9195 bfd_vma * i_data;
252b5132 9196
3f5e193b 9197 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9198
9199 if (e_data == NULL)
9200 {
9201 error (_("Out of memory\n"));
9202 return NULL;
9203 }
9204
66543521 9205 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9206 {
9207 error (_("Unable to read in dynamic data\n"));
9208 return NULL;
9209 }
9210
3f5e193b 9211 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9212
9213 if (i_data == NULL)
9214 {
9215 error (_("Out of memory\n"));
9216 free (e_data);
9217 return NULL;
9218 }
9219
9220 while (number--)
66543521 9221 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9222
9223 free (e_data);
9224
9225 return i_data;
9226}
9227
6bd1a22c
L		 9228static void
9229print_dynamic_symbol (bfd_vma si, unsigned long hn)
9230{
2cf0635d 9231 Elf_Internal_Sym * psym;
6bd1a22c
L		 9232 int n;
9233
9234 psym = dynamic_symbols + si;
9235
9236 n = print_vma (si, DEC_5);
9237 if (n < 5)
9238 fputs (" " + n, stdout);
9239 printf (" %3lu: ", hn);
9240 print_vma (psym->st_value, LONG_HEX);
9241 putchar (' ');
9242 print_vma (psym->st_size, DEC_5);
9243
f4be36b3
AM		 9244 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9245 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9246 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9247 /* Check to see if any other bits in the st_other field are set.
9248 Note - displaying this information disrupts the layout of the
9249 table being generated, but for the moment this case is very
9250 rare. */
9251 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9252 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9253 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9254 if (VALID_DYNAMIC_NAME (psym->st_name))
9255 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9256 else
2b692964 9257 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9258 putchar ('\n');
9259}
9260
e3c8793a 9261/* Dump the symbol table. */
252b5132 9262static int
2cf0635d 9263process_symbol_table (FILE * file)
252b5132 9264{
2cf0635d 9265 Elf_Internal_Shdr * section;
66543521
AM		 9266 bfd_vma nbuckets = 0;
9267 bfd_vma nchains = 0;
2cf0635d
NC		 9268 bfd_vma * buckets = NULL;
9269 bfd_vma * chains = NULL;
fdc90cb4 9270 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9271 bfd_vma * gnubuckets = NULL;
9272 bfd_vma * gnuchains = NULL;
6bd1a22c 9273 bfd_vma gnusymidx = 0;
252b5132 9274
2c610e4b 9275 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9276 return 1;
9277
6bd1a22c
L		 9278 if (dynamic_info[DT_HASH]
9279 && (do_histogram
2c610e4b
L		 9280 || (do_using_dynamic
9281 && !do_dyn_syms
9282 && dynamic_strings != NULL)))
252b5132 9283 {
66543521
AM		 9284 unsigned char nb[8];
9285 unsigned char nc[8];
9286 int hash_ent_size = 4;
9287
9288 if ((elf_header.e_machine == EM_ALPHA
9289 || elf_header.e_machine == EM_S390
9290 || elf_header.e_machine == EM_S390_OLD)
9291 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9292 hash_ent_size = 8;
9293
fb52b2f4
NC		 9294 if (fseek (file,
9295 (archive_file_offset
9296 + offset_from_vma (file, dynamic_info[DT_HASH],
9297 sizeof nb + sizeof nc)),
d93f0186 9298 SEEK_SET))
252b5132 9299 {
591a748a 9300 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9301 goto no_hash;
252b5132
RH		 9302 }
9303
66543521 9304 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9305 {
9306 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9307 goto no_hash;
252b5132
RH		 9308 }
9309
66543521 9310 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9311 {
9312 error (_("Failed to read in number of chains\n"));
d3a44ec6 9313 goto no_hash;
252b5132
RH		 9314 }
9315
66543521
AM		 9316 nbuckets = byte_get (nb, hash_ent_size);
9317 nchains = byte_get (nc, hash_ent_size);
252b5132 9318
66543521
AM		 9319 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9320 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9321
d3a44ec6 9322 no_hash:
252b5132 9323 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9324 {
9325 if (do_using_dynamic)
9326 return 0;
9327 free (buckets);
9328 free (chains);
9329 buckets = NULL;
9330 chains = NULL;
9331 nbuckets = 0;
9332 nchains = 0;
9333 }
252b5132
RH		 9334 }
9335
6bd1a22c
L		 9336 if (dynamic_info_DT_GNU_HASH
9337 && (do_histogram
2c610e4b
L		 9338 || (do_using_dynamic
9339 && !do_dyn_syms
9340 && dynamic_strings != NULL)))
252b5132 9341 {
6bd1a22c
L		 9342 unsigned char nb[16];
9343 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9344 bfd_vma buckets_vma;
9345
9346 if (fseek (file,
9347 (archive_file_offset
9348 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9349 sizeof nb)),
9350 SEEK_SET))
9351 {
9352 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9353 goto no_gnu_hash;
6bd1a22c 9354 }
252b5132 9355
6bd1a22c
L		 9356 if (fread (nb, 16, 1, file) != 1)
9357 {
9358 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9359 goto no_gnu_hash;
6bd1a22c
L		 9360 }
9361
9362 ngnubuckets = byte_get (nb, 4);
9363 gnusymidx = byte_get (nb + 4, 4);
9364 bitmaskwords = byte_get (nb + 8, 4);
9365 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9366 if (is_32bit_elf)
6bd1a22c 9367 buckets_vma += bitmaskwords * 4;
f7a99963 9368 else
6bd1a22c 9369 buckets_vma += bitmaskwords * 8;
252b5132 9370
6bd1a22c
L		 9371 if (fseek (file,
9372 (archive_file_offset
9373 + offset_from_vma (file, buckets_vma, 4)),
9374 SEEK_SET))
252b5132 9375 {
6bd1a22c 9376 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9377 goto no_gnu_hash;
6bd1a22c
L		 9378 }
9379
9380 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9381
6bd1a22c 9382 if (gnubuckets == NULL)
d3a44ec6 9383 goto no_gnu_hash;
6bd1a22c
L		 9384
9385 for (i = 0; i < ngnubuckets; i++)
9386 if (gnubuckets[i] != 0)
9387 {
9388 if (gnubuckets[i] < gnusymidx)
9389 return 0;
9390
9391 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9392 maxchain = gnubuckets[i];
9393 }
9394
9395 if (maxchain == 0xffffffff)
d3a44ec6 9396 goto no_gnu_hash;
6bd1a22c
L		 9397
9398 maxchain -= gnusymidx;
9399
9400 if (fseek (file,
9401 (archive_file_offset
9402 + offset_from_vma (file, buckets_vma
9403 + 4 * (ngnubuckets + maxchain), 4)),
9404 SEEK_SET))
9405 {
9406 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9407 goto no_gnu_hash;
6bd1a22c
L		 9408 }
9409
9410 do
9411 {
9412 if (fread (nb, 4, 1, file) != 1)
252b5132 9413 {
6bd1a22c 9414 error (_("Failed to determine last chain length\n"));
d3a44ec6 9415 goto no_gnu_hash;
6bd1a22c 9416 }
252b5132 9417
6bd1a22c 9418 if (maxchain + 1 == 0)
d3a44ec6 9419 goto no_gnu_hash;
252b5132 9420
6bd1a22c
L		 9421 ++maxchain;
9422 }
9423 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9424
6bd1a22c
L		 9425 if (fseek (file,
9426 (archive_file_offset
9427 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9428 SEEK_SET))
9429 {
9430 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9431 goto no_gnu_hash;
6bd1a22c
L		 9432 }
9433
9434 gnuchains = get_dynamic_data (file, maxchain, 4);
9435
d3a44ec6 9436 no_gnu_hash:
6bd1a22c 9437 if (gnuchains == NULL)
d3a44ec6
JJ		 9438 {
9439 free (gnubuckets);
d3a44ec6
JJ		 9440 gnubuckets = NULL;
9441 ngnubuckets = 0;
f64fddf1
NC		 9442 if (do_using_dynamic)
9443 return 0;
d3a44ec6 9444 }
6bd1a22c
L		 9445 }
9446
9447 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9448 && do_syms
9449 && do_using_dynamic
9450 && dynamic_strings != NULL)
9451 {
9452 unsigned long hn;
9453
9454 if (dynamic_info[DT_HASH])
9455 {
9456 bfd_vma si;
9457
9458 printf (_("\nSymbol table for image:\n"));
9459 if (is_32bit_elf)
9460 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9461 else
9462 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9463
9464 for (hn = 0; hn < nbuckets; hn++)
9465 {
9466 if (! buckets[hn])
9467 continue;
9468
9469 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9470 print_dynamic_symbol (si, hn);
252b5132
RH		 9471 }
9472 }
6bd1a22c
L		 9473
9474 if (dynamic_info_DT_GNU_HASH)
9475 {
9476 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9477 if (is_32bit_elf)
9478 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9479 else
9480 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9481
9482 for (hn = 0; hn < ngnubuckets; ++hn)
9483 if (gnubuckets[hn] != 0)
9484 {
9485 bfd_vma si = gnubuckets[hn];
9486 bfd_vma off = si - gnusymidx;
9487
9488 do
9489 {
9490 print_dynamic_symbol (si, hn);
9491 si++;
9492 }
9493 while ((gnuchains[off++] & 1) == 0);
9494 }
9495 }
252b5132 9496 }
2c610e4b 9497 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9498 {
b34976b6 9499 unsigned int i;
252b5132
RH		 9500
9501 for (i = 0, section = section_headers;
9502 i < elf_header.e_shnum;
9503 i++, section++)
9504 {
b34976b6 9505 unsigned int si;
2cf0635d 9506 char * strtab = NULL;
c256ffe7 9507 unsigned long int strtab_size = 0;
2cf0635d
NC		 9508 Elf_Internal_Sym * symtab;
9509 Elf_Internal_Sym * psym;
ba5cdace 9510 unsigned long num_syms;
252b5132 9511
2c610e4b
L		 9512 if ((section->sh_type != SHT_SYMTAB
9513 && section->sh_type != SHT_DYNSYM)
9514 || (!do_syms
9515 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9516 continue;
9517
dd24e3da
NC		 9518 if (section->sh_entsize == 0)
9519 {
9520 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9521 SECTION_NAME (section));
9522 continue;
9523 }
9524
252b5132
RH		 9525 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9526 SECTION_NAME (section),
9527 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9528
f7a99963 9529 if (is_32bit_elf)
ca47b30c 9530 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9531 else
ca47b30c 9532 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9533
ba5cdace 9534 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9535 if (symtab == NULL)
9536 continue;
9537
9538 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9539 {
9540 strtab = string_table;
9541 strtab_size = string_table_length;
9542 }
4fbb74a6 9543 else if (section->sh_link < elf_header.e_shnum)
252b5132 9544 {
2cf0635d 9545 Elf_Internal_Shdr * string_sec;
252b5132 9546
4fbb74a6 9547 string_sec = section_headers + section->sh_link;
252b5132 9548
3f5e193b
NC		 9549 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9550 1, string_sec->sh_size,
9551 _("string table"));
c256ffe7 9552 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9553 }
9554
ba5cdace 9555 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9556 {
5e220199 9557 printf ("%6d: ", si);
f7a99963
NC		 9558 print_vma (psym->st_value, LONG_HEX);
9559 putchar (' ');
9560 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9561 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9562 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9563 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9564 /* Check to see if any other bits in the st_other field are set.
9565 Note - displaying this information disrupts the layout of the
9566 table being generated, but for the moment this case is very rare. */
9567 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9568 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9569 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9570 print_symbol (25, psym->st_name < strtab_size
2b692964 9571 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9572
59245841
NC		 9573 if (section->sh_type == SHT_DYNSYM
9574 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9575 {
b34976b6
AM		 9576 unsigned char data[2];
9577 unsigned short vers_data;
9578 unsigned long offset;
9579 int is_nobits;
9580 int check_def;
252b5132 9581
d93f0186
NC		 9582 offset = offset_from_vma
9583 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9584 sizeof data + si * sizeof (vers_data));
252b5132 9585
59245841
NC		 9586 if (get_data (&data, file, offset + si * sizeof (vers_data),
9587 sizeof (data), 1, _("version data")) == NULL)
9588 break;
252b5132
RH		 9589
9590 vers_data = byte_get (data, 2);
9591
4fbb74a6
AM		 9592 is_nobits = (psym->st_shndx < elf_header.e_shnum
9593 && section_headers[psym->st_shndx].sh_type
c256ffe7 9594 == SHT_NOBITS);
252b5132
RH		 9595
9596 check_def = (psym->st_shndx != SHN_UNDEF);
9597
c244d050 9598 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9599 {
b34976b6 9600 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9601 && (is_nobits || ! check_def))
252b5132 9602 {
b34976b6
AM		 9603 Elf_External_Verneed evn;
9604 Elf_Internal_Verneed ivn;
9605 Elf_Internal_Vernaux ivna;
252b5132
RH		 9606
9607 /* We must test both. */
d93f0186
NC		 9608 offset = offset_from_vma
9609 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9610 sizeof evn);
252b5132 9611
252b5132
RH		 9612 do
9613 {
b34976b6 9614 unsigned long vna_off;
252b5132 9615
59245841
NC		 9616 if (get_data (&evn, file, offset, sizeof (evn), 1,
9617 _("version need")) == NULL)
9618 {
9619 ivna.vna_next = 0;
9620 ivna.vna_other = 0;
9621 ivna.vna_name = 0;
9622 break;
9623 }
dd27201e
L		 9624
9625 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9626 ivn.vn_next = BYTE_GET (evn.vn_next);
9627
252b5132
RH		 9628 vna_off = offset + ivn.vn_aux;
9629
9630 do
9631 {
b34976b6 9632 Elf_External_Vernaux evna;
252b5132 9633
59245841
NC		 9634 if (get_data (&evna, file, vna_off,
9635 sizeof (evna), 1,
9636 _("version need aux (3)")) == NULL)
9637 {
9638 ivna.vna_next = 0;
9639 ivna.vna_other = 0;
9640 ivna.vna_name = 0;
9641 }
9642 else
9643 {
9644 ivna.vna_other = BYTE_GET (evna.vna_other);
9645 ivna.vna_next = BYTE_GET (evna.vna_next);
9646 ivna.vna_name = BYTE_GET (evna.vna_name);
9647 }
252b5132
RH		 9648
9649 vna_off += ivna.vna_next;
9650 }
9651 while (ivna.vna_other != vers_data
9652 && ivna.vna_next != 0);
9653
9654 if (ivna.vna_other == vers_data)
9655 break;
9656
9657 offset += ivn.vn_next;
9658 }
9659 while (ivn.vn_next != 0);
9660
9661 if (ivna.vna_other == vers_data)
9662 {
9663 printf ("@%s (%d)",
c256ffe7 9664 ivna.vna_name < strtab_size
2b692964 9665 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9666 ivna.vna_other);
252b5132
RH		 9667 check_def = 0;
9668 }
9669 else if (! is_nobits)
591a748a 9670 error (_("bad dynamic symbol\n"));
252b5132
RH		 9671 else
9672 check_def = 1;
9673 }
9674
9675 if (check_def)
9676 {
00d93f34 9677 if (vers_data != 0x8001
b34976b6 9678 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9679 {
b34976b6
AM		 9680 Elf_Internal_Verdef ivd;
9681 Elf_Internal_Verdaux ivda;
9682 Elf_External_Verdaux evda;
91d6fa6a 9683 unsigned long off;
252b5132 9684
91d6fa6a 9685 off = offset_from_vma
d93f0186
NC		 9686 (file,
9687 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9688 sizeof (Elf_External_Verdef));
252b5132
RH		 9689
9690 do
9691 {
b34976b6 9692 Elf_External_Verdef evd;
252b5132 9693
59245841
NC		 9694 if (get_data (&evd, file, off, sizeof (evd),
9695 1, _("version def")) == NULL)
9696 {
9697 ivd.vd_ndx = 0;
9698 ivd.vd_aux = 0;
9699 ivd.vd_next = 0;
9700 }
9701 else
9702 {
9703 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9704 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9705 ivd.vd_next = BYTE_GET (evd.vd_next);
9706 }
252b5132 9707
91d6fa6a 9708 off += ivd.vd_next;
252b5132 9709 }
c244d050 9710 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9711 && ivd.vd_next != 0);
9712
91d6fa6a
NC		 9713 off -= ivd.vd_next;
9714 off += ivd.vd_aux;
252b5132 9715
59245841
NC		 9716 if (get_data (&evda, file, off, sizeof (evda),
9717 1, _("version def aux")) == NULL)
9718 break;
252b5132
RH		 9719
9720 ivda.vda_name = BYTE_GET (evda.vda_name);
9721
9722 if (psym->st_name != ivda.vda_name)
c244d050 9723 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9724 ? "@%s" : "@@%s",
c256ffe7 9725 ivda.vda_name < strtab_size
2b692964 9726 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9727 }
9728 }
9729 }
9730 }
9731
9732 putchar ('\n');
9733 }
9734
9735 free (symtab);
9736 if (strtab != string_table)
9737 free (strtab);
9738 }
9739 }
9740 else if (do_syms)
9741 printf
9742 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9743
9744 if (do_histogram && buckets != NULL)
9745 {
2cf0635d
NC		 9746 unsigned long * lengths;
9747 unsigned long * counts;
66543521
AM		 9748 unsigned long hn;
9749 bfd_vma si;
9750 unsigned long maxlength = 0;
9751 unsigned long nzero_counts = 0;
9752 unsigned long nsyms = 0;
252b5132 9753
66543521
AM		 9754 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9755 (unsigned long) nbuckets);
252b5132
RH		 9756 printf (_(" Length Number %% of total Coverage\n"));
9757
3f5e193b 9758 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9759 if (lengths == NULL)
9760 {
591a748a 9761 error (_("Out of memory\n"));
252b5132
RH		 9762 return 0;
9763 }
9764 for (hn = 0; hn < nbuckets; ++hn)
9765 {
f7a99963 9766 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9767 {
b34976b6 9768 ++nsyms;
252b5132 9769 if (maxlength < ++lengths[hn])
b34976b6 9770 ++maxlength;
252b5132
RH		 9771 }
9772 }
9773
3f5e193b 9774 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9775 if (counts == NULL)
9776 {
591a748a 9777 error (_("Out of memory\n"));
252b5132
RH		 9778 return 0;
9779 }
9780
9781 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9782 ++counts[lengths[hn]];
252b5132 9783
103f02d3 9784 if (nbuckets > 0)
252b5132 9785 {
66543521
AM		 9786 unsigned long i;
9787 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9788 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9789 for (i = 1; i <= maxlength; ++i)
103f02d3 9790 {
66543521
AM		 9791 nzero_counts += counts[i] * i;
9792 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9793 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9794 (nzero_counts * 100.0) / nsyms);
9795 }
252b5132
RH		 9796 }
9797
9798 free (counts);
9799 free (lengths);
9800 }
9801
9802 if (buckets != NULL)
9803 {
9804 free (buckets);
9805 free (chains);
9806 }
9807
d3a44ec6 9808 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9809 {
2cf0635d
NC		 9810 unsigned long * lengths;
9811 unsigned long * counts;
fdc90cb4
JJ		 9812 unsigned long hn;
9813 unsigned long maxlength = 0;
9814 unsigned long nzero_counts = 0;
9815 unsigned long nsyms = 0;
fdc90cb4 9816
3f5e193b 9817 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9818 if (lengths == NULL)
9819 {
591a748a 9820 error (_("Out of memory\n"));
fdc90cb4
JJ		 9821 return 0;
9822 }
9823
9824 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9825 (unsigned long) ngnubuckets);
9826 printf (_(" Length Number %% of total Coverage\n"));
9827
9828 for (hn = 0; hn < ngnubuckets; ++hn)
9829 if (gnubuckets[hn] != 0)
9830 {
9831 bfd_vma off, length = 1;
9832
6bd1a22c 9833 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9834 (gnuchains[off] & 1) == 0; ++off)
9835 ++length;
9836 lengths[hn] = length;
9837 if (length > maxlength)
9838 maxlength = length;
9839 nsyms += length;
9840 }
9841
3f5e193b 9842 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9843 if (counts == NULL)
9844 {
591a748a 9845 error (_("Out of memory\n"));
fdc90cb4
JJ		 9846 return 0;
9847 }
9848
9849 for (hn = 0; hn < ngnubuckets; ++hn)
9850 ++counts[lengths[hn]];
9851
9852 if (ngnubuckets > 0)
9853 {
9854 unsigned long j;
9855 printf (" 0 %-10lu (%5.1f%%)\n",
9856 counts[0], (counts[0] * 100.0) / ngnubuckets);
9857 for (j = 1; j <= maxlength; ++j)
9858 {
9859 nzero_counts += counts[j] * j;
9860 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9861 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9862 (nzero_counts * 100.0) / nsyms);
9863 }
9864 }
9865
9866 free (counts);
9867 free (lengths);
9868 free (gnubuckets);
9869 free (gnuchains);
9870 }
9871
252b5132
RH		 9872 return 1;
9873}
9874
9875static int
2cf0635d 9876process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9877{
b4c96d0d 9878 unsigned int i;
252b5132
RH		 9879
9880 if (dynamic_syminfo == NULL
9881 || !do_dynamic)
9882 /* No syminfo, this is ok. */
9883 return 1;
9884
9885 /* There better should be a dynamic symbol section. */
9886 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9887 return 0;
9888
9889 if (dynamic_addr)
9890 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9891 dynamic_syminfo_offset, dynamic_syminfo_nent);
9892
9893 printf (_(" Num: Name BoundTo Flags\n"));
9894 for (i = 0; i < dynamic_syminfo_nent; ++i)
9895 {
9896 unsigned short int flags = dynamic_syminfo[i].si_flags;
9897
31104126 9898 printf ("%4d: ", i);
d79b3d50
NC		 9899 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9900 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9901 else
2b692964 9902 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9903 putchar (' ');
252b5132
RH		 9904
9905 switch (dynamic_syminfo[i].si_boundto)
9906 {
9907 case SYMINFO_BT_SELF:
9908 fputs ("SELF ", stdout);
9909 break;
9910 case SYMINFO_BT_PARENT:
9911 fputs ("PARENT ", stdout);
9912 break;
9913 default:
9914 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9915 && dynamic_syminfo[i].si_boundto < dynamic_nent
9916 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9917 {
d79b3d50 9918 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9919 putchar (' ' );
9920 }
252b5132
RH		 9921 else
9922 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9923 break;
9924 }
9925
9926 if (flags & SYMINFO_FLG_DIRECT)
9927 printf (" DIRECT");
9928 if (flags & SYMINFO_FLG_PASSTHRU)
9929 printf (" PASSTHRU");
9930 if (flags & SYMINFO_FLG_COPY)
9931 printf (" COPY");
9932 if (flags & SYMINFO_FLG_LAZYLOAD)
9933 printf (" LAZYLOAD");
9934
9935 puts ("");
9936 }
9937
9938 return 1;
9939}
9940
cf13d699
NC		 9941/* Check to see if the given reloc needs to be handled in a target specific
9942 manner. If so then process the reloc and return TRUE otherwise return
9943 FALSE. */
09c11c86 9944
cf13d699
NC		 9945static bfd_boolean
9946target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9947 unsigned char * start,
9948 Elf_Internal_Sym * symtab)
252b5132 9949{
cf13d699 9950 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9951
cf13d699 9952 switch (elf_header.e_machine)
252b5132 9953 {
cf13d699
NC		 9954 case EM_MN10300:
9955 case EM_CYGNUS_MN10300:
9956 {
9957 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9958
cf13d699
NC		 9959 switch (reloc_type)
9960 {
9961 case 34: /* R_MN10300_ALIGN */
9962 return TRUE;
9963 case 33: /* R_MN10300_SYM_DIFF */
9964 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9965 return TRUE;
9966 case 1: /* R_MN10300_32 */
9967 case 2: /* R_MN10300_16 */
9968 if (saved_sym != NULL)
9969 {
9970 bfd_vma value;
252b5132 9971
cf13d699
NC		 9972 value = reloc->r_addend
9973 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9974 - saved_sym->st_value);
252b5132 9975
cf13d699 9976 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9977
cf13d699
NC		 9978 saved_sym = NULL;
9979 return TRUE;
9980 }
9981 break;
9982 default:
9983 if (saved_sym != NULL)
9984 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9985 break;
9986 }
9987 break;
9988 }
252b5132
RH		 9989 }
9990
cf13d699 9991 return FALSE;
252b5132
RH		 9992}
9993
aca88567
NC		 9994/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9995 DWARF debug sections. This is a target specific test. Note - we do not
9996 go through the whole including-target-headers-multiple-times route, (as
9997 we have already done with <elf/h8.h>) because this would become very
9998 messy and even then this function would have to contain target specific
9999 information (the names of the relocs instead of their numeric values).
10000 FIXME: This is not the correct way to solve this problem. The proper way
10001 is to have target specific reloc sizing and typing functions created by
10002 the reloc-macros.h header, in the same way that it already creates the
10003 reloc naming functions. */
10004
10005static bfd_boolean
10006is_32bit_abs_reloc (unsigned int reloc_type)
10007{
10008 switch (elf_header.e_machine)
10009 {
41e92641
NC		 10010 case EM_386:
10011 case EM_486:
10012 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 10013 case EM_68K:
10014 return reloc_type == 1; /* R_68K_32. */
10015 case EM_860:
10016 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10017 case EM_960:
10018 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10019 case EM_AARCH64:
10020 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10021 case EM_ALPHA:
137b6b5f 10022 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10023 case EM_ARC:
10024 return reloc_type == 1; /* R_ARC_32. */
10025 case EM_ARM:
10026 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10027 case EM_AVR_OLD:
aca88567
NC		 10028 case EM_AVR:
10029 return reloc_type == 1;
cfb8c092
NC		 10030 case EM_ADAPTEVA_EPIPHANY:
10031 return reloc_type == 3;
aca88567
NC		 10032 case EM_BLACKFIN:
10033 return reloc_type == 0x12; /* R_byte4_data. */
10034 case EM_CRIS:
10035 return reloc_type == 3; /* R_CRIS_32. */
10036 case EM_CR16:
10037 return reloc_type == 3; /* R_CR16_NUM32. */
10038 case EM_CRX:
10039 return reloc_type == 15; /* R_CRX_NUM32. */
10040 case EM_CYGNUS_FRV:
10041 return reloc_type == 1;
41e92641
NC		 10042 case EM_CYGNUS_D10V:
10043 case EM_D10V:
10044 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10045 case EM_CYGNUS_D30V:
10046 case EM_D30V:
10047 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10048 case EM_DLX:
10049 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10050 case EM_CYGNUS_FR30:
10051 case EM_FR30:
10052 return reloc_type == 3; /* R_FR30_32. */
10053 case EM_H8S:
10054 case EM_H8_300:
10055 case EM_H8_300H:
10056 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10057 case EM_IA_64:
10058 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10059 case EM_IP2K_OLD:
10060 case EM_IP2K:
10061 return reloc_type == 2; /* R_IP2K_32. */
10062 case EM_IQ2000:
10063 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10064 case EM_LATTICEMICO32:
10065 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10066 case EM_M32C_OLD:
aca88567
NC		 10067 case EM_M32C:
10068 return reloc_type == 3; /* R_M32C_32. */
10069 case EM_M32R:
10070 return reloc_type == 34; /* R_M32R_32_RELA. */
10071 case EM_MCORE:
10072 return reloc_type == 1; /* R_MCORE_ADDR32. */
10073 case EM_CYGNUS_MEP:
10074 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10075 case EM_METAG:
10076 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10077 case EM_MICROBLAZE:
10078 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10079 case EM_MIPS:
10080 return reloc_type == 2; /* R_MIPS_32. */
10081 case EM_MMIX:
10082 return reloc_type == 4; /* R_MMIX_32. */
10083 case EM_CYGNUS_MN10200:
10084 case EM_MN10200:
10085 return reloc_type == 1; /* R_MN10200_32. */
10086 case EM_CYGNUS_MN10300:
10087 case EM_MN10300:
10088 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10089 case EM_MOXIE:
10090 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10091 case EM_MSP430_OLD:
10092 case EM_MSP430:
10093 return reloc_type == 1; /* R_MSP43_32. */
10094 case EM_MT:
10095 return reloc_type == 2; /* R_MT_32. */
3e0873ac 10096 case EM_ALTERA_NIOS2:
36591ba1 10097 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 10098 case EM_NIOS32:
10099 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 10100 case EM_OPENRISC:
10101 case EM_OR32:
10102 return reloc_type == 1; /* R_OR32_32. */
aca88567 10103 case EM_PARISC:
5fda8eca
NC		 10104 return (reloc_type == 1 /* R_PARISC_DIR32. */
10105 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10106 case EM_PJ:
10107 case EM_PJ_OLD:
10108 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10109 case EM_PPC64:
10110 return reloc_type == 1; /* R_PPC64_ADDR32. */
10111 case EM_PPC:
10112 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10113 case EM_RL78:
10114 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10115 case EM_RX:
10116 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10117 case EM_S370:
10118 return reloc_type == 1; /* R_I370_ADDR31. */
10119 case EM_S390_OLD:
10120 case EM_S390:
10121 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10122 case EM_SCORE:
10123 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10124 case EM_SH:
10125 return reloc_type == 1; /* R_SH_DIR32. */
10126 case EM_SPARC32PLUS:
10127 case EM_SPARCV9:
10128 case EM_SPARC:
10129 return reloc_type == 3 /* R_SPARC_32. */
10130 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10131 case EM_SPU:
10132 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10133 case EM_TI_C6000:
10134 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10135 case EM_TILEGX:
10136 return reloc_type == 2; /* R_TILEGX_32. */
10137 case EM_TILEPRO:
10138 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10139 case EM_CYGNUS_V850:
10140 case EM_V850:
10141 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10142 case EM_V800:
10143 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10144 case EM_VAX:
10145 return reloc_type == 1; /* R_VAX_32. */
10146 case EM_X86_64:
8a9036a4 10147 case EM_L1OM:
7a9068fe 10148 case EM_K1OM:
aca88567 10149 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10150 case EM_XC16X:
10151 case EM_C166:
10152 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10153 case EM_XGATE:
10154 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10155 case EM_XSTORMY16:
10156 return reloc_type == 1; /* R_XSTROMY16_32. */
10157 case EM_XTENSA_OLD:
10158 case EM_XTENSA:
10159 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10160 default:
10161 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10162 elf_header.e_machine);
10163 abort ();
10164 }
10165}
10166
10167/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10168 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10169
10170static bfd_boolean
10171is_32bit_pcrel_reloc (unsigned int reloc_type)
10172{
10173 switch (elf_header.e_machine)
10174 {
41e92641
NC		 10175 case EM_386:
10176 case EM_486:
3e0873ac 10177 return reloc_type == 2; /* R_386_PC32. */
aca88567 10178 case EM_68K:
3e0873ac 10179 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10180 case EM_AARCH64:
10181 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10182 case EM_ADAPTEVA_EPIPHANY:
10183 return reloc_type == 6;
aca88567
NC		 10184 case EM_ALPHA:
10185 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10186 case EM_ARM:
3e0873ac 10187 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10188 case EM_MICROBLAZE:
10189 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 10190 case EM_PARISC:
85acf597 10191 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10192 case EM_PPC:
10193 return reloc_type == 26; /* R_PPC_REL32. */
10194 case EM_PPC64:
3e0873ac 10195 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10196 case EM_S390_OLD:
10197 case EM_S390:
3e0873ac 10198 return reloc_type == 5; /* R_390_PC32. */
aca88567 10199 case EM_SH:
3e0873ac 10200 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10201 case EM_SPARC32PLUS:
10202 case EM_SPARCV9:
10203 case EM_SPARC:
3e0873ac 10204 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10205 case EM_SPU:
10206 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10207 case EM_TILEGX:
10208 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10209 case EM_TILEPRO:
10210 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10211 case EM_X86_64:
8a9036a4 10212 case EM_L1OM:
7a9068fe 10213 case EM_K1OM:
3e0873ac 10214 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10215 case EM_XTENSA_OLD:
10216 case EM_XTENSA:
10217 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10218 default:
10219 /* Do not abort or issue an error message here. Not all targets use
10220 pc-relative 32-bit relocs in their DWARF debug information and we
10221 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10222 more helpful warning message will be generated by apply_relocations
10223 anyway, so just return. */
aca88567
NC		 10224 return FALSE;
10225 }
10226}
10227
10228/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10229 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10230
10231static bfd_boolean
10232is_64bit_abs_reloc (unsigned int reloc_type)
10233{
10234 switch (elf_header.e_machine)
10235 {
a06ea964
NC		 10236 case EM_AARCH64:
10237 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10238 case EM_ALPHA:
10239 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10240 case EM_IA_64:
10241 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10242 case EM_PARISC:
10243 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10244 case EM_PPC64:
10245 return reloc_type == 38; /* R_PPC64_ADDR64. */
10246 case EM_SPARC32PLUS:
10247 case EM_SPARCV9:
10248 case EM_SPARC:
10249 return reloc_type == 54; /* R_SPARC_UA64. */
10250 case EM_X86_64:
8a9036a4 10251 case EM_L1OM:
7a9068fe 10252 case EM_K1OM:
aca88567 10253 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10254 case EM_S390_OLD:
10255 case EM_S390:
aa137e4d
NC		 10256 return reloc_type == 22; /* R_S390_64. */
10257 case EM_TILEGX:
10258 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10259 case EM_MIPS:
aa137e4d 10260 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10261 default:
10262 return FALSE;
10263 }
10264}
10265
85acf597
RH		 10266/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10267 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10268
10269static bfd_boolean
10270is_64bit_pcrel_reloc (unsigned int reloc_type)
10271{
10272 switch (elf_header.e_machine)
10273 {
a06ea964
NC		 10274 case EM_AARCH64:
10275 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10276 case EM_ALPHA:
aa137e4d 10277 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10278 case EM_IA_64:
aa137e4d 10279 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10280 case EM_PARISC:
aa137e4d 10281 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10282 case EM_PPC64:
aa137e4d 10283 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10284 case EM_SPARC32PLUS:
10285 case EM_SPARCV9:
10286 case EM_SPARC:
aa137e4d 10287 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10288 case EM_X86_64:
8a9036a4 10289 case EM_L1OM:
7a9068fe 10290 case EM_K1OM:
aa137e4d 10291 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10292 case EM_S390_OLD:
10293 case EM_S390:
aa137e4d
NC		 10294 return reloc_type == 23; /* R_S390_PC64. */
10295 case EM_TILEGX:
10296 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10297 default:
10298 return FALSE;
10299 }
10300}
10301
4dc3c23d
AM		 10302/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10303 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10304
10305static bfd_boolean
10306is_24bit_abs_reloc (unsigned int reloc_type)
10307{
10308 switch (elf_header.e_machine)
10309 {
10310 case EM_CYGNUS_MN10200:
10311 case EM_MN10200:
10312 return reloc_type == 4; /* R_MN10200_24. */
10313 default:
10314 return FALSE;
10315 }
10316}
10317
aca88567
NC		 10318/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10319 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10320
10321static bfd_boolean
10322is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10323{
10324 switch (elf_header.e_machine)
10325 {
aca88567
NC		 10326 case EM_AVR_OLD:
10327 case EM_AVR:
10328 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10329 case EM_ADAPTEVA_EPIPHANY:
10330 return reloc_type == 5;
41e92641
NC		 10331 case EM_CYGNUS_D10V:
10332 case EM_D10V:
10333 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10334 case EM_H8S:
10335 case EM_H8_300:
10336 case EM_H8_300H:
aca88567
NC		 10337 return reloc_type == R_H8_DIR16;
10338 case EM_IP2K_OLD:
10339 case EM_IP2K:
10340 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10341 case EM_M32C_OLD:
f4236fe4
DD		 10342 case EM_M32C:
10343 return reloc_type == 1; /* R_M32C_16 */
aca88567 10344 case EM_MSP430:
78c8d46c 10345 case EM_MSP430_OLD:
aca88567 10346 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac 10347 case EM_ALTERA_NIOS2:
36591ba1 10348 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 10349 case EM_NIOS32:
10350 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10351 case EM_TI_C6000:
10352 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10353 case EM_XC16X:
10354 case EM_C166:
10355 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10356 case EM_CYGNUS_MN10200:
10357 case EM_MN10200:
10358 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10359 case EM_CYGNUS_MN10300:
10360 case EM_MN10300:
10361 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10362 case EM_XGATE:
10363 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10364 default:
aca88567 10365 return FALSE;
4b78141a
NC		 10366 }
10367}
10368
2a7b2e88
JK		 10369/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10370 relocation entries (possibly formerly used for SHT_GROUP sections). */
10371
10372static bfd_boolean
10373is_none_reloc (unsigned int reloc_type)
10374{
10375 switch (elf_header.e_machine)
10376 {
cb8f3167
NC		 10377 case EM_68K: /* R_68K_NONE. */
10378 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10379 case EM_SPARC32PLUS:
10380 case EM_SPARCV9:
cb8f3167
NC		 10381 case EM_SPARC: /* R_SPARC_NONE. */
10382 case EM_MIPS: /* R_MIPS_NONE. */
10383 case EM_PARISC: /* R_PARISC_NONE. */
10384 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10385 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10386 case EM_PPC: /* R_PPC_NONE. */
10387 case EM_PPC64: /* R_PPC64_NONE. */
10388 case EM_ARM: /* R_ARM_NONE. */
10389 case EM_IA_64: /* R_IA64_NONE. */
10390 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10391 case EM_S390_OLD:
cb8f3167
NC		 10392 case EM_S390: /* R_390_NONE. */
10393 case EM_CRIS: /* R_CRIS_NONE. */
10394 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10395 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10396 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10397 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10398 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10399 case EM_M32R: /* R_M32R_NONE. */
40b36596 10400 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10401 case EM_TILEGX: /* R_TILEGX_NONE. */
10402 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10403 case EM_XC16X:
10404 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 10405 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
10406 case EM_NIOS32: /* R_NIOS_NONE. */
cb8f3167 10407 return reloc_type == 0;
a06ea964
NC		 10408 case EM_AARCH64:
10409 return reloc_type == 0 || reloc_type == 256;
58332dda
JK		 10410 case EM_XTENSA_OLD:
10411 case EM_XTENSA:
4dc3c23d
AM		 10412 return (reloc_type == 0 /* R_XTENSA_NONE. */
10413 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10414 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10415 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 10416 case EM_METAG:
10417 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 10418 }
10419 return FALSE;
10420}
10421
cf13d699
NC		 10422/* Apply relocations to a section.
10423 Note: So far support has been added only for those relocations
10424 which can be found in debug sections.
10425 FIXME: Add support for more relocations ? */
1b315056 10426
cf13d699
NC		 10427static void
10428apply_relocations (void * file,
10429 Elf_Internal_Shdr * section,
10430 unsigned char * start)
1b315056 10431{
cf13d699
NC		 10432 Elf_Internal_Shdr * relsec;
10433 unsigned char * end = start + section->sh_size;
cb8f3167 10434
cf13d699
NC		 10435 if (elf_header.e_type != ET_REL)
10436 return;
1b315056 10437
cf13d699 10438 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10439 for (relsec = section_headers;
10440 relsec < section_headers + elf_header.e_shnum;
10441 ++relsec)
252b5132 10442 {
41e92641
NC		 10443 bfd_boolean is_rela;
10444 unsigned long num_relocs;
2cf0635d
NC		 10445 Elf_Internal_Rela * relocs;
10446 Elf_Internal_Rela * rp;
10447 Elf_Internal_Shdr * symsec;
10448 Elf_Internal_Sym * symtab;
ba5cdace 10449 unsigned long num_syms;
2cf0635d 10450 Elf_Internal_Sym * sym;
252b5132 10451
41e92641 10452 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10453 || relsec->sh_info >= elf_header.e_shnum
10454 || section_headers + relsec->sh_info != section
c256ffe7 10455 || relsec->sh_size == 0
4fbb74a6 10456 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10457 continue;
428409d5 10458
41e92641
NC		 10459 is_rela = relsec->sh_type == SHT_RELA;
10460
10461 if (is_rela)
10462 {
3f5e193b
NC		 10463 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10464 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10465 return;
10466 }
10467 else
10468 {
3f5e193b
NC		 10469 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10470 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10471 return;
10472 }
10473
10474 /* SH uses RELA but uses in place value instead of the addend field. */
10475 if (elf_header.e_machine == EM_SH)
10476 is_rela = FALSE;
428409d5 10477
4fbb74a6 10478 symsec = section_headers + relsec->sh_link;
ba5cdace 10479 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10480
41e92641 10481 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10482 {
41e92641
NC		 10483 bfd_vma addend;
10484 unsigned int reloc_type;
10485 unsigned int reloc_size;
91d6fa6a 10486 unsigned char * rloc;
ba5cdace 10487 unsigned long sym_index;
4b78141a 10488
aca88567 10489 reloc_type = get_reloc_type (rp->r_info);
41e92641 10490
98fb390a 10491 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10492 continue;
98fb390a
NC		 10493 else if (is_none_reloc (reloc_type))
10494 continue;
10495 else if (is_32bit_abs_reloc (reloc_type)
10496 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10497 reloc_size = 4;
85acf597
RH		 10498 else if (is_64bit_abs_reloc (reloc_type)
10499 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10500 reloc_size = 8;
4dc3c23d
AM		 10501 else if (is_24bit_abs_reloc (reloc_type))
10502 reloc_size = 3;
aca88567
NC		 10503 else if (is_16bit_abs_reloc (reloc_type))
10504 reloc_size = 2;
10505 else
4b78141a 10506 {
41e92641 10507 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10508 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10509 continue;
10510 }
103f02d3 10511
91d6fa6a
NC		 10512 rloc = start + rp->r_offset;
10513 if ((rloc + reloc_size) > end)
700dd8b7
L		 10514 {
10515 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10516 (unsigned long) rp->r_offset,
10517 SECTION_NAME (section));
10518 continue;
10519 }
103f02d3 10520
ba5cdace
NC		 10521 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10522 if (sym_index >= num_syms)
10523 {
10524 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10525 sym_index, SECTION_NAME (section));
10526 continue;
10527 }
10528 sym = symtab + sym_index;
41e92641
NC		 10529
10530 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10531 make sure that it is of an appropriate type.
10532
10533 Relocations against symbols without type can happen.
10534 Gcc -feliminate-dwarf2-dups may generate symbols
10535 without type for debug info.
10536
10537 Icc generates relocations against function symbols
10538 instead of local labels.
10539
10540 Relocations against object symbols can happen, eg when
10541 referencing a global array. For an example of this see
10542 the _clz.o binary in libgcc.a. */
aca88567 10543 if (sym != symtab
55f25fc3 10544 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10545 {
41e92641 10546 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10547 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10548 (long int)(rp - relocs),
41e92641 10549 SECTION_NAME (relsec));
aca88567 10550 continue;
5b18a4bc 10551 }
252b5132 10552
4dc3c23d
AM		 10553 addend = 0;
10554 if (is_rela)
10555 addend += rp->r_addend;
c47320c3
AM		 10556 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10557 partial_inplace. */
4dc3c23d
AM		 10558 if (!is_rela
10559 || (elf_header.e_machine == EM_XTENSA
10560 && reloc_type == 1)
10561 || ((elf_header.e_machine == EM_PJ
10562 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10563 && reloc_type == 1)
10564 || ((elf_header.e_machine == EM_D30V
10565 || elf_header.e_machine == EM_CYGNUS_D30V)
10566 && reloc_type == 12))
91d6fa6a 10567 addend += byte_get (rloc, reloc_size);
cb8f3167 10568
85acf597
RH		 10569 if (is_32bit_pcrel_reloc (reloc_type)
10570 || is_64bit_pcrel_reloc (reloc_type))
10571 {
10572 /* On HPPA, all pc-relative relocations are biased by 8. */
10573 if (elf_header.e_machine == EM_PARISC)
10574 addend -= 8;
91d6fa6a 10575 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10576 reloc_size);
10577 }
41e92641 10578 else
91d6fa6a 10579 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10580 }
252b5132 10581
5b18a4bc 10582 free (symtab);
41e92641 10583 free (relocs);
5b18a4bc
NC		 10584 break;
10585 }
5b18a4bc 10586}
103f02d3 10587
cf13d699
NC		 10588#ifdef SUPPORT_DISASSEMBLY
10589static int
10590disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10591{
10592 printf (_("\nAssembly dump of section %s\n"),
10593 SECTION_NAME (section));
10594
10595 /* XXX -- to be done --- XXX */
10596
10597 return 1;
10598}
10599#endif
10600
10601/* Reads in the contents of SECTION from FILE, returning a pointer
10602 to a malloc'ed buffer or NULL if something went wrong. */
10603
10604static char *
10605get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10606{
10607 bfd_size_type num_bytes;
10608
10609 num_bytes = section->sh_size;
10610
10611 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10612 {
10613 printf (_("\nSection '%s' has no data to dump.\n"),
10614 SECTION_NAME (section));
10615 return NULL;
10616 }
10617
3f5e193b
NC		 10618 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10619 _("section contents"));
cf13d699
NC		 10620}
10621
dd24e3da 10622
cf13d699
NC		 10623static void
10624dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10625{
10626 Elf_Internal_Shdr * relsec;
10627 bfd_size_type num_bytes;
cf13d699
NC		 10628 char * data;
10629 char * end;
10630 char * start;
10631 char * name = SECTION_NAME (section);
10632 bfd_boolean some_strings_shown;
10633
10634 start = get_section_contents (section, file);
10635 if (start == NULL)
10636 return;
10637
10638 printf (_("\nString dump of section '%s':\n"), name);
10639
10640 /* If the section being dumped has relocations against it the user might
10641 be expecting these relocations to have been applied. Check for this
10642 case and issue a warning message in order to avoid confusion.
10643 FIXME: Maybe we ought to have an option that dumps a section with
10644 relocs applied ? */
10645 for (relsec = section_headers;
10646 relsec < section_headers + elf_header.e_shnum;
10647 ++relsec)
10648 {
10649 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10650 || relsec->sh_info >= elf_header.e_shnum
10651 || section_headers + relsec->sh_info != section
10652 || relsec->sh_size == 0
10653 || relsec->sh_link >= elf_header.e_shnum)
10654 continue;
10655
10656 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10657 break;
10658 }
10659
10660 num_bytes = section->sh_size;
cf13d699
NC		 10661 data = start;
10662 end = start + num_bytes;
10663 some_strings_shown = FALSE;
10664
10665 while (data < end)
10666 {
10667 while (!ISPRINT (* data))
10668 if (++ data >= end)
10669 break;
10670
10671 if (data < end)
10672 {
10673#ifndef __MSVCRT__
c975cc98
NC		 10674 /* PR 11128: Use two separate invocations in order to work
10675 around bugs in the Solaris 8 implementation of printf. */
10676 printf (" [%6tx] ", data - start);
10677 printf ("%s\n", data);
cf13d699
NC		 10678#else
10679 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10680#endif
10681 data += strlen (data);
10682 some_strings_shown = TRUE;
10683 }
10684 }
10685
10686 if (! some_strings_shown)
10687 printf (_(" No strings found in this section."));
10688
10689 free (start);
10690
10691 putchar ('\n');
10692}
10693
10694static void
10695dump_section_as_bytes (Elf_Internal_Shdr * section,
10696 FILE * file,
10697 bfd_boolean relocate)
10698{
10699 Elf_Internal_Shdr * relsec;
10700 bfd_size_type bytes;
10701 bfd_vma addr;
10702 unsigned char * data;
10703 unsigned char * start;
10704
10705 start = (unsigned char *) get_section_contents (section, file);
10706 if (start == NULL)
10707 return;
10708
10709 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10710
10711 if (relocate)
10712 {
10713 apply_relocations (file, section, start);
10714 }
10715 else
10716 {
10717 /* If the section being dumped has relocations against it the user might
10718 be expecting these relocations to have been applied. Check for this
10719 case and issue a warning message in order to avoid confusion.
10720 FIXME: Maybe we ought to have an option that dumps a section with
10721 relocs applied ? */
10722 for (relsec = section_headers;
10723 relsec < section_headers + elf_header.e_shnum;
10724 ++relsec)
10725 {
10726 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10727 || relsec->sh_info >= elf_header.e_shnum
10728 || section_headers + relsec->sh_info != section
10729 || relsec->sh_size == 0
10730 || relsec->sh_link >= elf_header.e_shnum)
10731 continue;
10732
10733 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10734 break;
10735 }
10736 }
10737
10738 addr = section->sh_addr;
10739 bytes = section->sh_size;
10740 data = start;
10741
10742 while (bytes)
10743 {
10744 int j;
10745 int k;
10746 int lbytes;
10747
10748 lbytes = (bytes > 16 ? 16 : bytes);
10749
10750 printf (" 0x%8.8lx ", (unsigned long) addr);
10751
10752 for (j = 0; j < 16; j++)
10753 {
10754 if (j < lbytes)
10755 printf ("%2.2x", data[j]);
10756 else
10757 printf (" ");
10758
10759 if ((j & 3) == 3)
10760 printf (" ");
10761 }
10762
10763 for (j = 0; j < lbytes; j++)
10764 {
10765 k = data[j];
10766 if (k >= ' ' && k < 0x7f)
10767 printf ("%c", k);
10768 else
10769 printf (".");
10770 }
10771
10772 putchar ('\n');
10773
10774 data += lbytes;
10775 addr += lbytes;
10776 bytes -= lbytes;
10777 }
10778
10779 free (start);
10780
10781 putchar ('\n');
10782}
10783
4a114e3e 10784/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10785
10786static int
d3dbc530
AM		 10787uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10788 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10789{
10790#ifndef HAVE_ZLIB_H
cf13d699
NC		 10791 return FALSE;
10792#else
10793 dwarf_size_type compressed_size = *size;
10794 unsigned char * compressed_buffer = *buffer;
10795 dwarf_size_type uncompressed_size;
10796 unsigned char * uncompressed_buffer;
10797 z_stream strm;
10798 int rc;
10799 dwarf_size_type header_size = 12;
10800
10801 /* Read the zlib header. In this case, it should be "ZLIB" followed
10802 by the uncompressed section size, 8 bytes in big-endian order. */
10803 if (compressed_size < header_size
10804 || ! streq ((char *) compressed_buffer, "ZLIB"))
10805 return 0;
10806
10807 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10808 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10809 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10810 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10811 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10812 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10813 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10814 uncompressed_size += compressed_buffer[11];
10815
10816 /* It is possible the section consists of several compressed
10817 buffers concatenated together, so we uncompress in a loop. */
10818 strm.zalloc = NULL;
10819 strm.zfree = NULL;
10820 strm.opaque = NULL;
10821 strm.avail_in = compressed_size - header_size;
10822 strm.next_in = (Bytef *) compressed_buffer + header_size;
10823 strm.avail_out = uncompressed_size;
3f5e193b 10824 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10825
10826 rc = inflateInit (& strm);
10827 while (strm.avail_in > 0)
10828 {
10829 if (rc != Z_OK)
10830 goto fail;
10831 strm.next_out = ((Bytef *) uncompressed_buffer
10832 + (uncompressed_size - strm.avail_out));
10833 rc = inflate (&strm, Z_FINISH);
10834 if (rc != Z_STREAM_END)
10835 goto fail;
10836 rc = inflateReset (& strm);
10837 }
10838 rc = inflateEnd (& strm);
10839 if (rc != Z_OK
10840 || strm.avail_out != 0)
10841 goto fail;
10842
10843 free (compressed_buffer);
10844 *buffer = uncompressed_buffer;
10845 *size = uncompressed_size;
10846 return 1;
10847
10848 fail:
10849 free (uncompressed_buffer);
4a114e3e
L		 10850 /* Indicate decompression failure. */
10851 *buffer = NULL;
cf13d699
NC		 10852 return 0;
10853#endif /* HAVE_ZLIB_H */
10854}
10855
d966045b
DJ		 10856static int
10857load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10858 Elf_Internal_Shdr * sec, void * file)
1007acb3 10859{
2cf0635d 10860 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10861 char buf [64];
1007acb3 10862
19e6b90e
L		 10863 /* If it is already loaded, do nothing. */
10864 if (section->start != NULL)
10865 return 1;
1007acb3 10866
19e6b90e
L		 10867 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10868 section->address = sec->sh_addr;
3f5e193b
NC		 10869 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10870 sec->sh_offset, 1,
10871 sec->sh_size, buf);
59245841
NC		 10872 if (section->start == NULL)
10873 section->size = 0;
10874 else
10875 {
10876 section->size = sec->sh_size;
10877 if (uncompress_section_contents (&section->start, &section->size))
10878 sec->sh_size = section->size;
10879 }
4a114e3e 10880
1b315056
CS		 10881 if (section->start == NULL)
10882 return 0;
10883
19e6b90e 10884 if (debug_displays [debug].relocate)
3f5e193b 10885 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10886
1b315056 10887 return 1;
1007acb3
L		 10888}
10889
657d0d47
CC		 10890/* If this is not NULL, load_debug_section will only look for sections
10891 within the list of sections given here. */
10892unsigned int *section_subset = NULL;
10893
d966045b 10894int
2cf0635d 10895load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10896{
2cf0635d
NC		 10897 struct dwarf_section * section = &debug_displays [debug].section;
10898 Elf_Internal_Shdr * sec;
d966045b
DJ		 10899
10900 /* Locate the debug section. */
657d0d47 10901 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 10902 if (sec != NULL)
10903 section->name = section->uncompressed_name;
10904 else
10905 {
657d0d47 10906 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 10907 if (sec != NULL)
10908 section->name = section->compressed_name;
10909 }
10910 if (sec == NULL)
10911 return 0;
10912
657d0d47
CC		 10913 /* If we're loading from a subset of sections, and we've loaded
10914 a section matching this name before, it's likely that it's a
10915 different one. */
10916 if (section_subset != NULL)
10917 free_debug_section (debug);
10918
3f5e193b 10919 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10920}
10921
19e6b90e
L		 10922void
10923free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10924{
2cf0635d 10925 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10926
19e6b90e
L		 10927 if (section->start == NULL)
10928 return;
1007acb3 10929
19e6b90e
L		 10930 free ((char *) section->start);
10931 section->start = NULL;
10932 section->address = 0;
10933 section->size = 0;
1007acb3
L		 10934}
10935
1007acb3 10936static int
657d0d47 10937display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 10938{
2cf0635d 10939 char * name = SECTION_NAME (section);
19e6b90e
L		 10940 bfd_size_type length;
10941 int result = 1;
3f5e193b 10942 int i;
1007acb3 10943
19e6b90e
L		 10944 length = section->sh_size;
10945 if (length == 0)
1007acb3 10946 {
19e6b90e
L		 10947 printf (_("\nSection '%s' has no debugging data.\n"), name);
10948 return 0;
1007acb3 10949 }
5dff79d8
NC		 10950 if (section->sh_type == SHT_NOBITS)
10951 {
10952 /* There is no point in dumping the contents of a debugging section
10953 which has the NOBITS type - the bits in the file will be random.
10954 This can happen when a file containing a .eh_frame section is
10955 stripped with the --only-keep-debug command line option. */
10956 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10957 return 0;
10958 }
1007acb3 10959
0112cd26 10960 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10961 name = ".debug_info";
1007acb3 10962
19e6b90e
L		 10963 /* See if we know how to display the contents of this section. */
10964 for (i = 0; i < max; i++)
1b315056
CS		 10965 if (streq (debug_displays[i].section.uncompressed_name, name)
10966 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10967 {
2cf0635d 10968 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10969 int secondary = (section != find_section (name));
10970
10971 if (secondary)
3f5e193b 10972 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10973
2b6f5997 10974 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10975 sec->name = sec->uncompressed_name;
10976 else
10977 sec->name = sec->compressed_name;
3f5e193b
NC		 10978 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10979 section, file))
19e6b90e 10980 {
657d0d47
CC		 10981 /* If this debug section is part of a CU/TU set in a .dwp file,
10982 restrict load_debug_section to the sections in that set. */
10983 section_subset = find_cu_tu_set (file, shndx);
10984
19e6b90e 10985 result &= debug_displays[i].display (sec, file);
1007acb3 10986
657d0d47
CC		 10987 section_subset = NULL;
10988
d966045b 10989 if (secondary || (i != info && i != abbrev))
3f5e193b 10990 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10991 }
1007acb3 10992
19e6b90e
L		 10993 break;
10994 }
1007acb3 10995
19e6b90e 10996 if (i == max)
1007acb3 10997 {
19e6b90e
L		 10998 printf (_("Unrecognized debug section: %s\n"), name);
10999 result = 0;
1007acb3
L		 11000 }
11001
19e6b90e 11002 return result;
5b18a4bc 11003}
103f02d3 11004
aef1f6d0
DJ		 11005/* Set DUMP_SECTS for all sections where dumps were requested
11006 based on section name. */
11007
11008static void
11009initialise_dumps_byname (void)
11010{
2cf0635d 11011 struct dump_list_entry * cur;
aef1f6d0
DJ		 11012
11013 for (cur = dump_sects_byname; cur; cur = cur->next)
11014 {
11015 unsigned int i;
11016 int any;
11017
11018 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11019 if (streq (SECTION_NAME (section_headers + i), cur->name))
11020 {
09c11c86 11021 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11022 any = 1;
11023 }
11024
11025 if (!any)
11026 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11027 cur->name);
11028 }
11029}
11030
5b18a4bc 11031static void
2cf0635d 11032process_section_contents (FILE * file)
5b18a4bc 11033{
2cf0635d 11034 Elf_Internal_Shdr * section;
19e6b90e 11035 unsigned int i;
103f02d3 11036
19e6b90e
L		 11037 if (! do_dump)
11038 return;
103f02d3 11039
aef1f6d0
DJ		 11040 initialise_dumps_byname ();
11041
19e6b90e
L		 11042 for (i = 0, section = section_headers;
11043 i < elf_header.e_shnum && i < num_dump_sects;
11044 i++, section++)
11045 {
11046#ifdef SUPPORT_DISASSEMBLY
11047 if (dump_sects[i] & DISASS_DUMP)
11048 disassemble_section (section, file);
11049#endif
11050 if (dump_sects[i] & HEX_DUMP)
cf13d699 11051 dump_section_as_bytes (section, file, FALSE);
103f02d3 11052
cf13d699
NC		 11053 if (dump_sects[i] & RELOC_DUMP)
11054 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11055
11056 if (dump_sects[i] & STRING_DUMP)
11057 dump_section_as_strings (section, file);
cf13d699
NC		 11058
11059 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11060 display_debug_section (i, section, file);
5b18a4bc 11061 }
103f02d3 11062
19e6b90e
L		 11063 /* Check to see if the user requested a
11064 dump of a section that does not exist. */
11065 while (i++ < num_dump_sects)
11066 if (dump_sects[i])
11067 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11068}
103f02d3 11069
5b18a4bc 11070static void
19e6b90e 11071process_mips_fpe_exception (int mask)
5b18a4bc 11072{
19e6b90e
L		 11073 if (mask)
11074 {
11075 int first = 1;
11076 if (mask & OEX_FPU_INEX)
11077 fputs ("INEX", stdout), first = 0;
11078 if (mask & OEX_FPU_UFLO)
11079 printf ("%sUFLO", first ? "" : "|"), first = 0;
11080 if (mask & OEX_FPU_OFLO)
11081 printf ("%sOFLO", first ? "" : "|"), first = 0;
11082 if (mask & OEX_FPU_DIV0)
11083 printf ("%sDIV0", first ? "" : "|"), first = 0;
11084 if (mask & OEX_FPU_INVAL)
11085 printf ("%sINVAL", first ? "" : "|");
11086 }
5b18a4bc 11087 else
19e6b90e 11088 fputs ("0", stdout);
5b18a4bc 11089}
103f02d3 11090
11c1ff18
PB		 11091/* ARM EABI attributes section. */
11092typedef struct
11093{
11094 int tag;
2cf0635d 11095 const char * name;
11c1ff18
PB		 11096 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11097 int type;
2cf0635d 11098 const char ** table;
11c1ff18
PB		 11099} arm_attr_public_tag;
11100
2cf0635d 11101static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11102 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11103 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11104static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11105static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11106 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11107static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 11108 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11109 "FP for ARMv8"};
2cf0635d 11110static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11111static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11112 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11113static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11114 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11115 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11116static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11117 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11118static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11119 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11120static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11121 {"Absolute", "PC-relative", "None"};
2cf0635d 11122static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11123 {"None", "direct", "GOT-indirect"};
2cf0635d 11124static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11125 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11126static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11127static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11128 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11129static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11130static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11131static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11132 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11133static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11134 {"Unused", "small", "int", "forced to int"};
2cf0635d 11135static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11136 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11137static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11138 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11139static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11140 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11141static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11142 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11143 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11144static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 11145 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11146 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11147static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11148static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11149 {"Not Allowed", "Allowed"};
2cf0635d 11150static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11151 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11152static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 11153 {"Not Allowed", "Allowed"};
11154static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11155 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11156 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 11157static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11158static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11159 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11160 "TrustZone and Virtualization Extensions"};
dd24e3da 11161static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11162 {"Not Allowed", "Allowed"};
11c1ff18
PB		 11163
11164#define LOOKUP(id, name) \
11165 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11166static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 11167{
11168 {4, "CPU_raw_name", 1, NULL},
11169 {5, "CPU_name", 1, NULL},
11170 LOOKUP(6, CPU_arch),
11171 {7, "CPU_arch_profile", 0, NULL},
11172 LOOKUP(8, ARM_ISA_use),
11173 LOOKUP(9, THUMB_ISA_use),
75375b3e 11174 LOOKUP(10, FP_arch),
11c1ff18 11175 LOOKUP(11, WMMX_arch),
f5f53991
AS		 11176 LOOKUP(12, Advanced_SIMD_arch),
11177 LOOKUP(13, PCS_config),
11c1ff18
PB		 11178 LOOKUP(14, ABI_PCS_R9_use),
11179 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11180 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 11181 LOOKUP(17, ABI_PCS_GOT_use),
11182 LOOKUP(18, ABI_PCS_wchar_t),
11183 LOOKUP(19, ABI_FP_rounding),
11184 LOOKUP(20, ABI_FP_denormal),
11185 LOOKUP(21, ABI_FP_exceptions),
11186 LOOKUP(22, ABI_FP_user_exceptions),
11187 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 11188 {24, "ABI_align_needed", 0, NULL},
11189 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 11190 LOOKUP(26, ABI_enum_size),
11191 LOOKUP(27, ABI_HardFP_use),
11192 LOOKUP(28, ABI_VFP_args),
11193 LOOKUP(29, ABI_WMMX_args),
11194 LOOKUP(30, ABI_optimization_goals),
11195 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11196 {32, "compatibility", 0, NULL},
f5f53991 11197 LOOKUP(34, CPU_unaligned_access),
75375b3e 11198 LOOKUP(36, FP_HP_extension),
8e79c3df 11199 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 11200 LOOKUP(42, MPextension_use),
11201 LOOKUP(44, DIV_use),
f5f53991
AS		 11202 {64, "nodefaults", 0, NULL},
11203 {65, "also_compatible_with", 0, NULL},
11204 LOOKUP(66, T2EE_use),
11205 {67, "conformance", 1, NULL},
11206 LOOKUP(68, Virtualization_use),
cd21e546 11207 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 11208};
11209#undef LOOKUP
11210
11c1ff18 11211static unsigned char *
2cf0635d 11212display_arm_attribute (unsigned char * p)
11c1ff18
PB		 11213{
11214 int tag;
11215 unsigned int len;
11216 int val;
2cf0635d 11217 arm_attr_public_tag * attr;
11c1ff18
PB		 11218 unsigned i;
11219 int type;
11220
11221 tag = read_uleb128 (p, &len);
11222 p += len;
11223 attr = NULL;
2cf0635d 11224 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 11225 {
11226 if (arm_attr_public_tags[i].tag == tag)
11227 {
11228 attr = &arm_attr_public_tags[i];
11229 break;
11230 }
11231 }
11232
11233 if (attr)
11234 {
11235 printf (" Tag_%s: ", attr->name);
11236 switch (attr->type)
11237 {
11238 case 0:
11239 switch (tag)
11240 {
11241 case 7: /* Tag_CPU_arch_profile. */
11242 val = read_uleb128 (p, &len);
11243 p += len;
11244 switch (val)
11245 {
2b692964
NC		 11246 case 0: printf (_("None\n")); break;
11247 case 'A': printf (_("Application\n")); break;
11248 case 'R': printf (_("Realtime\n")); break;
11249 case 'M': printf (_("Microcontroller\n")); break;
11250 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11251 default: printf ("??? (%d)\n", val); break;
11252 }
11253 break;
11254
75375b3e
MGD		 11255 case 24: /* Tag_align_needed. */
11256 val = read_uleb128 (p, &len);
11257 p += len;
11258 switch (val)
11259 {
2b692964
NC		 11260 case 0: printf (_("None\n")); break;
11261 case 1: printf (_("8-byte\n")); break;
11262 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11263 case 3: printf ("??? 3\n"); break;
11264 default:
11265 if (val <= 12)
dd24e3da 11266 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11267 1 << val);
11268 else
11269 printf ("??? (%d)\n", val);
11270 break;
11271 }
11272 break;
11273
11274 case 25: /* Tag_align_preserved. */
11275 val = read_uleb128 (p, &len);
11276 p += len;
11277 switch (val)
11278 {
2b692964
NC		 11279 case 0: printf (_("None\n")); break;
11280 case 1: printf (_("8-byte, except leaf SP\n")); break;
11281 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11282 case 3: printf ("??? 3\n"); break;
11283 default:
11284 if (val <= 12)
dd24e3da 11285 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11286 1 << val);
11287 else
11288 printf ("??? (%d)\n", val);
11289 break;
11290 }
11291 break;
11292
11c1ff18
PB		 11293 case 32: /* Tag_compatibility. */
11294 val = read_uleb128 (p, &len);
11295 p += len;
2b692964 11296 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11297 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11298 break;
11299
f5f53991
AS		 11300 case 64: /* Tag_nodefaults. */
11301 p++;
2b692964 11302 printf (_("True\n"));
f5f53991
AS		 11303 break;
11304
11305 case 65: /* Tag_also_compatible_with. */
11306 val = read_uleb128 (p, &len);
11307 p += len;
11308 if (val == 6 /* Tag_CPU_arch. */)
11309 {
11310 val = read_uleb128 (p, &len);
11311 p += len;
2cf0635d 11312 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11313 printf ("??? (%d)\n", val);
11314 else
11315 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11316 }
11317 else
11318 printf ("???\n");
11319 while (*(p++) != '\0' /* NUL terminator. */);
11320 break;
11321
11c1ff18 11322 default:
2cf0635d 11323 abort ();
11c1ff18
PB		 11324 }
11325 return p;
11326
11327 case 1:
11328 case 2:
11329 type = attr->type;
11330 break;
11331
11332 default:
11333 assert (attr->type & 0x80);
11334 val = read_uleb128 (p, &len);
11335 p += len;
11336 type = attr->type & 0x7f;
11337 if (val >= type)
11338 printf ("??? (%d)\n", val);
11339 else
11340 printf ("%s\n", attr->table[val]);
11341 return p;
11342 }
11343 }
11344 else
11345 {
11346 if (tag & 1)
11347 type = 1; /* String. */
11348 else
11349 type = 2; /* uleb128. */
11350 printf (" Tag_unknown_%d: ", tag);
11351 }
11352
11353 if (type == 1)
11354 {
11355 printf ("\"%s\"\n", p);
2cf0635d 11356 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11357 }
11358 else
11359 {
11360 val = read_uleb128 (p, &len);
11361 p += len;
11362 printf ("%d (0x%x)\n", val, val);
11363 }
11364
11365 return p;
11366}
11367
104d59d1 11368static unsigned char *
60bca95a
NC		 11369display_gnu_attribute (unsigned char * p,
11370 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 11371{
11372 int tag;
11373 unsigned int len;
11374 int val;
11375 int type;
11376
11377 tag = read_uleb128 (p, &len);
11378 p += len;
11379
11380 /* Tag_compatibility is the only generic GNU attribute defined at
11381 present. */
11382 if (tag == 32)
11383 {
11384 val = read_uleb128 (p, &len);
11385 p += len;
2b692964 11386 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 11387 p += strlen ((char *) p) + 1;
104d59d1
JM		 11388 return p;
11389 }
11390
11391 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11392 return display_proc_gnu_attribute (p, tag);
11393
11394 if (tag & 1)
11395 type = 1; /* String. */
11396 else
11397 type = 2; /* uleb128. */
11398 printf (" Tag_unknown_%d: ", tag);
11399
11400 if (type == 1)
11401 {
11402 printf ("\"%s\"\n", p);
60bca95a 11403 p += strlen ((char *) p) + 1;
104d59d1
JM		 11404 }
11405 else
11406 {
11407 val = read_uleb128 (p, &len);
11408 p += len;
11409 printf ("%d (0x%x)\n", val, val);
11410 }
11411
11412 return p;
11413}
11414
34c8bcba 11415static unsigned char *
2cf0635d 11416display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 11417{
11418 int type;
11419 unsigned int len;
11420 int val;
11421
11422 if (tag == Tag_GNU_Power_ABI_FP)
11423 {
11424 val = read_uleb128 (p, &len);
11425 p += len;
11426 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11427
34c8bcba
JM		 11428 switch (val)
11429 {
11430 case 0:
2b692964 11431 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11432 break;
11433 case 1:
2b692964 11434 printf (_("Hard float\n"));
34c8bcba
JM		 11435 break;
11436 case 2:
2b692964 11437 printf (_("Soft float\n"));
34c8bcba 11438 break;
3c7b9897 11439 case 3:
2b692964 11440 printf (_("Single-precision hard float\n"));
3c7b9897 11441 break;
34c8bcba
JM		 11442 default:
11443 printf ("??? (%d)\n", val);
11444 break;
11445 }
11446 return p;
11447 }
11448
c6e65352
DJ		 11449 if (tag == Tag_GNU_Power_ABI_Vector)
11450 {
11451 val = read_uleb128 (p, &len);
11452 p += len;
11453 printf (" Tag_GNU_Power_ABI_Vector: ");
11454 switch (val)
11455 {
11456 case 0:
2b692964 11457 printf (_("Any\n"));
c6e65352
DJ		 11458 break;
11459 case 1:
2b692964 11460 printf (_("Generic\n"));
c6e65352
DJ		 11461 break;
11462 case 2:
11463 printf ("AltiVec\n");
11464 break;
11465 case 3:
11466 printf ("SPE\n");
11467 break;
11468 default:
11469 printf ("??? (%d)\n", val);
11470 break;
11471 }
11472 return p;
11473 }
11474
f82e0623
NF		 11475 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11476 {
11477 val = read_uleb128 (p, &len);
11478 p += len;
11479 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11480 switch (val)
11481 {
11482 case 0:
2b692964 11483 printf (_("Any\n"));
f82e0623
NF		 11484 break;
11485 case 1:
11486 printf ("r3/r4\n");
11487 break;
11488 case 2:
2b692964 11489 printf (_("Memory\n"));
f82e0623
NF		 11490 break;
11491 default:
11492 printf ("??? (%d)\n", val);
11493 break;
11494 }
11495 return p;
11496 }
11497
34c8bcba
JM		 11498 if (tag & 1)
11499 type = 1; /* String. */
11500 else
11501 type = 2; /* uleb128. */
11502 printf (" Tag_unknown_%d: ", tag);
11503
11504 if (type == 1)
11505 {
11506 printf ("\"%s\"\n", p);
60bca95a 11507 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11508 }
11509 else
11510 {
11511 val = read_uleb128 (p, &len);
11512 p += len;
11513 printf ("%d (0x%x)\n", val, val);
11514 }
11515
11516 return p;
11517}
11518
9e8c70f9
DM		 11519static void
11520display_sparc_hwcaps (int mask)
11521{
11522 if (mask)
11523 {
11524 int first = 1;
11525 if (mask & ELF_SPARC_HWCAP_MUL32)
11526 fputs ("mul32", stdout), first = 0;
11527 if (mask & ELF_SPARC_HWCAP_DIV32)
11528 printf ("%sdiv32", first ? "" : "|"), first = 0;
11529 if (mask & ELF_SPARC_HWCAP_FSMULD)
11530 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11531 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11532 printf ("%sv8plus", first ? "" : "|"), first = 0;
11533 if (mask & ELF_SPARC_HWCAP_POPC)
11534 printf ("%spopc", first ? "" : "|"), first = 0;
11535 if (mask & ELF_SPARC_HWCAP_VIS)
11536 printf ("%svis", first ? "" : "|"), first = 0;
11537 if (mask & ELF_SPARC_HWCAP_VIS2)
11538 printf ("%svis2", first ? "" : "|"), first = 0;
11539 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11540 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11541 if (mask & ELF_SPARC_HWCAP_FMAF)
11542 printf ("%sfmaf", first ? "" : "|"), first = 0;
11543 if (mask & ELF_SPARC_HWCAP_VIS3)
11544 printf ("%svis3", first ? "" : "|"), first = 0;
11545 if (mask & ELF_SPARC_HWCAP_HPC)
11546 printf ("%shpc", first ? "" : "|"), first = 0;
11547 if (mask & ELF_SPARC_HWCAP_RANDOM)
11548 printf ("%srandom", first ? "" : "|"), first = 0;
11549 if (mask & ELF_SPARC_HWCAP_TRANS)
11550 printf ("%strans", first ? "" : "|"), first = 0;
11551 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11552 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11553 if (mask & ELF_SPARC_HWCAP_IMA)
11554 printf ("%sima", first ? "" : "|"), first = 0;
11555 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11556 printf ("%scspare", first ? "" : "|"), first = 0;
11557 }
11558 else
11559 fputc('0', stdout);
11560 fputc('\n', stdout);
11561}
11562
11563static unsigned char *
11564display_sparc_gnu_attribute (unsigned char * p, int tag)
11565{
11566 int type;
11567 unsigned int len;
11568 int val;
11569
11570 if (tag == Tag_GNU_Sparc_HWCAPS)
11571 {
11572 val = read_uleb128 (p, &len);
11573 p += len;
11574 printf (" Tag_GNU_Sparc_HWCAPS: ");
11575
11576 display_sparc_hwcaps (val);
11577 return p;
11578 }
11579
11580 if (tag & 1)
11581 type = 1; /* String. */
11582 else
11583 type = 2; /* uleb128. */
11584 printf (" Tag_unknown_%d: ", tag);
11585
11586 if (type == 1)
11587 {
11588 printf ("\"%s\"\n", p);
11589 p += strlen ((char *) p) + 1;
11590 }
11591 else
11592 {
11593 val = read_uleb128 (p, &len);
11594 p += len;
11595 printf ("%d (0x%x)\n", val, val);
11596 }
11597
11598 return p;
11599}
11600
2cf19d5c 11601static unsigned char *
2cf0635d 11602display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11603{
11604 int type;
11605 unsigned int len;
11606 int val;
11607
11608 if (tag == Tag_GNU_MIPS_ABI_FP)
11609 {
11610 val = read_uleb128 (p, &len);
11611 p += len;
11612 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11613
2cf19d5c
JM		 11614 switch (val)
11615 {
11616 case 0:
2b692964 11617 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11618 break;
11619 case 1:
2b692964 11620 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11621 break;
11622 case 2:
2b692964 11623 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11624 break;
11625 case 3:
2b692964 11626 printf (_("Soft float\n"));
2cf19d5c 11627 break;
42554f6a 11628 case 4:
9eeefea8 11629 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11630 break;
2cf19d5c
JM		 11631 default:
11632 printf ("??? (%d)\n", val);
11633 break;
11634 }
11635 return p;
11636 }
11637
11638 if (tag & 1)
11639 type = 1; /* String. */
11640 else
11641 type = 2; /* uleb128. */
11642 printf (" Tag_unknown_%d: ", tag);
11643
11644 if (type == 1)
11645 {
11646 printf ("\"%s\"\n", p);
60bca95a 11647 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11648 }
11649 else
11650 {
11651 val = read_uleb128 (p, &len);
11652 p += len;
11653 printf ("%d (0x%x)\n", val, val);
11654 }
11655
11656 return p;
11657}
11658
59e6276b
JM		 11659static unsigned char *
11660display_tic6x_attribute (unsigned char * p)
11661{
11662 int tag;
11663 unsigned int len;
11664 int val;
11665
11666 tag = read_uleb128 (p, &len);
11667 p += len;
11668
11669 switch (tag)
11670 {
75fa6dc1 11671 case Tag_ISA:
59e6276b
JM		 11672 val = read_uleb128 (p, &len);
11673 p += len;
75fa6dc1 11674 printf (" Tag_ISA: ");
59e6276b
JM		 11675
11676 switch (val)
11677 {
75fa6dc1 11678 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11679 printf (_("None\n"));
11680 break;
75fa6dc1 11681 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11682 printf ("C62x\n");
11683 break;
75fa6dc1 11684 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11685 printf ("C67x\n");
11686 break;
75fa6dc1 11687 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11688 printf ("C67x+\n");
11689 break;
75fa6dc1 11690 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11691 printf ("C64x\n");
11692 break;
75fa6dc1 11693 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11694 printf ("C64x+\n");
11695 break;
75fa6dc1 11696 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11697 printf ("C674x\n");
11698 break;
11699 default:
11700 printf ("??? (%d)\n", val);
11701 break;
11702 }
11703 return p;
11704
87779176
JM		 11705 case Tag_ABI_wchar_t:
11706 val = read_uleb128 (p, &len);
11707 p += len;
11708 printf (" Tag_ABI_wchar_t: ");
11709 switch (val)
11710 {
11711 case 0:
11712 printf (_("Not used\n"));
11713 break;
11714 case 1:
11715 printf (_("2 bytes\n"));
11716 break;
11717 case 2:
11718 printf (_("4 bytes\n"));
11719 break;
11720 default:
11721 printf ("??? (%d)\n", val);
11722 break;
11723 }
11724 return p;
11725
11726 case Tag_ABI_stack_align_needed:
11727 val = read_uleb128 (p, &len);
11728 p += len;
11729 printf (" Tag_ABI_stack_align_needed: ");
11730 switch (val)
11731 {
11732 case 0:
11733 printf (_("8-byte\n"));
11734 break;
11735 case 1:
11736 printf (_("16-byte\n"));
11737 break;
11738 default:
11739 printf ("??? (%d)\n", val);
11740 break;
11741 }
11742 return p;
11743
11744 case Tag_ABI_stack_align_preserved:
11745 val = read_uleb128 (p, &len);
11746 p += len;
11747 printf (" Tag_ABI_stack_align_preserved: ");
11748 switch (val)
11749 {
11750 case 0:
11751 printf (_("8-byte\n"));
11752 break;
11753 case 1:
11754 printf (_("16-byte\n"));
11755 break;
11756 default:
11757 printf ("??? (%d)\n", val);
11758 break;
11759 }
11760 return p;
11761
b5593623
JM		 11762 case Tag_ABI_DSBT:
11763 val = read_uleb128 (p, &len);
11764 p += len;
11765 printf (" Tag_ABI_DSBT: ");
11766 switch (val)
11767 {
11768 case 0:
11769 printf (_("DSBT addressing not used\n"));
11770 break;
11771 case 1:
11772 printf (_("DSBT addressing used\n"));
11773 break;
11774 default:
11775 printf ("??? (%d)\n", val);
11776 break;
11777 }
11778 return p;
11779
87779176
JM		 11780 case Tag_ABI_PID:
11781 val = read_uleb128 (p, &len);
11782 p += len;
11783 printf (" Tag_ABI_PID: ");
11784 switch (val)
11785 {
11786 case 0:
11787 printf (_("Data addressing position-dependent\n"));
11788 break;
11789 case 1:
11790 printf (_("Data addressing position-independent, GOT near DP\n"));
11791 break;
11792 case 2:
11793 printf (_("Data addressing position-independent, GOT far from DP\n"));
11794 break;
11795 default:
11796 printf ("??? (%d)\n", val);
11797 break;
11798 }
11799 return p;
11800
11801 case Tag_ABI_PIC:
11802 val = read_uleb128 (p, &len);
11803 p += len;
11804 printf (" Tag_ABI_PIC: ");
11805 switch (val)
11806 {
11807 case 0:
11808 printf (_("Code addressing position-dependent\n"));
11809 break;
11810 case 1:
11811 printf (_("Code addressing position-independent\n"));
11812 break;
11813 default:
11814 printf ("??? (%d)\n", val);
11815 break;
11816 }
11817 return p;
11818
11819 case Tag_ABI_array_object_alignment:
11820 val = read_uleb128 (p, &len);
11821 p += len;
11822 printf (" Tag_ABI_array_object_alignment: ");
11823 switch (val)
11824 {
11825 case 0:
11826 printf (_("8-byte\n"));
11827 break;
11828 case 1:
11829 printf (_("4-byte\n"));
11830 break;
11831 case 2:
11832 printf (_("16-byte\n"));
11833 break;
11834 default:
11835 printf ("??? (%d)\n", val);
11836 break;
11837 }
11838 return p;
11839
11840 case Tag_ABI_array_object_align_expected:
11841 val = read_uleb128 (p, &len);
11842 p += len;
11843 printf (" Tag_ABI_array_object_align_expected: ");
11844 switch (val)
11845 {
11846 case 0:
11847 printf (_("8-byte\n"));
11848 break;
11849 case 1:
11850 printf (_("4-byte\n"));
11851 break;
11852 case 2:
11853 printf (_("16-byte\n"));
11854 break;
11855 default:
11856 printf ("??? (%d)\n", val);
11857 break;
11858 }
11859 return p;
11860
3cbd1c06 11861 case Tag_ABI_compatibility:
59e6276b
JM		 11862 val = read_uleb128 (p, &len);
11863 p += len;
3cbd1c06 11864 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11865 printf (_("flag = %d, vendor = %s\n"), val, p);
11866 p += strlen ((char *) p) + 1;
11867 return p;
87779176
JM		 11868
11869 case Tag_ABI_conformance:
11870 printf (" Tag_ABI_conformance: ");
11871 printf ("\"%s\"\n", p);
11872 p += strlen ((char *) p) + 1;
11873 return p;
59e6276b
JM		 11874 }
11875
11876 printf (" Tag_unknown_%d: ", tag);
11877
87779176
JM		 11878 if (tag & 1)
11879 {
11880 printf ("\"%s\"\n", p);
11881 p += strlen ((char *) p) + 1;
11882 }
11883 else
11884 {
11885 val = read_uleb128 (p, &len);
11886 p += len;
11887 printf ("%d (0x%x)\n", val, val);
11888 }
59e6276b
JM		 11889
11890 return p;
11891}
11892
11c1ff18 11893static int
60bca95a
NC		 11894process_attributes (FILE * file,
11895 const char * public_name,
104d59d1 11896 unsigned int proc_type,
60bca95a
NC		 11897 unsigned char * (* display_pub_attribute) (unsigned char *),
11898 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11899{
2cf0635d
NC		 11900 Elf_Internal_Shdr * sect;
11901 unsigned char * contents;
11902 unsigned char * p;
11903 unsigned char * end;
11c1ff18
PB		 11904 bfd_vma section_len;
11905 bfd_vma len;
11906 unsigned i;
11907
11908 /* Find the section header so that we get the size. */
11909 for (i = 0, sect = section_headers;
11910 i < elf_header.e_shnum;
11911 i++, sect++)
11912 {
104d59d1 11913 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11914 continue;
11915
3f5e193b
NC		 11916 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11917 sect->sh_size, _("attributes"));
60bca95a 11918 if (contents == NULL)
11c1ff18 11919 continue;
60bca95a 11920
11c1ff18
PB		 11921 p = contents;
11922 if (*p == 'A')
11923 {
11924 len = sect->sh_size - 1;
11925 p++;
60bca95a 11926
11c1ff18
PB		 11927 while (len > 0)
11928 {
11929 int namelen;
11930 bfd_boolean public_section;
104d59d1 11931 bfd_boolean gnu_section;
11c1ff18
PB		 11932
11933 section_len = byte_get (p, 4);
11934 p += 4;
60bca95a 11935
11c1ff18
PB		 11936 if (section_len > len)
11937 {
11938 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11939 (int) section_len, (int) len);
11c1ff18
PB		 11940 section_len = len;
11941 }
60bca95a 11942
11c1ff18 11943 len -= section_len;
2b692964 11944 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11945
11946 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11947 public_section = TRUE;
11948 else
11949 public_section = FALSE;
60bca95a
NC		 11950
11951 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11952 gnu_section = TRUE;
11953 else
11954 gnu_section = FALSE;
60bca95a
NC		 11955
11956 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11957 p += namelen;
11958 section_len -= namelen + 4;
60bca95a 11959
11c1ff18
PB		 11960 while (section_len > 0)
11961 {
11962 int tag = *(p++);
11963 int val;
11964 bfd_vma size;
60bca95a 11965
11c1ff18
PB		 11966 size = byte_get (p, 4);
11967 if (size > section_len)
11968 {
11969 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11970 (int) size, (int) section_len);
11c1ff18
PB		 11971 size = section_len;
11972 }
60bca95a 11973
11c1ff18
PB		 11974 section_len -= size;
11975 end = p + size - 1;
11976 p += 4;
60bca95a 11977
11c1ff18
PB		 11978 switch (tag)
11979 {
11980 case 1:
2b692964 11981 printf (_("File Attributes\n"));
11c1ff18
PB		 11982 break;
11983 case 2:
2b692964 11984 printf (_("Section Attributes:"));
11c1ff18
PB		 11985 goto do_numlist;
11986 case 3:
2b692964 11987 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11988 do_numlist:
11989 for (;;)
11990 {
91d6fa6a 11991 unsigned int j;
60bca95a 11992
91d6fa6a
NC		 11993 val = read_uleb128 (p, &j);
11994 p += j;
11c1ff18
PB		 11995 if (val == 0)
11996 break;
11997 printf (" %d", val);
11998 }
11999 printf ("\n");
12000 break;
12001 default:
2b692964 12002 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 12003 public_section = FALSE;
12004 break;
12005 }
60bca95a 12006
11c1ff18
PB		 12007 if (public_section)
12008 {
12009 while (p < end)
104d59d1
JM		 12010 p = display_pub_attribute (p);
12011 }
12012 else if (gnu_section)
12013 {
12014 while (p < end)
12015 p = display_gnu_attribute (p,
12016 display_proc_gnu_attribute);
11c1ff18
PB		 12017 }
12018 else
12019 {
12020 /* ??? Do something sensible, like dump hex. */
2b692964 12021 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 12022 p = end;
12023 }
12024 }
12025 }
12026 }
12027 else
60bca95a 12028 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 12029
60bca95a 12030 free (contents);
11c1ff18
PB		 12031 }
12032 return 1;
12033}
12034
104d59d1 12035static int
2cf0635d 12036process_arm_specific (FILE * file)
104d59d1
JM		 12037{
12038 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12039 display_arm_attribute, NULL);
12040}
12041
34c8bcba 12042static int
2cf0635d 12043process_power_specific (FILE * file)
34c8bcba
JM		 12044{
12045 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12046 display_power_gnu_attribute);
12047}
12048
9e8c70f9
DM		 12049static int
12050process_sparc_specific (FILE * file)
12051{
12052 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12053 display_sparc_gnu_attribute);
12054}
12055
59e6276b
JM		 12056static int
12057process_tic6x_specific (FILE * file)
12058{
12059 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12060 display_tic6x_attribute, NULL);
12061}
12062
ccb4c951
RS		 12063/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12064 Print the Address, Access and Initial fields of an entry at VMA ADDR
12065 and return the VMA of the next entry. */
12066
12067static bfd_vma
2cf0635d 12068print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 12069{
12070 printf (" ");
12071 print_vma (addr, LONG_HEX);
12072 printf (" ");
12073 if (addr < pltgot + 0xfff0)
12074 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12075 else
12076 printf ("%10s", "");
12077 printf (" ");
12078 if (data == NULL)
2b692964 12079 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 12080 else
12081 {
12082 bfd_vma entry;
12083
12084 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12085 print_vma (entry, LONG_HEX);
12086 }
12087 return addr + (is_32bit_elf ? 4 : 8);
12088}
12089
861fb55a
DJ		 12090/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12091 PLTGOT. Print the Address and Initial fields of an entry at VMA
12092 ADDR and return the VMA of the next entry. */
12093
12094static bfd_vma
2cf0635d 12095print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 12096{
12097 printf (" ");
12098 print_vma (addr, LONG_HEX);
12099 printf (" ");
12100 if (data == NULL)
2b692964 12101 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 12102 else
12103 {
12104 bfd_vma entry;
12105
12106 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12107 print_vma (entry, LONG_HEX);
12108 }
12109 return addr + (is_32bit_elf ? 4 : 8);
12110}
12111
19e6b90e 12112static int
2cf0635d 12113process_mips_specific (FILE * file)
5b18a4bc 12114{
2cf0635d 12115 Elf_Internal_Dyn * entry;
19e6b90e
L		 12116 size_t liblist_offset = 0;
12117 size_t liblistno = 0;
12118 size_t conflictsno = 0;
12119 size_t options_offset = 0;
12120 size_t conflicts_offset = 0;
861fb55a
DJ		 12121 size_t pltrelsz = 0;
12122 size_t pltrel = 0;
ccb4c951 12123 bfd_vma pltgot = 0;
861fb55a
DJ		 12124 bfd_vma mips_pltgot = 0;
12125 bfd_vma jmprel = 0;
ccb4c951
RS		 12126 bfd_vma local_gotno = 0;
12127 bfd_vma gotsym = 0;
12128 bfd_vma symtabno = 0;
103f02d3 12129
2cf19d5c
JM		 12130 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12131 display_mips_gnu_attribute);
12132
19e6b90e
L		 12133 /* We have a lot of special sections. Thanks SGI! */
12134 if (dynamic_section == NULL)
12135 /* No information available. */
12136 return 0;
252b5132 12137
b2d38a17 12138 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 12139 switch (entry->d_tag)
12140 {
12141 case DT_MIPS_LIBLIST:
d93f0186
NC		 12142 liblist_offset
12143 = offset_from_vma (file, entry->d_un.d_val,
12144 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 12145 break;
12146 case DT_MIPS_LIBLISTNO:
12147 liblistno = entry->d_un.d_val;
12148 break;
12149 case DT_MIPS_OPTIONS:
d93f0186 12150 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 12151 break;
12152 case DT_MIPS_CONFLICT:
d93f0186
NC		 12153 conflicts_offset
12154 = offset_from_vma (file, entry->d_un.d_val,
12155 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 12156 break;
12157 case DT_MIPS_CONFLICTNO:
12158 conflictsno = entry->d_un.d_val;
12159 break;
ccb4c951 12160 case DT_PLTGOT:
861fb55a
DJ		 12161 pltgot = entry->d_un.d_ptr;
12162 break;
ccb4c951
RS		 12163 case DT_MIPS_LOCAL_GOTNO:
12164 local_gotno = entry->d_un.d_val;
12165 break;
12166 case DT_MIPS_GOTSYM:
12167 gotsym = entry->d_un.d_val;
12168 break;
12169 case DT_MIPS_SYMTABNO:
12170 symtabno = entry->d_un.d_val;
12171 break;
861fb55a
DJ		 12172 case DT_MIPS_PLTGOT:
12173 mips_pltgot = entry->d_un.d_ptr;
12174 break;
12175 case DT_PLTREL:
12176 pltrel = entry->d_un.d_val;
12177 break;
12178 case DT_PLTRELSZ:
12179 pltrelsz = entry->d_un.d_val;
12180 break;
12181 case DT_JMPREL:
12182 jmprel = entry->d_un.d_ptr;
12183 break;
252b5132
RH		 12184 default:
12185 break;
12186 }
12187
12188 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12189 {
2cf0635d 12190 Elf32_External_Lib * elib;
252b5132
RH		 12191 size_t cnt;
12192
3f5e193b
NC		 12193 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12194 liblistno,
12195 sizeof (Elf32_External_Lib),
9cf03b7e 12196 _("liblist section data"));
a6e9f9df 12197 if (elib)
252b5132 12198 {
2b692964 12199 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 12200 (unsigned long) liblistno);
2b692964 12201 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 12202 stdout);
12203
12204 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 12205 {
a6e9f9df 12206 Elf32_Lib liblist;
91d6fa6a 12207 time_t atime;
a6e9f9df 12208 char timebuf[20];
2cf0635d 12209 struct tm * tmp;
a6e9f9df
AM		 12210
12211 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12212 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 12213 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12214 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12215 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12216
91d6fa6a 12217 tmp = gmtime (&atime);
e9e44622
JJ		 12218 snprintf (timebuf, sizeof (timebuf),
12219 "%04u-%02u-%02uT%02u:%02u:%02u",
12220 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12221 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 12222
31104126 12223 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 12224 if (VALID_DYNAMIC_NAME (liblist.l_name))
12225 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12226 else
2b692964 12227 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 12228 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12229 liblist.l_version);
a6e9f9df
AM		 12230
12231 if (liblist.l_flags == 0)
2b692964 12232 puts (_(" NONE"));
a6e9f9df
AM		 12233 else
12234 {
12235 static const struct
252b5132 12236 {
2cf0635d 12237 const char * name;
a6e9f9df 12238 int bit;
252b5132 12239 }
a6e9f9df
AM		 12240 l_flags_vals[] =
12241 {
12242 { " EXACT_MATCH", LL_EXACT_MATCH },
12243 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12244 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12245 { " EXPORTS", LL_EXPORTS },
12246 { " DELAY_LOAD", LL_DELAY_LOAD },
12247 { " DELTA", LL_DELTA }
12248 };
12249 int flags = liblist.l_flags;
12250 size_t fcnt;
12251
60bca95a 12252 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12253 if ((flags & l_flags_vals[fcnt].bit) != 0)
12254 {
12255 fputs (l_flags_vals[fcnt].name, stdout);
12256 flags ^= l_flags_vals[fcnt].bit;
12257 }
12258 if (flags != 0)
12259 printf (" %#x", (unsigned int) flags);
252b5132 12260
a6e9f9df
AM		 12261 puts ("");
12262 }
252b5132 12263 }
252b5132 12264
a6e9f9df
AM		 12265 free (elib);
12266 }
252b5132
RH		 12267 }
12268
12269 if (options_offset != 0)
12270 {
2cf0635d
NC		 12271 Elf_External_Options * eopt;
12272 Elf_Internal_Shdr * sect = section_headers;
12273 Elf_Internal_Options * iopt;
12274 Elf_Internal_Options * option;
252b5132
RH		 12275 size_t offset;
12276 int cnt;
12277
12278 /* Find the section header so that we get the size. */
12279 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12280 ++sect;
252b5132 12281
3f5e193b
NC		 12282 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12283 sect->sh_size, _("options"));
a6e9f9df 12284 if (eopt)
252b5132 12285 {
3f5e193b
NC		 12286 iopt = (Elf_Internal_Options *)
12287 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 12288 if (iopt == NULL)
12289 {
591a748a 12290 error (_("Out of memory\n"));
a6e9f9df
AM		 12291 return 0;
12292 }
76da6bbe 12293
a6e9f9df
AM		 12294 offset = cnt = 0;
12295 option = iopt;
252b5132 12296
a6e9f9df
AM		 12297 while (offset < sect->sh_size)
12298 {
2cf0635d 12299 Elf_External_Options * eoption;
252b5132 12300
a6e9f9df 12301 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12302
a6e9f9df
AM		 12303 option->kind = BYTE_GET (eoption->kind);
12304 option->size = BYTE_GET (eoption->size);
12305 option->section = BYTE_GET (eoption->section);
12306 option->info = BYTE_GET (eoption->info);
76da6bbe 12307
a6e9f9df 12308 offset += option->size;
252b5132 12309
a6e9f9df
AM		 12310 ++option;
12311 ++cnt;
12312 }
252b5132 12313
a6e9f9df
AM		 12314 printf (_("\nSection '%s' contains %d entries:\n"),
12315 SECTION_NAME (sect), cnt);
76da6bbe 12316
a6e9f9df 12317 option = iopt;
252b5132 12318
a6e9f9df 12319 while (cnt-- > 0)
252b5132 12320 {
a6e9f9df
AM		 12321 size_t len;
12322
12323 switch (option->kind)
252b5132 12324 {
a6e9f9df
AM		 12325 case ODK_NULL:
12326 /* This shouldn't happen. */
12327 printf (" NULL %d %lx", option->section, option->info);
12328 break;
12329 case ODK_REGINFO:
12330 printf (" REGINFO ");
12331 if (elf_header.e_machine == EM_MIPS)
12332 {
12333 /* 32bit form. */
2cf0635d 12334 Elf32_External_RegInfo * ereg;
b34976b6 12335 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12336
12337 ereg = (Elf32_External_RegInfo *) (option + 1);
12338 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12339 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12340 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12341 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12342 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12343 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12344
12345 printf ("GPR %08lx GP 0x%lx\n",
12346 reginfo.ri_gprmask,
12347 (unsigned long) reginfo.ri_gp_value);
12348 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12349 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12350 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12351 }
12352 else
12353 {
12354 /* 64 bit form. */
2cf0635d 12355 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12356 Elf64_Internal_RegInfo reginfo;
12357
12358 ereg = (Elf64_External_RegInfo *) (option + 1);
12359 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12360 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12361 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12362 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12363 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12364 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12365
12366 printf ("GPR %08lx GP 0x",
12367 reginfo.ri_gprmask);
12368 printf_vma (reginfo.ri_gp_value);
12369 printf ("\n");
12370
12371 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12372 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12373 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12374 }
12375 ++option;
12376 continue;
12377 case ODK_EXCEPTIONS:
12378 fputs (" EXCEPTIONS fpe_min(", stdout);
12379 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12380 fputs (") fpe_max(", stdout);
12381 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12382 fputs (")", stdout);
12383
12384 if (option->info & OEX_PAGE0)
12385 fputs (" PAGE0", stdout);
12386 if (option->info & OEX_SMM)
12387 fputs (" SMM", stdout);
12388 if (option->info & OEX_FPDBUG)
12389 fputs (" FPDBUG", stdout);
12390 if (option->info & OEX_DISMISS)
12391 fputs (" DISMISS", stdout);
12392 break;
12393 case ODK_PAD:
12394 fputs (" PAD ", stdout);
12395 if (option->info & OPAD_PREFIX)
12396 fputs (" PREFIX", stdout);
12397 if (option->info & OPAD_POSTFIX)
12398 fputs (" POSTFIX", stdout);
12399 if (option->info & OPAD_SYMBOL)
12400 fputs (" SYMBOL", stdout);
12401 break;
12402 case ODK_HWPATCH:
12403 fputs (" HWPATCH ", stdout);
12404 if (option->info & OHW_R4KEOP)
12405 fputs (" R4KEOP", stdout);
12406 if (option->info & OHW_R8KPFETCH)
12407 fputs (" R8KPFETCH", stdout);
12408 if (option->info & OHW_R5KEOP)
12409 fputs (" R5KEOP", stdout);
12410 if (option->info & OHW_R5KCVTL)
12411 fputs (" R5KCVTL", stdout);
12412 break;
12413 case ODK_FILL:
12414 fputs (" FILL ", stdout);
12415 /* XXX Print content of info word? */
12416 break;
12417 case ODK_TAGS:
12418 fputs (" TAGS ", stdout);
12419 /* XXX Print content of info word? */
12420 break;
12421 case ODK_HWAND:
12422 fputs (" HWAND ", stdout);
12423 if (option->info & OHWA0_R4KEOP_CHECKED)
12424 fputs (" R4KEOP_CHECKED", stdout);
12425 if (option->info & OHWA0_R4KEOP_CLEAN)
12426 fputs (" R4KEOP_CLEAN", stdout);
12427 break;
12428 case ODK_HWOR:
12429 fputs (" HWOR ", stdout);
12430 if (option->info & OHWA0_R4KEOP_CHECKED)
12431 fputs (" R4KEOP_CHECKED", stdout);
12432 if (option->info & OHWA0_R4KEOP_CLEAN)
12433 fputs (" R4KEOP_CLEAN", stdout);
12434 break;
12435 case ODK_GP_GROUP:
12436 printf (" GP_GROUP %#06lx self-contained %#06lx",
12437 option->info & OGP_GROUP,
12438 (option->info & OGP_SELF) >> 16);
12439 break;
12440 case ODK_IDENT:
12441 printf (" IDENT %#06lx self-contained %#06lx",
12442 option->info & OGP_GROUP,
12443 (option->info & OGP_SELF) >> 16);
12444 break;
12445 default:
12446 /* This shouldn't happen. */
12447 printf (" %3d ??? %d %lx",
12448 option->kind, option->section, option->info);
12449 break;
252b5132 12450 }
a6e9f9df 12451
2cf0635d 12452 len = sizeof (* eopt);
a6e9f9df
AM		 12453 while (len < option->size)
12454 if (((char *) option)[len] >= ' '
12455 && ((char *) option)[len] < 0x7f)
12456 printf ("%c", ((char *) option)[len++]);
12457 else
12458 printf ("\\%03o", ((char *) option)[len++]);
12459
12460 fputs ("\n", stdout);
252b5132 12461 ++option;
252b5132
RH		 12462 }
12463
a6e9f9df 12464 free (eopt);
252b5132 12465 }
252b5132
RH		 12466 }
12467
12468 if (conflicts_offset != 0 && conflictsno != 0)
12469 {
2cf0635d 12470 Elf32_Conflict * iconf;
252b5132
RH		 12471 size_t cnt;
12472
12473 if (dynamic_symbols == NULL)
12474 {
591a748a 12475 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12476 return 0;
12477 }
12478
3f5e193b 12479 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12480 if (iconf == NULL)
12481 {
591a748a 12482 error (_("Out of memory\n"));
252b5132
RH		 12483 return 0;
12484 }
12485
9ea033b2 12486 if (is_32bit_elf)
252b5132 12487 {
2cf0635d 12488 Elf32_External_Conflict * econf32;
a6e9f9df 12489
3f5e193b
NC		 12490 econf32 = (Elf32_External_Conflict *)
12491 get_data (NULL, file, conflicts_offset, conflictsno,
12492 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12493 if (!econf32)
12494 return 0;
252b5132
RH		 12495
12496 for (cnt = 0; cnt < conflictsno; ++cnt)
12497 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12498
12499 free (econf32);
252b5132
RH		 12500 }
12501 else
12502 {
2cf0635d 12503 Elf64_External_Conflict * econf64;
a6e9f9df 12504
3f5e193b
NC		 12505 econf64 = (Elf64_External_Conflict *)
12506 get_data (NULL, file, conflicts_offset, conflictsno,
12507 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12508 if (!econf64)
12509 return 0;
252b5132
RH		 12510
12511 for (cnt = 0; cnt < conflictsno; ++cnt)
12512 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12513
12514 free (econf64);
252b5132
RH		 12515 }
12516
c7e7ca54
NC		 12517 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12518 (unsigned long) conflictsno);
252b5132
RH		 12519 puts (_(" Num: Index Value Name"));
12520
12521 for (cnt = 0; cnt < conflictsno; ++cnt)
12522 {
2cf0635d 12523 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12524
b34976b6 12525 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12526 print_vma (psym->st_value, FULL_HEX);
31104126 12527 putchar (' ');
d79b3d50
NC		 12528 if (VALID_DYNAMIC_NAME (psym->st_name))
12529 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12530 else
2b692964 12531 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12532 putchar ('\n');
252b5132
RH		 12533 }
12534
252b5132
RH		 12535 free (iconf);
12536 }
12537
ccb4c951
RS		 12538 if (pltgot != 0 && local_gotno != 0)
12539 {
91d6fa6a 12540 bfd_vma ent, local_end, global_end;
bbeee7ea 12541 size_t i, offset;
2cf0635d 12542 unsigned char * data;
bbeee7ea 12543 int addr_size;
ccb4c951 12544
91d6fa6a 12545 ent = pltgot;
ccb4c951
RS		 12546 addr_size = (is_32bit_elf ? 4 : 8);
12547 local_end = pltgot + local_gotno * addr_size;
12548 global_end = local_end + (symtabno - gotsym) * addr_size;
12549
12550 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12551 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 12552 global_end - pltgot, 1,
12553 _("Global Offset Table data"));
59245841
NC		 12554 if (data == NULL)
12555 return 0;
12556
ccb4c951
RS		 12557 printf (_("\nPrimary GOT:\n"));
12558 printf (_(" Canonical gp value: "));
12559 print_vma (pltgot + 0x7ff0, LONG_HEX);
12560 printf ("\n\n");
12561
12562 printf (_(" Reserved entries:\n"));
12563 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12564 addr_size * 2, _("Address"), _("Access"),
12565 addr_size * 2, _("Initial"));
91d6fa6a 12566 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12567 printf (_(" Lazy resolver\n"));
ccb4c951 12568 if (data
91d6fa6a 12569 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12570 >> (addr_size * 8 - 1)) != 0)
12571 {
91d6fa6a 12572 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12573 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12574 }
12575 printf ("\n");
12576
91d6fa6a 12577 if (ent < local_end)
ccb4c951
RS		 12578 {
12579 printf (_(" Local entries:\n"));
cc5914eb 12580 printf (" %*s %10s %*s\n",
2b692964
NC		 12581 addr_size * 2, _("Address"), _("Access"),
12582 addr_size * 2, _("Initial"));
91d6fa6a 12583 while (ent < local_end)
ccb4c951 12584 {
91d6fa6a 12585 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12586 printf ("\n");
12587 }
12588 printf ("\n");
12589 }
12590
12591 if (gotsym < symtabno)
12592 {
12593 int sym_width;
12594
12595 printf (_(" Global entries:\n"));
cc5914eb 12596 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 12597 addr_size * 2, _("Address"),
12598 _("Access"),
2b692964 12599 addr_size * 2, _("Initial"),
9cf03b7e
NC		 12600 addr_size * 2, _("Sym.Val."),
12601 _("Type"),
12602 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12603 _("Ndx"), _("Name"));
12604
ccb4c951
RS		 12605 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12606 for (i = gotsym; i < symtabno; i++)
12607 {
2cf0635d 12608 Elf_Internal_Sym * psym;
ccb4c951
RS		 12609
12610 psym = dynamic_symbols + i;
91d6fa6a 12611 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12612 printf (" ");
12613 print_vma (psym->st_value, LONG_HEX);
12614 printf (" %-7s %3s ",
12615 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12616 get_symbol_index_type (psym->st_shndx));
12617 if (VALID_DYNAMIC_NAME (psym->st_name))
12618 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12619 else
2b692964 12620 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12621 printf ("\n");
12622 }
12623 printf ("\n");
12624 }
12625
12626 if (data)
12627 free (data);
12628 }
12629
861fb55a
DJ		 12630 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12631 {
91d6fa6a 12632 bfd_vma ent, end;
861fb55a
DJ		 12633 size_t offset, rel_offset;
12634 unsigned long count, i;
2cf0635d 12635 unsigned char * data;
861fb55a 12636 int addr_size, sym_width;
2cf0635d 12637 Elf_Internal_Rela * rels;
861fb55a
DJ		 12638
12639 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12640 if (pltrel == DT_RELA)
12641 {
12642 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12643 return 0;
12644 }
12645 else
12646 {
12647 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12648 return 0;
12649 }
12650
91d6fa6a 12651 ent = mips_pltgot;
861fb55a
DJ		 12652 addr_size = (is_32bit_elf ? 4 : 8);
12653 end = mips_pltgot + (2 + count) * addr_size;
12654
12655 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12656 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12657 1, _("Procedure Linkage Table data"));
59245841
NC		 12658 if (data == NULL)
12659 return 0;
12660
9cf03b7e 12661 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 12662 printf (_(" Reserved entries:\n"));
12663 printf (_(" %*s %*s Purpose\n"),
2b692964 12664 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12665 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12666 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12667 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12668 printf (_(" Module pointer\n"));
861fb55a
DJ		 12669 printf ("\n");
12670
12671 printf (_(" Entries:\n"));
cc5914eb 12672 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12673 addr_size * 2, _("Address"),
12674 addr_size * 2, _("Initial"),
12675 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12676 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12677 for (i = 0; i < count; i++)
12678 {
2cf0635d 12679 Elf_Internal_Sym * psym;
861fb55a
DJ		 12680
12681 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12682 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12683 printf (" ");
12684 print_vma (psym->st_value, LONG_HEX);
12685 printf (" %-7s %3s ",
12686 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12687 get_symbol_index_type (psym->st_shndx));
12688 if (VALID_DYNAMIC_NAME (psym->st_name))
12689 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12690 else
2b692964 12691 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12692 printf ("\n");
12693 }
12694 printf ("\n");
12695
12696 if (data)
12697 free (data);
12698 free (rels);
12699 }
12700
252b5132
RH		 12701 return 1;
12702}
12703
047b2264 12704static int
2cf0635d 12705process_gnu_liblist (FILE * file)
047b2264 12706{
2cf0635d
NC		 12707 Elf_Internal_Shdr * section;
12708 Elf_Internal_Shdr * string_sec;
12709 Elf32_External_Lib * elib;
12710 char * strtab;
c256ffe7 12711 size_t strtab_size;
047b2264
JJ		 12712 size_t cnt;
12713 unsigned i;
12714
12715 if (! do_arch)
12716 return 0;
12717
12718 for (i = 0, section = section_headers;
12719 i < elf_header.e_shnum;
b34976b6 12720 i++, section++)
047b2264
JJ		 12721 {
12722 switch (section->sh_type)
12723 {
12724 case SHT_GNU_LIBLIST:
4fbb74a6 12725 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12726 break;
12727
3f5e193b
NC		 12728 elib = (Elf32_External_Lib *)
12729 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 12730 _("liblist section data"));
047b2264
JJ		 12731
12732 if (elib == NULL)
12733 break;
4fbb74a6 12734 string_sec = section_headers + section->sh_link;
047b2264 12735
3f5e193b
NC		 12736 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12737 string_sec->sh_size,
12738 _("liblist string table"));
047b2264
JJ		 12739 if (strtab == NULL
12740 || section->sh_entsize != sizeof (Elf32_External_Lib))
12741 {
12742 free (elib);
2842702f 12743 free (strtab);
047b2264
JJ		 12744 break;
12745 }
59245841 12746 strtab_size = string_sec->sh_size;
047b2264
JJ		 12747
12748 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12749 SECTION_NAME (section),
0af1713e 12750 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12751
2b692964 12752 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12753
12754 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12755 ++cnt)
12756 {
12757 Elf32_Lib liblist;
91d6fa6a 12758 time_t atime;
047b2264 12759 char timebuf[20];
2cf0635d 12760 struct tm * tmp;
047b2264
JJ		 12761
12762 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12763 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12764 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12765 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12766 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12767
91d6fa6a 12768 tmp = gmtime (&atime);
e9e44622
JJ		 12769 snprintf (timebuf, sizeof (timebuf),
12770 "%04u-%02u-%02uT%02u:%02u:%02u",
12771 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12772 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12773
12774 printf ("%3lu: ", (unsigned long) cnt);
12775 if (do_wide)
c256ffe7 12776 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12777 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12778 else
c256ffe7 12779 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12780 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12781 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12782 liblist.l_version, liblist.l_flags);
12783 }
12784
12785 free (elib);
2842702f 12786 free (strtab);
047b2264
JJ		 12787 }
12788 }
12789
12790 return 1;
12791}
12792
9437c45b 12793static const char *
d3ba0551 12794get_note_type (unsigned e_type)
779fe533
NC		 12795{
12796 static char buff[64];
103f02d3 12797
1ec5cd37
NC		 12798 if (elf_header.e_type == ET_CORE)
12799 switch (e_type)
12800 {
57346661 12801 case NT_AUXV:
1ec5cd37 12802 return _("NT_AUXV (auxiliary vector)");
57346661 12803 case NT_PRSTATUS:
1ec5cd37 12804 return _("NT_PRSTATUS (prstatus structure)");
57346661 12805 case NT_FPREGSET:
1ec5cd37 12806 return _("NT_FPREGSET (floating point registers)");
57346661 12807 case NT_PRPSINFO:
1ec5cd37 12808 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12809 case NT_TASKSTRUCT:
1ec5cd37 12810 return _("NT_TASKSTRUCT (task structure)");
57346661 12811 case NT_PRXFPREG:
1ec5cd37 12812 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12813 case NT_PPC_VMX:
12814 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12815 case NT_PPC_VSX:
12816 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 12817 case NT_386_TLS:
12818 return _("NT_386_TLS (x86 TLS information)");
12819 case NT_386_IOPERM:
12820 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 12821 case NT_X86_XSTATE:
12822 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12823 case NT_S390_HIGH_GPRS:
12824 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12825 case NT_S390_TIMER:
12826 return _("NT_S390_TIMER (s390 timer register)");
12827 case NT_S390_TODCMP:
12828 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12829 case NT_S390_TODPREG:
12830 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12831 case NT_S390_CTRS:
12832 return _("NT_S390_CTRS (s390 control registers)");
12833 case NT_S390_PREFIX:
12834 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 12835 case NT_S390_LAST_BREAK:
12836 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
12837 case NT_S390_SYSTEM_CALL:
12838 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
faa9a424
UW		 12839 case NT_ARM_VFP:
12840 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 12841 case NT_ARM_TLS:
12842 return _("NT_ARM_TLS (AArch TLS registers)");
12843 case NT_ARM_HW_BREAK:
12844 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12845 case NT_ARM_HW_WATCH:
12846 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 12847 case NT_PSTATUS:
1ec5cd37 12848 return _("NT_PSTATUS (pstatus structure)");
57346661 12849 case NT_FPREGS:
1ec5cd37 12850 return _("NT_FPREGS (floating point registers)");
57346661 12851 case NT_PSINFO:
1ec5cd37 12852 return _("NT_PSINFO (psinfo structure)");
57346661 12853 case NT_LWPSTATUS:
1ec5cd37 12854 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12855 case NT_LWPSINFO:
1ec5cd37 12856 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12857 case NT_WIN32PSTATUS:
1ec5cd37 12858 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 12859 case NT_SIGINFO:
12860 return _("NT_SIGINFO (siginfo_t data)");
12861 case NT_FILE:
12862 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 12863 default:
12864 break;
12865 }
12866 else
12867 switch (e_type)
12868 {
12869 case NT_VERSION:
12870 return _("NT_VERSION (version)");
12871 case NT_ARCH:
12872 return _("NT_ARCH (architecture)");
12873 default:
12874 break;
12875 }
12876
e9e44622 12877 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12878 return buff;
779fe533
NC		 12879}
12880
9ece1fa9
TT		 12881static int
12882print_core_note (Elf_Internal_Note *pnote)
12883{
12884 unsigned int addr_size = is_32bit_elf ? 4 : 8;
12885 bfd_vma count, page_size;
12886 unsigned char *descdata, *filenames, *descend;
12887
12888 if (pnote->type != NT_FILE)
12889 return 1;
12890
12891#ifndef BFD64
12892 if (!is_32bit_elf)
12893 {
12894 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12895 /* Still "successful". */
12896 return 1;
12897 }
12898#endif
12899
12900 if (pnote->descsz < 2 * addr_size)
12901 {
12902 printf (_(" Malformed note - too short for header\n"));
12903 return 0;
12904 }
12905
12906 descdata = (unsigned char *) pnote->descdata;
12907 descend = descdata + pnote->descsz;
12908
12909 if (descdata[pnote->descsz - 1] != '\0')
12910 {
12911 printf (_(" Malformed note - does not end with \\0\n"));
12912 return 0;
12913 }
12914
12915 count = byte_get (descdata, addr_size);
12916 descdata += addr_size;
12917
12918 page_size = byte_get (descdata, addr_size);
12919 descdata += addr_size;
12920
12921 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12922 {
12923 printf (_(" Malformed note - too short for supplied file count\n"));
12924 return 0;
12925 }
12926
12927 printf (_(" Page size: "));
12928 print_vma (page_size, DEC);
12929 printf ("\n");
12930
12931 printf (_(" %*s%*s%*s\n"),
12932 (int) (2 + 2 * addr_size), _("Start"),
12933 (int) (4 + 2 * addr_size), _("End"),
12934 (int) (4 + 2 * addr_size), _("Page Offset"));
12935 filenames = descdata + count * 3 * addr_size;
12936 while (--count > 0)
12937 {
12938 bfd_vma start, end, file_ofs;
12939
12940 if (filenames == descend)
12941 {
12942 printf (_(" Malformed note - filenames end too early\n"));
12943 return 0;
12944 }
12945
12946 start = byte_get (descdata, addr_size);
12947 descdata += addr_size;
12948 end = byte_get (descdata, addr_size);
12949 descdata += addr_size;
12950 file_ofs = byte_get (descdata, addr_size);
12951 descdata += addr_size;
12952
12953 printf (" ");
12954 print_vma (start, FULL_HEX);
12955 printf (" ");
12956 print_vma (end, FULL_HEX);
12957 printf (" ");
12958 print_vma (file_ofs, FULL_HEX);
12959 printf ("\n %s\n", filenames);
12960
12961 filenames += 1 + strlen ((char *) filenames);
12962 }
12963
12964 return 1;
12965}
12966
1118d252
RM		 12967static const char *
12968get_gnu_elf_note_type (unsigned e_type)
12969{
12970 static char buff[64];
12971
12972 switch (e_type)
12973 {
12974 case NT_GNU_ABI_TAG:
12975 return _("NT_GNU_ABI_TAG (ABI version tag)");
12976 case NT_GNU_HWCAP:
12977 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12978 case NT_GNU_BUILD_ID:
12979 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12980 case NT_GNU_GOLD_VERSION:
12981 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12982 default:
12983 break;
12984 }
12985
12986 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12987 return buff;
12988}
12989
664f90a3
TT		 12990static int
12991print_gnu_note (Elf_Internal_Note *pnote)
12992{
12993 switch (pnote->type)
12994 {
12995 case NT_GNU_BUILD_ID:
12996 {
12997 unsigned long i;
12998
12999 printf (_(" Build ID: "));
13000 for (i = 0; i < pnote->descsz; ++i)
13001 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 13002 printf ("\n");
664f90a3
TT		 13003 }
13004 break;
13005
13006 case NT_GNU_ABI_TAG:
13007 {
13008 unsigned long os, major, minor, subminor;
13009 const char *osname;
13010
13011 os = byte_get ((unsigned char *) pnote->descdata, 4);
13012 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13013 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13014 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13015
13016 switch (os)
13017 {
13018 case GNU_ABI_TAG_LINUX:
13019 osname = "Linux";
13020 break;
13021 case GNU_ABI_TAG_HURD:
13022 osname = "Hurd";
13023 break;
13024 case GNU_ABI_TAG_SOLARIS:
13025 osname = "Solaris";
13026 break;
13027 case GNU_ABI_TAG_FREEBSD:
13028 osname = "FreeBSD";
13029 break;
13030 case GNU_ABI_TAG_NETBSD:
13031 osname = "NetBSD";
13032 break;
13033 default:
13034 osname = "Unknown";
13035 break;
13036 }
13037
13038 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13039 major, minor, subminor);
13040 }
13041 break;
13042 }
13043
13044 return 1;
13045}
13046
9437c45b 13047static const char *
d3ba0551 13048get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 13049{
13050 static char buff[64];
13051
b4db1224 13052 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 13053 {
13054 /* NetBSD core "procinfo" structure. */
13055 return _("NetBSD procinfo structure");
13056 }
13057
13058 /* As of Jan 2002 there are no other machine-independent notes
13059 defined for NetBSD core files. If the note type is less
13060 than the start of the machine-dependent note types, we don't
13061 understand it. */
13062
b4db1224 13063 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 13064 {
e9e44622 13065 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 13066 return buff;
13067 }
13068
13069 switch (elf_header.e_machine)
13070 {
13071 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13072 and PT_GETFPREGS == mach+2. */
13073
13074 case EM_OLD_ALPHA:
13075 case EM_ALPHA:
13076 case EM_SPARC:
13077 case EM_SPARC32PLUS:
13078 case EM_SPARCV9:
13079 switch (e_type)
13080 {
2b692964 13081 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 13082 return _("PT_GETREGS (reg structure)");
2b692964 13083 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 13084 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13085 default:
13086 break;
13087 }
13088 break;
13089
13090 /* On all other arch's, PT_GETREGS == mach+1 and
13091 PT_GETFPREGS == mach+3. */
13092 default:
13093 switch (e_type)
13094 {
2b692964 13095 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 13096 return _("PT_GETREGS (reg structure)");
2b692964 13097 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 13098 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13099 default:
13100 break;
13101 }
13102 }
13103
9cf03b7e 13104 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 13105 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 13106 return buff;
13107}
13108
70616151
TT		 13109static const char *
13110get_stapsdt_note_type (unsigned e_type)
13111{
13112 static char buff[64];
13113
13114 switch (e_type)
13115 {
13116 case NT_STAPSDT:
13117 return _("NT_STAPSDT (SystemTap probe descriptors)");
13118
13119 default:
13120 break;
13121 }
13122
13123 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13124 return buff;
13125}
13126
c6a9fc58
TT		 13127static int
13128print_stapsdt_note (Elf_Internal_Note *pnote)
13129{
13130 int addr_size = is_32bit_elf ? 4 : 8;
13131 char *data = pnote->descdata;
13132 char *data_end = pnote->descdata + pnote->descsz;
13133 bfd_vma pc, base_addr, semaphore;
13134 char *provider, *probe, *arg_fmt;
13135
13136 pc = byte_get ((unsigned char *) data, addr_size);
13137 data += addr_size;
13138 base_addr = byte_get ((unsigned char *) data, addr_size);
13139 data += addr_size;
13140 semaphore = byte_get ((unsigned char *) data, addr_size);
13141 data += addr_size;
13142
13143 provider = data;
13144 data += strlen (data) + 1;
13145 probe = data;
13146 data += strlen (data) + 1;
13147 arg_fmt = data;
13148 data += strlen (data) + 1;
13149
13150 printf (_(" Provider: %s\n"), provider);
13151 printf (_(" Name: %s\n"), probe);
13152 printf (_(" Location: "));
13153 print_vma (pc, FULL_HEX);
13154 printf (_(", Base: "));
13155 print_vma (base_addr, FULL_HEX);
13156 printf (_(", Semaphore: "));
13157 print_vma (semaphore, FULL_HEX);
9cf03b7e 13158 printf ("\n");
c6a9fc58
TT		 13159 printf (_(" Arguments: %s\n"), arg_fmt);
13160
13161 return data == data_end;
13162}
13163
00e98fc7
TG		 13164static const char *
13165get_ia64_vms_note_type (unsigned e_type)
13166{
13167 static char buff[64];
13168
13169 switch (e_type)
13170 {
13171 case NT_VMS_MHD:
13172 return _("NT_VMS_MHD (module header)");
13173 case NT_VMS_LNM:
13174 return _("NT_VMS_LNM (language name)");
13175 case NT_VMS_SRC:
13176 return _("NT_VMS_SRC (source files)");
13177 case NT_VMS_TITLE:
9cf03b7e 13178 return "NT_VMS_TITLE";
00e98fc7
TG		 13179 case NT_VMS_EIDC:
13180 return _("NT_VMS_EIDC (consistency check)");
13181 case NT_VMS_FPMODE:
13182 return _("NT_VMS_FPMODE (FP mode)");
13183 case NT_VMS_LINKTIME:
9cf03b7e 13184 return "NT_VMS_LINKTIME";
00e98fc7
TG		 13185 case NT_VMS_IMGNAM:
13186 return _("NT_VMS_IMGNAM (image name)");
13187 case NT_VMS_IMGID:
13188 return _("NT_VMS_IMGID (image id)");
13189 case NT_VMS_LINKID:
13190 return _("NT_VMS_LINKID (link id)");
13191 case NT_VMS_IMGBID:
13192 return _("NT_VMS_IMGBID (build id)");
13193 case NT_VMS_GSTNAM:
13194 return _("NT_VMS_GSTNAM (sym table name)");
13195 case NT_VMS_ORIG_DYN:
9cf03b7e 13196 return "NT_VMS_ORIG_DYN";
00e98fc7 13197 case NT_VMS_PATCHTIME:
9cf03b7e 13198 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 13199 default:
13200 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13201 return buff;
13202 }
13203}
13204
13205static int
13206print_ia64_vms_note (Elf_Internal_Note * pnote)
13207{
13208 switch (pnote->type)
13209 {
13210 case NT_VMS_MHD:
13211 if (pnote->descsz > 36)
13212 {
13213 size_t l = strlen (pnote->descdata + 34);
13214 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13215 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13216 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13217 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13218 }
13219 else
13220 printf (_(" Invalid size\n"));
13221 break;
13222 case NT_VMS_LNM:
13223 printf (_(" Language: %s\n"), pnote->descdata);
13224 break;
13225#ifdef BFD64
13226 case NT_VMS_FPMODE:
9cf03b7e 13227 printf (_(" Floating Point mode: "));
4a5cb34f 13228 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13229 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13230 break;
13231 case NT_VMS_LINKTIME:
13232 printf (_(" Link time: "));
13233 print_vms_time
13234 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13235 printf ("\n");
13236 break;
13237 case NT_VMS_PATCHTIME:
13238 printf (_(" Patch time: "));
13239 print_vms_time
13240 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13241 printf ("\n");
13242 break;
13243 case NT_VMS_ORIG_DYN:
13244 printf (_(" Major id: %u, minor id: %u\n"),
13245 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13246 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 13247 printf (_(" Last modified : "));
00e98fc7
TG		 13248 print_vms_time
13249 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 13250 printf (_("\n Link flags : "));
4a5cb34f 13251 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13252 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13253 printf (_(" Header flags: 0x%08x\n"),
13254 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13255 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13256 break;
13257#endif
13258 case NT_VMS_IMGNAM:
13259 printf (_(" Image name: %s\n"), pnote->descdata);
13260 break;
13261 case NT_VMS_GSTNAM:
13262 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13263 break;
13264 case NT_VMS_IMGID:
13265 printf (_(" Image id: %s\n"), pnote->descdata);
13266 break;
13267 case NT_VMS_LINKID:
13268 printf (_(" Linker id: %s\n"), pnote->descdata);
13269 break;
13270 default:
13271 break;
13272 }
13273 return 1;
13274}
13275
6d118b09
NC		 13276/* Note that by the ELF standard, the name field is already null byte
13277 terminated, and namesz includes the terminating null byte.
13278 I.E. the value of namesz for the name "FSF" is 4.
13279
e3c8793a 13280 If the value of namesz is zero, there is no name present. */
779fe533 13281static int
2cf0635d 13282process_note (Elf_Internal_Note * pnote)
779fe533 13283{
2cf0635d
NC		 13284 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13285 const char * nt;
9437c45b
JT		 13286
13287 if (pnote->namesz == 0)
1ec5cd37
NC		 13288 /* If there is no note name, then use the default set of
13289 note type strings. */
13290 nt = get_note_type (pnote->type);
13291
1118d252
RM		 13292 else if (const_strneq (pnote->namedata, "GNU"))
13293 /* GNU-specific object file notes. */
13294 nt = get_gnu_elf_note_type (pnote->type);
13295
0112cd26 13296 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 13297 /* NetBSD-specific core file notes. */
13298 nt = get_netbsd_elfcore_note_type (pnote->type);
13299
b15fa79e
AM		 13300 else if (strneq (pnote->namedata, "SPU/", 4))
13301 {
13302 /* SPU-specific core file notes. */
13303 nt = pnote->namedata + 4;
13304 name = "SPU";
13305 }
13306
00e98fc7
TG		 13307 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13308 /* VMS/ia64-specific file notes. */
13309 nt = get_ia64_vms_note_type (pnote->type);
13310
70616151
TT		 13311 else if (const_strneq (pnote->namedata, "stapsdt"))
13312 nt = get_stapsdt_note_type (pnote->type);
13313
9437c45b 13314 else
1ec5cd37
NC		 13315 /* Don't recognize this note name; just use the default set of
13316 note type strings. */
00e98fc7 13317 nt = get_note_type (pnote->type);
9437c45b 13318
2aee03ae 13319 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 13320
13321 if (const_strneq (pnote->namedata, "IPF/VMS"))
13322 return print_ia64_vms_note (pnote);
664f90a3
TT		 13323 else if (const_strneq (pnote->namedata, "GNU"))
13324 return print_gnu_note (pnote);
c6a9fc58
TT		 13325 else if (const_strneq (pnote->namedata, "stapsdt"))
13326 return print_stapsdt_note (pnote);
9ece1fa9
TT		 13327 else if (const_strneq (pnote->namedata, "CORE"))
13328 return print_core_note (pnote);
00e98fc7
TG		 13329 else
13330 return 1;
779fe533
NC		 13331}
13332
6d118b09 13333
779fe533 13334static int
2cf0635d 13335process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 13336{
2cf0635d
NC		 13337 Elf_External_Note * pnotes;
13338 Elf_External_Note * external;
b34976b6 13339 int res = 1;
103f02d3 13340
779fe533
NC		 13341 if (length <= 0)
13342 return 0;
103f02d3 13343
3f5e193b
NC		 13344 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13345 _("notes"));
dd24e3da 13346 if (pnotes == NULL)
a6e9f9df 13347 return 0;
779fe533 13348
103f02d3 13349 external = pnotes;
103f02d3 13350
305c7206 13351 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13352 (unsigned long) offset, (unsigned long) length);
2aee03ae 13353 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13354
2cf0635d 13355 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 13356 {
2cf0635d 13357 Elf_External_Note * next;
b34976b6 13358 Elf_Internal_Note inote;
2cf0635d 13359 char * temp = NULL;
6d118b09 13360
00e98fc7
TG		 13361 if (!is_ia64_vms ())
13362 {
13363 inote.type = BYTE_GET (external->type);
13364 inote.namesz = BYTE_GET (external->namesz);
13365 inote.namedata = external->name;
13366 inote.descsz = BYTE_GET (external->descsz);
13367 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13368 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13369
13370 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13371 }
13372 else
13373 {
13374 Elf64_External_VMS_Note *vms_external;
13375
13376 vms_external = (Elf64_External_VMS_Note *)external;
13377 inote.type = BYTE_GET (vms_external->type);
13378 inote.namesz = BYTE_GET (vms_external->namesz);
13379 inote.namedata = vms_external->name;
13380 inote.descsz = BYTE_GET (vms_external->descsz);
13381 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13382 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13383
13384 next = (Elf_External_Note *)
13385 (inote.descdata + align_power (inote.descsz, 3));
13386 }
3e55a963 13387
dd24e3da
NC		 13388 if ( ((char *) next > ((char *) pnotes) + length)
13389 || ((char *) next < (char *) pnotes))
3e55a963 13390 {
0fd3a477 13391 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 13392 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 13393 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 13394 inote.type, inote.namesz, inote.descsz);
13395 break;
13396 }
13397
13398 external = next;
6d118b09 13399
dd24e3da 13400 /* Prevent out-of-bounds indexing. */
8b971f9f 13401 if (inote.namedata + inote.namesz > (char *) pnotes + length
dd24e3da
NC		 13402 || inote.namedata + inote.namesz < inote.namedata)
13403 {
13404 warn (_("corrupt note found at offset %lx into core notes\n"),
13405 (unsigned long) ((char *) external - (char *) pnotes));
13406 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13407 inote.type, inote.namesz, inote.descsz);
13408 break;
13409 }
13410
6d118b09
NC		 13411 /* Verify that name is null terminated. It appears that at least
13412 one version of Linux (RedHat 6.0) generates corefiles that don't
13413 comply with the ELF spec by failing to include the null byte in
13414 namesz. */
8b971f9f 13415 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13416 {
3f5e193b 13417 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13418
6d118b09
NC		 13419 if (temp == NULL)
13420 {
13421 error (_("Out of memory\n"));
13422 res = 0;
13423 break;
13424 }
76da6bbe 13425
6d118b09
NC		 13426 strncpy (temp, inote.namedata, inote.namesz);
13427 temp[inote.namesz] = 0;
76da6bbe 13428
6d118b09
NC		 13429 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13430 inote.namedata = temp;
13431 }
13432
13433 res &= process_note (& inote);
103f02d3 13434
6d118b09
NC		 13435 if (temp != NULL)
13436 {
13437 free (temp);
13438 temp = NULL;
13439 }
779fe533
NC		 13440 }
13441
13442 free (pnotes);
103f02d3 13443
779fe533
NC		 13444 return res;
13445}
13446
13447static int
2cf0635d 13448process_corefile_note_segments (FILE * file)
779fe533 13449{
2cf0635d 13450 Elf_Internal_Phdr * segment;
b34976b6
AM		 13451 unsigned int i;
13452 int res = 1;
103f02d3 13453
d93f0186 13454 if (! get_program_headers (file))
779fe533 13455 return 0;
103f02d3 13456
779fe533
NC		 13457 for (i = 0, segment = program_headers;
13458 i < elf_header.e_phnum;
b34976b6 13459 i++, segment++)
779fe533
NC		 13460 {
13461 if (segment->p_type == PT_NOTE)
103f02d3 13462 res &= process_corefile_note_segment (file,
30800947
NC		 13463 (bfd_vma) segment->p_offset,
13464 (bfd_vma) segment->p_filesz);
779fe533 13465 }
103f02d3 13466
779fe533
NC		 13467 return res;
13468}
13469
13470static int
2cf0635d 13471process_note_sections (FILE * file)
1ec5cd37 13472{
2cf0635d 13473 Elf_Internal_Shdr * section;
1ec5cd37
NC		 13474 unsigned long i;
13475 int res = 1;
13476
13477 for (i = 0, section = section_headers;
fa1908fd 13478 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 13479 i++, section++)
13480 if (section->sh_type == SHT_NOTE)
13481 res &= process_corefile_note_segment (file,
13482 (bfd_vma) section->sh_offset,
13483 (bfd_vma) section->sh_size);
13484
13485 return res;
13486}
13487
13488static int
2cf0635d 13489process_notes (FILE * file)
779fe533
NC		 13490{
13491 /* If we have not been asked to display the notes then do nothing. */
13492 if (! do_notes)
13493 return 1;
103f02d3 13494
779fe533 13495 if (elf_header.e_type != ET_CORE)
1ec5cd37 13496 return process_note_sections (file);
103f02d3 13497
779fe533 13498 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 13499 if (elf_header.e_phnum > 0)
13500 return process_corefile_note_segments (file);
779fe533 13501
1ec5cd37
NC		 13502 printf (_("No note segments present in the core file.\n"));
13503 return 1;
779fe533
NC		 13504}
13505
252b5132 13506static int
2cf0635d 13507process_arch_specific (FILE * file)
252b5132 13508{
a952a375
NC		 13509 if (! do_arch)
13510 return 1;
13511
252b5132
RH		 13512 switch (elf_header.e_machine)
13513 {
11c1ff18
PB		 13514 case EM_ARM:
13515 return process_arm_specific (file);
252b5132 13516 case EM_MIPS:
4fe85591 13517 case EM_MIPS_RS3_LE:
252b5132
RH		 13518 return process_mips_specific (file);
13519 break;
34c8bcba
JM		 13520 case EM_PPC:
13521 return process_power_specific (file);
13522 break;
9e8c70f9
DM		 13523 case EM_SPARC:
13524 case EM_SPARC32PLUS:
13525 case EM_SPARCV9:
13526 return process_sparc_specific (file);
13527 break;
59e6276b
JM		 13528 case EM_TI_C6000:
13529 return process_tic6x_specific (file);
13530 break;
252b5132
RH		 13531 default:
13532 break;
13533 }
13534 return 1;
13535}
13536
13537static int
2cf0635d 13538get_file_header (FILE * file)
252b5132 13539{
9ea033b2
NC		 13540 /* Read in the identity array. */
13541 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13542 return 0;
13543
9ea033b2 13544 /* Determine how to read the rest of the header. */
b34976b6 13545 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13546 {
13547 default: /* fall through */
13548 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13549 case ELFDATA2LSB:
13550 byte_get = byte_get_little_endian;
13551 byte_put = byte_put_little_endian;
13552 break;
13553 case ELFDATA2MSB:
13554 byte_get = byte_get_big_endian;
13555 byte_put = byte_put_big_endian;
13556 break;
9ea033b2
NC		 13557 }
13558
13559 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13560 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13561
13562 /* Read in the rest of the header. */
13563 if (is_32bit_elf)
13564 {
13565 Elf32_External_Ehdr ehdr32;
252b5132 13566
9ea033b2
NC		 13567 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13568 return 0;
103f02d3 13569
9ea033b2
NC		 13570 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13571 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13572 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13573 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13574 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13575 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13576 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13577 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13578 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13579 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13580 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13581 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13582 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13583 }
252b5132 13584 else
9ea033b2
NC		 13585 {
13586 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13587
13588 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13589 we will not be able to cope with the 64bit data found in
13590 64 ELF files. Detect this now and abort before we start
50c2245b 13591 overwriting things. */
a952a375
NC		 13592 if (sizeof (bfd_vma) < 8)
13593 {
e3c8793a
NC		 13594 error (_("This instance of readelf has been built without support for a\n\
1359564 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13596 return 0;
13597 }
103f02d3 13598
9ea033b2
NC		 13599 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13600 return 0;
103f02d3 13601
9ea033b2
NC		 13602 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13603 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13604 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13605 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13606 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13607 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13608 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13609 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13610 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13611 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13612 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13613 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13614 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13615 }
252b5132 13616
7ece0d85
JJ		 13617 if (elf_header.e_shoff)
13618 {
13619 /* There may be some extensions in the first section header. Don't
13620 bomb if we can't read it. */
13621 if (is_32bit_elf)
13622 get_32bit_section_headers (file, 1);
13623 else
13624 get_64bit_section_headers (file, 1);
13625 }
560f3c1c 13626
252b5132
RH		 13627 return 1;
13628}
13629
fb52b2f4
NC		 13630/* Process one ELF object file according to the command line options.
13631 This file may actually be stored in an archive. The file is
13632 positioned at the start of the ELF object. */
13633
ff78d6d6 13634static int
2cf0635d 13635process_object (char * file_name, FILE * file)
252b5132 13636{
252b5132
RH		 13637 unsigned int i;
13638
252b5132
RH		 13639 if (! get_file_header (file))
13640 {
13641 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13642 return 1;
252b5132
RH		 13643 }
13644
13645 /* Initialise per file variables. */
60bca95a 13646 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13647 version_info[i] = 0;
13648
60bca95a 13649 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13650 dynamic_info[i] = 0;
5115b233 13651 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13652
13653 /* Process the file. */
13654 if (show_name)
13655 printf (_("\nFile: %s\n"), file_name);
13656
18bd398b
NC		 13657 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13658 Note we do this even if cmdline_dump_sects is empty because we
13659 must make sure that the dump_sets array is zeroed out before each
13660 object file is processed. */
13661 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13662 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13663
13664 if (num_cmdline_dump_sects > 0)
13665 {
13666 if (num_dump_sects == 0)
13667 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13668 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13669
13670 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13671 memcpy (dump_sects, cmdline_dump_sects,
13672 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13673 }
d70c5fc7 13674
252b5132 13675 if (! process_file_header ())
fb52b2f4 13676 return 1;
252b5132 13677
d1f5c6e3 13678 if (! process_section_headers (file))
2f62977e 13679 {
d1f5c6e3
L		 13680 /* Without loaded section headers we cannot process lots of
13681 things. */
2f62977e 13682 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13683
2f62977e 13684 if (! do_using_dynamic)
2c610e4b 13685 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13686 }
252b5132 13687
d1f5c6e3
L		 13688 if (! process_section_groups (file))
13689 {
13690 /* Without loaded section groups we cannot process unwind. */
13691 do_unwind = 0;
13692 }
13693
2f62977e 13694 if (process_program_headers (file))
b2d38a17 13695 process_dynamic_section (file);
252b5132
RH		 13696
13697 process_relocs (file);
13698
4d6ed7c8
NC		 13699 process_unwind (file);
13700
252b5132
RH		 13701 process_symbol_table (file);
13702
13703 process_syminfo (file);
13704
13705 process_version_sections (file);
13706
13707 process_section_contents (file);
f5842774 13708
1ec5cd37 13709 process_notes (file);
103f02d3 13710
047b2264
JJ		 13711 process_gnu_liblist (file);
13712
252b5132
RH		 13713 process_arch_specific (file);
13714
d93f0186
NC		 13715 if (program_headers)
13716 {
13717 free (program_headers);
13718 program_headers = NULL;
13719 }
13720
252b5132
RH		 13721 if (section_headers)
13722 {
13723 free (section_headers);
13724 section_headers = NULL;
13725 }
13726
13727 if (string_table)
13728 {
13729 free (string_table);
13730 string_table = NULL;
d40ac9bd 13731 string_table_length = 0;
252b5132
RH		 13732 }
13733
13734 if (dynamic_strings)
13735 {
13736 free (dynamic_strings);
13737 dynamic_strings = NULL;
d79b3d50 13738 dynamic_strings_length = 0;
252b5132
RH		 13739 }
13740
13741 if (dynamic_symbols)
13742 {
13743 free (dynamic_symbols);
13744 dynamic_symbols = NULL;
19936277 13745 num_dynamic_syms = 0;
252b5132
RH		 13746 }
13747
13748 if (dynamic_syminfo)
13749 {
13750 free (dynamic_syminfo);
13751 dynamic_syminfo = NULL;
13752 }
ff78d6d6 13753
293c573e
MR		 13754 if (dynamic_section)
13755 {
13756 free (dynamic_section);
13757 dynamic_section = NULL;
13758 }
13759
e4b17d5c
L		 13760 if (section_headers_groups)
13761 {
13762 free (section_headers_groups);
13763 section_headers_groups = NULL;
13764 }
13765
13766 if (section_groups)
13767 {
2cf0635d
NC		 13768 struct group_list * g;
13769 struct group_list * next;
e4b17d5c
L		 13770
13771 for (i = 0; i < group_count; i++)
13772 {
13773 for (g = section_groups [i].root; g != NULL; g = next)
13774 {
13775 next = g->next;
13776 free (g);
13777 }
13778 }
13779
13780 free (section_groups);
13781 section_groups = NULL;
13782 }
13783
19e6b90e 13784 free_debug_memory ();
18bd398b 13785
ff78d6d6 13786 return 0;
252b5132
RH		 13787}
13788
2cf0635d
NC		 13789/* Process an ELF archive.
13790 On entry the file is positioned just after the ARMAG string. */
13791
13792static int
13793process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13794{
13795 struct archive_info arch;
13796 struct archive_info nested_arch;
13797 size_t got;
2cf0635d
NC		 13798 int ret;
13799
13800 show_name = 1;
13801
13802 /* The ARCH structure is used to hold information about this archive. */
13803 arch.file_name = NULL;
13804 arch.file = NULL;
13805 arch.index_array = NULL;
13806 arch.sym_table = NULL;
13807 arch.longnames = NULL;
13808
13809 /* The NESTED_ARCH structure is used as a single-item cache of information
13810 about a nested archive (when members of a thin archive reside within
13811 another regular archive file). */
13812 nested_arch.file_name = NULL;
13813 nested_arch.file = NULL;
13814 nested_arch.index_array = NULL;
13815 nested_arch.sym_table = NULL;
13816 nested_arch.longnames = NULL;
13817
13818 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13819 {
13820 ret = 1;
13821 goto out;
4145f1d5 13822 }
fb52b2f4 13823
4145f1d5
NC		 13824 if (do_archive_index)
13825 {
2cf0635d 13826 if (arch.sym_table == NULL)
4145f1d5
NC		 13827 error (_("%s: unable to dump the index as none was found\n"), file_name);
13828 else
13829 {
2cf0635d 13830 unsigned int i, l;
4145f1d5
NC		 13831 unsigned long current_pos;
13832
13833 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 13834 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 13835 current_pos = ftell (file);
13836
2cf0635d 13837 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13838 {
2cf0635d
NC		 13839 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13840 {
13841 char * member_name;
4145f1d5 13842
2cf0635d
NC		 13843 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13844
13845 if (member_name != NULL)
13846 {
13847 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13848
13849 if (qualified_name != NULL)
13850 {
c2a7d3f5
NC		 13851 printf (_("Contents of binary %s at offset "), qualified_name);
13852 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13853 putchar ('\n');
2cf0635d
NC		 13854 free (qualified_name);
13855 }
4145f1d5
NC		 13856 }
13857 }
2cf0635d
NC		 13858
13859 if (l >= arch.sym_size)
4145f1d5
NC		 13860 {
13861 error (_("%s: end of the symbol table reached before the end of the index\n"),
13862 file_name);
cb8f3167 13863 break;
4145f1d5 13864 }
2cf0635d
NC		 13865 printf ("\t%s\n", arch.sym_table + l);
13866 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13867 }
13868
c2a7d3f5
NC		 13869 if (arch.uses_64bit_indicies)
13870 l = (l + 7) & ~ 7;
13871 else
13872 l += l & 1;
13873
2cf0635d 13874 if (l < arch.sym_size)
c2a7d3f5
NC		 13875 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13876 file_name, arch.sym_size - l);
4145f1d5 13877
4145f1d5
NC		 13878 if (fseek (file, current_pos, SEEK_SET) != 0)
13879 {
13880 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13881 ret = 1;
13882 goto out;
4145f1d5 13883 }
fb52b2f4 13884 }
4145f1d5
NC		 13885
13886 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13887 && !do_segments && !do_header && !do_dump && !do_version
13888 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13889 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13890 {
13891 ret = 0; /* Archive index only. */
13892 goto out;
13893 }
fb52b2f4
NC		 13894 }
13895
d989285c 13896 ret = 0;
fb52b2f4
NC		 13897
13898 while (1)
13899 {
2cf0635d
NC		 13900 char * name;
13901 size_t namelen;
13902 char * qualified_name;
13903
13904 /* Read the next archive header. */
13905 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13906 {
13907 error (_("%s: failed to seek to next archive header\n"), file_name);
13908 return 1;
13909 }
13910 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13911 if (got != sizeof arch.arhdr)
13912 {
13913 if (got == 0)
13914 break;
13915 error (_("%s: failed to read archive header\n"), file_name);
13916 ret = 1;
13917 break;
13918 }
13919 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13920 {
13921 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13922 ret = 1;
13923 break;
13924 }
13925
13926 arch.next_arhdr_offset += sizeof arch.arhdr;
13927
13928 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13929 if (archive_file_size & 01)
13930 ++archive_file_size;
13931
13932 name = get_archive_member_name (&arch, &nested_arch);
13933 if (name == NULL)
fb52b2f4 13934 {
0fd3a477 13935 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13936 ret = 1;
13937 break;
fb52b2f4 13938 }
2cf0635d 13939 namelen = strlen (name);
fb52b2f4 13940
2cf0635d
NC		 13941 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13942 if (qualified_name == NULL)
fb52b2f4 13943 {
2cf0635d 13944 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13945 ret = 1;
13946 break;
fb52b2f4
NC		 13947 }
13948
2cf0635d
NC		 13949 if (is_thin_archive && arch.nested_member_origin == 0)
13950 {
13951 /* This is a proxy for an external member of a thin archive. */
13952 FILE * member_file;
13953 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13954 if (member_file_name == NULL)
13955 {
13956 ret = 1;
13957 break;
13958 }
13959
13960 member_file = fopen (member_file_name, "rb");
13961 if (member_file == NULL)
13962 {
13963 error (_("Input file '%s' is not readable.\n"), member_file_name);
13964 free (member_file_name);
13965 ret = 1;
13966 break;
13967 }
13968
13969 archive_file_offset = arch.nested_member_origin;
13970
13971 ret |= process_object (qualified_name, member_file);
13972
13973 fclose (member_file);
13974 free (member_file_name);
13975 }
13976 else if (is_thin_archive)
13977 {
13978 /* This is a proxy for a member of a nested archive. */
13979 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13980
13981 /* The nested archive file will have been opened and setup by
13982 get_archive_member_name. */
13983 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13984 {
13985 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13986 ret = 1;
13987 break;
13988 }
13989
13990 ret |= process_object (qualified_name, nested_arch.file);
13991 }
13992 else
13993 {
13994 archive_file_offset = arch.next_arhdr_offset;
13995 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13996
2cf0635d
NC		 13997 ret |= process_object (qualified_name, file);
13998 }
fb52b2f4 13999
2b52916e
L		 14000 if (dump_sects != NULL)
14001 {
14002 free (dump_sects);
14003 dump_sects = NULL;
14004 num_dump_sects = 0;
14005 }
14006
2cf0635d 14007 free (qualified_name);
fb52b2f4
NC		 14008 }
14009
4145f1d5 14010 out:
2cf0635d
NC		 14011 if (nested_arch.file != NULL)
14012 fclose (nested_arch.file);
14013 release_archive (&nested_arch);
14014 release_archive (&arch);
fb52b2f4 14015
d989285c 14016 return ret;
fb52b2f4
NC		 14017}
14018
14019static int
2cf0635d 14020process_file (char * file_name)
fb52b2f4 14021{
2cf0635d 14022 FILE * file;
fb52b2f4
NC		 14023 struct stat statbuf;
14024 char armag[SARMAG];
14025 int ret;
14026
14027 if (stat (file_name, &statbuf) < 0)
14028 {
f24ddbdd
NC		 14029 if (errno == ENOENT)
14030 error (_("'%s': No such file\n"), file_name);
14031 else
14032 error (_("Could not locate '%s'. System error message: %s\n"),
14033 file_name, strerror (errno));
14034 return 1;
14035 }
14036
14037 if (! S_ISREG (statbuf.st_mode))
14038 {
14039 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 14040 return 1;
14041 }
14042
14043 file = fopen (file_name, "rb");
14044 if (file == NULL)
14045 {
f24ddbdd 14046 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 14047 return 1;
14048 }
14049
14050 if (fread (armag, SARMAG, 1, file) != 1)
14051 {
4145f1d5 14052 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 14053 fclose (file);
14054 return 1;
14055 }
14056
14057 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 14058 ret = process_archive (file_name, file, FALSE);
14059 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14060 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 14061 else
14062 {
4145f1d5
NC		 14063 if (do_archive_index)
14064 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14065 file_name);
14066
fb52b2f4
NC		 14067 rewind (file);
14068 archive_file_size = archive_file_offset = 0;
14069 ret = process_object (file_name, file);
14070 }
14071
14072 fclose (file);
14073
14074 return ret;
14075}
14076
252b5132
RH		 14077#ifdef SUPPORT_DISASSEMBLY
14078/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 14079 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 14080 symbols. */
252b5132
RH		 14081
14082void
2cf0635d 14083print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 14084{
14085 fprintf (outfile,"0x%8.8x", addr);
14086}
14087
e3c8793a 14088/* Needed by the i386 disassembler. */
252b5132
RH		 14089void
14090db_task_printsym (unsigned int addr)
14091{
14092 print_address (addr, stderr);
14093}
14094#endif
14095
14096int
2cf0635d 14097main (int argc, char ** argv)
252b5132 14098{
ff78d6d6
L		 14099 int err;
14100
252b5132
RH		 14101#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14102 setlocale (LC_MESSAGES, "");
3882b010
L		 14103#endif
14104#if defined (HAVE_SETLOCALE)
14105 setlocale (LC_CTYPE, "");
252b5132
RH		 14106#endif
14107 bindtextdomain (PACKAGE, LOCALEDIR);
14108 textdomain (PACKAGE);
14109
869b9d07
MM		 14110 expandargv (&argc, &argv);
14111
252b5132
RH		 14112 parse_args (argc, argv);
14113
18bd398b 14114 if (num_dump_sects > 0)
59f14fc0 14115 {
18bd398b 14116 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 14117 cmdline_dump_sects = (dump_type *)
14118 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 14119 if (cmdline_dump_sects == NULL)
591a748a 14120 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 14121 else
14122 {
09c11c86
NC		 14123 memcpy (cmdline_dump_sects, dump_sects,
14124 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 14125 num_cmdline_dump_sects = num_dump_sects;
14126 }
14127 }
14128
18bd398b
NC		 14129 if (optind < (argc - 1))
14130 show_name = 1;
14131
ff78d6d6 14132 err = 0;
252b5132 14133 while (optind < argc)
18bd398b 14134 err |= process_file (argv[optind++]);
252b5132
RH		 14135
14136 if (dump_sects != NULL)
14137 free (dump_sects);
59f14fc0
AS		 14138 if (cmdline_dump_sects != NULL)
14139 free (cmdline_dump_sects);
252b5132 14140
ff78d6d6 14141 return err;
252b5132 14142}
A mirror of the official binutils-gdb repository