]> 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
gold/
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
6e3d6dc1 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
652451f8 3 2008, 2009, 2010, 2011, 2012, 2013
a0f19280 4 Free Software Foundation, Inc.
252b5132
RH		 5
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 7 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 8
9 This file is part of GNU Binutils.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
32866df7 13 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
b43b5d5f
NC		 23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 02110-1301, USA. */
252b5132 25\f
9eb20dd8 26/* The difference between readelf and objdump:
252b5132 27
74013231 28 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 29 so why does the binutils project have two file dumpers ?
0de14b54 30
9eb20dd8
NC		 31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
37
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
40
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
44\f
3db64b00 45#include "sysdep.h"
252b5132 46#include <assert.h>
252b5132 47#include <time.h>
1b315056
CS		 48#ifdef HAVE_ZLIB_H
49#include <zlib.h>
50#endif
3bfcb652 51#ifdef HAVE_WCHAR_H
7bfd842d 52#include <wchar.h>
3bfcb652 53#endif
252b5132 54
a952a375 55#if __GNUC__ >= 2
19936277 56/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 57 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 58 Only do this if we believe that the compiler can support a 64 bit
a952a375 59 data type. For now we only rely on GCC being able to do this. */
19936277 60#define BFD64
a952a375
NC		 61#endif
62
3db64b00
AM		 63#include "bfd.h"
64#include "bucomm.h"
3284fe0c 65#include "elfcomm.h"
19e6b90e 66#include "dwarf.h"
252b5132
RH		 67
68#include "elf/common.h"
69#include "elf/external.h"
70#include "elf/internal.h"
252b5132 71
4b78141a
NC		 72
73/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
74 we can obtain the H8 reloc numbers. We need these for the
75 get_reloc_size() function. We include h8.h again after defining
76 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77
78#include "elf/h8.h"
79#undef _ELF_H8_H
80
81/* Undo the effects of #including reloc-macros.h. */
82
83#undef START_RELOC_NUMBERS
84#undef RELOC_NUMBER
85#undef FAKE_RELOC
86#undef EMPTY_RELOC
87#undef END_RELOC_NUMBERS
88#undef _RELOC_MACROS_H
89
252b5132
RH		 90/* The following headers use the elf/reloc-macros.h file to
91 automatically generate relocation recognition functions
92 such as elf_mips_reloc_type() */
93
94#define RELOC_MACROS_GEN_FUNC
95
a06ea964 96#include "elf/aarch64.h"
252b5132 97#include "elf/alpha.h"
3b16e843 98#include "elf/arc.h"
252b5132 99#include "elf/arm.h"
3b16e843 100#include "elf/avr.h"
1d65ded4 101#include "elf/bfin.h"
60bca95a 102#include "elf/cr16.h"
3b16e843 103#include "elf/cris.h"
1c0d3aa6 104#include "elf/crx.h"
252b5132
RH		 105#include "elf/d10v.h"
106#include "elf/d30v.h"
d172d4ba 107#include "elf/dlx.h"
cfb8c092 108#include "elf/epiphany.h"
252b5132 109#include "elf/fr30.h"
5c70f934 110#include "elf/frv.h"
3b16e843
NC		 111#include "elf/h8.h"
112#include "elf/hppa.h"
113#include "elf/i386.h"
35b1837e 114#include "elf/i370.h"
3b16e843
NC		 115#include "elf/i860.h"
116#include "elf/i960.h"
117#include "elf/ia64.h"
1e4cf259 118#include "elf/ip2k.h"
84e94c90 119#include "elf/lm32.h"
1c0d3aa6 120#include "elf/iq2000.h"
49f58d10 121#include "elf/m32c.h"
3b16e843
NC		 122#include "elf/m32r.h"
123#include "elf/m68k.h"
75751cd9 124#include "elf/m68hc11.h"
252b5132 125#include "elf/mcore.h"
15ab5209 126#include "elf/mep.h"
a3c62988 127#include "elf/metag.h"
7ba29e2a 128#include "elf/microblaze.h"
3b16e843 129#include "elf/mips.h"
3c3bdf30 130#include "elf/mmix.h"
3b16e843
NC		 131#include "elf/mn10200.h"
132#include "elf/mn10300.h"
5506d11a 133#include "elf/moxie.h"
4970f871 134#include "elf/mt.h"
2469cfa2 135#include "elf/msp430.h"
3b16e843 136#include "elf/or32.h"
7d466069 137#include "elf/pj.h"
3b16e843 138#include "elf/ppc.h"
c833c019 139#include "elf/ppc64.h"
99c513f6 140#include "elf/rl78.h"
c7927a3c 141#include "elf/rx.h"
a85d7ed0 142#include "elf/s390.h"
1c0d3aa6 143#include "elf/score.h"
3b16e843
NC		 144#include "elf/sh.h"
145#include "elf/sparc.h"
e9f53129 146#include "elf/spu.h"
40b36596 147#include "elf/tic6x.h"
aa137e4d
NC		 148#include "elf/tilegx.h"
149#include "elf/tilepro.h"
3b16e843 150#include "elf/v850.h"
179d3252 151#include "elf/vax.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
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;
252b5132
RH		 1293 }
1294
1295 if (rtype == NULL)
39dbeff8 1296 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1297 else
8beeaeb7 1298 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1299
7ace3541 1300 if (elf_header.e_machine == EM_ALPHA
157c2599 1301 && rtype != NULL
7ace3541
RH		 1302 && streq (rtype, "R_ALPHA_LITUSE")
1303 && is_rela)
1304 {
1305 switch (rels[i].r_addend)
1306 {
1307 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1308 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1309 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1310 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1311 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1312 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1313 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1314 default: rtype = NULL;
1315 }
1316 if (rtype)
1317 printf (" (%s)", rtype);
1318 else
1319 {
1320 putchar (' ');
1321 printf (_("<unknown addend: %lx>"),
1322 (unsigned long) rels[i].r_addend);
1323 }
1324 }
1325 else if (symtab_index)
252b5132 1326 {
af3fc3bc 1327 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1328 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1329 else
19936277 1330 {
2cf0635d 1331 Elf_Internal_Sym * psym;
19936277 1332
af3fc3bc 1333 psym = symtab + symtab_index;
103f02d3 1334
af3fc3bc 1335 printf (" ");
171191ba 1336
d8045f23
NC		 1337 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1338 {
1339 const char * name;
1340 unsigned int len;
1341 unsigned int width = is_32bit_elf ? 8 : 14;
1342
1343 /* Relocations against GNU_IFUNC symbols do not use the value
1344 of the symbol as the address to relocate against. Instead
1345 they invoke the function named by the symbol and use its
1346 result as the address for relocation.
1347
1348 To indicate this to the user, do not display the value of
1349 the symbol in the "Symbols's Value" field. Instead show
1350 its name followed by () as a hint that the symbol is
1351 invoked. */
1352
1353 if (strtab == NULL
1354 || psym->st_name == 0
1355 || psym->st_name >= strtablen)
1356 name = "??";
1357 else
1358 name = strtab + psym->st_name;
1359
1360 len = print_symbol (width, name);
1361 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1362 }
1363 else
1364 {
1365 print_vma (psym->st_value, LONG_HEX);
171191ba 1366
d8045f23
NC		 1367 printf (is_32bit_elf ? " " : " ");
1368 }
103f02d3 1369
af3fc3bc 1370 if (psym->st_name == 0)
f1ef08cb 1371 {
2cf0635d 1372 const char * sec_name = "<null>";
f1ef08cb
AM		 1373 char name_buf[40];
1374
1375 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1376 {
4fbb74a6
AM		 1377 if (psym->st_shndx < elf_header.e_shnum)
1378 sec_name
1379 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1380 else if (psym->st_shndx == SHN_ABS)
1381 sec_name = "ABS";
1382 else if (psym->st_shndx == SHN_COMMON)
1383 sec_name = "COMMON";
ac145307
BS		 1384 else if ((elf_header.e_machine == EM_MIPS
1385 && psym->st_shndx == SHN_MIPS_SCOMMON)
1386 || (elf_header.e_machine == EM_TI_C6000
1387 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1388 sec_name = "SCOMMON";
1389 else if (elf_header.e_machine == EM_MIPS
1390 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1391 sec_name = "SUNDEF";
8a9036a4 1392 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1393 || elf_header.e_machine == EM_L1OM
1394 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1395 && psym->st_shndx == SHN_X86_64_LCOMMON)
1396 sec_name = "LARGE_COMMON";
9ce701e2
L		 1397 else if (elf_header.e_machine == EM_IA_64
1398 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1399 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1400 sec_name = "ANSI_COM";
28f997cf 1401 else if (is_ia64_vms ()
148b93f2
NC		 1402 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1403 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1404 else
1405 {
1406 sprintf (name_buf, "<section 0x%x>",
1407 (unsigned int) psym->st_shndx);
1408 sec_name = name_buf;
1409 }
1410 }
1411 print_symbol (22, sec_name);
1412 }
af3fc3bc 1413 else if (strtab == NULL)
d79b3d50 1414 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1415 else if (psym->st_name >= strtablen)
d79b3d50 1416 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1417 else
2c71103e 1418 print_symbol (22, strtab + psym->st_name);
103f02d3 1419
af3fc3bc 1420 if (is_rela)
171191ba 1421 {
598aaa76 1422 bfd_signed_vma off = rels[i].r_addend;
171191ba 1423
91d6fa6a 1424 if (off < 0)
598aaa76 1425 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1426 else
598aaa76 1427 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1428 }
19936277 1429 }
252b5132 1430 }
1b228002 1431 else if (is_rela)
f7a99963 1432 {
e04d7088
L		 1433 bfd_signed_vma off = rels[i].r_addend;
1434
1435 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1436 if (off < 0)
1437 printf ("-%" BFD_VMA_FMT "x", - off);
1438 else
1439 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1440 }
252b5132 1441
157c2599
NC		 1442 if (elf_header.e_machine == EM_SPARCV9
1443 && rtype != NULL
1444 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1445 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1446
252b5132 1447 putchar ('\n');
2c71103e 1448
aca88567 1449#ifdef BFD64
53c7db4b 1450 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1451 {
91d6fa6a
NC		 1452 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1453 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1454 const char * rtype2 = elf_mips_reloc_type (type2);
1455 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1456
2c71103e
NC		 1457 printf (" Type2: ");
1458
1459 if (rtype2 == NULL)
39dbeff8
AM		 1460 printf (_("unrecognized: %-7lx"),
1461 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1462 else
1463 printf ("%-17.17s", rtype2);
1464
18bd398b 1465 printf ("\n Type3: ");
2c71103e
NC		 1466
1467 if (rtype3 == NULL)
39dbeff8
AM		 1468 printf (_("unrecognized: %-7lx"),
1469 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1470 else
1471 printf ("%-17.17s", rtype3);
1472
53c7db4b 1473 putchar ('\n');
2c71103e 1474 }
aca88567 1475#endif /* BFD64 */
252b5132
RH		 1476 }
1477
c8286bd1 1478 free (rels);
252b5132
RH		 1479}
1480
1481static const char *
d3ba0551 1482get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1483{
1484 switch (type)
1485 {
1486 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1487 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1488 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1489 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1490 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1491 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1492 case DT_MIPS_MSYM: return "MIPS_MSYM";
1493 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1494 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1495 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1496 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1497 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1498 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1499 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1500 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1501 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1502 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1503 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1504 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1505 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1506 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1507 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1508 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1509 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1510 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1511 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1512 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1513 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1514 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1515 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1516 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1517 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1518 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1519 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1520 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1521 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1522 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1523 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1524 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1525 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1526 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1527 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1528 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1529 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1530 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1531 default:
1532 return NULL;
1533 }
1534}
1535
9a097730 1536static const char *
d3ba0551 1537get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1538{
1539 switch (type)
1540 {
1541 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1542 default:
1543 return NULL;
1544 }
103f02d3
UD		 1545}
1546
7490d522
AM		 1547static const char *
1548get_ppc_dynamic_type (unsigned long type)
1549{
1550 switch (type)
1551 {
a7f2871e
AM		 1552 case DT_PPC_GOT: return "PPC_GOT";
1553 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1554 default:
1555 return NULL;
1556 }
1557}
1558
f1cb7e17 1559static const char *
d3ba0551 1560get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1561{
1562 switch (type)
1563 {
a7f2871e
AM		 1564 case DT_PPC64_GLINK: return "PPC64_GLINK";
1565 case DT_PPC64_OPD: return "PPC64_OPD";
1566 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1567 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1568 default:
1569 return NULL;
1570 }
1571}
1572
103f02d3 1573static const char *
d3ba0551 1574get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1575{
1576 switch (type)
1577 {
1578 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1579 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1580 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1581 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1582 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1583 case DT_HP_PREINIT: return "HP_PREINIT";
1584 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1585 case DT_HP_NEEDED: return "HP_NEEDED";
1586 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1587 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1588 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1589 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1590 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1591 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1592 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1593 case DT_HP_FILTERED: return "HP_FILTERED";
1594 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1595 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1596 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1597 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1598 case DT_PLT: return "PLT";
1599 case DT_PLT_SIZE: return "PLT_SIZE";
1600 case DT_DLT: return "DLT";
1601 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1602 default:
1603 return NULL;
1604 }
1605}
9a097730 1606
ecc51f48 1607static const char *
d3ba0551 1608get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1609{
1610 switch (type)
1611 {
148b93f2
NC		 1612 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1613 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1614 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1615 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1616 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1617 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1618 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1619 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1620 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1621 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1622 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1623 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1624 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1625 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1626 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1627 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1628 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1629 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1630 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1631 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1632 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1633 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1634 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1635 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1636 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1637 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1638 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1639 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1640 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1641 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1642 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1643 default:
1644 return NULL;
1645 }
1646}
1647
fabcb361
RH		 1648static const char *
1649get_alpha_dynamic_type (unsigned long type)
1650{
1651 switch (type)
1652 {
1653 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1654 default:
1655 return NULL;
1656 }
1657}
1658
1c0d3aa6
NC		 1659static const char *
1660get_score_dynamic_type (unsigned long type)
1661{
1662 switch (type)
1663 {
1664 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1665 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1666 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1667 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1668 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1669 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1670 default:
1671 return NULL;
1672 }
1673}
1674
40b36596
JM		 1675static const char *
1676get_tic6x_dynamic_type (unsigned long type)
1677{
1678 switch (type)
1679 {
1680 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1681 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1682 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1683 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1684 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1685 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1686 default:
1687 return NULL;
1688 }
1689}
1c0d3aa6 1690
252b5132 1691static const char *
d3ba0551 1692get_dynamic_type (unsigned long type)
252b5132 1693{
e9e44622 1694 static char buff[64];
252b5132
RH		 1695
1696 switch (type)
1697 {
1698 case DT_NULL: return "NULL";
1699 case DT_NEEDED: return "NEEDED";
1700 case DT_PLTRELSZ: return "PLTRELSZ";
1701 case DT_PLTGOT: return "PLTGOT";
1702 case DT_HASH: return "HASH";
1703 case DT_STRTAB: return "STRTAB";
1704 case DT_SYMTAB: return "SYMTAB";
1705 case DT_RELA: return "RELA";
1706 case DT_RELASZ: return "RELASZ";
1707 case DT_RELAENT: return "RELAENT";
1708 case DT_STRSZ: return "STRSZ";
1709 case DT_SYMENT: return "SYMENT";
1710 case DT_INIT: return "INIT";
1711 case DT_FINI: return "FINI";
1712 case DT_SONAME: return "SONAME";
1713 case DT_RPATH: return "RPATH";
1714 case DT_SYMBOLIC: return "SYMBOLIC";
1715 case DT_REL: return "REL";
1716 case DT_RELSZ: return "RELSZ";
1717 case DT_RELENT: return "RELENT";
1718 case DT_PLTREL: return "PLTREL";
1719 case DT_DEBUG: return "DEBUG";
1720 case DT_TEXTREL: return "TEXTREL";
1721 case DT_JMPREL: return "JMPREL";
1722 case DT_BIND_NOW: return "BIND_NOW";
1723 case DT_INIT_ARRAY: return "INIT_ARRAY";
1724 case DT_FINI_ARRAY: return "FINI_ARRAY";
1725 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1726 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1727 case DT_RUNPATH: return "RUNPATH";
1728 case DT_FLAGS: return "FLAGS";
2d0e6f43 1729
d1133906
NC		 1730 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1731 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1732
05107a46 1733 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1734 case DT_PLTPADSZ: return "PLTPADSZ";
1735 case DT_MOVEENT: return "MOVEENT";
1736 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1737 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1738 case DT_POSFLAG_1: return "POSFLAG_1";
1739 case DT_SYMINSZ: return "SYMINSZ";
1740 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1741
252b5132 1742 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1743 case DT_CONFIG: return "CONFIG";
1744 case DT_DEPAUDIT: return "DEPAUDIT";
1745 case DT_AUDIT: return "AUDIT";
1746 case DT_PLTPAD: return "PLTPAD";
1747 case DT_MOVETAB: return "MOVETAB";
252b5132 1748 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1749
252b5132 1750 case DT_VERSYM: return "VERSYM";
103f02d3 1751
67a4f2b7
AO		 1752 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1753 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1754 case DT_RELACOUNT: return "RELACOUNT";
1755 case DT_RELCOUNT: return "RELCOUNT";
1756 case DT_FLAGS_1: return "FLAGS_1";
1757 case DT_VERDEF: return "VERDEF";
1758 case DT_VERDEFNUM: return "VERDEFNUM";
1759 case DT_VERNEED: return "VERNEED";
1760 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1761
019148e4 1762 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1763 case DT_USED: return "USED";
1764 case DT_FILTER: return "FILTER";
103f02d3 1765
047b2264
JJ		 1766 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1767 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1768 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1769 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1770 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1771 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1772
252b5132
RH		 1773 default:
1774 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1775 {
2cf0635d 1776 const char * result;
103f02d3 1777
252b5132
RH		 1778 switch (elf_header.e_machine)
1779 {
1780 case EM_MIPS:
4fe85591 1781 case EM_MIPS_RS3_LE:
252b5132
RH		 1782 result = get_mips_dynamic_type (type);
1783 break;
9a097730
RH		 1784 case EM_SPARCV9:
1785 result = get_sparc64_dynamic_type (type);
1786 break;
7490d522
AM		 1787 case EM_PPC:
1788 result = get_ppc_dynamic_type (type);
1789 break;
f1cb7e17
AM		 1790 case EM_PPC64:
1791 result = get_ppc64_dynamic_type (type);
1792 break;
ecc51f48
NC		 1793 case EM_IA_64:
1794 result = get_ia64_dynamic_type (type);
1795 break;
fabcb361
RH		 1796 case EM_ALPHA:
1797 result = get_alpha_dynamic_type (type);
1798 break;
1c0d3aa6
NC		 1799 case EM_SCORE:
1800 result = get_score_dynamic_type (type);
1801 break;
40b36596
JM		 1802 case EM_TI_C6000:
1803 result = get_tic6x_dynamic_type (type);
1804 break;
252b5132
RH		 1805 default:
1806 result = NULL;
1807 break;
1808 }
1809
1810 if (result != NULL)
1811 return result;
1812
e9e44622 1813 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1814 }
eec8f817
DA		 1815 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1816 || (elf_header.e_machine == EM_PARISC
1817 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1818 {
2cf0635d 1819 const char * result;
103f02d3
UD		 1820
1821 switch (elf_header.e_machine)
1822 {
1823 case EM_PARISC:
1824 result = get_parisc_dynamic_type (type);
1825 break;
148b93f2
NC		 1826 case EM_IA_64:
1827 result = get_ia64_dynamic_type (type);
1828 break;
103f02d3
UD		 1829 default:
1830 result = NULL;
1831 break;
1832 }
1833
1834 if (result != NULL)
1835 return result;
1836
e9e44622
JJ		 1837 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1838 type);
103f02d3 1839 }
252b5132 1840 else
e9e44622 1841 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1842
252b5132
RH		 1843 return buff;
1844 }
1845}
1846
1847static char *
d3ba0551 1848get_file_type (unsigned e_type)
252b5132 1849{
b34976b6 1850 static char buff[32];
252b5132
RH		 1851
1852 switch (e_type)
1853 {
1854 case ET_NONE: return _("NONE (None)");
1855 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1856 case ET_EXEC: return _("EXEC (Executable file)");
1857 case ET_DYN: return _("DYN (Shared object file)");
1858 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1859
1860 default:
1861 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1862 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1863 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1864 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1865 else
e9e44622 1866 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1867 return buff;
1868 }
1869}
1870
1871static char *
d3ba0551 1872get_machine_name (unsigned e_machine)
252b5132 1873{
b34976b6 1874 static char buff[64]; /* XXX */
252b5132
RH		 1875
1876 switch (e_machine)
1877 {
c45021f2 1878 case EM_NONE: return _("None");
a06ea964 1879 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1880 case EM_M32: return "WE32100";
1881 case EM_SPARC: return "Sparc";
e9f53129 1882 case EM_SPU: return "SPU";
c45021f2
NC		 1883 case EM_386: return "Intel 80386";
1884 case EM_68K: return "MC68000";
1885 case EM_88K: return "MC88000";
1886 case EM_486: return "Intel 80486";
1887 case EM_860: return "Intel 80860";
1888 case EM_MIPS: return "MIPS R3000";
1889 case EM_S370: return "IBM System/370";
7036c0e1 1890 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1891 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1892 case EM_PARISC: return "HPPA";
252b5132 1893 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1894 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1895 case EM_960: return "Intel 90860";
1896 case EM_PPC: return "PowerPC";
285d1771 1897 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1898 case EM_FR20: return "Fujitsu FR20";
1899 case EM_RH32: return "TRW RH32";
b34976b6 1900 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1901 case EM_ARM: return "ARM";
1902 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1903 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1904 case EM_SPARCV9: return "Sparc v9";
1905 case EM_TRICORE: return "Siemens Tricore";
584da044 1906 case EM_ARC: return "ARC";
c2dcd04e
NC		 1907 case EM_H8_300: return "Renesas H8/300";
1908 case EM_H8_300H: return "Renesas H8/300H";
1909 case EM_H8S: return "Renesas H8S";
1910 case EM_H8_500: return "Renesas H8/500";
30800947 1911 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1912 case EM_MIPS_X: return "Stanford MIPS-X";
1913 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1914 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1915 case EM_CYGNUS_D10V:
1916 case EM_D10V: return "d10v";
1917 case EM_CYGNUS_D30V:
b34976b6 1918 case EM_D30V: return "d30v";
2b0337b0 1919 case EM_CYGNUS_M32R:
26597c86 1920 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1921 case EM_CYGNUS_V850:
708e2187 1922 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 1923 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1924 case EM_CYGNUS_MN10300:
1925 case EM_MN10300: return "mn10300";
1926 case EM_CYGNUS_MN10200:
1927 case EM_MN10200: return "mn10200";
5506d11a 1928 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1929 case EM_CYGNUS_FR30:
1930 case EM_FR30: return "Fujitsu FR30";
b34976b6 1931 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1932 case EM_PJ_OLD:
b34976b6 1933 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1934 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1935 case EM_PCP: return "Siemens PCP";
1936 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1937 case EM_NDR1: return "Denso NDR1 microprocesspr";
1938 case EM_STARCORE: return "Motorola Star*Core processor";
1939 case EM_ME16: return "Toyota ME16 processor";
1940 case EM_ST100: return "STMicroelectronics ST100 processor";
1941 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1942 case EM_PDSP: return "Sony DSP processor";
1943 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1944 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1945 case EM_FX66: return "Siemens FX66 microcontroller";
1946 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1947 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1948 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1949 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1950 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1951 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1952 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1953 case EM_SVX: return "Silicon Graphics SVx";
1954 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1955 case EM_VAX: return "Digital VAX";
2b0337b0 1956 case EM_AVR_OLD:
b34976b6 1957 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1958 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1959 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1960 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1961 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1962 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1963 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1964 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1965 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1966 case EM_L1OM: return "Intel L1OM";
7a9068fe 1967 case EM_K1OM: return "Intel K1OM";
b7498e0e 1968 case EM_S390_OLD:
b34976b6 1969 case EM_S390: return "IBM S/390";
1c0d3aa6 1970 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1971 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1972 case EM_OPENRISC:
1973 case EM_OR32: return "OpenRISC";
11636f9e 1974 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1975 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 1976 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 1977 case EM_DLX: return "OpenDLX";
1e4cf259 1978 case EM_IP2K_OLD:
b34976b6 1979 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1980 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1981 case EM_XTENSA_OLD:
1982 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1983 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1984 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1985 case EM_NS32K: return "National Semiconductor 32000 series";
1986 case EM_TPC: return "Tenor Network TPC processor";
1987 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1988 case EM_MAX: return "MAX Processor";
1989 case EM_CR: return "National Semiconductor CompactRISC";
1990 case EM_F2MC16: return "Fujitsu F2MC16";
1991 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1992 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1993 case EM_M32C_OLD:
49f58d10 1994 case EM_M32C: return "Renesas M32c";
d031aafb 1995 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1996 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1997 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1998 case EM_SEP: return "Sharp embedded microprocessor";
1999 case EM_ARCA: return "Arca RISC microprocessor";
2000 case EM_UNICORE: return "Unicore";
2001 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2002 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2003 case EM_NIOS32: return "Altera Nios";
2004 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2005 case EM_C166:
d70c5fc7 2006 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2007 case EM_M16C: return "Renesas M16C series microprocessors";
2008 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2009 case EM_CE: return "Freescale Communication Engine RISC core";
2010 case EM_TSK3000: return "Altium TSK3000 core";
2011 case EM_RS08: return "Freescale RS08 embedded processor";
2012 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2013 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2014 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2015 case EM_SE_C17: return "Seiko Epson C17 family";
2016 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2017 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2018 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2019 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2020 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2021 case EM_R32C: return "Renesas R32C series microprocessors";
2022 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2023 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2024 case EM_8051: return "Intel 8051 and variants";
2025 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2026 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2027 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2028 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2029 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2030 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2031 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2032 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2033 case EM_CR16:
f6c1a2d5 2034 case EM_MICROBLAZE:
7ba29e2a 2035 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2036 case EM_RL78: return "Renesas RL78";
c7927a3c 2037 case EM_RX: return "Renesas RX";
a3c62988 2038 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2039 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2040 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2041 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2042 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2043 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2044 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2045 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2046 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2047 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2048 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2049 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2050 default:
35d9dd2f 2051 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2052 return buff;
2053 }
2054}
2055
f3485b74 2056static void
d3ba0551 2057decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2058{
2059 unsigned eabi;
2060 int unknown = 0;
2061
2062 eabi = EF_ARM_EABI_VERSION (e_flags);
2063 e_flags &= ~ EF_ARM_EABIMASK;
2064
2065 /* Handle "generic" ARM flags. */
2066 if (e_flags & EF_ARM_RELEXEC)
2067 {
2068 strcat (buf, ", relocatable executable");
2069 e_flags &= ~ EF_ARM_RELEXEC;
2070 }
76da6bbe 2071
f3485b74
NC		 2072 if (e_flags & EF_ARM_HASENTRY)
2073 {
2074 strcat (buf, ", has entry point");
2075 e_flags &= ~ EF_ARM_HASENTRY;
2076 }
76da6bbe 2077
f3485b74
NC		 2078 /* Now handle EABI specific flags. */
2079 switch (eabi)
2080 {
2081 default:
2c71103e 2082 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2083 if (e_flags)
2084 unknown = 1;
2085 break;
2086
2087 case EF_ARM_EABI_VER1:
a5bcd848 2088 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2089 while (e_flags)
2090 {
2091 unsigned flag;
76da6bbe 2092
f3485b74
NC		 2093 /* Process flags one bit at a time. */
2094 flag = e_flags & - e_flags;
2095 e_flags &= ~ flag;
76da6bbe 2096
f3485b74
NC		 2097 switch (flag)
2098 {
a5bcd848 2099 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2100 strcat (buf, ", sorted symbol tables");
2101 break;
76da6bbe 2102
f3485b74
NC		 2103 default:
2104 unknown = 1;
2105 break;
2106 }
2107 }
2108 break;
76da6bbe 2109
a5bcd848
PB		 2110 case EF_ARM_EABI_VER2:
2111 strcat (buf, ", Version2 EABI");
2112 while (e_flags)
2113 {
2114 unsigned flag;
2115
2116 /* Process flags one bit at a time. */
2117 flag = e_flags & - e_flags;
2118 e_flags &= ~ flag;
2119
2120 switch (flag)
2121 {
2122 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2123 strcat (buf, ", sorted symbol tables");
2124 break;
2125
2126 case EF_ARM_DYNSYMSUSESEGIDX:
2127 strcat (buf, ", dynamic symbols use segment index");
2128 break;
2129
2130 case EF_ARM_MAPSYMSFIRST:
2131 strcat (buf, ", mapping symbols precede others");
2132 break;
2133
2134 default:
2135 unknown = 1;
2136 break;
2137 }
2138 }
2139 break;
2140
d507cf36
PB		 2141 case EF_ARM_EABI_VER3:
2142 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2143 break;
2144
2145 case EF_ARM_EABI_VER4:
2146 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2147 while (e_flags)
2148 {
2149 unsigned flag;
2150
2151 /* Process flags one bit at a time. */
2152 flag = e_flags & - e_flags;
2153 e_flags &= ~ flag;
2154
2155 switch (flag)
2156 {
2157 case EF_ARM_BE8:
2158 strcat (buf, ", BE8");
2159 break;
2160
2161 case EF_ARM_LE8:
2162 strcat (buf, ", LE8");
2163 break;
2164
2165 default:
2166 unknown = 1;
2167 break;
2168 }
2169 break;
2170 }
2171 break;
3a4a14e9
PB		 2172
2173 case EF_ARM_EABI_VER5:
2174 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2175 while (e_flags)
2176 {
2177 unsigned flag;
2178
2179 /* Process flags one bit at a time. */
2180 flag = e_flags & - e_flags;
2181 e_flags &= ~ flag;
2182
2183 switch (flag)
2184 {
2185 case EF_ARM_BE8:
2186 strcat (buf, ", BE8");
2187 break;
2188
2189 case EF_ARM_LE8:
2190 strcat (buf, ", LE8");
2191 break;
2192
3bfcb652
NC		 2193 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2194 strcat (buf, ", soft-float ABI");
2195 break;
2196
2197 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2198 strcat (buf, ", hard-float ABI");
2199 break;
2200
d507cf36
PB		 2201 default:
2202 unknown = 1;
2203 break;
2204 }
2205 }
2206 break;
2207
f3485b74 2208 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2209 strcat (buf, ", GNU EABI");
f3485b74
NC		 2210 while (e_flags)
2211 {
2212 unsigned flag;
76da6bbe 2213
f3485b74
NC		 2214 /* Process flags one bit at a time. */
2215 flag = e_flags & - e_flags;
2216 e_flags &= ~ flag;
76da6bbe 2217
f3485b74
NC		 2218 switch (flag)
2219 {
a5bcd848 2220 case EF_ARM_INTERWORK:
f3485b74
NC		 2221 strcat (buf, ", interworking enabled");
2222 break;
76da6bbe 2223
a5bcd848 2224 case EF_ARM_APCS_26:
f3485b74
NC		 2225 strcat (buf, ", uses APCS/26");
2226 break;
76da6bbe 2227
a5bcd848 2228 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2229 strcat (buf, ", uses APCS/float");
2230 break;
76da6bbe 2231
a5bcd848 2232 case EF_ARM_PIC:
f3485b74
NC		 2233 strcat (buf, ", position independent");
2234 break;
76da6bbe 2235
a5bcd848 2236 case EF_ARM_ALIGN8:
f3485b74
NC		 2237 strcat (buf, ", 8 bit structure alignment");
2238 break;
76da6bbe 2239
a5bcd848 2240 case EF_ARM_NEW_ABI:
f3485b74
NC		 2241 strcat (buf, ", uses new ABI");
2242 break;
76da6bbe 2243
a5bcd848 2244 case EF_ARM_OLD_ABI:
f3485b74
NC		 2245 strcat (buf, ", uses old ABI");
2246 break;
76da6bbe 2247
a5bcd848 2248 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2249 strcat (buf, ", software FP");
2250 break;
76da6bbe 2251
90e01f86
ILT		 2252 case EF_ARM_VFP_FLOAT:
2253 strcat (buf, ", VFP");
2254 break;
2255
fde78edd
NC		 2256 case EF_ARM_MAVERICK_FLOAT:
2257 strcat (buf, ", Maverick FP");
2258 break;
2259
f3485b74
NC		 2260 default:
2261 unknown = 1;
2262 break;
2263 }
2264 }
2265 }
f3485b74
NC		 2266
2267 if (unknown)
2b692964 2268 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2269}
2270
252b5132 2271static char *
d3ba0551 2272get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2273{
b34976b6 2274 static char buf[1024];
252b5132
RH		 2275
2276 buf[0] = '\0';
76da6bbe 2277
252b5132
RH		 2278 if (e_flags)
2279 {
2280 switch (e_machine)
2281 {
2282 default:
2283 break;
2284
f3485b74
NC		 2285 case EM_ARM:
2286 decode_ARM_machine_flags (e_flags, buf);
2287 break;
76da6bbe 2288
781303ce
MF		 2289 case EM_BLACKFIN:
2290 if (e_flags & EF_BFIN_PIC)
2291 strcat (buf, ", PIC");
2292
2293 if (e_flags & EF_BFIN_FDPIC)
2294 strcat (buf, ", FDPIC");
2295
2296 if (e_flags & EF_BFIN_CODE_IN_L1)
2297 strcat (buf, ", code in L1");
2298
2299 if (e_flags & EF_BFIN_DATA_IN_L1)
2300 strcat (buf, ", data in L1");
2301
2302 break;
2303
ec2dfb42
AO		 2304 case EM_CYGNUS_FRV:
2305 switch (e_flags & EF_FRV_CPU_MASK)
2306 {
2307 case EF_FRV_CPU_GENERIC:
2308 break;
2309
2310 default:
2311 strcat (buf, ", fr???");
2312 break;
57346661 2313
ec2dfb42
AO		 2314 case EF_FRV_CPU_FR300:
2315 strcat (buf, ", fr300");
2316 break;
2317
2318 case EF_FRV_CPU_FR400:
2319 strcat (buf, ", fr400");
2320 break;
2321 case EF_FRV_CPU_FR405:
2322 strcat (buf, ", fr405");
2323 break;
2324
2325 case EF_FRV_CPU_FR450:
2326 strcat (buf, ", fr450");
2327 break;
2328
2329 case EF_FRV_CPU_FR500:
2330 strcat (buf, ", fr500");
2331 break;
2332 case EF_FRV_CPU_FR550:
2333 strcat (buf, ", fr550");
2334 break;
2335
2336 case EF_FRV_CPU_SIMPLE:
2337 strcat (buf, ", simple");
2338 break;
2339 case EF_FRV_CPU_TOMCAT:
2340 strcat (buf, ", tomcat");
2341 break;
2342 }
1c877e87 2343 break;
ec2dfb42 2344
53c7db4b 2345 case EM_68K:
425c6cb0 2346 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2347 strcat (buf, ", m68000");
425c6cb0 2348 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2349 strcat (buf, ", cpu32");
2350 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2351 strcat (buf, ", fido_a");
425c6cb0 2352 else
266abb8f 2353 {
2cf0635d
NC		 2354 char const * isa = _("unknown");
2355 char const * mac = _("unknown mac");
2356 char const * additional = NULL;
0112cd26 2357
c694fd50 2358 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2359 {
c694fd50 2360 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2361 isa = "A";
2362 additional = ", nodiv";
2363 break;
c694fd50 2364 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2365 isa = "A";
2366 break;
c694fd50 2367 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2368 isa = "A+";
2369 break;
c694fd50 2370 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2371 isa = "B";
2372 additional = ", nousp";
2373 break;
c694fd50 2374 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2375 isa = "B";
2376 break;
f608cd77
NS		 2377 case EF_M68K_CF_ISA_C:
2378 isa = "C";
2379 break;
2380 case EF_M68K_CF_ISA_C_NODIV:
2381 isa = "C";
2382 additional = ", nodiv";
2383 break;
266abb8f
NS		 2384 }
2385 strcat (buf, ", cf, isa ");
2386 strcat (buf, isa);
0b2e31dc
NS		 2387 if (additional)
2388 strcat (buf, additional);
c694fd50 2389 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2390 strcat (buf, ", float");
c694fd50 2391 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2392 {
2393 case 0:
2394 mac = NULL;
2395 break;
c694fd50 2396 case EF_M68K_CF_MAC:
266abb8f
NS		 2397 mac = "mac";
2398 break;
c694fd50 2399 case EF_M68K_CF_EMAC:
266abb8f
NS		 2400 mac = "emac";
2401 break;
f608cd77
NS		 2402 case EF_M68K_CF_EMAC_B:
2403 mac = "emac_b";
2404 break;
266abb8f
NS		 2405 }
2406 if (mac)
2407 {
2408 strcat (buf, ", ");
2409 strcat (buf, mac);
2410 }
266abb8f 2411 }
53c7db4b 2412 break;
33c63f9d 2413
252b5132
RH		 2414 case EM_PPC:
2415 if (e_flags & EF_PPC_EMB)
2416 strcat (buf, ", emb");
2417
2418 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2419 strcat (buf, _(", relocatable"));
252b5132
RH		 2420
2421 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2422 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2423 break;
2424
708e2187
NC		 2425 case EM_V800:
2426 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2427 strcat (buf, ", RH850 ABI");
2428
2429 if (e_flags & EF_V800_850E3)
2430 strcat (buf, ", V3 architecture");
2431
2432 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2433 strcat (buf, ", FPU not used");
2434
2435 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2436 strcat (buf, ", regmode: COMMON");
2437
2438 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2439 strcat (buf, ", r4 not used");
2440
2441 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2442 strcat (buf, ", r30 not used");
2443
2444 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2445 strcat (buf, ", r5 not used");
2446
2447 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2448 strcat (buf, ", r2 not used");
2449
2450 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2451 {
2452 switch (e_flags & - e_flags)
2453 {
2454 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2455 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2456 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2457 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2458 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2459 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2460 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2461 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2462 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2463 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2464 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2465 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2466 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2467 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2468 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2469 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2470 default: break;
2471 }
2472 }
2473 break;
2474
2b0337b0 2475 case EM_V850:
252b5132
RH		 2476 case EM_CYGNUS_V850:
2477 switch (e_flags & EF_V850_ARCH)
2478 {
78c8d46c
NC		 2479 case E_V850E3V5_ARCH:
2480 strcat (buf, ", v850e3v5");
2481 break;
1cd986c5
NC		 2482 case E_V850E2V3_ARCH:
2483 strcat (buf, ", v850e2v3");
2484 break;
2485 case E_V850E2_ARCH:
2486 strcat (buf, ", v850e2");
2487 break;
2488 case E_V850E1_ARCH:
2489 strcat (buf, ", v850e1");
8ad30312 2490 break;
252b5132
RH		 2491 case E_V850E_ARCH:
2492 strcat (buf, ", v850e");
2493 break;
252b5132
RH		 2494 case E_V850_ARCH:
2495 strcat (buf, ", v850");
2496 break;
2497 default:
2b692964 2498 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2499 break;
2500 }
2501 break;
2502
2b0337b0 2503 case EM_M32R:
252b5132
RH		 2504 case EM_CYGNUS_M32R:
2505 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2506 strcat (buf, ", m32r");
252b5132
RH		 2507 break;
2508
2509 case EM_MIPS:
4fe85591 2510 case EM_MIPS_RS3_LE:
252b5132
RH		 2511 if (e_flags & EF_MIPS_NOREORDER)
2512 strcat (buf, ", noreorder");
2513
2514 if (e_flags & EF_MIPS_PIC)
2515 strcat (buf, ", pic");
2516
2517 if (e_flags & EF_MIPS_CPIC)
2518 strcat (buf, ", cpic");
2519
d1bdd336
TS		 2520 if (e_flags & EF_MIPS_UCODE)
2521 strcat (buf, ", ugen_reserved");
2522
252b5132
RH		 2523 if (e_flags & EF_MIPS_ABI2)
2524 strcat (buf, ", abi2");
2525
43521d43
TS		 2526 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2527 strcat (buf, ", odk first");
2528
a5d22d2a
TS		 2529 if (e_flags & EF_MIPS_32BITMODE)
2530 strcat (buf, ", 32bitmode");
2531
156c2f8b
NC		 2532 switch ((e_flags & EF_MIPS_MACH))
2533 {
2534 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2535 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2536 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2537 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2538 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2539 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2540 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2541 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2542 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2543 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2544 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2545 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2546 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2547 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2548 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2549 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2550 case 0:
2551 /* We simply ignore the field in this case to avoid confusion:
2552 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2553 extension. */
2554 break;
2b692964 2555 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2556 }
43521d43
TS		 2557
2558 switch ((e_flags & EF_MIPS_ABI))
2559 {
2560 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2561 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2562 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2563 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2564 case 0:
2565 /* We simply ignore the field in this case to avoid confusion:
2566 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2567 This means it is likely to be an o32 file, but not for
2568 sure. */
2569 break;
2b692964 2570 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2571 }
2572
2573 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2574 strcat (buf, ", mdmx");
2575
2576 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2577 strcat (buf, ", mips16");
2578
df58fc94
RS		 2579 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2580 strcat (buf, ", micromips");
2581
43521d43
TS		 2582 switch ((e_flags & EF_MIPS_ARCH))
2583 {
2584 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2585 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2586 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2587 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2588 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2589 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2590 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2591 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2592 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2593 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2594 }
252b5132 2595 break;
351b4b40 2596
ccde1100
AO		 2597 case EM_SH:
2598 switch ((e_flags & EF_SH_MACH_MASK))
2599 {
2600 case EF_SH1: strcat (buf, ", sh1"); break;
2601 case EF_SH2: strcat (buf, ", sh2"); break;
2602 case EF_SH3: strcat (buf, ", sh3"); break;
2603 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2604 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2605 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2606 case EF_SH3E: strcat (buf, ", sh3e"); break;
2607 case EF_SH4: strcat (buf, ", sh4"); break;
2608 case EF_SH5: strcat (buf, ", sh5"); break;
2609 case EF_SH2E: strcat (buf, ", sh2e"); break;
2610 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2611 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2612 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2613 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2614 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2615 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2616 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2617 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2618 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2619 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2620 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2621 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2622 }
2623
cec6a5b8
MR		 2624 if (e_flags & EF_SH_PIC)
2625 strcat (buf, ", pic");
2626
2627 if (e_flags & EF_SH_FDPIC)
2628 strcat (buf, ", fdpic");
ccde1100 2629 break;
57346661 2630
351b4b40
RH		 2631 case EM_SPARCV9:
2632 if (e_flags & EF_SPARC_32PLUS)
2633 strcat (buf, ", v8+");
2634
2635 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2636 strcat (buf, ", ultrasparcI");
2637
2638 if (e_flags & EF_SPARC_SUN_US3)
2639 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2640
2641 if (e_flags & EF_SPARC_HAL_R1)
2642 strcat (buf, ", halr1");
2643
2644 if (e_flags & EF_SPARC_LEDATA)
2645 strcat (buf, ", ledata");
2646
2647 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2648 strcat (buf, ", tso");
2649
2650 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2651 strcat (buf, ", pso");
2652
2653 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2654 strcat (buf, ", rmo");
2655 break;
7d466069 2656
103f02d3
UD		 2657 case EM_PARISC:
2658 switch (e_flags & EF_PARISC_ARCH)
2659 {
2660 case EFA_PARISC_1_0:
2661 strcpy (buf, ", PA-RISC 1.0");
2662 break;
2663 case EFA_PARISC_1_1:
2664 strcpy (buf, ", PA-RISC 1.1");
2665 break;
2666 case EFA_PARISC_2_0:
2667 strcpy (buf, ", PA-RISC 2.0");
2668 break;
2669 default:
2670 break;
2671 }
2672 if (e_flags & EF_PARISC_TRAPNIL)
2673 strcat (buf, ", trapnil");
2674 if (e_flags & EF_PARISC_EXT)
2675 strcat (buf, ", ext");
2676 if (e_flags & EF_PARISC_LSB)
2677 strcat (buf, ", lsb");
2678 if (e_flags & EF_PARISC_WIDE)
2679 strcat (buf, ", wide");
2680 if (e_flags & EF_PARISC_NO_KABP)
2681 strcat (buf, ", no kabp");
2682 if (e_flags & EF_PARISC_LAZYSWAP)
2683 strcat (buf, ", lazyswap");
30800947 2684 break;
76da6bbe 2685
7d466069 2686 case EM_PJ:
2b0337b0 2687 case EM_PJ_OLD:
7d466069
ILT		 2688 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2689 strcat (buf, ", new calling convention");
2690
2691 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2692 strcat (buf, ", gnu calling convention");
2693 break;
4d6ed7c8
NC		 2694
2695 case EM_IA_64:
2696 if ((e_flags & EF_IA_64_ABI64))
2697 strcat (buf, ", 64-bit");
2698 else
2699 strcat (buf, ", 32-bit");
2700 if ((e_flags & EF_IA_64_REDUCEDFP))
2701 strcat (buf, ", reduced fp model");
2702 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2703 strcat (buf, ", no function descriptors, constant gp");
2704 else if ((e_flags & EF_IA_64_CONS_GP))
2705 strcat (buf, ", constant gp");
2706 if ((e_flags & EF_IA_64_ABSOLUTE))
2707 strcat (buf, ", absolute");
28f997cf
TG		 2708 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2709 {
2710 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2711 strcat (buf, ", vms_linkages");
2712 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2713 {
2714 case EF_IA_64_VMS_COMCOD_SUCCESS:
2715 break;
2716 case EF_IA_64_VMS_COMCOD_WARNING:
2717 strcat (buf, ", warning");
2718 break;
2719 case EF_IA_64_VMS_COMCOD_ERROR:
2720 strcat (buf, ", error");
2721 break;
2722 case EF_IA_64_VMS_COMCOD_ABORT:
2723 strcat (buf, ", abort");
2724 break;
2725 default:
2726 abort ();
2727 }
2728 }
4d6ed7c8 2729 break;
179d3252
JT		 2730
2731 case EM_VAX:
2732 if ((e_flags & EF_VAX_NONPIC))
2733 strcat (buf, ", non-PIC");
2734 if ((e_flags & EF_VAX_DFLOAT))
2735 strcat (buf, ", D-Float");
2736 if ((e_flags & EF_VAX_GFLOAT))
2737 strcat (buf, ", G-Float");
2738 break;
c7927a3c
NC		 2739
2740 case EM_RX:
2741 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2742 strcat (buf, ", 64-bit doubles");
2743 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2744 strcat (buf, ", dsp");
d4cb0ea0
NC		 2745 if (e_flags & E_FLAG_RX_PID)
2746 strcat (buf, ", pid");
708e2187
NC		 2747 if (e_flags & E_FLAG_RX_ABI)
2748 strcat (buf, ", RX ABI");
d4cb0ea0 2749 break;
55786da2
AK		 2750
2751 case EM_S390:
2752 if (e_flags & EF_S390_HIGH_GPRS)
2753 strcat (buf, ", highgprs");
d4cb0ea0 2754 break;
40b36596
JM		 2755
2756 case EM_TI_C6000:
2757 if ((e_flags & EF_C6000_REL))
2758 strcat (buf, ", relocatable module");
d4cb0ea0 2759 break;
252b5132
RH		 2760 }
2761 }
2762
2763 return buf;
2764}
2765
252b5132 2766static const char *
d3ba0551
AM		 2767get_osabi_name (unsigned int osabi)
2768{
2769 static char buff[32];
2770
2771 switch (osabi)
2772 {
2773 case ELFOSABI_NONE: return "UNIX - System V";
2774 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2775 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2776 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2777 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2778 case ELFOSABI_AIX: return "UNIX - AIX";
2779 case ELFOSABI_IRIX: return "UNIX - IRIX";
2780 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2781 case ELFOSABI_TRU64: return "UNIX - TRU64";
2782 case ELFOSABI_MODESTO: return "Novell - Modesto";
2783 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2784 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2785 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2786 case ELFOSABI_AROS: return "AROS";
11636f9e 2787 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2788 default:
40b36596
JM		 2789 if (osabi >= 64)
2790 switch (elf_header.e_machine)
2791 {
2792 case EM_ARM:
2793 switch (osabi)
2794 {
2795 case ELFOSABI_ARM: return "ARM";
2796 default:
2797 break;
2798 }
2799 break;
2800
2801 case EM_MSP430:
2802 case EM_MSP430_OLD:
2803 switch (osabi)
2804 {
2805 case ELFOSABI_STANDALONE: return _("Standalone App");
2806 default:
2807 break;
2808 }
2809 break;
2810
2811 case EM_TI_C6000:
2812 switch (osabi)
2813 {
2814 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2815 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2816 default:
2817 break;
2818 }
2819 break;
2820
2821 default:
2822 break;
2823 }
e9e44622 2824 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2825 return buff;
2826 }
2827}
2828
a06ea964
NC		 2829static const char *
2830get_aarch64_segment_type (unsigned long type)
2831{
2832 switch (type)
2833 {
2834 case PT_AARCH64_ARCHEXT:
2835 return "AARCH64_ARCHEXT";
2836 default:
2837 break;
2838 }
2839
2840 return NULL;
2841}
2842
b294bdf8
MM		 2843static const char *
2844get_arm_segment_type (unsigned long type)
2845{
2846 switch (type)
2847 {
2848 case PT_ARM_EXIDX:
2849 return "EXIDX";
2850 default:
2851 break;
2852 }
2853
2854 return NULL;
2855}
2856
d3ba0551
AM		 2857static const char *
2858get_mips_segment_type (unsigned long type)
252b5132
RH		 2859{
2860 switch (type)
2861 {
2862 case PT_MIPS_REGINFO:
2863 return "REGINFO";
2864 case PT_MIPS_RTPROC:
2865 return "RTPROC";
2866 case PT_MIPS_OPTIONS:
2867 return "OPTIONS";
2868 default:
2869 break;
2870 }
2871
2872 return NULL;
2873}
2874
103f02d3 2875static const char *
d3ba0551 2876get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2877{
2878 switch (type)
2879 {
2880 case PT_HP_TLS: return "HP_TLS";
2881 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2882 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2883 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2884 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2885 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2886 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2887 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2888 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2889 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2890 case PT_HP_PARALLEL: return "HP_PARALLEL";
2891 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2892 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2893 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2894 case PT_HP_STACK: return "HP_STACK";
2895 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2896 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2897 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2898 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2899 default:
2900 break;
2901 }
2902
2903 return NULL;
2904}
2905
4d6ed7c8 2906static const char *
d3ba0551 2907get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2908{
2909 switch (type)
2910 {
2911 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2912 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2913 case PT_HP_TLS: return "HP_TLS";
2914 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2915 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2916 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2917 default:
2918 break;
2919 }
2920
2921 return NULL;
2922}
2923
40b36596
JM		 2924static const char *
2925get_tic6x_segment_type (unsigned long type)
2926{
2927 switch (type)
2928 {
2929 case PT_C6000_PHATTR: return "C6000_PHATTR";
2930 default:
2931 break;
2932 }
2933
2934 return NULL;
2935}
2936
252b5132 2937static const char *
d3ba0551 2938get_segment_type (unsigned long p_type)
252b5132 2939{
b34976b6 2940 static char buff[32];
252b5132
RH		 2941
2942 switch (p_type)
2943 {
b34976b6
AM		 2944 case PT_NULL: return "NULL";
2945 case PT_LOAD: return "LOAD";
252b5132 2946 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2947 case PT_INTERP: return "INTERP";
2948 case PT_NOTE: return "NOTE";
2949 case PT_SHLIB: return "SHLIB";
2950 case PT_PHDR: return "PHDR";
13ae64f3 2951 case PT_TLS: return "TLS";
252b5132 2952
65765700
JJ		 2953 case PT_GNU_EH_FRAME:
2954 return "GNU_EH_FRAME";
2b05f1b7 2955 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2956 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2957
252b5132
RH		 2958 default:
2959 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2960 {
2cf0635d 2961 const char * result;
103f02d3 2962
252b5132
RH		 2963 switch (elf_header.e_machine)
2964 {
a06ea964
NC		 2965 case EM_AARCH64:
2966 result = get_aarch64_segment_type (p_type);
2967 break;
b294bdf8
MM		 2968 case EM_ARM:
2969 result = get_arm_segment_type (p_type);
2970 break;
252b5132 2971 case EM_MIPS:
4fe85591 2972 case EM_MIPS_RS3_LE:
252b5132
RH		 2973 result = get_mips_segment_type (p_type);
2974 break;
103f02d3
UD		 2975 case EM_PARISC:
2976 result = get_parisc_segment_type (p_type);
2977 break;
4d6ed7c8
NC		 2978 case EM_IA_64:
2979 result = get_ia64_segment_type (p_type);
2980 break;
40b36596
JM		 2981 case EM_TI_C6000:
2982 result = get_tic6x_segment_type (p_type);
2983 break;
252b5132
RH		 2984 default:
2985 result = NULL;
2986 break;
2987 }
103f02d3 2988
252b5132
RH		 2989 if (result != NULL)
2990 return result;
103f02d3 2991
252b5132
RH		 2992 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2993 }
2994 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2995 {
2cf0635d 2996 const char * result;
103f02d3
UD		 2997
2998 switch (elf_header.e_machine)
2999 {
3000 case EM_PARISC:
3001 result = get_parisc_segment_type (p_type);
3002 break;
00428cca
AM		 3003 case EM_IA_64:
3004 result = get_ia64_segment_type (p_type);
3005 break;
103f02d3
UD		 3006 default:
3007 result = NULL;
3008 break;
3009 }
3010
3011 if (result != NULL)
3012 return result;
3013
3014 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3015 }
252b5132 3016 else
e9e44622 3017 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3018
3019 return buff;
3020 }
3021}
3022
3023static const char *
d3ba0551 3024get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3025{
3026 switch (sh_type)
3027 {
b34976b6
AM		 3028 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3029 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3030 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3031 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3032 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3033 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3034 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3035 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3036 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3037 case SHT_MIPS_RELD: return "MIPS_RELD";
3038 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3039 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3040 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3041 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3042 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3043 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3044 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3045 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3046 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3047 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3048 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3049 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3050 case SHT_MIPS_LINE: return "MIPS_LINE";
3051 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3052 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3053 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3054 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3055 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3056 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3057 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3058 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3059 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3060 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3061 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3062 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3063 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3064 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3065 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 3066 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3067 default:
3068 break;
3069 }
3070 return NULL;
3071}
3072
103f02d3 3073static const char *
d3ba0551 3074get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3075{
3076 switch (sh_type)
3077 {
3078 case SHT_PARISC_EXT: return "PARISC_EXT";
3079 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3080 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3081 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3082 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3083 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3084 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3085 default:
3086 break;
3087 }
3088 return NULL;
3089}
3090
4d6ed7c8 3091static const char *
d3ba0551 3092get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3093{
18bd398b 3094 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3095 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3096 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3097
4d6ed7c8
NC		 3098 switch (sh_type)
3099 {
148b93f2
NC		 3100 case SHT_IA_64_EXT: return "IA_64_EXT";
3101 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3102 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3103 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3104 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3105 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3106 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3107 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3108 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3109 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3110 default:
3111 break;
3112 }
3113 return NULL;
3114}
3115
d2b2c203
DJ		 3116static const char *
3117get_x86_64_section_type_name (unsigned int sh_type)
3118{
3119 switch (sh_type)
3120 {
3121 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3122 default:
3123 break;
3124 }
3125 return NULL;
3126}
3127
a06ea964
NC		 3128static const char *
3129get_aarch64_section_type_name (unsigned int sh_type)
3130{
3131 switch (sh_type)
3132 {
3133 case SHT_AARCH64_ATTRIBUTES:
3134 return "AARCH64_ATTRIBUTES";
3135 default:
3136 break;
3137 }
3138 return NULL;
3139}
3140
40a18ebd
NC		 3141static const char *
3142get_arm_section_type_name (unsigned int sh_type)
3143{
3144 switch (sh_type)
3145 {
7f6fed87
NC		 3146 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3147 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3148 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3149 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3150 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3151 default:
3152 break;
3153 }
3154 return NULL;
3155}
3156
40b36596
JM		 3157static const char *
3158get_tic6x_section_type_name (unsigned int sh_type)
3159{
3160 switch (sh_type)
3161 {
3162 case SHT_C6000_UNWIND:
3163 return "C6000_UNWIND";
3164 case SHT_C6000_PREEMPTMAP:
3165 return "C6000_PREEMPTMAP";
3166 case SHT_C6000_ATTRIBUTES:
3167 return "C6000_ATTRIBUTES";
3168 case SHT_TI_ICODE:
3169 return "TI_ICODE";
3170 case SHT_TI_XREF:
3171 return "TI_XREF";
3172 case SHT_TI_HANDLER:
3173 return "TI_HANDLER";
3174 case SHT_TI_INITINFO:
3175 return "TI_INITINFO";
3176 case SHT_TI_PHATTRS:
3177 return "TI_PHATTRS";
3178 default:
3179 break;
3180 }
3181 return NULL;
3182}
3183
252b5132 3184static const char *
d3ba0551 3185get_section_type_name (unsigned int sh_type)
252b5132 3186{
b34976b6 3187 static char buff[32];
252b5132
RH		 3188
3189 switch (sh_type)
3190 {
3191 case SHT_NULL: return "NULL";
3192 case SHT_PROGBITS: return "PROGBITS";
3193 case SHT_SYMTAB: return "SYMTAB";
3194 case SHT_STRTAB: return "STRTAB";
3195 case SHT_RELA: return "RELA";
3196 case SHT_HASH: return "HASH";
3197 case SHT_DYNAMIC: return "DYNAMIC";
3198 case SHT_NOTE: return "NOTE";
3199 case SHT_NOBITS: return "NOBITS";
3200 case SHT_REL: return "REL";
3201 case SHT_SHLIB: return "SHLIB";
3202 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3203 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3204 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3205 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3206 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3207 case SHT_GROUP: return "GROUP";
3208 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3209 case SHT_GNU_verdef: return "VERDEF";
3210 case SHT_GNU_verneed: return "VERNEED";
3211 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3212 case 0x6ffffff0: return "VERSYM";
3213 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3214 case 0x7ffffffd: return "AUXILIARY";
3215 case 0x7fffffff: return "FILTER";
047b2264 3216 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3217
3218 default:
3219 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3220 {
2cf0635d 3221 const char * result;
252b5132
RH		 3222
3223 switch (elf_header.e_machine)
3224 {
3225 case EM_MIPS:
4fe85591 3226 case EM_MIPS_RS3_LE:
252b5132
RH		 3227 result = get_mips_section_type_name (sh_type);
3228 break;
103f02d3
UD		 3229 case EM_PARISC:
3230 result = get_parisc_section_type_name (sh_type);
3231 break;
4d6ed7c8
NC		 3232 case EM_IA_64:
3233 result = get_ia64_section_type_name (sh_type);
3234 break;
d2b2c203 3235 case EM_X86_64:
8a9036a4 3236 case EM_L1OM:
7a9068fe 3237 case EM_K1OM:
d2b2c203
DJ		 3238 result = get_x86_64_section_type_name (sh_type);
3239 break;
a06ea964
NC		 3240 case EM_AARCH64:
3241 result = get_aarch64_section_type_name (sh_type);
3242 break;
40a18ebd
NC		 3243 case EM_ARM:
3244 result = get_arm_section_type_name (sh_type);
3245 break;
40b36596
JM		 3246 case EM_TI_C6000:
3247 result = get_tic6x_section_type_name (sh_type);
3248 break;
252b5132
RH		 3249 default:
3250 result = NULL;
3251 break;
3252 }
3253
3254 if (result != NULL)
3255 return result;
3256
c91d0dfb 3257 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3258 }
3259 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3260 {
2cf0635d 3261 const char * result;
148b93f2
NC		 3262
3263 switch (elf_header.e_machine)
3264 {
3265 case EM_IA_64:
3266 result = get_ia64_section_type_name (sh_type);
3267 break;
3268 default:
3269 result = NULL;
3270 break;
3271 }
3272
3273 if (result != NULL)
3274 return result;
3275
3276 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3277 }
252b5132 3278 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3279 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3280 else
a7dbfd1c
NC		 3281 /* This message is probably going to be displayed in a 15
3282 character wide field, so put the hex value first. */
3283 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3284
252b5132
RH		 3285 return buff;
3286 }
3287}
3288
2979dc34 3289#define OPTION_DEBUG_DUMP 512
2c610e4b 3290#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3291#define OPTION_DWARF_DEPTH 514
3292#define OPTION_DWARF_START 515
4723351a 3293#define OPTION_DWARF_CHECK 516
2979dc34 3294
85b1c36d 3295static struct option options[] =
252b5132 3296{
b34976b6 3297 {"all", no_argument, 0, 'a'},
252b5132
RH		 3298 {"file-header", no_argument, 0, 'h'},
3299 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3300 {"headers", no_argument, 0, 'e'},
3301 {"histogram", no_argument, 0, 'I'},
3302 {"segments", no_argument, 0, 'l'},
3303 {"sections", no_argument, 0, 'S'},
252b5132 3304 {"section-headers", no_argument, 0, 'S'},
f5842774 3305 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3306 {"section-details", no_argument, 0, 't'},
595cf52e 3307 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3308 {"symbols", no_argument, 0, 's'},
3309 {"syms", no_argument, 0, 's'},
2c610e4b 3310 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3311 {"relocs", no_argument, 0, 'r'},
3312 {"notes", no_argument, 0, 'n'},
3313 {"dynamic", no_argument, 0, 'd'},
a952a375 3314 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3315 {"version-info", no_argument, 0, 'V'},
3316 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3317 {"unwind", no_argument, 0, 'u'},
4145f1d5 3318 {"archive-index", no_argument, 0, 'c'},
b34976b6 3319 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3320 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3321 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3322#ifdef SUPPORT_DISASSEMBLY
3323 {"instruction-dump", required_argument, 0, 'i'},
3324#endif
cf13d699 3325 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3326
fd2f0033
TT		 3327 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3328 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3329 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3330
b34976b6
AM		 3331 {"version", no_argument, 0, 'v'},
3332 {"wide", no_argument, 0, 'W'},
3333 {"help", no_argument, 0, 'H'},
3334 {0, no_argument, 0, 0}
252b5132
RH		 3335};
3336
3337static void
2cf0635d 3338usage (FILE * stream)
252b5132 3339{
92f01d61
JM		 3340 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3341 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3342 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3343 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3344 -h --file-header Display the ELF file header\n\
3345 -l --program-headers Display the program headers\n\
3346 --segments An alias for --program-headers\n\
3347 -S --section-headers Display the sections' header\n\
3348 --sections An alias for --section-headers\n\
f5842774 3349 -g --section-groups Display the section groups\n\
5477e8a0 3350 -t --section-details Display the section details\n\
8b53311e
NC		 3351 -e --headers Equivalent to: -h -l -S\n\
3352 -s --syms Display the symbol table\n\
3f08eb35 3353 --symbols An alias for --syms\n\
2c610e4b 3354 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3355 -n --notes Display the core notes (if present)\n\
3356 -r --relocs Display the relocations (if present)\n\
3357 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3358 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3359 -V --version-info Display the version sections (if present)\n\
1b31d05e 3360 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3361 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3362 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3363 -x --hex-dump=<number|name>\n\
3364 Dump the contents of section <number|name> as bytes\n\
3365 -p --string-dump=<number|name>\n\
3366 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3367 -R --relocated-dump=<number|name>\n\
3368 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3369 -w[lLiaprmfFsoRt] or\n\
1ed06042 3370 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3371 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3372 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3373 =addr,=cu_index]\n\
8b53311e 3374 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3375 fprintf (stream, _("\
3376 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3377 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3378 or deeper\n"));
252b5132 3379#ifdef SUPPORT_DISASSEMBLY
92f01d61 3380 fprintf (stream, _("\
09c11c86
NC		 3381 -i --instruction-dump=<number|name>\n\
3382 Disassemble the contents of section <number|name>\n"));
252b5132 3383#endif
92f01d61 3384 fprintf (stream, _("\
8b53311e
NC		 3385 -I --histogram Display histogram of bucket list lengths\n\
3386 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3387 @<file> Read options from <file>\n\
8b53311e
NC		 3388 -H --help Display this information\n\
3389 -v --version Display the version number of readelf\n"));
1118d252 3390
92f01d61
JM		 3391 if (REPORT_BUGS_TO[0] && stream == stdout)
3392 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3393
92f01d61 3394 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3395}
3396
18bd398b
NC		 3397/* Record the fact that the user wants the contents of section number
3398 SECTION to be displayed using the method(s) encoded as flags bits
3399 in TYPE. Note, TYPE can be zero if we are creating the array for
3400 the first time. */
3401
252b5132 3402static void
09c11c86 3403request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3404{
3405 if (section >= num_dump_sects)
3406 {
2cf0635d 3407 dump_type * new_dump_sects;
252b5132 3408
3f5e193b
NC		 3409 new_dump_sects = (dump_type *) calloc (section + 1,
3410 sizeof (* dump_sects));
252b5132
RH		 3411
3412 if (new_dump_sects == NULL)
591a748a 3413 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3414 else
3415 {
3416 /* Copy current flag settings. */
09c11c86 3417 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3418
3419 free (dump_sects);
3420
3421 dump_sects = new_dump_sects;
3422 num_dump_sects = section + 1;
3423 }
3424 }
3425
3426 if (dump_sects)
b34976b6 3427 dump_sects[section] |= type;
252b5132
RH		 3428
3429 return;
3430}
3431
aef1f6d0
DJ		 3432/* Request a dump by section name. */
3433
3434static void
2cf0635d 3435request_dump_byname (const char * section, dump_type type)
aef1f6d0 3436{
2cf0635d 3437 struct dump_list_entry * new_request;
aef1f6d0 3438
3f5e193b
NC		 3439 new_request = (struct dump_list_entry *)
3440 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3441 if (!new_request)
591a748a 3442 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3443
3444 new_request->name = strdup (section);
3445 if (!new_request->name)
591a748a 3446 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3447
3448 new_request->type = type;
3449
3450 new_request->next = dump_sects_byname;
3451 dump_sects_byname = new_request;
3452}
3453
cf13d699
NC		 3454static inline void
3455request_dump (dump_type type)
3456{
3457 int section;
3458 char * cp;
3459
3460 do_dump++;
3461 section = strtoul (optarg, & cp, 0);
3462
3463 if (! *cp && section >= 0)
3464 request_dump_bynumber (section, type);
3465 else
3466 request_dump_byname (optarg, type);
3467}
3468
3469
252b5132 3470static void
2cf0635d 3471parse_args (int argc, char ** argv)
252b5132
RH		 3472{
3473 int c;
3474
3475 if (argc < 2)
92f01d61 3476 usage (stderr);
252b5132
RH		 3477
3478 while ((c = getopt_long
cf13d699 3479 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3480 {
252b5132
RH		 3481 switch (c)
3482 {
3483 case 0:
3484 /* Long options. */
3485 break;
3486 case 'H':
92f01d61 3487 usage (stdout);
252b5132
RH		 3488 break;
3489
3490 case 'a':
b34976b6
AM		 3491 do_syms++;
3492 do_reloc++;
3493 do_unwind++;
3494 do_dynamic++;
3495 do_header++;
3496 do_sections++;
f5842774 3497 do_section_groups++;
b34976b6
AM		 3498 do_segments++;
3499 do_version++;
3500 do_histogram++;
3501 do_arch++;
3502 do_notes++;
252b5132 3503 break;
f5842774
L		 3504 case 'g':
3505 do_section_groups++;
3506 break;
5477e8a0 3507 case 't':
595cf52e 3508 case 'N':
5477e8a0
L		 3509 do_sections++;
3510 do_section_details++;
595cf52e 3511 break;
252b5132 3512 case 'e':
b34976b6
AM		 3513 do_header++;
3514 do_sections++;
3515 do_segments++;
252b5132 3516 break;
a952a375 3517 case 'A':
b34976b6 3518 do_arch++;
a952a375 3519 break;
252b5132 3520 case 'D':
b34976b6 3521 do_using_dynamic++;
252b5132
RH		 3522 break;
3523 case 'r':
b34976b6 3524 do_reloc++;
252b5132 3525 break;
4d6ed7c8 3526 case 'u':
b34976b6 3527 do_unwind++;
4d6ed7c8 3528 break;
252b5132 3529 case 'h':
b34976b6 3530 do_header++;
252b5132
RH		 3531 break;
3532 case 'l':
b34976b6 3533 do_segments++;
252b5132
RH		 3534 break;
3535 case 's':
b34976b6 3536 do_syms++;
252b5132
RH		 3537 break;
3538 case 'S':
b34976b6 3539 do_sections++;
252b5132
RH		 3540 break;
3541 case 'd':
b34976b6 3542 do_dynamic++;
252b5132 3543 break;
a952a375 3544 case 'I':
b34976b6 3545 do_histogram++;
a952a375 3546 break;
779fe533 3547 case 'n':
b34976b6 3548 do_notes++;
779fe533 3549 break;
4145f1d5
NC		 3550 case 'c':
3551 do_archive_index++;
3552 break;
252b5132 3553 case 'x':
cf13d699 3554 request_dump (HEX_DUMP);
aef1f6d0 3555 break;
09c11c86 3556 case 'p':
cf13d699
NC		 3557 request_dump (STRING_DUMP);
3558 break;
3559 case 'R':
3560 request_dump (RELOC_DUMP);
09c11c86 3561 break;
252b5132 3562 case 'w':
b34976b6 3563 do_dump++;
252b5132 3564 if (optarg == 0)
613ff48b
CC		 3565 {
3566 do_debugging = 1;
3567 dwarf_select_sections_all ();
3568 }
252b5132
RH		 3569 else
3570 {
3571 do_debugging = 0;
4cb93e3b 3572 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3573 }
3574 break;
2979dc34 3575 case OPTION_DEBUG_DUMP:
b34976b6 3576 do_dump++;
2979dc34
JJ		 3577 if (optarg == 0)
3578 do_debugging = 1;
3579 else
3580 {
2979dc34 3581 do_debugging = 0;
4cb93e3b 3582 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3583 }
3584 break;
fd2f0033
TT		 3585 case OPTION_DWARF_DEPTH:
3586 {
3587 char *cp;
3588
3589 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3590 }
3591 break;
3592 case OPTION_DWARF_START:
3593 {
3594 char *cp;
3595
3596 dwarf_start_die = strtoul (optarg, & cp, 0);
3597 }
3598 break;
4723351a
CC		 3599 case OPTION_DWARF_CHECK:
3600 dwarf_check = 1;
3601 break;
2c610e4b
L		 3602 case OPTION_DYN_SYMS:
3603 do_dyn_syms++;
3604 break;
252b5132
RH		 3605#ifdef SUPPORT_DISASSEMBLY
3606 case 'i':
cf13d699
NC		 3607 request_dump (DISASS_DUMP);
3608 break;
252b5132
RH		 3609#endif
3610 case 'v':
3611 print_version (program_name);
3612 break;
3613 case 'V':
b34976b6 3614 do_version++;
252b5132 3615 break;
d974e256 3616 case 'W':
b34976b6 3617 do_wide++;
d974e256 3618 break;
252b5132 3619 default:
252b5132
RH		 3620 /* xgettext:c-format */
3621 error (_("Invalid option '-%c'\n"), c);
3622 /* Drop through. */
3623 case '?':
92f01d61 3624 usage (stderr);
252b5132
RH		 3625 }
3626 }
3627
4d6ed7c8 3628 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3629 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3630 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3631 && !do_section_groups && !do_archive_index
3632 && !do_dyn_syms)
92f01d61 3633 usage (stderr);
252b5132
RH		 3634 else if (argc < 3)
3635 {
3636 warn (_("Nothing to do.\n"));
92f01d61 3637 usage (stderr);
252b5132
RH		 3638 }
3639}
3640
3641static const char *
d3ba0551 3642get_elf_class (unsigned int elf_class)
252b5132 3643{
b34976b6 3644 static char buff[32];
103f02d3 3645
252b5132
RH		 3646 switch (elf_class)
3647 {
3648 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3649 case ELFCLASS32: return "ELF32";
3650 case ELFCLASS64: return "ELF64";
ab5e7794 3651 default:
e9e44622 3652 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3653 return buff;
252b5132
RH		 3654 }
3655}
3656
3657static const char *
d3ba0551 3658get_data_encoding (unsigned int encoding)
252b5132 3659{
b34976b6 3660 static char buff[32];
103f02d3 3661
252b5132
RH		 3662 switch (encoding)
3663 {
3664 case ELFDATANONE: return _("none");
33c63f9d
CM		 3665 case ELFDATA2LSB: return _("2's complement, little endian");
3666 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3667 default:
e9e44622 3668 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3669 return buff;
252b5132
RH		 3670 }
3671}
3672
252b5132 3673/* Decode the data held in 'elf_header'. */
ee42cf8c 3674
252b5132 3675static int
d3ba0551 3676process_file_header (void)
252b5132 3677{
b34976b6
AM		 3678 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3679 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3680 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3681 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3682 {
3683 error
3684 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3685 return 0;
3686 }
3687
2dc4cec1
L		 3688 init_dwarf_regnames (elf_header.e_machine);
3689
252b5132
RH		 3690 if (do_header)
3691 {
3692 int i;
3693
3694 printf (_("ELF Header:\n"));
3695 printf (_(" Magic: "));
b34976b6
AM		 3696 for (i = 0; i < EI_NIDENT; i++)
3697 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3698 printf ("\n");
3699 printf (_(" Class: %s\n"),
b34976b6 3700 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3701 printf (_(" Data: %s\n"),
b34976b6 3702 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3703 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3704 elf_header.e_ident[EI_VERSION],
3705 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3706 ? "(current)"
b34976b6 3707 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3708 ? _("<unknown: %lx>")
789be9f7 3709 : "")));
252b5132 3710 printf (_(" OS/ABI: %s\n"),
b34976b6 3711 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3712 printf (_(" ABI Version: %d\n"),
b34976b6 3713 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3714 printf (_(" Type: %s\n"),
3715 get_file_type (elf_header.e_type));
3716 printf (_(" Machine: %s\n"),
3717 get_machine_name (elf_header.e_machine));
3718 printf (_(" Version: 0x%lx\n"),
3719 (unsigned long) elf_header.e_version);
76da6bbe 3720
f7a99963
NC		 3721 printf (_(" Entry point address: "));
3722 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3723 printf (_("\n Start of program headers: "));
3724 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3725 printf (_(" (bytes into file)\n Start of section headers: "));
3726 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3727 printf (_(" (bytes into file)\n"));
76da6bbe 3728
252b5132
RH		 3729 printf (_(" Flags: 0x%lx%s\n"),
3730 (unsigned long) elf_header.e_flags,
3731 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3732 printf (_(" Size of this header: %ld (bytes)\n"),
3733 (long) elf_header.e_ehsize);
3734 printf (_(" Size of program headers: %ld (bytes)\n"),
3735 (long) elf_header.e_phentsize);
2046a35d 3736 printf (_(" Number of program headers: %ld"),
252b5132 3737 (long) elf_header.e_phnum);
2046a35d
AM		 3738 if (section_headers != NULL
3739 && elf_header.e_phnum == PN_XNUM
3740 && section_headers[0].sh_info != 0)
cc5914eb 3741 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3742 putc ('\n', stdout);
252b5132
RH		 3743 printf (_(" Size of section headers: %ld (bytes)\n"),
3744 (long) elf_header.e_shentsize);
560f3c1c 3745 printf (_(" Number of section headers: %ld"),
252b5132 3746 (long) elf_header.e_shnum);
4fbb74a6 3747 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3748 printf (" (%ld)", (long) section_headers[0].sh_size);
3749 putc ('\n', stdout);
3750 printf (_(" Section header string table index: %ld"),
252b5132 3751 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3752 if (section_headers != NULL
3753 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3754 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3755 else if (elf_header.e_shstrndx != SHN_UNDEF
3756 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3757 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3758 putc ('\n', stdout);
3759 }
3760
3761 if (section_headers != NULL)
3762 {
2046a35d
AM		 3763 if (elf_header.e_phnum == PN_XNUM
3764 && section_headers[0].sh_info != 0)
3765 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3766 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3767 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3768 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3769 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3770 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3771 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3772 free (section_headers);
3773 section_headers = NULL;
252b5132 3774 }
103f02d3 3775
9ea033b2
NC		 3776 return 1;
3777}
3778
252b5132 3779
9ea033b2 3780static int
91d6fa6a 3781get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3782{
2cf0635d
NC		 3783 Elf32_External_Phdr * phdrs;
3784 Elf32_External_Phdr * external;
3785 Elf_Internal_Phdr * internal;
b34976b6 3786 unsigned int i;
103f02d3 3787
3f5e193b
NC		 3788 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3789 elf_header.e_phentsize,
3790 elf_header.e_phnum,
3791 _("program headers"));
a6e9f9df
AM		 3792 if (!phdrs)
3793 return 0;
9ea033b2 3794
91d6fa6a 3795 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3796 i < elf_header.e_phnum;
b34976b6 3797 i++, internal++, external++)
252b5132 3798 {
9ea033b2
NC		 3799 internal->p_type = BYTE_GET (external->p_type);
3800 internal->p_offset = BYTE_GET (external->p_offset);
3801 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3802 internal->p_paddr = BYTE_GET (external->p_paddr);
3803 internal->p_filesz = BYTE_GET (external->p_filesz);
3804 internal->p_memsz = BYTE_GET (external->p_memsz);
3805 internal->p_flags = BYTE_GET (external->p_flags);
3806 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3807 }
3808
9ea033b2
NC		 3809 free (phdrs);
3810
252b5132
RH		 3811 return 1;
3812}
3813
9ea033b2 3814static int
91d6fa6a 3815get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3816{
2cf0635d
NC		 3817 Elf64_External_Phdr * phdrs;
3818 Elf64_External_Phdr * external;
3819 Elf_Internal_Phdr * internal;
b34976b6 3820 unsigned int i;
103f02d3 3821
3f5e193b
NC		 3822 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3823 elf_header.e_phentsize,
3824 elf_header.e_phnum,
3825 _("program headers"));
a6e9f9df
AM		 3826 if (!phdrs)
3827 return 0;
9ea033b2 3828
91d6fa6a 3829 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3830 i < elf_header.e_phnum;
b34976b6 3831 i++, internal++, external++)
9ea033b2
NC		 3832 {
3833 internal->p_type = BYTE_GET (external->p_type);
3834 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3835 internal->p_offset = BYTE_GET (external->p_offset);
3836 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3837 internal->p_paddr = BYTE_GET (external->p_paddr);
3838 internal->p_filesz = BYTE_GET (external->p_filesz);
3839 internal->p_memsz = BYTE_GET (external->p_memsz);
3840 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3841 }
3842
3843 free (phdrs);
3844
3845 return 1;
3846}
252b5132 3847
d93f0186
NC		 3848/* Returns 1 if the program headers were read into `program_headers'. */
3849
3850static int
2cf0635d 3851get_program_headers (FILE * file)
d93f0186 3852{
2cf0635d 3853 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3854
3855 /* Check cache of prior read. */
3856 if (program_headers != NULL)
3857 return 1;
3858
3f5e193b
NC		 3859 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3860 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3861
3862 if (phdrs == NULL)
3863 {
3864 error (_("Out of memory\n"));
3865 return 0;
3866 }
3867
3868 if (is_32bit_elf
3869 ? get_32bit_program_headers (file, phdrs)
3870 : get_64bit_program_headers (file, phdrs))
3871 {
3872 program_headers = phdrs;
3873 return 1;
3874 }
3875
3876 free (phdrs);
3877 return 0;
3878}
3879
2f62977e
NC		 3880/* Returns 1 if the program headers were loaded. */
3881
252b5132 3882static int
2cf0635d 3883process_program_headers (FILE * file)
252b5132 3884{
2cf0635d 3885 Elf_Internal_Phdr * segment;
b34976b6 3886 unsigned int i;
252b5132
RH		 3887
3888 if (elf_header.e_phnum == 0)
3889 {
82f2dbf7
NC		 3890 /* PR binutils/12467. */
3891 if (elf_header.e_phoff != 0)
3892 warn (_("possibly corrupt ELF header - it has a non-zero program"
3893 " header offset, but no program headers"));
3894 else if (do_segments)
252b5132 3895 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3896 return 0;
252b5132
RH		 3897 }
3898
3899 if (do_segments && !do_header)
3900 {
f7a99963
NC		 3901 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3902 printf (_("Entry point "));
3903 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3904 printf (_("\nThere are %d program headers, starting at offset "),
3905 elf_header.e_phnum);
3906 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3907 printf ("\n");
252b5132
RH		 3908 }
3909
d93f0186 3910 if (! get_program_headers (file))
252b5132 3911 return 0;
103f02d3 3912
252b5132
RH		 3913 if (do_segments)
3914 {
3a1a2036
NC		 3915 if (elf_header.e_phnum > 1)
3916 printf (_("\nProgram Headers:\n"));
3917 else
3918 printf (_("\nProgram Headers:\n"));
76da6bbe 3919
f7a99963
NC		 3920 if (is_32bit_elf)
3921 printf
3922 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3923 else if (do_wide)
3924 printf
3925 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3926 else
3927 {
3928 printf
3929 (_(" Type Offset VirtAddr PhysAddr\n"));
3930 printf
3931 (_(" FileSiz MemSiz Flags Align\n"));
3932 }
252b5132
RH		 3933 }
3934
252b5132 3935 dynamic_addr = 0;
1b228002 3936 dynamic_size = 0;
252b5132
RH		 3937
3938 for (i = 0, segment = program_headers;
3939 i < elf_header.e_phnum;
b34976b6 3940 i++, segment++)
252b5132
RH		 3941 {
3942 if (do_segments)
3943 {
103f02d3 3944 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3945
3946 if (is_32bit_elf)
3947 {
3948 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3949 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3950 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3951 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3952 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3953 printf ("%c%c%c ",
3954 (segment->p_flags & PF_R ? 'R' : ' '),
3955 (segment->p_flags & PF_W ? 'W' : ' '),
3956 (segment->p_flags & PF_X ? 'E' : ' '));
3957 printf ("%#lx", (unsigned long) segment->p_align);
3958 }
d974e256
JJ		 3959 else if (do_wide)
3960 {
3961 if ((unsigned long) segment->p_offset == segment->p_offset)
3962 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3963 else
3964 {
3965 print_vma (segment->p_offset, FULL_HEX);
3966 putchar (' ');
3967 }
3968
3969 print_vma (segment->p_vaddr, FULL_HEX);
3970 putchar (' ');
3971 print_vma (segment->p_paddr, FULL_HEX);
3972 putchar (' ');
3973
3974 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3975 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3976 else
3977 {
3978 print_vma (segment->p_filesz, FULL_HEX);
3979 putchar (' ');
3980 }
3981
3982 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3983 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3984 else
3985 {
f48e6c45 3986 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 3987 }
3988
3989 printf (" %c%c%c ",
3990 (segment->p_flags & PF_R ? 'R' : ' '),
3991 (segment->p_flags & PF_W ? 'W' : ' '),
3992 (segment->p_flags & PF_X ? 'E' : ' '));
3993
3994 if ((unsigned long) segment->p_align == segment->p_align)
3995 printf ("%#lx", (unsigned long) segment->p_align);
3996 else
3997 {
3998 print_vma (segment->p_align, PREFIX_HEX);
3999 }
4000 }
f7a99963
NC		 4001 else
4002 {
4003 print_vma (segment->p_offset, FULL_HEX);
4004 putchar (' ');
4005 print_vma (segment->p_vaddr, FULL_HEX);
4006 putchar (' ');
4007 print_vma (segment->p_paddr, FULL_HEX);
4008 printf ("\n ");
4009 print_vma (segment->p_filesz, FULL_HEX);
4010 putchar (' ');
4011 print_vma (segment->p_memsz, FULL_HEX);
4012 printf (" %c%c%c ",
4013 (segment->p_flags & PF_R ? 'R' : ' '),
4014 (segment->p_flags & PF_W ? 'W' : ' '),
4015 (segment->p_flags & PF_X ? 'E' : ' '));
4016 print_vma (segment->p_align, HEX);
4017 }
252b5132
RH		 4018 }
4019
4020 switch (segment->p_type)
4021 {
252b5132
RH		 4022 case PT_DYNAMIC:
4023 if (dynamic_addr)
4024 error (_("more than one dynamic segment\n"));
4025
20737c13
AM		 4026 /* By default, assume that the .dynamic section is the first
4027 section in the DYNAMIC segment. */
4028 dynamic_addr = segment->p_offset;
4029 dynamic_size = segment->p_filesz;
4030
b2d38a17
NC		 4031 /* Try to locate the .dynamic section. If there is
4032 a section header table, we can easily locate it. */
4033 if (section_headers != NULL)
4034 {
2cf0635d 4035 Elf_Internal_Shdr * sec;
b2d38a17 4036
89fac5e3
RS		 4037 sec = find_section (".dynamic");
4038 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4039 {
28f997cf
TG		 4040 /* A corresponding .dynamic section is expected, but on
4041 IA-64/OpenVMS it is OK for it to be missing. */
4042 if (!is_ia64_vms ())
4043 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4044 break;
4045 }
4046
42bb2e33 4047 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4048 {
4049 dynamic_size = 0;
4050 break;
4051 }
42bb2e33 4052
b2d38a17
NC		 4053 dynamic_addr = sec->sh_offset;
4054 dynamic_size = sec->sh_size;
4055
4056 if (dynamic_addr < segment->p_offset
4057 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4058 warn (_("the .dynamic section is not contained"
4059 " within the dynamic segment\n"));
b2d38a17 4060 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4061 warn (_("the .dynamic section is not the first section"
4062 " in the dynamic segment.\n"));
b2d38a17 4063 }
252b5132
RH		 4064 break;
4065
4066 case PT_INTERP:
fb52b2f4
NC		 4067 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4068 SEEK_SET))
252b5132
RH		 4069 error (_("Unable to find program interpreter name\n"));
4070 else
4071 {
f8eae8b2
L		 4072 char fmt [32];
4073 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4074
4075 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4076 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4077
252b5132 4078 program_interpreter[0] = 0;
7bd7b3ef
AM		 4079 if (fscanf (file, fmt, program_interpreter) <= 0)
4080 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4081
4082 if (do_segments)
4083 printf (_("\n [Requesting program interpreter: %s]"),
4084 program_interpreter);
4085 }
4086 break;
4087 }
4088
4089 if (do_segments)
4090 putc ('\n', stdout);
4091 }
4092
c256ffe7 4093 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4094 {
4095 printf (_("\n Section to Segment mapping:\n"));
4096 printf (_(" Segment Sections...\n"));
4097
252b5132
RH		 4098 for (i = 0; i < elf_header.e_phnum; i++)
4099 {
9ad5cbcf 4100 unsigned int j;
2cf0635d 4101 Elf_Internal_Shdr * section;
252b5132
RH		 4102
4103 segment = program_headers + i;
b391a3e3 4104 section = section_headers + 1;
252b5132
RH		 4105
4106 printf (" %2.2d ", i);
4107
b34976b6 4108 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4109 {
f4638467
AM		 4110 if (!ELF_TBSS_SPECIAL (section, segment)
4111 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 4112 printf ("%s ", SECTION_NAME (section));
4113 }
4114
4115 putc ('\n',stdout);
4116 }
4117 }
4118
252b5132
RH		 4119 return 1;
4120}
4121
4122
d93f0186
NC		 4123/* Find the file offset corresponding to VMA by using the program headers. */
4124
4125static long
2cf0635d 4126offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4127{
2cf0635d 4128 Elf_Internal_Phdr * seg;
d93f0186
NC		 4129
4130 if (! get_program_headers (file))
4131 {
4132 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4133 return (long) vma;
4134 }
4135
4136 for (seg = program_headers;
4137 seg < program_headers + elf_header.e_phnum;
4138 ++seg)
4139 {
4140 if (seg->p_type != PT_LOAD)
4141 continue;
4142
4143 if (vma >= (seg->p_vaddr & -seg->p_align)
4144 && vma + size <= seg->p_vaddr + seg->p_filesz)
4145 return vma - seg->p_vaddr + seg->p_offset;
4146 }
4147
4148 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4149 (unsigned long) vma);
d93f0186
NC		 4150 return (long) vma;
4151}
4152
4153
252b5132 4154static int
2cf0635d 4155get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4156{
2cf0635d
NC		 4157 Elf32_External_Shdr * shdrs;
4158 Elf_Internal_Shdr * internal;
b34976b6 4159 unsigned int i;
252b5132 4160
3f5e193b
NC		 4161 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4162 elf_header.e_shentsize, num,
4163 _("section headers"));
a6e9f9df
AM		 4164 if (!shdrs)
4165 return 0;
252b5132 4166
3f5e193b
NC		 4167 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4168 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4169
4170 if (section_headers == NULL)
4171 {
4172 error (_("Out of memory\n"));
4173 return 0;
4174 }
4175
4176 for (i = 0, internal = section_headers;
560f3c1c 4177 i < num;
b34976b6 4178 i++, internal++)
252b5132
RH		 4179 {
4180 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4181 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4182 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4183 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4184 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4185 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4186 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4187 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4188 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4189 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4190 }
4191
4192 free (shdrs);
4193
4194 return 1;
4195}
4196
9ea033b2 4197static int
2cf0635d 4198get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4199{
2cf0635d
NC		 4200 Elf64_External_Shdr * shdrs;
4201 Elf_Internal_Shdr * internal;
b34976b6 4202 unsigned int i;
9ea033b2 4203
3f5e193b
NC		 4204 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4205 elf_header.e_shentsize, num,
4206 _("section headers"));
a6e9f9df
AM		 4207 if (!shdrs)
4208 return 0;
9ea033b2 4209
3f5e193b
NC		 4210 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4211 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4212
4213 if (section_headers == NULL)
4214 {
4215 error (_("Out of memory\n"));
4216 return 0;
4217 }
4218
4219 for (i = 0, internal = section_headers;
560f3c1c 4220 i < num;
b34976b6 4221 i++, internal++)
9ea033b2
NC		 4222 {
4223 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4224 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4225 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4226 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4227 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4228 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4229 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4230 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4231 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4232 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4233 }
4234
4235 free (shdrs);
4236
4237 return 1;
4238}
4239
252b5132 4240static Elf_Internal_Sym *
ba5cdace
NC		 4241get_32bit_elf_symbols (FILE * file,
4242 Elf_Internal_Shdr * section,
4243 unsigned long * num_syms_return)
252b5132 4244{
ba5cdace 4245 unsigned long number = 0;
dd24e3da 4246 Elf32_External_Sym * esyms = NULL;
ba5cdace 4247 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4248 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4249 Elf_Internal_Sym * psym;
b34976b6 4250 unsigned int j;
252b5132 4251
dd24e3da
NC		 4252 /* Run some sanity checks first. */
4253 if (section->sh_entsize == 0)
4254 {
4255 error (_("sh_entsize is zero\n"));
ba5cdace 4256 goto exit_point;
dd24e3da
NC		 4257 }
4258
4259 number = section->sh_size / section->sh_entsize;
4260
4261 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4262 {
4263 error (_("Invalid sh_entsize\n"));
ba5cdace 4264 goto exit_point;
dd24e3da
NC		 4265 }
4266
3f5e193b
NC		 4267 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4268 section->sh_size, _("symbols"));
dd24e3da 4269 if (esyms == NULL)
ba5cdace 4270 goto exit_point;
252b5132 4271
9ad5cbcf
AM		 4272 shndx = NULL;
4273 if (symtab_shndx_hdr != NULL
4274 && (symtab_shndx_hdr->sh_link
4fbb74a6 4275 == (unsigned long) (section - section_headers)))
9ad5cbcf 4276 {
3f5e193b
NC		 4277 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4278 symtab_shndx_hdr->sh_offset,
4279 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4280 _("symbol table section indicies"));
dd24e3da
NC		 4281 if (shndx == NULL)
4282 goto exit_point;
9ad5cbcf
AM		 4283 }
4284
3f5e193b 4285 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4286
4287 if (isyms == NULL)
4288 {
4289 error (_("Out of memory\n"));
dd24e3da 4290 goto exit_point;
252b5132
RH		 4291 }
4292
dd24e3da 4293 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4294 {
4295 psym->st_name = BYTE_GET (esyms[j].st_name);
4296 psym->st_value = BYTE_GET (esyms[j].st_value);
4297 psym->st_size = BYTE_GET (esyms[j].st_size);
4298 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4299 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4300 psym->st_shndx
4301 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4302 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4303 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4304 psym->st_info = BYTE_GET (esyms[j].st_info);
4305 psym->st_other = BYTE_GET (esyms[j].st_other);
4306 }
4307
dd24e3da 4308 exit_point:
ba5cdace 4309 if (shndx != NULL)
9ad5cbcf 4310 free (shndx);
ba5cdace 4311 if (esyms != NULL)
dd24e3da 4312 free (esyms);
252b5132 4313
ba5cdace
NC		 4314 if (num_syms_return != NULL)
4315 * num_syms_return = isyms == NULL ? 0 : number;
4316
252b5132
RH		 4317 return isyms;
4318}
4319
9ea033b2 4320static Elf_Internal_Sym *
ba5cdace
NC		 4321get_64bit_elf_symbols (FILE * file,
4322 Elf_Internal_Shdr * section,
4323 unsigned long * num_syms_return)
9ea033b2 4324{
ba5cdace
NC		 4325 unsigned long number = 0;
4326 Elf64_External_Sym * esyms = NULL;
4327 Elf_External_Sym_Shndx * shndx = NULL;
4328 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4329 Elf_Internal_Sym * psym;
b34976b6 4330 unsigned int j;
9ea033b2 4331
dd24e3da
NC		 4332 /* Run some sanity checks first. */
4333 if (section->sh_entsize == 0)
4334 {
4335 error (_("sh_entsize is zero\n"));
ba5cdace 4336 goto exit_point;
dd24e3da
NC		 4337 }
4338
4339 number = section->sh_size / section->sh_entsize;
4340
4341 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4342 {
4343 error (_("Invalid sh_entsize\n"));
ba5cdace 4344 goto exit_point;
dd24e3da
NC		 4345 }
4346
3f5e193b
NC		 4347 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4348 section->sh_size, _("symbols"));
a6e9f9df 4349 if (!esyms)
ba5cdace 4350 goto exit_point;
9ea033b2 4351
9ad5cbcf
AM		 4352 if (symtab_shndx_hdr != NULL
4353 && (symtab_shndx_hdr->sh_link
4fbb74a6 4354 == (unsigned long) (section - section_headers)))
9ad5cbcf 4355 {
3f5e193b
NC		 4356 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4357 symtab_shndx_hdr->sh_offset,
4358 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4359 _("symbol table section indicies"));
ba5cdace
NC		 4360 if (shndx == NULL)
4361 goto exit_point;
9ad5cbcf
AM		 4362 }
4363
3f5e193b 4364 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4365
4366 if (isyms == NULL)
4367 {
4368 error (_("Out of memory\n"));
ba5cdace 4369 goto exit_point;
9ea033b2
NC		 4370 }
4371
ba5cdace 4372 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4373 {
4374 psym->st_name = BYTE_GET (esyms[j].st_name);
4375 psym->st_info = BYTE_GET (esyms[j].st_info);
4376 psym->st_other = BYTE_GET (esyms[j].st_other);
4377 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4378
4fbb74a6 4379 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4380 psym->st_shndx
4381 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4382 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4383 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4384
66543521
AM		 4385 psym->st_value = BYTE_GET (esyms[j].st_value);
4386 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4387 }
4388
ba5cdace
NC		 4389 exit_point:
4390 if (shndx != NULL)
9ad5cbcf 4391 free (shndx);
ba5cdace
NC		 4392 if (esyms != NULL)
4393 free (esyms);
4394
4395 if (num_syms_return != NULL)
4396 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4397
4398 return isyms;
4399}
4400
d1133906 4401static const char *
d3ba0551 4402get_elf_section_flags (bfd_vma sh_flags)
d1133906 4403{
5477e8a0 4404 static char buff[1024];
2cf0635d 4405 char * p = buff;
8d5ff12c 4406 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4407 int sindex;
4408 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4409 bfd_vma os_flags = 0;
4410 bfd_vma proc_flags = 0;
4411 bfd_vma unknown_flags = 0;
148b93f2 4412 static const struct
5477e8a0 4413 {
2cf0635d 4414 const char * str;
5477e8a0
L		 4415 int len;
4416 }
4417 flags [] =
4418 {
cfcac11d
NC		 4419 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4420 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4421 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4422 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4423 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4424 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4425 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4426 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4427 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4428 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4429 /* IA-64 specific. */
4430 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4431 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4432 /* IA-64 OpenVMS specific. */
4433 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4434 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4435 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4436 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4437 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4438 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4439 /* Generic. */
cfcac11d 4440 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4441 /* SPARC specific. */
cfcac11d 4442 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4443 };
4444
4445 if (do_section_details)
4446 {
8d5ff12c
L		 4447 sprintf (buff, "[%*.*lx]: ",
4448 field_size, field_size, (unsigned long) sh_flags);
4449 p += field_size + 4;
5477e8a0 4450 }
76da6bbe 4451
d1133906
NC		 4452 while (sh_flags)
4453 {
4454 bfd_vma flag;
4455
4456 flag = sh_flags & - sh_flags;
4457 sh_flags &= ~ flag;
76da6bbe 4458
5477e8a0 4459 if (do_section_details)
d1133906 4460 {
5477e8a0
L		 4461 switch (flag)
4462 {
91d6fa6a
NC		 4463 case SHF_WRITE: sindex = 0; break;
4464 case SHF_ALLOC: sindex = 1; break;
4465 case SHF_EXECINSTR: sindex = 2; break;
4466 case SHF_MERGE: sindex = 3; break;
4467 case SHF_STRINGS: sindex = 4; break;
4468 case SHF_INFO_LINK: sindex = 5; break;
4469 case SHF_LINK_ORDER: sindex = 6; break;
4470 case SHF_OS_NONCONFORMING: sindex = 7; break;
4471 case SHF_GROUP: sindex = 8; break;
4472 case SHF_TLS: sindex = 9; break;
18ae9cc1 4473 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4474
5477e8a0 4475 default:
91d6fa6a 4476 sindex = -1;
cfcac11d 4477 switch (elf_header.e_machine)
148b93f2 4478 {
cfcac11d 4479 case EM_IA_64:
148b93f2 4480 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4481 sindex = 10;
148b93f2 4482 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4483 sindex = 11;
148b93f2
NC		 4484#ifdef BFD64
4485 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4486 switch (flag)
4487 {
91d6fa6a
NC		 4488 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4489 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4490 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4491 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4492 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4493 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4494 default: break;
4495 }
4496#endif
cfcac11d
NC		 4497 break;
4498
caa83f8b
NC		 4499 case EM_386:
4500 case EM_486:
4501 case EM_X86_64:
7f502d6c 4502 case EM_L1OM:
7a9068fe 4503 case EM_K1OM:
cfcac11d
NC		 4504 case EM_OLD_SPARCV9:
4505 case EM_SPARC32PLUS:
4506 case EM_SPARCV9:
4507 case EM_SPARC:
18ae9cc1 4508 if (flag == SHF_ORDERED)
91d6fa6a 4509 sindex = 19;
cfcac11d
NC		 4510 break;
4511 default:
4512 break;
148b93f2 4513 }
5477e8a0
L		 4514 }
4515
91d6fa6a 4516 if (sindex != -1)
5477e8a0 4517 {
8d5ff12c
L		 4518 if (p != buff + field_size + 4)
4519 {
4520 if (size < (10 + 2))
4521 abort ();
4522 size -= 2;
4523 *p++ = ',';
4524 *p++ = ' ';
4525 }
4526
91d6fa6a
NC		 4527 size -= flags [sindex].len;
4528 p = stpcpy (p, flags [sindex].str);
5477e8a0 4529 }
3b22753a 4530 else if (flag & SHF_MASKOS)
8d5ff12c 4531 os_flags |= flag;
d1133906 4532 else if (flag & SHF_MASKPROC)
8d5ff12c 4533 proc_flags |= flag;
d1133906 4534 else
8d5ff12c 4535 unknown_flags |= flag;
5477e8a0
L		 4536 }
4537 else
4538 {
4539 switch (flag)
4540 {
4541 case SHF_WRITE: *p = 'W'; break;
4542 case SHF_ALLOC: *p = 'A'; break;
4543 case SHF_EXECINSTR: *p = 'X'; break;
4544 case SHF_MERGE: *p = 'M'; break;
4545 case SHF_STRINGS: *p = 'S'; break;
4546 case SHF_INFO_LINK: *p = 'I'; break;
4547 case SHF_LINK_ORDER: *p = 'L'; break;
4548 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4549 case SHF_GROUP: *p = 'G'; break;
4550 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4551 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4552
4553 default:
8a9036a4 4554 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4555 || elf_header.e_machine == EM_L1OM
4556 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4557 && flag == SHF_X86_64_LARGE)
4558 *p = 'l';
4559 else if (flag & SHF_MASKOS)
4560 {
4561 *p = 'o';
4562 sh_flags &= ~ SHF_MASKOS;
4563 }
4564 else if (flag & SHF_MASKPROC)
4565 {
4566 *p = 'p';
4567 sh_flags &= ~ SHF_MASKPROC;
4568 }
4569 else
4570 *p = 'x';
4571 break;
4572 }
4573 p++;
d1133906
NC		 4574 }
4575 }
76da6bbe 4576
8d5ff12c
L		 4577 if (do_section_details)
4578 {
4579 if (os_flags)
4580 {
4581 size -= 5 + field_size;
4582 if (p != buff + field_size + 4)
4583 {
4584 if (size < (2 + 1))
4585 abort ();
4586 size -= 2;
4587 *p++ = ',';
4588 *p++ = ' ';
4589 }
4590 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4591 (unsigned long) os_flags);
4592 p += 5 + field_size;
4593 }
4594 if (proc_flags)
4595 {
4596 size -= 7 + field_size;
4597 if (p != buff + field_size + 4)
4598 {
4599 if (size < (2 + 1))
4600 abort ();
4601 size -= 2;
4602 *p++ = ',';
4603 *p++ = ' ';
4604 }
4605 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4606 (unsigned long) proc_flags);
4607 p += 7 + field_size;
4608 }
4609 if (unknown_flags)
4610 {
4611 size -= 10 + field_size;
4612 if (p != buff + field_size + 4)
4613 {
4614 if (size < (2 + 1))
4615 abort ();
4616 size -= 2;
4617 *p++ = ',';
4618 *p++ = ' ';
4619 }
2b692964 4620 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4621 (unsigned long) unknown_flags);
4622 p += 10 + field_size;
4623 }
4624 }
4625
e9e44622 4626 *p = '\0';
d1133906
NC		 4627 return buff;
4628}
4629
252b5132 4630static int
2cf0635d 4631process_section_headers (FILE * file)
252b5132 4632{
2cf0635d 4633 Elf_Internal_Shdr * section;
b34976b6 4634 unsigned int i;
252b5132
RH		 4635
4636 section_headers = NULL;
4637
4638 if (elf_header.e_shnum == 0)
4639 {
82f2dbf7
NC		 4640 /* PR binutils/12467. */
4641 if (elf_header.e_shoff != 0)
4642 warn (_("possibly corrupt ELF file header - it has a non-zero"
4643 " section header offset, but no section headers\n"));
4644 else if (do_sections)
252b5132
RH		 4645 printf (_("\nThere are no sections in this file.\n"));
4646
4647 return 1;
4648 }
4649
4650 if (do_sections && !do_header)
9ea033b2 4651 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4652 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4653
9ea033b2
NC		 4654 if (is_32bit_elf)
4655 {
560f3c1c 4656 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4657 return 0;
4658 }
560f3c1c 4659 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4660 return 0;
4661
4662 /* Read in the string table, so that we have names to display. */
0b49d371 4663 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4664 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4665 {
4fbb74a6 4666 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4667
c256ffe7
JJ		 4668 if (section->sh_size != 0)
4669 {
3f5e193b
NC		 4670 string_table = (char *) get_data (NULL, file, section->sh_offset,
4671 1, section->sh_size,
4672 _("string table"));
0de14b54 4673
c256ffe7
JJ		 4674 string_table_length = string_table != NULL ? section->sh_size : 0;
4675 }
252b5132
RH		 4676 }
4677
4678 /* Scan the sections for the dynamic symbol table
e3c8793a 4679 and dynamic string table and debug sections. */
252b5132
RH		 4680 dynamic_symbols = NULL;
4681 dynamic_strings = NULL;
4682 dynamic_syminfo = NULL;
f1ef08cb 4683 symtab_shndx_hdr = NULL;
103f02d3 4684
89fac5e3
RS		 4685 eh_addr_size = is_32bit_elf ? 4 : 8;
4686 switch (elf_header.e_machine)
4687 {
4688 case EM_MIPS:
4689 case EM_MIPS_RS3_LE:
4690 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4691 FDE addresses. However, the ABI also has a semi-official ILP32
4692 variant for which the normal FDE address size rules apply.
4693
4694 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4695 section, where XX is the size of longs in bits. Unfortunately,
4696 earlier compilers provided no way of distinguishing ILP32 objects
4697 from LP64 objects, so if there's any doubt, we should assume that
4698 the official LP64 form is being used. */
4699 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4700 && find_section (".gcc_compiled_long32") == NULL)
4701 eh_addr_size = 8;
4702 break;
0f56a26a
DD		 4703
4704 case EM_H8_300:
4705 case EM_H8_300H:
4706 switch (elf_header.e_flags & EF_H8_MACH)
4707 {
4708 case E_H8_MACH_H8300:
4709 case E_H8_MACH_H8300HN:
4710 case E_H8_MACH_H8300SN:
4711 case E_H8_MACH_H8300SXN:
4712 eh_addr_size = 2;
4713 break;
4714 case E_H8_MACH_H8300H:
4715 case E_H8_MACH_H8300S:
4716 case E_H8_MACH_H8300SX:
4717 eh_addr_size = 4;
4718 break;
4719 }
f4236fe4
DD		 4720 break;
4721
ff7eeb89 4722 case EM_M32C_OLD:
f4236fe4
DD		 4723 case EM_M32C:
4724 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4725 {
4726 case EF_M32C_CPU_M16C:
4727 eh_addr_size = 2;
4728 break;
4729 }
4730 break;
89fac5e3
RS		 4731 }
4732
08d8fa11
JJ		 4733#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4734 do \
4735 { \
4736 size_t expected_entsize \
4737 = is_32bit_elf ? size32 : size64; \
4738 if (section->sh_entsize != expected_entsize) \
4739 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4740 i, (unsigned long int) section->sh_entsize, \
4741 (unsigned long int) expected_entsize); \
4742 section->sh_entsize = expected_entsize; \
4743 } \
4744 while (0)
4745#define CHECK_ENTSIZE(section, i, type) \
4746 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4747 sizeof (Elf64_External_##type))
4748
252b5132
RH		 4749 for (i = 0, section = section_headers;
4750 i < elf_header.e_shnum;
b34976b6 4751 i++, section++)
252b5132 4752 {
2cf0635d 4753 char * name = SECTION_NAME (section);
252b5132
RH		 4754
4755 if (section->sh_type == SHT_DYNSYM)
4756 {
4757 if (dynamic_symbols != NULL)
4758 {
4759 error (_("File contains multiple dynamic symbol tables\n"));
4760 continue;
4761 }
4762
08d8fa11 4763 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4764 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 4765 }
4766 else if (section->sh_type == SHT_STRTAB
18bd398b 4767 && streq (name, ".dynstr"))
252b5132
RH		 4768 {
4769 if (dynamic_strings != NULL)
4770 {
4771 error (_("File contains multiple dynamic string tables\n"));
4772 continue;
4773 }
4774
3f5e193b
NC		 4775 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4776 1, section->sh_size,
4777 _("dynamic strings"));
59245841 4778 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4779 }
9ad5cbcf
AM		 4780 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4781 {
4782 if (symtab_shndx_hdr != NULL)
4783 {
4784 error (_("File contains multiple symtab shndx tables\n"));
4785 continue;
4786 }
4787 symtab_shndx_hdr = section;
4788 }
08d8fa11
JJ		 4789 else if (section->sh_type == SHT_SYMTAB)
4790 CHECK_ENTSIZE (section, i, Sym);
4791 else if (section->sh_type == SHT_GROUP)
4792 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4793 else if (section->sh_type == SHT_REL)
4794 CHECK_ENTSIZE (section, i, Rel);
4795 else if (section->sh_type == SHT_RELA)
4796 CHECK_ENTSIZE (section, i, Rela);
252b5132 4797 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4798 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4799 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 4800 || do_debug_str || do_debug_loc || do_debug_ranges
4801 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 4802 && (const_strneq (name, ".debug_")
4803 || const_strneq (name, ".zdebug_")))
252b5132 4804 {
1b315056
CS		 4805 if (name[1] == 'z')
4806 name += sizeof (".zdebug_") - 1;
4807 else
4808 name += sizeof (".debug_") - 1;
252b5132
RH		 4809
4810 if (do_debugging
4723351a
CC		 4811 || (do_debug_info && const_strneq (name, "info"))
4812 || (do_debug_info && const_strneq (name, "types"))
4813 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4814 || (do_debug_lines && const_strneq (name, "line"))
4815 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4816 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4817 || (do_debug_aranges && const_strneq (name, "aranges"))
4818 || (do_debug_ranges && const_strneq (name, "ranges"))
4819 || (do_debug_frames && const_strneq (name, "frame"))
4820 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4821 || (do_debug_macinfo && const_strneq (name, "macro"))
4822 || (do_debug_str && const_strneq (name, "str"))
4823 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 4824 || (do_debug_addr && const_strneq (name, "addr"))
4825 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4826 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 4827 )
09c11c86 4828 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4829 }
a262ae96 4830 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4831 else if ((do_debugging || do_debug_info)
0112cd26 4832 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4833 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4834 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4835 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4836 else if (do_gdb_index && streq (name, ".gdb_index"))
4837 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4838 /* Trace sections for Itanium VMS. */
4839 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4840 || do_trace_aranges)
4841 && const_strneq (name, ".trace_"))
4842 {
4843 name += sizeof (".trace_") - 1;
4844
4845 if (do_debugging
4846 || (do_trace_info && streq (name, "info"))
4847 || (do_trace_abbrevs && streq (name, "abbrev"))
4848 || (do_trace_aranges && streq (name, "aranges"))
4849 )
4850 request_dump_bynumber (i, DEBUG_DUMP);
4851 }
4852
252b5132
RH		 4853 }
4854
4855 if (! do_sections)
4856 return 1;
4857
3a1a2036
NC		 4858 if (elf_header.e_shnum > 1)
4859 printf (_("\nSection Headers:\n"));
4860 else
4861 printf (_("\nSection Header:\n"));
76da6bbe 4862
f7a99963 4863 if (is_32bit_elf)
595cf52e 4864 {
5477e8a0 4865 if (do_section_details)
595cf52e
L		 4866 {
4867 printf (_(" [Nr] Name\n"));
5477e8a0 4868 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4869 }
4870 else
4871 printf
4872 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4873 }
d974e256 4874 else if (do_wide)
595cf52e 4875 {
5477e8a0 4876 if (do_section_details)
595cf52e
L		 4877 {
4878 printf (_(" [Nr] Name\n"));
5477e8a0 4879 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4880 }
4881 else
4882 printf
4883 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4884 }
f7a99963
NC		 4885 else
4886 {
5477e8a0 4887 if (do_section_details)
595cf52e
L		 4888 {
4889 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4890 printf (_(" Type Address Offset Link\n"));
4891 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4892 }
4893 else
4894 {
4895 printf (_(" [Nr] Name Type Address Offset\n"));
4896 printf (_(" Size EntSize Flags Link Info Align\n"));
4897 }
f7a99963 4898 }
252b5132 4899
5477e8a0
L		 4900 if (do_section_details)
4901 printf (_(" Flags\n"));
4902
252b5132
RH		 4903 for (i = 0, section = section_headers;
4904 i < elf_header.e_shnum;
b34976b6 4905 i++, section++)
252b5132 4906 {
7bfd842d 4907 printf (" [%2u] ", i);
5477e8a0 4908 if (do_section_details)
595cf52e 4909 {
7bfd842d 4910 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 4911 printf ("\n ");
595cf52e
L		 4912 }
4913 else
7bfd842d
NC		 4914 {
4915 print_symbol (-17, SECTION_NAME (section));
7bfd842d 4916 }
ea52a088
NC		 4917
4918 printf (do_wide ? " %-15s " : " %-15.15s ",
4919 get_section_type_name (section->sh_type));
4920
f7a99963
NC		 4921 if (is_32bit_elf)
4922 {
cfcac11d
NC		 4923 const char * link_too_big = NULL;
4924
f7a99963 4925 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4926
f7a99963
NC		 4927 printf ( " %6.6lx %6.6lx %2.2lx",
4928 (unsigned long) section->sh_offset,
4929 (unsigned long) section->sh_size,
4930 (unsigned long) section->sh_entsize);
d1133906 4931
5477e8a0
L		 4932 if (do_section_details)
4933 fputs (" ", stdout);
4934 else
4935 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4936
cfcac11d
NC		 4937 if (section->sh_link >= elf_header.e_shnum)
4938 {
4939 link_too_big = "";
4940 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4941 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4942 switch (elf_header.e_machine)
4943 {
caa83f8b
NC		 4944 case EM_386:
4945 case EM_486:
4946 case EM_X86_64:
7f502d6c 4947 case EM_L1OM:
7a9068fe 4948 case EM_K1OM:
cfcac11d
NC		 4949 case EM_OLD_SPARCV9:
4950 case EM_SPARC32PLUS:
4951 case EM_SPARCV9:
4952 case EM_SPARC:
4953 if (section->sh_link == (SHN_BEFORE & 0xffff))
4954 link_too_big = "BEFORE";
4955 else if (section->sh_link == (SHN_AFTER & 0xffff))
4956 link_too_big = "AFTER";
4957 break;
4958 default:
4959 break;
4960 }
4961 }
4962
4963 if (do_section_details)
4964 {
4965 if (link_too_big != NULL && * link_too_big)
4966 printf ("<%s> ", link_too_big);
4967 else
4968 printf ("%2u ", section->sh_link);
4969 printf ("%3u %2lu\n", section->sh_info,
4970 (unsigned long) section->sh_addralign);
4971 }
4972 else
4973 printf ("%2u %3u %2lu\n",
4974 section->sh_link,
4975 section->sh_info,
4976 (unsigned long) section->sh_addralign);
4977
4978 if (link_too_big && ! * link_too_big)
4979 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4980 i, section->sh_link);
f7a99963 4981 }
d974e256
JJ		 4982 else if (do_wide)
4983 {
4984 print_vma (section->sh_addr, LONG_HEX);
4985
4986 if ((long) section->sh_offset == section->sh_offset)
4987 printf (" %6.6lx", (unsigned long) section->sh_offset);
4988 else
4989 {
4990 putchar (' ');
4991 print_vma (section->sh_offset, LONG_HEX);
4992 }
4993
4994 if ((unsigned long) section->sh_size == section->sh_size)
4995 printf (" %6.6lx", (unsigned long) section->sh_size);
4996 else
4997 {
4998 putchar (' ');
4999 print_vma (section->sh_size, LONG_HEX);
5000 }
5001
5002 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5003 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5004 else
5005 {
5006 putchar (' ');
5007 print_vma (section->sh_entsize, LONG_HEX);
5008 }
5009
5477e8a0
L		 5010 if (do_section_details)
5011 fputs (" ", stdout);
5012 else
5013 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5014
72de5009 5015 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5016
5017 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5018 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5019 else
5020 {
5021 print_vma (section->sh_addralign, DEC);
5022 putchar ('\n');
5023 }
5024 }
5477e8a0 5025 else if (do_section_details)
595cf52e 5026 {
5477e8a0 5027 printf (" %-15.15s ",
595cf52e 5028 get_section_type_name (section->sh_type));
595cf52e
L		 5029 print_vma (section->sh_addr, LONG_HEX);
5030 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5031 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5032 else
5033 {
5034 printf (" ");
5035 print_vma (section->sh_offset, LONG_HEX);
5036 }
72de5009 5037 printf (" %u\n ", section->sh_link);
595cf52e 5038 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5039 putchar (' ');
595cf52e
L		 5040 print_vma (section->sh_entsize, LONG_HEX);
5041
72de5009
AM		 5042 printf (" %-16u %lu\n",
5043 section->sh_info,
595cf52e
L		 5044 (unsigned long) section->sh_addralign);
5045 }
f7a99963
NC		 5046 else
5047 {
5048 putchar (' ');
5049 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5050 if ((long) section->sh_offset == section->sh_offset)
5051 printf (" %8.8lx", (unsigned long) section->sh_offset);
5052 else
5053 {
5054 printf (" ");
5055 print_vma (section->sh_offset, LONG_HEX);
5056 }
f7a99963
NC		 5057 printf ("\n ");
5058 print_vma (section->sh_size, LONG_HEX);
5059 printf (" ");
5060 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5061
d1133906 5062 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5063
72de5009
AM		 5064 printf (" %2u %3u %lu\n",
5065 section->sh_link,
5066 section->sh_info,
f7a99963
NC		 5067 (unsigned long) section->sh_addralign);
5068 }
5477e8a0
L		 5069
5070 if (do_section_details)
5071 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5072 }
5073
5477e8a0 5074 if (!do_section_details)
3dbcc61d
NC		 5075 {
5076 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5077 || elf_header.e_machine == EM_L1OM
5078 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5079 printf (_("Key to Flags:\n\
5080 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5081 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5082 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5083 else
5084 printf (_("Key to Flags:\n\
e3c8793a 5085 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5086 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5087 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 5088 }
d1133906 5089
252b5132
RH		 5090 return 1;
5091}
5092
f5842774
L		 5093static const char *
5094get_group_flags (unsigned int flags)
5095{
5096 static char buff[32];
5097 switch (flags)
5098 {
220453ec
AM		 5099 case 0:
5100 return "";
5101
f5842774 5102 case GRP_COMDAT:
220453ec 5103 return "COMDAT ";
f5842774
L		 5104
5105 default:
220453ec 5106 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5107 break;
5108 }
5109 return buff;
5110}
5111
5112static int
2cf0635d 5113process_section_groups (FILE * file)
f5842774 5114{
2cf0635d 5115 Elf_Internal_Shdr * section;
f5842774 5116 unsigned int i;
2cf0635d
NC		 5117 struct group * group;
5118 Elf_Internal_Shdr * symtab_sec;
5119 Elf_Internal_Shdr * strtab_sec;
5120 Elf_Internal_Sym * symtab;
ba5cdace 5121 unsigned long num_syms;
2cf0635d 5122 char * strtab;
c256ffe7 5123 size_t strtab_size;
d1f5c6e3
L		 5124
5125 /* Don't process section groups unless needed. */
5126 if (!do_unwind && !do_section_groups)
5127 return 1;
f5842774
L		 5128
5129 if (elf_header.e_shnum == 0)
5130 {
5131 if (do_section_groups)
82f2dbf7 5132 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5133
5134 return 1;
5135 }
5136
5137 if (section_headers == NULL)
5138 {
5139 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5140 /* PR 13622: This can happen with a corrupt ELF header. */
5141 return 0;
f5842774
L		 5142 }
5143
3f5e193b
NC		 5144 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5145 sizeof (struct group *));
e4b17d5c
L		 5146
5147 if (section_headers_groups == NULL)
5148 {
5149 error (_("Out of memory\n"));
5150 return 0;
5151 }
5152
f5842774 5153 /* Scan the sections for the group section. */
d1f5c6e3 5154 group_count = 0;
f5842774
L		 5155 for (i = 0, section = section_headers;
5156 i < elf_header.e_shnum;
5157 i++, section++)
e4b17d5c
L		 5158 if (section->sh_type == SHT_GROUP)
5159 group_count++;
5160
d1f5c6e3
L		 5161 if (group_count == 0)
5162 {
5163 if (do_section_groups)
5164 printf (_("\nThere are no section groups in this file.\n"));
5165
5166 return 1;
5167 }
5168
3f5e193b 5169 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5170
5171 if (section_groups == NULL)
5172 {
5173 error (_("Out of memory\n"));
5174 return 0;
5175 }
5176
d1f5c6e3
L		 5177 symtab_sec = NULL;
5178 strtab_sec = NULL;
5179 symtab = NULL;
ba5cdace 5180 num_syms = 0;
d1f5c6e3 5181 strtab = NULL;
c256ffe7 5182 strtab_size = 0;
e4b17d5c
L		 5183 for (i = 0, section = section_headers, group = section_groups;
5184 i < elf_header.e_shnum;
5185 i++, section++)
f5842774
L		 5186 {
5187 if (section->sh_type == SHT_GROUP)
5188 {
2cf0635d
NC		 5189 char * name = SECTION_NAME (section);
5190 char * group_name;
5191 unsigned char * start;
5192 unsigned char * indices;
f5842774 5193 unsigned int entry, j, size;
2cf0635d
NC		 5194 Elf_Internal_Shdr * sec;
5195 Elf_Internal_Sym * sym;
f5842774
L		 5196
5197 /* Get the symbol table. */
4fbb74a6
AM		 5198 if (section->sh_link >= elf_header.e_shnum
5199 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5200 != SHT_SYMTAB))
f5842774
L		 5201 {
5202 error (_("Bad sh_link in group section `%s'\n"), name);
5203 continue;
5204 }
d1f5c6e3
L		 5205
5206 if (symtab_sec != sec)
5207 {
5208 symtab_sec = sec;
5209 if (symtab)
5210 free (symtab);
ba5cdace 5211 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5212 }
f5842774 5213
dd24e3da
NC		 5214 if (symtab == NULL)
5215 {
5216 error (_("Corrupt header in group section `%s'\n"), name);
5217 continue;
5218 }
5219
ba5cdace
NC		 5220 if (section->sh_info >= num_syms)
5221 {
5222 error (_("Bad sh_info in group section `%s'\n"), name);
5223 continue;
5224 }
5225
f5842774
L		 5226 sym = symtab + section->sh_info;
5227
5228 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5229 {
4fbb74a6
AM		 5230 if (sym->st_shndx == 0
5231 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5232 {
5233 error (_("Bad sh_info in group section `%s'\n"), name);
5234 continue;
5235 }
ba2685cc 5236
4fbb74a6 5237 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5238 strtab_sec = NULL;
5239 if (strtab)
5240 free (strtab);
f5842774 5241 strtab = NULL;
c256ffe7 5242 strtab_size = 0;
f5842774
L		 5243 }
5244 else
5245 {
5246 /* Get the string table. */
4fbb74a6 5247 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5248 {
5249 strtab_sec = NULL;
5250 if (strtab)
5251 free (strtab);
5252 strtab = NULL;
5253 strtab_size = 0;
5254 }
5255 else if (strtab_sec
4fbb74a6 5256 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5257 {
5258 strtab_sec = sec;
5259 if (strtab)
5260 free (strtab);
3f5e193b
NC		 5261 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5262 1, strtab_sec->sh_size,
5263 _("string table"));
c256ffe7 5264 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5265 }
c256ffe7 5266 group_name = sym->st_name < strtab_size
2b692964 5267 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5268 }
5269
3f5e193b
NC		 5270 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5271 1, section->sh_size,
5272 _("section data"));
59245841
NC		 5273 if (start == NULL)
5274 continue;
f5842774
L		 5275
5276 indices = start;
5277 size = (section->sh_size / section->sh_entsize) - 1;
5278 entry = byte_get (indices, 4);
5279 indices += 4;
e4b17d5c
L		 5280
5281 if (do_section_groups)
5282 {
2b692964 5283 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5284 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5285
e4b17d5c
L		 5286 printf (_(" [Index] Name\n"));
5287 }
5288
5289 group->group_index = i;
5290
f5842774
L		 5291 for (j = 0; j < size; j++)
5292 {
2cf0635d 5293 struct group_list * g;
e4b17d5c 5294
f5842774
L		 5295 entry = byte_get (indices, 4);
5296 indices += 4;
5297
4fbb74a6 5298 if (entry >= elf_header.e_shnum)
391cb864
L		 5299 {
5300 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5301 entry, i, elf_header.e_shnum - 1);
5302 continue;
5303 }
391cb864 5304
4fbb74a6 5305 if (section_headers_groups [entry] != NULL)
e4b17d5c 5306 {
d1f5c6e3
L		 5307 if (entry)
5308 {
391cb864
L		 5309 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5310 entry, i,
4fbb74a6 5311 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5312 continue;
5313 }
5314 else
5315 {
5316 /* Intel C/C++ compiler may put section 0 in a
5317 section group. We just warn it the first time
5318 and ignore it afterwards. */
5319 static int warned = 0;
5320 if (!warned)
5321 {
5322 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5323 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5324 warned++;
5325 }
5326 }
e4b17d5c
L		 5327 }
5328
4fbb74a6 5329 section_headers_groups [entry] = group;
e4b17d5c
L		 5330
5331 if (do_section_groups)
5332 {
4fbb74a6 5333 sec = section_headers + entry;
c256ffe7 5334 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5335 }
5336
3f5e193b 5337 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5338 g->section_index = entry;
5339 g->next = group->root;
5340 group->root = g;
f5842774
L		 5341 }
5342
f5842774
L		 5343 if (start)
5344 free (start);
e4b17d5c
L		 5345
5346 group++;
f5842774
L		 5347 }
5348 }
5349
d1f5c6e3
L		 5350 if (symtab)
5351 free (symtab);
5352 if (strtab)
5353 free (strtab);
f5842774
L		 5354 return 1;
5355}
5356
28f997cf
TG		 5357/* Data used to display dynamic fixups. */
5358
5359struct ia64_vms_dynfixup
5360{
5361 bfd_vma needed_ident; /* Library ident number. */
5362 bfd_vma needed; /* Index in the dstrtab of the library name. */
5363 bfd_vma fixup_needed; /* Index of the library. */
5364 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5365 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5366};
5367
5368/* Data used to display dynamic relocations. */
5369
5370struct ia64_vms_dynimgrela
5371{
5372 bfd_vma img_rela_cnt; /* Number of relocations. */
5373 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5374};
5375
5376/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5377 library). */
5378
5379static void
5380dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5381 const char *strtab, unsigned int strtab_sz)
5382{
5383 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5384 long i;
5385 const char *lib_name;
5386
5387 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5388 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5389 _("dynamic section image fixups"));
5390 if (!imfs)
5391 return;
5392
5393 if (fixup->needed < strtab_sz)
5394 lib_name = strtab + fixup->needed;
5395 else
5396 {
5397 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5398 (unsigned long) fixup->needed);
28f997cf
TG		 5399 lib_name = "???";
5400 }
5401 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5402 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5403 printf
5404 (_("Seg Offset Type SymVec DataType\n"));
5405
5406 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5407 {
5408 unsigned int type;
5409 const char *rtype;
5410
5411 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5412 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5413 type = BYTE_GET (imfs [i].type);
5414 rtype = elf_ia64_reloc_type (type);
5415 if (rtype == NULL)
5416 printf (" 0x%08x ", type);
5417 else
5418 printf (" %-32s ", rtype);
5419 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5420 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5421 }
5422
5423 free (imfs);
5424}
5425
5426/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5427
5428static void
5429dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5430{
5431 Elf64_External_VMS_IMAGE_RELA *imrs;
5432 long i;
5433
5434 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5435 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5436 _("dynamic section image relocations"));
28f997cf
TG		 5437 if (!imrs)
5438 return;
5439
5440 printf (_("\nImage relocs\n"));
5441 printf
5442 (_("Seg Offset Type Addend Seg Sym Off\n"));
5443
5444 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5445 {
5446 unsigned int type;
5447 const char *rtype;
5448
5449 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5450 printf ("%08" BFD_VMA_FMT "x ",
5451 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5452 type = BYTE_GET (imrs [i].type);
5453 rtype = elf_ia64_reloc_type (type);
5454 if (rtype == NULL)
5455 printf ("0x%08x ", type);
5456 else
5457 printf ("%-31s ", rtype);
5458 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5459 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5460 printf ("%08" BFD_VMA_FMT "x\n",
5461 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5462 }
5463
5464 free (imrs);
5465}
5466
5467/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5468
5469static int
5470process_ia64_vms_dynamic_relocs (FILE *file)
5471{
5472 struct ia64_vms_dynfixup fixup;
5473 struct ia64_vms_dynimgrela imgrela;
5474 Elf_Internal_Dyn *entry;
5475 int res = 0;
5476 bfd_vma strtab_off = 0;
5477 bfd_vma strtab_sz = 0;
5478 char *strtab = NULL;
5479
5480 memset (&fixup, 0, sizeof (fixup));
5481 memset (&imgrela, 0, sizeof (imgrela));
5482
5483 /* Note: the order of the entries is specified by the OpenVMS specs. */
5484 for (entry = dynamic_section;
5485 entry < dynamic_section + dynamic_nent;
5486 entry++)
5487 {
5488 switch (entry->d_tag)
5489 {
5490 case DT_IA_64_VMS_STRTAB_OFFSET:
5491 strtab_off = entry->d_un.d_val;
5492 break;
5493 case DT_STRSZ:
5494 strtab_sz = entry->d_un.d_val;
5495 if (strtab == NULL)
5496 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5497 1, strtab_sz, _("dynamic string section"));
5498 break;
5499
5500 case DT_IA_64_VMS_NEEDED_IDENT:
5501 fixup.needed_ident = entry->d_un.d_val;
5502 break;
5503 case DT_NEEDED:
5504 fixup.needed = entry->d_un.d_val;
5505 break;
5506 case DT_IA_64_VMS_FIXUP_NEEDED:
5507 fixup.fixup_needed = entry->d_un.d_val;
5508 break;
5509 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5510 fixup.fixup_rela_cnt = entry->d_un.d_val;
5511 break;
5512 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5513 fixup.fixup_rela_off = entry->d_un.d_val;
5514 res++;
5515 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5516 break;
5517
5518 case DT_IA_64_VMS_IMG_RELA_CNT:
5519 imgrela.img_rela_cnt = entry->d_un.d_val;
5520 break;
5521 case DT_IA_64_VMS_IMG_RELA_OFF:
5522 imgrela.img_rela_off = entry->d_un.d_val;
5523 res++;
5524 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5525 break;
5526
5527 default:
5528 break;
5529 }
5530 }
5531
5532 if (strtab != NULL)
5533 free (strtab);
5534
5535 return res;
5536}
5537
85b1c36d 5538static struct
566b0d53 5539{
2cf0635d 5540 const char * name;
566b0d53
L		 5541 int reloc;
5542 int size;
5543 int rela;
5544} dynamic_relocations [] =
5545{
5546 { "REL", DT_REL, DT_RELSZ, FALSE },
5547 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5548 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5549};
5550
252b5132 5551/* Process the reloc section. */
18bd398b 5552
252b5132 5553static int
2cf0635d 5554process_relocs (FILE * file)
252b5132 5555{
b34976b6
AM		 5556 unsigned long rel_size;
5557 unsigned long rel_offset;
252b5132
RH		 5558
5559
5560 if (!do_reloc)
5561 return 1;
5562
5563 if (do_using_dynamic)
5564 {
566b0d53 5565 int is_rela;
2cf0635d 5566 const char * name;
566b0d53
L		 5567 int has_dynamic_reloc;
5568 unsigned int i;
0de14b54 5569
566b0d53 5570 has_dynamic_reloc = 0;
252b5132 5571
566b0d53 5572 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5573 {
566b0d53
L		 5574 is_rela = dynamic_relocations [i].rela;
5575 name = dynamic_relocations [i].name;
5576 rel_size = dynamic_info [dynamic_relocations [i].size];
5577 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5578
566b0d53
L		 5579 has_dynamic_reloc |= rel_size;
5580
5581 if (is_rela == UNKNOWN)
aa903cfb 5582 {
566b0d53
L		 5583 if (dynamic_relocations [i].reloc == DT_JMPREL)
5584 switch (dynamic_info[DT_PLTREL])
5585 {
5586 case DT_REL:
5587 is_rela = FALSE;
5588 break;
5589 case DT_RELA:
5590 is_rela = TRUE;
5591 break;
5592 }
aa903cfb 5593 }
252b5132 5594
566b0d53
L		 5595 if (rel_size)
5596 {
5597 printf
5598 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5599 name, rel_offset, rel_size);
252b5132 5600
d93f0186
NC		 5601 dump_relocations (file,
5602 offset_from_vma (file, rel_offset, rel_size),
5603 rel_size,
566b0d53 5604 dynamic_symbols, num_dynamic_syms,
d79b3d50 5605 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5606 }
252b5132 5607 }
566b0d53 5608
28f997cf
TG		 5609 if (is_ia64_vms ())
5610 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5611
566b0d53 5612 if (! has_dynamic_reloc)
252b5132
RH		 5613 printf (_("\nThere are no dynamic relocations in this file.\n"));
5614 }
5615 else
5616 {
2cf0635d 5617 Elf_Internal_Shdr * section;
b34976b6
AM		 5618 unsigned long i;
5619 int found = 0;
252b5132
RH		 5620
5621 for (i = 0, section = section_headers;
5622 i < elf_header.e_shnum;
b34976b6 5623 i++, section++)
252b5132
RH		 5624 {
5625 if ( section->sh_type != SHT_RELA
5626 && section->sh_type != SHT_REL)
5627 continue;
5628
5629 rel_offset = section->sh_offset;
5630 rel_size = section->sh_size;
5631
5632 if (rel_size)
5633 {
2cf0635d 5634 Elf_Internal_Shdr * strsec;
b34976b6 5635 int is_rela;
103f02d3 5636
252b5132
RH		 5637 printf (_("\nRelocation section "));
5638
5639 if (string_table == NULL)
19936277 5640 printf ("%d", section->sh_name);
252b5132 5641 else
9cf03b7e 5642 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5643
5644 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5645 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5646
d79b3d50
NC		 5647 is_rela = section->sh_type == SHT_RELA;
5648
4fbb74a6
AM		 5649 if (section->sh_link != 0
5650 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5651 {
2cf0635d
NC		 5652 Elf_Internal_Shdr * symsec;
5653 Elf_Internal_Sym * symtab;
d79b3d50 5654 unsigned long nsyms;
c256ffe7 5655 unsigned long strtablen = 0;
2cf0635d 5656 char * strtab = NULL;
57346661 5657
4fbb74a6 5658 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5659 if (symsec->sh_type != SHT_SYMTAB
5660 && symsec->sh_type != SHT_DYNSYM)
5661 continue;
5662
ba5cdace 5663 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5664
af3fc3bc
AM		 5665 if (symtab == NULL)
5666 continue;
252b5132 5667
4fbb74a6
AM		 5668 if (symsec->sh_link != 0
5669 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5670 {
4fbb74a6 5671 strsec = section_headers + symsec->sh_link;
103f02d3 5672
3f5e193b
NC		 5673 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5674 1, strsec->sh_size,
5675 _("string table"));
c256ffe7
JJ		 5676 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5677 }
252b5132 5678
d79b3d50
NC		 5679 dump_relocations (file, rel_offset, rel_size,
5680 symtab, nsyms, strtab, strtablen, is_rela);
5681 if (strtab)
5682 free (strtab);
5683 free (symtab);
5684 }
5685 else
5686 dump_relocations (file, rel_offset, rel_size,
5687 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5688
5689 found = 1;
5690 }
5691 }
5692
5693 if (! found)
5694 printf (_("\nThere are no relocations in this file.\n"));
5695 }
5696
5697 return 1;
5698}
5699
57346661
AM		 5700/* Process the unwind section. */
5701
4d6ed7c8
NC		 5702#include "unwind-ia64.h"
5703
5704/* An absolute address consists of a section and an offset. If the
5705 section is NULL, the offset itself is the address, otherwise, the
5706 address equals to LOAD_ADDRESS(section) + offset. */
5707
5708struct absaddr
5709 {
5710 unsigned short section;
5711 bfd_vma offset;
5712 };
5713
1949de15
L		 5714#define ABSADDR(a) \
5715 ((a).section \
5716 ? section_headers [(a).section].sh_addr + (a).offset \
5717 : (a).offset)
5718
3f5e193b
NC		 5719struct ia64_unw_table_entry
5720 {
5721 struct absaddr start;
5722 struct absaddr end;
5723 struct absaddr info;
5724 };
5725
57346661 5726struct ia64_unw_aux_info
4d6ed7c8 5727 {
3f5e193b
NC		 5728
5729 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5730 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5731 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5732 unsigned long info_size; /* Size of unwind info. */
5733 bfd_vma info_addr; /* starting address of unwind info. */
5734 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5735 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5736 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5737 char * strtab; /* The string table. */
b34976b6 5738 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5739 };
5740
4d6ed7c8 5741static void
2cf0635d 5742find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5743 unsigned long nsyms,
2cf0635d 5744 const char * strtab,
57346661 5745 unsigned long strtab_size,
d3ba0551 5746 struct absaddr addr,
2cf0635d
NC		 5747 const char ** symname,
5748 bfd_vma * offset)
4d6ed7c8 5749{
d3ba0551 5750 bfd_vma dist = 0x100000;
2cf0635d
NC		 5751 Elf_Internal_Sym * sym;
5752 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5753 unsigned long i;
5754
0b6ae522
DJ		 5755 REMOVE_ARCH_BITS (addr.offset);
5756
57346661 5757 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5758 {
0b6ae522
DJ		 5759 bfd_vma value = sym->st_value;
5760
5761 REMOVE_ARCH_BITS (value);
5762
4d6ed7c8
NC		 5763 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5764 && sym->st_name != 0
5765 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5766 && addr.offset >= value
5767 && addr.offset - value < dist)
4d6ed7c8
NC		 5768 {
5769 best = sym;
0b6ae522 5770 dist = addr.offset - value;
4d6ed7c8
NC		 5771 if (!dist)
5772 break;
5773 }
5774 }
1b31d05e 5775
4d6ed7c8
NC		 5776 if (best)
5777 {
57346661 5778 *symname = (best->st_name >= strtab_size
2b692964 5779 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5780 *offset = dist;
5781 return;
5782 }
1b31d05e 5783
4d6ed7c8
NC		 5784 *symname = NULL;
5785 *offset = addr.offset;
5786}
5787
5788static void
2cf0635d 5789dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5790{
2cf0635d 5791 struct ia64_unw_table_entry * tp;
4d6ed7c8 5792 int in_body;
7036c0e1 5793
4d6ed7c8
NC		 5794 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5795 {
5796 bfd_vma stamp;
5797 bfd_vma offset;
2cf0635d
NC		 5798 const unsigned char * dp;
5799 const unsigned char * head;
5800 const char * procname;
4d6ed7c8 5801
57346661
AM		 5802 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5803 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5804
5805 fputs ("\n<", stdout);
5806
5807 if (procname)
5808 {
5809 fputs (procname, stdout);
5810
5811 if (offset)
5812 printf ("+%lx", (unsigned long) offset);
5813 }
5814
5815 fputs (">: [", stdout);
5816 print_vma (tp->start.offset, PREFIX_HEX);
5817 fputc ('-', stdout);
5818 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5819 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5820 (unsigned long) (tp->info.offset - aux->seg_base));
5821
1949de15 5822 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5823 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5824
86f55779 5825 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5826 (unsigned) UNW_VER (stamp),
5827 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5828 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5829 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5830 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5831
5832 if (UNW_VER (stamp) != 1)
5833 {
2b692964 5834 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5835 continue;
5836 }
5837
5838 in_body = 0;
89fac5e3 5839 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5840 dp = unw_decode (dp, in_body, & in_body);
5841 }
5842}
5843
5844static int
2cf0635d
NC		 5845slurp_ia64_unwind_table (FILE * file,
5846 struct ia64_unw_aux_info * aux,
5847 Elf_Internal_Shdr * sec)
4d6ed7c8 5848{
89fac5e3 5849 unsigned long size, nrelas, i;
2cf0635d
NC		 5850 Elf_Internal_Phdr * seg;
5851 struct ia64_unw_table_entry * tep;
5852 Elf_Internal_Shdr * relsec;
5853 Elf_Internal_Rela * rela;
5854 Elf_Internal_Rela * rp;
5855 unsigned char * table;
5856 unsigned char * tp;
5857 Elf_Internal_Sym * sym;
5858 const char * relname;
4d6ed7c8 5859
4d6ed7c8
NC		 5860 /* First, find the starting address of the segment that includes
5861 this section: */
5862
5863 if (elf_header.e_phnum)
5864 {
d93f0186 5865 if (! get_program_headers (file))
4d6ed7c8 5866 return 0;
4d6ed7c8 5867
d93f0186
NC		 5868 for (seg = program_headers;
5869 seg < program_headers + elf_header.e_phnum;
5870 ++seg)
4d6ed7c8
NC		 5871 {
5872 if (seg->p_type != PT_LOAD)
5873 continue;
5874
5875 if (sec->sh_addr >= seg->p_vaddr
5876 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5877 {
5878 aux->seg_base = seg->p_vaddr;
5879 break;
5880 }
5881 }
4d6ed7c8
NC		 5882 }
5883
5884 /* Second, build the unwind table from the contents of the unwind section: */
5885 size = sec->sh_size;
3f5e193b
NC		 5886 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5887 _("unwind table"));
a6e9f9df
AM		 5888 if (!table)
5889 return 0;
4d6ed7c8 5890
3f5e193b
NC		 5891 aux->table = (struct ia64_unw_table_entry *)
5892 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5893 tep = aux->table;
c6a0c689 5894 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5895 {
5896 tep->start.section = SHN_UNDEF;
5897 tep->end.section = SHN_UNDEF;
5898 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5899 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5900 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5901 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5902 tep->start.offset += aux->seg_base;
5903 tep->end.offset += aux->seg_base;
5904 tep->info.offset += aux->seg_base;
5905 }
5906 free (table);
5907
41e92641 5908 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5909 for (relsec = section_headers;
5910 relsec < section_headers + elf_header.e_shnum;
5911 ++relsec)
5912 {
5913 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5914 || relsec->sh_info >= elf_header.e_shnum
5915 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5916 continue;
5917
5918 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5919 & rela, & nrelas))
5920 return 0;
5921
5922 for (rp = rela; rp < rela + nrelas; ++rp)
5923 {
aca88567
NC		 5924 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5925 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5926
0112cd26 5927 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5928 {
e5fb9629 5929 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5930 continue;
5931 }
5932
89fac5e3 5933 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5934
89fac5e3 5935 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5936 {
5937 case 0:
5938 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5939 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5940 break;
5941 case 1:
5942 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5943 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5944 break;
5945 case 2:
5946 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5947 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5948 break;
5949 default:
5950 break;
5951 }
5952 }
5953
5954 free (rela);
5955 }
5956
89fac5e3 5957 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5958 return 1;
5959}
5960
1b31d05e 5961static void
2cf0635d 5962ia64_process_unwind (FILE * file)
4d6ed7c8 5963{
2cf0635d
NC		 5964 Elf_Internal_Shdr * sec;
5965 Elf_Internal_Shdr * unwsec = NULL;
5966 Elf_Internal_Shdr * strsec;
89fac5e3 5967 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5968 struct ia64_unw_aux_info aux;
f1467e33 5969
4d6ed7c8
NC		 5970 memset (& aux, 0, sizeof (aux));
5971
4d6ed7c8
NC		 5972 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5973 {
c256ffe7 5974 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5975 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 5976 {
ba5cdace 5977 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 5978
4fbb74a6 5979 strsec = section_headers + sec->sh_link;
59245841 5980 assert (aux.strtab == NULL);
3f5e193b
NC		 5981 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5982 1, strsec->sh_size,
5983 _("string table"));
c256ffe7 5984 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5985 }
5986 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5987 unwcount++;
5988 }
5989
5990 if (!unwcount)
5991 printf (_("\nThere are no unwind sections in this file.\n"));
5992
5993 while (unwcount-- > 0)
5994 {
2cf0635d 5995 char * suffix;
579f31ac
JJ		 5996 size_t len, len2;
5997
5998 for (i = unwstart, sec = section_headers + unwstart;
5999 i < elf_header.e_shnum; ++i, ++sec)
6000 if (sec->sh_type == SHT_IA_64_UNWIND)
6001 {
6002 unwsec = sec;
6003 break;
6004 }
6005
6006 unwstart = i + 1;
6007 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6008
e4b17d5c
L		 6009 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6010 {
6011 /* We need to find which section group it is in. */
2cf0635d 6012 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 6013
6014 for (; g != NULL; g = g->next)
6015 {
4fbb74a6 6016 sec = section_headers + g->section_index;
18bd398b
NC		 6017
6018 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6019 break;
e4b17d5c
L		 6020 }
6021
6022 if (g == NULL)
6023 i = elf_header.e_shnum;
6024 }
18bd398b 6025 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6026 {
18bd398b 6027 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6028 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6029 suffix = SECTION_NAME (unwsec) + len;
6030 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6031 ++i, ++sec)
18bd398b
NC		 6032 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6033 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6034 break;
6035 }
6036 else
6037 {
6038 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6039 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6040 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6041 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6042 suffix = "";
18bd398b 6043 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6044 suffix = SECTION_NAME (unwsec) + len;
6045 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6046 ++i, ++sec)
18bd398b
NC		 6047 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6048 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6049 break;
6050 }
6051
6052 if (i == elf_header.e_shnum)
6053 {
6054 printf (_("\nCould not find unwind info section for "));
6055
6056 if (string_table == NULL)
6057 printf ("%d", unwsec->sh_name);
6058 else
3a1a2036 6059 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 6060 }
6061 else
4d6ed7c8 6062 {
4d6ed7c8 6063 aux.info_addr = sec->sh_addr;
3f5e193b 6064 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6065 sec->sh_size,
3f5e193b 6066 _("unwind info"));
59245841 6067 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6068
579f31ac 6069 printf (_("\nUnwind section "));
4d6ed7c8 6070
579f31ac
JJ		 6071 if (string_table == NULL)
6072 printf ("%d", unwsec->sh_name);
6073 else
3a1a2036 6074 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6075
579f31ac 6076 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6077 (unsigned long) unwsec->sh_offset,
89fac5e3 6078 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6079
579f31ac 6080 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6081
579f31ac
JJ		 6082 if (aux.table_len > 0)
6083 dump_ia64_unwind (& aux);
6084
6085 if (aux.table)
6086 free ((char *) aux.table);
6087 if (aux.info)
6088 free ((char *) aux.info);
6089 aux.table = NULL;
6090 aux.info = NULL;
6091 }
4d6ed7c8 6092 }
4d6ed7c8 6093
4d6ed7c8
NC		 6094 if (aux.symtab)
6095 free (aux.symtab);
6096 if (aux.strtab)
6097 free ((char *) aux.strtab);
4d6ed7c8
NC		 6098}
6099
3f5e193b
NC		 6100struct hppa_unw_table_entry
6101 {
6102 struct absaddr start;
6103 struct absaddr end;
6104 unsigned int Cannot_unwind:1; /* 0 */
6105 unsigned int Millicode:1; /* 1 */
6106 unsigned int Millicode_save_sr0:1; /* 2 */
6107 unsigned int Region_description:2; /* 3..4 */
6108 unsigned int reserved1:1; /* 5 */
6109 unsigned int Entry_SR:1; /* 6 */
6110 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6111 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6112 unsigned int Args_stored:1; /* 16 */
6113 unsigned int Variable_Frame:1; /* 17 */
6114 unsigned int Separate_Package_Body:1; /* 18 */
6115 unsigned int Frame_Extension_Millicode:1; /* 19 */
6116 unsigned int Stack_Overflow_Check:1; /* 20 */
6117 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6118 unsigned int Ada_Region:1; /* 22 */
6119 unsigned int cxx_info:1; /* 23 */
6120 unsigned int cxx_try_catch:1; /* 24 */
6121 unsigned int sched_entry_seq:1; /* 25 */
6122 unsigned int reserved2:1; /* 26 */
6123 unsigned int Save_SP:1; /* 27 */
6124 unsigned int Save_RP:1; /* 28 */
6125 unsigned int Save_MRP_in_frame:1; /* 29 */
6126 unsigned int extn_ptr_defined:1; /* 30 */
6127 unsigned int Cleanup_defined:1; /* 31 */
6128
6129 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6130 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6131 unsigned int Large_frame:1; /* 2 */
6132 unsigned int Pseudo_SP_Set:1; /* 3 */
6133 unsigned int reserved4:1; /* 4 */
6134 unsigned int Total_frame_size:27; /* 5..31 */
6135 };
6136
57346661
AM		 6137struct hppa_unw_aux_info
6138 {
3f5e193b 6139 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6140 unsigned long table_len; /* Length of unwind table. */
6141 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6142 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6143 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6144 char * strtab; /* The string table. */
57346661
AM		 6145 unsigned long strtab_size; /* Size of string table. */
6146 };
6147
6148static void
2cf0635d 6149dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6150{
2cf0635d 6151 struct hppa_unw_table_entry * tp;
57346661 6152
57346661
AM		 6153 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6154 {
6155 bfd_vma offset;
2cf0635d 6156 const char * procname;
57346661
AM		 6157
6158 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6159 aux->strtab_size, tp->start, &procname,
6160 &offset);
6161
6162 fputs ("\n<", stdout);
6163
6164 if (procname)
6165 {
6166 fputs (procname, stdout);
6167
6168 if (offset)
6169 printf ("+%lx", (unsigned long) offset);
6170 }
6171
6172 fputs (">: [", stdout);
6173 print_vma (tp->start.offset, PREFIX_HEX);
6174 fputc ('-', stdout);
6175 print_vma (tp->end.offset, PREFIX_HEX);
6176 printf ("]\n\t");
6177
18bd398b
NC		 6178#define PF(_m) if (tp->_m) printf (#_m " ");
6179#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6180 PF(Cannot_unwind);
6181 PF(Millicode);
6182 PF(Millicode_save_sr0);
18bd398b 6183 /* PV(Region_description); */
57346661
AM		 6184 PF(Entry_SR);
6185 PV(Entry_FR);
6186 PV(Entry_GR);
6187 PF(Args_stored);
6188 PF(Variable_Frame);
6189 PF(Separate_Package_Body);
6190 PF(Frame_Extension_Millicode);
6191 PF(Stack_Overflow_Check);
6192 PF(Two_Instruction_SP_Increment);
6193 PF(Ada_Region);
6194 PF(cxx_info);
6195 PF(cxx_try_catch);
6196 PF(sched_entry_seq);
6197 PF(Save_SP);
6198 PF(Save_RP);
6199 PF(Save_MRP_in_frame);
6200 PF(extn_ptr_defined);
6201 PF(Cleanup_defined);
6202 PF(MPE_XL_interrupt_marker);
6203 PF(HP_UX_interrupt_marker);
6204 PF(Large_frame);
6205 PF(Pseudo_SP_Set);
6206 PV(Total_frame_size);
6207#undef PF
6208#undef PV
6209 }
6210
18bd398b 6211 printf ("\n");
57346661
AM		 6212}
6213
6214static int
2cf0635d
NC		 6215slurp_hppa_unwind_table (FILE * file,
6216 struct hppa_unw_aux_info * aux,
6217 Elf_Internal_Shdr * sec)
57346661 6218{
1c0751b2 6219 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6220 Elf_Internal_Phdr * seg;
6221 struct hppa_unw_table_entry * tep;
6222 Elf_Internal_Shdr * relsec;
6223 Elf_Internal_Rela * rela;
6224 Elf_Internal_Rela * rp;
6225 unsigned char * table;
6226 unsigned char * tp;
6227 Elf_Internal_Sym * sym;
6228 const char * relname;
57346661 6229
57346661
AM		 6230 /* First, find the starting address of the segment that includes
6231 this section. */
6232
6233 if (elf_header.e_phnum)
6234 {
6235 if (! get_program_headers (file))
6236 return 0;
6237
6238 for (seg = program_headers;
6239 seg < program_headers + elf_header.e_phnum;
6240 ++seg)
6241 {
6242 if (seg->p_type != PT_LOAD)
6243 continue;
6244
6245 if (sec->sh_addr >= seg->p_vaddr
6246 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6247 {
6248 aux->seg_base = seg->p_vaddr;
6249 break;
6250 }
6251 }
6252 }
6253
6254 /* Second, build the unwind table from the contents of the unwind
6255 section. */
6256 size = sec->sh_size;
3f5e193b
NC		 6257 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6258 _("unwind table"));
57346661
AM		 6259 if (!table)
6260 return 0;
6261
1c0751b2
DA		 6262 unw_ent_size = 16;
6263 nentries = size / unw_ent_size;
6264 size = unw_ent_size * nentries;
57346661 6265
3f5e193b
NC		 6266 tep = aux->table = (struct hppa_unw_table_entry *)
6267 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6268
1c0751b2 6269 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6270 {
6271 unsigned int tmp1, tmp2;
6272
6273 tep->start.section = SHN_UNDEF;
6274 tep->end.section = SHN_UNDEF;
6275
1c0751b2
DA		 6276 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6277 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6278 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6279 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6280
6281 tep->start.offset += aux->seg_base;
6282 tep->end.offset += aux->seg_base;
57346661
AM		 6283
6284 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6285 tep->Millicode = (tmp1 >> 30) & 0x1;
6286 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6287 tep->Region_description = (tmp1 >> 27) & 0x3;
6288 tep->reserved1 = (tmp1 >> 26) & 0x1;
6289 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6290 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6291 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6292 tep->Args_stored = (tmp1 >> 15) & 0x1;
6293 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6294 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6295 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6296 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6297 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6298 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6299 tep->cxx_info = (tmp1 >> 8) & 0x1;
6300 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6301 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6302 tep->reserved2 = (tmp1 >> 5) & 0x1;
6303 tep->Save_SP = (tmp1 >> 4) & 0x1;
6304 tep->Save_RP = (tmp1 >> 3) & 0x1;
6305 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6306 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6307 tep->Cleanup_defined = tmp1 & 0x1;
6308
6309 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6310 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6311 tep->Large_frame = (tmp2 >> 29) & 0x1;
6312 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6313 tep->reserved4 = (tmp2 >> 27) & 0x1;
6314 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6315 }
6316 free (table);
6317
6318 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6319 for (relsec = section_headers;
6320 relsec < section_headers + elf_header.e_shnum;
6321 ++relsec)
6322 {
6323 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6324 || relsec->sh_info >= elf_header.e_shnum
6325 || section_headers + relsec->sh_info != sec)
57346661
AM		 6326 continue;
6327
6328 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6329 & rela, & nrelas))
6330 return 0;
6331
6332 for (rp = rela; rp < rela + nrelas; ++rp)
6333 {
aca88567
NC		 6334 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6335 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6336
6337 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6338 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6339 {
6340 warn (_("Skipping unexpected relocation type %s\n"), relname);
6341 continue;
6342 }
6343
6344 i = rp->r_offset / unw_ent_size;
6345
89fac5e3 6346 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6347 {
6348 case 0:
6349 aux->table[i].start.section = sym->st_shndx;
1e456d54 6350 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6351 break;
6352 case 1:
6353 aux->table[i].end.section = sym->st_shndx;
1e456d54 6354 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6355 break;
6356 default:
6357 break;
6358 }
6359 }
6360
6361 free (rela);
6362 }
6363
1c0751b2 6364 aux->table_len = nentries;
57346661
AM		 6365
6366 return 1;
6367}
6368
1b31d05e 6369static void
2cf0635d 6370hppa_process_unwind (FILE * file)
57346661 6371{
57346661 6372 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6373 Elf_Internal_Shdr * unwsec = NULL;
6374 Elf_Internal_Shdr * strsec;
6375 Elf_Internal_Shdr * sec;
18bd398b 6376 unsigned long i;
57346661 6377
c256ffe7 6378 if (string_table == NULL)
1b31d05e
NC		 6379 return;
6380
6381 memset (& aux, 0, sizeof (aux));
57346661
AM		 6382
6383 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6384 {
c256ffe7 6385 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6386 && sec->sh_link < elf_header.e_shnum)
57346661 6387 {
ba5cdace 6388 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6389
4fbb74a6 6390 strsec = section_headers + sec->sh_link;
59245841 6391 assert (aux.strtab == NULL);
3f5e193b
NC		 6392 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6393 1, strsec->sh_size,
6394 _("string table"));
c256ffe7 6395 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6396 }
18bd398b 6397 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6398 unwsec = sec;
6399 }
6400
6401 if (!unwsec)
6402 printf (_("\nThere are no unwind sections in this file.\n"));
6403
6404 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6405 {
18bd398b 6406 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6407 {
57346661
AM		 6408 printf (_("\nUnwind section "));
6409 printf (_("'%s'"), SECTION_NAME (sec));
6410
6411 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6412 (unsigned long) sec->sh_offset,
89fac5e3 6413 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6414
6415 slurp_hppa_unwind_table (file, &aux, sec);
6416 if (aux.table_len > 0)
6417 dump_hppa_unwind (&aux);
6418
6419 if (aux.table)
6420 free ((char *) aux.table);
6421 aux.table = NULL;
6422 }
6423 }
6424
6425 if (aux.symtab)
6426 free (aux.symtab);
6427 if (aux.strtab)
6428 free ((char *) aux.strtab);
57346661
AM		 6429}
6430
0b6ae522
DJ		 6431struct arm_section
6432{
a734115a
NC		 6433 unsigned char * data; /* The unwind data. */
6434 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6435 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6436 unsigned long nrelas; /* The number of relocations. */
6437 unsigned int rel_type; /* REL or RELA ? */
6438 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6439};
6440
6441struct arm_unw_aux_info
6442{
a734115a
NC		 6443 FILE * file; /* The file containing the unwind sections. */
6444 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6445 unsigned long nsyms; /* Number of symbols. */
6446 char * strtab; /* The file's string table. */
6447 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6448};
6449
6450static const char *
6451arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6452 bfd_vma fn, struct absaddr addr)
6453{
6454 const char *procname;
6455 bfd_vma sym_offset;
6456
6457 if (addr.section == SHN_UNDEF)
6458 addr.offset = fn;
6459
6460 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6461 aux->strtab_size, addr, &procname,
6462 &sym_offset);
6463
6464 print_vma (fn, PREFIX_HEX);
6465
6466 if (procname)
6467 {
6468 fputs (" <", stdout);
6469 fputs (procname, stdout);
6470
6471 if (sym_offset)
6472 printf ("+0x%lx", (unsigned long) sym_offset);
6473 fputc ('>', stdout);
6474 }
6475
6476 return procname;
6477}
6478
6479static void
6480arm_free_section (struct arm_section *arm_sec)
6481{
6482 if (arm_sec->data != NULL)
6483 free (arm_sec->data);
6484
6485 if (arm_sec->rela != NULL)
6486 free (arm_sec->rela);
6487}
6488
a734115a
NC		 6489/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6490 cached section and install SEC instead.
6491 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6492 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6493 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6494 relocation's offset in ADDR.
1b31d05e
NC		 6495 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6496 into the string table of the symbol associated with the reloc. If no
6497 reloc was applied store -1 there.
6498 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6499
6500static bfd_boolean
1b31d05e
NC		 6501get_unwind_section_word (struct arm_unw_aux_info * aux,
6502 struct arm_section * arm_sec,
6503 Elf_Internal_Shdr * sec,
6504 bfd_vma word_offset,
6505 unsigned int * wordp,
6506 struct absaddr * addr,
6507 bfd_vma * sym_name)
0b6ae522
DJ		 6508{
6509 Elf_Internal_Rela *rp;
6510 Elf_Internal_Sym *sym;
6511 const char * relname;
6512 unsigned int word;
6513 bfd_boolean wrapped;
6514
6515 addr->section = SHN_UNDEF;
6516 addr->offset = 0;
6517
1b31d05e
NC		 6518 if (sym_name != NULL)
6519 *sym_name = (bfd_vma) -1;
6520
a734115a 6521 /* If necessary, update the section cache. */
0b6ae522
DJ		 6522 if (sec != arm_sec->sec)
6523 {
6524 Elf_Internal_Shdr *relsec;
6525
6526 arm_free_section (arm_sec);
6527
6528 arm_sec->sec = sec;
6529 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6530 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6531 arm_sec->rela = NULL;
6532 arm_sec->nrelas = 0;
6533
6534 for (relsec = section_headers;
6535 relsec < section_headers + elf_header.e_shnum;
6536 ++relsec)
6537 {
6538 if (relsec->sh_info >= elf_header.e_shnum
6539 || section_headers + relsec->sh_info != sec)
6540 continue;
6541
a734115a 6542 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6543 if (relsec->sh_type == SHT_REL)
6544 {
6545 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6546 relsec->sh_size,
6547 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6548 return FALSE;
0b6ae522
DJ		 6549 break;
6550 }
6551 else if (relsec->sh_type == SHT_RELA)
6552 {
6553 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6554 relsec->sh_size,
6555 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6556 return FALSE;
0b6ae522
DJ		 6557 break;
6558 }
a734115a
NC		 6559 else
6560 warn (_("unexpected relocation type (%d) for section %d"),
6561 relsec->sh_type, relsec->sh_info);
0b6ae522
DJ		 6562 }
6563
6564 arm_sec->next_rela = arm_sec->rela;
6565 }
6566
a734115a 6567 /* If there is no unwind data we can do nothing. */
0b6ae522 6568 if (arm_sec->data == NULL)
a734115a 6569 return FALSE;
0b6ae522 6570
a734115a 6571 /* Get the word at the required offset. */
0b6ae522
DJ		 6572 word = byte_get (arm_sec->data + word_offset, 4);
6573
a734115a 6574 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6575 wrapped = FALSE;
6576 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6577 {
6578 bfd_vma prelval, offset;
6579
6580 if (rp->r_offset > word_offset && !wrapped)
6581 {
6582 rp = arm_sec->rela;
6583 wrapped = TRUE;
6584 }
6585 if (rp->r_offset > word_offset)
6586 break;
6587
6588 if (rp->r_offset & 3)
6589 {
6590 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6591 (unsigned long) rp->r_offset);
6592 continue;
6593 }
6594
6595 if (rp->r_offset < word_offset)
6596 continue;
6597
0b6ae522
DJ		 6598 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6599
6600 if (arm_sec->rel_type == SHT_REL)
6601 {
6602 offset = word & 0x7fffffff;
6603 if (offset & 0x40000000)
6604 offset |= ~ (bfd_vma) 0x7fffffff;
6605 }
a734115a 6606 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6607 offset = rp->r_addend;
a734115a
NC		 6608 else
6609 abort ();
0b6ae522
DJ		 6610
6611 offset += sym->st_value;
6612 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6613
a734115a
NC		 6614 /* Check that we are processing the expected reloc type. */
6615 if (elf_header.e_machine == EM_ARM)
6616 {
6617 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6618
6619 if (streq (relname, "R_ARM_NONE"))
6620 continue;
6621
6622 if (! streq (relname, "R_ARM_PREL31"))
6623 {
6624 warn (_("Skipping unexpected relocation type %s\n"), relname);
6625 continue;
6626 }
6627 }
6628 else if (elf_header.e_machine == EM_TI_C6000)
6629 {
6630 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6631
6632 if (streq (relname, "R_C6000_NONE"))
6633 continue;
6634
6635 if (! streq (relname, "R_C6000_PREL31"))
6636 {
6637 warn (_("Skipping unexpected relocation type %s\n"), relname);
6638 continue;
6639 }
6640
6641 prelval >>= 1;
6642 }
6643 else
6644 /* This function currently only supports ARM and TI unwinders. */
6645 abort ();
fa197c1c 6646
0b6ae522
DJ		 6647 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6648 addr->section = sym->st_shndx;
6649 addr->offset = offset;
1b31d05e
NC		 6650 if (sym_name)
6651 * sym_name = sym->st_name;
0b6ae522
DJ		 6652 break;
6653 }
6654
6655 *wordp = word;
6656 arm_sec->next_rela = rp;
6657
a734115a 6658 return TRUE;
0b6ae522
DJ		 6659}
6660
a734115a
NC		 6661static const char *tic6x_unwind_regnames[16] =
6662{
6663 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6664 "A14", "A13", "A12", "A11", "A10",
6665 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6666};
fa197c1c 6667
0b6ae522 6668static void
fa197c1c 6669decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6670{
fa197c1c
PB		 6671 int i;
6672
6673 for (i = 12; mask; mask >>= 1, i--)
6674 {
6675 if (mask & 1)
6676 {
6677 fputs (tic6x_unwind_regnames[i], stdout);
6678 if (mask > 1)
6679 fputs (", ", stdout);
6680 }
6681 }
6682}
0b6ae522
DJ		 6683
6684#define ADVANCE \
6685 if (remaining == 0 && more_words) \
6686 { \
6687 data_offset += 4; \
1b31d05e
NC		 6688 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6689 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 6690 return; \
6691 remaining = 4; \
6692 more_words--; \
6693 } \
6694
6695#define GET_OP(OP) \
6696 ADVANCE; \
6697 if (remaining) \
6698 { \
6699 remaining--; \
6700 (OP) = word >> 24; \
6701 word <<= 8; \
6702 } \
6703 else \
6704 { \
2b692964 6705 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6706 return; \
6707 } \
cc5914eb 6708 printf ("0x%02x ", OP)
0b6ae522 6709
fa197c1c
PB		 6710static void
6711decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6712 unsigned int word, unsigned int remaining,
6713 unsigned int more_words,
6714 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6715 struct arm_section *data_arm_sec)
6716{
6717 struct absaddr addr;
0b6ae522
DJ		 6718
6719 /* Decode the unwinding instructions. */
6720 while (1)
6721 {
6722 unsigned int op, op2;
6723
6724 ADVANCE;
6725 if (remaining == 0)
6726 break;
6727 remaining--;
6728 op = word >> 24;
6729 word <<= 8;
6730
cc5914eb 6731 printf (" 0x%02x ", op);
0b6ae522
DJ		 6732
6733 if ((op & 0xc0) == 0x00)
6734 {
6735 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6736
cc5914eb 6737 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6738 }
6739 else if ((op & 0xc0) == 0x40)
6740 {
6741 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6742
cc5914eb 6743 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6744 }
6745 else if ((op & 0xf0) == 0x80)
6746 {
6747 GET_OP (op2);
6748 if (op == 0x80 && op2 == 0)
6749 printf (_("Refuse to unwind"));
6750 else
6751 {
6752 unsigned int mask = ((op & 0x0f) << 8) | op2;
6753 int first = 1;
6754 int i;
2b692964 6755
0b6ae522
DJ		 6756 printf ("pop {");
6757 for (i = 0; i < 12; i++)
6758 if (mask & (1 << i))
6759 {
6760 if (first)
6761 first = 0;
6762 else
6763 printf (", ");
6764 printf ("r%d", 4 + i);
6765 }
6766 printf ("}");
6767 }
6768 }
6769 else if ((op & 0xf0) == 0x90)
6770 {
6771 if (op == 0x9d || op == 0x9f)
6772 printf (_(" [Reserved]"));
6773 else
cc5914eb 6774 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6775 }
6776 else if ((op & 0xf0) == 0xa0)
6777 {
6778 int end = 4 + (op & 0x07);
6779 int first = 1;
6780 int i;
61865e30 6781
0b6ae522
DJ		 6782 printf (" pop {");
6783 for (i = 4; i <= end; i++)
6784 {
6785 if (first)
6786 first = 0;
6787 else
6788 printf (", ");
6789 printf ("r%d", i);
6790 }
6791 if (op & 0x08)
6792 {
1b31d05e 6793 if (!first)
0b6ae522
DJ		 6794 printf (", ");
6795 printf ("r14");
6796 }
6797 printf ("}");
6798 }
6799 else if (op == 0xb0)
6800 printf (_(" finish"));
6801 else if (op == 0xb1)
6802 {
6803 GET_OP (op2);
6804 if (op2 == 0 || (op2 & 0xf0) != 0)
6805 printf (_("[Spare]"));
6806 else
6807 {
6808 unsigned int mask = op2 & 0x0f;
6809 int first = 1;
6810 int i;
61865e30 6811
0b6ae522
DJ		 6812 printf ("pop {");
6813 for (i = 0; i < 12; i++)
6814 if (mask & (1 << i))
6815 {
6816 if (first)
6817 first = 0;
6818 else
6819 printf (", ");
6820 printf ("r%d", i);
6821 }
6822 printf ("}");
6823 }
6824 }
6825 else if (op == 0xb2)
6826 {
b115cf96 6827 unsigned char buf[9];
0b6ae522
DJ		 6828 unsigned int i, len;
6829 unsigned long offset;
61865e30 6830
b115cf96 6831 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6832 {
6833 GET_OP (buf[i]);
6834 if ((buf[i] & 0x80) == 0)
6835 break;
6836 }
6837 assert (i < sizeof (buf));
6838 offset = read_uleb128 (buf, &len);
6839 assert (len == i + 1);
6840 offset = offset * 4 + 0x204;
cc5914eb 6841 printf ("vsp = vsp + %ld", offset);
0b6ae522 6842 }
61865e30 6843 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6844 {
61865e30
NC		 6845 unsigned int first, last;
6846
6847 GET_OP (op2);
6848 first = op2 >> 4;
6849 last = op2 & 0x0f;
6850 if (op == 0xc8)
6851 first = first + 16;
6852 printf ("pop {D%d", first);
6853 if (last)
6854 printf ("-D%d", first + last);
6855 printf ("}");
6856 }
6857 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6858 {
6859 unsigned int count = op & 0x07;
6860
6861 printf ("pop {D8");
6862 if (count)
6863 printf ("-D%d", 8 + count);
6864 printf ("}");
6865 }
6866 else if (op >= 0xc0 && op <= 0xc5)
6867 {
6868 unsigned int count = op & 0x07;
6869
6870 printf (" pop {wR10");
6871 if (count)
6872 printf ("-wR%d", 10 + count);
6873 printf ("}");
6874 }
6875 else if (op == 0xc6)
6876 {
6877 unsigned int first, last;
6878
6879 GET_OP (op2);
6880 first = op2 >> 4;
6881 last = op2 & 0x0f;
6882 printf ("pop {wR%d", first);
6883 if (last)
6884 printf ("-wR%d", first + last);
6885 printf ("}");
6886 }
6887 else if (op == 0xc7)
6888 {
6889 GET_OP (op2);
6890 if (op2 == 0 || (op2 & 0xf0) != 0)
6891 printf (_("[Spare]"));
0b6ae522
DJ		 6892 else
6893 {
61865e30
NC		 6894 unsigned int mask = op2 & 0x0f;
6895 int first = 1;
6896 int i;
6897
6898 printf ("pop {");
6899 for (i = 0; i < 4; i++)
6900 if (mask & (1 << i))
6901 {
6902 if (first)
6903 first = 0;
6904 else
6905 printf (", ");
6906 printf ("wCGR%d", i);
6907 }
6908 printf ("}");
0b6ae522
DJ		 6909 }
6910 }
61865e30
NC		 6911 else
6912 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6913 printf ("\n");
6914 }
fa197c1c
PB		 6915}
6916
6917static void
6918decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6919 unsigned int word, unsigned int remaining,
6920 unsigned int more_words,
6921 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6922 struct arm_section *data_arm_sec)
6923{
6924 struct absaddr addr;
6925
6926 /* Decode the unwinding instructions. */
6927 while (1)
6928 {
6929 unsigned int op, op2;
6930
6931 ADVANCE;
6932 if (remaining == 0)
6933 break;
6934 remaining--;
6935 op = word >> 24;
6936 word <<= 8;
6937
9cf03b7e 6938 printf (" 0x%02x ", op);
fa197c1c
PB		 6939
6940 if ((op & 0xc0) == 0x00)
6941 {
6942 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 6943 printf (" sp = sp + %d", offset);
fa197c1c
PB		 6944 }
6945 else if ((op & 0xc0) == 0x80)
6946 {
6947 GET_OP (op2);
6948 if (op == 0x80 && op2 == 0)
6949 printf (_("Refuse to unwind"));
6950 else
6951 {
6952 unsigned int mask = ((op & 0x1f) << 8) | op2;
6953 if (op & 0x20)
6954 printf ("pop compact {");
6955 else
6956 printf ("pop {");
6957
6958 decode_tic6x_unwind_regmask (mask);
6959 printf("}");
6960 }
6961 }
6962 else if ((op & 0xf0) == 0xc0)
6963 {
6964 unsigned int reg;
6965 unsigned int nregs;
6966 unsigned int i;
6967 const char *name;
a734115a
NC		 6968 struct
6969 {
fa197c1c
PB		 6970 unsigned int offset;
6971 unsigned int reg;
6972 } regpos[16];
6973
6974 /* Scan entire instruction first so that GET_OP output is not
6975 interleaved with disassembly. */
6976 nregs = 0;
6977 for (i = 0; nregs < (op & 0xf); i++)
6978 {
6979 GET_OP (op2);
6980 reg = op2 >> 4;
6981 if (reg != 0xf)
6982 {
6983 regpos[nregs].offset = i * 2;
6984 regpos[nregs].reg = reg;
6985 nregs++;
6986 }
6987
6988 reg = op2 & 0xf;
6989 if (reg != 0xf)
6990 {
6991 regpos[nregs].offset = i * 2 + 1;
6992 regpos[nregs].reg = reg;
6993 nregs++;
6994 }
6995 }
6996
6997 printf (_("pop frame {"));
6998 reg = nregs - 1;
6999 for (i = i * 2; i > 0; i--)
7000 {
7001 if (regpos[reg].offset == i - 1)
7002 {
7003 name = tic6x_unwind_regnames[regpos[reg].reg];
7004 if (reg > 0)
7005 reg--;
7006 }
7007 else
7008 name = _("[pad]");
7009
7010 fputs (name, stdout);
7011 if (i > 1)
7012 printf (", ");
7013 }
7014
7015 printf ("}");
7016 }
7017 else if (op == 0xd0)
7018 printf (" MOV FP, SP");
7019 else if (op == 0xd1)
7020 printf (" __c6xabi_pop_rts");
7021 else if (op == 0xd2)
7022 {
7023 unsigned char buf[9];
7024 unsigned int i, len;
7025 unsigned long offset;
a734115a 7026
fa197c1c
PB		 7027 for (i = 0; i < sizeof (buf); i++)
7028 {
7029 GET_OP (buf[i]);
7030 if ((buf[i] & 0x80) == 0)
7031 break;
7032 }
7033 assert (i < sizeof (buf));
7034 offset = read_uleb128 (buf, &len);
7035 assert (len == i + 1);
7036 offset = offset * 8 + 0x408;
7037 printf (_("sp = sp + %ld"), offset);
7038 }
7039 else if ((op & 0xf0) == 0xe0)
7040 {
7041 if ((op & 0x0f) == 7)
7042 printf (" RETURN");
7043 else
7044 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7045 }
7046 else
7047 {
7048 printf (_(" [unsupported opcode]"));
7049 }
7050 putchar ('\n');
7051 }
7052}
7053
7054static bfd_vma
a734115a 7055arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7056{
7057 bfd_vma offset;
7058
7059 offset = word & 0x7fffffff;
7060 if (offset & 0x40000000)
7061 offset |= ~ (bfd_vma) 0x7fffffff;
7062
7063 if (elf_header.e_machine == EM_TI_C6000)
7064 offset <<= 1;
7065
7066 return offset + where;
7067}
7068
7069static void
1b31d05e
NC		 7070decode_arm_unwind (struct arm_unw_aux_info * aux,
7071 unsigned int word,
7072 unsigned int remaining,
7073 bfd_vma data_offset,
7074 Elf_Internal_Shdr * data_sec,
7075 struct arm_section * data_arm_sec)
fa197c1c
PB		 7076{
7077 int per_index;
7078 unsigned int more_words = 0;
7079 struct absaddr addr;
1b31d05e 7080 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7081
7082 if (remaining == 0)
7083 {
1b31d05e
NC		 7084 /* Fetch the first word.
7085 Note - when decoding an object file the address extracted
7086 here will always be 0. So we also pass in the sym_name
7087 parameter so that we can find the symbol associated with
7088 the personality routine. */
7089 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7090 & word, & addr, & sym_name))
fa197c1c 7091 return;
1b31d05e 7092
fa197c1c
PB		 7093 remaining = 4;
7094 }
7095
7096 if ((word & 0x80000000) == 0)
7097 {
7098 /* Expand prel31 for personality routine. */
7099 bfd_vma fn;
7100 const char *procname;
7101
a734115a 7102 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7103 printf (_(" Personality routine: "));
1b31d05e
NC		 7104 if (fn == 0
7105 && addr.section == SHN_UNDEF && addr.offset == 0
7106 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7107 {
7108 procname = aux->strtab + sym_name;
7109 print_vma (fn, PREFIX_HEX);
7110 if (procname)
7111 {
7112 fputs (" <", stdout);
7113 fputs (procname, stdout);
7114 fputc ('>', stdout);
7115 }
7116 }
7117 else
7118 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7119 fputc ('\n', stdout);
7120
7121 /* The GCC personality routines use the standard compact
7122 encoding, starting with one byte giving the number of
7123 words. */
7124 if (procname != NULL
7125 && (const_strneq (procname, "__gcc_personality_v0")
7126 || const_strneq (procname, "__gxx_personality_v0")
7127 || const_strneq (procname, "__gcj_personality_v0")
7128 || const_strneq (procname, "__gnu_objc_personality_v0")))
7129 {
7130 remaining = 0;
7131 more_words = 1;
7132 ADVANCE;
7133 if (!remaining)
7134 {
7135 printf (_(" [Truncated data]\n"));
7136 return;
7137 }
7138 more_words = word >> 24;
7139 word <<= 8;
7140 remaining--;
7141 per_index = -1;
7142 }
7143 else
7144 return;
7145 }
7146 else
7147 {
1b31d05e
NC		 7148 /* ARM EHABI Section 6.3:
7149
7150 An exception-handling table entry for the compact model looks like:
7151
7152 31 30-28 27-24 23-0
7153 -- ----- ----- ----
7154 1 0 index Data for personalityRoutine[index] */
7155
7156 if (elf_header.e_machine == EM_ARM
7157 && (word & 0x70000000))
83c257ca 7158 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7159
fa197c1c 7160 per_index = (word >> 24) & 0x7f;
1b31d05e 7161 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7162 if (per_index == 0)
7163 {
7164 more_words = 0;
7165 word <<= 8;
7166 remaining--;
7167 }
7168 else if (per_index < 3)
7169 {
7170 more_words = (word >> 16) & 0xff;
7171 word <<= 16;
7172 remaining -= 2;
7173 }
7174 }
7175
7176 switch (elf_header.e_machine)
7177 {
7178 case EM_ARM:
7179 if (per_index < 3)
7180 {
7181 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7182 data_offset, data_sec, data_arm_sec);
7183 }
7184 else
1b31d05e
NC		 7185 {
7186 warn (_("Unknown ARM compact model index encountered\n"));
7187 printf (_(" [reserved]\n"));
7188 }
fa197c1c
PB		 7189 break;
7190
7191 case EM_TI_C6000:
7192 if (per_index < 3)
7193 {
7194 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7195 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7196 }
7197 else if (per_index < 5)
7198 {
7199 if (((word >> 17) & 0x7f) == 0x7f)
7200 printf (_(" Restore stack from frame pointer\n"));
7201 else
7202 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7203 printf (_(" Registers restored: "));
7204 if (per_index == 4)
7205 printf (" (compact) ");
7206 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7207 putchar ('\n');
7208 printf (_(" Return register: %s\n"),
7209 tic6x_unwind_regnames[word & 0xf]);
7210 }
7211 else
1b31d05e 7212 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7213 break;
7214
7215 default:
1b31d05e
NC		 7216 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7217 elf_header.e_machine);
fa197c1c 7218 }
0b6ae522
DJ		 7219
7220 /* Decode the descriptors. Not implemented. */
7221}
7222
7223static void
7224dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7225{
7226 struct arm_section exidx_arm_sec, extab_arm_sec;
7227 unsigned int i, exidx_len;
7228
7229 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7230 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7231 exidx_len = exidx_sec->sh_size / 8;
7232
7233 for (i = 0; i < exidx_len; i++)
7234 {
7235 unsigned int exidx_fn, exidx_entry;
7236 struct absaddr fn_addr, entry_addr;
7237 bfd_vma fn;
7238
7239 fputc ('\n', stdout);
7240
1b31d05e
NC		 7241 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7242 8 * i, & exidx_fn, & fn_addr, NULL)
7243 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7244 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7245 {
1b31d05e
NC		 7246 arm_free_section (& exidx_arm_sec);
7247 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7248 return;
7249 }
7250
83c257ca
NC		 7251 /* ARM EHABI, Section 5:
7252 An index table entry consists of 2 words.
7253 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7254 if (exidx_fn & 0x80000000)
7255 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7256
a734115a 7257 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7258
a734115a 7259 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7260 fputs (": ", stdout);
7261
7262 if (exidx_entry == 1)
7263 {
7264 print_vma (exidx_entry, PREFIX_HEX);
7265 fputs (" [cantunwind]\n", stdout);
7266 }
7267 else if (exidx_entry & 0x80000000)
7268 {
7269 print_vma (exidx_entry, PREFIX_HEX);
7270 fputc ('\n', stdout);
7271 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7272 }
7273 else
7274 {
8f73510c 7275 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7276 Elf_Internal_Shdr *table_sec;
7277
7278 fputs ("@", stdout);
a734115a 7279 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7280 print_vma (table, PREFIX_HEX);
7281 printf ("\n");
7282
7283 /* Locate the matching .ARM.extab. */
7284 if (entry_addr.section != SHN_UNDEF
7285 && entry_addr.section < elf_header.e_shnum)
7286 {
7287 table_sec = section_headers + entry_addr.section;
7288 table_offset = entry_addr.offset;
7289 }
7290 else
7291 {
7292 table_sec = find_section_by_address (table);
7293 if (table_sec != NULL)
7294 table_offset = table - table_sec->sh_addr;
7295 }
7296 if (table_sec == NULL)
7297 {
7298 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7299 (unsigned long) table);
7300 continue;
7301 }
7302 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7303 &extab_arm_sec);
7304 }
7305 }
7306
7307 printf ("\n");
7308
7309 arm_free_section (&exidx_arm_sec);
7310 arm_free_section (&extab_arm_sec);
7311}
7312
fa197c1c 7313/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7314
7315static void
0b6ae522
DJ		 7316arm_process_unwind (FILE *file)
7317{
7318 struct arm_unw_aux_info aux;
7319 Elf_Internal_Shdr *unwsec = NULL;
7320 Elf_Internal_Shdr *strsec;
7321 Elf_Internal_Shdr *sec;
7322 unsigned long i;
fa197c1c 7323 unsigned int sec_type;
0b6ae522 7324
fa197c1c
PB		 7325 switch (elf_header.e_machine)
7326 {
7327 case EM_ARM:
7328 sec_type = SHT_ARM_EXIDX;
7329 break;
7330
7331 case EM_TI_C6000:
7332 sec_type = SHT_C6000_UNWIND;
7333 break;
7334
1b31d05e
NC		 7335 default:
7336 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7337 elf_header.e_machine);
7338 return;
fa197c1c
PB		 7339 }
7340
0b6ae522 7341 if (string_table == NULL)
1b31d05e
NC		 7342 return;
7343
7344 memset (& aux, 0, sizeof (aux));
7345 aux.file = file;
0b6ae522
DJ		 7346
7347 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7348 {
7349 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7350 {
ba5cdace 7351 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7352
7353 strsec = section_headers + sec->sh_link;
59245841 7354 assert (aux.strtab == NULL);
0b6ae522
DJ		 7355 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7356 1, strsec->sh_size, _("string table"));
7357 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7358 }
fa197c1c 7359 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7360 unwsec = sec;
7361 }
7362
1b31d05e 7363 if (unwsec == NULL)
0b6ae522 7364 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7365 else
7366 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7367 {
7368 if (sec->sh_type == sec_type)
7369 {
7370 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7371 SECTION_NAME (sec),
7372 (unsigned long) sec->sh_offset,
7373 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7374
1b31d05e
NC		 7375 dump_arm_unwind (&aux, sec);
7376 }
7377 }
0b6ae522
DJ		 7378
7379 if (aux.symtab)
7380 free (aux.symtab);
7381 if (aux.strtab)
7382 free ((char *) aux.strtab);
0b6ae522
DJ		 7383}
7384
1b31d05e 7385static void
2cf0635d 7386process_unwind (FILE * file)
57346661 7387{
2cf0635d
NC		 7388 struct unwind_handler
7389 {
57346661 7390 int machtype;
1b31d05e 7391 void (* handler)(FILE *);
2cf0635d
NC		 7392 } handlers[] =
7393 {
0b6ae522 7394 { EM_ARM, arm_process_unwind },
57346661
AM		 7395 { EM_IA_64, ia64_process_unwind },
7396 { EM_PARISC, hppa_process_unwind },
fa197c1c 7397 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7398 { 0, 0 }
7399 };
7400 int i;
7401
7402 if (!do_unwind)
1b31d05e 7403 return;
57346661
AM		 7404
7405 for (i = 0; handlers[i].handler != NULL; i++)
7406 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7407 return handlers[i].handler (file);
57346661 7408
1b31d05e
NC		 7409 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7410 get_machine_name (elf_header.e_machine));
57346661
AM		 7411}
7412
252b5132 7413static void
2cf0635d 7414dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7415{
7416 switch (entry->d_tag)
7417 {
7418 case DT_MIPS_FLAGS:
7419 if (entry->d_un.d_val == 0)
4b68bca3 7420 printf (_("NONE"));
252b5132
RH		 7421 else
7422 {
7423 static const char * opts[] =
7424 {
7425 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7426 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7427 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7428 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7429 "RLD_ORDER_SAFE"
7430 };
7431 unsigned int cnt;
7432 int first = 1;
2b692964 7433
60bca95a 7434 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7435 if (entry->d_un.d_val & (1 << cnt))
7436 {
7437 printf ("%s%s", first ? "" : " ", opts[cnt]);
7438 first = 0;
7439 }
252b5132
RH		 7440 }
7441 break;
103f02d3 7442
252b5132 7443 case DT_MIPS_IVERSION:
d79b3d50 7444 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7445 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7446 else
4b68bca3 7447 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7448 break;
103f02d3 7449
252b5132
RH		 7450 case DT_MIPS_TIME_STAMP:
7451 {
7452 char timebuf[20];
2cf0635d 7453 struct tm * tmp;
50da7a9c 7454
91d6fa6a
NC		 7455 time_t atime = entry->d_un.d_val;
7456 tmp = gmtime (&atime);
e9e44622
JJ		 7457 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7458 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7459 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7460 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7461 }
7462 break;
103f02d3 7463
252b5132
RH		 7464 case DT_MIPS_RLD_VERSION:
7465 case DT_MIPS_LOCAL_GOTNO:
7466 case DT_MIPS_CONFLICTNO:
7467 case DT_MIPS_LIBLISTNO:
7468 case DT_MIPS_SYMTABNO:
7469 case DT_MIPS_UNREFEXTNO:
7470 case DT_MIPS_HIPAGENO:
7471 case DT_MIPS_DELTA_CLASS_NO:
7472 case DT_MIPS_DELTA_INSTANCE_NO:
7473 case DT_MIPS_DELTA_RELOC_NO:
7474 case DT_MIPS_DELTA_SYM_NO:
7475 case DT_MIPS_DELTA_CLASSSYM_NO:
7476 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7477 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7478 break;
103f02d3
UD		 7479
7480 default:
4b68bca3 7481 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7482 }
4b68bca3 7483 putchar ('\n');
103f02d3
UD		 7484}
7485
103f02d3 7486static void
2cf0635d 7487dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7488{
7489 switch (entry->d_tag)
7490 {
7491 case DT_HP_DLD_FLAGS:
7492 {
7493 static struct
7494 {
7495 long int bit;
2cf0635d 7496 const char * str;
5e220199
NC		 7497 }
7498 flags[] =
7499 {
7500 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7501 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7502 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7503 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7504 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7505 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7506 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7507 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7508 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7509 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7510 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7511 { DT_HP_GST, "HP_GST" },
7512 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7513 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7514 { DT_HP_NODELETE, "HP_NODELETE" },
7515 { DT_HP_GROUP, "HP_GROUP" },
7516 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7517 };
103f02d3 7518 int first = 1;
5e220199 7519 size_t cnt;
f7a99963 7520 bfd_vma val = entry->d_un.d_val;
103f02d3 7521
60bca95a 7522 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7523 if (val & flags[cnt].bit)
30800947
NC		 7524 {
7525 if (! first)
7526 putchar (' ');
7527 fputs (flags[cnt].str, stdout);
7528 first = 0;
7529 val ^= flags[cnt].bit;
7530 }
76da6bbe 7531
103f02d3 7532 if (val != 0 || first)
f7a99963
NC		 7533 {
7534 if (! first)
7535 putchar (' ');
7536 print_vma (val, HEX);
7537 }
103f02d3
UD		 7538 }
7539 break;
76da6bbe 7540
252b5132 7541 default:
f7a99963
NC		 7542 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7543 break;
252b5132 7544 }
35b1837e 7545 putchar ('\n');
252b5132
RH		 7546}
7547
28f997cf
TG		 7548#ifdef BFD64
7549
7550/* VMS vs Unix time offset and factor. */
7551
7552#define VMS_EPOCH_OFFSET 35067168000000000LL
7553#define VMS_GRANULARITY_FACTOR 10000000
7554
7555/* Display a VMS time in a human readable format. */
7556
7557static void
7558print_vms_time (bfd_int64_t vmstime)
7559{
7560 struct tm *tm;
7561 time_t unxtime;
7562
7563 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7564 tm = gmtime (&unxtime);
7565 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7566 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7567 tm->tm_hour, tm->tm_min, tm->tm_sec);
7568}
7569#endif /* BFD64 */
7570
ecc51f48 7571static void
2cf0635d 7572dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7573{
7574 switch (entry->d_tag)
7575 {
0de14b54 7576 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7577 /* First 3 slots reserved. */
ecc51f48
NC		 7578 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7579 printf (" -- ");
7580 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7581 break;
7582
28f997cf
TG		 7583 case DT_IA_64_VMS_LINKTIME:
7584#ifdef BFD64
7585 print_vms_time (entry->d_un.d_val);
7586#endif
7587 break;
7588
7589 case DT_IA_64_VMS_LNKFLAGS:
7590 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7591 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7592 printf (" CALL_DEBUG");
7593 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7594 printf (" NOP0BUFS");
7595 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7596 printf (" P0IMAGE");
7597 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7598 printf (" MKTHREADS");
7599 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7600 printf (" UPCALLS");
7601 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7602 printf (" IMGSTA");
7603 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7604 printf (" INITIALIZE");
7605 if (entry->d_un.d_val & VMS_LF_MAIN)
7606 printf (" MAIN");
7607 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7608 printf (" EXE_INIT");
7609 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7610 printf (" TBK_IN_IMG");
7611 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7612 printf (" DBG_IN_IMG");
7613 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7614 printf (" TBK_IN_DSF");
7615 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7616 printf (" DBG_IN_DSF");
7617 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7618 printf (" SIGNATURES");
7619 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7620 printf (" REL_SEG_OFF");
7621 break;
7622
bdf4d63a
JJ		 7623 default:
7624 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7625 break;
ecc51f48 7626 }
bdf4d63a 7627 putchar ('\n');
ecc51f48
NC		 7628}
7629
252b5132 7630static int
2cf0635d 7631get_32bit_dynamic_section (FILE * file)
252b5132 7632{
2cf0635d
NC		 7633 Elf32_External_Dyn * edyn;
7634 Elf32_External_Dyn * ext;
7635 Elf_Internal_Dyn * entry;
103f02d3 7636
3f5e193b
NC		 7637 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7638 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7639 if (!edyn)
7640 return 0;
103f02d3 7641
ba2685cc
AM		 7642/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7643 might not have the luxury of section headers. Look for the DT_NULL
7644 terminator to determine the number of entries. */
7645 for (ext = edyn, dynamic_nent = 0;
7646 (char *) ext < (char *) edyn + dynamic_size;
7647 ext++)
7648 {
7649 dynamic_nent++;
7650 if (BYTE_GET (ext->d_tag) == DT_NULL)
7651 break;
7652 }
252b5132 7653
3f5e193b
NC		 7654 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7655 sizeof (* entry));
b2d38a17 7656 if (dynamic_section == NULL)
252b5132 7657 {
9ea033b2
NC		 7658 error (_("Out of memory\n"));
7659 free (edyn);
7660 return 0;
7661 }
252b5132 7662
fb514b26 7663 for (ext = edyn, entry = dynamic_section;
ba2685cc 7664 entry < dynamic_section + dynamic_nent;
fb514b26 7665 ext++, entry++)
9ea033b2 7666 {
fb514b26
AM		 7667 entry->d_tag = BYTE_GET (ext->d_tag);
7668 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7669 }
7670
9ea033b2
NC		 7671 free (edyn);
7672
7673 return 1;
7674}
7675
7676static int
2cf0635d 7677get_64bit_dynamic_section (FILE * file)
9ea033b2 7678{
2cf0635d
NC		 7679 Elf64_External_Dyn * edyn;
7680 Elf64_External_Dyn * ext;
7681 Elf_Internal_Dyn * entry;
103f02d3 7682
3f5e193b
NC		 7683 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7684 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7685 if (!edyn)
7686 return 0;
103f02d3 7687
ba2685cc
AM		 7688/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7689 might not have the luxury of section headers. Look for the DT_NULL
7690 terminator to determine the number of entries. */
7691 for (ext = edyn, dynamic_nent = 0;
7692 (char *) ext < (char *) edyn + dynamic_size;
7693 ext++)
7694 {
7695 dynamic_nent++;
66543521 7696 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7697 break;
7698 }
252b5132 7699
3f5e193b
NC		 7700 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7701 sizeof (* entry));
b2d38a17 7702 if (dynamic_section == NULL)
252b5132
RH		 7703 {
7704 error (_("Out of memory\n"));
7705 free (edyn);
7706 return 0;
7707 }
7708
fb514b26 7709 for (ext = edyn, entry = dynamic_section;
ba2685cc 7710 entry < dynamic_section + dynamic_nent;
fb514b26 7711 ext++, entry++)
252b5132 7712 {
66543521
AM		 7713 entry->d_tag = BYTE_GET (ext->d_tag);
7714 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7715 }
7716
7717 free (edyn);
7718
9ea033b2
NC		 7719 return 1;
7720}
7721
e9e44622
JJ		 7722static void
7723print_dynamic_flags (bfd_vma flags)
d1133906 7724{
e9e44622 7725 int first = 1;
13ae64f3 7726
d1133906
NC		 7727 while (flags)
7728 {
7729 bfd_vma flag;
7730
7731 flag = flags & - flags;
7732 flags &= ~ flag;
7733
e9e44622
JJ		 7734 if (first)
7735 first = 0;
7736 else
7737 putc (' ', stdout);
13ae64f3 7738
d1133906
NC		 7739 switch (flag)
7740 {
e9e44622
JJ		 7741 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7742 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7743 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7744 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7745 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7746 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7747 }
7748 }
e9e44622 7749 puts ("");
d1133906
NC		 7750}
7751
b2d38a17
NC		 7752/* Parse and display the contents of the dynamic section. */
7753
9ea033b2 7754static int
2cf0635d 7755process_dynamic_section (FILE * file)
9ea033b2 7756{
2cf0635d 7757 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7758
7759 if (dynamic_size == 0)
7760 {
7761 if (do_dynamic)
b2d38a17 7762 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7763
7764 return 1;
7765 }
7766
7767 if (is_32bit_elf)
7768 {
b2d38a17 7769 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7770 return 0;
7771 }
b2d38a17 7772 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7773 return 0;
7774
252b5132
RH		 7775 /* Find the appropriate symbol table. */
7776 if (dynamic_symbols == NULL)
7777 {
86dba8ee
AM		 7778 for (entry = dynamic_section;
7779 entry < dynamic_section + dynamic_nent;
7780 ++entry)
252b5132 7781 {
c8286bd1 7782 Elf_Internal_Shdr section;
252b5132
RH		 7783
7784 if (entry->d_tag != DT_SYMTAB)
7785 continue;
7786
7787 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7788
7789 /* Since we do not know how big the symbol table is,
7790 we default to reading in the entire file (!) and
7791 processing that. This is overkill, I know, but it
e3c8793a 7792 should work. */
d93f0186 7793 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7794
fb52b2f4
NC		 7795 if (archive_file_offset != 0)
7796 section.sh_size = archive_file_size - section.sh_offset;
7797 else
7798 {
7799 if (fseek (file, 0, SEEK_END))
591a748a 7800 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7801
7802 section.sh_size = ftell (file) - section.sh_offset;
7803 }
252b5132 7804
9ea033b2 7805 if (is_32bit_elf)
9ad5cbcf 7806 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7807 else
9ad5cbcf 7808 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7809
ba5cdace 7810 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7811 if (num_dynamic_syms < 1)
252b5132
RH		 7812 {
7813 error (_("Unable to determine the number of symbols to load\n"));
7814 continue;
7815 }
252b5132
RH		 7816 }
7817 }
7818
7819 /* Similarly find a string table. */
7820 if (dynamic_strings == NULL)
7821 {
86dba8ee
AM		 7822 for (entry = dynamic_section;
7823 entry < dynamic_section + dynamic_nent;
7824 ++entry)
252b5132
RH		 7825 {
7826 unsigned long offset;
b34976b6 7827 long str_tab_len;
252b5132
RH		 7828
7829 if (entry->d_tag != DT_STRTAB)
7830 continue;
7831
7832 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7833
7834 /* Since we do not know how big the string table is,
7835 we default to reading in the entire file (!) and
7836 processing that. This is overkill, I know, but it
e3c8793a 7837 should work. */
252b5132 7838
d93f0186 7839 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7840
7841 if (archive_file_offset != 0)
7842 str_tab_len = archive_file_size - offset;
7843 else
7844 {
7845 if (fseek (file, 0, SEEK_END))
7846 error (_("Unable to seek to end of file\n"));
7847 str_tab_len = ftell (file) - offset;
7848 }
252b5132
RH		 7849
7850 if (str_tab_len < 1)
7851 {
7852 error
7853 (_("Unable to determine the length of the dynamic string table\n"));
7854 continue;
7855 }
7856
3f5e193b
NC		 7857 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7858 str_tab_len,
7859 _("dynamic string table"));
59245841 7860 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7861 break;
7862 }
7863 }
7864
7865 /* And find the syminfo section if available. */
7866 if (dynamic_syminfo == NULL)
7867 {
3e8bba36 7868 unsigned long syminsz = 0;
252b5132 7869
86dba8ee
AM		 7870 for (entry = dynamic_section;
7871 entry < dynamic_section + dynamic_nent;
7872 ++entry)
252b5132
RH		 7873 {
7874 if (entry->d_tag == DT_SYMINENT)
7875 {
7876 /* Note: these braces are necessary to avoid a syntax
7877 error from the SunOS4 C compiler. */
7878 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7879 }
7880 else if (entry->d_tag == DT_SYMINSZ)
7881 syminsz = entry->d_un.d_val;
7882 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7883 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7884 syminsz);
252b5132
RH		 7885 }
7886
7887 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7888 {
2cf0635d
NC		 7889 Elf_External_Syminfo * extsyminfo;
7890 Elf_External_Syminfo * extsym;
7891 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7892
7893 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7894 extsyminfo = (Elf_External_Syminfo *)
7895 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7896 _("symbol information"));
a6e9f9df
AM		 7897 if (!extsyminfo)
7898 return 0;
252b5132 7899
3f5e193b 7900 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7901 if (dynamic_syminfo == NULL)
7902 {
7903 error (_("Out of memory\n"));
7904 return 0;
7905 }
7906
7907 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7908 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7909 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7910 ++syminfo, ++extsym)
252b5132 7911 {
86dba8ee
AM		 7912 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7913 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7914 }
7915
7916 free (extsyminfo);
7917 }
7918 }
7919
7920 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7921 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7922 dynamic_addr, dynamic_nent);
252b5132
RH		 7923 if (do_dynamic)
7924 printf (_(" Tag Type Name/Value\n"));
7925
86dba8ee
AM		 7926 for (entry = dynamic_section;
7927 entry < dynamic_section + dynamic_nent;
7928 entry++)
252b5132
RH		 7929 {
7930 if (do_dynamic)
f7a99963 7931 {
2cf0635d 7932 const char * dtype;
e699b9ff 7933
f7a99963
NC		 7934 putchar (' ');
7935 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7936 dtype = get_dynamic_type (entry->d_tag);
7937 printf (" (%s)%*s", dtype,
7938 ((is_32bit_elf ? 27 : 19)
7939 - (int) strlen (dtype)),
f7a99963
NC		 7940 " ");
7941 }
252b5132
RH		 7942
7943 switch (entry->d_tag)
7944 {
d1133906
NC		 7945 case DT_FLAGS:
7946 if (do_dynamic)
e9e44622 7947 print_dynamic_flags (entry->d_un.d_val);
d1133906 7948 break;
76da6bbe 7949
252b5132
RH		 7950 case DT_AUXILIARY:
7951 case DT_FILTER:
019148e4
L		 7952 case DT_CONFIG:
7953 case DT_DEPAUDIT:
7954 case DT_AUDIT:
252b5132
RH		 7955 if (do_dynamic)
7956 {
019148e4 7957 switch (entry->d_tag)
b34976b6 7958 {
019148e4
L		 7959 case DT_AUXILIARY:
7960 printf (_("Auxiliary library"));
7961 break;
7962
7963 case DT_FILTER:
7964 printf (_("Filter library"));
7965 break;
7966
b34976b6 7967 case DT_CONFIG:
019148e4
L		 7968 printf (_("Configuration file"));
7969 break;
7970
7971 case DT_DEPAUDIT:
7972 printf (_("Dependency audit library"));
7973 break;
7974
7975 case DT_AUDIT:
7976 printf (_("Audit library"));
7977 break;
7978 }
252b5132 7979
d79b3d50
NC		 7980 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7981 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7982 else
f7a99963
NC		 7983 {
7984 printf (": ");
7985 print_vma (entry->d_un.d_val, PREFIX_HEX);
7986 putchar ('\n');
7987 }
252b5132
RH		 7988 }
7989 break;
7990
dcefbbbd 7991 case DT_FEATURE:
252b5132
RH		 7992 if (do_dynamic)
7993 {
7994 printf (_("Flags:"));
86f55779 7995
252b5132
RH		 7996 if (entry->d_un.d_val == 0)
7997 printf (_(" None\n"));
7998 else
7999 {
8000 unsigned long int val = entry->d_un.d_val;
86f55779 8001
252b5132
RH		 8002 if (val & DTF_1_PARINIT)
8003 {
8004 printf (" PARINIT");
8005 val ^= DTF_1_PARINIT;
8006 }
dcefbbbd
L		 8007 if (val & DTF_1_CONFEXP)
8008 {
8009 printf (" CONFEXP");
8010 val ^= DTF_1_CONFEXP;
8011 }
252b5132
RH		 8012 if (val != 0)
8013 printf (" %lx", val);
8014 puts ("");
8015 }
8016 }
8017 break;
8018
8019 case DT_POSFLAG_1:
8020 if (do_dynamic)
8021 {
8022 printf (_("Flags:"));
86f55779 8023
252b5132
RH		 8024 if (entry->d_un.d_val == 0)
8025 printf (_(" None\n"));
8026 else
8027 {
8028 unsigned long int val = entry->d_un.d_val;
86f55779 8029
252b5132
RH		 8030 if (val & DF_P1_LAZYLOAD)
8031 {
8032 printf (" LAZYLOAD");
8033 val ^= DF_P1_LAZYLOAD;
8034 }
8035 if (val & DF_P1_GROUPPERM)
8036 {
8037 printf (" GROUPPERM");
8038 val ^= DF_P1_GROUPPERM;
8039 }
8040 if (val != 0)
8041 printf (" %lx", val);
8042 puts ("");
8043 }
8044 }
8045 break;
8046
8047 case DT_FLAGS_1:
8048 if (do_dynamic)
8049 {
8050 printf (_("Flags:"));
8051 if (entry->d_un.d_val == 0)
8052 printf (_(" None\n"));
8053 else
8054 {
8055 unsigned long int val = entry->d_un.d_val;
86f55779 8056
252b5132
RH		 8057 if (val & DF_1_NOW)
8058 {
8059 printf (" NOW");
8060 val ^= DF_1_NOW;
8061 }
8062 if (val & DF_1_GLOBAL)
8063 {
8064 printf (" GLOBAL");
8065 val ^= DF_1_GLOBAL;
8066 }
8067 if (val & DF_1_GROUP)
8068 {
8069 printf (" GROUP");
8070 val ^= DF_1_GROUP;
8071 }
8072 if (val & DF_1_NODELETE)
8073 {
8074 printf (" NODELETE");
8075 val ^= DF_1_NODELETE;
8076 }
8077 if (val & DF_1_LOADFLTR)
8078 {
8079 printf (" LOADFLTR");
8080 val ^= DF_1_LOADFLTR;
8081 }
8082 if (val & DF_1_INITFIRST)
8083 {
8084 printf (" INITFIRST");
8085 val ^= DF_1_INITFIRST;
8086 }
8087 if (val & DF_1_NOOPEN)
8088 {
8089 printf (" NOOPEN");
8090 val ^= DF_1_NOOPEN;
8091 }
8092 if (val & DF_1_ORIGIN)
8093 {
8094 printf (" ORIGIN");
8095 val ^= DF_1_ORIGIN;
8096 }
8097 if (val & DF_1_DIRECT)
8098 {
8099 printf (" DIRECT");
8100 val ^= DF_1_DIRECT;
8101 }
8102 if (val & DF_1_TRANS)
8103 {
8104 printf (" TRANS");
8105 val ^= DF_1_TRANS;
8106 }
8107 if (val & DF_1_INTERPOSE)
8108 {
8109 printf (" INTERPOSE");
8110 val ^= DF_1_INTERPOSE;
8111 }
f7db6139 8112 if (val & DF_1_NODEFLIB)
dcefbbbd 8113 {
f7db6139
L		 8114 printf (" NODEFLIB");
8115 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8116 }
8117 if (val & DF_1_NODUMP)
8118 {
8119 printf (" NODUMP");
8120 val ^= DF_1_NODUMP;
8121 }
34b60028 8122 if (val & DF_1_CONFALT)
dcefbbbd 8123 {
34b60028
L		 8124 printf (" CONFALT");
8125 val ^= DF_1_CONFALT;
8126 }
8127 if (val & DF_1_ENDFILTEE)
8128 {
8129 printf (" ENDFILTEE");
8130 val ^= DF_1_ENDFILTEE;
8131 }
8132 if (val & DF_1_DISPRELDNE)
8133 {
8134 printf (" DISPRELDNE");
8135 val ^= DF_1_DISPRELDNE;
8136 }
8137 if (val & DF_1_DISPRELPND)
8138 {
8139 printf (" DISPRELPND");
8140 val ^= DF_1_DISPRELPND;
8141 }
8142 if (val & DF_1_NODIRECT)
8143 {
8144 printf (" NODIRECT");
8145 val ^= DF_1_NODIRECT;
8146 }
8147 if (val & DF_1_IGNMULDEF)
8148 {
8149 printf (" IGNMULDEF");
8150 val ^= DF_1_IGNMULDEF;
8151 }
8152 if (val & DF_1_NOKSYMS)
8153 {
8154 printf (" NOKSYMS");
8155 val ^= DF_1_NOKSYMS;
8156 }
8157 if (val & DF_1_NOHDR)
8158 {
8159 printf (" NOHDR");
8160 val ^= DF_1_NOHDR;
8161 }
8162 if (val & DF_1_EDITED)
8163 {
8164 printf (" EDITED");
8165 val ^= DF_1_EDITED;
8166 }
8167 if (val & DF_1_NORELOC)
8168 {
8169 printf (" NORELOC");
8170 val ^= DF_1_NORELOC;
8171 }
8172 if (val & DF_1_SYMINTPOSE)
8173 {
8174 printf (" SYMINTPOSE");
8175 val ^= DF_1_SYMINTPOSE;
8176 }
8177 if (val & DF_1_GLOBAUDIT)
8178 {
8179 printf (" GLOBAUDIT");
8180 val ^= DF_1_GLOBAUDIT;
8181 }
8182 if (val & DF_1_SINGLETON)
8183 {
8184 printf (" SINGLETON");
8185 val ^= DF_1_SINGLETON;
dcefbbbd 8186 }
252b5132
RH		 8187 if (val != 0)
8188 printf (" %lx", val);
8189 puts ("");
8190 }
8191 }
8192 break;
8193
8194 case DT_PLTREL:
566b0d53 8195 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8196 if (do_dynamic)
8197 puts (get_dynamic_type (entry->d_un.d_val));
8198 break;
8199
8200 case DT_NULL :
8201 case DT_NEEDED :
8202 case DT_PLTGOT :
8203 case DT_HASH :
8204 case DT_STRTAB :
8205 case DT_SYMTAB :
8206 case DT_RELA :
8207 case DT_INIT :
8208 case DT_FINI :
8209 case DT_SONAME :
8210 case DT_RPATH :
8211 case DT_SYMBOLIC:
8212 case DT_REL :
8213 case DT_DEBUG :
8214 case DT_TEXTREL :
8215 case DT_JMPREL :
019148e4 8216 case DT_RUNPATH :
252b5132
RH		 8217 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8218
8219 if (do_dynamic)
8220 {
2cf0635d 8221 char * name;
252b5132 8222
d79b3d50
NC		 8223 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8224 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8225 else
d79b3d50 8226 name = NULL;
252b5132
RH		 8227
8228 if (name)
8229 {
8230 switch (entry->d_tag)
8231 {
8232 case DT_NEEDED:
8233 printf (_("Shared library: [%s]"), name);
8234
18bd398b 8235 if (streq (name, program_interpreter))
f7a99963 8236 printf (_(" program interpreter"));
252b5132
RH		 8237 break;
8238
8239 case DT_SONAME:
f7a99963 8240 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8241 break;
8242
8243 case DT_RPATH:
f7a99963 8244 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8245 break;
8246
019148e4
L		 8247 case DT_RUNPATH:
8248 printf (_("Library runpath: [%s]"), name);
8249 break;
8250
252b5132 8251 default:
f7a99963
NC		 8252 print_vma (entry->d_un.d_val, PREFIX_HEX);
8253 break;
252b5132
RH		 8254 }
8255 }
8256 else
f7a99963
NC		 8257 print_vma (entry->d_un.d_val, PREFIX_HEX);
8258
8259 putchar ('\n');
252b5132
RH		 8260 }
8261 break;
8262
8263 case DT_PLTRELSZ:
8264 case DT_RELASZ :
8265 case DT_STRSZ :
8266 case DT_RELSZ :
8267 case DT_RELAENT :
8268 case DT_SYMENT :
8269 case DT_RELENT :
566b0d53 8270 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8271 case DT_PLTPADSZ:
8272 case DT_MOVEENT :
8273 case DT_MOVESZ :
8274 case DT_INIT_ARRAYSZ:
8275 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8276 case DT_GNU_CONFLICTSZ:
8277 case DT_GNU_LIBLISTSZ:
252b5132 8278 if (do_dynamic)
f7a99963
NC		 8279 {
8280 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8281 printf (_(" (bytes)\n"));
f7a99963 8282 }
252b5132
RH		 8283 break;
8284
8285 case DT_VERDEFNUM:
8286 case DT_VERNEEDNUM:
8287 case DT_RELACOUNT:
8288 case DT_RELCOUNT:
8289 if (do_dynamic)
f7a99963
NC		 8290 {
8291 print_vma (entry->d_un.d_val, UNSIGNED);
8292 putchar ('\n');
8293 }
252b5132
RH		 8294 break;
8295
8296 case DT_SYMINSZ:
8297 case DT_SYMINENT:
8298 case DT_SYMINFO:
8299 case DT_USED:
8300 case DT_INIT_ARRAY:
8301 case DT_FINI_ARRAY:
8302 if (do_dynamic)
8303 {
d79b3d50
NC		 8304 if (entry->d_tag == DT_USED
8305 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8306 {
2cf0635d 8307 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8308
b34976b6 8309 if (*name)
252b5132
RH		 8310 {
8311 printf (_("Not needed object: [%s]\n"), name);
8312 break;
8313 }
8314 }
103f02d3 8315
f7a99963
NC		 8316 print_vma (entry->d_un.d_val, PREFIX_HEX);
8317 putchar ('\n');
252b5132
RH		 8318 }
8319 break;
8320
8321 case DT_BIND_NOW:
8322 /* The value of this entry is ignored. */
35b1837e
AM		 8323 if (do_dynamic)
8324 putchar ('\n');
252b5132 8325 break;
103f02d3 8326
047b2264
JJ		 8327 case DT_GNU_PRELINKED:
8328 if (do_dynamic)
8329 {
2cf0635d 8330 struct tm * tmp;
91d6fa6a 8331 time_t atime = entry->d_un.d_val;
047b2264 8332
91d6fa6a 8333 tmp = gmtime (&atime);
047b2264
JJ		 8334 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8335 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8336 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8337
8338 }
8339 break;
8340
fdc90cb4
JJ		 8341 case DT_GNU_HASH:
8342 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8343 if (do_dynamic)
8344 {
8345 print_vma (entry->d_un.d_val, PREFIX_HEX);
8346 putchar ('\n');
8347 }
8348 break;
8349
252b5132
RH		 8350 default:
8351 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8352 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8353 entry->d_un.d_val;
8354
8355 if (do_dynamic)
8356 {
8357 switch (elf_header.e_machine)
8358 {
8359 case EM_MIPS:
4fe85591 8360 case EM_MIPS_RS3_LE:
b2d38a17 8361 dynamic_section_mips_val (entry);
252b5132 8362 break;
103f02d3 8363 case EM_PARISC:
b2d38a17 8364 dynamic_section_parisc_val (entry);
103f02d3 8365 break;
ecc51f48 8366 case EM_IA_64:
b2d38a17 8367 dynamic_section_ia64_val (entry);
ecc51f48 8368 break;
252b5132 8369 default:
f7a99963
NC		 8370 print_vma (entry->d_un.d_val, PREFIX_HEX);
8371 putchar ('\n');
252b5132
RH		 8372 }
8373 }
8374 break;
8375 }
8376 }
8377
8378 return 1;
8379}
8380
8381static char *
d3ba0551 8382get_ver_flags (unsigned int flags)
252b5132 8383{
b34976b6 8384 static char buff[32];
252b5132
RH		 8385
8386 buff[0] = 0;
8387
8388 if (flags == 0)
8389 return _("none");
8390
8391 if (flags & VER_FLG_BASE)
8392 strcat (buff, "BASE ");
8393
8394 if (flags & VER_FLG_WEAK)
8395 {
8396 if (flags & VER_FLG_BASE)
8397 strcat (buff, "| ");
8398
8399 strcat (buff, "WEAK ");
8400 }
8401
44ec90b9
RO		 8402 if (flags & VER_FLG_INFO)
8403 {
8404 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8405 strcat (buff, "| ");
8406
8407 strcat (buff, "INFO ");
8408 }
8409
8410 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8411 strcat (buff, _("| <unknown>"));
252b5132
RH		 8412
8413 return buff;
8414}
8415
8416/* Display the contents of the version sections. */
98fb390a 8417
252b5132 8418static int
2cf0635d 8419process_version_sections (FILE * file)
252b5132 8420{
2cf0635d 8421 Elf_Internal_Shdr * section;
b34976b6
AM		 8422 unsigned i;
8423 int found = 0;
252b5132
RH		 8424
8425 if (! do_version)
8426 return 1;
8427
8428 for (i = 0, section = section_headers;
8429 i < elf_header.e_shnum;
b34976b6 8430 i++, section++)
252b5132
RH		 8431 {
8432 switch (section->sh_type)
8433 {
8434 case SHT_GNU_verdef:
8435 {
2cf0635d 8436 Elf_External_Verdef * edefs;
b34976b6
AM		 8437 unsigned int idx;
8438 unsigned int cnt;
2cf0635d 8439 char * endbuf;
252b5132
RH		 8440
8441 found = 1;
8442
8443 printf
72de5009 8444 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8445 SECTION_NAME (section), section->sh_info);
8446
8447 printf (_(" Addr: 0x"));
8448 printf_vma (section->sh_addr);
72de5009 8449 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8450 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8451 section->sh_link < elf_header.e_shnum
8452 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8453 : _("<corrupt>"));
252b5132 8454
3f5e193b
NC		 8455 edefs = (Elf_External_Verdef *)
8456 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8457 _("version definition section"));
a6e9f9df
AM		 8458 if (!edefs)
8459 break;
59245841 8460 endbuf = (char *) edefs + section->sh_size;
252b5132 8461
b34976b6 8462 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8463 {
2cf0635d
NC		 8464 char * vstart;
8465 Elf_External_Verdef * edef;
b34976b6 8466 Elf_Internal_Verdef ent;
2cf0635d 8467 Elf_External_Verdaux * eaux;
b34976b6
AM		 8468 Elf_Internal_Verdaux aux;
8469 int j;
8470 int isum;
103f02d3 8471
dd24e3da
NC		 8472 /* Check for negative or very large indicies. */
8473 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8474 break;
8475
252b5132 8476 vstart = ((char *) edefs) + idx;
54806181
AM		 8477 if (vstart + sizeof (*edef) > endbuf)
8478 break;
252b5132
RH		 8479
8480 edef = (Elf_External_Verdef *) vstart;
8481
8482 ent.vd_version = BYTE_GET (edef->vd_version);
8483 ent.vd_flags = BYTE_GET (edef->vd_flags);
8484 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8485 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8486 ent.vd_hash = BYTE_GET (edef->vd_hash);
8487 ent.vd_aux = BYTE_GET (edef->vd_aux);
8488 ent.vd_next = BYTE_GET (edef->vd_next);
8489
8490 printf (_(" %#06x: Rev: %d Flags: %s"),
8491 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8492
8493 printf (_(" Index: %d Cnt: %d "),
8494 ent.vd_ndx, ent.vd_cnt);
8495
dd24e3da
NC		 8496 /* Check for overflow. */
8497 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8498 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8499 break;
8500
252b5132
RH		 8501 vstart += ent.vd_aux;
8502
8503 eaux = (Elf_External_Verdaux *) vstart;
8504
8505 aux.vda_name = BYTE_GET (eaux->vda_name);
8506 aux.vda_next = BYTE_GET (eaux->vda_next);
8507
d79b3d50
NC		 8508 if (VALID_DYNAMIC_NAME (aux.vda_name))
8509 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8510 else
8511 printf (_("Name index: %ld\n"), aux.vda_name);
8512
8513 isum = idx + ent.vd_aux;
8514
b34976b6 8515 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8516 {
dd24e3da
NC		 8517 /* Check for overflow. */
8518 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8519 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8520 break;
8521
252b5132
RH		 8522 isum += aux.vda_next;
8523 vstart += aux.vda_next;
8524
8525 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8526 if (vstart + sizeof (*eaux) > endbuf)
8527 break;
252b5132
RH		 8528
8529 aux.vda_name = BYTE_GET (eaux->vda_name);
8530 aux.vda_next = BYTE_GET (eaux->vda_next);
8531
d79b3d50 8532 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8533 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8534 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8535 else
8536 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8537 isum, j, aux.vda_name);
8538 }
dd24e3da 8539
54806181
AM		 8540 if (j < ent.vd_cnt)
8541 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8542
8543 idx += ent.vd_next;
8544 }
dd24e3da 8545
54806181
AM		 8546 if (cnt < section->sh_info)
8547 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8548
8549 free (edefs);
8550 }
8551 break;
103f02d3 8552
252b5132
RH		 8553 case SHT_GNU_verneed:
8554 {
2cf0635d 8555 Elf_External_Verneed * eneed;
b34976b6
AM		 8556 unsigned int idx;
8557 unsigned int cnt;
2cf0635d 8558 char * endbuf;
252b5132
RH		 8559
8560 found = 1;
8561
72de5009 8562 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8563 SECTION_NAME (section), section->sh_info);
8564
8565 printf (_(" Addr: 0x"));
8566 printf_vma (section->sh_addr);
72de5009 8567 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8568 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8569 section->sh_link < elf_header.e_shnum
8570 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8571 : _("<corrupt>"));
252b5132 8572
3f5e193b
NC		 8573 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8574 section->sh_offset, 1,
8575 section->sh_size,
9cf03b7e 8576 _("Version Needs section"));
a6e9f9df
AM		 8577 if (!eneed)
8578 break;
59245841 8579 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8580
8581 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8582 {
2cf0635d 8583 Elf_External_Verneed * entry;
b34976b6
AM		 8584 Elf_Internal_Verneed ent;
8585 int j;
8586 int isum;
2cf0635d 8587 char * vstart;
252b5132 8588
dd24e3da
NC		 8589 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8590 break;
8591
252b5132 8592 vstart = ((char *) eneed) + idx;
54806181
AM		 8593 if (vstart + sizeof (*entry) > endbuf)
8594 break;
252b5132
RH		 8595
8596 entry = (Elf_External_Verneed *) vstart;
8597
8598 ent.vn_version = BYTE_GET (entry->vn_version);
8599 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8600 ent.vn_file = BYTE_GET (entry->vn_file);
8601 ent.vn_aux = BYTE_GET (entry->vn_aux);
8602 ent.vn_next = BYTE_GET (entry->vn_next);
8603
8604 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8605
d79b3d50
NC		 8606 if (VALID_DYNAMIC_NAME (ent.vn_file))
8607 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8608 else
8609 printf (_(" File: %lx"), ent.vn_file);
8610
8611 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8612
dd24e3da
NC		 8613 /* Check for overflow. */
8614 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8615 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8616 break;
8617
252b5132
RH		 8618 vstart += ent.vn_aux;
8619
8620 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8621 {
2cf0635d 8622 Elf_External_Vernaux * eaux;
b34976b6 8623 Elf_Internal_Vernaux aux;
252b5132 8624
54806181
AM		 8625 if (vstart + sizeof (*eaux) > endbuf)
8626 break;
252b5132
RH		 8627 eaux = (Elf_External_Vernaux *) vstart;
8628
8629 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8630 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8631 aux.vna_other = BYTE_GET (eaux->vna_other);
8632 aux.vna_name = BYTE_GET (eaux->vna_name);
8633 aux.vna_next = BYTE_GET (eaux->vna_next);
8634
d79b3d50 8635 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8636 printf (_(" %#06x: Name: %s"),
d79b3d50 8637 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8638 else
ecc2063b 8639 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8640 isum, aux.vna_name);
8641
8642 printf (_(" Flags: %s Version: %d\n"),
8643 get_ver_flags (aux.vna_flags), aux.vna_other);
8644
dd24e3da
NC		 8645 /* Check for overflow. */
8646 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8647 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8648 break;
8649
252b5132
RH		 8650 isum += aux.vna_next;
8651 vstart += aux.vna_next;
8652 }
9cf03b7e 8653
54806181 8654 if (j < ent.vn_cnt)
9cf03b7e 8655 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8656
8657 idx += ent.vn_next;
8658 }
9cf03b7e 8659
54806181 8660 if (cnt < section->sh_info)
9cf03b7e 8661 warn (_("Missing Version Needs information\n"));
103f02d3 8662
252b5132
RH		 8663 free (eneed);
8664 }
8665 break;
8666
8667 case SHT_GNU_versym:
8668 {
2cf0635d 8669 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8670 int total;
8671 int cnt;
2cf0635d
NC		 8672 unsigned char * edata;
8673 unsigned short * data;
8674 char * strtab;
8675 Elf_Internal_Sym * symbols;
8676 Elf_Internal_Shdr * string_sec;
ba5cdace 8677 unsigned long num_syms;
d3ba0551 8678 long off;
252b5132 8679
4fbb74a6 8680 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8681 break;
8682
4fbb74a6 8683 link_section = section_headers + section->sh_link;
08d8fa11 8684 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8685
4fbb74a6 8686 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8687 break;
8688
252b5132
RH		 8689 found = 1;
8690
ba5cdace 8691 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 8692 if (symbols == NULL)
8693 break;
252b5132 8694
4fbb74a6 8695 string_sec = section_headers + link_section->sh_link;
252b5132 8696
3f5e193b
NC		 8697 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8698 string_sec->sh_size,
8699 _("version string table"));
a6e9f9df 8700 if (!strtab)
0429c154
MS		 8701 {
8702 free (symbols);
8703 break;
8704 }
252b5132
RH		 8705
8706 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8707 SECTION_NAME (section), total);
8708
8709 printf (_(" Addr: "));
8710 printf_vma (section->sh_addr);
72de5009 8711 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8712 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8713 SECTION_NAME (link_section));
8714
d3ba0551
AM		 8715 off = offset_from_vma (file,
8716 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8717 total * sizeof (short));
3f5e193b
NC		 8718 edata = (unsigned char *) get_data (NULL, file, off, total,
8719 sizeof (short),
8720 _("version symbol data"));
a6e9f9df
AM		 8721 if (!edata)
8722 {
8723 free (strtab);
0429c154 8724 free (symbols);
a6e9f9df
AM		 8725 break;
8726 }
252b5132 8727
3f5e193b 8728 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8729
8730 for (cnt = total; cnt --;)
b34976b6
AM		 8731 data[cnt] = byte_get (edata + cnt * sizeof (short),
8732 sizeof (short));
252b5132
RH		 8733
8734 free (edata);
8735
8736 for (cnt = 0; cnt < total; cnt += 4)
8737 {
8738 int j, nn;
00d93f34 8739 int check_def, check_need;
2cf0635d 8740 char * name;
252b5132
RH		 8741
8742 printf (" %03x:", cnt);
8743
8744 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8745 switch (data[cnt + j])
252b5132
RH		 8746 {
8747 case 0:
8748 fputs (_(" 0 (*local*) "), stdout);
8749 break;
8750
8751 case 1:
8752 fputs (_(" 1 (*global*) "), stdout);
8753 break;
8754
8755 default:
c244d050
NC		 8756 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8757 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8758
dd24e3da 8759 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 8760 array, break to avoid an out-of-bounds read. */
8761 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 8762 {
8763 warn (_("invalid index into symbol array\n"));
8764 break;
8765 }
8766
00d93f34
JJ		 8767 check_def = 1;
8768 check_need = 1;
4fbb74a6
AM		 8769 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8770 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8771 != SHT_NOBITS)
252b5132 8772 {
b34976b6 8773 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8774 check_def = 0;
8775 else
8776 check_need = 0;
252b5132 8777 }
00d93f34
JJ		 8778
8779 if (check_need
b34976b6 8780 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8781 {
b34976b6
AM		 8782 Elf_Internal_Verneed ivn;
8783 unsigned long offset;
252b5132 8784
d93f0186
NC		 8785 offset = offset_from_vma
8786 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8787 sizeof (Elf_External_Verneed));
252b5132 8788
b34976b6 8789 do
252b5132 8790 {
b34976b6
AM		 8791 Elf_Internal_Vernaux ivna;
8792 Elf_External_Verneed evn;
8793 Elf_External_Vernaux evna;
8794 unsigned long a_off;
252b5132 8795
59245841
NC		 8796 if (get_data (&evn, file, offset, sizeof (evn), 1,
8797 _("version need")) == NULL)
8798 break;
8799
252b5132
RH		 8800 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8801 ivn.vn_next = BYTE_GET (evn.vn_next);
8802
8803 a_off = offset + ivn.vn_aux;
8804
8805 do
8806 {
59245841
NC		 8807 if (get_data (&evna, file, a_off, sizeof (evna),
8808 1, _("version need aux (2)")) == NULL)
8809 {
8810 ivna.vna_next = 0;
8811 ivna.vna_other = 0;
8812 }
8813 else
8814 {
8815 ivna.vna_next = BYTE_GET (evna.vna_next);
8816 ivna.vna_other = BYTE_GET (evna.vna_other);
8817 }
252b5132
RH		 8818
8819 a_off += ivna.vna_next;
8820 }
b34976b6 8821 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8822 && ivna.vna_next != 0);
8823
b34976b6 8824 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8825 {
8826 ivna.vna_name = BYTE_GET (evna.vna_name);
8827
54806181
AM		 8828 if (ivna.vna_name >= string_sec->sh_size)
8829 name = _("*invalid*");
8830 else
8831 name = strtab + ivna.vna_name;
252b5132 8832 nn += printf ("(%s%-*s",
16062207
ILT		 8833 name,
8834 12 - (int) strlen (name),
252b5132 8835 ")");
00d93f34 8836 check_def = 0;
252b5132
RH		 8837 break;
8838 }
8839
8840 offset += ivn.vn_next;
8841 }
8842 while (ivn.vn_next);
8843 }
00d93f34 8844
b34976b6
AM		 8845 if (check_def && data[cnt + j] != 0x8001
8846 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8847 {
b34976b6
AM		 8848 Elf_Internal_Verdef ivd;
8849 Elf_External_Verdef evd;
8850 unsigned long offset;
252b5132 8851
d93f0186
NC		 8852 offset = offset_from_vma
8853 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8854 sizeof evd);
252b5132
RH		 8855
8856 do
8857 {
59245841
NC		 8858 if (get_data (&evd, file, offset, sizeof (evd), 1,
8859 _("version def")) == NULL)
8860 {
8861 ivd.vd_next = 0;
8862 ivd.vd_ndx = 0;
8863 }
8864 else
8865 {
8866 ivd.vd_next = BYTE_GET (evd.vd_next);
8867 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8868 }
252b5132
RH		 8869
8870 offset += ivd.vd_next;
8871 }
c244d050 8872 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8873 && ivd.vd_next != 0);
8874
c244d050 8875 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8876 {
b34976b6
AM		 8877 Elf_External_Verdaux evda;
8878 Elf_Internal_Verdaux ivda;
252b5132
RH		 8879
8880 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8881
59245841
NC		 8882 if (get_data (&evda, file,
8883 offset - ivd.vd_next + ivd.vd_aux,
8884 sizeof (evda), 1,
8885 _("version def aux")) == NULL)
8886 break;
252b5132
RH		 8887
8888 ivda.vda_name = BYTE_GET (evda.vda_name);
8889
54806181
AM		 8890 if (ivda.vda_name >= string_sec->sh_size)
8891 name = _("*invalid*");
8892 else
8893 name = strtab + ivda.vda_name;
252b5132 8894 nn += printf ("(%s%-*s",
16062207
ILT		 8895 name,
8896 12 - (int) strlen (name),
252b5132
RH		 8897 ")");
8898 }
8899 }
8900
8901 if (nn < 18)
8902 printf ("%*c", 18 - nn, ' ');
8903 }
8904
8905 putchar ('\n');
8906 }
8907
8908 free (data);
8909 free (strtab);
8910 free (symbols);
8911 }
8912 break;
103f02d3 8913
252b5132
RH		 8914 default:
8915 break;
8916 }
8917 }
8918
8919 if (! found)
8920 printf (_("\nNo version information found in this file.\n"));
8921
8922 return 1;
8923}
8924
d1133906 8925static const char *
d3ba0551 8926get_symbol_binding (unsigned int binding)
252b5132 8927{
b34976b6 8928 static char buff[32];
252b5132
RH		 8929
8930 switch (binding)
8931 {
b34976b6
AM		 8932 case STB_LOCAL: return "LOCAL";
8933 case STB_GLOBAL: return "GLOBAL";
8934 case STB_WEAK: return "WEAK";
252b5132
RH		 8935 default:
8936 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8937 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8938 binding);
252b5132 8939 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8940 {
8941 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8942 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8943 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8944 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8945 return "UNIQUE";
8946 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8947 }
252b5132 8948 else
e9e44622 8949 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8950 return buff;
8951 }
8952}
8953
d1133906 8954static const char *
d3ba0551 8955get_symbol_type (unsigned int type)
252b5132 8956{
b34976b6 8957 static char buff[32];
252b5132
RH		 8958
8959 switch (type)
8960 {
b34976b6
AM		 8961 case STT_NOTYPE: return "NOTYPE";
8962 case STT_OBJECT: return "OBJECT";
8963 case STT_FUNC: return "FUNC";
8964 case STT_SECTION: return "SECTION";
8965 case STT_FILE: return "FILE";
8966 case STT_COMMON: return "COMMON";
8967 case STT_TLS: return "TLS";
15ab5209
DB		 8968 case STT_RELC: return "RELC";
8969 case STT_SRELC: return "SRELC";
252b5132
RH		 8970 default:
8971 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8972 {
8973 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8974 return "THUMB_FUNC";
8975
351b4b40 8976 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8977 return "REGISTER";
8978
8979 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8980 return "PARISC_MILLI";
8981
e9e44622 8982 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8983 }
252b5132 8984 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8985 {
8986 if (elf_header.e_machine == EM_PARISC)
8987 {
8988 if (type == STT_HP_OPAQUE)
8989 return "HP_OPAQUE";
8990 if (type == STT_HP_STUB)
8991 return "HP_STUB";
8992 }
8993
d8045f23 8994 if (type == STT_GNU_IFUNC
9c55345c 8995 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 8996 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 8997 /* GNU is still using the default value 0. */
d8045f23
NC		 8998 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8999 return "IFUNC";
9000
e9e44622 9001 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9002 }
252b5132 9003 else
e9e44622 9004 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9005 return buff;
9006 }
9007}
9008
d1133906 9009static const char *
d3ba0551 9010get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9011{
9012 switch (visibility)
9013 {
b34976b6
AM		 9014 case STV_DEFAULT: return "DEFAULT";
9015 case STV_INTERNAL: return "INTERNAL";
9016 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9017 case STV_PROTECTED: return "PROTECTED";
9018 default: abort ();
9019 }
9020}
9021
5e2b0d47
NC		 9022static const char *
9023get_mips_symbol_other (unsigned int other)
9024{
9025 switch (other)
9026 {
df58fc94
RS		 9027 case STO_OPTIONAL:
9028 return "OPTIONAL";
9029 case STO_MIPS_PLT:
9030 return "MIPS PLT";
9031 case STO_MIPS_PIC:
9032 return "MIPS PIC";
9033 case STO_MICROMIPS:
9034 return "MICROMIPS";
9035 case STO_MICROMIPS | STO_MIPS_PIC:
9036 return "MICROMIPS, MIPS PIC";
9037 case STO_MIPS16:
9038 return "MIPS16";
9039 default:
9040 return NULL;
5e2b0d47
NC		 9041 }
9042}
9043
28f997cf
TG		 9044static const char *
9045get_ia64_symbol_other (unsigned int other)
9046{
9047 if (is_ia64_vms ())
9048 {
9049 static char res[32];
9050
9051 res[0] = 0;
9052
9053 /* Function types is for images and .STB files only. */
9054 switch (elf_header.e_type)
9055 {
9056 case ET_DYN:
9057 case ET_EXEC:
9058 switch (VMS_ST_FUNC_TYPE (other))
9059 {
9060 case VMS_SFT_CODE_ADDR:
9061 strcat (res, " CA");
9062 break;
9063 case VMS_SFT_SYMV_IDX:
9064 strcat (res, " VEC");
9065 break;
9066 case VMS_SFT_FD:
9067 strcat (res, " FD");
9068 break;
9069 case VMS_SFT_RESERVE:
9070 strcat (res, " RSV");
9071 break;
9072 default:
9073 abort ();
9074 }
9075 break;
9076 default:
9077 break;
9078 }
9079 switch (VMS_ST_LINKAGE (other))
9080 {
9081 case VMS_STL_IGNORE:
9082 strcat (res, " IGN");
9083 break;
9084 case VMS_STL_RESERVE:
9085 strcat (res, " RSV");
9086 break;
9087 case VMS_STL_STD:
9088 strcat (res, " STD");
9089 break;
9090 case VMS_STL_LNK:
9091 strcat (res, " LNK");
9092 break;
9093 default:
9094 abort ();
9095 }
9096
9097 if (res[0] != 0)
9098 return res + 1;
9099 else
9100 return res;
9101 }
9102 return NULL;
9103}
9104
5e2b0d47
NC		 9105static const char *
9106get_symbol_other (unsigned int other)
9107{
9108 const char * result = NULL;
9109 static char buff [32];
9110
9111 if (other == 0)
9112 return "";
9113
9114 switch (elf_header.e_machine)
9115 {
9116 case EM_MIPS:
9117 result = get_mips_symbol_other (other);
28f997cf
TG		 9118 break;
9119 case EM_IA_64:
9120 result = get_ia64_symbol_other (other);
9121 break;
5e2b0d47
NC		 9122 default:
9123 break;
9124 }
9125
9126 if (result)
9127 return result;
9128
9129 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9130 return buff;
9131}
9132
d1133906 9133static const char *
d3ba0551 9134get_symbol_index_type (unsigned int type)
252b5132 9135{
b34976b6 9136 static char buff[32];
5cf1065c 9137
252b5132
RH		 9138 switch (type)
9139 {
b34976b6
AM		 9140 case SHN_UNDEF: return "UND";
9141 case SHN_ABS: return "ABS";
9142 case SHN_COMMON: return "COM";
252b5132 9143 default:
9ce701e2
L		 9144 if (type == SHN_IA_64_ANSI_COMMON
9145 && elf_header.e_machine == EM_IA_64
9146 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9147 return "ANSI_COM";
8a9036a4 9148 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9149 || elf_header.e_machine == EM_L1OM
9150 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9151 && type == SHN_X86_64_LCOMMON)
9152 return "LARGE_COM";
ac145307
BS		 9153 else if ((type == SHN_MIPS_SCOMMON
9154 && elf_header.e_machine == EM_MIPS)
9155 || (type == SHN_TIC6X_SCOMMON
9156 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9157 return "SCOM";
9158 else if (type == SHN_MIPS_SUNDEFINED
9159 && elf_header.e_machine == EM_MIPS)
9160 return "SUND";
9ce701e2 9161 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9162 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9163 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9164 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9165 else if (type >= SHN_LORESERVE)
9166 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L		 9167 else if (type >= elf_header.e_shnum)
9168 sprintf (buff, "bad section index[%3d]", type);
252b5132 9169 else
232e7cb8 9170 sprintf (buff, "%3d", type);
5cf1065c 9171 break;
252b5132 9172 }
5cf1065c
NC		 9173
9174 return buff;
252b5132
RH		 9175}
9176
66543521 9177static bfd_vma *
2cf0635d 9178get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9179{
2cf0635d
NC		 9180 unsigned char * e_data;
9181 bfd_vma * i_data;
252b5132 9182
3f5e193b 9183 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9184
9185 if (e_data == NULL)
9186 {
9187 error (_("Out of memory\n"));
9188 return NULL;
9189 }
9190
66543521 9191 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9192 {
9193 error (_("Unable to read in dynamic data\n"));
9194 return NULL;
9195 }
9196
3f5e193b 9197 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9198
9199 if (i_data == NULL)
9200 {
9201 error (_("Out of memory\n"));
9202 free (e_data);
9203 return NULL;
9204 }
9205
9206 while (number--)
66543521 9207 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9208
9209 free (e_data);
9210
9211 return i_data;
9212}
9213
6bd1a22c
L		 9214static void
9215print_dynamic_symbol (bfd_vma si, unsigned long hn)
9216{
2cf0635d 9217 Elf_Internal_Sym * psym;
6bd1a22c
L		 9218 int n;
9219
9220 psym = dynamic_symbols + si;
9221
9222 n = print_vma (si, DEC_5);
9223 if (n < 5)
9224 fputs (" " + n, stdout);
9225 printf (" %3lu: ", hn);
9226 print_vma (psym->st_value, LONG_HEX);
9227 putchar (' ');
9228 print_vma (psym->st_size, DEC_5);
9229
f4be36b3
AM		 9230 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9231 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9232 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9233 /* Check to see if any other bits in the st_other field are set.
9234 Note - displaying this information disrupts the layout of the
9235 table being generated, but for the moment this case is very
9236 rare. */
9237 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9238 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9239 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9240 if (VALID_DYNAMIC_NAME (psym->st_name))
9241 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9242 else
2b692964 9243 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9244 putchar ('\n');
9245}
9246
e3c8793a 9247/* Dump the symbol table. */
252b5132 9248static int
2cf0635d 9249process_symbol_table (FILE * file)
252b5132 9250{
2cf0635d 9251 Elf_Internal_Shdr * section;
66543521
AM		 9252 bfd_vma nbuckets = 0;
9253 bfd_vma nchains = 0;
2cf0635d
NC		 9254 bfd_vma * buckets = NULL;
9255 bfd_vma * chains = NULL;
fdc90cb4 9256 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9257 bfd_vma * gnubuckets = NULL;
9258 bfd_vma * gnuchains = NULL;
6bd1a22c 9259 bfd_vma gnusymidx = 0;
252b5132 9260
2c610e4b 9261 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9262 return 1;
9263
6bd1a22c
L		 9264 if (dynamic_info[DT_HASH]
9265 && (do_histogram
2c610e4b
L		 9266 || (do_using_dynamic
9267 && !do_dyn_syms
9268 && dynamic_strings != NULL)))
252b5132 9269 {
66543521
AM		 9270 unsigned char nb[8];
9271 unsigned char nc[8];
9272 int hash_ent_size = 4;
9273
9274 if ((elf_header.e_machine == EM_ALPHA
9275 || elf_header.e_machine == EM_S390
9276 || elf_header.e_machine == EM_S390_OLD)
9277 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9278 hash_ent_size = 8;
9279
fb52b2f4
NC		 9280 if (fseek (file,
9281 (archive_file_offset
9282 + offset_from_vma (file, dynamic_info[DT_HASH],
9283 sizeof nb + sizeof nc)),
d93f0186 9284 SEEK_SET))
252b5132 9285 {
591a748a 9286 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9287 goto no_hash;
252b5132
RH		 9288 }
9289
66543521 9290 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9291 {
9292 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9293 goto no_hash;
252b5132
RH		 9294 }
9295
66543521 9296 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9297 {
9298 error (_("Failed to read in number of chains\n"));
d3a44ec6 9299 goto no_hash;
252b5132
RH		 9300 }
9301
66543521
AM		 9302 nbuckets = byte_get (nb, hash_ent_size);
9303 nchains = byte_get (nc, hash_ent_size);
252b5132 9304
66543521
AM		 9305 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9306 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9307
d3a44ec6 9308 no_hash:
252b5132 9309 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9310 {
9311 if (do_using_dynamic)
9312 return 0;
9313 free (buckets);
9314 free (chains);
9315 buckets = NULL;
9316 chains = NULL;
9317 nbuckets = 0;
9318 nchains = 0;
9319 }
252b5132
RH		 9320 }
9321
6bd1a22c
L		 9322 if (dynamic_info_DT_GNU_HASH
9323 && (do_histogram
2c610e4b
L		 9324 || (do_using_dynamic
9325 && !do_dyn_syms
9326 && dynamic_strings != NULL)))
252b5132 9327 {
6bd1a22c
L		 9328 unsigned char nb[16];
9329 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9330 bfd_vma buckets_vma;
9331
9332 if (fseek (file,
9333 (archive_file_offset
9334 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9335 sizeof nb)),
9336 SEEK_SET))
9337 {
9338 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9339 goto no_gnu_hash;
6bd1a22c 9340 }
252b5132 9341
6bd1a22c
L		 9342 if (fread (nb, 16, 1, file) != 1)
9343 {
9344 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9345 goto no_gnu_hash;
6bd1a22c
L		 9346 }
9347
9348 ngnubuckets = byte_get (nb, 4);
9349 gnusymidx = byte_get (nb + 4, 4);
9350 bitmaskwords = byte_get (nb + 8, 4);
9351 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9352 if (is_32bit_elf)
6bd1a22c 9353 buckets_vma += bitmaskwords * 4;
f7a99963 9354 else
6bd1a22c 9355 buckets_vma += bitmaskwords * 8;
252b5132 9356
6bd1a22c
L		 9357 if (fseek (file,
9358 (archive_file_offset
9359 + offset_from_vma (file, buckets_vma, 4)),
9360 SEEK_SET))
252b5132 9361 {
6bd1a22c 9362 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9363 goto no_gnu_hash;
6bd1a22c
L		 9364 }
9365
9366 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9367
6bd1a22c 9368 if (gnubuckets == NULL)
d3a44ec6 9369 goto no_gnu_hash;
6bd1a22c
L		 9370
9371 for (i = 0; i < ngnubuckets; i++)
9372 if (gnubuckets[i] != 0)
9373 {
9374 if (gnubuckets[i] < gnusymidx)
9375 return 0;
9376
9377 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9378 maxchain = gnubuckets[i];
9379 }
9380
9381 if (maxchain == 0xffffffff)
d3a44ec6 9382 goto no_gnu_hash;
6bd1a22c
L		 9383
9384 maxchain -= gnusymidx;
9385
9386 if (fseek (file,
9387 (archive_file_offset
9388 + offset_from_vma (file, buckets_vma
9389 + 4 * (ngnubuckets + maxchain), 4)),
9390 SEEK_SET))
9391 {
9392 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9393 goto no_gnu_hash;
6bd1a22c
L		 9394 }
9395
9396 do
9397 {
9398 if (fread (nb, 4, 1, file) != 1)
252b5132 9399 {
6bd1a22c 9400 error (_("Failed to determine last chain length\n"));
d3a44ec6 9401 goto no_gnu_hash;
6bd1a22c 9402 }
252b5132 9403
6bd1a22c 9404 if (maxchain + 1 == 0)
d3a44ec6 9405 goto no_gnu_hash;
252b5132 9406
6bd1a22c
L		 9407 ++maxchain;
9408 }
9409 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9410
6bd1a22c
L		 9411 if (fseek (file,
9412 (archive_file_offset
9413 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9414 SEEK_SET))
9415 {
9416 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9417 goto no_gnu_hash;
6bd1a22c
L		 9418 }
9419
9420 gnuchains = get_dynamic_data (file, maxchain, 4);
9421
d3a44ec6 9422 no_gnu_hash:
6bd1a22c 9423 if (gnuchains == NULL)
d3a44ec6
JJ		 9424 {
9425 free (gnubuckets);
d3a44ec6
JJ		 9426 gnubuckets = NULL;
9427 ngnubuckets = 0;
f64fddf1
NC		 9428 if (do_using_dynamic)
9429 return 0;
d3a44ec6 9430 }
6bd1a22c
L		 9431 }
9432
9433 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9434 && do_syms
9435 && do_using_dynamic
9436 && dynamic_strings != NULL)
9437 {
9438 unsigned long hn;
9439
9440 if (dynamic_info[DT_HASH])
9441 {
9442 bfd_vma si;
9443
9444 printf (_("\nSymbol table for image:\n"));
9445 if (is_32bit_elf)
9446 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9447 else
9448 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9449
9450 for (hn = 0; hn < nbuckets; hn++)
9451 {
9452 if (! buckets[hn])
9453 continue;
9454
9455 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9456 print_dynamic_symbol (si, hn);
252b5132
RH		 9457 }
9458 }
6bd1a22c
L		 9459
9460 if (dynamic_info_DT_GNU_HASH)
9461 {
9462 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9463 if (is_32bit_elf)
9464 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9465 else
9466 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9467
9468 for (hn = 0; hn < ngnubuckets; ++hn)
9469 if (gnubuckets[hn] != 0)
9470 {
9471 bfd_vma si = gnubuckets[hn];
9472 bfd_vma off = si - gnusymidx;
9473
9474 do
9475 {
9476 print_dynamic_symbol (si, hn);
9477 si++;
9478 }
9479 while ((gnuchains[off++] & 1) == 0);
9480 }
9481 }
252b5132 9482 }
2c610e4b 9483 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9484 {
b34976b6 9485 unsigned int i;
252b5132
RH		 9486
9487 for (i = 0, section = section_headers;
9488 i < elf_header.e_shnum;
9489 i++, section++)
9490 {
b34976b6 9491 unsigned int si;
2cf0635d 9492 char * strtab = NULL;
c256ffe7 9493 unsigned long int strtab_size = 0;
2cf0635d
NC		 9494 Elf_Internal_Sym * symtab;
9495 Elf_Internal_Sym * psym;
ba5cdace 9496 unsigned long num_syms;
252b5132 9497
2c610e4b
L		 9498 if ((section->sh_type != SHT_SYMTAB
9499 && section->sh_type != SHT_DYNSYM)
9500 || (!do_syms
9501 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9502 continue;
9503
dd24e3da
NC		 9504 if (section->sh_entsize == 0)
9505 {
9506 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9507 SECTION_NAME (section));
9508 continue;
9509 }
9510
252b5132
RH		 9511 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9512 SECTION_NAME (section),
9513 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9514
f7a99963 9515 if (is_32bit_elf)
ca47b30c 9516 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9517 else
ca47b30c 9518 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9519
ba5cdace 9520 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9521 if (symtab == NULL)
9522 continue;
9523
9524 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9525 {
9526 strtab = string_table;
9527 strtab_size = string_table_length;
9528 }
4fbb74a6 9529 else if (section->sh_link < elf_header.e_shnum)
252b5132 9530 {
2cf0635d 9531 Elf_Internal_Shdr * string_sec;
252b5132 9532
4fbb74a6 9533 string_sec = section_headers + section->sh_link;
252b5132 9534
3f5e193b
NC		 9535 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9536 1, string_sec->sh_size,
9537 _("string table"));
c256ffe7 9538 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9539 }
9540
ba5cdace 9541 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9542 {
5e220199 9543 printf ("%6d: ", si);
f7a99963
NC		 9544 print_vma (psym->st_value, LONG_HEX);
9545 putchar (' ');
9546 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9547 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9548 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9549 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9550 /* Check to see if any other bits in the st_other field are set.
9551 Note - displaying this information disrupts the layout of the
9552 table being generated, but for the moment this case is very rare. */
9553 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9554 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9555 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9556 print_symbol (25, psym->st_name < strtab_size
2b692964 9557 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9558
59245841
NC		 9559 if (section->sh_type == SHT_DYNSYM
9560 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9561 {
b34976b6
AM		 9562 unsigned char data[2];
9563 unsigned short vers_data;
9564 unsigned long offset;
9565 int is_nobits;
9566 int check_def;
252b5132 9567
d93f0186
NC		 9568 offset = offset_from_vma
9569 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9570 sizeof data + si * sizeof (vers_data));
252b5132 9571
59245841
NC		 9572 if (get_data (&data, file, offset + si * sizeof (vers_data),
9573 sizeof (data), 1, _("version data")) == NULL)
9574 break;
252b5132
RH		 9575
9576 vers_data = byte_get (data, 2);
9577
4fbb74a6
AM		 9578 is_nobits = (psym->st_shndx < elf_header.e_shnum
9579 && section_headers[psym->st_shndx].sh_type
c256ffe7 9580 == SHT_NOBITS);
252b5132
RH		 9581
9582 check_def = (psym->st_shndx != SHN_UNDEF);
9583
c244d050 9584 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9585 {
b34976b6 9586 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9587 && (is_nobits || ! check_def))
252b5132 9588 {
b34976b6
AM		 9589 Elf_External_Verneed evn;
9590 Elf_Internal_Verneed ivn;
9591 Elf_Internal_Vernaux ivna;
252b5132
RH		 9592
9593 /* We must test both. */
d93f0186
NC		 9594 offset = offset_from_vma
9595 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9596 sizeof evn);
252b5132 9597
252b5132
RH		 9598 do
9599 {
b34976b6 9600 unsigned long vna_off;
252b5132 9601
59245841
NC		 9602 if (get_data (&evn, file, offset, sizeof (evn), 1,
9603 _("version need")) == NULL)
9604 {
9605 ivna.vna_next = 0;
9606 ivna.vna_other = 0;
9607 ivna.vna_name = 0;
9608 break;
9609 }
dd27201e
L		 9610
9611 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9612 ivn.vn_next = BYTE_GET (evn.vn_next);
9613
252b5132
RH		 9614 vna_off = offset + ivn.vn_aux;
9615
9616 do
9617 {
b34976b6 9618 Elf_External_Vernaux evna;
252b5132 9619
59245841
NC		 9620 if (get_data (&evna, file, vna_off,
9621 sizeof (evna), 1,
9622 _("version need aux (3)")) == NULL)
9623 {
9624 ivna.vna_next = 0;
9625 ivna.vna_other = 0;
9626 ivna.vna_name = 0;
9627 }
9628 else
9629 {
9630 ivna.vna_other = BYTE_GET (evna.vna_other);
9631 ivna.vna_next = BYTE_GET (evna.vna_next);
9632 ivna.vna_name = BYTE_GET (evna.vna_name);
9633 }
252b5132
RH		 9634
9635 vna_off += ivna.vna_next;
9636 }
9637 while (ivna.vna_other != vers_data
9638 && ivna.vna_next != 0);
9639
9640 if (ivna.vna_other == vers_data)
9641 break;
9642
9643 offset += ivn.vn_next;
9644 }
9645 while (ivn.vn_next != 0);
9646
9647 if (ivna.vna_other == vers_data)
9648 {
9649 printf ("@%s (%d)",
c256ffe7 9650 ivna.vna_name < strtab_size
2b692964 9651 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9652 ivna.vna_other);
252b5132
RH		 9653 check_def = 0;
9654 }
9655 else if (! is_nobits)
591a748a 9656 error (_("bad dynamic symbol\n"));
252b5132
RH		 9657 else
9658 check_def = 1;
9659 }
9660
9661 if (check_def)
9662 {
00d93f34 9663 if (vers_data != 0x8001
b34976b6 9664 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9665 {
b34976b6
AM		 9666 Elf_Internal_Verdef ivd;
9667 Elf_Internal_Verdaux ivda;
9668 Elf_External_Verdaux evda;
91d6fa6a 9669 unsigned long off;
252b5132 9670
91d6fa6a 9671 off = offset_from_vma
d93f0186
NC		 9672 (file,
9673 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9674 sizeof (Elf_External_Verdef));
252b5132
RH		 9675
9676 do
9677 {
b34976b6 9678 Elf_External_Verdef evd;
252b5132 9679
59245841
NC		 9680 if (get_data (&evd, file, off, sizeof (evd),
9681 1, _("version def")) == NULL)
9682 {
9683 ivd.vd_ndx = 0;
9684 ivd.vd_aux = 0;
9685 ivd.vd_next = 0;
9686 }
9687 else
9688 {
9689 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9690 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9691 ivd.vd_next = BYTE_GET (evd.vd_next);
9692 }
252b5132 9693
91d6fa6a 9694 off += ivd.vd_next;
252b5132 9695 }
c244d050 9696 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9697 && ivd.vd_next != 0);
9698
91d6fa6a
NC		 9699 off -= ivd.vd_next;
9700 off += ivd.vd_aux;
252b5132 9701
59245841
NC		 9702 if (get_data (&evda, file, off, sizeof (evda),
9703 1, _("version def aux")) == NULL)
9704 break;
252b5132
RH		 9705
9706 ivda.vda_name = BYTE_GET (evda.vda_name);
9707
9708 if (psym->st_name != ivda.vda_name)
c244d050 9709 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9710 ? "@%s" : "@@%s",
c256ffe7 9711 ivda.vda_name < strtab_size
2b692964 9712 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9713 }
9714 }
9715 }
9716 }
9717
9718 putchar ('\n');
9719 }
9720
9721 free (symtab);
9722 if (strtab != string_table)
9723 free (strtab);
9724 }
9725 }
9726 else if (do_syms)
9727 printf
9728 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9729
9730 if (do_histogram && buckets != NULL)
9731 {
2cf0635d
NC		 9732 unsigned long * lengths;
9733 unsigned long * counts;
66543521
AM		 9734 unsigned long hn;
9735 bfd_vma si;
9736 unsigned long maxlength = 0;
9737 unsigned long nzero_counts = 0;
9738 unsigned long nsyms = 0;
252b5132 9739
66543521
AM		 9740 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9741 (unsigned long) nbuckets);
252b5132
RH		 9742 printf (_(" Length Number %% of total Coverage\n"));
9743
3f5e193b 9744 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9745 if (lengths == NULL)
9746 {
591a748a 9747 error (_("Out of memory\n"));
252b5132
RH		 9748 return 0;
9749 }
9750 for (hn = 0; hn < nbuckets; ++hn)
9751 {
f7a99963 9752 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9753 {
b34976b6 9754 ++nsyms;
252b5132 9755 if (maxlength < ++lengths[hn])
b34976b6 9756 ++maxlength;
252b5132
RH		 9757 }
9758 }
9759
3f5e193b 9760 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9761 if (counts == NULL)
9762 {
591a748a 9763 error (_("Out of memory\n"));
252b5132
RH		 9764 return 0;
9765 }
9766
9767 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9768 ++counts[lengths[hn]];
252b5132 9769
103f02d3 9770 if (nbuckets > 0)
252b5132 9771 {
66543521
AM		 9772 unsigned long i;
9773 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9774 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9775 for (i = 1; i <= maxlength; ++i)
103f02d3 9776 {
66543521
AM		 9777 nzero_counts += counts[i] * i;
9778 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9779 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9780 (nzero_counts * 100.0) / nsyms);
9781 }
252b5132
RH		 9782 }
9783
9784 free (counts);
9785 free (lengths);
9786 }
9787
9788 if (buckets != NULL)
9789 {
9790 free (buckets);
9791 free (chains);
9792 }
9793
d3a44ec6 9794 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9795 {
2cf0635d
NC		 9796 unsigned long * lengths;
9797 unsigned long * counts;
fdc90cb4
JJ		 9798 unsigned long hn;
9799 unsigned long maxlength = 0;
9800 unsigned long nzero_counts = 0;
9801 unsigned long nsyms = 0;
fdc90cb4 9802
3f5e193b 9803 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9804 if (lengths == NULL)
9805 {
591a748a 9806 error (_("Out of memory\n"));
fdc90cb4
JJ		 9807 return 0;
9808 }
9809
9810 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9811 (unsigned long) ngnubuckets);
9812 printf (_(" Length Number %% of total Coverage\n"));
9813
9814 for (hn = 0; hn < ngnubuckets; ++hn)
9815 if (gnubuckets[hn] != 0)
9816 {
9817 bfd_vma off, length = 1;
9818
6bd1a22c 9819 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9820 (gnuchains[off] & 1) == 0; ++off)
9821 ++length;
9822 lengths[hn] = length;
9823 if (length > maxlength)
9824 maxlength = length;
9825 nsyms += length;
9826 }
9827
3f5e193b 9828 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9829 if (counts == NULL)
9830 {
591a748a 9831 error (_("Out of memory\n"));
fdc90cb4
JJ		 9832 return 0;
9833 }
9834
9835 for (hn = 0; hn < ngnubuckets; ++hn)
9836 ++counts[lengths[hn]];
9837
9838 if (ngnubuckets > 0)
9839 {
9840 unsigned long j;
9841 printf (" 0 %-10lu (%5.1f%%)\n",
9842 counts[0], (counts[0] * 100.0) / ngnubuckets);
9843 for (j = 1; j <= maxlength; ++j)
9844 {
9845 nzero_counts += counts[j] * j;
9846 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9847 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9848 (nzero_counts * 100.0) / nsyms);
9849 }
9850 }
9851
9852 free (counts);
9853 free (lengths);
9854 free (gnubuckets);
9855 free (gnuchains);
9856 }
9857
252b5132
RH		 9858 return 1;
9859}
9860
9861static int
2cf0635d 9862process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9863{
b4c96d0d 9864 unsigned int i;
252b5132
RH		 9865
9866 if (dynamic_syminfo == NULL
9867 || !do_dynamic)
9868 /* No syminfo, this is ok. */
9869 return 1;
9870
9871 /* There better should be a dynamic symbol section. */
9872 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9873 return 0;
9874
9875 if (dynamic_addr)
9876 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9877 dynamic_syminfo_offset, dynamic_syminfo_nent);
9878
9879 printf (_(" Num: Name BoundTo Flags\n"));
9880 for (i = 0; i < dynamic_syminfo_nent; ++i)
9881 {
9882 unsigned short int flags = dynamic_syminfo[i].si_flags;
9883
31104126 9884 printf ("%4d: ", i);
d79b3d50
NC		 9885 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9886 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9887 else
2b692964 9888 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9889 putchar (' ');
252b5132
RH		 9890
9891 switch (dynamic_syminfo[i].si_boundto)
9892 {
9893 case SYMINFO_BT_SELF:
9894 fputs ("SELF ", stdout);
9895 break;
9896 case SYMINFO_BT_PARENT:
9897 fputs ("PARENT ", stdout);
9898 break;
9899 default:
9900 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9901 && dynamic_syminfo[i].si_boundto < dynamic_nent
9902 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9903 {
d79b3d50 9904 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9905 putchar (' ' );
9906 }
252b5132
RH		 9907 else
9908 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9909 break;
9910 }
9911
9912 if (flags & SYMINFO_FLG_DIRECT)
9913 printf (" DIRECT");
9914 if (flags & SYMINFO_FLG_PASSTHRU)
9915 printf (" PASSTHRU");
9916 if (flags & SYMINFO_FLG_COPY)
9917 printf (" COPY");
9918 if (flags & SYMINFO_FLG_LAZYLOAD)
9919 printf (" LAZYLOAD");
9920
9921 puts ("");
9922 }
9923
9924 return 1;
9925}
9926
cf13d699
NC		 9927/* Check to see if the given reloc needs to be handled in a target specific
9928 manner. If so then process the reloc and return TRUE otherwise return
9929 FALSE. */
09c11c86 9930
cf13d699
NC		 9931static bfd_boolean
9932target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9933 unsigned char * start,
9934 Elf_Internal_Sym * symtab)
252b5132 9935{
cf13d699 9936 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9937
cf13d699 9938 switch (elf_header.e_machine)
252b5132 9939 {
cf13d699
NC		 9940 case EM_MN10300:
9941 case EM_CYGNUS_MN10300:
9942 {
9943 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9944
cf13d699
NC		 9945 switch (reloc_type)
9946 {
9947 case 34: /* R_MN10300_ALIGN */
9948 return TRUE;
9949 case 33: /* R_MN10300_SYM_DIFF */
9950 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9951 return TRUE;
9952 case 1: /* R_MN10300_32 */
9953 case 2: /* R_MN10300_16 */
9954 if (saved_sym != NULL)
9955 {
9956 bfd_vma value;
252b5132 9957
cf13d699
NC		 9958 value = reloc->r_addend
9959 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9960 - saved_sym->st_value);
252b5132 9961
cf13d699 9962 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9963
cf13d699
NC		 9964 saved_sym = NULL;
9965 return TRUE;
9966 }
9967 break;
9968 default:
9969 if (saved_sym != NULL)
9970 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9971 break;
9972 }
9973 break;
9974 }
252b5132
RH		 9975 }
9976
cf13d699 9977 return FALSE;
252b5132
RH		 9978}
9979
aca88567
NC		 9980/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9981 DWARF debug sections. This is a target specific test. Note - we do not
9982 go through the whole including-target-headers-multiple-times route, (as
9983 we have already done with <elf/h8.h>) because this would become very
9984 messy and even then this function would have to contain target specific
9985 information (the names of the relocs instead of their numeric values).
9986 FIXME: This is not the correct way to solve this problem. The proper way
9987 is to have target specific reloc sizing and typing functions created by
9988 the reloc-macros.h header, in the same way that it already creates the
9989 reloc naming functions. */
9990
9991static bfd_boolean
9992is_32bit_abs_reloc (unsigned int reloc_type)
9993{
9994 switch (elf_header.e_machine)
9995 {
41e92641
NC		 9996 case EM_386:
9997 case EM_486:
9998 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9999 case EM_68K:
10000 return reloc_type == 1; /* R_68K_32. */
10001 case EM_860:
10002 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10003 case EM_960:
10004 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10005 case EM_AARCH64:
10006 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10007 case EM_ALPHA:
137b6b5f 10008 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10009 case EM_ARC:
10010 return reloc_type == 1; /* R_ARC_32. */
10011 case EM_ARM:
10012 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10013 case EM_AVR_OLD:
aca88567
NC		 10014 case EM_AVR:
10015 return reloc_type == 1;
cfb8c092
NC		 10016 case EM_ADAPTEVA_EPIPHANY:
10017 return reloc_type == 3;
aca88567
NC		 10018 case EM_BLACKFIN:
10019 return reloc_type == 0x12; /* R_byte4_data. */
10020 case EM_CRIS:
10021 return reloc_type == 3; /* R_CRIS_32. */
10022 case EM_CR16:
10023 return reloc_type == 3; /* R_CR16_NUM32. */
10024 case EM_CRX:
10025 return reloc_type == 15; /* R_CRX_NUM32. */
10026 case EM_CYGNUS_FRV:
10027 return reloc_type == 1;
41e92641
NC		 10028 case EM_CYGNUS_D10V:
10029 case EM_D10V:
10030 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10031 case EM_CYGNUS_D30V:
10032 case EM_D30V:
10033 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10034 case EM_DLX:
10035 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10036 case EM_CYGNUS_FR30:
10037 case EM_FR30:
10038 return reloc_type == 3; /* R_FR30_32. */
10039 case EM_H8S:
10040 case EM_H8_300:
10041 case EM_H8_300H:
10042 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10043 case EM_IA_64:
10044 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10045 case EM_IP2K_OLD:
10046 case EM_IP2K:
10047 return reloc_type == 2; /* R_IP2K_32. */
10048 case EM_IQ2000:
10049 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10050 case EM_LATTICEMICO32:
10051 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10052 case EM_M32C_OLD:
aca88567
NC		 10053 case EM_M32C:
10054 return reloc_type == 3; /* R_M32C_32. */
10055 case EM_M32R:
10056 return reloc_type == 34; /* R_M32R_32_RELA. */
10057 case EM_MCORE:
10058 return reloc_type == 1; /* R_MCORE_ADDR32. */
10059 case EM_CYGNUS_MEP:
10060 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10061 case EM_METAG:
10062 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10063 case EM_MICROBLAZE:
10064 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10065 case EM_MIPS:
10066 return reloc_type == 2; /* R_MIPS_32. */
10067 case EM_MMIX:
10068 return reloc_type == 4; /* R_MMIX_32. */
10069 case EM_CYGNUS_MN10200:
10070 case EM_MN10200:
10071 return reloc_type == 1; /* R_MN10200_32. */
10072 case EM_CYGNUS_MN10300:
10073 case EM_MN10300:
10074 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10075 case EM_MOXIE:
10076 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10077 case EM_MSP430_OLD:
10078 case EM_MSP430:
10079 return reloc_type == 1; /* R_MSP43_32. */
10080 case EM_MT:
10081 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 10082 case EM_ALTERA_NIOS2:
10083 case EM_NIOS32:
10084 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 10085 case EM_OPENRISC:
10086 case EM_OR32:
10087 return reloc_type == 1; /* R_OR32_32. */
aca88567 10088 case EM_PARISC:
5fda8eca
NC		 10089 return (reloc_type == 1 /* R_PARISC_DIR32. */
10090 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10091 case EM_PJ:
10092 case EM_PJ_OLD:
10093 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10094 case EM_PPC64:
10095 return reloc_type == 1; /* R_PPC64_ADDR32. */
10096 case EM_PPC:
10097 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10098 case EM_RL78:
10099 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10100 case EM_RX:
10101 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10102 case EM_S370:
10103 return reloc_type == 1; /* R_I370_ADDR31. */
10104 case EM_S390_OLD:
10105 case EM_S390:
10106 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10107 case EM_SCORE:
10108 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10109 case EM_SH:
10110 return reloc_type == 1; /* R_SH_DIR32. */
10111 case EM_SPARC32PLUS:
10112 case EM_SPARCV9:
10113 case EM_SPARC:
10114 return reloc_type == 3 /* R_SPARC_32. */
10115 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10116 case EM_SPU:
10117 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10118 case EM_TI_C6000:
10119 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10120 case EM_TILEGX:
10121 return reloc_type == 2; /* R_TILEGX_32. */
10122 case EM_TILEPRO:
10123 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10124 case EM_CYGNUS_V850:
10125 case EM_V850:
10126 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10127 case EM_V800:
10128 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10129 case EM_VAX:
10130 return reloc_type == 1; /* R_VAX_32. */
10131 case EM_X86_64:
8a9036a4 10132 case EM_L1OM:
7a9068fe 10133 case EM_K1OM:
aca88567 10134 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10135 case EM_XC16X:
10136 case EM_C166:
10137 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10138 case EM_XGATE:
10139 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10140 case EM_XSTORMY16:
10141 return reloc_type == 1; /* R_XSTROMY16_32. */
10142 case EM_XTENSA_OLD:
10143 case EM_XTENSA:
10144 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10145 default:
10146 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10147 elf_header.e_machine);
10148 abort ();
10149 }
10150}
10151
10152/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10153 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10154
10155static bfd_boolean
10156is_32bit_pcrel_reloc (unsigned int reloc_type)
10157{
10158 switch (elf_header.e_machine)
10159 {
41e92641
NC		 10160 case EM_386:
10161 case EM_486:
3e0873ac 10162 return reloc_type == 2; /* R_386_PC32. */
aca88567 10163 case EM_68K:
3e0873ac 10164 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10165 case EM_AARCH64:
10166 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10167 case EM_ADAPTEVA_EPIPHANY:
10168 return reloc_type == 6;
aca88567
NC		 10169 case EM_ALPHA:
10170 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10171 case EM_ARM:
3e0873ac 10172 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10173 case EM_MICROBLAZE:
10174 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 10175 case EM_PARISC:
85acf597 10176 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10177 case EM_PPC:
10178 return reloc_type == 26; /* R_PPC_REL32. */
10179 case EM_PPC64:
3e0873ac 10180 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10181 case EM_S390_OLD:
10182 case EM_S390:
3e0873ac 10183 return reloc_type == 5; /* R_390_PC32. */
aca88567 10184 case EM_SH:
3e0873ac 10185 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10186 case EM_SPARC32PLUS:
10187 case EM_SPARCV9:
10188 case EM_SPARC:
3e0873ac 10189 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10190 case EM_SPU:
10191 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10192 case EM_TILEGX:
10193 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10194 case EM_TILEPRO:
10195 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10196 case EM_X86_64:
8a9036a4 10197 case EM_L1OM:
7a9068fe 10198 case EM_K1OM:
3e0873ac 10199 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10200 case EM_XTENSA_OLD:
10201 case EM_XTENSA:
10202 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10203 default:
10204 /* Do not abort or issue an error message here. Not all targets use
10205 pc-relative 32-bit relocs in their DWARF debug information and we
10206 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10207 more helpful warning message will be generated by apply_relocations
10208 anyway, so just return. */
aca88567
NC		 10209 return FALSE;
10210 }
10211}
10212
10213/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10214 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10215
10216static bfd_boolean
10217is_64bit_abs_reloc (unsigned int reloc_type)
10218{
10219 switch (elf_header.e_machine)
10220 {
a06ea964
NC		 10221 case EM_AARCH64:
10222 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10223 case EM_ALPHA:
10224 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10225 case EM_IA_64:
10226 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10227 case EM_PARISC:
10228 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10229 case EM_PPC64:
10230 return reloc_type == 38; /* R_PPC64_ADDR64. */
10231 case EM_SPARC32PLUS:
10232 case EM_SPARCV9:
10233 case EM_SPARC:
10234 return reloc_type == 54; /* R_SPARC_UA64. */
10235 case EM_X86_64:
8a9036a4 10236 case EM_L1OM:
7a9068fe 10237 case EM_K1OM:
aca88567 10238 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10239 case EM_S390_OLD:
10240 case EM_S390:
aa137e4d
NC		 10241 return reloc_type == 22; /* R_S390_64. */
10242 case EM_TILEGX:
10243 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10244 case EM_MIPS:
aa137e4d 10245 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10246 default:
10247 return FALSE;
10248 }
10249}
10250
85acf597
RH		 10251/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10252 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10253
10254static bfd_boolean
10255is_64bit_pcrel_reloc (unsigned int reloc_type)
10256{
10257 switch (elf_header.e_machine)
10258 {
a06ea964
NC		 10259 case EM_AARCH64:
10260 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10261 case EM_ALPHA:
aa137e4d 10262 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10263 case EM_IA_64:
aa137e4d 10264 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10265 case EM_PARISC:
aa137e4d 10266 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10267 case EM_PPC64:
aa137e4d 10268 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10269 case EM_SPARC32PLUS:
10270 case EM_SPARCV9:
10271 case EM_SPARC:
aa137e4d 10272 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10273 case EM_X86_64:
8a9036a4 10274 case EM_L1OM:
7a9068fe 10275 case EM_K1OM:
aa137e4d 10276 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10277 case EM_S390_OLD:
10278 case EM_S390:
aa137e4d
NC		 10279 return reloc_type == 23; /* R_S390_PC64. */
10280 case EM_TILEGX:
10281 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10282 default:
10283 return FALSE;
10284 }
10285}
10286
4dc3c23d
AM		 10287/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10288 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10289
10290static bfd_boolean
10291is_24bit_abs_reloc (unsigned int reloc_type)
10292{
10293 switch (elf_header.e_machine)
10294 {
10295 case EM_CYGNUS_MN10200:
10296 case EM_MN10200:
10297 return reloc_type == 4; /* R_MN10200_24. */
10298 default:
10299 return FALSE;
10300 }
10301}
10302
aca88567
NC		 10303/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10304 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10305
10306static bfd_boolean
10307is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10308{
10309 switch (elf_header.e_machine)
10310 {
aca88567
NC		 10311 case EM_AVR_OLD:
10312 case EM_AVR:
10313 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10314 case EM_ADAPTEVA_EPIPHANY:
10315 return reloc_type == 5;
41e92641
NC		 10316 case EM_CYGNUS_D10V:
10317 case EM_D10V:
10318 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10319 case EM_H8S:
10320 case EM_H8_300:
10321 case EM_H8_300H:
aca88567
NC		 10322 return reloc_type == R_H8_DIR16;
10323 case EM_IP2K_OLD:
10324 case EM_IP2K:
10325 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10326 case EM_M32C_OLD:
f4236fe4
DD		 10327 case EM_M32C:
10328 return reloc_type == 1; /* R_M32C_16 */
aca88567 10329 case EM_MSP430:
78c8d46c 10330 case EM_MSP430_OLD:
aca88567 10331 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 10332 case EM_ALTERA_NIOS2:
10333 case EM_NIOS32:
10334 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10335 case EM_TI_C6000:
10336 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10337 case EM_XC16X:
10338 case EM_C166:
10339 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10340 case EM_CYGNUS_MN10200:
10341 case EM_MN10200:
10342 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10343 case EM_CYGNUS_MN10300:
10344 case EM_MN10300:
10345 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10346 case EM_XGATE:
10347 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10348 default:
aca88567 10349 return FALSE;
4b78141a
NC		 10350 }
10351}
10352
2a7b2e88
JK		 10353/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10354 relocation entries (possibly formerly used for SHT_GROUP sections). */
10355
10356static bfd_boolean
10357is_none_reloc (unsigned int reloc_type)
10358{
10359 switch (elf_header.e_machine)
10360 {
cb8f3167
NC		 10361 case EM_68K: /* R_68K_NONE. */
10362 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10363 case EM_SPARC32PLUS:
10364 case EM_SPARCV9:
cb8f3167
NC		 10365 case EM_SPARC: /* R_SPARC_NONE. */
10366 case EM_MIPS: /* R_MIPS_NONE. */
10367 case EM_PARISC: /* R_PARISC_NONE. */
10368 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10369 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10370 case EM_PPC: /* R_PPC_NONE. */
10371 case EM_PPC64: /* R_PPC64_NONE. */
10372 case EM_ARM: /* R_ARM_NONE. */
10373 case EM_IA_64: /* R_IA64_NONE. */
10374 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10375 case EM_S390_OLD:
cb8f3167
NC		 10376 case EM_S390: /* R_390_NONE. */
10377 case EM_CRIS: /* R_CRIS_NONE. */
10378 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10379 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10380 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10381 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10382 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10383 case EM_M32R: /* R_M32R_NONE. */
40b36596 10384 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10385 case EM_TILEGX: /* R_TILEGX_NONE. */
10386 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10387 case EM_XC16X:
10388 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 10389 return reloc_type == 0;
a06ea964
NC		 10390 case EM_AARCH64:
10391 return reloc_type == 0 || reloc_type == 256;
58332dda
JK		 10392 case EM_XTENSA_OLD:
10393 case EM_XTENSA:
4dc3c23d
AM		 10394 return (reloc_type == 0 /* R_XTENSA_NONE. */
10395 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10396 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10397 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 10398 case EM_METAG:
10399 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 10400 }
10401 return FALSE;
10402}
10403
cf13d699
NC		 10404/* Apply relocations to a section.
10405 Note: So far support has been added only for those relocations
10406 which can be found in debug sections.
10407 FIXME: Add support for more relocations ? */
1b315056 10408
cf13d699
NC		 10409static void
10410apply_relocations (void * file,
10411 Elf_Internal_Shdr * section,
10412 unsigned char * start)
1b315056 10413{
cf13d699
NC		 10414 Elf_Internal_Shdr * relsec;
10415 unsigned char * end = start + section->sh_size;
cb8f3167 10416
cf13d699
NC		 10417 if (elf_header.e_type != ET_REL)
10418 return;
1b315056 10419
cf13d699 10420 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10421 for (relsec = section_headers;
10422 relsec < section_headers + elf_header.e_shnum;
10423 ++relsec)
252b5132 10424 {
41e92641
NC		 10425 bfd_boolean is_rela;
10426 unsigned long num_relocs;
2cf0635d
NC		 10427 Elf_Internal_Rela * relocs;
10428 Elf_Internal_Rela * rp;
10429 Elf_Internal_Shdr * symsec;
10430 Elf_Internal_Sym * symtab;
ba5cdace 10431 unsigned long num_syms;
2cf0635d 10432 Elf_Internal_Sym * sym;
252b5132 10433
41e92641 10434 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10435 || relsec->sh_info >= elf_header.e_shnum
10436 || section_headers + relsec->sh_info != section
c256ffe7 10437 || relsec->sh_size == 0
4fbb74a6 10438 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10439 continue;
428409d5 10440
41e92641
NC		 10441 is_rela = relsec->sh_type == SHT_RELA;
10442
10443 if (is_rela)
10444 {
3f5e193b
NC		 10445 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10446 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10447 return;
10448 }
10449 else
10450 {
3f5e193b
NC		 10451 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10452 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10453 return;
10454 }
10455
10456 /* SH uses RELA but uses in place value instead of the addend field. */
10457 if (elf_header.e_machine == EM_SH)
10458 is_rela = FALSE;
428409d5 10459
4fbb74a6 10460 symsec = section_headers + relsec->sh_link;
ba5cdace 10461 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10462
41e92641 10463 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10464 {
41e92641
NC		 10465 bfd_vma addend;
10466 unsigned int reloc_type;
10467 unsigned int reloc_size;
91d6fa6a 10468 unsigned char * rloc;
ba5cdace 10469 unsigned long sym_index;
4b78141a 10470
aca88567 10471 reloc_type = get_reloc_type (rp->r_info);
41e92641 10472
98fb390a 10473 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10474 continue;
98fb390a
NC		 10475 else if (is_none_reloc (reloc_type))
10476 continue;
10477 else if (is_32bit_abs_reloc (reloc_type)
10478 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10479 reloc_size = 4;
85acf597
RH		 10480 else if (is_64bit_abs_reloc (reloc_type)
10481 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10482 reloc_size = 8;
4dc3c23d
AM		 10483 else if (is_24bit_abs_reloc (reloc_type))
10484 reloc_size = 3;
aca88567
NC		 10485 else if (is_16bit_abs_reloc (reloc_type))
10486 reloc_size = 2;
10487 else
4b78141a 10488 {
41e92641 10489 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10490 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10491 continue;
10492 }
103f02d3 10493
91d6fa6a
NC		 10494 rloc = start + rp->r_offset;
10495 if ((rloc + reloc_size) > end)
700dd8b7
L		 10496 {
10497 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10498 (unsigned long) rp->r_offset,
10499 SECTION_NAME (section));
10500 continue;
10501 }
103f02d3 10502
ba5cdace
NC		 10503 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10504 if (sym_index >= num_syms)
10505 {
10506 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10507 sym_index, SECTION_NAME (section));
10508 continue;
10509 }
10510 sym = symtab + sym_index;
41e92641
NC		 10511
10512 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10513 make sure that it is of an appropriate type.
10514
10515 Relocations against symbols without type can happen.
10516 Gcc -feliminate-dwarf2-dups may generate symbols
10517 without type for debug info.
10518
10519 Icc generates relocations against function symbols
10520 instead of local labels.
10521
10522 Relocations against object symbols can happen, eg when
10523 referencing a global array. For an example of this see
10524 the _clz.o binary in libgcc.a. */
aca88567 10525 if (sym != symtab
55f25fc3 10526 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10527 {
41e92641 10528 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10529 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10530 (long int)(rp - relocs),
41e92641 10531 SECTION_NAME (relsec));
aca88567 10532 continue;
5b18a4bc 10533 }
252b5132 10534
4dc3c23d
AM		 10535 addend = 0;
10536 if (is_rela)
10537 addend += rp->r_addend;
c47320c3
AM		 10538 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10539 partial_inplace. */
4dc3c23d
AM		 10540 if (!is_rela
10541 || (elf_header.e_machine == EM_XTENSA
10542 && reloc_type == 1)
10543 || ((elf_header.e_machine == EM_PJ
10544 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10545 && reloc_type == 1)
10546 || ((elf_header.e_machine == EM_D30V
10547 || elf_header.e_machine == EM_CYGNUS_D30V)
10548 && reloc_type == 12))
91d6fa6a 10549 addend += byte_get (rloc, reloc_size);
cb8f3167 10550
85acf597
RH		 10551 if (is_32bit_pcrel_reloc (reloc_type)
10552 || is_64bit_pcrel_reloc (reloc_type))
10553 {
10554 /* On HPPA, all pc-relative relocations are biased by 8. */
10555 if (elf_header.e_machine == EM_PARISC)
10556 addend -= 8;
91d6fa6a 10557 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10558 reloc_size);
10559 }
41e92641 10560 else
91d6fa6a 10561 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10562 }
252b5132 10563
5b18a4bc 10564 free (symtab);
41e92641 10565 free (relocs);
5b18a4bc
NC		 10566 break;
10567 }
5b18a4bc 10568}
103f02d3 10569
cf13d699
NC		 10570#ifdef SUPPORT_DISASSEMBLY
10571static int
10572disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10573{
10574 printf (_("\nAssembly dump of section %s\n"),
10575 SECTION_NAME (section));
10576
10577 /* XXX -- to be done --- XXX */
10578
10579 return 1;
10580}
10581#endif
10582
10583/* Reads in the contents of SECTION from FILE, returning a pointer
10584 to a malloc'ed buffer or NULL if something went wrong. */
10585
10586static char *
10587get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10588{
10589 bfd_size_type num_bytes;
10590
10591 num_bytes = section->sh_size;
10592
10593 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10594 {
10595 printf (_("\nSection '%s' has no data to dump.\n"),
10596 SECTION_NAME (section));
10597 return NULL;
10598 }
10599
3f5e193b
NC		 10600 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10601 _("section contents"));
cf13d699
NC		 10602}
10603
dd24e3da 10604
cf13d699
NC		 10605static void
10606dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10607{
10608 Elf_Internal_Shdr * relsec;
10609 bfd_size_type num_bytes;
cf13d699
NC		 10610 char * data;
10611 char * end;
10612 char * start;
10613 char * name = SECTION_NAME (section);
10614 bfd_boolean some_strings_shown;
10615
10616 start = get_section_contents (section, file);
10617 if (start == NULL)
10618 return;
10619
10620 printf (_("\nString dump of section '%s':\n"), name);
10621
10622 /* If the section being dumped has relocations against it the user might
10623 be expecting these relocations to have been applied. Check for this
10624 case and issue a warning message in order to avoid confusion.
10625 FIXME: Maybe we ought to have an option that dumps a section with
10626 relocs applied ? */
10627 for (relsec = section_headers;
10628 relsec < section_headers + elf_header.e_shnum;
10629 ++relsec)
10630 {
10631 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10632 || relsec->sh_info >= elf_header.e_shnum
10633 || section_headers + relsec->sh_info != section
10634 || relsec->sh_size == 0
10635 || relsec->sh_link >= elf_header.e_shnum)
10636 continue;
10637
10638 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10639 break;
10640 }
10641
10642 num_bytes = section->sh_size;
cf13d699
NC		 10643 data = start;
10644 end = start + num_bytes;
10645 some_strings_shown = FALSE;
10646
10647 while (data < end)
10648 {
10649 while (!ISPRINT (* data))
10650 if (++ data >= end)
10651 break;
10652
10653 if (data < end)
10654 {
10655#ifndef __MSVCRT__
c975cc98
NC		 10656 /* PR 11128: Use two separate invocations in order to work
10657 around bugs in the Solaris 8 implementation of printf. */
10658 printf (" [%6tx] ", data - start);
10659 printf ("%s\n", data);
cf13d699
NC		 10660#else
10661 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10662#endif
10663 data += strlen (data);
10664 some_strings_shown = TRUE;
10665 }
10666 }
10667
10668 if (! some_strings_shown)
10669 printf (_(" No strings found in this section."));
10670
10671 free (start);
10672
10673 putchar ('\n');
10674}
10675
10676static void
10677dump_section_as_bytes (Elf_Internal_Shdr * section,
10678 FILE * file,
10679 bfd_boolean relocate)
10680{
10681 Elf_Internal_Shdr * relsec;
10682 bfd_size_type bytes;
10683 bfd_vma addr;
10684 unsigned char * data;
10685 unsigned char * start;
10686
10687 start = (unsigned char *) get_section_contents (section, file);
10688 if (start == NULL)
10689 return;
10690
10691 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10692
10693 if (relocate)
10694 {
10695 apply_relocations (file, section, start);
10696 }
10697 else
10698 {
10699 /* If the section being dumped has relocations against it the user might
10700 be expecting these relocations to have been applied. Check for this
10701 case and issue a warning message in order to avoid confusion.
10702 FIXME: Maybe we ought to have an option that dumps a section with
10703 relocs applied ? */
10704 for (relsec = section_headers;
10705 relsec < section_headers + elf_header.e_shnum;
10706 ++relsec)
10707 {
10708 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10709 || relsec->sh_info >= elf_header.e_shnum
10710 || section_headers + relsec->sh_info != section
10711 || relsec->sh_size == 0
10712 || relsec->sh_link >= elf_header.e_shnum)
10713 continue;
10714
10715 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10716 break;
10717 }
10718 }
10719
10720 addr = section->sh_addr;
10721 bytes = section->sh_size;
10722 data = start;
10723
10724 while (bytes)
10725 {
10726 int j;
10727 int k;
10728 int lbytes;
10729
10730 lbytes = (bytes > 16 ? 16 : bytes);
10731
10732 printf (" 0x%8.8lx ", (unsigned long) addr);
10733
10734 for (j = 0; j < 16; j++)
10735 {
10736 if (j < lbytes)
10737 printf ("%2.2x", data[j]);
10738 else
10739 printf (" ");
10740
10741 if ((j & 3) == 3)
10742 printf (" ");
10743 }
10744
10745 for (j = 0; j < lbytes; j++)
10746 {
10747 k = data[j];
10748 if (k >= ' ' && k < 0x7f)
10749 printf ("%c", k);
10750 else
10751 printf (".");
10752 }
10753
10754 putchar ('\n');
10755
10756 data += lbytes;
10757 addr += lbytes;
10758 bytes -= lbytes;
10759 }
10760
10761 free (start);
10762
10763 putchar ('\n');
10764}
10765
4a114e3e 10766/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10767
10768static int
d3dbc530
AM		 10769uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10770 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10771{
10772#ifndef HAVE_ZLIB_H
cf13d699
NC		 10773 return FALSE;
10774#else
10775 dwarf_size_type compressed_size = *size;
10776 unsigned char * compressed_buffer = *buffer;
10777 dwarf_size_type uncompressed_size;
10778 unsigned char * uncompressed_buffer;
10779 z_stream strm;
10780 int rc;
10781 dwarf_size_type header_size = 12;
10782
10783 /* Read the zlib header. In this case, it should be "ZLIB" followed
10784 by the uncompressed section size, 8 bytes in big-endian order. */
10785 if (compressed_size < header_size
10786 || ! streq ((char *) compressed_buffer, "ZLIB"))
10787 return 0;
10788
10789 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10790 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10791 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10792 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10793 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10794 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10795 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10796 uncompressed_size += compressed_buffer[11];
10797
10798 /* It is possible the section consists of several compressed
10799 buffers concatenated together, so we uncompress in a loop. */
10800 strm.zalloc = NULL;
10801 strm.zfree = NULL;
10802 strm.opaque = NULL;
10803 strm.avail_in = compressed_size - header_size;
10804 strm.next_in = (Bytef *) compressed_buffer + header_size;
10805 strm.avail_out = uncompressed_size;
3f5e193b 10806 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10807
10808 rc = inflateInit (& strm);
10809 while (strm.avail_in > 0)
10810 {
10811 if (rc != Z_OK)
10812 goto fail;
10813 strm.next_out = ((Bytef *) uncompressed_buffer
10814 + (uncompressed_size - strm.avail_out));
10815 rc = inflate (&strm, Z_FINISH);
10816 if (rc != Z_STREAM_END)
10817 goto fail;
10818 rc = inflateReset (& strm);
10819 }
10820 rc = inflateEnd (& strm);
10821 if (rc != Z_OK
10822 || strm.avail_out != 0)
10823 goto fail;
10824
10825 free (compressed_buffer);
10826 *buffer = uncompressed_buffer;
10827 *size = uncompressed_size;
10828 return 1;
10829
10830 fail:
10831 free (uncompressed_buffer);
4a114e3e
L		 10832 /* Indicate decompression failure. */
10833 *buffer = NULL;
cf13d699
NC		 10834 return 0;
10835#endif /* HAVE_ZLIB_H */
10836}
10837
d966045b
DJ		 10838static int
10839load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10840 Elf_Internal_Shdr * sec, void * file)
1007acb3 10841{
2cf0635d 10842 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10843 char buf [64];
1007acb3 10844
19e6b90e
L		 10845 /* If it is already loaded, do nothing. */
10846 if (section->start != NULL)
10847 return 1;
1007acb3 10848
19e6b90e
L		 10849 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10850 section->address = sec->sh_addr;
3f5e193b
NC		 10851 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10852 sec->sh_offset, 1,
10853 sec->sh_size, buf);
59245841
NC		 10854 if (section->start == NULL)
10855 section->size = 0;
10856 else
10857 {
10858 section->size = sec->sh_size;
10859 if (uncompress_section_contents (&section->start, &section->size))
10860 sec->sh_size = section->size;
10861 }
4a114e3e 10862
1b315056
CS		 10863 if (section->start == NULL)
10864 return 0;
10865
19e6b90e 10866 if (debug_displays [debug].relocate)
3f5e193b 10867 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10868
1b315056 10869 return 1;
1007acb3
L		 10870}
10871
657d0d47
CC		 10872/* If this is not NULL, load_debug_section will only look for sections
10873 within the list of sections given here. */
10874unsigned int *section_subset = NULL;
10875
d966045b 10876int
2cf0635d 10877load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10878{
2cf0635d
NC		 10879 struct dwarf_section * section = &debug_displays [debug].section;
10880 Elf_Internal_Shdr * sec;
d966045b
DJ		 10881
10882 /* Locate the debug section. */
657d0d47 10883 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 10884 if (sec != NULL)
10885 section->name = section->uncompressed_name;
10886 else
10887 {
657d0d47 10888 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 10889 if (sec != NULL)
10890 section->name = section->compressed_name;
10891 }
10892 if (sec == NULL)
10893 return 0;
10894
657d0d47
CC		 10895 /* If we're loading from a subset of sections, and we've loaded
10896 a section matching this name before, it's likely that it's a
10897 different one. */
10898 if (section_subset != NULL)
10899 free_debug_section (debug);
10900
3f5e193b 10901 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10902}
10903
19e6b90e
L		 10904void
10905free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10906{
2cf0635d 10907 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10908
19e6b90e
L		 10909 if (section->start == NULL)
10910 return;
1007acb3 10911
19e6b90e
L		 10912 free ((char *) section->start);
10913 section->start = NULL;
10914 section->address = 0;
10915 section->size = 0;
1007acb3
L		 10916}
10917
1007acb3 10918static int
657d0d47 10919display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 10920{
2cf0635d 10921 char * name = SECTION_NAME (section);
19e6b90e
L		 10922 bfd_size_type length;
10923 int result = 1;
3f5e193b 10924 int i;
1007acb3 10925
19e6b90e
L		 10926 length = section->sh_size;
10927 if (length == 0)
1007acb3 10928 {
19e6b90e
L		 10929 printf (_("\nSection '%s' has no debugging data.\n"), name);
10930 return 0;
1007acb3 10931 }
5dff79d8
NC		 10932 if (section->sh_type == SHT_NOBITS)
10933 {
10934 /* There is no point in dumping the contents of a debugging section
10935 which has the NOBITS type - the bits in the file will be random.
10936 This can happen when a file containing a .eh_frame section is
10937 stripped with the --only-keep-debug command line option. */
10938 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10939 return 0;
10940 }
1007acb3 10941
0112cd26 10942 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10943 name = ".debug_info";
1007acb3 10944
19e6b90e
L		 10945 /* See if we know how to display the contents of this section. */
10946 for (i = 0; i < max; i++)
1b315056
CS		 10947 if (streq (debug_displays[i].section.uncompressed_name, name)
10948 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10949 {
2cf0635d 10950 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10951 int secondary = (section != find_section (name));
10952
10953 if (secondary)
3f5e193b 10954 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10955
2b6f5997 10956 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10957 sec->name = sec->uncompressed_name;
10958 else
10959 sec->name = sec->compressed_name;
3f5e193b
NC		 10960 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10961 section, file))
19e6b90e 10962 {
657d0d47
CC		 10963 /* If this debug section is part of a CU/TU set in a .dwp file,
10964 restrict load_debug_section to the sections in that set. */
10965 section_subset = find_cu_tu_set (file, shndx);
10966
19e6b90e 10967 result &= debug_displays[i].display (sec, file);
1007acb3 10968
657d0d47
CC		 10969 section_subset = NULL;
10970
d966045b 10971 if (secondary || (i != info && i != abbrev))
3f5e193b 10972 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10973 }
1007acb3 10974
19e6b90e
L		 10975 break;
10976 }
1007acb3 10977
19e6b90e 10978 if (i == max)
1007acb3 10979 {
19e6b90e
L		 10980 printf (_("Unrecognized debug section: %s\n"), name);
10981 result = 0;
1007acb3
L		 10982 }
10983
19e6b90e 10984 return result;
5b18a4bc 10985}
103f02d3 10986
aef1f6d0
DJ		 10987/* Set DUMP_SECTS for all sections where dumps were requested
10988 based on section name. */
10989
10990static void
10991initialise_dumps_byname (void)
10992{
2cf0635d 10993 struct dump_list_entry * cur;
aef1f6d0
DJ		 10994
10995 for (cur = dump_sects_byname; cur; cur = cur->next)
10996 {
10997 unsigned int i;
10998 int any;
10999
11000 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11001 if (streq (SECTION_NAME (section_headers + i), cur->name))
11002 {
09c11c86 11003 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11004 any = 1;
11005 }
11006
11007 if (!any)
11008 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11009 cur->name);
11010 }
11011}
11012
5b18a4bc 11013static void
2cf0635d 11014process_section_contents (FILE * file)
5b18a4bc 11015{
2cf0635d 11016 Elf_Internal_Shdr * section;
19e6b90e 11017 unsigned int i;
103f02d3 11018
19e6b90e
L		 11019 if (! do_dump)
11020 return;
103f02d3 11021
aef1f6d0
DJ		 11022 initialise_dumps_byname ();
11023
19e6b90e
L		 11024 for (i = 0, section = section_headers;
11025 i < elf_header.e_shnum && i < num_dump_sects;
11026 i++, section++)
11027 {
11028#ifdef SUPPORT_DISASSEMBLY
11029 if (dump_sects[i] & DISASS_DUMP)
11030 disassemble_section (section, file);
11031#endif
11032 if (dump_sects[i] & HEX_DUMP)
cf13d699 11033 dump_section_as_bytes (section, file, FALSE);
103f02d3 11034
cf13d699
NC		 11035 if (dump_sects[i] & RELOC_DUMP)
11036 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11037
11038 if (dump_sects[i] & STRING_DUMP)
11039 dump_section_as_strings (section, file);
cf13d699
NC		 11040
11041 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11042 display_debug_section (i, section, file);
5b18a4bc 11043 }
103f02d3 11044
19e6b90e
L		 11045 /* Check to see if the user requested a
11046 dump of a section that does not exist. */
11047 while (i++ < num_dump_sects)
11048 if (dump_sects[i])
11049 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11050}
103f02d3 11051
5b18a4bc 11052static void
19e6b90e 11053process_mips_fpe_exception (int mask)
5b18a4bc 11054{
19e6b90e
L		 11055 if (mask)
11056 {
11057 int first = 1;
11058 if (mask & OEX_FPU_INEX)
11059 fputs ("INEX", stdout), first = 0;
11060 if (mask & OEX_FPU_UFLO)
11061 printf ("%sUFLO", first ? "" : "|"), first = 0;
11062 if (mask & OEX_FPU_OFLO)
11063 printf ("%sOFLO", first ? "" : "|"), first = 0;
11064 if (mask & OEX_FPU_DIV0)
11065 printf ("%sDIV0", first ? "" : "|"), first = 0;
11066 if (mask & OEX_FPU_INVAL)
11067 printf ("%sINVAL", first ? "" : "|");
11068 }
5b18a4bc 11069 else
19e6b90e 11070 fputs ("0", stdout);
5b18a4bc 11071}
103f02d3 11072
11c1ff18
PB		 11073/* ARM EABI attributes section. */
11074typedef struct
11075{
11076 int tag;
2cf0635d 11077 const char * name;
11c1ff18
PB		 11078 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11079 int type;
2cf0635d 11080 const char ** table;
11c1ff18
PB		 11081} arm_attr_public_tag;
11082
2cf0635d 11083static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11084 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11085 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11086static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11087static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11088 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11089static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 11090 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11091 "FP for ARMv8"};
2cf0635d 11092static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11093static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11094 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11095static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11096 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11097 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11098static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11099 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11100static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11101 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11102static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11103 {"Absolute", "PC-relative", "None"};
2cf0635d 11104static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11105 {"None", "direct", "GOT-indirect"};
2cf0635d 11106static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11107 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11108static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11109static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11110 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11111static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11112static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11113static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11114 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11115static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11116 {"Unused", "small", "int", "forced to int"};
2cf0635d 11117static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11118 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11119static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11120 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11121static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11122 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11123static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11124 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11125 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11126static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 11127 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11128 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11129static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11130static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11131 {"Not Allowed", "Allowed"};
2cf0635d 11132static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11133 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11134static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 11135 {"Not Allowed", "Allowed"};
11136static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11137 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11138 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 11139static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11140static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11141 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11142 "TrustZone and Virtualization Extensions"};
dd24e3da 11143static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11144 {"Not Allowed", "Allowed"};
11c1ff18
PB		 11145
11146#define LOOKUP(id, name) \
11147 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11148static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 11149{
11150 {4, "CPU_raw_name", 1, NULL},
11151 {5, "CPU_name", 1, NULL},
11152 LOOKUP(6, CPU_arch),
11153 {7, "CPU_arch_profile", 0, NULL},
11154 LOOKUP(8, ARM_ISA_use),
11155 LOOKUP(9, THUMB_ISA_use),
75375b3e 11156 LOOKUP(10, FP_arch),
11c1ff18 11157 LOOKUP(11, WMMX_arch),
f5f53991
AS		 11158 LOOKUP(12, Advanced_SIMD_arch),
11159 LOOKUP(13, PCS_config),
11c1ff18
PB		 11160 LOOKUP(14, ABI_PCS_R9_use),
11161 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11162 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 11163 LOOKUP(17, ABI_PCS_GOT_use),
11164 LOOKUP(18, ABI_PCS_wchar_t),
11165 LOOKUP(19, ABI_FP_rounding),
11166 LOOKUP(20, ABI_FP_denormal),
11167 LOOKUP(21, ABI_FP_exceptions),
11168 LOOKUP(22, ABI_FP_user_exceptions),
11169 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 11170 {24, "ABI_align_needed", 0, NULL},
11171 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 11172 LOOKUP(26, ABI_enum_size),
11173 LOOKUP(27, ABI_HardFP_use),
11174 LOOKUP(28, ABI_VFP_args),
11175 LOOKUP(29, ABI_WMMX_args),
11176 LOOKUP(30, ABI_optimization_goals),
11177 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11178 {32, "compatibility", 0, NULL},
f5f53991 11179 LOOKUP(34, CPU_unaligned_access),
75375b3e 11180 LOOKUP(36, FP_HP_extension),
8e79c3df 11181 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 11182 LOOKUP(42, MPextension_use),
11183 LOOKUP(44, DIV_use),
f5f53991
AS		 11184 {64, "nodefaults", 0, NULL},
11185 {65, "also_compatible_with", 0, NULL},
11186 LOOKUP(66, T2EE_use),
11187 {67, "conformance", 1, NULL},
11188 LOOKUP(68, Virtualization_use),
cd21e546 11189 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 11190};
11191#undef LOOKUP
11192
11c1ff18 11193static unsigned char *
2cf0635d 11194display_arm_attribute (unsigned char * p)
11c1ff18
PB		 11195{
11196 int tag;
11197 unsigned int len;
11198 int val;
2cf0635d 11199 arm_attr_public_tag * attr;
11c1ff18
PB		 11200 unsigned i;
11201 int type;
11202
11203 tag = read_uleb128 (p, &len);
11204 p += len;
11205 attr = NULL;
2cf0635d 11206 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 11207 {
11208 if (arm_attr_public_tags[i].tag == tag)
11209 {
11210 attr = &arm_attr_public_tags[i];
11211 break;
11212 }
11213 }
11214
11215 if (attr)
11216 {
11217 printf (" Tag_%s: ", attr->name);
11218 switch (attr->type)
11219 {
11220 case 0:
11221 switch (tag)
11222 {
11223 case 7: /* Tag_CPU_arch_profile. */
11224 val = read_uleb128 (p, &len);
11225 p += len;
11226 switch (val)
11227 {
2b692964
NC		 11228 case 0: printf (_("None\n")); break;
11229 case 'A': printf (_("Application\n")); break;
11230 case 'R': printf (_("Realtime\n")); break;
11231 case 'M': printf (_("Microcontroller\n")); break;
11232 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11233 default: printf ("??? (%d)\n", val); break;
11234 }
11235 break;
11236
75375b3e
MGD		 11237 case 24: /* Tag_align_needed. */
11238 val = read_uleb128 (p, &len);
11239 p += len;
11240 switch (val)
11241 {
2b692964
NC		 11242 case 0: printf (_("None\n")); break;
11243 case 1: printf (_("8-byte\n")); break;
11244 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11245 case 3: printf ("??? 3\n"); break;
11246 default:
11247 if (val <= 12)
dd24e3da 11248 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11249 1 << val);
11250 else
11251 printf ("??? (%d)\n", val);
11252 break;
11253 }
11254 break;
11255
11256 case 25: /* Tag_align_preserved. */
11257 val = read_uleb128 (p, &len);
11258 p += len;
11259 switch (val)
11260 {
2b692964
NC		 11261 case 0: printf (_("None\n")); break;
11262 case 1: printf (_("8-byte, except leaf SP\n")); break;
11263 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11264 case 3: printf ("??? 3\n"); break;
11265 default:
11266 if (val <= 12)
dd24e3da 11267 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11268 1 << val);
11269 else
11270 printf ("??? (%d)\n", val);
11271 break;
11272 }
11273 break;
11274
11c1ff18
PB		 11275 case 32: /* Tag_compatibility. */
11276 val = read_uleb128 (p, &len);
11277 p += len;
2b692964 11278 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11279 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11280 break;
11281
f5f53991
AS		 11282 case 64: /* Tag_nodefaults. */
11283 p++;
2b692964 11284 printf (_("True\n"));
f5f53991
AS		 11285 break;
11286
11287 case 65: /* Tag_also_compatible_with. */
11288 val = read_uleb128 (p, &len);
11289 p += len;
11290 if (val == 6 /* Tag_CPU_arch. */)
11291 {
11292 val = read_uleb128 (p, &len);
11293 p += len;
2cf0635d 11294 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11295 printf ("??? (%d)\n", val);
11296 else
11297 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11298 }
11299 else
11300 printf ("???\n");
11301 while (*(p++) != '\0' /* NUL terminator. */);
11302 break;
11303
11c1ff18 11304 default:
2cf0635d 11305 abort ();
11c1ff18
PB		 11306 }
11307 return p;
11308
11309 case 1:
11310 case 2:
11311 type = attr->type;
11312 break;
11313
11314 default:
11315 assert (attr->type & 0x80);
11316 val = read_uleb128 (p, &len);
11317 p += len;
11318 type = attr->type & 0x7f;
11319 if (val >= type)
11320 printf ("??? (%d)\n", val);
11321 else
11322 printf ("%s\n", attr->table[val]);
11323 return p;
11324 }
11325 }
11326 else
11327 {
11328 if (tag & 1)
11329 type = 1; /* String. */
11330 else
11331 type = 2; /* uleb128. */
11332 printf (" Tag_unknown_%d: ", tag);
11333 }
11334
11335 if (type == 1)
11336 {
11337 printf ("\"%s\"\n", p);
2cf0635d 11338 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11339 }
11340 else
11341 {
11342 val = read_uleb128 (p, &len);
11343 p += len;
11344 printf ("%d (0x%x)\n", val, val);
11345 }
11346
11347 return p;
11348}
11349
104d59d1 11350static unsigned char *
60bca95a
NC		 11351display_gnu_attribute (unsigned char * p,
11352 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 11353{
11354 int tag;
11355 unsigned int len;
11356 int val;
11357 int type;
11358
11359 tag = read_uleb128 (p, &len);
11360 p += len;
11361
11362 /* Tag_compatibility is the only generic GNU attribute defined at
11363 present. */
11364 if (tag == 32)
11365 {
11366 val = read_uleb128 (p, &len);
11367 p += len;
2b692964 11368 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 11369 p += strlen ((char *) p) + 1;
104d59d1
JM		 11370 return p;
11371 }
11372
11373 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11374 return display_proc_gnu_attribute (p, tag);
11375
11376 if (tag & 1)
11377 type = 1; /* String. */
11378 else
11379 type = 2; /* uleb128. */
11380 printf (" Tag_unknown_%d: ", tag);
11381
11382 if (type == 1)
11383 {
11384 printf ("\"%s\"\n", p);
60bca95a 11385 p += strlen ((char *) p) + 1;
104d59d1
JM		 11386 }
11387 else
11388 {
11389 val = read_uleb128 (p, &len);
11390 p += len;
11391 printf ("%d (0x%x)\n", val, val);
11392 }
11393
11394 return p;
11395}
11396
34c8bcba 11397static unsigned char *
2cf0635d 11398display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 11399{
11400 int type;
11401 unsigned int len;
11402 int val;
11403
11404 if (tag == Tag_GNU_Power_ABI_FP)
11405 {
11406 val = read_uleb128 (p, &len);
11407 p += len;
11408 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11409
34c8bcba
JM		 11410 switch (val)
11411 {
11412 case 0:
2b692964 11413 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11414 break;
11415 case 1:
2b692964 11416 printf (_("Hard float\n"));
34c8bcba
JM		 11417 break;
11418 case 2:
2b692964 11419 printf (_("Soft float\n"));
34c8bcba 11420 break;
3c7b9897 11421 case 3:
2b692964 11422 printf (_("Single-precision hard float\n"));
3c7b9897 11423 break;
34c8bcba
JM		 11424 default:
11425 printf ("??? (%d)\n", val);
11426 break;
11427 }
11428 return p;
11429 }
11430
c6e65352
DJ		 11431 if (tag == Tag_GNU_Power_ABI_Vector)
11432 {
11433 val = read_uleb128 (p, &len);
11434 p += len;
11435 printf (" Tag_GNU_Power_ABI_Vector: ");
11436 switch (val)
11437 {
11438 case 0:
2b692964 11439 printf (_("Any\n"));
c6e65352
DJ		 11440 break;
11441 case 1:
2b692964 11442 printf (_("Generic\n"));
c6e65352
DJ		 11443 break;
11444 case 2:
11445 printf ("AltiVec\n");
11446 break;
11447 case 3:
11448 printf ("SPE\n");
11449 break;
11450 default:
11451 printf ("??? (%d)\n", val);
11452 break;
11453 }
11454 return p;
11455 }
11456
f82e0623
NF		 11457 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11458 {
11459 val = read_uleb128 (p, &len);
11460 p += len;
11461 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11462 switch (val)
11463 {
11464 case 0:
2b692964 11465 printf (_("Any\n"));
f82e0623
NF		 11466 break;
11467 case 1:
11468 printf ("r3/r4\n");
11469 break;
11470 case 2:
2b692964 11471 printf (_("Memory\n"));
f82e0623
NF		 11472 break;
11473 default:
11474 printf ("??? (%d)\n", val);
11475 break;
11476 }
11477 return p;
11478 }
11479
34c8bcba
JM		 11480 if (tag & 1)
11481 type = 1; /* String. */
11482 else
11483 type = 2; /* uleb128. */
11484 printf (" Tag_unknown_%d: ", tag);
11485
11486 if (type == 1)
11487 {
11488 printf ("\"%s\"\n", p);
60bca95a 11489 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11490 }
11491 else
11492 {
11493 val = read_uleb128 (p, &len);
11494 p += len;
11495 printf ("%d (0x%x)\n", val, val);
11496 }
11497
11498 return p;
11499}
11500
9e8c70f9
DM		 11501static void
11502display_sparc_hwcaps (int mask)
11503{
11504 if (mask)
11505 {
11506 int first = 1;
11507 if (mask & ELF_SPARC_HWCAP_MUL32)
11508 fputs ("mul32", stdout), first = 0;
11509 if (mask & ELF_SPARC_HWCAP_DIV32)
11510 printf ("%sdiv32", first ? "" : "|"), first = 0;
11511 if (mask & ELF_SPARC_HWCAP_FSMULD)
11512 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11513 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11514 printf ("%sv8plus", first ? "" : "|"), first = 0;
11515 if (mask & ELF_SPARC_HWCAP_POPC)
11516 printf ("%spopc", first ? "" : "|"), first = 0;
11517 if (mask & ELF_SPARC_HWCAP_VIS)
11518 printf ("%svis", first ? "" : "|"), first = 0;
11519 if (mask & ELF_SPARC_HWCAP_VIS2)
11520 printf ("%svis2", first ? "" : "|"), first = 0;
11521 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11522 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11523 if (mask & ELF_SPARC_HWCAP_FMAF)
11524 printf ("%sfmaf", first ? "" : "|"), first = 0;
11525 if (mask & ELF_SPARC_HWCAP_VIS3)
11526 printf ("%svis3", first ? "" : "|"), first = 0;
11527 if (mask & ELF_SPARC_HWCAP_HPC)
11528 printf ("%shpc", first ? "" : "|"), first = 0;
11529 if (mask & ELF_SPARC_HWCAP_RANDOM)
11530 printf ("%srandom", first ? "" : "|"), first = 0;
11531 if (mask & ELF_SPARC_HWCAP_TRANS)
11532 printf ("%strans", first ? "" : "|"), first = 0;
11533 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11534 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11535 if (mask & ELF_SPARC_HWCAP_IMA)
11536 printf ("%sima", first ? "" : "|"), first = 0;
11537 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11538 printf ("%scspare", first ? "" : "|"), first = 0;
11539 }
11540 else
11541 fputc('0', stdout);
11542 fputc('\n', stdout);
11543}
11544
11545static unsigned char *
11546display_sparc_gnu_attribute (unsigned char * p, int tag)
11547{
11548 int type;
11549 unsigned int len;
11550 int val;
11551
11552 if (tag == Tag_GNU_Sparc_HWCAPS)
11553 {
11554 val = read_uleb128 (p, &len);
11555 p += len;
11556 printf (" Tag_GNU_Sparc_HWCAPS: ");
11557
11558 display_sparc_hwcaps (val);
11559 return p;
11560 }
11561
11562 if (tag & 1)
11563 type = 1; /* String. */
11564 else
11565 type = 2; /* uleb128. */
11566 printf (" Tag_unknown_%d: ", tag);
11567
11568 if (type == 1)
11569 {
11570 printf ("\"%s\"\n", p);
11571 p += strlen ((char *) p) + 1;
11572 }
11573 else
11574 {
11575 val = read_uleb128 (p, &len);
11576 p += len;
11577 printf ("%d (0x%x)\n", val, val);
11578 }
11579
11580 return p;
11581}
11582
2cf19d5c 11583static unsigned char *
2cf0635d 11584display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11585{
11586 int type;
11587 unsigned int len;
11588 int val;
11589
11590 if (tag == Tag_GNU_MIPS_ABI_FP)
11591 {
11592 val = read_uleb128 (p, &len);
11593 p += len;
11594 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11595
2cf19d5c
JM		 11596 switch (val)
11597 {
11598 case 0:
2b692964 11599 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11600 break;
11601 case 1:
2b692964 11602 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11603 break;
11604 case 2:
2b692964 11605 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11606 break;
11607 case 3:
2b692964 11608 printf (_("Soft float\n"));
2cf19d5c 11609 break;
42554f6a 11610 case 4:
9eeefea8 11611 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11612 break;
2cf19d5c
JM		 11613 default:
11614 printf ("??? (%d)\n", val);
11615 break;
11616 }
11617 return p;
11618 }
11619
11620 if (tag & 1)
11621 type = 1; /* String. */
11622 else
11623 type = 2; /* uleb128. */
11624 printf (" Tag_unknown_%d: ", tag);
11625
11626 if (type == 1)
11627 {
11628 printf ("\"%s\"\n", p);
60bca95a 11629 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11630 }
11631 else
11632 {
11633 val = read_uleb128 (p, &len);
11634 p += len;
11635 printf ("%d (0x%x)\n", val, val);
11636 }
11637
11638 return p;
11639}
11640
59e6276b
JM		 11641static unsigned char *
11642display_tic6x_attribute (unsigned char * p)
11643{
11644 int tag;
11645 unsigned int len;
11646 int val;
11647
11648 tag = read_uleb128 (p, &len);
11649 p += len;
11650
11651 switch (tag)
11652 {
75fa6dc1 11653 case Tag_ISA:
59e6276b
JM		 11654 val = read_uleb128 (p, &len);
11655 p += len;
75fa6dc1 11656 printf (" Tag_ISA: ");
59e6276b
JM		 11657
11658 switch (val)
11659 {
75fa6dc1 11660 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11661 printf (_("None\n"));
11662 break;
75fa6dc1 11663 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11664 printf ("C62x\n");
11665 break;
75fa6dc1 11666 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11667 printf ("C67x\n");
11668 break;
75fa6dc1 11669 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11670 printf ("C67x+\n");
11671 break;
75fa6dc1 11672 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11673 printf ("C64x\n");
11674 break;
75fa6dc1 11675 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11676 printf ("C64x+\n");
11677 break;
75fa6dc1 11678 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11679 printf ("C674x\n");
11680 break;
11681 default:
11682 printf ("??? (%d)\n", val);
11683 break;
11684 }
11685 return p;
11686
87779176
JM		 11687 case Tag_ABI_wchar_t:
11688 val = read_uleb128 (p, &len);
11689 p += len;
11690 printf (" Tag_ABI_wchar_t: ");
11691 switch (val)
11692 {
11693 case 0:
11694 printf (_("Not used\n"));
11695 break;
11696 case 1:
11697 printf (_("2 bytes\n"));
11698 break;
11699 case 2:
11700 printf (_("4 bytes\n"));
11701 break;
11702 default:
11703 printf ("??? (%d)\n", val);
11704 break;
11705 }
11706 return p;
11707
11708 case Tag_ABI_stack_align_needed:
11709 val = read_uleb128 (p, &len);
11710 p += len;
11711 printf (" Tag_ABI_stack_align_needed: ");
11712 switch (val)
11713 {
11714 case 0:
11715 printf (_("8-byte\n"));
11716 break;
11717 case 1:
11718 printf (_("16-byte\n"));
11719 break;
11720 default:
11721 printf ("??? (%d)\n", val);
11722 break;
11723 }
11724 return p;
11725
11726 case Tag_ABI_stack_align_preserved:
11727 val = read_uleb128 (p, &len);
11728 p += len;
11729 printf (" Tag_ABI_stack_align_preserved: ");
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
b5593623
JM		 11744 case Tag_ABI_DSBT:
11745 val = read_uleb128 (p, &len);
11746 p += len;
11747 printf (" Tag_ABI_DSBT: ");
11748 switch (val)
11749 {
11750 case 0:
11751 printf (_("DSBT addressing not used\n"));
11752 break;
11753 case 1:
11754 printf (_("DSBT addressing used\n"));
11755 break;
11756 default:
11757 printf ("??? (%d)\n", val);
11758 break;
11759 }
11760 return p;
11761
87779176
JM		 11762 case Tag_ABI_PID:
11763 val = read_uleb128 (p, &len);
11764 p += len;
11765 printf (" Tag_ABI_PID: ");
11766 switch (val)
11767 {
11768 case 0:
11769 printf (_("Data addressing position-dependent\n"));
11770 break;
11771 case 1:
11772 printf (_("Data addressing position-independent, GOT near DP\n"));
11773 break;
11774 case 2:
11775 printf (_("Data addressing position-independent, GOT far from DP\n"));
11776 break;
11777 default:
11778 printf ("??? (%d)\n", val);
11779 break;
11780 }
11781 return p;
11782
11783 case Tag_ABI_PIC:
11784 val = read_uleb128 (p, &len);
11785 p += len;
11786 printf (" Tag_ABI_PIC: ");
11787 switch (val)
11788 {
11789 case 0:
11790 printf (_("Code addressing position-dependent\n"));
11791 break;
11792 case 1:
11793 printf (_("Code addressing position-independent\n"));
11794 break;
11795 default:
11796 printf ("??? (%d)\n", val);
11797 break;
11798 }
11799 return p;
11800
11801 case Tag_ABI_array_object_alignment:
11802 val = read_uleb128 (p, &len);
11803 p += len;
11804 printf (" Tag_ABI_array_object_alignment: ");
11805 switch (val)
11806 {
11807 case 0:
11808 printf (_("8-byte\n"));
11809 break;
11810 case 1:
11811 printf (_("4-byte\n"));
11812 break;
11813 case 2:
11814 printf (_("16-byte\n"));
11815 break;
11816 default:
11817 printf ("??? (%d)\n", val);
11818 break;
11819 }
11820 return p;
11821
11822 case Tag_ABI_array_object_align_expected:
11823 val = read_uleb128 (p, &len);
11824 p += len;
11825 printf (" Tag_ABI_array_object_align_expected: ");
11826 switch (val)
11827 {
11828 case 0:
11829 printf (_("8-byte\n"));
11830 break;
11831 case 1:
11832 printf (_("4-byte\n"));
11833 break;
11834 case 2:
11835 printf (_("16-byte\n"));
11836 break;
11837 default:
11838 printf ("??? (%d)\n", val);
11839 break;
11840 }
11841 return p;
11842
3cbd1c06 11843 case Tag_ABI_compatibility:
59e6276b
JM		 11844 val = read_uleb128 (p, &len);
11845 p += len;
3cbd1c06 11846 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11847 printf (_("flag = %d, vendor = %s\n"), val, p);
11848 p += strlen ((char *) p) + 1;
11849 return p;
87779176
JM		 11850
11851 case Tag_ABI_conformance:
11852 printf (" Tag_ABI_conformance: ");
11853 printf ("\"%s\"\n", p);
11854 p += strlen ((char *) p) + 1;
11855 return p;
59e6276b
JM		 11856 }
11857
11858 printf (" Tag_unknown_%d: ", tag);
11859
87779176
JM		 11860 if (tag & 1)
11861 {
11862 printf ("\"%s\"\n", p);
11863 p += strlen ((char *) p) + 1;
11864 }
11865 else
11866 {
11867 val = read_uleb128 (p, &len);
11868 p += len;
11869 printf ("%d (0x%x)\n", val, val);
11870 }
59e6276b
JM		 11871
11872 return p;
11873}
11874
11c1ff18 11875static int
60bca95a
NC		 11876process_attributes (FILE * file,
11877 const char * public_name,
104d59d1 11878 unsigned int proc_type,
60bca95a
NC		 11879 unsigned char * (* display_pub_attribute) (unsigned char *),
11880 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11881{
2cf0635d
NC		 11882 Elf_Internal_Shdr * sect;
11883 unsigned char * contents;
11884 unsigned char * p;
11885 unsigned char * end;
11c1ff18
PB		 11886 bfd_vma section_len;
11887 bfd_vma len;
11888 unsigned i;
11889
11890 /* Find the section header so that we get the size. */
11891 for (i = 0, sect = section_headers;
11892 i < elf_header.e_shnum;
11893 i++, sect++)
11894 {
104d59d1 11895 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11896 continue;
11897
3f5e193b
NC		 11898 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11899 sect->sh_size, _("attributes"));
60bca95a 11900 if (contents == NULL)
11c1ff18 11901 continue;
60bca95a 11902
11c1ff18
PB		 11903 p = contents;
11904 if (*p == 'A')
11905 {
11906 len = sect->sh_size - 1;
11907 p++;
60bca95a 11908
11c1ff18
PB		 11909 while (len > 0)
11910 {
11911 int namelen;
11912 bfd_boolean public_section;
104d59d1 11913 bfd_boolean gnu_section;
11c1ff18
PB		 11914
11915 section_len = byte_get (p, 4);
11916 p += 4;
60bca95a 11917
11c1ff18
PB		 11918 if (section_len > len)
11919 {
11920 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11921 (int) section_len, (int) len);
11c1ff18
PB		 11922 section_len = len;
11923 }
60bca95a 11924
11c1ff18 11925 len -= section_len;
2b692964 11926 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11927
11928 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11929 public_section = TRUE;
11930 else
11931 public_section = FALSE;
60bca95a
NC		 11932
11933 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11934 gnu_section = TRUE;
11935 else
11936 gnu_section = FALSE;
60bca95a
NC		 11937
11938 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11939 p += namelen;
11940 section_len -= namelen + 4;
60bca95a 11941
11c1ff18
PB		 11942 while (section_len > 0)
11943 {
11944 int tag = *(p++);
11945 int val;
11946 bfd_vma size;
60bca95a 11947
11c1ff18
PB		 11948 size = byte_get (p, 4);
11949 if (size > section_len)
11950 {
11951 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11952 (int) size, (int) section_len);
11c1ff18
PB		 11953 size = section_len;
11954 }
60bca95a 11955
11c1ff18
PB		 11956 section_len -= size;
11957 end = p + size - 1;
11958 p += 4;
60bca95a 11959
11c1ff18
PB		 11960 switch (tag)
11961 {
11962 case 1:
2b692964 11963 printf (_("File Attributes\n"));
11c1ff18
PB		 11964 break;
11965 case 2:
2b692964 11966 printf (_("Section Attributes:"));
11c1ff18
PB		 11967 goto do_numlist;
11968 case 3:
2b692964 11969 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11970 do_numlist:
11971 for (;;)
11972 {
91d6fa6a 11973 unsigned int j;
60bca95a 11974
91d6fa6a
NC		 11975 val = read_uleb128 (p, &j);
11976 p += j;
11c1ff18
PB		 11977 if (val == 0)
11978 break;
11979 printf (" %d", val);
11980 }
11981 printf ("\n");
11982 break;
11983 default:
2b692964 11984 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11985 public_section = FALSE;
11986 break;
11987 }
60bca95a 11988
11c1ff18
PB		 11989 if (public_section)
11990 {
11991 while (p < end)
104d59d1
JM		 11992 p = display_pub_attribute (p);
11993 }
11994 else if (gnu_section)
11995 {
11996 while (p < end)
11997 p = display_gnu_attribute (p,
11998 display_proc_gnu_attribute);
11c1ff18
PB		 11999 }
12000 else
12001 {
12002 /* ??? Do something sensible, like dump hex. */
2b692964 12003 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 12004 p = end;
12005 }
12006 }
12007 }
12008 }
12009 else
60bca95a 12010 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 12011
60bca95a 12012 free (contents);
11c1ff18
PB		 12013 }
12014 return 1;
12015}
12016
104d59d1 12017static int
2cf0635d 12018process_arm_specific (FILE * file)
104d59d1
JM		 12019{
12020 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12021 display_arm_attribute, NULL);
12022}
12023
34c8bcba 12024static int
2cf0635d 12025process_power_specific (FILE * file)
34c8bcba
JM		 12026{
12027 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12028 display_power_gnu_attribute);
12029}
12030
9e8c70f9
DM		 12031static int
12032process_sparc_specific (FILE * file)
12033{
12034 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12035 display_sparc_gnu_attribute);
12036}
12037
59e6276b
JM		 12038static int
12039process_tic6x_specific (FILE * file)
12040{
12041 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12042 display_tic6x_attribute, NULL);
12043}
12044
ccb4c951
RS		 12045/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12046 Print the Address, Access and Initial fields of an entry at VMA ADDR
12047 and return the VMA of the next entry. */
12048
12049static bfd_vma
2cf0635d 12050print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 12051{
12052 printf (" ");
12053 print_vma (addr, LONG_HEX);
12054 printf (" ");
12055 if (addr < pltgot + 0xfff0)
12056 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12057 else
12058 printf ("%10s", "");
12059 printf (" ");
12060 if (data == NULL)
2b692964 12061 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 12062 else
12063 {
12064 bfd_vma entry;
12065
12066 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12067 print_vma (entry, LONG_HEX);
12068 }
12069 return addr + (is_32bit_elf ? 4 : 8);
12070}
12071
861fb55a
DJ		 12072/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12073 PLTGOT. Print the Address and Initial fields of an entry at VMA
12074 ADDR and return the VMA of the next entry. */
12075
12076static bfd_vma
2cf0635d 12077print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 12078{
12079 printf (" ");
12080 print_vma (addr, LONG_HEX);
12081 printf (" ");
12082 if (data == NULL)
2b692964 12083 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 12084 else
12085 {
12086 bfd_vma entry;
12087
12088 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12089 print_vma (entry, LONG_HEX);
12090 }
12091 return addr + (is_32bit_elf ? 4 : 8);
12092}
12093
19e6b90e 12094static int
2cf0635d 12095process_mips_specific (FILE * file)
5b18a4bc 12096{
2cf0635d 12097 Elf_Internal_Dyn * entry;
19e6b90e
L		 12098 size_t liblist_offset = 0;
12099 size_t liblistno = 0;
12100 size_t conflictsno = 0;
12101 size_t options_offset = 0;
12102 size_t conflicts_offset = 0;
861fb55a
DJ		 12103 size_t pltrelsz = 0;
12104 size_t pltrel = 0;
ccb4c951 12105 bfd_vma pltgot = 0;
861fb55a
DJ		 12106 bfd_vma mips_pltgot = 0;
12107 bfd_vma jmprel = 0;
ccb4c951
RS		 12108 bfd_vma local_gotno = 0;
12109 bfd_vma gotsym = 0;
12110 bfd_vma symtabno = 0;
103f02d3 12111
2cf19d5c
JM		 12112 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12113 display_mips_gnu_attribute);
12114
19e6b90e
L		 12115 /* We have a lot of special sections. Thanks SGI! */
12116 if (dynamic_section == NULL)
12117 /* No information available. */
12118 return 0;
252b5132 12119
b2d38a17 12120 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 12121 switch (entry->d_tag)
12122 {
12123 case DT_MIPS_LIBLIST:
d93f0186
NC		 12124 liblist_offset
12125 = offset_from_vma (file, entry->d_un.d_val,
12126 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 12127 break;
12128 case DT_MIPS_LIBLISTNO:
12129 liblistno = entry->d_un.d_val;
12130 break;
12131 case DT_MIPS_OPTIONS:
d93f0186 12132 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 12133 break;
12134 case DT_MIPS_CONFLICT:
d93f0186
NC		 12135 conflicts_offset
12136 = offset_from_vma (file, entry->d_un.d_val,
12137 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 12138 break;
12139 case DT_MIPS_CONFLICTNO:
12140 conflictsno = entry->d_un.d_val;
12141 break;
ccb4c951 12142 case DT_PLTGOT:
861fb55a
DJ		 12143 pltgot = entry->d_un.d_ptr;
12144 break;
ccb4c951
RS		 12145 case DT_MIPS_LOCAL_GOTNO:
12146 local_gotno = entry->d_un.d_val;
12147 break;
12148 case DT_MIPS_GOTSYM:
12149 gotsym = entry->d_un.d_val;
12150 break;
12151 case DT_MIPS_SYMTABNO:
12152 symtabno = entry->d_un.d_val;
12153 break;
861fb55a
DJ		 12154 case DT_MIPS_PLTGOT:
12155 mips_pltgot = entry->d_un.d_ptr;
12156 break;
12157 case DT_PLTREL:
12158 pltrel = entry->d_un.d_val;
12159 break;
12160 case DT_PLTRELSZ:
12161 pltrelsz = entry->d_un.d_val;
12162 break;
12163 case DT_JMPREL:
12164 jmprel = entry->d_un.d_ptr;
12165 break;
252b5132
RH		 12166 default:
12167 break;
12168 }
12169
12170 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12171 {
2cf0635d 12172 Elf32_External_Lib * elib;
252b5132
RH		 12173 size_t cnt;
12174
3f5e193b
NC		 12175 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12176 liblistno,
12177 sizeof (Elf32_External_Lib),
9cf03b7e 12178 _("liblist section data"));
a6e9f9df 12179 if (elib)
252b5132 12180 {
2b692964 12181 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 12182 (unsigned long) liblistno);
2b692964 12183 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 12184 stdout);
12185
12186 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 12187 {
a6e9f9df 12188 Elf32_Lib liblist;
91d6fa6a 12189 time_t atime;
a6e9f9df 12190 char timebuf[20];
2cf0635d 12191 struct tm * tmp;
a6e9f9df
AM		 12192
12193 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12194 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 12195 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12196 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12197 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12198
91d6fa6a 12199 tmp = gmtime (&atime);
e9e44622
JJ		 12200 snprintf (timebuf, sizeof (timebuf),
12201 "%04u-%02u-%02uT%02u:%02u:%02u",
12202 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12203 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 12204
31104126 12205 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 12206 if (VALID_DYNAMIC_NAME (liblist.l_name))
12207 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12208 else
2b692964 12209 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 12210 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12211 liblist.l_version);
a6e9f9df
AM		 12212
12213 if (liblist.l_flags == 0)
2b692964 12214 puts (_(" NONE"));
a6e9f9df
AM		 12215 else
12216 {
12217 static const struct
252b5132 12218 {
2cf0635d 12219 const char * name;
a6e9f9df 12220 int bit;
252b5132 12221 }
a6e9f9df
AM		 12222 l_flags_vals[] =
12223 {
12224 { " EXACT_MATCH", LL_EXACT_MATCH },
12225 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12226 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12227 { " EXPORTS", LL_EXPORTS },
12228 { " DELAY_LOAD", LL_DELAY_LOAD },
12229 { " DELTA", LL_DELTA }
12230 };
12231 int flags = liblist.l_flags;
12232 size_t fcnt;
12233
60bca95a 12234 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12235 if ((flags & l_flags_vals[fcnt].bit) != 0)
12236 {
12237 fputs (l_flags_vals[fcnt].name, stdout);
12238 flags ^= l_flags_vals[fcnt].bit;
12239 }
12240 if (flags != 0)
12241 printf (" %#x", (unsigned int) flags);
252b5132 12242
a6e9f9df
AM		 12243 puts ("");
12244 }
252b5132 12245 }
252b5132 12246
a6e9f9df
AM		 12247 free (elib);
12248 }
252b5132
RH		 12249 }
12250
12251 if (options_offset != 0)
12252 {
2cf0635d
NC		 12253 Elf_External_Options * eopt;
12254 Elf_Internal_Shdr * sect = section_headers;
12255 Elf_Internal_Options * iopt;
12256 Elf_Internal_Options * option;
252b5132
RH		 12257 size_t offset;
12258 int cnt;
12259
12260 /* Find the section header so that we get the size. */
12261 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12262 ++sect;
252b5132 12263
3f5e193b
NC		 12264 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12265 sect->sh_size, _("options"));
a6e9f9df 12266 if (eopt)
252b5132 12267 {
3f5e193b
NC		 12268 iopt = (Elf_Internal_Options *)
12269 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 12270 if (iopt == NULL)
12271 {
591a748a 12272 error (_("Out of memory\n"));
a6e9f9df
AM		 12273 return 0;
12274 }
76da6bbe 12275
a6e9f9df
AM		 12276 offset = cnt = 0;
12277 option = iopt;
252b5132 12278
a6e9f9df
AM		 12279 while (offset < sect->sh_size)
12280 {
2cf0635d 12281 Elf_External_Options * eoption;
252b5132 12282
a6e9f9df 12283 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12284
a6e9f9df
AM		 12285 option->kind = BYTE_GET (eoption->kind);
12286 option->size = BYTE_GET (eoption->size);
12287 option->section = BYTE_GET (eoption->section);
12288 option->info = BYTE_GET (eoption->info);
76da6bbe 12289
a6e9f9df 12290 offset += option->size;
252b5132 12291
a6e9f9df
AM		 12292 ++option;
12293 ++cnt;
12294 }
252b5132 12295
a6e9f9df
AM		 12296 printf (_("\nSection '%s' contains %d entries:\n"),
12297 SECTION_NAME (sect), cnt);
76da6bbe 12298
a6e9f9df 12299 option = iopt;
252b5132 12300
a6e9f9df 12301 while (cnt-- > 0)
252b5132 12302 {
a6e9f9df
AM		 12303 size_t len;
12304
12305 switch (option->kind)
252b5132 12306 {
a6e9f9df
AM		 12307 case ODK_NULL:
12308 /* This shouldn't happen. */
12309 printf (" NULL %d %lx", option->section, option->info);
12310 break;
12311 case ODK_REGINFO:
12312 printf (" REGINFO ");
12313 if (elf_header.e_machine == EM_MIPS)
12314 {
12315 /* 32bit form. */
2cf0635d 12316 Elf32_External_RegInfo * ereg;
b34976b6 12317 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12318
12319 ereg = (Elf32_External_RegInfo *) (option + 1);
12320 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12321 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12322 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12323 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12324 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12325 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12326
12327 printf ("GPR %08lx GP 0x%lx\n",
12328 reginfo.ri_gprmask,
12329 (unsigned long) reginfo.ri_gp_value);
12330 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12331 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12332 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12333 }
12334 else
12335 {
12336 /* 64 bit form. */
2cf0635d 12337 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12338 Elf64_Internal_RegInfo reginfo;
12339
12340 ereg = (Elf64_External_RegInfo *) (option + 1);
12341 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12342 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12343 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12344 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12345 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12346 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12347
12348 printf ("GPR %08lx GP 0x",
12349 reginfo.ri_gprmask);
12350 printf_vma (reginfo.ri_gp_value);
12351 printf ("\n");
12352
12353 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12354 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12355 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12356 }
12357 ++option;
12358 continue;
12359 case ODK_EXCEPTIONS:
12360 fputs (" EXCEPTIONS fpe_min(", stdout);
12361 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12362 fputs (") fpe_max(", stdout);
12363 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12364 fputs (")", stdout);
12365
12366 if (option->info & OEX_PAGE0)
12367 fputs (" PAGE0", stdout);
12368 if (option->info & OEX_SMM)
12369 fputs (" SMM", stdout);
12370 if (option->info & OEX_FPDBUG)
12371 fputs (" FPDBUG", stdout);
12372 if (option->info & OEX_DISMISS)
12373 fputs (" DISMISS", stdout);
12374 break;
12375 case ODK_PAD:
12376 fputs (" PAD ", stdout);
12377 if (option->info & OPAD_PREFIX)
12378 fputs (" PREFIX", stdout);
12379 if (option->info & OPAD_POSTFIX)
12380 fputs (" POSTFIX", stdout);
12381 if (option->info & OPAD_SYMBOL)
12382 fputs (" SYMBOL", stdout);
12383 break;
12384 case ODK_HWPATCH:
12385 fputs (" HWPATCH ", stdout);
12386 if (option->info & OHW_R4KEOP)
12387 fputs (" R4KEOP", stdout);
12388 if (option->info & OHW_R8KPFETCH)
12389 fputs (" R8KPFETCH", stdout);
12390 if (option->info & OHW_R5KEOP)
12391 fputs (" R5KEOP", stdout);
12392 if (option->info & OHW_R5KCVTL)
12393 fputs (" R5KCVTL", stdout);
12394 break;
12395 case ODK_FILL:
12396 fputs (" FILL ", stdout);
12397 /* XXX Print content of info word? */
12398 break;
12399 case ODK_TAGS:
12400 fputs (" TAGS ", stdout);
12401 /* XXX Print content of info word? */
12402 break;
12403 case ODK_HWAND:
12404 fputs (" HWAND ", stdout);
12405 if (option->info & OHWA0_R4KEOP_CHECKED)
12406 fputs (" R4KEOP_CHECKED", stdout);
12407 if (option->info & OHWA0_R4KEOP_CLEAN)
12408 fputs (" R4KEOP_CLEAN", stdout);
12409 break;
12410 case ODK_HWOR:
12411 fputs (" HWOR ", stdout);
12412 if (option->info & OHWA0_R4KEOP_CHECKED)
12413 fputs (" R4KEOP_CHECKED", stdout);
12414 if (option->info & OHWA0_R4KEOP_CLEAN)
12415 fputs (" R4KEOP_CLEAN", stdout);
12416 break;
12417 case ODK_GP_GROUP:
12418 printf (" GP_GROUP %#06lx self-contained %#06lx",
12419 option->info & OGP_GROUP,
12420 (option->info & OGP_SELF) >> 16);
12421 break;
12422 case ODK_IDENT:
12423 printf (" IDENT %#06lx self-contained %#06lx",
12424 option->info & OGP_GROUP,
12425 (option->info & OGP_SELF) >> 16);
12426 break;
12427 default:
12428 /* This shouldn't happen. */
12429 printf (" %3d ??? %d %lx",
12430 option->kind, option->section, option->info);
12431 break;
252b5132 12432 }
a6e9f9df 12433
2cf0635d 12434 len = sizeof (* eopt);
a6e9f9df
AM		 12435 while (len < option->size)
12436 if (((char *) option)[len] >= ' '
12437 && ((char *) option)[len] < 0x7f)
12438 printf ("%c", ((char *) option)[len++]);
12439 else
12440 printf ("\\%03o", ((char *) option)[len++]);
12441
12442 fputs ("\n", stdout);
252b5132 12443 ++option;
252b5132
RH		 12444 }
12445
a6e9f9df 12446 free (eopt);
252b5132 12447 }
252b5132
RH		 12448 }
12449
12450 if (conflicts_offset != 0 && conflictsno != 0)
12451 {
2cf0635d 12452 Elf32_Conflict * iconf;
252b5132
RH		 12453 size_t cnt;
12454
12455 if (dynamic_symbols == NULL)
12456 {
591a748a 12457 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12458 return 0;
12459 }
12460
3f5e193b 12461 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12462 if (iconf == NULL)
12463 {
591a748a 12464 error (_("Out of memory\n"));
252b5132
RH		 12465 return 0;
12466 }
12467
9ea033b2 12468 if (is_32bit_elf)
252b5132 12469 {
2cf0635d 12470 Elf32_External_Conflict * econf32;
a6e9f9df 12471
3f5e193b
NC		 12472 econf32 = (Elf32_External_Conflict *)
12473 get_data (NULL, file, conflicts_offset, conflictsno,
12474 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12475 if (!econf32)
12476 return 0;
252b5132
RH		 12477
12478 for (cnt = 0; cnt < conflictsno; ++cnt)
12479 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12480
12481 free (econf32);
252b5132
RH		 12482 }
12483 else
12484 {
2cf0635d 12485 Elf64_External_Conflict * econf64;
a6e9f9df 12486
3f5e193b
NC		 12487 econf64 = (Elf64_External_Conflict *)
12488 get_data (NULL, file, conflicts_offset, conflictsno,
12489 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12490 if (!econf64)
12491 return 0;
252b5132
RH		 12492
12493 for (cnt = 0; cnt < conflictsno; ++cnt)
12494 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12495
12496 free (econf64);
252b5132
RH		 12497 }
12498
c7e7ca54
NC		 12499 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12500 (unsigned long) conflictsno);
252b5132
RH		 12501 puts (_(" Num: Index Value Name"));
12502
12503 for (cnt = 0; cnt < conflictsno; ++cnt)
12504 {
2cf0635d 12505 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12506
b34976b6 12507 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12508 print_vma (psym->st_value, FULL_HEX);
31104126 12509 putchar (' ');
d79b3d50
NC		 12510 if (VALID_DYNAMIC_NAME (psym->st_name))
12511 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12512 else
2b692964 12513 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12514 putchar ('\n');
252b5132
RH		 12515 }
12516
252b5132
RH		 12517 free (iconf);
12518 }
12519
ccb4c951
RS		 12520 if (pltgot != 0 && local_gotno != 0)
12521 {
91d6fa6a 12522 bfd_vma ent, local_end, global_end;
bbeee7ea 12523 size_t i, offset;
2cf0635d 12524 unsigned char * data;
bbeee7ea 12525 int addr_size;
ccb4c951 12526
91d6fa6a 12527 ent = pltgot;
ccb4c951
RS		 12528 addr_size = (is_32bit_elf ? 4 : 8);
12529 local_end = pltgot + local_gotno * addr_size;
12530 global_end = local_end + (symtabno - gotsym) * addr_size;
12531
12532 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12533 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 12534 global_end - pltgot, 1,
12535 _("Global Offset Table data"));
59245841
NC		 12536 if (data == NULL)
12537 return 0;
12538
ccb4c951
RS		 12539 printf (_("\nPrimary GOT:\n"));
12540 printf (_(" Canonical gp value: "));
12541 print_vma (pltgot + 0x7ff0, LONG_HEX);
12542 printf ("\n\n");
12543
12544 printf (_(" Reserved entries:\n"));
12545 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12546 addr_size * 2, _("Address"), _("Access"),
12547 addr_size * 2, _("Initial"));
91d6fa6a 12548 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12549 printf (_(" Lazy resolver\n"));
ccb4c951 12550 if (data
91d6fa6a 12551 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12552 >> (addr_size * 8 - 1)) != 0)
12553 {
91d6fa6a 12554 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12555 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12556 }
12557 printf ("\n");
12558
91d6fa6a 12559 if (ent < local_end)
ccb4c951
RS		 12560 {
12561 printf (_(" Local entries:\n"));
cc5914eb 12562 printf (" %*s %10s %*s\n",
2b692964
NC		 12563 addr_size * 2, _("Address"), _("Access"),
12564 addr_size * 2, _("Initial"));
91d6fa6a 12565 while (ent < local_end)
ccb4c951 12566 {
91d6fa6a 12567 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12568 printf ("\n");
12569 }
12570 printf ("\n");
12571 }
12572
12573 if (gotsym < symtabno)
12574 {
12575 int sym_width;
12576
12577 printf (_(" Global entries:\n"));
cc5914eb 12578 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 12579 addr_size * 2, _("Address"),
12580 _("Access"),
2b692964 12581 addr_size * 2, _("Initial"),
9cf03b7e
NC		 12582 addr_size * 2, _("Sym.Val."),
12583 _("Type"),
12584 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12585 _("Ndx"), _("Name"));
12586
ccb4c951
RS		 12587 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12588 for (i = gotsym; i < symtabno; i++)
12589 {
2cf0635d 12590 Elf_Internal_Sym * psym;
ccb4c951
RS		 12591
12592 psym = dynamic_symbols + i;
91d6fa6a 12593 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12594 printf (" ");
12595 print_vma (psym->st_value, LONG_HEX);
12596 printf (" %-7s %3s ",
12597 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12598 get_symbol_index_type (psym->st_shndx));
12599 if (VALID_DYNAMIC_NAME (psym->st_name))
12600 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12601 else
2b692964 12602 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12603 printf ("\n");
12604 }
12605 printf ("\n");
12606 }
12607
12608 if (data)
12609 free (data);
12610 }
12611
861fb55a
DJ		 12612 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12613 {
91d6fa6a 12614 bfd_vma ent, end;
861fb55a
DJ		 12615 size_t offset, rel_offset;
12616 unsigned long count, i;
2cf0635d 12617 unsigned char * data;
861fb55a 12618 int addr_size, sym_width;
2cf0635d 12619 Elf_Internal_Rela * rels;
861fb55a
DJ		 12620
12621 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12622 if (pltrel == DT_RELA)
12623 {
12624 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12625 return 0;
12626 }
12627 else
12628 {
12629 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12630 return 0;
12631 }
12632
91d6fa6a 12633 ent = mips_pltgot;
861fb55a
DJ		 12634 addr_size = (is_32bit_elf ? 4 : 8);
12635 end = mips_pltgot + (2 + count) * addr_size;
12636
12637 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12638 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12639 1, _("Procedure Linkage Table data"));
59245841
NC		 12640 if (data == NULL)
12641 return 0;
12642
9cf03b7e 12643 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 12644 printf (_(" Reserved entries:\n"));
12645 printf (_(" %*s %*s Purpose\n"),
2b692964 12646 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12647 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12648 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12649 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12650 printf (_(" Module pointer\n"));
861fb55a
DJ		 12651 printf ("\n");
12652
12653 printf (_(" Entries:\n"));
cc5914eb 12654 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12655 addr_size * 2, _("Address"),
12656 addr_size * 2, _("Initial"),
12657 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12658 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12659 for (i = 0; i < count; i++)
12660 {
2cf0635d 12661 Elf_Internal_Sym * psym;
861fb55a
DJ		 12662
12663 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12664 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12665 printf (" ");
12666 print_vma (psym->st_value, LONG_HEX);
12667 printf (" %-7s %3s ",
12668 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12669 get_symbol_index_type (psym->st_shndx));
12670 if (VALID_DYNAMIC_NAME (psym->st_name))
12671 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12672 else
2b692964 12673 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12674 printf ("\n");
12675 }
12676 printf ("\n");
12677
12678 if (data)
12679 free (data);
12680 free (rels);
12681 }
12682
252b5132
RH		 12683 return 1;
12684}
12685
047b2264 12686static int
2cf0635d 12687process_gnu_liblist (FILE * file)
047b2264 12688{
2cf0635d
NC		 12689 Elf_Internal_Shdr * section;
12690 Elf_Internal_Shdr * string_sec;
12691 Elf32_External_Lib * elib;
12692 char * strtab;
c256ffe7 12693 size_t strtab_size;
047b2264
JJ		 12694 size_t cnt;
12695 unsigned i;
12696
12697 if (! do_arch)
12698 return 0;
12699
12700 for (i = 0, section = section_headers;
12701 i < elf_header.e_shnum;
b34976b6 12702 i++, section++)
047b2264
JJ		 12703 {
12704 switch (section->sh_type)
12705 {
12706 case SHT_GNU_LIBLIST:
4fbb74a6 12707 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12708 break;
12709
3f5e193b
NC		 12710 elib = (Elf32_External_Lib *)
12711 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 12712 _("liblist section data"));
047b2264
JJ		 12713
12714 if (elib == NULL)
12715 break;
4fbb74a6 12716 string_sec = section_headers + section->sh_link;
047b2264 12717
3f5e193b
NC		 12718 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12719 string_sec->sh_size,
12720 _("liblist string table"));
047b2264
JJ		 12721 if (strtab == NULL
12722 || section->sh_entsize != sizeof (Elf32_External_Lib))
12723 {
12724 free (elib);
2842702f 12725 free (strtab);
047b2264
JJ		 12726 break;
12727 }
59245841 12728 strtab_size = string_sec->sh_size;
047b2264
JJ		 12729
12730 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12731 SECTION_NAME (section),
0af1713e 12732 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12733
2b692964 12734 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12735
12736 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12737 ++cnt)
12738 {
12739 Elf32_Lib liblist;
91d6fa6a 12740 time_t atime;
047b2264 12741 char timebuf[20];
2cf0635d 12742 struct tm * tmp;
047b2264
JJ		 12743
12744 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12745 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12746 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12747 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12748 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12749
91d6fa6a 12750 tmp = gmtime (&atime);
e9e44622
JJ		 12751 snprintf (timebuf, sizeof (timebuf),
12752 "%04u-%02u-%02uT%02u:%02u:%02u",
12753 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12754 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12755
12756 printf ("%3lu: ", (unsigned long) cnt);
12757 if (do_wide)
c256ffe7 12758 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12759 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12760 else
c256ffe7 12761 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12762 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12763 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12764 liblist.l_version, liblist.l_flags);
12765 }
12766
12767 free (elib);
2842702f 12768 free (strtab);
047b2264
JJ		 12769 }
12770 }
12771
12772 return 1;
12773}
12774
9437c45b 12775static const char *
d3ba0551 12776get_note_type (unsigned e_type)
779fe533
NC		 12777{
12778 static char buff[64];
103f02d3 12779
1ec5cd37
NC		 12780 if (elf_header.e_type == ET_CORE)
12781 switch (e_type)
12782 {
57346661 12783 case NT_AUXV:
1ec5cd37 12784 return _("NT_AUXV (auxiliary vector)");
57346661 12785 case NT_PRSTATUS:
1ec5cd37 12786 return _("NT_PRSTATUS (prstatus structure)");
57346661 12787 case NT_FPREGSET:
1ec5cd37 12788 return _("NT_FPREGSET (floating point registers)");
57346661 12789 case NT_PRPSINFO:
1ec5cd37 12790 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12791 case NT_TASKSTRUCT:
1ec5cd37 12792 return _("NT_TASKSTRUCT (task structure)");
57346661 12793 case NT_PRXFPREG:
1ec5cd37 12794 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12795 case NT_PPC_VMX:
12796 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12797 case NT_PPC_VSX:
12798 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 12799 case NT_386_TLS:
12800 return _("NT_386_TLS (x86 TLS information)");
12801 case NT_386_IOPERM:
12802 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 12803 case NT_X86_XSTATE:
12804 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12805 case NT_S390_HIGH_GPRS:
12806 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12807 case NT_S390_TIMER:
12808 return _("NT_S390_TIMER (s390 timer register)");
12809 case NT_S390_TODCMP:
12810 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12811 case NT_S390_TODPREG:
12812 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12813 case NT_S390_CTRS:
12814 return _("NT_S390_CTRS (s390 control registers)");
12815 case NT_S390_PREFIX:
12816 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 12817 case NT_S390_LAST_BREAK:
12818 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
12819 case NT_S390_SYSTEM_CALL:
12820 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
faa9a424
UW		 12821 case NT_ARM_VFP:
12822 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 12823 case NT_ARM_TLS:
12824 return _("NT_ARM_TLS (AArch TLS registers)");
12825 case NT_ARM_HW_BREAK:
12826 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12827 case NT_ARM_HW_WATCH:
12828 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 12829 case NT_PSTATUS:
1ec5cd37 12830 return _("NT_PSTATUS (pstatus structure)");
57346661 12831 case NT_FPREGS:
1ec5cd37 12832 return _("NT_FPREGS (floating point registers)");
57346661 12833 case NT_PSINFO:
1ec5cd37 12834 return _("NT_PSINFO (psinfo structure)");
57346661 12835 case NT_LWPSTATUS:
1ec5cd37 12836 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12837 case NT_LWPSINFO:
1ec5cd37 12838 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12839 case NT_WIN32PSTATUS:
1ec5cd37 12840 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 12841 case NT_SIGINFO:
12842 return _("NT_SIGINFO (siginfo_t data)");
12843 case NT_FILE:
12844 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 12845 default:
12846 break;
12847 }
12848 else
12849 switch (e_type)
12850 {
12851 case NT_VERSION:
12852 return _("NT_VERSION (version)");
12853 case NT_ARCH:
12854 return _("NT_ARCH (architecture)");
12855 default:
12856 break;
12857 }
12858
e9e44622 12859 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12860 return buff;
779fe533
NC		 12861}
12862
9ece1fa9
TT		 12863static int
12864print_core_note (Elf_Internal_Note *pnote)
12865{
12866 unsigned int addr_size = is_32bit_elf ? 4 : 8;
12867 bfd_vma count, page_size;
12868 unsigned char *descdata, *filenames, *descend;
12869
12870 if (pnote->type != NT_FILE)
12871 return 1;
12872
12873#ifndef BFD64
12874 if (!is_32bit_elf)
12875 {
12876 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12877 /* Still "successful". */
12878 return 1;
12879 }
12880#endif
12881
12882 if (pnote->descsz < 2 * addr_size)
12883 {
12884 printf (_(" Malformed note - too short for header\n"));
12885 return 0;
12886 }
12887
12888 descdata = (unsigned char *) pnote->descdata;
12889 descend = descdata + pnote->descsz;
12890
12891 if (descdata[pnote->descsz - 1] != '\0')
12892 {
12893 printf (_(" Malformed note - does not end with \\0\n"));
12894 return 0;
12895 }
12896
12897 count = byte_get (descdata, addr_size);
12898 descdata += addr_size;
12899
12900 page_size = byte_get (descdata, addr_size);
12901 descdata += addr_size;
12902
12903 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12904 {
12905 printf (_(" Malformed note - too short for supplied file count\n"));
12906 return 0;
12907 }
12908
12909 printf (_(" Page size: "));
12910 print_vma (page_size, DEC);
12911 printf ("\n");
12912
12913 printf (_(" %*s%*s%*s\n"),
12914 (int) (2 + 2 * addr_size), _("Start"),
12915 (int) (4 + 2 * addr_size), _("End"),
12916 (int) (4 + 2 * addr_size), _("Page Offset"));
12917 filenames = descdata + count * 3 * addr_size;
12918 while (--count > 0)
12919 {
12920 bfd_vma start, end, file_ofs;
12921
12922 if (filenames == descend)
12923 {
12924 printf (_(" Malformed note - filenames end too early\n"));
12925 return 0;
12926 }
12927
12928 start = byte_get (descdata, addr_size);
12929 descdata += addr_size;
12930 end = byte_get (descdata, addr_size);
12931 descdata += addr_size;
12932 file_ofs = byte_get (descdata, addr_size);
12933 descdata += addr_size;
12934
12935 printf (" ");
12936 print_vma (start, FULL_HEX);
12937 printf (" ");
12938 print_vma (end, FULL_HEX);
12939 printf (" ");
12940 print_vma (file_ofs, FULL_HEX);
12941 printf ("\n %s\n", filenames);
12942
12943 filenames += 1 + strlen ((char *) filenames);
12944 }
12945
12946 return 1;
12947}
12948
1118d252
RM		 12949static const char *
12950get_gnu_elf_note_type (unsigned e_type)
12951{
12952 static char buff[64];
12953
12954 switch (e_type)
12955 {
12956 case NT_GNU_ABI_TAG:
12957 return _("NT_GNU_ABI_TAG (ABI version tag)");
12958 case NT_GNU_HWCAP:
12959 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12960 case NT_GNU_BUILD_ID:
12961 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12962 case NT_GNU_GOLD_VERSION:
12963 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12964 default:
12965 break;
12966 }
12967
12968 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12969 return buff;
12970}
12971
664f90a3
TT		 12972static int
12973print_gnu_note (Elf_Internal_Note *pnote)
12974{
12975 switch (pnote->type)
12976 {
12977 case NT_GNU_BUILD_ID:
12978 {
12979 unsigned long i;
12980
12981 printf (_(" Build ID: "));
12982 for (i = 0; i < pnote->descsz; ++i)
12983 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 12984 printf ("\n");
664f90a3
TT		 12985 }
12986 break;
12987
12988 case NT_GNU_ABI_TAG:
12989 {
12990 unsigned long os, major, minor, subminor;
12991 const char *osname;
12992
12993 os = byte_get ((unsigned char *) pnote->descdata, 4);
12994 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12995 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12996 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12997
12998 switch (os)
12999 {
13000 case GNU_ABI_TAG_LINUX:
13001 osname = "Linux";
13002 break;
13003 case GNU_ABI_TAG_HURD:
13004 osname = "Hurd";
13005 break;
13006 case GNU_ABI_TAG_SOLARIS:
13007 osname = "Solaris";
13008 break;
13009 case GNU_ABI_TAG_FREEBSD:
13010 osname = "FreeBSD";
13011 break;
13012 case GNU_ABI_TAG_NETBSD:
13013 osname = "NetBSD";
13014 break;
13015 default:
13016 osname = "Unknown";
13017 break;
13018 }
13019
13020 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13021 major, minor, subminor);
13022 }
13023 break;
13024 }
13025
13026 return 1;
13027}
13028
9437c45b 13029static const char *
d3ba0551 13030get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 13031{
13032 static char buff[64];
13033
b4db1224 13034 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 13035 {
13036 /* NetBSD core "procinfo" structure. */
13037 return _("NetBSD procinfo structure");
13038 }
13039
13040 /* As of Jan 2002 there are no other machine-independent notes
13041 defined for NetBSD core files. If the note type is less
13042 than the start of the machine-dependent note types, we don't
13043 understand it. */
13044
b4db1224 13045 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 13046 {
e9e44622 13047 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 13048 return buff;
13049 }
13050
13051 switch (elf_header.e_machine)
13052 {
13053 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13054 and PT_GETFPREGS == mach+2. */
13055
13056 case EM_OLD_ALPHA:
13057 case EM_ALPHA:
13058 case EM_SPARC:
13059 case EM_SPARC32PLUS:
13060 case EM_SPARCV9:
13061 switch (e_type)
13062 {
2b692964 13063 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 13064 return _("PT_GETREGS (reg structure)");
2b692964 13065 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 13066 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13067 default:
13068 break;
13069 }
13070 break;
13071
13072 /* On all other arch's, PT_GETREGS == mach+1 and
13073 PT_GETFPREGS == mach+3. */
13074 default:
13075 switch (e_type)
13076 {
2b692964 13077 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 13078 return _("PT_GETREGS (reg structure)");
2b692964 13079 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 13080 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13081 default:
13082 break;
13083 }
13084 }
13085
9cf03b7e 13086 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 13087 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 13088 return buff;
13089}
13090
70616151
TT		 13091static const char *
13092get_stapsdt_note_type (unsigned e_type)
13093{
13094 static char buff[64];
13095
13096 switch (e_type)
13097 {
13098 case NT_STAPSDT:
13099 return _("NT_STAPSDT (SystemTap probe descriptors)");
13100
13101 default:
13102 break;
13103 }
13104
13105 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13106 return buff;
13107}
13108
c6a9fc58
TT		 13109static int
13110print_stapsdt_note (Elf_Internal_Note *pnote)
13111{
13112 int addr_size = is_32bit_elf ? 4 : 8;
13113 char *data = pnote->descdata;
13114 char *data_end = pnote->descdata + pnote->descsz;
13115 bfd_vma pc, base_addr, semaphore;
13116 char *provider, *probe, *arg_fmt;
13117
13118 pc = byte_get ((unsigned char *) data, addr_size);
13119 data += addr_size;
13120 base_addr = byte_get ((unsigned char *) data, addr_size);
13121 data += addr_size;
13122 semaphore = byte_get ((unsigned char *) data, addr_size);
13123 data += addr_size;
13124
13125 provider = data;
13126 data += strlen (data) + 1;
13127 probe = data;
13128 data += strlen (data) + 1;
13129 arg_fmt = data;
13130 data += strlen (data) + 1;
13131
13132 printf (_(" Provider: %s\n"), provider);
13133 printf (_(" Name: %s\n"), probe);
13134 printf (_(" Location: "));
13135 print_vma (pc, FULL_HEX);
13136 printf (_(", Base: "));
13137 print_vma (base_addr, FULL_HEX);
13138 printf (_(", Semaphore: "));
13139 print_vma (semaphore, FULL_HEX);
9cf03b7e 13140 printf ("\n");
c6a9fc58
TT		 13141 printf (_(" Arguments: %s\n"), arg_fmt);
13142
13143 return data == data_end;
13144}
13145
00e98fc7
TG		 13146static const char *
13147get_ia64_vms_note_type (unsigned e_type)
13148{
13149 static char buff[64];
13150
13151 switch (e_type)
13152 {
13153 case NT_VMS_MHD:
13154 return _("NT_VMS_MHD (module header)");
13155 case NT_VMS_LNM:
13156 return _("NT_VMS_LNM (language name)");
13157 case NT_VMS_SRC:
13158 return _("NT_VMS_SRC (source files)");
13159 case NT_VMS_TITLE:
9cf03b7e 13160 return "NT_VMS_TITLE";
00e98fc7
TG		 13161 case NT_VMS_EIDC:
13162 return _("NT_VMS_EIDC (consistency check)");
13163 case NT_VMS_FPMODE:
13164 return _("NT_VMS_FPMODE (FP mode)");
13165 case NT_VMS_LINKTIME:
9cf03b7e 13166 return "NT_VMS_LINKTIME";
00e98fc7
TG		 13167 case NT_VMS_IMGNAM:
13168 return _("NT_VMS_IMGNAM (image name)");
13169 case NT_VMS_IMGID:
13170 return _("NT_VMS_IMGID (image id)");
13171 case NT_VMS_LINKID:
13172 return _("NT_VMS_LINKID (link id)");
13173 case NT_VMS_IMGBID:
13174 return _("NT_VMS_IMGBID (build id)");
13175 case NT_VMS_GSTNAM:
13176 return _("NT_VMS_GSTNAM (sym table name)");
13177 case NT_VMS_ORIG_DYN:
9cf03b7e 13178 return "NT_VMS_ORIG_DYN";
00e98fc7 13179 case NT_VMS_PATCHTIME:
9cf03b7e 13180 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 13181 default:
13182 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13183 return buff;
13184 }
13185}
13186
13187static int
13188print_ia64_vms_note (Elf_Internal_Note * pnote)
13189{
13190 switch (pnote->type)
13191 {
13192 case NT_VMS_MHD:
13193 if (pnote->descsz > 36)
13194 {
13195 size_t l = strlen (pnote->descdata + 34);
13196 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13197 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13198 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13199 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13200 }
13201 else
13202 printf (_(" Invalid size\n"));
13203 break;
13204 case NT_VMS_LNM:
13205 printf (_(" Language: %s\n"), pnote->descdata);
13206 break;
13207#ifdef BFD64
13208 case NT_VMS_FPMODE:
9cf03b7e 13209 printf (_(" Floating Point mode: "));
4a5cb34f 13210 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13211 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13212 break;
13213 case NT_VMS_LINKTIME:
13214 printf (_(" Link time: "));
13215 print_vms_time
13216 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13217 printf ("\n");
13218 break;
13219 case NT_VMS_PATCHTIME:
13220 printf (_(" Patch time: "));
13221 print_vms_time
13222 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13223 printf ("\n");
13224 break;
13225 case NT_VMS_ORIG_DYN:
13226 printf (_(" Major id: %u, minor id: %u\n"),
13227 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13228 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 13229 printf (_(" Last modified : "));
00e98fc7
TG		 13230 print_vms_time
13231 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 13232 printf (_("\n Link flags : "));
4a5cb34f 13233 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13234 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13235 printf (_(" Header flags: 0x%08x\n"),
13236 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13237 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13238 break;
13239#endif
13240 case NT_VMS_IMGNAM:
13241 printf (_(" Image name: %s\n"), pnote->descdata);
13242 break;
13243 case NT_VMS_GSTNAM:
13244 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13245 break;
13246 case NT_VMS_IMGID:
13247 printf (_(" Image id: %s\n"), pnote->descdata);
13248 break;
13249 case NT_VMS_LINKID:
13250 printf (_(" Linker id: %s\n"), pnote->descdata);
13251 break;
13252 default:
13253 break;
13254 }
13255 return 1;
13256}
13257
6d118b09
NC		 13258/* Note that by the ELF standard, the name field is already null byte
13259 terminated, and namesz includes the terminating null byte.
13260 I.E. the value of namesz for the name "FSF" is 4.
13261
e3c8793a 13262 If the value of namesz is zero, there is no name present. */
779fe533 13263static int
2cf0635d 13264process_note (Elf_Internal_Note * pnote)
779fe533 13265{
2cf0635d
NC		 13266 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13267 const char * nt;
9437c45b
JT		 13268
13269 if (pnote->namesz == 0)
1ec5cd37
NC		 13270 /* If there is no note name, then use the default set of
13271 note type strings. */
13272 nt = get_note_type (pnote->type);
13273
1118d252
RM		 13274 else if (const_strneq (pnote->namedata, "GNU"))
13275 /* GNU-specific object file notes. */
13276 nt = get_gnu_elf_note_type (pnote->type);
13277
0112cd26 13278 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 13279 /* NetBSD-specific core file notes. */
13280 nt = get_netbsd_elfcore_note_type (pnote->type);
13281
b15fa79e
AM		 13282 else if (strneq (pnote->namedata, "SPU/", 4))
13283 {
13284 /* SPU-specific core file notes. */
13285 nt = pnote->namedata + 4;
13286 name = "SPU";
13287 }
13288
00e98fc7
TG		 13289 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13290 /* VMS/ia64-specific file notes. */
13291 nt = get_ia64_vms_note_type (pnote->type);
13292
70616151
TT		 13293 else if (const_strneq (pnote->namedata, "stapsdt"))
13294 nt = get_stapsdt_note_type (pnote->type);
13295
9437c45b 13296 else
1ec5cd37
NC		 13297 /* Don't recognize this note name; just use the default set of
13298 note type strings. */
00e98fc7 13299 nt = get_note_type (pnote->type);
9437c45b 13300
2aee03ae 13301 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 13302
13303 if (const_strneq (pnote->namedata, "IPF/VMS"))
13304 return print_ia64_vms_note (pnote);
664f90a3
TT		 13305 else if (const_strneq (pnote->namedata, "GNU"))
13306 return print_gnu_note (pnote);
c6a9fc58
TT		 13307 else if (const_strneq (pnote->namedata, "stapsdt"))
13308 return print_stapsdt_note (pnote);
9ece1fa9
TT		 13309 else if (const_strneq (pnote->namedata, "CORE"))
13310 return print_core_note (pnote);
00e98fc7
TG		 13311 else
13312 return 1;
779fe533
NC		 13313}
13314
6d118b09 13315
779fe533 13316static int
2cf0635d 13317process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 13318{
2cf0635d
NC		 13319 Elf_External_Note * pnotes;
13320 Elf_External_Note * external;
b34976b6 13321 int res = 1;
103f02d3 13322
779fe533
NC		 13323 if (length <= 0)
13324 return 0;
103f02d3 13325
3f5e193b
NC		 13326 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13327 _("notes"));
dd24e3da 13328 if (pnotes == NULL)
a6e9f9df 13329 return 0;
779fe533 13330
103f02d3 13331 external = pnotes;
103f02d3 13332
305c7206 13333 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13334 (unsigned long) offset, (unsigned long) length);
2aee03ae 13335 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13336
2cf0635d 13337 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 13338 {
2cf0635d 13339 Elf_External_Note * next;
b34976b6 13340 Elf_Internal_Note inote;
2cf0635d 13341 char * temp = NULL;
6d118b09 13342
00e98fc7
TG		 13343 if (!is_ia64_vms ())
13344 {
13345 inote.type = BYTE_GET (external->type);
13346 inote.namesz = BYTE_GET (external->namesz);
13347 inote.namedata = external->name;
13348 inote.descsz = BYTE_GET (external->descsz);
13349 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13350 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13351
13352 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13353 }
13354 else
13355 {
13356 Elf64_External_VMS_Note *vms_external;
13357
13358 vms_external = (Elf64_External_VMS_Note *)external;
13359 inote.type = BYTE_GET (vms_external->type);
13360 inote.namesz = BYTE_GET (vms_external->namesz);
13361 inote.namedata = vms_external->name;
13362 inote.descsz = BYTE_GET (vms_external->descsz);
13363 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13364 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13365
13366 next = (Elf_External_Note *)
13367 (inote.descdata + align_power (inote.descsz, 3));
13368 }
3e55a963 13369
dd24e3da
NC		 13370 if ( ((char *) next > ((char *) pnotes) + length)
13371 || ((char *) next < (char *) pnotes))
3e55a963 13372 {
0fd3a477 13373 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 13374 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 13375 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 13376 inote.type, inote.namesz, inote.descsz);
13377 break;
13378 }
13379
13380 external = next;
6d118b09 13381
dd24e3da 13382 /* Prevent out-of-bounds indexing. */
8b971f9f 13383 if (inote.namedata + inote.namesz > (char *) pnotes + length
dd24e3da
NC		 13384 || inote.namedata + inote.namesz < inote.namedata)
13385 {
13386 warn (_("corrupt note found at offset %lx into core notes\n"),
13387 (unsigned long) ((char *) external - (char *) pnotes));
13388 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13389 inote.type, inote.namesz, inote.descsz);
13390 break;
13391 }
13392
6d118b09
NC		 13393 /* Verify that name is null terminated. It appears that at least
13394 one version of Linux (RedHat 6.0) generates corefiles that don't
13395 comply with the ELF spec by failing to include the null byte in
13396 namesz. */
8b971f9f 13397 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13398 {
3f5e193b 13399 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13400
6d118b09
NC		 13401 if (temp == NULL)
13402 {
13403 error (_("Out of memory\n"));
13404 res = 0;
13405 break;
13406 }
76da6bbe 13407
6d118b09
NC		 13408 strncpy (temp, inote.namedata, inote.namesz);
13409 temp[inote.namesz] = 0;
76da6bbe 13410
6d118b09
NC		 13411 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13412 inote.namedata = temp;
13413 }
13414
13415 res &= process_note (& inote);
103f02d3 13416
6d118b09
NC		 13417 if (temp != NULL)
13418 {
13419 free (temp);
13420 temp = NULL;
13421 }
779fe533
NC		 13422 }
13423
13424 free (pnotes);
103f02d3 13425
779fe533
NC		 13426 return res;
13427}
13428
13429static int
2cf0635d 13430process_corefile_note_segments (FILE * file)
779fe533 13431{
2cf0635d 13432 Elf_Internal_Phdr * segment;
b34976b6
AM		 13433 unsigned int i;
13434 int res = 1;
103f02d3 13435
d93f0186 13436 if (! get_program_headers (file))
779fe533 13437 return 0;
103f02d3 13438
779fe533
NC		 13439 for (i = 0, segment = program_headers;
13440 i < elf_header.e_phnum;
b34976b6 13441 i++, segment++)
779fe533
NC		 13442 {
13443 if (segment->p_type == PT_NOTE)
103f02d3 13444 res &= process_corefile_note_segment (file,
30800947
NC		 13445 (bfd_vma) segment->p_offset,
13446 (bfd_vma) segment->p_filesz);
779fe533 13447 }
103f02d3 13448
779fe533
NC		 13449 return res;
13450}
13451
13452static int
2cf0635d 13453process_note_sections (FILE * file)
1ec5cd37 13454{
2cf0635d 13455 Elf_Internal_Shdr * section;
1ec5cd37
NC		 13456 unsigned long i;
13457 int res = 1;
13458
13459 for (i = 0, section = section_headers;
fa1908fd 13460 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 13461 i++, section++)
13462 if (section->sh_type == SHT_NOTE)
13463 res &= process_corefile_note_segment (file,
13464 (bfd_vma) section->sh_offset,
13465 (bfd_vma) section->sh_size);
13466
13467 return res;
13468}
13469
13470static int
2cf0635d 13471process_notes (FILE * file)
779fe533
NC		 13472{
13473 /* If we have not been asked to display the notes then do nothing. */
13474 if (! do_notes)
13475 return 1;
103f02d3 13476
779fe533 13477 if (elf_header.e_type != ET_CORE)
1ec5cd37 13478 return process_note_sections (file);
103f02d3 13479
779fe533 13480 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 13481 if (elf_header.e_phnum > 0)
13482 return process_corefile_note_segments (file);
779fe533 13483
1ec5cd37
NC		 13484 printf (_("No note segments present in the core file.\n"));
13485 return 1;
779fe533
NC		 13486}
13487
252b5132 13488static int
2cf0635d 13489process_arch_specific (FILE * file)
252b5132 13490{
a952a375
NC		 13491 if (! do_arch)
13492 return 1;
13493
252b5132
RH		 13494 switch (elf_header.e_machine)
13495 {
11c1ff18
PB		 13496 case EM_ARM:
13497 return process_arm_specific (file);
252b5132 13498 case EM_MIPS:
4fe85591 13499 case EM_MIPS_RS3_LE:
252b5132
RH		 13500 return process_mips_specific (file);
13501 break;
34c8bcba
JM		 13502 case EM_PPC:
13503 return process_power_specific (file);
13504 break;
9e8c70f9
DM		 13505 case EM_SPARC:
13506 case EM_SPARC32PLUS:
13507 case EM_SPARCV9:
13508 return process_sparc_specific (file);
13509 break;
59e6276b
JM		 13510 case EM_TI_C6000:
13511 return process_tic6x_specific (file);
13512 break;
252b5132
RH		 13513 default:
13514 break;
13515 }
13516 return 1;
13517}
13518
13519static int
2cf0635d 13520get_file_header (FILE * file)
252b5132 13521{
9ea033b2
NC		 13522 /* Read in the identity array. */
13523 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13524 return 0;
13525
9ea033b2 13526 /* Determine how to read the rest of the header. */
b34976b6 13527 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13528 {
13529 default: /* fall through */
13530 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13531 case ELFDATA2LSB:
13532 byte_get = byte_get_little_endian;
13533 byte_put = byte_put_little_endian;
13534 break;
13535 case ELFDATA2MSB:
13536 byte_get = byte_get_big_endian;
13537 byte_put = byte_put_big_endian;
13538 break;
9ea033b2
NC		 13539 }
13540
13541 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13542 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13543
13544 /* Read in the rest of the header. */
13545 if (is_32bit_elf)
13546 {
13547 Elf32_External_Ehdr ehdr32;
252b5132 13548
9ea033b2
NC		 13549 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13550 return 0;
103f02d3 13551
9ea033b2
NC		 13552 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13553 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13554 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13555 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13556 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13557 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13558 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13559 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13560 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13561 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13562 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13563 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13564 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13565 }
252b5132 13566 else
9ea033b2
NC		 13567 {
13568 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13569
13570 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13571 we will not be able to cope with the 64bit data found in
13572 64 ELF files. Detect this now and abort before we start
50c2245b 13573 overwriting things. */
a952a375
NC		 13574 if (sizeof (bfd_vma) < 8)
13575 {
e3c8793a
NC		 13576 error (_("This instance of readelf has been built without support for a\n\
1357764 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13578 return 0;
13579 }
103f02d3 13580
9ea033b2
NC		 13581 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13582 return 0;
103f02d3 13583
9ea033b2
NC		 13584 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13585 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13586 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13587 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13588 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13589 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13590 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13591 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13592 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13593 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13594 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13595 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13596 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13597 }
252b5132 13598
7ece0d85
JJ		 13599 if (elf_header.e_shoff)
13600 {
13601 /* There may be some extensions in the first section header. Don't
13602 bomb if we can't read it. */
13603 if (is_32bit_elf)
13604 get_32bit_section_headers (file, 1);
13605 else
13606 get_64bit_section_headers (file, 1);
13607 }
560f3c1c 13608
252b5132
RH		 13609 return 1;
13610}
13611
fb52b2f4
NC		 13612/* Process one ELF object file according to the command line options.
13613 This file may actually be stored in an archive. The file is
13614 positioned at the start of the ELF object. */
13615
ff78d6d6 13616static int
2cf0635d 13617process_object (char * file_name, FILE * file)
252b5132 13618{
252b5132
RH		 13619 unsigned int i;
13620
252b5132
RH		 13621 if (! get_file_header (file))
13622 {
13623 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13624 return 1;
252b5132
RH		 13625 }
13626
13627 /* Initialise per file variables. */
60bca95a 13628 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13629 version_info[i] = 0;
13630
60bca95a 13631 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13632 dynamic_info[i] = 0;
5115b233 13633 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13634
13635 /* Process the file. */
13636 if (show_name)
13637 printf (_("\nFile: %s\n"), file_name);
13638
18bd398b
NC		 13639 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13640 Note we do this even if cmdline_dump_sects is empty because we
13641 must make sure that the dump_sets array is zeroed out before each
13642 object file is processed. */
13643 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13644 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13645
13646 if (num_cmdline_dump_sects > 0)
13647 {
13648 if (num_dump_sects == 0)
13649 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13650 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13651
13652 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13653 memcpy (dump_sects, cmdline_dump_sects,
13654 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13655 }
d70c5fc7 13656
252b5132 13657 if (! process_file_header ())
fb52b2f4 13658 return 1;
252b5132 13659
d1f5c6e3 13660 if (! process_section_headers (file))
2f62977e 13661 {
d1f5c6e3
L		 13662 /* Without loaded section headers we cannot process lots of
13663 things. */
2f62977e 13664 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13665
2f62977e 13666 if (! do_using_dynamic)
2c610e4b 13667 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13668 }
252b5132 13669
d1f5c6e3
L		 13670 if (! process_section_groups (file))
13671 {
13672 /* Without loaded section groups we cannot process unwind. */
13673 do_unwind = 0;
13674 }
13675
2f62977e 13676 if (process_program_headers (file))
b2d38a17 13677 process_dynamic_section (file);
252b5132
RH		 13678
13679 process_relocs (file);
13680
4d6ed7c8
NC		 13681 process_unwind (file);
13682
252b5132
RH		 13683 process_symbol_table (file);
13684
13685 process_syminfo (file);
13686
13687 process_version_sections (file);
13688
13689 process_section_contents (file);
f5842774 13690
1ec5cd37 13691 process_notes (file);
103f02d3 13692
047b2264
JJ		 13693 process_gnu_liblist (file);
13694
252b5132
RH		 13695 process_arch_specific (file);
13696
d93f0186
NC		 13697 if (program_headers)
13698 {
13699 free (program_headers);
13700 program_headers = NULL;
13701 }
13702
252b5132
RH		 13703 if (section_headers)
13704 {
13705 free (section_headers);
13706 section_headers = NULL;
13707 }
13708
13709 if (string_table)
13710 {
13711 free (string_table);
13712 string_table = NULL;
d40ac9bd 13713 string_table_length = 0;
252b5132
RH		 13714 }
13715
13716 if (dynamic_strings)
13717 {
13718 free (dynamic_strings);
13719 dynamic_strings = NULL;
d79b3d50 13720 dynamic_strings_length = 0;
252b5132
RH		 13721 }
13722
13723 if (dynamic_symbols)
13724 {
13725 free (dynamic_symbols);
13726 dynamic_symbols = NULL;
19936277 13727 num_dynamic_syms = 0;
252b5132
RH		 13728 }
13729
13730 if (dynamic_syminfo)
13731 {
13732 free (dynamic_syminfo);
13733 dynamic_syminfo = NULL;
13734 }
ff78d6d6 13735
293c573e
MR		 13736 if (dynamic_section)
13737 {
13738 free (dynamic_section);
13739 dynamic_section = NULL;
13740 }
13741
e4b17d5c
L		 13742 if (section_headers_groups)
13743 {
13744 free (section_headers_groups);
13745 section_headers_groups = NULL;
13746 }
13747
13748 if (section_groups)
13749 {
2cf0635d
NC		 13750 struct group_list * g;
13751 struct group_list * next;
e4b17d5c
L		 13752
13753 for (i = 0; i < group_count; i++)
13754 {
13755 for (g = section_groups [i].root; g != NULL; g = next)
13756 {
13757 next = g->next;
13758 free (g);
13759 }
13760 }
13761
13762 free (section_groups);
13763 section_groups = NULL;
13764 }
13765
19e6b90e 13766 free_debug_memory ();
18bd398b 13767
ff78d6d6 13768 return 0;
252b5132
RH		 13769}
13770
2cf0635d
NC		 13771/* Process an ELF archive.
13772 On entry the file is positioned just after the ARMAG string. */
13773
13774static int
13775process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13776{
13777 struct archive_info arch;
13778 struct archive_info nested_arch;
13779 size_t got;
2cf0635d
NC		 13780 int ret;
13781
13782 show_name = 1;
13783
13784 /* The ARCH structure is used to hold information about this archive. */
13785 arch.file_name = NULL;
13786 arch.file = NULL;
13787 arch.index_array = NULL;
13788 arch.sym_table = NULL;
13789 arch.longnames = NULL;
13790
13791 /* The NESTED_ARCH structure is used as a single-item cache of information
13792 about a nested archive (when members of a thin archive reside within
13793 another regular archive file). */
13794 nested_arch.file_name = NULL;
13795 nested_arch.file = NULL;
13796 nested_arch.index_array = NULL;
13797 nested_arch.sym_table = NULL;
13798 nested_arch.longnames = NULL;
13799
13800 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13801 {
13802 ret = 1;
13803 goto out;
4145f1d5 13804 }
fb52b2f4 13805
4145f1d5
NC		 13806 if (do_archive_index)
13807 {
2cf0635d 13808 if (arch.sym_table == NULL)
4145f1d5
NC		 13809 error (_("%s: unable to dump the index as none was found\n"), file_name);
13810 else
13811 {
2cf0635d 13812 unsigned int i, l;
4145f1d5
NC		 13813 unsigned long current_pos;
13814
13815 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 13816 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 13817 current_pos = ftell (file);
13818
2cf0635d 13819 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13820 {
2cf0635d
NC		 13821 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13822 {
13823 char * member_name;
4145f1d5 13824
2cf0635d
NC		 13825 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13826
13827 if (member_name != NULL)
13828 {
13829 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13830
13831 if (qualified_name != NULL)
13832 {
c2a7d3f5
NC		 13833 printf (_("Contents of binary %s at offset "), qualified_name);
13834 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13835 putchar ('\n');
2cf0635d
NC		 13836 free (qualified_name);
13837 }
4145f1d5
NC		 13838 }
13839 }
2cf0635d
NC		 13840
13841 if (l >= arch.sym_size)
4145f1d5
NC		 13842 {
13843 error (_("%s: end of the symbol table reached before the end of the index\n"),
13844 file_name);
cb8f3167 13845 break;
4145f1d5 13846 }
2cf0635d
NC		 13847 printf ("\t%s\n", arch.sym_table + l);
13848 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13849 }
13850
c2a7d3f5
NC		 13851 if (arch.uses_64bit_indicies)
13852 l = (l + 7) & ~ 7;
13853 else
13854 l += l & 1;
13855
2cf0635d 13856 if (l < arch.sym_size)
c2a7d3f5
NC		 13857 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13858 file_name, arch.sym_size - l);
4145f1d5 13859
4145f1d5
NC		 13860 if (fseek (file, current_pos, SEEK_SET) != 0)
13861 {
13862 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13863 ret = 1;
13864 goto out;
4145f1d5 13865 }
fb52b2f4 13866 }
4145f1d5
NC		 13867
13868 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13869 && !do_segments && !do_header && !do_dump && !do_version
13870 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13871 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13872 {
13873 ret = 0; /* Archive index only. */
13874 goto out;
13875 }
fb52b2f4
NC		 13876 }
13877
d989285c 13878 ret = 0;
fb52b2f4
NC		 13879
13880 while (1)
13881 {
2cf0635d
NC		 13882 char * name;
13883 size_t namelen;
13884 char * qualified_name;
13885
13886 /* Read the next archive header. */
13887 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13888 {
13889 error (_("%s: failed to seek to next archive header\n"), file_name);
13890 return 1;
13891 }
13892 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13893 if (got != sizeof arch.arhdr)
13894 {
13895 if (got == 0)
13896 break;
13897 error (_("%s: failed to read archive header\n"), file_name);
13898 ret = 1;
13899 break;
13900 }
13901 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13902 {
13903 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13904 ret = 1;
13905 break;
13906 }
13907
13908 arch.next_arhdr_offset += sizeof arch.arhdr;
13909
13910 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13911 if (archive_file_size & 01)
13912 ++archive_file_size;
13913
13914 name = get_archive_member_name (&arch, &nested_arch);
13915 if (name == NULL)
fb52b2f4 13916 {
0fd3a477 13917 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13918 ret = 1;
13919 break;
fb52b2f4 13920 }
2cf0635d 13921 namelen = strlen (name);
fb52b2f4 13922
2cf0635d
NC		 13923 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13924 if (qualified_name == NULL)
fb52b2f4 13925 {
2cf0635d 13926 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13927 ret = 1;
13928 break;
fb52b2f4
NC		 13929 }
13930
2cf0635d
NC		 13931 if (is_thin_archive && arch.nested_member_origin == 0)
13932 {
13933 /* This is a proxy for an external member of a thin archive. */
13934 FILE * member_file;
13935 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13936 if (member_file_name == NULL)
13937 {
13938 ret = 1;
13939 break;
13940 }
13941
13942 member_file = fopen (member_file_name, "rb");
13943 if (member_file == NULL)
13944 {
13945 error (_("Input file '%s' is not readable.\n"), member_file_name);
13946 free (member_file_name);
13947 ret = 1;
13948 break;
13949 }
13950
13951 archive_file_offset = arch.nested_member_origin;
13952
13953 ret |= process_object (qualified_name, member_file);
13954
13955 fclose (member_file);
13956 free (member_file_name);
13957 }
13958 else if (is_thin_archive)
13959 {
13960 /* This is a proxy for a member of a nested archive. */
13961 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13962
13963 /* The nested archive file will have been opened and setup by
13964 get_archive_member_name. */
13965 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13966 {
13967 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13968 ret = 1;
13969 break;
13970 }
13971
13972 ret |= process_object (qualified_name, nested_arch.file);
13973 }
13974 else
13975 {
13976 archive_file_offset = arch.next_arhdr_offset;
13977 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13978
2cf0635d
NC		 13979 ret |= process_object (qualified_name, file);
13980 }
fb52b2f4 13981
2b52916e
L		 13982 if (dump_sects != NULL)
13983 {
13984 free (dump_sects);
13985 dump_sects = NULL;
13986 num_dump_sects = 0;
13987 }
13988
2cf0635d 13989 free (qualified_name);
fb52b2f4
NC		 13990 }
13991
4145f1d5 13992 out:
2cf0635d
NC		 13993 if (nested_arch.file != NULL)
13994 fclose (nested_arch.file);
13995 release_archive (&nested_arch);
13996 release_archive (&arch);
fb52b2f4 13997
d989285c 13998 return ret;
fb52b2f4
NC		 13999}
14000
14001static int
2cf0635d 14002process_file (char * file_name)
fb52b2f4 14003{
2cf0635d 14004 FILE * file;
fb52b2f4
NC		 14005 struct stat statbuf;
14006 char armag[SARMAG];
14007 int ret;
14008
14009 if (stat (file_name, &statbuf) < 0)
14010 {
f24ddbdd
NC		 14011 if (errno == ENOENT)
14012 error (_("'%s': No such file\n"), file_name);
14013 else
14014 error (_("Could not locate '%s'. System error message: %s\n"),
14015 file_name, strerror (errno));
14016 return 1;
14017 }
14018
14019 if (! S_ISREG (statbuf.st_mode))
14020 {
14021 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 14022 return 1;
14023 }
14024
14025 file = fopen (file_name, "rb");
14026 if (file == NULL)
14027 {
f24ddbdd 14028 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 14029 return 1;
14030 }
14031
14032 if (fread (armag, SARMAG, 1, file) != 1)
14033 {
4145f1d5 14034 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 14035 fclose (file);
14036 return 1;
14037 }
14038
14039 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 14040 ret = process_archive (file_name, file, FALSE);
14041 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14042 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 14043 else
14044 {
4145f1d5
NC		 14045 if (do_archive_index)
14046 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14047 file_name);
14048
fb52b2f4
NC		 14049 rewind (file);
14050 archive_file_size = archive_file_offset = 0;
14051 ret = process_object (file_name, file);
14052 }
14053
14054 fclose (file);
14055
14056 return ret;
14057}
14058
252b5132
RH		 14059#ifdef SUPPORT_DISASSEMBLY
14060/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 14061 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 14062 symbols. */
252b5132
RH		 14063
14064void
2cf0635d 14065print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 14066{
14067 fprintf (outfile,"0x%8.8x", addr);
14068}
14069
e3c8793a 14070/* Needed by the i386 disassembler. */
252b5132
RH		 14071void
14072db_task_printsym (unsigned int addr)
14073{
14074 print_address (addr, stderr);
14075}
14076#endif
14077
14078int
2cf0635d 14079main (int argc, char ** argv)
252b5132 14080{
ff78d6d6
L		 14081 int err;
14082
252b5132
RH		 14083#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14084 setlocale (LC_MESSAGES, "");
3882b010
L		 14085#endif
14086#if defined (HAVE_SETLOCALE)
14087 setlocale (LC_CTYPE, "");
252b5132
RH		 14088#endif
14089 bindtextdomain (PACKAGE, LOCALEDIR);
14090 textdomain (PACKAGE);
14091
869b9d07
MM		 14092 expandargv (&argc, &argv);
14093
252b5132
RH		 14094 parse_args (argc, argv);
14095
18bd398b 14096 if (num_dump_sects > 0)
59f14fc0 14097 {
18bd398b 14098 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 14099 cmdline_dump_sects = (dump_type *)
14100 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 14101 if (cmdline_dump_sects == NULL)
591a748a 14102 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 14103 else
14104 {
09c11c86
NC		 14105 memcpy (cmdline_dump_sects, dump_sects,
14106 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 14107 num_cmdline_dump_sects = num_dump_sects;
14108 }
14109 }
14110
18bd398b
NC		 14111 if (optind < (argc - 1))
14112 show_name = 1;
14113
ff78d6d6 14114 err = 0;
252b5132 14115 while (optind < argc)
18bd398b 14116 err |= process_file (argv[optind++]);
252b5132
RH		 14117
14118 if (dump_sects != NULL)
14119 free (dump_sects);
59f14fc0
AS		 14120 if (cmdline_dump_sects != NULL)
14121 free (cmdline_dump_sects);
252b5132 14122
ff78d6d6 14123 return err;
252b5132 14124}
A mirror of the official binutils-gdb repository