]> 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
*** empty log message ***
[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 {
1cd986c5
NC		 2479 case E_V850E2V3_ARCH:
2480 strcat (buf, ", v850e2v3");
2481 break;
2482 case E_V850E2_ARCH:
2483 strcat (buf, ", v850e2");
2484 break;
2485 case E_V850E1_ARCH:
2486 strcat (buf, ", v850e1");
8ad30312 2487 break;
252b5132
RH		 2488 case E_V850E_ARCH:
2489 strcat (buf, ", v850e");
2490 break;
252b5132
RH		 2491 case E_V850_ARCH:
2492 strcat (buf, ", v850");
2493 break;
2494 default:
2b692964 2495 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2496 break;
2497 }
2498 break;
2499
2b0337b0 2500 case EM_M32R:
252b5132
RH		 2501 case EM_CYGNUS_M32R:
2502 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2503 strcat (buf, ", m32r");
252b5132
RH		 2504 break;
2505
2506 case EM_MIPS:
4fe85591 2507 case EM_MIPS_RS3_LE:
252b5132
RH		 2508 if (e_flags & EF_MIPS_NOREORDER)
2509 strcat (buf, ", noreorder");
2510
2511 if (e_flags & EF_MIPS_PIC)
2512 strcat (buf, ", pic");
2513
2514 if (e_flags & EF_MIPS_CPIC)
2515 strcat (buf, ", cpic");
2516
d1bdd336
TS		 2517 if (e_flags & EF_MIPS_UCODE)
2518 strcat (buf, ", ugen_reserved");
2519
252b5132
RH		 2520 if (e_flags & EF_MIPS_ABI2)
2521 strcat (buf, ", abi2");
2522
43521d43
TS		 2523 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2524 strcat (buf, ", odk first");
2525
a5d22d2a
TS		 2526 if (e_flags & EF_MIPS_32BITMODE)
2527 strcat (buf, ", 32bitmode");
2528
156c2f8b
NC		 2529 switch ((e_flags & EF_MIPS_MACH))
2530 {
2531 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2532 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2533 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2534 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2535 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2536 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2537 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2538 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2539 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2540 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2541 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2542 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2543 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2544 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2545 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2546 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2547 case 0:
2548 /* We simply ignore the field in this case to avoid confusion:
2549 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2550 extension. */
2551 break;
2b692964 2552 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2553 }
43521d43
TS		 2554
2555 switch ((e_flags & EF_MIPS_ABI))
2556 {
2557 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2558 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2559 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2560 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2561 case 0:
2562 /* We simply ignore the field in this case to avoid confusion:
2563 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2564 This means it is likely to be an o32 file, but not for
2565 sure. */
2566 break;
2b692964 2567 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2568 }
2569
2570 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2571 strcat (buf, ", mdmx");
2572
2573 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2574 strcat (buf, ", mips16");
2575
df58fc94
RS		 2576 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2577 strcat (buf, ", micromips");
2578
43521d43
TS		 2579 switch ((e_flags & EF_MIPS_ARCH))
2580 {
2581 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2582 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2583 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2584 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2585 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2586 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2587 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2588 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2589 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2590 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2591 }
252b5132 2592 break;
351b4b40 2593
ccde1100
AO		 2594 case EM_SH:
2595 switch ((e_flags & EF_SH_MACH_MASK))
2596 {
2597 case EF_SH1: strcat (buf, ", sh1"); break;
2598 case EF_SH2: strcat (buf, ", sh2"); break;
2599 case EF_SH3: strcat (buf, ", sh3"); break;
2600 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2601 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2602 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2603 case EF_SH3E: strcat (buf, ", sh3e"); break;
2604 case EF_SH4: strcat (buf, ", sh4"); break;
2605 case EF_SH5: strcat (buf, ", sh5"); break;
2606 case EF_SH2E: strcat (buf, ", sh2e"); break;
2607 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2608 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2609 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2610 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2611 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2612 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2613 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2614 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2615 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2616 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2617 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2618 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2619 }
2620
cec6a5b8
MR		 2621 if (e_flags & EF_SH_PIC)
2622 strcat (buf, ", pic");
2623
2624 if (e_flags & EF_SH_FDPIC)
2625 strcat (buf, ", fdpic");
ccde1100 2626 break;
57346661 2627
351b4b40
RH		 2628 case EM_SPARCV9:
2629 if (e_flags & EF_SPARC_32PLUS)
2630 strcat (buf, ", v8+");
2631
2632 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2633 strcat (buf, ", ultrasparcI");
2634
2635 if (e_flags & EF_SPARC_SUN_US3)
2636 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2637
2638 if (e_flags & EF_SPARC_HAL_R1)
2639 strcat (buf, ", halr1");
2640
2641 if (e_flags & EF_SPARC_LEDATA)
2642 strcat (buf, ", ledata");
2643
2644 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2645 strcat (buf, ", tso");
2646
2647 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2648 strcat (buf, ", pso");
2649
2650 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2651 strcat (buf, ", rmo");
2652 break;
7d466069 2653
103f02d3
UD		 2654 case EM_PARISC:
2655 switch (e_flags & EF_PARISC_ARCH)
2656 {
2657 case EFA_PARISC_1_0:
2658 strcpy (buf, ", PA-RISC 1.0");
2659 break;
2660 case EFA_PARISC_1_1:
2661 strcpy (buf, ", PA-RISC 1.1");
2662 break;
2663 case EFA_PARISC_2_0:
2664 strcpy (buf, ", PA-RISC 2.0");
2665 break;
2666 default:
2667 break;
2668 }
2669 if (e_flags & EF_PARISC_TRAPNIL)
2670 strcat (buf, ", trapnil");
2671 if (e_flags & EF_PARISC_EXT)
2672 strcat (buf, ", ext");
2673 if (e_flags & EF_PARISC_LSB)
2674 strcat (buf, ", lsb");
2675 if (e_flags & EF_PARISC_WIDE)
2676 strcat (buf, ", wide");
2677 if (e_flags & EF_PARISC_NO_KABP)
2678 strcat (buf, ", no kabp");
2679 if (e_flags & EF_PARISC_LAZYSWAP)
2680 strcat (buf, ", lazyswap");
30800947 2681 break;
76da6bbe 2682
7d466069 2683 case EM_PJ:
2b0337b0 2684 case EM_PJ_OLD:
7d466069
ILT		 2685 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2686 strcat (buf, ", new calling convention");
2687
2688 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2689 strcat (buf, ", gnu calling convention");
2690 break;
4d6ed7c8
NC		 2691
2692 case EM_IA_64:
2693 if ((e_flags & EF_IA_64_ABI64))
2694 strcat (buf, ", 64-bit");
2695 else
2696 strcat (buf, ", 32-bit");
2697 if ((e_flags & EF_IA_64_REDUCEDFP))
2698 strcat (buf, ", reduced fp model");
2699 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2700 strcat (buf, ", no function descriptors, constant gp");
2701 else if ((e_flags & EF_IA_64_CONS_GP))
2702 strcat (buf, ", constant gp");
2703 if ((e_flags & EF_IA_64_ABSOLUTE))
2704 strcat (buf, ", absolute");
28f997cf
TG		 2705 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2706 {
2707 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2708 strcat (buf, ", vms_linkages");
2709 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2710 {
2711 case EF_IA_64_VMS_COMCOD_SUCCESS:
2712 break;
2713 case EF_IA_64_VMS_COMCOD_WARNING:
2714 strcat (buf, ", warning");
2715 break;
2716 case EF_IA_64_VMS_COMCOD_ERROR:
2717 strcat (buf, ", error");
2718 break;
2719 case EF_IA_64_VMS_COMCOD_ABORT:
2720 strcat (buf, ", abort");
2721 break;
2722 default:
2723 abort ();
2724 }
2725 }
4d6ed7c8 2726 break;
179d3252
JT		 2727
2728 case EM_VAX:
2729 if ((e_flags & EF_VAX_NONPIC))
2730 strcat (buf, ", non-PIC");
2731 if ((e_flags & EF_VAX_DFLOAT))
2732 strcat (buf, ", D-Float");
2733 if ((e_flags & EF_VAX_GFLOAT))
2734 strcat (buf, ", G-Float");
2735 break;
c7927a3c
NC		 2736
2737 case EM_RX:
2738 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2739 strcat (buf, ", 64-bit doubles");
2740 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2741 strcat (buf, ", dsp");
d4cb0ea0
NC		 2742 if (e_flags & E_FLAG_RX_PID)
2743 strcat (buf, ", pid");
708e2187
NC		 2744 if (e_flags & E_FLAG_RX_ABI)
2745 strcat (buf, ", RX ABI");
d4cb0ea0 2746 break;
55786da2
AK		 2747
2748 case EM_S390:
2749 if (e_flags & EF_S390_HIGH_GPRS)
2750 strcat (buf, ", highgprs");
d4cb0ea0 2751 break;
40b36596
JM		 2752
2753 case EM_TI_C6000:
2754 if ((e_flags & EF_C6000_REL))
2755 strcat (buf, ", relocatable module");
d4cb0ea0 2756 break;
252b5132
RH		 2757 }
2758 }
2759
2760 return buf;
2761}
2762
252b5132 2763static const char *
d3ba0551
AM		 2764get_osabi_name (unsigned int osabi)
2765{
2766 static char buff[32];
2767
2768 switch (osabi)
2769 {
2770 case ELFOSABI_NONE: return "UNIX - System V";
2771 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2772 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2773 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2774 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2775 case ELFOSABI_AIX: return "UNIX - AIX";
2776 case ELFOSABI_IRIX: return "UNIX - IRIX";
2777 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2778 case ELFOSABI_TRU64: return "UNIX - TRU64";
2779 case ELFOSABI_MODESTO: return "Novell - Modesto";
2780 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2781 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2782 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2783 case ELFOSABI_AROS: return "AROS";
11636f9e 2784 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2785 default:
40b36596
JM		 2786 if (osabi >= 64)
2787 switch (elf_header.e_machine)
2788 {
2789 case EM_ARM:
2790 switch (osabi)
2791 {
2792 case ELFOSABI_ARM: return "ARM";
2793 default:
2794 break;
2795 }
2796 break;
2797
2798 case EM_MSP430:
2799 case EM_MSP430_OLD:
2800 switch (osabi)
2801 {
2802 case ELFOSABI_STANDALONE: return _("Standalone App");
2803 default:
2804 break;
2805 }
2806 break;
2807
2808 case EM_TI_C6000:
2809 switch (osabi)
2810 {
2811 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2812 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2813 default:
2814 break;
2815 }
2816 break;
2817
2818 default:
2819 break;
2820 }
e9e44622 2821 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2822 return buff;
2823 }
2824}
2825
a06ea964
NC		 2826static const char *
2827get_aarch64_segment_type (unsigned long type)
2828{
2829 switch (type)
2830 {
2831 case PT_AARCH64_ARCHEXT:
2832 return "AARCH64_ARCHEXT";
2833 default:
2834 break;
2835 }
2836
2837 return NULL;
2838}
2839
b294bdf8
MM		 2840static const char *
2841get_arm_segment_type (unsigned long type)
2842{
2843 switch (type)
2844 {
2845 case PT_ARM_EXIDX:
2846 return "EXIDX";
2847 default:
2848 break;
2849 }
2850
2851 return NULL;
2852}
2853
d3ba0551
AM		 2854static const char *
2855get_mips_segment_type (unsigned long type)
252b5132
RH		 2856{
2857 switch (type)
2858 {
2859 case PT_MIPS_REGINFO:
2860 return "REGINFO";
2861 case PT_MIPS_RTPROC:
2862 return "RTPROC";
2863 case PT_MIPS_OPTIONS:
2864 return "OPTIONS";
2865 default:
2866 break;
2867 }
2868
2869 return NULL;
2870}
2871
103f02d3 2872static const char *
d3ba0551 2873get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2874{
2875 switch (type)
2876 {
2877 case PT_HP_TLS: return "HP_TLS";
2878 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2879 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2880 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2881 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2882 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2883 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2884 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2885 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2886 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2887 case PT_HP_PARALLEL: return "HP_PARALLEL";
2888 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2889 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2890 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2891 case PT_HP_STACK: return "HP_STACK";
2892 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2893 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2894 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2895 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2896 default:
2897 break;
2898 }
2899
2900 return NULL;
2901}
2902
4d6ed7c8 2903static const char *
d3ba0551 2904get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2905{
2906 switch (type)
2907 {
2908 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2909 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2910 case PT_HP_TLS: return "HP_TLS";
2911 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2912 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2913 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2914 default:
2915 break;
2916 }
2917
2918 return NULL;
2919}
2920
40b36596
JM		 2921static const char *
2922get_tic6x_segment_type (unsigned long type)
2923{
2924 switch (type)
2925 {
2926 case PT_C6000_PHATTR: return "C6000_PHATTR";
2927 default:
2928 break;
2929 }
2930
2931 return NULL;
2932}
2933
252b5132 2934static const char *
d3ba0551 2935get_segment_type (unsigned long p_type)
252b5132 2936{
b34976b6 2937 static char buff[32];
252b5132
RH		 2938
2939 switch (p_type)
2940 {
b34976b6
AM		 2941 case PT_NULL: return "NULL";
2942 case PT_LOAD: return "LOAD";
252b5132 2943 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2944 case PT_INTERP: return "INTERP";
2945 case PT_NOTE: return "NOTE";
2946 case PT_SHLIB: return "SHLIB";
2947 case PT_PHDR: return "PHDR";
13ae64f3 2948 case PT_TLS: return "TLS";
252b5132 2949
65765700
JJ		 2950 case PT_GNU_EH_FRAME:
2951 return "GNU_EH_FRAME";
2b05f1b7 2952 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2953 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2954
252b5132
RH		 2955 default:
2956 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2957 {
2cf0635d 2958 const char * result;
103f02d3 2959
252b5132
RH		 2960 switch (elf_header.e_machine)
2961 {
a06ea964
NC		 2962 case EM_AARCH64:
2963 result = get_aarch64_segment_type (p_type);
2964 break;
b294bdf8
MM		 2965 case EM_ARM:
2966 result = get_arm_segment_type (p_type);
2967 break;
252b5132 2968 case EM_MIPS:
4fe85591 2969 case EM_MIPS_RS3_LE:
252b5132
RH		 2970 result = get_mips_segment_type (p_type);
2971 break;
103f02d3
UD		 2972 case EM_PARISC:
2973 result = get_parisc_segment_type (p_type);
2974 break;
4d6ed7c8
NC		 2975 case EM_IA_64:
2976 result = get_ia64_segment_type (p_type);
2977 break;
40b36596
JM		 2978 case EM_TI_C6000:
2979 result = get_tic6x_segment_type (p_type);
2980 break;
252b5132
RH		 2981 default:
2982 result = NULL;
2983 break;
2984 }
103f02d3 2985
252b5132
RH		 2986 if (result != NULL)
2987 return result;
103f02d3 2988
252b5132
RH		 2989 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2990 }
2991 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2992 {
2cf0635d 2993 const char * result;
103f02d3
UD		 2994
2995 switch (elf_header.e_machine)
2996 {
2997 case EM_PARISC:
2998 result = get_parisc_segment_type (p_type);
2999 break;
00428cca
AM		 3000 case EM_IA_64:
3001 result = get_ia64_segment_type (p_type);
3002 break;
103f02d3
UD		 3003 default:
3004 result = NULL;
3005 break;
3006 }
3007
3008 if (result != NULL)
3009 return result;
3010
3011 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3012 }
252b5132 3013 else
e9e44622 3014 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3015
3016 return buff;
3017 }
3018}
3019
3020static const char *
d3ba0551 3021get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3022{
3023 switch (sh_type)
3024 {
b34976b6
AM		 3025 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3026 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3027 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3028 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3029 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3030 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3031 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3032 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3033 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3034 case SHT_MIPS_RELD: return "MIPS_RELD";
3035 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3036 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3037 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3038 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3039 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3040 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3041 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3042 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3043 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3044 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3045 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3046 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3047 case SHT_MIPS_LINE: return "MIPS_LINE";
3048 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3049 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3050 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3051 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3052 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3053 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3054 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3055 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3056 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3057 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3058 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3059 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3060 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3061 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3062 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 3063 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3064 default:
3065 break;
3066 }
3067 return NULL;
3068}
3069
103f02d3 3070static const char *
d3ba0551 3071get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3072{
3073 switch (sh_type)
3074 {
3075 case SHT_PARISC_EXT: return "PARISC_EXT";
3076 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3077 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3078 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3079 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3080 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3081 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3082 default:
3083 break;
3084 }
3085 return NULL;
3086}
3087
4d6ed7c8 3088static const char *
d3ba0551 3089get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3090{
18bd398b 3091 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3092 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3093 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3094
4d6ed7c8
NC		 3095 switch (sh_type)
3096 {
148b93f2
NC		 3097 case SHT_IA_64_EXT: return "IA_64_EXT";
3098 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3099 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3100 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3101 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3102 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3103 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3104 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3105 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3106 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3107 default:
3108 break;
3109 }
3110 return NULL;
3111}
3112
d2b2c203
DJ		 3113static const char *
3114get_x86_64_section_type_name (unsigned int sh_type)
3115{
3116 switch (sh_type)
3117 {
3118 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3119 default:
3120 break;
3121 }
3122 return NULL;
3123}
3124
a06ea964
NC		 3125static const char *
3126get_aarch64_section_type_name (unsigned int sh_type)
3127{
3128 switch (sh_type)
3129 {
3130 case SHT_AARCH64_ATTRIBUTES:
3131 return "AARCH64_ATTRIBUTES";
3132 default:
3133 break;
3134 }
3135 return NULL;
3136}
3137
40a18ebd
NC		 3138static const char *
3139get_arm_section_type_name (unsigned int sh_type)
3140{
3141 switch (sh_type)
3142 {
7f6fed87
NC		 3143 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3144 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3145 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3146 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3147 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3148 default:
3149 break;
3150 }
3151 return NULL;
3152}
3153
40b36596
JM		 3154static const char *
3155get_tic6x_section_type_name (unsigned int sh_type)
3156{
3157 switch (sh_type)
3158 {
3159 case SHT_C6000_UNWIND:
3160 return "C6000_UNWIND";
3161 case SHT_C6000_PREEMPTMAP:
3162 return "C6000_PREEMPTMAP";
3163 case SHT_C6000_ATTRIBUTES:
3164 return "C6000_ATTRIBUTES";
3165 case SHT_TI_ICODE:
3166 return "TI_ICODE";
3167 case SHT_TI_XREF:
3168 return "TI_XREF";
3169 case SHT_TI_HANDLER:
3170 return "TI_HANDLER";
3171 case SHT_TI_INITINFO:
3172 return "TI_INITINFO";
3173 case SHT_TI_PHATTRS:
3174 return "TI_PHATTRS";
3175 default:
3176 break;
3177 }
3178 return NULL;
3179}
3180
252b5132 3181static const char *
d3ba0551 3182get_section_type_name (unsigned int sh_type)
252b5132 3183{
b34976b6 3184 static char buff[32];
252b5132
RH		 3185
3186 switch (sh_type)
3187 {
3188 case SHT_NULL: return "NULL";
3189 case SHT_PROGBITS: return "PROGBITS";
3190 case SHT_SYMTAB: return "SYMTAB";
3191 case SHT_STRTAB: return "STRTAB";
3192 case SHT_RELA: return "RELA";
3193 case SHT_HASH: return "HASH";
3194 case SHT_DYNAMIC: return "DYNAMIC";
3195 case SHT_NOTE: return "NOTE";
3196 case SHT_NOBITS: return "NOBITS";
3197 case SHT_REL: return "REL";
3198 case SHT_SHLIB: return "SHLIB";
3199 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3200 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3201 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3202 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3203 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3204 case SHT_GROUP: return "GROUP";
3205 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3206 case SHT_GNU_verdef: return "VERDEF";
3207 case SHT_GNU_verneed: return "VERNEED";
3208 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3209 case 0x6ffffff0: return "VERSYM";
3210 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3211 case 0x7ffffffd: return "AUXILIARY";
3212 case 0x7fffffff: return "FILTER";
047b2264 3213 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3214
3215 default:
3216 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3217 {
2cf0635d 3218 const char * result;
252b5132
RH		 3219
3220 switch (elf_header.e_machine)
3221 {
3222 case EM_MIPS:
4fe85591 3223 case EM_MIPS_RS3_LE:
252b5132
RH		 3224 result = get_mips_section_type_name (sh_type);
3225 break;
103f02d3
UD		 3226 case EM_PARISC:
3227 result = get_parisc_section_type_name (sh_type);
3228 break;
4d6ed7c8
NC		 3229 case EM_IA_64:
3230 result = get_ia64_section_type_name (sh_type);
3231 break;
d2b2c203 3232 case EM_X86_64:
8a9036a4 3233 case EM_L1OM:
7a9068fe 3234 case EM_K1OM:
d2b2c203
DJ		 3235 result = get_x86_64_section_type_name (sh_type);
3236 break;
a06ea964
NC		 3237 case EM_AARCH64:
3238 result = get_aarch64_section_type_name (sh_type);
3239 break;
40a18ebd
NC		 3240 case EM_ARM:
3241 result = get_arm_section_type_name (sh_type);
3242 break;
40b36596
JM		 3243 case EM_TI_C6000:
3244 result = get_tic6x_section_type_name (sh_type);
3245 break;
252b5132
RH		 3246 default:
3247 result = NULL;
3248 break;
3249 }
3250
3251 if (result != NULL)
3252 return result;
3253
c91d0dfb 3254 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3255 }
3256 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3257 {
2cf0635d 3258 const char * result;
148b93f2
NC		 3259
3260 switch (elf_header.e_machine)
3261 {
3262 case EM_IA_64:
3263 result = get_ia64_section_type_name (sh_type);
3264 break;
3265 default:
3266 result = NULL;
3267 break;
3268 }
3269
3270 if (result != NULL)
3271 return result;
3272
3273 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3274 }
252b5132 3275 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3276 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3277 else
a7dbfd1c
NC		 3278 /* This message is probably going to be displayed in a 15
3279 character wide field, so put the hex value first. */
3280 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3281
252b5132
RH		 3282 return buff;
3283 }
3284}
3285
2979dc34 3286#define OPTION_DEBUG_DUMP 512
2c610e4b 3287#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3288#define OPTION_DWARF_DEPTH 514
3289#define OPTION_DWARF_START 515
4723351a 3290#define OPTION_DWARF_CHECK 516
2979dc34 3291
85b1c36d 3292static struct option options[] =
252b5132 3293{
b34976b6 3294 {"all", no_argument, 0, 'a'},
252b5132
RH		 3295 {"file-header", no_argument, 0, 'h'},
3296 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3297 {"headers", no_argument, 0, 'e'},
3298 {"histogram", no_argument, 0, 'I'},
3299 {"segments", no_argument, 0, 'l'},
3300 {"sections", no_argument, 0, 'S'},
252b5132 3301 {"section-headers", no_argument, 0, 'S'},
f5842774 3302 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3303 {"section-details", no_argument, 0, 't'},
595cf52e 3304 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3305 {"symbols", no_argument, 0, 's'},
3306 {"syms", no_argument, 0, 's'},
2c610e4b 3307 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3308 {"relocs", no_argument, 0, 'r'},
3309 {"notes", no_argument, 0, 'n'},
3310 {"dynamic", no_argument, 0, 'd'},
a952a375 3311 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3312 {"version-info", no_argument, 0, 'V'},
3313 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3314 {"unwind", no_argument, 0, 'u'},
4145f1d5 3315 {"archive-index", no_argument, 0, 'c'},
b34976b6 3316 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3317 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3318 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3319#ifdef SUPPORT_DISASSEMBLY
3320 {"instruction-dump", required_argument, 0, 'i'},
3321#endif
cf13d699 3322 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3323
fd2f0033
TT		 3324 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3325 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3326 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3327
b34976b6
AM		 3328 {"version", no_argument, 0, 'v'},
3329 {"wide", no_argument, 0, 'W'},
3330 {"help", no_argument, 0, 'H'},
3331 {0, no_argument, 0, 0}
252b5132
RH		 3332};
3333
3334static void
2cf0635d 3335usage (FILE * stream)
252b5132 3336{
92f01d61
JM		 3337 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3338 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3339 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3340 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3341 -h --file-header Display the ELF file header\n\
3342 -l --program-headers Display the program headers\n\
3343 --segments An alias for --program-headers\n\
3344 -S --section-headers Display the sections' header\n\
3345 --sections An alias for --section-headers\n\
f5842774 3346 -g --section-groups Display the section groups\n\
5477e8a0 3347 -t --section-details Display the section details\n\
8b53311e
NC		 3348 -e --headers Equivalent to: -h -l -S\n\
3349 -s --syms Display the symbol table\n\
3f08eb35 3350 --symbols An alias for --syms\n\
2c610e4b 3351 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3352 -n --notes Display the core notes (if present)\n\
3353 -r --relocs Display the relocations (if present)\n\
3354 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3355 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3356 -V --version-info Display the version sections (if present)\n\
1b31d05e 3357 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3358 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3359 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3360 -x --hex-dump=<number|name>\n\
3361 Dump the contents of section <number|name> as bytes\n\
3362 -p --string-dump=<number|name>\n\
3363 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3364 -R --relocated-dump=<number|name>\n\
3365 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3366 -w[lLiaprmfFsoRt] or\n\
1ed06042 3367 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3368 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3369 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3370 =addr,=cu_index]\n\
8b53311e 3371 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3372 fprintf (stream, _("\
3373 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3374 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3375 or deeper\n"));
252b5132 3376#ifdef SUPPORT_DISASSEMBLY
92f01d61 3377 fprintf (stream, _("\
09c11c86
NC		 3378 -i --instruction-dump=<number|name>\n\
3379 Disassemble the contents of section <number|name>\n"));
252b5132 3380#endif
92f01d61 3381 fprintf (stream, _("\
8b53311e
NC		 3382 -I --histogram Display histogram of bucket list lengths\n\
3383 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3384 @<file> Read options from <file>\n\
8b53311e
NC		 3385 -H --help Display this information\n\
3386 -v --version Display the version number of readelf\n"));
1118d252 3387
92f01d61
JM		 3388 if (REPORT_BUGS_TO[0] && stream == stdout)
3389 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3390
92f01d61 3391 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3392}
3393
18bd398b
NC		 3394/* Record the fact that the user wants the contents of section number
3395 SECTION to be displayed using the method(s) encoded as flags bits
3396 in TYPE. Note, TYPE can be zero if we are creating the array for
3397 the first time. */
3398
252b5132 3399static void
09c11c86 3400request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3401{
3402 if (section >= num_dump_sects)
3403 {
2cf0635d 3404 dump_type * new_dump_sects;
252b5132 3405
3f5e193b
NC		 3406 new_dump_sects = (dump_type *) calloc (section + 1,
3407 sizeof (* dump_sects));
252b5132
RH		 3408
3409 if (new_dump_sects == NULL)
591a748a 3410 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3411 else
3412 {
3413 /* Copy current flag settings. */
09c11c86 3414 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3415
3416 free (dump_sects);
3417
3418 dump_sects = new_dump_sects;
3419 num_dump_sects = section + 1;
3420 }
3421 }
3422
3423 if (dump_sects)
b34976b6 3424 dump_sects[section] |= type;
252b5132
RH		 3425
3426 return;
3427}
3428
aef1f6d0
DJ		 3429/* Request a dump by section name. */
3430
3431static void
2cf0635d 3432request_dump_byname (const char * section, dump_type type)
aef1f6d0 3433{
2cf0635d 3434 struct dump_list_entry * new_request;
aef1f6d0 3435
3f5e193b
NC		 3436 new_request = (struct dump_list_entry *)
3437 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3438 if (!new_request)
591a748a 3439 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3440
3441 new_request->name = strdup (section);
3442 if (!new_request->name)
591a748a 3443 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3444
3445 new_request->type = type;
3446
3447 new_request->next = dump_sects_byname;
3448 dump_sects_byname = new_request;
3449}
3450
cf13d699
NC		 3451static inline void
3452request_dump (dump_type type)
3453{
3454 int section;
3455 char * cp;
3456
3457 do_dump++;
3458 section = strtoul (optarg, & cp, 0);
3459
3460 if (! *cp && section >= 0)
3461 request_dump_bynumber (section, type);
3462 else
3463 request_dump_byname (optarg, type);
3464}
3465
3466
252b5132 3467static void
2cf0635d 3468parse_args (int argc, char ** argv)
252b5132
RH		 3469{
3470 int c;
3471
3472 if (argc < 2)
92f01d61 3473 usage (stderr);
252b5132
RH		 3474
3475 while ((c = getopt_long
cf13d699 3476 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3477 {
252b5132
RH		 3478 switch (c)
3479 {
3480 case 0:
3481 /* Long options. */
3482 break;
3483 case 'H':
92f01d61 3484 usage (stdout);
252b5132
RH		 3485 break;
3486
3487 case 'a':
b34976b6
AM		 3488 do_syms++;
3489 do_reloc++;
3490 do_unwind++;
3491 do_dynamic++;
3492 do_header++;
3493 do_sections++;
f5842774 3494 do_section_groups++;
b34976b6
AM		 3495 do_segments++;
3496 do_version++;
3497 do_histogram++;
3498 do_arch++;
3499 do_notes++;
252b5132 3500 break;
f5842774
L		 3501 case 'g':
3502 do_section_groups++;
3503 break;
5477e8a0 3504 case 't':
595cf52e 3505 case 'N':
5477e8a0
L		 3506 do_sections++;
3507 do_section_details++;
595cf52e 3508 break;
252b5132 3509 case 'e':
b34976b6
AM		 3510 do_header++;
3511 do_sections++;
3512 do_segments++;
252b5132 3513 break;
a952a375 3514 case 'A':
b34976b6 3515 do_arch++;
a952a375 3516 break;
252b5132 3517 case 'D':
b34976b6 3518 do_using_dynamic++;
252b5132
RH		 3519 break;
3520 case 'r':
b34976b6 3521 do_reloc++;
252b5132 3522 break;
4d6ed7c8 3523 case 'u':
b34976b6 3524 do_unwind++;
4d6ed7c8 3525 break;
252b5132 3526 case 'h':
b34976b6 3527 do_header++;
252b5132
RH		 3528 break;
3529 case 'l':
b34976b6 3530 do_segments++;
252b5132
RH		 3531 break;
3532 case 's':
b34976b6 3533 do_syms++;
252b5132
RH		 3534 break;
3535 case 'S':
b34976b6 3536 do_sections++;
252b5132
RH		 3537 break;
3538 case 'd':
b34976b6 3539 do_dynamic++;
252b5132 3540 break;
a952a375 3541 case 'I':
b34976b6 3542 do_histogram++;
a952a375 3543 break;
779fe533 3544 case 'n':
b34976b6 3545 do_notes++;
779fe533 3546 break;
4145f1d5
NC		 3547 case 'c':
3548 do_archive_index++;
3549 break;
252b5132 3550 case 'x':
cf13d699 3551 request_dump (HEX_DUMP);
aef1f6d0 3552 break;
09c11c86 3553 case 'p':
cf13d699
NC		 3554 request_dump (STRING_DUMP);
3555 break;
3556 case 'R':
3557 request_dump (RELOC_DUMP);
09c11c86 3558 break;
252b5132 3559 case 'w':
b34976b6 3560 do_dump++;
252b5132 3561 if (optarg == 0)
613ff48b
CC		 3562 {
3563 do_debugging = 1;
3564 dwarf_select_sections_all ();
3565 }
252b5132
RH		 3566 else
3567 {
3568 do_debugging = 0;
4cb93e3b 3569 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3570 }
3571 break;
2979dc34 3572 case OPTION_DEBUG_DUMP:
b34976b6 3573 do_dump++;
2979dc34
JJ		 3574 if (optarg == 0)
3575 do_debugging = 1;
3576 else
3577 {
2979dc34 3578 do_debugging = 0;
4cb93e3b 3579 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3580 }
3581 break;
fd2f0033
TT		 3582 case OPTION_DWARF_DEPTH:
3583 {
3584 char *cp;
3585
3586 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3587 }
3588 break;
3589 case OPTION_DWARF_START:
3590 {
3591 char *cp;
3592
3593 dwarf_start_die = strtoul (optarg, & cp, 0);
3594 }
3595 break;
4723351a
CC		 3596 case OPTION_DWARF_CHECK:
3597 dwarf_check = 1;
3598 break;
2c610e4b
L		 3599 case OPTION_DYN_SYMS:
3600 do_dyn_syms++;
3601 break;
252b5132
RH		 3602#ifdef SUPPORT_DISASSEMBLY
3603 case 'i':
cf13d699
NC		 3604 request_dump (DISASS_DUMP);
3605 break;
252b5132
RH		 3606#endif
3607 case 'v':
3608 print_version (program_name);
3609 break;
3610 case 'V':
b34976b6 3611 do_version++;
252b5132 3612 break;
d974e256 3613 case 'W':
b34976b6 3614 do_wide++;
d974e256 3615 break;
252b5132 3616 default:
252b5132
RH		 3617 /* xgettext:c-format */
3618 error (_("Invalid option '-%c'\n"), c);
3619 /* Drop through. */
3620 case '?':
92f01d61 3621 usage (stderr);
252b5132
RH		 3622 }
3623 }
3624
4d6ed7c8 3625 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3626 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3627 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3628 && !do_section_groups && !do_archive_index
3629 && !do_dyn_syms)
92f01d61 3630 usage (stderr);
252b5132
RH		 3631 else if (argc < 3)
3632 {
3633 warn (_("Nothing to do.\n"));
92f01d61 3634 usage (stderr);
252b5132
RH		 3635 }
3636}
3637
3638static const char *
d3ba0551 3639get_elf_class (unsigned int elf_class)
252b5132 3640{
b34976b6 3641 static char buff[32];
103f02d3 3642
252b5132
RH		 3643 switch (elf_class)
3644 {
3645 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3646 case ELFCLASS32: return "ELF32";
3647 case ELFCLASS64: return "ELF64";
ab5e7794 3648 default:
e9e44622 3649 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3650 return buff;
252b5132
RH		 3651 }
3652}
3653
3654static const char *
d3ba0551 3655get_data_encoding (unsigned int encoding)
252b5132 3656{
b34976b6 3657 static char buff[32];
103f02d3 3658
252b5132
RH		 3659 switch (encoding)
3660 {
3661 case ELFDATANONE: return _("none");
33c63f9d
CM		 3662 case ELFDATA2LSB: return _("2's complement, little endian");
3663 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3664 default:
e9e44622 3665 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3666 return buff;
252b5132
RH		 3667 }
3668}
3669
252b5132 3670/* Decode the data held in 'elf_header'. */
ee42cf8c 3671
252b5132 3672static int
d3ba0551 3673process_file_header (void)
252b5132 3674{
b34976b6
AM		 3675 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3676 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3677 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3678 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3679 {
3680 error
3681 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3682 return 0;
3683 }
3684
2dc4cec1
L		 3685 init_dwarf_regnames (elf_header.e_machine);
3686
252b5132
RH		 3687 if (do_header)
3688 {
3689 int i;
3690
3691 printf (_("ELF Header:\n"));
3692 printf (_(" Magic: "));
b34976b6
AM		 3693 for (i = 0; i < EI_NIDENT; i++)
3694 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3695 printf ("\n");
3696 printf (_(" Class: %s\n"),
b34976b6 3697 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3698 printf (_(" Data: %s\n"),
b34976b6 3699 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3700 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3701 elf_header.e_ident[EI_VERSION],
3702 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3703 ? "(current)"
b34976b6 3704 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3705 ? _("<unknown: %lx>")
789be9f7 3706 : "")));
252b5132 3707 printf (_(" OS/ABI: %s\n"),
b34976b6 3708 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3709 printf (_(" ABI Version: %d\n"),
b34976b6 3710 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3711 printf (_(" Type: %s\n"),
3712 get_file_type (elf_header.e_type));
3713 printf (_(" Machine: %s\n"),
3714 get_machine_name (elf_header.e_machine));
3715 printf (_(" Version: 0x%lx\n"),
3716 (unsigned long) elf_header.e_version);
76da6bbe 3717
f7a99963
NC		 3718 printf (_(" Entry point address: "));
3719 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3720 printf (_("\n Start of program headers: "));
3721 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3722 printf (_(" (bytes into file)\n Start of section headers: "));
3723 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3724 printf (_(" (bytes into file)\n"));
76da6bbe 3725
252b5132
RH		 3726 printf (_(" Flags: 0x%lx%s\n"),
3727 (unsigned long) elf_header.e_flags,
3728 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3729 printf (_(" Size of this header: %ld (bytes)\n"),
3730 (long) elf_header.e_ehsize);
3731 printf (_(" Size of program headers: %ld (bytes)\n"),
3732 (long) elf_header.e_phentsize);
2046a35d 3733 printf (_(" Number of program headers: %ld"),
252b5132 3734 (long) elf_header.e_phnum);
2046a35d
AM		 3735 if (section_headers != NULL
3736 && elf_header.e_phnum == PN_XNUM
3737 && section_headers[0].sh_info != 0)
cc5914eb 3738 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3739 putc ('\n', stdout);
252b5132
RH		 3740 printf (_(" Size of section headers: %ld (bytes)\n"),
3741 (long) elf_header.e_shentsize);
560f3c1c 3742 printf (_(" Number of section headers: %ld"),
252b5132 3743 (long) elf_header.e_shnum);
4fbb74a6 3744 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3745 printf (" (%ld)", (long) section_headers[0].sh_size);
3746 putc ('\n', stdout);
3747 printf (_(" Section header string table index: %ld"),
252b5132 3748 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3749 if (section_headers != NULL
3750 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3751 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3752 else if (elf_header.e_shstrndx != SHN_UNDEF
3753 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3754 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3755 putc ('\n', stdout);
3756 }
3757
3758 if (section_headers != NULL)
3759 {
2046a35d
AM		 3760 if (elf_header.e_phnum == PN_XNUM
3761 && section_headers[0].sh_info != 0)
3762 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3763 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3764 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3765 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3766 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3767 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3768 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3769 free (section_headers);
3770 section_headers = NULL;
252b5132 3771 }
103f02d3 3772
9ea033b2
NC		 3773 return 1;
3774}
3775
252b5132 3776
9ea033b2 3777static int
91d6fa6a 3778get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3779{
2cf0635d
NC		 3780 Elf32_External_Phdr * phdrs;
3781 Elf32_External_Phdr * external;
3782 Elf_Internal_Phdr * internal;
b34976b6 3783 unsigned int i;
103f02d3 3784
3f5e193b
NC		 3785 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3786 elf_header.e_phentsize,
3787 elf_header.e_phnum,
3788 _("program headers"));
a6e9f9df
AM		 3789 if (!phdrs)
3790 return 0;
9ea033b2 3791
91d6fa6a 3792 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3793 i < elf_header.e_phnum;
b34976b6 3794 i++, internal++, external++)
252b5132 3795 {
9ea033b2
NC		 3796 internal->p_type = BYTE_GET (external->p_type);
3797 internal->p_offset = BYTE_GET (external->p_offset);
3798 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3799 internal->p_paddr = BYTE_GET (external->p_paddr);
3800 internal->p_filesz = BYTE_GET (external->p_filesz);
3801 internal->p_memsz = BYTE_GET (external->p_memsz);
3802 internal->p_flags = BYTE_GET (external->p_flags);
3803 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3804 }
3805
9ea033b2
NC		 3806 free (phdrs);
3807
252b5132
RH		 3808 return 1;
3809}
3810
9ea033b2 3811static int
91d6fa6a 3812get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3813{
2cf0635d
NC		 3814 Elf64_External_Phdr * phdrs;
3815 Elf64_External_Phdr * external;
3816 Elf_Internal_Phdr * internal;
b34976b6 3817 unsigned int i;
103f02d3 3818
3f5e193b
NC		 3819 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3820 elf_header.e_phentsize,
3821 elf_header.e_phnum,
3822 _("program headers"));
a6e9f9df
AM		 3823 if (!phdrs)
3824 return 0;
9ea033b2 3825
91d6fa6a 3826 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3827 i < elf_header.e_phnum;
b34976b6 3828 i++, internal++, external++)
9ea033b2
NC		 3829 {
3830 internal->p_type = BYTE_GET (external->p_type);
3831 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3832 internal->p_offset = BYTE_GET (external->p_offset);
3833 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3834 internal->p_paddr = BYTE_GET (external->p_paddr);
3835 internal->p_filesz = BYTE_GET (external->p_filesz);
3836 internal->p_memsz = BYTE_GET (external->p_memsz);
3837 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3838 }
3839
3840 free (phdrs);
3841
3842 return 1;
3843}
252b5132 3844
d93f0186
NC		 3845/* Returns 1 if the program headers were read into `program_headers'. */
3846
3847static int
2cf0635d 3848get_program_headers (FILE * file)
d93f0186 3849{
2cf0635d 3850 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3851
3852 /* Check cache of prior read. */
3853 if (program_headers != NULL)
3854 return 1;
3855
3f5e193b
NC		 3856 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3857 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3858
3859 if (phdrs == NULL)
3860 {
3861 error (_("Out of memory\n"));
3862 return 0;
3863 }
3864
3865 if (is_32bit_elf
3866 ? get_32bit_program_headers (file, phdrs)
3867 : get_64bit_program_headers (file, phdrs))
3868 {
3869 program_headers = phdrs;
3870 return 1;
3871 }
3872
3873 free (phdrs);
3874 return 0;
3875}
3876
2f62977e
NC		 3877/* Returns 1 if the program headers were loaded. */
3878
252b5132 3879static int
2cf0635d 3880process_program_headers (FILE * file)
252b5132 3881{
2cf0635d 3882 Elf_Internal_Phdr * segment;
b34976b6 3883 unsigned int i;
252b5132
RH		 3884
3885 if (elf_header.e_phnum == 0)
3886 {
82f2dbf7
NC		 3887 /* PR binutils/12467. */
3888 if (elf_header.e_phoff != 0)
3889 warn (_("possibly corrupt ELF header - it has a non-zero program"
3890 " header offset, but no program headers"));
3891 else if (do_segments)
252b5132 3892 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3893 return 0;
252b5132
RH		 3894 }
3895
3896 if (do_segments && !do_header)
3897 {
f7a99963
NC		 3898 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3899 printf (_("Entry point "));
3900 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3901 printf (_("\nThere are %d program headers, starting at offset "),
3902 elf_header.e_phnum);
3903 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3904 printf ("\n");
252b5132
RH		 3905 }
3906
d93f0186 3907 if (! get_program_headers (file))
252b5132 3908 return 0;
103f02d3 3909
252b5132
RH		 3910 if (do_segments)
3911 {
3a1a2036
NC		 3912 if (elf_header.e_phnum > 1)
3913 printf (_("\nProgram Headers:\n"));
3914 else
3915 printf (_("\nProgram Headers:\n"));
76da6bbe 3916
f7a99963
NC		 3917 if (is_32bit_elf)
3918 printf
3919 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3920 else if (do_wide)
3921 printf
3922 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3923 else
3924 {
3925 printf
3926 (_(" Type Offset VirtAddr PhysAddr\n"));
3927 printf
3928 (_(" FileSiz MemSiz Flags Align\n"));
3929 }
252b5132
RH		 3930 }
3931
252b5132 3932 dynamic_addr = 0;
1b228002 3933 dynamic_size = 0;
252b5132
RH		 3934
3935 for (i = 0, segment = program_headers;
3936 i < elf_header.e_phnum;
b34976b6 3937 i++, segment++)
252b5132
RH		 3938 {
3939 if (do_segments)
3940 {
103f02d3 3941 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3942
3943 if (is_32bit_elf)
3944 {
3945 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3946 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3947 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3948 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3949 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3950 printf ("%c%c%c ",
3951 (segment->p_flags & PF_R ? 'R' : ' '),
3952 (segment->p_flags & PF_W ? 'W' : ' '),
3953 (segment->p_flags & PF_X ? 'E' : ' '));
3954 printf ("%#lx", (unsigned long) segment->p_align);
3955 }
d974e256
JJ		 3956 else if (do_wide)
3957 {
3958 if ((unsigned long) segment->p_offset == segment->p_offset)
3959 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3960 else
3961 {
3962 print_vma (segment->p_offset, FULL_HEX);
3963 putchar (' ');
3964 }
3965
3966 print_vma (segment->p_vaddr, FULL_HEX);
3967 putchar (' ');
3968 print_vma (segment->p_paddr, FULL_HEX);
3969 putchar (' ');
3970
3971 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3972 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3973 else
3974 {
3975 print_vma (segment->p_filesz, FULL_HEX);
3976 putchar (' ');
3977 }
3978
3979 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3980 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3981 else
3982 {
f48e6c45 3983 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 3984 }
3985
3986 printf (" %c%c%c ",
3987 (segment->p_flags & PF_R ? 'R' : ' '),
3988 (segment->p_flags & PF_W ? 'W' : ' '),
3989 (segment->p_flags & PF_X ? 'E' : ' '));
3990
3991 if ((unsigned long) segment->p_align == segment->p_align)
3992 printf ("%#lx", (unsigned long) segment->p_align);
3993 else
3994 {
3995 print_vma (segment->p_align, PREFIX_HEX);
3996 }
3997 }
f7a99963
NC		 3998 else
3999 {
4000 print_vma (segment->p_offset, FULL_HEX);
4001 putchar (' ');
4002 print_vma (segment->p_vaddr, FULL_HEX);
4003 putchar (' ');
4004 print_vma (segment->p_paddr, FULL_HEX);
4005 printf ("\n ");
4006 print_vma (segment->p_filesz, FULL_HEX);
4007 putchar (' ');
4008 print_vma (segment->p_memsz, FULL_HEX);
4009 printf (" %c%c%c ",
4010 (segment->p_flags & PF_R ? 'R' : ' '),
4011 (segment->p_flags & PF_W ? 'W' : ' '),
4012 (segment->p_flags & PF_X ? 'E' : ' '));
4013 print_vma (segment->p_align, HEX);
4014 }
252b5132
RH		 4015 }
4016
4017 switch (segment->p_type)
4018 {
252b5132
RH		 4019 case PT_DYNAMIC:
4020 if (dynamic_addr)
4021 error (_("more than one dynamic segment\n"));
4022
20737c13
AM		 4023 /* By default, assume that the .dynamic section is the first
4024 section in the DYNAMIC segment. */
4025 dynamic_addr = segment->p_offset;
4026 dynamic_size = segment->p_filesz;
4027
b2d38a17
NC		 4028 /* Try to locate the .dynamic section. If there is
4029 a section header table, we can easily locate it. */
4030 if (section_headers != NULL)
4031 {
2cf0635d 4032 Elf_Internal_Shdr * sec;
b2d38a17 4033
89fac5e3
RS		 4034 sec = find_section (".dynamic");
4035 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4036 {
28f997cf
TG		 4037 /* A corresponding .dynamic section is expected, but on
4038 IA-64/OpenVMS it is OK for it to be missing. */
4039 if (!is_ia64_vms ())
4040 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4041 break;
4042 }
4043
42bb2e33 4044 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4045 {
4046 dynamic_size = 0;
4047 break;
4048 }
42bb2e33 4049
b2d38a17
NC		 4050 dynamic_addr = sec->sh_offset;
4051 dynamic_size = sec->sh_size;
4052
4053 if (dynamic_addr < segment->p_offset
4054 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4055 warn (_("the .dynamic section is not contained"
4056 " within the dynamic segment\n"));
b2d38a17 4057 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4058 warn (_("the .dynamic section is not the first section"
4059 " in the dynamic segment.\n"));
b2d38a17 4060 }
252b5132
RH		 4061 break;
4062
4063 case PT_INTERP:
fb52b2f4
NC		 4064 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4065 SEEK_SET))
252b5132
RH		 4066 error (_("Unable to find program interpreter name\n"));
4067 else
4068 {
f8eae8b2
L		 4069 char fmt [32];
4070 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4071
4072 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4073 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4074
252b5132 4075 program_interpreter[0] = 0;
7bd7b3ef
AM		 4076 if (fscanf (file, fmt, program_interpreter) <= 0)
4077 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4078
4079 if (do_segments)
4080 printf (_("\n [Requesting program interpreter: %s]"),
4081 program_interpreter);
4082 }
4083 break;
4084 }
4085
4086 if (do_segments)
4087 putc ('\n', stdout);
4088 }
4089
c256ffe7 4090 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4091 {
4092 printf (_("\n Section to Segment mapping:\n"));
4093 printf (_(" Segment Sections...\n"));
4094
252b5132
RH		 4095 for (i = 0; i < elf_header.e_phnum; i++)
4096 {
9ad5cbcf 4097 unsigned int j;
2cf0635d 4098 Elf_Internal_Shdr * section;
252b5132
RH		 4099
4100 segment = program_headers + i;
b391a3e3 4101 section = section_headers + 1;
252b5132
RH		 4102
4103 printf (" %2.2d ", i);
4104
b34976b6 4105 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4106 {
f4638467
AM		 4107 if (!ELF_TBSS_SPECIAL (section, segment)
4108 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 4109 printf ("%s ", SECTION_NAME (section));
4110 }
4111
4112 putc ('\n',stdout);
4113 }
4114 }
4115
252b5132
RH		 4116 return 1;
4117}
4118
4119
d93f0186
NC		 4120/* Find the file offset corresponding to VMA by using the program headers. */
4121
4122static long
2cf0635d 4123offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4124{
2cf0635d 4125 Elf_Internal_Phdr * seg;
d93f0186
NC		 4126
4127 if (! get_program_headers (file))
4128 {
4129 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4130 return (long) vma;
4131 }
4132
4133 for (seg = program_headers;
4134 seg < program_headers + elf_header.e_phnum;
4135 ++seg)
4136 {
4137 if (seg->p_type != PT_LOAD)
4138 continue;
4139
4140 if (vma >= (seg->p_vaddr & -seg->p_align)
4141 && vma + size <= seg->p_vaddr + seg->p_filesz)
4142 return vma - seg->p_vaddr + seg->p_offset;
4143 }
4144
4145 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4146 (unsigned long) vma);
d93f0186
NC		 4147 return (long) vma;
4148}
4149
4150
252b5132 4151static int
2cf0635d 4152get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4153{
2cf0635d
NC		 4154 Elf32_External_Shdr * shdrs;
4155 Elf_Internal_Shdr * internal;
b34976b6 4156 unsigned int i;
252b5132 4157
3f5e193b
NC		 4158 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4159 elf_header.e_shentsize, num,
4160 _("section headers"));
a6e9f9df
AM		 4161 if (!shdrs)
4162 return 0;
252b5132 4163
3f5e193b
NC		 4164 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4165 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4166
4167 if (section_headers == NULL)
4168 {
4169 error (_("Out of memory\n"));
4170 return 0;
4171 }
4172
4173 for (i = 0, internal = section_headers;
560f3c1c 4174 i < num;
b34976b6 4175 i++, internal++)
252b5132
RH		 4176 {
4177 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4178 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4179 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4180 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4181 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4182 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4183 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4184 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4185 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4186 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4187 }
4188
4189 free (shdrs);
4190
4191 return 1;
4192}
4193
9ea033b2 4194static int
2cf0635d 4195get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4196{
2cf0635d
NC		 4197 Elf64_External_Shdr * shdrs;
4198 Elf_Internal_Shdr * internal;
b34976b6 4199 unsigned int i;
9ea033b2 4200
3f5e193b
NC		 4201 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4202 elf_header.e_shentsize, num,
4203 _("section headers"));
a6e9f9df
AM		 4204 if (!shdrs)
4205 return 0;
9ea033b2 4206
3f5e193b
NC		 4207 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4208 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4209
4210 if (section_headers == NULL)
4211 {
4212 error (_("Out of memory\n"));
4213 return 0;
4214 }
4215
4216 for (i = 0, internal = section_headers;
560f3c1c 4217 i < num;
b34976b6 4218 i++, internal++)
9ea033b2
NC		 4219 {
4220 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4221 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4222 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4223 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4224 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4225 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4226 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4227 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4228 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4229 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4230 }
4231
4232 free (shdrs);
4233
4234 return 1;
4235}
4236
252b5132 4237static Elf_Internal_Sym *
ba5cdace
NC		 4238get_32bit_elf_symbols (FILE * file,
4239 Elf_Internal_Shdr * section,
4240 unsigned long * num_syms_return)
252b5132 4241{
ba5cdace 4242 unsigned long number = 0;
dd24e3da 4243 Elf32_External_Sym * esyms = NULL;
ba5cdace 4244 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4245 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4246 Elf_Internal_Sym * psym;
b34976b6 4247 unsigned int j;
252b5132 4248
dd24e3da
NC		 4249 /* Run some sanity checks first. */
4250 if (section->sh_entsize == 0)
4251 {
4252 error (_("sh_entsize is zero\n"));
ba5cdace 4253 goto exit_point;
dd24e3da
NC		 4254 }
4255
4256 number = section->sh_size / section->sh_entsize;
4257
4258 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4259 {
4260 error (_("Invalid sh_entsize\n"));
ba5cdace 4261 goto exit_point;
dd24e3da
NC		 4262 }
4263
3f5e193b
NC		 4264 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4265 section->sh_size, _("symbols"));
dd24e3da 4266 if (esyms == NULL)
ba5cdace 4267 goto exit_point;
252b5132 4268
9ad5cbcf
AM		 4269 shndx = NULL;
4270 if (symtab_shndx_hdr != NULL
4271 && (symtab_shndx_hdr->sh_link
4fbb74a6 4272 == (unsigned long) (section - section_headers)))
9ad5cbcf 4273 {
3f5e193b
NC		 4274 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4275 symtab_shndx_hdr->sh_offset,
4276 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4277 _("symbol table section indicies"));
dd24e3da
NC		 4278 if (shndx == NULL)
4279 goto exit_point;
9ad5cbcf
AM		 4280 }
4281
3f5e193b 4282 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4283
4284 if (isyms == NULL)
4285 {
4286 error (_("Out of memory\n"));
dd24e3da 4287 goto exit_point;
252b5132
RH		 4288 }
4289
dd24e3da 4290 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4291 {
4292 psym->st_name = BYTE_GET (esyms[j].st_name);
4293 psym->st_value = BYTE_GET (esyms[j].st_value);
4294 psym->st_size = BYTE_GET (esyms[j].st_size);
4295 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4296 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4297 psym->st_shndx
4298 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4299 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4300 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4301 psym->st_info = BYTE_GET (esyms[j].st_info);
4302 psym->st_other = BYTE_GET (esyms[j].st_other);
4303 }
4304
dd24e3da 4305 exit_point:
ba5cdace 4306 if (shndx != NULL)
9ad5cbcf 4307 free (shndx);
ba5cdace 4308 if (esyms != NULL)
dd24e3da 4309 free (esyms);
252b5132 4310
ba5cdace
NC		 4311 if (num_syms_return != NULL)
4312 * num_syms_return = isyms == NULL ? 0 : number;
4313
252b5132
RH		 4314 return isyms;
4315}
4316
9ea033b2 4317static Elf_Internal_Sym *
ba5cdace
NC		 4318get_64bit_elf_symbols (FILE * file,
4319 Elf_Internal_Shdr * section,
4320 unsigned long * num_syms_return)
9ea033b2 4321{
ba5cdace
NC		 4322 unsigned long number = 0;
4323 Elf64_External_Sym * esyms = NULL;
4324 Elf_External_Sym_Shndx * shndx = NULL;
4325 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4326 Elf_Internal_Sym * psym;
b34976b6 4327 unsigned int j;
9ea033b2 4328
dd24e3da
NC		 4329 /* Run some sanity checks first. */
4330 if (section->sh_entsize == 0)
4331 {
4332 error (_("sh_entsize is zero\n"));
ba5cdace 4333 goto exit_point;
dd24e3da
NC		 4334 }
4335
4336 number = section->sh_size / section->sh_entsize;
4337
4338 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4339 {
4340 error (_("Invalid sh_entsize\n"));
ba5cdace 4341 goto exit_point;
dd24e3da
NC		 4342 }
4343
3f5e193b
NC		 4344 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4345 section->sh_size, _("symbols"));
a6e9f9df 4346 if (!esyms)
ba5cdace 4347 goto exit_point;
9ea033b2 4348
9ad5cbcf
AM		 4349 if (symtab_shndx_hdr != NULL
4350 && (symtab_shndx_hdr->sh_link
4fbb74a6 4351 == (unsigned long) (section - section_headers)))
9ad5cbcf 4352 {
3f5e193b
NC		 4353 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4354 symtab_shndx_hdr->sh_offset,
4355 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4356 _("symbol table section indicies"));
ba5cdace
NC		 4357 if (shndx == NULL)
4358 goto exit_point;
9ad5cbcf
AM		 4359 }
4360
3f5e193b 4361 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4362
4363 if (isyms == NULL)
4364 {
4365 error (_("Out of memory\n"));
ba5cdace 4366 goto exit_point;
9ea033b2
NC		 4367 }
4368
ba5cdace 4369 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4370 {
4371 psym->st_name = BYTE_GET (esyms[j].st_name);
4372 psym->st_info = BYTE_GET (esyms[j].st_info);
4373 psym->st_other = BYTE_GET (esyms[j].st_other);
4374 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4375
4fbb74a6 4376 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4377 psym->st_shndx
4378 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4379 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4380 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4381
66543521
AM		 4382 psym->st_value = BYTE_GET (esyms[j].st_value);
4383 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4384 }
4385
ba5cdace
NC		 4386 exit_point:
4387 if (shndx != NULL)
9ad5cbcf 4388 free (shndx);
ba5cdace
NC		 4389 if (esyms != NULL)
4390 free (esyms);
4391
4392 if (num_syms_return != NULL)
4393 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4394
4395 return isyms;
4396}
4397
d1133906 4398static const char *
d3ba0551 4399get_elf_section_flags (bfd_vma sh_flags)
d1133906 4400{
5477e8a0 4401 static char buff[1024];
2cf0635d 4402 char * p = buff;
8d5ff12c 4403 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4404 int sindex;
4405 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4406 bfd_vma os_flags = 0;
4407 bfd_vma proc_flags = 0;
4408 bfd_vma unknown_flags = 0;
148b93f2 4409 static const struct
5477e8a0 4410 {
2cf0635d 4411 const char * str;
5477e8a0
L		 4412 int len;
4413 }
4414 flags [] =
4415 {
cfcac11d
NC		 4416 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4417 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4418 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4419 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4420 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4421 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4422 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4423 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4424 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4425 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4426 /* IA-64 specific. */
4427 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4428 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4429 /* IA-64 OpenVMS specific. */
4430 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4431 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4432 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4433 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4434 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4435 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4436 /* Generic. */
cfcac11d 4437 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4438 /* SPARC specific. */
cfcac11d 4439 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4440 };
4441
4442 if (do_section_details)
4443 {
8d5ff12c
L		 4444 sprintf (buff, "[%*.*lx]: ",
4445 field_size, field_size, (unsigned long) sh_flags);
4446 p += field_size + 4;
5477e8a0 4447 }
76da6bbe 4448
d1133906
NC		 4449 while (sh_flags)
4450 {
4451 bfd_vma flag;
4452
4453 flag = sh_flags & - sh_flags;
4454 sh_flags &= ~ flag;
76da6bbe 4455
5477e8a0 4456 if (do_section_details)
d1133906 4457 {
5477e8a0
L		 4458 switch (flag)
4459 {
91d6fa6a
NC		 4460 case SHF_WRITE: sindex = 0; break;
4461 case SHF_ALLOC: sindex = 1; break;
4462 case SHF_EXECINSTR: sindex = 2; break;
4463 case SHF_MERGE: sindex = 3; break;
4464 case SHF_STRINGS: sindex = 4; break;
4465 case SHF_INFO_LINK: sindex = 5; break;
4466 case SHF_LINK_ORDER: sindex = 6; break;
4467 case SHF_OS_NONCONFORMING: sindex = 7; break;
4468 case SHF_GROUP: sindex = 8; break;
4469 case SHF_TLS: sindex = 9; break;
18ae9cc1 4470 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4471
5477e8a0 4472 default:
91d6fa6a 4473 sindex = -1;
cfcac11d 4474 switch (elf_header.e_machine)
148b93f2 4475 {
cfcac11d 4476 case EM_IA_64:
148b93f2 4477 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4478 sindex = 10;
148b93f2 4479 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4480 sindex = 11;
148b93f2
NC		 4481#ifdef BFD64
4482 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4483 switch (flag)
4484 {
91d6fa6a
NC		 4485 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4486 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4487 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4488 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4489 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4490 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4491 default: break;
4492 }
4493#endif
cfcac11d
NC		 4494 break;
4495
caa83f8b
NC		 4496 case EM_386:
4497 case EM_486:
4498 case EM_X86_64:
7f502d6c 4499 case EM_L1OM:
7a9068fe 4500 case EM_K1OM:
cfcac11d
NC		 4501 case EM_OLD_SPARCV9:
4502 case EM_SPARC32PLUS:
4503 case EM_SPARCV9:
4504 case EM_SPARC:
18ae9cc1 4505 if (flag == SHF_ORDERED)
91d6fa6a 4506 sindex = 19;
cfcac11d
NC		 4507 break;
4508 default:
4509 break;
148b93f2 4510 }
5477e8a0
L		 4511 }
4512
91d6fa6a 4513 if (sindex != -1)
5477e8a0 4514 {
8d5ff12c
L		 4515 if (p != buff + field_size + 4)
4516 {
4517 if (size < (10 + 2))
4518 abort ();
4519 size -= 2;
4520 *p++ = ',';
4521 *p++ = ' ';
4522 }
4523
91d6fa6a
NC		 4524 size -= flags [sindex].len;
4525 p = stpcpy (p, flags [sindex].str);
5477e8a0 4526 }
3b22753a 4527 else if (flag & SHF_MASKOS)
8d5ff12c 4528 os_flags |= flag;
d1133906 4529 else if (flag & SHF_MASKPROC)
8d5ff12c 4530 proc_flags |= flag;
d1133906 4531 else
8d5ff12c 4532 unknown_flags |= flag;
5477e8a0
L		 4533 }
4534 else
4535 {
4536 switch (flag)
4537 {
4538 case SHF_WRITE: *p = 'W'; break;
4539 case SHF_ALLOC: *p = 'A'; break;
4540 case SHF_EXECINSTR: *p = 'X'; break;
4541 case SHF_MERGE: *p = 'M'; break;
4542 case SHF_STRINGS: *p = 'S'; break;
4543 case SHF_INFO_LINK: *p = 'I'; break;
4544 case SHF_LINK_ORDER: *p = 'L'; break;
4545 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4546 case SHF_GROUP: *p = 'G'; break;
4547 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4548 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4549
4550 default:
8a9036a4 4551 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4552 || elf_header.e_machine == EM_L1OM
4553 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4554 && flag == SHF_X86_64_LARGE)
4555 *p = 'l';
4556 else if (flag & SHF_MASKOS)
4557 {
4558 *p = 'o';
4559 sh_flags &= ~ SHF_MASKOS;
4560 }
4561 else if (flag & SHF_MASKPROC)
4562 {
4563 *p = 'p';
4564 sh_flags &= ~ SHF_MASKPROC;
4565 }
4566 else
4567 *p = 'x';
4568 break;
4569 }
4570 p++;
d1133906
NC		 4571 }
4572 }
76da6bbe 4573
8d5ff12c
L		 4574 if (do_section_details)
4575 {
4576 if (os_flags)
4577 {
4578 size -= 5 + field_size;
4579 if (p != buff + field_size + 4)
4580 {
4581 if (size < (2 + 1))
4582 abort ();
4583 size -= 2;
4584 *p++ = ',';
4585 *p++ = ' ';
4586 }
4587 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4588 (unsigned long) os_flags);
4589 p += 5 + field_size;
4590 }
4591 if (proc_flags)
4592 {
4593 size -= 7 + field_size;
4594 if (p != buff + field_size + 4)
4595 {
4596 if (size < (2 + 1))
4597 abort ();
4598 size -= 2;
4599 *p++ = ',';
4600 *p++ = ' ';
4601 }
4602 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4603 (unsigned long) proc_flags);
4604 p += 7 + field_size;
4605 }
4606 if (unknown_flags)
4607 {
4608 size -= 10 + field_size;
4609 if (p != buff + field_size + 4)
4610 {
4611 if (size < (2 + 1))
4612 abort ();
4613 size -= 2;
4614 *p++ = ',';
4615 *p++ = ' ';
4616 }
2b692964 4617 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4618 (unsigned long) unknown_flags);
4619 p += 10 + field_size;
4620 }
4621 }
4622
e9e44622 4623 *p = '\0';
d1133906
NC		 4624 return buff;
4625}
4626
252b5132 4627static int
2cf0635d 4628process_section_headers (FILE * file)
252b5132 4629{
2cf0635d 4630 Elf_Internal_Shdr * section;
b34976b6 4631 unsigned int i;
252b5132
RH		 4632
4633 section_headers = NULL;
4634
4635 if (elf_header.e_shnum == 0)
4636 {
82f2dbf7
NC		 4637 /* PR binutils/12467. */
4638 if (elf_header.e_shoff != 0)
4639 warn (_("possibly corrupt ELF file header - it has a non-zero"
4640 " section header offset, but no section headers\n"));
4641 else if (do_sections)
252b5132
RH		 4642 printf (_("\nThere are no sections in this file.\n"));
4643
4644 return 1;
4645 }
4646
4647 if (do_sections && !do_header)
9ea033b2 4648 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4649 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4650
9ea033b2
NC		 4651 if (is_32bit_elf)
4652 {
560f3c1c 4653 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4654 return 0;
4655 }
560f3c1c 4656 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4657 return 0;
4658
4659 /* Read in the string table, so that we have names to display. */
0b49d371 4660 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4661 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4662 {
4fbb74a6 4663 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4664
c256ffe7
JJ		 4665 if (section->sh_size != 0)
4666 {
3f5e193b
NC		 4667 string_table = (char *) get_data (NULL, file, section->sh_offset,
4668 1, section->sh_size,
4669 _("string table"));
0de14b54 4670
c256ffe7
JJ		 4671 string_table_length = string_table != NULL ? section->sh_size : 0;
4672 }
252b5132
RH		 4673 }
4674
4675 /* Scan the sections for the dynamic symbol table
e3c8793a 4676 and dynamic string table and debug sections. */
252b5132
RH		 4677 dynamic_symbols = NULL;
4678 dynamic_strings = NULL;
4679 dynamic_syminfo = NULL;
f1ef08cb 4680 symtab_shndx_hdr = NULL;
103f02d3 4681
89fac5e3
RS		 4682 eh_addr_size = is_32bit_elf ? 4 : 8;
4683 switch (elf_header.e_machine)
4684 {
4685 case EM_MIPS:
4686 case EM_MIPS_RS3_LE:
4687 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4688 FDE addresses. However, the ABI also has a semi-official ILP32
4689 variant for which the normal FDE address size rules apply.
4690
4691 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4692 section, where XX is the size of longs in bits. Unfortunately,
4693 earlier compilers provided no way of distinguishing ILP32 objects
4694 from LP64 objects, so if there's any doubt, we should assume that
4695 the official LP64 form is being used. */
4696 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4697 && find_section (".gcc_compiled_long32") == NULL)
4698 eh_addr_size = 8;
4699 break;
0f56a26a
DD		 4700
4701 case EM_H8_300:
4702 case EM_H8_300H:
4703 switch (elf_header.e_flags & EF_H8_MACH)
4704 {
4705 case E_H8_MACH_H8300:
4706 case E_H8_MACH_H8300HN:
4707 case E_H8_MACH_H8300SN:
4708 case E_H8_MACH_H8300SXN:
4709 eh_addr_size = 2;
4710 break;
4711 case E_H8_MACH_H8300H:
4712 case E_H8_MACH_H8300S:
4713 case E_H8_MACH_H8300SX:
4714 eh_addr_size = 4;
4715 break;
4716 }
f4236fe4
DD		 4717 break;
4718
ff7eeb89 4719 case EM_M32C_OLD:
f4236fe4
DD		 4720 case EM_M32C:
4721 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4722 {
4723 case EF_M32C_CPU_M16C:
4724 eh_addr_size = 2;
4725 break;
4726 }
4727 break;
89fac5e3
RS		 4728 }
4729
08d8fa11
JJ		 4730#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4731 do \
4732 { \
4733 size_t expected_entsize \
4734 = is_32bit_elf ? size32 : size64; \
4735 if (section->sh_entsize != expected_entsize) \
4736 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4737 i, (unsigned long int) section->sh_entsize, \
4738 (unsigned long int) expected_entsize); \
4739 section->sh_entsize = expected_entsize; \
4740 } \
4741 while (0)
4742#define CHECK_ENTSIZE(section, i, type) \
4743 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4744 sizeof (Elf64_External_##type))
4745
252b5132
RH		 4746 for (i = 0, section = section_headers;
4747 i < elf_header.e_shnum;
b34976b6 4748 i++, section++)
252b5132 4749 {
2cf0635d 4750 char * name = SECTION_NAME (section);
252b5132
RH		 4751
4752 if (section->sh_type == SHT_DYNSYM)
4753 {
4754 if (dynamic_symbols != NULL)
4755 {
4756 error (_("File contains multiple dynamic symbol tables\n"));
4757 continue;
4758 }
4759
08d8fa11 4760 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4761 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 4762 }
4763 else if (section->sh_type == SHT_STRTAB
18bd398b 4764 && streq (name, ".dynstr"))
252b5132
RH		 4765 {
4766 if (dynamic_strings != NULL)
4767 {
4768 error (_("File contains multiple dynamic string tables\n"));
4769 continue;
4770 }
4771
3f5e193b
NC		 4772 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4773 1, section->sh_size,
4774 _("dynamic strings"));
59245841 4775 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4776 }
9ad5cbcf
AM		 4777 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4778 {
4779 if (symtab_shndx_hdr != NULL)
4780 {
4781 error (_("File contains multiple symtab shndx tables\n"));
4782 continue;
4783 }
4784 symtab_shndx_hdr = section;
4785 }
08d8fa11
JJ		 4786 else if (section->sh_type == SHT_SYMTAB)
4787 CHECK_ENTSIZE (section, i, Sym);
4788 else if (section->sh_type == SHT_GROUP)
4789 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4790 else if (section->sh_type == SHT_REL)
4791 CHECK_ENTSIZE (section, i, Rel);
4792 else if (section->sh_type == SHT_RELA)
4793 CHECK_ENTSIZE (section, i, Rela);
252b5132 4794 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4795 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4796 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 4797 || do_debug_str || do_debug_loc || do_debug_ranges
4798 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 4799 && (const_strneq (name, ".debug_")
4800 || const_strneq (name, ".zdebug_")))
252b5132 4801 {
1b315056
CS		 4802 if (name[1] == 'z')
4803 name += sizeof (".zdebug_") - 1;
4804 else
4805 name += sizeof (".debug_") - 1;
252b5132
RH		 4806
4807 if (do_debugging
4723351a
CC		 4808 || (do_debug_info && const_strneq (name, "info"))
4809 || (do_debug_info && const_strneq (name, "types"))
4810 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4811 || (do_debug_lines && const_strneq (name, "line"))
4812 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4813 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4814 || (do_debug_aranges && const_strneq (name, "aranges"))
4815 || (do_debug_ranges && const_strneq (name, "ranges"))
4816 || (do_debug_frames && const_strneq (name, "frame"))
4817 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4818 || (do_debug_macinfo && const_strneq (name, "macro"))
4819 || (do_debug_str && const_strneq (name, "str"))
4820 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 4821 || (do_debug_addr && const_strneq (name, "addr"))
4822 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4823 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 4824 )
09c11c86 4825 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4826 }
a262ae96 4827 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4828 else if ((do_debugging || do_debug_info)
0112cd26 4829 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4830 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4831 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4832 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4833 else if (do_gdb_index && streq (name, ".gdb_index"))
4834 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4835 /* Trace sections for Itanium VMS. */
4836 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4837 || do_trace_aranges)
4838 && const_strneq (name, ".trace_"))
4839 {
4840 name += sizeof (".trace_") - 1;
4841
4842 if (do_debugging
4843 || (do_trace_info && streq (name, "info"))
4844 || (do_trace_abbrevs && streq (name, "abbrev"))
4845 || (do_trace_aranges && streq (name, "aranges"))
4846 )
4847 request_dump_bynumber (i, DEBUG_DUMP);
4848 }
4849
252b5132
RH		 4850 }
4851
4852 if (! do_sections)
4853 return 1;
4854
3a1a2036
NC		 4855 if (elf_header.e_shnum > 1)
4856 printf (_("\nSection Headers:\n"));
4857 else
4858 printf (_("\nSection Header:\n"));
76da6bbe 4859
f7a99963 4860 if (is_32bit_elf)
595cf52e 4861 {
5477e8a0 4862 if (do_section_details)
595cf52e
L		 4863 {
4864 printf (_(" [Nr] Name\n"));
5477e8a0 4865 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4866 }
4867 else
4868 printf
4869 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4870 }
d974e256 4871 else if (do_wide)
595cf52e 4872 {
5477e8a0 4873 if (do_section_details)
595cf52e
L		 4874 {
4875 printf (_(" [Nr] Name\n"));
5477e8a0 4876 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4877 }
4878 else
4879 printf
4880 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4881 }
f7a99963
NC		 4882 else
4883 {
5477e8a0 4884 if (do_section_details)
595cf52e
L		 4885 {
4886 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4887 printf (_(" Type Address Offset Link\n"));
4888 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4889 }
4890 else
4891 {
4892 printf (_(" [Nr] Name Type Address Offset\n"));
4893 printf (_(" Size EntSize Flags Link Info Align\n"));
4894 }
f7a99963 4895 }
252b5132 4896
5477e8a0
L		 4897 if (do_section_details)
4898 printf (_(" Flags\n"));
4899
252b5132
RH		 4900 for (i = 0, section = section_headers;
4901 i < elf_header.e_shnum;
b34976b6 4902 i++, section++)
252b5132 4903 {
7bfd842d 4904 printf (" [%2u] ", i);
5477e8a0 4905 if (do_section_details)
595cf52e 4906 {
7bfd842d 4907 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 4908 printf ("\n ");
595cf52e
L		 4909 }
4910 else
7bfd842d
NC		 4911 {
4912 print_symbol (-17, SECTION_NAME (section));
7bfd842d 4913 }
ea52a088
NC		 4914
4915 printf (do_wide ? " %-15s " : " %-15.15s ",
4916 get_section_type_name (section->sh_type));
4917
f7a99963
NC		 4918 if (is_32bit_elf)
4919 {
cfcac11d
NC		 4920 const char * link_too_big = NULL;
4921
f7a99963 4922 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4923
f7a99963
NC		 4924 printf ( " %6.6lx %6.6lx %2.2lx",
4925 (unsigned long) section->sh_offset,
4926 (unsigned long) section->sh_size,
4927 (unsigned long) section->sh_entsize);
d1133906 4928
5477e8a0
L		 4929 if (do_section_details)
4930 fputs (" ", stdout);
4931 else
4932 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4933
cfcac11d
NC		 4934 if (section->sh_link >= elf_header.e_shnum)
4935 {
4936 link_too_big = "";
4937 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4938 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4939 switch (elf_header.e_machine)
4940 {
caa83f8b
NC		 4941 case EM_386:
4942 case EM_486:
4943 case EM_X86_64:
7f502d6c 4944 case EM_L1OM:
7a9068fe 4945 case EM_K1OM:
cfcac11d
NC		 4946 case EM_OLD_SPARCV9:
4947 case EM_SPARC32PLUS:
4948 case EM_SPARCV9:
4949 case EM_SPARC:
4950 if (section->sh_link == (SHN_BEFORE & 0xffff))
4951 link_too_big = "BEFORE";
4952 else if (section->sh_link == (SHN_AFTER & 0xffff))
4953 link_too_big = "AFTER";
4954 break;
4955 default:
4956 break;
4957 }
4958 }
4959
4960 if (do_section_details)
4961 {
4962 if (link_too_big != NULL && * link_too_big)
4963 printf ("<%s> ", link_too_big);
4964 else
4965 printf ("%2u ", section->sh_link);
4966 printf ("%3u %2lu\n", section->sh_info,
4967 (unsigned long) section->sh_addralign);
4968 }
4969 else
4970 printf ("%2u %3u %2lu\n",
4971 section->sh_link,
4972 section->sh_info,
4973 (unsigned long) section->sh_addralign);
4974
4975 if (link_too_big && ! * link_too_big)
4976 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4977 i, section->sh_link);
f7a99963 4978 }
d974e256
JJ		 4979 else if (do_wide)
4980 {
4981 print_vma (section->sh_addr, LONG_HEX);
4982
4983 if ((long) section->sh_offset == section->sh_offset)
4984 printf (" %6.6lx", (unsigned long) section->sh_offset);
4985 else
4986 {
4987 putchar (' ');
4988 print_vma (section->sh_offset, LONG_HEX);
4989 }
4990
4991 if ((unsigned long) section->sh_size == section->sh_size)
4992 printf (" %6.6lx", (unsigned long) section->sh_size);
4993 else
4994 {
4995 putchar (' ');
4996 print_vma (section->sh_size, LONG_HEX);
4997 }
4998
4999 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5000 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5001 else
5002 {
5003 putchar (' ');
5004 print_vma (section->sh_entsize, LONG_HEX);
5005 }
5006
5477e8a0
L		 5007 if (do_section_details)
5008 fputs (" ", stdout);
5009 else
5010 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5011
72de5009 5012 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5013
5014 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5015 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5016 else
5017 {
5018 print_vma (section->sh_addralign, DEC);
5019 putchar ('\n');
5020 }
5021 }
5477e8a0 5022 else if (do_section_details)
595cf52e 5023 {
5477e8a0 5024 printf (" %-15.15s ",
595cf52e 5025 get_section_type_name (section->sh_type));
595cf52e
L		 5026 print_vma (section->sh_addr, LONG_HEX);
5027 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5028 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5029 else
5030 {
5031 printf (" ");
5032 print_vma (section->sh_offset, LONG_HEX);
5033 }
72de5009 5034 printf (" %u\n ", section->sh_link);
595cf52e 5035 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5036 putchar (' ');
595cf52e
L		 5037 print_vma (section->sh_entsize, LONG_HEX);
5038
72de5009
AM		 5039 printf (" %-16u %lu\n",
5040 section->sh_info,
595cf52e
L		 5041 (unsigned long) section->sh_addralign);
5042 }
f7a99963
NC		 5043 else
5044 {
5045 putchar (' ');
5046 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5047 if ((long) section->sh_offset == section->sh_offset)
5048 printf (" %8.8lx", (unsigned long) section->sh_offset);
5049 else
5050 {
5051 printf (" ");
5052 print_vma (section->sh_offset, LONG_HEX);
5053 }
f7a99963
NC		 5054 printf ("\n ");
5055 print_vma (section->sh_size, LONG_HEX);
5056 printf (" ");
5057 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5058
d1133906 5059 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5060
72de5009
AM		 5061 printf (" %2u %3u %lu\n",
5062 section->sh_link,
5063 section->sh_info,
f7a99963
NC		 5064 (unsigned long) section->sh_addralign);
5065 }
5477e8a0
L		 5066
5067 if (do_section_details)
5068 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5069 }
5070
5477e8a0 5071 if (!do_section_details)
3dbcc61d
NC		 5072 {
5073 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5074 || elf_header.e_machine == EM_L1OM
5075 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5076 printf (_("Key to Flags:\n\
5077 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5078 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5079 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5080 else
5081 printf (_("Key to Flags:\n\
e3c8793a 5082 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5083 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5084 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 5085 }
d1133906 5086
252b5132
RH		 5087 return 1;
5088}
5089
f5842774
L		 5090static const char *
5091get_group_flags (unsigned int flags)
5092{
5093 static char buff[32];
5094 switch (flags)
5095 {
220453ec
AM		 5096 case 0:
5097 return "";
5098
f5842774 5099 case GRP_COMDAT:
220453ec 5100 return "COMDAT ";
f5842774
L		 5101
5102 default:
220453ec 5103 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5104 break;
5105 }
5106 return buff;
5107}
5108
5109static int
2cf0635d 5110process_section_groups (FILE * file)
f5842774 5111{
2cf0635d 5112 Elf_Internal_Shdr * section;
f5842774 5113 unsigned int i;
2cf0635d
NC		 5114 struct group * group;
5115 Elf_Internal_Shdr * symtab_sec;
5116 Elf_Internal_Shdr * strtab_sec;
5117 Elf_Internal_Sym * symtab;
ba5cdace 5118 unsigned long num_syms;
2cf0635d 5119 char * strtab;
c256ffe7 5120 size_t strtab_size;
d1f5c6e3
L		 5121
5122 /* Don't process section groups unless needed. */
5123 if (!do_unwind && !do_section_groups)
5124 return 1;
f5842774
L		 5125
5126 if (elf_header.e_shnum == 0)
5127 {
5128 if (do_section_groups)
82f2dbf7 5129 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5130
5131 return 1;
5132 }
5133
5134 if (section_headers == NULL)
5135 {
5136 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5137 /* PR 13622: This can happen with a corrupt ELF header. */
5138 return 0;
f5842774
L		 5139 }
5140
3f5e193b
NC		 5141 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5142 sizeof (struct group *));
e4b17d5c
L		 5143
5144 if (section_headers_groups == NULL)
5145 {
5146 error (_("Out of memory\n"));
5147 return 0;
5148 }
5149
f5842774 5150 /* Scan the sections for the group section. */
d1f5c6e3 5151 group_count = 0;
f5842774
L		 5152 for (i = 0, section = section_headers;
5153 i < elf_header.e_shnum;
5154 i++, section++)
e4b17d5c
L		 5155 if (section->sh_type == SHT_GROUP)
5156 group_count++;
5157
d1f5c6e3
L		 5158 if (group_count == 0)
5159 {
5160 if (do_section_groups)
5161 printf (_("\nThere are no section groups in this file.\n"));
5162
5163 return 1;
5164 }
5165
3f5e193b 5166 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5167
5168 if (section_groups == NULL)
5169 {
5170 error (_("Out of memory\n"));
5171 return 0;
5172 }
5173
d1f5c6e3
L		 5174 symtab_sec = NULL;
5175 strtab_sec = NULL;
5176 symtab = NULL;
ba5cdace 5177 num_syms = 0;
d1f5c6e3 5178 strtab = NULL;
c256ffe7 5179 strtab_size = 0;
e4b17d5c
L		 5180 for (i = 0, section = section_headers, group = section_groups;
5181 i < elf_header.e_shnum;
5182 i++, section++)
f5842774
L		 5183 {
5184 if (section->sh_type == SHT_GROUP)
5185 {
2cf0635d
NC		 5186 char * name = SECTION_NAME (section);
5187 char * group_name;
5188 unsigned char * start;
5189 unsigned char * indices;
f5842774 5190 unsigned int entry, j, size;
2cf0635d
NC		 5191 Elf_Internal_Shdr * sec;
5192 Elf_Internal_Sym * sym;
f5842774
L		 5193
5194 /* Get the symbol table. */
4fbb74a6
AM		 5195 if (section->sh_link >= elf_header.e_shnum
5196 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5197 != SHT_SYMTAB))
f5842774
L		 5198 {
5199 error (_("Bad sh_link in group section `%s'\n"), name);
5200 continue;
5201 }
d1f5c6e3
L		 5202
5203 if (symtab_sec != sec)
5204 {
5205 symtab_sec = sec;
5206 if (symtab)
5207 free (symtab);
ba5cdace 5208 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5209 }
f5842774 5210
dd24e3da
NC		 5211 if (symtab == NULL)
5212 {
5213 error (_("Corrupt header in group section `%s'\n"), name);
5214 continue;
5215 }
5216
ba5cdace
NC		 5217 if (section->sh_info >= num_syms)
5218 {
5219 error (_("Bad sh_info in group section `%s'\n"), name);
5220 continue;
5221 }
5222
f5842774
L		 5223 sym = symtab + section->sh_info;
5224
5225 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5226 {
4fbb74a6
AM		 5227 if (sym->st_shndx == 0
5228 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5229 {
5230 error (_("Bad sh_info in group section `%s'\n"), name);
5231 continue;
5232 }
ba2685cc 5233
4fbb74a6 5234 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5235 strtab_sec = NULL;
5236 if (strtab)
5237 free (strtab);
f5842774 5238 strtab = NULL;
c256ffe7 5239 strtab_size = 0;
f5842774
L		 5240 }
5241 else
5242 {
5243 /* Get the string table. */
4fbb74a6 5244 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5245 {
5246 strtab_sec = NULL;
5247 if (strtab)
5248 free (strtab);
5249 strtab = NULL;
5250 strtab_size = 0;
5251 }
5252 else if (strtab_sec
4fbb74a6 5253 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5254 {
5255 strtab_sec = sec;
5256 if (strtab)
5257 free (strtab);
3f5e193b
NC		 5258 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5259 1, strtab_sec->sh_size,
5260 _("string table"));
c256ffe7 5261 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5262 }
c256ffe7 5263 group_name = sym->st_name < strtab_size
2b692964 5264 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5265 }
5266
3f5e193b
NC		 5267 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5268 1, section->sh_size,
5269 _("section data"));
59245841
NC		 5270 if (start == NULL)
5271 continue;
f5842774
L		 5272
5273 indices = start;
5274 size = (section->sh_size / section->sh_entsize) - 1;
5275 entry = byte_get (indices, 4);
5276 indices += 4;
e4b17d5c
L		 5277
5278 if (do_section_groups)
5279 {
2b692964 5280 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5281 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5282
e4b17d5c
L		 5283 printf (_(" [Index] Name\n"));
5284 }
5285
5286 group->group_index = i;
5287
f5842774
L		 5288 for (j = 0; j < size; j++)
5289 {
2cf0635d 5290 struct group_list * g;
e4b17d5c 5291
f5842774
L		 5292 entry = byte_get (indices, 4);
5293 indices += 4;
5294
4fbb74a6 5295 if (entry >= elf_header.e_shnum)
391cb864
L		 5296 {
5297 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5298 entry, i, elf_header.e_shnum - 1);
5299 continue;
5300 }
391cb864 5301
4fbb74a6 5302 if (section_headers_groups [entry] != NULL)
e4b17d5c 5303 {
d1f5c6e3
L		 5304 if (entry)
5305 {
391cb864
L		 5306 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5307 entry, i,
4fbb74a6 5308 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5309 continue;
5310 }
5311 else
5312 {
5313 /* Intel C/C++ compiler may put section 0 in a
5314 section group. We just warn it the first time
5315 and ignore it afterwards. */
5316 static int warned = 0;
5317 if (!warned)
5318 {
5319 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5320 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5321 warned++;
5322 }
5323 }
e4b17d5c
L		 5324 }
5325
4fbb74a6 5326 section_headers_groups [entry] = group;
e4b17d5c
L		 5327
5328 if (do_section_groups)
5329 {
4fbb74a6 5330 sec = section_headers + entry;
c256ffe7 5331 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5332 }
5333
3f5e193b 5334 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5335 g->section_index = entry;
5336 g->next = group->root;
5337 group->root = g;
f5842774
L		 5338 }
5339
f5842774
L		 5340 if (start)
5341 free (start);
e4b17d5c
L		 5342
5343 group++;
f5842774
L		 5344 }
5345 }
5346
d1f5c6e3
L		 5347 if (symtab)
5348 free (symtab);
5349 if (strtab)
5350 free (strtab);
f5842774
L		 5351 return 1;
5352}
5353
28f997cf
TG		 5354/* Data used to display dynamic fixups. */
5355
5356struct ia64_vms_dynfixup
5357{
5358 bfd_vma needed_ident; /* Library ident number. */
5359 bfd_vma needed; /* Index in the dstrtab of the library name. */
5360 bfd_vma fixup_needed; /* Index of the library. */
5361 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5362 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5363};
5364
5365/* Data used to display dynamic relocations. */
5366
5367struct ia64_vms_dynimgrela
5368{
5369 bfd_vma img_rela_cnt; /* Number of relocations. */
5370 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5371};
5372
5373/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5374 library). */
5375
5376static void
5377dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5378 const char *strtab, unsigned int strtab_sz)
5379{
5380 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5381 long i;
5382 const char *lib_name;
5383
5384 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5385 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5386 _("dynamic section image fixups"));
5387 if (!imfs)
5388 return;
5389
5390 if (fixup->needed < strtab_sz)
5391 lib_name = strtab + fixup->needed;
5392 else
5393 {
5394 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5395 (unsigned long) fixup->needed);
28f997cf
TG		 5396 lib_name = "???";
5397 }
5398 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5399 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5400 printf
5401 (_("Seg Offset Type SymVec DataType\n"));
5402
5403 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5404 {
5405 unsigned int type;
5406 const char *rtype;
5407
5408 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5409 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5410 type = BYTE_GET (imfs [i].type);
5411 rtype = elf_ia64_reloc_type (type);
5412 if (rtype == NULL)
5413 printf (" 0x%08x ", type);
5414 else
5415 printf (" %-32s ", rtype);
5416 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5417 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5418 }
5419
5420 free (imfs);
5421}
5422
5423/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5424
5425static void
5426dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5427{
5428 Elf64_External_VMS_IMAGE_RELA *imrs;
5429 long i;
5430
5431 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5432 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5433 _("dynamic section image relocations"));
28f997cf
TG		 5434 if (!imrs)
5435 return;
5436
5437 printf (_("\nImage relocs\n"));
5438 printf
5439 (_("Seg Offset Type Addend Seg Sym Off\n"));
5440
5441 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5442 {
5443 unsigned int type;
5444 const char *rtype;
5445
5446 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5447 printf ("%08" BFD_VMA_FMT "x ",
5448 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5449 type = BYTE_GET (imrs [i].type);
5450 rtype = elf_ia64_reloc_type (type);
5451 if (rtype == NULL)
5452 printf ("0x%08x ", type);
5453 else
5454 printf ("%-31s ", rtype);
5455 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5456 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5457 printf ("%08" BFD_VMA_FMT "x\n",
5458 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5459 }
5460
5461 free (imrs);
5462}
5463
5464/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5465
5466static int
5467process_ia64_vms_dynamic_relocs (FILE *file)
5468{
5469 struct ia64_vms_dynfixup fixup;
5470 struct ia64_vms_dynimgrela imgrela;
5471 Elf_Internal_Dyn *entry;
5472 int res = 0;
5473 bfd_vma strtab_off = 0;
5474 bfd_vma strtab_sz = 0;
5475 char *strtab = NULL;
5476
5477 memset (&fixup, 0, sizeof (fixup));
5478 memset (&imgrela, 0, sizeof (imgrela));
5479
5480 /* Note: the order of the entries is specified by the OpenVMS specs. */
5481 for (entry = dynamic_section;
5482 entry < dynamic_section + dynamic_nent;
5483 entry++)
5484 {
5485 switch (entry->d_tag)
5486 {
5487 case DT_IA_64_VMS_STRTAB_OFFSET:
5488 strtab_off = entry->d_un.d_val;
5489 break;
5490 case DT_STRSZ:
5491 strtab_sz = entry->d_un.d_val;
5492 if (strtab == NULL)
5493 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5494 1, strtab_sz, _("dynamic string section"));
5495 break;
5496
5497 case DT_IA_64_VMS_NEEDED_IDENT:
5498 fixup.needed_ident = entry->d_un.d_val;
5499 break;
5500 case DT_NEEDED:
5501 fixup.needed = entry->d_un.d_val;
5502 break;
5503 case DT_IA_64_VMS_FIXUP_NEEDED:
5504 fixup.fixup_needed = entry->d_un.d_val;
5505 break;
5506 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5507 fixup.fixup_rela_cnt = entry->d_un.d_val;
5508 break;
5509 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5510 fixup.fixup_rela_off = entry->d_un.d_val;
5511 res++;
5512 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5513 break;
5514
5515 case DT_IA_64_VMS_IMG_RELA_CNT:
5516 imgrela.img_rela_cnt = entry->d_un.d_val;
5517 break;
5518 case DT_IA_64_VMS_IMG_RELA_OFF:
5519 imgrela.img_rela_off = entry->d_un.d_val;
5520 res++;
5521 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5522 break;
5523
5524 default:
5525 break;
5526 }
5527 }
5528
5529 if (strtab != NULL)
5530 free (strtab);
5531
5532 return res;
5533}
5534
85b1c36d 5535static struct
566b0d53 5536{
2cf0635d 5537 const char * name;
566b0d53
L		 5538 int reloc;
5539 int size;
5540 int rela;
5541} dynamic_relocations [] =
5542{
5543 { "REL", DT_REL, DT_RELSZ, FALSE },
5544 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5545 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5546};
5547
252b5132 5548/* Process the reloc section. */
18bd398b 5549
252b5132 5550static int
2cf0635d 5551process_relocs (FILE * file)
252b5132 5552{
b34976b6
AM		 5553 unsigned long rel_size;
5554 unsigned long rel_offset;
252b5132
RH		 5555
5556
5557 if (!do_reloc)
5558 return 1;
5559
5560 if (do_using_dynamic)
5561 {
566b0d53 5562 int is_rela;
2cf0635d 5563 const char * name;
566b0d53
L		 5564 int has_dynamic_reloc;
5565 unsigned int i;
0de14b54 5566
566b0d53 5567 has_dynamic_reloc = 0;
252b5132 5568
566b0d53 5569 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5570 {
566b0d53
L		 5571 is_rela = dynamic_relocations [i].rela;
5572 name = dynamic_relocations [i].name;
5573 rel_size = dynamic_info [dynamic_relocations [i].size];
5574 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5575
566b0d53
L		 5576 has_dynamic_reloc |= rel_size;
5577
5578 if (is_rela == UNKNOWN)
aa903cfb 5579 {
566b0d53
L		 5580 if (dynamic_relocations [i].reloc == DT_JMPREL)
5581 switch (dynamic_info[DT_PLTREL])
5582 {
5583 case DT_REL:
5584 is_rela = FALSE;
5585 break;
5586 case DT_RELA:
5587 is_rela = TRUE;
5588 break;
5589 }
aa903cfb 5590 }
252b5132 5591
566b0d53
L		 5592 if (rel_size)
5593 {
5594 printf
5595 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5596 name, rel_offset, rel_size);
252b5132 5597
d93f0186
NC		 5598 dump_relocations (file,
5599 offset_from_vma (file, rel_offset, rel_size),
5600 rel_size,
566b0d53 5601 dynamic_symbols, num_dynamic_syms,
d79b3d50 5602 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5603 }
252b5132 5604 }
566b0d53 5605
28f997cf
TG		 5606 if (is_ia64_vms ())
5607 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5608
566b0d53 5609 if (! has_dynamic_reloc)
252b5132
RH		 5610 printf (_("\nThere are no dynamic relocations in this file.\n"));
5611 }
5612 else
5613 {
2cf0635d 5614 Elf_Internal_Shdr * section;
b34976b6
AM		 5615 unsigned long i;
5616 int found = 0;
252b5132
RH		 5617
5618 for (i = 0, section = section_headers;
5619 i < elf_header.e_shnum;
b34976b6 5620 i++, section++)
252b5132
RH		 5621 {
5622 if ( section->sh_type != SHT_RELA
5623 && section->sh_type != SHT_REL)
5624 continue;
5625
5626 rel_offset = section->sh_offset;
5627 rel_size = section->sh_size;
5628
5629 if (rel_size)
5630 {
2cf0635d 5631 Elf_Internal_Shdr * strsec;
b34976b6 5632 int is_rela;
103f02d3 5633
252b5132
RH		 5634 printf (_("\nRelocation section "));
5635
5636 if (string_table == NULL)
19936277 5637 printf ("%d", section->sh_name);
252b5132 5638 else
9cf03b7e 5639 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5640
5641 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5642 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5643
d79b3d50
NC		 5644 is_rela = section->sh_type == SHT_RELA;
5645
4fbb74a6
AM		 5646 if (section->sh_link != 0
5647 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5648 {
2cf0635d
NC		 5649 Elf_Internal_Shdr * symsec;
5650 Elf_Internal_Sym * symtab;
d79b3d50 5651 unsigned long nsyms;
c256ffe7 5652 unsigned long strtablen = 0;
2cf0635d 5653 char * strtab = NULL;
57346661 5654
4fbb74a6 5655 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5656 if (symsec->sh_type != SHT_SYMTAB
5657 && symsec->sh_type != SHT_DYNSYM)
5658 continue;
5659
ba5cdace 5660 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5661
af3fc3bc
AM		 5662 if (symtab == NULL)
5663 continue;
252b5132 5664
4fbb74a6
AM		 5665 if (symsec->sh_link != 0
5666 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5667 {
4fbb74a6 5668 strsec = section_headers + symsec->sh_link;
103f02d3 5669
3f5e193b
NC		 5670 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5671 1, strsec->sh_size,
5672 _("string table"));
c256ffe7
JJ		 5673 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5674 }
252b5132 5675
d79b3d50
NC		 5676 dump_relocations (file, rel_offset, rel_size,
5677 symtab, nsyms, strtab, strtablen, is_rela);
5678 if (strtab)
5679 free (strtab);
5680 free (symtab);
5681 }
5682 else
5683 dump_relocations (file, rel_offset, rel_size,
5684 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5685
5686 found = 1;
5687 }
5688 }
5689
5690 if (! found)
5691 printf (_("\nThere are no relocations in this file.\n"));
5692 }
5693
5694 return 1;
5695}
5696
57346661
AM		 5697/* Process the unwind section. */
5698
4d6ed7c8
NC		 5699#include "unwind-ia64.h"
5700
5701/* An absolute address consists of a section and an offset. If the
5702 section is NULL, the offset itself is the address, otherwise, the
5703 address equals to LOAD_ADDRESS(section) + offset. */
5704
5705struct absaddr
5706 {
5707 unsigned short section;
5708 bfd_vma offset;
5709 };
5710
1949de15
L		 5711#define ABSADDR(a) \
5712 ((a).section \
5713 ? section_headers [(a).section].sh_addr + (a).offset \
5714 : (a).offset)
5715
3f5e193b
NC		 5716struct ia64_unw_table_entry
5717 {
5718 struct absaddr start;
5719 struct absaddr end;
5720 struct absaddr info;
5721 };
5722
57346661 5723struct ia64_unw_aux_info
4d6ed7c8 5724 {
3f5e193b
NC		 5725
5726 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5727 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5728 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5729 unsigned long info_size; /* Size of unwind info. */
5730 bfd_vma info_addr; /* starting address of unwind info. */
5731 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5732 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5733 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5734 char * strtab; /* The string table. */
b34976b6 5735 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5736 };
5737
4d6ed7c8 5738static void
2cf0635d 5739find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5740 unsigned long nsyms,
2cf0635d 5741 const char * strtab,
57346661 5742 unsigned long strtab_size,
d3ba0551 5743 struct absaddr addr,
2cf0635d
NC		 5744 const char ** symname,
5745 bfd_vma * offset)
4d6ed7c8 5746{
d3ba0551 5747 bfd_vma dist = 0x100000;
2cf0635d
NC		 5748 Elf_Internal_Sym * sym;
5749 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5750 unsigned long i;
5751
0b6ae522
DJ		 5752 REMOVE_ARCH_BITS (addr.offset);
5753
57346661 5754 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5755 {
0b6ae522
DJ		 5756 bfd_vma value = sym->st_value;
5757
5758 REMOVE_ARCH_BITS (value);
5759
4d6ed7c8
NC		 5760 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5761 && sym->st_name != 0
5762 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5763 && addr.offset >= value
5764 && addr.offset - value < dist)
4d6ed7c8
NC		 5765 {
5766 best = sym;
0b6ae522 5767 dist = addr.offset - value;
4d6ed7c8
NC		 5768 if (!dist)
5769 break;
5770 }
5771 }
1b31d05e 5772
4d6ed7c8
NC		 5773 if (best)
5774 {
57346661 5775 *symname = (best->st_name >= strtab_size
2b692964 5776 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5777 *offset = dist;
5778 return;
5779 }
1b31d05e 5780
4d6ed7c8
NC		 5781 *symname = NULL;
5782 *offset = addr.offset;
5783}
5784
5785static void
2cf0635d 5786dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5787{
2cf0635d 5788 struct ia64_unw_table_entry * tp;
4d6ed7c8 5789 int in_body;
7036c0e1 5790
4d6ed7c8
NC		 5791 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5792 {
5793 bfd_vma stamp;
5794 bfd_vma offset;
2cf0635d
NC		 5795 const unsigned char * dp;
5796 const unsigned char * head;
5797 const char * procname;
4d6ed7c8 5798
57346661
AM		 5799 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5800 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5801
5802 fputs ("\n<", stdout);
5803
5804 if (procname)
5805 {
5806 fputs (procname, stdout);
5807
5808 if (offset)
5809 printf ("+%lx", (unsigned long) offset);
5810 }
5811
5812 fputs (">: [", stdout);
5813 print_vma (tp->start.offset, PREFIX_HEX);
5814 fputc ('-', stdout);
5815 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5816 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5817 (unsigned long) (tp->info.offset - aux->seg_base));
5818
1949de15 5819 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5820 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5821
86f55779 5822 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5823 (unsigned) UNW_VER (stamp),
5824 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5825 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5826 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5827 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5828
5829 if (UNW_VER (stamp) != 1)
5830 {
2b692964 5831 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5832 continue;
5833 }
5834
5835 in_body = 0;
89fac5e3 5836 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5837 dp = unw_decode (dp, in_body, & in_body);
5838 }
5839}
5840
5841static int
2cf0635d
NC		 5842slurp_ia64_unwind_table (FILE * file,
5843 struct ia64_unw_aux_info * aux,
5844 Elf_Internal_Shdr * sec)
4d6ed7c8 5845{
89fac5e3 5846 unsigned long size, nrelas, i;
2cf0635d
NC		 5847 Elf_Internal_Phdr * seg;
5848 struct ia64_unw_table_entry * tep;
5849 Elf_Internal_Shdr * relsec;
5850 Elf_Internal_Rela * rela;
5851 Elf_Internal_Rela * rp;
5852 unsigned char * table;
5853 unsigned char * tp;
5854 Elf_Internal_Sym * sym;
5855 const char * relname;
4d6ed7c8 5856
4d6ed7c8
NC		 5857 /* First, find the starting address of the segment that includes
5858 this section: */
5859
5860 if (elf_header.e_phnum)
5861 {
d93f0186 5862 if (! get_program_headers (file))
4d6ed7c8 5863 return 0;
4d6ed7c8 5864
d93f0186
NC		 5865 for (seg = program_headers;
5866 seg < program_headers + elf_header.e_phnum;
5867 ++seg)
4d6ed7c8
NC		 5868 {
5869 if (seg->p_type != PT_LOAD)
5870 continue;
5871
5872 if (sec->sh_addr >= seg->p_vaddr
5873 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5874 {
5875 aux->seg_base = seg->p_vaddr;
5876 break;
5877 }
5878 }
4d6ed7c8
NC		 5879 }
5880
5881 /* Second, build the unwind table from the contents of the unwind section: */
5882 size = sec->sh_size;
3f5e193b
NC		 5883 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5884 _("unwind table"));
a6e9f9df
AM		 5885 if (!table)
5886 return 0;
4d6ed7c8 5887
3f5e193b
NC		 5888 aux->table = (struct ia64_unw_table_entry *)
5889 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5890 tep = aux->table;
c6a0c689 5891 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5892 {
5893 tep->start.section = SHN_UNDEF;
5894 tep->end.section = SHN_UNDEF;
5895 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5896 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5897 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5898 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5899 tep->start.offset += aux->seg_base;
5900 tep->end.offset += aux->seg_base;
5901 tep->info.offset += aux->seg_base;
5902 }
5903 free (table);
5904
41e92641 5905 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5906 for (relsec = section_headers;
5907 relsec < section_headers + elf_header.e_shnum;
5908 ++relsec)
5909 {
5910 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5911 || relsec->sh_info >= elf_header.e_shnum
5912 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5913 continue;
5914
5915 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5916 & rela, & nrelas))
5917 return 0;
5918
5919 for (rp = rela; rp < rela + nrelas; ++rp)
5920 {
aca88567
NC		 5921 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5922 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5923
0112cd26 5924 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5925 {
e5fb9629 5926 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5927 continue;
5928 }
5929
89fac5e3 5930 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5931
89fac5e3 5932 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5933 {
5934 case 0:
5935 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5936 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5937 break;
5938 case 1:
5939 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5940 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5941 break;
5942 case 2:
5943 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5944 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5945 break;
5946 default:
5947 break;
5948 }
5949 }
5950
5951 free (rela);
5952 }
5953
89fac5e3 5954 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5955 return 1;
5956}
5957
1b31d05e 5958static void
2cf0635d 5959ia64_process_unwind (FILE * file)
4d6ed7c8 5960{
2cf0635d
NC		 5961 Elf_Internal_Shdr * sec;
5962 Elf_Internal_Shdr * unwsec = NULL;
5963 Elf_Internal_Shdr * strsec;
89fac5e3 5964 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5965 struct ia64_unw_aux_info aux;
f1467e33 5966
4d6ed7c8
NC		 5967 memset (& aux, 0, sizeof (aux));
5968
4d6ed7c8
NC		 5969 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5970 {
c256ffe7 5971 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5972 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 5973 {
ba5cdace 5974 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 5975
4fbb74a6 5976 strsec = section_headers + sec->sh_link;
59245841 5977 assert (aux.strtab == NULL);
3f5e193b
NC		 5978 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5979 1, strsec->sh_size,
5980 _("string table"));
c256ffe7 5981 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5982 }
5983 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5984 unwcount++;
5985 }
5986
5987 if (!unwcount)
5988 printf (_("\nThere are no unwind sections in this file.\n"));
5989
5990 while (unwcount-- > 0)
5991 {
2cf0635d 5992 char * suffix;
579f31ac
JJ		 5993 size_t len, len2;
5994
5995 for (i = unwstart, sec = section_headers + unwstart;
5996 i < elf_header.e_shnum; ++i, ++sec)
5997 if (sec->sh_type == SHT_IA_64_UNWIND)
5998 {
5999 unwsec = sec;
6000 break;
6001 }
6002
6003 unwstart = i + 1;
6004 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6005
e4b17d5c
L		 6006 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6007 {
6008 /* We need to find which section group it is in. */
2cf0635d 6009 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 6010
6011 for (; g != NULL; g = g->next)
6012 {
4fbb74a6 6013 sec = section_headers + g->section_index;
18bd398b
NC		 6014
6015 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6016 break;
e4b17d5c
L		 6017 }
6018
6019 if (g == NULL)
6020 i = elf_header.e_shnum;
6021 }
18bd398b 6022 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6023 {
18bd398b 6024 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6025 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6026 suffix = SECTION_NAME (unwsec) + len;
6027 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6028 ++i, ++sec)
18bd398b
NC		 6029 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6030 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6031 break;
6032 }
6033 else
6034 {
6035 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6036 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6037 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6038 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6039 suffix = "";
18bd398b 6040 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6041 suffix = SECTION_NAME (unwsec) + len;
6042 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6043 ++i, ++sec)
18bd398b
NC		 6044 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6045 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6046 break;
6047 }
6048
6049 if (i == elf_header.e_shnum)
6050 {
6051 printf (_("\nCould not find unwind info section for "));
6052
6053 if (string_table == NULL)
6054 printf ("%d", unwsec->sh_name);
6055 else
3a1a2036 6056 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 6057 }
6058 else
4d6ed7c8 6059 {
4d6ed7c8 6060 aux.info_addr = sec->sh_addr;
3f5e193b 6061 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6062 sec->sh_size,
3f5e193b 6063 _("unwind info"));
59245841 6064 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6065
579f31ac 6066 printf (_("\nUnwind section "));
4d6ed7c8 6067
579f31ac
JJ		 6068 if (string_table == NULL)
6069 printf ("%d", unwsec->sh_name);
6070 else
3a1a2036 6071 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6072
579f31ac 6073 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6074 (unsigned long) unwsec->sh_offset,
89fac5e3 6075 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6076
579f31ac 6077 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6078
579f31ac
JJ		 6079 if (aux.table_len > 0)
6080 dump_ia64_unwind (& aux);
6081
6082 if (aux.table)
6083 free ((char *) aux.table);
6084 if (aux.info)
6085 free ((char *) aux.info);
6086 aux.table = NULL;
6087 aux.info = NULL;
6088 }
4d6ed7c8 6089 }
4d6ed7c8 6090
4d6ed7c8
NC		 6091 if (aux.symtab)
6092 free (aux.symtab);
6093 if (aux.strtab)
6094 free ((char *) aux.strtab);
4d6ed7c8
NC		 6095}
6096
3f5e193b
NC		 6097struct hppa_unw_table_entry
6098 {
6099 struct absaddr start;
6100 struct absaddr end;
6101 unsigned int Cannot_unwind:1; /* 0 */
6102 unsigned int Millicode:1; /* 1 */
6103 unsigned int Millicode_save_sr0:1; /* 2 */
6104 unsigned int Region_description:2; /* 3..4 */
6105 unsigned int reserved1:1; /* 5 */
6106 unsigned int Entry_SR:1; /* 6 */
6107 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6108 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6109 unsigned int Args_stored:1; /* 16 */
6110 unsigned int Variable_Frame:1; /* 17 */
6111 unsigned int Separate_Package_Body:1; /* 18 */
6112 unsigned int Frame_Extension_Millicode:1; /* 19 */
6113 unsigned int Stack_Overflow_Check:1; /* 20 */
6114 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6115 unsigned int Ada_Region:1; /* 22 */
6116 unsigned int cxx_info:1; /* 23 */
6117 unsigned int cxx_try_catch:1; /* 24 */
6118 unsigned int sched_entry_seq:1; /* 25 */
6119 unsigned int reserved2:1; /* 26 */
6120 unsigned int Save_SP:1; /* 27 */
6121 unsigned int Save_RP:1; /* 28 */
6122 unsigned int Save_MRP_in_frame:1; /* 29 */
6123 unsigned int extn_ptr_defined:1; /* 30 */
6124 unsigned int Cleanup_defined:1; /* 31 */
6125
6126 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6127 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6128 unsigned int Large_frame:1; /* 2 */
6129 unsigned int Pseudo_SP_Set:1; /* 3 */
6130 unsigned int reserved4:1; /* 4 */
6131 unsigned int Total_frame_size:27; /* 5..31 */
6132 };
6133
57346661
AM		 6134struct hppa_unw_aux_info
6135 {
3f5e193b 6136 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6137 unsigned long table_len; /* Length of unwind table. */
6138 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6139 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6140 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6141 char * strtab; /* The string table. */
57346661
AM		 6142 unsigned long strtab_size; /* Size of string table. */
6143 };
6144
6145static void
2cf0635d 6146dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6147{
2cf0635d 6148 struct hppa_unw_table_entry * tp;
57346661 6149
57346661
AM		 6150 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6151 {
6152 bfd_vma offset;
2cf0635d 6153 const char * procname;
57346661
AM		 6154
6155 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6156 aux->strtab_size, tp->start, &procname,
6157 &offset);
6158
6159 fputs ("\n<", stdout);
6160
6161 if (procname)
6162 {
6163 fputs (procname, stdout);
6164
6165 if (offset)
6166 printf ("+%lx", (unsigned long) offset);
6167 }
6168
6169 fputs (">: [", stdout);
6170 print_vma (tp->start.offset, PREFIX_HEX);
6171 fputc ('-', stdout);
6172 print_vma (tp->end.offset, PREFIX_HEX);
6173 printf ("]\n\t");
6174
18bd398b
NC		 6175#define PF(_m) if (tp->_m) printf (#_m " ");
6176#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6177 PF(Cannot_unwind);
6178 PF(Millicode);
6179 PF(Millicode_save_sr0);
18bd398b 6180 /* PV(Region_description); */
57346661
AM		 6181 PF(Entry_SR);
6182 PV(Entry_FR);
6183 PV(Entry_GR);
6184 PF(Args_stored);
6185 PF(Variable_Frame);
6186 PF(Separate_Package_Body);
6187 PF(Frame_Extension_Millicode);
6188 PF(Stack_Overflow_Check);
6189 PF(Two_Instruction_SP_Increment);
6190 PF(Ada_Region);
6191 PF(cxx_info);
6192 PF(cxx_try_catch);
6193 PF(sched_entry_seq);
6194 PF(Save_SP);
6195 PF(Save_RP);
6196 PF(Save_MRP_in_frame);
6197 PF(extn_ptr_defined);
6198 PF(Cleanup_defined);
6199 PF(MPE_XL_interrupt_marker);
6200 PF(HP_UX_interrupt_marker);
6201 PF(Large_frame);
6202 PF(Pseudo_SP_Set);
6203 PV(Total_frame_size);
6204#undef PF
6205#undef PV
6206 }
6207
18bd398b 6208 printf ("\n");
57346661
AM		 6209}
6210
6211static int
2cf0635d
NC		 6212slurp_hppa_unwind_table (FILE * file,
6213 struct hppa_unw_aux_info * aux,
6214 Elf_Internal_Shdr * sec)
57346661 6215{
1c0751b2 6216 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6217 Elf_Internal_Phdr * seg;
6218 struct hppa_unw_table_entry * tep;
6219 Elf_Internal_Shdr * relsec;
6220 Elf_Internal_Rela * rela;
6221 Elf_Internal_Rela * rp;
6222 unsigned char * table;
6223 unsigned char * tp;
6224 Elf_Internal_Sym * sym;
6225 const char * relname;
57346661 6226
57346661
AM		 6227 /* First, find the starting address of the segment that includes
6228 this section. */
6229
6230 if (elf_header.e_phnum)
6231 {
6232 if (! get_program_headers (file))
6233 return 0;
6234
6235 for (seg = program_headers;
6236 seg < program_headers + elf_header.e_phnum;
6237 ++seg)
6238 {
6239 if (seg->p_type != PT_LOAD)
6240 continue;
6241
6242 if (sec->sh_addr >= seg->p_vaddr
6243 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6244 {
6245 aux->seg_base = seg->p_vaddr;
6246 break;
6247 }
6248 }
6249 }
6250
6251 /* Second, build the unwind table from the contents of the unwind
6252 section. */
6253 size = sec->sh_size;
3f5e193b
NC		 6254 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6255 _("unwind table"));
57346661
AM		 6256 if (!table)
6257 return 0;
6258
1c0751b2
DA		 6259 unw_ent_size = 16;
6260 nentries = size / unw_ent_size;
6261 size = unw_ent_size * nentries;
57346661 6262
3f5e193b
NC		 6263 tep = aux->table = (struct hppa_unw_table_entry *)
6264 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6265
1c0751b2 6266 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6267 {
6268 unsigned int tmp1, tmp2;
6269
6270 tep->start.section = SHN_UNDEF;
6271 tep->end.section = SHN_UNDEF;
6272
1c0751b2
DA		 6273 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6274 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6275 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6276 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6277
6278 tep->start.offset += aux->seg_base;
6279 tep->end.offset += aux->seg_base;
57346661
AM		 6280
6281 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6282 tep->Millicode = (tmp1 >> 30) & 0x1;
6283 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6284 tep->Region_description = (tmp1 >> 27) & 0x3;
6285 tep->reserved1 = (tmp1 >> 26) & 0x1;
6286 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6287 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6288 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6289 tep->Args_stored = (tmp1 >> 15) & 0x1;
6290 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6291 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6292 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6293 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6294 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6295 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6296 tep->cxx_info = (tmp1 >> 8) & 0x1;
6297 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6298 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6299 tep->reserved2 = (tmp1 >> 5) & 0x1;
6300 tep->Save_SP = (tmp1 >> 4) & 0x1;
6301 tep->Save_RP = (tmp1 >> 3) & 0x1;
6302 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6303 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6304 tep->Cleanup_defined = tmp1 & 0x1;
6305
6306 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6307 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6308 tep->Large_frame = (tmp2 >> 29) & 0x1;
6309 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6310 tep->reserved4 = (tmp2 >> 27) & 0x1;
6311 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6312 }
6313 free (table);
6314
6315 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6316 for (relsec = section_headers;
6317 relsec < section_headers + elf_header.e_shnum;
6318 ++relsec)
6319 {
6320 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6321 || relsec->sh_info >= elf_header.e_shnum
6322 || section_headers + relsec->sh_info != sec)
57346661
AM		 6323 continue;
6324
6325 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6326 & rela, & nrelas))
6327 return 0;
6328
6329 for (rp = rela; rp < rela + nrelas; ++rp)
6330 {
aca88567
NC		 6331 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6332 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6333
6334 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6335 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6336 {
6337 warn (_("Skipping unexpected relocation type %s\n"), relname);
6338 continue;
6339 }
6340
6341 i = rp->r_offset / unw_ent_size;
6342
89fac5e3 6343 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6344 {
6345 case 0:
6346 aux->table[i].start.section = sym->st_shndx;
1e456d54 6347 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6348 break;
6349 case 1:
6350 aux->table[i].end.section = sym->st_shndx;
1e456d54 6351 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6352 break;
6353 default:
6354 break;
6355 }
6356 }
6357
6358 free (rela);
6359 }
6360
1c0751b2 6361 aux->table_len = nentries;
57346661
AM		 6362
6363 return 1;
6364}
6365
1b31d05e 6366static void
2cf0635d 6367hppa_process_unwind (FILE * file)
57346661 6368{
57346661 6369 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6370 Elf_Internal_Shdr * unwsec = NULL;
6371 Elf_Internal_Shdr * strsec;
6372 Elf_Internal_Shdr * sec;
18bd398b 6373 unsigned long i;
57346661 6374
c256ffe7 6375 if (string_table == NULL)
1b31d05e
NC		 6376 return;
6377
6378 memset (& aux, 0, sizeof (aux));
57346661
AM		 6379
6380 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6381 {
c256ffe7 6382 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6383 && sec->sh_link < elf_header.e_shnum)
57346661 6384 {
ba5cdace 6385 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6386
4fbb74a6 6387 strsec = section_headers + sec->sh_link;
59245841 6388 assert (aux.strtab == NULL);
3f5e193b
NC		 6389 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6390 1, strsec->sh_size,
6391 _("string table"));
c256ffe7 6392 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6393 }
18bd398b 6394 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6395 unwsec = sec;
6396 }
6397
6398 if (!unwsec)
6399 printf (_("\nThere are no unwind sections in this file.\n"));
6400
6401 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6402 {
18bd398b 6403 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6404 {
57346661
AM		 6405 printf (_("\nUnwind section "));
6406 printf (_("'%s'"), SECTION_NAME (sec));
6407
6408 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6409 (unsigned long) sec->sh_offset,
89fac5e3 6410 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6411
6412 slurp_hppa_unwind_table (file, &aux, sec);
6413 if (aux.table_len > 0)
6414 dump_hppa_unwind (&aux);
6415
6416 if (aux.table)
6417 free ((char *) aux.table);
6418 aux.table = NULL;
6419 }
6420 }
6421
6422 if (aux.symtab)
6423 free (aux.symtab);
6424 if (aux.strtab)
6425 free ((char *) aux.strtab);
57346661
AM		 6426}
6427
0b6ae522
DJ		 6428struct arm_section
6429{
a734115a
NC		 6430 unsigned char * data; /* The unwind data. */
6431 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6432 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6433 unsigned long nrelas; /* The number of relocations. */
6434 unsigned int rel_type; /* REL or RELA ? */
6435 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6436};
6437
6438struct arm_unw_aux_info
6439{
a734115a
NC		 6440 FILE * file; /* The file containing the unwind sections. */
6441 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6442 unsigned long nsyms; /* Number of symbols. */
6443 char * strtab; /* The file's string table. */
6444 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6445};
6446
6447static const char *
6448arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6449 bfd_vma fn, struct absaddr addr)
6450{
6451 const char *procname;
6452 bfd_vma sym_offset;
6453
6454 if (addr.section == SHN_UNDEF)
6455 addr.offset = fn;
6456
6457 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6458 aux->strtab_size, addr, &procname,
6459 &sym_offset);
6460
6461 print_vma (fn, PREFIX_HEX);
6462
6463 if (procname)
6464 {
6465 fputs (" <", stdout);
6466 fputs (procname, stdout);
6467
6468 if (sym_offset)
6469 printf ("+0x%lx", (unsigned long) sym_offset);
6470 fputc ('>', stdout);
6471 }
6472
6473 return procname;
6474}
6475
6476static void
6477arm_free_section (struct arm_section *arm_sec)
6478{
6479 if (arm_sec->data != NULL)
6480 free (arm_sec->data);
6481
6482 if (arm_sec->rela != NULL)
6483 free (arm_sec->rela);
6484}
6485
a734115a
NC		 6486/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6487 cached section and install SEC instead.
6488 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6489 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6490 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6491 relocation's offset in ADDR.
1b31d05e
NC		 6492 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6493 into the string table of the symbol associated with the reloc. If no
6494 reloc was applied store -1 there.
6495 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6496
6497static bfd_boolean
1b31d05e
NC		 6498get_unwind_section_word (struct arm_unw_aux_info * aux,
6499 struct arm_section * arm_sec,
6500 Elf_Internal_Shdr * sec,
6501 bfd_vma word_offset,
6502 unsigned int * wordp,
6503 struct absaddr * addr,
6504 bfd_vma * sym_name)
0b6ae522
DJ		 6505{
6506 Elf_Internal_Rela *rp;
6507 Elf_Internal_Sym *sym;
6508 const char * relname;
6509 unsigned int word;
6510 bfd_boolean wrapped;
6511
6512 addr->section = SHN_UNDEF;
6513 addr->offset = 0;
6514
1b31d05e
NC		 6515 if (sym_name != NULL)
6516 *sym_name = (bfd_vma) -1;
6517
a734115a 6518 /* If necessary, update the section cache. */
0b6ae522
DJ		 6519 if (sec != arm_sec->sec)
6520 {
6521 Elf_Internal_Shdr *relsec;
6522
6523 arm_free_section (arm_sec);
6524
6525 arm_sec->sec = sec;
6526 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6527 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6528 arm_sec->rela = NULL;
6529 arm_sec->nrelas = 0;
6530
6531 for (relsec = section_headers;
6532 relsec < section_headers + elf_header.e_shnum;
6533 ++relsec)
6534 {
6535 if (relsec->sh_info >= elf_header.e_shnum
6536 || section_headers + relsec->sh_info != sec)
6537 continue;
6538
a734115a 6539 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6540 if (relsec->sh_type == SHT_REL)
6541 {
6542 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6543 relsec->sh_size,
6544 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6545 return FALSE;
0b6ae522
DJ		 6546 break;
6547 }
6548 else if (relsec->sh_type == SHT_RELA)
6549 {
6550 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6551 relsec->sh_size,
6552 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6553 return FALSE;
0b6ae522
DJ		 6554 break;
6555 }
a734115a
NC		 6556 else
6557 warn (_("unexpected relocation type (%d) for section %d"),
6558 relsec->sh_type, relsec->sh_info);
0b6ae522
DJ		 6559 }
6560
6561 arm_sec->next_rela = arm_sec->rela;
6562 }
6563
a734115a 6564 /* If there is no unwind data we can do nothing. */
0b6ae522 6565 if (arm_sec->data == NULL)
a734115a 6566 return FALSE;
0b6ae522 6567
a734115a 6568 /* Get the word at the required offset. */
0b6ae522
DJ		 6569 word = byte_get (arm_sec->data + word_offset, 4);
6570
a734115a 6571 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6572 wrapped = FALSE;
6573 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6574 {
6575 bfd_vma prelval, offset;
6576
6577 if (rp->r_offset > word_offset && !wrapped)
6578 {
6579 rp = arm_sec->rela;
6580 wrapped = TRUE;
6581 }
6582 if (rp->r_offset > word_offset)
6583 break;
6584
6585 if (rp->r_offset & 3)
6586 {
6587 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6588 (unsigned long) rp->r_offset);
6589 continue;
6590 }
6591
6592 if (rp->r_offset < word_offset)
6593 continue;
6594
0b6ae522
DJ		 6595 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6596
6597 if (arm_sec->rel_type == SHT_REL)
6598 {
6599 offset = word & 0x7fffffff;
6600 if (offset & 0x40000000)
6601 offset |= ~ (bfd_vma) 0x7fffffff;
6602 }
a734115a 6603 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6604 offset = rp->r_addend;
a734115a
NC		 6605 else
6606 abort ();
0b6ae522
DJ		 6607
6608 offset += sym->st_value;
6609 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6610
a734115a
NC		 6611 /* Check that we are processing the expected reloc type. */
6612 if (elf_header.e_machine == EM_ARM)
6613 {
6614 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6615
6616 if (streq (relname, "R_ARM_NONE"))
6617 continue;
6618
6619 if (! streq (relname, "R_ARM_PREL31"))
6620 {
6621 warn (_("Skipping unexpected relocation type %s\n"), relname);
6622 continue;
6623 }
6624 }
6625 else if (elf_header.e_machine == EM_TI_C6000)
6626 {
6627 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6628
6629 if (streq (relname, "R_C6000_NONE"))
6630 continue;
6631
6632 if (! streq (relname, "R_C6000_PREL31"))
6633 {
6634 warn (_("Skipping unexpected relocation type %s\n"), relname);
6635 continue;
6636 }
6637
6638 prelval >>= 1;
6639 }
6640 else
6641 /* This function currently only supports ARM and TI unwinders. */
6642 abort ();
fa197c1c 6643
0b6ae522
DJ		 6644 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6645 addr->section = sym->st_shndx;
6646 addr->offset = offset;
1b31d05e
NC		 6647 if (sym_name)
6648 * sym_name = sym->st_name;
0b6ae522
DJ		 6649 break;
6650 }
6651
6652 *wordp = word;
6653 arm_sec->next_rela = rp;
6654
a734115a 6655 return TRUE;
0b6ae522
DJ		 6656}
6657
a734115a
NC		 6658static const char *tic6x_unwind_regnames[16] =
6659{
6660 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6661 "A14", "A13", "A12", "A11", "A10",
6662 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6663};
fa197c1c 6664
0b6ae522 6665static void
fa197c1c 6666decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6667{
fa197c1c
PB		 6668 int i;
6669
6670 for (i = 12; mask; mask >>= 1, i--)
6671 {
6672 if (mask & 1)
6673 {
6674 fputs (tic6x_unwind_regnames[i], stdout);
6675 if (mask > 1)
6676 fputs (", ", stdout);
6677 }
6678 }
6679}
0b6ae522
DJ		 6680
6681#define ADVANCE \
6682 if (remaining == 0 && more_words) \
6683 { \
6684 data_offset += 4; \
1b31d05e
NC		 6685 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6686 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 6687 return; \
6688 remaining = 4; \
6689 more_words--; \
6690 } \
6691
6692#define GET_OP(OP) \
6693 ADVANCE; \
6694 if (remaining) \
6695 { \
6696 remaining--; \
6697 (OP) = word >> 24; \
6698 word <<= 8; \
6699 } \
6700 else \
6701 { \
2b692964 6702 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6703 return; \
6704 } \
cc5914eb 6705 printf ("0x%02x ", OP)
0b6ae522 6706
fa197c1c
PB		 6707static void
6708decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6709 unsigned int word, unsigned int remaining,
6710 unsigned int more_words,
6711 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6712 struct arm_section *data_arm_sec)
6713{
6714 struct absaddr addr;
0b6ae522
DJ		 6715
6716 /* Decode the unwinding instructions. */
6717 while (1)
6718 {
6719 unsigned int op, op2;
6720
6721 ADVANCE;
6722 if (remaining == 0)
6723 break;
6724 remaining--;
6725 op = word >> 24;
6726 word <<= 8;
6727
cc5914eb 6728 printf (" 0x%02x ", op);
0b6ae522
DJ		 6729
6730 if ((op & 0xc0) == 0x00)
6731 {
6732 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6733
cc5914eb 6734 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6735 }
6736 else if ((op & 0xc0) == 0x40)
6737 {
6738 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6739
cc5914eb 6740 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6741 }
6742 else if ((op & 0xf0) == 0x80)
6743 {
6744 GET_OP (op2);
6745 if (op == 0x80 && op2 == 0)
6746 printf (_("Refuse to unwind"));
6747 else
6748 {
6749 unsigned int mask = ((op & 0x0f) << 8) | op2;
6750 int first = 1;
6751 int i;
2b692964 6752
0b6ae522
DJ		 6753 printf ("pop {");
6754 for (i = 0; i < 12; i++)
6755 if (mask & (1 << i))
6756 {
6757 if (first)
6758 first = 0;
6759 else
6760 printf (", ");
6761 printf ("r%d", 4 + i);
6762 }
6763 printf ("}");
6764 }
6765 }
6766 else if ((op & 0xf0) == 0x90)
6767 {
6768 if (op == 0x9d || op == 0x9f)
6769 printf (_(" [Reserved]"));
6770 else
cc5914eb 6771 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6772 }
6773 else if ((op & 0xf0) == 0xa0)
6774 {
6775 int end = 4 + (op & 0x07);
6776 int first = 1;
6777 int i;
61865e30 6778
0b6ae522
DJ		 6779 printf (" pop {");
6780 for (i = 4; i <= end; i++)
6781 {
6782 if (first)
6783 first = 0;
6784 else
6785 printf (", ");
6786 printf ("r%d", i);
6787 }
6788 if (op & 0x08)
6789 {
1b31d05e 6790 if (!first)
0b6ae522
DJ		 6791 printf (", ");
6792 printf ("r14");
6793 }
6794 printf ("}");
6795 }
6796 else if (op == 0xb0)
6797 printf (_(" finish"));
6798 else if (op == 0xb1)
6799 {
6800 GET_OP (op2);
6801 if (op2 == 0 || (op2 & 0xf0) != 0)
6802 printf (_("[Spare]"));
6803 else
6804 {
6805 unsigned int mask = op2 & 0x0f;
6806 int first = 1;
6807 int i;
61865e30 6808
0b6ae522
DJ		 6809 printf ("pop {");
6810 for (i = 0; i < 12; i++)
6811 if (mask & (1 << i))
6812 {
6813 if (first)
6814 first = 0;
6815 else
6816 printf (", ");
6817 printf ("r%d", i);
6818 }
6819 printf ("}");
6820 }
6821 }
6822 else if (op == 0xb2)
6823 {
b115cf96 6824 unsigned char buf[9];
0b6ae522
DJ		 6825 unsigned int i, len;
6826 unsigned long offset;
61865e30 6827
b115cf96 6828 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6829 {
6830 GET_OP (buf[i]);
6831 if ((buf[i] & 0x80) == 0)
6832 break;
6833 }
6834 assert (i < sizeof (buf));
6835 offset = read_uleb128 (buf, &len);
6836 assert (len == i + 1);
6837 offset = offset * 4 + 0x204;
cc5914eb 6838 printf ("vsp = vsp + %ld", offset);
0b6ae522 6839 }
61865e30 6840 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6841 {
61865e30
NC		 6842 unsigned int first, last;
6843
6844 GET_OP (op2);
6845 first = op2 >> 4;
6846 last = op2 & 0x0f;
6847 if (op == 0xc8)
6848 first = first + 16;
6849 printf ("pop {D%d", first);
6850 if (last)
6851 printf ("-D%d", first + last);
6852 printf ("}");
6853 }
6854 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6855 {
6856 unsigned int count = op & 0x07;
6857
6858 printf ("pop {D8");
6859 if (count)
6860 printf ("-D%d", 8 + count);
6861 printf ("}");
6862 }
6863 else if (op >= 0xc0 && op <= 0xc5)
6864 {
6865 unsigned int count = op & 0x07;
6866
6867 printf (" pop {wR10");
6868 if (count)
6869 printf ("-wR%d", 10 + count);
6870 printf ("}");
6871 }
6872 else if (op == 0xc6)
6873 {
6874 unsigned int first, last;
6875
6876 GET_OP (op2);
6877 first = op2 >> 4;
6878 last = op2 & 0x0f;
6879 printf ("pop {wR%d", first);
6880 if (last)
6881 printf ("-wR%d", first + last);
6882 printf ("}");
6883 }
6884 else if (op == 0xc7)
6885 {
6886 GET_OP (op2);
6887 if (op2 == 0 || (op2 & 0xf0) != 0)
6888 printf (_("[Spare]"));
0b6ae522
DJ		 6889 else
6890 {
61865e30
NC		 6891 unsigned int mask = op2 & 0x0f;
6892 int first = 1;
6893 int i;
6894
6895 printf ("pop {");
6896 for (i = 0; i < 4; i++)
6897 if (mask & (1 << i))
6898 {
6899 if (first)
6900 first = 0;
6901 else
6902 printf (", ");
6903 printf ("wCGR%d", i);
6904 }
6905 printf ("}");
0b6ae522
DJ		 6906 }
6907 }
61865e30
NC		 6908 else
6909 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6910 printf ("\n");
6911 }
fa197c1c
PB		 6912}
6913
6914static void
6915decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6916 unsigned int word, unsigned int remaining,
6917 unsigned int more_words,
6918 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6919 struct arm_section *data_arm_sec)
6920{
6921 struct absaddr addr;
6922
6923 /* Decode the unwinding instructions. */
6924 while (1)
6925 {
6926 unsigned int op, op2;
6927
6928 ADVANCE;
6929 if (remaining == 0)
6930 break;
6931 remaining--;
6932 op = word >> 24;
6933 word <<= 8;
6934
9cf03b7e 6935 printf (" 0x%02x ", op);
fa197c1c
PB		 6936
6937 if ((op & 0xc0) == 0x00)
6938 {
6939 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 6940 printf (" sp = sp + %d", offset);
fa197c1c
PB		 6941 }
6942 else if ((op & 0xc0) == 0x80)
6943 {
6944 GET_OP (op2);
6945 if (op == 0x80 && op2 == 0)
6946 printf (_("Refuse to unwind"));
6947 else
6948 {
6949 unsigned int mask = ((op & 0x1f) << 8) | op2;
6950 if (op & 0x20)
6951 printf ("pop compact {");
6952 else
6953 printf ("pop {");
6954
6955 decode_tic6x_unwind_regmask (mask);
6956 printf("}");
6957 }
6958 }
6959 else if ((op & 0xf0) == 0xc0)
6960 {
6961 unsigned int reg;
6962 unsigned int nregs;
6963 unsigned int i;
6964 const char *name;
a734115a
NC		 6965 struct
6966 {
fa197c1c
PB		 6967 unsigned int offset;
6968 unsigned int reg;
6969 } regpos[16];
6970
6971 /* Scan entire instruction first so that GET_OP output is not
6972 interleaved with disassembly. */
6973 nregs = 0;
6974 for (i = 0; nregs < (op & 0xf); i++)
6975 {
6976 GET_OP (op2);
6977 reg = op2 >> 4;
6978 if (reg != 0xf)
6979 {
6980 regpos[nregs].offset = i * 2;
6981 regpos[nregs].reg = reg;
6982 nregs++;
6983 }
6984
6985 reg = op2 & 0xf;
6986 if (reg != 0xf)
6987 {
6988 regpos[nregs].offset = i * 2 + 1;
6989 regpos[nregs].reg = reg;
6990 nregs++;
6991 }
6992 }
6993
6994 printf (_("pop frame {"));
6995 reg = nregs - 1;
6996 for (i = i * 2; i > 0; i--)
6997 {
6998 if (regpos[reg].offset == i - 1)
6999 {
7000 name = tic6x_unwind_regnames[regpos[reg].reg];
7001 if (reg > 0)
7002 reg--;
7003 }
7004 else
7005 name = _("[pad]");
7006
7007 fputs (name, stdout);
7008 if (i > 1)
7009 printf (", ");
7010 }
7011
7012 printf ("}");
7013 }
7014 else if (op == 0xd0)
7015 printf (" MOV FP, SP");
7016 else if (op == 0xd1)
7017 printf (" __c6xabi_pop_rts");
7018 else if (op == 0xd2)
7019 {
7020 unsigned char buf[9];
7021 unsigned int i, len;
7022 unsigned long offset;
a734115a 7023
fa197c1c
PB		 7024 for (i = 0; i < sizeof (buf); i++)
7025 {
7026 GET_OP (buf[i]);
7027 if ((buf[i] & 0x80) == 0)
7028 break;
7029 }
7030 assert (i < sizeof (buf));
7031 offset = read_uleb128 (buf, &len);
7032 assert (len == i + 1);
7033 offset = offset * 8 + 0x408;
7034 printf (_("sp = sp + %ld"), offset);
7035 }
7036 else if ((op & 0xf0) == 0xe0)
7037 {
7038 if ((op & 0x0f) == 7)
7039 printf (" RETURN");
7040 else
7041 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7042 }
7043 else
7044 {
7045 printf (_(" [unsupported opcode]"));
7046 }
7047 putchar ('\n');
7048 }
7049}
7050
7051static bfd_vma
a734115a 7052arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7053{
7054 bfd_vma offset;
7055
7056 offset = word & 0x7fffffff;
7057 if (offset & 0x40000000)
7058 offset |= ~ (bfd_vma) 0x7fffffff;
7059
7060 if (elf_header.e_machine == EM_TI_C6000)
7061 offset <<= 1;
7062
7063 return offset + where;
7064}
7065
7066static void
1b31d05e
NC		 7067decode_arm_unwind (struct arm_unw_aux_info * aux,
7068 unsigned int word,
7069 unsigned int remaining,
7070 bfd_vma data_offset,
7071 Elf_Internal_Shdr * data_sec,
7072 struct arm_section * data_arm_sec)
fa197c1c
PB		 7073{
7074 int per_index;
7075 unsigned int more_words = 0;
7076 struct absaddr addr;
1b31d05e 7077 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7078
7079 if (remaining == 0)
7080 {
1b31d05e
NC		 7081 /* Fetch the first word.
7082 Note - when decoding an object file the address extracted
7083 here will always be 0. So we also pass in the sym_name
7084 parameter so that we can find the symbol associated with
7085 the personality routine. */
7086 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7087 & word, & addr, & sym_name))
fa197c1c 7088 return;
1b31d05e 7089
fa197c1c
PB		 7090 remaining = 4;
7091 }
7092
7093 if ((word & 0x80000000) == 0)
7094 {
7095 /* Expand prel31 for personality routine. */
7096 bfd_vma fn;
7097 const char *procname;
7098
a734115a 7099 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7100 printf (_(" Personality routine: "));
1b31d05e
NC		 7101 if (fn == 0
7102 && addr.section == SHN_UNDEF && addr.offset == 0
7103 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7104 {
7105 procname = aux->strtab + sym_name;
7106 print_vma (fn, PREFIX_HEX);
7107 if (procname)
7108 {
7109 fputs (" <", stdout);
7110 fputs (procname, stdout);
7111 fputc ('>', stdout);
7112 }
7113 }
7114 else
7115 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7116 fputc ('\n', stdout);
7117
7118 /* The GCC personality routines use the standard compact
7119 encoding, starting with one byte giving the number of
7120 words. */
7121 if (procname != NULL
7122 && (const_strneq (procname, "__gcc_personality_v0")
7123 || const_strneq (procname, "__gxx_personality_v0")
7124 || const_strneq (procname, "__gcj_personality_v0")
7125 || const_strneq (procname, "__gnu_objc_personality_v0")))
7126 {
7127 remaining = 0;
7128 more_words = 1;
7129 ADVANCE;
7130 if (!remaining)
7131 {
7132 printf (_(" [Truncated data]\n"));
7133 return;
7134 }
7135 more_words = word >> 24;
7136 word <<= 8;
7137 remaining--;
7138 per_index = -1;
7139 }
7140 else
7141 return;
7142 }
7143 else
7144 {
1b31d05e
NC		 7145 /* ARM EHABI Section 6.3:
7146
7147 An exception-handling table entry for the compact model looks like:
7148
7149 31 30-28 27-24 23-0
7150 -- ----- ----- ----
7151 1 0 index Data for personalityRoutine[index] */
7152
7153 if (elf_header.e_machine == EM_ARM
7154 && (word & 0x70000000))
83c257ca 7155 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7156
fa197c1c 7157 per_index = (word >> 24) & 0x7f;
1b31d05e 7158 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7159 if (per_index == 0)
7160 {
7161 more_words = 0;
7162 word <<= 8;
7163 remaining--;
7164 }
7165 else if (per_index < 3)
7166 {
7167 more_words = (word >> 16) & 0xff;
7168 word <<= 16;
7169 remaining -= 2;
7170 }
7171 }
7172
7173 switch (elf_header.e_machine)
7174 {
7175 case EM_ARM:
7176 if (per_index < 3)
7177 {
7178 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7179 data_offset, data_sec, data_arm_sec);
7180 }
7181 else
1b31d05e
NC		 7182 {
7183 warn (_("Unknown ARM compact model index encountered\n"));
7184 printf (_(" [reserved]\n"));
7185 }
fa197c1c
PB		 7186 break;
7187
7188 case EM_TI_C6000:
7189 if (per_index < 3)
7190 {
7191 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7192 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7193 }
7194 else if (per_index < 5)
7195 {
7196 if (((word >> 17) & 0x7f) == 0x7f)
7197 printf (_(" Restore stack from frame pointer\n"));
7198 else
7199 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7200 printf (_(" Registers restored: "));
7201 if (per_index == 4)
7202 printf (" (compact) ");
7203 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7204 putchar ('\n');
7205 printf (_(" Return register: %s\n"),
7206 tic6x_unwind_regnames[word & 0xf]);
7207 }
7208 else
1b31d05e 7209 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7210 break;
7211
7212 default:
1b31d05e
NC		 7213 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7214 elf_header.e_machine);
fa197c1c 7215 }
0b6ae522
DJ		 7216
7217 /* Decode the descriptors. Not implemented. */
7218}
7219
7220static void
7221dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7222{
7223 struct arm_section exidx_arm_sec, extab_arm_sec;
7224 unsigned int i, exidx_len;
7225
7226 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7227 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7228 exidx_len = exidx_sec->sh_size / 8;
7229
7230 for (i = 0; i < exidx_len; i++)
7231 {
7232 unsigned int exidx_fn, exidx_entry;
7233 struct absaddr fn_addr, entry_addr;
7234 bfd_vma fn;
7235
7236 fputc ('\n', stdout);
7237
1b31d05e
NC		 7238 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7239 8 * i, & exidx_fn, & fn_addr, NULL)
7240 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7241 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7242 {
1b31d05e
NC		 7243 arm_free_section (& exidx_arm_sec);
7244 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7245 return;
7246 }
7247
83c257ca
NC		 7248 /* ARM EHABI, Section 5:
7249 An index table entry consists of 2 words.
7250 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7251 if (exidx_fn & 0x80000000)
7252 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7253
a734115a 7254 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7255
a734115a 7256 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7257 fputs (": ", stdout);
7258
7259 if (exidx_entry == 1)
7260 {
7261 print_vma (exidx_entry, PREFIX_HEX);
7262 fputs (" [cantunwind]\n", stdout);
7263 }
7264 else if (exidx_entry & 0x80000000)
7265 {
7266 print_vma (exidx_entry, PREFIX_HEX);
7267 fputc ('\n', stdout);
7268 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7269 }
7270 else
7271 {
8f73510c 7272 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7273 Elf_Internal_Shdr *table_sec;
7274
7275 fputs ("@", stdout);
a734115a 7276 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7277 print_vma (table, PREFIX_HEX);
7278 printf ("\n");
7279
7280 /* Locate the matching .ARM.extab. */
7281 if (entry_addr.section != SHN_UNDEF
7282 && entry_addr.section < elf_header.e_shnum)
7283 {
7284 table_sec = section_headers + entry_addr.section;
7285 table_offset = entry_addr.offset;
7286 }
7287 else
7288 {
7289 table_sec = find_section_by_address (table);
7290 if (table_sec != NULL)
7291 table_offset = table - table_sec->sh_addr;
7292 }
7293 if (table_sec == NULL)
7294 {
7295 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7296 (unsigned long) table);
7297 continue;
7298 }
7299 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7300 &extab_arm_sec);
7301 }
7302 }
7303
7304 printf ("\n");
7305
7306 arm_free_section (&exidx_arm_sec);
7307 arm_free_section (&extab_arm_sec);
7308}
7309
fa197c1c 7310/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7311
7312static void
0b6ae522
DJ		 7313arm_process_unwind (FILE *file)
7314{
7315 struct arm_unw_aux_info aux;
7316 Elf_Internal_Shdr *unwsec = NULL;
7317 Elf_Internal_Shdr *strsec;
7318 Elf_Internal_Shdr *sec;
7319 unsigned long i;
fa197c1c 7320 unsigned int sec_type;
0b6ae522 7321
fa197c1c
PB		 7322 switch (elf_header.e_machine)
7323 {
7324 case EM_ARM:
7325 sec_type = SHT_ARM_EXIDX;
7326 break;
7327
7328 case EM_TI_C6000:
7329 sec_type = SHT_C6000_UNWIND;
7330 break;
7331
1b31d05e
NC		 7332 default:
7333 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7334 elf_header.e_machine);
7335 return;
fa197c1c
PB		 7336 }
7337
0b6ae522 7338 if (string_table == NULL)
1b31d05e
NC		 7339 return;
7340
7341 memset (& aux, 0, sizeof (aux));
7342 aux.file = file;
0b6ae522
DJ		 7343
7344 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7345 {
7346 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7347 {
ba5cdace 7348 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7349
7350 strsec = section_headers + sec->sh_link;
59245841 7351 assert (aux.strtab == NULL);
0b6ae522
DJ		 7352 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7353 1, strsec->sh_size, _("string table"));
7354 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7355 }
fa197c1c 7356 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7357 unwsec = sec;
7358 }
7359
1b31d05e 7360 if (unwsec == NULL)
0b6ae522 7361 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7362 else
7363 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7364 {
7365 if (sec->sh_type == sec_type)
7366 {
7367 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7368 SECTION_NAME (sec),
7369 (unsigned long) sec->sh_offset,
7370 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7371
1b31d05e
NC		 7372 dump_arm_unwind (&aux, sec);
7373 }
7374 }
0b6ae522
DJ		 7375
7376 if (aux.symtab)
7377 free (aux.symtab);
7378 if (aux.strtab)
7379 free ((char *) aux.strtab);
0b6ae522
DJ		 7380}
7381
1b31d05e 7382static void
2cf0635d 7383process_unwind (FILE * file)
57346661 7384{
2cf0635d
NC		 7385 struct unwind_handler
7386 {
57346661 7387 int machtype;
1b31d05e 7388 void (* handler)(FILE *);
2cf0635d
NC		 7389 } handlers[] =
7390 {
0b6ae522 7391 { EM_ARM, arm_process_unwind },
57346661
AM		 7392 { EM_IA_64, ia64_process_unwind },
7393 { EM_PARISC, hppa_process_unwind },
fa197c1c 7394 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7395 { 0, 0 }
7396 };
7397 int i;
7398
7399 if (!do_unwind)
1b31d05e 7400 return;
57346661
AM		 7401
7402 for (i = 0; handlers[i].handler != NULL; i++)
7403 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7404 return handlers[i].handler (file);
57346661 7405
1b31d05e
NC		 7406 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7407 get_machine_name (elf_header.e_machine));
57346661
AM		 7408}
7409
252b5132 7410static void
2cf0635d 7411dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7412{
7413 switch (entry->d_tag)
7414 {
7415 case DT_MIPS_FLAGS:
7416 if (entry->d_un.d_val == 0)
4b68bca3 7417 printf (_("NONE"));
252b5132
RH		 7418 else
7419 {
7420 static const char * opts[] =
7421 {
7422 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7423 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7424 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7425 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7426 "RLD_ORDER_SAFE"
7427 };
7428 unsigned int cnt;
7429 int first = 1;
2b692964 7430
60bca95a 7431 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7432 if (entry->d_un.d_val & (1 << cnt))
7433 {
7434 printf ("%s%s", first ? "" : " ", opts[cnt]);
7435 first = 0;
7436 }
252b5132
RH		 7437 }
7438 break;
103f02d3 7439
252b5132 7440 case DT_MIPS_IVERSION:
d79b3d50 7441 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7442 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7443 else
4b68bca3 7444 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7445 break;
103f02d3 7446
252b5132
RH		 7447 case DT_MIPS_TIME_STAMP:
7448 {
7449 char timebuf[20];
2cf0635d 7450 struct tm * tmp;
50da7a9c 7451
91d6fa6a
NC		 7452 time_t atime = entry->d_un.d_val;
7453 tmp = gmtime (&atime);
e9e44622
JJ		 7454 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7455 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7456 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7457 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7458 }
7459 break;
103f02d3 7460
252b5132
RH		 7461 case DT_MIPS_RLD_VERSION:
7462 case DT_MIPS_LOCAL_GOTNO:
7463 case DT_MIPS_CONFLICTNO:
7464 case DT_MIPS_LIBLISTNO:
7465 case DT_MIPS_SYMTABNO:
7466 case DT_MIPS_UNREFEXTNO:
7467 case DT_MIPS_HIPAGENO:
7468 case DT_MIPS_DELTA_CLASS_NO:
7469 case DT_MIPS_DELTA_INSTANCE_NO:
7470 case DT_MIPS_DELTA_RELOC_NO:
7471 case DT_MIPS_DELTA_SYM_NO:
7472 case DT_MIPS_DELTA_CLASSSYM_NO:
7473 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7474 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7475 break;
103f02d3
UD		 7476
7477 default:
4b68bca3 7478 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7479 }
4b68bca3 7480 putchar ('\n');
103f02d3
UD		 7481}
7482
103f02d3 7483static void
2cf0635d 7484dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7485{
7486 switch (entry->d_tag)
7487 {
7488 case DT_HP_DLD_FLAGS:
7489 {
7490 static struct
7491 {
7492 long int bit;
2cf0635d 7493 const char * str;
5e220199
NC		 7494 }
7495 flags[] =
7496 {
7497 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7498 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7499 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7500 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7501 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7502 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7503 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7504 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7505 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7506 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7507 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7508 { DT_HP_GST, "HP_GST" },
7509 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7510 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7511 { DT_HP_NODELETE, "HP_NODELETE" },
7512 { DT_HP_GROUP, "HP_GROUP" },
7513 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7514 };
103f02d3 7515 int first = 1;
5e220199 7516 size_t cnt;
f7a99963 7517 bfd_vma val = entry->d_un.d_val;
103f02d3 7518
60bca95a 7519 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7520 if (val & flags[cnt].bit)
30800947
NC		 7521 {
7522 if (! first)
7523 putchar (' ');
7524 fputs (flags[cnt].str, stdout);
7525 first = 0;
7526 val ^= flags[cnt].bit;
7527 }
76da6bbe 7528
103f02d3 7529 if (val != 0 || first)
f7a99963
NC		 7530 {
7531 if (! first)
7532 putchar (' ');
7533 print_vma (val, HEX);
7534 }
103f02d3
UD		 7535 }
7536 break;
76da6bbe 7537
252b5132 7538 default:
f7a99963
NC		 7539 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7540 break;
252b5132 7541 }
35b1837e 7542 putchar ('\n');
252b5132
RH		 7543}
7544
28f997cf
TG		 7545#ifdef BFD64
7546
7547/* VMS vs Unix time offset and factor. */
7548
7549#define VMS_EPOCH_OFFSET 35067168000000000LL
7550#define VMS_GRANULARITY_FACTOR 10000000
7551
7552/* Display a VMS time in a human readable format. */
7553
7554static void
7555print_vms_time (bfd_int64_t vmstime)
7556{
7557 struct tm *tm;
7558 time_t unxtime;
7559
7560 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7561 tm = gmtime (&unxtime);
7562 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7563 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7564 tm->tm_hour, tm->tm_min, tm->tm_sec);
7565}
7566#endif /* BFD64 */
7567
ecc51f48 7568static void
2cf0635d 7569dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7570{
7571 switch (entry->d_tag)
7572 {
0de14b54 7573 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7574 /* First 3 slots reserved. */
ecc51f48
NC		 7575 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7576 printf (" -- ");
7577 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7578 break;
7579
28f997cf
TG		 7580 case DT_IA_64_VMS_LINKTIME:
7581#ifdef BFD64
7582 print_vms_time (entry->d_un.d_val);
7583#endif
7584 break;
7585
7586 case DT_IA_64_VMS_LNKFLAGS:
7587 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7588 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7589 printf (" CALL_DEBUG");
7590 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7591 printf (" NOP0BUFS");
7592 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7593 printf (" P0IMAGE");
7594 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7595 printf (" MKTHREADS");
7596 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7597 printf (" UPCALLS");
7598 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7599 printf (" IMGSTA");
7600 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7601 printf (" INITIALIZE");
7602 if (entry->d_un.d_val & VMS_LF_MAIN)
7603 printf (" MAIN");
7604 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7605 printf (" EXE_INIT");
7606 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7607 printf (" TBK_IN_IMG");
7608 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7609 printf (" DBG_IN_IMG");
7610 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7611 printf (" TBK_IN_DSF");
7612 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7613 printf (" DBG_IN_DSF");
7614 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7615 printf (" SIGNATURES");
7616 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7617 printf (" REL_SEG_OFF");
7618 break;
7619
bdf4d63a
JJ		 7620 default:
7621 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7622 break;
ecc51f48 7623 }
bdf4d63a 7624 putchar ('\n');
ecc51f48
NC		 7625}
7626
252b5132 7627static int
2cf0635d 7628get_32bit_dynamic_section (FILE * file)
252b5132 7629{
2cf0635d
NC		 7630 Elf32_External_Dyn * edyn;
7631 Elf32_External_Dyn * ext;
7632 Elf_Internal_Dyn * entry;
103f02d3 7633
3f5e193b
NC		 7634 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7635 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7636 if (!edyn)
7637 return 0;
103f02d3 7638
ba2685cc
AM		 7639/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7640 might not have the luxury of section headers. Look for the DT_NULL
7641 terminator to determine the number of entries. */
7642 for (ext = edyn, dynamic_nent = 0;
7643 (char *) ext < (char *) edyn + dynamic_size;
7644 ext++)
7645 {
7646 dynamic_nent++;
7647 if (BYTE_GET (ext->d_tag) == DT_NULL)
7648 break;
7649 }
252b5132 7650
3f5e193b
NC		 7651 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7652 sizeof (* entry));
b2d38a17 7653 if (dynamic_section == NULL)
252b5132 7654 {
9ea033b2
NC		 7655 error (_("Out of memory\n"));
7656 free (edyn);
7657 return 0;
7658 }
252b5132 7659
fb514b26 7660 for (ext = edyn, entry = dynamic_section;
ba2685cc 7661 entry < dynamic_section + dynamic_nent;
fb514b26 7662 ext++, entry++)
9ea033b2 7663 {
fb514b26
AM		 7664 entry->d_tag = BYTE_GET (ext->d_tag);
7665 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7666 }
7667
9ea033b2
NC		 7668 free (edyn);
7669
7670 return 1;
7671}
7672
7673static int
2cf0635d 7674get_64bit_dynamic_section (FILE * file)
9ea033b2 7675{
2cf0635d
NC		 7676 Elf64_External_Dyn * edyn;
7677 Elf64_External_Dyn * ext;
7678 Elf_Internal_Dyn * entry;
103f02d3 7679
3f5e193b
NC		 7680 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7681 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7682 if (!edyn)
7683 return 0;
103f02d3 7684
ba2685cc
AM		 7685/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7686 might not have the luxury of section headers. Look for the DT_NULL
7687 terminator to determine the number of entries. */
7688 for (ext = edyn, dynamic_nent = 0;
7689 (char *) ext < (char *) edyn + dynamic_size;
7690 ext++)
7691 {
7692 dynamic_nent++;
66543521 7693 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7694 break;
7695 }
252b5132 7696
3f5e193b
NC		 7697 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7698 sizeof (* entry));
b2d38a17 7699 if (dynamic_section == NULL)
252b5132
RH		 7700 {
7701 error (_("Out of memory\n"));
7702 free (edyn);
7703 return 0;
7704 }
7705
fb514b26 7706 for (ext = edyn, entry = dynamic_section;
ba2685cc 7707 entry < dynamic_section + dynamic_nent;
fb514b26 7708 ext++, entry++)
252b5132 7709 {
66543521
AM		 7710 entry->d_tag = BYTE_GET (ext->d_tag);
7711 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7712 }
7713
7714 free (edyn);
7715
9ea033b2
NC		 7716 return 1;
7717}
7718
e9e44622
JJ		 7719static void
7720print_dynamic_flags (bfd_vma flags)
d1133906 7721{
e9e44622 7722 int first = 1;
13ae64f3 7723
d1133906
NC		 7724 while (flags)
7725 {
7726 bfd_vma flag;
7727
7728 flag = flags & - flags;
7729 flags &= ~ flag;
7730
e9e44622
JJ		 7731 if (first)
7732 first = 0;
7733 else
7734 putc (' ', stdout);
13ae64f3 7735
d1133906
NC		 7736 switch (flag)
7737 {
e9e44622
JJ		 7738 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7739 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7740 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7741 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7742 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7743 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7744 }
7745 }
e9e44622 7746 puts ("");
d1133906
NC		 7747}
7748
b2d38a17
NC		 7749/* Parse and display the contents of the dynamic section. */
7750
9ea033b2 7751static int
2cf0635d 7752process_dynamic_section (FILE * file)
9ea033b2 7753{
2cf0635d 7754 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7755
7756 if (dynamic_size == 0)
7757 {
7758 if (do_dynamic)
b2d38a17 7759 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7760
7761 return 1;
7762 }
7763
7764 if (is_32bit_elf)
7765 {
b2d38a17 7766 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7767 return 0;
7768 }
b2d38a17 7769 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7770 return 0;
7771
252b5132
RH		 7772 /* Find the appropriate symbol table. */
7773 if (dynamic_symbols == NULL)
7774 {
86dba8ee
AM		 7775 for (entry = dynamic_section;
7776 entry < dynamic_section + dynamic_nent;
7777 ++entry)
252b5132 7778 {
c8286bd1 7779 Elf_Internal_Shdr section;
252b5132
RH		 7780
7781 if (entry->d_tag != DT_SYMTAB)
7782 continue;
7783
7784 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7785
7786 /* Since we do not know how big the symbol table is,
7787 we default to reading in the entire file (!) and
7788 processing that. This is overkill, I know, but it
e3c8793a 7789 should work. */
d93f0186 7790 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7791
fb52b2f4
NC		 7792 if (archive_file_offset != 0)
7793 section.sh_size = archive_file_size - section.sh_offset;
7794 else
7795 {
7796 if (fseek (file, 0, SEEK_END))
591a748a 7797 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7798
7799 section.sh_size = ftell (file) - section.sh_offset;
7800 }
252b5132 7801
9ea033b2 7802 if (is_32bit_elf)
9ad5cbcf 7803 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7804 else
9ad5cbcf 7805 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7806
ba5cdace 7807 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7808 if (num_dynamic_syms < 1)
252b5132
RH		 7809 {
7810 error (_("Unable to determine the number of symbols to load\n"));
7811 continue;
7812 }
252b5132
RH		 7813 }
7814 }
7815
7816 /* Similarly find a string table. */
7817 if (dynamic_strings == NULL)
7818 {
86dba8ee
AM		 7819 for (entry = dynamic_section;
7820 entry < dynamic_section + dynamic_nent;
7821 ++entry)
252b5132
RH		 7822 {
7823 unsigned long offset;
b34976b6 7824 long str_tab_len;
252b5132
RH		 7825
7826 if (entry->d_tag != DT_STRTAB)
7827 continue;
7828
7829 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7830
7831 /* Since we do not know how big the string table is,
7832 we default to reading in the entire file (!) and
7833 processing that. This is overkill, I know, but it
e3c8793a 7834 should work. */
252b5132 7835
d93f0186 7836 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7837
7838 if (archive_file_offset != 0)
7839 str_tab_len = archive_file_size - offset;
7840 else
7841 {
7842 if (fseek (file, 0, SEEK_END))
7843 error (_("Unable to seek to end of file\n"));
7844 str_tab_len = ftell (file) - offset;
7845 }
252b5132
RH		 7846
7847 if (str_tab_len < 1)
7848 {
7849 error
7850 (_("Unable to determine the length of the dynamic string table\n"));
7851 continue;
7852 }
7853
3f5e193b
NC		 7854 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7855 str_tab_len,
7856 _("dynamic string table"));
59245841 7857 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7858 break;
7859 }
7860 }
7861
7862 /* And find the syminfo section if available. */
7863 if (dynamic_syminfo == NULL)
7864 {
3e8bba36 7865 unsigned long syminsz = 0;
252b5132 7866
86dba8ee
AM		 7867 for (entry = dynamic_section;
7868 entry < dynamic_section + dynamic_nent;
7869 ++entry)
252b5132
RH		 7870 {
7871 if (entry->d_tag == DT_SYMINENT)
7872 {
7873 /* Note: these braces are necessary to avoid a syntax
7874 error from the SunOS4 C compiler. */
7875 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7876 }
7877 else if (entry->d_tag == DT_SYMINSZ)
7878 syminsz = entry->d_un.d_val;
7879 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7880 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7881 syminsz);
252b5132
RH		 7882 }
7883
7884 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7885 {
2cf0635d
NC		 7886 Elf_External_Syminfo * extsyminfo;
7887 Elf_External_Syminfo * extsym;
7888 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7889
7890 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7891 extsyminfo = (Elf_External_Syminfo *)
7892 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7893 _("symbol information"));
a6e9f9df
AM		 7894 if (!extsyminfo)
7895 return 0;
252b5132 7896
3f5e193b 7897 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7898 if (dynamic_syminfo == NULL)
7899 {
7900 error (_("Out of memory\n"));
7901 return 0;
7902 }
7903
7904 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7905 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7906 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7907 ++syminfo, ++extsym)
252b5132 7908 {
86dba8ee
AM		 7909 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7910 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7911 }
7912
7913 free (extsyminfo);
7914 }
7915 }
7916
7917 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7918 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7919 dynamic_addr, dynamic_nent);
252b5132
RH		 7920 if (do_dynamic)
7921 printf (_(" Tag Type Name/Value\n"));
7922
86dba8ee
AM		 7923 for (entry = dynamic_section;
7924 entry < dynamic_section + dynamic_nent;
7925 entry++)
252b5132
RH		 7926 {
7927 if (do_dynamic)
f7a99963 7928 {
2cf0635d 7929 const char * dtype;
e699b9ff 7930
f7a99963
NC		 7931 putchar (' ');
7932 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7933 dtype = get_dynamic_type (entry->d_tag);
7934 printf (" (%s)%*s", dtype,
7935 ((is_32bit_elf ? 27 : 19)
7936 - (int) strlen (dtype)),
f7a99963
NC		 7937 " ");
7938 }
252b5132
RH		 7939
7940 switch (entry->d_tag)
7941 {
d1133906
NC		 7942 case DT_FLAGS:
7943 if (do_dynamic)
e9e44622 7944 print_dynamic_flags (entry->d_un.d_val);
d1133906 7945 break;
76da6bbe 7946
252b5132
RH		 7947 case DT_AUXILIARY:
7948 case DT_FILTER:
019148e4
L		 7949 case DT_CONFIG:
7950 case DT_DEPAUDIT:
7951 case DT_AUDIT:
252b5132
RH		 7952 if (do_dynamic)
7953 {
019148e4 7954 switch (entry->d_tag)
b34976b6 7955 {
019148e4
L		 7956 case DT_AUXILIARY:
7957 printf (_("Auxiliary library"));
7958 break;
7959
7960 case DT_FILTER:
7961 printf (_("Filter library"));
7962 break;
7963
b34976b6 7964 case DT_CONFIG:
019148e4
L		 7965 printf (_("Configuration file"));
7966 break;
7967
7968 case DT_DEPAUDIT:
7969 printf (_("Dependency audit library"));
7970 break;
7971
7972 case DT_AUDIT:
7973 printf (_("Audit library"));
7974 break;
7975 }
252b5132 7976
d79b3d50
NC		 7977 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7978 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7979 else
f7a99963
NC		 7980 {
7981 printf (": ");
7982 print_vma (entry->d_un.d_val, PREFIX_HEX);
7983 putchar ('\n');
7984 }
252b5132
RH		 7985 }
7986 break;
7987
dcefbbbd 7988 case DT_FEATURE:
252b5132
RH		 7989 if (do_dynamic)
7990 {
7991 printf (_("Flags:"));
86f55779 7992
252b5132
RH		 7993 if (entry->d_un.d_val == 0)
7994 printf (_(" None\n"));
7995 else
7996 {
7997 unsigned long int val = entry->d_un.d_val;
86f55779 7998
252b5132
RH		 7999 if (val & DTF_1_PARINIT)
8000 {
8001 printf (" PARINIT");
8002 val ^= DTF_1_PARINIT;
8003 }
dcefbbbd
L		 8004 if (val & DTF_1_CONFEXP)
8005 {
8006 printf (" CONFEXP");
8007 val ^= DTF_1_CONFEXP;
8008 }
252b5132
RH		 8009 if (val != 0)
8010 printf (" %lx", val);
8011 puts ("");
8012 }
8013 }
8014 break;
8015
8016 case DT_POSFLAG_1:
8017 if (do_dynamic)
8018 {
8019 printf (_("Flags:"));
86f55779 8020
252b5132
RH		 8021 if (entry->d_un.d_val == 0)
8022 printf (_(" None\n"));
8023 else
8024 {
8025 unsigned long int val = entry->d_un.d_val;
86f55779 8026
252b5132
RH		 8027 if (val & DF_P1_LAZYLOAD)
8028 {
8029 printf (" LAZYLOAD");
8030 val ^= DF_P1_LAZYLOAD;
8031 }
8032 if (val & DF_P1_GROUPPERM)
8033 {
8034 printf (" GROUPPERM");
8035 val ^= DF_P1_GROUPPERM;
8036 }
8037 if (val != 0)
8038 printf (" %lx", val);
8039 puts ("");
8040 }
8041 }
8042 break;
8043
8044 case DT_FLAGS_1:
8045 if (do_dynamic)
8046 {
8047 printf (_("Flags:"));
8048 if (entry->d_un.d_val == 0)
8049 printf (_(" None\n"));
8050 else
8051 {
8052 unsigned long int val = entry->d_un.d_val;
86f55779 8053
252b5132
RH		 8054 if (val & DF_1_NOW)
8055 {
8056 printf (" NOW");
8057 val ^= DF_1_NOW;
8058 }
8059 if (val & DF_1_GLOBAL)
8060 {
8061 printf (" GLOBAL");
8062 val ^= DF_1_GLOBAL;
8063 }
8064 if (val & DF_1_GROUP)
8065 {
8066 printf (" GROUP");
8067 val ^= DF_1_GROUP;
8068 }
8069 if (val & DF_1_NODELETE)
8070 {
8071 printf (" NODELETE");
8072 val ^= DF_1_NODELETE;
8073 }
8074 if (val & DF_1_LOADFLTR)
8075 {
8076 printf (" LOADFLTR");
8077 val ^= DF_1_LOADFLTR;
8078 }
8079 if (val & DF_1_INITFIRST)
8080 {
8081 printf (" INITFIRST");
8082 val ^= DF_1_INITFIRST;
8083 }
8084 if (val & DF_1_NOOPEN)
8085 {
8086 printf (" NOOPEN");
8087 val ^= DF_1_NOOPEN;
8088 }
8089 if (val & DF_1_ORIGIN)
8090 {
8091 printf (" ORIGIN");
8092 val ^= DF_1_ORIGIN;
8093 }
8094 if (val & DF_1_DIRECT)
8095 {
8096 printf (" DIRECT");
8097 val ^= DF_1_DIRECT;
8098 }
8099 if (val & DF_1_TRANS)
8100 {
8101 printf (" TRANS");
8102 val ^= DF_1_TRANS;
8103 }
8104 if (val & DF_1_INTERPOSE)
8105 {
8106 printf (" INTERPOSE");
8107 val ^= DF_1_INTERPOSE;
8108 }
f7db6139 8109 if (val & DF_1_NODEFLIB)
dcefbbbd 8110 {
f7db6139
L		 8111 printf (" NODEFLIB");
8112 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8113 }
8114 if (val & DF_1_NODUMP)
8115 {
8116 printf (" NODUMP");
8117 val ^= DF_1_NODUMP;
8118 }
34b60028 8119 if (val & DF_1_CONFALT)
dcefbbbd 8120 {
34b60028
L		 8121 printf (" CONFALT");
8122 val ^= DF_1_CONFALT;
8123 }
8124 if (val & DF_1_ENDFILTEE)
8125 {
8126 printf (" ENDFILTEE");
8127 val ^= DF_1_ENDFILTEE;
8128 }
8129 if (val & DF_1_DISPRELDNE)
8130 {
8131 printf (" DISPRELDNE");
8132 val ^= DF_1_DISPRELDNE;
8133 }
8134 if (val & DF_1_DISPRELPND)
8135 {
8136 printf (" DISPRELPND");
8137 val ^= DF_1_DISPRELPND;
8138 }
8139 if (val & DF_1_NODIRECT)
8140 {
8141 printf (" NODIRECT");
8142 val ^= DF_1_NODIRECT;
8143 }
8144 if (val & DF_1_IGNMULDEF)
8145 {
8146 printf (" IGNMULDEF");
8147 val ^= DF_1_IGNMULDEF;
8148 }
8149 if (val & DF_1_NOKSYMS)
8150 {
8151 printf (" NOKSYMS");
8152 val ^= DF_1_NOKSYMS;
8153 }
8154 if (val & DF_1_NOHDR)
8155 {
8156 printf (" NOHDR");
8157 val ^= DF_1_NOHDR;
8158 }
8159 if (val & DF_1_EDITED)
8160 {
8161 printf (" EDITED");
8162 val ^= DF_1_EDITED;
8163 }
8164 if (val & DF_1_NORELOC)
8165 {
8166 printf (" NORELOC");
8167 val ^= DF_1_NORELOC;
8168 }
8169 if (val & DF_1_SYMINTPOSE)
8170 {
8171 printf (" SYMINTPOSE");
8172 val ^= DF_1_SYMINTPOSE;
8173 }
8174 if (val & DF_1_GLOBAUDIT)
8175 {
8176 printf (" GLOBAUDIT");
8177 val ^= DF_1_GLOBAUDIT;
8178 }
8179 if (val & DF_1_SINGLETON)
8180 {
8181 printf (" SINGLETON");
8182 val ^= DF_1_SINGLETON;
dcefbbbd 8183 }
252b5132
RH		 8184 if (val != 0)
8185 printf (" %lx", val);
8186 puts ("");
8187 }
8188 }
8189 break;
8190
8191 case DT_PLTREL:
566b0d53 8192 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8193 if (do_dynamic)
8194 puts (get_dynamic_type (entry->d_un.d_val));
8195 break;
8196
8197 case DT_NULL :
8198 case DT_NEEDED :
8199 case DT_PLTGOT :
8200 case DT_HASH :
8201 case DT_STRTAB :
8202 case DT_SYMTAB :
8203 case DT_RELA :
8204 case DT_INIT :
8205 case DT_FINI :
8206 case DT_SONAME :
8207 case DT_RPATH :
8208 case DT_SYMBOLIC:
8209 case DT_REL :
8210 case DT_DEBUG :
8211 case DT_TEXTREL :
8212 case DT_JMPREL :
019148e4 8213 case DT_RUNPATH :
252b5132
RH		 8214 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8215
8216 if (do_dynamic)
8217 {
2cf0635d 8218 char * name;
252b5132 8219
d79b3d50
NC		 8220 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8221 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8222 else
d79b3d50 8223 name = NULL;
252b5132
RH		 8224
8225 if (name)
8226 {
8227 switch (entry->d_tag)
8228 {
8229 case DT_NEEDED:
8230 printf (_("Shared library: [%s]"), name);
8231
18bd398b 8232 if (streq (name, program_interpreter))
f7a99963 8233 printf (_(" program interpreter"));
252b5132
RH		 8234 break;
8235
8236 case DT_SONAME:
f7a99963 8237 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8238 break;
8239
8240 case DT_RPATH:
f7a99963 8241 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8242 break;
8243
019148e4
L		 8244 case DT_RUNPATH:
8245 printf (_("Library runpath: [%s]"), name);
8246 break;
8247
252b5132 8248 default:
f7a99963
NC		 8249 print_vma (entry->d_un.d_val, PREFIX_HEX);
8250 break;
252b5132
RH		 8251 }
8252 }
8253 else
f7a99963
NC		 8254 print_vma (entry->d_un.d_val, PREFIX_HEX);
8255
8256 putchar ('\n');
252b5132
RH		 8257 }
8258 break;
8259
8260 case DT_PLTRELSZ:
8261 case DT_RELASZ :
8262 case DT_STRSZ :
8263 case DT_RELSZ :
8264 case DT_RELAENT :
8265 case DT_SYMENT :
8266 case DT_RELENT :
566b0d53 8267 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8268 case DT_PLTPADSZ:
8269 case DT_MOVEENT :
8270 case DT_MOVESZ :
8271 case DT_INIT_ARRAYSZ:
8272 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8273 case DT_GNU_CONFLICTSZ:
8274 case DT_GNU_LIBLISTSZ:
252b5132 8275 if (do_dynamic)
f7a99963
NC		 8276 {
8277 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8278 printf (_(" (bytes)\n"));
f7a99963 8279 }
252b5132
RH		 8280 break;
8281
8282 case DT_VERDEFNUM:
8283 case DT_VERNEEDNUM:
8284 case DT_RELACOUNT:
8285 case DT_RELCOUNT:
8286 if (do_dynamic)
f7a99963
NC		 8287 {
8288 print_vma (entry->d_un.d_val, UNSIGNED);
8289 putchar ('\n');
8290 }
252b5132
RH		 8291 break;
8292
8293 case DT_SYMINSZ:
8294 case DT_SYMINENT:
8295 case DT_SYMINFO:
8296 case DT_USED:
8297 case DT_INIT_ARRAY:
8298 case DT_FINI_ARRAY:
8299 if (do_dynamic)
8300 {
d79b3d50
NC		 8301 if (entry->d_tag == DT_USED
8302 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8303 {
2cf0635d 8304 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8305
b34976b6 8306 if (*name)
252b5132
RH		 8307 {
8308 printf (_("Not needed object: [%s]\n"), name);
8309 break;
8310 }
8311 }
103f02d3 8312
f7a99963
NC		 8313 print_vma (entry->d_un.d_val, PREFIX_HEX);
8314 putchar ('\n');
252b5132
RH		 8315 }
8316 break;
8317
8318 case DT_BIND_NOW:
8319 /* The value of this entry is ignored. */
35b1837e
AM		 8320 if (do_dynamic)
8321 putchar ('\n');
252b5132 8322 break;
103f02d3 8323
047b2264
JJ		 8324 case DT_GNU_PRELINKED:
8325 if (do_dynamic)
8326 {
2cf0635d 8327 struct tm * tmp;
91d6fa6a 8328 time_t atime = entry->d_un.d_val;
047b2264 8329
91d6fa6a 8330 tmp = gmtime (&atime);
047b2264
JJ		 8331 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8332 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8333 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8334
8335 }
8336 break;
8337
fdc90cb4
JJ		 8338 case DT_GNU_HASH:
8339 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8340 if (do_dynamic)
8341 {
8342 print_vma (entry->d_un.d_val, PREFIX_HEX);
8343 putchar ('\n');
8344 }
8345 break;
8346
252b5132
RH		 8347 default:
8348 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8349 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8350 entry->d_un.d_val;
8351
8352 if (do_dynamic)
8353 {
8354 switch (elf_header.e_machine)
8355 {
8356 case EM_MIPS:
4fe85591 8357 case EM_MIPS_RS3_LE:
b2d38a17 8358 dynamic_section_mips_val (entry);
252b5132 8359 break;
103f02d3 8360 case EM_PARISC:
b2d38a17 8361 dynamic_section_parisc_val (entry);
103f02d3 8362 break;
ecc51f48 8363 case EM_IA_64:
b2d38a17 8364 dynamic_section_ia64_val (entry);
ecc51f48 8365 break;
252b5132 8366 default:
f7a99963
NC		 8367 print_vma (entry->d_un.d_val, PREFIX_HEX);
8368 putchar ('\n');
252b5132
RH		 8369 }
8370 }
8371 break;
8372 }
8373 }
8374
8375 return 1;
8376}
8377
8378static char *
d3ba0551 8379get_ver_flags (unsigned int flags)
252b5132 8380{
b34976b6 8381 static char buff[32];
252b5132
RH		 8382
8383 buff[0] = 0;
8384
8385 if (flags == 0)
8386 return _("none");
8387
8388 if (flags & VER_FLG_BASE)
8389 strcat (buff, "BASE ");
8390
8391 if (flags & VER_FLG_WEAK)
8392 {
8393 if (flags & VER_FLG_BASE)
8394 strcat (buff, "| ");
8395
8396 strcat (buff, "WEAK ");
8397 }
8398
44ec90b9
RO		 8399 if (flags & VER_FLG_INFO)
8400 {
8401 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8402 strcat (buff, "| ");
8403
8404 strcat (buff, "INFO ");
8405 }
8406
8407 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8408 strcat (buff, _("| <unknown>"));
252b5132
RH		 8409
8410 return buff;
8411}
8412
8413/* Display the contents of the version sections. */
98fb390a 8414
252b5132 8415static int
2cf0635d 8416process_version_sections (FILE * file)
252b5132 8417{
2cf0635d 8418 Elf_Internal_Shdr * section;
b34976b6
AM		 8419 unsigned i;
8420 int found = 0;
252b5132
RH		 8421
8422 if (! do_version)
8423 return 1;
8424
8425 for (i = 0, section = section_headers;
8426 i < elf_header.e_shnum;
b34976b6 8427 i++, section++)
252b5132
RH		 8428 {
8429 switch (section->sh_type)
8430 {
8431 case SHT_GNU_verdef:
8432 {
2cf0635d 8433 Elf_External_Verdef * edefs;
b34976b6
AM		 8434 unsigned int idx;
8435 unsigned int cnt;
2cf0635d 8436 char * endbuf;
252b5132
RH		 8437
8438 found = 1;
8439
8440 printf
72de5009 8441 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8442 SECTION_NAME (section), section->sh_info);
8443
8444 printf (_(" Addr: 0x"));
8445 printf_vma (section->sh_addr);
72de5009 8446 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8447 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8448 section->sh_link < elf_header.e_shnum
8449 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8450 : _("<corrupt>"));
252b5132 8451
3f5e193b
NC		 8452 edefs = (Elf_External_Verdef *)
8453 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8454 _("version definition section"));
a6e9f9df
AM		 8455 if (!edefs)
8456 break;
59245841 8457 endbuf = (char *) edefs + section->sh_size;
252b5132 8458
b34976b6 8459 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8460 {
2cf0635d
NC		 8461 char * vstart;
8462 Elf_External_Verdef * edef;
b34976b6 8463 Elf_Internal_Verdef ent;
2cf0635d 8464 Elf_External_Verdaux * eaux;
b34976b6
AM		 8465 Elf_Internal_Verdaux aux;
8466 int j;
8467 int isum;
103f02d3 8468
dd24e3da
NC		 8469 /* Check for negative or very large indicies. */
8470 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8471 break;
8472
252b5132 8473 vstart = ((char *) edefs) + idx;
54806181
AM		 8474 if (vstart + sizeof (*edef) > endbuf)
8475 break;
252b5132
RH		 8476
8477 edef = (Elf_External_Verdef *) vstart;
8478
8479 ent.vd_version = BYTE_GET (edef->vd_version);
8480 ent.vd_flags = BYTE_GET (edef->vd_flags);
8481 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8482 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8483 ent.vd_hash = BYTE_GET (edef->vd_hash);
8484 ent.vd_aux = BYTE_GET (edef->vd_aux);
8485 ent.vd_next = BYTE_GET (edef->vd_next);
8486
8487 printf (_(" %#06x: Rev: %d Flags: %s"),
8488 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8489
8490 printf (_(" Index: %d Cnt: %d "),
8491 ent.vd_ndx, ent.vd_cnt);
8492
dd24e3da
NC		 8493 /* Check for overflow. */
8494 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8495 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8496 break;
8497
252b5132
RH		 8498 vstart += ent.vd_aux;
8499
8500 eaux = (Elf_External_Verdaux *) vstart;
8501
8502 aux.vda_name = BYTE_GET (eaux->vda_name);
8503 aux.vda_next = BYTE_GET (eaux->vda_next);
8504
d79b3d50
NC		 8505 if (VALID_DYNAMIC_NAME (aux.vda_name))
8506 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8507 else
8508 printf (_("Name index: %ld\n"), aux.vda_name);
8509
8510 isum = idx + ent.vd_aux;
8511
b34976b6 8512 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8513 {
dd24e3da
NC		 8514 /* Check for overflow. */
8515 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8516 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8517 break;
8518
252b5132
RH		 8519 isum += aux.vda_next;
8520 vstart += aux.vda_next;
8521
8522 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8523 if (vstart + sizeof (*eaux) > endbuf)
8524 break;
252b5132
RH		 8525
8526 aux.vda_name = BYTE_GET (eaux->vda_name);
8527 aux.vda_next = BYTE_GET (eaux->vda_next);
8528
d79b3d50 8529 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8530 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8531 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8532 else
8533 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8534 isum, j, aux.vda_name);
8535 }
dd24e3da 8536
54806181
AM		 8537 if (j < ent.vd_cnt)
8538 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8539
8540 idx += ent.vd_next;
8541 }
dd24e3da 8542
54806181
AM		 8543 if (cnt < section->sh_info)
8544 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8545
8546 free (edefs);
8547 }
8548 break;
103f02d3 8549
252b5132
RH		 8550 case SHT_GNU_verneed:
8551 {
2cf0635d 8552 Elf_External_Verneed * eneed;
b34976b6
AM		 8553 unsigned int idx;
8554 unsigned int cnt;
2cf0635d 8555 char * endbuf;
252b5132
RH		 8556
8557 found = 1;
8558
72de5009 8559 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8560 SECTION_NAME (section), section->sh_info);
8561
8562 printf (_(" Addr: 0x"));
8563 printf_vma (section->sh_addr);
72de5009 8564 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8565 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8566 section->sh_link < elf_header.e_shnum
8567 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8568 : _("<corrupt>"));
252b5132 8569
3f5e193b
NC		 8570 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8571 section->sh_offset, 1,
8572 section->sh_size,
9cf03b7e 8573 _("Version Needs section"));
a6e9f9df
AM		 8574 if (!eneed)
8575 break;
59245841 8576 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8577
8578 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8579 {
2cf0635d 8580 Elf_External_Verneed * entry;
b34976b6
AM		 8581 Elf_Internal_Verneed ent;
8582 int j;
8583 int isum;
2cf0635d 8584 char * vstart;
252b5132 8585
dd24e3da
NC		 8586 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8587 break;
8588
252b5132 8589 vstart = ((char *) eneed) + idx;
54806181
AM		 8590 if (vstart + sizeof (*entry) > endbuf)
8591 break;
252b5132
RH		 8592
8593 entry = (Elf_External_Verneed *) vstart;
8594
8595 ent.vn_version = BYTE_GET (entry->vn_version);
8596 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8597 ent.vn_file = BYTE_GET (entry->vn_file);
8598 ent.vn_aux = BYTE_GET (entry->vn_aux);
8599 ent.vn_next = BYTE_GET (entry->vn_next);
8600
8601 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8602
d79b3d50
NC		 8603 if (VALID_DYNAMIC_NAME (ent.vn_file))
8604 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8605 else
8606 printf (_(" File: %lx"), ent.vn_file);
8607
8608 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8609
dd24e3da
NC		 8610 /* Check for overflow. */
8611 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8612 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8613 break;
8614
252b5132
RH		 8615 vstart += ent.vn_aux;
8616
8617 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8618 {
2cf0635d 8619 Elf_External_Vernaux * eaux;
b34976b6 8620 Elf_Internal_Vernaux aux;
252b5132 8621
54806181
AM		 8622 if (vstart + sizeof (*eaux) > endbuf)
8623 break;
252b5132
RH		 8624 eaux = (Elf_External_Vernaux *) vstart;
8625
8626 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8627 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8628 aux.vna_other = BYTE_GET (eaux->vna_other);
8629 aux.vna_name = BYTE_GET (eaux->vna_name);
8630 aux.vna_next = BYTE_GET (eaux->vna_next);
8631
d79b3d50 8632 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8633 printf (_(" %#06x: Name: %s"),
d79b3d50 8634 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8635 else
ecc2063b 8636 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8637 isum, aux.vna_name);
8638
8639 printf (_(" Flags: %s Version: %d\n"),
8640 get_ver_flags (aux.vna_flags), aux.vna_other);
8641
dd24e3da
NC		 8642 /* Check for overflow. */
8643 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8644 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8645 break;
8646
252b5132
RH		 8647 isum += aux.vna_next;
8648 vstart += aux.vna_next;
8649 }
9cf03b7e 8650
54806181 8651 if (j < ent.vn_cnt)
9cf03b7e 8652 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8653
8654 idx += ent.vn_next;
8655 }
9cf03b7e 8656
54806181 8657 if (cnt < section->sh_info)
9cf03b7e 8658 warn (_("Missing Version Needs information\n"));
103f02d3 8659
252b5132
RH		 8660 free (eneed);
8661 }
8662 break;
8663
8664 case SHT_GNU_versym:
8665 {
2cf0635d 8666 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8667 int total;
8668 int cnt;
2cf0635d
NC		 8669 unsigned char * edata;
8670 unsigned short * data;
8671 char * strtab;
8672 Elf_Internal_Sym * symbols;
8673 Elf_Internal_Shdr * string_sec;
ba5cdace 8674 unsigned long num_syms;
d3ba0551 8675 long off;
252b5132 8676
4fbb74a6 8677 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8678 break;
8679
4fbb74a6 8680 link_section = section_headers + section->sh_link;
08d8fa11 8681 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8682
4fbb74a6 8683 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8684 break;
8685
252b5132
RH		 8686 found = 1;
8687
ba5cdace 8688 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 8689 if (symbols == NULL)
8690 break;
252b5132 8691
4fbb74a6 8692 string_sec = section_headers + link_section->sh_link;
252b5132 8693
3f5e193b
NC		 8694 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8695 string_sec->sh_size,
8696 _("version string table"));
a6e9f9df 8697 if (!strtab)
0429c154
MS		 8698 {
8699 free (symbols);
8700 break;
8701 }
252b5132
RH		 8702
8703 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8704 SECTION_NAME (section), total);
8705
8706 printf (_(" Addr: "));
8707 printf_vma (section->sh_addr);
72de5009 8708 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8709 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8710 SECTION_NAME (link_section));
8711
d3ba0551
AM		 8712 off = offset_from_vma (file,
8713 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8714 total * sizeof (short));
3f5e193b
NC		 8715 edata = (unsigned char *) get_data (NULL, file, off, total,
8716 sizeof (short),
8717 _("version symbol data"));
a6e9f9df
AM		 8718 if (!edata)
8719 {
8720 free (strtab);
0429c154 8721 free (symbols);
a6e9f9df
AM		 8722 break;
8723 }
252b5132 8724
3f5e193b 8725 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8726
8727 for (cnt = total; cnt --;)
b34976b6
AM		 8728 data[cnt] = byte_get (edata + cnt * sizeof (short),
8729 sizeof (short));
252b5132
RH		 8730
8731 free (edata);
8732
8733 for (cnt = 0; cnt < total; cnt += 4)
8734 {
8735 int j, nn;
00d93f34 8736 int check_def, check_need;
2cf0635d 8737 char * name;
252b5132
RH		 8738
8739 printf (" %03x:", cnt);
8740
8741 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8742 switch (data[cnt + j])
252b5132
RH		 8743 {
8744 case 0:
8745 fputs (_(" 0 (*local*) "), stdout);
8746 break;
8747
8748 case 1:
8749 fputs (_(" 1 (*global*) "), stdout);
8750 break;
8751
8752 default:
c244d050
NC		 8753 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8754 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8755
dd24e3da 8756 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 8757 array, break to avoid an out-of-bounds read. */
8758 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 8759 {
8760 warn (_("invalid index into symbol array\n"));
8761 break;
8762 }
8763
00d93f34
JJ		 8764 check_def = 1;
8765 check_need = 1;
4fbb74a6
AM		 8766 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8767 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8768 != SHT_NOBITS)
252b5132 8769 {
b34976b6 8770 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8771 check_def = 0;
8772 else
8773 check_need = 0;
252b5132 8774 }
00d93f34
JJ		 8775
8776 if (check_need
b34976b6 8777 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8778 {
b34976b6
AM		 8779 Elf_Internal_Verneed ivn;
8780 unsigned long offset;
252b5132 8781
d93f0186
NC		 8782 offset = offset_from_vma
8783 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8784 sizeof (Elf_External_Verneed));
252b5132 8785
b34976b6 8786 do
252b5132 8787 {
b34976b6
AM		 8788 Elf_Internal_Vernaux ivna;
8789 Elf_External_Verneed evn;
8790 Elf_External_Vernaux evna;
8791 unsigned long a_off;
252b5132 8792
59245841
NC		 8793 if (get_data (&evn, file, offset, sizeof (evn), 1,
8794 _("version need")) == NULL)
8795 break;
8796
252b5132
RH		 8797 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8798 ivn.vn_next = BYTE_GET (evn.vn_next);
8799
8800 a_off = offset + ivn.vn_aux;
8801
8802 do
8803 {
59245841
NC		 8804 if (get_data (&evna, file, a_off, sizeof (evna),
8805 1, _("version need aux (2)")) == NULL)
8806 {
8807 ivna.vna_next = 0;
8808 ivna.vna_other = 0;
8809 }
8810 else
8811 {
8812 ivna.vna_next = BYTE_GET (evna.vna_next);
8813 ivna.vna_other = BYTE_GET (evna.vna_other);
8814 }
252b5132
RH		 8815
8816 a_off += ivna.vna_next;
8817 }
b34976b6 8818 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8819 && ivna.vna_next != 0);
8820
b34976b6 8821 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8822 {
8823 ivna.vna_name = BYTE_GET (evna.vna_name);
8824
54806181
AM		 8825 if (ivna.vna_name >= string_sec->sh_size)
8826 name = _("*invalid*");
8827 else
8828 name = strtab + ivna.vna_name;
252b5132 8829 nn += printf ("(%s%-*s",
16062207
ILT		 8830 name,
8831 12 - (int) strlen (name),
252b5132 8832 ")");
00d93f34 8833 check_def = 0;
252b5132
RH		 8834 break;
8835 }
8836
8837 offset += ivn.vn_next;
8838 }
8839 while (ivn.vn_next);
8840 }
00d93f34 8841
b34976b6
AM		 8842 if (check_def && data[cnt + j] != 0x8001
8843 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8844 {
b34976b6
AM		 8845 Elf_Internal_Verdef ivd;
8846 Elf_External_Verdef evd;
8847 unsigned long offset;
252b5132 8848
d93f0186
NC		 8849 offset = offset_from_vma
8850 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8851 sizeof evd);
252b5132
RH		 8852
8853 do
8854 {
59245841
NC		 8855 if (get_data (&evd, file, offset, sizeof (evd), 1,
8856 _("version def")) == NULL)
8857 {
8858 ivd.vd_next = 0;
8859 ivd.vd_ndx = 0;
8860 }
8861 else
8862 {
8863 ivd.vd_next = BYTE_GET (evd.vd_next);
8864 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8865 }
252b5132
RH		 8866
8867 offset += ivd.vd_next;
8868 }
c244d050 8869 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8870 && ivd.vd_next != 0);
8871
c244d050 8872 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8873 {
b34976b6
AM		 8874 Elf_External_Verdaux evda;
8875 Elf_Internal_Verdaux ivda;
252b5132
RH		 8876
8877 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8878
59245841
NC		 8879 if (get_data (&evda, file,
8880 offset - ivd.vd_next + ivd.vd_aux,
8881 sizeof (evda), 1,
8882 _("version def aux")) == NULL)
8883 break;
252b5132
RH		 8884
8885 ivda.vda_name = BYTE_GET (evda.vda_name);
8886
54806181
AM		 8887 if (ivda.vda_name >= string_sec->sh_size)
8888 name = _("*invalid*");
8889 else
8890 name = strtab + ivda.vda_name;
252b5132 8891 nn += printf ("(%s%-*s",
16062207
ILT		 8892 name,
8893 12 - (int) strlen (name),
252b5132
RH		 8894 ")");
8895 }
8896 }
8897
8898 if (nn < 18)
8899 printf ("%*c", 18 - nn, ' ');
8900 }
8901
8902 putchar ('\n');
8903 }
8904
8905 free (data);
8906 free (strtab);
8907 free (symbols);
8908 }
8909 break;
103f02d3 8910
252b5132
RH		 8911 default:
8912 break;
8913 }
8914 }
8915
8916 if (! found)
8917 printf (_("\nNo version information found in this file.\n"));
8918
8919 return 1;
8920}
8921
d1133906 8922static const char *
d3ba0551 8923get_symbol_binding (unsigned int binding)
252b5132 8924{
b34976b6 8925 static char buff[32];
252b5132
RH		 8926
8927 switch (binding)
8928 {
b34976b6
AM		 8929 case STB_LOCAL: return "LOCAL";
8930 case STB_GLOBAL: return "GLOBAL";
8931 case STB_WEAK: return "WEAK";
252b5132
RH		 8932 default:
8933 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8934 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8935 binding);
252b5132 8936 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8937 {
8938 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8939 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8940 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8941 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8942 return "UNIQUE";
8943 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8944 }
252b5132 8945 else
e9e44622 8946 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8947 return buff;
8948 }
8949}
8950
d1133906 8951static const char *
d3ba0551 8952get_symbol_type (unsigned int type)
252b5132 8953{
b34976b6 8954 static char buff[32];
252b5132
RH		 8955
8956 switch (type)
8957 {
b34976b6
AM		 8958 case STT_NOTYPE: return "NOTYPE";
8959 case STT_OBJECT: return "OBJECT";
8960 case STT_FUNC: return "FUNC";
8961 case STT_SECTION: return "SECTION";
8962 case STT_FILE: return "FILE";
8963 case STT_COMMON: return "COMMON";
8964 case STT_TLS: return "TLS";
15ab5209
DB		 8965 case STT_RELC: return "RELC";
8966 case STT_SRELC: return "SRELC";
252b5132
RH		 8967 default:
8968 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8969 {
8970 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8971 return "THUMB_FUNC";
8972
351b4b40 8973 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8974 return "REGISTER";
8975
8976 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8977 return "PARISC_MILLI";
8978
e9e44622 8979 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8980 }
252b5132 8981 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8982 {
8983 if (elf_header.e_machine == EM_PARISC)
8984 {
8985 if (type == STT_HP_OPAQUE)
8986 return "HP_OPAQUE";
8987 if (type == STT_HP_STUB)
8988 return "HP_STUB";
8989 }
8990
d8045f23 8991 if (type == STT_GNU_IFUNC
9c55345c 8992 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 8993 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 8994 /* GNU is still using the default value 0. */
d8045f23
NC		 8995 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8996 return "IFUNC";
8997
e9e44622 8998 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8999 }
252b5132 9000 else
e9e44622 9001 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9002 return buff;
9003 }
9004}
9005
d1133906 9006static const char *
d3ba0551 9007get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9008{
9009 switch (visibility)
9010 {
b34976b6
AM		 9011 case STV_DEFAULT: return "DEFAULT";
9012 case STV_INTERNAL: return "INTERNAL";
9013 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9014 case STV_PROTECTED: return "PROTECTED";
9015 default: abort ();
9016 }
9017}
9018
5e2b0d47
NC		 9019static const char *
9020get_mips_symbol_other (unsigned int other)
9021{
9022 switch (other)
9023 {
df58fc94
RS		 9024 case STO_OPTIONAL:
9025 return "OPTIONAL";
9026 case STO_MIPS_PLT:
9027 return "MIPS PLT";
9028 case STO_MIPS_PIC:
9029 return "MIPS PIC";
9030 case STO_MICROMIPS:
9031 return "MICROMIPS";
9032 case STO_MICROMIPS | STO_MIPS_PIC:
9033 return "MICROMIPS, MIPS PIC";
9034 case STO_MIPS16:
9035 return "MIPS16";
9036 default:
9037 return NULL;
5e2b0d47
NC		 9038 }
9039}
9040
28f997cf
TG		 9041static const char *
9042get_ia64_symbol_other (unsigned int other)
9043{
9044 if (is_ia64_vms ())
9045 {
9046 static char res[32];
9047
9048 res[0] = 0;
9049
9050 /* Function types is for images and .STB files only. */
9051 switch (elf_header.e_type)
9052 {
9053 case ET_DYN:
9054 case ET_EXEC:
9055 switch (VMS_ST_FUNC_TYPE (other))
9056 {
9057 case VMS_SFT_CODE_ADDR:
9058 strcat (res, " CA");
9059 break;
9060 case VMS_SFT_SYMV_IDX:
9061 strcat (res, " VEC");
9062 break;
9063 case VMS_SFT_FD:
9064 strcat (res, " FD");
9065 break;
9066 case VMS_SFT_RESERVE:
9067 strcat (res, " RSV");
9068 break;
9069 default:
9070 abort ();
9071 }
9072 break;
9073 default:
9074 break;
9075 }
9076 switch (VMS_ST_LINKAGE (other))
9077 {
9078 case VMS_STL_IGNORE:
9079 strcat (res, " IGN");
9080 break;
9081 case VMS_STL_RESERVE:
9082 strcat (res, " RSV");
9083 break;
9084 case VMS_STL_STD:
9085 strcat (res, " STD");
9086 break;
9087 case VMS_STL_LNK:
9088 strcat (res, " LNK");
9089 break;
9090 default:
9091 abort ();
9092 }
9093
9094 if (res[0] != 0)
9095 return res + 1;
9096 else
9097 return res;
9098 }
9099 return NULL;
9100}
9101
5e2b0d47
NC		 9102static const char *
9103get_symbol_other (unsigned int other)
9104{
9105 const char * result = NULL;
9106 static char buff [32];
9107
9108 if (other == 0)
9109 return "";
9110
9111 switch (elf_header.e_machine)
9112 {
9113 case EM_MIPS:
9114 result = get_mips_symbol_other (other);
28f997cf
TG		 9115 break;
9116 case EM_IA_64:
9117 result = get_ia64_symbol_other (other);
9118 break;
5e2b0d47
NC		 9119 default:
9120 break;
9121 }
9122
9123 if (result)
9124 return result;
9125
9126 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9127 return buff;
9128}
9129
d1133906 9130static const char *
d3ba0551 9131get_symbol_index_type (unsigned int type)
252b5132 9132{
b34976b6 9133 static char buff[32];
5cf1065c 9134
252b5132
RH		 9135 switch (type)
9136 {
b34976b6
AM		 9137 case SHN_UNDEF: return "UND";
9138 case SHN_ABS: return "ABS";
9139 case SHN_COMMON: return "COM";
252b5132 9140 default:
9ce701e2
L		 9141 if (type == SHN_IA_64_ANSI_COMMON
9142 && elf_header.e_machine == EM_IA_64
9143 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9144 return "ANSI_COM";
8a9036a4 9145 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9146 || elf_header.e_machine == EM_L1OM
9147 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9148 && type == SHN_X86_64_LCOMMON)
9149 return "LARGE_COM";
ac145307
BS		 9150 else if ((type == SHN_MIPS_SCOMMON
9151 && elf_header.e_machine == EM_MIPS)
9152 || (type == SHN_TIC6X_SCOMMON
9153 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9154 return "SCOM";
9155 else if (type == SHN_MIPS_SUNDEFINED
9156 && elf_header.e_machine == EM_MIPS)
9157 return "SUND";
9ce701e2 9158 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9159 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9160 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9161 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9162 else if (type >= SHN_LORESERVE)
9163 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L		 9164 else if (type >= elf_header.e_shnum)
9165 sprintf (buff, "bad section index[%3d]", type);
252b5132 9166 else
232e7cb8 9167 sprintf (buff, "%3d", type);
5cf1065c 9168 break;
252b5132 9169 }
5cf1065c
NC		 9170
9171 return buff;
252b5132
RH		 9172}
9173
66543521 9174static bfd_vma *
2cf0635d 9175get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9176{
2cf0635d
NC		 9177 unsigned char * e_data;
9178 bfd_vma * i_data;
252b5132 9179
3f5e193b 9180 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9181
9182 if (e_data == NULL)
9183 {
9184 error (_("Out of memory\n"));
9185 return NULL;
9186 }
9187
66543521 9188 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9189 {
9190 error (_("Unable to read in dynamic data\n"));
9191 return NULL;
9192 }
9193
3f5e193b 9194 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9195
9196 if (i_data == NULL)
9197 {
9198 error (_("Out of memory\n"));
9199 free (e_data);
9200 return NULL;
9201 }
9202
9203 while (number--)
66543521 9204 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9205
9206 free (e_data);
9207
9208 return i_data;
9209}
9210
6bd1a22c
L		 9211static void
9212print_dynamic_symbol (bfd_vma si, unsigned long hn)
9213{
2cf0635d 9214 Elf_Internal_Sym * psym;
6bd1a22c
L		 9215 int n;
9216
9217 psym = dynamic_symbols + si;
9218
9219 n = print_vma (si, DEC_5);
9220 if (n < 5)
9221 fputs (" " + n, stdout);
9222 printf (" %3lu: ", hn);
9223 print_vma (psym->st_value, LONG_HEX);
9224 putchar (' ');
9225 print_vma (psym->st_size, DEC_5);
9226
f4be36b3
AM		 9227 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9228 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9229 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9230 /* Check to see if any other bits in the st_other field are set.
9231 Note - displaying this information disrupts the layout of the
9232 table being generated, but for the moment this case is very
9233 rare. */
9234 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9235 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9236 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9237 if (VALID_DYNAMIC_NAME (psym->st_name))
9238 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9239 else
2b692964 9240 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9241 putchar ('\n');
9242}
9243
e3c8793a 9244/* Dump the symbol table. */
252b5132 9245static int
2cf0635d 9246process_symbol_table (FILE * file)
252b5132 9247{
2cf0635d 9248 Elf_Internal_Shdr * section;
66543521
AM		 9249 bfd_vma nbuckets = 0;
9250 bfd_vma nchains = 0;
2cf0635d
NC		 9251 bfd_vma * buckets = NULL;
9252 bfd_vma * chains = NULL;
fdc90cb4 9253 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9254 bfd_vma * gnubuckets = NULL;
9255 bfd_vma * gnuchains = NULL;
6bd1a22c 9256 bfd_vma gnusymidx = 0;
252b5132 9257
2c610e4b 9258 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9259 return 1;
9260
6bd1a22c
L		 9261 if (dynamic_info[DT_HASH]
9262 && (do_histogram
2c610e4b
L		 9263 || (do_using_dynamic
9264 && !do_dyn_syms
9265 && dynamic_strings != NULL)))
252b5132 9266 {
66543521
AM		 9267 unsigned char nb[8];
9268 unsigned char nc[8];
9269 int hash_ent_size = 4;
9270
9271 if ((elf_header.e_machine == EM_ALPHA
9272 || elf_header.e_machine == EM_S390
9273 || elf_header.e_machine == EM_S390_OLD)
9274 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9275 hash_ent_size = 8;
9276
fb52b2f4
NC		 9277 if (fseek (file,
9278 (archive_file_offset
9279 + offset_from_vma (file, dynamic_info[DT_HASH],
9280 sizeof nb + sizeof nc)),
d93f0186 9281 SEEK_SET))
252b5132 9282 {
591a748a 9283 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9284 goto no_hash;
252b5132
RH		 9285 }
9286
66543521 9287 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9288 {
9289 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9290 goto no_hash;
252b5132
RH		 9291 }
9292
66543521 9293 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9294 {
9295 error (_("Failed to read in number of chains\n"));
d3a44ec6 9296 goto no_hash;
252b5132
RH		 9297 }
9298
66543521
AM		 9299 nbuckets = byte_get (nb, hash_ent_size);
9300 nchains = byte_get (nc, hash_ent_size);
252b5132 9301
66543521
AM		 9302 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9303 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9304
d3a44ec6 9305 no_hash:
252b5132 9306 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9307 {
9308 if (do_using_dynamic)
9309 return 0;
9310 free (buckets);
9311 free (chains);
9312 buckets = NULL;
9313 chains = NULL;
9314 nbuckets = 0;
9315 nchains = 0;
9316 }
252b5132
RH		 9317 }
9318
6bd1a22c
L		 9319 if (dynamic_info_DT_GNU_HASH
9320 && (do_histogram
2c610e4b
L		 9321 || (do_using_dynamic
9322 && !do_dyn_syms
9323 && dynamic_strings != NULL)))
252b5132 9324 {
6bd1a22c
L		 9325 unsigned char nb[16];
9326 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9327 bfd_vma buckets_vma;
9328
9329 if (fseek (file,
9330 (archive_file_offset
9331 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9332 sizeof nb)),
9333 SEEK_SET))
9334 {
9335 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9336 goto no_gnu_hash;
6bd1a22c 9337 }
252b5132 9338
6bd1a22c
L		 9339 if (fread (nb, 16, 1, file) != 1)
9340 {
9341 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9342 goto no_gnu_hash;
6bd1a22c
L		 9343 }
9344
9345 ngnubuckets = byte_get (nb, 4);
9346 gnusymidx = byte_get (nb + 4, 4);
9347 bitmaskwords = byte_get (nb + 8, 4);
9348 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9349 if (is_32bit_elf)
6bd1a22c 9350 buckets_vma += bitmaskwords * 4;
f7a99963 9351 else
6bd1a22c 9352 buckets_vma += bitmaskwords * 8;
252b5132 9353
6bd1a22c
L		 9354 if (fseek (file,
9355 (archive_file_offset
9356 + offset_from_vma (file, buckets_vma, 4)),
9357 SEEK_SET))
252b5132 9358 {
6bd1a22c 9359 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9360 goto no_gnu_hash;
6bd1a22c
L		 9361 }
9362
9363 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9364
6bd1a22c 9365 if (gnubuckets == NULL)
d3a44ec6 9366 goto no_gnu_hash;
6bd1a22c
L		 9367
9368 for (i = 0; i < ngnubuckets; i++)
9369 if (gnubuckets[i] != 0)
9370 {
9371 if (gnubuckets[i] < gnusymidx)
9372 return 0;
9373
9374 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9375 maxchain = gnubuckets[i];
9376 }
9377
9378 if (maxchain == 0xffffffff)
d3a44ec6 9379 goto no_gnu_hash;
6bd1a22c
L		 9380
9381 maxchain -= gnusymidx;
9382
9383 if (fseek (file,
9384 (archive_file_offset
9385 + offset_from_vma (file, buckets_vma
9386 + 4 * (ngnubuckets + maxchain), 4)),
9387 SEEK_SET))
9388 {
9389 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9390 goto no_gnu_hash;
6bd1a22c
L		 9391 }
9392
9393 do
9394 {
9395 if (fread (nb, 4, 1, file) != 1)
252b5132 9396 {
6bd1a22c 9397 error (_("Failed to determine last chain length\n"));
d3a44ec6 9398 goto no_gnu_hash;
6bd1a22c 9399 }
252b5132 9400
6bd1a22c 9401 if (maxchain + 1 == 0)
d3a44ec6 9402 goto no_gnu_hash;
252b5132 9403
6bd1a22c
L		 9404 ++maxchain;
9405 }
9406 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9407
6bd1a22c
L		 9408 if (fseek (file,
9409 (archive_file_offset
9410 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9411 SEEK_SET))
9412 {
9413 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9414 goto no_gnu_hash;
6bd1a22c
L		 9415 }
9416
9417 gnuchains = get_dynamic_data (file, maxchain, 4);
9418
d3a44ec6 9419 no_gnu_hash:
6bd1a22c 9420 if (gnuchains == NULL)
d3a44ec6
JJ		 9421 {
9422 free (gnubuckets);
d3a44ec6
JJ		 9423 gnubuckets = NULL;
9424 ngnubuckets = 0;
f64fddf1
NC		 9425 if (do_using_dynamic)
9426 return 0;
d3a44ec6 9427 }
6bd1a22c
L		 9428 }
9429
9430 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9431 && do_syms
9432 && do_using_dynamic
9433 && dynamic_strings != NULL)
9434 {
9435 unsigned long hn;
9436
9437 if (dynamic_info[DT_HASH])
9438 {
9439 bfd_vma si;
9440
9441 printf (_("\nSymbol table for image:\n"));
9442 if (is_32bit_elf)
9443 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9444 else
9445 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9446
9447 for (hn = 0; hn < nbuckets; hn++)
9448 {
9449 if (! buckets[hn])
9450 continue;
9451
9452 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9453 print_dynamic_symbol (si, hn);
252b5132
RH		 9454 }
9455 }
6bd1a22c
L		 9456
9457 if (dynamic_info_DT_GNU_HASH)
9458 {
9459 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9460 if (is_32bit_elf)
9461 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9462 else
9463 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9464
9465 for (hn = 0; hn < ngnubuckets; ++hn)
9466 if (gnubuckets[hn] != 0)
9467 {
9468 bfd_vma si = gnubuckets[hn];
9469 bfd_vma off = si - gnusymidx;
9470
9471 do
9472 {
9473 print_dynamic_symbol (si, hn);
9474 si++;
9475 }
9476 while ((gnuchains[off++] & 1) == 0);
9477 }
9478 }
252b5132 9479 }
2c610e4b 9480 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9481 {
b34976b6 9482 unsigned int i;
252b5132
RH		 9483
9484 for (i = 0, section = section_headers;
9485 i < elf_header.e_shnum;
9486 i++, section++)
9487 {
b34976b6 9488 unsigned int si;
2cf0635d 9489 char * strtab = NULL;
c256ffe7 9490 unsigned long int strtab_size = 0;
2cf0635d
NC		 9491 Elf_Internal_Sym * symtab;
9492 Elf_Internal_Sym * psym;
ba5cdace 9493 unsigned long num_syms;
252b5132 9494
2c610e4b
L		 9495 if ((section->sh_type != SHT_SYMTAB
9496 && section->sh_type != SHT_DYNSYM)
9497 || (!do_syms
9498 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9499 continue;
9500
dd24e3da
NC		 9501 if (section->sh_entsize == 0)
9502 {
9503 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9504 SECTION_NAME (section));
9505 continue;
9506 }
9507
252b5132
RH		 9508 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9509 SECTION_NAME (section),
9510 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9511
f7a99963 9512 if (is_32bit_elf)
ca47b30c 9513 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9514 else
ca47b30c 9515 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9516
ba5cdace 9517 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9518 if (symtab == NULL)
9519 continue;
9520
9521 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9522 {
9523 strtab = string_table;
9524 strtab_size = string_table_length;
9525 }
4fbb74a6 9526 else if (section->sh_link < elf_header.e_shnum)
252b5132 9527 {
2cf0635d 9528 Elf_Internal_Shdr * string_sec;
252b5132 9529
4fbb74a6 9530 string_sec = section_headers + section->sh_link;
252b5132 9531
3f5e193b
NC		 9532 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9533 1, string_sec->sh_size,
9534 _("string table"));
c256ffe7 9535 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9536 }
9537
ba5cdace 9538 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9539 {
5e220199 9540 printf ("%6d: ", si);
f7a99963
NC		 9541 print_vma (psym->st_value, LONG_HEX);
9542 putchar (' ');
9543 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9544 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9545 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9546 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9547 /* Check to see if any other bits in the st_other field are set.
9548 Note - displaying this information disrupts the layout of the
9549 table being generated, but for the moment this case is very rare. */
9550 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9551 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9552 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9553 print_symbol (25, psym->st_name < strtab_size
2b692964 9554 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9555
59245841
NC		 9556 if (section->sh_type == SHT_DYNSYM
9557 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9558 {
b34976b6
AM		 9559 unsigned char data[2];
9560 unsigned short vers_data;
9561 unsigned long offset;
9562 int is_nobits;
9563 int check_def;
252b5132 9564
d93f0186
NC		 9565 offset = offset_from_vma
9566 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9567 sizeof data + si * sizeof (vers_data));
252b5132 9568
59245841
NC		 9569 if (get_data (&data, file, offset + si * sizeof (vers_data),
9570 sizeof (data), 1, _("version data")) == NULL)
9571 break;
252b5132
RH		 9572
9573 vers_data = byte_get (data, 2);
9574
4fbb74a6
AM		 9575 is_nobits = (psym->st_shndx < elf_header.e_shnum
9576 && section_headers[psym->st_shndx].sh_type
c256ffe7 9577 == SHT_NOBITS);
252b5132
RH		 9578
9579 check_def = (psym->st_shndx != SHN_UNDEF);
9580
c244d050 9581 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9582 {
b34976b6 9583 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9584 && (is_nobits || ! check_def))
252b5132 9585 {
b34976b6
AM		 9586 Elf_External_Verneed evn;
9587 Elf_Internal_Verneed ivn;
9588 Elf_Internal_Vernaux ivna;
252b5132
RH		 9589
9590 /* We must test both. */
d93f0186
NC		 9591 offset = offset_from_vma
9592 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9593 sizeof evn);
252b5132 9594
252b5132
RH		 9595 do
9596 {
b34976b6 9597 unsigned long vna_off;
252b5132 9598
59245841
NC		 9599 if (get_data (&evn, file, offset, sizeof (evn), 1,
9600 _("version need")) == NULL)
9601 {
9602 ivna.vna_next = 0;
9603 ivna.vna_other = 0;
9604 ivna.vna_name = 0;
9605 break;
9606 }
dd27201e
L		 9607
9608 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9609 ivn.vn_next = BYTE_GET (evn.vn_next);
9610
252b5132
RH		 9611 vna_off = offset + ivn.vn_aux;
9612
9613 do
9614 {
b34976b6 9615 Elf_External_Vernaux evna;
252b5132 9616
59245841
NC		 9617 if (get_data (&evna, file, vna_off,
9618 sizeof (evna), 1,
9619 _("version need aux (3)")) == NULL)
9620 {
9621 ivna.vna_next = 0;
9622 ivna.vna_other = 0;
9623 ivna.vna_name = 0;
9624 }
9625 else
9626 {
9627 ivna.vna_other = BYTE_GET (evna.vna_other);
9628 ivna.vna_next = BYTE_GET (evna.vna_next);
9629 ivna.vna_name = BYTE_GET (evna.vna_name);
9630 }
252b5132
RH		 9631
9632 vna_off += ivna.vna_next;
9633 }
9634 while (ivna.vna_other != vers_data
9635 && ivna.vna_next != 0);
9636
9637 if (ivna.vna_other == vers_data)
9638 break;
9639
9640 offset += ivn.vn_next;
9641 }
9642 while (ivn.vn_next != 0);
9643
9644 if (ivna.vna_other == vers_data)
9645 {
9646 printf ("@%s (%d)",
c256ffe7 9647 ivna.vna_name < strtab_size
2b692964 9648 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9649 ivna.vna_other);
252b5132
RH		 9650 check_def = 0;
9651 }
9652 else if (! is_nobits)
591a748a 9653 error (_("bad dynamic symbol\n"));
252b5132
RH		 9654 else
9655 check_def = 1;
9656 }
9657
9658 if (check_def)
9659 {
00d93f34 9660 if (vers_data != 0x8001
b34976b6 9661 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9662 {
b34976b6
AM		 9663 Elf_Internal_Verdef ivd;
9664 Elf_Internal_Verdaux ivda;
9665 Elf_External_Verdaux evda;
91d6fa6a 9666 unsigned long off;
252b5132 9667
91d6fa6a 9668 off = offset_from_vma
d93f0186
NC		 9669 (file,
9670 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9671 sizeof (Elf_External_Verdef));
252b5132
RH		 9672
9673 do
9674 {
b34976b6 9675 Elf_External_Verdef evd;
252b5132 9676
59245841
NC		 9677 if (get_data (&evd, file, off, sizeof (evd),
9678 1, _("version def")) == NULL)
9679 {
9680 ivd.vd_ndx = 0;
9681 ivd.vd_aux = 0;
9682 ivd.vd_next = 0;
9683 }
9684 else
9685 {
9686 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9687 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9688 ivd.vd_next = BYTE_GET (evd.vd_next);
9689 }
252b5132 9690
91d6fa6a 9691 off += ivd.vd_next;
252b5132 9692 }
c244d050 9693 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9694 && ivd.vd_next != 0);
9695
91d6fa6a
NC		 9696 off -= ivd.vd_next;
9697 off += ivd.vd_aux;
252b5132 9698
59245841
NC		 9699 if (get_data (&evda, file, off, sizeof (evda),
9700 1, _("version def aux")) == NULL)
9701 break;
252b5132
RH		 9702
9703 ivda.vda_name = BYTE_GET (evda.vda_name);
9704
9705 if (psym->st_name != ivda.vda_name)
c244d050 9706 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9707 ? "@%s" : "@@%s",
c256ffe7 9708 ivda.vda_name < strtab_size
2b692964 9709 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9710 }
9711 }
9712 }
9713 }
9714
9715 putchar ('\n');
9716 }
9717
9718 free (symtab);
9719 if (strtab != string_table)
9720 free (strtab);
9721 }
9722 }
9723 else if (do_syms)
9724 printf
9725 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9726
9727 if (do_histogram && buckets != NULL)
9728 {
2cf0635d
NC		 9729 unsigned long * lengths;
9730 unsigned long * counts;
66543521
AM		 9731 unsigned long hn;
9732 bfd_vma si;
9733 unsigned long maxlength = 0;
9734 unsigned long nzero_counts = 0;
9735 unsigned long nsyms = 0;
252b5132 9736
66543521
AM		 9737 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9738 (unsigned long) nbuckets);
252b5132
RH		 9739 printf (_(" Length Number %% of total Coverage\n"));
9740
3f5e193b 9741 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9742 if (lengths == NULL)
9743 {
591a748a 9744 error (_("Out of memory\n"));
252b5132
RH		 9745 return 0;
9746 }
9747 for (hn = 0; hn < nbuckets; ++hn)
9748 {
f7a99963 9749 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9750 {
b34976b6 9751 ++nsyms;
252b5132 9752 if (maxlength < ++lengths[hn])
b34976b6 9753 ++maxlength;
252b5132
RH		 9754 }
9755 }
9756
3f5e193b 9757 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9758 if (counts == NULL)
9759 {
591a748a 9760 error (_("Out of memory\n"));
252b5132
RH		 9761 return 0;
9762 }
9763
9764 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9765 ++counts[lengths[hn]];
252b5132 9766
103f02d3 9767 if (nbuckets > 0)
252b5132 9768 {
66543521
AM		 9769 unsigned long i;
9770 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9771 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9772 for (i = 1; i <= maxlength; ++i)
103f02d3 9773 {
66543521
AM		 9774 nzero_counts += counts[i] * i;
9775 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9776 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9777 (nzero_counts * 100.0) / nsyms);
9778 }
252b5132
RH		 9779 }
9780
9781 free (counts);
9782 free (lengths);
9783 }
9784
9785 if (buckets != NULL)
9786 {
9787 free (buckets);
9788 free (chains);
9789 }
9790
d3a44ec6 9791 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9792 {
2cf0635d
NC		 9793 unsigned long * lengths;
9794 unsigned long * counts;
fdc90cb4
JJ		 9795 unsigned long hn;
9796 unsigned long maxlength = 0;
9797 unsigned long nzero_counts = 0;
9798 unsigned long nsyms = 0;
fdc90cb4 9799
3f5e193b 9800 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9801 if (lengths == NULL)
9802 {
591a748a 9803 error (_("Out of memory\n"));
fdc90cb4
JJ		 9804 return 0;
9805 }
9806
9807 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9808 (unsigned long) ngnubuckets);
9809 printf (_(" Length Number %% of total Coverage\n"));
9810
9811 for (hn = 0; hn < ngnubuckets; ++hn)
9812 if (gnubuckets[hn] != 0)
9813 {
9814 bfd_vma off, length = 1;
9815
6bd1a22c 9816 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9817 (gnuchains[off] & 1) == 0; ++off)
9818 ++length;
9819 lengths[hn] = length;
9820 if (length > maxlength)
9821 maxlength = length;
9822 nsyms += length;
9823 }
9824
3f5e193b 9825 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9826 if (counts == NULL)
9827 {
591a748a 9828 error (_("Out of memory\n"));
fdc90cb4
JJ		 9829 return 0;
9830 }
9831
9832 for (hn = 0; hn < ngnubuckets; ++hn)
9833 ++counts[lengths[hn]];
9834
9835 if (ngnubuckets > 0)
9836 {
9837 unsigned long j;
9838 printf (" 0 %-10lu (%5.1f%%)\n",
9839 counts[0], (counts[0] * 100.0) / ngnubuckets);
9840 for (j = 1; j <= maxlength; ++j)
9841 {
9842 nzero_counts += counts[j] * j;
9843 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9844 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9845 (nzero_counts * 100.0) / nsyms);
9846 }
9847 }
9848
9849 free (counts);
9850 free (lengths);
9851 free (gnubuckets);
9852 free (gnuchains);
9853 }
9854
252b5132
RH		 9855 return 1;
9856}
9857
9858static int
2cf0635d 9859process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9860{
b4c96d0d 9861 unsigned int i;
252b5132
RH		 9862
9863 if (dynamic_syminfo == NULL
9864 || !do_dynamic)
9865 /* No syminfo, this is ok. */
9866 return 1;
9867
9868 /* There better should be a dynamic symbol section. */
9869 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9870 return 0;
9871
9872 if (dynamic_addr)
9873 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9874 dynamic_syminfo_offset, dynamic_syminfo_nent);
9875
9876 printf (_(" Num: Name BoundTo Flags\n"));
9877 for (i = 0; i < dynamic_syminfo_nent; ++i)
9878 {
9879 unsigned short int flags = dynamic_syminfo[i].si_flags;
9880
31104126 9881 printf ("%4d: ", i);
d79b3d50
NC		 9882 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9883 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9884 else
2b692964 9885 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9886 putchar (' ');
252b5132
RH		 9887
9888 switch (dynamic_syminfo[i].si_boundto)
9889 {
9890 case SYMINFO_BT_SELF:
9891 fputs ("SELF ", stdout);
9892 break;
9893 case SYMINFO_BT_PARENT:
9894 fputs ("PARENT ", stdout);
9895 break;
9896 default:
9897 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9898 && dynamic_syminfo[i].si_boundto < dynamic_nent
9899 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9900 {
d79b3d50 9901 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9902 putchar (' ' );
9903 }
252b5132
RH		 9904 else
9905 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9906 break;
9907 }
9908
9909 if (flags & SYMINFO_FLG_DIRECT)
9910 printf (" DIRECT");
9911 if (flags & SYMINFO_FLG_PASSTHRU)
9912 printf (" PASSTHRU");
9913 if (flags & SYMINFO_FLG_COPY)
9914 printf (" COPY");
9915 if (flags & SYMINFO_FLG_LAZYLOAD)
9916 printf (" LAZYLOAD");
9917
9918 puts ("");
9919 }
9920
9921 return 1;
9922}
9923
cf13d699
NC		 9924/* Check to see if the given reloc needs to be handled in a target specific
9925 manner. If so then process the reloc and return TRUE otherwise return
9926 FALSE. */
09c11c86 9927
cf13d699
NC		 9928static bfd_boolean
9929target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9930 unsigned char * start,
9931 Elf_Internal_Sym * symtab)
252b5132 9932{
cf13d699 9933 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9934
cf13d699 9935 switch (elf_header.e_machine)
252b5132 9936 {
cf13d699
NC		 9937 case EM_MN10300:
9938 case EM_CYGNUS_MN10300:
9939 {
9940 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9941
cf13d699
NC		 9942 switch (reloc_type)
9943 {
9944 case 34: /* R_MN10300_ALIGN */
9945 return TRUE;
9946 case 33: /* R_MN10300_SYM_DIFF */
9947 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9948 return TRUE;
9949 case 1: /* R_MN10300_32 */
9950 case 2: /* R_MN10300_16 */
9951 if (saved_sym != NULL)
9952 {
9953 bfd_vma value;
252b5132 9954
cf13d699
NC		 9955 value = reloc->r_addend
9956 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9957 - saved_sym->st_value);
252b5132 9958
cf13d699 9959 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9960
cf13d699
NC		 9961 saved_sym = NULL;
9962 return TRUE;
9963 }
9964 break;
9965 default:
9966 if (saved_sym != NULL)
9967 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9968 break;
9969 }
9970 break;
9971 }
252b5132
RH		 9972 }
9973
cf13d699 9974 return FALSE;
252b5132
RH		 9975}
9976
aca88567
NC		 9977/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9978 DWARF debug sections. This is a target specific test. Note - we do not
9979 go through the whole including-target-headers-multiple-times route, (as
9980 we have already done with <elf/h8.h>) because this would become very
9981 messy and even then this function would have to contain target specific
9982 information (the names of the relocs instead of their numeric values).
9983 FIXME: This is not the correct way to solve this problem. The proper way
9984 is to have target specific reloc sizing and typing functions created by
9985 the reloc-macros.h header, in the same way that it already creates the
9986 reloc naming functions. */
9987
9988static bfd_boolean
9989is_32bit_abs_reloc (unsigned int reloc_type)
9990{
9991 switch (elf_header.e_machine)
9992 {
41e92641
NC		 9993 case EM_386:
9994 case EM_486:
9995 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9996 case EM_68K:
9997 return reloc_type == 1; /* R_68K_32. */
9998 case EM_860:
9999 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10000 case EM_960:
10001 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10002 case EM_AARCH64:
10003 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10004 case EM_ALPHA:
137b6b5f 10005 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10006 case EM_ARC:
10007 return reloc_type == 1; /* R_ARC_32. */
10008 case EM_ARM:
10009 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10010 case EM_AVR_OLD:
aca88567
NC		 10011 case EM_AVR:
10012 return reloc_type == 1;
cfb8c092
NC		 10013 case EM_ADAPTEVA_EPIPHANY:
10014 return reloc_type == 3;
aca88567
NC		 10015 case EM_BLACKFIN:
10016 return reloc_type == 0x12; /* R_byte4_data. */
10017 case EM_CRIS:
10018 return reloc_type == 3; /* R_CRIS_32. */
10019 case EM_CR16:
10020 return reloc_type == 3; /* R_CR16_NUM32. */
10021 case EM_CRX:
10022 return reloc_type == 15; /* R_CRX_NUM32. */
10023 case EM_CYGNUS_FRV:
10024 return reloc_type == 1;
41e92641
NC		 10025 case EM_CYGNUS_D10V:
10026 case EM_D10V:
10027 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10028 case EM_CYGNUS_D30V:
10029 case EM_D30V:
10030 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10031 case EM_DLX:
10032 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10033 case EM_CYGNUS_FR30:
10034 case EM_FR30:
10035 return reloc_type == 3; /* R_FR30_32. */
10036 case EM_H8S:
10037 case EM_H8_300:
10038 case EM_H8_300H:
10039 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10040 case EM_IA_64:
10041 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10042 case EM_IP2K_OLD:
10043 case EM_IP2K:
10044 return reloc_type == 2; /* R_IP2K_32. */
10045 case EM_IQ2000:
10046 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10047 case EM_LATTICEMICO32:
10048 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10049 case EM_M32C_OLD:
aca88567
NC		 10050 case EM_M32C:
10051 return reloc_type == 3; /* R_M32C_32. */
10052 case EM_M32R:
10053 return reloc_type == 34; /* R_M32R_32_RELA. */
10054 case EM_MCORE:
10055 return reloc_type == 1; /* R_MCORE_ADDR32. */
10056 case EM_CYGNUS_MEP:
10057 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10058 case EM_METAG:
10059 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10060 case EM_MICROBLAZE:
10061 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10062 case EM_MIPS:
10063 return reloc_type == 2; /* R_MIPS_32. */
10064 case EM_MMIX:
10065 return reloc_type == 4; /* R_MMIX_32. */
10066 case EM_CYGNUS_MN10200:
10067 case EM_MN10200:
10068 return reloc_type == 1; /* R_MN10200_32. */
10069 case EM_CYGNUS_MN10300:
10070 case EM_MN10300:
10071 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10072 case EM_MOXIE:
10073 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10074 case EM_MSP430_OLD:
10075 case EM_MSP430:
10076 return reloc_type == 1; /* R_MSP43_32. */
10077 case EM_MT:
10078 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 10079 case EM_ALTERA_NIOS2:
10080 case EM_NIOS32:
10081 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 10082 case EM_OPENRISC:
10083 case EM_OR32:
10084 return reloc_type == 1; /* R_OR32_32. */
aca88567 10085 case EM_PARISC:
5fda8eca
NC		 10086 return (reloc_type == 1 /* R_PARISC_DIR32. */
10087 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10088 case EM_PJ:
10089 case EM_PJ_OLD:
10090 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10091 case EM_PPC64:
10092 return reloc_type == 1; /* R_PPC64_ADDR32. */
10093 case EM_PPC:
10094 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10095 case EM_RL78:
10096 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10097 case EM_RX:
10098 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10099 case EM_S370:
10100 return reloc_type == 1; /* R_I370_ADDR31. */
10101 case EM_S390_OLD:
10102 case EM_S390:
10103 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10104 case EM_SCORE:
10105 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10106 case EM_SH:
10107 return reloc_type == 1; /* R_SH_DIR32. */
10108 case EM_SPARC32PLUS:
10109 case EM_SPARCV9:
10110 case EM_SPARC:
10111 return reloc_type == 3 /* R_SPARC_32. */
10112 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10113 case EM_SPU:
10114 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10115 case EM_TI_C6000:
10116 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10117 case EM_TILEGX:
10118 return reloc_type == 2; /* R_TILEGX_32. */
10119 case EM_TILEPRO:
10120 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10121 case EM_CYGNUS_V850:
10122 case EM_V850:
10123 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10124 case EM_V800:
10125 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10126 case EM_VAX:
10127 return reloc_type == 1; /* R_VAX_32. */
10128 case EM_X86_64:
8a9036a4 10129 case EM_L1OM:
7a9068fe 10130 case EM_K1OM:
aca88567 10131 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10132 case EM_XC16X:
10133 case EM_C166:
10134 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10135 case EM_XGATE:
10136 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10137 case EM_XSTORMY16:
10138 return reloc_type == 1; /* R_XSTROMY16_32. */
10139 case EM_XTENSA_OLD:
10140 case EM_XTENSA:
10141 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10142 default:
10143 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10144 elf_header.e_machine);
10145 abort ();
10146 }
10147}
10148
10149/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10150 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10151
10152static bfd_boolean
10153is_32bit_pcrel_reloc (unsigned int reloc_type)
10154{
10155 switch (elf_header.e_machine)
10156 {
41e92641
NC		 10157 case EM_386:
10158 case EM_486:
3e0873ac 10159 return reloc_type == 2; /* R_386_PC32. */
aca88567 10160 case EM_68K:
3e0873ac 10161 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10162 case EM_AARCH64:
10163 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10164 case EM_ADAPTEVA_EPIPHANY:
10165 return reloc_type == 6;
aca88567
NC		 10166 case EM_ALPHA:
10167 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10168 case EM_ARM:
3e0873ac 10169 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10170 case EM_MICROBLAZE:
10171 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 10172 case EM_PARISC:
85acf597 10173 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10174 case EM_PPC:
10175 return reloc_type == 26; /* R_PPC_REL32. */
10176 case EM_PPC64:
3e0873ac 10177 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10178 case EM_S390_OLD:
10179 case EM_S390:
3e0873ac 10180 return reloc_type == 5; /* R_390_PC32. */
aca88567 10181 case EM_SH:
3e0873ac 10182 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10183 case EM_SPARC32PLUS:
10184 case EM_SPARCV9:
10185 case EM_SPARC:
3e0873ac 10186 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10187 case EM_SPU:
10188 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10189 case EM_TILEGX:
10190 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10191 case EM_TILEPRO:
10192 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10193 case EM_X86_64:
8a9036a4 10194 case EM_L1OM:
7a9068fe 10195 case EM_K1OM:
3e0873ac 10196 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10197 case EM_XTENSA_OLD:
10198 case EM_XTENSA:
10199 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10200 default:
10201 /* Do not abort or issue an error message here. Not all targets use
10202 pc-relative 32-bit relocs in their DWARF debug information and we
10203 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10204 more helpful warning message will be generated by apply_relocations
10205 anyway, so just return. */
aca88567
NC		 10206 return FALSE;
10207 }
10208}
10209
10210/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10211 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10212
10213static bfd_boolean
10214is_64bit_abs_reloc (unsigned int reloc_type)
10215{
10216 switch (elf_header.e_machine)
10217 {
a06ea964
NC		 10218 case EM_AARCH64:
10219 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10220 case EM_ALPHA:
10221 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10222 case EM_IA_64:
10223 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10224 case EM_PARISC:
10225 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10226 case EM_PPC64:
10227 return reloc_type == 38; /* R_PPC64_ADDR64. */
10228 case EM_SPARC32PLUS:
10229 case EM_SPARCV9:
10230 case EM_SPARC:
10231 return reloc_type == 54; /* R_SPARC_UA64. */
10232 case EM_X86_64:
8a9036a4 10233 case EM_L1OM:
7a9068fe 10234 case EM_K1OM:
aca88567 10235 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10236 case EM_S390_OLD:
10237 case EM_S390:
aa137e4d
NC		 10238 return reloc_type == 22; /* R_S390_64. */
10239 case EM_TILEGX:
10240 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10241 case EM_MIPS:
aa137e4d 10242 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10243 default:
10244 return FALSE;
10245 }
10246}
10247
85acf597
RH		 10248/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10249 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10250
10251static bfd_boolean
10252is_64bit_pcrel_reloc (unsigned int reloc_type)
10253{
10254 switch (elf_header.e_machine)
10255 {
a06ea964
NC		 10256 case EM_AARCH64:
10257 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10258 case EM_ALPHA:
aa137e4d 10259 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10260 case EM_IA_64:
aa137e4d 10261 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10262 case EM_PARISC:
aa137e4d 10263 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10264 case EM_PPC64:
aa137e4d 10265 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10266 case EM_SPARC32PLUS:
10267 case EM_SPARCV9:
10268 case EM_SPARC:
aa137e4d 10269 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10270 case EM_X86_64:
8a9036a4 10271 case EM_L1OM:
7a9068fe 10272 case EM_K1OM:
aa137e4d 10273 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10274 case EM_S390_OLD:
10275 case EM_S390:
aa137e4d
NC		 10276 return reloc_type == 23; /* R_S390_PC64. */
10277 case EM_TILEGX:
10278 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10279 default:
10280 return FALSE;
10281 }
10282}
10283
4dc3c23d
AM		 10284/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10285 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10286
10287static bfd_boolean
10288is_24bit_abs_reloc (unsigned int reloc_type)
10289{
10290 switch (elf_header.e_machine)
10291 {
10292 case EM_CYGNUS_MN10200:
10293 case EM_MN10200:
10294 return reloc_type == 4; /* R_MN10200_24. */
10295 default:
10296 return FALSE;
10297 }
10298}
10299
aca88567
NC		 10300/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10301 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10302
10303static bfd_boolean
10304is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10305{
10306 switch (elf_header.e_machine)
10307 {
aca88567
NC		 10308 case EM_AVR_OLD:
10309 case EM_AVR:
10310 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10311 case EM_ADAPTEVA_EPIPHANY:
10312 return reloc_type == 5;
41e92641
NC		 10313 case EM_CYGNUS_D10V:
10314 case EM_D10V:
10315 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10316 case EM_H8S:
10317 case EM_H8_300:
10318 case EM_H8_300H:
aca88567
NC		 10319 return reloc_type == R_H8_DIR16;
10320 case EM_IP2K_OLD:
10321 case EM_IP2K:
10322 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10323 case EM_M32C_OLD:
f4236fe4
DD		 10324 case EM_M32C:
10325 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 10326 case EM_MSP430_OLD:
10327 case EM_MSP430:
10328 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 10329 case EM_ALTERA_NIOS2:
10330 case EM_NIOS32:
10331 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10332 case EM_TI_C6000:
10333 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10334 case EM_XC16X:
10335 case EM_C166:
10336 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10337 case EM_CYGNUS_MN10200:
10338 case EM_MN10200:
10339 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10340 case EM_CYGNUS_MN10300:
10341 case EM_MN10300:
10342 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10343 case EM_XGATE:
10344 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10345 default:
aca88567 10346 return FALSE;
4b78141a
NC		 10347 }
10348}
10349
2a7b2e88
JK		 10350/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10351 relocation entries (possibly formerly used for SHT_GROUP sections). */
10352
10353static bfd_boolean
10354is_none_reloc (unsigned int reloc_type)
10355{
10356 switch (elf_header.e_machine)
10357 {
cb8f3167
NC		 10358 case EM_68K: /* R_68K_NONE. */
10359 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10360 case EM_SPARC32PLUS:
10361 case EM_SPARCV9:
cb8f3167
NC		 10362 case EM_SPARC: /* R_SPARC_NONE. */
10363 case EM_MIPS: /* R_MIPS_NONE. */
10364 case EM_PARISC: /* R_PARISC_NONE. */
10365 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10366 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10367 case EM_PPC: /* R_PPC_NONE. */
10368 case EM_PPC64: /* R_PPC64_NONE. */
10369 case EM_ARM: /* R_ARM_NONE. */
10370 case EM_IA_64: /* R_IA64_NONE. */
10371 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10372 case EM_S390_OLD:
cb8f3167
NC		 10373 case EM_S390: /* R_390_NONE. */
10374 case EM_CRIS: /* R_CRIS_NONE. */
10375 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10376 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10377 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10378 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10379 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10380 case EM_M32R: /* R_M32R_NONE. */
40b36596 10381 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10382 case EM_TILEGX: /* R_TILEGX_NONE. */
10383 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10384 case EM_XC16X:
10385 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 10386 return reloc_type == 0;
a06ea964
NC		 10387 case EM_AARCH64:
10388 return reloc_type == 0 || reloc_type == 256;
58332dda
JK		 10389 case EM_XTENSA_OLD:
10390 case EM_XTENSA:
4dc3c23d
AM		 10391 return (reloc_type == 0 /* R_XTENSA_NONE. */
10392 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10393 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10394 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 10395 case EM_METAG:
10396 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 10397 }
10398 return FALSE;
10399}
10400
cf13d699
NC		 10401/* Apply relocations to a section.
10402 Note: So far support has been added only for those relocations
10403 which can be found in debug sections.
10404 FIXME: Add support for more relocations ? */
1b315056 10405
cf13d699
NC		 10406static void
10407apply_relocations (void * file,
10408 Elf_Internal_Shdr * section,
10409 unsigned char * start)
1b315056 10410{
cf13d699
NC		 10411 Elf_Internal_Shdr * relsec;
10412 unsigned char * end = start + section->sh_size;
cb8f3167 10413
cf13d699
NC		 10414 if (elf_header.e_type != ET_REL)
10415 return;
1b315056 10416
cf13d699 10417 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10418 for (relsec = section_headers;
10419 relsec < section_headers + elf_header.e_shnum;
10420 ++relsec)
252b5132 10421 {
41e92641
NC		 10422 bfd_boolean is_rela;
10423 unsigned long num_relocs;
2cf0635d
NC		 10424 Elf_Internal_Rela * relocs;
10425 Elf_Internal_Rela * rp;
10426 Elf_Internal_Shdr * symsec;
10427 Elf_Internal_Sym * symtab;
ba5cdace 10428 unsigned long num_syms;
2cf0635d 10429 Elf_Internal_Sym * sym;
252b5132 10430
41e92641 10431 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10432 || relsec->sh_info >= elf_header.e_shnum
10433 || section_headers + relsec->sh_info != section
c256ffe7 10434 || relsec->sh_size == 0
4fbb74a6 10435 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10436 continue;
428409d5 10437
41e92641
NC		 10438 is_rela = relsec->sh_type == SHT_RELA;
10439
10440 if (is_rela)
10441 {
3f5e193b
NC		 10442 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10443 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10444 return;
10445 }
10446 else
10447 {
3f5e193b
NC		 10448 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10449 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10450 return;
10451 }
10452
10453 /* SH uses RELA but uses in place value instead of the addend field. */
10454 if (elf_header.e_machine == EM_SH)
10455 is_rela = FALSE;
428409d5 10456
4fbb74a6 10457 symsec = section_headers + relsec->sh_link;
ba5cdace 10458 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10459
41e92641 10460 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10461 {
41e92641
NC		 10462 bfd_vma addend;
10463 unsigned int reloc_type;
10464 unsigned int reloc_size;
91d6fa6a 10465 unsigned char * rloc;
ba5cdace 10466 unsigned long sym_index;
4b78141a 10467
aca88567 10468 reloc_type = get_reloc_type (rp->r_info);
41e92641 10469
98fb390a 10470 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10471 continue;
98fb390a
NC		 10472 else if (is_none_reloc (reloc_type))
10473 continue;
10474 else if (is_32bit_abs_reloc (reloc_type)
10475 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10476 reloc_size = 4;
85acf597
RH		 10477 else if (is_64bit_abs_reloc (reloc_type)
10478 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10479 reloc_size = 8;
4dc3c23d
AM		 10480 else if (is_24bit_abs_reloc (reloc_type))
10481 reloc_size = 3;
aca88567
NC		 10482 else if (is_16bit_abs_reloc (reloc_type))
10483 reloc_size = 2;
10484 else
4b78141a 10485 {
41e92641 10486 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10487 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10488 continue;
10489 }
103f02d3 10490
91d6fa6a
NC		 10491 rloc = start + rp->r_offset;
10492 if ((rloc + reloc_size) > end)
700dd8b7
L		 10493 {
10494 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10495 (unsigned long) rp->r_offset,
10496 SECTION_NAME (section));
10497 continue;
10498 }
103f02d3 10499
ba5cdace
NC		 10500 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10501 if (sym_index >= num_syms)
10502 {
10503 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10504 sym_index, SECTION_NAME (section));
10505 continue;
10506 }
10507 sym = symtab + sym_index;
41e92641
NC		 10508
10509 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10510 make sure that it is of an appropriate type.
10511
10512 Relocations against symbols without type can happen.
10513 Gcc -feliminate-dwarf2-dups may generate symbols
10514 without type for debug info.
10515
10516 Icc generates relocations against function symbols
10517 instead of local labels.
10518
10519 Relocations against object symbols can happen, eg when
10520 referencing a global array. For an example of this see
10521 the _clz.o binary in libgcc.a. */
aca88567 10522 if (sym != symtab
55f25fc3 10523 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10524 {
41e92641 10525 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10526 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10527 (long int)(rp - relocs),
41e92641 10528 SECTION_NAME (relsec));
aca88567 10529 continue;
5b18a4bc 10530 }
252b5132 10531
4dc3c23d
AM		 10532 addend = 0;
10533 if (is_rela)
10534 addend += rp->r_addend;
c47320c3
AM		 10535 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10536 partial_inplace. */
4dc3c23d
AM		 10537 if (!is_rela
10538 || (elf_header.e_machine == EM_XTENSA
10539 && reloc_type == 1)
10540 || ((elf_header.e_machine == EM_PJ
10541 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10542 && reloc_type == 1)
10543 || ((elf_header.e_machine == EM_D30V
10544 || elf_header.e_machine == EM_CYGNUS_D30V)
10545 && reloc_type == 12))
91d6fa6a 10546 addend += byte_get (rloc, reloc_size);
cb8f3167 10547
85acf597
RH		 10548 if (is_32bit_pcrel_reloc (reloc_type)
10549 || is_64bit_pcrel_reloc (reloc_type))
10550 {
10551 /* On HPPA, all pc-relative relocations are biased by 8. */
10552 if (elf_header.e_machine == EM_PARISC)
10553 addend -= 8;
91d6fa6a 10554 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10555 reloc_size);
10556 }
41e92641 10557 else
91d6fa6a 10558 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10559 }
252b5132 10560
5b18a4bc 10561 free (symtab);
41e92641 10562 free (relocs);
5b18a4bc
NC		 10563 break;
10564 }
5b18a4bc 10565}
103f02d3 10566
cf13d699
NC		 10567#ifdef SUPPORT_DISASSEMBLY
10568static int
10569disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10570{
10571 printf (_("\nAssembly dump of section %s\n"),
10572 SECTION_NAME (section));
10573
10574 /* XXX -- to be done --- XXX */
10575
10576 return 1;
10577}
10578#endif
10579
10580/* Reads in the contents of SECTION from FILE, returning a pointer
10581 to a malloc'ed buffer or NULL if something went wrong. */
10582
10583static char *
10584get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10585{
10586 bfd_size_type num_bytes;
10587
10588 num_bytes = section->sh_size;
10589
10590 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10591 {
10592 printf (_("\nSection '%s' has no data to dump.\n"),
10593 SECTION_NAME (section));
10594 return NULL;
10595 }
10596
3f5e193b
NC		 10597 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10598 _("section contents"));
cf13d699
NC		 10599}
10600
dd24e3da 10601
cf13d699
NC		 10602static void
10603dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10604{
10605 Elf_Internal_Shdr * relsec;
10606 bfd_size_type num_bytes;
cf13d699
NC		 10607 char * data;
10608 char * end;
10609 char * start;
10610 char * name = SECTION_NAME (section);
10611 bfd_boolean some_strings_shown;
10612
10613 start = get_section_contents (section, file);
10614 if (start == NULL)
10615 return;
10616
10617 printf (_("\nString dump of section '%s':\n"), name);
10618
10619 /* If the section being dumped has relocations against it the user might
10620 be expecting these relocations to have been applied. Check for this
10621 case and issue a warning message in order to avoid confusion.
10622 FIXME: Maybe we ought to have an option that dumps a section with
10623 relocs applied ? */
10624 for (relsec = section_headers;
10625 relsec < section_headers + elf_header.e_shnum;
10626 ++relsec)
10627 {
10628 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10629 || relsec->sh_info >= elf_header.e_shnum
10630 || section_headers + relsec->sh_info != section
10631 || relsec->sh_size == 0
10632 || relsec->sh_link >= elf_header.e_shnum)
10633 continue;
10634
10635 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10636 break;
10637 }
10638
10639 num_bytes = section->sh_size;
cf13d699
NC		 10640 data = start;
10641 end = start + num_bytes;
10642 some_strings_shown = FALSE;
10643
10644 while (data < end)
10645 {
10646 while (!ISPRINT (* data))
10647 if (++ data >= end)
10648 break;
10649
10650 if (data < end)
10651 {
10652#ifndef __MSVCRT__
c975cc98
NC		 10653 /* PR 11128: Use two separate invocations in order to work
10654 around bugs in the Solaris 8 implementation of printf. */
10655 printf (" [%6tx] ", data - start);
10656 printf ("%s\n", data);
cf13d699
NC		 10657#else
10658 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10659#endif
10660 data += strlen (data);
10661 some_strings_shown = TRUE;
10662 }
10663 }
10664
10665 if (! some_strings_shown)
10666 printf (_(" No strings found in this section."));
10667
10668 free (start);
10669
10670 putchar ('\n');
10671}
10672
10673static void
10674dump_section_as_bytes (Elf_Internal_Shdr * section,
10675 FILE * file,
10676 bfd_boolean relocate)
10677{
10678 Elf_Internal_Shdr * relsec;
10679 bfd_size_type bytes;
10680 bfd_vma addr;
10681 unsigned char * data;
10682 unsigned char * start;
10683
10684 start = (unsigned char *) get_section_contents (section, file);
10685 if (start == NULL)
10686 return;
10687
10688 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10689
10690 if (relocate)
10691 {
10692 apply_relocations (file, section, start);
10693 }
10694 else
10695 {
10696 /* If the section being dumped has relocations against it the user might
10697 be expecting these relocations to have been applied. Check for this
10698 case and issue a warning message in order to avoid confusion.
10699 FIXME: Maybe we ought to have an option that dumps a section with
10700 relocs applied ? */
10701 for (relsec = section_headers;
10702 relsec < section_headers + elf_header.e_shnum;
10703 ++relsec)
10704 {
10705 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10706 || relsec->sh_info >= elf_header.e_shnum
10707 || section_headers + relsec->sh_info != section
10708 || relsec->sh_size == 0
10709 || relsec->sh_link >= elf_header.e_shnum)
10710 continue;
10711
10712 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10713 break;
10714 }
10715 }
10716
10717 addr = section->sh_addr;
10718 bytes = section->sh_size;
10719 data = start;
10720
10721 while (bytes)
10722 {
10723 int j;
10724 int k;
10725 int lbytes;
10726
10727 lbytes = (bytes > 16 ? 16 : bytes);
10728
10729 printf (" 0x%8.8lx ", (unsigned long) addr);
10730
10731 for (j = 0; j < 16; j++)
10732 {
10733 if (j < lbytes)
10734 printf ("%2.2x", data[j]);
10735 else
10736 printf (" ");
10737
10738 if ((j & 3) == 3)
10739 printf (" ");
10740 }
10741
10742 for (j = 0; j < lbytes; j++)
10743 {
10744 k = data[j];
10745 if (k >= ' ' && k < 0x7f)
10746 printf ("%c", k);
10747 else
10748 printf (".");
10749 }
10750
10751 putchar ('\n');
10752
10753 data += lbytes;
10754 addr += lbytes;
10755 bytes -= lbytes;
10756 }
10757
10758 free (start);
10759
10760 putchar ('\n');
10761}
10762
4a114e3e 10763/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10764
10765static int
d3dbc530
AM		 10766uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10767 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10768{
10769#ifndef HAVE_ZLIB_H
cf13d699
NC		 10770 return FALSE;
10771#else
10772 dwarf_size_type compressed_size = *size;
10773 unsigned char * compressed_buffer = *buffer;
10774 dwarf_size_type uncompressed_size;
10775 unsigned char * uncompressed_buffer;
10776 z_stream strm;
10777 int rc;
10778 dwarf_size_type header_size = 12;
10779
10780 /* Read the zlib header. In this case, it should be "ZLIB" followed
10781 by the uncompressed section size, 8 bytes in big-endian order. */
10782 if (compressed_size < header_size
10783 || ! streq ((char *) compressed_buffer, "ZLIB"))
10784 return 0;
10785
10786 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10787 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10788 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10789 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10790 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10791 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10792 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10793 uncompressed_size += compressed_buffer[11];
10794
10795 /* It is possible the section consists of several compressed
10796 buffers concatenated together, so we uncompress in a loop. */
10797 strm.zalloc = NULL;
10798 strm.zfree = NULL;
10799 strm.opaque = NULL;
10800 strm.avail_in = compressed_size - header_size;
10801 strm.next_in = (Bytef *) compressed_buffer + header_size;
10802 strm.avail_out = uncompressed_size;
3f5e193b 10803 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10804
10805 rc = inflateInit (& strm);
10806 while (strm.avail_in > 0)
10807 {
10808 if (rc != Z_OK)
10809 goto fail;
10810 strm.next_out = ((Bytef *) uncompressed_buffer
10811 + (uncompressed_size - strm.avail_out));
10812 rc = inflate (&strm, Z_FINISH);
10813 if (rc != Z_STREAM_END)
10814 goto fail;
10815 rc = inflateReset (& strm);
10816 }
10817 rc = inflateEnd (& strm);
10818 if (rc != Z_OK
10819 || strm.avail_out != 0)
10820 goto fail;
10821
10822 free (compressed_buffer);
10823 *buffer = uncompressed_buffer;
10824 *size = uncompressed_size;
10825 return 1;
10826
10827 fail:
10828 free (uncompressed_buffer);
4a114e3e
L		 10829 /* Indicate decompression failure. */
10830 *buffer = NULL;
cf13d699
NC		 10831 return 0;
10832#endif /* HAVE_ZLIB_H */
10833}
10834
d966045b
DJ		 10835static int
10836load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10837 Elf_Internal_Shdr * sec, void * file)
1007acb3 10838{
2cf0635d 10839 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10840 char buf [64];
1007acb3 10841
19e6b90e
L		 10842 /* If it is already loaded, do nothing. */
10843 if (section->start != NULL)
10844 return 1;
1007acb3 10845
19e6b90e
L		 10846 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10847 section->address = sec->sh_addr;
3f5e193b
NC		 10848 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10849 sec->sh_offset, 1,
10850 sec->sh_size, buf);
59245841
NC		 10851 if (section->start == NULL)
10852 section->size = 0;
10853 else
10854 {
10855 section->size = sec->sh_size;
10856 if (uncompress_section_contents (&section->start, &section->size))
10857 sec->sh_size = section->size;
10858 }
4a114e3e 10859
1b315056
CS		 10860 if (section->start == NULL)
10861 return 0;
10862
19e6b90e 10863 if (debug_displays [debug].relocate)
3f5e193b 10864 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10865
1b315056 10866 return 1;
1007acb3
L		 10867}
10868
657d0d47
CC		 10869/* If this is not NULL, load_debug_section will only look for sections
10870 within the list of sections given here. */
10871unsigned int *section_subset = NULL;
10872
d966045b 10873int
2cf0635d 10874load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10875{
2cf0635d
NC		 10876 struct dwarf_section * section = &debug_displays [debug].section;
10877 Elf_Internal_Shdr * sec;
d966045b
DJ		 10878
10879 /* Locate the debug section. */
657d0d47 10880 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 10881 if (sec != NULL)
10882 section->name = section->uncompressed_name;
10883 else
10884 {
657d0d47 10885 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 10886 if (sec != NULL)
10887 section->name = section->compressed_name;
10888 }
10889 if (sec == NULL)
10890 return 0;
10891
657d0d47
CC		 10892 /* If we're loading from a subset of sections, and we've loaded
10893 a section matching this name before, it's likely that it's a
10894 different one. */
10895 if (section_subset != NULL)
10896 free_debug_section (debug);
10897
3f5e193b 10898 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10899}
10900
19e6b90e
L		 10901void
10902free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10903{
2cf0635d 10904 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10905
19e6b90e
L		 10906 if (section->start == NULL)
10907 return;
1007acb3 10908
19e6b90e
L		 10909 free ((char *) section->start);
10910 section->start = NULL;
10911 section->address = 0;
10912 section->size = 0;
1007acb3
L		 10913}
10914
1007acb3 10915static int
657d0d47 10916display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 10917{
2cf0635d 10918 char * name = SECTION_NAME (section);
19e6b90e
L		 10919 bfd_size_type length;
10920 int result = 1;
3f5e193b 10921 int i;
1007acb3 10922
19e6b90e
L		 10923 length = section->sh_size;
10924 if (length == 0)
1007acb3 10925 {
19e6b90e
L		 10926 printf (_("\nSection '%s' has no debugging data.\n"), name);
10927 return 0;
1007acb3 10928 }
5dff79d8
NC		 10929 if (section->sh_type == SHT_NOBITS)
10930 {
10931 /* There is no point in dumping the contents of a debugging section
10932 which has the NOBITS type - the bits in the file will be random.
10933 This can happen when a file containing a .eh_frame section is
10934 stripped with the --only-keep-debug command line option. */
10935 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10936 return 0;
10937 }
1007acb3 10938
0112cd26 10939 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10940 name = ".debug_info";
1007acb3 10941
19e6b90e
L		 10942 /* See if we know how to display the contents of this section. */
10943 for (i = 0; i < max; i++)
1b315056
CS		 10944 if (streq (debug_displays[i].section.uncompressed_name, name)
10945 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10946 {
2cf0635d 10947 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10948 int secondary = (section != find_section (name));
10949
10950 if (secondary)
3f5e193b 10951 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10952
2b6f5997 10953 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10954 sec->name = sec->uncompressed_name;
10955 else
10956 sec->name = sec->compressed_name;
3f5e193b
NC		 10957 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10958 section, file))
19e6b90e 10959 {
657d0d47
CC		 10960 /* If this debug section is part of a CU/TU set in a .dwp file,
10961 restrict load_debug_section to the sections in that set. */
10962 section_subset = find_cu_tu_set (file, shndx);
10963
19e6b90e 10964 result &= debug_displays[i].display (sec, file);
1007acb3 10965
657d0d47
CC		 10966 section_subset = NULL;
10967
d966045b 10968 if (secondary || (i != info && i != abbrev))
3f5e193b 10969 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10970 }
1007acb3 10971
19e6b90e
L		 10972 break;
10973 }
1007acb3 10974
19e6b90e 10975 if (i == max)
1007acb3 10976 {
19e6b90e
L		 10977 printf (_("Unrecognized debug section: %s\n"), name);
10978 result = 0;
1007acb3
L		 10979 }
10980
19e6b90e 10981 return result;
5b18a4bc 10982}
103f02d3 10983
aef1f6d0
DJ		 10984/* Set DUMP_SECTS for all sections where dumps were requested
10985 based on section name. */
10986
10987static void
10988initialise_dumps_byname (void)
10989{
2cf0635d 10990 struct dump_list_entry * cur;
aef1f6d0
DJ		 10991
10992 for (cur = dump_sects_byname; cur; cur = cur->next)
10993 {
10994 unsigned int i;
10995 int any;
10996
10997 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10998 if (streq (SECTION_NAME (section_headers + i), cur->name))
10999 {
09c11c86 11000 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11001 any = 1;
11002 }
11003
11004 if (!any)
11005 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11006 cur->name);
11007 }
11008}
11009
5b18a4bc 11010static void
2cf0635d 11011process_section_contents (FILE * file)
5b18a4bc 11012{
2cf0635d 11013 Elf_Internal_Shdr * section;
19e6b90e 11014 unsigned int i;
103f02d3 11015
19e6b90e
L		 11016 if (! do_dump)
11017 return;
103f02d3 11018
aef1f6d0
DJ		 11019 initialise_dumps_byname ();
11020
19e6b90e
L		 11021 for (i = 0, section = section_headers;
11022 i < elf_header.e_shnum && i < num_dump_sects;
11023 i++, section++)
11024 {
11025#ifdef SUPPORT_DISASSEMBLY
11026 if (dump_sects[i] & DISASS_DUMP)
11027 disassemble_section (section, file);
11028#endif
11029 if (dump_sects[i] & HEX_DUMP)
cf13d699 11030 dump_section_as_bytes (section, file, FALSE);
103f02d3 11031
cf13d699
NC		 11032 if (dump_sects[i] & RELOC_DUMP)
11033 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11034
11035 if (dump_sects[i] & STRING_DUMP)
11036 dump_section_as_strings (section, file);
cf13d699
NC		 11037
11038 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11039 display_debug_section (i, section, file);
5b18a4bc 11040 }
103f02d3 11041
19e6b90e
L		 11042 /* Check to see if the user requested a
11043 dump of a section that does not exist. */
11044 while (i++ < num_dump_sects)
11045 if (dump_sects[i])
11046 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11047}
103f02d3 11048
5b18a4bc 11049static void
19e6b90e 11050process_mips_fpe_exception (int mask)
5b18a4bc 11051{
19e6b90e
L		 11052 if (mask)
11053 {
11054 int first = 1;
11055 if (mask & OEX_FPU_INEX)
11056 fputs ("INEX", stdout), first = 0;
11057 if (mask & OEX_FPU_UFLO)
11058 printf ("%sUFLO", first ? "" : "|"), first = 0;
11059 if (mask & OEX_FPU_OFLO)
11060 printf ("%sOFLO", first ? "" : "|"), first = 0;
11061 if (mask & OEX_FPU_DIV0)
11062 printf ("%sDIV0", first ? "" : "|"), first = 0;
11063 if (mask & OEX_FPU_INVAL)
11064 printf ("%sINVAL", first ? "" : "|");
11065 }
5b18a4bc 11066 else
19e6b90e 11067 fputs ("0", stdout);
5b18a4bc 11068}
103f02d3 11069
11c1ff18
PB		 11070/* ARM EABI attributes section. */
11071typedef struct
11072{
11073 int tag;
2cf0635d 11074 const char * name;
11c1ff18
PB		 11075 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11076 int type;
2cf0635d 11077 const char ** table;
11c1ff18
PB		 11078} arm_attr_public_tag;
11079
2cf0635d 11080static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11081 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11082 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11083static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11084static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11085 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11086static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 11087 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11088 "FP for ARMv8"};
2cf0635d 11089static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11090static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11091 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11092static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11093 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11094 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11095static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11096 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11097static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11098 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11099static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11100 {"Absolute", "PC-relative", "None"};
2cf0635d 11101static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11102 {"None", "direct", "GOT-indirect"};
2cf0635d 11103static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11104 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11105static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11106static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11107 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11108static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11109static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11110static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11111 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11112static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11113 {"Unused", "small", "int", "forced to int"};
2cf0635d 11114static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11115 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11116static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11117 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11118static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11119 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11120static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11121 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11122 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11123static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 11124 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11125 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11126static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11127static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11128 {"Not Allowed", "Allowed"};
2cf0635d 11129static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11130 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11131static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 11132 {"Not Allowed", "Allowed"};
11133static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11134 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11135 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 11136static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11137static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11138 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11139 "TrustZone and Virtualization Extensions"};
dd24e3da 11140static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11141 {"Not Allowed", "Allowed"};
11c1ff18
PB		 11142
11143#define LOOKUP(id, name) \
11144 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11145static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 11146{
11147 {4, "CPU_raw_name", 1, NULL},
11148 {5, "CPU_name", 1, NULL},
11149 LOOKUP(6, CPU_arch),
11150 {7, "CPU_arch_profile", 0, NULL},
11151 LOOKUP(8, ARM_ISA_use),
11152 LOOKUP(9, THUMB_ISA_use),
75375b3e 11153 LOOKUP(10, FP_arch),
11c1ff18 11154 LOOKUP(11, WMMX_arch),
f5f53991
AS		 11155 LOOKUP(12, Advanced_SIMD_arch),
11156 LOOKUP(13, PCS_config),
11c1ff18
PB		 11157 LOOKUP(14, ABI_PCS_R9_use),
11158 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11159 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 11160 LOOKUP(17, ABI_PCS_GOT_use),
11161 LOOKUP(18, ABI_PCS_wchar_t),
11162 LOOKUP(19, ABI_FP_rounding),
11163 LOOKUP(20, ABI_FP_denormal),
11164 LOOKUP(21, ABI_FP_exceptions),
11165 LOOKUP(22, ABI_FP_user_exceptions),
11166 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 11167 {24, "ABI_align_needed", 0, NULL},
11168 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 11169 LOOKUP(26, ABI_enum_size),
11170 LOOKUP(27, ABI_HardFP_use),
11171 LOOKUP(28, ABI_VFP_args),
11172 LOOKUP(29, ABI_WMMX_args),
11173 LOOKUP(30, ABI_optimization_goals),
11174 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11175 {32, "compatibility", 0, NULL},
f5f53991 11176 LOOKUP(34, CPU_unaligned_access),
75375b3e 11177 LOOKUP(36, FP_HP_extension),
8e79c3df 11178 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 11179 LOOKUP(42, MPextension_use),
11180 LOOKUP(44, DIV_use),
f5f53991
AS		 11181 {64, "nodefaults", 0, NULL},
11182 {65, "also_compatible_with", 0, NULL},
11183 LOOKUP(66, T2EE_use),
11184 {67, "conformance", 1, NULL},
11185 LOOKUP(68, Virtualization_use),
cd21e546 11186 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 11187};
11188#undef LOOKUP
11189
11c1ff18 11190static unsigned char *
2cf0635d 11191display_arm_attribute (unsigned char * p)
11c1ff18
PB		 11192{
11193 int tag;
11194 unsigned int len;
11195 int val;
2cf0635d 11196 arm_attr_public_tag * attr;
11c1ff18
PB		 11197 unsigned i;
11198 int type;
11199
11200 tag = read_uleb128 (p, &len);
11201 p += len;
11202 attr = NULL;
2cf0635d 11203 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 11204 {
11205 if (arm_attr_public_tags[i].tag == tag)
11206 {
11207 attr = &arm_attr_public_tags[i];
11208 break;
11209 }
11210 }
11211
11212 if (attr)
11213 {
11214 printf (" Tag_%s: ", attr->name);
11215 switch (attr->type)
11216 {
11217 case 0:
11218 switch (tag)
11219 {
11220 case 7: /* Tag_CPU_arch_profile. */
11221 val = read_uleb128 (p, &len);
11222 p += len;
11223 switch (val)
11224 {
2b692964
NC		 11225 case 0: printf (_("None\n")); break;
11226 case 'A': printf (_("Application\n")); break;
11227 case 'R': printf (_("Realtime\n")); break;
11228 case 'M': printf (_("Microcontroller\n")); break;
11229 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11230 default: printf ("??? (%d)\n", val); break;
11231 }
11232 break;
11233
75375b3e
MGD		 11234 case 24: /* Tag_align_needed. */
11235 val = read_uleb128 (p, &len);
11236 p += len;
11237 switch (val)
11238 {
2b692964
NC		 11239 case 0: printf (_("None\n")); break;
11240 case 1: printf (_("8-byte\n")); break;
11241 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11242 case 3: printf ("??? 3\n"); break;
11243 default:
11244 if (val <= 12)
dd24e3da 11245 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11246 1 << val);
11247 else
11248 printf ("??? (%d)\n", val);
11249 break;
11250 }
11251 break;
11252
11253 case 25: /* Tag_align_preserved. */
11254 val = read_uleb128 (p, &len);
11255 p += len;
11256 switch (val)
11257 {
2b692964
NC		 11258 case 0: printf (_("None\n")); break;
11259 case 1: printf (_("8-byte, except leaf SP\n")); break;
11260 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11261 case 3: printf ("??? 3\n"); break;
11262 default:
11263 if (val <= 12)
dd24e3da 11264 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11265 1 << val);
11266 else
11267 printf ("??? (%d)\n", val);
11268 break;
11269 }
11270 break;
11271
11c1ff18
PB		 11272 case 32: /* Tag_compatibility. */
11273 val = read_uleb128 (p, &len);
11274 p += len;
2b692964 11275 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11276 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11277 break;
11278
f5f53991
AS		 11279 case 64: /* Tag_nodefaults. */
11280 p++;
2b692964 11281 printf (_("True\n"));
f5f53991
AS		 11282 break;
11283
11284 case 65: /* Tag_also_compatible_with. */
11285 val = read_uleb128 (p, &len);
11286 p += len;
11287 if (val == 6 /* Tag_CPU_arch. */)
11288 {
11289 val = read_uleb128 (p, &len);
11290 p += len;
2cf0635d 11291 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11292 printf ("??? (%d)\n", val);
11293 else
11294 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11295 }
11296 else
11297 printf ("???\n");
11298 while (*(p++) != '\0' /* NUL terminator. */);
11299 break;
11300
11c1ff18 11301 default:
2cf0635d 11302 abort ();
11c1ff18
PB		 11303 }
11304 return p;
11305
11306 case 1:
11307 case 2:
11308 type = attr->type;
11309 break;
11310
11311 default:
11312 assert (attr->type & 0x80);
11313 val = read_uleb128 (p, &len);
11314 p += len;
11315 type = attr->type & 0x7f;
11316 if (val >= type)
11317 printf ("??? (%d)\n", val);
11318 else
11319 printf ("%s\n", attr->table[val]);
11320 return p;
11321 }
11322 }
11323 else
11324 {
11325 if (tag & 1)
11326 type = 1; /* String. */
11327 else
11328 type = 2; /* uleb128. */
11329 printf (" Tag_unknown_%d: ", tag);
11330 }
11331
11332 if (type == 1)
11333 {
11334 printf ("\"%s\"\n", p);
2cf0635d 11335 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11336 }
11337 else
11338 {
11339 val = read_uleb128 (p, &len);
11340 p += len;
11341 printf ("%d (0x%x)\n", val, val);
11342 }
11343
11344 return p;
11345}
11346
104d59d1 11347static unsigned char *
60bca95a
NC		 11348display_gnu_attribute (unsigned char * p,
11349 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 11350{
11351 int tag;
11352 unsigned int len;
11353 int val;
11354 int type;
11355
11356 tag = read_uleb128 (p, &len);
11357 p += len;
11358
11359 /* Tag_compatibility is the only generic GNU attribute defined at
11360 present. */
11361 if (tag == 32)
11362 {
11363 val = read_uleb128 (p, &len);
11364 p += len;
2b692964 11365 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 11366 p += strlen ((char *) p) + 1;
104d59d1
JM		 11367 return p;
11368 }
11369
11370 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11371 return display_proc_gnu_attribute (p, tag);
11372
11373 if (tag & 1)
11374 type = 1; /* String. */
11375 else
11376 type = 2; /* uleb128. */
11377 printf (" Tag_unknown_%d: ", tag);
11378
11379 if (type == 1)
11380 {
11381 printf ("\"%s\"\n", p);
60bca95a 11382 p += strlen ((char *) p) + 1;
104d59d1
JM		 11383 }
11384 else
11385 {
11386 val = read_uleb128 (p, &len);
11387 p += len;
11388 printf ("%d (0x%x)\n", val, val);
11389 }
11390
11391 return p;
11392}
11393
34c8bcba 11394static unsigned char *
2cf0635d 11395display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 11396{
11397 int type;
11398 unsigned int len;
11399 int val;
11400
11401 if (tag == Tag_GNU_Power_ABI_FP)
11402 {
11403 val = read_uleb128 (p, &len);
11404 p += len;
11405 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11406
34c8bcba
JM		 11407 switch (val)
11408 {
11409 case 0:
2b692964 11410 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11411 break;
11412 case 1:
2b692964 11413 printf (_("Hard float\n"));
34c8bcba
JM		 11414 break;
11415 case 2:
2b692964 11416 printf (_("Soft float\n"));
34c8bcba 11417 break;
3c7b9897 11418 case 3:
2b692964 11419 printf (_("Single-precision hard float\n"));
3c7b9897 11420 break;
34c8bcba
JM		 11421 default:
11422 printf ("??? (%d)\n", val);
11423 break;
11424 }
11425 return p;
11426 }
11427
c6e65352
DJ		 11428 if (tag == Tag_GNU_Power_ABI_Vector)
11429 {
11430 val = read_uleb128 (p, &len);
11431 p += len;
11432 printf (" Tag_GNU_Power_ABI_Vector: ");
11433 switch (val)
11434 {
11435 case 0:
2b692964 11436 printf (_("Any\n"));
c6e65352
DJ		 11437 break;
11438 case 1:
2b692964 11439 printf (_("Generic\n"));
c6e65352
DJ		 11440 break;
11441 case 2:
11442 printf ("AltiVec\n");
11443 break;
11444 case 3:
11445 printf ("SPE\n");
11446 break;
11447 default:
11448 printf ("??? (%d)\n", val);
11449 break;
11450 }
11451 return p;
11452 }
11453
f82e0623
NF		 11454 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11455 {
11456 val = read_uleb128 (p, &len);
11457 p += len;
11458 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11459 switch (val)
11460 {
11461 case 0:
2b692964 11462 printf (_("Any\n"));
f82e0623
NF		 11463 break;
11464 case 1:
11465 printf ("r3/r4\n");
11466 break;
11467 case 2:
2b692964 11468 printf (_("Memory\n"));
f82e0623
NF		 11469 break;
11470 default:
11471 printf ("??? (%d)\n", val);
11472 break;
11473 }
11474 return p;
11475 }
11476
34c8bcba
JM		 11477 if (tag & 1)
11478 type = 1; /* String. */
11479 else
11480 type = 2; /* uleb128. */
11481 printf (" Tag_unknown_%d: ", tag);
11482
11483 if (type == 1)
11484 {
11485 printf ("\"%s\"\n", p);
60bca95a 11486 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11487 }
11488 else
11489 {
11490 val = read_uleb128 (p, &len);
11491 p += len;
11492 printf ("%d (0x%x)\n", val, val);
11493 }
11494
11495 return p;
11496}
11497
9e8c70f9
DM		 11498static void
11499display_sparc_hwcaps (int mask)
11500{
11501 if (mask)
11502 {
11503 int first = 1;
11504 if (mask & ELF_SPARC_HWCAP_MUL32)
11505 fputs ("mul32", stdout), first = 0;
11506 if (mask & ELF_SPARC_HWCAP_DIV32)
11507 printf ("%sdiv32", first ? "" : "|"), first = 0;
11508 if (mask & ELF_SPARC_HWCAP_FSMULD)
11509 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11510 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11511 printf ("%sv8plus", first ? "" : "|"), first = 0;
11512 if (mask & ELF_SPARC_HWCAP_POPC)
11513 printf ("%spopc", first ? "" : "|"), first = 0;
11514 if (mask & ELF_SPARC_HWCAP_VIS)
11515 printf ("%svis", first ? "" : "|"), first = 0;
11516 if (mask & ELF_SPARC_HWCAP_VIS2)
11517 printf ("%svis2", first ? "" : "|"), first = 0;
11518 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11519 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11520 if (mask & ELF_SPARC_HWCAP_FMAF)
11521 printf ("%sfmaf", first ? "" : "|"), first = 0;
11522 if (mask & ELF_SPARC_HWCAP_VIS3)
11523 printf ("%svis3", first ? "" : "|"), first = 0;
11524 if (mask & ELF_SPARC_HWCAP_HPC)
11525 printf ("%shpc", first ? "" : "|"), first = 0;
11526 if (mask & ELF_SPARC_HWCAP_RANDOM)
11527 printf ("%srandom", first ? "" : "|"), first = 0;
11528 if (mask & ELF_SPARC_HWCAP_TRANS)
11529 printf ("%strans", first ? "" : "|"), first = 0;
11530 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11531 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11532 if (mask & ELF_SPARC_HWCAP_IMA)
11533 printf ("%sima", first ? "" : "|"), first = 0;
11534 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11535 printf ("%scspare", first ? "" : "|"), first = 0;
11536 }
11537 else
11538 fputc('0', stdout);
11539 fputc('\n', stdout);
11540}
11541
11542static unsigned char *
11543display_sparc_gnu_attribute (unsigned char * p, int tag)
11544{
11545 int type;
11546 unsigned int len;
11547 int val;
11548
11549 if (tag == Tag_GNU_Sparc_HWCAPS)
11550 {
11551 val = read_uleb128 (p, &len);
11552 p += len;
11553 printf (" Tag_GNU_Sparc_HWCAPS: ");
11554
11555 display_sparc_hwcaps (val);
11556 return p;
11557 }
11558
11559 if (tag & 1)
11560 type = 1; /* String. */
11561 else
11562 type = 2; /* uleb128. */
11563 printf (" Tag_unknown_%d: ", tag);
11564
11565 if (type == 1)
11566 {
11567 printf ("\"%s\"\n", p);
11568 p += strlen ((char *) p) + 1;
11569 }
11570 else
11571 {
11572 val = read_uleb128 (p, &len);
11573 p += len;
11574 printf ("%d (0x%x)\n", val, val);
11575 }
11576
11577 return p;
11578}
11579
2cf19d5c 11580static unsigned char *
2cf0635d 11581display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11582{
11583 int type;
11584 unsigned int len;
11585 int val;
11586
11587 if (tag == Tag_GNU_MIPS_ABI_FP)
11588 {
11589 val = read_uleb128 (p, &len);
11590 p += len;
11591 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11592
2cf19d5c
JM		 11593 switch (val)
11594 {
11595 case 0:
2b692964 11596 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11597 break;
11598 case 1:
2b692964 11599 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11600 break;
11601 case 2:
2b692964 11602 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11603 break;
11604 case 3:
2b692964 11605 printf (_("Soft float\n"));
2cf19d5c 11606 break;
42554f6a 11607 case 4:
9eeefea8 11608 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11609 break;
2cf19d5c
JM		 11610 default:
11611 printf ("??? (%d)\n", val);
11612 break;
11613 }
11614 return p;
11615 }
11616
11617 if (tag & 1)
11618 type = 1; /* String. */
11619 else
11620 type = 2; /* uleb128. */
11621 printf (" Tag_unknown_%d: ", tag);
11622
11623 if (type == 1)
11624 {
11625 printf ("\"%s\"\n", p);
60bca95a 11626 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11627 }
11628 else
11629 {
11630 val = read_uleb128 (p, &len);
11631 p += len;
11632 printf ("%d (0x%x)\n", val, val);
11633 }
11634
11635 return p;
11636}
11637
59e6276b
JM		 11638static unsigned char *
11639display_tic6x_attribute (unsigned char * p)
11640{
11641 int tag;
11642 unsigned int len;
11643 int val;
11644
11645 tag = read_uleb128 (p, &len);
11646 p += len;
11647
11648 switch (tag)
11649 {
75fa6dc1 11650 case Tag_ISA:
59e6276b
JM		 11651 val = read_uleb128 (p, &len);
11652 p += len;
75fa6dc1 11653 printf (" Tag_ISA: ");
59e6276b
JM		 11654
11655 switch (val)
11656 {
75fa6dc1 11657 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11658 printf (_("None\n"));
11659 break;
75fa6dc1 11660 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11661 printf ("C62x\n");
11662 break;
75fa6dc1 11663 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11664 printf ("C67x\n");
11665 break;
75fa6dc1 11666 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11667 printf ("C67x+\n");
11668 break;
75fa6dc1 11669 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11670 printf ("C64x\n");
11671 break;
75fa6dc1 11672 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11673 printf ("C64x+\n");
11674 break;
75fa6dc1 11675 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11676 printf ("C674x\n");
11677 break;
11678 default:
11679 printf ("??? (%d)\n", val);
11680 break;
11681 }
11682 return p;
11683
87779176
JM		 11684 case Tag_ABI_wchar_t:
11685 val = read_uleb128 (p, &len);
11686 p += len;
11687 printf (" Tag_ABI_wchar_t: ");
11688 switch (val)
11689 {
11690 case 0:
11691 printf (_("Not used\n"));
11692 break;
11693 case 1:
11694 printf (_("2 bytes\n"));
11695 break;
11696 case 2:
11697 printf (_("4 bytes\n"));
11698 break;
11699 default:
11700 printf ("??? (%d)\n", val);
11701 break;
11702 }
11703 return p;
11704
11705 case Tag_ABI_stack_align_needed:
11706 val = read_uleb128 (p, &len);
11707 p += len;
11708 printf (" Tag_ABI_stack_align_needed: ");
11709 switch (val)
11710 {
11711 case 0:
11712 printf (_("8-byte\n"));
11713 break;
11714 case 1:
11715 printf (_("16-byte\n"));
11716 break;
11717 default:
11718 printf ("??? (%d)\n", val);
11719 break;
11720 }
11721 return p;
11722
11723 case Tag_ABI_stack_align_preserved:
11724 val = read_uleb128 (p, &len);
11725 p += len;
11726 printf (" Tag_ABI_stack_align_preserved: ");
11727 switch (val)
11728 {
11729 case 0:
11730 printf (_("8-byte\n"));
11731 break;
11732 case 1:
11733 printf (_("16-byte\n"));
11734 break;
11735 default:
11736 printf ("??? (%d)\n", val);
11737 break;
11738 }
11739 return p;
11740
b5593623
JM		 11741 case Tag_ABI_DSBT:
11742 val = read_uleb128 (p, &len);
11743 p += len;
11744 printf (" Tag_ABI_DSBT: ");
11745 switch (val)
11746 {
11747 case 0:
11748 printf (_("DSBT addressing not used\n"));
11749 break;
11750 case 1:
11751 printf (_("DSBT addressing used\n"));
11752 break;
11753 default:
11754 printf ("??? (%d)\n", val);
11755 break;
11756 }
11757 return p;
11758
87779176
JM		 11759 case Tag_ABI_PID:
11760 val = read_uleb128 (p, &len);
11761 p += len;
11762 printf (" Tag_ABI_PID: ");
11763 switch (val)
11764 {
11765 case 0:
11766 printf (_("Data addressing position-dependent\n"));
11767 break;
11768 case 1:
11769 printf (_("Data addressing position-independent, GOT near DP\n"));
11770 break;
11771 case 2:
11772 printf (_("Data addressing position-independent, GOT far from DP\n"));
11773 break;
11774 default:
11775 printf ("??? (%d)\n", val);
11776 break;
11777 }
11778 return p;
11779
11780 case Tag_ABI_PIC:
11781 val = read_uleb128 (p, &len);
11782 p += len;
11783 printf (" Tag_ABI_PIC: ");
11784 switch (val)
11785 {
11786 case 0:
11787 printf (_("Code addressing position-dependent\n"));
11788 break;
11789 case 1:
11790 printf (_("Code addressing position-independent\n"));
11791 break;
11792 default:
11793 printf ("??? (%d)\n", val);
11794 break;
11795 }
11796 return p;
11797
11798 case Tag_ABI_array_object_alignment:
11799 val = read_uleb128 (p, &len);
11800 p += len;
11801 printf (" Tag_ABI_array_object_alignment: ");
11802 switch (val)
11803 {
11804 case 0:
11805 printf (_("8-byte\n"));
11806 break;
11807 case 1:
11808 printf (_("4-byte\n"));
11809 break;
11810 case 2:
11811 printf (_("16-byte\n"));
11812 break;
11813 default:
11814 printf ("??? (%d)\n", val);
11815 break;
11816 }
11817 return p;
11818
11819 case Tag_ABI_array_object_align_expected:
11820 val = read_uleb128 (p, &len);
11821 p += len;
11822 printf (" Tag_ABI_array_object_align_expected: ");
11823 switch (val)
11824 {
11825 case 0:
11826 printf (_("8-byte\n"));
11827 break;
11828 case 1:
11829 printf (_("4-byte\n"));
11830 break;
11831 case 2:
11832 printf (_("16-byte\n"));
11833 break;
11834 default:
11835 printf ("??? (%d)\n", val);
11836 break;
11837 }
11838 return p;
11839
3cbd1c06 11840 case Tag_ABI_compatibility:
59e6276b
JM		 11841 val = read_uleb128 (p, &len);
11842 p += len;
3cbd1c06 11843 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11844 printf (_("flag = %d, vendor = %s\n"), val, p);
11845 p += strlen ((char *) p) + 1;
11846 return p;
87779176
JM		 11847
11848 case Tag_ABI_conformance:
11849 printf (" Tag_ABI_conformance: ");
11850 printf ("\"%s\"\n", p);
11851 p += strlen ((char *) p) + 1;
11852 return p;
59e6276b
JM		 11853 }
11854
11855 printf (" Tag_unknown_%d: ", tag);
11856
87779176
JM		 11857 if (tag & 1)
11858 {
11859 printf ("\"%s\"\n", p);
11860 p += strlen ((char *) p) + 1;
11861 }
11862 else
11863 {
11864 val = read_uleb128 (p, &len);
11865 p += len;
11866 printf ("%d (0x%x)\n", val, val);
11867 }
59e6276b
JM		 11868
11869 return p;
11870}
11871
11c1ff18 11872static int
60bca95a
NC		 11873process_attributes (FILE * file,
11874 const char * public_name,
104d59d1 11875 unsigned int proc_type,
60bca95a
NC		 11876 unsigned char * (* display_pub_attribute) (unsigned char *),
11877 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11878{
2cf0635d
NC		 11879 Elf_Internal_Shdr * sect;
11880 unsigned char * contents;
11881 unsigned char * p;
11882 unsigned char * end;
11c1ff18
PB		 11883 bfd_vma section_len;
11884 bfd_vma len;
11885 unsigned i;
11886
11887 /* Find the section header so that we get the size. */
11888 for (i = 0, sect = section_headers;
11889 i < elf_header.e_shnum;
11890 i++, sect++)
11891 {
104d59d1 11892 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11893 continue;
11894
3f5e193b
NC		 11895 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11896 sect->sh_size, _("attributes"));
60bca95a 11897 if (contents == NULL)
11c1ff18 11898 continue;
60bca95a 11899
11c1ff18
PB		 11900 p = contents;
11901 if (*p == 'A')
11902 {
11903 len = sect->sh_size - 1;
11904 p++;
60bca95a 11905
11c1ff18
PB		 11906 while (len > 0)
11907 {
11908 int namelen;
11909 bfd_boolean public_section;
104d59d1 11910 bfd_boolean gnu_section;
11c1ff18
PB		 11911
11912 section_len = byte_get (p, 4);
11913 p += 4;
60bca95a 11914
11c1ff18
PB		 11915 if (section_len > len)
11916 {
11917 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11918 (int) section_len, (int) len);
11c1ff18
PB		 11919 section_len = len;
11920 }
60bca95a 11921
11c1ff18 11922 len -= section_len;
2b692964 11923 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11924
11925 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11926 public_section = TRUE;
11927 else
11928 public_section = FALSE;
60bca95a
NC		 11929
11930 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11931 gnu_section = TRUE;
11932 else
11933 gnu_section = FALSE;
60bca95a
NC		 11934
11935 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11936 p += namelen;
11937 section_len -= namelen + 4;
60bca95a 11938
11c1ff18
PB		 11939 while (section_len > 0)
11940 {
11941 int tag = *(p++);
11942 int val;
11943 bfd_vma size;
60bca95a 11944
11c1ff18
PB		 11945 size = byte_get (p, 4);
11946 if (size > section_len)
11947 {
11948 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11949 (int) size, (int) section_len);
11c1ff18
PB		 11950 size = section_len;
11951 }
60bca95a 11952
11c1ff18
PB		 11953 section_len -= size;
11954 end = p + size - 1;
11955 p += 4;
60bca95a 11956
11c1ff18
PB		 11957 switch (tag)
11958 {
11959 case 1:
2b692964 11960 printf (_("File Attributes\n"));
11c1ff18
PB		 11961 break;
11962 case 2:
2b692964 11963 printf (_("Section Attributes:"));
11c1ff18
PB		 11964 goto do_numlist;
11965 case 3:
2b692964 11966 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11967 do_numlist:
11968 for (;;)
11969 {
91d6fa6a 11970 unsigned int j;
60bca95a 11971
91d6fa6a
NC		 11972 val = read_uleb128 (p, &j);
11973 p += j;
11c1ff18
PB		 11974 if (val == 0)
11975 break;
11976 printf (" %d", val);
11977 }
11978 printf ("\n");
11979 break;
11980 default:
2b692964 11981 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11982 public_section = FALSE;
11983 break;
11984 }
60bca95a 11985
11c1ff18
PB		 11986 if (public_section)
11987 {
11988 while (p < end)
104d59d1
JM		 11989 p = display_pub_attribute (p);
11990 }
11991 else if (gnu_section)
11992 {
11993 while (p < end)
11994 p = display_gnu_attribute (p,
11995 display_proc_gnu_attribute);
11c1ff18
PB		 11996 }
11997 else
11998 {
11999 /* ??? Do something sensible, like dump hex. */
2b692964 12000 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 12001 p = end;
12002 }
12003 }
12004 }
12005 }
12006 else
60bca95a 12007 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 12008
60bca95a 12009 free (contents);
11c1ff18
PB		 12010 }
12011 return 1;
12012}
12013
104d59d1 12014static int
2cf0635d 12015process_arm_specific (FILE * file)
104d59d1
JM		 12016{
12017 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12018 display_arm_attribute, NULL);
12019}
12020
34c8bcba 12021static int
2cf0635d 12022process_power_specific (FILE * file)
34c8bcba
JM		 12023{
12024 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12025 display_power_gnu_attribute);
12026}
12027
9e8c70f9
DM		 12028static int
12029process_sparc_specific (FILE * file)
12030{
12031 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12032 display_sparc_gnu_attribute);
12033}
12034
59e6276b
JM		 12035static int
12036process_tic6x_specific (FILE * file)
12037{
12038 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12039 display_tic6x_attribute, NULL);
12040}
12041
ccb4c951
RS		 12042/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12043 Print the Address, Access and Initial fields of an entry at VMA ADDR
12044 and return the VMA of the next entry. */
12045
12046static bfd_vma
2cf0635d 12047print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 12048{
12049 printf (" ");
12050 print_vma (addr, LONG_HEX);
12051 printf (" ");
12052 if (addr < pltgot + 0xfff0)
12053 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12054 else
12055 printf ("%10s", "");
12056 printf (" ");
12057 if (data == NULL)
2b692964 12058 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 12059 else
12060 {
12061 bfd_vma entry;
12062
12063 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12064 print_vma (entry, LONG_HEX);
12065 }
12066 return addr + (is_32bit_elf ? 4 : 8);
12067}
12068
861fb55a
DJ		 12069/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12070 PLTGOT. Print the Address and Initial fields of an entry at VMA
12071 ADDR and return the VMA of the next entry. */
12072
12073static bfd_vma
2cf0635d 12074print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 12075{
12076 printf (" ");
12077 print_vma (addr, LONG_HEX);
12078 printf (" ");
12079 if (data == NULL)
2b692964 12080 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 12081 else
12082 {
12083 bfd_vma entry;
12084
12085 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12086 print_vma (entry, LONG_HEX);
12087 }
12088 return addr + (is_32bit_elf ? 4 : 8);
12089}
12090
19e6b90e 12091static int
2cf0635d 12092process_mips_specific (FILE * file)
5b18a4bc 12093{
2cf0635d 12094 Elf_Internal_Dyn * entry;
19e6b90e
L		 12095 size_t liblist_offset = 0;
12096 size_t liblistno = 0;
12097 size_t conflictsno = 0;
12098 size_t options_offset = 0;
12099 size_t conflicts_offset = 0;
861fb55a
DJ		 12100 size_t pltrelsz = 0;
12101 size_t pltrel = 0;
ccb4c951 12102 bfd_vma pltgot = 0;
861fb55a
DJ		 12103 bfd_vma mips_pltgot = 0;
12104 bfd_vma jmprel = 0;
ccb4c951
RS		 12105 bfd_vma local_gotno = 0;
12106 bfd_vma gotsym = 0;
12107 bfd_vma symtabno = 0;
103f02d3 12108
2cf19d5c
JM		 12109 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12110 display_mips_gnu_attribute);
12111
19e6b90e
L		 12112 /* We have a lot of special sections. Thanks SGI! */
12113 if (dynamic_section == NULL)
12114 /* No information available. */
12115 return 0;
252b5132 12116
b2d38a17 12117 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 12118 switch (entry->d_tag)
12119 {
12120 case DT_MIPS_LIBLIST:
d93f0186
NC		 12121 liblist_offset
12122 = offset_from_vma (file, entry->d_un.d_val,
12123 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 12124 break;
12125 case DT_MIPS_LIBLISTNO:
12126 liblistno = entry->d_un.d_val;
12127 break;
12128 case DT_MIPS_OPTIONS:
d93f0186 12129 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 12130 break;
12131 case DT_MIPS_CONFLICT:
d93f0186
NC		 12132 conflicts_offset
12133 = offset_from_vma (file, entry->d_un.d_val,
12134 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 12135 break;
12136 case DT_MIPS_CONFLICTNO:
12137 conflictsno = entry->d_un.d_val;
12138 break;
ccb4c951 12139 case DT_PLTGOT:
861fb55a
DJ		 12140 pltgot = entry->d_un.d_ptr;
12141 break;
ccb4c951
RS		 12142 case DT_MIPS_LOCAL_GOTNO:
12143 local_gotno = entry->d_un.d_val;
12144 break;
12145 case DT_MIPS_GOTSYM:
12146 gotsym = entry->d_un.d_val;
12147 break;
12148 case DT_MIPS_SYMTABNO:
12149 symtabno = entry->d_un.d_val;
12150 break;
861fb55a
DJ		 12151 case DT_MIPS_PLTGOT:
12152 mips_pltgot = entry->d_un.d_ptr;
12153 break;
12154 case DT_PLTREL:
12155 pltrel = entry->d_un.d_val;
12156 break;
12157 case DT_PLTRELSZ:
12158 pltrelsz = entry->d_un.d_val;
12159 break;
12160 case DT_JMPREL:
12161 jmprel = entry->d_un.d_ptr;
12162 break;
252b5132
RH		 12163 default:
12164 break;
12165 }
12166
12167 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12168 {
2cf0635d 12169 Elf32_External_Lib * elib;
252b5132
RH		 12170 size_t cnt;
12171
3f5e193b
NC		 12172 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12173 liblistno,
12174 sizeof (Elf32_External_Lib),
9cf03b7e 12175 _("liblist section data"));
a6e9f9df 12176 if (elib)
252b5132 12177 {
2b692964 12178 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 12179 (unsigned long) liblistno);
2b692964 12180 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 12181 stdout);
12182
12183 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 12184 {
a6e9f9df 12185 Elf32_Lib liblist;
91d6fa6a 12186 time_t atime;
a6e9f9df 12187 char timebuf[20];
2cf0635d 12188 struct tm * tmp;
a6e9f9df
AM		 12189
12190 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12191 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 12192 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12193 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12194 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12195
91d6fa6a 12196 tmp = gmtime (&atime);
e9e44622
JJ		 12197 snprintf (timebuf, sizeof (timebuf),
12198 "%04u-%02u-%02uT%02u:%02u:%02u",
12199 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12200 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 12201
31104126 12202 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 12203 if (VALID_DYNAMIC_NAME (liblist.l_name))
12204 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12205 else
2b692964 12206 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 12207 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12208 liblist.l_version);
a6e9f9df
AM		 12209
12210 if (liblist.l_flags == 0)
2b692964 12211 puts (_(" NONE"));
a6e9f9df
AM		 12212 else
12213 {
12214 static const struct
252b5132 12215 {
2cf0635d 12216 const char * name;
a6e9f9df 12217 int bit;
252b5132 12218 }
a6e9f9df
AM		 12219 l_flags_vals[] =
12220 {
12221 { " EXACT_MATCH", LL_EXACT_MATCH },
12222 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12223 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12224 { " EXPORTS", LL_EXPORTS },
12225 { " DELAY_LOAD", LL_DELAY_LOAD },
12226 { " DELTA", LL_DELTA }
12227 };
12228 int flags = liblist.l_flags;
12229 size_t fcnt;
12230
60bca95a 12231 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12232 if ((flags & l_flags_vals[fcnt].bit) != 0)
12233 {
12234 fputs (l_flags_vals[fcnt].name, stdout);
12235 flags ^= l_flags_vals[fcnt].bit;
12236 }
12237 if (flags != 0)
12238 printf (" %#x", (unsigned int) flags);
252b5132 12239
a6e9f9df
AM		 12240 puts ("");
12241 }
252b5132 12242 }
252b5132 12243
a6e9f9df
AM		 12244 free (elib);
12245 }
252b5132
RH		 12246 }
12247
12248 if (options_offset != 0)
12249 {
2cf0635d
NC		 12250 Elf_External_Options * eopt;
12251 Elf_Internal_Shdr * sect = section_headers;
12252 Elf_Internal_Options * iopt;
12253 Elf_Internal_Options * option;
252b5132
RH		 12254 size_t offset;
12255 int cnt;
12256
12257 /* Find the section header so that we get the size. */
12258 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12259 ++sect;
252b5132 12260
3f5e193b
NC		 12261 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12262 sect->sh_size, _("options"));
a6e9f9df 12263 if (eopt)
252b5132 12264 {
3f5e193b
NC		 12265 iopt = (Elf_Internal_Options *)
12266 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 12267 if (iopt == NULL)
12268 {
591a748a 12269 error (_("Out of memory\n"));
a6e9f9df
AM		 12270 return 0;
12271 }
76da6bbe 12272
a6e9f9df
AM		 12273 offset = cnt = 0;
12274 option = iopt;
252b5132 12275
a6e9f9df
AM		 12276 while (offset < sect->sh_size)
12277 {
2cf0635d 12278 Elf_External_Options * eoption;
252b5132 12279
a6e9f9df 12280 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12281
a6e9f9df
AM		 12282 option->kind = BYTE_GET (eoption->kind);
12283 option->size = BYTE_GET (eoption->size);
12284 option->section = BYTE_GET (eoption->section);
12285 option->info = BYTE_GET (eoption->info);
76da6bbe 12286
a6e9f9df 12287 offset += option->size;
252b5132 12288
a6e9f9df
AM		 12289 ++option;
12290 ++cnt;
12291 }
252b5132 12292
a6e9f9df
AM		 12293 printf (_("\nSection '%s' contains %d entries:\n"),
12294 SECTION_NAME (sect), cnt);
76da6bbe 12295
a6e9f9df 12296 option = iopt;
252b5132 12297
a6e9f9df 12298 while (cnt-- > 0)
252b5132 12299 {
a6e9f9df
AM		 12300 size_t len;
12301
12302 switch (option->kind)
252b5132 12303 {
a6e9f9df
AM		 12304 case ODK_NULL:
12305 /* This shouldn't happen. */
12306 printf (" NULL %d %lx", option->section, option->info);
12307 break;
12308 case ODK_REGINFO:
12309 printf (" REGINFO ");
12310 if (elf_header.e_machine == EM_MIPS)
12311 {
12312 /* 32bit form. */
2cf0635d 12313 Elf32_External_RegInfo * ereg;
b34976b6 12314 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12315
12316 ereg = (Elf32_External_RegInfo *) (option + 1);
12317 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12318 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12319 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12320 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12321 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12322 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12323
12324 printf ("GPR %08lx GP 0x%lx\n",
12325 reginfo.ri_gprmask,
12326 (unsigned long) reginfo.ri_gp_value);
12327 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12328 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12329 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12330 }
12331 else
12332 {
12333 /* 64 bit form. */
2cf0635d 12334 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12335 Elf64_Internal_RegInfo reginfo;
12336
12337 ereg = (Elf64_External_RegInfo *) (option + 1);
12338 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12339 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12340 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12341 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12342 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12343 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12344
12345 printf ("GPR %08lx GP 0x",
12346 reginfo.ri_gprmask);
12347 printf_vma (reginfo.ri_gp_value);
12348 printf ("\n");
12349
12350 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12351 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12352 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12353 }
12354 ++option;
12355 continue;
12356 case ODK_EXCEPTIONS:
12357 fputs (" EXCEPTIONS fpe_min(", stdout);
12358 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12359 fputs (") fpe_max(", stdout);
12360 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12361 fputs (")", stdout);
12362
12363 if (option->info & OEX_PAGE0)
12364 fputs (" PAGE0", stdout);
12365 if (option->info & OEX_SMM)
12366 fputs (" SMM", stdout);
12367 if (option->info & OEX_FPDBUG)
12368 fputs (" FPDBUG", stdout);
12369 if (option->info & OEX_DISMISS)
12370 fputs (" DISMISS", stdout);
12371 break;
12372 case ODK_PAD:
12373 fputs (" PAD ", stdout);
12374 if (option->info & OPAD_PREFIX)
12375 fputs (" PREFIX", stdout);
12376 if (option->info & OPAD_POSTFIX)
12377 fputs (" POSTFIX", stdout);
12378 if (option->info & OPAD_SYMBOL)
12379 fputs (" SYMBOL", stdout);
12380 break;
12381 case ODK_HWPATCH:
12382 fputs (" HWPATCH ", stdout);
12383 if (option->info & OHW_R4KEOP)
12384 fputs (" R4KEOP", stdout);
12385 if (option->info & OHW_R8KPFETCH)
12386 fputs (" R8KPFETCH", stdout);
12387 if (option->info & OHW_R5KEOP)
12388 fputs (" R5KEOP", stdout);
12389 if (option->info & OHW_R5KCVTL)
12390 fputs (" R5KCVTL", stdout);
12391 break;
12392 case ODK_FILL:
12393 fputs (" FILL ", stdout);
12394 /* XXX Print content of info word? */
12395 break;
12396 case ODK_TAGS:
12397 fputs (" TAGS ", stdout);
12398 /* XXX Print content of info word? */
12399 break;
12400 case ODK_HWAND:
12401 fputs (" HWAND ", stdout);
12402 if (option->info & OHWA0_R4KEOP_CHECKED)
12403 fputs (" R4KEOP_CHECKED", stdout);
12404 if (option->info & OHWA0_R4KEOP_CLEAN)
12405 fputs (" R4KEOP_CLEAN", stdout);
12406 break;
12407 case ODK_HWOR:
12408 fputs (" HWOR ", stdout);
12409 if (option->info & OHWA0_R4KEOP_CHECKED)
12410 fputs (" R4KEOP_CHECKED", stdout);
12411 if (option->info & OHWA0_R4KEOP_CLEAN)
12412 fputs (" R4KEOP_CLEAN", stdout);
12413 break;
12414 case ODK_GP_GROUP:
12415 printf (" GP_GROUP %#06lx self-contained %#06lx",
12416 option->info & OGP_GROUP,
12417 (option->info & OGP_SELF) >> 16);
12418 break;
12419 case ODK_IDENT:
12420 printf (" IDENT %#06lx self-contained %#06lx",
12421 option->info & OGP_GROUP,
12422 (option->info & OGP_SELF) >> 16);
12423 break;
12424 default:
12425 /* This shouldn't happen. */
12426 printf (" %3d ??? %d %lx",
12427 option->kind, option->section, option->info);
12428 break;
252b5132 12429 }
a6e9f9df 12430
2cf0635d 12431 len = sizeof (* eopt);
a6e9f9df
AM		 12432 while (len < option->size)
12433 if (((char *) option)[len] >= ' '
12434 && ((char *) option)[len] < 0x7f)
12435 printf ("%c", ((char *) option)[len++]);
12436 else
12437 printf ("\\%03o", ((char *) option)[len++]);
12438
12439 fputs ("\n", stdout);
252b5132 12440 ++option;
252b5132
RH		 12441 }
12442
a6e9f9df 12443 free (eopt);
252b5132 12444 }
252b5132
RH		 12445 }
12446
12447 if (conflicts_offset != 0 && conflictsno != 0)
12448 {
2cf0635d 12449 Elf32_Conflict * iconf;
252b5132
RH		 12450 size_t cnt;
12451
12452 if (dynamic_symbols == NULL)
12453 {
591a748a 12454 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12455 return 0;
12456 }
12457
3f5e193b 12458 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12459 if (iconf == NULL)
12460 {
591a748a 12461 error (_("Out of memory\n"));
252b5132
RH		 12462 return 0;
12463 }
12464
9ea033b2 12465 if (is_32bit_elf)
252b5132 12466 {
2cf0635d 12467 Elf32_External_Conflict * econf32;
a6e9f9df 12468
3f5e193b
NC		 12469 econf32 = (Elf32_External_Conflict *)
12470 get_data (NULL, file, conflicts_offset, conflictsno,
12471 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12472 if (!econf32)
12473 return 0;
252b5132
RH		 12474
12475 for (cnt = 0; cnt < conflictsno; ++cnt)
12476 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12477
12478 free (econf32);
252b5132
RH		 12479 }
12480 else
12481 {
2cf0635d 12482 Elf64_External_Conflict * econf64;
a6e9f9df 12483
3f5e193b
NC		 12484 econf64 = (Elf64_External_Conflict *)
12485 get_data (NULL, file, conflicts_offset, conflictsno,
12486 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12487 if (!econf64)
12488 return 0;
252b5132
RH		 12489
12490 for (cnt = 0; cnt < conflictsno; ++cnt)
12491 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12492
12493 free (econf64);
252b5132
RH		 12494 }
12495
c7e7ca54
NC		 12496 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12497 (unsigned long) conflictsno);
252b5132
RH		 12498 puts (_(" Num: Index Value Name"));
12499
12500 for (cnt = 0; cnt < conflictsno; ++cnt)
12501 {
2cf0635d 12502 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12503
b34976b6 12504 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12505 print_vma (psym->st_value, FULL_HEX);
31104126 12506 putchar (' ');
d79b3d50
NC		 12507 if (VALID_DYNAMIC_NAME (psym->st_name))
12508 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12509 else
2b692964 12510 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12511 putchar ('\n');
252b5132
RH		 12512 }
12513
252b5132
RH		 12514 free (iconf);
12515 }
12516
ccb4c951
RS		 12517 if (pltgot != 0 && local_gotno != 0)
12518 {
91d6fa6a 12519 bfd_vma ent, local_end, global_end;
bbeee7ea 12520 size_t i, offset;
2cf0635d 12521 unsigned char * data;
bbeee7ea 12522 int addr_size;
ccb4c951 12523
91d6fa6a 12524 ent = pltgot;
ccb4c951
RS		 12525 addr_size = (is_32bit_elf ? 4 : 8);
12526 local_end = pltgot + local_gotno * addr_size;
12527 global_end = local_end + (symtabno - gotsym) * addr_size;
12528
12529 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12530 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 12531 global_end - pltgot, 1,
12532 _("Global Offset Table data"));
59245841
NC		 12533 if (data == NULL)
12534 return 0;
12535
ccb4c951
RS		 12536 printf (_("\nPrimary GOT:\n"));
12537 printf (_(" Canonical gp value: "));
12538 print_vma (pltgot + 0x7ff0, LONG_HEX);
12539 printf ("\n\n");
12540
12541 printf (_(" Reserved entries:\n"));
12542 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12543 addr_size * 2, _("Address"), _("Access"),
12544 addr_size * 2, _("Initial"));
91d6fa6a 12545 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12546 printf (_(" Lazy resolver\n"));
ccb4c951 12547 if (data
91d6fa6a 12548 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12549 >> (addr_size * 8 - 1)) != 0)
12550 {
91d6fa6a 12551 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12552 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12553 }
12554 printf ("\n");
12555
91d6fa6a 12556 if (ent < local_end)
ccb4c951
RS		 12557 {
12558 printf (_(" Local entries:\n"));
cc5914eb 12559 printf (" %*s %10s %*s\n",
2b692964
NC		 12560 addr_size * 2, _("Address"), _("Access"),
12561 addr_size * 2, _("Initial"));
91d6fa6a 12562 while (ent < local_end)
ccb4c951 12563 {
91d6fa6a 12564 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12565 printf ("\n");
12566 }
12567 printf ("\n");
12568 }
12569
12570 if (gotsym < symtabno)
12571 {
12572 int sym_width;
12573
12574 printf (_(" Global entries:\n"));
cc5914eb 12575 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 12576 addr_size * 2, _("Address"),
12577 _("Access"),
2b692964 12578 addr_size * 2, _("Initial"),
9cf03b7e
NC		 12579 addr_size * 2, _("Sym.Val."),
12580 _("Type"),
12581 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12582 _("Ndx"), _("Name"));
12583
ccb4c951
RS		 12584 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12585 for (i = gotsym; i < symtabno; i++)
12586 {
2cf0635d 12587 Elf_Internal_Sym * psym;
ccb4c951
RS		 12588
12589 psym = dynamic_symbols + i;
91d6fa6a 12590 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12591 printf (" ");
12592 print_vma (psym->st_value, LONG_HEX);
12593 printf (" %-7s %3s ",
12594 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12595 get_symbol_index_type (psym->st_shndx));
12596 if (VALID_DYNAMIC_NAME (psym->st_name))
12597 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12598 else
2b692964 12599 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12600 printf ("\n");
12601 }
12602 printf ("\n");
12603 }
12604
12605 if (data)
12606 free (data);
12607 }
12608
861fb55a
DJ		 12609 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12610 {
91d6fa6a 12611 bfd_vma ent, end;
861fb55a
DJ		 12612 size_t offset, rel_offset;
12613 unsigned long count, i;
2cf0635d 12614 unsigned char * data;
861fb55a 12615 int addr_size, sym_width;
2cf0635d 12616 Elf_Internal_Rela * rels;
861fb55a
DJ		 12617
12618 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12619 if (pltrel == DT_RELA)
12620 {
12621 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12622 return 0;
12623 }
12624 else
12625 {
12626 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12627 return 0;
12628 }
12629
91d6fa6a 12630 ent = mips_pltgot;
861fb55a
DJ		 12631 addr_size = (is_32bit_elf ? 4 : 8);
12632 end = mips_pltgot + (2 + count) * addr_size;
12633
12634 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12635 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12636 1, _("Procedure Linkage Table data"));
59245841
NC		 12637 if (data == NULL)
12638 return 0;
12639
9cf03b7e 12640 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 12641 printf (_(" Reserved entries:\n"));
12642 printf (_(" %*s %*s Purpose\n"),
2b692964 12643 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12644 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12645 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12646 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12647 printf (_(" Module pointer\n"));
861fb55a
DJ		 12648 printf ("\n");
12649
12650 printf (_(" Entries:\n"));
cc5914eb 12651 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12652 addr_size * 2, _("Address"),
12653 addr_size * 2, _("Initial"),
12654 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12655 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12656 for (i = 0; i < count; i++)
12657 {
2cf0635d 12658 Elf_Internal_Sym * psym;
861fb55a
DJ		 12659
12660 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12661 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12662 printf (" ");
12663 print_vma (psym->st_value, LONG_HEX);
12664 printf (" %-7s %3s ",
12665 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12666 get_symbol_index_type (psym->st_shndx));
12667 if (VALID_DYNAMIC_NAME (psym->st_name))
12668 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12669 else
2b692964 12670 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12671 printf ("\n");
12672 }
12673 printf ("\n");
12674
12675 if (data)
12676 free (data);
12677 free (rels);
12678 }
12679
252b5132
RH		 12680 return 1;
12681}
12682
047b2264 12683static int
2cf0635d 12684process_gnu_liblist (FILE * file)
047b2264 12685{
2cf0635d
NC		 12686 Elf_Internal_Shdr * section;
12687 Elf_Internal_Shdr * string_sec;
12688 Elf32_External_Lib * elib;
12689 char * strtab;
c256ffe7 12690 size_t strtab_size;
047b2264
JJ		 12691 size_t cnt;
12692 unsigned i;
12693
12694 if (! do_arch)
12695 return 0;
12696
12697 for (i = 0, section = section_headers;
12698 i < elf_header.e_shnum;
b34976b6 12699 i++, section++)
047b2264
JJ		 12700 {
12701 switch (section->sh_type)
12702 {
12703 case SHT_GNU_LIBLIST:
4fbb74a6 12704 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12705 break;
12706
3f5e193b
NC		 12707 elib = (Elf32_External_Lib *)
12708 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 12709 _("liblist section data"));
047b2264
JJ		 12710
12711 if (elib == NULL)
12712 break;
4fbb74a6 12713 string_sec = section_headers + section->sh_link;
047b2264 12714
3f5e193b
NC		 12715 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12716 string_sec->sh_size,
12717 _("liblist string table"));
047b2264
JJ		 12718 if (strtab == NULL
12719 || section->sh_entsize != sizeof (Elf32_External_Lib))
12720 {
12721 free (elib);
2842702f 12722 free (strtab);
047b2264
JJ		 12723 break;
12724 }
59245841 12725 strtab_size = string_sec->sh_size;
047b2264
JJ		 12726
12727 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12728 SECTION_NAME (section),
0af1713e 12729 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12730
2b692964 12731 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12732
12733 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12734 ++cnt)
12735 {
12736 Elf32_Lib liblist;
91d6fa6a 12737 time_t atime;
047b2264 12738 char timebuf[20];
2cf0635d 12739 struct tm * tmp;
047b2264
JJ		 12740
12741 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12742 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12743 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12744 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12745 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12746
91d6fa6a 12747 tmp = gmtime (&atime);
e9e44622
JJ		 12748 snprintf (timebuf, sizeof (timebuf),
12749 "%04u-%02u-%02uT%02u:%02u:%02u",
12750 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12751 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12752
12753 printf ("%3lu: ", (unsigned long) cnt);
12754 if (do_wide)
c256ffe7 12755 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12756 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12757 else
c256ffe7 12758 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12759 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12760 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12761 liblist.l_version, liblist.l_flags);
12762 }
12763
12764 free (elib);
2842702f 12765 free (strtab);
047b2264
JJ		 12766 }
12767 }
12768
12769 return 1;
12770}
12771
9437c45b 12772static const char *
d3ba0551 12773get_note_type (unsigned e_type)
779fe533
NC		 12774{
12775 static char buff[64];
103f02d3 12776
1ec5cd37
NC		 12777 if (elf_header.e_type == ET_CORE)
12778 switch (e_type)
12779 {
57346661 12780 case NT_AUXV:
1ec5cd37 12781 return _("NT_AUXV (auxiliary vector)");
57346661 12782 case NT_PRSTATUS:
1ec5cd37 12783 return _("NT_PRSTATUS (prstatus structure)");
57346661 12784 case NT_FPREGSET:
1ec5cd37 12785 return _("NT_FPREGSET (floating point registers)");
57346661 12786 case NT_PRPSINFO:
1ec5cd37 12787 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12788 case NT_TASKSTRUCT:
1ec5cd37 12789 return _("NT_TASKSTRUCT (task structure)");
57346661 12790 case NT_PRXFPREG:
1ec5cd37 12791 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12792 case NT_PPC_VMX:
12793 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12794 case NT_PPC_VSX:
12795 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 12796 case NT_386_TLS:
12797 return _("NT_386_TLS (x86 TLS information)");
12798 case NT_386_IOPERM:
12799 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 12800 case NT_X86_XSTATE:
12801 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12802 case NT_S390_HIGH_GPRS:
12803 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12804 case NT_S390_TIMER:
12805 return _("NT_S390_TIMER (s390 timer register)");
12806 case NT_S390_TODCMP:
12807 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12808 case NT_S390_TODPREG:
12809 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12810 case NT_S390_CTRS:
12811 return _("NT_S390_CTRS (s390 control registers)");
12812 case NT_S390_PREFIX:
12813 return _("NT_S390_PREFIX (s390 prefix register)");
faa9a424
UW		 12814 case NT_ARM_VFP:
12815 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 12816 case NT_ARM_TLS:
12817 return _("NT_ARM_TLS (AArch TLS registers)");
12818 case NT_ARM_HW_BREAK:
12819 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12820 case NT_ARM_HW_WATCH:
12821 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 12822 case NT_PSTATUS:
1ec5cd37 12823 return _("NT_PSTATUS (pstatus structure)");
57346661 12824 case NT_FPREGS:
1ec5cd37 12825 return _("NT_FPREGS (floating point registers)");
57346661 12826 case NT_PSINFO:
1ec5cd37 12827 return _("NT_PSINFO (psinfo structure)");
57346661 12828 case NT_LWPSTATUS:
1ec5cd37 12829 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12830 case NT_LWPSINFO:
1ec5cd37 12831 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12832 case NT_WIN32PSTATUS:
1ec5cd37 12833 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 12834 case NT_SIGINFO:
12835 return _("NT_SIGINFO (siginfo_t data)");
12836 case NT_FILE:
12837 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 12838 default:
12839 break;
12840 }
12841 else
12842 switch (e_type)
12843 {
12844 case NT_VERSION:
12845 return _("NT_VERSION (version)");
12846 case NT_ARCH:
12847 return _("NT_ARCH (architecture)");
12848 default:
12849 break;
12850 }
12851
e9e44622 12852 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12853 return buff;
779fe533
NC		 12854}
12855
9ece1fa9
TT		 12856static int
12857print_core_note (Elf_Internal_Note *pnote)
12858{
12859 unsigned int addr_size = is_32bit_elf ? 4 : 8;
12860 bfd_vma count, page_size;
12861 unsigned char *descdata, *filenames, *descend;
12862
12863 if (pnote->type != NT_FILE)
12864 return 1;
12865
12866#ifndef BFD64
12867 if (!is_32bit_elf)
12868 {
12869 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12870 /* Still "successful". */
12871 return 1;
12872 }
12873#endif
12874
12875 if (pnote->descsz < 2 * addr_size)
12876 {
12877 printf (_(" Malformed note - too short for header\n"));
12878 return 0;
12879 }
12880
12881 descdata = (unsigned char *) pnote->descdata;
12882 descend = descdata + pnote->descsz;
12883
12884 if (descdata[pnote->descsz - 1] != '\0')
12885 {
12886 printf (_(" Malformed note - does not end with \\0\n"));
12887 return 0;
12888 }
12889
12890 count = byte_get (descdata, addr_size);
12891 descdata += addr_size;
12892
12893 page_size = byte_get (descdata, addr_size);
12894 descdata += addr_size;
12895
12896 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12897 {
12898 printf (_(" Malformed note - too short for supplied file count\n"));
12899 return 0;
12900 }
12901
12902 printf (_(" Page size: "));
12903 print_vma (page_size, DEC);
12904 printf ("\n");
12905
12906 printf (_(" %*s%*s%*s\n"),
12907 (int) (2 + 2 * addr_size), _("Start"),
12908 (int) (4 + 2 * addr_size), _("End"),
12909 (int) (4 + 2 * addr_size), _("Page Offset"));
12910 filenames = descdata + count * 3 * addr_size;
12911 while (--count > 0)
12912 {
12913 bfd_vma start, end, file_ofs;
12914
12915 if (filenames == descend)
12916 {
12917 printf (_(" Malformed note - filenames end too early\n"));
12918 return 0;
12919 }
12920
12921 start = byte_get (descdata, addr_size);
12922 descdata += addr_size;
12923 end = byte_get (descdata, addr_size);
12924 descdata += addr_size;
12925 file_ofs = byte_get (descdata, addr_size);
12926 descdata += addr_size;
12927
12928 printf (" ");
12929 print_vma (start, FULL_HEX);
12930 printf (" ");
12931 print_vma (end, FULL_HEX);
12932 printf (" ");
12933 print_vma (file_ofs, FULL_HEX);
12934 printf ("\n %s\n", filenames);
12935
12936 filenames += 1 + strlen ((char *) filenames);
12937 }
12938
12939 return 1;
12940}
12941
1118d252
RM		 12942static const char *
12943get_gnu_elf_note_type (unsigned e_type)
12944{
12945 static char buff[64];
12946
12947 switch (e_type)
12948 {
12949 case NT_GNU_ABI_TAG:
12950 return _("NT_GNU_ABI_TAG (ABI version tag)");
12951 case NT_GNU_HWCAP:
12952 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12953 case NT_GNU_BUILD_ID:
12954 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12955 case NT_GNU_GOLD_VERSION:
12956 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12957 default:
12958 break;
12959 }
12960
12961 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12962 return buff;
12963}
12964
664f90a3
TT		 12965static int
12966print_gnu_note (Elf_Internal_Note *pnote)
12967{
12968 switch (pnote->type)
12969 {
12970 case NT_GNU_BUILD_ID:
12971 {
12972 unsigned long i;
12973
12974 printf (_(" Build ID: "));
12975 for (i = 0; i < pnote->descsz; ++i)
12976 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 12977 printf ("\n");
664f90a3
TT		 12978 }
12979 break;
12980
12981 case NT_GNU_ABI_TAG:
12982 {
12983 unsigned long os, major, minor, subminor;
12984 const char *osname;
12985
12986 os = byte_get ((unsigned char *) pnote->descdata, 4);
12987 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12988 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12989 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12990
12991 switch (os)
12992 {
12993 case GNU_ABI_TAG_LINUX:
12994 osname = "Linux";
12995 break;
12996 case GNU_ABI_TAG_HURD:
12997 osname = "Hurd";
12998 break;
12999 case GNU_ABI_TAG_SOLARIS:
13000 osname = "Solaris";
13001 break;
13002 case GNU_ABI_TAG_FREEBSD:
13003 osname = "FreeBSD";
13004 break;
13005 case GNU_ABI_TAG_NETBSD:
13006 osname = "NetBSD";
13007 break;
13008 default:
13009 osname = "Unknown";
13010 break;
13011 }
13012
13013 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13014 major, minor, subminor);
13015 }
13016 break;
13017 }
13018
13019 return 1;
13020}
13021
9437c45b 13022static const char *
d3ba0551 13023get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 13024{
13025 static char buff[64];
13026
b4db1224 13027 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 13028 {
13029 /* NetBSD core "procinfo" structure. */
13030 return _("NetBSD procinfo structure");
13031 }
13032
13033 /* As of Jan 2002 there are no other machine-independent notes
13034 defined for NetBSD core files. If the note type is less
13035 than the start of the machine-dependent note types, we don't
13036 understand it. */
13037
b4db1224 13038 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 13039 {
e9e44622 13040 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 13041 return buff;
13042 }
13043
13044 switch (elf_header.e_machine)
13045 {
13046 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13047 and PT_GETFPREGS == mach+2. */
13048
13049 case EM_OLD_ALPHA:
13050 case EM_ALPHA:
13051 case EM_SPARC:
13052 case EM_SPARC32PLUS:
13053 case EM_SPARCV9:
13054 switch (e_type)
13055 {
2b692964 13056 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 13057 return _("PT_GETREGS (reg structure)");
2b692964 13058 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 13059 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13060 default:
13061 break;
13062 }
13063 break;
13064
13065 /* On all other arch's, PT_GETREGS == mach+1 and
13066 PT_GETFPREGS == mach+3. */
13067 default:
13068 switch (e_type)
13069 {
2b692964 13070 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 13071 return _("PT_GETREGS (reg structure)");
2b692964 13072 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 13073 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13074 default:
13075 break;
13076 }
13077 }
13078
9cf03b7e 13079 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 13080 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 13081 return buff;
13082}
13083
70616151
TT		 13084static const char *
13085get_stapsdt_note_type (unsigned e_type)
13086{
13087 static char buff[64];
13088
13089 switch (e_type)
13090 {
13091 case NT_STAPSDT:
13092 return _("NT_STAPSDT (SystemTap probe descriptors)");
13093
13094 default:
13095 break;
13096 }
13097
13098 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13099 return buff;
13100}
13101
c6a9fc58
TT		 13102static int
13103print_stapsdt_note (Elf_Internal_Note *pnote)
13104{
13105 int addr_size = is_32bit_elf ? 4 : 8;
13106 char *data = pnote->descdata;
13107 char *data_end = pnote->descdata + pnote->descsz;
13108 bfd_vma pc, base_addr, semaphore;
13109 char *provider, *probe, *arg_fmt;
13110
13111 pc = byte_get ((unsigned char *) data, addr_size);
13112 data += addr_size;
13113 base_addr = byte_get ((unsigned char *) data, addr_size);
13114 data += addr_size;
13115 semaphore = byte_get ((unsigned char *) data, addr_size);
13116 data += addr_size;
13117
13118 provider = data;
13119 data += strlen (data) + 1;
13120 probe = data;
13121 data += strlen (data) + 1;
13122 arg_fmt = data;
13123 data += strlen (data) + 1;
13124
13125 printf (_(" Provider: %s\n"), provider);
13126 printf (_(" Name: %s\n"), probe);
13127 printf (_(" Location: "));
13128 print_vma (pc, FULL_HEX);
13129 printf (_(", Base: "));
13130 print_vma (base_addr, FULL_HEX);
13131 printf (_(", Semaphore: "));
13132 print_vma (semaphore, FULL_HEX);
9cf03b7e 13133 printf ("\n");
c6a9fc58
TT		 13134 printf (_(" Arguments: %s\n"), arg_fmt);
13135
13136 return data == data_end;
13137}
13138
00e98fc7
TG		 13139static const char *
13140get_ia64_vms_note_type (unsigned e_type)
13141{
13142 static char buff[64];
13143
13144 switch (e_type)
13145 {
13146 case NT_VMS_MHD:
13147 return _("NT_VMS_MHD (module header)");
13148 case NT_VMS_LNM:
13149 return _("NT_VMS_LNM (language name)");
13150 case NT_VMS_SRC:
13151 return _("NT_VMS_SRC (source files)");
13152 case NT_VMS_TITLE:
9cf03b7e 13153 return "NT_VMS_TITLE";
00e98fc7
TG		 13154 case NT_VMS_EIDC:
13155 return _("NT_VMS_EIDC (consistency check)");
13156 case NT_VMS_FPMODE:
13157 return _("NT_VMS_FPMODE (FP mode)");
13158 case NT_VMS_LINKTIME:
9cf03b7e 13159 return "NT_VMS_LINKTIME";
00e98fc7
TG		 13160 case NT_VMS_IMGNAM:
13161 return _("NT_VMS_IMGNAM (image name)");
13162 case NT_VMS_IMGID:
13163 return _("NT_VMS_IMGID (image id)");
13164 case NT_VMS_LINKID:
13165 return _("NT_VMS_LINKID (link id)");
13166 case NT_VMS_IMGBID:
13167 return _("NT_VMS_IMGBID (build id)");
13168 case NT_VMS_GSTNAM:
13169 return _("NT_VMS_GSTNAM (sym table name)");
13170 case NT_VMS_ORIG_DYN:
9cf03b7e 13171 return "NT_VMS_ORIG_DYN";
00e98fc7 13172 case NT_VMS_PATCHTIME:
9cf03b7e 13173 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 13174 default:
13175 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13176 return buff;
13177 }
13178}
13179
13180static int
13181print_ia64_vms_note (Elf_Internal_Note * pnote)
13182{
13183 switch (pnote->type)
13184 {
13185 case NT_VMS_MHD:
13186 if (pnote->descsz > 36)
13187 {
13188 size_t l = strlen (pnote->descdata + 34);
13189 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13190 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13191 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13192 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13193 }
13194 else
13195 printf (_(" Invalid size\n"));
13196 break;
13197 case NT_VMS_LNM:
13198 printf (_(" Language: %s\n"), pnote->descdata);
13199 break;
13200#ifdef BFD64
13201 case NT_VMS_FPMODE:
9cf03b7e 13202 printf (_(" Floating Point mode: "));
4a5cb34f 13203 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13204 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13205 break;
13206 case NT_VMS_LINKTIME:
13207 printf (_(" Link time: "));
13208 print_vms_time
13209 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13210 printf ("\n");
13211 break;
13212 case NT_VMS_PATCHTIME:
13213 printf (_(" Patch time: "));
13214 print_vms_time
13215 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13216 printf ("\n");
13217 break;
13218 case NT_VMS_ORIG_DYN:
13219 printf (_(" Major id: %u, minor id: %u\n"),
13220 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13221 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 13222 printf (_(" Last modified : "));
00e98fc7
TG		 13223 print_vms_time
13224 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 13225 printf (_("\n Link flags : "));
4a5cb34f 13226 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13227 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13228 printf (_(" Header flags: 0x%08x\n"),
13229 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13230 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13231 break;
13232#endif
13233 case NT_VMS_IMGNAM:
13234 printf (_(" Image name: %s\n"), pnote->descdata);
13235 break;
13236 case NT_VMS_GSTNAM:
13237 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13238 break;
13239 case NT_VMS_IMGID:
13240 printf (_(" Image id: %s\n"), pnote->descdata);
13241 break;
13242 case NT_VMS_LINKID:
13243 printf (_(" Linker id: %s\n"), pnote->descdata);
13244 break;
13245 default:
13246 break;
13247 }
13248 return 1;
13249}
13250
6d118b09
NC		 13251/* Note that by the ELF standard, the name field is already null byte
13252 terminated, and namesz includes the terminating null byte.
13253 I.E. the value of namesz for the name "FSF" is 4.
13254
e3c8793a 13255 If the value of namesz is zero, there is no name present. */
779fe533 13256static int
2cf0635d 13257process_note (Elf_Internal_Note * pnote)
779fe533 13258{
2cf0635d
NC		 13259 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13260 const char * nt;
9437c45b
JT		 13261
13262 if (pnote->namesz == 0)
1ec5cd37
NC		 13263 /* If there is no note name, then use the default set of
13264 note type strings. */
13265 nt = get_note_type (pnote->type);
13266
1118d252
RM		 13267 else if (const_strneq (pnote->namedata, "GNU"))
13268 /* GNU-specific object file notes. */
13269 nt = get_gnu_elf_note_type (pnote->type);
13270
0112cd26 13271 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 13272 /* NetBSD-specific core file notes. */
13273 nt = get_netbsd_elfcore_note_type (pnote->type);
13274
b15fa79e
AM		 13275 else if (strneq (pnote->namedata, "SPU/", 4))
13276 {
13277 /* SPU-specific core file notes. */
13278 nt = pnote->namedata + 4;
13279 name = "SPU";
13280 }
13281
00e98fc7
TG		 13282 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13283 /* VMS/ia64-specific file notes. */
13284 nt = get_ia64_vms_note_type (pnote->type);
13285
70616151
TT		 13286 else if (const_strneq (pnote->namedata, "stapsdt"))
13287 nt = get_stapsdt_note_type (pnote->type);
13288
9437c45b 13289 else
1ec5cd37
NC		 13290 /* Don't recognize this note name; just use the default set of
13291 note type strings. */
00e98fc7 13292 nt = get_note_type (pnote->type);
9437c45b 13293
2aee03ae 13294 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 13295
13296 if (const_strneq (pnote->namedata, "IPF/VMS"))
13297 return print_ia64_vms_note (pnote);
664f90a3
TT		 13298 else if (const_strneq (pnote->namedata, "GNU"))
13299 return print_gnu_note (pnote);
c6a9fc58
TT		 13300 else if (const_strneq (pnote->namedata, "stapsdt"))
13301 return print_stapsdt_note (pnote);
9ece1fa9
TT		 13302 else if (const_strneq (pnote->namedata, "CORE"))
13303 return print_core_note (pnote);
00e98fc7
TG		 13304 else
13305 return 1;
779fe533
NC		 13306}
13307
6d118b09 13308
779fe533 13309static int
2cf0635d 13310process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 13311{
2cf0635d
NC		 13312 Elf_External_Note * pnotes;
13313 Elf_External_Note * external;
b34976b6 13314 int res = 1;
103f02d3 13315
779fe533
NC		 13316 if (length <= 0)
13317 return 0;
103f02d3 13318
3f5e193b
NC		 13319 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13320 _("notes"));
dd24e3da 13321 if (pnotes == NULL)
a6e9f9df 13322 return 0;
779fe533 13323
103f02d3 13324 external = pnotes;
103f02d3 13325
305c7206 13326 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13327 (unsigned long) offset, (unsigned long) length);
2aee03ae 13328 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13329
2cf0635d 13330 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 13331 {
2cf0635d 13332 Elf_External_Note * next;
b34976b6 13333 Elf_Internal_Note inote;
2cf0635d 13334 char * temp = NULL;
6d118b09 13335
00e98fc7
TG		 13336 if (!is_ia64_vms ())
13337 {
13338 inote.type = BYTE_GET (external->type);
13339 inote.namesz = BYTE_GET (external->namesz);
13340 inote.namedata = external->name;
13341 inote.descsz = BYTE_GET (external->descsz);
13342 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13343 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13344
13345 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13346 }
13347 else
13348 {
13349 Elf64_External_VMS_Note *vms_external;
13350
13351 vms_external = (Elf64_External_VMS_Note *)external;
13352 inote.type = BYTE_GET (vms_external->type);
13353 inote.namesz = BYTE_GET (vms_external->namesz);
13354 inote.namedata = vms_external->name;
13355 inote.descsz = BYTE_GET (vms_external->descsz);
13356 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13357 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13358
13359 next = (Elf_External_Note *)
13360 (inote.descdata + align_power (inote.descsz, 3));
13361 }
3e55a963 13362
dd24e3da
NC		 13363 if ( ((char *) next > ((char *) pnotes) + length)
13364 || ((char *) next < (char *) pnotes))
3e55a963 13365 {
0fd3a477 13366 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 13367 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 13368 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 13369 inote.type, inote.namesz, inote.descsz);
13370 break;
13371 }
13372
13373 external = next;
6d118b09 13374
dd24e3da 13375 /* Prevent out-of-bounds indexing. */
8b971f9f 13376 if (inote.namedata + inote.namesz > (char *) pnotes + length
dd24e3da
NC		 13377 || inote.namedata + inote.namesz < inote.namedata)
13378 {
13379 warn (_("corrupt note found at offset %lx into core notes\n"),
13380 (unsigned long) ((char *) external - (char *) pnotes));
13381 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13382 inote.type, inote.namesz, inote.descsz);
13383 break;
13384 }
13385
6d118b09
NC		 13386 /* Verify that name is null terminated. It appears that at least
13387 one version of Linux (RedHat 6.0) generates corefiles that don't
13388 comply with the ELF spec by failing to include the null byte in
13389 namesz. */
8b971f9f 13390 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13391 {
3f5e193b 13392 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13393
6d118b09
NC		 13394 if (temp == NULL)
13395 {
13396 error (_("Out of memory\n"));
13397 res = 0;
13398 break;
13399 }
76da6bbe 13400
6d118b09
NC		 13401 strncpy (temp, inote.namedata, inote.namesz);
13402 temp[inote.namesz] = 0;
76da6bbe 13403
6d118b09
NC		 13404 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13405 inote.namedata = temp;
13406 }
13407
13408 res &= process_note (& inote);
103f02d3 13409
6d118b09
NC		 13410 if (temp != NULL)
13411 {
13412 free (temp);
13413 temp = NULL;
13414 }
779fe533
NC		 13415 }
13416
13417 free (pnotes);
103f02d3 13418
779fe533
NC		 13419 return res;
13420}
13421
13422static int
2cf0635d 13423process_corefile_note_segments (FILE * file)
779fe533 13424{
2cf0635d 13425 Elf_Internal_Phdr * segment;
b34976b6
AM		 13426 unsigned int i;
13427 int res = 1;
103f02d3 13428
d93f0186 13429 if (! get_program_headers (file))
779fe533 13430 return 0;
103f02d3 13431
779fe533
NC		 13432 for (i = 0, segment = program_headers;
13433 i < elf_header.e_phnum;
b34976b6 13434 i++, segment++)
779fe533
NC		 13435 {
13436 if (segment->p_type == PT_NOTE)
103f02d3 13437 res &= process_corefile_note_segment (file,
30800947
NC		 13438 (bfd_vma) segment->p_offset,
13439 (bfd_vma) segment->p_filesz);
779fe533 13440 }
103f02d3 13441
779fe533
NC		 13442 return res;
13443}
13444
13445static int
2cf0635d 13446process_note_sections (FILE * file)
1ec5cd37 13447{
2cf0635d 13448 Elf_Internal_Shdr * section;
1ec5cd37
NC		 13449 unsigned long i;
13450 int res = 1;
13451
13452 for (i = 0, section = section_headers;
fa1908fd 13453 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 13454 i++, section++)
13455 if (section->sh_type == SHT_NOTE)
13456 res &= process_corefile_note_segment (file,
13457 (bfd_vma) section->sh_offset,
13458 (bfd_vma) section->sh_size);
13459
13460 return res;
13461}
13462
13463static int
2cf0635d 13464process_notes (FILE * file)
779fe533
NC		 13465{
13466 /* If we have not been asked to display the notes then do nothing. */
13467 if (! do_notes)
13468 return 1;
103f02d3 13469
779fe533 13470 if (elf_header.e_type != ET_CORE)
1ec5cd37 13471 return process_note_sections (file);
103f02d3 13472
779fe533 13473 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 13474 if (elf_header.e_phnum > 0)
13475 return process_corefile_note_segments (file);
779fe533 13476
1ec5cd37
NC		 13477 printf (_("No note segments present in the core file.\n"));
13478 return 1;
779fe533
NC		 13479}
13480
252b5132 13481static int
2cf0635d 13482process_arch_specific (FILE * file)
252b5132 13483{
a952a375
NC		 13484 if (! do_arch)
13485 return 1;
13486
252b5132
RH		 13487 switch (elf_header.e_machine)
13488 {
11c1ff18
PB		 13489 case EM_ARM:
13490 return process_arm_specific (file);
252b5132 13491 case EM_MIPS:
4fe85591 13492 case EM_MIPS_RS3_LE:
252b5132
RH		 13493 return process_mips_specific (file);
13494 break;
34c8bcba
JM		 13495 case EM_PPC:
13496 return process_power_specific (file);
13497 break;
9e8c70f9
DM		 13498 case EM_SPARC:
13499 case EM_SPARC32PLUS:
13500 case EM_SPARCV9:
13501 return process_sparc_specific (file);
13502 break;
59e6276b
JM		 13503 case EM_TI_C6000:
13504 return process_tic6x_specific (file);
13505 break;
252b5132
RH		 13506 default:
13507 break;
13508 }
13509 return 1;
13510}
13511
13512static int
2cf0635d 13513get_file_header (FILE * file)
252b5132 13514{
9ea033b2
NC		 13515 /* Read in the identity array. */
13516 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13517 return 0;
13518
9ea033b2 13519 /* Determine how to read the rest of the header. */
b34976b6 13520 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13521 {
13522 default: /* fall through */
13523 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13524 case ELFDATA2LSB:
13525 byte_get = byte_get_little_endian;
13526 byte_put = byte_put_little_endian;
13527 break;
13528 case ELFDATA2MSB:
13529 byte_get = byte_get_big_endian;
13530 byte_put = byte_put_big_endian;
13531 break;
9ea033b2
NC		 13532 }
13533
13534 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13535 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13536
13537 /* Read in the rest of the header. */
13538 if (is_32bit_elf)
13539 {
13540 Elf32_External_Ehdr ehdr32;
252b5132 13541
9ea033b2
NC		 13542 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13543 return 0;
103f02d3 13544
9ea033b2
NC		 13545 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13546 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13547 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13548 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13549 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13550 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13551 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13552 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13553 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13554 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13555 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13556 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13557 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13558 }
252b5132 13559 else
9ea033b2
NC		 13560 {
13561 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13562
13563 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13564 we will not be able to cope with the 64bit data found in
13565 64 ELF files. Detect this now and abort before we start
50c2245b 13566 overwriting things. */
a952a375
NC		 13567 if (sizeof (bfd_vma) < 8)
13568 {
e3c8793a
NC		 13569 error (_("This instance of readelf has been built without support for a\n\
1357064 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13571 return 0;
13572 }
103f02d3 13573
9ea033b2
NC		 13574 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13575 return 0;
103f02d3 13576
9ea033b2
NC		 13577 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13578 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13579 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13580 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13581 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13582 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13583 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13584 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13585 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13586 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13587 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13588 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13589 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13590 }
252b5132 13591
7ece0d85
JJ		 13592 if (elf_header.e_shoff)
13593 {
13594 /* There may be some extensions in the first section header. Don't
13595 bomb if we can't read it. */
13596 if (is_32bit_elf)
13597 get_32bit_section_headers (file, 1);
13598 else
13599 get_64bit_section_headers (file, 1);
13600 }
560f3c1c 13601
252b5132
RH		 13602 return 1;
13603}
13604
fb52b2f4
NC		 13605/* Process one ELF object file according to the command line options.
13606 This file may actually be stored in an archive. The file is
13607 positioned at the start of the ELF object. */
13608
ff78d6d6 13609static int
2cf0635d 13610process_object (char * file_name, FILE * file)
252b5132 13611{
252b5132
RH		 13612 unsigned int i;
13613
252b5132
RH		 13614 if (! get_file_header (file))
13615 {
13616 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13617 return 1;
252b5132
RH		 13618 }
13619
13620 /* Initialise per file variables. */
60bca95a 13621 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13622 version_info[i] = 0;
13623
60bca95a 13624 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13625 dynamic_info[i] = 0;
5115b233 13626 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13627
13628 /* Process the file. */
13629 if (show_name)
13630 printf (_("\nFile: %s\n"), file_name);
13631
18bd398b
NC		 13632 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13633 Note we do this even if cmdline_dump_sects is empty because we
13634 must make sure that the dump_sets array is zeroed out before each
13635 object file is processed. */
13636 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13637 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13638
13639 if (num_cmdline_dump_sects > 0)
13640 {
13641 if (num_dump_sects == 0)
13642 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13643 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13644
13645 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13646 memcpy (dump_sects, cmdline_dump_sects,
13647 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13648 }
d70c5fc7 13649
252b5132 13650 if (! process_file_header ())
fb52b2f4 13651 return 1;
252b5132 13652
d1f5c6e3 13653 if (! process_section_headers (file))
2f62977e 13654 {
d1f5c6e3
L		 13655 /* Without loaded section headers we cannot process lots of
13656 things. */
2f62977e 13657 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13658
2f62977e 13659 if (! do_using_dynamic)
2c610e4b 13660 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13661 }
252b5132 13662
d1f5c6e3
L		 13663 if (! process_section_groups (file))
13664 {
13665 /* Without loaded section groups we cannot process unwind. */
13666 do_unwind = 0;
13667 }
13668
2f62977e 13669 if (process_program_headers (file))
b2d38a17 13670 process_dynamic_section (file);
252b5132
RH		 13671
13672 process_relocs (file);
13673
4d6ed7c8
NC		 13674 process_unwind (file);
13675
252b5132
RH		 13676 process_symbol_table (file);
13677
13678 process_syminfo (file);
13679
13680 process_version_sections (file);
13681
13682 process_section_contents (file);
f5842774 13683
1ec5cd37 13684 process_notes (file);
103f02d3 13685
047b2264
JJ		 13686 process_gnu_liblist (file);
13687
252b5132
RH		 13688 process_arch_specific (file);
13689
d93f0186
NC		 13690 if (program_headers)
13691 {
13692 free (program_headers);
13693 program_headers = NULL;
13694 }
13695
252b5132
RH		 13696 if (section_headers)
13697 {
13698 free (section_headers);
13699 section_headers = NULL;
13700 }
13701
13702 if (string_table)
13703 {
13704 free (string_table);
13705 string_table = NULL;
d40ac9bd 13706 string_table_length = 0;
252b5132
RH		 13707 }
13708
13709 if (dynamic_strings)
13710 {
13711 free (dynamic_strings);
13712 dynamic_strings = NULL;
d79b3d50 13713 dynamic_strings_length = 0;
252b5132
RH		 13714 }
13715
13716 if (dynamic_symbols)
13717 {
13718 free (dynamic_symbols);
13719 dynamic_symbols = NULL;
19936277 13720 num_dynamic_syms = 0;
252b5132
RH		 13721 }
13722
13723 if (dynamic_syminfo)
13724 {
13725 free (dynamic_syminfo);
13726 dynamic_syminfo = NULL;
13727 }
ff78d6d6 13728
293c573e
MR		 13729 if (dynamic_section)
13730 {
13731 free (dynamic_section);
13732 dynamic_section = NULL;
13733 }
13734
e4b17d5c
L		 13735 if (section_headers_groups)
13736 {
13737 free (section_headers_groups);
13738 section_headers_groups = NULL;
13739 }
13740
13741 if (section_groups)
13742 {
2cf0635d
NC		 13743 struct group_list * g;
13744 struct group_list * next;
e4b17d5c
L		 13745
13746 for (i = 0; i < group_count; i++)
13747 {
13748 for (g = section_groups [i].root; g != NULL; g = next)
13749 {
13750 next = g->next;
13751 free (g);
13752 }
13753 }
13754
13755 free (section_groups);
13756 section_groups = NULL;
13757 }
13758
19e6b90e 13759 free_debug_memory ();
18bd398b 13760
ff78d6d6 13761 return 0;
252b5132
RH		 13762}
13763
2cf0635d
NC		 13764/* Process an ELF archive.
13765 On entry the file is positioned just after the ARMAG string. */
13766
13767static int
13768process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13769{
13770 struct archive_info arch;
13771 struct archive_info nested_arch;
13772 size_t got;
2cf0635d
NC		 13773 int ret;
13774
13775 show_name = 1;
13776
13777 /* The ARCH structure is used to hold information about this archive. */
13778 arch.file_name = NULL;
13779 arch.file = NULL;
13780 arch.index_array = NULL;
13781 arch.sym_table = NULL;
13782 arch.longnames = NULL;
13783
13784 /* The NESTED_ARCH structure is used as a single-item cache of information
13785 about a nested archive (when members of a thin archive reside within
13786 another regular archive file). */
13787 nested_arch.file_name = NULL;
13788 nested_arch.file = NULL;
13789 nested_arch.index_array = NULL;
13790 nested_arch.sym_table = NULL;
13791 nested_arch.longnames = NULL;
13792
13793 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13794 {
13795 ret = 1;
13796 goto out;
4145f1d5 13797 }
fb52b2f4 13798
4145f1d5
NC		 13799 if (do_archive_index)
13800 {
2cf0635d 13801 if (arch.sym_table == NULL)
4145f1d5
NC		 13802 error (_("%s: unable to dump the index as none was found\n"), file_name);
13803 else
13804 {
2cf0635d 13805 unsigned int i, l;
4145f1d5
NC		 13806 unsigned long current_pos;
13807
13808 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 13809 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 13810 current_pos = ftell (file);
13811
2cf0635d 13812 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13813 {
2cf0635d
NC		 13814 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13815 {
13816 char * member_name;
4145f1d5 13817
2cf0635d
NC		 13818 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13819
13820 if (member_name != NULL)
13821 {
13822 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13823
13824 if (qualified_name != NULL)
13825 {
c2a7d3f5
NC		 13826 printf (_("Contents of binary %s at offset "), qualified_name);
13827 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13828 putchar ('\n');
2cf0635d
NC		 13829 free (qualified_name);
13830 }
4145f1d5
NC		 13831 }
13832 }
2cf0635d
NC		 13833
13834 if (l >= arch.sym_size)
4145f1d5
NC		 13835 {
13836 error (_("%s: end of the symbol table reached before the end of the index\n"),
13837 file_name);
cb8f3167 13838 break;
4145f1d5 13839 }
2cf0635d
NC		 13840 printf ("\t%s\n", arch.sym_table + l);
13841 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13842 }
13843
c2a7d3f5
NC		 13844 if (arch.uses_64bit_indicies)
13845 l = (l + 7) & ~ 7;
13846 else
13847 l += l & 1;
13848
2cf0635d 13849 if (l < arch.sym_size)
c2a7d3f5
NC		 13850 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13851 file_name, arch.sym_size - l);
4145f1d5 13852
4145f1d5
NC		 13853 if (fseek (file, current_pos, SEEK_SET) != 0)
13854 {
13855 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13856 ret = 1;
13857 goto out;
4145f1d5 13858 }
fb52b2f4 13859 }
4145f1d5
NC		 13860
13861 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13862 && !do_segments && !do_header && !do_dump && !do_version
13863 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13864 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13865 {
13866 ret = 0; /* Archive index only. */
13867 goto out;
13868 }
fb52b2f4
NC		 13869 }
13870
d989285c 13871 ret = 0;
fb52b2f4
NC		 13872
13873 while (1)
13874 {
2cf0635d
NC		 13875 char * name;
13876 size_t namelen;
13877 char * qualified_name;
13878
13879 /* Read the next archive header. */
13880 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13881 {
13882 error (_("%s: failed to seek to next archive header\n"), file_name);
13883 return 1;
13884 }
13885 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13886 if (got != sizeof arch.arhdr)
13887 {
13888 if (got == 0)
13889 break;
13890 error (_("%s: failed to read archive header\n"), file_name);
13891 ret = 1;
13892 break;
13893 }
13894 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13895 {
13896 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13897 ret = 1;
13898 break;
13899 }
13900
13901 arch.next_arhdr_offset += sizeof arch.arhdr;
13902
13903 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13904 if (archive_file_size & 01)
13905 ++archive_file_size;
13906
13907 name = get_archive_member_name (&arch, &nested_arch);
13908 if (name == NULL)
fb52b2f4 13909 {
0fd3a477 13910 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13911 ret = 1;
13912 break;
fb52b2f4 13913 }
2cf0635d 13914 namelen = strlen (name);
fb52b2f4 13915
2cf0635d
NC		 13916 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13917 if (qualified_name == NULL)
fb52b2f4 13918 {
2cf0635d 13919 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13920 ret = 1;
13921 break;
fb52b2f4
NC		 13922 }
13923
2cf0635d
NC		 13924 if (is_thin_archive && arch.nested_member_origin == 0)
13925 {
13926 /* This is a proxy for an external member of a thin archive. */
13927 FILE * member_file;
13928 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13929 if (member_file_name == NULL)
13930 {
13931 ret = 1;
13932 break;
13933 }
13934
13935 member_file = fopen (member_file_name, "rb");
13936 if (member_file == NULL)
13937 {
13938 error (_("Input file '%s' is not readable.\n"), member_file_name);
13939 free (member_file_name);
13940 ret = 1;
13941 break;
13942 }
13943
13944 archive_file_offset = arch.nested_member_origin;
13945
13946 ret |= process_object (qualified_name, member_file);
13947
13948 fclose (member_file);
13949 free (member_file_name);
13950 }
13951 else if (is_thin_archive)
13952 {
13953 /* This is a proxy for a member of a nested archive. */
13954 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13955
13956 /* The nested archive file will have been opened and setup by
13957 get_archive_member_name. */
13958 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13959 {
13960 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13961 ret = 1;
13962 break;
13963 }
13964
13965 ret |= process_object (qualified_name, nested_arch.file);
13966 }
13967 else
13968 {
13969 archive_file_offset = arch.next_arhdr_offset;
13970 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13971
2cf0635d
NC		 13972 ret |= process_object (qualified_name, file);
13973 }
fb52b2f4 13974
2b52916e
L		 13975 if (dump_sects != NULL)
13976 {
13977 free (dump_sects);
13978 dump_sects = NULL;
13979 num_dump_sects = 0;
13980 }
13981
2cf0635d 13982 free (qualified_name);
fb52b2f4
NC		 13983 }
13984
4145f1d5 13985 out:
2cf0635d
NC		 13986 if (nested_arch.file != NULL)
13987 fclose (nested_arch.file);
13988 release_archive (&nested_arch);
13989 release_archive (&arch);
fb52b2f4 13990
d989285c 13991 return ret;
fb52b2f4
NC		 13992}
13993
13994static int
2cf0635d 13995process_file (char * file_name)
fb52b2f4 13996{
2cf0635d 13997 FILE * file;
fb52b2f4
NC		 13998 struct stat statbuf;
13999 char armag[SARMAG];
14000 int ret;
14001
14002 if (stat (file_name, &statbuf) < 0)
14003 {
f24ddbdd
NC		 14004 if (errno == ENOENT)
14005 error (_("'%s': No such file\n"), file_name);
14006 else
14007 error (_("Could not locate '%s'. System error message: %s\n"),
14008 file_name, strerror (errno));
14009 return 1;
14010 }
14011
14012 if (! S_ISREG (statbuf.st_mode))
14013 {
14014 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 14015 return 1;
14016 }
14017
14018 file = fopen (file_name, "rb");
14019 if (file == NULL)
14020 {
f24ddbdd 14021 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 14022 return 1;
14023 }
14024
14025 if (fread (armag, SARMAG, 1, file) != 1)
14026 {
4145f1d5 14027 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 14028 fclose (file);
14029 return 1;
14030 }
14031
14032 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 14033 ret = process_archive (file_name, file, FALSE);
14034 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14035 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 14036 else
14037 {
4145f1d5
NC		 14038 if (do_archive_index)
14039 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14040 file_name);
14041
fb52b2f4
NC		 14042 rewind (file);
14043 archive_file_size = archive_file_offset = 0;
14044 ret = process_object (file_name, file);
14045 }
14046
14047 fclose (file);
14048
14049 return ret;
14050}
14051
252b5132
RH		 14052#ifdef SUPPORT_DISASSEMBLY
14053/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 14054 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 14055 symbols. */
252b5132
RH		 14056
14057void
2cf0635d 14058print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 14059{
14060 fprintf (outfile,"0x%8.8x", addr);
14061}
14062
e3c8793a 14063/* Needed by the i386 disassembler. */
252b5132
RH		 14064void
14065db_task_printsym (unsigned int addr)
14066{
14067 print_address (addr, stderr);
14068}
14069#endif
14070
14071int
2cf0635d 14072main (int argc, char ** argv)
252b5132 14073{
ff78d6d6
L		 14074 int err;
14075
252b5132
RH		 14076#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14077 setlocale (LC_MESSAGES, "");
3882b010
L		 14078#endif
14079#if defined (HAVE_SETLOCALE)
14080 setlocale (LC_CTYPE, "");
252b5132
RH		 14081#endif
14082 bindtextdomain (PACKAGE, LOCALEDIR);
14083 textdomain (PACKAGE);
14084
869b9d07
MM		 14085 expandargv (&argc, &argv);
14086
252b5132
RH		 14087 parse_args (argc, argv);
14088
18bd398b 14089 if (num_dump_sects > 0)
59f14fc0 14090 {
18bd398b 14091 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 14092 cmdline_dump_sects = (dump_type *)
14093 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 14094 if (cmdline_dump_sects == NULL)
591a748a 14095 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 14096 else
14097 {
09c11c86
NC		 14098 memcpy (cmdline_dump_sects, dump_sects,
14099 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 14100 num_cmdline_dump_sects = num_dump_sects;
14101 }
14102 }
14103
18bd398b
NC		 14104 if (optind < (argc - 1))
14105 show_name = 1;
14106
ff78d6d6 14107 err = 0;
252b5132 14108 while (optind < argc)
18bd398b 14109 err |= process_file (argv[optind++]);
252b5132
RH		 14110
14111 if (dump_sects != NULL)
14112 free (dump_sects);
59f14fc0
AS		 14113 if (cmdline_dump_sects != NULL)
14114 free (cmdline_dump_sects);
252b5132 14115
ff78d6d6 14116 return err;
252b5132 14117}
A mirror of the official binutils-gdb repository