projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
FT32 initial support
[deliverable/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
b90efa5b 2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056
CS		 46#ifdef HAVE_ZLIB_H
47#include <zlib.h>
48#endif
3bfcb652 49#ifdef HAVE_WCHAR_H
7bfd842d 50#include <wchar.h>
3bfcb652 51#endif
252b5132 52
a952a375 53#if __GNUC__ >= 2
19936277 54/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 55 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 56 Only do this if we believe that the compiler can support a 64 bit
a952a375 57 data type. For now we only rely on GCC being able to do this. */
19936277 58#define BFD64
a952a375
NC		 59#endif
60
3db64b00
AM		 61#include "bfd.h"
62#include "bucomm.h"
3284fe0c 63#include "elfcomm.h"
19e6b90e 64#include "dwarf.h"
252b5132
RH		 65
66#include "elf/common.h"
67#include "elf/external.h"
68#include "elf/internal.h"
252b5132 69
4b78141a
NC		 70
71/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76#include "elf/h8.h"
77#undef _ELF_H8_H
78
79/* Undo the effects of #including reloc-macros.h. */
80
81#undef START_RELOC_NUMBERS
82#undef RELOC_NUMBER
83#undef FAKE_RELOC
84#undef EMPTY_RELOC
85#undef END_RELOC_NUMBERS
86#undef _RELOC_MACROS_H
87
252b5132
RH		 88/* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92#define RELOC_MACROS_GEN_FUNC
93
a06ea964 94#include "elf/aarch64.h"
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
cfb8c092 106#include "elf/epiphany.h"
252b5132 107#include "elf/fr30.h"
5c70f934 108#include "elf/frv.h"
3f8107ab 109#include "elf/ft32.h"
3b16e843
NC		 110#include "elf/h8.h"
111#include "elf/hppa.h"
112#include "elf/i386.h"
35b1837e 113#include "elf/i370.h"
3b16e843
NC		 114#include "elf/i860.h"
115#include "elf/i960.h"
116#include "elf/ia64.h"
1e4cf259 117#include "elf/ip2k.h"
84e94c90 118#include "elf/lm32.h"
1c0d3aa6 119#include "elf/iq2000.h"
49f58d10 120#include "elf/m32c.h"
3b16e843
NC		 121#include "elf/m32r.h"
122#include "elf/m68k.h"
75751cd9 123#include "elf/m68hc11.h"
252b5132 124#include "elf/mcore.h"
15ab5209 125#include "elf/mep.h"
a3c62988 126#include "elf/metag.h"
7ba29e2a 127#include "elf/microblaze.h"
3b16e843 128#include "elf/mips.h"
3c3bdf30 129#include "elf/mmix.h"
3b16e843
NC		 130#include "elf/mn10200.h"
131#include "elf/mn10300.h"
5506d11a 132#include "elf/moxie.h"
4970f871 133#include "elf/mt.h"
2469cfa2 134#include "elf/msp430.h"
35c08157 135#include "elf/nds32.h"
13761a11 136#include "elf/nios2.h"
73589c9d 137#include "elf/or1k.h"
7d466069 138#include "elf/pj.h"
3b16e843 139#include "elf/ppc.h"
c833c019 140#include "elf/ppc64.h"
99c513f6 141#include "elf/rl78.h"
c7927a3c 142#include "elf/rx.h"
a85d7ed0 143#include "elf/s390.h"
1c0d3aa6 144#include "elf/score.h"
3b16e843
NC		 145#include "elf/sh.h"
146#include "elf/sparc.h"
e9f53129 147#include "elf/spu.h"
40b36596 148#include "elf/tic6x.h"
aa137e4d
NC		 149#include "elf/tilegx.h"
150#include "elf/tilepro.h"
3b16e843 151#include "elf/v850.h"
179d3252 152#include "elf/vax.h"
619ed720 153#include "elf/visium.h"
3b16e843 154#include "elf/x86-64.h"
c29aca4a 155#include "elf/xc16x.h"
f6c1a2d5 156#include "elf/xgate.h"
93fbbb04 157#include "elf/xstormy16.h"
88da6820 158#include "elf/xtensa.h"
252b5132 159
252b5132 160#include "getopt.h"
566b0d53 161#include "libiberty.h"
09c11c86 162#include "safe-ctype.h"
2cf0635d 163#include "filenames.h"
252b5132 164
15b42fb0
AM		 165#ifndef offsetof
166#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167#endif
168
2cf0635d 169char * program_name = "readelf";
c9c1d674 170static unsigned long archive_file_offset;
85b1c36d 171static unsigned long archive_file_size;
f54498b4 172static bfd_size_type current_file_size;
85b1c36d
BE		 173static unsigned long dynamic_addr;
174static bfd_size_type dynamic_size;
8b73c356 175static size_t dynamic_nent;
2cf0635d 176static char * dynamic_strings;
85b1c36d 177static unsigned long dynamic_strings_length;
2cf0635d 178static char * string_table;
85b1c36d
BE		 179static unsigned long string_table_length;
180static unsigned long num_dynamic_syms;
2cf0635d
NC		 181static Elf_Internal_Sym * dynamic_symbols;
182static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 183static unsigned long dynamic_syminfo_offset;
184static unsigned int dynamic_syminfo_nent;
f8eae8b2 185static char program_interpreter[PATH_MAX];
bb8a0291 186static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 187static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 188static bfd_vma version_info[16];
189static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 190static Elf_Internal_Shdr * section_headers;
191static Elf_Internal_Phdr * program_headers;
192static Elf_Internal_Dyn * dynamic_section;
193static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 194static int show_name;
195static int do_dynamic;
196static int do_syms;
2c610e4b 197static int do_dyn_syms;
85b1c36d
BE		 198static int do_reloc;
199static int do_sections;
200static int do_section_groups;
5477e8a0 201static int do_section_details;
85b1c36d
BE		 202static int do_segments;
203static int do_unwind;
204static int do_using_dynamic;
205static int do_header;
206static int do_dump;
207static int do_version;
85b1c36d
BE		 208static int do_histogram;
209static int do_debugging;
85b1c36d
BE		 210static int do_arch;
211static int do_notes;
4145f1d5 212static int do_archive_index;
85b1c36d 213static int is_32bit_elf;
252b5132 214
e4b17d5c
L		 215struct group_list
216{
2cf0635d 217 struct group_list * next;
e4b17d5c
L		 218 unsigned int section_index;
219};
220
221struct group
222{
2cf0635d 223 struct group_list * root;
e4b17d5c
L		 224 unsigned int group_index;
225};
226
85b1c36d 227static size_t group_count;
2cf0635d
NC		 228static struct group * section_groups;
229static struct group ** section_headers_groups;
e4b17d5c 230
09c11c86
NC		 231
232/* Flag bits indicating particular types of dump. */
233#define HEX_DUMP (1 << 0) /* The -x command line switch. */
234#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
235#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
236#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 237#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 238
239typedef unsigned char dump_type;
240
241/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 242struct dump_list_entry
243{
2cf0635d 244 char * name;
09c11c86 245 dump_type type;
2cf0635d 246 struct dump_list_entry * next;
aef1f6d0 247};
2cf0635d 248static struct dump_list_entry * dump_sects_byname;
aef1f6d0 249
09c11c86
NC		 250/* A dynamic array of flags indicating for which sections a dump
251 has been requested via command line switches. */
252static dump_type * cmdline_dump_sects = NULL;
253static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 254
255/* A dynamic array of flags indicating for which sections a dump of
256 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 257 basis and then initialised from the cmdline_dump_sects array,
258 the results of interpreting the -w switch, and the
259 dump_sects_byname list. */
09c11c86
NC		 260static dump_type * dump_sects = NULL;
261static unsigned int num_dump_sects = 0;
252b5132 262
252b5132 263
c256ffe7 264/* How to print a vma value. */
843dd992
NC		 265typedef enum print_mode
266{
267 HEX,
268 DEC,
269 DEC_5,
270 UNSIGNED,
271 PREFIX_HEX,
272 FULL_HEX,
273 LONG_HEX
274}
275print_mode;
276
bb4d2ac2
L		 277/* Versioned symbol info. */
278enum versioned_symbol_info
279{
280 symbol_undefined,
281 symbol_hidden,
282 symbol_public
283};
284
285static const char *get_symbol_version_string
286 (FILE *file, int is_dynsym, const char *strtab,
287 unsigned long int strtab_size, unsigned int si,
288 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
289 unsigned short *vna_other);
290
9c19a809
NC		 291#define UNKNOWN -1
292
2b692964
NC		 293#define SECTION_NAME(X) \
294 ((X) == NULL ? _("<none>") \
295 : string_table == NULL ? _("<no-name>") \
296 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 297 : string_table + (X)->sh_name))
252b5132 298
ee42cf8c 299#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 300
ba5cdace
NC		 301#define GET_ELF_SYMBOLS(file, section, sym_count) \
302 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
303 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 304
d79b3d50
NC		 305#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
306/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
307 already been called and verified that the string exists. */
308#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 309
61865e30
NC		 310#define REMOVE_ARCH_BITS(ADDR) \
311 do \
312 { \
313 if (elf_header.e_machine == EM_ARM) \
314 (ADDR) &= ~1; \
315 } \
316 while (0)
d79b3d50 317\f
c9c1d674
EG		 318/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
319 the offset of the current archive member, if we are examining an archive.
59245841
NC		 320 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
321 using malloc and fill that. In either case return the pointer to the start of
322 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 323 and REASON is not NULL then emit an error message using REASON as part of the
324 context. */
59245841 325
c256ffe7 326static void *
c9c1d674 327get_data (void * var, FILE * file, unsigned long offset, size_t size, size_t nmemb,
2cf0635d 328 const char * reason)
a6e9f9df 329{
2cf0635d 330 void * mvar;
c9c1d674 331 size_t amt = size * nmemb;
a6e9f9df 332
c256ffe7 333 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 334 return NULL;
335
c9c1d674
EG		 336 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
337 attempting to allocate memory when the read is bound to fail. */
338 if (amt > current_file_size
339 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 340 {
049b0c3a 341 if (reason)
c9c1d674
EG		 342 error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
343 (unsigned long) amt, reason);
a6e9f9df
AM		 344 return NULL;
345 }
346
c9c1d674 347 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 348 {
349 if (reason)
c9c1d674
EG		 350 error (_("Unable to seek to 0x%lx for %s\n"),
351 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 352 return NULL;
353 }
354
a6e9f9df
AM		 355 mvar = var;
356 if (mvar == NULL)
357 {
c256ffe7
JJ		 358 /* Check for overflow. */
359 if (nmemb < (~(size_t) 0 - 1) / size)
360 /* + 1 so that we can '\0' terminate invalid string table sections. */
361 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 362
363 if (mvar == NULL)
364 {
049b0c3a
NC		 365 if (reason)
366 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
367 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 368 return NULL;
369 }
c256ffe7 370
c9c1d674 371 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 372 }
373
c256ffe7 374 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 375 {
049b0c3a
NC		 376 if (reason)
377 error (_("Unable to read in 0x%lx bytes of %s\n"),
c9c1d674 378 (unsigned long) amt, reason);
a6e9f9df
AM		 379 if (mvar != var)
380 free (mvar);
381 return NULL;
382 }
383
384 return mvar;
385}
386
14a91970 387/* Print a VMA value. */
cb8f3167 388
66543521 389static int
14a91970 390print_vma (bfd_vma vma, print_mode mode)
66543521 391{
66543521
AM		 392 int nc = 0;
393
14a91970 394 switch (mode)
66543521 395 {
14a91970
AM		 396 case FULL_HEX:
397 nc = printf ("0x");
398 /* Drop through. */
66543521 399
14a91970 400 case LONG_HEX:
f7a99963 401#ifdef BFD64
14a91970 402 if (is_32bit_elf)
437c2fb7 403 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 404#endif
14a91970
AM		 405 printf_vma (vma);
406 return nc + 16;
b19aac67 407
14a91970
AM		 408 case DEC_5:
409 if (vma <= 99999)
410 return printf ("%5" BFD_VMA_FMT "d", vma);
411 /* Drop through. */
66543521 412
14a91970
AM		 413 case PREFIX_HEX:
414 nc = printf ("0x");
415 /* Drop through. */
66543521 416
14a91970
AM		 417 case HEX:
418 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 419
14a91970
AM		 420 case DEC:
421 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 422
14a91970
AM		 423 case UNSIGNED:
424 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 425 }
66543521 426 return 0;
f7a99963
NC		 427}
428
7bfd842d 429/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 430 multibye characters (assuming the host environment supports them).
31104126 431
7bfd842d
NC		 432 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
433
434 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
435 padding as necessary.
171191ba
NC		 436
437 Returns the number of emitted characters. */
438
439static unsigned int
7a88bc9c 440print_symbol (int width, const char *symbol)
31104126 441{
171191ba 442 bfd_boolean extra_padding = FALSE;
7bfd842d 443 int num_printed = 0;
3bfcb652 444#ifdef HAVE_MBSTATE_T
7bfd842d 445 mbstate_t state;
3bfcb652 446#endif
7bfd842d 447 int width_remaining;
961c521f 448
7bfd842d 449 if (width < 0)
961c521f 450 {
961c521f
NC		 451 /* Keep the width positive. This also helps. */
452 width = - width;
171191ba 453 extra_padding = TRUE;
0b4362b0 454 }
74e1a04b 455 assert (width != 0);
961c521f 456
7bfd842d
NC		 457 if (do_wide)
458 /* Set the remaining width to a very large value.
459 This simplifies the code below. */
460 width_remaining = INT_MAX;
461 else
462 width_remaining = width;
cb8f3167 463
3bfcb652 464#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 465 /* Initialise the multibyte conversion state. */
466 memset (& state, 0, sizeof (state));
3bfcb652 467#endif
961c521f 468
7bfd842d
NC		 469 while (width_remaining)
470 {
471 size_t n;
7bfd842d 472 const char c = *symbol++;
961c521f 473
7bfd842d 474 if (c == 0)
961c521f
NC		 475 break;
476
7bfd842d
NC		 477 /* Do not print control characters directly as they can affect terminal
478 settings. Such characters usually appear in the names generated
479 by the assembler for local labels. */
480 if (ISCNTRL (c))
961c521f 481 {
7bfd842d 482 if (width_remaining < 2)
961c521f
NC		 483 break;
484
7bfd842d
NC		 485 printf ("^%c", c + 0x40);
486 width_remaining -= 2;
171191ba 487 num_printed += 2;
961c521f 488 }
7bfd842d
NC		 489 else if (ISPRINT (c))
490 {
491 putchar (c);
492 width_remaining --;
493 num_printed ++;
494 }
961c521f
NC		 495 else
496 {
3bfcb652
NC		 497#ifdef HAVE_MBSTATE_T
498 wchar_t w;
499#endif
7bfd842d
NC		 500 /* Let printf do the hard work of displaying multibyte characters. */
501 printf ("%.1s", symbol - 1);
502 width_remaining --;
503 num_printed ++;
504
3bfcb652 505#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 506 /* Try to find out how many bytes made up the character that was
507 just printed. Advance the symbol pointer past the bytes that
508 were displayed. */
509 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 510#else
511 n = 1;
512#endif
7bfd842d
NC		 513 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
514 symbol += (n - 1);
961c521f 515 }
961c521f 516 }
171191ba 517
7bfd842d 518 if (extra_padding && num_printed < width)
171191ba
NC		 519 {
520 /* Fill in the remaining spaces. */
7bfd842d
NC		 521 printf ("%-*s", width - num_printed, " ");
522 num_printed = width;
171191ba
NC		 523 }
524
525 return num_printed;
31104126
NC		 526}
527
74e1a04b
NC		 528/* Returns a pointer to a static buffer containing a printable version of
529 the given section's name. Like print_symbol, except that it does not try
530 to print multibyte characters, it just interprets them as hex values. */
531
532static const char *
533printable_section_name (Elf_Internal_Shdr * sec)
534{
535#define MAX_PRINT_SEC_NAME_LEN 128
536 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
537 const char * name = SECTION_NAME (sec);
538 char * buf = sec_name_buf;
539 char c;
540 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
541
542 while ((c = * name ++) != 0)
543 {
544 if (ISCNTRL (c))
545 {
546 if (remaining < 2)
547 break;
548
549 * buf ++ = '^';
550 * buf ++ = c + 0x40;
551 remaining -= 2;
552 }
553 else if (ISPRINT (c))
554 {
555 * buf ++ = c;
556 remaining -= 1;
557 }
558 else
559 {
560 static char hex[17] = "0123456789ABCDEF";
561
562 if (remaining < 4)
563 break;
564 * buf ++ = '<';
565 * buf ++ = hex[(c & 0xf0) >> 4];
566 * buf ++ = hex[c & 0x0f];
567 * buf ++ = '>';
568 remaining -= 4;
569 }
570
571 if (remaining == 0)
572 break;
573 }
574
575 * buf = 0;
576 return sec_name_buf;
577}
578
579static const char *
580printable_section_name_from_index (unsigned long ndx)
581{
582 if (ndx >= elf_header.e_shnum)
583 return _("<corrupt>");
584
585 return printable_section_name (section_headers + ndx);
586}
587
89fac5e3
RS		 588/* Return a pointer to section NAME, or NULL if no such section exists. */
589
590static Elf_Internal_Shdr *
2cf0635d 591find_section (const char * name)
89fac5e3
RS		 592{
593 unsigned int i;
594
595 for (i = 0; i < elf_header.e_shnum; i++)
596 if (streq (SECTION_NAME (section_headers + i), name))
597 return section_headers + i;
598
599 return NULL;
600}
601
0b6ae522
DJ		 602/* Return a pointer to a section containing ADDR, or NULL if no such
603 section exists. */
604
605static Elf_Internal_Shdr *
606find_section_by_address (bfd_vma addr)
607{
608 unsigned int i;
609
610 for (i = 0; i < elf_header.e_shnum; i++)
611 {
612 Elf_Internal_Shdr *sec = section_headers + i;
613 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
614 return sec;
615 }
616
617 return NULL;
618}
619
071436c6
NC		 620static Elf_Internal_Shdr *
621find_section_by_type (unsigned int type)
622{
623 unsigned int i;
624
625 for (i = 0; i < elf_header.e_shnum; i++)
626 {
627 Elf_Internal_Shdr *sec = section_headers + i;
628 if (sec->sh_type == type)
629 return sec;
630 }
631
632 return NULL;
633}
634
657d0d47
CC		 635/* Return a pointer to section NAME, or NULL if no such section exists,
636 restricted to the list of sections given in SET. */
637
638static Elf_Internal_Shdr *
639find_section_in_set (const char * name, unsigned int * set)
640{
641 unsigned int i;
642
643 if (set != NULL)
644 {
645 while ((i = *set++) > 0)
646 if (streq (SECTION_NAME (section_headers + i), name))
647 return section_headers + i;
648 }
649
650 return find_section (name);
651}
652
0b6ae522
DJ		 653/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
654 bytes read. */
655
f6f0e17b
NC		 656static inline unsigned long
657read_uleb128 (unsigned char *data,
658 unsigned int *length_return,
659 const unsigned char * const end)
0b6ae522 660{
f6f0e17b 661 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 662}
663
28f997cf
TG		 664/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
665 This OS has so many departures from the ELF standard that we test it at
666 many places. */
667
668static inline int
669is_ia64_vms (void)
670{
671 return elf_header.e_machine == EM_IA_64
672 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
673}
674
bcedfee6 675/* Guess the relocation size commonly used by the specific machines. */
252b5132 676
252b5132 677static int
2dc4cec1 678guess_is_rela (unsigned int e_machine)
252b5132 679{
9c19a809 680 switch (e_machine)
252b5132
RH		 681 {
682 /* Targets that use REL relocations. */
252b5132
RH		 683 case EM_386:
684 case EM_486:
63fcb9e9 685 case EM_960:
e9f53129 686 case EM_ARM:
2b0337b0 687 case EM_D10V:
252b5132 688 case EM_CYGNUS_D10V:
e9f53129 689 case EM_DLX:
252b5132 690 case EM_MIPS:
4fe85591 691 case EM_MIPS_RS3_LE:
e9f53129 692 case EM_CYGNUS_M32R:
1c0d3aa6 693 case EM_SCORE:
f6c1a2d5 694 case EM_XGATE:
9c19a809 695 return FALSE;
103f02d3 696
252b5132
RH		 697 /* Targets that use RELA relocations. */
698 case EM_68K:
e9f53129 699 case EM_860:
a06ea964 700 case EM_AARCH64:
cfb8c092 701 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 702 case EM_ALPHA:
703 case EM_ALTERA_NIOS2:
704 case EM_AVR:
705 case EM_AVR_OLD:
706 case EM_BLACKFIN:
60bca95a 707 case EM_CR16:
e9f53129
AM		 708 case EM_CRIS:
709 case EM_CRX:
2b0337b0 710 case EM_D30V:
252b5132 711 case EM_CYGNUS_D30V:
2b0337b0 712 case EM_FR30:
3f8107ab 713 case EM_FT32:
252b5132 714 case EM_CYGNUS_FR30:
5c70f934 715 case EM_CYGNUS_FRV:
e9f53129
AM		 716 case EM_H8S:
717 case EM_H8_300:
718 case EM_H8_300H:
800eeca4 719 case EM_IA_64:
1e4cf259
NC		 720 case EM_IP2K:
721 case EM_IP2K_OLD:
3b36097d 722 case EM_IQ2000:
84e94c90 723 case EM_LATTICEMICO32:
ff7eeb89 724 case EM_M32C_OLD:
49f58d10 725 case EM_M32C:
e9f53129
AM		 726 case EM_M32R:
727 case EM_MCORE:
15ab5209 728 case EM_CYGNUS_MEP:
a3c62988 729 case EM_METAG:
e9f53129
AM		 730 case EM_MMIX:
731 case EM_MN10200:
732 case EM_CYGNUS_MN10200:
733 case EM_MN10300:
734 case EM_CYGNUS_MN10300:
5506d11a 735 case EM_MOXIE:
e9f53129
AM		 736 case EM_MSP430:
737 case EM_MSP430_OLD:
d031aafb 738 case EM_MT:
35c08157 739 case EM_NDS32:
64fd6348 740 case EM_NIOS32:
73589c9d 741 case EM_OR1K:
e9f53129
AM		 742 case EM_PPC64:
743 case EM_PPC:
99c513f6 744 case EM_RL78:
c7927a3c 745 case EM_RX:
e9f53129
AM		 746 case EM_S390:
747 case EM_S390_OLD:
748 case EM_SH:
749 case EM_SPARC:
750 case EM_SPARC32PLUS:
751 case EM_SPARCV9:
752 case EM_SPU:
40b36596 753 case EM_TI_C6000:
aa137e4d
NC		 754 case EM_TILEGX:
755 case EM_TILEPRO:
708e2187 756 case EM_V800:
e9f53129
AM		 757 case EM_V850:
758 case EM_CYGNUS_V850:
759 case EM_VAX:
619ed720 760 case EM_VISIUM:
e9f53129 761 case EM_X86_64:
8a9036a4 762 case EM_L1OM:
7a9068fe 763 case EM_K1OM:
e9f53129
AM		 764 case EM_XSTORMY16:
765 case EM_XTENSA:
766 case EM_XTENSA_OLD:
7ba29e2a
NC		 767 case EM_MICROBLAZE:
768 case EM_MICROBLAZE_OLD:
9c19a809 769 return TRUE;
103f02d3 770
e9f53129
AM		 771 case EM_68HC05:
772 case EM_68HC08:
773 case EM_68HC11:
774 case EM_68HC16:
775 case EM_FX66:
776 case EM_ME16:
d1133906 777 case EM_MMA:
d1133906
NC		 778 case EM_NCPU:
779 case EM_NDR1:
e9f53129 780 case EM_PCP:
d1133906 781 case EM_ST100:
e9f53129 782 case EM_ST19:
d1133906 783 case EM_ST7:
e9f53129
AM		 784 case EM_ST9PLUS:
785 case EM_STARCORE:
d1133906 786 case EM_SVX:
e9f53129 787 case EM_TINYJ:
9c19a809
NC		 788 default:
789 warn (_("Don't know about relocations on this machine architecture\n"));
790 return FALSE;
791 }
792}
252b5132 793
9c19a809 794static int
2cf0635d 795slurp_rela_relocs (FILE * file,
d3ba0551
AM		 796 unsigned long rel_offset,
797 unsigned long rel_size,
2cf0635d
NC		 798 Elf_Internal_Rela ** relasp,
799 unsigned long * nrelasp)
9c19a809 800{
2cf0635d 801 Elf_Internal_Rela * relas;
8b73c356 802 size_t nrelas;
4d6ed7c8 803 unsigned int i;
252b5132 804
4d6ed7c8
NC		 805 if (is_32bit_elf)
806 {
2cf0635d 807 Elf32_External_Rela * erelas;
103f02d3 808
3f5e193b 809 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 810 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 811 if (!erelas)
812 return 0;
252b5132 813
4d6ed7c8 814 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 815
3f5e193b
NC		 816 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
817 sizeof (Elf_Internal_Rela));
103f02d3 818
4d6ed7c8
NC		 819 if (relas == NULL)
820 {
c256ffe7 821 free (erelas);
591a748a 822 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 823 return 0;
824 }
103f02d3 825
4d6ed7c8
NC		 826 for (i = 0; i < nrelas; i++)
827 {
828 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
829 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 830 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 831 }
103f02d3 832
4d6ed7c8
NC		 833 free (erelas);
834 }
835 else
836 {
2cf0635d 837 Elf64_External_Rela * erelas;
103f02d3 838
3f5e193b 839 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 840 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 841 if (!erelas)
842 return 0;
4d6ed7c8
NC		 843
844 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 845
3f5e193b
NC		 846 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
847 sizeof (Elf_Internal_Rela));
103f02d3 848
4d6ed7c8
NC		 849 if (relas == NULL)
850 {
c256ffe7 851 free (erelas);
591a748a 852 error (_("out of memory parsing relocs\n"));
4d6ed7c8 853 return 0;
9c19a809 854 }
4d6ed7c8
NC		 855
856 for (i = 0; i < nrelas; i++)
9c19a809 857 {
66543521
AM		 858 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
859 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 860 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 861
862 /* The #ifdef BFD64 below is to prevent a compile time
863 warning. We know that if we do not have a 64 bit data
864 type that we will never execute this code anyway. */
865#ifdef BFD64
866 if (elf_header.e_machine == EM_MIPS
867 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
868 {
869 /* In little-endian objects, r_info isn't really a
870 64-bit little-endian value: it has a 32-bit
871 little-endian symbol index followed by four
872 individual byte fields. Reorder INFO
873 accordingly. */
91d6fa6a
NC		 874 bfd_vma inf = relas[i].r_info;
875 inf = (((inf & 0xffffffff) << 32)
876 | ((inf >> 56) & 0xff)
877 | ((inf >> 40) & 0xff00)
878 | ((inf >> 24) & 0xff0000)
879 | ((inf >> 8) & 0xff000000));
880 relas[i].r_info = inf;
861fb55a
DJ		 881 }
882#endif /* BFD64 */
4d6ed7c8 883 }
103f02d3 884
4d6ed7c8
NC		 885 free (erelas);
886 }
887 *relasp = relas;
888 *nrelasp = nrelas;
889 return 1;
890}
103f02d3 891
4d6ed7c8 892static int
2cf0635d 893slurp_rel_relocs (FILE * file,
d3ba0551
AM		 894 unsigned long rel_offset,
895 unsigned long rel_size,
2cf0635d
NC		 896 Elf_Internal_Rela ** relsp,
897 unsigned long * nrelsp)
4d6ed7c8 898{
2cf0635d 899 Elf_Internal_Rela * rels;
8b73c356 900 size_t nrels;
4d6ed7c8 901 unsigned int i;
103f02d3 902
4d6ed7c8
NC		 903 if (is_32bit_elf)
904 {
2cf0635d 905 Elf32_External_Rel * erels;
103f02d3 906
3f5e193b 907 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 908 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 909 if (!erels)
910 return 0;
103f02d3 911
4d6ed7c8 912 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 913
3f5e193b 914 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 915
4d6ed7c8
NC		 916 if (rels == NULL)
917 {
c256ffe7 918 free (erels);
591a748a 919 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 920 return 0;
921 }
922
923 for (i = 0; i < nrels; i++)
924 {
925 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
926 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 927 rels[i].r_addend = 0;
9ea033b2 928 }
4d6ed7c8
NC		 929
930 free (erels);
9c19a809
NC		 931 }
932 else
933 {
2cf0635d 934 Elf64_External_Rel * erels;
9ea033b2 935
3f5e193b 936 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 937 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 938 if (!erels)
939 return 0;
103f02d3 940
4d6ed7c8 941 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 942
3f5e193b 943 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 944
4d6ed7c8 945 if (rels == NULL)
9c19a809 946 {
c256ffe7 947 free (erels);
591a748a 948 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 949 return 0;
950 }
103f02d3 951
4d6ed7c8
NC		 952 for (i = 0; i < nrels; i++)
953 {
66543521
AM		 954 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
955 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 956 rels[i].r_addend = 0;
861fb55a
DJ		 957
958 /* The #ifdef BFD64 below is to prevent a compile time
959 warning. We know that if we do not have a 64 bit data
960 type that we will never execute this code anyway. */
961#ifdef BFD64
962 if (elf_header.e_machine == EM_MIPS
963 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
964 {
965 /* In little-endian objects, r_info isn't really a
966 64-bit little-endian value: it has a 32-bit
967 little-endian symbol index followed by four
968 individual byte fields. Reorder INFO
969 accordingly. */
91d6fa6a
NC		 970 bfd_vma inf = rels[i].r_info;
971 inf = (((inf & 0xffffffff) << 32)
972 | ((inf >> 56) & 0xff)
973 | ((inf >> 40) & 0xff00)
974 | ((inf >> 24) & 0xff0000)
975 | ((inf >> 8) & 0xff000000));
976 rels[i].r_info = inf;
861fb55a
DJ		 977 }
978#endif /* BFD64 */
4d6ed7c8 979 }
103f02d3 980
4d6ed7c8
NC		 981 free (erels);
982 }
983 *relsp = rels;
984 *nrelsp = nrels;
985 return 1;
986}
103f02d3 987
aca88567
NC		 988/* Returns the reloc type extracted from the reloc info field. */
989
990static unsigned int
991get_reloc_type (bfd_vma reloc_info)
992{
993 if (is_32bit_elf)
994 return ELF32_R_TYPE (reloc_info);
995
996 switch (elf_header.e_machine)
997 {
998 case EM_MIPS:
999 /* Note: We assume that reloc_info has already been adjusted for us. */
1000 return ELF64_MIPS_R_TYPE (reloc_info);
1001
1002 case EM_SPARCV9:
1003 return ELF64_R_TYPE_ID (reloc_info);
1004
1005 default:
1006 return ELF64_R_TYPE (reloc_info);
1007 }
1008}
1009
1010/* Return the symbol index extracted from the reloc info field. */
1011
1012static bfd_vma
1013get_reloc_symindex (bfd_vma reloc_info)
1014{
1015 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1016}
1017
13761a11
NC		 1018static inline bfd_boolean
1019uses_msp430x_relocs (void)
1020{
1021 return
1022 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1023 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1024 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1025 /* TI compiler uses ELFOSABI_NONE. */
1026 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1027}
1028
d3ba0551
AM		 1029/* Display the contents of the relocation data found at the specified
1030 offset. */
ee42cf8c 1031
41e92641 1032static void
2cf0635d 1033dump_relocations (FILE * file,
d3ba0551
AM		 1034 unsigned long rel_offset,
1035 unsigned long rel_size,
2cf0635d 1036 Elf_Internal_Sym * symtab,
d3ba0551 1037 unsigned long nsyms,
2cf0635d 1038 char * strtab,
d79b3d50 1039 unsigned long strtablen,
bb4d2ac2
L		 1040 int is_rela,
1041 int is_dynsym)
4d6ed7c8 1042{
b34976b6 1043 unsigned int i;
2cf0635d 1044 Elf_Internal_Rela * rels;
103f02d3 1045
4d6ed7c8
NC		 1046 if (is_rela == UNKNOWN)
1047 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1048
4d6ed7c8
NC		 1049 if (is_rela)
1050 {
c8286bd1 1051 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1052 return;
4d6ed7c8
NC		 1053 }
1054 else
1055 {
1056 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1057 return;
252b5132
RH		 1058 }
1059
410f7a12
L		 1060 if (is_32bit_elf)
1061 {
1062 if (is_rela)
2c71103e
NC		 1063 {
1064 if (do_wide)
1065 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1066 else
1067 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1068 }
410f7a12 1069 else
2c71103e
NC		 1070 {
1071 if (do_wide)
1072 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1073 else
1074 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1075 }
410f7a12 1076 }
252b5132 1077 else
410f7a12
L		 1078 {
1079 if (is_rela)
2c71103e
NC		 1080 {
1081 if (do_wide)
8beeaeb7 1082 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1083 else
1084 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1085 }
410f7a12 1086 else
2c71103e
NC		 1087 {
1088 if (do_wide)
8beeaeb7 1089 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1090 else
1091 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1092 }
410f7a12 1093 }
252b5132
RH		 1094
1095 for (i = 0; i < rel_size; i++)
1096 {
2cf0635d 1097 const char * rtype;
b34976b6 1098 bfd_vma offset;
91d6fa6a 1099 bfd_vma inf;
b34976b6
AM		 1100 bfd_vma symtab_index;
1101 bfd_vma type;
103f02d3 1102
b34976b6 1103 offset = rels[i].r_offset;
91d6fa6a 1104 inf = rels[i].r_info;
103f02d3 1105
91d6fa6a
NC		 1106 type = get_reloc_type (inf);
1107 symtab_index = get_reloc_symindex (inf);
252b5132 1108
410f7a12
L		 1109 if (is_32bit_elf)
1110 {
39dbeff8
AM		 1111 printf ("%8.8lx %8.8lx ",
1112 (unsigned long) offset & 0xffffffff,
91d6fa6a 1113 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1114 }
1115 else
1116 {
39dbeff8
AM		 1117#if BFD_HOST_64BIT_LONG
1118 printf (do_wide
1119 ? "%16.16lx %16.16lx "
1120 : "%12.12lx %12.12lx ",
91d6fa6a 1121 offset, inf);
39dbeff8 1122#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1123#ifndef __MSVCRT__
39dbeff8
AM		 1124 printf (do_wide
1125 ? "%16.16llx %16.16llx "
1126 : "%12.12llx %12.12llx ",
91d6fa6a 1127 offset, inf);
6e3d6dc1
NC		 1128#else
1129 printf (do_wide
1130 ? "%16.16I64x %16.16I64x "
1131 : "%12.12I64x %12.12I64x ",
91d6fa6a 1132 offset, inf);
6e3d6dc1 1133#endif
39dbeff8 1134#else
2c71103e
NC		 1135 printf (do_wide
1136 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1137 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1138 _bfd_int64_high (offset),
1139 _bfd_int64_low (offset),
91d6fa6a
NC		 1140 _bfd_int64_high (inf),
1141 _bfd_int64_low (inf));
9ea033b2 1142#endif
410f7a12 1143 }
103f02d3 1144
252b5132
RH		 1145 switch (elf_header.e_machine)
1146 {
1147 default:
1148 rtype = NULL;
1149 break;
1150
a06ea964
NC		 1151 case EM_AARCH64:
1152 rtype = elf_aarch64_reloc_type (type);
1153 break;
1154
2b0337b0 1155 case EM_M32R:
252b5132 1156 case EM_CYGNUS_M32R:
9ea033b2 1157 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1158 break;
1159
1160 case EM_386:
1161 case EM_486:
9ea033b2 1162 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1163 break;
1164
ba2685cc
AM		 1165 case EM_68HC11:
1166 case EM_68HC12:
1167 rtype = elf_m68hc11_reloc_type (type);
1168 break;
75751cd9 1169
252b5132 1170 case EM_68K:
9ea033b2 1171 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1172 break;
1173
63fcb9e9 1174 case EM_960:
9ea033b2 1175 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1176 break;
1177
adde6300 1178 case EM_AVR:
2b0337b0 1179 case EM_AVR_OLD:
adde6300
AM		 1180 rtype = elf_avr_reloc_type (type);
1181 break;
1182
9ea033b2
NC		 1183 case EM_OLD_SPARCV9:
1184 case EM_SPARC32PLUS:
1185 case EM_SPARCV9:
252b5132 1186 case EM_SPARC:
9ea033b2 1187 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1188 break;
1189
e9f53129
AM		 1190 case EM_SPU:
1191 rtype = elf_spu_reloc_type (type);
1192 break;
1193
708e2187
NC		 1194 case EM_V800:
1195 rtype = v800_reloc_type (type);
1196 break;
2b0337b0 1197 case EM_V850:
252b5132 1198 case EM_CYGNUS_V850:
9ea033b2 1199 rtype = v850_reloc_type (type);
252b5132
RH		 1200 break;
1201
2b0337b0 1202 case EM_D10V:
252b5132 1203 case EM_CYGNUS_D10V:
9ea033b2 1204 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1205 break;
1206
2b0337b0 1207 case EM_D30V:
252b5132 1208 case EM_CYGNUS_D30V:
9ea033b2 1209 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1210 break;
1211
d172d4ba
NC		 1212 case EM_DLX:
1213 rtype = elf_dlx_reloc_type (type);
1214 break;
1215
252b5132 1216 case EM_SH:
9ea033b2 1217 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1218 break;
1219
2b0337b0 1220 case EM_MN10300:
252b5132 1221 case EM_CYGNUS_MN10300:
9ea033b2 1222 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1223 break;
1224
2b0337b0 1225 case EM_MN10200:
252b5132 1226 case EM_CYGNUS_MN10200:
9ea033b2 1227 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1228 break;
1229
2b0337b0 1230 case EM_FR30:
252b5132 1231 case EM_CYGNUS_FR30:
9ea033b2 1232 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1233 break;
1234
ba2685cc
AM		 1235 case EM_CYGNUS_FRV:
1236 rtype = elf_frv_reloc_type (type);
1237 break;
5c70f934 1238
3f8107ab
AM		 1239 case EM_FT32:
1240 rtype = elf_ft32_reloc_type (type);
1241 break;
1242
252b5132 1243 case EM_MCORE:
9ea033b2 1244 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1245 break;
1246
3c3bdf30
NC		 1247 case EM_MMIX:
1248 rtype = elf_mmix_reloc_type (type);
1249 break;
1250
5506d11a
AM		 1251 case EM_MOXIE:
1252 rtype = elf_moxie_reloc_type (type);
1253 break;
1254
2469cfa2 1255 case EM_MSP430:
13761a11
NC		 1256 if (uses_msp430x_relocs ())
1257 {
1258 rtype = elf_msp430x_reloc_type (type);
1259 break;
1260 }
2469cfa2
NC		 1261 case EM_MSP430_OLD:
1262 rtype = elf_msp430_reloc_type (type);
1263 break;
1264
35c08157
KLC		 1265 case EM_NDS32:
1266 rtype = elf_nds32_reloc_type (type);
1267 break;
1268
252b5132 1269 case EM_PPC:
9ea033b2 1270 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1271 break;
1272
c833c019
AM		 1273 case EM_PPC64:
1274 rtype = elf_ppc64_reloc_type (type);
1275 break;
1276
252b5132 1277 case EM_MIPS:
4fe85591 1278 case EM_MIPS_RS3_LE:
9ea033b2 1279 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1280 break;
1281
1282 case EM_ALPHA:
9ea033b2 1283 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1284 break;
1285
1286 case EM_ARM:
9ea033b2 1287 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1288 break;
1289
584da044 1290 case EM_ARC:
9ea033b2 1291 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1292 break;
1293
1294 case EM_PARISC:
69e617ca 1295 rtype = elf_hppa_reloc_type (type);
252b5132 1296 break;
7d466069 1297
b8720f9d
JL		 1298 case EM_H8_300:
1299 case EM_H8_300H:
1300 case EM_H8S:
1301 rtype = elf_h8_reloc_type (type);
1302 break;
1303
73589c9d
CS		 1304 case EM_OR1K:
1305 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1306 break;
1307
7d466069 1308 case EM_PJ:
2b0337b0 1309 case EM_PJ_OLD:
7d466069
ILT		 1310 rtype = elf_pj_reloc_type (type);
1311 break;
800eeca4
JW		 1312 case EM_IA_64:
1313 rtype = elf_ia64_reloc_type (type);
1314 break;
1b61cf92
HPN		 1315
1316 case EM_CRIS:
1317 rtype = elf_cris_reloc_type (type);
1318 break;
535c37ff
JE		 1319
1320 case EM_860:
1321 rtype = elf_i860_reloc_type (type);
1322 break;
bcedfee6
NC		 1323
1324 case EM_X86_64:
8a9036a4 1325 case EM_L1OM:
7a9068fe 1326 case EM_K1OM:
bcedfee6
NC		 1327 rtype = elf_x86_64_reloc_type (type);
1328 break;
a85d7ed0 1329
35b1837e
AM		 1330 case EM_S370:
1331 rtype = i370_reloc_type (type);
1332 break;
1333
53c7db4b
KH		 1334 case EM_S390_OLD:
1335 case EM_S390:
1336 rtype = elf_s390_reloc_type (type);
1337 break;
93fbbb04 1338
1c0d3aa6
NC		 1339 case EM_SCORE:
1340 rtype = elf_score_reloc_type (type);
1341 break;
1342
93fbbb04
GK		 1343 case EM_XSTORMY16:
1344 rtype = elf_xstormy16_reloc_type (type);
1345 break;
179d3252 1346
1fe1f39c
NC		 1347 case EM_CRX:
1348 rtype = elf_crx_reloc_type (type);
1349 break;
1350
179d3252
JT		 1351 case EM_VAX:
1352 rtype = elf_vax_reloc_type (type);
1353 break;
1e4cf259 1354
619ed720
EB		 1355 case EM_VISIUM:
1356 rtype = elf_visium_reloc_type (type);
1357 break;
1358
cfb8c092
NC		 1359 case EM_ADAPTEVA_EPIPHANY:
1360 rtype = elf_epiphany_reloc_type (type);
1361 break;
1362
1e4cf259
NC		 1363 case EM_IP2K:
1364 case EM_IP2K_OLD:
1365 rtype = elf_ip2k_reloc_type (type);
1366 break;
3b36097d
SC		 1367
1368 case EM_IQ2000:
1369 rtype = elf_iq2000_reloc_type (type);
1370 break;
88da6820
NC		 1371
1372 case EM_XTENSA_OLD:
1373 case EM_XTENSA:
1374 rtype = elf_xtensa_reloc_type (type);
1375 break;
a34e3ecb 1376
84e94c90
NC		 1377 case EM_LATTICEMICO32:
1378 rtype = elf_lm32_reloc_type (type);
1379 break;
1380
ff7eeb89 1381 case EM_M32C_OLD:
49f58d10
JB		 1382 case EM_M32C:
1383 rtype = elf_m32c_reloc_type (type);
1384 break;
1385
d031aafb
NS		 1386 case EM_MT:
1387 rtype = elf_mt_reloc_type (type);
a34e3ecb 1388 break;
1d65ded4
CM		 1389
1390 case EM_BLACKFIN:
1391 rtype = elf_bfin_reloc_type (type);
1392 break;
15ab5209
DB		 1393
1394 case EM_CYGNUS_MEP:
1395 rtype = elf_mep_reloc_type (type);
1396 break;
60bca95a
NC		 1397
1398 case EM_CR16:
1399 rtype = elf_cr16_reloc_type (type);
1400 break;
dd24e3da 1401
7ba29e2a
NC		 1402 case EM_MICROBLAZE:
1403 case EM_MICROBLAZE_OLD:
1404 rtype = elf_microblaze_reloc_type (type);
1405 break;
c7927a3c 1406
99c513f6
DD		 1407 case EM_RL78:
1408 rtype = elf_rl78_reloc_type (type);
1409 break;
1410
c7927a3c
NC		 1411 case EM_RX:
1412 rtype = elf_rx_reloc_type (type);
1413 break;
c29aca4a 1414
a3c62988
NC		 1415 case EM_METAG:
1416 rtype = elf_metag_reloc_type (type);
1417 break;
1418
c29aca4a
NC		 1419 case EM_XC16X:
1420 case EM_C166:
1421 rtype = elf_xc16x_reloc_type (type);
1422 break;
40b36596
JM		 1423
1424 case EM_TI_C6000:
1425 rtype = elf_tic6x_reloc_type (type);
1426 break;
aa137e4d
NC		 1427
1428 case EM_TILEGX:
1429 rtype = elf_tilegx_reloc_type (type);
1430 break;
1431
1432 case EM_TILEPRO:
1433 rtype = elf_tilepro_reloc_type (type);
1434 break;
f6c1a2d5
NC		 1435
1436 case EM_XGATE:
1437 rtype = elf_xgate_reloc_type (type);
1438 break;
36591ba1
SL		 1439
1440 case EM_ALTERA_NIOS2:
1441 rtype = elf_nios2_reloc_type (type);
1442 break;
252b5132
RH		 1443 }
1444
1445 if (rtype == NULL)
39dbeff8 1446 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1447 else
8beeaeb7 1448 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1449
7ace3541 1450 if (elf_header.e_machine == EM_ALPHA
157c2599 1451 && rtype != NULL
7ace3541
RH		 1452 && streq (rtype, "R_ALPHA_LITUSE")
1453 && is_rela)
1454 {
1455 switch (rels[i].r_addend)
1456 {
1457 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1458 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1459 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1460 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1461 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1462 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1463 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1464 default: rtype = NULL;
1465 }
1466 if (rtype)
1467 printf (" (%s)", rtype);
1468 else
1469 {
1470 putchar (' ');
1471 printf (_("<unknown addend: %lx>"),
1472 (unsigned long) rels[i].r_addend);
1473 }
1474 }
1475 else if (symtab_index)
252b5132 1476 {
af3fc3bc 1477 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1478 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1479 else
19936277 1480 {
2cf0635d 1481 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1482 const char * version_string;
1483 enum versioned_symbol_info sym_info;
1484 unsigned short vna_other;
19936277 1485
af3fc3bc 1486 psym = symtab + symtab_index;
103f02d3 1487
bb4d2ac2
L		 1488 version_string
1489 = get_symbol_version_string (file, is_dynsym,
1490 strtab, strtablen,
1491 symtab_index,
1492 psym,
1493 &sym_info,
1494 &vna_other);
1495
af3fc3bc 1496 printf (" ");
171191ba 1497
d8045f23
NC		 1498 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1499 {
1500 const char * name;
1501 unsigned int len;
1502 unsigned int width = is_32bit_elf ? 8 : 14;
1503
1504 /* Relocations against GNU_IFUNC symbols do not use the value
1505 of the symbol as the address to relocate against. Instead
1506 they invoke the function named by the symbol and use its
1507 result as the address for relocation.
1508
1509 To indicate this to the user, do not display the value of
1510 the symbol in the "Symbols's Value" field. Instead show
1511 its name followed by () as a hint that the symbol is
1512 invoked. */
1513
1514 if (strtab == NULL
1515 || psym->st_name == 0
1516 || psym->st_name >= strtablen)
1517 name = "??";
1518 else
1519 name = strtab + psym->st_name;
1520
1521 len = print_symbol (width, name);
bb4d2ac2
L		 1522 if (version_string)
1523 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1524 version_string);
d8045f23
NC		 1525 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1526 }
1527 else
1528 {
1529 print_vma (psym->st_value, LONG_HEX);
171191ba 1530
d8045f23
NC		 1531 printf (is_32bit_elf ? " " : " ");
1532 }
103f02d3 1533
af3fc3bc 1534 if (psym->st_name == 0)
f1ef08cb 1535 {
2cf0635d 1536 const char * sec_name = "<null>";
f1ef08cb
AM		 1537 char name_buf[40];
1538
1539 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1540 {
4fbb74a6 1541 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1542 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1543 else if (psym->st_shndx == SHN_ABS)
1544 sec_name = "ABS";
1545 else if (psym->st_shndx == SHN_COMMON)
1546 sec_name = "COMMON";
ac145307
BS		 1547 else if ((elf_header.e_machine == EM_MIPS
1548 && psym->st_shndx == SHN_MIPS_SCOMMON)
1549 || (elf_header.e_machine == EM_TI_C6000
1550 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1551 sec_name = "SCOMMON";
1552 else if (elf_header.e_machine == EM_MIPS
1553 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1554 sec_name = "SUNDEF";
8a9036a4 1555 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1556 || elf_header.e_machine == EM_L1OM
1557 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1558 && psym->st_shndx == SHN_X86_64_LCOMMON)
1559 sec_name = "LARGE_COMMON";
9ce701e2
L		 1560 else if (elf_header.e_machine == EM_IA_64
1561 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1562 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1563 sec_name = "ANSI_COM";
28f997cf 1564 else if (is_ia64_vms ()
148b93f2
NC		 1565 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1566 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1567 else
1568 {
1569 sprintf (name_buf, "<section 0x%x>",
1570 (unsigned int) psym->st_shndx);
1571 sec_name = name_buf;
1572 }
1573 }
1574 print_symbol (22, sec_name);
1575 }
af3fc3bc 1576 else if (strtab == NULL)
d79b3d50 1577 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1578 else if (psym->st_name >= strtablen)
d79b3d50 1579 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1580 else
bb4d2ac2
L		 1581 {
1582 print_symbol (22, strtab + psym->st_name);
1583 if (version_string)
1584 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1585 version_string);
1586 }
103f02d3 1587
af3fc3bc 1588 if (is_rela)
171191ba 1589 {
598aaa76 1590 bfd_signed_vma off = rels[i].r_addend;
171191ba 1591
91d6fa6a 1592 if (off < 0)
598aaa76 1593 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1594 else
598aaa76 1595 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1596 }
19936277 1597 }
252b5132 1598 }
1b228002 1599 else if (is_rela)
f7a99963 1600 {
e04d7088
L		 1601 bfd_signed_vma off = rels[i].r_addend;
1602
1603 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1604 if (off < 0)
1605 printf ("-%" BFD_VMA_FMT "x", - off);
1606 else
1607 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1608 }
252b5132 1609
157c2599
NC		 1610 if (elf_header.e_machine == EM_SPARCV9
1611 && rtype != NULL
1612 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1613 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1614
252b5132 1615 putchar ('\n');
2c71103e 1616
aca88567 1617#ifdef BFD64
53c7db4b 1618 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1619 {
91d6fa6a
NC		 1620 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1621 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1622 const char * rtype2 = elf_mips_reloc_type (type2);
1623 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1624
2c71103e
NC		 1625 printf (" Type2: ");
1626
1627 if (rtype2 == NULL)
39dbeff8
AM		 1628 printf (_("unrecognized: %-7lx"),
1629 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1630 else
1631 printf ("%-17.17s", rtype2);
1632
18bd398b 1633 printf ("\n Type3: ");
2c71103e
NC		 1634
1635 if (rtype3 == NULL)
39dbeff8
AM		 1636 printf (_("unrecognized: %-7lx"),
1637 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1638 else
1639 printf ("%-17.17s", rtype3);
1640
53c7db4b 1641 putchar ('\n');
2c71103e 1642 }
aca88567 1643#endif /* BFD64 */
252b5132
RH		 1644 }
1645
c8286bd1 1646 free (rels);
252b5132
RH		 1647}
1648
1649static const char *
d3ba0551 1650get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1651{
1652 switch (type)
1653 {
1654 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1655 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1656 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1657 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1658 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1659 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1660 case DT_MIPS_MSYM: return "MIPS_MSYM";
1661 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1662 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1663 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1664 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1665 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1666 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1667 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1668 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1669 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1670 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1671 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1672 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1673 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1674 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1675 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1676 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1677 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1678 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1679 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1680 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1681 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1682 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1683 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1684 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1685 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1686 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1687 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1688 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1689 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1690 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1691 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1692 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1693 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1694 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1695 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1696 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1697 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1698 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1699 default:
1700 return NULL;
1701 }
1702}
1703
9a097730 1704static const char *
d3ba0551 1705get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1706{
1707 switch (type)
1708 {
1709 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1710 default:
1711 return NULL;
1712 }
103f02d3
UD		 1713}
1714
7490d522
AM		 1715static const char *
1716get_ppc_dynamic_type (unsigned long type)
1717{
1718 switch (type)
1719 {
a7f2871e 1720 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1721 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1722 default:
1723 return NULL;
1724 }
1725}
1726
f1cb7e17 1727static const char *
d3ba0551 1728get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1729{
1730 switch (type)
1731 {
a7f2871e
AM		 1732 case DT_PPC64_GLINK: return "PPC64_GLINK";
1733 case DT_PPC64_OPD: return "PPC64_OPD";
1734 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1735 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1736 default:
1737 return NULL;
1738 }
1739}
1740
103f02d3 1741static const char *
d3ba0551 1742get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1743{
1744 switch (type)
1745 {
1746 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1747 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1748 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1749 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1750 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1751 case DT_HP_PREINIT: return "HP_PREINIT";
1752 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1753 case DT_HP_NEEDED: return "HP_NEEDED";
1754 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1755 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1756 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1757 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1758 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1759 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1760 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1761 case DT_HP_FILTERED: return "HP_FILTERED";
1762 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1763 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1764 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1765 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1766 case DT_PLT: return "PLT";
1767 case DT_PLT_SIZE: return "PLT_SIZE";
1768 case DT_DLT: return "DLT";
1769 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1770 default:
1771 return NULL;
1772 }
1773}
9a097730 1774
ecc51f48 1775static const char *
d3ba0551 1776get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1777{
1778 switch (type)
1779 {
148b93f2
NC		 1780 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1781 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1782 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1783 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1784 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1785 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1786 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1787 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1788 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1789 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1790 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1791 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1792 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1793 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1794 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1795 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1796 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1797 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1798 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1799 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1800 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1801 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1802 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1803 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1804 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1805 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1806 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1807 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1808 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1809 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1810 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1811 default:
1812 return NULL;
1813 }
1814}
1815
fabcb361
RH		 1816static const char *
1817get_alpha_dynamic_type (unsigned long type)
1818{
1819 switch (type)
1820 {
1821 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1822 default:
1823 return NULL;
1824 }
1825}
1826
1c0d3aa6
NC		 1827static const char *
1828get_score_dynamic_type (unsigned long type)
1829{
1830 switch (type)
1831 {
1832 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1833 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1834 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1835 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1836 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1837 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1838 default:
1839 return NULL;
1840 }
1841}
1842
40b36596
JM		 1843static const char *
1844get_tic6x_dynamic_type (unsigned long type)
1845{
1846 switch (type)
1847 {
1848 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1849 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1850 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1851 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1852 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1853 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1854 default:
1855 return NULL;
1856 }
1857}
1c0d3aa6 1858
36591ba1
SL		 1859static const char *
1860get_nios2_dynamic_type (unsigned long type)
1861{
1862 switch (type)
1863 {
1864 case DT_NIOS2_GP: return "NIOS2_GP";
1865 default:
1866 return NULL;
1867 }
1868}
1869
252b5132 1870static const char *
d3ba0551 1871get_dynamic_type (unsigned long type)
252b5132 1872{
e9e44622 1873 static char buff[64];
252b5132
RH		 1874
1875 switch (type)
1876 {
1877 case DT_NULL: return "NULL";
1878 case DT_NEEDED: return "NEEDED";
1879 case DT_PLTRELSZ: return "PLTRELSZ";
1880 case DT_PLTGOT: return "PLTGOT";
1881 case DT_HASH: return "HASH";
1882 case DT_STRTAB: return "STRTAB";
1883 case DT_SYMTAB: return "SYMTAB";
1884 case DT_RELA: return "RELA";
1885 case DT_RELASZ: return "RELASZ";
1886 case DT_RELAENT: return "RELAENT";
1887 case DT_STRSZ: return "STRSZ";
1888 case DT_SYMENT: return "SYMENT";
1889 case DT_INIT: return "INIT";
1890 case DT_FINI: return "FINI";
1891 case DT_SONAME: return "SONAME";
1892 case DT_RPATH: return "RPATH";
1893 case DT_SYMBOLIC: return "SYMBOLIC";
1894 case DT_REL: return "REL";
1895 case DT_RELSZ: return "RELSZ";
1896 case DT_RELENT: return "RELENT";
1897 case DT_PLTREL: return "PLTREL";
1898 case DT_DEBUG: return "DEBUG";
1899 case DT_TEXTREL: return "TEXTREL";
1900 case DT_JMPREL: return "JMPREL";
1901 case DT_BIND_NOW: return "BIND_NOW";
1902 case DT_INIT_ARRAY: return "INIT_ARRAY";
1903 case DT_FINI_ARRAY: return "FINI_ARRAY";
1904 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1905 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1906 case DT_RUNPATH: return "RUNPATH";
1907 case DT_FLAGS: return "FLAGS";
2d0e6f43 1908
d1133906
NC		 1909 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1910 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1911
05107a46 1912 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1913 case DT_PLTPADSZ: return "PLTPADSZ";
1914 case DT_MOVEENT: return "MOVEENT";
1915 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1916 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1917 case DT_POSFLAG_1: return "POSFLAG_1";
1918 case DT_SYMINSZ: return "SYMINSZ";
1919 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1920
252b5132 1921 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1922 case DT_CONFIG: return "CONFIG";
1923 case DT_DEPAUDIT: return "DEPAUDIT";
1924 case DT_AUDIT: return "AUDIT";
1925 case DT_PLTPAD: return "PLTPAD";
1926 case DT_MOVETAB: return "MOVETAB";
252b5132 1927 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1928
252b5132 1929 case DT_VERSYM: return "VERSYM";
103f02d3 1930
67a4f2b7
AO		 1931 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1932 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1933 case DT_RELACOUNT: return "RELACOUNT";
1934 case DT_RELCOUNT: return "RELCOUNT";
1935 case DT_FLAGS_1: return "FLAGS_1";
1936 case DT_VERDEF: return "VERDEF";
1937 case DT_VERDEFNUM: return "VERDEFNUM";
1938 case DT_VERNEED: return "VERNEED";
1939 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1940
019148e4 1941 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1942 case DT_USED: return "USED";
1943 case DT_FILTER: return "FILTER";
103f02d3 1944
047b2264
JJ		 1945 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1946 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1947 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1948 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1949 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1950 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1951
252b5132
RH		 1952 default:
1953 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1954 {
2cf0635d 1955 const char * result;
103f02d3 1956
252b5132
RH		 1957 switch (elf_header.e_machine)
1958 {
1959 case EM_MIPS:
4fe85591 1960 case EM_MIPS_RS3_LE:
252b5132
RH		 1961 result = get_mips_dynamic_type (type);
1962 break;
9a097730
RH		 1963 case EM_SPARCV9:
1964 result = get_sparc64_dynamic_type (type);
1965 break;
7490d522
AM		 1966 case EM_PPC:
1967 result = get_ppc_dynamic_type (type);
1968 break;
f1cb7e17
AM		 1969 case EM_PPC64:
1970 result = get_ppc64_dynamic_type (type);
1971 break;
ecc51f48
NC		 1972 case EM_IA_64:
1973 result = get_ia64_dynamic_type (type);
1974 break;
fabcb361
RH		 1975 case EM_ALPHA:
1976 result = get_alpha_dynamic_type (type);
1977 break;
1c0d3aa6
NC		 1978 case EM_SCORE:
1979 result = get_score_dynamic_type (type);
1980 break;
40b36596
JM		 1981 case EM_TI_C6000:
1982 result = get_tic6x_dynamic_type (type);
1983 break;
36591ba1
SL		 1984 case EM_ALTERA_NIOS2:
1985 result = get_nios2_dynamic_type (type);
1986 break;
252b5132
RH		 1987 default:
1988 result = NULL;
1989 break;
1990 }
1991
1992 if (result != NULL)
1993 return result;
1994
e9e44622 1995 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1996 }
eec8f817
DA		 1997 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1998 || (elf_header.e_machine == EM_PARISC
1999 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2000 {
2cf0635d 2001 const char * result;
103f02d3
UD		 2002
2003 switch (elf_header.e_machine)
2004 {
2005 case EM_PARISC:
2006 result = get_parisc_dynamic_type (type);
2007 break;
148b93f2
NC		 2008 case EM_IA_64:
2009 result = get_ia64_dynamic_type (type);
2010 break;
103f02d3
UD		 2011 default:
2012 result = NULL;
2013 break;
2014 }
2015
2016 if (result != NULL)
2017 return result;
2018
e9e44622
JJ		 2019 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2020 type);
103f02d3 2021 }
252b5132 2022 else
e9e44622 2023 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2024
252b5132
RH		 2025 return buff;
2026 }
2027}
2028
2029static char *
d3ba0551 2030get_file_type (unsigned e_type)
252b5132 2031{
b34976b6 2032 static char buff[32];
252b5132
RH		 2033
2034 switch (e_type)
2035 {
2036 case ET_NONE: return _("NONE (None)");
2037 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2038 case ET_EXEC: return _("EXEC (Executable file)");
2039 case ET_DYN: return _("DYN (Shared object file)");
2040 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2041
2042 default:
2043 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2044 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2045 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2046 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2047 else
e9e44622 2048 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2049 return buff;
2050 }
2051}
2052
2053static char *
d3ba0551 2054get_machine_name (unsigned e_machine)
252b5132 2055{
b34976b6 2056 static char buff[64]; /* XXX */
252b5132
RH		 2057
2058 switch (e_machine)
2059 {
c45021f2 2060 case EM_NONE: return _("None");
a06ea964 2061 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2062 case EM_M32: return "WE32100";
2063 case EM_SPARC: return "Sparc";
e9f53129 2064 case EM_SPU: return "SPU";
c45021f2
NC		 2065 case EM_386: return "Intel 80386";
2066 case EM_68K: return "MC68000";
2067 case EM_88K: return "MC88000";
2068 case EM_486: return "Intel 80486";
2069 case EM_860: return "Intel 80860";
2070 case EM_MIPS: return "MIPS R3000";
2071 case EM_S370: return "IBM System/370";
7036c0e1 2072 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2073 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2074 case EM_PARISC: return "HPPA";
252b5132 2075 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2076 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2077 case EM_960: return "Intel 90860";
2078 case EM_PPC: return "PowerPC";
285d1771 2079 case EM_PPC64: return "PowerPC64";
c45021f2 2080 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2081 case EM_FT32: return "FTDI FT32";
c45021f2 2082 case EM_RH32: return "TRW RH32";
b34976b6 2083 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2084 case EM_ARM: return "ARM";
2085 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2086 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2087 case EM_SPARCV9: return "Sparc v9";
2088 case EM_TRICORE: return "Siemens Tricore";
584da044 2089 case EM_ARC: return "ARC";
c2dcd04e
NC		 2090 case EM_H8_300: return "Renesas H8/300";
2091 case EM_H8_300H: return "Renesas H8/300H";
2092 case EM_H8S: return "Renesas H8S";
2093 case EM_H8_500: return "Renesas H8/500";
30800947 2094 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2095 case EM_MIPS_X: return "Stanford MIPS-X";
2096 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2097 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2098 case EM_CYGNUS_D10V:
2099 case EM_D10V: return "d10v";
2100 case EM_CYGNUS_D30V:
b34976b6 2101 case EM_D30V: return "d30v";
2b0337b0 2102 case EM_CYGNUS_M32R:
26597c86 2103 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2104 case EM_CYGNUS_V850:
708e2187 2105 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2106 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2107 case EM_CYGNUS_MN10300:
2108 case EM_MN10300: return "mn10300";
2109 case EM_CYGNUS_MN10200:
2110 case EM_MN10200: return "mn10200";
5506d11a 2111 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2112 case EM_CYGNUS_FR30:
2113 case EM_FR30: return "Fujitsu FR30";
b34976b6 2114 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2115 case EM_PJ_OLD:
b34976b6 2116 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2117 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2118 case EM_PCP: return "Siemens PCP";
2119 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2120 case EM_NDR1: return "Denso NDR1 microprocesspr";
2121 case EM_STARCORE: return "Motorola Star*Core processor";
2122 case EM_ME16: return "Toyota ME16 processor";
2123 case EM_ST100: return "STMicroelectronics ST100 processor";
2124 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2125 case EM_PDSP: return "Sony DSP processor";
2126 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2127 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2128 case EM_FX66: return "Siemens FX66 microcontroller";
2129 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2130 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2131 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2132 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2133 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2134 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2135 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2136 case EM_SVX: return "Silicon Graphics SVx";
2137 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2138 case EM_VAX: return "Digital VAX";
619ed720 2139 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2140 case EM_AVR_OLD:
b34976b6 2141 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2142 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2143 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2144 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2145 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2146 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2147 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2148 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2149 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2150 case EM_L1OM: return "Intel L1OM";
7a9068fe 2151 case EM_K1OM: return "Intel K1OM";
b7498e0e 2152 case EM_S390_OLD:
b34976b6 2153 case EM_S390: return "IBM S/390";
1c0d3aa6 2154 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2155 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2156 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2157 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2158 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2159 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2160 case EM_DLX: return "OpenDLX";
1e4cf259 2161 case EM_IP2K_OLD:
b34976b6 2162 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2163 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2164 case EM_XTENSA_OLD:
2165 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2166 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2167 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2168 case EM_NS32K: return "National Semiconductor 32000 series";
2169 case EM_TPC: return "Tenor Network TPC processor";
2170 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2171 case EM_MAX: return "MAX Processor";
2172 case EM_CR: return "National Semiconductor CompactRISC";
2173 case EM_F2MC16: return "Fujitsu F2MC16";
2174 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2175 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2176 case EM_M32C_OLD:
49f58d10 2177 case EM_M32C: return "Renesas M32c";
d031aafb 2178 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2179 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2180 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2181 case EM_SEP: return "Sharp embedded microprocessor";
2182 case EM_ARCA: return "Arca RISC microprocessor";
2183 case EM_UNICORE: return "Unicore";
2184 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2185 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2186 case EM_NIOS32: return "Altera Nios";
2187 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2188 case EM_C166:
d70c5fc7 2189 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2190 case EM_M16C: return "Renesas M16C series microprocessors";
2191 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2192 case EM_CE: return "Freescale Communication Engine RISC core";
2193 case EM_TSK3000: return "Altium TSK3000 core";
2194 case EM_RS08: return "Freescale RS08 embedded processor";
2195 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2196 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2197 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2198 case EM_SE_C17: return "Seiko Epson C17 family";
2199 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2200 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2201 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2202 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2203 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2204 case EM_R32C: return "Renesas R32C series microprocessors";
2205 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2206 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2207 case EM_8051: return "Intel 8051 and variants";
2208 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2209 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2210 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2211 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2212 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2213 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2214 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2215 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2216 case EM_CR16:
f6c1a2d5 2217 case EM_MICROBLAZE:
7ba29e2a 2218 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2219 case EM_RL78: return "Renesas RL78";
c7927a3c 2220 case EM_RX: return "Renesas RX";
a3c62988 2221 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2222 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2223 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2224 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2225 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2226 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2227 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2228 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2229 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2230 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2231 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2232 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2233 default:
35d9dd2f 2234 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2235 return buff;
2236 }
2237}
2238
f3485b74 2239static void
d3ba0551 2240decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2241{
2242 unsigned eabi;
2243 int unknown = 0;
2244
2245 eabi = EF_ARM_EABI_VERSION (e_flags);
2246 e_flags &= ~ EF_ARM_EABIMASK;
2247
2248 /* Handle "generic" ARM flags. */
2249 if (e_flags & EF_ARM_RELEXEC)
2250 {
2251 strcat (buf, ", relocatable executable");
2252 e_flags &= ~ EF_ARM_RELEXEC;
2253 }
76da6bbe 2254
f3485b74
NC		 2255 if (e_flags & EF_ARM_HASENTRY)
2256 {
2257 strcat (buf, ", has entry point");
2258 e_flags &= ~ EF_ARM_HASENTRY;
2259 }
76da6bbe 2260
f3485b74
NC		 2261 /* Now handle EABI specific flags. */
2262 switch (eabi)
2263 {
2264 default:
2c71103e 2265 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2266 if (e_flags)
2267 unknown = 1;
2268 break;
2269
2270 case EF_ARM_EABI_VER1:
a5bcd848 2271 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2272 while (e_flags)
2273 {
2274 unsigned flag;
76da6bbe 2275
f3485b74
NC		 2276 /* Process flags one bit at a time. */
2277 flag = e_flags & - e_flags;
2278 e_flags &= ~ flag;
76da6bbe 2279
f3485b74
NC		 2280 switch (flag)
2281 {
a5bcd848 2282 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2283 strcat (buf, ", sorted symbol tables");
2284 break;
76da6bbe 2285
f3485b74
NC		 2286 default:
2287 unknown = 1;
2288 break;
2289 }
2290 }
2291 break;
76da6bbe 2292
a5bcd848
PB		 2293 case EF_ARM_EABI_VER2:
2294 strcat (buf, ", Version2 EABI");
2295 while (e_flags)
2296 {
2297 unsigned flag;
2298
2299 /* Process flags one bit at a time. */
2300 flag = e_flags & - e_flags;
2301 e_flags &= ~ flag;
2302
2303 switch (flag)
2304 {
2305 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2306 strcat (buf, ", sorted symbol tables");
2307 break;
2308
2309 case EF_ARM_DYNSYMSUSESEGIDX:
2310 strcat (buf, ", dynamic symbols use segment index");
2311 break;
2312
2313 case EF_ARM_MAPSYMSFIRST:
2314 strcat (buf, ", mapping symbols precede others");
2315 break;
2316
2317 default:
2318 unknown = 1;
2319 break;
2320 }
2321 }
2322 break;
2323
d507cf36
PB		 2324 case EF_ARM_EABI_VER3:
2325 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2326 break;
2327
2328 case EF_ARM_EABI_VER4:
2329 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2330 while (e_flags)
2331 {
2332 unsigned flag;
2333
2334 /* Process flags one bit at a time. */
2335 flag = e_flags & - e_flags;
2336 e_flags &= ~ flag;
2337
2338 switch (flag)
2339 {
2340 case EF_ARM_BE8:
2341 strcat (buf, ", BE8");
2342 break;
2343
2344 case EF_ARM_LE8:
2345 strcat (buf, ", LE8");
2346 break;
2347
2348 default:
2349 unknown = 1;
2350 break;
2351 }
2352 break;
2353 }
2354 break;
3a4a14e9
PB		 2355
2356 case EF_ARM_EABI_VER5:
2357 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2358 while (e_flags)
2359 {
2360 unsigned flag;
2361
2362 /* Process flags one bit at a time. */
2363 flag = e_flags & - e_flags;
2364 e_flags &= ~ flag;
2365
2366 switch (flag)
2367 {
2368 case EF_ARM_BE8:
2369 strcat (buf, ", BE8");
2370 break;
2371
2372 case EF_ARM_LE8:
2373 strcat (buf, ", LE8");
2374 break;
2375
3bfcb652
NC		 2376 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2377 strcat (buf, ", soft-float ABI");
2378 break;
2379
2380 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2381 strcat (buf, ", hard-float ABI");
2382 break;
2383
d507cf36
PB		 2384 default:
2385 unknown = 1;
2386 break;
2387 }
2388 }
2389 break;
2390
f3485b74 2391 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2392 strcat (buf, ", GNU EABI");
f3485b74
NC		 2393 while (e_flags)
2394 {
2395 unsigned flag;
76da6bbe 2396
f3485b74
NC		 2397 /* Process flags one bit at a time. */
2398 flag = e_flags & - e_flags;
2399 e_flags &= ~ flag;
76da6bbe 2400
f3485b74
NC		 2401 switch (flag)
2402 {
a5bcd848 2403 case EF_ARM_INTERWORK:
f3485b74
NC		 2404 strcat (buf, ", interworking enabled");
2405 break;
76da6bbe 2406
a5bcd848 2407 case EF_ARM_APCS_26:
f3485b74
NC		 2408 strcat (buf, ", uses APCS/26");
2409 break;
76da6bbe 2410
a5bcd848 2411 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2412 strcat (buf, ", uses APCS/float");
2413 break;
76da6bbe 2414
a5bcd848 2415 case EF_ARM_PIC:
f3485b74
NC		 2416 strcat (buf, ", position independent");
2417 break;
76da6bbe 2418
a5bcd848 2419 case EF_ARM_ALIGN8:
f3485b74
NC		 2420 strcat (buf, ", 8 bit structure alignment");
2421 break;
76da6bbe 2422
a5bcd848 2423 case EF_ARM_NEW_ABI:
f3485b74
NC		 2424 strcat (buf, ", uses new ABI");
2425 break;
76da6bbe 2426
a5bcd848 2427 case EF_ARM_OLD_ABI:
f3485b74
NC		 2428 strcat (buf, ", uses old ABI");
2429 break;
76da6bbe 2430
a5bcd848 2431 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2432 strcat (buf, ", software FP");
2433 break;
76da6bbe 2434
90e01f86
ILT		 2435 case EF_ARM_VFP_FLOAT:
2436 strcat (buf, ", VFP");
2437 break;
2438
fde78edd
NC		 2439 case EF_ARM_MAVERICK_FLOAT:
2440 strcat (buf, ", Maverick FP");
2441 break;
2442
f3485b74
NC		 2443 default:
2444 unknown = 1;
2445 break;
2446 }
2447 }
2448 }
f3485b74
NC		 2449
2450 if (unknown)
2b692964 2451 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2452}
2453
343433df
AB		 2454static void
2455decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2456{
2457 --size; /* Leave space for null terminator. */
2458
2459 switch (e_flags & EF_AVR_MACH)
2460 {
2461 case E_AVR_MACH_AVR1:
2462 strncat (buf, ", avr:1", size);
2463 break;
2464 case E_AVR_MACH_AVR2:
2465 strncat (buf, ", avr:2", size);
2466 break;
2467 case E_AVR_MACH_AVR25:
2468 strncat (buf, ", avr:25", size);
2469 break;
2470 case E_AVR_MACH_AVR3:
2471 strncat (buf, ", avr:3", size);
2472 break;
2473 case E_AVR_MACH_AVR31:
2474 strncat (buf, ", avr:31", size);
2475 break;
2476 case E_AVR_MACH_AVR35:
2477 strncat (buf, ", avr:35", size);
2478 break;
2479 case E_AVR_MACH_AVR4:
2480 strncat (buf, ", avr:4", size);
2481 break;
2482 case E_AVR_MACH_AVR5:
2483 strncat (buf, ", avr:5", size);
2484 break;
2485 case E_AVR_MACH_AVR51:
2486 strncat (buf, ", avr:51", size);
2487 break;
2488 case E_AVR_MACH_AVR6:
2489 strncat (buf, ", avr:6", size);
2490 break;
2491 case E_AVR_MACH_AVRTINY:
2492 strncat (buf, ", avr:100", size);
2493 break;
2494 case E_AVR_MACH_XMEGA1:
2495 strncat (buf, ", avr:101", size);
2496 break;
2497 case E_AVR_MACH_XMEGA2:
2498 strncat (buf, ", avr:102", size);
2499 break;
2500 case E_AVR_MACH_XMEGA3:
2501 strncat (buf, ", avr:103", size);
2502 break;
2503 case E_AVR_MACH_XMEGA4:
2504 strncat (buf, ", avr:104", size);
2505 break;
2506 case E_AVR_MACH_XMEGA5:
2507 strncat (buf, ", avr:105", size);
2508 break;
2509 case E_AVR_MACH_XMEGA6:
2510 strncat (buf, ", avr:106", size);
2511 break;
2512 case E_AVR_MACH_XMEGA7:
2513 strncat (buf, ", avr:107", size);
2514 break;
2515 default:
2516 strncat (buf, ", avr:<unknown>", size);
2517 break;
2518 }
2519
2520 size -= strlen (buf);
2521 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2522 strncat (buf, ", link-relax", size);
2523}
2524
35c08157
KLC		 2525static void
2526decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2527{
2528 unsigned abi;
2529 unsigned arch;
2530 unsigned config;
2531 unsigned version;
2532 int has_fpu = 0;
2533 int r = 0;
2534
2535 static const char *ABI_STRINGS[] =
2536 {
2537 "ABI v0", /* use r5 as return register; only used in N1213HC */
2538 "ABI v1", /* use r0 as return register */
2539 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2540 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2541 "AABI",
2542 "ABI2 FP+"
35c08157
KLC		 2543 };
2544 static const char *VER_STRINGS[] =
2545 {
2546 "Andes ELF V1.3 or older",
2547 "Andes ELF V1.3.1",
2548 "Andes ELF V1.4"
2549 };
2550 static const char *ARCH_STRINGS[] =
2551 {
2552 "",
2553 "Andes Star v1.0",
2554 "Andes Star v2.0",
2555 "Andes Star v3.0",
2556 "Andes Star v3.0m"
2557 };
2558
2559 abi = EF_NDS_ABI & e_flags;
2560 arch = EF_NDS_ARCH & e_flags;
2561 config = EF_NDS_INST & e_flags;
2562 version = EF_NDS32_ELF_VERSION & e_flags;
2563
2564 memset (buf, 0, size);
2565
2566 switch (abi)
2567 {
2568 case E_NDS_ABI_V0:
2569 case E_NDS_ABI_V1:
2570 case E_NDS_ABI_V2:
2571 case E_NDS_ABI_V2FP:
2572 case E_NDS_ABI_AABI:
40c7a7cb 2573 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2574 /* In case there are holes in the array. */
2575 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2576 break;
2577
2578 default:
2579 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2580 break;
2581 }
2582
2583 switch (version)
2584 {
2585 case E_NDS32_ELF_VER_1_2:
2586 case E_NDS32_ELF_VER_1_3:
2587 case E_NDS32_ELF_VER_1_4:
2588 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2589 break;
2590
2591 default:
2592 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2593 break;
2594 }
2595
2596 if (E_NDS_ABI_V0 == abi)
2597 {
2598 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2599 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2600 if (arch == E_NDS_ARCH_STAR_V1_0)
2601 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2602 return;
2603 }
2604
2605 switch (arch)
2606 {
2607 case E_NDS_ARCH_STAR_V1_0:
2608 case E_NDS_ARCH_STAR_V2_0:
2609 case E_NDS_ARCH_STAR_V3_0:
2610 case E_NDS_ARCH_STAR_V3_M:
2611 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2612 break;
2613
2614 default:
2615 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2616 /* ARCH version determines how the e_flags are interpreted.
2617 If it is unknown, we cannot proceed. */
2618 return;
2619 }
2620
2621 /* Newer ABI; Now handle architecture specific flags. */
2622 if (arch == E_NDS_ARCH_STAR_V1_0)
2623 {
2624 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2625 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2626
2627 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2628 r += snprintf (buf + r, size -r, ", MAC");
2629
2630 if (config & E_NDS32_HAS_DIV_INST)
2631 r += snprintf (buf + r, size -r, ", DIV");
2632
2633 if (config & E_NDS32_HAS_16BIT_INST)
2634 r += snprintf (buf + r, size -r, ", 16b");
2635 }
2636 else
2637 {
2638 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2639 {
2640 if (version <= E_NDS32_ELF_VER_1_3)
2641 r += snprintf (buf + r, size -r, ", [B8]");
2642 else
2643 r += snprintf (buf + r, size -r, ", EX9");
2644 }
2645
2646 if (config & E_NDS32_HAS_MAC_DX_INST)
2647 r += snprintf (buf + r, size -r, ", MAC_DX");
2648
2649 if (config & E_NDS32_HAS_DIV_DX_INST)
2650 r += snprintf (buf + r, size -r, ", DIV_DX");
2651
2652 if (config & E_NDS32_HAS_16BIT_INST)
2653 {
2654 if (version <= E_NDS32_ELF_VER_1_3)
2655 r += snprintf (buf + r, size -r, ", 16b");
2656 else
2657 r += snprintf (buf + r, size -r, ", IFC");
2658 }
2659 }
2660
2661 if (config & E_NDS32_HAS_EXT_INST)
2662 r += snprintf (buf + r, size -r, ", PERF1");
2663
2664 if (config & E_NDS32_HAS_EXT2_INST)
2665 r += snprintf (buf + r, size -r, ", PERF2");
2666
2667 if (config & E_NDS32_HAS_FPU_INST)
2668 {
2669 has_fpu = 1;
2670 r += snprintf (buf + r, size -r, ", FPU_SP");
2671 }
2672
2673 if (config & E_NDS32_HAS_FPU_DP_INST)
2674 {
2675 has_fpu = 1;
2676 r += snprintf (buf + r, size -r, ", FPU_DP");
2677 }
2678
2679 if (config & E_NDS32_HAS_FPU_MAC_INST)
2680 {
2681 has_fpu = 1;
2682 r += snprintf (buf + r, size -r, ", FPU_MAC");
2683 }
2684
2685 if (has_fpu)
2686 {
2687 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2688 {
2689 case E_NDS32_FPU_REG_8SP_4DP:
2690 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2691 break;
2692 case E_NDS32_FPU_REG_16SP_8DP:
2693 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2694 break;
2695 case E_NDS32_FPU_REG_32SP_16DP:
2696 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2697 break;
2698 case E_NDS32_FPU_REG_32SP_32DP:
2699 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2700 break;
2701 }
2702 }
2703
2704 if (config & E_NDS32_HAS_AUDIO_INST)
2705 r += snprintf (buf + r, size -r, ", AUDIO");
2706
2707 if (config & E_NDS32_HAS_STRING_INST)
2708 r += snprintf (buf + r, size -r, ", STR");
2709
2710 if (config & E_NDS32_HAS_REDUCED_REGS)
2711 r += snprintf (buf + r, size -r, ", 16REG");
2712
2713 if (config & E_NDS32_HAS_VIDEO_INST)
2714 {
2715 if (version <= E_NDS32_ELF_VER_1_3)
2716 r += snprintf (buf + r, size -r, ", VIDEO");
2717 else
2718 r += snprintf (buf + r, size -r, ", SATURATION");
2719 }
2720
2721 if (config & E_NDS32_HAS_ENCRIPT_INST)
2722 r += snprintf (buf + r, size -r, ", ENCRP");
2723
2724 if (config & E_NDS32_HAS_L2C_INST)
2725 r += snprintf (buf + r, size -r, ", L2C");
2726}
2727
252b5132 2728static char *
d3ba0551 2729get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2730{
b34976b6 2731 static char buf[1024];
252b5132
RH		 2732
2733 buf[0] = '\0';
76da6bbe 2734
252b5132
RH		 2735 if (e_flags)
2736 {
2737 switch (e_machine)
2738 {
2739 default:
2740 break;
2741
f3485b74
NC		 2742 case EM_ARM:
2743 decode_ARM_machine_flags (e_flags, buf);
2744 break;
76da6bbe 2745
343433df
AB		 2746 case EM_AVR:
2747 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2748 break;
2749
781303ce
MF		 2750 case EM_BLACKFIN:
2751 if (e_flags & EF_BFIN_PIC)
2752 strcat (buf, ", PIC");
2753
2754 if (e_flags & EF_BFIN_FDPIC)
2755 strcat (buf, ", FDPIC");
2756
2757 if (e_flags & EF_BFIN_CODE_IN_L1)
2758 strcat (buf, ", code in L1");
2759
2760 if (e_flags & EF_BFIN_DATA_IN_L1)
2761 strcat (buf, ", data in L1");
2762
2763 break;
2764
ec2dfb42
AO		 2765 case EM_CYGNUS_FRV:
2766 switch (e_flags & EF_FRV_CPU_MASK)
2767 {
2768 case EF_FRV_CPU_GENERIC:
2769 break;
2770
2771 default:
2772 strcat (buf, ", fr???");
2773 break;
57346661 2774
ec2dfb42
AO		 2775 case EF_FRV_CPU_FR300:
2776 strcat (buf, ", fr300");
2777 break;
2778
2779 case EF_FRV_CPU_FR400:
2780 strcat (buf, ", fr400");
2781 break;
2782 case EF_FRV_CPU_FR405:
2783 strcat (buf, ", fr405");
2784 break;
2785
2786 case EF_FRV_CPU_FR450:
2787 strcat (buf, ", fr450");
2788 break;
2789
2790 case EF_FRV_CPU_FR500:
2791 strcat (buf, ", fr500");
2792 break;
2793 case EF_FRV_CPU_FR550:
2794 strcat (buf, ", fr550");
2795 break;
2796
2797 case EF_FRV_CPU_SIMPLE:
2798 strcat (buf, ", simple");
2799 break;
2800 case EF_FRV_CPU_TOMCAT:
2801 strcat (buf, ", tomcat");
2802 break;
2803 }
1c877e87 2804 break;
ec2dfb42 2805
53c7db4b 2806 case EM_68K:
425c6cb0 2807 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2808 strcat (buf, ", m68000");
425c6cb0 2809 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2810 strcat (buf, ", cpu32");
2811 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2812 strcat (buf, ", fido_a");
425c6cb0 2813 else
266abb8f 2814 {
2cf0635d
NC		 2815 char const * isa = _("unknown");
2816 char const * mac = _("unknown mac");
2817 char const * additional = NULL;
0112cd26 2818
c694fd50 2819 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2820 {
c694fd50 2821 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2822 isa = "A";
2823 additional = ", nodiv";
2824 break;
c694fd50 2825 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2826 isa = "A";
2827 break;
c694fd50 2828 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2829 isa = "A+";
2830 break;
c694fd50 2831 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2832 isa = "B";
2833 additional = ", nousp";
2834 break;
c694fd50 2835 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2836 isa = "B";
2837 break;
f608cd77
NS		 2838 case EF_M68K_CF_ISA_C:
2839 isa = "C";
2840 break;
2841 case EF_M68K_CF_ISA_C_NODIV:
2842 isa = "C";
2843 additional = ", nodiv";
2844 break;
266abb8f
NS		 2845 }
2846 strcat (buf, ", cf, isa ");
2847 strcat (buf, isa);
0b2e31dc
NS		 2848 if (additional)
2849 strcat (buf, additional);
c694fd50 2850 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2851 strcat (buf, ", float");
c694fd50 2852 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2853 {
2854 case 0:
2855 mac = NULL;
2856 break;
c694fd50 2857 case EF_M68K_CF_MAC:
266abb8f
NS		 2858 mac = "mac";
2859 break;
c694fd50 2860 case EF_M68K_CF_EMAC:
266abb8f
NS		 2861 mac = "emac";
2862 break;
f608cd77
NS		 2863 case EF_M68K_CF_EMAC_B:
2864 mac = "emac_b";
2865 break;
266abb8f
NS		 2866 }
2867 if (mac)
2868 {
2869 strcat (buf, ", ");
2870 strcat (buf, mac);
2871 }
266abb8f 2872 }
53c7db4b 2873 break;
33c63f9d 2874
252b5132
RH		 2875 case EM_PPC:
2876 if (e_flags & EF_PPC_EMB)
2877 strcat (buf, ", emb");
2878
2879 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2880 strcat (buf, _(", relocatable"));
252b5132
RH		 2881
2882 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2883 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2884 break;
2885
ee67d69a
AM		 2886 case EM_PPC64:
2887 if (e_flags & EF_PPC64_ABI)
2888 {
2889 char abi[] = ", abiv0";
2890
2891 abi[6] += e_flags & EF_PPC64_ABI;
2892 strcat (buf, abi);
2893 }
2894 break;
2895
708e2187
NC		 2896 case EM_V800:
2897 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2898 strcat (buf, ", RH850 ABI");
0b4362b0 2899
708e2187
NC		 2900 if (e_flags & EF_V800_850E3)
2901 strcat (buf, ", V3 architecture");
2902
2903 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2904 strcat (buf, ", FPU not used");
2905
2906 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2907 strcat (buf, ", regmode: COMMON");
2908
2909 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2910 strcat (buf, ", r4 not used");
2911
2912 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2913 strcat (buf, ", r30 not used");
2914
2915 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2916 strcat (buf, ", r5 not used");
2917
2918 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2919 strcat (buf, ", r2 not used");
2920
2921 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2922 {
2923 switch (e_flags & - e_flags)
2924 {
2925 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2926 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2927 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2928 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2929 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2930 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2931 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2932 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2933 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2934 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2935 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2936 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2937 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2938 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2939 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2940 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2941 default: break;
2942 }
2943 }
2944 break;
2945
2b0337b0 2946 case EM_V850:
252b5132
RH		 2947 case EM_CYGNUS_V850:
2948 switch (e_flags & EF_V850_ARCH)
2949 {
78c8d46c
NC		 2950 case E_V850E3V5_ARCH:
2951 strcat (buf, ", v850e3v5");
2952 break;
1cd986c5
NC		 2953 case E_V850E2V3_ARCH:
2954 strcat (buf, ", v850e2v3");
2955 break;
2956 case E_V850E2_ARCH:
2957 strcat (buf, ", v850e2");
2958 break;
2959 case E_V850E1_ARCH:
2960 strcat (buf, ", v850e1");
8ad30312 2961 break;
252b5132
RH		 2962 case E_V850E_ARCH:
2963 strcat (buf, ", v850e");
2964 break;
252b5132
RH		 2965 case E_V850_ARCH:
2966 strcat (buf, ", v850");
2967 break;
2968 default:
2b692964 2969 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2970 break;
2971 }
2972 break;
2973
2b0337b0 2974 case EM_M32R:
252b5132
RH		 2975 case EM_CYGNUS_M32R:
2976 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2977 strcat (buf, ", m32r");
252b5132
RH		 2978 break;
2979
2980 case EM_MIPS:
4fe85591 2981 case EM_MIPS_RS3_LE:
252b5132
RH		 2982 if (e_flags & EF_MIPS_NOREORDER)
2983 strcat (buf, ", noreorder");
2984
2985 if (e_flags & EF_MIPS_PIC)
2986 strcat (buf, ", pic");
2987
2988 if (e_flags & EF_MIPS_CPIC)
2989 strcat (buf, ", cpic");
2990
d1bdd336
TS		 2991 if (e_flags & EF_MIPS_UCODE)
2992 strcat (buf, ", ugen_reserved");
2993
252b5132
RH		 2994 if (e_flags & EF_MIPS_ABI2)
2995 strcat (buf, ", abi2");
2996
43521d43
TS		 2997 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2998 strcat (buf, ", odk first");
2999
a5d22d2a
TS		 3000 if (e_flags & EF_MIPS_32BITMODE)
3001 strcat (buf, ", 32bitmode");
3002
ba92f887
MR		 3003 if (e_flags & EF_MIPS_NAN2008)
3004 strcat (buf, ", nan2008");
3005
fef1b0b3
SE		 3006 if (e_flags & EF_MIPS_FP64)
3007 strcat (buf, ", fp64");
3008
156c2f8b
NC		 3009 switch ((e_flags & EF_MIPS_MACH))
3010 {
3011 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3012 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3013 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3014 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3015 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3016 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3017 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3018 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3019 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3020 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3021 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3022 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3023 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3024 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3025 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3026 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3027 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3028 case 0:
3029 /* We simply ignore the field in this case to avoid confusion:
3030 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3031 extension. */
3032 break;
2b692964 3033 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3034 }
43521d43
TS		 3035
3036 switch ((e_flags & EF_MIPS_ABI))
3037 {
3038 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3039 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3040 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3041 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3042 case 0:
3043 /* We simply ignore the field in this case to avoid confusion:
3044 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3045 This means it is likely to be an o32 file, but not for
3046 sure. */
3047 break;
2b692964 3048 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3049 }
3050
3051 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3052 strcat (buf, ", mdmx");
3053
3054 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3055 strcat (buf, ", mips16");
3056
df58fc94
RS		 3057 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3058 strcat (buf, ", micromips");
3059
43521d43
TS		 3060 switch ((e_flags & EF_MIPS_ARCH))
3061 {
3062 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3063 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3064 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3065 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3066 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3067 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3068 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3069 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3070 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3071 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3072 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3073 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3074 }
252b5132 3075 break;
351b4b40 3076
35c08157
KLC		 3077 case EM_NDS32:
3078 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3079 break;
3080
ccde1100
AO		 3081 case EM_SH:
3082 switch ((e_flags & EF_SH_MACH_MASK))
3083 {
3084 case EF_SH1: strcat (buf, ", sh1"); break;
3085 case EF_SH2: strcat (buf, ", sh2"); break;
3086 case EF_SH3: strcat (buf, ", sh3"); break;
3087 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3088 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3089 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3090 case EF_SH3E: strcat (buf, ", sh3e"); break;
3091 case EF_SH4: strcat (buf, ", sh4"); break;
3092 case EF_SH5: strcat (buf, ", sh5"); break;
3093 case EF_SH2E: strcat (buf, ", sh2e"); break;
3094 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3095 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3096 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3097 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3098 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3099 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3100 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3101 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3102 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3103 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3104 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3105 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3106 }
3107
cec6a5b8
MR		 3108 if (e_flags & EF_SH_PIC)
3109 strcat (buf, ", pic");
3110
3111 if (e_flags & EF_SH_FDPIC)
3112 strcat (buf, ", fdpic");
ccde1100 3113 break;
73589c9d
CS		 3114
3115 case EM_OR1K:
3116 if (e_flags & EF_OR1K_NODELAY)
3117 strcat (buf, ", no delay");
3118 break;
57346661 3119
351b4b40
RH		 3120 case EM_SPARCV9:
3121 if (e_flags & EF_SPARC_32PLUS)
3122 strcat (buf, ", v8+");
3123
3124 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3125 strcat (buf, ", ultrasparcI");
3126
3127 if (e_flags & EF_SPARC_SUN_US3)
3128 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3129
3130 if (e_flags & EF_SPARC_HAL_R1)
3131 strcat (buf, ", halr1");
3132
3133 if (e_flags & EF_SPARC_LEDATA)
3134 strcat (buf, ", ledata");
3135
3136 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3137 strcat (buf, ", tso");
3138
3139 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3140 strcat (buf, ", pso");
3141
3142 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3143 strcat (buf, ", rmo");
3144 break;
7d466069 3145
103f02d3
UD		 3146 case EM_PARISC:
3147 switch (e_flags & EF_PARISC_ARCH)
3148 {
3149 case EFA_PARISC_1_0:
3150 strcpy (buf, ", PA-RISC 1.0");
3151 break;
3152 case EFA_PARISC_1_1:
3153 strcpy (buf, ", PA-RISC 1.1");
3154 break;
3155 case EFA_PARISC_2_0:
3156 strcpy (buf, ", PA-RISC 2.0");
3157 break;
3158 default:
3159 break;
3160 }
3161 if (e_flags & EF_PARISC_TRAPNIL)
3162 strcat (buf, ", trapnil");
3163 if (e_flags & EF_PARISC_EXT)
3164 strcat (buf, ", ext");
3165 if (e_flags & EF_PARISC_LSB)
3166 strcat (buf, ", lsb");
3167 if (e_flags & EF_PARISC_WIDE)
3168 strcat (buf, ", wide");
3169 if (e_flags & EF_PARISC_NO_KABP)
3170 strcat (buf, ", no kabp");
3171 if (e_flags & EF_PARISC_LAZYSWAP)
3172 strcat (buf, ", lazyswap");
30800947 3173 break;
76da6bbe 3174
7d466069 3175 case EM_PJ:
2b0337b0 3176 case EM_PJ_OLD:
7d466069
ILT		 3177 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3178 strcat (buf, ", new calling convention");
3179
3180 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3181 strcat (buf, ", gnu calling convention");
3182 break;
4d6ed7c8
NC		 3183
3184 case EM_IA_64:
3185 if ((e_flags & EF_IA_64_ABI64))
3186 strcat (buf, ", 64-bit");
3187 else
3188 strcat (buf, ", 32-bit");
3189 if ((e_flags & EF_IA_64_REDUCEDFP))
3190 strcat (buf, ", reduced fp model");
3191 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3192 strcat (buf, ", no function descriptors, constant gp");
3193 else if ((e_flags & EF_IA_64_CONS_GP))
3194 strcat (buf, ", constant gp");
3195 if ((e_flags & EF_IA_64_ABSOLUTE))
3196 strcat (buf, ", absolute");
28f997cf
TG		 3197 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3198 {
3199 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3200 strcat (buf, ", vms_linkages");
3201 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3202 {
3203 case EF_IA_64_VMS_COMCOD_SUCCESS:
3204 break;
3205 case EF_IA_64_VMS_COMCOD_WARNING:
3206 strcat (buf, ", warning");
3207 break;
3208 case EF_IA_64_VMS_COMCOD_ERROR:
3209 strcat (buf, ", error");
3210 break;
3211 case EF_IA_64_VMS_COMCOD_ABORT:
3212 strcat (buf, ", abort");
3213 break;
3214 default:
bee0ee85
NC		 3215 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3216 e_flags & EF_IA_64_VMS_COMCOD);
3217 strcat (buf, ", <unknown>");
28f997cf
TG		 3218 }
3219 }
4d6ed7c8 3220 break;
179d3252
JT		 3221
3222 case EM_VAX:
3223 if ((e_flags & EF_VAX_NONPIC))
3224 strcat (buf, ", non-PIC");
3225 if ((e_flags & EF_VAX_DFLOAT))
3226 strcat (buf, ", D-Float");
3227 if ((e_flags & EF_VAX_GFLOAT))
3228 strcat (buf, ", G-Float");
3229 break;
c7927a3c 3230
619ed720
EB		 3231 case EM_VISIUM:
3232 if (e_flags & EF_VISIUM_ARCH_MCM)
3233 strcat (buf, ", mcm");
3234 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3235 strcat (buf, ", mcm24");
3236 if (e_flags & EF_VISIUM_ARCH_GR6)
3237 strcat (buf, ", gr6");
3238 break;
3239
4046d87a
NC		 3240 case EM_RL78:
3241 if (e_flags & E_FLAG_RL78_G10)
3242 strcat (buf, ", G10");
856ea05c
KP		 3243 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3244 strcat (buf, ", 64-bit doubles");
4046d87a 3245 break;
0b4362b0 3246
c7927a3c
NC		 3247 case EM_RX:
3248 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3249 strcat (buf, ", 64-bit doubles");
3250 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3251 strcat (buf, ", dsp");
d4cb0ea0 3252 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3253 strcat (buf, ", pid");
708e2187
NC		 3254 if (e_flags & E_FLAG_RX_ABI)
3255 strcat (buf, ", RX ABI");
d4cb0ea0 3256 break;
55786da2
AK		 3257
3258 case EM_S390:
3259 if (e_flags & EF_S390_HIGH_GPRS)
3260 strcat (buf, ", highgprs");
d4cb0ea0 3261 break;
40b36596
JM		 3262
3263 case EM_TI_C6000:
3264 if ((e_flags & EF_C6000_REL))
3265 strcat (buf, ", relocatable module");
d4cb0ea0 3266 break;
13761a11
NC		 3267
3268 case EM_MSP430:
3269 strcat (buf, _(": architecture variant: "));
3270 switch (e_flags & EF_MSP430_MACH)
3271 {
3272 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3273 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3274 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3275 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3276 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3277 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3278 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3279 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3280 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3281 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3282 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3283 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3284 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3285 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3286 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3287 default:
3288 strcat (buf, _(": unknown")); break;
3289 }
3290
3291 if (e_flags & ~ EF_MSP430_MACH)
3292 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3293 }
3294 }
3295
3296 return buf;
3297}
3298
252b5132 3299static const char *
d3ba0551
AM		 3300get_osabi_name (unsigned int osabi)
3301{
3302 static char buff[32];
3303
3304 switch (osabi)
3305 {
3306 case ELFOSABI_NONE: return "UNIX - System V";
3307 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3308 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3309 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3310 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3311 case ELFOSABI_AIX: return "UNIX - AIX";
3312 case ELFOSABI_IRIX: return "UNIX - IRIX";
3313 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3314 case ELFOSABI_TRU64: return "UNIX - TRU64";
3315 case ELFOSABI_MODESTO: return "Novell - Modesto";
3316 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3317 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3318 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3319 case ELFOSABI_AROS: return "AROS";
11636f9e 3320 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3321 default:
40b36596
JM		 3322 if (osabi >= 64)
3323 switch (elf_header.e_machine)
3324 {
3325 case EM_ARM:
3326 switch (osabi)
3327 {
3328 case ELFOSABI_ARM: return "ARM";
3329 default:
3330 break;
3331 }
3332 break;
3333
3334 case EM_MSP430:
3335 case EM_MSP430_OLD:
619ed720 3336 case EM_VISIUM:
40b36596
JM		 3337 switch (osabi)
3338 {
3339 case ELFOSABI_STANDALONE: return _("Standalone App");
3340 default:
3341 break;
3342 }
3343 break;
3344
3345 case EM_TI_C6000:
3346 switch (osabi)
3347 {
3348 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3349 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3350 default:
3351 break;
3352 }
3353 break;
3354
3355 default:
3356 break;
3357 }
e9e44622 3358 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3359 return buff;
3360 }
3361}
3362
a06ea964
NC		 3363static const char *
3364get_aarch64_segment_type (unsigned long type)
3365{
3366 switch (type)
3367 {
3368 case PT_AARCH64_ARCHEXT:
3369 return "AARCH64_ARCHEXT";
3370 default:
3371 break;
3372 }
3373
3374 return NULL;
3375}
3376
b294bdf8
MM		 3377static const char *
3378get_arm_segment_type (unsigned long type)
3379{
3380 switch (type)
3381 {
3382 case PT_ARM_EXIDX:
3383 return "EXIDX";
3384 default:
3385 break;
3386 }
3387
3388 return NULL;
3389}
3390
d3ba0551
AM		 3391static const char *
3392get_mips_segment_type (unsigned long type)
252b5132
RH		 3393{
3394 switch (type)
3395 {
3396 case PT_MIPS_REGINFO:
3397 return "REGINFO";
3398 case PT_MIPS_RTPROC:
3399 return "RTPROC";
3400 case PT_MIPS_OPTIONS:
3401 return "OPTIONS";
351cdf24
MF		 3402 case PT_MIPS_ABIFLAGS:
3403 return "ABIFLAGS";
252b5132
RH		 3404 default:
3405 break;
3406 }
3407
3408 return NULL;
3409}
3410
103f02d3 3411static const char *
d3ba0551 3412get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3413{
3414 switch (type)
3415 {
3416 case PT_HP_TLS: return "HP_TLS";
3417 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3418 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3419 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3420 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3421 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3422 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3423 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3424 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3425 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3426 case PT_HP_PARALLEL: return "HP_PARALLEL";
3427 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3428 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3429 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3430 case PT_HP_STACK: return "HP_STACK";
3431 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3432 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3433 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3434 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3435 default:
3436 break;
3437 }
3438
3439 return NULL;
3440}
3441
4d6ed7c8 3442static const char *
d3ba0551 3443get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3444{
3445 switch (type)
3446 {
3447 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3448 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3449 case PT_HP_TLS: return "HP_TLS";
3450 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3451 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3452 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3453 default:
3454 break;
3455 }
3456
3457 return NULL;
3458}
3459
40b36596
JM		 3460static const char *
3461get_tic6x_segment_type (unsigned long type)
3462{
3463 switch (type)
3464 {
3465 case PT_C6000_PHATTR: return "C6000_PHATTR";
3466 default:
3467 break;
3468 }
3469
3470 return NULL;
3471}
3472
252b5132 3473static const char *
d3ba0551 3474get_segment_type (unsigned long p_type)
252b5132 3475{
b34976b6 3476 static char buff[32];
252b5132
RH		 3477
3478 switch (p_type)
3479 {
b34976b6
AM		 3480 case PT_NULL: return "NULL";
3481 case PT_LOAD: return "LOAD";
252b5132 3482 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3483 case PT_INTERP: return "INTERP";
3484 case PT_NOTE: return "NOTE";
3485 case PT_SHLIB: return "SHLIB";
3486 case PT_PHDR: return "PHDR";
13ae64f3 3487 case PT_TLS: return "TLS";
252b5132 3488
65765700
JJ		 3489 case PT_GNU_EH_FRAME:
3490 return "GNU_EH_FRAME";
2b05f1b7 3491 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3492 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3493
252b5132
RH		 3494 default:
3495 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3496 {
2cf0635d 3497 const char * result;
103f02d3 3498
252b5132
RH		 3499 switch (elf_header.e_machine)
3500 {
a06ea964
NC		 3501 case EM_AARCH64:
3502 result = get_aarch64_segment_type (p_type);
3503 break;
b294bdf8
MM		 3504 case EM_ARM:
3505 result = get_arm_segment_type (p_type);
3506 break;
252b5132 3507 case EM_MIPS:
4fe85591 3508 case EM_MIPS_RS3_LE:
252b5132
RH		 3509 result = get_mips_segment_type (p_type);
3510 break;
103f02d3
UD		 3511 case EM_PARISC:
3512 result = get_parisc_segment_type (p_type);
3513 break;
4d6ed7c8
NC		 3514 case EM_IA_64:
3515 result = get_ia64_segment_type (p_type);
3516 break;
40b36596
JM		 3517 case EM_TI_C6000:
3518 result = get_tic6x_segment_type (p_type);
3519 break;
252b5132
RH		 3520 default:
3521 result = NULL;
3522 break;
3523 }
103f02d3 3524
252b5132
RH		 3525 if (result != NULL)
3526 return result;
103f02d3 3527
252b5132
RH		 3528 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3529 }
3530 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3531 {
2cf0635d 3532 const char * result;
103f02d3
UD		 3533
3534 switch (elf_header.e_machine)
3535 {
3536 case EM_PARISC:
3537 result = get_parisc_segment_type (p_type);
3538 break;
00428cca
AM		 3539 case EM_IA_64:
3540 result = get_ia64_segment_type (p_type);
3541 break;
103f02d3
UD		 3542 default:
3543 result = NULL;
3544 break;
3545 }
3546
3547 if (result != NULL)
3548 return result;
3549
3550 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3551 }
252b5132 3552 else
e9e44622 3553 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3554
3555 return buff;
3556 }
3557}
3558
3559static const char *
d3ba0551 3560get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3561{
3562 switch (sh_type)
3563 {
b34976b6
AM		 3564 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3565 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3566 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3567 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3568 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3569 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3570 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3571 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3572 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3573 case SHT_MIPS_RELD: return "MIPS_RELD";
3574 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3575 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3576 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3577 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3578 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3579 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3580 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3581 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3582 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3583 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3584 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3585 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3586 case SHT_MIPS_LINE: return "MIPS_LINE";
3587 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3588 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3589 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3590 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3591 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3592 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3593 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3594 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3595 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3596 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3597 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3598 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3599 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3600 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3601 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3602 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3603 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3604 default:
3605 break;
3606 }
3607 return NULL;
3608}
3609
103f02d3 3610static const char *
d3ba0551 3611get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3612{
3613 switch (sh_type)
3614 {
3615 case SHT_PARISC_EXT: return "PARISC_EXT";
3616 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3617 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3618 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3619 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3620 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3621 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3622 default:
3623 break;
3624 }
3625 return NULL;
3626}
3627
4d6ed7c8 3628static const char *
d3ba0551 3629get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3630{
18bd398b 3631 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3632 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3633 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3634
4d6ed7c8
NC		 3635 switch (sh_type)
3636 {
148b93f2
NC		 3637 case SHT_IA_64_EXT: return "IA_64_EXT";
3638 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3639 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3640 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3641 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3642 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3643 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3644 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3645 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3646 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3647 default:
3648 break;
3649 }
3650 return NULL;
3651}
3652
d2b2c203
DJ		 3653static const char *
3654get_x86_64_section_type_name (unsigned int sh_type)
3655{
3656 switch (sh_type)
3657 {
3658 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3659 default:
3660 break;
3661 }
3662 return NULL;
3663}
3664
a06ea964
NC		 3665static const char *
3666get_aarch64_section_type_name (unsigned int sh_type)
3667{
3668 switch (sh_type)
3669 {
3670 case SHT_AARCH64_ATTRIBUTES:
3671 return "AARCH64_ATTRIBUTES";
3672 default:
3673 break;
3674 }
3675 return NULL;
3676}
3677
40a18ebd
NC		 3678static const char *
3679get_arm_section_type_name (unsigned int sh_type)
3680{
3681 switch (sh_type)
3682 {
7f6fed87
NC		 3683 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3684 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3685 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3686 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3687 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3688 default:
3689 break;
3690 }
3691 return NULL;
3692}
3693
40b36596
JM		 3694static const char *
3695get_tic6x_section_type_name (unsigned int sh_type)
3696{
3697 switch (sh_type)
3698 {
3699 case SHT_C6000_UNWIND:
3700 return "C6000_UNWIND";
3701 case SHT_C6000_PREEMPTMAP:
3702 return "C6000_PREEMPTMAP";
3703 case SHT_C6000_ATTRIBUTES:
3704 return "C6000_ATTRIBUTES";
3705 case SHT_TI_ICODE:
3706 return "TI_ICODE";
3707 case SHT_TI_XREF:
3708 return "TI_XREF";
3709 case SHT_TI_HANDLER:
3710 return "TI_HANDLER";
3711 case SHT_TI_INITINFO:
3712 return "TI_INITINFO";
3713 case SHT_TI_PHATTRS:
3714 return "TI_PHATTRS";
3715 default:
3716 break;
3717 }
3718 return NULL;
3719}
3720
13761a11
NC		 3721static const char *
3722get_msp430x_section_type_name (unsigned int sh_type)
3723{
3724 switch (sh_type)
3725 {
3726 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3727 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3728 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3729 default: return NULL;
3730 }
3731}
3732
252b5132 3733static const char *
d3ba0551 3734get_section_type_name (unsigned int sh_type)
252b5132 3735{
b34976b6 3736 static char buff[32];
252b5132
RH		 3737
3738 switch (sh_type)
3739 {
3740 case SHT_NULL: return "NULL";
3741 case SHT_PROGBITS: return "PROGBITS";
3742 case SHT_SYMTAB: return "SYMTAB";
3743 case SHT_STRTAB: return "STRTAB";
3744 case SHT_RELA: return "RELA";
3745 case SHT_HASH: return "HASH";
3746 case SHT_DYNAMIC: return "DYNAMIC";
3747 case SHT_NOTE: return "NOTE";
3748 case SHT_NOBITS: return "NOBITS";
3749 case SHT_REL: return "REL";
3750 case SHT_SHLIB: return "SHLIB";
3751 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3752 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3753 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3754 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3755 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3756 case SHT_GROUP: return "GROUP";
3757 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3758 case SHT_GNU_verdef: return "VERDEF";
3759 case SHT_GNU_verneed: return "VERNEED";
3760 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3761 case 0x6ffffff0: return "VERSYM";
3762 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3763 case 0x7ffffffd: return "AUXILIARY";
3764 case 0x7fffffff: return "FILTER";
047b2264 3765 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3766
3767 default:
3768 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3769 {
2cf0635d 3770 const char * result;
252b5132
RH		 3771
3772 switch (elf_header.e_machine)
3773 {
3774 case EM_MIPS:
4fe85591 3775 case EM_MIPS_RS3_LE:
252b5132
RH		 3776 result = get_mips_section_type_name (sh_type);
3777 break;
103f02d3
UD		 3778 case EM_PARISC:
3779 result = get_parisc_section_type_name (sh_type);
3780 break;
4d6ed7c8
NC		 3781 case EM_IA_64:
3782 result = get_ia64_section_type_name (sh_type);
3783 break;
d2b2c203 3784 case EM_X86_64:
8a9036a4 3785 case EM_L1OM:
7a9068fe 3786 case EM_K1OM:
d2b2c203
DJ		 3787 result = get_x86_64_section_type_name (sh_type);
3788 break;
a06ea964
NC		 3789 case EM_AARCH64:
3790 result = get_aarch64_section_type_name (sh_type);
3791 break;
40a18ebd
NC		 3792 case EM_ARM:
3793 result = get_arm_section_type_name (sh_type);
3794 break;
40b36596
JM		 3795 case EM_TI_C6000:
3796 result = get_tic6x_section_type_name (sh_type);
3797 break;
13761a11
NC		 3798 case EM_MSP430:
3799 result = get_msp430x_section_type_name (sh_type);
3800 break;
252b5132
RH		 3801 default:
3802 result = NULL;
3803 break;
3804 }
3805
3806 if (result != NULL)
3807 return result;
3808
c91d0dfb 3809 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3810 }
3811 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3812 {
2cf0635d 3813 const char * result;
148b93f2
NC		 3814
3815 switch (elf_header.e_machine)
3816 {
3817 case EM_IA_64:
3818 result = get_ia64_section_type_name (sh_type);
3819 break;
3820 default:
3821 result = NULL;
3822 break;
3823 }
3824
3825 if (result != NULL)
3826 return result;
3827
3828 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3829 }
252b5132 3830 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3831 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3832 else
a7dbfd1c
NC		 3833 /* This message is probably going to be displayed in a 15
3834 character wide field, so put the hex value first. */
3835 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3836
252b5132
RH		 3837 return buff;
3838 }
3839}
3840
2979dc34 3841#define OPTION_DEBUG_DUMP 512
2c610e4b 3842#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3843#define OPTION_DWARF_DEPTH 514
3844#define OPTION_DWARF_START 515
4723351a 3845#define OPTION_DWARF_CHECK 516
2979dc34 3846
85b1c36d 3847static struct option options[] =
252b5132 3848{
b34976b6 3849 {"all", no_argument, 0, 'a'},
252b5132
RH		 3850 {"file-header", no_argument, 0, 'h'},
3851 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3852 {"headers", no_argument, 0, 'e'},
3853 {"histogram", no_argument, 0, 'I'},
3854 {"segments", no_argument, 0, 'l'},
3855 {"sections", no_argument, 0, 'S'},
252b5132 3856 {"section-headers", no_argument, 0, 'S'},
f5842774 3857 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3858 {"section-details", no_argument, 0, 't'},
595cf52e 3859 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3860 {"symbols", no_argument, 0, 's'},
3861 {"syms", no_argument, 0, 's'},
2c610e4b 3862 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3863 {"relocs", no_argument, 0, 'r'},
3864 {"notes", no_argument, 0, 'n'},
3865 {"dynamic", no_argument, 0, 'd'},
a952a375 3866 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3867 {"version-info", no_argument, 0, 'V'},
3868 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3869 {"unwind", no_argument, 0, 'u'},
4145f1d5 3870 {"archive-index", no_argument, 0, 'c'},
b34976b6 3871 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3872 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3873 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3874#ifdef SUPPORT_DISASSEMBLY
3875 {"instruction-dump", required_argument, 0, 'i'},
3876#endif
cf13d699 3877 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3878
fd2f0033
TT		 3879 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3880 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3881 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3882
b34976b6
AM		 3883 {"version", no_argument, 0, 'v'},
3884 {"wide", no_argument, 0, 'W'},
3885 {"help", no_argument, 0, 'H'},
3886 {0, no_argument, 0, 0}
252b5132
RH		 3887};
3888
3889static void
2cf0635d 3890usage (FILE * stream)
252b5132 3891{
92f01d61
JM		 3892 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3893 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3894 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3895 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3896 -h --file-header Display the ELF file header\n\
3897 -l --program-headers Display the program headers\n\
3898 --segments An alias for --program-headers\n\
3899 -S --section-headers Display the sections' header\n\
3900 --sections An alias for --section-headers\n\
f5842774 3901 -g --section-groups Display the section groups\n\
5477e8a0 3902 -t --section-details Display the section details\n\
8b53311e
NC		 3903 -e --headers Equivalent to: -h -l -S\n\
3904 -s --syms Display the symbol table\n\
3f08eb35 3905 --symbols An alias for --syms\n\
2c610e4b 3906 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3907 -n --notes Display the core notes (if present)\n\
3908 -r --relocs Display the relocations (if present)\n\
3909 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3910 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3911 -V --version-info Display the version sections (if present)\n\
1b31d05e 3912 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3913 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3914 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3915 -x --hex-dump=<number|name>\n\
3916 Dump the contents of section <number|name> as bytes\n\
3917 -p --string-dump=<number|name>\n\
3918 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3919 -R --relocated-dump=<number|name>\n\
3920 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3921 -w[lLiaprmfFsoRt] or\n\
1ed06042 3922 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3923 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3924 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3925 =addr,=cu_index]\n\
8b53311e 3926 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3927 fprintf (stream, _("\
3928 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3929 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3930 or deeper\n"));
252b5132 3931#ifdef SUPPORT_DISASSEMBLY
92f01d61 3932 fprintf (stream, _("\
09c11c86
NC		 3933 -i --instruction-dump=<number|name>\n\
3934 Disassemble the contents of section <number|name>\n"));
252b5132 3935#endif
92f01d61 3936 fprintf (stream, _("\
8b53311e
NC		 3937 -I --histogram Display histogram of bucket list lengths\n\
3938 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3939 @<file> Read options from <file>\n\
8b53311e
NC		 3940 -H --help Display this information\n\
3941 -v --version Display the version number of readelf\n"));
1118d252 3942
92f01d61
JM		 3943 if (REPORT_BUGS_TO[0] && stream == stdout)
3944 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3945
92f01d61 3946 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3947}
3948
18bd398b
NC		 3949/* Record the fact that the user wants the contents of section number
3950 SECTION to be displayed using the method(s) encoded as flags bits
3951 in TYPE. Note, TYPE can be zero if we are creating the array for
3952 the first time. */
3953
252b5132 3954static void
09c11c86 3955request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3956{
3957 if (section >= num_dump_sects)
3958 {
2cf0635d 3959 dump_type * new_dump_sects;
252b5132 3960
3f5e193b
NC		 3961 new_dump_sects = (dump_type *) calloc (section + 1,
3962 sizeof (* dump_sects));
252b5132
RH		 3963
3964 if (new_dump_sects == NULL)
591a748a 3965 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3966 else
3967 {
3968 /* Copy current flag settings. */
09c11c86 3969 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3970
3971 free (dump_sects);
3972
3973 dump_sects = new_dump_sects;
3974 num_dump_sects = section + 1;
3975 }
3976 }
3977
3978 if (dump_sects)
b34976b6 3979 dump_sects[section] |= type;
252b5132
RH		 3980
3981 return;
3982}
3983
aef1f6d0
DJ		 3984/* Request a dump by section name. */
3985
3986static void
2cf0635d 3987request_dump_byname (const char * section, dump_type type)
aef1f6d0 3988{
2cf0635d 3989 struct dump_list_entry * new_request;
aef1f6d0 3990
3f5e193b
NC		 3991 new_request = (struct dump_list_entry *)
3992 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3993 if (!new_request)
591a748a 3994 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3995
3996 new_request->name = strdup (section);
3997 if (!new_request->name)
591a748a 3998 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3999
4000 new_request->type = type;
4001
4002 new_request->next = dump_sects_byname;
4003 dump_sects_byname = new_request;
4004}
4005
cf13d699
NC		 4006static inline void
4007request_dump (dump_type type)
4008{
4009 int section;
4010 char * cp;
4011
4012 do_dump++;
4013 section = strtoul (optarg, & cp, 0);
4014
4015 if (! *cp && section >= 0)
4016 request_dump_bynumber (section, type);
4017 else
4018 request_dump_byname (optarg, type);
4019}
4020
4021
252b5132 4022static void
2cf0635d 4023parse_args (int argc, char ** argv)
252b5132
RH		 4024{
4025 int c;
4026
4027 if (argc < 2)
92f01d61 4028 usage (stderr);
252b5132
RH		 4029
4030 while ((c = getopt_long
cf13d699 4031 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 4032 {
252b5132
RH		 4033 switch (c)
4034 {
4035 case 0:
4036 /* Long options. */
4037 break;
4038 case 'H':
92f01d61 4039 usage (stdout);
252b5132
RH		 4040 break;
4041
4042 case 'a':
b34976b6
AM		 4043 do_syms++;
4044 do_reloc++;
4045 do_unwind++;
4046 do_dynamic++;
4047 do_header++;
4048 do_sections++;
f5842774 4049 do_section_groups++;
b34976b6
AM		 4050 do_segments++;
4051 do_version++;
4052 do_histogram++;
4053 do_arch++;
4054 do_notes++;
252b5132 4055 break;
f5842774
L		 4056 case 'g':
4057 do_section_groups++;
4058 break;
5477e8a0 4059 case 't':
595cf52e 4060 case 'N':
5477e8a0
L		 4061 do_sections++;
4062 do_section_details++;
595cf52e 4063 break;
252b5132 4064 case 'e':
b34976b6
AM		 4065 do_header++;
4066 do_sections++;
4067 do_segments++;
252b5132 4068 break;
a952a375 4069 case 'A':
b34976b6 4070 do_arch++;
a952a375 4071 break;
252b5132 4072 case 'D':
b34976b6 4073 do_using_dynamic++;
252b5132
RH		 4074 break;
4075 case 'r':
b34976b6 4076 do_reloc++;
252b5132 4077 break;
4d6ed7c8 4078 case 'u':
b34976b6 4079 do_unwind++;
4d6ed7c8 4080 break;
252b5132 4081 case 'h':
b34976b6 4082 do_header++;
252b5132
RH		 4083 break;
4084 case 'l':
b34976b6 4085 do_segments++;
252b5132
RH		 4086 break;
4087 case 's':
b34976b6 4088 do_syms++;
252b5132
RH		 4089 break;
4090 case 'S':
b34976b6 4091 do_sections++;
252b5132
RH		 4092 break;
4093 case 'd':
b34976b6 4094 do_dynamic++;
252b5132 4095 break;
a952a375 4096 case 'I':
b34976b6 4097 do_histogram++;
a952a375 4098 break;
779fe533 4099 case 'n':
b34976b6 4100 do_notes++;
779fe533 4101 break;
4145f1d5
NC		 4102 case 'c':
4103 do_archive_index++;
4104 break;
252b5132 4105 case 'x':
cf13d699 4106 request_dump (HEX_DUMP);
aef1f6d0 4107 break;
09c11c86 4108 case 'p':
cf13d699
NC		 4109 request_dump (STRING_DUMP);
4110 break;
4111 case 'R':
4112 request_dump (RELOC_DUMP);
09c11c86 4113 break;
252b5132 4114 case 'w':
b34976b6 4115 do_dump++;
252b5132 4116 if (optarg == 0)
613ff48b
CC		 4117 {
4118 do_debugging = 1;
4119 dwarf_select_sections_all ();
4120 }
252b5132
RH		 4121 else
4122 {
4123 do_debugging = 0;
4cb93e3b 4124 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4125 }
4126 break;
2979dc34 4127 case OPTION_DEBUG_DUMP:
b34976b6 4128 do_dump++;
2979dc34
JJ		 4129 if (optarg == 0)
4130 do_debugging = 1;
4131 else
4132 {
2979dc34 4133 do_debugging = 0;
4cb93e3b 4134 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4135 }
4136 break;
fd2f0033
TT		 4137 case OPTION_DWARF_DEPTH:
4138 {
4139 char *cp;
4140
4141 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4142 }
4143 break;
4144 case OPTION_DWARF_START:
4145 {
4146 char *cp;
4147
4148 dwarf_start_die = strtoul (optarg, & cp, 0);
4149 }
4150 break;
4723351a
CC		 4151 case OPTION_DWARF_CHECK:
4152 dwarf_check = 1;
4153 break;
2c610e4b
L		 4154 case OPTION_DYN_SYMS:
4155 do_dyn_syms++;
4156 break;
252b5132
RH		 4157#ifdef SUPPORT_DISASSEMBLY
4158 case 'i':
cf13d699
NC		 4159 request_dump (DISASS_DUMP);
4160 break;
252b5132
RH		 4161#endif
4162 case 'v':
4163 print_version (program_name);
4164 break;
4165 case 'V':
b34976b6 4166 do_version++;
252b5132 4167 break;
d974e256 4168 case 'W':
b34976b6 4169 do_wide++;
d974e256 4170 break;
252b5132 4171 default:
252b5132
RH		 4172 /* xgettext:c-format */
4173 error (_("Invalid option '-%c'\n"), c);
4174 /* Drop through. */
4175 case '?':
92f01d61 4176 usage (stderr);
252b5132
RH		 4177 }
4178 }
4179
4d6ed7c8 4180 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4181 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4182 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4183 && !do_section_groups && !do_archive_index
4184 && !do_dyn_syms)
92f01d61 4185 usage (stderr);
252b5132
RH		 4186 else if (argc < 3)
4187 {
4188 warn (_("Nothing to do.\n"));
92f01d61 4189 usage (stderr);
252b5132
RH		 4190 }
4191}
4192
4193static const char *
d3ba0551 4194get_elf_class (unsigned int elf_class)
252b5132 4195{
b34976b6 4196 static char buff[32];
103f02d3 4197
252b5132
RH		 4198 switch (elf_class)
4199 {
4200 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4201 case ELFCLASS32: return "ELF32";
4202 case ELFCLASS64: return "ELF64";
ab5e7794 4203 default:
e9e44622 4204 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4205 return buff;
252b5132
RH		 4206 }
4207}
4208
4209static const char *
d3ba0551 4210get_data_encoding (unsigned int encoding)
252b5132 4211{
b34976b6 4212 static char buff[32];
103f02d3 4213
252b5132
RH		 4214 switch (encoding)
4215 {
4216 case ELFDATANONE: return _("none");
33c63f9d
CM		 4217 case ELFDATA2LSB: return _("2's complement, little endian");
4218 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4219 default:
e9e44622 4220 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4221 return buff;
252b5132
RH		 4222 }
4223}
4224
252b5132 4225/* Decode the data held in 'elf_header'. */
ee42cf8c 4226
252b5132 4227static int
d3ba0551 4228process_file_header (void)
252b5132 4229{
b34976b6
AM		 4230 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4231 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4232 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4233 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4234 {
4235 error
4236 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4237 return 0;
4238 }
4239
2dc4cec1
L		 4240 init_dwarf_regnames (elf_header.e_machine);
4241
252b5132
RH		 4242 if (do_header)
4243 {
4244 int i;
4245
4246 printf (_("ELF Header:\n"));
4247 printf (_(" Magic: "));
b34976b6
AM		 4248 for (i = 0; i < EI_NIDENT; i++)
4249 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4250 printf ("\n");
4251 printf (_(" Class: %s\n"),
b34976b6 4252 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4253 printf (_(" Data: %s\n"),
b34976b6 4254 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4255 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4256 elf_header.e_ident[EI_VERSION],
4257 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4258 ? "(current)"
b34976b6 4259 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4260 ? _("<unknown: %lx>")
789be9f7 4261 : "")));
252b5132 4262 printf (_(" OS/ABI: %s\n"),
b34976b6 4263 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4264 printf (_(" ABI Version: %d\n"),
b34976b6 4265 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4266 printf (_(" Type: %s\n"),
4267 get_file_type (elf_header.e_type));
4268 printf (_(" Machine: %s\n"),
4269 get_machine_name (elf_header.e_machine));
4270 printf (_(" Version: 0x%lx\n"),
4271 (unsigned long) elf_header.e_version);
76da6bbe 4272
f7a99963
NC		 4273 printf (_(" Entry point address: "));
4274 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4275 printf (_("\n Start of program headers: "));
4276 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4277 printf (_(" (bytes into file)\n Start of section headers: "));
4278 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4279 printf (_(" (bytes into file)\n"));
76da6bbe 4280
252b5132
RH		 4281 printf (_(" Flags: 0x%lx%s\n"),
4282 (unsigned long) elf_header.e_flags,
4283 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4284 printf (_(" Size of this header: %ld (bytes)\n"),
4285 (long) elf_header.e_ehsize);
4286 printf (_(" Size of program headers: %ld (bytes)\n"),
4287 (long) elf_header.e_phentsize);
2046a35d 4288 printf (_(" Number of program headers: %ld"),
252b5132 4289 (long) elf_header.e_phnum);
2046a35d
AM		 4290 if (section_headers != NULL
4291 && elf_header.e_phnum == PN_XNUM
4292 && section_headers[0].sh_info != 0)
cc5914eb 4293 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4294 putc ('\n', stdout);
252b5132
RH		 4295 printf (_(" Size of section headers: %ld (bytes)\n"),
4296 (long) elf_header.e_shentsize);
560f3c1c 4297 printf (_(" Number of section headers: %ld"),
252b5132 4298 (long) elf_header.e_shnum);
4fbb74a6 4299 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4300 printf (" (%ld)", (long) section_headers[0].sh_size);
4301 putc ('\n', stdout);
4302 printf (_(" Section header string table index: %ld"),
252b5132 4303 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4304 if (section_headers != NULL
4305 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4306 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4307 else if (elf_header.e_shstrndx != SHN_UNDEF
4308 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4309 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4310 putc ('\n', stdout);
4311 }
4312
4313 if (section_headers != NULL)
4314 {
2046a35d
AM		 4315 if (elf_header.e_phnum == PN_XNUM
4316 && section_headers[0].sh_info != 0)
4317 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4318 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4319 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4320 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4321 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4322 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4323 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4324 free (section_headers);
4325 section_headers = NULL;
252b5132 4326 }
103f02d3 4327
9ea033b2
NC		 4328 return 1;
4329}
4330
e0a31db1 4331static bfd_boolean
91d6fa6a 4332get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4333{
2cf0635d
NC		 4334 Elf32_External_Phdr * phdrs;
4335 Elf32_External_Phdr * external;
4336 Elf_Internal_Phdr * internal;
b34976b6 4337 unsigned int i;
e0a31db1
NC		 4338 unsigned int size = elf_header.e_phentsize;
4339 unsigned int num = elf_header.e_phnum;
4340
4341 /* PR binutils/17531: Cope with unexpected section header sizes. */
4342 if (size == 0 || num == 0)
4343 return FALSE;
4344 if (size < sizeof * phdrs)
4345 {
4346 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4347 return FALSE;
4348 }
4349 if (size > sizeof * phdrs)
4350 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4351
3f5e193b 4352 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4353 size, num, _("program headers"));
4354 if (phdrs == NULL)
4355 return FALSE;
9ea033b2 4356
91d6fa6a 4357 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4358 i < elf_header.e_phnum;
b34976b6 4359 i++, internal++, external++)
252b5132 4360 {
9ea033b2
NC		 4361 internal->p_type = BYTE_GET (external->p_type);
4362 internal->p_offset = BYTE_GET (external->p_offset);
4363 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4364 internal->p_paddr = BYTE_GET (external->p_paddr);
4365 internal->p_filesz = BYTE_GET (external->p_filesz);
4366 internal->p_memsz = BYTE_GET (external->p_memsz);
4367 internal->p_flags = BYTE_GET (external->p_flags);
4368 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4369 }
4370
9ea033b2 4371 free (phdrs);
e0a31db1 4372 return TRUE;
252b5132
RH		 4373}
4374
e0a31db1 4375static bfd_boolean
91d6fa6a 4376get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4377{
2cf0635d
NC		 4378 Elf64_External_Phdr * phdrs;
4379 Elf64_External_Phdr * external;
4380 Elf_Internal_Phdr * internal;
b34976b6 4381 unsigned int i;
e0a31db1
NC		 4382 unsigned int size = elf_header.e_phentsize;
4383 unsigned int num = elf_header.e_phnum;
4384
4385 /* PR binutils/17531: Cope with unexpected section header sizes. */
4386 if (size == 0 || num == 0)
4387 return FALSE;
4388 if (size < sizeof * phdrs)
4389 {
4390 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4391 return FALSE;
4392 }
4393 if (size > sizeof * phdrs)
4394 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4395
3f5e193b 4396 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4397 size, num, _("program headers"));
a6e9f9df 4398 if (!phdrs)
e0a31db1 4399 return FALSE;
9ea033b2 4400
91d6fa6a 4401 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4402 i < elf_header.e_phnum;
b34976b6 4403 i++, internal++, external++)
9ea033b2
NC		 4404 {
4405 internal->p_type = BYTE_GET (external->p_type);
4406 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4407 internal->p_offset = BYTE_GET (external->p_offset);
4408 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4409 internal->p_paddr = BYTE_GET (external->p_paddr);
4410 internal->p_filesz = BYTE_GET (external->p_filesz);
4411 internal->p_memsz = BYTE_GET (external->p_memsz);
4412 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4413 }
4414
4415 free (phdrs);
e0a31db1 4416 return TRUE;
9ea033b2 4417}
252b5132 4418
d93f0186
NC		 4419/* Returns 1 if the program headers were read into `program_headers'. */
4420
4421static int
2cf0635d 4422get_program_headers (FILE * file)
d93f0186 4423{
2cf0635d 4424 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4425
4426 /* Check cache of prior read. */
4427 if (program_headers != NULL)
4428 return 1;
4429
3f5e193b
NC		 4430 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4431 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4432
4433 if (phdrs == NULL)
4434 {
8b73c356
NC		 4435 error (_("Out of memory reading %u program headers\n"),
4436 elf_header.e_phnum);
d93f0186
NC		 4437 return 0;
4438 }
4439
4440 if (is_32bit_elf
4441 ? get_32bit_program_headers (file, phdrs)
4442 : get_64bit_program_headers (file, phdrs))
4443 {
4444 program_headers = phdrs;
4445 return 1;
4446 }
4447
4448 free (phdrs);
4449 return 0;
4450}
4451
2f62977e
NC		 4452/* Returns 1 if the program headers were loaded. */
4453
252b5132 4454static int
2cf0635d 4455process_program_headers (FILE * file)
252b5132 4456{
2cf0635d 4457 Elf_Internal_Phdr * segment;
b34976b6 4458 unsigned int i;
252b5132
RH		 4459
4460 if (elf_header.e_phnum == 0)
4461 {
82f2dbf7
NC		 4462 /* PR binutils/12467. */
4463 if (elf_header.e_phoff != 0)
4464 warn (_("possibly corrupt ELF header - it has a non-zero program"
4465 " header offset, but no program headers"));
4466 else if (do_segments)
252b5132 4467 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4468 return 0;
252b5132
RH		 4469 }
4470
4471 if (do_segments && !do_header)
4472 {
f7a99963
NC		 4473 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4474 printf (_("Entry point "));
4475 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4476 printf (_("\nThere are %d program headers, starting at offset "),
4477 elf_header.e_phnum);
4478 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4479 printf ("\n");
252b5132
RH		 4480 }
4481
d93f0186 4482 if (! get_program_headers (file))
252b5132 4483 return 0;
103f02d3 4484
252b5132
RH		 4485 if (do_segments)
4486 {
3a1a2036
NC		 4487 if (elf_header.e_phnum > 1)
4488 printf (_("\nProgram Headers:\n"));
4489 else
4490 printf (_("\nProgram Headers:\n"));
76da6bbe 4491
f7a99963
NC		 4492 if (is_32bit_elf)
4493 printf
4494 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4495 else if (do_wide)
4496 printf
4497 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4498 else
4499 {
4500 printf
4501 (_(" Type Offset VirtAddr PhysAddr\n"));
4502 printf
4503 (_(" FileSiz MemSiz Flags Align\n"));
4504 }
252b5132
RH		 4505 }
4506
252b5132 4507 dynamic_addr = 0;
1b228002 4508 dynamic_size = 0;
252b5132
RH		 4509
4510 for (i = 0, segment = program_headers;
4511 i < elf_header.e_phnum;
b34976b6 4512 i++, segment++)
252b5132
RH		 4513 {
4514 if (do_segments)
4515 {
103f02d3 4516 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4517
4518 if (is_32bit_elf)
4519 {
4520 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4521 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4522 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4523 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4524 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4525 printf ("%c%c%c ",
4526 (segment->p_flags & PF_R ? 'R' : ' '),
4527 (segment->p_flags & PF_W ? 'W' : ' '),
4528 (segment->p_flags & PF_X ? 'E' : ' '));
4529 printf ("%#lx", (unsigned long) segment->p_align);
4530 }
d974e256
JJ		 4531 else if (do_wide)
4532 {
4533 if ((unsigned long) segment->p_offset == segment->p_offset)
4534 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4535 else
4536 {
4537 print_vma (segment->p_offset, FULL_HEX);
4538 putchar (' ');
4539 }
4540
4541 print_vma (segment->p_vaddr, FULL_HEX);
4542 putchar (' ');
4543 print_vma (segment->p_paddr, FULL_HEX);
4544 putchar (' ');
4545
4546 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4547 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4548 else
4549 {
4550 print_vma (segment->p_filesz, FULL_HEX);
4551 putchar (' ');
4552 }
4553
4554 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4555 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4556 else
4557 {
f48e6c45 4558 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4559 }
4560
4561 printf (" %c%c%c ",
4562 (segment->p_flags & PF_R ? 'R' : ' '),
4563 (segment->p_flags & PF_W ? 'W' : ' '),
4564 (segment->p_flags & PF_X ? 'E' : ' '));
4565
4566 if ((unsigned long) segment->p_align == segment->p_align)
4567 printf ("%#lx", (unsigned long) segment->p_align);
4568 else
4569 {
4570 print_vma (segment->p_align, PREFIX_HEX);
4571 }
4572 }
f7a99963
NC		 4573 else
4574 {
4575 print_vma (segment->p_offset, FULL_HEX);
4576 putchar (' ');
4577 print_vma (segment->p_vaddr, FULL_HEX);
4578 putchar (' ');
4579 print_vma (segment->p_paddr, FULL_HEX);
4580 printf ("\n ");
4581 print_vma (segment->p_filesz, FULL_HEX);
4582 putchar (' ');
4583 print_vma (segment->p_memsz, FULL_HEX);
4584 printf (" %c%c%c ",
4585 (segment->p_flags & PF_R ? 'R' : ' '),
4586 (segment->p_flags & PF_W ? 'W' : ' '),
4587 (segment->p_flags & PF_X ? 'E' : ' '));
4588 print_vma (segment->p_align, HEX);
4589 }
252b5132
RH		 4590 }
4591
f54498b4
NC		 4592 if (do_segments)
4593 putc ('\n', stdout);
4594
252b5132
RH		 4595 switch (segment->p_type)
4596 {
252b5132
RH		 4597 case PT_DYNAMIC:
4598 if (dynamic_addr)
4599 error (_("more than one dynamic segment\n"));
4600
20737c13
AM		 4601 /* By default, assume that the .dynamic section is the first
4602 section in the DYNAMIC segment. */
4603 dynamic_addr = segment->p_offset;
4604 dynamic_size = segment->p_filesz;
f54498b4
NC		 4605 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4606 if (dynamic_addr + dynamic_size >= current_file_size)
4607 {
4608 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4609 dynamic_addr = dynamic_size = 0;
4610 }
20737c13 4611
b2d38a17
NC		 4612 /* Try to locate the .dynamic section. If there is
4613 a section header table, we can easily locate it. */
4614 if (section_headers != NULL)
4615 {
2cf0635d 4616 Elf_Internal_Shdr * sec;
b2d38a17 4617
89fac5e3
RS		 4618 sec = find_section (".dynamic");
4619 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4620 {
28f997cf
TG		 4621 /* A corresponding .dynamic section is expected, but on
4622 IA-64/OpenVMS it is OK for it to be missing. */
4623 if (!is_ia64_vms ())
4624 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4625 break;
4626 }
4627
42bb2e33 4628 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4629 {
4630 dynamic_size = 0;
4631 break;
4632 }
42bb2e33 4633
b2d38a17
NC		 4634 dynamic_addr = sec->sh_offset;
4635 dynamic_size = sec->sh_size;
4636
4637 if (dynamic_addr < segment->p_offset
4638 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4639 warn (_("the .dynamic section is not contained"
4640 " within the dynamic segment\n"));
b2d38a17 4641 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4642 warn (_("the .dynamic section is not the first section"
4643 " in the dynamic segment.\n"));
b2d38a17 4644 }
252b5132
RH		 4645 break;
4646
4647 case PT_INTERP:
fb52b2f4
NC		 4648 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4649 SEEK_SET))
252b5132
RH		 4650 error (_("Unable to find program interpreter name\n"));
4651 else
4652 {
f8eae8b2 4653 char fmt [32];
9495b2e6 4654 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4655
4656 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4657 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4658
252b5132 4659 program_interpreter[0] = 0;
7bd7b3ef
AM		 4660 if (fscanf (file, fmt, program_interpreter) <= 0)
4661 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4662
4663 if (do_segments)
f54498b4 4664 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4665 program_interpreter);
4666 }
4667 break;
4668 }
252b5132
RH		 4669 }
4670
c256ffe7 4671 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4672 {
4673 printf (_("\n Section to Segment mapping:\n"));
4674 printf (_(" Segment Sections...\n"));
4675
252b5132
RH		 4676 for (i = 0; i < elf_header.e_phnum; i++)
4677 {
9ad5cbcf 4678 unsigned int j;
2cf0635d 4679 Elf_Internal_Shdr * section;
252b5132
RH		 4680
4681 segment = program_headers + i;
b391a3e3 4682 section = section_headers + 1;
252b5132
RH		 4683
4684 printf (" %2.2d ", i);
4685
b34976b6 4686 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4687 {
f4638467
AM		 4688 if (!ELF_TBSS_SPECIAL (section, segment)
4689 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4690 printf ("%s ", printable_section_name (section));
252b5132
RH		 4691 }
4692
4693 putc ('\n',stdout);
4694 }
4695 }
4696
252b5132
RH		 4697 return 1;
4698}
4699
4700
d93f0186
NC		 4701/* Find the file offset corresponding to VMA by using the program headers. */
4702
4703static long
2cf0635d 4704offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4705{
2cf0635d 4706 Elf_Internal_Phdr * seg;
d93f0186
NC		 4707
4708 if (! get_program_headers (file))
4709 {
4710 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4711 return (long) vma;
4712 }
4713
4714 for (seg = program_headers;
4715 seg < program_headers + elf_header.e_phnum;
4716 ++seg)
4717 {
4718 if (seg->p_type != PT_LOAD)
4719 continue;
4720
4721 if (vma >= (seg->p_vaddr & -seg->p_align)
4722 && vma + size <= seg->p_vaddr + seg->p_filesz)
4723 return vma - seg->p_vaddr + seg->p_offset;
4724 }
4725
4726 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4727 (unsigned long) vma);
d93f0186
NC		 4728 return (long) vma;
4729}
4730
4731
049b0c3a
NC		 4732/* Allocate memory and load the sections headers into the global pointer
4733 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4734 generate any error messages if the load fails. */
4735
4736static bfd_boolean
4737get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4738{
2cf0635d
NC		 4739 Elf32_External_Shdr * shdrs;
4740 Elf_Internal_Shdr * internal;
b34976b6 4741 unsigned int i;
049b0c3a
NC		 4742 unsigned int size = elf_header.e_shentsize;
4743 unsigned int num = probe ? 1 : elf_header.e_shnum;
4744
4745 /* PR binutils/17531: Cope with unexpected section header sizes. */
4746 if (size == 0 || num == 0)
4747 return FALSE;
4748 if (size < sizeof * shdrs)
4749 {
4750 if (! probe)
4751 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4752 return FALSE;
4753 }
4754 if (!probe && size > sizeof * shdrs)
4755 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4756
3f5e193b 4757 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4758 size, num,
4759 probe ? NULL : _("section headers"));
4760 if (shdrs == NULL)
4761 return FALSE;
252b5132 4762
049b0c3a
NC		 4763 if (section_headers != NULL)
4764 free (section_headers);
3f5e193b
NC		 4765 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4766 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4767 if (section_headers == NULL)
4768 {
049b0c3a 4769 if (!probe)
8b73c356 4770 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4771 return FALSE;
252b5132
RH		 4772 }
4773
4774 for (i = 0, internal = section_headers;
560f3c1c 4775 i < num;
b34976b6 4776 i++, internal++)
252b5132
RH		 4777 {
4778 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4779 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4780 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4781 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4782 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4783 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4784 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4785 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4786 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4787 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4788 }
4789
4790 free (shdrs);
049b0c3a 4791 return TRUE;
252b5132
RH		 4792}
4793
049b0c3a
NC		 4794static bfd_boolean
4795get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4796{
2cf0635d
NC		 4797 Elf64_External_Shdr * shdrs;
4798 Elf_Internal_Shdr * internal;
b34976b6 4799 unsigned int i;
049b0c3a
NC		 4800 unsigned int size = elf_header.e_shentsize;
4801 unsigned int num = probe ? 1 : elf_header.e_shnum;
4802
4803 /* PR binutils/17531: Cope with unexpected section header sizes. */
4804 if (size == 0 || num == 0)
4805 return FALSE;
4806 if (size < sizeof * shdrs)
4807 {
4808 if (! probe)
4809 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4810 return FALSE;
4811 }
4812 if (! probe && size > sizeof * shdrs)
4813 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4814
3f5e193b 4815 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4816 size, num,
4817 probe ? NULL : _("section headers"));
4818 if (shdrs == NULL)
4819 return FALSE;
9ea033b2 4820
049b0c3a
NC		 4821 if (section_headers != NULL)
4822 free (section_headers);
3f5e193b
NC		 4823 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4824 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4825 if (section_headers == NULL)
4826 {
049b0c3a 4827 if (! probe)
8b73c356 4828 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4829 return FALSE;
9ea033b2
NC		 4830 }
4831
4832 for (i = 0, internal = section_headers;
560f3c1c 4833 i < num;
b34976b6 4834 i++, internal++)
9ea033b2
NC		 4835 {
4836 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4837 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4838 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4839 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4840 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4841 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4842 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4843 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4844 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4845 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4846 }
4847
4848 free (shdrs);
049b0c3a 4849 return TRUE;
9ea033b2
NC		 4850}
4851
252b5132 4852static Elf_Internal_Sym *
ba5cdace
NC		 4853get_32bit_elf_symbols (FILE * file,
4854 Elf_Internal_Shdr * section,
4855 unsigned long * num_syms_return)
252b5132 4856{
ba5cdace 4857 unsigned long number = 0;
dd24e3da 4858 Elf32_External_Sym * esyms = NULL;
ba5cdace 4859 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4860 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4861 Elf_Internal_Sym * psym;
b34976b6 4862 unsigned int j;
252b5132 4863
c9c1d674
EG		 4864 if (section->sh_size == 0)
4865 {
4866 if (num_syms_return != NULL)
4867 * num_syms_return = 0;
4868 return NULL;
4869 }
4870
dd24e3da 4871 /* Run some sanity checks first. */
c9c1d674 4872 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4873 {
c9c1d674
EG		 4874 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4875 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4876 goto exit_point;
dd24e3da
NC		 4877 }
4878
f54498b4
NC		 4879 if (section->sh_size > current_file_size)
4880 {
4881 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4882 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4883 goto exit_point;
4884 }
4885
dd24e3da
NC		 4886 number = section->sh_size / section->sh_entsize;
4887
4888 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4889 {
c9c1d674 4890 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4891 (unsigned long) section->sh_size,
4892 printable_section_name (section),
4893 (unsigned long) section->sh_entsize);
ba5cdace 4894 goto exit_point;
dd24e3da
NC		 4895 }
4896
3f5e193b
NC		 4897 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4898 section->sh_size, _("symbols"));
dd24e3da 4899 if (esyms == NULL)
ba5cdace 4900 goto exit_point;
252b5132 4901
9ad5cbcf
AM		 4902 shndx = NULL;
4903 if (symtab_shndx_hdr != NULL
4904 && (symtab_shndx_hdr->sh_link
4fbb74a6 4905 == (unsigned long) (section - section_headers)))
9ad5cbcf 4906 {
3f5e193b
NC		 4907 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4908 symtab_shndx_hdr->sh_offset,
4909 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4910 _("symbol table section indicies"));
dd24e3da
NC		 4911 if (shndx == NULL)
4912 goto exit_point;
c9c1d674
EG		 4913 /* PR17531: file: heap-buffer-overflow */
4914 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4915 {
4916 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4917 printable_section_name (symtab_shndx_hdr),
4918 (unsigned long) symtab_shndx_hdr->sh_size,
4919 (unsigned long) section->sh_size);
4920 goto exit_point;
4921 }
9ad5cbcf
AM		 4922 }
4923
3f5e193b 4924 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4925
4926 if (isyms == NULL)
4927 {
8b73c356
NC		 4928 error (_("Out of memory reading %lu symbols\n"),
4929 (unsigned long) number);
dd24e3da 4930 goto exit_point;
252b5132
RH		 4931 }
4932
dd24e3da 4933 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4934 {
4935 psym->st_name = BYTE_GET (esyms[j].st_name);
4936 psym->st_value = BYTE_GET (esyms[j].st_value);
4937 psym->st_size = BYTE_GET (esyms[j].st_size);
4938 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4939 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4940 psym->st_shndx
4941 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4942 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4943 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4944 psym->st_info = BYTE_GET (esyms[j].st_info);
4945 psym->st_other = BYTE_GET (esyms[j].st_other);
4946 }
4947
dd24e3da 4948 exit_point:
ba5cdace 4949 if (shndx != NULL)
9ad5cbcf 4950 free (shndx);
ba5cdace 4951 if (esyms != NULL)
dd24e3da 4952 free (esyms);
252b5132 4953
ba5cdace
NC		 4954 if (num_syms_return != NULL)
4955 * num_syms_return = isyms == NULL ? 0 : number;
4956
252b5132
RH		 4957 return isyms;
4958}
4959
9ea033b2 4960static Elf_Internal_Sym *
ba5cdace
NC		 4961get_64bit_elf_symbols (FILE * file,
4962 Elf_Internal_Shdr * section,
4963 unsigned long * num_syms_return)
9ea033b2 4964{
ba5cdace
NC		 4965 unsigned long number = 0;
4966 Elf64_External_Sym * esyms = NULL;
4967 Elf_External_Sym_Shndx * shndx = NULL;
4968 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4969 Elf_Internal_Sym * psym;
b34976b6 4970 unsigned int j;
9ea033b2 4971
c9c1d674
EG		 4972 if (section->sh_size == 0)
4973 {
4974 if (num_syms_return != NULL)
4975 * num_syms_return = 0;
4976 return NULL;
4977 }
4978
dd24e3da 4979 /* Run some sanity checks first. */
c9c1d674 4980 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4981 {
c9c1d674 4982 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 4983 printable_section_name (section),
4984 (unsigned long) section->sh_entsize);
ba5cdace 4985 goto exit_point;
dd24e3da
NC		 4986 }
4987
f54498b4
NC		 4988 if (section->sh_size > current_file_size)
4989 {
4990 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 4991 printable_section_name (section),
4992 (unsigned long) section->sh_size);
f54498b4
NC		 4993 goto exit_point;
4994 }
4995
dd24e3da
NC		 4996 number = section->sh_size / section->sh_entsize;
4997
4998 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4999 {
c9c1d674 5000 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5001 (unsigned long) section->sh_size,
5002 printable_section_name (section),
5003 (unsigned long) section->sh_entsize);
ba5cdace 5004 goto exit_point;
dd24e3da
NC		 5005 }
5006
3f5e193b
NC		 5007 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5008 section->sh_size, _("symbols"));
a6e9f9df 5009 if (!esyms)
ba5cdace 5010 goto exit_point;
9ea033b2 5011
9ad5cbcf
AM		 5012 if (symtab_shndx_hdr != NULL
5013 && (symtab_shndx_hdr->sh_link
4fbb74a6 5014 == (unsigned long) (section - section_headers)))
9ad5cbcf 5015 {
3f5e193b
NC		 5016 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5017 symtab_shndx_hdr->sh_offset,
5018 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5019 _("symbol table section indicies"));
ba5cdace
NC		 5020 if (shndx == NULL)
5021 goto exit_point;
c9c1d674
EG		 5022 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5023 {
5024 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5025 printable_section_name (symtab_shndx_hdr),
5026 (unsigned long) symtab_shndx_hdr->sh_size,
5027 (unsigned long) section->sh_size);
5028 goto exit_point;
5029 }
9ad5cbcf
AM		 5030 }
5031
3f5e193b 5032 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5033
5034 if (isyms == NULL)
5035 {
8b73c356
NC		 5036 error (_("Out of memory reading %lu symbols\n"),
5037 (unsigned long) number);
ba5cdace 5038 goto exit_point;
9ea033b2
NC		 5039 }
5040
ba5cdace 5041 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5042 {
5043 psym->st_name = BYTE_GET (esyms[j].st_name);
5044 psym->st_info = BYTE_GET (esyms[j].st_info);
5045 psym->st_other = BYTE_GET (esyms[j].st_other);
5046 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5047
4fbb74a6 5048 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5049 psym->st_shndx
5050 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5051 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5052 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5053
66543521
AM		 5054 psym->st_value = BYTE_GET (esyms[j].st_value);
5055 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5056 }
5057
ba5cdace
NC		 5058 exit_point:
5059 if (shndx != NULL)
9ad5cbcf 5060 free (shndx);
ba5cdace
NC		 5061 if (esyms != NULL)
5062 free (esyms);
5063
5064 if (num_syms_return != NULL)
5065 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5066
5067 return isyms;
5068}
5069
d1133906 5070static const char *
d3ba0551 5071get_elf_section_flags (bfd_vma sh_flags)
d1133906 5072{
5477e8a0 5073 static char buff[1024];
2cf0635d 5074 char * p = buff;
8d5ff12c 5075 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5076 int sindex;
5077 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5078 bfd_vma os_flags = 0;
5079 bfd_vma proc_flags = 0;
5080 bfd_vma unknown_flags = 0;
148b93f2 5081 static const struct
5477e8a0 5082 {
2cf0635d 5083 const char * str;
5477e8a0
L		 5084 int len;
5085 }
5086 flags [] =
5087 {
cfcac11d
NC		 5088 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5089 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5090 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5091 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5092 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5093 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5094 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5095 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5096 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5097 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5098 /* IA-64 specific. */
5099 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5100 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5101 /* IA-64 OpenVMS specific. */
5102 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5103 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5104 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5105 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5106 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5107 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5108 /* Generic. */
cfcac11d 5109 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5110 /* SPARC specific. */
cfcac11d 5111 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 5112 };
5113
5114 if (do_section_details)
5115 {
8d5ff12c
L		 5116 sprintf (buff, "[%*.*lx]: ",
5117 field_size, field_size, (unsigned long) sh_flags);
5118 p += field_size + 4;
5477e8a0 5119 }
76da6bbe 5120
d1133906
NC		 5121 while (sh_flags)
5122 {
5123 bfd_vma flag;
5124
5125 flag = sh_flags & - sh_flags;
5126 sh_flags &= ~ flag;
76da6bbe 5127
5477e8a0 5128 if (do_section_details)
d1133906 5129 {
5477e8a0
L		 5130 switch (flag)
5131 {
91d6fa6a
NC		 5132 case SHF_WRITE: sindex = 0; break;
5133 case SHF_ALLOC: sindex = 1; break;
5134 case SHF_EXECINSTR: sindex = 2; break;
5135 case SHF_MERGE: sindex = 3; break;
5136 case SHF_STRINGS: sindex = 4; break;
5137 case SHF_INFO_LINK: sindex = 5; break;
5138 case SHF_LINK_ORDER: sindex = 6; break;
5139 case SHF_OS_NONCONFORMING: sindex = 7; break;
5140 case SHF_GROUP: sindex = 8; break;
5141 case SHF_TLS: sindex = 9; break;
18ae9cc1 5142 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 5143
5477e8a0 5144 default:
91d6fa6a 5145 sindex = -1;
cfcac11d 5146 switch (elf_header.e_machine)
148b93f2 5147 {
cfcac11d 5148 case EM_IA_64:
148b93f2 5149 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5150 sindex = 10;
148b93f2 5151 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5152 sindex = 11;
148b93f2
NC		 5153#ifdef BFD64
5154 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5155 switch (flag)
5156 {
91d6fa6a
NC		 5157 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5158 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5159 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5160 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5161 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5162 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5163 default: break;
5164 }
5165#endif
cfcac11d
NC		 5166 break;
5167
caa83f8b
NC		 5168 case EM_386:
5169 case EM_486:
5170 case EM_X86_64:
7f502d6c 5171 case EM_L1OM:
7a9068fe 5172 case EM_K1OM:
cfcac11d
NC		 5173 case EM_OLD_SPARCV9:
5174 case EM_SPARC32PLUS:
5175 case EM_SPARCV9:
5176 case EM_SPARC:
18ae9cc1 5177 if (flag == SHF_ORDERED)
91d6fa6a 5178 sindex = 19;
cfcac11d
NC		 5179 break;
5180 default:
5181 break;
148b93f2 5182 }
5477e8a0
L		 5183 }
5184
91d6fa6a 5185 if (sindex != -1)
5477e8a0 5186 {
8d5ff12c
L		 5187 if (p != buff + field_size + 4)
5188 {
5189 if (size < (10 + 2))
bee0ee85
NC		 5190 {
5191 warn (_("Internal error: not enough buffer room for section flag info"));
5192 return _("<unknown>");
5193 }
8d5ff12c
L		 5194 size -= 2;
5195 *p++ = ',';
5196 *p++ = ' ';
5197 }
5198
91d6fa6a
NC		 5199 size -= flags [sindex].len;
5200 p = stpcpy (p, flags [sindex].str);
5477e8a0 5201 }
3b22753a 5202 else if (flag & SHF_MASKOS)
8d5ff12c 5203 os_flags |= flag;
d1133906 5204 else if (flag & SHF_MASKPROC)
8d5ff12c 5205 proc_flags |= flag;
d1133906 5206 else
8d5ff12c 5207 unknown_flags |= flag;
5477e8a0
L		 5208 }
5209 else
5210 {
5211 switch (flag)
5212 {
5213 case SHF_WRITE: *p = 'W'; break;
5214 case SHF_ALLOC: *p = 'A'; break;
5215 case SHF_EXECINSTR: *p = 'X'; break;
5216 case SHF_MERGE: *p = 'M'; break;
5217 case SHF_STRINGS: *p = 'S'; break;
5218 case SHF_INFO_LINK: *p = 'I'; break;
5219 case SHF_LINK_ORDER: *p = 'L'; break;
5220 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5221 case SHF_GROUP: *p = 'G'; break;
5222 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5223 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 5224
5225 default:
8a9036a4 5226 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5227 || elf_header.e_machine == EM_L1OM
5228 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5229 && flag == SHF_X86_64_LARGE)
5230 *p = 'l';
5231 else if (flag & SHF_MASKOS)
5232 {
5233 *p = 'o';
5234 sh_flags &= ~ SHF_MASKOS;
5235 }
5236 else if (flag & SHF_MASKPROC)
5237 {
5238 *p = 'p';
5239 sh_flags &= ~ SHF_MASKPROC;
5240 }
5241 else
5242 *p = 'x';
5243 break;
5244 }
5245 p++;
d1133906
NC		 5246 }
5247 }
76da6bbe 5248
8d5ff12c
L		 5249 if (do_section_details)
5250 {
5251 if (os_flags)
5252 {
5253 size -= 5 + field_size;
5254 if (p != buff + field_size + 4)
5255 {
5256 if (size < (2 + 1))
bee0ee85
NC		 5257 {
5258 warn (_("Internal error: not enough buffer room for section flag info"));
5259 return _("<unknown>");
5260 }
8d5ff12c
L		 5261 size -= 2;
5262 *p++ = ',';
5263 *p++ = ' ';
5264 }
5265 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5266 (unsigned long) os_flags);
5267 p += 5 + field_size;
5268 }
5269 if (proc_flags)
5270 {
5271 size -= 7 + field_size;
5272 if (p != buff + field_size + 4)
5273 {
5274 if (size < (2 + 1))
bee0ee85
NC		 5275 {
5276 warn (_("Internal error: not enough buffer room for section flag info"));
5277 return _("<unknown>");
5278 }
8d5ff12c
L		 5279 size -= 2;
5280 *p++ = ',';
5281 *p++ = ' ';
5282 }
5283 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5284 (unsigned long) proc_flags);
5285 p += 7 + field_size;
5286 }
5287 if (unknown_flags)
5288 {
5289 size -= 10 + field_size;
5290 if (p != buff + field_size + 4)
5291 {
5292 if (size < (2 + 1))
bee0ee85
NC		 5293 {
5294 warn (_("Internal error: not enough buffer room for section flag info"));
5295 return _("<unknown>");
5296 }
8d5ff12c
L		 5297 size -= 2;
5298 *p++ = ',';
5299 *p++ = ' ';
5300 }
2b692964 5301 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5302 (unsigned long) unknown_flags);
5303 p += 10 + field_size;
5304 }
5305 }
5306
e9e44622 5307 *p = '\0';
d1133906
NC		 5308 return buff;
5309}
5310
252b5132 5311static int
2cf0635d 5312process_section_headers (FILE * file)
252b5132 5313{
2cf0635d 5314 Elf_Internal_Shdr * section;
b34976b6 5315 unsigned int i;
252b5132
RH		 5316
5317 section_headers = NULL;
5318
5319 if (elf_header.e_shnum == 0)
5320 {
82f2dbf7
NC		 5321 /* PR binutils/12467. */
5322 if (elf_header.e_shoff != 0)
5323 warn (_("possibly corrupt ELF file header - it has a non-zero"
5324 " section header offset, but no section headers\n"));
5325 else if (do_sections)
252b5132
RH		 5326 printf (_("\nThere are no sections in this file.\n"));
5327
5328 return 1;
5329 }
5330
5331 if (do_sections && !do_header)
9ea033b2 5332 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5333 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5334
9ea033b2
NC		 5335 if (is_32bit_elf)
5336 {
049b0c3a 5337 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5338 return 0;
5339 }
049b0c3a 5340 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5341 return 0;
5342
5343 /* Read in the string table, so that we have names to display. */
0b49d371 5344 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5345 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5346 {
4fbb74a6 5347 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5348
c256ffe7
JJ		 5349 if (section->sh_size != 0)
5350 {
3f5e193b
NC		 5351 string_table = (char *) get_data (NULL, file, section->sh_offset,
5352 1, section->sh_size,
5353 _("string table"));
0de14b54 5354
c256ffe7
JJ		 5355 string_table_length = string_table != NULL ? section->sh_size : 0;
5356 }
252b5132
RH		 5357 }
5358
5359 /* Scan the sections for the dynamic symbol table
e3c8793a 5360 and dynamic string table and debug sections. */
252b5132
RH		 5361 dynamic_symbols = NULL;
5362 dynamic_strings = NULL;
5363 dynamic_syminfo = NULL;
f1ef08cb 5364 symtab_shndx_hdr = NULL;
103f02d3 5365
89fac5e3
RS		 5366 eh_addr_size = is_32bit_elf ? 4 : 8;
5367 switch (elf_header.e_machine)
5368 {
5369 case EM_MIPS:
5370 case EM_MIPS_RS3_LE:
5371 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5372 FDE addresses. However, the ABI also has a semi-official ILP32
5373 variant for which the normal FDE address size rules apply.
5374
5375 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5376 section, where XX is the size of longs in bits. Unfortunately,
5377 earlier compilers provided no way of distinguishing ILP32 objects
5378 from LP64 objects, so if there's any doubt, we should assume that
5379 the official LP64 form is being used. */
5380 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5381 && find_section (".gcc_compiled_long32") == NULL)
5382 eh_addr_size = 8;
5383 break;
0f56a26a
DD		 5384
5385 case EM_H8_300:
5386 case EM_H8_300H:
5387 switch (elf_header.e_flags & EF_H8_MACH)
5388 {
5389 case E_H8_MACH_H8300:
5390 case E_H8_MACH_H8300HN:
5391 case E_H8_MACH_H8300SN:
5392 case E_H8_MACH_H8300SXN:
5393 eh_addr_size = 2;
5394 break;
5395 case E_H8_MACH_H8300H:
5396 case E_H8_MACH_H8300S:
5397 case E_H8_MACH_H8300SX:
5398 eh_addr_size = 4;
5399 break;
5400 }
f4236fe4
DD		 5401 break;
5402
ff7eeb89 5403 case EM_M32C_OLD:
f4236fe4
DD		 5404 case EM_M32C:
5405 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5406 {
5407 case EF_M32C_CPU_M16C:
5408 eh_addr_size = 2;
5409 break;
5410 }
5411 break;
89fac5e3
RS		 5412 }
5413
76ca31c0
NC		 5414#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5415 do \
5416 { \
5417 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5418 if (section->sh_entsize != expected_entsize) \
9dd3a467 5419 { \
76ca31c0
NC		 5420 char buf[40]; \
5421 sprintf_vma (buf, section->sh_entsize); \
5422 /* Note: coded this way so that there is a single string for \
5423 translation. */ \
5424 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5425 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5426 (unsigned) expected_entsize); \
9dd3a467 5427 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5428 } \
5429 } \
08d8fa11 5430 while (0)
9dd3a467
NC		 5431
5432#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5433 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5434 sizeof (Elf64_External_##type))
5435
252b5132
RH		 5436 for (i = 0, section = section_headers;
5437 i < elf_header.e_shnum;
b34976b6 5438 i++, section++)
252b5132 5439 {
2cf0635d 5440 char * name = SECTION_NAME (section);
252b5132
RH		 5441
5442 if (section->sh_type == SHT_DYNSYM)
5443 {
5444 if (dynamic_symbols != NULL)
5445 {
5446 error (_("File contains multiple dynamic symbol tables\n"));
5447 continue;
5448 }
5449
08d8fa11 5450 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5451 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5452 }
5453 else if (section->sh_type == SHT_STRTAB
18bd398b 5454 && streq (name, ".dynstr"))
252b5132
RH		 5455 {
5456 if (dynamic_strings != NULL)
5457 {
5458 error (_("File contains multiple dynamic string tables\n"));
5459 continue;
5460 }
5461
3f5e193b
NC		 5462 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5463 1, section->sh_size,
5464 _("dynamic strings"));
59245841 5465 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5466 }
9ad5cbcf
AM		 5467 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5468 {
5469 if (symtab_shndx_hdr != NULL)
5470 {
5471 error (_("File contains multiple symtab shndx tables\n"));
5472 continue;
5473 }
5474 symtab_shndx_hdr = section;
5475 }
08d8fa11
JJ		 5476 else if (section->sh_type == SHT_SYMTAB)
5477 CHECK_ENTSIZE (section, i, Sym);
5478 else if (section->sh_type == SHT_GROUP)
5479 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5480 else if (section->sh_type == SHT_REL)
5481 CHECK_ENTSIZE (section, i, Rel);
5482 else if (section->sh_type == SHT_RELA)
5483 CHECK_ENTSIZE (section, i, Rela);
252b5132 5484 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5485 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5486 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5487 || do_debug_str || do_debug_loc || do_debug_ranges
5488 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5489 && (const_strneq (name, ".debug_")
5490 || const_strneq (name, ".zdebug_")))
252b5132 5491 {
1b315056
CS		 5492 if (name[1] == 'z')
5493 name += sizeof (".zdebug_") - 1;
5494 else
5495 name += sizeof (".debug_") - 1;
252b5132
RH		 5496
5497 if (do_debugging
4723351a
CC		 5498 || (do_debug_info && const_strneq (name, "info"))
5499 || (do_debug_info && const_strneq (name, "types"))
5500 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5501 || (do_debug_lines && strcmp (name, "line") == 0)
5502 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5503 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5504 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5505 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5506 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5507 || (do_debug_aranges && const_strneq (name, "aranges"))
5508 || (do_debug_ranges && const_strneq (name, "ranges"))
5509 || (do_debug_frames && const_strneq (name, "frame"))
5510 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5511 || (do_debug_macinfo && const_strneq (name, "macro"))
5512 || (do_debug_str && const_strneq (name, "str"))
5513 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5514 || (do_debug_addr && const_strneq (name, "addr"))
5515 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5516 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5517 )
09c11c86 5518 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5519 }
a262ae96 5520 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5521 else if ((do_debugging || do_debug_info)
0112cd26 5522 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5523 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5524 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5525 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5526 else if (do_gdb_index && streq (name, ".gdb_index"))
5527 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5528 /* Trace sections for Itanium VMS. */
5529 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5530 || do_trace_aranges)
5531 && const_strneq (name, ".trace_"))
5532 {
5533 name += sizeof (".trace_") - 1;
5534
5535 if (do_debugging
5536 || (do_trace_info && streq (name, "info"))
5537 || (do_trace_abbrevs && streq (name, "abbrev"))
5538 || (do_trace_aranges && streq (name, "aranges"))
5539 )
5540 request_dump_bynumber (i, DEBUG_DUMP);
5541 }
252b5132
RH		 5542 }
5543
5544 if (! do_sections)
5545 return 1;
5546
3a1a2036
NC		 5547 if (elf_header.e_shnum > 1)
5548 printf (_("\nSection Headers:\n"));
5549 else
5550 printf (_("\nSection Header:\n"));
76da6bbe 5551
f7a99963 5552 if (is_32bit_elf)
595cf52e 5553 {
5477e8a0 5554 if (do_section_details)
595cf52e
L		 5555 {
5556 printf (_(" [Nr] Name\n"));
5477e8a0 5557 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5558 }
5559 else
5560 printf
5561 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5562 }
d974e256 5563 else if (do_wide)
595cf52e 5564 {
5477e8a0 5565 if (do_section_details)
595cf52e
L		 5566 {
5567 printf (_(" [Nr] Name\n"));
5477e8a0 5568 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5569 }
5570 else
5571 printf
5572 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5573 }
f7a99963
NC		 5574 else
5575 {
5477e8a0 5576 if (do_section_details)
595cf52e
L		 5577 {
5578 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5579 printf (_(" Type Address Offset Link\n"));
5580 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5581 }
5582 else
5583 {
5584 printf (_(" [Nr] Name Type Address Offset\n"));
5585 printf (_(" Size EntSize Flags Link Info Align\n"));
5586 }
f7a99963 5587 }
252b5132 5588
5477e8a0
L		 5589 if (do_section_details)
5590 printf (_(" Flags\n"));
5591
252b5132
RH		 5592 for (i = 0, section = section_headers;
5593 i < elf_header.e_shnum;
b34976b6 5594 i++, section++)
252b5132 5595 {
7bfd842d 5596 printf (" [%2u] ", i);
5477e8a0 5597 if (do_section_details)
74e1a04b 5598 printf ("%s\n ", printable_section_name (section));
595cf52e 5599 else
74e1a04b 5600 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5601
ea52a088
NC		 5602 printf (do_wide ? " %-15s " : " %-15.15s ",
5603 get_section_type_name (section->sh_type));
0b4362b0 5604
f7a99963
NC		 5605 if (is_32bit_elf)
5606 {
cfcac11d
NC		 5607 const char * link_too_big = NULL;
5608
f7a99963 5609 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5610
f7a99963
NC		 5611 printf ( " %6.6lx %6.6lx %2.2lx",
5612 (unsigned long) section->sh_offset,
5613 (unsigned long) section->sh_size,
5614 (unsigned long) section->sh_entsize);
d1133906 5615
5477e8a0
L		 5616 if (do_section_details)
5617 fputs (" ", stdout);
5618 else
5619 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5620
cfcac11d
NC		 5621 if (section->sh_link >= elf_header.e_shnum)
5622 {
5623 link_too_big = "";
5624 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5625 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5626 switch (elf_header.e_machine)
5627 {
caa83f8b
NC		 5628 case EM_386:
5629 case EM_486:
5630 case EM_X86_64:
7f502d6c 5631 case EM_L1OM:
7a9068fe 5632 case EM_K1OM:
cfcac11d
NC		 5633 case EM_OLD_SPARCV9:
5634 case EM_SPARC32PLUS:
5635 case EM_SPARCV9:
5636 case EM_SPARC:
5637 if (section->sh_link == (SHN_BEFORE & 0xffff))
5638 link_too_big = "BEFORE";
5639 else if (section->sh_link == (SHN_AFTER & 0xffff))
5640 link_too_big = "AFTER";
5641 break;
5642 default:
5643 break;
5644 }
5645 }
5646
5647 if (do_section_details)
5648 {
5649 if (link_too_big != NULL && * link_too_big)
5650 printf ("<%s> ", link_too_big);
5651 else
5652 printf ("%2u ", section->sh_link);
5653 printf ("%3u %2lu\n", section->sh_info,
5654 (unsigned long) section->sh_addralign);
5655 }
5656 else
5657 printf ("%2u %3u %2lu\n",
5658 section->sh_link,
5659 section->sh_info,
5660 (unsigned long) section->sh_addralign);
5661
5662 if (link_too_big && ! * link_too_big)
5663 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5664 i, section->sh_link);
f7a99963 5665 }
d974e256
JJ		 5666 else if (do_wide)
5667 {
5668 print_vma (section->sh_addr, LONG_HEX);
5669
5670 if ((long) section->sh_offset == section->sh_offset)
5671 printf (" %6.6lx", (unsigned long) section->sh_offset);
5672 else
5673 {
5674 putchar (' ');
5675 print_vma (section->sh_offset, LONG_HEX);
5676 }
5677
5678 if ((unsigned long) section->sh_size == section->sh_size)
5679 printf (" %6.6lx", (unsigned long) section->sh_size);
5680 else
5681 {
5682 putchar (' ');
5683 print_vma (section->sh_size, LONG_HEX);
5684 }
5685
5686 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5687 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5688 else
5689 {
5690 putchar (' ');
5691 print_vma (section->sh_entsize, LONG_HEX);
5692 }
5693
5477e8a0
L		 5694 if (do_section_details)
5695 fputs (" ", stdout);
5696 else
5697 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5698
72de5009 5699 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5700
5701 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5702 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5703 else
5704 {
5705 print_vma (section->sh_addralign, DEC);
5706 putchar ('\n');
5707 }
5708 }
5477e8a0 5709 else if (do_section_details)
595cf52e 5710 {
5477e8a0 5711 printf (" %-15.15s ",
595cf52e 5712 get_section_type_name (section->sh_type));
595cf52e
L		 5713 print_vma (section->sh_addr, LONG_HEX);
5714 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5715 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5716 else
5717 {
5718 printf (" ");
5719 print_vma (section->sh_offset, LONG_HEX);
5720 }
72de5009 5721 printf (" %u\n ", section->sh_link);
595cf52e 5722 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5723 putchar (' ');
595cf52e
L		 5724 print_vma (section->sh_entsize, LONG_HEX);
5725
72de5009
AM		 5726 printf (" %-16u %lu\n",
5727 section->sh_info,
595cf52e
L		 5728 (unsigned long) section->sh_addralign);
5729 }
f7a99963
NC		 5730 else
5731 {
5732 putchar (' ');
5733 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5734 if ((long) section->sh_offset == section->sh_offset)
5735 printf (" %8.8lx", (unsigned long) section->sh_offset);
5736 else
5737 {
5738 printf (" ");
5739 print_vma (section->sh_offset, LONG_HEX);
5740 }
f7a99963
NC		 5741 printf ("\n ");
5742 print_vma (section->sh_size, LONG_HEX);
5743 printf (" ");
5744 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5745
d1133906 5746 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5747
72de5009
AM		 5748 printf (" %2u %3u %lu\n",
5749 section->sh_link,
5750 section->sh_info,
f7a99963
NC		 5751 (unsigned long) section->sh_addralign);
5752 }
5477e8a0
L		 5753
5754 if (do_section_details)
5755 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5756 }
5757
5477e8a0 5758 if (!do_section_details)
3dbcc61d
NC		 5759 {
5760 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5761 || elf_header.e_machine == EM_L1OM
5762 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5763 printf (_("Key to Flags:\n\
5764 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5765 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5766 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5767 else
5768 printf (_("Key to Flags:\n\
e3c8793a 5769 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5770 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5771 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5772 }
d1133906 5773
252b5132
RH		 5774 return 1;
5775}
5776
f5842774
L		 5777static const char *
5778get_group_flags (unsigned int flags)
5779{
5780 static char buff[32];
5781 switch (flags)
5782 {
220453ec
AM		 5783 case 0:
5784 return "";
5785
f5842774 5786 case GRP_COMDAT:
220453ec 5787 return "COMDAT ";
f5842774
L		 5788
5789 default:
220453ec 5790 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5791 break;
5792 }
5793 return buff;
5794}
5795
5796static int
2cf0635d 5797process_section_groups (FILE * file)
f5842774 5798{
2cf0635d 5799 Elf_Internal_Shdr * section;
f5842774 5800 unsigned int i;
2cf0635d
NC		 5801 struct group * group;
5802 Elf_Internal_Shdr * symtab_sec;
5803 Elf_Internal_Shdr * strtab_sec;
5804 Elf_Internal_Sym * symtab;
ba5cdace 5805 unsigned long num_syms;
2cf0635d 5806 char * strtab;
c256ffe7 5807 size_t strtab_size;
d1f5c6e3
L		 5808
5809 /* Don't process section groups unless needed. */
5810 if (!do_unwind && !do_section_groups)
5811 return 1;
f5842774
L		 5812
5813 if (elf_header.e_shnum == 0)
5814 {
5815 if (do_section_groups)
82f2dbf7 5816 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5817
5818 return 1;
5819 }
5820
5821 if (section_headers == NULL)
5822 {
5823 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5824 /* PR 13622: This can happen with a corrupt ELF header. */
5825 return 0;
f5842774
L		 5826 }
5827
3f5e193b
NC		 5828 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5829 sizeof (struct group *));
e4b17d5c
L		 5830
5831 if (section_headers_groups == NULL)
5832 {
8b73c356
NC		 5833 error (_("Out of memory reading %u section group headers\n"),
5834 elf_header.e_shnum);
e4b17d5c
L		 5835 return 0;
5836 }
5837
f5842774 5838 /* Scan the sections for the group section. */
d1f5c6e3 5839 group_count = 0;
f5842774
L		 5840 for (i = 0, section = section_headers;
5841 i < elf_header.e_shnum;
5842 i++, section++)
e4b17d5c
L		 5843 if (section->sh_type == SHT_GROUP)
5844 group_count++;
5845
d1f5c6e3
L		 5846 if (group_count == 0)
5847 {
5848 if (do_section_groups)
5849 printf (_("\nThere are no section groups in this file.\n"));
5850
5851 return 1;
5852 }
5853
3f5e193b 5854 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5855
5856 if (section_groups == NULL)
5857 {
8b73c356
NC		 5858 error (_("Out of memory reading %lu groups\n"),
5859 (unsigned long) group_count);
e4b17d5c
L		 5860 return 0;
5861 }
5862
d1f5c6e3
L		 5863 symtab_sec = NULL;
5864 strtab_sec = NULL;
5865 symtab = NULL;
ba5cdace 5866 num_syms = 0;
d1f5c6e3 5867 strtab = NULL;
c256ffe7 5868 strtab_size = 0;
e4b17d5c
L		 5869 for (i = 0, section = section_headers, group = section_groups;
5870 i < elf_header.e_shnum;
5871 i++, section++)
f5842774
L		 5872 {
5873 if (section->sh_type == SHT_GROUP)
5874 {
74e1a04b
NC		 5875 const char * name = printable_section_name (section);
5876 const char * group_name;
2cf0635d
NC		 5877 unsigned char * start;
5878 unsigned char * indices;
f5842774 5879 unsigned int entry, j, size;
2cf0635d
NC		 5880 Elf_Internal_Shdr * sec;
5881 Elf_Internal_Sym * sym;
f5842774
L		 5882
5883 /* Get the symbol table. */
4fbb74a6
AM		 5884 if (section->sh_link >= elf_header.e_shnum
5885 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5886 != SHT_SYMTAB))
f5842774
L		 5887 {
5888 error (_("Bad sh_link in group section `%s'\n"), name);
5889 continue;
5890 }
d1f5c6e3
L		 5891
5892 if (symtab_sec != sec)
5893 {
5894 symtab_sec = sec;
5895 if (symtab)
5896 free (symtab);
ba5cdace 5897 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5898 }
f5842774 5899
dd24e3da
NC		 5900 if (symtab == NULL)
5901 {
5902 error (_("Corrupt header in group section `%s'\n"), name);
5903 continue;
5904 }
5905
ba5cdace
NC		 5906 if (section->sh_info >= num_syms)
5907 {
5908 error (_("Bad sh_info in group section `%s'\n"), name);
5909 continue;
5910 }
5911
f5842774
L		 5912 sym = symtab + section->sh_info;
5913
5914 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5915 {
4fbb74a6
AM		 5916 if (sym->st_shndx == 0
5917 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5918 {
5919 error (_("Bad sh_info in group section `%s'\n"), name);
5920 continue;
5921 }
ba2685cc 5922
4fbb74a6 5923 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5924 strtab_sec = NULL;
5925 if (strtab)
5926 free (strtab);
f5842774 5927 strtab = NULL;
c256ffe7 5928 strtab_size = 0;
f5842774
L		 5929 }
5930 else
5931 {
5932 /* Get the string table. */
4fbb74a6 5933 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5934 {
5935 strtab_sec = NULL;
5936 if (strtab)
5937 free (strtab);
5938 strtab = NULL;
5939 strtab_size = 0;
5940 }
5941 else if (strtab_sec
4fbb74a6 5942 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5943 {
5944 strtab_sec = sec;
5945 if (strtab)
5946 free (strtab);
071436c6 5947
3f5e193b 5948 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 5949 1, strtab_sec->sh_size,
5950 _("string table"));
c256ffe7 5951 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5952 }
c256ffe7 5953 group_name = sym->st_name < strtab_size
2b692964 5954 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5955 }
5956
c9c1d674
EG		 5957 /* PR 17531: file: loop. */
5958 if (section->sh_entsize > section->sh_size)
5959 {
5960 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5961 printable_section_name (section),
8066deb1
AM		 5962 (unsigned long) section->sh_entsize,
5963 (unsigned long) section->sh_size);
c9c1d674
EG		 5964 break;
5965 }
5966
3f5e193b
NC		 5967 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5968 1, section->sh_size,
5969 _("section data"));
59245841
NC		 5970 if (start == NULL)
5971 continue;
f5842774
L		 5972
5973 indices = start;
5974 size = (section->sh_size / section->sh_entsize) - 1;
5975 entry = byte_get (indices, 4);
5976 indices += 4;
e4b17d5c
L		 5977
5978 if (do_section_groups)
5979 {
2b692964 5980 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5981 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5982
e4b17d5c
L		 5983 printf (_(" [Index] Name\n"));
5984 }
5985
5986 group->group_index = i;
5987
f5842774
L		 5988 for (j = 0; j < size; j++)
5989 {
2cf0635d 5990 struct group_list * g;
e4b17d5c 5991
f5842774
L		 5992 entry = byte_get (indices, 4);
5993 indices += 4;
5994
4fbb74a6 5995 if (entry >= elf_header.e_shnum)
391cb864
L		 5996 {
5997 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5998 entry, i, elf_header.e_shnum - 1);
5999 continue;
6000 }
391cb864 6001
4fbb74a6 6002 if (section_headers_groups [entry] != NULL)
e4b17d5c 6003 {
d1f5c6e3
L		 6004 if (entry)
6005 {
391cb864
L		 6006 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6007 entry, i,
4fbb74a6 6008 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6009 continue;
6010 }
6011 else
6012 {
6013 /* Intel C/C++ compiler may put section 0 in a
6014 section group. We just warn it the first time
6015 and ignore it afterwards. */
6016 static int warned = 0;
6017 if (!warned)
6018 {
6019 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6020 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6021 warned++;
6022 }
6023 }
e4b17d5c
L		 6024 }
6025
4fbb74a6 6026 section_headers_groups [entry] = group;
e4b17d5c
L		 6027
6028 if (do_section_groups)
6029 {
4fbb74a6 6030 sec = section_headers + entry;
74e1a04b 6031 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6032 }
6033
3f5e193b 6034 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6035 g->section_index = entry;
6036 g->next = group->root;
6037 group->root = g;
f5842774
L		 6038 }
6039
f5842774
L		 6040 if (start)
6041 free (start);
e4b17d5c
L		 6042
6043 group++;
f5842774
L		 6044 }
6045 }
6046
d1f5c6e3
L		 6047 if (symtab)
6048 free (symtab);
6049 if (strtab)
6050 free (strtab);
f5842774
L		 6051 return 1;
6052}
6053
28f997cf
TG		 6054/* Data used to display dynamic fixups. */
6055
6056struct ia64_vms_dynfixup
6057{
6058 bfd_vma needed_ident; /* Library ident number. */
6059 bfd_vma needed; /* Index in the dstrtab of the library name. */
6060 bfd_vma fixup_needed; /* Index of the library. */
6061 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6062 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6063};
6064
6065/* Data used to display dynamic relocations. */
6066
6067struct ia64_vms_dynimgrela
6068{
6069 bfd_vma img_rela_cnt; /* Number of relocations. */
6070 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6071};
6072
6073/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6074 library). */
6075
6076static void
6077dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6078 const char *strtab, unsigned int strtab_sz)
6079{
6080 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6081 long i;
6082 const char *lib_name;
6083
6084 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6085 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6086 _("dynamic section image fixups"));
6087 if (!imfs)
6088 return;
6089
6090 if (fixup->needed < strtab_sz)
6091 lib_name = strtab + fixup->needed;
6092 else
6093 {
6094 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6095 (unsigned long) fixup->needed);
28f997cf
TG		 6096 lib_name = "???";
6097 }
6098 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6099 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6100 printf
6101 (_("Seg Offset Type SymVec DataType\n"));
6102
6103 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6104 {
6105 unsigned int type;
6106 const char *rtype;
6107
6108 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6109 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6110 type = BYTE_GET (imfs [i].type);
6111 rtype = elf_ia64_reloc_type (type);
6112 if (rtype == NULL)
6113 printf (" 0x%08x ", type);
6114 else
6115 printf (" %-32s ", rtype);
6116 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6117 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6118 }
6119
6120 free (imfs);
6121}
6122
6123/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6124
6125static void
6126dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6127{
6128 Elf64_External_VMS_IMAGE_RELA *imrs;
6129 long i;
6130
6131 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6132 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6133 _("dynamic section image relocations"));
28f997cf
TG		 6134 if (!imrs)
6135 return;
6136
6137 printf (_("\nImage relocs\n"));
6138 printf
6139 (_("Seg Offset Type Addend Seg Sym Off\n"));
6140
6141 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6142 {
6143 unsigned int type;
6144 const char *rtype;
6145
6146 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6147 printf ("%08" BFD_VMA_FMT "x ",
6148 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6149 type = BYTE_GET (imrs [i].type);
6150 rtype = elf_ia64_reloc_type (type);
6151 if (rtype == NULL)
6152 printf ("0x%08x ", type);
6153 else
6154 printf ("%-31s ", rtype);
6155 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6156 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6157 printf ("%08" BFD_VMA_FMT "x\n",
6158 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6159 }
6160
6161 free (imrs);
6162}
6163
6164/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6165
6166static int
6167process_ia64_vms_dynamic_relocs (FILE *file)
6168{
6169 struct ia64_vms_dynfixup fixup;
6170 struct ia64_vms_dynimgrela imgrela;
6171 Elf_Internal_Dyn *entry;
6172 int res = 0;
6173 bfd_vma strtab_off = 0;
6174 bfd_vma strtab_sz = 0;
6175 char *strtab = NULL;
6176
6177 memset (&fixup, 0, sizeof (fixup));
6178 memset (&imgrela, 0, sizeof (imgrela));
6179
6180 /* Note: the order of the entries is specified by the OpenVMS specs. */
6181 for (entry = dynamic_section;
6182 entry < dynamic_section + dynamic_nent;
6183 entry++)
6184 {
6185 switch (entry->d_tag)
6186 {
6187 case DT_IA_64_VMS_STRTAB_OFFSET:
6188 strtab_off = entry->d_un.d_val;
6189 break;
6190 case DT_STRSZ:
6191 strtab_sz = entry->d_un.d_val;
6192 if (strtab == NULL)
6193 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6194 1, strtab_sz, _("dynamic string section"));
6195 break;
6196
6197 case DT_IA_64_VMS_NEEDED_IDENT:
6198 fixup.needed_ident = entry->d_un.d_val;
6199 break;
6200 case DT_NEEDED:
6201 fixup.needed = entry->d_un.d_val;
6202 break;
6203 case DT_IA_64_VMS_FIXUP_NEEDED:
6204 fixup.fixup_needed = entry->d_un.d_val;
6205 break;
6206 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6207 fixup.fixup_rela_cnt = entry->d_un.d_val;
6208 break;
6209 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6210 fixup.fixup_rela_off = entry->d_un.d_val;
6211 res++;
6212 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6213 break;
6214
6215 case DT_IA_64_VMS_IMG_RELA_CNT:
6216 imgrela.img_rela_cnt = entry->d_un.d_val;
6217 break;
6218 case DT_IA_64_VMS_IMG_RELA_OFF:
6219 imgrela.img_rela_off = entry->d_un.d_val;
6220 res++;
6221 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6222 break;
6223
6224 default:
6225 break;
6226 }
6227 }
6228
6229 if (strtab != NULL)
6230 free (strtab);
6231
6232 return res;
6233}
6234
85b1c36d 6235static struct
566b0d53 6236{
2cf0635d 6237 const char * name;
566b0d53
L		 6238 int reloc;
6239 int size;
6240 int rela;
6241} dynamic_relocations [] =
6242{
6243 { "REL", DT_REL, DT_RELSZ, FALSE },
6244 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6245 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6246};
6247
252b5132 6248/* Process the reloc section. */
18bd398b 6249
252b5132 6250static int
2cf0635d 6251process_relocs (FILE * file)
252b5132 6252{
b34976b6
AM		 6253 unsigned long rel_size;
6254 unsigned long rel_offset;
252b5132
RH		 6255
6256
6257 if (!do_reloc)
6258 return 1;
6259
6260 if (do_using_dynamic)
6261 {
566b0d53 6262 int is_rela;
2cf0635d 6263 const char * name;
566b0d53
L		 6264 int has_dynamic_reloc;
6265 unsigned int i;
0de14b54 6266
566b0d53 6267 has_dynamic_reloc = 0;
252b5132 6268
566b0d53 6269 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6270 {
566b0d53
L		 6271 is_rela = dynamic_relocations [i].rela;
6272 name = dynamic_relocations [i].name;
6273 rel_size = dynamic_info [dynamic_relocations [i].size];
6274 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6275
566b0d53
L		 6276 has_dynamic_reloc |= rel_size;
6277
6278 if (is_rela == UNKNOWN)
aa903cfb 6279 {
566b0d53
L		 6280 if (dynamic_relocations [i].reloc == DT_JMPREL)
6281 switch (dynamic_info[DT_PLTREL])
6282 {
6283 case DT_REL:
6284 is_rela = FALSE;
6285 break;
6286 case DT_RELA:
6287 is_rela = TRUE;
6288 break;
6289 }
aa903cfb 6290 }
252b5132 6291
566b0d53
L		 6292 if (rel_size)
6293 {
6294 printf
6295 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6296 name, rel_offset, rel_size);
252b5132 6297
d93f0186
NC		 6298 dump_relocations (file,
6299 offset_from_vma (file, rel_offset, rel_size),
6300 rel_size,
566b0d53 6301 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6302 dynamic_strings, dynamic_strings_length,
6303 is_rela, 1);
566b0d53 6304 }
252b5132 6305 }
566b0d53 6306
28f997cf
TG		 6307 if (is_ia64_vms ())
6308 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6309
566b0d53 6310 if (! has_dynamic_reloc)
252b5132
RH		 6311 printf (_("\nThere are no dynamic relocations in this file.\n"));
6312 }
6313 else
6314 {
2cf0635d 6315 Elf_Internal_Shdr * section;
b34976b6
AM		 6316 unsigned long i;
6317 int found = 0;
252b5132
RH		 6318
6319 for (i = 0, section = section_headers;
6320 i < elf_header.e_shnum;
b34976b6 6321 i++, section++)
252b5132
RH		 6322 {
6323 if ( section->sh_type != SHT_RELA
6324 && section->sh_type != SHT_REL)
6325 continue;
6326
6327 rel_offset = section->sh_offset;
6328 rel_size = section->sh_size;
6329
6330 if (rel_size)
6331 {
2cf0635d 6332 Elf_Internal_Shdr * strsec;
b34976b6 6333 int is_rela;
103f02d3 6334
252b5132
RH		 6335 printf (_("\nRelocation section "));
6336
6337 if (string_table == NULL)
19936277 6338 printf ("%d", section->sh_name);
252b5132 6339 else
74e1a04b 6340 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6341
6342 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6343 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6344
d79b3d50
NC		 6345 is_rela = section->sh_type == SHT_RELA;
6346
4fbb74a6
AM		 6347 if (section->sh_link != 0
6348 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6349 {
2cf0635d
NC		 6350 Elf_Internal_Shdr * symsec;
6351 Elf_Internal_Sym * symtab;
d79b3d50 6352 unsigned long nsyms;
c256ffe7 6353 unsigned long strtablen = 0;
2cf0635d 6354 char * strtab = NULL;
57346661 6355
4fbb74a6 6356 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6357 if (symsec->sh_type != SHT_SYMTAB
6358 && symsec->sh_type != SHT_DYNSYM)
6359 continue;
6360
ba5cdace 6361 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6362
af3fc3bc
AM		 6363 if (symtab == NULL)
6364 continue;
252b5132 6365
4fbb74a6
AM		 6366 if (symsec->sh_link != 0
6367 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6368 {
4fbb74a6 6369 strsec = section_headers + symsec->sh_link;
103f02d3 6370
3f5e193b 6371 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6372 1, strsec->sh_size,
6373 _("string table"));
c256ffe7
JJ		 6374 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6375 }
252b5132 6376
d79b3d50 6377 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6378 symtab, nsyms, strtab, strtablen,
6379 is_rela,
6380 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6381 if (strtab)
6382 free (strtab);
6383 free (symtab);
6384 }
6385 else
6386 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6387 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6388
6389 found = 1;
6390 }
6391 }
6392
6393 if (! found)
6394 printf (_("\nThere are no relocations in this file.\n"));
6395 }
6396
6397 return 1;
6398}
6399
57346661
AM		 6400/* Process the unwind section. */
6401
4d6ed7c8
NC		 6402#include "unwind-ia64.h"
6403
6404/* An absolute address consists of a section and an offset. If the
6405 section is NULL, the offset itself is the address, otherwise, the
6406 address equals to LOAD_ADDRESS(section) + offset. */
6407
6408struct absaddr
6409 {
6410 unsigned short section;
6411 bfd_vma offset;
6412 };
6413
1949de15
L		 6414#define ABSADDR(a) \
6415 ((a).section \
6416 ? section_headers [(a).section].sh_addr + (a).offset \
6417 : (a).offset)
6418
3f5e193b
NC		 6419struct ia64_unw_table_entry
6420 {
6421 struct absaddr start;
6422 struct absaddr end;
6423 struct absaddr info;
6424 };
6425
57346661 6426struct ia64_unw_aux_info
4d6ed7c8 6427 {
3f5e193b
NC		 6428
6429 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 6430 unsigned long table_len; /* Length of unwind table. */
2cf0635d 6431 unsigned char * info; /* Unwind info. */
b34976b6
AM		 6432 unsigned long info_size; /* Size of unwind info. */
6433 bfd_vma info_addr; /* starting address of unwind info. */
6434 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6435 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 6436 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6437 char * strtab; /* The string table. */
b34976b6 6438 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 6439 };
6440
4d6ed7c8 6441static void
2cf0635d 6442find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 6443 unsigned long nsyms,
2cf0635d 6444 const char * strtab,
57346661 6445 unsigned long strtab_size,
d3ba0551 6446 struct absaddr addr,
2cf0635d
NC		 6447 const char ** symname,
6448 bfd_vma * offset)
4d6ed7c8 6449{
d3ba0551 6450 bfd_vma dist = 0x100000;
2cf0635d
NC		 6451 Elf_Internal_Sym * sym;
6452 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 6453 unsigned long i;
6454
0b6ae522
DJ		 6455 REMOVE_ARCH_BITS (addr.offset);
6456
57346661 6457 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 6458 {
0b6ae522
DJ		 6459 bfd_vma value = sym->st_value;
6460
6461 REMOVE_ARCH_BITS (value);
6462
4d6ed7c8
NC		 6463 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6464 && sym->st_name != 0
6465 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6466 && addr.offset >= value
6467 && addr.offset - value < dist)
4d6ed7c8
NC		 6468 {
6469 best = sym;
0b6ae522 6470 dist = addr.offset - value;
4d6ed7c8
NC		 6471 if (!dist)
6472 break;
6473 }
6474 }
1b31d05e 6475
4d6ed7c8
NC		 6476 if (best)
6477 {
57346661 6478 *symname = (best->st_name >= strtab_size
2b692964 6479 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6480 *offset = dist;
6481 return;
6482 }
1b31d05e 6483
4d6ed7c8
NC		 6484 *symname = NULL;
6485 *offset = addr.offset;
6486}
6487
6488static void
2cf0635d 6489dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6490{
2cf0635d 6491 struct ia64_unw_table_entry * tp;
4d6ed7c8 6492 int in_body;
7036c0e1 6493
4d6ed7c8
NC		 6494 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6495 {
6496 bfd_vma stamp;
6497 bfd_vma offset;
2cf0635d
NC		 6498 const unsigned char * dp;
6499 const unsigned char * head;
53774b7e 6500 const unsigned char * end;
2cf0635d 6501 const char * procname;
4d6ed7c8 6502
57346661
AM		 6503 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6504 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6505
6506 fputs ("\n<", stdout);
6507
6508 if (procname)
6509 {
6510 fputs (procname, stdout);
6511
6512 if (offset)
6513 printf ("+%lx", (unsigned long) offset);
6514 }
6515
6516 fputs (">: [", stdout);
6517 print_vma (tp->start.offset, PREFIX_HEX);
6518 fputc ('-', stdout);
6519 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6520 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6521 (unsigned long) (tp->info.offset - aux->seg_base));
6522
53774b7e
NC		 6523 /* PR 17531: file: 86232b32. */
6524 if (aux->info == NULL)
6525 continue;
6526
6527 /* PR 17531: file: 0997b4d1. */
6528 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6529 {
6530 warn (_("Invalid offset %lx in table entry %ld\n"),
6531 (long) tp->info.offset, (long) (tp - aux->table));
6532 continue;
6533 }
6534
1949de15 6535 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6536 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6537
86f55779 6538 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6539 (unsigned) UNW_VER (stamp),
6540 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6541 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6542 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6543 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6544
6545 if (UNW_VER (stamp) != 1)
6546 {
2b692964 6547 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6548 continue;
6549 }
6550
6551 in_body = 0;
53774b7e
NC		 6552 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6553 /* PR 17531: file: 16ceda89. */
6554 if (end > aux->info + aux->info_size)
6555 end = aux->info + aux->info_size;
6556 for (dp = head + 8; dp < end;)
4d6ed7c8
NC		 6557 dp = unw_decode (dp, in_body, & in_body);
6558 }
6559}
6560
53774b7e 6561static bfd_boolean
2cf0635d
NC		 6562slurp_ia64_unwind_table (FILE * file,
6563 struct ia64_unw_aux_info * aux,
6564 Elf_Internal_Shdr * sec)
4d6ed7c8 6565{
89fac5e3 6566 unsigned long size, nrelas, i;
2cf0635d
NC		 6567 Elf_Internal_Phdr * seg;
6568 struct ia64_unw_table_entry * tep;
6569 Elf_Internal_Shdr * relsec;
6570 Elf_Internal_Rela * rela;
6571 Elf_Internal_Rela * rp;
6572 unsigned char * table;
6573 unsigned char * tp;
6574 Elf_Internal_Sym * sym;
6575 const char * relname;
4d6ed7c8 6576
53774b7e
NC		 6577 aux->table_len = 0;
6578
4d6ed7c8
NC		 6579 /* First, find the starting address of the segment that includes
6580 this section: */
6581
6582 if (elf_header.e_phnum)
6583 {
d93f0186 6584 if (! get_program_headers (file))
53774b7e 6585 return FALSE;
4d6ed7c8 6586
d93f0186
NC		 6587 for (seg = program_headers;
6588 seg < program_headers + elf_header.e_phnum;
6589 ++seg)
4d6ed7c8
NC		 6590 {
6591 if (seg->p_type != PT_LOAD)
6592 continue;
6593
6594 if (sec->sh_addr >= seg->p_vaddr
6595 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6596 {
6597 aux->seg_base = seg->p_vaddr;
6598 break;
6599 }
6600 }
4d6ed7c8
NC		 6601 }
6602
6603 /* Second, build the unwind table from the contents of the unwind section: */
6604 size = sec->sh_size;
3f5e193b
NC		 6605 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6606 _("unwind table"));
a6e9f9df 6607 if (!table)
53774b7e 6608 return FALSE;
4d6ed7c8 6609
53774b7e 6610 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6611 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6612 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6613 tep = aux->table;
53774b7e
NC		 6614
6615 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6616 {
6617 tep->start.section = SHN_UNDEF;
6618 tep->end.section = SHN_UNDEF;
6619 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6620 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6621 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6622 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6623 tep->start.offset += aux->seg_base;
6624 tep->end.offset += aux->seg_base;
6625 tep->info.offset += aux->seg_base;
6626 }
6627 free (table);
6628
41e92641 6629 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6630 for (relsec = section_headers;
6631 relsec < section_headers + elf_header.e_shnum;
6632 ++relsec)
6633 {
6634 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6635 || relsec->sh_info >= elf_header.e_shnum
6636 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6637 continue;
6638
6639 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6640 & rela, & nrelas))
53774b7e
NC		 6641 {
6642 free (aux->table);
6643 aux->table = NULL;
6644 aux->table_len = 0;
6645 return FALSE;
6646 }
4d6ed7c8
NC		 6647
6648 for (rp = rela; rp < rela + nrelas; ++rp)
6649 {
aca88567
NC		 6650 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6651 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6652
82b1b41b
NC		 6653 /* PR 17531: file: 9fa67536. */
6654 if (relname == NULL)
6655 {
6656 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6657 continue;
6658 }
6659
0112cd26 6660 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6661 {
82b1b41b 6662 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6663 continue;
6664 }
6665
89fac5e3 6666 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6667
53774b7e
NC		 6668 /* PR 17531: file: 5bc8d9bf. */
6669 if (i >= aux->table_len)
6670 {
6671 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6672 continue;
6673 }
6674
6675 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6676 {
6677 case 0:
6678 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6679 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6680 break;
6681 case 1:
6682 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6683 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6684 break;
6685 case 2:
6686 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6687 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6688 break;
6689 default:
6690 break;
6691 }
6692 }
6693
6694 free (rela);
6695 }
6696
53774b7e 6697 return TRUE;
4d6ed7c8
NC		 6698}
6699
1b31d05e 6700static void
2cf0635d 6701ia64_process_unwind (FILE * file)
4d6ed7c8 6702{
2cf0635d
NC		 6703 Elf_Internal_Shdr * sec;
6704 Elf_Internal_Shdr * unwsec = NULL;
6705 Elf_Internal_Shdr * strsec;
89fac5e3 6706 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6707 struct ia64_unw_aux_info aux;
f1467e33 6708
4d6ed7c8
NC		 6709 memset (& aux, 0, sizeof (aux));
6710
4d6ed7c8
NC		 6711 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6712 {
c256ffe7 6713 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6714 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6715 {
ba5cdace 6716 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6717
4fbb74a6 6718 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6719 if (aux.strtab != NULL)
6720 {
6721 error (_("Multiple auxillary string tables encountered\n"));
6722 free (aux.strtab);
6723 }
3f5e193b
NC		 6724 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6725 1, strsec->sh_size,
6726 _("string table"));
c256ffe7 6727 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6728 }
6729 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6730 unwcount++;
6731 }
6732
6733 if (!unwcount)
6734 printf (_("\nThere are no unwind sections in this file.\n"));
6735
6736 while (unwcount-- > 0)
6737 {
2cf0635d 6738 char * suffix;
579f31ac
JJ		 6739 size_t len, len2;
6740
4082ef84 6741 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6742 i < elf_header.e_shnum; ++i, ++sec)
6743 if (sec->sh_type == SHT_IA_64_UNWIND)
6744 {
6745 unwsec = sec;
6746 break;
6747 }
4082ef84
NC		 6748 /* We have already counted the number of SHT_IA64_UNWIND
6749 sections so the loop above should never fail. */
6750 assert (unwsec != NULL);
579f31ac
JJ		 6751
6752 unwstart = i + 1;
6753 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6754
e4b17d5c
L		 6755 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6756 {
6757 /* We need to find which section group it is in. */
4082ef84 6758 struct group_list * g;
e4b17d5c 6759
4082ef84
NC		 6760 if (section_headers_groups == NULL
6761 || section_headers_groups [i] == NULL)
6762 i = elf_header.e_shnum;
6763 else
e4b17d5c 6764 {
4082ef84 6765 g = section_headers_groups [i]->root;
18bd398b 6766
4082ef84
NC		 6767 for (; g != NULL; g = g->next)
6768 {
6769 sec = section_headers + g->section_index;
e4b17d5c 6770
4082ef84
NC		 6771 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6772 break;
6773 }
6774
6775 if (g == NULL)
6776 i = elf_header.e_shnum;
6777 }
e4b17d5c 6778 }
18bd398b 6779 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6780 {
18bd398b 6781 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6782 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6783 suffix = SECTION_NAME (unwsec) + len;
6784 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6785 ++i, ++sec)
18bd398b
NC		 6786 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6787 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6788 break;
6789 }
6790 else
6791 {
6792 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6793 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6794 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6795 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6796 suffix = "";
18bd398b 6797 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6798 suffix = SECTION_NAME (unwsec) + len;
6799 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6800 ++i, ++sec)
18bd398b
NC		 6801 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6802 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6803 break;
6804 }
6805
6806 if (i == elf_header.e_shnum)
6807 {
6808 printf (_("\nCould not find unwind info section for "));
6809
6810 if (string_table == NULL)
6811 printf ("%d", unwsec->sh_name);
6812 else
74e1a04b 6813 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6814 }
6815 else
4d6ed7c8 6816 {
4d6ed7c8 6817 aux.info_addr = sec->sh_addr;
3f5e193b 6818 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6819 sec->sh_size,
6820 _("unwind info"));
59245841 6821 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6822
579f31ac 6823 printf (_("\nUnwind section "));
4d6ed7c8 6824
579f31ac
JJ		 6825 if (string_table == NULL)
6826 printf ("%d", unwsec->sh_name);
6827 else
74e1a04b 6828 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 6829
579f31ac 6830 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6831 (unsigned long) unwsec->sh_offset,
89fac5e3 6832 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6833
53774b7e
NC		 6834 if (slurp_ia64_unwind_table (file, & aux, unwsec)
6835 && aux.table_len > 0)
579f31ac
JJ		 6836 dump_ia64_unwind (& aux);
6837
6838 if (aux.table)
6839 free ((char *) aux.table);
6840 if (aux.info)
6841 free ((char *) aux.info);
6842 aux.table = NULL;
6843 aux.info = NULL;
6844 }
4d6ed7c8 6845 }
4d6ed7c8 6846
4d6ed7c8
NC		 6847 if (aux.symtab)
6848 free (aux.symtab);
6849 if (aux.strtab)
6850 free ((char *) aux.strtab);
4d6ed7c8
NC		 6851}
6852
3f5e193b
NC		 6853struct hppa_unw_table_entry
6854 {
6855 struct absaddr start;
6856 struct absaddr end;
6857 unsigned int Cannot_unwind:1; /* 0 */
6858 unsigned int Millicode:1; /* 1 */
6859 unsigned int Millicode_save_sr0:1; /* 2 */
6860 unsigned int Region_description:2; /* 3..4 */
6861 unsigned int reserved1:1; /* 5 */
6862 unsigned int Entry_SR:1; /* 6 */
6863 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6864 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6865 unsigned int Args_stored:1; /* 16 */
6866 unsigned int Variable_Frame:1; /* 17 */
6867 unsigned int Separate_Package_Body:1; /* 18 */
6868 unsigned int Frame_Extension_Millicode:1; /* 19 */
6869 unsigned int Stack_Overflow_Check:1; /* 20 */
6870 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6871 unsigned int Ada_Region:1; /* 22 */
6872 unsigned int cxx_info:1; /* 23 */
6873 unsigned int cxx_try_catch:1; /* 24 */
6874 unsigned int sched_entry_seq:1; /* 25 */
6875 unsigned int reserved2:1; /* 26 */
6876 unsigned int Save_SP:1; /* 27 */
6877 unsigned int Save_RP:1; /* 28 */
6878 unsigned int Save_MRP_in_frame:1; /* 29 */
6879 unsigned int extn_ptr_defined:1; /* 30 */
6880 unsigned int Cleanup_defined:1; /* 31 */
6881
6882 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6883 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6884 unsigned int Large_frame:1; /* 2 */
6885 unsigned int Pseudo_SP_Set:1; /* 3 */
6886 unsigned int reserved4:1; /* 4 */
6887 unsigned int Total_frame_size:27; /* 5..31 */
6888 };
6889
57346661
AM		 6890struct hppa_unw_aux_info
6891 {
3f5e193b 6892 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6893 unsigned long table_len; /* Length of unwind table. */
6894 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6895 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6896 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6897 char * strtab; /* The string table. */
57346661
AM		 6898 unsigned long strtab_size; /* Size of string table. */
6899 };
6900
6901static void
2cf0635d 6902dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6903{
2cf0635d 6904 struct hppa_unw_table_entry * tp;
57346661 6905
57346661
AM		 6906 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6907 {
6908 bfd_vma offset;
2cf0635d 6909 const char * procname;
57346661
AM		 6910
6911 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6912 aux->strtab_size, tp->start, &procname,
6913 &offset);
6914
6915 fputs ("\n<", stdout);
6916
6917 if (procname)
6918 {
6919 fputs (procname, stdout);
6920
6921 if (offset)
6922 printf ("+%lx", (unsigned long) offset);
6923 }
6924
6925 fputs (">: [", stdout);
6926 print_vma (tp->start.offset, PREFIX_HEX);
6927 fputc ('-', stdout);
6928 print_vma (tp->end.offset, PREFIX_HEX);
6929 printf ("]\n\t");
6930
18bd398b
NC		 6931#define PF(_m) if (tp->_m) printf (#_m " ");
6932#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6933 PF(Cannot_unwind);
6934 PF(Millicode);
6935 PF(Millicode_save_sr0);
18bd398b 6936 /* PV(Region_description); */
57346661
AM		 6937 PF(Entry_SR);
6938 PV(Entry_FR);
6939 PV(Entry_GR);
6940 PF(Args_stored);
6941 PF(Variable_Frame);
6942 PF(Separate_Package_Body);
6943 PF(Frame_Extension_Millicode);
6944 PF(Stack_Overflow_Check);
6945 PF(Two_Instruction_SP_Increment);
6946 PF(Ada_Region);
6947 PF(cxx_info);
6948 PF(cxx_try_catch);
6949 PF(sched_entry_seq);
6950 PF(Save_SP);
6951 PF(Save_RP);
6952 PF(Save_MRP_in_frame);
6953 PF(extn_ptr_defined);
6954 PF(Cleanup_defined);
6955 PF(MPE_XL_interrupt_marker);
6956 PF(HP_UX_interrupt_marker);
6957 PF(Large_frame);
6958 PF(Pseudo_SP_Set);
6959 PV(Total_frame_size);
6960#undef PF
6961#undef PV
6962 }
6963
18bd398b 6964 printf ("\n");
57346661
AM		 6965}
6966
6967static int
2cf0635d
NC		 6968slurp_hppa_unwind_table (FILE * file,
6969 struct hppa_unw_aux_info * aux,
6970 Elf_Internal_Shdr * sec)
57346661 6971{
1c0751b2 6972 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6973 Elf_Internal_Phdr * seg;
6974 struct hppa_unw_table_entry * tep;
6975 Elf_Internal_Shdr * relsec;
6976 Elf_Internal_Rela * rela;
6977 Elf_Internal_Rela * rp;
6978 unsigned char * table;
6979 unsigned char * tp;
6980 Elf_Internal_Sym * sym;
6981 const char * relname;
57346661 6982
57346661
AM		 6983 /* First, find the starting address of the segment that includes
6984 this section. */
6985
6986 if (elf_header.e_phnum)
6987 {
6988 if (! get_program_headers (file))
6989 return 0;
6990
6991 for (seg = program_headers;
6992 seg < program_headers + elf_header.e_phnum;
6993 ++seg)
6994 {
6995 if (seg->p_type != PT_LOAD)
6996 continue;
6997
6998 if (sec->sh_addr >= seg->p_vaddr
6999 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7000 {
7001 aux->seg_base = seg->p_vaddr;
7002 break;
7003 }
7004 }
7005 }
7006
7007 /* Second, build the unwind table from the contents of the unwind
7008 section. */
7009 size = sec->sh_size;
3f5e193b
NC		 7010 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7011 _("unwind table"));
57346661
AM		 7012 if (!table)
7013 return 0;
7014
1c0751b2
DA		 7015 unw_ent_size = 16;
7016 nentries = size / unw_ent_size;
7017 size = unw_ent_size * nentries;
57346661 7018
3f5e193b
NC		 7019 tep = aux->table = (struct hppa_unw_table_entry *)
7020 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7021
1c0751b2 7022 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7023 {
7024 unsigned int tmp1, tmp2;
7025
7026 tep->start.section = SHN_UNDEF;
7027 tep->end.section = SHN_UNDEF;
7028
1c0751b2
DA		 7029 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7030 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7031 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7032 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7033
7034 tep->start.offset += aux->seg_base;
7035 tep->end.offset += aux->seg_base;
57346661
AM		 7036
7037 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7038 tep->Millicode = (tmp1 >> 30) & 0x1;
7039 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7040 tep->Region_description = (tmp1 >> 27) & 0x3;
7041 tep->reserved1 = (tmp1 >> 26) & 0x1;
7042 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7043 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7044 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7045 tep->Args_stored = (tmp1 >> 15) & 0x1;
7046 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7047 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7048 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7049 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7050 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7051 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7052 tep->cxx_info = (tmp1 >> 8) & 0x1;
7053 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7054 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7055 tep->reserved2 = (tmp1 >> 5) & 0x1;
7056 tep->Save_SP = (tmp1 >> 4) & 0x1;
7057 tep->Save_RP = (tmp1 >> 3) & 0x1;
7058 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7059 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7060 tep->Cleanup_defined = tmp1 & 0x1;
7061
7062 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7063 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7064 tep->Large_frame = (tmp2 >> 29) & 0x1;
7065 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7066 tep->reserved4 = (tmp2 >> 27) & 0x1;
7067 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7068 }
7069 free (table);
7070
7071 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7072 for (relsec = section_headers;
7073 relsec < section_headers + elf_header.e_shnum;
7074 ++relsec)
7075 {
7076 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7077 || relsec->sh_info >= elf_header.e_shnum
7078 || section_headers + relsec->sh_info != sec)
57346661
AM		 7079 continue;
7080
7081 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7082 & rela, & nrelas))
7083 return 0;
7084
7085 for (rp = rela; rp < rela + nrelas; ++rp)
7086 {
aca88567
NC		 7087 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7088 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7089
7090 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7091 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7092 {
7093 warn (_("Skipping unexpected relocation type %s\n"), relname);
7094 continue;
7095 }
7096
7097 i = rp->r_offset / unw_ent_size;
7098
89fac5e3 7099 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7100 {
7101 case 0:
7102 aux->table[i].start.section = sym->st_shndx;
1e456d54 7103 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7104 break;
7105 case 1:
7106 aux->table[i].end.section = sym->st_shndx;
1e456d54 7107 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7108 break;
7109 default:
7110 break;
7111 }
7112 }
7113
7114 free (rela);
7115 }
7116
1c0751b2 7117 aux->table_len = nentries;
57346661
AM		 7118
7119 return 1;
7120}
7121
1b31d05e 7122static void
2cf0635d 7123hppa_process_unwind (FILE * file)
57346661 7124{
57346661 7125 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7126 Elf_Internal_Shdr * unwsec = NULL;
7127 Elf_Internal_Shdr * strsec;
7128 Elf_Internal_Shdr * sec;
18bd398b 7129 unsigned long i;
57346661 7130
c256ffe7 7131 if (string_table == NULL)
1b31d05e
NC		 7132 return;
7133
7134 memset (& aux, 0, sizeof (aux));
57346661
AM		 7135
7136 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7137 {
c256ffe7 7138 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7139 && sec->sh_link < elf_header.e_shnum)
57346661 7140 {
ba5cdace 7141 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7142
4fbb74a6 7143 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7144 if (aux.strtab != NULL)
7145 {
7146 error (_("Multiple auxillary string tables encountered\n"));
7147 free (aux.strtab);
7148 }
3f5e193b
NC		 7149 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7150 1, strsec->sh_size,
7151 _("string table"));
c256ffe7 7152 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7153 }
18bd398b 7154 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7155 unwsec = sec;
7156 }
7157
7158 if (!unwsec)
7159 printf (_("\nThere are no unwind sections in this file.\n"));
7160
7161 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7162 {
18bd398b 7163 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7164 {
74e1a04b
NC		 7165 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7166 printable_section_name (sec),
57346661 7167 (unsigned long) sec->sh_offset,
89fac5e3 7168 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7169
7170 slurp_hppa_unwind_table (file, &aux, sec);
7171 if (aux.table_len > 0)
7172 dump_hppa_unwind (&aux);
7173
7174 if (aux.table)
7175 free ((char *) aux.table);
7176 aux.table = NULL;
7177 }
7178 }
7179
7180 if (aux.symtab)
7181 free (aux.symtab);
7182 if (aux.strtab)
7183 free ((char *) aux.strtab);
57346661
AM		 7184}
7185
0b6ae522
DJ		 7186struct arm_section
7187{
a734115a
NC		 7188 unsigned char * data; /* The unwind data. */
7189 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7190 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7191 unsigned long nrelas; /* The number of relocations. */
7192 unsigned int rel_type; /* REL or RELA ? */
7193 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7194};
7195
7196struct arm_unw_aux_info
7197{
a734115a
NC		 7198 FILE * file; /* The file containing the unwind sections. */
7199 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7200 unsigned long nsyms; /* Number of symbols. */
7201 char * strtab; /* The file's string table. */
7202 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7203};
7204
7205static const char *
7206arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7207 bfd_vma fn, struct absaddr addr)
7208{
7209 const char *procname;
7210 bfd_vma sym_offset;
7211
7212 if (addr.section == SHN_UNDEF)
7213 addr.offset = fn;
7214
7215 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7216 aux->strtab_size, addr, &procname,
7217 &sym_offset);
7218
7219 print_vma (fn, PREFIX_HEX);
7220
7221 if (procname)
7222 {
7223 fputs (" <", stdout);
7224 fputs (procname, stdout);
7225
7226 if (sym_offset)
7227 printf ("+0x%lx", (unsigned long) sym_offset);
7228 fputc ('>', stdout);
7229 }
7230
7231 return procname;
7232}
7233
7234static void
7235arm_free_section (struct arm_section *arm_sec)
7236{
7237 if (arm_sec->data != NULL)
7238 free (arm_sec->data);
7239
7240 if (arm_sec->rela != NULL)
7241 free (arm_sec->rela);
7242}
7243
a734115a
NC		 7244/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7245 cached section and install SEC instead.
7246 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7247 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7248 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7249 relocation's offset in ADDR.
1b31d05e
NC		 7250 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7251 into the string table of the symbol associated with the reloc. If no
7252 reloc was applied store -1 there.
7253 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7254
7255static bfd_boolean
1b31d05e
NC		 7256get_unwind_section_word (struct arm_unw_aux_info * aux,
7257 struct arm_section * arm_sec,
7258 Elf_Internal_Shdr * sec,
7259 bfd_vma word_offset,
7260 unsigned int * wordp,
7261 struct absaddr * addr,
7262 bfd_vma * sym_name)
0b6ae522
DJ		 7263{
7264 Elf_Internal_Rela *rp;
7265 Elf_Internal_Sym *sym;
7266 const char * relname;
7267 unsigned int word;
7268 bfd_boolean wrapped;
7269
e0a31db1
NC		 7270 if (sec == NULL || arm_sec == NULL)
7271 return FALSE;
7272
0b6ae522
DJ		 7273 addr->section = SHN_UNDEF;
7274 addr->offset = 0;
7275
1b31d05e
NC		 7276 if (sym_name != NULL)
7277 *sym_name = (bfd_vma) -1;
7278
a734115a 7279 /* If necessary, update the section cache. */
0b6ae522
DJ		 7280 if (sec != arm_sec->sec)
7281 {
7282 Elf_Internal_Shdr *relsec;
7283
7284 arm_free_section (arm_sec);
7285
7286 arm_sec->sec = sec;
7287 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7288 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7289 arm_sec->rela = NULL;
7290 arm_sec->nrelas = 0;
7291
7292 for (relsec = section_headers;
7293 relsec < section_headers + elf_header.e_shnum;
7294 ++relsec)
7295 {
7296 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7297 || section_headers + relsec->sh_info != sec
7298 /* PR 15745: Check the section type as well. */
7299 || (relsec->sh_type != SHT_REL
7300 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7301 continue;
7302
a734115a 7303 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7304 if (relsec->sh_type == SHT_REL)
7305 {
7306 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7307 relsec->sh_size,
7308 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7309 return FALSE;
0b6ae522 7310 }
1ae40aa4 7311 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7312 {
7313 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7314 relsec->sh_size,
7315 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7316 return FALSE;
0b6ae522 7317 }
1ae40aa4 7318 break;
0b6ae522
DJ		 7319 }
7320
7321 arm_sec->next_rela = arm_sec->rela;
7322 }
7323
a734115a 7324 /* If there is no unwind data we can do nothing. */
0b6ae522 7325 if (arm_sec->data == NULL)
a734115a 7326 return FALSE;
0b6ae522 7327
e0a31db1
NC		 7328 /* If the offset is invalid then fail. */
7329 if (word_offset > sec->sh_size - 4)
7330 return FALSE;
7331
a734115a 7332 /* Get the word at the required offset. */
0b6ae522
DJ		 7333 word = byte_get (arm_sec->data + word_offset, 4);
7334
0eff7165
NC		 7335 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7336 if (arm_sec->rela == NULL)
7337 {
7338 * wordp = word;
7339 return TRUE;
7340 }
7341
a734115a 7342 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7343 wrapped = FALSE;
7344 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7345 {
7346 bfd_vma prelval, offset;
7347
7348 if (rp->r_offset > word_offset && !wrapped)
7349 {
7350 rp = arm_sec->rela;
7351 wrapped = TRUE;
7352 }
7353 if (rp->r_offset > word_offset)
7354 break;
7355
7356 if (rp->r_offset & 3)
7357 {
7358 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7359 (unsigned long) rp->r_offset);
7360 continue;
7361 }
7362
7363 if (rp->r_offset < word_offset)
7364 continue;
7365
74e1a04b
NC		 7366 /* PR 17531: file: 027-161405-0.004 */
7367 if (aux->symtab == NULL)
7368 continue;
7369
0b6ae522
DJ		 7370 if (arm_sec->rel_type == SHT_REL)
7371 {
7372 offset = word & 0x7fffffff;
7373 if (offset & 0x40000000)
7374 offset |= ~ (bfd_vma) 0x7fffffff;
7375 }
a734115a 7376 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7377 offset = rp->r_addend;
a734115a 7378 else
74e1a04b
NC		 7379 {
7380 error (_("Unknown section relocation type %d encountered\n"),
7381 arm_sec->rel_type);
7382 break;
7383 }
0b6ae522 7384
071436c6
NC		 7385 /* PR 17531 file: 027-1241568-0.004. */
7386 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7387 {
7388 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7389 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7390 break;
7391 }
7392
7393 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7394 offset += sym->st_value;
7395 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7396
a734115a
NC		 7397 /* Check that we are processing the expected reloc type. */
7398 if (elf_header.e_machine == EM_ARM)
7399 {
7400 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7401 if (relname == NULL)
7402 {
7403 warn (_("Skipping unknown ARM relocation type: %d\n"),
7404 (int) ELF32_R_TYPE (rp->r_info));
7405 continue;
7406 }
a734115a
NC		 7407
7408 if (streq (relname, "R_ARM_NONE"))
7409 continue;
0b4362b0 7410
a734115a
NC		 7411 if (! streq (relname, "R_ARM_PREL31"))
7412 {
071436c6 7413 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7414 continue;
7415 }
7416 }
7417 else if (elf_header.e_machine == EM_TI_C6000)
7418 {
7419 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7420 if (relname == NULL)
7421 {
7422 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7423 (int) ELF32_R_TYPE (rp->r_info));
7424 continue;
7425 }
0b4362b0 7426
a734115a
NC		 7427 if (streq (relname, "R_C6000_NONE"))
7428 continue;
7429
7430 if (! streq (relname, "R_C6000_PREL31"))
7431 {
071436c6 7432 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7433 continue;
7434 }
7435
7436 prelval >>= 1;
7437 }
7438 else
74e1a04b
NC		 7439 {
7440 /* This function currently only supports ARM and TI unwinders. */
7441 warn (_("Only TI and ARM unwinders are currently supported\n"));
7442 break;
7443 }
fa197c1c 7444
0b6ae522
DJ		 7445 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7446 addr->section = sym->st_shndx;
7447 addr->offset = offset;
74e1a04b 7448
1b31d05e
NC		 7449 if (sym_name)
7450 * sym_name = sym->st_name;
0b6ae522
DJ		 7451 break;
7452 }
7453
7454 *wordp = word;
7455 arm_sec->next_rela = rp;
7456
a734115a 7457 return TRUE;
0b6ae522
DJ		 7458}
7459
a734115a
NC		 7460static const char *tic6x_unwind_regnames[16] =
7461{
0b4362b0
RM		 7462 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7463 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7464 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7465};
fa197c1c 7466
0b6ae522 7467static void
fa197c1c 7468decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7469{
fa197c1c
PB		 7470 int i;
7471
7472 for (i = 12; mask; mask >>= 1, i--)
7473 {
7474 if (mask & 1)
7475 {
7476 fputs (tic6x_unwind_regnames[i], stdout);
7477 if (mask > 1)
7478 fputs (", ", stdout);
7479 }
7480 }
7481}
0b6ae522
DJ		 7482
7483#define ADVANCE \
7484 if (remaining == 0 && more_words) \
7485 { \
7486 data_offset += 4; \
1b31d05e
NC		 7487 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7488 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7489 return; \
7490 remaining = 4; \
7491 more_words--; \
7492 } \
7493
7494#define GET_OP(OP) \
7495 ADVANCE; \
7496 if (remaining) \
7497 { \
7498 remaining--; \
7499 (OP) = word >> 24; \
7500 word <<= 8; \
7501 } \
7502 else \
7503 { \
2b692964 7504 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7505 return; \
7506 } \
cc5914eb 7507 printf ("0x%02x ", OP)
0b6ae522 7508
fa197c1c
PB		 7509static void
7510decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7511 unsigned int word, unsigned int remaining,
7512 unsigned int more_words,
7513 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7514 struct arm_section *data_arm_sec)
7515{
7516 struct absaddr addr;
0b6ae522
DJ		 7517
7518 /* Decode the unwinding instructions. */
7519 while (1)
7520 {
7521 unsigned int op, op2;
7522
7523 ADVANCE;
7524 if (remaining == 0)
7525 break;
7526 remaining--;
7527 op = word >> 24;
7528 word <<= 8;
7529
cc5914eb 7530 printf (" 0x%02x ", op);
0b6ae522
DJ		 7531
7532 if ((op & 0xc0) == 0x00)
7533 {
7534 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7535
cc5914eb 7536 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7537 }
7538 else if ((op & 0xc0) == 0x40)
7539 {
7540 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7541
cc5914eb 7542 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7543 }
7544 else if ((op & 0xf0) == 0x80)
7545 {
7546 GET_OP (op2);
7547 if (op == 0x80 && op2 == 0)
7548 printf (_("Refuse to unwind"));
7549 else
7550 {
7551 unsigned int mask = ((op & 0x0f) << 8) | op2;
7552 int first = 1;
7553 int i;
2b692964 7554
0b6ae522
DJ		 7555 printf ("pop {");
7556 for (i = 0; i < 12; i++)
7557 if (mask & (1 << i))
7558 {
7559 if (first)
7560 first = 0;
7561 else
7562 printf (", ");
7563 printf ("r%d", 4 + i);
7564 }
7565 printf ("}");
7566 }
7567 }
7568 else if ((op & 0xf0) == 0x90)
7569 {
7570 if (op == 0x9d || op == 0x9f)
7571 printf (_(" [Reserved]"));
7572 else
cc5914eb 7573 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7574 }
7575 else if ((op & 0xf0) == 0xa0)
7576 {
7577 int end = 4 + (op & 0x07);
7578 int first = 1;
7579 int i;
61865e30 7580
0b6ae522
DJ		 7581 printf (" pop {");
7582 for (i = 4; i <= end; i++)
7583 {
7584 if (first)
7585 first = 0;
7586 else
7587 printf (", ");
7588 printf ("r%d", i);
7589 }
7590 if (op & 0x08)
7591 {
1b31d05e 7592 if (!first)
0b6ae522
DJ		 7593 printf (", ");
7594 printf ("r14");
7595 }
7596 printf ("}");
7597 }
7598 else if (op == 0xb0)
7599 printf (_(" finish"));
7600 else if (op == 0xb1)
7601 {
7602 GET_OP (op2);
7603 if (op2 == 0 || (op2 & 0xf0) != 0)
7604 printf (_("[Spare]"));
7605 else
7606 {
7607 unsigned int mask = op2 & 0x0f;
7608 int first = 1;
7609 int i;
61865e30 7610
0b6ae522
DJ		 7611 printf ("pop {");
7612 for (i = 0; i < 12; i++)
7613 if (mask & (1 << i))
7614 {
7615 if (first)
7616 first = 0;
7617 else
7618 printf (", ");
7619 printf ("r%d", i);
7620 }
7621 printf ("}");
7622 }
7623 }
7624 else if (op == 0xb2)
7625 {
b115cf96 7626 unsigned char buf[9];
0b6ae522
DJ		 7627 unsigned int i, len;
7628 unsigned long offset;
61865e30 7629
b115cf96 7630 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7631 {
7632 GET_OP (buf[i]);
7633 if ((buf[i] & 0x80) == 0)
7634 break;
7635 }
4082ef84
NC		 7636 if (i == sizeof (buf))
7637 printf (_("corrupt change to vsp"));
7638 else
7639 {
7640 offset = read_uleb128 (buf, &len, buf + i + 1);
7641 assert (len == i + 1);
7642 offset = offset * 4 + 0x204;
7643 printf ("vsp = vsp + %ld", offset);
7644 }
0b6ae522 7645 }
61865e30 7646 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7647 {
61865e30
NC		 7648 unsigned int first, last;
7649
7650 GET_OP (op2);
7651 first = op2 >> 4;
7652 last = op2 & 0x0f;
7653 if (op == 0xc8)
7654 first = first + 16;
7655 printf ("pop {D%d", first);
7656 if (last)
7657 printf ("-D%d", first + last);
7658 printf ("}");
7659 }
7660 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7661 {
7662 unsigned int count = op & 0x07;
7663
7664 printf ("pop {D8");
7665 if (count)
7666 printf ("-D%d", 8 + count);
7667 printf ("}");
7668 }
7669 else if (op >= 0xc0 && op <= 0xc5)
7670 {
7671 unsigned int count = op & 0x07;
7672
7673 printf (" pop {wR10");
7674 if (count)
7675 printf ("-wR%d", 10 + count);
7676 printf ("}");
7677 }
7678 else if (op == 0xc6)
7679 {
7680 unsigned int first, last;
7681
7682 GET_OP (op2);
7683 first = op2 >> 4;
7684 last = op2 & 0x0f;
7685 printf ("pop {wR%d", first);
7686 if (last)
7687 printf ("-wR%d", first + last);
7688 printf ("}");
7689 }
7690 else if (op == 0xc7)
7691 {
7692 GET_OP (op2);
7693 if (op2 == 0 || (op2 & 0xf0) != 0)
7694 printf (_("[Spare]"));
0b6ae522
DJ		 7695 else
7696 {
61865e30
NC		 7697 unsigned int mask = op2 & 0x0f;
7698 int first = 1;
7699 int i;
7700
7701 printf ("pop {");
7702 for (i = 0; i < 4; i++)
7703 if (mask & (1 << i))
7704 {
7705 if (first)
7706 first = 0;
7707 else
7708 printf (", ");
7709 printf ("wCGR%d", i);
7710 }
7711 printf ("}");
0b6ae522
DJ		 7712 }
7713 }
61865e30
NC		 7714 else
7715 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7716 printf ("\n");
7717 }
fa197c1c
PB		 7718}
7719
7720static void
7721decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7722 unsigned int word, unsigned int remaining,
7723 unsigned int more_words,
7724 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7725 struct arm_section *data_arm_sec)
7726{
7727 struct absaddr addr;
7728
7729 /* Decode the unwinding instructions. */
7730 while (1)
7731 {
7732 unsigned int op, op2;
7733
7734 ADVANCE;
7735 if (remaining == 0)
7736 break;
7737 remaining--;
7738 op = word >> 24;
7739 word <<= 8;
7740
9cf03b7e 7741 printf (" 0x%02x ", op);
fa197c1c
PB		 7742
7743 if ((op & 0xc0) == 0x00)
7744 {
7745 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7746 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7747 }
7748 else if ((op & 0xc0) == 0x80)
7749 {
7750 GET_OP (op2);
7751 if (op == 0x80 && op2 == 0)
7752 printf (_("Refuse to unwind"));
7753 else
7754 {
7755 unsigned int mask = ((op & 0x1f) << 8) | op2;
7756 if (op & 0x20)
7757 printf ("pop compact {");
7758 else
7759 printf ("pop {");
7760
7761 decode_tic6x_unwind_regmask (mask);
7762 printf("}");
7763 }
7764 }
7765 else if ((op & 0xf0) == 0xc0)
7766 {
7767 unsigned int reg;
7768 unsigned int nregs;
7769 unsigned int i;
7770 const char *name;
a734115a
NC		 7771 struct
7772 {
fa197c1c
PB		 7773 unsigned int offset;
7774 unsigned int reg;
7775 } regpos[16];
7776
7777 /* Scan entire instruction first so that GET_OP output is not
7778 interleaved with disassembly. */
7779 nregs = 0;
7780 for (i = 0; nregs < (op & 0xf); i++)
7781 {
7782 GET_OP (op2);
7783 reg = op2 >> 4;
7784 if (reg != 0xf)
7785 {
7786 regpos[nregs].offset = i * 2;
7787 regpos[nregs].reg = reg;
7788 nregs++;
7789 }
7790
7791 reg = op2 & 0xf;
7792 if (reg != 0xf)
7793 {
7794 regpos[nregs].offset = i * 2 + 1;
7795 regpos[nregs].reg = reg;
7796 nregs++;
7797 }
7798 }
7799
7800 printf (_("pop frame {"));
7801 reg = nregs - 1;
7802 for (i = i * 2; i > 0; i--)
7803 {
7804 if (regpos[reg].offset == i - 1)
7805 {
7806 name = tic6x_unwind_regnames[regpos[reg].reg];
7807 if (reg > 0)
7808 reg--;
7809 }
7810 else
7811 name = _("[pad]");
7812
7813 fputs (name, stdout);
7814 if (i > 1)
7815 printf (", ");
7816 }
7817
7818 printf ("}");
7819 }
7820 else if (op == 0xd0)
7821 printf (" MOV FP, SP");
7822 else if (op == 0xd1)
7823 printf (" __c6xabi_pop_rts");
7824 else if (op == 0xd2)
7825 {
7826 unsigned char buf[9];
7827 unsigned int i, len;
7828 unsigned long offset;
a734115a 7829
fa197c1c
PB		 7830 for (i = 0; i < sizeof (buf); i++)
7831 {
7832 GET_OP (buf[i]);
7833 if ((buf[i] & 0x80) == 0)
7834 break;
7835 }
0eff7165
NC		 7836 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7837 if (i == sizeof (buf))
7838 {
7839 printf ("<corrupt sp adjust>\n");
7840 warn (_("Corrupt stack pointer adjustment detected\n"));
7841 return;
7842 }
7843
f6f0e17b 7844 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7845 assert (len == i + 1);
7846 offset = offset * 8 + 0x408;
7847 printf (_("sp = sp + %ld"), offset);
7848 }
7849 else if ((op & 0xf0) == 0xe0)
7850 {
7851 if ((op & 0x0f) == 7)
7852 printf (" RETURN");
7853 else
7854 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7855 }
7856 else
7857 {
7858 printf (_(" [unsupported opcode]"));
7859 }
7860 putchar ('\n');
7861 }
7862}
7863
7864static bfd_vma
a734115a 7865arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7866{
7867 bfd_vma offset;
7868
7869 offset = word & 0x7fffffff;
7870 if (offset & 0x40000000)
7871 offset |= ~ (bfd_vma) 0x7fffffff;
7872
7873 if (elf_header.e_machine == EM_TI_C6000)
7874 offset <<= 1;
7875
7876 return offset + where;
7877}
7878
7879static void
1b31d05e
NC		 7880decode_arm_unwind (struct arm_unw_aux_info * aux,
7881 unsigned int word,
7882 unsigned int remaining,
7883 bfd_vma data_offset,
7884 Elf_Internal_Shdr * data_sec,
7885 struct arm_section * data_arm_sec)
fa197c1c
PB		 7886{
7887 int per_index;
7888 unsigned int more_words = 0;
37e14bc3 7889 struct absaddr addr;
1b31d05e 7890 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7891
7892 if (remaining == 0)
7893 {
1b31d05e
NC		 7894 /* Fetch the first word.
7895 Note - when decoding an object file the address extracted
7896 here will always be 0. So we also pass in the sym_name
7897 parameter so that we can find the symbol associated with
7898 the personality routine. */
7899 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7900 & word, & addr, & sym_name))
fa197c1c 7901 return;
1b31d05e 7902
fa197c1c
PB		 7903 remaining = 4;
7904 }
7905
7906 if ((word & 0x80000000) == 0)
7907 {
7908 /* Expand prel31 for personality routine. */
7909 bfd_vma fn;
7910 const char *procname;
7911
a734115a 7912 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7913 printf (_(" Personality routine: "));
1b31d05e
NC		 7914 if (fn == 0
7915 && addr.section == SHN_UNDEF && addr.offset == 0
7916 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7917 {
7918 procname = aux->strtab + sym_name;
7919 print_vma (fn, PREFIX_HEX);
7920 if (procname)
7921 {
7922 fputs (" <", stdout);
7923 fputs (procname, stdout);
7924 fputc ('>', stdout);
7925 }
7926 }
7927 else
7928 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7929 fputc ('\n', stdout);
7930
7931 /* The GCC personality routines use the standard compact
7932 encoding, starting with one byte giving the number of
7933 words. */
7934 if (procname != NULL
7935 && (const_strneq (procname, "__gcc_personality_v0")
7936 || const_strneq (procname, "__gxx_personality_v0")
7937 || const_strneq (procname, "__gcj_personality_v0")
7938 || const_strneq (procname, "__gnu_objc_personality_v0")))
7939 {
7940 remaining = 0;
7941 more_words = 1;
7942 ADVANCE;
7943 if (!remaining)
7944 {
7945 printf (_(" [Truncated data]\n"));
7946 return;
7947 }
7948 more_words = word >> 24;
7949 word <<= 8;
7950 remaining--;
7951 per_index = -1;
7952 }
7953 else
7954 return;
7955 }
7956 else
7957 {
1b31d05e 7958 /* ARM EHABI Section 6.3:
0b4362b0 7959
1b31d05e 7960 An exception-handling table entry for the compact model looks like:
0b4362b0 7961
1b31d05e
NC		 7962 31 30-28 27-24 23-0
7963 -- ----- ----- ----
7964 1 0 index Data for personalityRoutine[index] */
7965
7966 if (elf_header.e_machine == EM_ARM
7967 && (word & 0x70000000))
83c257ca 7968 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7969
fa197c1c 7970 per_index = (word >> 24) & 0x7f;
1b31d05e 7971 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7972 if (per_index == 0)
7973 {
7974 more_words = 0;
7975 word <<= 8;
7976 remaining--;
7977 }
7978 else if (per_index < 3)
7979 {
7980 more_words = (word >> 16) & 0xff;
7981 word <<= 16;
7982 remaining -= 2;
7983 }
7984 }
7985
7986 switch (elf_header.e_machine)
7987 {
7988 case EM_ARM:
7989 if (per_index < 3)
7990 {
7991 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7992 data_offset, data_sec, data_arm_sec);
7993 }
7994 else
1b31d05e
NC		 7995 {
7996 warn (_("Unknown ARM compact model index encountered\n"));
7997 printf (_(" [reserved]\n"));
7998 }
fa197c1c
PB		 7999 break;
8000
8001 case EM_TI_C6000:
8002 if (per_index < 3)
8003 {
8004 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8005 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8006 }
8007 else if (per_index < 5)
8008 {
8009 if (((word >> 17) & 0x7f) == 0x7f)
8010 printf (_(" Restore stack from frame pointer\n"));
8011 else
8012 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8013 printf (_(" Registers restored: "));
8014 if (per_index == 4)
8015 printf (" (compact) ");
8016 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8017 putchar ('\n');
8018 printf (_(" Return register: %s\n"),
8019 tic6x_unwind_regnames[word & 0xf]);
8020 }
8021 else
1b31d05e 8022 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8023 break;
8024
8025 default:
74e1a04b 8026 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8027 elf_header.e_machine);
fa197c1c 8028 }
0b6ae522
DJ		 8029
8030 /* Decode the descriptors. Not implemented. */
8031}
8032
8033static void
8034dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8035{
8036 struct arm_section exidx_arm_sec, extab_arm_sec;
8037 unsigned int i, exidx_len;
8038
8039 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8040 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8041 exidx_len = exidx_sec->sh_size / 8;
8042
8043 for (i = 0; i < exidx_len; i++)
8044 {
8045 unsigned int exidx_fn, exidx_entry;
8046 struct absaddr fn_addr, entry_addr;
8047 bfd_vma fn;
8048
8049 fputc ('\n', stdout);
8050
1b31d05e
NC		 8051 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8052 8 * i, & exidx_fn, & fn_addr, NULL)
8053 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8054 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8055 {
1b31d05e
NC		 8056 arm_free_section (& exidx_arm_sec);
8057 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8058 return;
8059 }
8060
83c257ca
NC		 8061 /* ARM EHABI, Section 5:
8062 An index table entry consists of 2 words.
8063 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8064 if (exidx_fn & 0x80000000)
8065 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8066
a734115a 8067 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8068
a734115a 8069 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8070 fputs (": ", stdout);
8071
8072 if (exidx_entry == 1)
8073 {
8074 print_vma (exidx_entry, PREFIX_HEX);
8075 fputs (" [cantunwind]\n", stdout);
8076 }
8077 else if (exidx_entry & 0x80000000)
8078 {
8079 print_vma (exidx_entry, PREFIX_HEX);
8080 fputc ('\n', stdout);
8081 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8082 }
8083 else
8084 {
8f73510c 8085 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8086 Elf_Internal_Shdr *table_sec;
8087
8088 fputs ("@", stdout);
a734115a 8089 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8090 print_vma (table, PREFIX_HEX);
8091 printf ("\n");
8092
8093 /* Locate the matching .ARM.extab. */
8094 if (entry_addr.section != SHN_UNDEF
8095 && entry_addr.section < elf_header.e_shnum)
8096 {
8097 table_sec = section_headers + entry_addr.section;
8098 table_offset = entry_addr.offset;
8099 }
8100 else
8101 {
8102 table_sec = find_section_by_address (table);
8103 if (table_sec != NULL)
8104 table_offset = table - table_sec->sh_addr;
8105 }
8106 if (table_sec == NULL)
8107 {
8108 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8109 (unsigned long) table);
8110 continue;
8111 }
8112 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8113 &extab_arm_sec);
8114 }
8115 }
8116
8117 printf ("\n");
8118
8119 arm_free_section (&exidx_arm_sec);
8120 arm_free_section (&extab_arm_sec);
8121}
8122
fa197c1c 8123/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8124
8125static void
0b6ae522
DJ		 8126arm_process_unwind (FILE *file)
8127{
8128 struct arm_unw_aux_info aux;
8129 Elf_Internal_Shdr *unwsec = NULL;
8130 Elf_Internal_Shdr *strsec;
8131 Elf_Internal_Shdr *sec;
8132 unsigned long i;
fa197c1c 8133 unsigned int sec_type;
0b6ae522 8134
fa197c1c
PB		 8135 switch (elf_header.e_machine)
8136 {
8137 case EM_ARM:
8138 sec_type = SHT_ARM_EXIDX;
8139 break;
8140
8141 case EM_TI_C6000:
8142 sec_type = SHT_C6000_UNWIND;
8143 break;
8144
0b4362b0 8145 default:
74e1a04b 8146 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8147 elf_header.e_machine);
8148 return;
fa197c1c
PB		 8149 }
8150
0b6ae522 8151 if (string_table == NULL)
1b31d05e
NC		 8152 return;
8153
8154 memset (& aux, 0, sizeof (aux));
8155 aux.file = file;
0b6ae522
DJ		 8156
8157 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8158 {
8159 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8160 {
ba5cdace 8161 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8162
8163 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8164
8165 /* PR binutils/17531 file: 011-12666-0.004. */
8166 if (aux.strtab != NULL)
8167 {
4082ef84 8168 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8169 free (aux.strtab);
8170 }
0b6ae522
DJ		 8171 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8172 1, strsec->sh_size, _("string table"));
8173 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8174 }
fa197c1c 8175 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8176 unwsec = sec;
8177 }
8178
1b31d05e 8179 if (unwsec == NULL)
0b6ae522 8180 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8181 else
8182 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8183 {
8184 if (sec->sh_type == sec_type)
8185 {
8186 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8187 printable_section_name (sec),
1b31d05e
NC		 8188 (unsigned long) sec->sh_offset,
8189 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8190
1b31d05e
NC		 8191 dump_arm_unwind (&aux, sec);
8192 }
8193 }
0b6ae522
DJ		 8194
8195 if (aux.symtab)
8196 free (aux.symtab);
8197 if (aux.strtab)
8198 free ((char *) aux.strtab);
0b6ae522
DJ		 8199}
8200
1b31d05e 8201static void
2cf0635d 8202process_unwind (FILE * file)
57346661 8203{
2cf0635d
NC		 8204 struct unwind_handler
8205 {
57346661 8206 int machtype;
1b31d05e 8207 void (* handler)(FILE *);
2cf0635d
NC		 8208 } handlers[] =
8209 {
0b6ae522 8210 { EM_ARM, arm_process_unwind },
57346661
AM		 8211 { EM_IA_64, ia64_process_unwind },
8212 { EM_PARISC, hppa_process_unwind },
fa197c1c 8213 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8214 { 0, 0 }
8215 };
8216 int i;
8217
8218 if (!do_unwind)
1b31d05e 8219 return;
57346661
AM		 8220
8221 for (i = 0; handlers[i].handler != NULL; i++)
8222 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8223 {
8224 handlers[i].handler (file);
8225 return;
8226 }
57346661 8227
1b31d05e
NC		 8228 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8229 get_machine_name (elf_header.e_machine));
57346661
AM		 8230}
8231
252b5132 8232static void
2cf0635d 8233dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8234{
8235 switch (entry->d_tag)
8236 {
8237 case DT_MIPS_FLAGS:
8238 if (entry->d_un.d_val == 0)
4b68bca3 8239 printf (_("NONE"));
252b5132
RH		 8240 else
8241 {
8242 static const char * opts[] =
8243 {
8244 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8245 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8246 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8247 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8248 "RLD_ORDER_SAFE"
8249 };
8250 unsigned int cnt;
8251 int first = 1;
2b692964 8252
60bca95a 8253 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8254 if (entry->d_un.d_val & (1 << cnt))
8255 {
8256 printf ("%s%s", first ? "" : " ", opts[cnt]);
8257 first = 0;
8258 }
252b5132
RH		 8259 }
8260 break;
103f02d3 8261
252b5132 8262 case DT_MIPS_IVERSION:
d79b3d50 8263 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8264 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8265 else
76ca31c0
NC		 8266 {
8267 char buf[40];
8268 sprintf_vma (buf, entry->d_un.d_ptr);
8269 /* Note: coded this way so that there is a single string for translation. */
8270 printf (_("<corrupt: %s>"), buf);
8271 }
252b5132 8272 break;
103f02d3 8273
252b5132
RH		 8274 case DT_MIPS_TIME_STAMP:
8275 {
8276 char timebuf[20];
2cf0635d 8277 struct tm * tmp;
91d6fa6a 8278 time_t atime = entry->d_un.d_val;
82b1b41b 8279
91d6fa6a 8280 tmp = gmtime (&atime);
82b1b41b
NC		 8281 /* PR 17531: file: 6accc532. */
8282 if (tmp == NULL)
8283 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8284 else
8285 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8286 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8287 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8288 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8289 }
8290 break;
103f02d3 8291
252b5132
RH		 8292 case DT_MIPS_RLD_VERSION:
8293 case DT_MIPS_LOCAL_GOTNO:
8294 case DT_MIPS_CONFLICTNO:
8295 case DT_MIPS_LIBLISTNO:
8296 case DT_MIPS_SYMTABNO:
8297 case DT_MIPS_UNREFEXTNO:
8298 case DT_MIPS_HIPAGENO:
8299 case DT_MIPS_DELTA_CLASS_NO:
8300 case DT_MIPS_DELTA_INSTANCE_NO:
8301 case DT_MIPS_DELTA_RELOC_NO:
8302 case DT_MIPS_DELTA_SYM_NO:
8303 case DT_MIPS_DELTA_CLASSSYM_NO:
8304 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8305 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8306 break;
103f02d3
UD		 8307
8308 default:
4b68bca3 8309 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8310 }
4b68bca3 8311 putchar ('\n');
103f02d3
UD		 8312}
8313
103f02d3 8314static void
2cf0635d 8315dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8316{
8317 switch (entry->d_tag)
8318 {
8319 case DT_HP_DLD_FLAGS:
8320 {
8321 static struct
8322 {
8323 long int bit;
2cf0635d 8324 const char * str;
5e220199
NC		 8325 }
8326 flags[] =
8327 {
8328 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8329 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8330 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8331 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8332 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8333 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8334 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8335 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8336 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8337 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8338 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8339 { DT_HP_GST, "HP_GST" },
8340 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8341 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8342 { DT_HP_NODELETE, "HP_NODELETE" },
8343 { DT_HP_GROUP, "HP_GROUP" },
8344 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8345 };
103f02d3 8346 int first = 1;
5e220199 8347 size_t cnt;
f7a99963 8348 bfd_vma val = entry->d_un.d_val;
103f02d3 8349
60bca95a 8350 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8351 if (val & flags[cnt].bit)
30800947
NC		 8352 {
8353 if (! first)
8354 putchar (' ');
8355 fputs (flags[cnt].str, stdout);
8356 first = 0;
8357 val ^= flags[cnt].bit;
8358 }
76da6bbe 8359
103f02d3 8360 if (val != 0 || first)
f7a99963
NC		 8361 {
8362 if (! first)
8363 putchar (' ');
8364 print_vma (val, HEX);
8365 }
103f02d3
UD		 8366 }
8367 break;
76da6bbe 8368
252b5132 8369 default:
f7a99963
NC		 8370 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8371 break;
252b5132 8372 }
35b1837e 8373 putchar ('\n');
252b5132
RH		 8374}
8375
28f997cf
TG		 8376#ifdef BFD64
8377
8378/* VMS vs Unix time offset and factor. */
8379
8380#define VMS_EPOCH_OFFSET 35067168000000000LL
8381#define VMS_GRANULARITY_FACTOR 10000000
8382
8383/* Display a VMS time in a human readable format. */
8384
8385static void
8386print_vms_time (bfd_int64_t vmstime)
8387{
8388 struct tm *tm;
8389 time_t unxtime;
8390
8391 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8392 tm = gmtime (&unxtime);
8393 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8394 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8395 tm->tm_hour, tm->tm_min, tm->tm_sec);
8396}
8397#endif /* BFD64 */
8398
ecc51f48 8399static void
2cf0635d 8400dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8401{
8402 switch (entry->d_tag)
8403 {
0de14b54 8404 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8405 /* First 3 slots reserved. */
ecc51f48
NC		 8406 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8407 printf (" -- ");
8408 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8409 break;
8410
28f997cf
TG		 8411 case DT_IA_64_VMS_LINKTIME:
8412#ifdef BFD64
8413 print_vms_time (entry->d_un.d_val);
8414#endif
8415 break;
8416
8417 case DT_IA_64_VMS_LNKFLAGS:
8418 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8419 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8420 printf (" CALL_DEBUG");
8421 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8422 printf (" NOP0BUFS");
8423 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8424 printf (" P0IMAGE");
8425 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8426 printf (" MKTHREADS");
8427 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8428 printf (" UPCALLS");
8429 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8430 printf (" IMGSTA");
8431 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8432 printf (" INITIALIZE");
8433 if (entry->d_un.d_val & VMS_LF_MAIN)
8434 printf (" MAIN");
8435 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8436 printf (" EXE_INIT");
8437 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8438 printf (" TBK_IN_IMG");
8439 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8440 printf (" DBG_IN_IMG");
8441 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8442 printf (" TBK_IN_DSF");
8443 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8444 printf (" DBG_IN_DSF");
8445 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8446 printf (" SIGNATURES");
8447 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8448 printf (" REL_SEG_OFF");
8449 break;
8450
bdf4d63a
JJ		 8451 default:
8452 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8453 break;
ecc51f48 8454 }
bdf4d63a 8455 putchar ('\n');
ecc51f48
NC		 8456}
8457
252b5132 8458static int
2cf0635d 8459get_32bit_dynamic_section (FILE * file)
252b5132 8460{
2cf0635d
NC		 8461 Elf32_External_Dyn * edyn;
8462 Elf32_External_Dyn * ext;
8463 Elf_Internal_Dyn * entry;
103f02d3 8464
3f5e193b
NC		 8465 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8466 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8467 if (!edyn)
8468 return 0;
103f02d3 8469
071436c6
NC		 8470 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8471 might not have the luxury of section headers. Look for the DT_NULL
8472 terminator to determine the number of entries. */
ba2685cc 8473 for (ext = edyn, dynamic_nent = 0;
071436c6 8474 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8475 ext++)
8476 {
8477 dynamic_nent++;
8478 if (BYTE_GET (ext->d_tag) == DT_NULL)
8479 break;
8480 }
252b5132 8481
3f5e193b
NC		 8482 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8483 sizeof (* entry));
b2d38a17 8484 if (dynamic_section == NULL)
252b5132 8485 {
8b73c356
NC		 8486 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8487 (unsigned long) dynamic_nent);
9ea033b2
NC		 8488 free (edyn);
8489 return 0;
8490 }
252b5132 8491
fb514b26 8492 for (ext = edyn, entry = dynamic_section;
ba2685cc 8493 entry < dynamic_section + dynamic_nent;
fb514b26 8494 ext++, entry++)
9ea033b2 8495 {
fb514b26
AM		 8496 entry->d_tag = BYTE_GET (ext->d_tag);
8497 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8498 }
8499
9ea033b2
NC		 8500 free (edyn);
8501
8502 return 1;
8503}
8504
8505static int
2cf0635d 8506get_64bit_dynamic_section (FILE * file)
9ea033b2 8507{
2cf0635d
NC		 8508 Elf64_External_Dyn * edyn;
8509 Elf64_External_Dyn * ext;
8510 Elf_Internal_Dyn * entry;
103f02d3 8511
071436c6 8512 /* Read in the data. */
3f5e193b
NC		 8513 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8514 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8515 if (!edyn)
8516 return 0;
103f02d3 8517
071436c6
NC		 8518 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8519 might not have the luxury of section headers. Look for the DT_NULL
8520 terminator to determine the number of entries. */
ba2685cc 8521 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8522 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8523 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8524 ext++)
8525 {
8526 dynamic_nent++;
66543521 8527 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8528 break;
8529 }
252b5132 8530
3f5e193b
NC		 8531 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8532 sizeof (* entry));
b2d38a17 8533 if (dynamic_section == NULL)
252b5132 8534 {
8b73c356
NC		 8535 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8536 (unsigned long) dynamic_nent);
252b5132
RH		 8537 free (edyn);
8538 return 0;
8539 }
8540
071436c6 8541 /* Convert from external to internal formats. */
fb514b26 8542 for (ext = edyn, entry = dynamic_section;
ba2685cc 8543 entry < dynamic_section + dynamic_nent;
fb514b26 8544 ext++, entry++)
252b5132 8545 {
66543521
AM		 8546 entry->d_tag = BYTE_GET (ext->d_tag);
8547 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8548 }
8549
8550 free (edyn);
8551
9ea033b2
NC		 8552 return 1;
8553}
8554
e9e44622
JJ		 8555static void
8556print_dynamic_flags (bfd_vma flags)
d1133906 8557{
e9e44622 8558 int first = 1;
13ae64f3 8559
d1133906
NC		 8560 while (flags)
8561 {
8562 bfd_vma flag;
8563
8564 flag = flags & - flags;
8565 flags &= ~ flag;
8566
e9e44622
JJ		 8567 if (first)
8568 first = 0;
8569 else
8570 putc (' ', stdout);
13ae64f3 8571
d1133906
NC		 8572 switch (flag)
8573 {
e9e44622
JJ		 8574 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8575 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8576 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8577 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8578 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8579 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8580 }
8581 }
e9e44622 8582 puts ("");
d1133906
NC		 8583}
8584
b2d38a17
NC		 8585/* Parse and display the contents of the dynamic section. */
8586
9ea033b2 8587static int
2cf0635d 8588process_dynamic_section (FILE * file)
9ea033b2 8589{
2cf0635d 8590 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8591
8592 if (dynamic_size == 0)
8593 {
8594 if (do_dynamic)
b2d38a17 8595 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8596
8597 return 1;
8598 }
8599
8600 if (is_32bit_elf)
8601 {
b2d38a17 8602 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8603 return 0;
8604 }
b2d38a17 8605 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8606 return 0;
8607
252b5132
RH		 8608 /* Find the appropriate symbol table. */
8609 if (dynamic_symbols == NULL)
8610 {
86dba8ee
AM		 8611 for (entry = dynamic_section;
8612 entry < dynamic_section + dynamic_nent;
8613 ++entry)
252b5132 8614 {
c8286bd1 8615 Elf_Internal_Shdr section;
252b5132
RH		 8616
8617 if (entry->d_tag != DT_SYMTAB)
8618 continue;
8619
8620 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8621
8622 /* Since we do not know how big the symbol table is,
8623 we default to reading in the entire file (!) and
8624 processing that. This is overkill, I know, but it
e3c8793a 8625 should work. */
d93f0186 8626 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8627
fb52b2f4
NC		 8628 if (archive_file_offset != 0)
8629 section.sh_size = archive_file_size - section.sh_offset;
8630 else
8631 {
8632 if (fseek (file, 0, SEEK_END))
591a748a 8633 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8634
8635 section.sh_size = ftell (file) - section.sh_offset;
8636 }
252b5132 8637
9ea033b2 8638 if (is_32bit_elf)
9ad5cbcf 8639 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8640 else
9ad5cbcf 8641 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8642 section.sh_name = string_table_length;
252b5132 8643
ba5cdace 8644 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8645 if (num_dynamic_syms < 1)
252b5132
RH		 8646 {
8647 error (_("Unable to determine the number of symbols to load\n"));
8648 continue;
8649 }
252b5132
RH		 8650 }
8651 }
8652
8653 /* Similarly find a string table. */
8654 if (dynamic_strings == NULL)
8655 {
86dba8ee
AM		 8656 for (entry = dynamic_section;
8657 entry < dynamic_section + dynamic_nent;
8658 ++entry)
252b5132
RH		 8659 {
8660 unsigned long offset;
b34976b6 8661 long str_tab_len;
252b5132
RH		 8662
8663 if (entry->d_tag != DT_STRTAB)
8664 continue;
8665
8666 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8667
8668 /* Since we do not know how big the string table is,
8669 we default to reading in the entire file (!) and
8670 processing that. This is overkill, I know, but it
e3c8793a 8671 should work. */
252b5132 8672
d93f0186 8673 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8674
8675 if (archive_file_offset != 0)
8676 str_tab_len = archive_file_size - offset;
8677 else
8678 {
8679 if (fseek (file, 0, SEEK_END))
8680 error (_("Unable to seek to end of file\n"));
8681 str_tab_len = ftell (file) - offset;
8682 }
252b5132
RH		 8683
8684 if (str_tab_len < 1)
8685 {
8686 error
8687 (_("Unable to determine the length of the dynamic string table\n"));
8688 continue;
8689 }
8690
3f5e193b
NC		 8691 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8692 str_tab_len,
8693 _("dynamic string table"));
59245841 8694 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8695 break;
8696 }
8697 }
8698
8699 /* And find the syminfo section if available. */
8700 if (dynamic_syminfo == NULL)
8701 {
3e8bba36 8702 unsigned long syminsz = 0;
252b5132 8703
86dba8ee
AM		 8704 for (entry = dynamic_section;
8705 entry < dynamic_section + dynamic_nent;
8706 ++entry)
252b5132
RH		 8707 {
8708 if (entry->d_tag == DT_SYMINENT)
8709 {
8710 /* Note: these braces are necessary to avoid a syntax
8711 error from the SunOS4 C compiler. */
049b0c3a
NC		 8712 /* PR binutils/17531: A corrupt file can trigger this test.
8713 So do not use an assert, instead generate an error message. */
8714 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8715 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8716 (int) entry->d_un.d_val);
252b5132
RH		 8717 }
8718 else if (entry->d_tag == DT_SYMINSZ)
8719 syminsz = entry->d_un.d_val;
8720 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8721 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8722 syminsz);
252b5132
RH		 8723 }
8724
8725 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8726 {
2cf0635d
NC		 8727 Elf_External_Syminfo * extsyminfo;
8728 Elf_External_Syminfo * extsym;
8729 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8730
8731 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8732 extsyminfo = (Elf_External_Syminfo *)
8733 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8734 _("symbol information"));
a6e9f9df
AM		 8735 if (!extsyminfo)
8736 return 0;
252b5132 8737
3f5e193b 8738 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8739 if (dynamic_syminfo == NULL)
8740 {
8b73c356
NC		 8741 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8742 (unsigned long) syminsz);
252b5132
RH		 8743 return 0;
8744 }
8745
8746 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8747 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8748 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8749 ++syminfo, ++extsym)
252b5132 8750 {
86dba8ee
AM		 8751 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8752 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8753 }
8754
8755 free (extsyminfo);
8756 }
8757 }
8758
8759 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8760 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8761 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8762 if (do_dynamic)
8763 printf (_(" Tag Type Name/Value\n"));
8764
86dba8ee
AM		 8765 for (entry = dynamic_section;
8766 entry < dynamic_section + dynamic_nent;
8767 entry++)
252b5132
RH		 8768 {
8769 if (do_dynamic)
f7a99963 8770 {
2cf0635d 8771 const char * dtype;
e699b9ff 8772
f7a99963
NC		 8773 putchar (' ');
8774 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8775 dtype = get_dynamic_type (entry->d_tag);
8776 printf (" (%s)%*s", dtype,
8777 ((is_32bit_elf ? 27 : 19)
8778 - (int) strlen (dtype)),
f7a99963
NC		 8779 " ");
8780 }
252b5132
RH		 8781
8782 switch (entry->d_tag)
8783 {
d1133906
NC		 8784 case DT_FLAGS:
8785 if (do_dynamic)
e9e44622 8786 print_dynamic_flags (entry->d_un.d_val);
d1133906 8787 break;
76da6bbe 8788
252b5132
RH		 8789 case DT_AUXILIARY:
8790 case DT_FILTER:
019148e4
L		 8791 case DT_CONFIG:
8792 case DT_DEPAUDIT:
8793 case DT_AUDIT:
252b5132
RH		 8794 if (do_dynamic)
8795 {
019148e4 8796 switch (entry->d_tag)
b34976b6 8797 {
019148e4
L		 8798 case DT_AUXILIARY:
8799 printf (_("Auxiliary library"));
8800 break;
8801
8802 case DT_FILTER:
8803 printf (_("Filter library"));
8804 break;
8805
b34976b6 8806 case DT_CONFIG:
019148e4
L		 8807 printf (_("Configuration file"));
8808 break;
8809
8810 case DT_DEPAUDIT:
8811 printf (_("Dependency audit library"));
8812 break;
8813
8814 case DT_AUDIT:
8815 printf (_("Audit library"));
8816 break;
8817 }
252b5132 8818
d79b3d50
NC		 8819 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8820 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8821 else
f7a99963
NC		 8822 {
8823 printf (": ");
8824 print_vma (entry->d_un.d_val, PREFIX_HEX);
8825 putchar ('\n');
8826 }
252b5132
RH		 8827 }
8828 break;
8829
dcefbbbd 8830 case DT_FEATURE:
252b5132
RH		 8831 if (do_dynamic)
8832 {
8833 printf (_("Flags:"));
86f55779 8834
252b5132
RH		 8835 if (entry->d_un.d_val == 0)
8836 printf (_(" None\n"));
8837 else
8838 {
8839 unsigned long int val = entry->d_un.d_val;
86f55779 8840
252b5132
RH		 8841 if (val & DTF_1_PARINIT)
8842 {
8843 printf (" PARINIT");
8844 val ^= DTF_1_PARINIT;
8845 }
dcefbbbd
L		 8846 if (val & DTF_1_CONFEXP)
8847 {
8848 printf (" CONFEXP");
8849 val ^= DTF_1_CONFEXP;
8850 }
252b5132
RH		 8851 if (val != 0)
8852 printf (" %lx", val);
8853 puts ("");
8854 }
8855 }
8856 break;
8857
8858 case DT_POSFLAG_1:
8859 if (do_dynamic)
8860 {
8861 printf (_("Flags:"));
86f55779 8862
252b5132
RH		 8863 if (entry->d_un.d_val == 0)
8864 printf (_(" None\n"));
8865 else
8866 {
8867 unsigned long int val = entry->d_un.d_val;
86f55779 8868
252b5132
RH		 8869 if (val & DF_P1_LAZYLOAD)
8870 {
8871 printf (" LAZYLOAD");
8872 val ^= DF_P1_LAZYLOAD;
8873 }
8874 if (val & DF_P1_GROUPPERM)
8875 {
8876 printf (" GROUPPERM");
8877 val ^= DF_P1_GROUPPERM;
8878 }
8879 if (val != 0)
8880 printf (" %lx", val);
8881 puts ("");
8882 }
8883 }
8884 break;
8885
8886 case DT_FLAGS_1:
8887 if (do_dynamic)
8888 {
8889 printf (_("Flags:"));
8890 if (entry->d_un.d_val == 0)
8891 printf (_(" None\n"));
8892 else
8893 {
8894 unsigned long int val = entry->d_un.d_val;
86f55779 8895
252b5132
RH		 8896 if (val & DF_1_NOW)
8897 {
8898 printf (" NOW");
8899 val ^= DF_1_NOW;
8900 }
8901 if (val & DF_1_GLOBAL)
8902 {
8903 printf (" GLOBAL");
8904 val ^= DF_1_GLOBAL;
8905 }
8906 if (val & DF_1_GROUP)
8907 {
8908 printf (" GROUP");
8909 val ^= DF_1_GROUP;
8910 }
8911 if (val & DF_1_NODELETE)
8912 {
8913 printf (" NODELETE");
8914 val ^= DF_1_NODELETE;
8915 }
8916 if (val & DF_1_LOADFLTR)
8917 {
8918 printf (" LOADFLTR");
8919 val ^= DF_1_LOADFLTR;
8920 }
8921 if (val & DF_1_INITFIRST)
8922 {
8923 printf (" INITFIRST");
8924 val ^= DF_1_INITFIRST;
8925 }
8926 if (val & DF_1_NOOPEN)
8927 {
8928 printf (" NOOPEN");
8929 val ^= DF_1_NOOPEN;
8930 }
8931 if (val & DF_1_ORIGIN)
8932 {
8933 printf (" ORIGIN");
8934 val ^= DF_1_ORIGIN;
8935 }
8936 if (val & DF_1_DIRECT)
8937 {
8938 printf (" DIRECT");
8939 val ^= DF_1_DIRECT;
8940 }
8941 if (val & DF_1_TRANS)
8942 {
8943 printf (" TRANS");
8944 val ^= DF_1_TRANS;
8945 }
8946 if (val & DF_1_INTERPOSE)
8947 {
8948 printf (" INTERPOSE");
8949 val ^= DF_1_INTERPOSE;
8950 }
f7db6139 8951 if (val & DF_1_NODEFLIB)
dcefbbbd 8952 {
f7db6139
L		 8953 printf (" NODEFLIB");
8954 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8955 }
8956 if (val & DF_1_NODUMP)
8957 {
8958 printf (" NODUMP");
8959 val ^= DF_1_NODUMP;
8960 }
34b60028 8961 if (val & DF_1_CONFALT)
dcefbbbd 8962 {
34b60028
L		 8963 printf (" CONFALT");
8964 val ^= DF_1_CONFALT;
8965 }
8966 if (val & DF_1_ENDFILTEE)
8967 {
8968 printf (" ENDFILTEE");
8969 val ^= DF_1_ENDFILTEE;
8970 }
8971 if (val & DF_1_DISPRELDNE)
8972 {
8973 printf (" DISPRELDNE");
8974 val ^= DF_1_DISPRELDNE;
8975 }
8976 if (val & DF_1_DISPRELPND)
8977 {
8978 printf (" DISPRELPND");
8979 val ^= DF_1_DISPRELPND;
8980 }
8981 if (val & DF_1_NODIRECT)
8982 {
8983 printf (" NODIRECT");
8984 val ^= DF_1_NODIRECT;
8985 }
8986 if (val & DF_1_IGNMULDEF)
8987 {
8988 printf (" IGNMULDEF");
8989 val ^= DF_1_IGNMULDEF;
8990 }
8991 if (val & DF_1_NOKSYMS)
8992 {
8993 printf (" NOKSYMS");
8994 val ^= DF_1_NOKSYMS;
8995 }
8996 if (val & DF_1_NOHDR)
8997 {
8998 printf (" NOHDR");
8999 val ^= DF_1_NOHDR;
9000 }
9001 if (val & DF_1_EDITED)
9002 {
9003 printf (" EDITED");
9004 val ^= DF_1_EDITED;
9005 }
9006 if (val & DF_1_NORELOC)
9007 {
9008 printf (" NORELOC");
9009 val ^= DF_1_NORELOC;
9010 }
9011 if (val & DF_1_SYMINTPOSE)
9012 {
9013 printf (" SYMINTPOSE");
9014 val ^= DF_1_SYMINTPOSE;
9015 }
9016 if (val & DF_1_GLOBAUDIT)
9017 {
9018 printf (" GLOBAUDIT");
9019 val ^= DF_1_GLOBAUDIT;
9020 }
9021 if (val & DF_1_SINGLETON)
9022 {
9023 printf (" SINGLETON");
9024 val ^= DF_1_SINGLETON;
dcefbbbd 9025 }
252b5132
RH		 9026 if (val != 0)
9027 printf (" %lx", val);
9028 puts ("");
9029 }
9030 }
9031 break;
9032
9033 case DT_PLTREL:
566b0d53 9034 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9035 if (do_dynamic)
9036 puts (get_dynamic_type (entry->d_un.d_val));
9037 break;
9038
9039 case DT_NULL :
9040 case DT_NEEDED :
9041 case DT_PLTGOT :
9042 case DT_HASH :
9043 case DT_STRTAB :
9044 case DT_SYMTAB :
9045 case DT_RELA :
9046 case DT_INIT :
9047 case DT_FINI :
9048 case DT_SONAME :
9049 case DT_RPATH :
9050 case DT_SYMBOLIC:
9051 case DT_REL :
9052 case DT_DEBUG :
9053 case DT_TEXTREL :
9054 case DT_JMPREL :
019148e4 9055 case DT_RUNPATH :
252b5132
RH		 9056 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9057
9058 if (do_dynamic)
9059 {
2cf0635d 9060 char * name;
252b5132 9061
d79b3d50
NC		 9062 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9063 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9064 else
d79b3d50 9065 name = NULL;
252b5132
RH		 9066
9067 if (name)
9068 {
9069 switch (entry->d_tag)
9070 {
9071 case DT_NEEDED:
9072 printf (_("Shared library: [%s]"), name);
9073
18bd398b 9074 if (streq (name, program_interpreter))
f7a99963 9075 printf (_(" program interpreter"));
252b5132
RH		 9076 break;
9077
9078 case DT_SONAME:
f7a99963 9079 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9080 break;
9081
9082 case DT_RPATH:
f7a99963 9083 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9084 break;
9085
019148e4
L		 9086 case DT_RUNPATH:
9087 printf (_("Library runpath: [%s]"), name);
9088 break;
9089
252b5132 9090 default:
f7a99963
NC		 9091 print_vma (entry->d_un.d_val, PREFIX_HEX);
9092 break;
252b5132
RH		 9093 }
9094 }
9095 else
f7a99963
NC		 9096 print_vma (entry->d_un.d_val, PREFIX_HEX);
9097
9098 putchar ('\n');
252b5132
RH		 9099 }
9100 break;
9101
9102 case DT_PLTRELSZ:
9103 case DT_RELASZ :
9104 case DT_STRSZ :
9105 case DT_RELSZ :
9106 case DT_RELAENT :
9107 case DT_SYMENT :
9108 case DT_RELENT :
566b0d53 9109 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9110 case DT_PLTPADSZ:
9111 case DT_MOVEENT :
9112 case DT_MOVESZ :
9113 case DT_INIT_ARRAYSZ:
9114 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9115 case DT_GNU_CONFLICTSZ:
9116 case DT_GNU_LIBLISTSZ:
252b5132 9117 if (do_dynamic)
f7a99963
NC		 9118 {
9119 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9120 printf (_(" (bytes)\n"));
f7a99963 9121 }
252b5132
RH		 9122 break;
9123
9124 case DT_VERDEFNUM:
9125 case DT_VERNEEDNUM:
9126 case DT_RELACOUNT:
9127 case DT_RELCOUNT:
9128 if (do_dynamic)
f7a99963
NC		 9129 {
9130 print_vma (entry->d_un.d_val, UNSIGNED);
9131 putchar ('\n');
9132 }
252b5132
RH		 9133 break;
9134
9135 case DT_SYMINSZ:
9136 case DT_SYMINENT:
9137 case DT_SYMINFO:
9138 case DT_USED:
9139 case DT_INIT_ARRAY:
9140 case DT_FINI_ARRAY:
9141 if (do_dynamic)
9142 {
d79b3d50
NC		 9143 if (entry->d_tag == DT_USED
9144 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9145 {
2cf0635d 9146 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9147
b34976b6 9148 if (*name)
252b5132
RH		 9149 {
9150 printf (_("Not needed object: [%s]\n"), name);
9151 break;
9152 }
9153 }
103f02d3 9154
f7a99963
NC		 9155 print_vma (entry->d_un.d_val, PREFIX_HEX);
9156 putchar ('\n');
252b5132
RH		 9157 }
9158 break;
9159
9160 case DT_BIND_NOW:
9161 /* The value of this entry is ignored. */
35b1837e
AM		 9162 if (do_dynamic)
9163 putchar ('\n');
252b5132 9164 break;
103f02d3 9165
047b2264
JJ		 9166 case DT_GNU_PRELINKED:
9167 if (do_dynamic)
9168 {
2cf0635d 9169 struct tm * tmp;
91d6fa6a 9170 time_t atime = entry->d_un.d_val;
047b2264 9171
91d6fa6a 9172 tmp = gmtime (&atime);
071436c6
NC		 9173 /* PR 17533 file: 041-1244816-0.004. */
9174 if (tmp == NULL)
5a2cbcf4
L		 9175 printf (_("<corrupt time val: %lx"),
9176 (unsigned long) atime);
071436c6
NC		 9177 else
9178 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9179 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9180 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9181
9182 }
9183 break;
9184
fdc90cb4
JJ		 9185 case DT_GNU_HASH:
9186 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9187 if (do_dynamic)
9188 {
9189 print_vma (entry->d_un.d_val, PREFIX_HEX);
9190 putchar ('\n');
9191 }
9192 break;
9193
252b5132
RH		 9194 default:
9195 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9196 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9197 entry->d_un.d_val;
9198
9199 if (do_dynamic)
9200 {
9201 switch (elf_header.e_machine)
9202 {
9203 case EM_MIPS:
4fe85591 9204 case EM_MIPS_RS3_LE:
b2d38a17 9205 dynamic_section_mips_val (entry);
252b5132 9206 break;
103f02d3 9207 case EM_PARISC:
b2d38a17 9208 dynamic_section_parisc_val (entry);
103f02d3 9209 break;
ecc51f48 9210 case EM_IA_64:
b2d38a17 9211 dynamic_section_ia64_val (entry);
ecc51f48 9212 break;
252b5132 9213 default:
f7a99963
NC		 9214 print_vma (entry->d_un.d_val, PREFIX_HEX);
9215 putchar ('\n');
252b5132
RH		 9216 }
9217 }
9218 break;
9219 }
9220 }
9221
9222 return 1;
9223}
9224
9225static char *
d3ba0551 9226get_ver_flags (unsigned int flags)
252b5132 9227{
b34976b6 9228 static char buff[32];
252b5132
RH		 9229
9230 buff[0] = 0;
9231
9232 if (flags == 0)
9233 return _("none");
9234
9235 if (flags & VER_FLG_BASE)
9236 strcat (buff, "BASE ");
9237
9238 if (flags & VER_FLG_WEAK)
9239 {
9240 if (flags & VER_FLG_BASE)
9241 strcat (buff, "| ");
9242
9243 strcat (buff, "WEAK ");
9244 }
9245
44ec90b9
RO		 9246 if (flags & VER_FLG_INFO)
9247 {
9248 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9249 strcat (buff, "| ");
9250
9251 strcat (buff, "INFO ");
9252 }
9253
9254 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9255 strcat (buff, _("| <unknown>"));
252b5132
RH		 9256
9257 return buff;
9258}
9259
9260/* Display the contents of the version sections. */
98fb390a 9261
252b5132 9262static int
2cf0635d 9263process_version_sections (FILE * file)
252b5132 9264{
2cf0635d 9265 Elf_Internal_Shdr * section;
b34976b6
AM		 9266 unsigned i;
9267 int found = 0;
252b5132
RH		 9268
9269 if (! do_version)
9270 return 1;
9271
9272 for (i = 0, section = section_headers;
9273 i < elf_header.e_shnum;
b34976b6 9274 i++, section++)
252b5132
RH		 9275 {
9276 switch (section->sh_type)
9277 {
9278 case SHT_GNU_verdef:
9279 {
2cf0635d 9280 Elf_External_Verdef * edefs;
b34976b6
AM		 9281 unsigned int idx;
9282 unsigned int cnt;
2cf0635d 9283 char * endbuf;
252b5132
RH		 9284
9285 found = 1;
9286
74e1a04b
NC		 9287 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9288 printable_section_name (section),
9289 section->sh_info);
252b5132
RH		 9290
9291 printf (_(" Addr: 0x"));
9292 printf_vma (section->sh_addr);
74e1a04b 9293 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9294 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9295 printable_section_name_from_index (section->sh_link));
252b5132 9296
3f5e193b
NC		 9297 edefs = (Elf_External_Verdef *)
9298 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9299 _("version definition section"));
a6e9f9df
AM		 9300 if (!edefs)
9301 break;
59245841 9302 endbuf = (char *) edefs + section->sh_size;
252b5132 9303
b34976b6 9304 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9305 {
2cf0635d
NC		 9306 char * vstart;
9307 Elf_External_Verdef * edef;
b34976b6 9308 Elf_Internal_Verdef ent;
2cf0635d 9309 Elf_External_Verdaux * eaux;
b34976b6
AM		 9310 Elf_Internal_Verdaux aux;
9311 int j;
9312 int isum;
103f02d3 9313
7e26601c
NC		 9314 /* Check for very large indicies. */
9315 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9316 break;
9317
252b5132 9318 vstart = ((char *) edefs) + idx;
54806181
AM		 9319 if (vstart + sizeof (*edef) > endbuf)
9320 break;
252b5132
RH		 9321
9322 edef = (Elf_External_Verdef *) vstart;
9323
9324 ent.vd_version = BYTE_GET (edef->vd_version);
9325 ent.vd_flags = BYTE_GET (edef->vd_flags);
9326 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9327 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9328 ent.vd_hash = BYTE_GET (edef->vd_hash);
9329 ent.vd_aux = BYTE_GET (edef->vd_aux);
9330 ent.vd_next = BYTE_GET (edef->vd_next);
9331
9332 printf (_(" %#06x: Rev: %d Flags: %s"),
9333 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9334
9335 printf (_(" Index: %d Cnt: %d "),
9336 ent.vd_ndx, ent.vd_cnt);
9337
dd24e3da 9338 /* Check for overflow. */
7e26601c 9339 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9340 break;
9341
252b5132
RH		 9342 vstart += ent.vd_aux;
9343
9344 eaux = (Elf_External_Verdaux *) vstart;
9345
9346 aux.vda_name = BYTE_GET (eaux->vda_name);
9347 aux.vda_next = BYTE_GET (eaux->vda_next);
9348
d79b3d50
NC		 9349 if (VALID_DYNAMIC_NAME (aux.vda_name))
9350 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9351 else
9352 printf (_("Name index: %ld\n"), aux.vda_name);
9353
9354 isum = idx + ent.vd_aux;
9355
b34976b6 9356 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9357 {
dd24e3da 9358 /* Check for overflow. */
7e26601c 9359 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9360 break;
9361
252b5132
RH		 9362 isum += aux.vda_next;
9363 vstart += aux.vda_next;
9364
9365 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9366 if (vstart + sizeof (*eaux) > endbuf)
9367 break;
252b5132
RH		 9368
9369 aux.vda_name = BYTE_GET (eaux->vda_name);
9370 aux.vda_next = BYTE_GET (eaux->vda_next);
9371
d79b3d50 9372 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9373 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9374 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9375 else
9376 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9377 isum, j, aux.vda_name);
9378 }
dd24e3da 9379
54806181
AM		 9380 if (j < ent.vd_cnt)
9381 printf (_(" Version def aux past end of section\n"));
252b5132 9382
5d921cbd
NC		 9383 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9384 if (idx + ent.vd_next <= idx)
9385 break;
9386
252b5132
RH		 9387 idx += ent.vd_next;
9388 }
dd24e3da 9389
54806181
AM		 9390 if (cnt < section->sh_info)
9391 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9392
9393 free (edefs);
9394 }
9395 break;
103f02d3 9396
252b5132
RH		 9397 case SHT_GNU_verneed:
9398 {
2cf0635d 9399 Elf_External_Verneed * eneed;
b34976b6
AM		 9400 unsigned int idx;
9401 unsigned int cnt;
2cf0635d 9402 char * endbuf;
252b5132
RH		 9403
9404 found = 1;
9405
72de5009 9406 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9407 printable_section_name (section), section->sh_info);
252b5132
RH		 9408
9409 printf (_(" Addr: 0x"));
9410 printf_vma (section->sh_addr);
72de5009 9411 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9412 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9413 printable_section_name_from_index (section->sh_link));
252b5132 9414
3f5e193b
NC		 9415 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9416 section->sh_offset, 1,
9417 section->sh_size,
9cf03b7e 9418 _("Version Needs section"));
a6e9f9df
AM		 9419 if (!eneed)
9420 break;
59245841 9421 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9422
9423 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9424 {
2cf0635d 9425 Elf_External_Verneed * entry;
b34976b6
AM		 9426 Elf_Internal_Verneed ent;
9427 int j;
9428 int isum;
2cf0635d 9429 char * vstart;
252b5132 9430
7e26601c 9431 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9432 break;
9433
252b5132 9434 vstart = ((char *) eneed) + idx;
54806181
AM		 9435 if (vstart + sizeof (*entry) > endbuf)
9436 break;
252b5132
RH		 9437
9438 entry = (Elf_External_Verneed *) vstart;
9439
9440 ent.vn_version = BYTE_GET (entry->vn_version);
9441 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9442 ent.vn_file = BYTE_GET (entry->vn_file);
9443 ent.vn_aux = BYTE_GET (entry->vn_aux);
9444 ent.vn_next = BYTE_GET (entry->vn_next);
9445
9446 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9447
d79b3d50
NC		 9448 if (VALID_DYNAMIC_NAME (ent.vn_file))
9449 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9450 else
9451 printf (_(" File: %lx"), ent.vn_file);
9452
9453 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9454
dd24e3da 9455 /* Check for overflow. */
7e26601c 9456 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9457 break;
252b5132
RH		 9458 vstart += ent.vn_aux;
9459
9460 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9461 {
2cf0635d 9462 Elf_External_Vernaux * eaux;
b34976b6 9463 Elf_Internal_Vernaux aux;
252b5132 9464
54806181
AM		 9465 if (vstart + sizeof (*eaux) > endbuf)
9466 break;
252b5132
RH		 9467 eaux = (Elf_External_Vernaux *) vstart;
9468
9469 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9470 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9471 aux.vna_other = BYTE_GET (eaux->vna_other);
9472 aux.vna_name = BYTE_GET (eaux->vna_name);
9473 aux.vna_next = BYTE_GET (eaux->vna_next);
9474
d79b3d50 9475 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9476 printf (_(" %#06x: Name: %s"),
d79b3d50 9477 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9478 else
ecc2063b 9479 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9480 isum, aux.vna_name);
9481
9482 printf (_(" Flags: %s Version: %d\n"),
9483 get_ver_flags (aux.vna_flags), aux.vna_other);
9484
dd24e3da 9485 /* Check for overflow. */
53774b7e
NC		 9486 if (aux.vna_next > (size_t) (endbuf - vstart)
9487 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9488 {
9489 warn (_("Invalid vna_next field of %lx\n"),
9490 aux.vna_next);
9491 j = ent.vn_cnt;
9492 break;
9493 }
252b5132
RH		 9494 isum += aux.vna_next;
9495 vstart += aux.vna_next;
9496 }
9cf03b7e 9497
54806181 9498 if (j < ent.vn_cnt)
9cf03b7e 9499 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9500
bcf83b2a 9501 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9502 {
9503 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9504 cnt = section->sh_info;
9505 break;
9506 }
252b5132
RH		 9507 idx += ent.vn_next;
9508 }
9cf03b7e 9509
54806181 9510 if (cnt < section->sh_info)
9cf03b7e 9511 warn (_("Missing Version Needs information\n"));
103f02d3 9512
252b5132
RH		 9513 free (eneed);
9514 }
9515 break;
9516
9517 case SHT_GNU_versym:
9518 {
2cf0635d 9519 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9520 size_t total;
9521 unsigned int cnt;
2cf0635d
NC		 9522 unsigned char * edata;
9523 unsigned short * data;
9524 char * strtab;
9525 Elf_Internal_Sym * symbols;
9526 Elf_Internal_Shdr * string_sec;
ba5cdace 9527 unsigned long num_syms;
d3ba0551 9528 long off;
252b5132 9529
4fbb74a6 9530 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9531 break;
9532
4fbb74a6 9533 link_section = section_headers + section->sh_link;
08d8fa11 9534 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9535
4fbb74a6 9536 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9537 break;
9538
252b5132
RH		 9539 found = 1;
9540
ba5cdace 9541 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9542 if (symbols == NULL)
9543 break;
252b5132 9544
4fbb74a6 9545 string_sec = section_headers + link_section->sh_link;
252b5132 9546
3f5e193b
NC		 9547 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9548 string_sec->sh_size,
9549 _("version string table"));
a6e9f9df 9550 if (!strtab)
0429c154
MS		 9551 {
9552 free (symbols);
9553 break;
9554 }
252b5132 9555
8b73c356
NC		 9556 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9557 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9558
9559 printf (_(" Addr: "));
9560 printf_vma (section->sh_addr);
72de5009 9561 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9562 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9563 printable_section_name (link_section));
252b5132 9564
d3ba0551
AM		 9565 off = offset_from_vma (file,
9566 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9567 total * sizeof (short));
3f5e193b
NC		 9568 edata = (unsigned char *) get_data (NULL, file, off, total,
9569 sizeof (short),
9570 _("version symbol data"));
a6e9f9df
AM		 9571 if (!edata)
9572 {
9573 free (strtab);
0429c154 9574 free (symbols);
a6e9f9df
AM		 9575 break;
9576 }
252b5132 9577
3f5e193b 9578 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9579
9580 for (cnt = total; cnt --;)
b34976b6
AM		 9581 data[cnt] = byte_get (edata + cnt * sizeof (short),
9582 sizeof (short));
252b5132
RH		 9583
9584 free (edata);
9585
9586 for (cnt = 0; cnt < total; cnt += 4)
9587 {
9588 int j, nn;
00d93f34 9589 int check_def, check_need;
2cf0635d 9590 char * name;
252b5132
RH		 9591
9592 printf (" %03x:", cnt);
9593
9594 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9595 switch (data[cnt + j])
252b5132
RH		 9596 {
9597 case 0:
9598 fputs (_(" 0 (*local*) "), stdout);
9599 break;
9600
9601 case 1:
9602 fputs (_(" 1 (*global*) "), stdout);
9603 break;
9604
9605 default:
c244d050
NC		 9606 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9607 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9608
dd24e3da 9609 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9610 array, break to avoid an out-of-bounds read. */
9611 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9612 {
9613 warn (_("invalid index into symbol array\n"));
9614 break;
9615 }
9616
00d93f34
JJ		 9617 check_def = 1;
9618 check_need = 1;
4fbb74a6
AM		 9619 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9620 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9621 != SHT_NOBITS)
252b5132 9622 {
b34976b6 9623 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9624 check_def = 0;
9625 else
9626 check_need = 0;
252b5132 9627 }
00d93f34
JJ		 9628
9629 if (check_need
b34976b6 9630 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9631 {
b34976b6
AM		 9632 Elf_Internal_Verneed ivn;
9633 unsigned long offset;
252b5132 9634
d93f0186
NC		 9635 offset = offset_from_vma
9636 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9637 sizeof (Elf_External_Verneed));
252b5132 9638
b34976b6 9639 do
252b5132 9640 {
b34976b6
AM		 9641 Elf_Internal_Vernaux ivna;
9642 Elf_External_Verneed evn;
9643 Elf_External_Vernaux evna;
9644 unsigned long a_off;
252b5132 9645
59245841
NC		 9646 if (get_data (&evn, file, offset, sizeof (evn), 1,
9647 _("version need")) == NULL)
9648 break;
0b4362b0 9649
252b5132
RH		 9650 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9651 ivn.vn_next = BYTE_GET (evn.vn_next);
9652
9653 a_off = offset + ivn.vn_aux;
9654
9655 do
9656 {
59245841
NC		 9657 if (get_data (&evna, file, a_off, sizeof (evna),
9658 1, _("version need aux (2)")) == NULL)
9659 {
9660 ivna.vna_next = 0;
9661 ivna.vna_other = 0;
9662 }
9663 else
9664 {
9665 ivna.vna_next = BYTE_GET (evna.vna_next);
9666 ivna.vna_other = BYTE_GET (evna.vna_other);
9667 }
252b5132
RH		 9668
9669 a_off += ivna.vna_next;
9670 }
b34976b6 9671 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9672 && ivna.vna_next != 0);
9673
b34976b6 9674 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9675 {
9676 ivna.vna_name = BYTE_GET (evna.vna_name);
9677
54806181
AM		 9678 if (ivna.vna_name >= string_sec->sh_size)
9679 name = _("*invalid*");
9680 else
9681 name = strtab + ivna.vna_name;
252b5132 9682 nn += printf ("(%s%-*s",
16062207
ILT		 9683 name,
9684 12 - (int) strlen (name),
252b5132 9685 ")");
00d93f34 9686 check_def = 0;
252b5132
RH		 9687 break;
9688 }
9689
9690 offset += ivn.vn_next;
9691 }
9692 while (ivn.vn_next);
9693 }
00d93f34 9694
b34976b6
AM		 9695 if (check_def && data[cnt + j] != 0x8001
9696 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9697 {
b34976b6
AM		 9698 Elf_Internal_Verdef ivd;
9699 Elf_External_Verdef evd;
9700 unsigned long offset;
252b5132 9701
d93f0186
NC		 9702 offset = offset_from_vma
9703 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9704 sizeof evd);
252b5132
RH		 9705
9706 do
9707 {
59245841
NC		 9708 if (get_data (&evd, file, offset, sizeof (evd), 1,
9709 _("version def")) == NULL)
9710 {
9711 ivd.vd_next = 0;
3102e897
NC		 9712 /* PR 17531: file: 046-1082287-0.004. */
9713 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9714 break;
59245841
NC		 9715 }
9716 else
9717 {
9718 ivd.vd_next = BYTE_GET (evd.vd_next);
9719 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9720 }
252b5132
RH		 9721
9722 offset += ivd.vd_next;
9723 }
c244d050 9724 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9725 && ivd.vd_next != 0);
9726
c244d050 9727 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9728 {
b34976b6
AM		 9729 Elf_External_Verdaux evda;
9730 Elf_Internal_Verdaux ivda;
252b5132
RH		 9731
9732 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9733
59245841
NC		 9734 if (get_data (&evda, file,
9735 offset - ivd.vd_next + ivd.vd_aux,
9736 sizeof (evda), 1,
9737 _("version def aux")) == NULL)
9738 break;
252b5132
RH		 9739
9740 ivda.vda_name = BYTE_GET (evda.vda_name);
9741
54806181
AM		 9742 if (ivda.vda_name >= string_sec->sh_size)
9743 name = _("*invalid*");
9744 else
9745 name = strtab + ivda.vda_name;
252b5132 9746 nn += printf ("(%s%-*s",
16062207
ILT		 9747 name,
9748 12 - (int) strlen (name),
252b5132
RH		 9749 ")");
9750 }
9751 }
9752
9753 if (nn < 18)
9754 printf ("%*c", 18 - nn, ' ');
9755 }
9756
9757 putchar ('\n');
9758 }
9759
9760 free (data);
9761 free (strtab);
9762 free (symbols);
9763 }
9764 break;
103f02d3 9765
252b5132
RH		 9766 default:
9767 break;
9768 }
9769 }
9770
9771 if (! found)
9772 printf (_("\nNo version information found in this file.\n"));
9773
9774 return 1;
9775}
9776
d1133906 9777static const char *
d3ba0551 9778get_symbol_binding (unsigned int binding)
252b5132 9779{
b34976b6 9780 static char buff[32];
252b5132
RH		 9781
9782 switch (binding)
9783 {
b34976b6
AM		 9784 case STB_LOCAL: return "LOCAL";
9785 case STB_GLOBAL: return "GLOBAL";
9786 case STB_WEAK: return "WEAK";
252b5132
RH		 9787 default:
9788 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9789 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9790 binding);
252b5132 9791 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9792 {
9793 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9794 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9795 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9796 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9797 return "UNIQUE";
9798 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9799 }
252b5132 9800 else
e9e44622 9801 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9802 return buff;
9803 }
9804}
9805
d1133906 9806static const char *
d3ba0551 9807get_symbol_type (unsigned int type)
252b5132 9808{
b34976b6 9809 static char buff[32];
252b5132
RH		 9810
9811 switch (type)
9812 {
b34976b6
AM		 9813 case STT_NOTYPE: return "NOTYPE";
9814 case STT_OBJECT: return "OBJECT";
9815 case STT_FUNC: return "FUNC";
9816 case STT_SECTION: return "SECTION";
9817 case STT_FILE: return "FILE";
9818 case STT_COMMON: return "COMMON";
9819 case STT_TLS: return "TLS";
15ab5209
DB		 9820 case STT_RELC: return "RELC";
9821 case STT_SRELC: return "SRELC";
252b5132
RH		 9822 default:
9823 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9824 {
3510a7b8
NC		 9825 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9826 return "THUMB_FUNC";
103f02d3 9827
351b4b40 9828 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9829 return "REGISTER";
9830
9831 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9832 return "PARISC_MILLI";
9833
e9e44622 9834 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9835 }
252b5132 9836 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9837 {
9838 if (elf_header.e_machine == EM_PARISC)
9839 {
9840 if (type == STT_HP_OPAQUE)
9841 return "HP_OPAQUE";
9842 if (type == STT_HP_STUB)
9843 return "HP_STUB";
9844 }
9845
d8045f23 9846 if (type == STT_GNU_IFUNC
9c55345c 9847 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9848 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9849 /* GNU is still using the default value 0. */
d8045f23
NC		 9850 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9851 return "IFUNC";
9852
e9e44622 9853 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9854 }
252b5132 9855 else
e9e44622 9856 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9857 return buff;
9858 }
9859}
9860
d1133906 9861static const char *
d3ba0551 9862get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9863{
9864 switch (visibility)
9865 {
b34976b6
AM		 9866 case STV_DEFAULT: return "DEFAULT";
9867 case STV_INTERNAL: return "INTERNAL";
9868 case STV_HIDDEN: return "HIDDEN";
d1133906 9869 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 9870 default:
9871 error (_("Unrecognized visibility value: %u"), visibility);
9872 return _("<unknown>");
d1133906
NC		 9873 }
9874}
9875
5e2b0d47
NC		 9876static const char *
9877get_mips_symbol_other (unsigned int other)
9878{
9879 switch (other)
9880 {
df58fc94
RS		 9881 case STO_OPTIONAL:
9882 return "OPTIONAL";
9883 case STO_MIPS_PLT:
9884 return "MIPS PLT";
9885 case STO_MIPS_PIC:
9886 return "MIPS PIC";
9887 case STO_MICROMIPS:
9888 return "MICROMIPS";
9889 case STO_MICROMIPS | STO_MIPS_PIC:
9890 return "MICROMIPS, MIPS PIC";
9891 case STO_MIPS16:
9892 return "MIPS16";
9893 default:
9894 return NULL;
5e2b0d47
NC		 9895 }
9896}
9897
28f997cf
TG		 9898static const char *
9899get_ia64_symbol_other (unsigned int other)
9900{
9901 if (is_ia64_vms ())
9902 {
9903 static char res[32];
9904
9905 res[0] = 0;
9906
9907 /* Function types is for images and .STB files only. */
9908 switch (elf_header.e_type)
9909 {
9910 case ET_DYN:
9911 case ET_EXEC:
9912 switch (VMS_ST_FUNC_TYPE (other))
9913 {
9914 case VMS_SFT_CODE_ADDR:
9915 strcat (res, " CA");
9916 break;
9917 case VMS_SFT_SYMV_IDX:
9918 strcat (res, " VEC");
9919 break;
9920 case VMS_SFT_FD:
9921 strcat (res, " FD");
9922 break;
9923 case VMS_SFT_RESERVE:
9924 strcat (res, " RSV");
9925 break;
9926 default:
bee0ee85
NC		 9927 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9928 VMS_ST_FUNC_TYPE (other));
9929 strcat (res, " <unknown>");
9930 break;
28f997cf
TG		 9931 }
9932 break;
9933 default:
9934 break;
9935 }
9936 switch (VMS_ST_LINKAGE (other))
9937 {
9938 case VMS_STL_IGNORE:
9939 strcat (res, " IGN");
9940 break;
9941 case VMS_STL_RESERVE:
9942 strcat (res, " RSV");
9943 break;
9944 case VMS_STL_STD:
9945 strcat (res, " STD");
9946 break;
9947 case VMS_STL_LNK:
9948 strcat (res, " LNK");
9949 break;
9950 default:
bee0ee85
NC		 9951 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9952 VMS_ST_LINKAGE (other));
9953 strcat (res, " <unknown>");
9954 break;
28f997cf
TG		 9955 }
9956
9957 if (res[0] != 0)
9958 return res + 1;
9959 else
9960 return res;
9961 }
9962 return NULL;
9963}
9964
6911b7dc
AM		 9965static const char *
9966get_ppc64_symbol_other (unsigned int other)
9967{
9968 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9969 {
9970 static char buf[32];
9971 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9972 PPC64_LOCAL_ENTRY_OFFSET (other));
9973 return buf;
9974 }
9975 return NULL;
9976}
9977
5e2b0d47
NC		 9978static const char *
9979get_symbol_other (unsigned int other)
9980{
9981 const char * result = NULL;
9982 static char buff [32];
9983
9984 if (other == 0)
9985 return "";
9986
9987 switch (elf_header.e_machine)
9988 {
9989 case EM_MIPS:
9990 result = get_mips_symbol_other (other);
28f997cf
TG		 9991 break;
9992 case EM_IA_64:
9993 result = get_ia64_symbol_other (other);
9994 break;
6911b7dc
AM		 9995 case EM_PPC64:
9996 result = get_ppc64_symbol_other (other);
9997 break;
5e2b0d47
NC		 9998 default:
9999 break;
10000 }
10001
10002 if (result)
10003 return result;
10004
10005 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10006 return buff;
10007}
10008
d1133906 10009static const char *
d3ba0551 10010get_symbol_index_type (unsigned int type)
252b5132 10011{
b34976b6 10012 static char buff[32];
5cf1065c 10013
252b5132
RH		 10014 switch (type)
10015 {
b34976b6
AM		 10016 case SHN_UNDEF: return "UND";
10017 case SHN_ABS: return "ABS";
10018 case SHN_COMMON: return "COM";
252b5132 10019 default:
9ce701e2
L		 10020 if (type == SHN_IA_64_ANSI_COMMON
10021 && elf_header.e_machine == EM_IA_64
10022 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10023 return "ANSI_COM";
8a9036a4 10024 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10025 || elf_header.e_machine == EM_L1OM
10026 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10027 && type == SHN_X86_64_LCOMMON)
10028 return "LARGE_COM";
ac145307
BS		 10029 else if ((type == SHN_MIPS_SCOMMON
10030 && elf_header.e_machine == EM_MIPS)
10031 || (type == SHN_TIC6X_SCOMMON
10032 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10033 return "SCOM";
10034 else if (type == SHN_MIPS_SUNDEFINED
10035 && elf_header.e_machine == EM_MIPS)
10036 return "SUND";
9ce701e2 10037 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10038 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10039 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10040 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10041 else if (type >= SHN_LORESERVE)
10042 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10043 else if (type >= elf_header.e_shnum)
e0a31db1 10044 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10045 else
232e7cb8 10046 sprintf (buff, "%3d", type);
5cf1065c 10047 break;
252b5132 10048 }
5cf1065c
NC		 10049
10050 return buff;
252b5132
RH		 10051}
10052
66543521 10053static bfd_vma *
8b73c356 10054get_dynamic_data (FILE * file, size_t number, unsigned int ent_size)
252b5132 10055{
2cf0635d
NC		 10056 unsigned char * e_data;
10057 bfd_vma * i_data;
252b5132 10058
3102e897
NC		 10059 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10060 attempting to allocate memory when the read is bound to fail. */
10061 if (ent_size * number > current_file_size)
10062 {
10063 error (_("Invalid number of dynamic entries: %lu\n"),
10064 (unsigned long) number);
10065 return NULL;
10066 }
10067
3f5e193b 10068 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 10069 if (e_data == NULL)
10070 {
8b73c356
NC		 10071 error (_("Out of memory reading %lu dynamic entries\n"),
10072 (unsigned long) number);
252b5132
RH		 10073 return NULL;
10074 }
10075
66543521 10076 if (fread (e_data, ent_size, number, file) != number)
252b5132 10077 {
3102e897
NC		 10078 error (_("Unable to read in %lu bytes of dynamic data\n"),
10079 (unsigned long) (number * ent_size));
10080 free (e_data);
252b5132
RH		 10081 return NULL;
10082 }
10083
3f5e193b 10084 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 10085 if (i_data == NULL)
10086 {
8b73c356
NC		 10087 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10088 (unsigned long) number);
252b5132
RH		 10089 free (e_data);
10090 return NULL;
10091 }
10092
10093 while (number--)
66543521 10094 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10095
10096 free (e_data);
10097
10098 return i_data;
10099}
10100
6bd1a22c
L		 10101static void
10102print_dynamic_symbol (bfd_vma si, unsigned long hn)
10103{
2cf0635d 10104 Elf_Internal_Sym * psym;
6bd1a22c
L		 10105 int n;
10106
6bd1a22c
L		 10107 n = print_vma (si, DEC_5);
10108 if (n < 5)
0b4362b0 10109 fputs (&" "[n], stdout);
6bd1a22c 10110 printf (" %3lu: ", hn);
e0a31db1
NC		 10111
10112 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10113 {
3102e897
NC		 10114 printf (_("<No info available for dynamic symbol number %lu>\n"),
10115 (unsigned long) si);
e0a31db1
NC		 10116 return;
10117 }
10118
10119 psym = dynamic_symbols + si;
6bd1a22c
L		 10120 print_vma (psym->st_value, LONG_HEX);
10121 putchar (' ');
10122 print_vma (psym->st_size, DEC_5);
10123
f4be36b3
AM		 10124 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10125 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10126 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10127 /* Check to see if any other bits in the st_other field are set.
10128 Note - displaying this information disrupts the layout of the
10129 table being generated, but for the moment this case is very
10130 rare. */
10131 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10132 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10133 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10134 if (VALID_DYNAMIC_NAME (psym->st_name))
10135 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10136 else
2b692964 10137 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10138 putchar ('\n');
10139}
10140
bb4d2ac2
L		 10141static const char *
10142get_symbol_version_string (FILE *file, int is_dynsym,
10143 const char *strtab,
10144 unsigned long int strtab_size,
10145 unsigned int si, Elf_Internal_Sym *psym,
10146 enum versioned_symbol_info *sym_info,
10147 unsigned short *vna_other)
10148{
10149 const char *version_string = NULL;
10150
10151 if (is_dynsym
10152 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10153 {
10154 unsigned char data[2];
10155 unsigned short vers_data;
10156 unsigned long offset;
10157 int is_nobits;
10158 int check_def;
10159
10160 offset = offset_from_vma
10161 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10162 sizeof data + si * sizeof (vers_data));
10163
10164 if (get_data (&data, file, offset + si * sizeof (vers_data),
10165 sizeof (data), 1, _("version data")) == NULL)
10166 return NULL;
10167
10168 vers_data = byte_get (data, 2);
10169
53774b7e
NC		 10170 is_nobits = (section_headers != NULL
10171 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10172 && section_headers[psym->st_shndx].sh_type
10173 == SHT_NOBITS);
10174
10175 check_def = (psym->st_shndx != SHN_UNDEF);
10176
10177 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10178 {
10179 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10180 && (is_nobits || ! check_def))
10181 {
10182 Elf_External_Verneed evn;
10183 Elf_Internal_Verneed ivn;
10184 Elf_Internal_Vernaux ivna;
10185
10186 /* We must test both. */
10187 offset = offset_from_vma
10188 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10189 sizeof evn);
10190
10191 do
10192 {
10193 unsigned long vna_off;
10194
10195 if (get_data (&evn, file, offset, sizeof (evn), 1,
10196 _("version need")) == NULL)
10197 {
10198 ivna.vna_next = 0;
10199 ivna.vna_other = 0;
10200 ivna.vna_name = 0;
10201 break;
10202 }
10203
10204 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10205 ivn.vn_next = BYTE_GET (evn.vn_next);
10206
10207 vna_off = offset + ivn.vn_aux;
10208
10209 do
10210 {
10211 Elf_External_Vernaux evna;
10212
10213 if (get_data (&evna, file, vna_off,
10214 sizeof (evna), 1,
10215 _("version need aux (3)")) == NULL)
10216 {
10217 ivna.vna_next = 0;
10218 ivna.vna_other = 0;
10219 ivna.vna_name = 0;
10220 }
10221 else
10222 {
10223 ivna.vna_other = BYTE_GET (evna.vna_other);
10224 ivna.vna_next = BYTE_GET (evna.vna_next);
10225 ivna.vna_name = BYTE_GET (evna.vna_name);
10226 }
10227
10228 vna_off += ivna.vna_next;
10229 }
10230 while (ivna.vna_other != vers_data
10231 && ivna.vna_next != 0);
10232
10233 if (ivna.vna_other == vers_data)
10234 break;
10235
10236 offset += ivn.vn_next;
10237 }
10238 while (ivn.vn_next != 0);
10239
10240 if (ivna.vna_other == vers_data)
10241 {
10242 *sym_info = symbol_undefined;
10243 *vna_other = ivna.vna_other;
10244 version_string = (ivna.vna_name < strtab_size
10245 ? strtab + ivna.vna_name
10246 : _("<corrupt>"));
10247 check_def = 0;
10248 }
10249 else if (! is_nobits)
10250 error (_("bad dynamic symbol\n"));
10251 else
10252 check_def = 1;
10253 }
10254
10255 if (check_def)
10256 {
10257 if (vers_data != 0x8001
10258 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10259 {
10260 Elf_Internal_Verdef ivd;
10261 Elf_Internal_Verdaux ivda;
10262 Elf_External_Verdaux evda;
10263 unsigned long off;
10264
10265 off = offset_from_vma
10266 (file,
10267 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10268 sizeof (Elf_External_Verdef));
10269
10270 do
10271 {
10272 Elf_External_Verdef evd;
10273
10274 if (get_data (&evd, file, off, sizeof (evd),
10275 1, _("version def")) == NULL)
10276 {
10277 ivd.vd_ndx = 0;
10278 ivd.vd_aux = 0;
10279 ivd.vd_next = 0;
10280 }
10281 else
10282 {
10283 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10284 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10285 ivd.vd_next = BYTE_GET (evd.vd_next);
10286 }
10287
10288 off += ivd.vd_next;
10289 }
10290 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10291 && ivd.vd_next != 0);
10292
10293 off -= ivd.vd_next;
10294 off += ivd.vd_aux;
10295
10296 if (get_data (&evda, file, off, sizeof (evda),
10297 1, _("version def aux")) == NULL)
10298 return version_string;
10299
10300 ivda.vda_name = BYTE_GET (evda.vda_name);
10301
10302 if (psym->st_name != ivda.vda_name)
10303 {
10304 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10305 ? symbol_hidden : symbol_public);
10306 version_string = (ivda.vda_name < strtab_size
10307 ? strtab + ivda.vda_name
10308 : _("<corrupt>"));
10309 }
10310 }
10311 }
10312 }
10313 }
10314 return version_string;
10315}
10316
e3c8793a 10317/* Dump the symbol table. */
252b5132 10318static int
2cf0635d 10319process_symbol_table (FILE * file)
252b5132 10320{
2cf0635d 10321 Elf_Internal_Shdr * section;
8b73c356
NC		 10322 bfd_size_type nbuckets = 0;
10323 bfd_size_type nchains = 0;
2cf0635d
NC		 10324 bfd_vma * buckets = NULL;
10325 bfd_vma * chains = NULL;
fdc90cb4 10326 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10327 bfd_vma * gnubuckets = NULL;
10328 bfd_vma * gnuchains = NULL;
6bd1a22c 10329 bfd_vma gnusymidx = 0;
071436c6 10330 bfd_size_type ngnuchains = 0;
252b5132 10331
2c610e4b 10332 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10333 return 1;
10334
6bd1a22c
L		 10335 if (dynamic_info[DT_HASH]
10336 && (do_histogram
2c610e4b
L		 10337 || (do_using_dynamic
10338 && !do_dyn_syms
10339 && dynamic_strings != NULL)))
252b5132 10340 {
66543521
AM		 10341 unsigned char nb[8];
10342 unsigned char nc[8];
8b73c356 10343 unsigned int hash_ent_size = 4;
66543521
AM		 10344
10345 if ((elf_header.e_machine == EM_ALPHA
10346 || elf_header.e_machine == EM_S390
10347 || elf_header.e_machine == EM_S390_OLD)
10348 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10349 hash_ent_size = 8;
10350
fb52b2f4
NC		 10351 if (fseek (file,
10352 (archive_file_offset
10353 + offset_from_vma (file, dynamic_info[DT_HASH],
10354 sizeof nb + sizeof nc)),
d93f0186 10355 SEEK_SET))
252b5132 10356 {
591a748a 10357 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10358 goto no_hash;
252b5132
RH		 10359 }
10360
66543521 10361 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10362 {
10363 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10364 goto no_hash;
252b5132
RH		 10365 }
10366
66543521 10367 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10368 {
10369 error (_("Failed to read in number of chains\n"));
d3a44ec6 10370 goto no_hash;
252b5132
RH		 10371 }
10372
66543521
AM		 10373 nbuckets = byte_get (nb, hash_ent_size);
10374 nchains = byte_get (nc, hash_ent_size);
252b5132 10375
66543521
AM		 10376 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10377 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10378
d3a44ec6 10379 no_hash:
252b5132 10380 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10381 {
10382 if (do_using_dynamic)
10383 return 0;
10384 free (buckets);
10385 free (chains);
10386 buckets = NULL;
10387 chains = NULL;
10388 nbuckets = 0;
10389 nchains = 0;
10390 }
252b5132
RH		 10391 }
10392
6bd1a22c
L		 10393 if (dynamic_info_DT_GNU_HASH
10394 && (do_histogram
2c610e4b
L		 10395 || (do_using_dynamic
10396 && !do_dyn_syms
10397 && dynamic_strings != NULL)))
252b5132 10398 {
6bd1a22c
L		 10399 unsigned char nb[16];
10400 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10401 bfd_vma buckets_vma;
10402
10403 if (fseek (file,
10404 (archive_file_offset
10405 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10406 sizeof nb)),
10407 SEEK_SET))
10408 {
10409 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10410 goto no_gnu_hash;
6bd1a22c 10411 }
252b5132 10412
6bd1a22c
L		 10413 if (fread (nb, 16, 1, file) != 1)
10414 {
10415 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10416 goto no_gnu_hash;
6bd1a22c
L		 10417 }
10418
10419 ngnubuckets = byte_get (nb, 4);
10420 gnusymidx = byte_get (nb + 4, 4);
10421 bitmaskwords = byte_get (nb + 8, 4);
10422 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10423 if (is_32bit_elf)
6bd1a22c 10424 buckets_vma += bitmaskwords * 4;
f7a99963 10425 else
6bd1a22c 10426 buckets_vma += bitmaskwords * 8;
252b5132 10427
6bd1a22c
L		 10428 if (fseek (file,
10429 (archive_file_offset
10430 + offset_from_vma (file, buckets_vma, 4)),
10431 SEEK_SET))
252b5132 10432 {
6bd1a22c 10433 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10434 goto no_gnu_hash;
6bd1a22c
L		 10435 }
10436
10437 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10438
6bd1a22c 10439 if (gnubuckets == NULL)
d3a44ec6 10440 goto no_gnu_hash;
6bd1a22c
L		 10441
10442 for (i = 0; i < ngnubuckets; i++)
10443 if (gnubuckets[i] != 0)
10444 {
10445 if (gnubuckets[i] < gnusymidx)
10446 return 0;
10447
10448 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10449 maxchain = gnubuckets[i];
10450 }
10451
10452 if (maxchain == 0xffffffff)
d3a44ec6 10453 goto no_gnu_hash;
6bd1a22c
L		 10454
10455 maxchain -= gnusymidx;
10456
10457 if (fseek (file,
10458 (archive_file_offset
10459 + offset_from_vma (file, buckets_vma
10460 + 4 * (ngnubuckets + maxchain), 4)),
10461 SEEK_SET))
10462 {
10463 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10464 goto no_gnu_hash;
6bd1a22c
L		 10465 }
10466
10467 do
10468 {
10469 if (fread (nb, 4, 1, file) != 1)
252b5132 10470 {
6bd1a22c 10471 error (_("Failed to determine last chain length\n"));
d3a44ec6 10472 goto no_gnu_hash;
6bd1a22c 10473 }
252b5132 10474
6bd1a22c 10475 if (maxchain + 1 == 0)
d3a44ec6 10476 goto no_gnu_hash;
252b5132 10477
6bd1a22c
L		 10478 ++maxchain;
10479 }
10480 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10481
6bd1a22c
L		 10482 if (fseek (file,
10483 (archive_file_offset
10484 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10485 SEEK_SET))
10486 {
10487 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10488 goto no_gnu_hash;
6bd1a22c
L		 10489 }
10490
10491 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10492 ngnuchains = maxchain;
6bd1a22c 10493
d3a44ec6 10494 no_gnu_hash:
6bd1a22c 10495 if (gnuchains == NULL)
d3a44ec6
JJ		 10496 {
10497 free (gnubuckets);
d3a44ec6
JJ		 10498 gnubuckets = NULL;
10499 ngnubuckets = 0;
f64fddf1
NC		 10500 if (do_using_dynamic)
10501 return 0;
d3a44ec6 10502 }
6bd1a22c
L		 10503 }
10504
10505 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10506 && do_syms
10507 && do_using_dynamic
3102e897
NC		 10508 && dynamic_strings != NULL
10509 && dynamic_symbols != NULL)
6bd1a22c
L		 10510 {
10511 unsigned long hn;
10512
10513 if (dynamic_info[DT_HASH])
10514 {
10515 bfd_vma si;
10516
10517 printf (_("\nSymbol table for image:\n"));
10518 if (is_32bit_elf)
10519 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10520 else
10521 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10522
10523 for (hn = 0; hn < nbuckets; hn++)
10524 {
10525 if (! buckets[hn])
10526 continue;
10527
10528 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10529 print_dynamic_symbol (si, hn);
252b5132
RH		 10530 }
10531 }
6bd1a22c
L		 10532
10533 if (dynamic_info_DT_GNU_HASH)
10534 {
10535 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10536 if (is_32bit_elf)
10537 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10538 else
10539 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10540
10541 for (hn = 0; hn < ngnubuckets; ++hn)
10542 if (gnubuckets[hn] != 0)
10543 {
10544 bfd_vma si = gnubuckets[hn];
10545 bfd_vma off = si - gnusymidx;
10546
10547 do
10548 {
10549 print_dynamic_symbol (si, hn);
10550 si++;
10551 }
071436c6 10552 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10553 }
10554 }
252b5132 10555 }
8b73c356
NC		 10556 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10557 && section_headers != NULL)
252b5132 10558 {
b34976b6 10559 unsigned int i;
252b5132
RH		 10560
10561 for (i = 0, section = section_headers;
10562 i < elf_header.e_shnum;
10563 i++, section++)
10564 {
b34976b6 10565 unsigned int si;
2cf0635d 10566 char * strtab = NULL;
c256ffe7 10567 unsigned long int strtab_size = 0;
2cf0635d
NC		 10568 Elf_Internal_Sym * symtab;
10569 Elf_Internal_Sym * psym;
ba5cdace 10570 unsigned long num_syms;
252b5132 10571
2c610e4b
L		 10572 if ((section->sh_type != SHT_SYMTAB
10573 && section->sh_type != SHT_DYNSYM)
10574 || (!do_syms
10575 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10576 continue;
10577
dd24e3da
NC		 10578 if (section->sh_entsize == 0)
10579 {
10580 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10581 printable_section_name (section));
dd24e3da
NC		 10582 continue;
10583 }
10584
252b5132 10585 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10586 printable_section_name (section),
252b5132 10587 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10588
f7a99963 10589 if (is_32bit_elf)
ca47b30c 10590 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10591 else
ca47b30c 10592 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10593
ba5cdace 10594 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10595 if (symtab == NULL)
10596 continue;
10597
10598 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10599 {
10600 strtab = string_table;
10601 strtab_size = string_table_length;
10602 }
4fbb74a6 10603 else if (section->sh_link < elf_header.e_shnum)
252b5132 10604 {
2cf0635d 10605 Elf_Internal_Shdr * string_sec;
252b5132 10606
4fbb74a6 10607 string_sec = section_headers + section->sh_link;
252b5132 10608
3f5e193b
NC		 10609 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10610 1, string_sec->sh_size,
10611 _("string table"));
c256ffe7 10612 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10613 }
10614
ba5cdace 10615 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10616 {
bb4d2ac2
L		 10617 const char *version_string;
10618 enum versioned_symbol_info sym_info;
10619 unsigned short vna_other;
10620
5e220199 10621 printf ("%6d: ", si);
f7a99963
NC		 10622 print_vma (psym->st_value, LONG_HEX);
10623 putchar (' ');
10624 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10625 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10626 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10627 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10628 /* Check to see if any other bits in the st_other field are set.
10629 Note - displaying this information disrupts the layout of the
10630 table being generated, but for the moment this case is very rare. */
10631 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10632 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10633 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10634 print_symbol (25, psym->st_name < strtab_size
2b692964 10635 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10636
bb4d2ac2
L		 10637 version_string
10638 = get_symbol_version_string (file,
10639 section->sh_type == SHT_DYNSYM,
10640 strtab, strtab_size, si,
10641 psym, &sym_info, &vna_other);
10642 if (version_string)
252b5132 10643 {
bb4d2ac2
L		 10644 if (sym_info == symbol_undefined)
10645 printf ("@%s (%d)", version_string, vna_other);
10646 else
10647 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10648 version_string);
252b5132
RH		 10649 }
10650
10651 putchar ('\n');
10652 }
10653
10654 free (symtab);
10655 if (strtab != string_table)
10656 free (strtab);
10657 }
10658 }
10659 else if (do_syms)
10660 printf
10661 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10662
10663 if (do_histogram && buckets != NULL)
10664 {
2cf0635d
NC		 10665 unsigned long * lengths;
10666 unsigned long * counts;
66543521
AM		 10667 unsigned long hn;
10668 bfd_vma si;
10669 unsigned long maxlength = 0;
10670 unsigned long nzero_counts = 0;
10671 unsigned long nsyms = 0;
252b5132 10672
66543521
AM		 10673 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10674 (unsigned long) nbuckets);
252b5132 10675
3f5e193b 10676 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10677 if (lengths == NULL)
10678 {
8b73c356 10679 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10680 return 0;
10681 }
8b73c356
NC		 10682
10683 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10684 for (hn = 0; hn < nbuckets; ++hn)
10685 {
f7a99963 10686 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 10687 {
b34976b6 10688 ++nsyms;
252b5132 10689 if (maxlength < ++lengths[hn])
b34976b6 10690 ++maxlength;
049b0c3a
NC		 10691
10692 /* PR binutils/17531: A corrupt binary could contain broken
10693 histogram data. Do not go into an infinite loop trying
10694 to process it. */
10695 if (chains[si] == si)
10696 {
10697 error (_("histogram chain links to itself\n"));
10698 break;
10699 }
252b5132
RH		 10700 }
10701 }
10702
3f5e193b 10703 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10704 if (counts == NULL)
10705 {
b2e951ec 10706 free (lengths);
8b73c356 10707 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10708 return 0;
10709 }
10710
10711 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10712 ++counts[lengths[hn]];
252b5132 10713
103f02d3 10714 if (nbuckets > 0)
252b5132 10715 {
66543521
AM		 10716 unsigned long i;
10717 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10718 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10719 for (i = 1; i <= maxlength; ++i)
103f02d3 10720 {
66543521
AM		 10721 nzero_counts += counts[i] * i;
10722 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10723 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10724 (nzero_counts * 100.0) / nsyms);
10725 }
252b5132
RH		 10726 }
10727
10728 free (counts);
10729 free (lengths);
10730 }
10731
10732 if (buckets != NULL)
10733 {
10734 free (buckets);
10735 free (chains);
10736 }
10737
d3a44ec6 10738 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10739 {
2cf0635d
NC		 10740 unsigned long * lengths;
10741 unsigned long * counts;
fdc90cb4
JJ		 10742 unsigned long hn;
10743 unsigned long maxlength = 0;
10744 unsigned long nzero_counts = 0;
10745 unsigned long nsyms = 0;
fdc90cb4 10746
8b73c356
NC		 10747 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10748 (unsigned long) ngnubuckets);
10749
3f5e193b 10750 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10751 if (lengths == NULL)
10752 {
8b73c356 10753 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10754 return 0;
10755 }
10756
fdc90cb4
JJ		 10757 printf (_(" Length Number %% of total Coverage\n"));
10758
10759 for (hn = 0; hn < ngnubuckets; ++hn)
10760 if (gnubuckets[hn] != 0)
10761 {
10762 bfd_vma off, length = 1;
10763
6bd1a22c 10764 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10765 /* PR 17531 file: 010-77222-0.004. */
10766 off < ngnuchains && (gnuchains[off] & 1) == 0;
10767 ++off)
fdc90cb4
JJ		 10768 ++length;
10769 lengths[hn] = length;
10770 if (length > maxlength)
10771 maxlength = length;
10772 nsyms += length;
10773 }
10774
3f5e193b 10775 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10776 if (counts == NULL)
10777 {
b2e951ec 10778 free (lengths);
8b73c356 10779 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 10780 return 0;
10781 }
10782
10783 for (hn = 0; hn < ngnubuckets; ++hn)
10784 ++counts[lengths[hn]];
10785
10786 if (ngnubuckets > 0)
10787 {
10788 unsigned long j;
10789 printf (" 0 %-10lu (%5.1f%%)\n",
10790 counts[0], (counts[0] * 100.0) / ngnubuckets);
10791 for (j = 1; j <= maxlength; ++j)
10792 {
10793 nzero_counts += counts[j] * j;
10794 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10795 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10796 (nzero_counts * 100.0) / nsyms);
10797 }
10798 }
10799
10800 free (counts);
10801 free (lengths);
10802 free (gnubuckets);
10803 free (gnuchains);
10804 }
10805
252b5132
RH		 10806 return 1;
10807}
10808
10809static int
2cf0635d 10810process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10811{
b4c96d0d 10812 unsigned int i;
252b5132
RH		 10813
10814 if (dynamic_syminfo == NULL
10815 || !do_dynamic)
10816 /* No syminfo, this is ok. */
10817 return 1;
10818
10819 /* There better should be a dynamic symbol section. */
10820 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10821 return 0;
10822
10823 if (dynamic_addr)
10824 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10825 dynamic_syminfo_offset, dynamic_syminfo_nent);
10826
10827 printf (_(" Num: Name BoundTo Flags\n"));
10828 for (i = 0; i < dynamic_syminfo_nent; ++i)
10829 {
10830 unsigned short int flags = dynamic_syminfo[i].si_flags;
10831
31104126 10832 printf ("%4d: ", i);
4082ef84
NC		 10833 if (i >= num_dynamic_syms)
10834 printf (_("<corrupt index>"));
10835 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 10836 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10837 else
2b692964 10838 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10839 putchar (' ');
252b5132
RH		 10840
10841 switch (dynamic_syminfo[i].si_boundto)
10842 {
10843 case SYMINFO_BT_SELF:
10844 fputs ("SELF ", stdout);
10845 break;
10846 case SYMINFO_BT_PARENT:
10847 fputs ("PARENT ", stdout);
10848 break;
10849 default:
10850 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10851 && dynamic_syminfo[i].si_boundto < dynamic_nent
10852 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10853 {
d79b3d50 10854 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10855 putchar (' ' );
10856 }
252b5132
RH		 10857 else
10858 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10859 break;
10860 }
10861
10862 if (flags & SYMINFO_FLG_DIRECT)
10863 printf (" DIRECT");
10864 if (flags & SYMINFO_FLG_PASSTHRU)
10865 printf (" PASSTHRU");
10866 if (flags & SYMINFO_FLG_COPY)
10867 printf (" COPY");
10868 if (flags & SYMINFO_FLG_LAZYLOAD)
10869 printf (" LAZYLOAD");
10870
10871 puts ("");
10872 }
10873
10874 return 1;
10875}
10876
cf13d699
NC		 10877/* Check to see if the given reloc needs to be handled in a target specific
10878 manner. If so then process the reloc and return TRUE otherwise return
10879 FALSE. */
09c11c86 10880
cf13d699
NC		 10881static bfd_boolean
10882target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10883 unsigned char * start,
10884 Elf_Internal_Sym * symtab)
252b5132 10885{
cf13d699 10886 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 10887
cf13d699 10888 switch (elf_header.e_machine)
252b5132 10889 {
13761a11
NC		 10890 case EM_MSP430:
10891 case EM_MSP430_OLD:
10892 {
10893 static Elf_Internal_Sym * saved_sym = NULL;
10894
10895 switch (reloc_type)
10896 {
10897 case 10: /* R_MSP430_SYM_DIFF */
10898 if (uses_msp430x_relocs ())
10899 break;
10900 case 21: /* R_MSP430X_SYM_DIFF */
10901 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10902 return TRUE;
10903
10904 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10905 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10906 goto handle_sym_diff;
0b4362b0 10907
13761a11
NC		 10908 case 5: /* R_MSP430_16_BYTE */
10909 case 9: /* R_MSP430_8 */
10910 if (uses_msp430x_relocs ())
10911 break;
10912 goto handle_sym_diff;
10913
10914 case 2: /* R_MSP430_ABS16 */
10915 case 15: /* R_MSP430X_ABS16 */
10916 if (! uses_msp430x_relocs ())
10917 break;
10918 goto handle_sym_diff;
0b4362b0 10919
13761a11
NC		 10920 handle_sym_diff:
10921 if (saved_sym != NULL)
10922 {
10923 bfd_vma value;
10924
10925 value = reloc->r_addend
10926 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10927 - saved_sym->st_value);
10928
10929 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10930
10931 saved_sym = NULL;
10932 return TRUE;
10933 }
10934 break;
10935
10936 default:
10937 if (saved_sym != NULL)
071436c6 10938 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 10939 break;
10940 }
10941 break;
10942 }
10943
cf13d699
NC		 10944 case EM_MN10300:
10945 case EM_CYGNUS_MN10300:
10946 {
10947 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 10948
cf13d699
NC		 10949 switch (reloc_type)
10950 {
10951 case 34: /* R_MN10300_ALIGN */
10952 return TRUE;
10953 case 33: /* R_MN10300_SYM_DIFF */
10954 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10955 return TRUE;
10956 case 1: /* R_MN10300_32 */
10957 case 2: /* R_MN10300_16 */
10958 if (saved_sym != NULL)
10959 {
10960 bfd_vma value;
252b5132 10961
cf13d699
NC		 10962 value = reloc->r_addend
10963 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10964 - saved_sym->st_value);
252b5132 10965
cf13d699 10966 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 10967
cf13d699
NC		 10968 saved_sym = NULL;
10969 return TRUE;
10970 }
10971 break;
10972 default:
10973 if (saved_sym != NULL)
071436c6 10974 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 10975 break;
10976 }
10977 break;
10978 }
252b5132
RH		 10979 }
10980
cf13d699 10981 return FALSE;
252b5132
RH		 10982}
10983
aca88567
NC		 10984/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10985 DWARF debug sections. This is a target specific test. Note - we do not
10986 go through the whole including-target-headers-multiple-times route, (as
10987 we have already done with <elf/h8.h>) because this would become very
10988 messy and even then this function would have to contain target specific
10989 information (the names of the relocs instead of their numeric values).
10990 FIXME: This is not the correct way to solve this problem. The proper way
10991 is to have target specific reloc sizing and typing functions created by
10992 the reloc-macros.h header, in the same way that it already creates the
10993 reloc naming functions. */
10994
10995static bfd_boolean
10996is_32bit_abs_reloc (unsigned int reloc_type)
10997{
10998 switch (elf_header.e_machine)
10999 {
41e92641
NC		 11000 case EM_386:
11001 case EM_486:
11002 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11003 case EM_68K:
11004 return reloc_type == 1; /* R_68K_32. */
11005 case EM_860:
11006 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11007 case EM_960:
11008 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11009 case EM_AARCH64:
11010 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11011 case EM_ALPHA:
137b6b5f 11012 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11013 case EM_ARC:
11014 return reloc_type == 1; /* R_ARC_32. */
11015 case EM_ARM:
11016 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11017 case EM_AVR_OLD:
aca88567
NC		 11018 case EM_AVR:
11019 return reloc_type == 1;
cfb8c092
NC		 11020 case EM_ADAPTEVA_EPIPHANY:
11021 return reloc_type == 3;
aca88567
NC		 11022 case EM_BLACKFIN:
11023 return reloc_type == 0x12; /* R_byte4_data. */
11024 case EM_CRIS:
11025 return reloc_type == 3; /* R_CRIS_32. */
11026 case EM_CR16:
11027 return reloc_type == 3; /* R_CR16_NUM32. */
11028 case EM_CRX:
11029 return reloc_type == 15; /* R_CRX_NUM32. */
11030 case EM_CYGNUS_FRV:
11031 return reloc_type == 1;
41e92641
NC		 11032 case EM_CYGNUS_D10V:
11033 case EM_D10V:
11034 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11035 case EM_CYGNUS_D30V:
11036 case EM_D30V:
11037 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11038 case EM_DLX:
11039 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11040 case EM_CYGNUS_FR30:
11041 case EM_FR30:
11042 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11043 case EM_FT32:
11044 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11045 case EM_H8S:
11046 case EM_H8_300:
11047 case EM_H8_300H:
11048 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 11049 case EM_IA_64:
11050 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 11051 case EM_IP2K_OLD:
11052 case EM_IP2K:
11053 return reloc_type == 2; /* R_IP2K_32. */
11054 case EM_IQ2000:
11055 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11056 case EM_LATTICEMICO32:
11057 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11058 case EM_M32C_OLD:
aca88567
NC		 11059 case EM_M32C:
11060 return reloc_type == 3; /* R_M32C_32. */
11061 case EM_M32R:
11062 return reloc_type == 34; /* R_M32R_32_RELA. */
11063 case EM_MCORE:
11064 return reloc_type == 1; /* R_MCORE_ADDR32. */
11065 case EM_CYGNUS_MEP:
11066 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11067 case EM_METAG:
11068 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11069 case EM_MICROBLAZE:
11070 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11071 case EM_MIPS:
11072 return reloc_type == 2; /* R_MIPS_32. */
11073 case EM_MMIX:
11074 return reloc_type == 4; /* R_MMIX_32. */
11075 case EM_CYGNUS_MN10200:
11076 case EM_MN10200:
11077 return reloc_type == 1; /* R_MN10200_32. */
11078 case EM_CYGNUS_MN10300:
11079 case EM_MN10300:
11080 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11081 case EM_MOXIE:
11082 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11083 case EM_MSP430_OLD:
11084 case EM_MSP430:
13761a11 11085 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11086 case EM_MT:
11087 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11088 case EM_NDS32:
11089 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11090 case EM_ALTERA_NIOS2:
36591ba1 11091 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11092 case EM_NIOS32:
11093 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11094 case EM_OR1K:
11095 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11096 case EM_PARISC:
5fda8eca
NC		 11097 return (reloc_type == 1 /* R_PARISC_DIR32. */
11098 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11099 case EM_PJ:
11100 case EM_PJ_OLD:
11101 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11102 case EM_PPC64:
11103 return reloc_type == 1; /* R_PPC64_ADDR32. */
11104 case EM_PPC:
11105 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11106 case EM_RL78:
11107 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11108 case EM_RX:
11109 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11110 case EM_S370:
11111 return reloc_type == 1; /* R_I370_ADDR31. */
11112 case EM_S390_OLD:
11113 case EM_S390:
11114 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11115 case EM_SCORE:
11116 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11117 case EM_SH:
11118 return reloc_type == 1; /* R_SH_DIR32. */
11119 case EM_SPARC32PLUS:
11120 case EM_SPARCV9:
11121 case EM_SPARC:
11122 return reloc_type == 3 /* R_SPARC_32. */
11123 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11124 case EM_SPU:
11125 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11126 case EM_TI_C6000:
11127 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11128 case EM_TILEGX:
11129 return reloc_type == 2; /* R_TILEGX_32. */
11130 case EM_TILEPRO:
11131 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11132 case EM_CYGNUS_V850:
11133 case EM_V850:
11134 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11135 case EM_V800:
11136 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11137 case EM_VAX:
11138 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11139 case EM_VISIUM:
11140 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11141 case EM_X86_64:
8a9036a4 11142 case EM_L1OM:
7a9068fe 11143 case EM_K1OM:
aca88567 11144 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11145 case EM_XC16X:
11146 case EM_C166:
11147 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11148 case EM_XGATE:
11149 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11150 case EM_XSTORMY16:
11151 return reloc_type == 1; /* R_XSTROMY16_32. */
11152 case EM_XTENSA_OLD:
11153 case EM_XTENSA:
11154 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11155 default:
bee0ee85
NC		 11156 {
11157 static unsigned int prev_warn = 0;
11158
11159 /* Avoid repeating the same warning multiple times. */
11160 if (prev_warn != elf_header.e_machine)
11161 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11162 elf_header.e_machine);
11163 prev_warn = elf_header.e_machine;
11164 return FALSE;
11165 }
aca88567
NC		 11166 }
11167}
11168
11169/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11170 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11171
11172static bfd_boolean
11173is_32bit_pcrel_reloc (unsigned int reloc_type)
11174{
11175 switch (elf_header.e_machine)
11176 {
41e92641
NC		 11177 case EM_386:
11178 case EM_486:
3e0873ac 11179 return reloc_type == 2; /* R_386_PC32. */
aca88567 11180 case EM_68K:
3e0873ac 11181 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11182 case EM_AARCH64:
11183 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11184 case EM_ADAPTEVA_EPIPHANY:
11185 return reloc_type == 6;
aca88567
NC		 11186 case EM_ALPHA:
11187 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11188 case EM_ARM:
3e0873ac 11189 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11190 case EM_MICROBLAZE:
11191 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11192 case EM_OR1K:
11193 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11194 case EM_PARISC:
85acf597 11195 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11196 case EM_PPC:
11197 return reloc_type == 26; /* R_PPC_REL32. */
11198 case EM_PPC64:
3e0873ac 11199 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11200 case EM_S390_OLD:
11201 case EM_S390:
3e0873ac 11202 return reloc_type == 5; /* R_390_PC32. */
aca88567 11203 case EM_SH:
3e0873ac 11204 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11205 case EM_SPARC32PLUS:
11206 case EM_SPARCV9:
11207 case EM_SPARC:
3e0873ac 11208 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11209 case EM_SPU:
11210 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11211 case EM_TILEGX:
11212 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11213 case EM_TILEPRO:
11214 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11215 case EM_VISIUM:
11216 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11217 case EM_X86_64:
8a9036a4 11218 case EM_L1OM:
7a9068fe 11219 case EM_K1OM:
3e0873ac 11220 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11221 case EM_XTENSA_OLD:
11222 case EM_XTENSA:
11223 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11224 default:
11225 /* Do not abort or issue an error message here. Not all targets use
11226 pc-relative 32-bit relocs in their DWARF debug information and we
11227 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11228 more helpful warning message will be generated by apply_relocations
11229 anyway, so just return. */
aca88567
NC		 11230 return FALSE;
11231 }
11232}
11233
11234/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11235 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11236
11237static bfd_boolean
11238is_64bit_abs_reloc (unsigned int reloc_type)
11239{
11240 switch (elf_header.e_machine)
11241 {
a06ea964
NC		 11242 case EM_AARCH64:
11243 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11244 case EM_ALPHA:
11245 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11246 case EM_IA_64:
11247 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11248 case EM_PARISC:
11249 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11250 case EM_PPC64:
11251 return reloc_type == 38; /* R_PPC64_ADDR64. */
11252 case EM_SPARC32PLUS:
11253 case EM_SPARCV9:
11254 case EM_SPARC:
11255 return reloc_type == 54; /* R_SPARC_UA64. */
11256 case EM_X86_64:
8a9036a4 11257 case EM_L1OM:
7a9068fe 11258 case EM_K1OM:
aca88567 11259 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11260 case EM_S390_OLD:
11261 case EM_S390:
aa137e4d
NC		 11262 return reloc_type == 22; /* R_S390_64. */
11263 case EM_TILEGX:
11264 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11265 case EM_MIPS:
aa137e4d 11266 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11267 default:
11268 return FALSE;
11269 }
11270}
11271
85acf597
RH		 11272/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11273 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11274
11275static bfd_boolean
11276is_64bit_pcrel_reloc (unsigned int reloc_type)
11277{
11278 switch (elf_header.e_machine)
11279 {
a06ea964
NC		 11280 case EM_AARCH64:
11281 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11282 case EM_ALPHA:
aa137e4d 11283 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11284 case EM_IA_64:
aa137e4d 11285 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11286 case EM_PARISC:
aa137e4d 11287 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11288 case EM_PPC64:
aa137e4d 11289 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11290 case EM_SPARC32PLUS:
11291 case EM_SPARCV9:
11292 case EM_SPARC:
aa137e4d 11293 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11294 case EM_X86_64:
8a9036a4 11295 case EM_L1OM:
7a9068fe 11296 case EM_K1OM:
aa137e4d 11297 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11298 case EM_S390_OLD:
11299 case EM_S390:
aa137e4d
NC		 11300 return reloc_type == 23; /* R_S390_PC64. */
11301 case EM_TILEGX:
11302 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11303 default:
11304 return FALSE;
11305 }
11306}
11307
4dc3c23d
AM		 11308/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11309 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11310
11311static bfd_boolean
11312is_24bit_abs_reloc (unsigned int reloc_type)
11313{
11314 switch (elf_header.e_machine)
11315 {
11316 case EM_CYGNUS_MN10200:
11317 case EM_MN10200:
11318 return reloc_type == 4; /* R_MN10200_24. */
11319 default:
11320 return FALSE;
11321 }
11322}
11323
aca88567
NC		 11324/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11325 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11326
11327static bfd_boolean
11328is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11329{
11330 switch (elf_header.e_machine)
11331 {
aca88567
NC		 11332 case EM_AVR_OLD:
11333 case EM_AVR:
11334 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11335 case EM_ADAPTEVA_EPIPHANY:
11336 return reloc_type == 5;
41e92641
NC		 11337 case EM_CYGNUS_D10V:
11338 case EM_D10V:
11339 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11340 case EM_H8S:
11341 case EM_H8_300:
11342 case EM_H8_300H:
aca88567
NC		 11343 return reloc_type == R_H8_DIR16;
11344 case EM_IP2K_OLD:
11345 case EM_IP2K:
11346 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11347 case EM_M32C_OLD:
f4236fe4
DD		 11348 case EM_M32C:
11349 return reloc_type == 1; /* R_M32C_16 */
aca88567 11350 case EM_MSP430:
13761a11
NC		 11351 if (uses_msp430x_relocs ())
11352 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11353 case EM_MSP430_OLD:
aca88567 11354 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11355 case EM_NDS32:
11356 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11357 case EM_ALTERA_NIOS2:
36591ba1 11358 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11359 case EM_NIOS32:
11360 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11361 case EM_OR1K:
11362 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11363 case EM_TI_C6000:
11364 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11365 case EM_XC16X:
11366 case EM_C166:
11367 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11368 case EM_CYGNUS_MN10200:
11369 case EM_MN10200:
11370 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11371 case EM_CYGNUS_MN10300:
11372 case EM_MN10300:
11373 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11374 case EM_VISIUM:
11375 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11376 case EM_XGATE:
11377 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11378 default:
aca88567 11379 return FALSE;
4b78141a
NC		 11380 }
11381}
11382
2a7b2e88
JK		 11383/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11384 relocation entries (possibly formerly used for SHT_GROUP sections). */
11385
11386static bfd_boolean
11387is_none_reloc (unsigned int reloc_type)
11388{
11389 switch (elf_header.e_machine)
11390 {
cb8f3167
NC		 11391 case EM_68K: /* R_68K_NONE. */
11392 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11393 case EM_SPARC32PLUS:
11394 case EM_SPARCV9:
cb8f3167
NC		 11395 case EM_SPARC: /* R_SPARC_NONE. */
11396 case EM_MIPS: /* R_MIPS_NONE. */
11397 case EM_PARISC: /* R_PARISC_NONE. */
11398 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11399 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11400 case EM_PPC: /* R_PPC_NONE. */
11401 case EM_PPC64: /* R_PPC64_NONE. */
11402 case EM_ARM: /* R_ARM_NONE. */
11403 case EM_IA_64: /* R_IA64_NONE. */
11404 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11405 case EM_S390_OLD:
cb8f3167
NC		 11406 case EM_S390: /* R_390_NONE. */
11407 case EM_CRIS: /* R_CRIS_NONE. */
11408 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11409 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11410 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11411 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11412 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11413 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11414 case EM_M32R: /* R_M32R_NONE. */
40b36596 11415 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11416 case EM_TILEGX: /* R_TILEGX_NONE. */
11417 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11418 case EM_XC16X:
11419 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11420 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11421 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11422 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11423 return reloc_type == 0;
a06ea964
NC		 11424 case EM_AARCH64:
11425 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11426 case EM_NDS32:
11427 return (reloc_type == 0 /* R_XTENSA_NONE. */
11428 || reloc_type == 204 /* R_NDS32_DIFF8. */
11429 || reloc_type == 205 /* R_NDS32_DIFF16. */
11430 || reloc_type == 206 /* R_NDS32_DIFF32. */
11431 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11432 case EM_XTENSA_OLD:
11433 case EM_XTENSA:
4dc3c23d
AM		 11434 return (reloc_type == 0 /* R_XTENSA_NONE. */
11435 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11436 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11437 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11438 case EM_METAG:
11439 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11440 }
11441 return FALSE;
11442}
11443
cf13d699
NC		 11444/* Apply relocations to a section.
11445 Note: So far support has been added only for those relocations
11446 which can be found in debug sections.
11447 FIXME: Add support for more relocations ? */
1b315056 11448
cf13d699
NC		 11449static void
11450apply_relocations (void * file,
11451 Elf_Internal_Shdr * section,
11452 unsigned char * start)
1b315056 11453{
cf13d699
NC		 11454 Elf_Internal_Shdr * relsec;
11455 unsigned char * end = start + section->sh_size;
cb8f3167 11456
cf13d699
NC		 11457 if (elf_header.e_type != ET_REL)
11458 return;
1b315056 11459
cf13d699 11460 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11461 for (relsec = section_headers;
11462 relsec < section_headers + elf_header.e_shnum;
11463 ++relsec)
252b5132 11464 {
41e92641
NC		 11465 bfd_boolean is_rela;
11466 unsigned long num_relocs;
2cf0635d
NC		 11467 Elf_Internal_Rela * relocs;
11468 Elf_Internal_Rela * rp;
11469 Elf_Internal_Shdr * symsec;
11470 Elf_Internal_Sym * symtab;
ba5cdace 11471 unsigned long num_syms;
2cf0635d 11472 Elf_Internal_Sym * sym;
252b5132 11473
41e92641 11474 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11475 || relsec->sh_info >= elf_header.e_shnum
11476 || section_headers + relsec->sh_info != section
c256ffe7 11477 || relsec->sh_size == 0
4fbb74a6 11478 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11479 continue;
428409d5 11480
41e92641
NC		 11481 is_rela = relsec->sh_type == SHT_RELA;
11482
11483 if (is_rela)
11484 {
3f5e193b
NC		 11485 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11486 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11487 return;
11488 }
11489 else
11490 {
3f5e193b
NC		 11491 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11492 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11493 return;
11494 }
11495
11496 /* SH uses RELA but uses in place value instead of the addend field. */
11497 if (elf_header.e_machine == EM_SH)
11498 is_rela = FALSE;
428409d5 11499
4fbb74a6 11500 symsec = section_headers + relsec->sh_link;
ba5cdace 11501 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11502
41e92641 11503 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11504 {
41e92641
NC		 11505 bfd_vma addend;
11506 unsigned int reloc_type;
11507 unsigned int reloc_size;
91d6fa6a 11508 unsigned char * rloc;
ba5cdace 11509 unsigned long sym_index;
4b78141a 11510
aca88567 11511 reloc_type = get_reloc_type (rp->r_info);
41e92641 11512
98fb390a 11513 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11514 continue;
98fb390a
NC		 11515 else if (is_none_reloc (reloc_type))
11516 continue;
11517 else if (is_32bit_abs_reloc (reloc_type)
11518 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11519 reloc_size = 4;
85acf597
RH		 11520 else if (is_64bit_abs_reloc (reloc_type)
11521 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11522 reloc_size = 8;
4dc3c23d
AM		 11523 else if (is_24bit_abs_reloc (reloc_type))
11524 reloc_size = 3;
aca88567
NC		 11525 else if (is_16bit_abs_reloc (reloc_type))
11526 reloc_size = 2;
11527 else
4b78141a 11528 {
bee0ee85
NC		 11529 static unsigned int prev_reloc = 0;
11530 if (reloc_type != prev_reloc)
11531 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11532 reloc_type, printable_section_name (section));
11533 prev_reloc = reloc_type;
4b78141a
NC		 11534 continue;
11535 }
103f02d3 11536
91d6fa6a 11537 rloc = start + rp->r_offset;
c8da6823 11538 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11539 {
11540 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11541 (unsigned long) rp->r_offset,
74e1a04b 11542 printable_section_name (section));
700dd8b7
L		 11543 continue;
11544 }
103f02d3 11545
ba5cdace
NC		 11546 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11547 if (sym_index >= num_syms)
11548 {
11549 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11550 sym_index, printable_section_name (section));
ba5cdace
NC		 11551 continue;
11552 }
11553 sym = symtab + sym_index;
41e92641
NC		 11554
11555 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11556 make sure that it is of an appropriate type.
11557
11558 Relocations against symbols without type can happen.
11559 Gcc -feliminate-dwarf2-dups may generate symbols
11560 without type for debug info.
11561
11562 Icc generates relocations against function symbols
11563 instead of local labels.
11564
11565 Relocations against object symbols can happen, eg when
11566 referencing a global array. For an example of this see
11567 the _clz.o binary in libgcc.a. */
aca88567 11568 if (sym != symtab
55f25fc3 11569 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11570 {
41e92641 11571 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11572 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11573 (long int)(rp - relocs),
74e1a04b 11574 printable_section_name (relsec));
aca88567 11575 continue;
5b18a4bc 11576 }
252b5132 11577
4dc3c23d
AM		 11578 addend = 0;
11579 if (is_rela)
11580 addend += rp->r_addend;
c47320c3
AM		 11581 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11582 partial_inplace. */
4dc3c23d
AM		 11583 if (!is_rela
11584 || (elf_header.e_machine == EM_XTENSA
11585 && reloc_type == 1)
11586 || ((elf_header.e_machine == EM_PJ
11587 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11588 && reloc_type == 1)
11589 || ((elf_header.e_machine == EM_D30V
11590 || elf_header.e_machine == EM_CYGNUS_D30V)
11591 && reloc_type == 12))
91d6fa6a 11592 addend += byte_get (rloc, reloc_size);
cb8f3167 11593
85acf597
RH		 11594 if (is_32bit_pcrel_reloc (reloc_type)
11595 || is_64bit_pcrel_reloc (reloc_type))
11596 {
11597 /* On HPPA, all pc-relative relocations are biased by 8. */
11598 if (elf_header.e_machine == EM_PARISC)
11599 addend -= 8;
91d6fa6a 11600 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11601 reloc_size);
11602 }
41e92641 11603 else
91d6fa6a 11604 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11605 }
252b5132 11606
5b18a4bc 11607 free (symtab);
41e92641 11608 free (relocs);
5b18a4bc
NC		 11609 break;
11610 }
5b18a4bc 11611}
103f02d3 11612
cf13d699
NC		 11613#ifdef SUPPORT_DISASSEMBLY
11614static int
11615disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11616{
74e1a04b 11617 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11618
74e1a04b 11619 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11620
11621 return 1;
11622}
11623#endif
11624
11625/* Reads in the contents of SECTION from FILE, returning a pointer
11626 to a malloc'ed buffer or NULL if something went wrong. */
11627
11628static char *
11629get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11630{
11631 bfd_size_type num_bytes;
11632
11633 num_bytes = section->sh_size;
11634
11635 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11636 {
11637 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11638 printable_section_name (section));
cf13d699
NC		 11639 return NULL;
11640 }
11641
3f5e193b
NC		 11642 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11643 _("section contents"));
cf13d699
NC		 11644}
11645
dd24e3da 11646
cf13d699
NC		 11647static void
11648dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11649{
11650 Elf_Internal_Shdr * relsec;
11651 bfd_size_type num_bytes;
cf13d699
NC		 11652 char * data;
11653 char * end;
11654 char * start;
cf13d699
NC		 11655 bfd_boolean some_strings_shown;
11656
11657 start = get_section_contents (section, file);
11658 if (start == NULL)
11659 return;
11660
74e1a04b 11661 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11662
11663 /* If the section being dumped has relocations against it the user might
11664 be expecting these relocations to have been applied. Check for this
11665 case and issue a warning message in order to avoid confusion.
11666 FIXME: Maybe we ought to have an option that dumps a section with
11667 relocs applied ? */
11668 for (relsec = section_headers;
11669 relsec < section_headers + elf_header.e_shnum;
11670 ++relsec)
11671 {
11672 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11673 || relsec->sh_info >= elf_header.e_shnum
11674 || section_headers + relsec->sh_info != section
11675 || relsec->sh_size == 0
11676 || relsec->sh_link >= elf_header.e_shnum)
11677 continue;
11678
11679 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11680 break;
11681 }
11682
11683 num_bytes = section->sh_size;
cf13d699
NC		 11684 data = start;
11685 end = start + num_bytes;
11686 some_strings_shown = FALSE;
11687
11688 while (data < end)
11689 {
11690 while (!ISPRINT (* data))
11691 if (++ data >= end)
11692 break;
11693
11694 if (data < end)
11695 {
071436c6
NC		 11696 size_t maxlen = end - data;
11697
cf13d699 11698#ifndef __MSVCRT__
c975cc98
NC		 11699 /* PR 11128: Use two separate invocations in order to work
11700 around bugs in the Solaris 8 implementation of printf. */
11701 printf (" [%6tx] ", data - start);
cf13d699 11702#else
071436c6 11703 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 11704#endif
4082ef84
NC		 11705 if (maxlen > 0)
11706 {
11707 print_symbol ((int) maxlen, data);
11708 putchar ('\n');
11709 data += strnlen (data, maxlen);
11710 }
11711 else
11712 {
11713 printf (_("<corrupt>\n"));
11714 data = end;
11715 }
cf13d699
NC		 11716 some_strings_shown = TRUE;
11717 }
11718 }
11719
11720 if (! some_strings_shown)
11721 printf (_(" No strings found in this section."));
11722
11723 free (start);
11724
11725 putchar ('\n');
11726}
11727
11728static void
11729dump_section_as_bytes (Elf_Internal_Shdr * section,
11730 FILE * file,
11731 bfd_boolean relocate)
11732{
11733 Elf_Internal_Shdr * relsec;
11734 bfd_size_type bytes;
11735 bfd_vma addr;
11736 unsigned char * data;
11737 unsigned char * start;
11738
11739 start = (unsigned char *) get_section_contents (section, file);
11740 if (start == NULL)
11741 return;
11742
74e1a04b 11743 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11744
11745 if (relocate)
11746 {
11747 apply_relocations (file, section, start);
11748 }
11749 else
11750 {
11751 /* If the section being dumped has relocations against it the user might
11752 be expecting these relocations to have been applied. Check for this
11753 case and issue a warning message in order to avoid confusion.
11754 FIXME: Maybe we ought to have an option that dumps a section with
11755 relocs applied ? */
11756 for (relsec = section_headers;
11757 relsec < section_headers + elf_header.e_shnum;
11758 ++relsec)
11759 {
11760 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11761 || relsec->sh_info >= elf_header.e_shnum
11762 || section_headers + relsec->sh_info != section
11763 || relsec->sh_size == 0
11764 || relsec->sh_link >= elf_header.e_shnum)
11765 continue;
11766
11767 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11768 break;
11769 }
11770 }
11771
11772 addr = section->sh_addr;
11773 bytes = section->sh_size;
11774 data = start;
11775
11776 while (bytes)
11777 {
11778 int j;
11779 int k;
11780 int lbytes;
11781
11782 lbytes = (bytes > 16 ? 16 : bytes);
11783
11784 printf (" 0x%8.8lx ", (unsigned long) addr);
11785
11786 for (j = 0; j < 16; j++)
11787 {
11788 if (j < lbytes)
11789 printf ("%2.2x", data[j]);
11790 else
11791 printf (" ");
11792
11793 if ((j & 3) == 3)
11794 printf (" ");
11795 }
11796
11797 for (j = 0; j < lbytes; j++)
11798 {
11799 k = data[j];
11800 if (k >= ' ' && k < 0x7f)
11801 printf ("%c", k);
11802 else
11803 printf (".");
11804 }
11805
11806 putchar ('\n');
11807
11808 data += lbytes;
11809 addr += lbytes;
11810 bytes -= lbytes;
11811 }
11812
11813 free (start);
11814
11815 putchar ('\n');
11816}
11817
4a114e3e 11818/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11819
11820static int
d3dbc530
AM		 11821uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11822 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 11823{
11824#ifndef HAVE_ZLIB_H
cf13d699
NC		 11825 return FALSE;
11826#else
11827 dwarf_size_type compressed_size = *size;
11828 unsigned char * compressed_buffer = *buffer;
11829 dwarf_size_type uncompressed_size;
11830 unsigned char * uncompressed_buffer;
11831 z_stream strm;
11832 int rc;
11833 dwarf_size_type header_size = 12;
11834
11835 /* Read the zlib header. In this case, it should be "ZLIB" followed
11836 by the uncompressed section size, 8 bytes in big-endian order. */
11837 if (compressed_size < header_size
11838 || ! streq ((char *) compressed_buffer, "ZLIB"))
11839 return 0;
11840
11841 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11842 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11843 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11844 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11845 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11846 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11847 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11848 uncompressed_size += compressed_buffer[11];
11849
11850 /* It is possible the section consists of several compressed
11851 buffers concatenated together, so we uncompress in a loop. */
11852 strm.zalloc = NULL;
11853 strm.zfree = NULL;
11854 strm.opaque = NULL;
11855 strm.avail_in = compressed_size - header_size;
11856 strm.next_in = (Bytef *) compressed_buffer + header_size;
11857 strm.avail_out = uncompressed_size;
3f5e193b 11858 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 11859
11860 rc = inflateInit (& strm);
11861 while (strm.avail_in > 0)
11862 {
11863 if (rc != Z_OK)
11864 goto fail;
11865 strm.next_out = ((Bytef *) uncompressed_buffer
11866 + (uncompressed_size - strm.avail_out));
11867 rc = inflate (&strm, Z_FINISH);
11868 if (rc != Z_STREAM_END)
11869 goto fail;
11870 rc = inflateReset (& strm);
11871 }
11872 rc = inflateEnd (& strm);
11873 if (rc != Z_OK
11874 || strm.avail_out != 0)
11875 goto fail;
11876
11877 free (compressed_buffer);
11878 *buffer = uncompressed_buffer;
11879 *size = uncompressed_size;
11880 return 1;
11881
11882 fail:
11883 free (uncompressed_buffer);
4a114e3e
L		 11884 /* Indicate decompression failure. */
11885 *buffer = NULL;
cf13d699
NC		 11886 return 0;
11887#endif /* HAVE_ZLIB_H */
11888}
11889
d966045b
DJ		 11890static int
11891load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 11892 Elf_Internal_Shdr * sec, void * file)
1007acb3 11893{
2cf0635d 11894 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 11895 char buf [64];
1007acb3 11896
19e6b90e
L		 11897 /* If it is already loaded, do nothing. */
11898 if (section->start != NULL)
11899 return 1;
1007acb3 11900
19e6b90e
L		 11901 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11902 section->address = sec->sh_addr;
06614111 11903 section->user_data = NULL;
3f5e193b
NC		 11904 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11905 sec->sh_offset, 1,
11906 sec->sh_size, buf);
59245841
NC		 11907 if (section->start == NULL)
11908 section->size = 0;
11909 else
11910 {
11911 section->size = sec->sh_size;
11912 if (uncompress_section_contents (&section->start, &section->size))
11913 sec->sh_size = section->size;
11914 }
4a114e3e 11915
1b315056
CS		 11916 if (section->start == NULL)
11917 return 0;
11918
19e6b90e 11919 if (debug_displays [debug].relocate)
3f5e193b 11920 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11921
1b315056 11922 return 1;
1007acb3
L		 11923}
11924
657d0d47
CC		 11925/* If this is not NULL, load_debug_section will only look for sections
11926 within the list of sections given here. */
11927unsigned int *section_subset = NULL;
11928
d966045b 11929int
2cf0635d 11930load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11931{
2cf0635d
NC		 11932 struct dwarf_section * section = &debug_displays [debug].section;
11933 Elf_Internal_Shdr * sec;
d966045b
DJ		 11934
11935 /* Locate the debug section. */
657d0d47 11936 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 11937 if (sec != NULL)
11938 section->name = section->uncompressed_name;
11939 else
11940 {
657d0d47 11941 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 11942 if (sec != NULL)
11943 section->name = section->compressed_name;
11944 }
11945 if (sec == NULL)
11946 return 0;
11947
657d0d47
CC		 11948 /* If we're loading from a subset of sections, and we've loaded
11949 a section matching this name before, it's likely that it's a
11950 different one. */
11951 if (section_subset != NULL)
11952 free_debug_section (debug);
11953
3f5e193b 11954 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 11955}
11956
19e6b90e
L		 11957void
11958free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 11959{
2cf0635d 11960 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 11961
19e6b90e
L		 11962 if (section->start == NULL)
11963 return;
1007acb3 11964
19e6b90e
L		 11965 free ((char *) section->start);
11966 section->start = NULL;
11967 section->address = 0;
11968 section->size = 0;
1007acb3
L		 11969}
11970
1007acb3 11971static int
657d0d47 11972display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 11973{
2cf0635d 11974 char * name = SECTION_NAME (section);
74e1a04b 11975 const char * print_name = printable_section_name (section);
19e6b90e
L		 11976 bfd_size_type length;
11977 int result = 1;
3f5e193b 11978 int i;
1007acb3 11979
19e6b90e
L		 11980 length = section->sh_size;
11981 if (length == 0)
1007acb3 11982 {
74e1a04b 11983 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 11984 return 0;
1007acb3 11985 }
5dff79d8
NC		 11986 if (section->sh_type == SHT_NOBITS)
11987 {
11988 /* There is no point in dumping the contents of a debugging section
11989 which has the NOBITS type - the bits in the file will be random.
11990 This can happen when a file containing a .eh_frame section is
11991 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 11992 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11993 print_name);
5dff79d8
NC		 11994 return 0;
11995 }
1007acb3 11996
0112cd26 11997 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 11998 name = ".debug_info";
1007acb3 11999
19e6b90e
L		 12000 /* See if we know how to display the contents of this section. */
12001 for (i = 0; i < max; i++)
1b315056 12002 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12003 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12004 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12005 {
2cf0635d 12006 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12007 int secondary = (section != find_section (name));
12008
12009 if (secondary)
3f5e193b 12010 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12011
b40bf0a2
NC		 12012 if (i == line && const_strneq (name, ".debug_line."))
12013 sec->name = name;
12014 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12015 sec->name = sec->uncompressed_name;
12016 else
12017 sec->name = sec->compressed_name;
3f5e193b
NC		 12018 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12019 section, file))
19e6b90e 12020 {
657d0d47
CC		 12021 /* If this debug section is part of a CU/TU set in a .dwp file,
12022 restrict load_debug_section to the sections in that set. */
12023 section_subset = find_cu_tu_set (file, shndx);
12024
19e6b90e 12025 result &= debug_displays[i].display (sec, file);
1007acb3 12026
657d0d47
CC		 12027 section_subset = NULL;
12028
d966045b 12029 if (secondary || (i != info && i != abbrev))
3f5e193b 12030 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12031 }
1007acb3 12032
19e6b90e
L		 12033 break;
12034 }
1007acb3 12035
19e6b90e 12036 if (i == max)
1007acb3 12037 {
74e1a04b 12038 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12039 result = 0;
1007acb3
L		 12040 }
12041
19e6b90e 12042 return result;
5b18a4bc 12043}
103f02d3 12044
aef1f6d0
DJ		 12045/* Set DUMP_SECTS for all sections where dumps were requested
12046 based on section name. */
12047
12048static void
12049initialise_dumps_byname (void)
12050{
2cf0635d 12051 struct dump_list_entry * cur;
aef1f6d0
DJ		 12052
12053 for (cur = dump_sects_byname; cur; cur = cur->next)
12054 {
12055 unsigned int i;
12056 int any;
12057
12058 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12059 if (streq (SECTION_NAME (section_headers + i), cur->name))
12060 {
09c11c86 12061 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12062 any = 1;
12063 }
12064
12065 if (!any)
12066 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12067 cur->name);
12068 }
12069}
12070
5b18a4bc 12071static void
2cf0635d 12072process_section_contents (FILE * file)
5b18a4bc 12073{
2cf0635d 12074 Elf_Internal_Shdr * section;
19e6b90e 12075 unsigned int i;
103f02d3 12076
19e6b90e
L		 12077 if (! do_dump)
12078 return;
103f02d3 12079
aef1f6d0
DJ		 12080 initialise_dumps_byname ();
12081
19e6b90e
L		 12082 for (i = 0, section = section_headers;
12083 i < elf_header.e_shnum && i < num_dump_sects;
12084 i++, section++)
12085 {
12086#ifdef SUPPORT_DISASSEMBLY
12087 if (dump_sects[i] & DISASS_DUMP)
12088 disassemble_section (section, file);
12089#endif
12090 if (dump_sects[i] & HEX_DUMP)
cf13d699 12091 dump_section_as_bytes (section, file, FALSE);
103f02d3 12092
cf13d699
NC		 12093 if (dump_sects[i] & RELOC_DUMP)
12094 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12095
12096 if (dump_sects[i] & STRING_DUMP)
12097 dump_section_as_strings (section, file);
cf13d699
NC		 12098
12099 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12100 display_debug_section (i, section, file);
5b18a4bc 12101 }
103f02d3 12102
19e6b90e
L		 12103 /* Check to see if the user requested a
12104 dump of a section that does not exist. */
12105 while (i++ < num_dump_sects)
12106 if (dump_sects[i])
12107 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12108}
103f02d3 12109
5b18a4bc 12110static void
19e6b90e 12111process_mips_fpe_exception (int mask)
5b18a4bc 12112{
19e6b90e
L		 12113 if (mask)
12114 {
12115 int first = 1;
12116 if (mask & OEX_FPU_INEX)
12117 fputs ("INEX", stdout), first = 0;
12118 if (mask & OEX_FPU_UFLO)
12119 printf ("%sUFLO", first ? "" : "|"), first = 0;
12120 if (mask & OEX_FPU_OFLO)
12121 printf ("%sOFLO", first ? "" : "|"), first = 0;
12122 if (mask & OEX_FPU_DIV0)
12123 printf ("%sDIV0", first ? "" : "|"), first = 0;
12124 if (mask & OEX_FPU_INVAL)
12125 printf ("%sINVAL", first ? "" : "|");
12126 }
5b18a4bc 12127 else
19e6b90e 12128 fputs ("0", stdout);
5b18a4bc 12129}
103f02d3 12130
f6f0e17b
NC		 12131/* Display's the value of TAG at location P. If TAG is
12132 greater than 0 it is assumed to be an unknown tag, and
12133 a message is printed to this effect. Otherwise it is
12134 assumed that a message has already been printed.
12135
12136 If the bottom bit of TAG is set it assumed to have a
12137 string value, otherwise it is assumed to have an integer
12138 value.
12139
12140 Returns an updated P pointing to the first unread byte
12141 beyond the end of TAG's value.
12142
12143 Reads at or beyond END will not be made. */
12144
12145static unsigned char *
12146display_tag_value (int tag,
12147 unsigned char * p,
12148 const unsigned char * const end)
12149{
12150 unsigned long val;
12151
12152 if (tag > 0)
12153 printf (" Tag_unknown_%d: ", tag);
12154
12155 if (p >= end)
12156 {
4082ef84 12157 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12158 }
12159 else if (tag & 1)
12160 {
071436c6
NC		 12161 /* PR 17531 file: 027-19978-0.004. */
12162 size_t maxlen = (end - p) - 1;
12163
12164 putchar ('"');
4082ef84
NC		 12165 if (maxlen > 0)
12166 {
12167 print_symbol ((int) maxlen, (const char *) p);
12168 p += strnlen ((char *) p, maxlen) + 1;
12169 }
12170 else
12171 {
12172 printf (_("<corrupt string tag>"));
12173 p = (unsigned char *) end;
12174 }
071436c6 12175 printf ("\"\n");
f6f0e17b
NC		 12176 }
12177 else
12178 {
12179 unsigned int len;
12180
12181 val = read_uleb128 (p, &len, end);
12182 p += len;
12183 printf ("%ld (0x%lx)\n", val, val);
12184 }
12185
4082ef84 12186 assert (p <= end);
f6f0e17b
NC		 12187 return p;
12188}
12189
11c1ff18
PB		 12190/* ARM EABI attributes section. */
12191typedef struct
12192{
70e99720 12193 unsigned int tag;
2cf0635d 12194 const char * name;
11c1ff18 12195 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12196 unsigned int type;
2cf0635d 12197 const char ** table;
11c1ff18
PB		 12198} arm_attr_public_tag;
12199
2cf0635d 12200static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12201 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12202 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12203static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12204static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12205 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12206static const char * arm_attr_tag_FP_arch[] =
bca38921 12207 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12208 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12209static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12210static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12211 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12212static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12213 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12214 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12215static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12216 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12217static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12218 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12219static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12220 {"Absolute", "PC-relative", "None"};
2cf0635d 12221static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12222 {"None", "direct", "GOT-indirect"};
2cf0635d 12223static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12224 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12225static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12226static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12227 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12228static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12229static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12230static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12231 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12232static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12233 {"Unused", "small", "int", "forced to int"};
2cf0635d 12234static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 12235 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 12236static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12237 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12238static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12239 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12240static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12241 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12242 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12243static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12244 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12245 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12246static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12247static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12248 {"Not Allowed", "Allowed"};
2cf0635d 12249static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12250 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12251static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12252 {"Not Allowed", "Allowed"};
12253static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12254 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12255 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12256static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12257static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12258 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12259 "TrustZone and Virtualization Extensions"};
dd24e3da 12260static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12261 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12262
12263#define LOOKUP(id, name) \
12264 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12265static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12266{
12267 {4, "CPU_raw_name", 1, NULL},
12268 {5, "CPU_name", 1, NULL},
12269 LOOKUP(6, CPU_arch),
12270 {7, "CPU_arch_profile", 0, NULL},
12271 LOOKUP(8, ARM_ISA_use),
12272 LOOKUP(9, THUMB_ISA_use),
75375b3e 12273 LOOKUP(10, FP_arch),
11c1ff18 12274 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12275 LOOKUP(12, Advanced_SIMD_arch),
12276 LOOKUP(13, PCS_config),
11c1ff18
PB		 12277 LOOKUP(14, ABI_PCS_R9_use),
12278 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12279 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12280 LOOKUP(17, ABI_PCS_GOT_use),
12281 LOOKUP(18, ABI_PCS_wchar_t),
12282 LOOKUP(19, ABI_FP_rounding),
12283 LOOKUP(20, ABI_FP_denormal),
12284 LOOKUP(21, ABI_FP_exceptions),
12285 LOOKUP(22, ABI_FP_user_exceptions),
12286 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12287 {24, "ABI_align_needed", 0, NULL},
12288 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12289 LOOKUP(26, ABI_enum_size),
12290 LOOKUP(27, ABI_HardFP_use),
12291 LOOKUP(28, ABI_VFP_args),
12292 LOOKUP(29, ABI_WMMX_args),
12293 LOOKUP(30, ABI_optimization_goals),
12294 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12295 {32, "compatibility", 0, NULL},
f5f53991 12296 LOOKUP(34, CPU_unaligned_access),
75375b3e 12297 LOOKUP(36, FP_HP_extension),
8e79c3df 12298 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12299 LOOKUP(42, MPextension_use),
12300 LOOKUP(44, DIV_use),
f5f53991
AS		 12301 {64, "nodefaults", 0, NULL},
12302 {65, "also_compatible_with", 0, NULL},
12303 LOOKUP(66, T2EE_use),
12304 {67, "conformance", 1, NULL},
12305 LOOKUP(68, Virtualization_use),
cd21e546 12306 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12307};
12308#undef LOOKUP
12309
11c1ff18 12310static unsigned char *
f6f0e17b
NC		 12311display_arm_attribute (unsigned char * p,
12312 const unsigned char * const end)
11c1ff18 12313{
70e99720 12314 unsigned int tag;
11c1ff18 12315 unsigned int len;
70e99720 12316 unsigned int val;
2cf0635d 12317 arm_attr_public_tag * attr;
11c1ff18 12318 unsigned i;
70e99720 12319 unsigned int type;
11c1ff18 12320
f6f0e17b 12321 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12322 p += len;
12323 attr = NULL;
2cf0635d 12324 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12325 {
12326 if (arm_attr_public_tags[i].tag == tag)
12327 {
12328 attr = &arm_attr_public_tags[i];
12329 break;
12330 }
12331 }
12332
12333 if (attr)
12334 {
12335 printf (" Tag_%s: ", attr->name);
12336 switch (attr->type)
12337 {
12338 case 0:
12339 switch (tag)
12340 {
12341 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12342 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12343 p += len;
12344 switch (val)
12345 {
2b692964
NC		 12346 case 0: printf (_("None\n")); break;
12347 case 'A': printf (_("Application\n")); break;
12348 case 'R': printf (_("Realtime\n")); break;
12349 case 'M': printf (_("Microcontroller\n")); break;
12350 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12351 default: printf ("??? (%d)\n", val); break;
12352 }
12353 break;
12354
75375b3e 12355 case 24: /* Tag_align_needed. */
f6f0e17b 12356 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12357 p += len;
12358 switch (val)
12359 {
2b692964
NC		 12360 case 0: printf (_("None\n")); break;
12361 case 1: printf (_("8-byte\n")); break;
12362 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12363 case 3: printf ("??? 3\n"); break;
12364 default:
12365 if (val <= 12)
dd24e3da 12366 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12367 1 << val);
12368 else
12369 printf ("??? (%d)\n", val);
12370 break;
12371 }
12372 break;
12373
12374 case 25: /* Tag_align_preserved. */
f6f0e17b 12375 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12376 p += len;
12377 switch (val)
12378 {
2b692964
NC		 12379 case 0: printf (_("None\n")); break;
12380 case 1: printf (_("8-byte, except leaf SP\n")); break;
12381 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12382 case 3: printf ("??? 3\n"); break;
12383 default:
12384 if (val <= 12)
dd24e3da 12385 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12386 1 << val);
12387 else
12388 printf ("??? (%d)\n", val);
12389 break;
12390 }
12391 break;
12392
11c1ff18 12393 case 32: /* Tag_compatibility. */
071436c6 12394 {
071436c6
NC		 12395 val = read_uleb128 (p, &len, end);
12396 p += len;
071436c6 12397 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12398 if (p < end - 1)
12399 {
12400 size_t maxlen = (end - p) - 1;
12401
12402 print_symbol ((int) maxlen, (const char *) p);
12403 p += strnlen ((char *) p, maxlen) + 1;
12404 }
12405 else
12406 {
12407 printf (_("<corrupt>"));
12408 p = (unsigned char *) end;
12409 }
071436c6 12410 putchar ('\n');
071436c6 12411 }
11c1ff18
PB		 12412 break;
12413
f5f53991 12414 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12415 /* PR 17531: file: 001-505008-0.01. */
12416 if (p < end)
12417 p++;
2b692964 12418 printf (_("True\n"));
f5f53991
AS		 12419 break;
12420
12421 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12422 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12423 p += len;
12424 if (val == 6 /* Tag_CPU_arch. */)
12425 {
f6f0e17b 12426 val = read_uleb128 (p, &len, end);
f5f53991 12427 p += len;
071436c6 12428 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12429 printf ("??? (%d)\n", val);
12430 else
12431 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12432 }
12433 else
12434 printf ("???\n");
071436c6
NC		 12435 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12436 ;
f5f53991
AS		 12437 break;
12438
11c1ff18 12439 default:
bee0ee85
NC		 12440 printf (_("<unknown: %d>\n"), tag);
12441 break;
11c1ff18
PB		 12442 }
12443 return p;
12444
12445 case 1:
f6f0e17b 12446 return display_tag_value (-1, p, end);
11c1ff18 12447 case 2:
f6f0e17b 12448 return display_tag_value (0, p, end);
11c1ff18
PB		 12449
12450 default:
12451 assert (attr->type & 0x80);
f6f0e17b 12452 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12453 p += len;
12454 type = attr->type & 0x7f;
12455 if (val >= type)
12456 printf ("??? (%d)\n", val);
12457 else
12458 printf ("%s\n", attr->table[val]);
12459 return p;
12460 }
12461 }
11c1ff18 12462
f6f0e17b 12463 return display_tag_value (tag, p, end);
11c1ff18
PB		 12464}
12465
104d59d1 12466static unsigned char *
60bca95a 12467display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12468 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12469 const unsigned char * const end)
104d59d1
JM		 12470{
12471 int tag;
12472 unsigned int len;
12473 int val;
104d59d1 12474
f6f0e17b 12475 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12476 p += len;
12477
12478 /* Tag_compatibility is the only generic GNU attribute defined at
12479 present. */
12480 if (tag == 32)
12481 {
f6f0e17b 12482 val = read_uleb128 (p, &len, end);
104d59d1 12483 p += len;
071436c6
NC		 12484
12485 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12486 if (p == end)
12487 {
071436c6 12488 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12489 warn (_("corrupt vendor attribute\n"));
12490 }
12491 else
12492 {
4082ef84
NC		 12493 if (p < end - 1)
12494 {
12495 size_t maxlen = (end - p) - 1;
071436c6 12496
4082ef84
NC		 12497 print_symbol ((int) maxlen, (const char *) p);
12498 p += strnlen ((char *) p, maxlen) + 1;
12499 }
12500 else
12501 {
12502 printf (_("<corrupt>"));
12503 p = (unsigned char *) end;
12504 }
071436c6 12505 putchar ('\n');
f6f0e17b 12506 }
104d59d1
JM		 12507 return p;
12508 }
12509
12510 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12511 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12512
f6f0e17b 12513 return display_tag_value (tag, p, end);
104d59d1
JM		 12514}
12515
34c8bcba 12516static unsigned char *
f6f0e17b
NC		 12517display_power_gnu_attribute (unsigned char * p,
12518 int tag,
12519 const unsigned char * const end)
34c8bcba 12520{
34c8bcba
JM		 12521 unsigned int len;
12522 int val;
12523
12524 if (tag == Tag_GNU_Power_ABI_FP)
12525 {
f6f0e17b 12526 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12527 p += len;
12528 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12529
34c8bcba
JM		 12530 switch (val)
12531 {
12532 case 0:
2b692964 12533 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12534 break;
12535 case 1:
2b692964 12536 printf (_("Hard float\n"));
34c8bcba
JM		 12537 break;
12538 case 2:
2b692964 12539 printf (_("Soft float\n"));
34c8bcba 12540 break;
3c7b9897 12541 case 3:
2b692964 12542 printf (_("Single-precision hard float\n"));
3c7b9897 12543 break;
34c8bcba
JM		 12544 default:
12545 printf ("??? (%d)\n", val);
12546 break;
12547 }
12548 return p;
12549 }
12550
c6e65352
DJ		 12551 if (tag == Tag_GNU_Power_ABI_Vector)
12552 {
f6f0e17b 12553 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12554 p += len;
12555 printf (" Tag_GNU_Power_ABI_Vector: ");
12556 switch (val)
12557 {
12558 case 0:
2b692964 12559 printf (_("Any\n"));
c6e65352
DJ		 12560 break;
12561 case 1:
2b692964 12562 printf (_("Generic\n"));
c6e65352
DJ		 12563 break;
12564 case 2:
12565 printf ("AltiVec\n");
12566 break;
12567 case 3:
12568 printf ("SPE\n");
12569 break;
12570 default:
12571 printf ("??? (%d)\n", val);
12572 break;
12573 }
12574 return p;
12575 }
12576
f82e0623
NF		 12577 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12578 {
f6f0e17b
NC		 12579 if (p == end)
12580 {
071436c6 12581 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12582 return p;
12583 }
0b4362b0 12584
f6f0e17b 12585 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12586 p += len;
12587 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12588 switch (val)
12589 {
12590 case 0:
2b692964 12591 printf (_("Any\n"));
f82e0623
NF		 12592 break;
12593 case 1:
12594 printf ("r3/r4\n");
12595 break;
12596 case 2:
2b692964 12597 printf (_("Memory\n"));
f82e0623
NF		 12598 break;
12599 default:
12600 printf ("??? (%d)\n", val);
12601 break;
12602 }
12603 return p;
12604 }
12605
f6f0e17b 12606 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12607}
12608
9e8c70f9
DM		 12609static void
12610display_sparc_hwcaps (int mask)
12611{
12612 if (mask)
12613 {
12614 int first = 1;
071436c6 12615
9e8c70f9
DM		 12616 if (mask & ELF_SPARC_HWCAP_MUL32)
12617 fputs ("mul32", stdout), first = 0;
12618 if (mask & ELF_SPARC_HWCAP_DIV32)
12619 printf ("%sdiv32", first ? "" : "|"), first = 0;
12620 if (mask & ELF_SPARC_HWCAP_FSMULD)
12621 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12622 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12623 printf ("%sv8plus", first ? "" : "|"), first = 0;
12624 if (mask & ELF_SPARC_HWCAP_POPC)
12625 printf ("%spopc", first ? "" : "|"), first = 0;
12626 if (mask & ELF_SPARC_HWCAP_VIS)
12627 printf ("%svis", first ? "" : "|"), first = 0;
12628 if (mask & ELF_SPARC_HWCAP_VIS2)
12629 printf ("%svis2", first ? "" : "|"), first = 0;
12630 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12631 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12632 if (mask & ELF_SPARC_HWCAP_FMAF)
12633 printf ("%sfmaf", first ? "" : "|"), first = 0;
12634 if (mask & ELF_SPARC_HWCAP_VIS3)
12635 printf ("%svis3", first ? "" : "|"), first = 0;
12636 if (mask & ELF_SPARC_HWCAP_HPC)
12637 printf ("%shpc", first ? "" : "|"), first = 0;
12638 if (mask & ELF_SPARC_HWCAP_RANDOM)
12639 printf ("%srandom", first ? "" : "|"), first = 0;
12640 if (mask & ELF_SPARC_HWCAP_TRANS)
12641 printf ("%strans", first ? "" : "|"), first = 0;
12642 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12643 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12644 if (mask & ELF_SPARC_HWCAP_IMA)
12645 printf ("%sima", first ? "" : "|"), first = 0;
12646 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12647 printf ("%scspare", first ? "" : "|"), first = 0;
12648 }
12649 else
071436c6
NC		 12650 fputc ('0', stdout);
12651 fputc ('\n', stdout);
9e8c70f9
DM		 12652}
12653
3d68f91c
JM		 12654static void
12655display_sparc_hwcaps2 (int mask)
12656{
12657 if (mask)
12658 {
12659 int first = 1;
071436c6 12660
3d68f91c
JM		 12661 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12662 fputs ("fjathplus", stdout), first = 0;
12663 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12664 printf ("%svis3b", first ? "" : "|"), first = 0;
12665 if (mask & ELF_SPARC_HWCAP2_ADP)
12666 printf ("%sadp", first ? "" : "|"), first = 0;
12667 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12668 printf ("%ssparc5", first ? "" : "|"), first = 0;
12669 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12670 printf ("%smwait", first ? "" : "|"), first = 0;
12671 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12672 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12673 if (mask & ELF_SPARC_HWCAP2_XMONT)
12674 printf ("%sxmont2", first ? "" : "|"), first = 0;
12675 if (mask & ELF_SPARC_HWCAP2_NSEC)
12676 printf ("%snsec", first ? "" : "|"), first = 0;
12677 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12678 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12679 if (mask & ELF_SPARC_HWCAP2_FJDES)
12680 printf ("%sfjdes", first ? "" : "|"), first = 0;
12681 if (mask & ELF_SPARC_HWCAP2_FJAES)
12682 printf ("%sfjaes", first ? "" : "|"), first = 0;
12683 }
12684 else
071436c6
NC		 12685 fputc ('0', stdout);
12686 fputc ('\n', stdout);
3d68f91c
JM		 12687}
12688
9e8c70f9 12689static unsigned char *
f6f0e17b
NC		 12690display_sparc_gnu_attribute (unsigned char * p,
12691 int tag,
12692 const unsigned char * const end)
9e8c70f9 12693{
3d68f91c
JM		 12694 unsigned int len;
12695 int val;
12696
9e8c70f9
DM		 12697 if (tag == Tag_GNU_Sparc_HWCAPS)
12698 {
f6f0e17b 12699 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12700 p += len;
12701 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12702 display_sparc_hwcaps (val);
12703 return p;
3d68f91c
JM		 12704 }
12705 if (tag == Tag_GNU_Sparc_HWCAPS2)
12706 {
12707 val = read_uleb128 (p, &len, end);
12708 p += len;
12709 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12710 display_sparc_hwcaps2 (val);
12711 return p;
12712 }
9e8c70f9 12713
f6f0e17b 12714 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12715}
12716
351cdf24
MF		 12717static void
12718print_mips_fp_abi_value (int val)
12719{
12720 switch (val)
12721 {
12722 case Val_GNU_MIPS_ABI_FP_ANY:
12723 printf (_("Hard or soft float\n"));
12724 break;
12725 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12726 printf (_("Hard float (double precision)\n"));
12727 break;
12728 case Val_GNU_MIPS_ABI_FP_SINGLE:
12729 printf (_("Hard float (single precision)\n"));
12730 break;
12731 case Val_GNU_MIPS_ABI_FP_SOFT:
12732 printf (_("Soft float\n"));
12733 break;
12734 case Val_GNU_MIPS_ABI_FP_OLD_64:
12735 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12736 break;
12737 case Val_GNU_MIPS_ABI_FP_XX:
12738 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12739 break;
12740 case Val_GNU_MIPS_ABI_FP_64:
12741 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12742 break;
12743 case Val_GNU_MIPS_ABI_FP_64A:
12744 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12745 break;
12746 default:
12747 printf ("??? (%d)\n", val);
12748 break;
12749 }
12750}
12751
2cf19d5c 12752static unsigned char *
f6f0e17b
NC		 12753display_mips_gnu_attribute (unsigned char * p,
12754 int tag,
12755 const unsigned char * const end)
2cf19d5c 12756{
2cf19d5c
JM		 12757 if (tag == Tag_GNU_MIPS_ABI_FP)
12758 {
f6f0e17b
NC		 12759 unsigned int len;
12760 int val;
12761
12762 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12763 p += len;
12764 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12765
351cdf24
MF		 12766 print_mips_fp_abi_value (val);
12767
2cf19d5c
JM		 12768 return p;
12769 }
12770
a9f58168
CF		 12771 if (tag == Tag_GNU_MIPS_ABI_MSA)
12772 {
12773 unsigned int len;
12774 int val;
12775
12776 val = read_uleb128 (p, &len, end);
12777 p += len;
12778 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12779
12780 switch (val)
12781 {
12782 case Val_GNU_MIPS_ABI_MSA_ANY:
12783 printf (_("Any MSA or not\n"));
12784 break;
12785 case Val_GNU_MIPS_ABI_MSA_128:
12786 printf (_("128-bit MSA\n"));
12787 break;
12788 default:
12789 printf ("??? (%d)\n", val);
12790 break;
12791 }
12792 return p;
12793 }
12794
f6f0e17b 12795 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12796}
12797
59e6276b 12798static unsigned char *
f6f0e17b
NC		 12799display_tic6x_attribute (unsigned char * p,
12800 const unsigned char * const end)
59e6276b
JM		 12801{
12802 int tag;
12803 unsigned int len;
12804 int val;
12805
f6f0e17b 12806 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12807 p += len;
12808
12809 switch (tag)
12810 {
75fa6dc1 12811 case Tag_ISA:
f6f0e17b 12812 val = read_uleb128 (p, &len, end);
59e6276b 12813 p += len;
75fa6dc1 12814 printf (" Tag_ISA: ");
59e6276b
JM		 12815
12816 switch (val)
12817 {
75fa6dc1 12818 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12819 printf (_("None\n"));
12820 break;
75fa6dc1 12821 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12822 printf ("C62x\n");
12823 break;
75fa6dc1 12824 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12825 printf ("C67x\n");
12826 break;
75fa6dc1 12827 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12828 printf ("C67x+\n");
12829 break;
75fa6dc1 12830 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12831 printf ("C64x\n");
12832 break;
75fa6dc1 12833 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12834 printf ("C64x+\n");
12835 break;
75fa6dc1 12836 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12837 printf ("C674x\n");
12838 break;
12839 default:
12840 printf ("??? (%d)\n", val);
12841 break;
12842 }
12843 return p;
12844
87779176 12845 case Tag_ABI_wchar_t:
f6f0e17b 12846 val = read_uleb128 (p, &len, end);
87779176
JM		 12847 p += len;
12848 printf (" Tag_ABI_wchar_t: ");
12849 switch (val)
12850 {
12851 case 0:
12852 printf (_("Not used\n"));
12853 break;
12854 case 1:
12855 printf (_("2 bytes\n"));
12856 break;
12857 case 2:
12858 printf (_("4 bytes\n"));
12859 break;
12860 default:
12861 printf ("??? (%d)\n", val);
12862 break;
12863 }
12864 return p;
12865
12866 case Tag_ABI_stack_align_needed:
f6f0e17b 12867 val = read_uleb128 (p, &len, end);
87779176
JM		 12868 p += len;
12869 printf (" Tag_ABI_stack_align_needed: ");
12870 switch (val)
12871 {
12872 case 0:
12873 printf (_("8-byte\n"));
12874 break;
12875 case 1:
12876 printf (_("16-byte\n"));
12877 break;
12878 default:
12879 printf ("??? (%d)\n", val);
12880 break;
12881 }
12882 return p;
12883
12884 case Tag_ABI_stack_align_preserved:
f6f0e17b 12885 val = read_uleb128 (p, &len, end);
87779176
JM		 12886 p += len;
12887 printf (" Tag_ABI_stack_align_preserved: ");
12888 switch (val)
12889 {
12890 case 0:
12891 printf (_("8-byte\n"));
12892 break;
12893 case 1:
12894 printf (_("16-byte\n"));
12895 break;
12896 default:
12897 printf ("??? (%d)\n", val);
12898 break;
12899 }
12900 return p;
12901
b5593623 12902 case Tag_ABI_DSBT:
f6f0e17b 12903 val = read_uleb128 (p, &len, end);
b5593623
JM		 12904 p += len;
12905 printf (" Tag_ABI_DSBT: ");
12906 switch (val)
12907 {
12908 case 0:
12909 printf (_("DSBT addressing not used\n"));
12910 break;
12911 case 1:
12912 printf (_("DSBT addressing used\n"));
12913 break;
12914 default:
12915 printf ("??? (%d)\n", val);
12916 break;
12917 }
12918 return p;
12919
87779176 12920 case Tag_ABI_PID:
f6f0e17b 12921 val = read_uleb128 (p, &len, end);
87779176
JM		 12922 p += len;
12923 printf (" Tag_ABI_PID: ");
12924 switch (val)
12925 {
12926 case 0:
12927 printf (_("Data addressing position-dependent\n"));
12928 break;
12929 case 1:
12930 printf (_("Data addressing position-independent, GOT near DP\n"));
12931 break;
12932 case 2:
12933 printf (_("Data addressing position-independent, GOT far from DP\n"));
12934 break;
12935 default:
12936 printf ("??? (%d)\n", val);
12937 break;
12938 }
12939 return p;
12940
12941 case Tag_ABI_PIC:
f6f0e17b 12942 val = read_uleb128 (p, &len, end);
87779176
JM		 12943 p += len;
12944 printf (" Tag_ABI_PIC: ");
12945 switch (val)
12946 {
12947 case 0:
12948 printf (_("Code addressing position-dependent\n"));
12949 break;
12950 case 1:
12951 printf (_("Code addressing position-independent\n"));
12952 break;
12953 default:
12954 printf ("??? (%d)\n", val);
12955 break;
12956 }
12957 return p;
12958
12959 case Tag_ABI_array_object_alignment:
f6f0e17b 12960 val = read_uleb128 (p, &len, end);
87779176
JM		 12961 p += len;
12962 printf (" Tag_ABI_array_object_alignment: ");
12963 switch (val)
12964 {
12965 case 0:
12966 printf (_("8-byte\n"));
12967 break;
12968 case 1:
12969 printf (_("4-byte\n"));
12970 break;
12971 case 2:
12972 printf (_("16-byte\n"));
12973 break;
12974 default:
12975 printf ("??? (%d)\n", val);
12976 break;
12977 }
12978 return p;
12979
12980 case Tag_ABI_array_object_align_expected:
f6f0e17b 12981 val = read_uleb128 (p, &len, end);
87779176
JM		 12982 p += len;
12983 printf (" Tag_ABI_array_object_align_expected: ");
12984 switch (val)
12985 {
12986 case 0:
12987 printf (_("8-byte\n"));
12988 break;
12989 case 1:
12990 printf (_("4-byte\n"));
12991 break;
12992 case 2:
12993 printf (_("16-byte\n"));
12994 break;
12995 default:
12996 printf ("??? (%d)\n", val);
12997 break;
12998 }
12999 return p;
13000
3cbd1c06 13001 case Tag_ABI_compatibility:
071436c6 13002 {
071436c6
NC		 13003 val = read_uleb128 (p, &len, end);
13004 p += len;
13005 printf (" Tag_ABI_compatibility: ");
071436c6 13006 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13007 if (p < end - 1)
13008 {
13009 size_t maxlen = (end - p) - 1;
13010
13011 print_symbol ((int) maxlen, (const char *) p);
13012 p += strnlen ((char *) p, maxlen) + 1;
13013 }
13014 else
13015 {
13016 printf (_("<corrupt>"));
13017 p = (unsigned char *) end;
13018 }
071436c6 13019 putchar ('\n');
071436c6
NC		 13020 return p;
13021 }
87779176
JM		 13022
13023 case Tag_ABI_conformance:
071436c6 13024 {
4082ef84
NC		 13025 printf (" Tag_ABI_conformance: \"");
13026 if (p < end - 1)
13027 {
13028 size_t maxlen = (end - p) - 1;
071436c6 13029
4082ef84
NC		 13030 print_symbol ((int) maxlen, (const char *) p);
13031 p += strnlen ((char *) p, maxlen) + 1;
13032 }
13033 else
13034 {
13035 printf (_("<corrupt>"));
13036 p = (unsigned char *) end;
13037 }
071436c6 13038 printf ("\"\n");
071436c6
NC		 13039 return p;
13040 }
59e6276b
JM		 13041 }
13042
f6f0e17b
NC		 13043 return display_tag_value (tag, p, end);
13044}
59e6276b 13045
f6f0e17b
NC		 13046static void
13047display_raw_attribute (unsigned char * p, unsigned char * end)
13048{
13049 unsigned long addr = 0;
13050 size_t bytes = end - p;
13051
e0a31db1 13052 assert (end > p);
f6f0e17b 13053 while (bytes)
87779176 13054 {
f6f0e17b
NC		 13055 int j;
13056 int k;
13057 int lbytes = (bytes > 16 ? 16 : bytes);
13058
13059 printf (" 0x%8.8lx ", addr);
13060
13061 for (j = 0; j < 16; j++)
13062 {
13063 if (j < lbytes)
13064 printf ("%2.2x", p[j]);
13065 else
13066 printf (" ");
13067
13068 if ((j & 3) == 3)
13069 printf (" ");
13070 }
13071
13072 for (j = 0; j < lbytes; j++)
13073 {
13074 k = p[j];
13075 if (k >= ' ' && k < 0x7f)
13076 printf ("%c", k);
13077 else
13078 printf (".");
13079 }
13080
13081 putchar ('\n');
13082
13083 p += lbytes;
13084 bytes -= lbytes;
13085 addr += lbytes;
87779176 13086 }
59e6276b 13087
f6f0e17b 13088 putchar ('\n');
59e6276b
JM		 13089}
13090
13761a11
NC		 13091static unsigned char *
13092display_msp430x_attribute (unsigned char * p,
13093 const unsigned char * const end)
13094{
13095 unsigned int len;
13096 int val;
13097 int tag;
13098
13099 tag = read_uleb128 (p, & len, end);
13100 p += len;
0b4362b0 13101
13761a11
NC		 13102 switch (tag)
13103 {
13104 case OFBA_MSPABI_Tag_ISA:
13105 val = read_uleb128 (p, &len, end);
13106 p += len;
13107 printf (" Tag_ISA: ");
13108 switch (val)
13109 {
13110 case 0: printf (_("None\n")); break;
13111 case 1: printf (_("MSP430\n")); break;
13112 case 2: printf (_("MSP430X\n")); break;
13113 default: printf ("??? (%d)\n", val); break;
13114 }
13115 break;
13116
13117 case OFBA_MSPABI_Tag_Code_Model:
13118 val = read_uleb128 (p, &len, end);
13119 p += len;
13120 printf (" Tag_Code_Model: ");
13121 switch (val)
13122 {
13123 case 0: printf (_("None\n")); break;
13124 case 1: printf (_("Small\n")); break;
13125 case 2: printf (_("Large\n")); break;
13126 default: printf ("??? (%d)\n", val); break;
13127 }
13128 break;
13129
13130 case OFBA_MSPABI_Tag_Data_Model:
13131 val = read_uleb128 (p, &len, end);
13132 p += len;
13133 printf (" Tag_Data_Model: ");
13134 switch (val)
13135 {
13136 case 0: printf (_("None\n")); break;
13137 case 1: printf (_("Small\n")); break;
13138 case 2: printf (_("Large\n")); break;
13139 case 3: printf (_("Restricted Large\n")); break;
13140 default: printf ("??? (%d)\n", val); break;
13141 }
13142 break;
13143
13144 default:
13145 printf (_(" <unknown tag %d>: "), tag);
13146
13147 if (tag & 1)
13148 {
071436c6 13149 putchar ('"');
4082ef84
NC		 13150 if (p < end - 1)
13151 {
13152 size_t maxlen = (end - p) - 1;
13153
13154 print_symbol ((int) maxlen, (const char *) p);
13155 p += strnlen ((char *) p, maxlen) + 1;
13156 }
13157 else
13158 {
13159 printf (_("<corrupt>"));
13160 p = (unsigned char *) end;
13161 }
071436c6 13162 printf ("\"\n");
13761a11
NC		 13163 }
13164 else
13165 {
13166 val = read_uleb128 (p, &len, end);
13167 p += len;
13168 printf ("%d (0x%x)\n", val, val);
13169 }
13170 break;
13171 }
13172
4082ef84 13173 assert (p <= end);
13761a11
NC		 13174 return p;
13175}
13176
11c1ff18 13177static int
60bca95a
NC		 13178process_attributes (FILE * file,
13179 const char * public_name,
104d59d1 13180 unsigned int proc_type,
f6f0e17b
NC		 13181 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13182 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13183{
2cf0635d 13184 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13185 unsigned i;
13186
13187 /* Find the section header so that we get the size. */
13188 for (i = 0, sect = section_headers;
13189 i < elf_header.e_shnum;
13190 i++, sect++)
13191 {
071436c6
NC		 13192 unsigned char * contents;
13193 unsigned char * p;
13194
104d59d1 13195 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13196 continue;
13197
3f5e193b
NC		 13198 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13199 sect->sh_size, _("attributes"));
60bca95a 13200 if (contents == NULL)
11c1ff18 13201 continue;
60bca95a 13202
11c1ff18
PB		 13203 p = contents;
13204 if (*p == 'A')
13205 {
071436c6
NC		 13206 bfd_vma section_len;
13207
13208 section_len = sect->sh_size - 1;
11c1ff18 13209 p++;
60bca95a 13210
071436c6 13211 while (section_len > 0)
11c1ff18 13212 {
071436c6 13213 bfd_vma attr_len;
e9847026 13214 unsigned int namelen;
11c1ff18 13215 bfd_boolean public_section;
104d59d1 13216 bfd_boolean gnu_section;
11c1ff18 13217
071436c6 13218 if (section_len <= 4)
e0a31db1
NC		 13219 {
13220 error (_("Tag section ends prematurely\n"));
13221 break;
13222 }
071436c6 13223 attr_len = byte_get (p, 4);
11c1ff18 13224 p += 4;
60bca95a 13225
071436c6 13226 if (attr_len > section_len)
11c1ff18 13227 {
071436c6
NC		 13228 error (_("Bad attribute length (%u > %u)\n"),
13229 (unsigned) attr_len, (unsigned) section_len);
13230 attr_len = section_len;
11c1ff18 13231 }
74e1a04b 13232 /* PR 17531: file: 001-101425-0.004 */
071436c6 13233 else if (attr_len < 5)
74e1a04b 13234 {
071436c6 13235 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13236 break;
13237 }
e9847026 13238
071436c6
NC		 13239 section_len -= attr_len;
13240 attr_len -= 4;
13241
13242 namelen = strnlen ((char *) p, attr_len) + 1;
13243 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13244 {
13245 error (_("Corrupt attribute section name\n"));
13246 break;
13247 }
13248
071436c6
NC		 13249 printf (_("Attribute Section: "));
13250 print_symbol (INT_MAX, (const char *) p);
13251 putchar ('\n');
60bca95a
NC		 13252
13253 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13254 public_section = TRUE;
13255 else
13256 public_section = FALSE;
60bca95a
NC		 13257
13258 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13259 gnu_section = TRUE;
13260 else
13261 gnu_section = FALSE;
60bca95a 13262
11c1ff18 13263 p += namelen;
071436c6 13264 attr_len -= namelen;
e0a31db1 13265
071436c6 13266 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13267 {
e0a31db1 13268 int tag;
11c1ff18
PB		 13269 int val;
13270 bfd_vma size;
071436c6 13271 unsigned char * end;
60bca95a 13272
e0a31db1 13273 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13274 if (attr_len < 6)
e0a31db1
NC		 13275 {
13276 error (_("Unused bytes at end of section\n"));
13277 section_len = 0;
13278 break;
13279 }
13280
13281 tag = *(p++);
11c1ff18 13282 size = byte_get (p, 4);
071436c6 13283 if (size > attr_len)
11c1ff18 13284 {
e9847026 13285 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13286 (unsigned) size, (unsigned) attr_len);
13287 size = attr_len;
11c1ff18 13288 }
e0a31db1
NC		 13289 /* PR binutils/17531: Safe handling of corrupt files. */
13290 if (size < 6)
13291 {
13292 error (_("Bad subsection length (%u < 6)\n"),
13293 (unsigned) size);
13294 section_len = 0;
13295 break;
13296 }
60bca95a 13297
071436c6 13298 attr_len -= size;
11c1ff18 13299 end = p + size - 1;
071436c6 13300 assert (end <= contents + sect->sh_size);
11c1ff18 13301 p += 4;
60bca95a 13302
11c1ff18
PB		 13303 switch (tag)
13304 {
13305 case 1:
2b692964 13306 printf (_("File Attributes\n"));
11c1ff18
PB		 13307 break;
13308 case 2:
2b692964 13309 printf (_("Section Attributes:"));
11c1ff18
PB		 13310 goto do_numlist;
13311 case 3:
2b692964 13312 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13313 do_numlist:
13314 for (;;)
13315 {
91d6fa6a 13316 unsigned int j;
60bca95a 13317
f6f0e17b 13318 val = read_uleb128 (p, &j, end);
91d6fa6a 13319 p += j;
11c1ff18
PB		 13320 if (val == 0)
13321 break;
13322 printf (" %d", val);
13323 }
13324 printf ("\n");
13325 break;
13326 default:
2b692964 13327 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13328 public_section = FALSE;
13329 break;
13330 }
60bca95a 13331
071436c6 13332 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13333 {
13334 while (p < end)
f6f0e17b 13335 p = display_pub_attribute (p, end);
071436c6 13336 assert (p <= end);
104d59d1 13337 }
071436c6 13338 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13339 {
13340 while (p < end)
13341 p = display_gnu_attribute (p,
f6f0e17b
NC		 13342 display_proc_gnu_attribute,
13343 end);
071436c6 13344 assert (p <= end);
11c1ff18 13345 }
071436c6 13346 else if (p < end)
11c1ff18 13347 {
071436c6 13348 printf (_(" Unknown attribute:\n"));
f6f0e17b 13349 display_raw_attribute (p, end);
11c1ff18
PB		 13350 p = end;
13351 }
071436c6
NC		 13352 else
13353 attr_len = 0;
11c1ff18
PB		 13354 }
13355 }
13356 }
13357 else
e9847026 13358 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13359
60bca95a 13360 free (contents);
11c1ff18
PB		 13361 }
13362 return 1;
13363}
13364
104d59d1 13365static int
2cf0635d 13366process_arm_specific (FILE * file)
104d59d1
JM		 13367{
13368 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13369 display_arm_attribute, NULL);
13370}
13371
34c8bcba 13372static int
2cf0635d 13373process_power_specific (FILE * file)
34c8bcba
JM		 13374{
13375 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13376 display_power_gnu_attribute);
13377}
13378
9e8c70f9
DM		 13379static int
13380process_sparc_specific (FILE * file)
13381{
13382 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13383 display_sparc_gnu_attribute);
13384}
13385
59e6276b
JM		 13386static int
13387process_tic6x_specific (FILE * file)
13388{
13389 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13390 display_tic6x_attribute, NULL);
13391}
13392
13761a11
NC		 13393static int
13394process_msp430x_specific (FILE * file)
13395{
13396 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13397 display_msp430x_attribute, NULL);
13398}
13399
ccb4c951
RS		 13400/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13401 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13402 and return the VMA of the next entry, or -1 if there was a problem.
13403 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13404
13405static bfd_vma
82b1b41b
NC		 13406print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13407 unsigned char * data_end)
ccb4c951
RS		 13408{
13409 printf (" ");
13410 print_vma (addr, LONG_HEX);
13411 printf (" ");
13412 if (addr < pltgot + 0xfff0)
13413 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13414 else
13415 printf ("%10s", "");
13416 printf (" ");
13417 if (data == NULL)
2b692964 13418 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13419 else
13420 {
13421 bfd_vma entry;
82b1b41b 13422 unsigned char * from = data + addr - pltgot;
ccb4c951 13423
82b1b41b
NC		 13424 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13425 {
13426 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13427 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13428 return (bfd_vma) -1;
13429 }
13430 else
13431 {
13432 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13433 print_vma (entry, LONG_HEX);
13434 }
ccb4c951
RS		 13435 }
13436 return addr + (is_32bit_elf ? 4 : 8);
13437}
13438
861fb55a
DJ		 13439/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13440 PLTGOT. Print the Address and Initial fields of an entry at VMA
13441 ADDR and return the VMA of the next entry. */
13442
13443static bfd_vma
2cf0635d 13444print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13445{
13446 printf (" ");
13447 print_vma (addr, LONG_HEX);
13448 printf (" ");
13449 if (data == NULL)
2b692964 13450 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13451 else
13452 {
13453 bfd_vma entry;
13454
13455 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13456 print_vma (entry, LONG_HEX);
13457 }
13458 return addr + (is_32bit_elf ? 4 : 8);
13459}
13460
351cdf24
MF		 13461static void
13462print_mips_ases (unsigned int mask)
13463{
13464 if (mask & AFL_ASE_DSP)
13465 fputs ("\n\tDSP ASE", stdout);
13466 if (mask & AFL_ASE_DSPR2)
13467 fputs ("\n\tDSP R2 ASE", stdout);
13468 if (mask & AFL_ASE_EVA)
13469 fputs ("\n\tEnhanced VA Scheme", stdout);
13470 if (mask & AFL_ASE_MCU)
13471 fputs ("\n\tMCU (MicroController) ASE", stdout);
13472 if (mask & AFL_ASE_MDMX)
13473 fputs ("\n\tMDMX ASE", stdout);
13474 if (mask & AFL_ASE_MIPS3D)
13475 fputs ("\n\tMIPS-3D ASE", stdout);
13476 if (mask & AFL_ASE_MT)
13477 fputs ("\n\tMT ASE", stdout);
13478 if (mask & AFL_ASE_SMARTMIPS)
13479 fputs ("\n\tSmartMIPS ASE", stdout);
13480 if (mask & AFL_ASE_VIRT)
13481 fputs ("\n\tVZ ASE", stdout);
13482 if (mask & AFL_ASE_MSA)
13483 fputs ("\n\tMSA ASE", stdout);
13484 if (mask & AFL_ASE_MIPS16)
13485 fputs ("\n\tMIPS16 ASE", stdout);
13486 if (mask & AFL_ASE_MICROMIPS)
13487 fputs ("\n\tMICROMIPS ASE", stdout);
13488 if (mask & AFL_ASE_XPA)
13489 fputs ("\n\tXPA ASE", stdout);
13490 if (mask == 0)
13491 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13492 else if ((mask & ~AFL_ASE_MASK) != 0)
13493 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13494}
13495
13496static void
13497print_mips_isa_ext (unsigned int isa_ext)
13498{
13499 switch (isa_ext)
13500 {
13501 case 0:
13502 fputs (_("None"), stdout);
13503 break;
13504 case AFL_EXT_XLR:
13505 fputs ("RMI XLR", stdout);
13506 break;
2c629856
N		 13507 case AFL_EXT_OCTEON3:
13508 fputs ("Cavium Networks Octeon3", stdout);
13509 break;
351cdf24
MF		 13510 case AFL_EXT_OCTEON2:
13511 fputs ("Cavium Networks Octeon2", stdout);
13512 break;
13513 case AFL_EXT_OCTEONP:
13514 fputs ("Cavium Networks OcteonP", stdout);
13515 break;
13516 case AFL_EXT_LOONGSON_3A:
13517 fputs ("Loongson 3A", stdout);
13518 break;
13519 case AFL_EXT_OCTEON:
13520 fputs ("Cavium Networks Octeon", stdout);
13521 break;
13522 case AFL_EXT_5900:
13523 fputs ("Toshiba R5900", stdout);
13524 break;
13525 case AFL_EXT_4650:
13526 fputs ("MIPS R4650", stdout);
13527 break;
13528 case AFL_EXT_4010:
13529 fputs ("LSI R4010", stdout);
13530 break;
13531 case AFL_EXT_4100:
13532 fputs ("NEC VR4100", stdout);
13533 break;
13534 case AFL_EXT_3900:
13535 fputs ("Toshiba R3900", stdout);
13536 break;
13537 case AFL_EXT_10000:
13538 fputs ("MIPS R10000", stdout);
13539 break;
13540 case AFL_EXT_SB1:
13541 fputs ("Broadcom SB-1", stdout);
13542 break;
13543 case AFL_EXT_4111:
13544 fputs ("NEC VR4111/VR4181", stdout);
13545 break;
13546 case AFL_EXT_4120:
13547 fputs ("NEC VR4120", stdout);
13548 break;
13549 case AFL_EXT_5400:
13550 fputs ("NEC VR5400", stdout);
13551 break;
13552 case AFL_EXT_5500:
13553 fputs ("NEC VR5500", stdout);
13554 break;
13555 case AFL_EXT_LOONGSON_2E:
13556 fputs ("ST Microelectronics Loongson 2E", stdout);
13557 break;
13558 case AFL_EXT_LOONGSON_2F:
13559 fputs ("ST Microelectronics Loongson 2F", stdout);
13560 break;
13561 default:
00ac7aa0 13562 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13563 }
13564}
13565
13566static int
13567get_mips_reg_size (int reg_size)
13568{
13569 return (reg_size == AFL_REG_NONE) ? 0
13570 : (reg_size == AFL_REG_32) ? 32
13571 : (reg_size == AFL_REG_64) ? 64
13572 : (reg_size == AFL_REG_128) ? 128
13573 : -1;
13574}
13575
19e6b90e 13576static int
2cf0635d 13577process_mips_specific (FILE * file)
5b18a4bc 13578{
2cf0635d 13579 Elf_Internal_Dyn * entry;
351cdf24 13580 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13581 size_t liblist_offset = 0;
13582 size_t liblistno = 0;
13583 size_t conflictsno = 0;
13584 size_t options_offset = 0;
13585 size_t conflicts_offset = 0;
861fb55a
DJ		 13586 size_t pltrelsz = 0;
13587 size_t pltrel = 0;
ccb4c951 13588 bfd_vma pltgot = 0;
861fb55a
DJ		 13589 bfd_vma mips_pltgot = 0;
13590 bfd_vma jmprel = 0;
ccb4c951
RS		 13591 bfd_vma local_gotno = 0;
13592 bfd_vma gotsym = 0;
13593 bfd_vma symtabno = 0;
103f02d3 13594
2cf19d5c
JM		 13595 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13596 display_mips_gnu_attribute);
13597
351cdf24
MF		 13598 sect = find_section (".MIPS.abiflags");
13599
13600 if (sect != NULL)
13601 {
13602 Elf_External_ABIFlags_v0 *abiflags_ext;
13603 Elf_Internal_ABIFlags_v0 abiflags_in;
13604
13605 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13606 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13607 else
13608 {
13609 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13610 sect->sh_size, _("MIPS ABI Flags section"));
13611 if (abiflags_ext)
13612 {
13613 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13614 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13615 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13616 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13617 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13618 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13619 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13620 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13621 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13622 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13623 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13624
13625 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13626 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13627 if (abiflags_in.isa_rev > 1)
13628 printf ("r%d", abiflags_in.isa_rev);
13629 printf ("\nGPR size: %d",
13630 get_mips_reg_size (abiflags_in.gpr_size));
13631 printf ("\nCPR1 size: %d",
13632 get_mips_reg_size (abiflags_in.cpr1_size));
13633 printf ("\nCPR2 size: %d",
13634 get_mips_reg_size (abiflags_in.cpr2_size));
13635 fputs ("\nFP ABI: ", stdout);
13636 print_mips_fp_abi_value (abiflags_in.fp_abi);
13637 fputs ("ISA Extension: ", stdout);
13638 print_mips_isa_ext (abiflags_in.isa_ext);
13639 fputs ("\nASEs:", stdout);
13640 print_mips_ases (abiflags_in.ases);
13641 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13642 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13643 fputc ('\n', stdout);
13644 free (abiflags_ext);
13645 }
13646 }
13647 }
13648
19e6b90e
L		 13649 /* We have a lot of special sections. Thanks SGI! */
13650 if (dynamic_section == NULL)
13651 /* No information available. */
13652 return 0;
252b5132 13653
071436c6
NC		 13654 for (entry = dynamic_section;
13655 /* PR 17531 file: 012-50589-0.004. */
13656 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13657 ++entry)
252b5132
RH		 13658 switch (entry->d_tag)
13659 {
13660 case DT_MIPS_LIBLIST:
d93f0186
NC		 13661 liblist_offset
13662 = offset_from_vma (file, entry->d_un.d_val,
13663 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13664 break;
13665 case DT_MIPS_LIBLISTNO:
13666 liblistno = entry->d_un.d_val;
13667 break;
13668 case DT_MIPS_OPTIONS:
d93f0186 13669 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13670 break;
13671 case DT_MIPS_CONFLICT:
d93f0186
NC		 13672 conflicts_offset
13673 = offset_from_vma (file, entry->d_un.d_val,
13674 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13675 break;
13676 case DT_MIPS_CONFLICTNO:
13677 conflictsno = entry->d_un.d_val;
13678 break;
ccb4c951 13679 case DT_PLTGOT:
861fb55a
DJ		 13680 pltgot = entry->d_un.d_ptr;
13681 break;
ccb4c951
RS		 13682 case DT_MIPS_LOCAL_GOTNO:
13683 local_gotno = entry->d_un.d_val;
13684 break;
13685 case DT_MIPS_GOTSYM:
13686 gotsym = entry->d_un.d_val;
13687 break;
13688 case DT_MIPS_SYMTABNO:
13689 symtabno = entry->d_un.d_val;
13690 break;
861fb55a
DJ		 13691 case DT_MIPS_PLTGOT:
13692 mips_pltgot = entry->d_un.d_ptr;
13693 break;
13694 case DT_PLTREL:
13695 pltrel = entry->d_un.d_val;
13696 break;
13697 case DT_PLTRELSZ:
13698 pltrelsz = entry->d_un.d_val;
13699 break;
13700 case DT_JMPREL:
13701 jmprel = entry->d_un.d_ptr;
13702 break;
252b5132
RH		 13703 default:
13704 break;
13705 }
13706
13707 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13708 {
2cf0635d 13709 Elf32_External_Lib * elib;
252b5132
RH		 13710 size_t cnt;
13711
3f5e193b
NC		 13712 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13713 liblistno,
13714 sizeof (Elf32_External_Lib),
9cf03b7e 13715 _("liblist section data"));
a6e9f9df 13716 if (elib)
252b5132 13717 {
2b692964 13718 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13719 (unsigned long) liblistno);
2b692964 13720 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13721 stdout);
13722
13723 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13724 {
a6e9f9df 13725 Elf32_Lib liblist;
91d6fa6a 13726 time_t atime;
a6e9f9df 13727 char timebuf[20];
2cf0635d 13728 struct tm * tmp;
a6e9f9df
AM		 13729
13730 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13731 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13732 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13733 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13734 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13735
91d6fa6a 13736 tmp = gmtime (&atime);
e9e44622
JJ		 13737 snprintf (timebuf, sizeof (timebuf),
13738 "%04u-%02u-%02uT%02u:%02u:%02u",
13739 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13740 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13741
31104126 13742 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13743 if (VALID_DYNAMIC_NAME (liblist.l_name))
13744 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13745 else
2b692964 13746 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13747 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13748 liblist.l_version);
a6e9f9df
AM		 13749
13750 if (liblist.l_flags == 0)
2b692964 13751 puts (_(" NONE"));
a6e9f9df
AM		 13752 else
13753 {
13754 static const struct
252b5132 13755 {
2cf0635d 13756 const char * name;
a6e9f9df 13757 int bit;
252b5132 13758 }
a6e9f9df
AM		 13759 l_flags_vals[] =
13760 {
13761 { " EXACT_MATCH", LL_EXACT_MATCH },
13762 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13763 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13764 { " EXPORTS", LL_EXPORTS },
13765 { " DELAY_LOAD", LL_DELAY_LOAD },
13766 { " DELTA", LL_DELTA }
13767 };
13768 int flags = liblist.l_flags;
13769 size_t fcnt;
13770
60bca95a 13771 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13772 if ((flags & l_flags_vals[fcnt].bit) != 0)
13773 {
13774 fputs (l_flags_vals[fcnt].name, stdout);
13775 flags ^= l_flags_vals[fcnt].bit;
13776 }
13777 if (flags != 0)
13778 printf (" %#x", (unsigned int) flags);
252b5132 13779
a6e9f9df
AM		 13780 puts ("");
13781 }
252b5132 13782 }
252b5132 13783
a6e9f9df
AM		 13784 free (elib);
13785 }
252b5132
RH		 13786 }
13787
13788 if (options_offset != 0)
13789 {
2cf0635d 13790 Elf_External_Options * eopt;
2cf0635d
NC		 13791 Elf_Internal_Options * iopt;
13792 Elf_Internal_Options * option;
252b5132
RH		 13793 size_t offset;
13794 int cnt;
351cdf24 13795 sect = section_headers;
252b5132
RH		 13796
13797 /* Find the section header so that we get the size. */
071436c6
NC		 13798 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13799 /* PR 17533 file: 012-277276-0.004. */
13800 if (sect == NULL)
13801 {
13802 error (_("No MIPS_OPTIONS header found\n"));
13803 return 0;
13804 }
252b5132 13805
3f5e193b
NC		 13806 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13807 sect->sh_size, _("options"));
a6e9f9df 13808 if (eopt)
252b5132 13809 {
3f5e193b
NC		 13810 iopt = (Elf_Internal_Options *)
13811 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13812 if (iopt == NULL)
13813 {
8b73c356 13814 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 13815 return 0;
13816 }
76da6bbe 13817
a6e9f9df
AM		 13818 offset = cnt = 0;
13819 option = iopt;
252b5132 13820
82b1b41b 13821 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 13822 {
2cf0635d 13823 Elf_External_Options * eoption;
252b5132 13824
a6e9f9df 13825 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13826
a6e9f9df
AM		 13827 option->kind = BYTE_GET (eoption->kind);
13828 option->size = BYTE_GET (eoption->size);
13829 option->section = BYTE_GET (eoption->section);
13830 option->info = BYTE_GET (eoption->info);
76da6bbe 13831
82b1b41b
NC		 13832 /* PR 17531: file: ffa0fa3b. */
13833 if (option->size < sizeof (* eopt)
13834 || offset + option->size > sect->sh_size)
13835 {
13836 warn (_("Invalid size (%u) for MIPS option\n"), option->size);
13837 option->size = sizeof (* eopt);
13838 break;
13839 }
a6e9f9df 13840 offset += option->size;
82b1b41b 13841
a6e9f9df
AM		 13842 ++option;
13843 ++cnt;
13844 }
252b5132 13845
a6e9f9df 13846 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 13847 printable_section_name (sect), cnt);
76da6bbe 13848
a6e9f9df 13849 option = iopt;
82b1b41b 13850 offset = 0;
252b5132 13851
a6e9f9df 13852 while (cnt-- > 0)
252b5132 13853 {
a6e9f9df
AM		 13854 size_t len;
13855
13856 switch (option->kind)
252b5132 13857 {
a6e9f9df
AM		 13858 case ODK_NULL:
13859 /* This shouldn't happen. */
13860 printf (" NULL %d %lx", option->section, option->info);
13861 break;
13862 case ODK_REGINFO:
13863 printf (" REGINFO ");
13864 if (elf_header.e_machine == EM_MIPS)
13865 {
13866 /* 32bit form. */
2cf0635d 13867 Elf32_External_RegInfo * ereg;
b34976b6 13868 Elf32_RegInfo reginfo;
a6e9f9df
AM		 13869
13870 ereg = (Elf32_External_RegInfo *) (option + 1);
13871 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13872 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13873 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13874 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13875 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13876 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13877
13878 printf ("GPR %08lx GP 0x%lx\n",
13879 reginfo.ri_gprmask,
13880 (unsigned long) reginfo.ri_gp_value);
13881 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13882 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13883 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13884 }
13885 else
13886 {
13887 /* 64 bit form. */
2cf0635d 13888 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 13889 Elf64_Internal_RegInfo reginfo;
13890
13891 ereg = (Elf64_External_RegInfo *) (option + 1);
13892 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13893 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13894 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13895 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13896 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 13897 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 13898
13899 printf ("GPR %08lx GP 0x",
13900 reginfo.ri_gprmask);
13901 printf_vma (reginfo.ri_gp_value);
13902 printf ("\n");
13903
13904 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13905 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13906 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13907 }
13908 ++option;
13909 continue;
13910 case ODK_EXCEPTIONS:
13911 fputs (" EXCEPTIONS fpe_min(", stdout);
13912 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13913 fputs (") fpe_max(", stdout);
13914 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13915 fputs (")", stdout);
13916
13917 if (option->info & OEX_PAGE0)
13918 fputs (" PAGE0", stdout);
13919 if (option->info & OEX_SMM)
13920 fputs (" SMM", stdout);
13921 if (option->info & OEX_FPDBUG)
13922 fputs (" FPDBUG", stdout);
13923 if (option->info & OEX_DISMISS)
13924 fputs (" DISMISS", stdout);
13925 break;
13926 case ODK_PAD:
13927 fputs (" PAD ", stdout);
13928 if (option->info & OPAD_PREFIX)
13929 fputs (" PREFIX", stdout);
13930 if (option->info & OPAD_POSTFIX)
13931 fputs (" POSTFIX", stdout);
13932 if (option->info & OPAD_SYMBOL)
13933 fputs (" SYMBOL", stdout);
13934 break;
13935 case ODK_HWPATCH:
13936 fputs (" HWPATCH ", stdout);
13937 if (option->info & OHW_R4KEOP)
13938 fputs (" R4KEOP", stdout);
13939 if (option->info & OHW_R8KPFETCH)
13940 fputs (" R8KPFETCH", stdout);
13941 if (option->info & OHW_R5KEOP)
13942 fputs (" R5KEOP", stdout);
13943 if (option->info & OHW_R5KCVTL)
13944 fputs (" R5KCVTL", stdout);
13945 break;
13946 case ODK_FILL:
13947 fputs (" FILL ", stdout);
13948 /* XXX Print content of info word? */
13949 break;
13950 case ODK_TAGS:
13951 fputs (" TAGS ", stdout);
13952 /* XXX Print content of info word? */
13953 break;
13954 case ODK_HWAND:
13955 fputs (" HWAND ", stdout);
13956 if (option->info & OHWA0_R4KEOP_CHECKED)
13957 fputs (" R4KEOP_CHECKED", stdout);
13958 if (option->info & OHWA0_R4KEOP_CLEAN)
13959 fputs (" R4KEOP_CLEAN", stdout);
13960 break;
13961 case ODK_HWOR:
13962 fputs (" HWOR ", stdout);
13963 if (option->info & OHWA0_R4KEOP_CHECKED)
13964 fputs (" R4KEOP_CHECKED", stdout);
13965 if (option->info & OHWA0_R4KEOP_CLEAN)
13966 fputs (" R4KEOP_CLEAN", stdout);
13967 break;
13968 case ODK_GP_GROUP:
13969 printf (" GP_GROUP %#06lx self-contained %#06lx",
13970 option->info & OGP_GROUP,
13971 (option->info & OGP_SELF) >> 16);
13972 break;
13973 case ODK_IDENT:
13974 printf (" IDENT %#06lx self-contained %#06lx",
13975 option->info & OGP_GROUP,
13976 (option->info & OGP_SELF) >> 16);
13977 break;
13978 default:
13979 /* This shouldn't happen. */
13980 printf (" %3d ??? %d %lx",
13981 option->kind, option->section, option->info);
13982 break;
252b5132 13983 }
a6e9f9df 13984
2cf0635d 13985 len = sizeof (* eopt);
a6e9f9df 13986 while (len < option->size)
82b1b41b
NC		 13987 {
13988 char datum = * ((char *) eopt + offset + len);
a6e9f9df 13989
82b1b41b
NC		 13990 if (ISPRINT (datum))
13991 printf ("%c", datum);
13992 else
13993 printf ("\\%03o", datum);
13994 len ++;
13995 }
a6e9f9df 13996 fputs ("\n", stdout);
82b1b41b
NC		 13997
13998 offset += option->size;
252b5132 13999 ++option;
252b5132
RH		 14000 }
14001
a6e9f9df 14002 free (eopt);
252b5132 14003 }
252b5132
RH		 14004 }
14005
14006 if (conflicts_offset != 0 && conflictsno != 0)
14007 {
2cf0635d 14008 Elf32_Conflict * iconf;
252b5132
RH		 14009 size_t cnt;
14010
14011 if (dynamic_symbols == NULL)
14012 {
591a748a 14013 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14014 return 0;
14015 }
14016
3f5e193b 14017 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14018 if (iconf == NULL)
14019 {
8b73c356 14020 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14021 return 0;
14022 }
14023
9ea033b2 14024 if (is_32bit_elf)
252b5132 14025 {
2cf0635d 14026 Elf32_External_Conflict * econf32;
a6e9f9df 14027
3f5e193b
NC		 14028 econf32 = (Elf32_External_Conflict *)
14029 get_data (NULL, file, conflicts_offset, conflictsno,
14030 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14031 if (!econf32)
14032 return 0;
252b5132
RH		 14033
14034 for (cnt = 0; cnt < conflictsno; ++cnt)
14035 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14036
14037 free (econf32);
252b5132
RH		 14038 }
14039 else
14040 {
2cf0635d 14041 Elf64_External_Conflict * econf64;
a6e9f9df 14042
3f5e193b
NC		 14043 econf64 = (Elf64_External_Conflict *)
14044 get_data (NULL, file, conflicts_offset, conflictsno,
14045 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14046 if (!econf64)
14047 return 0;
252b5132
RH		 14048
14049 for (cnt = 0; cnt < conflictsno; ++cnt)
14050 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14051
14052 free (econf64);
252b5132
RH		 14053 }
14054
c7e7ca54
NC		 14055 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14056 (unsigned long) conflictsno);
252b5132
RH		 14057 puts (_(" Num: Index Value Name"));
14058
14059 for (cnt = 0; cnt < conflictsno; ++cnt)
14060 {
b34976b6 14061 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14062
14063 if (iconf[cnt] >= num_dynamic_syms)
14064 printf (_("<corrupt symbol index>"));
d79b3d50 14065 else
e0a31db1
NC		 14066 {
14067 Elf_Internal_Sym * psym;
14068
14069 psym = & dynamic_symbols[iconf[cnt]];
14070 print_vma (psym->st_value, FULL_HEX);
14071 putchar (' ');
14072 if (VALID_DYNAMIC_NAME (psym->st_name))
14073 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14074 else
14075 printf (_("<corrupt: %14ld>"), psym->st_name);
14076 }
31104126 14077 putchar ('\n');
252b5132
RH		 14078 }
14079
252b5132
RH		 14080 free (iconf);
14081 }
14082
ccb4c951
RS		 14083 if (pltgot != 0 && local_gotno != 0)
14084 {
91d6fa6a 14085 bfd_vma ent, local_end, global_end;
bbeee7ea 14086 size_t i, offset;
2cf0635d 14087 unsigned char * data;
82b1b41b 14088 unsigned char * data_end;
bbeee7ea 14089 int addr_size;
ccb4c951 14090
91d6fa6a 14091 ent = pltgot;
ccb4c951
RS		 14092 addr_size = (is_32bit_elf ? 4 : 8);
14093 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14094
74e1a04b
NC		 14095 /* PR binutils/17533 file: 012-111227-0.004 */
14096 if (symtabno < gotsym)
14097 {
14098 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14099 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14100 return 0;
14101 }
82b1b41b 14102
74e1a04b 14103 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14104 /* PR 17531: file: 54c91a34. */
14105 if (global_end < local_end)
14106 {
14107 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14108 return 0;
14109 }
14110
ccb4c951 14111 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14112 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14113 global_end - pltgot, 1,
14114 _("Global Offset Table data"));
59245841
NC		 14115 if (data == NULL)
14116 return 0;
82b1b41b 14117 data_end = data + (global_end - pltgot);
59245841 14118
ccb4c951
RS		 14119 printf (_("\nPrimary GOT:\n"));
14120 printf (_(" Canonical gp value: "));
14121 print_vma (pltgot + 0x7ff0, LONG_HEX);
14122 printf ("\n\n");
14123
14124 printf (_(" Reserved entries:\n"));
14125 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14126 addr_size * 2, _("Address"), _("Access"),
14127 addr_size * 2, _("Initial"));
82b1b41b 14128 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14129 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14130 if (ent == (bfd_vma) -1)
14131 goto got_print_fail;
ccb4c951 14132 if (data
91d6fa6a 14133 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14134 >> (addr_size * 8 - 1)) != 0)
14135 {
82b1b41b 14136 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14137 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14138 if (ent == (bfd_vma) -1)
14139 goto got_print_fail;
ccb4c951
RS		 14140 }
14141 printf ("\n");
14142
91d6fa6a 14143 if (ent < local_end)
ccb4c951
RS		 14144 {
14145 printf (_(" Local entries:\n"));
cc5914eb 14146 printf (" %*s %10s %*s\n",
2b692964
NC		 14147 addr_size * 2, _("Address"), _("Access"),
14148 addr_size * 2, _("Initial"));
91d6fa6a 14149 while (ent < local_end)
ccb4c951 14150 {
82b1b41b 14151 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14152 printf ("\n");
82b1b41b
NC		 14153 if (ent == (bfd_vma) -1)
14154 goto got_print_fail;
ccb4c951
RS		 14155 }
14156 printf ("\n");
14157 }
14158
14159 if (gotsym < symtabno)
14160 {
14161 int sym_width;
14162
14163 printf (_(" Global entries:\n"));
cc5914eb 14164 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14165 addr_size * 2, _("Address"),
14166 _("Access"),
2b692964 14167 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14168 addr_size * 2, _("Sym.Val."),
14169 _("Type"),
14170 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14171 _("Ndx"), _("Name"));
0b4362b0 14172
ccb4c951 14173 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14174
ccb4c951
RS		 14175 for (i = gotsym; i < symtabno; i++)
14176 {
82b1b41b 14177 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14178 printf (" ");
e0a31db1
NC		 14179
14180 if (dynamic_symbols == NULL)
14181 printf (_("<no dynamic symbols>"));
14182 else if (i < num_dynamic_syms)
14183 {
14184 Elf_Internal_Sym * psym = dynamic_symbols + i;
14185
14186 print_vma (psym->st_value, LONG_HEX);
14187 printf (" %-7s %3s ",
14188 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14189 get_symbol_index_type (psym->st_shndx));
14190
14191 if (VALID_DYNAMIC_NAME (psym->st_name))
14192 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14193 else
14194 printf (_("<corrupt: %14ld>"), psym->st_name);
14195 }
ccb4c951 14196 else
7fc5ac57
JBG		 14197 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14198 (unsigned long) i);
e0a31db1 14199
ccb4c951 14200 printf ("\n");
82b1b41b
NC		 14201 if (ent == (bfd_vma) -1)
14202 break;
ccb4c951
RS		 14203 }
14204 printf ("\n");
14205 }
14206
82b1b41b 14207 got_print_fail:
ccb4c951
RS		 14208 if (data)
14209 free (data);
14210 }
14211
861fb55a
DJ		 14212 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14213 {
91d6fa6a 14214 bfd_vma ent, end;
861fb55a
DJ		 14215 size_t offset, rel_offset;
14216 unsigned long count, i;
2cf0635d 14217 unsigned char * data;
861fb55a 14218 int addr_size, sym_width;
2cf0635d 14219 Elf_Internal_Rela * rels;
861fb55a
DJ		 14220
14221 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14222 if (pltrel == DT_RELA)
14223 {
14224 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14225 return 0;
14226 }
14227 else
14228 {
14229 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14230 return 0;
14231 }
14232
91d6fa6a 14233 ent = mips_pltgot;
861fb55a
DJ		 14234 addr_size = (is_32bit_elf ? 4 : 8);
14235 end = mips_pltgot + (2 + count) * addr_size;
14236
14237 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14238 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14239 1, _("Procedure Linkage Table data"));
59245841
NC		 14240 if (data == NULL)
14241 return 0;
14242
9cf03b7e 14243 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14244 printf (_(" Reserved entries:\n"));
14245 printf (_(" %*s %*s Purpose\n"),
2b692964 14246 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14247 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14248 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14249 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14250 printf (_(" Module pointer\n"));
861fb55a
DJ		 14251 printf ("\n");
14252
14253 printf (_(" Entries:\n"));
cc5914eb 14254 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14255 addr_size * 2, _("Address"),
14256 addr_size * 2, _("Initial"),
14257 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14258 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14259 for (i = 0; i < count; i++)
14260 {
df97ab2a 14261 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14262
91d6fa6a 14263 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14264 printf (" ");
e0a31db1 14265
df97ab2a
MF		 14266 if (idx >= num_dynamic_syms)
14267 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14268 else
e0a31db1 14269 {
df97ab2a 14270 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14271
14272 print_vma (psym->st_value, LONG_HEX);
14273 printf (" %-7s %3s ",
14274 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14275 get_symbol_index_type (psym->st_shndx));
14276 if (VALID_DYNAMIC_NAME (psym->st_name))
14277 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14278 else
14279 printf (_("<corrupt: %14ld>"), psym->st_name);
14280 }
861fb55a
DJ		 14281 printf ("\n");
14282 }
14283 printf ("\n");
14284
14285 if (data)
14286 free (data);
14287 free (rels);
14288 }
14289
252b5132
RH		 14290 return 1;
14291}
14292
35c08157
KLC		 14293static int
14294process_nds32_specific (FILE * file)
14295{
14296 Elf_Internal_Shdr *sect = NULL;
14297
14298 sect = find_section (".nds32_e_flags");
14299 if (sect != NULL)
14300 {
14301 unsigned int *flag;
14302
14303 printf ("\nNDS32 elf flags section:\n");
14304 flag = get_data (NULL, file, sect->sh_offset, 1,
14305 sect->sh_size, _("NDS32 elf flags section"));
14306
14307 switch ((*flag) & 0x3)
14308 {
14309 case 0:
14310 printf ("(VEC_SIZE):\tNo entry.\n");
14311 break;
14312 case 1:
14313 printf ("(VEC_SIZE):\t4 bytes\n");
14314 break;
14315 case 2:
14316 printf ("(VEC_SIZE):\t16 bytes\n");
14317 break;
14318 case 3:
14319 printf ("(VEC_SIZE):\treserved\n");
14320 break;
14321 }
14322 }
14323
14324 return TRUE;
14325}
14326
047b2264 14327static int
2cf0635d 14328process_gnu_liblist (FILE * file)
047b2264 14329{
2cf0635d
NC		 14330 Elf_Internal_Shdr * section;
14331 Elf_Internal_Shdr * string_sec;
14332 Elf32_External_Lib * elib;
14333 char * strtab;
c256ffe7 14334 size_t strtab_size;
047b2264
JJ		 14335 size_t cnt;
14336 unsigned i;
14337
14338 if (! do_arch)
14339 return 0;
14340
14341 for (i = 0, section = section_headers;
14342 i < elf_header.e_shnum;
b34976b6 14343 i++, section++)
047b2264
JJ		 14344 {
14345 switch (section->sh_type)
14346 {
14347 case SHT_GNU_LIBLIST:
4fbb74a6 14348 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14349 break;
14350
3f5e193b
NC		 14351 elib = (Elf32_External_Lib *)
14352 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14353 _("liblist section data"));
047b2264
JJ		 14354
14355 if (elib == NULL)
14356 break;
4fbb74a6 14357 string_sec = section_headers + section->sh_link;
047b2264 14358
3f5e193b
NC		 14359 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14360 string_sec->sh_size,
14361 _("liblist string table"));
047b2264
JJ		 14362 if (strtab == NULL
14363 || section->sh_entsize != sizeof (Elf32_External_Lib))
14364 {
14365 free (elib);
2842702f 14366 free (strtab);
047b2264
JJ		 14367 break;
14368 }
59245841 14369 strtab_size = string_sec->sh_size;
047b2264
JJ		 14370
14371 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14372 printable_section_name (section),
0af1713e 14373 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14374
2b692964 14375 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14376
14377 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14378 ++cnt)
14379 {
14380 Elf32_Lib liblist;
91d6fa6a 14381 time_t atime;
047b2264 14382 char timebuf[20];
2cf0635d 14383 struct tm * tmp;
047b2264
JJ		 14384
14385 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14386 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14387 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14388 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14389 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14390
91d6fa6a 14391 tmp = gmtime (&atime);
e9e44622
JJ		 14392 snprintf (timebuf, sizeof (timebuf),
14393 "%04u-%02u-%02uT%02u:%02u:%02u",
14394 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14395 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14396
14397 printf ("%3lu: ", (unsigned long) cnt);
14398 if (do_wide)
c256ffe7 14399 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14400 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14401 else
c256ffe7 14402 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14403 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14404 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14405 liblist.l_version, liblist.l_flags);
14406 }
14407
14408 free (elib);
2842702f 14409 free (strtab);
047b2264
JJ		 14410 }
14411 }
14412
14413 return 1;
14414}
14415
9437c45b 14416static const char *
d3ba0551 14417get_note_type (unsigned e_type)
779fe533
NC		 14418{
14419 static char buff[64];
103f02d3 14420
1ec5cd37
NC		 14421 if (elf_header.e_type == ET_CORE)
14422 switch (e_type)
14423 {
57346661 14424 case NT_AUXV:
1ec5cd37 14425 return _("NT_AUXV (auxiliary vector)");
57346661 14426 case NT_PRSTATUS:
1ec5cd37 14427 return _("NT_PRSTATUS (prstatus structure)");
57346661 14428 case NT_FPREGSET:
1ec5cd37 14429 return _("NT_FPREGSET (floating point registers)");
57346661 14430 case NT_PRPSINFO:
1ec5cd37 14431 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14432 case NT_TASKSTRUCT:
1ec5cd37 14433 return _("NT_TASKSTRUCT (task structure)");
57346661 14434 case NT_PRXFPREG:
1ec5cd37 14435 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14436 case NT_PPC_VMX:
14437 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14438 case NT_PPC_VSX:
14439 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14440 case NT_386_TLS:
14441 return _("NT_386_TLS (x86 TLS information)");
14442 case NT_386_IOPERM:
14443 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14444 case NT_X86_XSTATE:
14445 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14446 case NT_S390_HIGH_GPRS:
14447 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14448 case NT_S390_TIMER:
14449 return _("NT_S390_TIMER (s390 timer register)");
14450 case NT_S390_TODCMP:
14451 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14452 case NT_S390_TODPREG:
14453 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14454 case NT_S390_CTRS:
14455 return _("NT_S390_CTRS (s390 control registers)");
14456 case NT_S390_PREFIX:
14457 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14458 case NT_S390_LAST_BREAK:
14459 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14460 case NT_S390_SYSTEM_CALL:
14461 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14462 case NT_S390_TDB:
14463 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW		 14464 case NT_ARM_VFP:
14465 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14466 case NT_ARM_TLS:
14467 return _("NT_ARM_TLS (AArch TLS registers)");
14468 case NT_ARM_HW_BREAK:
14469 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14470 case NT_ARM_HW_WATCH:
14471 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14472 case NT_PSTATUS:
1ec5cd37 14473 return _("NT_PSTATUS (pstatus structure)");
57346661 14474 case NT_FPREGS:
1ec5cd37 14475 return _("NT_FPREGS (floating point registers)");
57346661 14476 case NT_PSINFO:
1ec5cd37 14477 return _("NT_PSINFO (psinfo structure)");
57346661 14478 case NT_LWPSTATUS:
1ec5cd37 14479 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14480 case NT_LWPSINFO:
1ec5cd37 14481 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14482 case NT_WIN32PSTATUS:
1ec5cd37 14483 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14484 case NT_SIGINFO:
14485 return _("NT_SIGINFO (siginfo_t data)");
14486 case NT_FILE:
14487 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14488 default:
14489 break;
14490 }
14491 else
14492 switch (e_type)
14493 {
14494 case NT_VERSION:
14495 return _("NT_VERSION (version)");
14496 case NT_ARCH:
14497 return _("NT_ARCH (architecture)");
14498 default:
14499 break;
14500 }
14501
e9e44622 14502 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14503 return buff;
779fe533
NC		 14504}
14505
9ece1fa9
TT		 14506static int
14507print_core_note (Elf_Internal_Note *pnote)
14508{
14509 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14510 bfd_vma count, page_size;
14511 unsigned char *descdata, *filenames, *descend;
14512
14513 if (pnote->type != NT_FILE)
14514 return 1;
14515
14516#ifndef BFD64
14517 if (!is_32bit_elf)
14518 {
14519 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14520 /* Still "successful". */
14521 return 1;
14522 }
14523#endif
14524
14525 if (pnote->descsz < 2 * addr_size)
14526 {
14527 printf (_(" Malformed note - too short for header\n"));
14528 return 0;
14529 }
14530
14531 descdata = (unsigned char *) pnote->descdata;
14532 descend = descdata + pnote->descsz;
14533
14534 if (descdata[pnote->descsz - 1] != '\0')
14535 {
14536 printf (_(" Malformed note - does not end with \\0\n"));
14537 return 0;
14538 }
14539
14540 count = byte_get (descdata, addr_size);
14541 descdata += addr_size;
14542
14543 page_size = byte_get (descdata, addr_size);
14544 descdata += addr_size;
14545
14546 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14547 {
14548 printf (_(" Malformed note - too short for supplied file count\n"));
14549 return 0;
14550 }
14551
14552 printf (_(" Page size: "));
14553 print_vma (page_size, DEC);
14554 printf ("\n");
14555
14556 printf (_(" %*s%*s%*s\n"),
14557 (int) (2 + 2 * addr_size), _("Start"),
14558 (int) (4 + 2 * addr_size), _("End"),
14559 (int) (4 + 2 * addr_size), _("Page Offset"));
14560 filenames = descdata + count * 3 * addr_size;
14561 while (--count > 0)
14562 {
14563 bfd_vma start, end, file_ofs;
14564
14565 if (filenames == descend)
14566 {
14567 printf (_(" Malformed note - filenames end too early\n"));
14568 return 0;
14569 }
14570
14571 start = byte_get (descdata, addr_size);
14572 descdata += addr_size;
14573 end = byte_get (descdata, addr_size);
14574 descdata += addr_size;
14575 file_ofs = byte_get (descdata, addr_size);
14576 descdata += addr_size;
14577
14578 printf (" ");
14579 print_vma (start, FULL_HEX);
14580 printf (" ");
14581 print_vma (end, FULL_HEX);
14582 printf (" ");
14583 print_vma (file_ofs, FULL_HEX);
14584 printf ("\n %s\n", filenames);
14585
14586 filenames += 1 + strlen ((char *) filenames);
14587 }
14588
14589 return 1;
14590}
14591
1118d252
RM		 14592static const char *
14593get_gnu_elf_note_type (unsigned e_type)
14594{
14595 static char buff[64];
14596
14597 switch (e_type)
14598 {
14599 case NT_GNU_ABI_TAG:
14600 return _("NT_GNU_ABI_TAG (ABI version tag)");
14601 case NT_GNU_HWCAP:
14602 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14603 case NT_GNU_BUILD_ID:
14604 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14605 case NT_GNU_GOLD_VERSION:
14606 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14607 default:
14608 break;
14609 }
14610
14611 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14612 return buff;
14613}
14614
664f90a3
TT		 14615static int
14616print_gnu_note (Elf_Internal_Note *pnote)
14617{
14618 switch (pnote->type)
14619 {
14620 case NT_GNU_BUILD_ID:
14621 {
14622 unsigned long i;
14623
14624 printf (_(" Build ID: "));
14625 for (i = 0; i < pnote->descsz; ++i)
14626 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14627 printf ("\n");
664f90a3
TT		 14628 }
14629 break;
14630
14631 case NT_GNU_ABI_TAG:
14632 {
14633 unsigned long os, major, minor, subminor;
14634 const char *osname;
14635
3102e897
NC		 14636 /* PR 17531: file: 030-599401-0.004. */
14637 if (pnote->descsz < 16)
14638 {
14639 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14640 break;
14641 }
14642
664f90a3
TT		 14643 os = byte_get ((unsigned char *) pnote->descdata, 4);
14644 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14645 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14646 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14647
14648 switch (os)
14649 {
14650 case GNU_ABI_TAG_LINUX:
14651 osname = "Linux";
14652 break;
14653 case GNU_ABI_TAG_HURD:
14654 osname = "Hurd";
14655 break;
14656 case GNU_ABI_TAG_SOLARIS:
14657 osname = "Solaris";
14658 break;
14659 case GNU_ABI_TAG_FREEBSD:
14660 osname = "FreeBSD";
14661 break;
14662 case GNU_ABI_TAG_NETBSD:
14663 osname = "NetBSD";
14664 break;
14665 default:
14666 osname = "Unknown";
14667 break;
14668 }
14669
14670 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14671 major, minor, subminor);
14672 }
14673 break;
926c5385
CC		 14674
14675 case NT_GNU_GOLD_VERSION:
14676 {
14677 unsigned long i;
14678
14679 printf (_(" Version: "));
14680 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14681 printf ("%c", pnote->descdata[i]);
14682 printf ("\n");
14683 }
14684 break;
664f90a3
TT		 14685 }
14686
14687 return 1;
14688}
14689
9437c45b 14690static const char *
d3ba0551 14691get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14692{
14693 static char buff[64];
14694
b4db1224 14695 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14696 {
14697 /* NetBSD core "procinfo" structure. */
14698 return _("NetBSD procinfo structure");
14699 }
14700
14701 /* As of Jan 2002 there are no other machine-independent notes
14702 defined for NetBSD core files. If the note type is less
14703 than the start of the machine-dependent note types, we don't
14704 understand it. */
14705
b4db1224 14706 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14707 {
e9e44622 14708 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14709 return buff;
14710 }
14711
14712 switch (elf_header.e_machine)
14713 {
14714 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14715 and PT_GETFPREGS == mach+2. */
14716
14717 case EM_OLD_ALPHA:
14718 case EM_ALPHA:
14719 case EM_SPARC:
14720 case EM_SPARC32PLUS:
14721 case EM_SPARCV9:
14722 switch (e_type)
14723 {
2b692964 14724 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 14725 return _("PT_GETREGS (reg structure)");
2b692964 14726 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 14727 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14728 default:
14729 break;
14730 }
14731 break;
14732
14733 /* On all other arch's, PT_GETREGS == mach+1 and
14734 PT_GETFPREGS == mach+3. */
14735 default:
14736 switch (e_type)
14737 {
2b692964 14738 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 14739 return _("PT_GETREGS (reg structure)");
2b692964 14740 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 14741 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14742 default:
14743 break;
14744 }
14745 }
14746
9cf03b7e 14747 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 14748 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 14749 return buff;
14750}
14751
70616151
TT		 14752static const char *
14753get_stapsdt_note_type (unsigned e_type)
14754{
14755 static char buff[64];
14756
14757 switch (e_type)
14758 {
14759 case NT_STAPSDT:
14760 return _("NT_STAPSDT (SystemTap probe descriptors)");
14761
14762 default:
14763 break;
14764 }
14765
14766 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14767 return buff;
14768}
14769
c6a9fc58
TT		 14770static int
14771print_stapsdt_note (Elf_Internal_Note *pnote)
14772{
14773 int addr_size = is_32bit_elf ? 4 : 8;
14774 char *data = pnote->descdata;
14775 char *data_end = pnote->descdata + pnote->descsz;
14776 bfd_vma pc, base_addr, semaphore;
14777 char *provider, *probe, *arg_fmt;
14778
14779 pc = byte_get ((unsigned char *) data, addr_size);
14780 data += addr_size;
14781 base_addr = byte_get ((unsigned char *) data, addr_size);
14782 data += addr_size;
14783 semaphore = byte_get ((unsigned char *) data, addr_size);
14784 data += addr_size;
14785
14786 provider = data;
14787 data += strlen (data) + 1;
14788 probe = data;
14789 data += strlen (data) + 1;
14790 arg_fmt = data;
14791 data += strlen (data) + 1;
14792
14793 printf (_(" Provider: %s\n"), provider);
14794 printf (_(" Name: %s\n"), probe);
14795 printf (_(" Location: "));
14796 print_vma (pc, FULL_HEX);
14797 printf (_(", Base: "));
14798 print_vma (base_addr, FULL_HEX);
14799 printf (_(", Semaphore: "));
14800 print_vma (semaphore, FULL_HEX);
9cf03b7e 14801 printf ("\n");
c6a9fc58
TT		 14802 printf (_(" Arguments: %s\n"), arg_fmt);
14803
14804 return data == data_end;
14805}
14806
00e98fc7
TG		 14807static const char *
14808get_ia64_vms_note_type (unsigned e_type)
14809{
14810 static char buff[64];
14811
14812 switch (e_type)
14813 {
14814 case NT_VMS_MHD:
14815 return _("NT_VMS_MHD (module header)");
14816 case NT_VMS_LNM:
14817 return _("NT_VMS_LNM (language name)");
14818 case NT_VMS_SRC:
14819 return _("NT_VMS_SRC (source files)");
14820 case NT_VMS_TITLE:
9cf03b7e 14821 return "NT_VMS_TITLE";
00e98fc7
TG		 14822 case NT_VMS_EIDC:
14823 return _("NT_VMS_EIDC (consistency check)");
14824 case NT_VMS_FPMODE:
14825 return _("NT_VMS_FPMODE (FP mode)");
14826 case NT_VMS_LINKTIME:
9cf03b7e 14827 return "NT_VMS_LINKTIME";
00e98fc7
TG		 14828 case NT_VMS_IMGNAM:
14829 return _("NT_VMS_IMGNAM (image name)");
14830 case NT_VMS_IMGID:
14831 return _("NT_VMS_IMGID (image id)");
14832 case NT_VMS_LINKID:
14833 return _("NT_VMS_LINKID (link id)");
14834 case NT_VMS_IMGBID:
14835 return _("NT_VMS_IMGBID (build id)");
14836 case NT_VMS_GSTNAM:
14837 return _("NT_VMS_GSTNAM (sym table name)");
14838 case NT_VMS_ORIG_DYN:
9cf03b7e 14839 return "NT_VMS_ORIG_DYN";
00e98fc7 14840 case NT_VMS_PATCHTIME:
9cf03b7e 14841 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 14842 default:
14843 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14844 return buff;
14845 }
14846}
14847
14848static int
14849print_ia64_vms_note (Elf_Internal_Note * pnote)
14850{
14851 switch (pnote->type)
14852 {
14853 case NT_VMS_MHD:
14854 if (pnote->descsz > 36)
14855 {
14856 size_t l = strlen (pnote->descdata + 34);
14857 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14858 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14859 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14860 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14861 }
14862 else
14863 printf (_(" Invalid size\n"));
14864 break;
14865 case NT_VMS_LNM:
14866 printf (_(" Language: %s\n"), pnote->descdata);
14867 break;
14868#ifdef BFD64
14869 case NT_VMS_FPMODE:
9cf03b7e 14870 printf (_(" Floating Point mode: "));
4a5cb34f 14871 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14872 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14873 break;
14874 case NT_VMS_LINKTIME:
14875 printf (_(" Link time: "));
14876 print_vms_time
14877 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14878 printf ("\n");
14879 break;
14880 case NT_VMS_PATCHTIME:
14881 printf (_(" Patch time: "));
14882 print_vms_time
14883 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14884 printf ("\n");
14885 break;
14886 case NT_VMS_ORIG_DYN:
14887 printf (_(" Major id: %u, minor id: %u\n"),
14888 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14889 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 14890 printf (_(" Last modified : "));
00e98fc7
TG		 14891 print_vms_time
14892 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 14893 printf (_("\n Link flags : "));
4a5cb34f 14894 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14895 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14896 printf (_(" Header flags: 0x%08x\n"),
14897 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14898 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14899 break;
14900#endif
14901 case NT_VMS_IMGNAM:
14902 printf (_(" Image name: %s\n"), pnote->descdata);
14903 break;
14904 case NT_VMS_GSTNAM:
14905 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14906 break;
14907 case NT_VMS_IMGID:
14908 printf (_(" Image id: %s\n"), pnote->descdata);
14909 break;
14910 case NT_VMS_LINKID:
14911 printf (_(" Linker id: %s\n"), pnote->descdata);
14912 break;
14913 default:
14914 break;
14915 }
14916 return 1;
14917}
14918
6d118b09
NC		 14919/* Note that by the ELF standard, the name field is already null byte
14920 terminated, and namesz includes the terminating null byte.
14921 I.E. the value of namesz for the name "FSF" is 4.
14922
e3c8793a 14923 If the value of namesz is zero, there is no name present. */
779fe533 14924static int
2cf0635d 14925process_note (Elf_Internal_Note * pnote)
779fe533 14926{
2cf0635d
NC		 14927 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14928 const char * nt;
9437c45b
JT		 14929
14930 if (pnote->namesz == 0)
1ec5cd37
NC		 14931 /* If there is no note name, then use the default set of
14932 note type strings. */
14933 nt = get_note_type (pnote->type);
14934
1118d252
RM		 14935 else if (const_strneq (pnote->namedata, "GNU"))
14936 /* GNU-specific object file notes. */
14937 nt = get_gnu_elf_note_type (pnote->type);
14938
0112cd26 14939 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 14940 /* NetBSD-specific core file notes. */
14941 nt = get_netbsd_elfcore_note_type (pnote->type);
14942
b15fa79e
AM		 14943 else if (strneq (pnote->namedata, "SPU/", 4))
14944 {
14945 /* SPU-specific core file notes. */
14946 nt = pnote->namedata + 4;
14947 name = "SPU";
14948 }
14949
00e98fc7
TG		 14950 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14951 /* VMS/ia64-specific file notes. */
14952 nt = get_ia64_vms_note_type (pnote->type);
14953
70616151
TT		 14954 else if (const_strneq (pnote->namedata, "stapsdt"))
14955 nt = get_stapsdt_note_type (pnote->type);
14956
9437c45b 14957 else
1ec5cd37
NC		 14958 /* Don't recognize this note name; just use the default set of
14959 note type strings. */
00e98fc7 14960 nt = get_note_type (pnote->type);
9437c45b 14961
2aee03ae 14962 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 14963
14964 if (const_strneq (pnote->namedata, "IPF/VMS"))
14965 return print_ia64_vms_note (pnote);
664f90a3
TT		 14966 else if (const_strneq (pnote->namedata, "GNU"))
14967 return print_gnu_note (pnote);
c6a9fc58
TT		 14968 else if (const_strneq (pnote->namedata, "stapsdt"))
14969 return print_stapsdt_note (pnote);
9ece1fa9
TT		 14970 else if (const_strneq (pnote->namedata, "CORE"))
14971 return print_core_note (pnote);
00e98fc7
TG		 14972 else
14973 return 1;
779fe533
NC		 14974}
14975
6d118b09 14976
779fe533 14977static int
2cf0635d 14978process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 14979{
2cf0635d
NC		 14980 Elf_External_Note * pnotes;
14981 Elf_External_Note * external;
b34976b6 14982 int res = 1;
103f02d3 14983
779fe533
NC		 14984 if (length <= 0)
14985 return 0;
103f02d3 14986
3f5e193b 14987 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 14988 _("notes"));
dd24e3da 14989 if (pnotes == NULL)
a6e9f9df 14990 return 0;
779fe533 14991
103f02d3 14992 external = pnotes;
103f02d3 14993
9dd3a467 14994 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 14995 (unsigned long) offset, (unsigned long) length);
2aee03ae 14996 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 14997
15b42fb0 14998 while ((char *) external < (char *) pnotes + length)
779fe533 14999 {
b34976b6 15000 Elf_Internal_Note inote;
15b42fb0
AM		 15001 size_t min_notesz;
15002 char *next;
2cf0635d 15003 char * temp = NULL;
15b42fb0 15004 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 15005
00e98fc7 15006 if (!is_ia64_vms ())
15b42fb0 15007 {
9dd3a467
NC		 15008 /* PR binutils/15191
15009 Make sure that there is enough data to read. */
15b42fb0
AM		 15010 min_notesz = offsetof (Elf_External_Note, name);
15011 if (data_remaining < min_notesz)
9dd3a467
NC		 15012 {
15013 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15014 (int) data_remaining);
15015 break;
15016 }
15b42fb0
AM		 15017 inote.type = BYTE_GET (external->type);
15018 inote.namesz = BYTE_GET (external->namesz);
15019 inote.namedata = external->name;
15020 inote.descsz = BYTE_GET (external->descsz);
15021 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15022 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15023 next = inote.descdata + align_power (inote.descsz, 2);
15024 }
00e98fc7 15025 else
15b42fb0
AM		 15026 {
15027 Elf64_External_VMS_Note *vms_external;
00e98fc7 15028
9dd3a467
NC		 15029 /* PR binutils/15191
15030 Make sure that there is enough data to read. */
15b42fb0
AM		 15031 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15032 if (data_remaining < min_notesz)
9dd3a467
NC		 15033 {
15034 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15035 (int) data_remaining);
15036 break;
15037 }
3e55a963 15038
15b42fb0
AM		 15039 vms_external = (Elf64_External_VMS_Note *) external;
15040 inote.type = BYTE_GET (vms_external->type);
15041 inote.namesz = BYTE_GET (vms_external->namesz);
15042 inote.namedata = vms_external->name;
15043 inote.descsz = BYTE_GET (vms_external->descsz);
15044 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15045 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15046 next = inote.descdata + align_power (inote.descsz, 3);
15047 }
15048
15049 if (inote.descdata < (char *) external + min_notesz
15050 || next < (char *) external + min_notesz
5d921cbd
NC		 15051 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15052 || inote.namedata + inote.namesz < inote.namedata
15053 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15054 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15055 {
15b42fb0 15056 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15057 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15058 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15059 inote.type, inote.namesz, inote.descsz);
15060 break;
15061 }
15062
15b42fb0 15063 external = (Elf_External_Note *) next;
dd24e3da 15064
6d118b09
NC		 15065 /* Verify that name is null terminated. It appears that at least
15066 one version of Linux (RedHat 6.0) generates corefiles that don't
15067 comply with the ELF spec by failing to include the null byte in
15068 namesz. */
8b971f9f 15069 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15070 {
3f5e193b 15071 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15072 if (temp == NULL)
15073 {
8b73c356 15074 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15075 res = 0;
15076 break;
15077 }
76da6bbe 15078
6d118b09
NC		 15079 strncpy (temp, inote.namedata, inote.namesz);
15080 temp[inote.namesz] = 0;
76da6bbe 15081
6d118b09
NC		 15082 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15083 inote.namedata = temp;
15084 }
15085
15086 res &= process_note (& inote);
103f02d3 15087
6d118b09
NC		 15088 if (temp != NULL)
15089 {
15090 free (temp);
15091 temp = NULL;
15092 }
779fe533
NC		 15093 }
15094
15095 free (pnotes);
103f02d3 15096
779fe533
NC		 15097 return res;
15098}
15099
15100static int
2cf0635d 15101process_corefile_note_segments (FILE * file)
779fe533 15102{
2cf0635d 15103 Elf_Internal_Phdr * segment;
b34976b6
AM		 15104 unsigned int i;
15105 int res = 1;
103f02d3 15106
d93f0186 15107 if (! get_program_headers (file))
779fe533 15108 return 0;
103f02d3 15109
779fe533
NC		 15110 for (i = 0, segment = program_headers;
15111 i < elf_header.e_phnum;
b34976b6 15112 i++, segment++)
779fe533
NC		 15113 {
15114 if (segment->p_type == PT_NOTE)
103f02d3 15115 res &= process_corefile_note_segment (file,
30800947
NC		 15116 (bfd_vma) segment->p_offset,
15117 (bfd_vma) segment->p_filesz);
779fe533 15118 }
103f02d3 15119
779fe533
NC		 15120 return res;
15121}
15122
15123static int
2cf0635d 15124process_note_sections (FILE * file)
1ec5cd37 15125{
2cf0635d 15126 Elf_Internal_Shdr * section;
1ec5cd37 15127 unsigned long i;
df565f32 15128 int n = 0;
1ec5cd37
NC		 15129 int res = 1;
15130
15131 for (i = 0, section = section_headers;
fa1908fd 15132 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 15133 i++, section++)
15134 if (section->sh_type == SHT_NOTE)
df565f32
NC		 15135 {
15136 res &= process_corefile_note_segment (file,
15137 (bfd_vma) section->sh_offset,
15138 (bfd_vma) section->sh_size);
15139 n++;
15140 }
15141
15142 if (n == 0)
15143 /* Try processing NOTE segments instead. */
15144 return process_corefile_note_segments (file);
1ec5cd37
NC		 15145
15146 return res;
15147}
15148
15149static int
2cf0635d 15150process_notes (FILE * file)
779fe533
NC		 15151{
15152 /* If we have not been asked to display the notes then do nothing. */
15153 if (! do_notes)
15154 return 1;
103f02d3 15155
779fe533 15156 if (elf_header.e_type != ET_CORE)
1ec5cd37 15157 return process_note_sections (file);
103f02d3 15158
779fe533 15159 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15160 if (elf_header.e_phnum > 0)
15161 return process_corefile_note_segments (file);
779fe533 15162
1ec5cd37
NC		 15163 printf (_("No note segments present in the core file.\n"));
15164 return 1;
779fe533
NC		 15165}
15166
252b5132 15167static int
2cf0635d 15168process_arch_specific (FILE * file)
252b5132 15169{
a952a375
NC		 15170 if (! do_arch)
15171 return 1;
15172
252b5132
RH		 15173 switch (elf_header.e_machine)
15174 {
11c1ff18
PB		 15175 case EM_ARM:
15176 return process_arm_specific (file);
252b5132 15177 case EM_MIPS:
4fe85591 15178 case EM_MIPS_RS3_LE:
252b5132
RH		 15179 return process_mips_specific (file);
15180 break;
35c08157
KLC		 15181 case EM_NDS32:
15182 return process_nds32_specific (file);
15183 break;
34c8bcba
JM		 15184 case EM_PPC:
15185 return process_power_specific (file);
15186 break;
9e8c70f9
DM		 15187 case EM_SPARC:
15188 case EM_SPARC32PLUS:
15189 case EM_SPARCV9:
15190 return process_sparc_specific (file);
15191 break;
59e6276b
JM		 15192 case EM_TI_C6000:
15193 return process_tic6x_specific (file);
15194 break;
13761a11
NC		 15195 case EM_MSP430:
15196 return process_msp430x_specific (file);
252b5132
RH		 15197 default:
15198 break;
15199 }
15200 return 1;
15201}
15202
15203static int
2cf0635d 15204get_file_header (FILE * file)
252b5132 15205{
9ea033b2
NC		 15206 /* Read in the identity array. */
15207 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15208 return 0;
15209
9ea033b2 15210 /* Determine how to read the rest of the header. */
b34976b6 15211 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15212 {
15213 default: /* fall through */
15214 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15215 case ELFDATA2LSB:
15216 byte_get = byte_get_little_endian;
15217 byte_put = byte_put_little_endian;
15218 break;
15219 case ELFDATA2MSB:
15220 byte_get = byte_get_big_endian;
15221 byte_put = byte_put_big_endian;
15222 break;
9ea033b2
NC		 15223 }
15224
15225 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15226 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15227
15228 /* Read in the rest of the header. */
15229 if (is_32bit_elf)
15230 {
15231 Elf32_External_Ehdr ehdr32;
252b5132 15232
9ea033b2
NC		 15233 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15234 return 0;
103f02d3 15235
9ea033b2
NC		 15236 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15237 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15238 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15239 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15240 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15241 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15242 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15243 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15244 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15245 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15246 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15247 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15248 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15249 }
252b5132 15250 else
9ea033b2
NC		 15251 {
15252 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15253
15254 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15255 we will not be able to cope with the 64bit data found in
15256 64 ELF files. Detect this now and abort before we start
50c2245b 15257 overwriting things. */
a952a375
NC		 15258 if (sizeof (bfd_vma) < 8)
15259 {
e3c8793a
NC		 15260 error (_("This instance of readelf has been built without support for a\n\
1526164 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15262 return 0;
15263 }
103f02d3 15264
9ea033b2
NC		 15265 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15266 return 0;
103f02d3 15267
9ea033b2
NC		 15268 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15269 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15270 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15271 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15272 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15273 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15274 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15275 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15276 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15277 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15278 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15279 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15280 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15281 }
252b5132 15282
7ece0d85
JJ		 15283 if (elf_header.e_shoff)
15284 {
15285 /* There may be some extensions in the first section header. Don't
15286 bomb if we can't read it. */
15287 if (is_32bit_elf)
049b0c3a 15288 get_32bit_section_headers (file, TRUE);
7ece0d85 15289 else
049b0c3a 15290 get_64bit_section_headers (file, TRUE);
7ece0d85 15291 }
560f3c1c 15292
252b5132
RH		 15293 return 1;
15294}
15295
fb52b2f4
NC		 15296/* Process one ELF object file according to the command line options.
15297 This file may actually be stored in an archive. The file is
15298 positioned at the start of the ELF object. */
15299
ff78d6d6 15300static int
2cf0635d 15301process_object (char * file_name, FILE * file)
252b5132 15302{
252b5132
RH		 15303 unsigned int i;
15304
252b5132
RH		 15305 if (! get_file_header (file))
15306 {
15307 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15308 return 1;
252b5132
RH		 15309 }
15310
15311 /* Initialise per file variables. */
60bca95a 15312 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15313 version_info[i] = 0;
15314
60bca95a 15315 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15316 dynamic_info[i] = 0;
5115b233 15317 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15318
15319 /* Process the file. */
15320 if (show_name)
15321 printf (_("\nFile: %s\n"), file_name);
15322
18bd398b
NC		 15323 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15324 Note we do this even if cmdline_dump_sects is empty because we
15325 must make sure that the dump_sets array is zeroed out before each
15326 object file is processed. */
15327 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15328 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15329
15330 if (num_cmdline_dump_sects > 0)
15331 {
15332 if (num_dump_sects == 0)
15333 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15334 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15335
15336 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15337 memcpy (dump_sects, cmdline_dump_sects,
15338 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15339 }
d70c5fc7 15340
252b5132 15341 if (! process_file_header ())
fb52b2f4 15342 return 1;
252b5132 15343
d1f5c6e3 15344 if (! process_section_headers (file))
2f62977e 15345 {
d1f5c6e3
L		 15346 /* Without loaded section headers we cannot process lots of
15347 things. */
2f62977e 15348 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15349
2f62977e 15350 if (! do_using_dynamic)
2c610e4b 15351 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15352 }
252b5132 15353
d1f5c6e3
L		 15354 if (! process_section_groups (file))
15355 {
15356 /* Without loaded section groups we cannot process unwind. */
15357 do_unwind = 0;
15358 }
15359
2f62977e 15360 if (process_program_headers (file))
b2d38a17 15361 process_dynamic_section (file);
252b5132
RH		 15362
15363 process_relocs (file);
15364
4d6ed7c8
NC		 15365 process_unwind (file);
15366
252b5132
RH		 15367 process_symbol_table (file);
15368
15369 process_syminfo (file);
15370
15371 process_version_sections (file);
15372
15373 process_section_contents (file);
f5842774 15374
1ec5cd37 15375 process_notes (file);
103f02d3 15376
047b2264
JJ		 15377 process_gnu_liblist (file);
15378
252b5132
RH		 15379 process_arch_specific (file);
15380
d93f0186
NC		 15381 if (program_headers)
15382 {
15383 free (program_headers);
15384 program_headers = NULL;
15385 }
15386
252b5132
RH		 15387 if (section_headers)
15388 {
15389 free (section_headers);
15390 section_headers = NULL;
15391 }
15392
15393 if (string_table)
15394 {
15395 free (string_table);
15396 string_table = NULL;
d40ac9bd 15397 string_table_length = 0;
252b5132
RH		 15398 }
15399
15400 if (dynamic_strings)
15401 {
15402 free (dynamic_strings);
15403 dynamic_strings = NULL;
d79b3d50 15404 dynamic_strings_length = 0;
252b5132
RH		 15405 }
15406
15407 if (dynamic_symbols)
15408 {
15409 free (dynamic_symbols);
15410 dynamic_symbols = NULL;
19936277 15411 num_dynamic_syms = 0;
252b5132
RH		 15412 }
15413
15414 if (dynamic_syminfo)
15415 {
15416 free (dynamic_syminfo);
15417 dynamic_syminfo = NULL;
15418 }
ff78d6d6 15419
293c573e
MR		 15420 if (dynamic_section)
15421 {
15422 free (dynamic_section);
15423 dynamic_section = NULL;
15424 }
15425
e4b17d5c
L		 15426 if (section_headers_groups)
15427 {
15428 free (section_headers_groups);
15429 section_headers_groups = NULL;
15430 }
15431
15432 if (section_groups)
15433 {
2cf0635d
NC		 15434 struct group_list * g;
15435 struct group_list * next;
e4b17d5c
L		 15436
15437 for (i = 0; i < group_count; i++)
15438 {
15439 for (g = section_groups [i].root; g != NULL; g = next)
15440 {
15441 next = g->next;
15442 free (g);
15443 }
15444 }
15445
15446 free (section_groups);
15447 section_groups = NULL;
15448 }
15449
19e6b90e 15450 free_debug_memory ();
18bd398b 15451
ff78d6d6 15452 return 0;
252b5132
RH		 15453}
15454
2cf0635d
NC		 15455/* Process an ELF archive.
15456 On entry the file is positioned just after the ARMAG string. */
15457
15458static int
15459process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15460{
15461 struct archive_info arch;
15462 struct archive_info nested_arch;
15463 size_t got;
2cf0635d
NC		 15464 int ret;
15465
15466 show_name = 1;
15467
15468 /* The ARCH structure is used to hold information about this archive. */
15469 arch.file_name = NULL;
15470 arch.file = NULL;
15471 arch.index_array = NULL;
15472 arch.sym_table = NULL;
15473 arch.longnames = NULL;
15474
15475 /* The NESTED_ARCH structure is used as a single-item cache of information
15476 about a nested archive (when members of a thin archive reside within
15477 another regular archive file). */
15478 nested_arch.file_name = NULL;
15479 nested_arch.file = NULL;
15480 nested_arch.index_array = NULL;
15481 nested_arch.sym_table = NULL;
15482 nested_arch.longnames = NULL;
15483
15484 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15485 {
15486 ret = 1;
15487 goto out;
4145f1d5 15488 }
fb52b2f4 15489
4145f1d5
NC		 15490 if (do_archive_index)
15491 {
2cf0635d 15492 if (arch.sym_table == NULL)
4145f1d5
NC		 15493 error (_("%s: unable to dump the index as none was found\n"), file_name);
15494 else
15495 {
591f7597 15496 unsigned long i, l;
4145f1d5
NC		 15497 unsigned long current_pos;
15498
591f7597
NC		 15499 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15500 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 15501 current_pos = ftell (file);
15502
2cf0635d 15503 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 15504 {
2cf0635d
NC		 15505 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15506 {
15507 char * member_name;
4145f1d5 15508
2cf0635d
NC		 15509 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15510
15511 if (member_name != NULL)
15512 {
15513 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15514
15515 if (qualified_name != NULL)
15516 {
c2a7d3f5
NC		 15517 printf (_("Contents of binary %s at offset "), qualified_name);
15518 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15519 putchar ('\n');
2cf0635d
NC		 15520 free (qualified_name);
15521 }
4145f1d5
NC		 15522 }
15523 }
2cf0635d
NC		 15524
15525 if (l >= arch.sym_size)
4145f1d5
NC		 15526 {
15527 error (_("%s: end of the symbol table reached before the end of the index\n"),
15528 file_name);
cb8f3167 15529 break;
4145f1d5 15530 }
591f7597
NC		 15531 /* PR 17531: file: 0b6630b2. */
15532 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15533 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 15534 }
15535
c2a7d3f5
NC		 15536 if (arch.uses_64bit_indicies)
15537 l = (l + 7) & ~ 7;
15538 else
15539 l += l & 1;
15540
2cf0635d 15541 if (l < arch.sym_size)
c2a7d3f5
NC		 15542 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15543 file_name, arch.sym_size - l);
4145f1d5 15544
4145f1d5
NC		 15545 if (fseek (file, current_pos, SEEK_SET) != 0)
15546 {
15547 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 15548 ret = 1;
15549 goto out;
4145f1d5 15550 }
fb52b2f4 15551 }
4145f1d5
NC		 15552
15553 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15554 && !do_segments && !do_header && !do_dump && !do_version
15555 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 15556 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 15557 {
15558 ret = 0; /* Archive index only. */
15559 goto out;
15560 }
fb52b2f4
NC		 15561 }
15562
d989285c 15563 ret = 0;
fb52b2f4
NC		 15564
15565 while (1)
15566 {
2cf0635d
NC		 15567 char * name;
15568 size_t namelen;
15569 char * qualified_name;
15570
15571 /* Read the next archive header. */
15572 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15573 {
15574 error (_("%s: failed to seek to next archive header\n"), file_name);
15575 return 1;
15576 }
15577 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15578 if (got != sizeof arch.arhdr)
15579 {
15580 if (got == 0)
15581 break;
15582 error (_("%s: failed to read archive header\n"), file_name);
15583 ret = 1;
15584 break;
15585 }
15586 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15587 {
15588 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15589 ret = 1;
15590 break;
15591 }
15592
15593 arch.next_arhdr_offset += sizeof arch.arhdr;
15594
15595 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15596 if (archive_file_size & 01)
15597 ++archive_file_size;
15598
15599 name = get_archive_member_name (&arch, &nested_arch);
15600 if (name == NULL)
fb52b2f4 15601 {
0fd3a477 15602 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15603 ret = 1;
15604 break;
fb52b2f4 15605 }
2cf0635d 15606 namelen = strlen (name);
fb52b2f4 15607
2cf0635d
NC		 15608 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15609 if (qualified_name == NULL)
fb52b2f4 15610 {
2cf0635d 15611 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15612 ret = 1;
15613 break;
fb52b2f4
NC		 15614 }
15615
2cf0635d
NC		 15616 if (is_thin_archive && arch.nested_member_origin == 0)
15617 {
15618 /* This is a proxy for an external member of a thin archive. */
15619 FILE * member_file;
15620 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15621 if (member_file_name == NULL)
15622 {
15623 ret = 1;
15624 break;
15625 }
15626
15627 member_file = fopen (member_file_name, "rb");
15628 if (member_file == NULL)
15629 {
15630 error (_("Input file '%s' is not readable.\n"), member_file_name);
15631 free (member_file_name);
15632 ret = 1;
15633 break;
15634 }
15635
15636 archive_file_offset = arch.nested_member_origin;
15637
15638 ret |= process_object (qualified_name, member_file);
15639
15640 fclose (member_file);
15641 free (member_file_name);
15642 }
15643 else if (is_thin_archive)
15644 {
a043396b
NC		 15645 /* PR 15140: Allow for corrupt thin archives. */
15646 if (nested_arch.file == NULL)
15647 {
15648 error (_("%s: contains corrupt thin archive: %s\n"),
15649 file_name, name);
15650 ret = 1;
15651 break;
15652 }
15653
2cf0635d
NC		 15654 /* This is a proxy for a member of a nested archive. */
15655 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15656
15657 /* The nested archive file will have been opened and setup by
15658 get_archive_member_name. */
15659 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15660 {
15661 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15662 ret = 1;
15663 break;
15664 }
15665
15666 ret |= process_object (qualified_name, nested_arch.file);
15667 }
15668 else
15669 {
15670 archive_file_offset = arch.next_arhdr_offset;
15671 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 15672
2cf0635d
NC		 15673 ret |= process_object (qualified_name, file);
15674 }
fb52b2f4 15675
2b52916e
L		 15676 if (dump_sects != NULL)
15677 {
15678 free (dump_sects);
15679 dump_sects = NULL;
15680 num_dump_sects = 0;
15681 }
15682
2cf0635d 15683 free (qualified_name);
fb52b2f4
NC		 15684 }
15685
4145f1d5 15686 out:
2cf0635d
NC		 15687 if (nested_arch.file != NULL)
15688 fclose (nested_arch.file);
15689 release_archive (&nested_arch);
15690 release_archive (&arch);
fb52b2f4 15691
d989285c 15692 return ret;
fb52b2f4
NC		 15693}
15694
15695static int
2cf0635d 15696process_file (char * file_name)
fb52b2f4 15697{
2cf0635d 15698 FILE * file;
fb52b2f4
NC		 15699 struct stat statbuf;
15700 char armag[SARMAG];
15701 int ret;
15702
15703 if (stat (file_name, &statbuf) < 0)
15704 {
f24ddbdd
NC		 15705 if (errno == ENOENT)
15706 error (_("'%s': No such file\n"), file_name);
15707 else
15708 error (_("Could not locate '%s'. System error message: %s\n"),
15709 file_name, strerror (errno));
15710 return 1;
15711 }
15712
15713 if (! S_ISREG (statbuf.st_mode))
15714 {
15715 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 15716 return 1;
15717 }
15718
15719 file = fopen (file_name, "rb");
15720 if (file == NULL)
15721 {
f24ddbdd 15722 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 15723 return 1;
15724 }
15725
15726 if (fread (armag, SARMAG, 1, file) != 1)
15727 {
4145f1d5 15728 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 15729 fclose (file);
15730 return 1;
15731 }
15732
f54498b4
NC		 15733 current_file_size = (bfd_size_type) statbuf.st_size;
15734
fb52b2f4 15735 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 15736 ret = process_archive (file_name, file, FALSE);
15737 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15738 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 15739 else
15740 {
4145f1d5
NC		 15741 if (do_archive_index)
15742 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15743 file_name);
15744
fb52b2f4
NC		 15745 rewind (file);
15746 archive_file_size = archive_file_offset = 0;
15747 ret = process_object (file_name, file);
15748 }
15749
15750 fclose (file);
15751
f54498b4 15752 current_file_size = 0;
fb52b2f4
NC		 15753 return ret;
15754}
15755
252b5132
RH		 15756#ifdef SUPPORT_DISASSEMBLY
15757/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 15758 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 15759 symbols. */
252b5132
RH		 15760
15761void
2cf0635d 15762print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 15763{
15764 fprintf (outfile,"0x%8.8x", addr);
15765}
15766
e3c8793a 15767/* Needed by the i386 disassembler. */
252b5132
RH		 15768void
15769db_task_printsym (unsigned int addr)
15770{
15771 print_address (addr, stderr);
15772}
15773#endif
15774
15775int
2cf0635d 15776main (int argc, char ** argv)
252b5132 15777{
ff78d6d6
L		 15778 int err;
15779
252b5132
RH		 15780#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15781 setlocale (LC_MESSAGES, "");
3882b010
L		 15782#endif
15783#if defined (HAVE_SETLOCALE)
15784 setlocale (LC_CTYPE, "");
252b5132
RH		 15785#endif
15786 bindtextdomain (PACKAGE, LOCALEDIR);
15787 textdomain (PACKAGE);
15788
869b9d07
MM		 15789 expandargv (&argc, &argv);
15790
252b5132
RH		 15791 parse_args (argc, argv);
15792
18bd398b 15793 if (num_dump_sects > 0)
59f14fc0 15794 {
18bd398b 15795 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 15796 cmdline_dump_sects = (dump_type *)
15797 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 15798 if (cmdline_dump_sects == NULL)
591a748a 15799 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 15800 else
15801 {
09c11c86
NC		 15802 memcpy (cmdline_dump_sects, dump_sects,
15803 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 15804 num_cmdline_dump_sects = num_dump_sects;
15805 }
15806 }
15807
18bd398b
NC		 15808 if (optind < (argc - 1))
15809 show_name = 1;
15810
ff78d6d6 15811 err = 0;
252b5132 15812 while (optind < argc)
18bd398b 15813 err |= process_file (argv[optind++]);
252b5132
RH		 15814
15815 if (dump_sects != NULL)
15816 free (dump_sects);
59f14fc0
AS		 15817 if (cmdline_dump_sects != NULL)
15818 free (cmdline_dump_sects);
252b5132 15819
ff78d6d6 15820 return err;
252b5132 15821}
GDB Binutils - Deliverables
This page took 2.708921 seconds and 4 git commands to generate.