]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gdbserver/Linux: unbreak thread event randomization
[thirdparty/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 *
57028622
NC		 327get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
328 bfd_size_type nmemb, const char * reason)
a6e9f9df 329{
2cf0635d 330 void * mvar;
57028622 331 bfd_size_type amt = size * nmemb;
a6e9f9df 332
c256ffe7 333 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 334 return NULL;
335
57028622
NC		 336 /* If the size_t type is smaller than the bfd_size_type, eg because
337 you are building a 32-bit tool on a 64-bit host, then make sure
338 that when the sizes are cast to (size_t) no information is lost. */
339 if (sizeof (size_t) < sizeof (bfd_size_type)
340 && ( (bfd_size_type) ((size_t) size) != size
341 || (bfd_size_type) ((size_t) nmemb) != nmemb))
342 {
343 if (reason)
344 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
345 (unsigned long long) nmemb, (unsigned long long) size, reason);
346 return NULL;
347 }
348
349 /* Check for size overflow. */
350 if (amt < nmemb)
351 {
352 if (reason)
353 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
354 (unsigned long long) nmemb, (unsigned long long) size, reason);
355 return NULL;
356 }
357
c9c1d674
EG		 358 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
359 attempting to allocate memory when the read is bound to fail. */
360 if (amt > current_file_size
361 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 362 {
049b0c3a 363 if (reason)
57028622
NC		 364 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
365 (unsigned long long) amt, reason);
a6e9f9df
AM		 366 return NULL;
367 }
368
c9c1d674 369 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 370 {
371 if (reason)
c9c1d674
EG		 372 error (_("Unable to seek to 0x%lx for %s\n"),
373 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 374 return NULL;
375 }
376
a6e9f9df
AM		 377 mvar = var;
378 if (mvar == NULL)
379 {
c256ffe7 380 /* Check for overflow. */
57028622 381 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 382 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 383 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 384
385 if (mvar == NULL)
386 {
049b0c3a 387 if (reason)
57028622
NC		 388 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
389 (unsigned long long) amt, reason);
a6e9f9df
AM		 390 return NULL;
391 }
c256ffe7 392
c9c1d674 393 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 394 }
395
57028622 396 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 397 {
049b0c3a 398 if (reason)
57028622
NC		 399 error (_("Unable to read in 0x%llx bytes of %s\n"),
400 (unsigned long long) amt, reason);
a6e9f9df
AM		 401 if (mvar != var)
402 free (mvar);
403 return NULL;
404 }
405
406 return mvar;
407}
408
14a91970 409/* Print a VMA value. */
cb8f3167 410
66543521 411static int
14a91970 412print_vma (bfd_vma vma, print_mode mode)
66543521 413{
66543521
AM		 414 int nc = 0;
415
14a91970 416 switch (mode)
66543521 417 {
14a91970
AM		 418 case FULL_HEX:
419 nc = printf ("0x");
420 /* Drop through. */
66543521 421
14a91970 422 case LONG_HEX:
f7a99963 423#ifdef BFD64
14a91970 424 if (is_32bit_elf)
437c2fb7 425 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 426#endif
14a91970
AM		 427 printf_vma (vma);
428 return nc + 16;
b19aac67 429
14a91970
AM		 430 case DEC_5:
431 if (vma <= 99999)
432 return printf ("%5" BFD_VMA_FMT "d", vma);
433 /* Drop through. */
66543521 434
14a91970
AM		 435 case PREFIX_HEX:
436 nc = printf ("0x");
437 /* Drop through. */
66543521 438
14a91970
AM		 439 case HEX:
440 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 441
14a91970
AM		 442 case DEC:
443 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 444
14a91970
AM		 445 case UNSIGNED:
446 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 447 }
66543521 448 return 0;
f7a99963
NC		 449}
450
7bfd842d 451/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 452 multibye characters (assuming the host environment supports them).
31104126 453
7bfd842d
NC		 454 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
455
456 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
457 padding as necessary.
171191ba
NC		 458
459 Returns the number of emitted characters. */
460
461static unsigned int
7a88bc9c 462print_symbol (int width, const char *symbol)
31104126 463{
171191ba 464 bfd_boolean extra_padding = FALSE;
7bfd842d 465 int num_printed = 0;
3bfcb652 466#ifdef HAVE_MBSTATE_T
7bfd842d 467 mbstate_t state;
3bfcb652 468#endif
7bfd842d 469 int width_remaining;
961c521f 470
7bfd842d 471 if (width < 0)
961c521f 472 {
961c521f
NC		 473 /* Keep the width positive. This also helps. */
474 width = - width;
171191ba 475 extra_padding = TRUE;
0b4362b0 476 }
74e1a04b 477 assert (width != 0);
961c521f 478
7bfd842d
NC		 479 if (do_wide)
480 /* Set the remaining width to a very large value.
481 This simplifies the code below. */
482 width_remaining = INT_MAX;
483 else
484 width_remaining = width;
cb8f3167 485
3bfcb652 486#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 487 /* Initialise the multibyte conversion state. */
488 memset (& state, 0, sizeof (state));
3bfcb652 489#endif
961c521f 490
7bfd842d
NC		 491 while (width_remaining)
492 {
493 size_t n;
7bfd842d 494 const char c = *symbol++;
961c521f 495
7bfd842d 496 if (c == 0)
961c521f
NC		 497 break;
498
7bfd842d
NC		 499 /* Do not print control characters directly as they can affect terminal
500 settings. Such characters usually appear in the names generated
501 by the assembler for local labels. */
502 if (ISCNTRL (c))
961c521f 503 {
7bfd842d 504 if (width_remaining < 2)
961c521f
NC		 505 break;
506
7bfd842d
NC		 507 printf ("^%c", c + 0x40);
508 width_remaining -= 2;
171191ba 509 num_printed += 2;
961c521f 510 }
7bfd842d
NC		 511 else if (ISPRINT (c))
512 {
513 putchar (c);
514 width_remaining --;
515 num_printed ++;
516 }
961c521f
NC		 517 else
518 {
3bfcb652
NC		 519#ifdef HAVE_MBSTATE_T
520 wchar_t w;
521#endif
7bfd842d
NC		 522 /* Let printf do the hard work of displaying multibyte characters. */
523 printf ("%.1s", symbol - 1);
524 width_remaining --;
525 num_printed ++;
526
3bfcb652 527#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 528 /* Try to find out how many bytes made up the character that was
529 just printed. Advance the symbol pointer past the bytes that
530 were displayed. */
531 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 532#else
533 n = 1;
534#endif
7bfd842d
NC		 535 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
536 symbol += (n - 1);
961c521f 537 }
961c521f 538 }
171191ba 539
7bfd842d 540 if (extra_padding && num_printed < width)
171191ba
NC		 541 {
542 /* Fill in the remaining spaces. */
7bfd842d
NC		 543 printf ("%-*s", width - num_printed, " ");
544 num_printed = width;
171191ba
NC		 545 }
546
547 return num_printed;
31104126
NC		 548}
549
74e1a04b
NC		 550/* Returns a pointer to a static buffer containing a printable version of
551 the given section's name. Like print_symbol, except that it does not try
552 to print multibyte characters, it just interprets them as hex values. */
553
554static const char *
555printable_section_name (Elf_Internal_Shdr * sec)
556{
557#define MAX_PRINT_SEC_NAME_LEN 128
558 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
559 const char * name = SECTION_NAME (sec);
560 char * buf = sec_name_buf;
561 char c;
562 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
563
564 while ((c = * name ++) != 0)
565 {
566 if (ISCNTRL (c))
567 {
568 if (remaining < 2)
569 break;
948f632f 570
74e1a04b
NC		 571 * buf ++ = '^';
572 * buf ++ = c + 0x40;
573 remaining -= 2;
574 }
575 else if (ISPRINT (c))
576 {
577 * buf ++ = c;
578 remaining -= 1;
579 }
580 else
581 {
582 static char hex[17] = "0123456789ABCDEF";
583
584 if (remaining < 4)
585 break;
586 * buf ++ = '<';
587 * buf ++ = hex[(c & 0xf0) >> 4];
588 * buf ++ = hex[c & 0x0f];
589 * buf ++ = '>';
590 remaining -= 4;
591 }
592
593 if (remaining == 0)
594 break;
595 }
596
597 * buf = 0;
598 return sec_name_buf;
599}
600
601static const char *
602printable_section_name_from_index (unsigned long ndx)
603{
604 if (ndx >= elf_header.e_shnum)
605 return _("<corrupt>");
606
607 return printable_section_name (section_headers + ndx);
608}
609
89fac5e3
RS		 610/* Return a pointer to section NAME, or NULL if no such section exists. */
611
612static Elf_Internal_Shdr *
2cf0635d 613find_section (const char * name)
89fac5e3
RS		 614{
615 unsigned int i;
616
617 for (i = 0; i < elf_header.e_shnum; i++)
618 if (streq (SECTION_NAME (section_headers + i), name))
619 return section_headers + i;
620
621 return NULL;
622}
623
0b6ae522
DJ		 624/* Return a pointer to a section containing ADDR, or NULL if no such
625 section exists. */
626
627static Elf_Internal_Shdr *
628find_section_by_address (bfd_vma addr)
629{
630 unsigned int i;
631
632 for (i = 0; i < elf_header.e_shnum; i++)
633 {
634 Elf_Internal_Shdr *sec = section_headers + i;
635 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
636 return sec;
637 }
638
639 return NULL;
640}
641
071436c6
NC		 642static Elf_Internal_Shdr *
643find_section_by_type (unsigned int type)
644{
645 unsigned int i;
646
647 for (i = 0; i < elf_header.e_shnum; i++)
648 {
649 Elf_Internal_Shdr *sec = section_headers + i;
650 if (sec->sh_type == type)
651 return sec;
652 }
653
654 return NULL;
655}
656
657d0d47
CC		 657/* Return a pointer to section NAME, or NULL if no such section exists,
658 restricted to the list of sections given in SET. */
659
660static Elf_Internal_Shdr *
661find_section_in_set (const char * name, unsigned int * set)
662{
663 unsigned int i;
664
665 if (set != NULL)
666 {
667 while ((i = *set++) > 0)
668 if (streq (SECTION_NAME (section_headers + i), name))
669 return section_headers + i;
670 }
671
672 return find_section (name);
673}
674
0b6ae522
DJ		 675/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
676 bytes read. */
677
f6f0e17b
NC		 678static inline unsigned long
679read_uleb128 (unsigned char *data,
680 unsigned int *length_return,
681 const unsigned char * const end)
0b6ae522 682{
f6f0e17b 683 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 684}
685
28f997cf
TG		 686/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
687 This OS has so many departures from the ELF standard that we test it at
688 many places. */
689
690static inline int
691is_ia64_vms (void)
692{
693 return elf_header.e_machine == EM_IA_64
694 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
695}
696
bcedfee6 697/* Guess the relocation size commonly used by the specific machines. */
252b5132 698
252b5132 699static int
2dc4cec1 700guess_is_rela (unsigned int e_machine)
252b5132 701{
9c19a809 702 switch (e_machine)
252b5132
RH		 703 {
704 /* Targets that use REL relocations. */
252b5132
RH		 705 case EM_386:
706 case EM_486:
63fcb9e9 707 case EM_960:
e9f53129 708 case EM_ARM:
2b0337b0 709 case EM_D10V:
252b5132 710 case EM_CYGNUS_D10V:
e9f53129 711 case EM_DLX:
252b5132 712 case EM_MIPS:
4fe85591 713 case EM_MIPS_RS3_LE:
e9f53129 714 case EM_CYGNUS_M32R:
1c0d3aa6 715 case EM_SCORE:
f6c1a2d5 716 case EM_XGATE:
9c19a809 717 return FALSE;
103f02d3 718
252b5132
RH		 719 /* Targets that use RELA relocations. */
720 case EM_68K:
e9f53129 721 case EM_860:
a06ea964 722 case EM_AARCH64:
cfb8c092 723 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 724 case EM_ALPHA:
725 case EM_ALTERA_NIOS2:
726 case EM_AVR:
727 case EM_AVR_OLD:
728 case EM_BLACKFIN:
60bca95a 729 case EM_CR16:
e9f53129
AM		 730 case EM_CRIS:
731 case EM_CRX:
2b0337b0 732 case EM_D30V:
252b5132 733 case EM_CYGNUS_D30V:
2b0337b0 734 case EM_FR30:
3f8107ab 735 case EM_FT32:
252b5132 736 case EM_CYGNUS_FR30:
5c70f934 737 case EM_CYGNUS_FRV:
e9f53129
AM		 738 case EM_H8S:
739 case EM_H8_300:
740 case EM_H8_300H:
800eeca4 741 case EM_IA_64:
1e4cf259
NC		 742 case EM_IP2K:
743 case EM_IP2K_OLD:
3b36097d 744 case EM_IQ2000:
84e94c90 745 case EM_LATTICEMICO32:
ff7eeb89 746 case EM_M32C_OLD:
49f58d10 747 case EM_M32C:
e9f53129
AM		 748 case EM_M32R:
749 case EM_MCORE:
15ab5209 750 case EM_CYGNUS_MEP:
a3c62988 751 case EM_METAG:
e9f53129
AM		 752 case EM_MMIX:
753 case EM_MN10200:
754 case EM_CYGNUS_MN10200:
755 case EM_MN10300:
756 case EM_CYGNUS_MN10300:
5506d11a 757 case EM_MOXIE:
e9f53129
AM		 758 case EM_MSP430:
759 case EM_MSP430_OLD:
d031aafb 760 case EM_MT:
35c08157 761 case EM_NDS32:
64fd6348 762 case EM_NIOS32:
73589c9d 763 case EM_OR1K:
e9f53129
AM		 764 case EM_PPC64:
765 case EM_PPC:
99c513f6 766 case EM_RL78:
c7927a3c 767 case EM_RX:
e9f53129
AM		 768 case EM_S390:
769 case EM_S390_OLD:
770 case EM_SH:
771 case EM_SPARC:
772 case EM_SPARC32PLUS:
773 case EM_SPARCV9:
774 case EM_SPU:
40b36596 775 case EM_TI_C6000:
aa137e4d
NC		 776 case EM_TILEGX:
777 case EM_TILEPRO:
708e2187 778 case EM_V800:
e9f53129
AM		 779 case EM_V850:
780 case EM_CYGNUS_V850:
781 case EM_VAX:
619ed720 782 case EM_VISIUM:
e9f53129 783 case EM_X86_64:
8a9036a4 784 case EM_L1OM:
7a9068fe 785 case EM_K1OM:
e9f53129
AM		 786 case EM_XSTORMY16:
787 case EM_XTENSA:
788 case EM_XTENSA_OLD:
7ba29e2a
NC		 789 case EM_MICROBLAZE:
790 case EM_MICROBLAZE_OLD:
9c19a809 791 return TRUE;
103f02d3 792
e9f53129
AM		 793 case EM_68HC05:
794 case EM_68HC08:
795 case EM_68HC11:
796 case EM_68HC16:
797 case EM_FX66:
798 case EM_ME16:
d1133906 799 case EM_MMA:
d1133906
NC		 800 case EM_NCPU:
801 case EM_NDR1:
e9f53129 802 case EM_PCP:
d1133906 803 case EM_ST100:
e9f53129 804 case EM_ST19:
d1133906 805 case EM_ST7:
e9f53129
AM		 806 case EM_ST9PLUS:
807 case EM_STARCORE:
d1133906 808 case EM_SVX:
e9f53129 809 case EM_TINYJ:
9c19a809
NC		 810 default:
811 warn (_("Don't know about relocations on this machine architecture\n"));
812 return FALSE;
813 }
814}
252b5132 815
9c19a809 816static int
2cf0635d 817slurp_rela_relocs (FILE * file,
d3ba0551
AM		 818 unsigned long rel_offset,
819 unsigned long rel_size,
2cf0635d
NC		 820 Elf_Internal_Rela ** relasp,
821 unsigned long * nrelasp)
9c19a809 822{
2cf0635d 823 Elf_Internal_Rela * relas;
8b73c356 824 size_t nrelas;
4d6ed7c8 825 unsigned int i;
252b5132 826
4d6ed7c8
NC		 827 if (is_32bit_elf)
828 {
2cf0635d 829 Elf32_External_Rela * erelas;
103f02d3 830
3f5e193b 831 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 832 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 833 if (!erelas)
834 return 0;
252b5132 835
4d6ed7c8 836 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 837
3f5e193b
NC		 838 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
839 sizeof (Elf_Internal_Rela));
103f02d3 840
4d6ed7c8
NC		 841 if (relas == NULL)
842 {
c256ffe7 843 free (erelas);
591a748a 844 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 845 return 0;
846 }
103f02d3 847
4d6ed7c8
NC		 848 for (i = 0; i < nrelas; i++)
849 {
850 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
851 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 852 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 853 }
103f02d3 854
4d6ed7c8
NC		 855 free (erelas);
856 }
857 else
858 {
2cf0635d 859 Elf64_External_Rela * erelas;
103f02d3 860
3f5e193b 861 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 862 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 863 if (!erelas)
864 return 0;
4d6ed7c8
NC		 865
866 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 867
3f5e193b
NC		 868 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
869 sizeof (Elf_Internal_Rela));
103f02d3 870
4d6ed7c8
NC		 871 if (relas == NULL)
872 {
c256ffe7 873 free (erelas);
591a748a 874 error (_("out of memory parsing relocs\n"));
4d6ed7c8 875 return 0;
9c19a809 876 }
4d6ed7c8
NC		 877
878 for (i = 0; i < nrelas; i++)
9c19a809 879 {
66543521
AM		 880 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
881 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 882 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 883
884 /* The #ifdef BFD64 below is to prevent a compile time
885 warning. We know that if we do not have a 64 bit data
886 type that we will never execute this code anyway. */
887#ifdef BFD64
888 if (elf_header.e_machine == EM_MIPS
889 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
890 {
891 /* In little-endian objects, r_info isn't really a
892 64-bit little-endian value: it has a 32-bit
893 little-endian symbol index followed by four
894 individual byte fields. Reorder INFO
895 accordingly. */
91d6fa6a
NC		 896 bfd_vma inf = relas[i].r_info;
897 inf = (((inf & 0xffffffff) << 32)
898 | ((inf >> 56) & 0xff)
899 | ((inf >> 40) & 0xff00)
900 | ((inf >> 24) & 0xff0000)
901 | ((inf >> 8) & 0xff000000));
902 relas[i].r_info = inf;
861fb55a
DJ		 903 }
904#endif /* BFD64 */
4d6ed7c8 905 }
103f02d3 906
4d6ed7c8
NC		 907 free (erelas);
908 }
909 *relasp = relas;
910 *nrelasp = nrelas;
911 return 1;
912}
103f02d3 913
4d6ed7c8 914static int
2cf0635d 915slurp_rel_relocs (FILE * file,
d3ba0551
AM		 916 unsigned long rel_offset,
917 unsigned long rel_size,
2cf0635d
NC		 918 Elf_Internal_Rela ** relsp,
919 unsigned long * nrelsp)
4d6ed7c8 920{
2cf0635d 921 Elf_Internal_Rela * rels;
8b73c356 922 size_t nrels;
4d6ed7c8 923 unsigned int i;
103f02d3 924
4d6ed7c8
NC		 925 if (is_32bit_elf)
926 {
2cf0635d 927 Elf32_External_Rel * erels;
103f02d3 928
3f5e193b 929 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 930 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 931 if (!erels)
932 return 0;
103f02d3 933
4d6ed7c8 934 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 935
3f5e193b 936 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 937
4d6ed7c8
NC		 938 if (rels == NULL)
939 {
c256ffe7 940 free (erels);
591a748a 941 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 942 return 0;
943 }
944
945 for (i = 0; i < nrels; i++)
946 {
947 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
948 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 949 rels[i].r_addend = 0;
9ea033b2 950 }
4d6ed7c8
NC		 951
952 free (erels);
9c19a809
NC		 953 }
954 else
955 {
2cf0635d 956 Elf64_External_Rel * erels;
9ea033b2 957
3f5e193b 958 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 959 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 960 if (!erels)
961 return 0;
103f02d3 962
4d6ed7c8 963 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 964
3f5e193b 965 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 966
4d6ed7c8 967 if (rels == NULL)
9c19a809 968 {
c256ffe7 969 free (erels);
591a748a 970 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 971 return 0;
972 }
103f02d3 973
4d6ed7c8
NC		 974 for (i = 0; i < nrels; i++)
975 {
66543521
AM		 976 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
977 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 978 rels[i].r_addend = 0;
861fb55a
DJ		 979
980 /* The #ifdef BFD64 below is to prevent a compile time
981 warning. We know that if we do not have a 64 bit data
982 type that we will never execute this code anyway. */
983#ifdef BFD64
984 if (elf_header.e_machine == EM_MIPS
985 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
986 {
987 /* In little-endian objects, r_info isn't really a
988 64-bit little-endian value: it has a 32-bit
989 little-endian symbol index followed by four
990 individual byte fields. Reorder INFO
991 accordingly. */
91d6fa6a
NC		 992 bfd_vma inf = rels[i].r_info;
993 inf = (((inf & 0xffffffff) << 32)
994 | ((inf >> 56) & 0xff)
995 | ((inf >> 40) & 0xff00)
996 | ((inf >> 24) & 0xff0000)
997 | ((inf >> 8) & 0xff000000));
998 rels[i].r_info = inf;
861fb55a
DJ		 999 }
1000#endif /* BFD64 */
4d6ed7c8 1001 }
103f02d3 1002
4d6ed7c8
NC		 1003 free (erels);
1004 }
1005 *relsp = rels;
1006 *nrelsp = nrels;
1007 return 1;
1008}
103f02d3 1009
aca88567
NC		 1010/* Returns the reloc type extracted from the reloc info field. */
1011
1012static unsigned int
1013get_reloc_type (bfd_vma reloc_info)
1014{
1015 if (is_32bit_elf)
1016 return ELF32_R_TYPE (reloc_info);
1017
1018 switch (elf_header.e_machine)
1019 {
1020 case EM_MIPS:
1021 /* Note: We assume that reloc_info has already been adjusted for us. */
1022 return ELF64_MIPS_R_TYPE (reloc_info);
1023
1024 case EM_SPARCV9:
1025 return ELF64_R_TYPE_ID (reloc_info);
1026
1027 default:
1028 return ELF64_R_TYPE (reloc_info);
1029 }
1030}
1031
1032/* Return the symbol index extracted from the reloc info field. */
1033
1034static bfd_vma
1035get_reloc_symindex (bfd_vma reloc_info)
1036{
1037 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1038}
1039
13761a11
NC		 1040static inline bfd_boolean
1041uses_msp430x_relocs (void)
1042{
1043 return
1044 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1045 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1046 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1047 /* TI compiler uses ELFOSABI_NONE. */
1048 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1049}
1050
d3ba0551
AM		 1051/* Display the contents of the relocation data found at the specified
1052 offset. */
ee42cf8c 1053
41e92641 1054static void
2cf0635d 1055dump_relocations (FILE * file,
d3ba0551
AM		 1056 unsigned long rel_offset,
1057 unsigned long rel_size,
2cf0635d 1058 Elf_Internal_Sym * symtab,
d3ba0551 1059 unsigned long nsyms,
2cf0635d 1060 char * strtab,
d79b3d50 1061 unsigned long strtablen,
bb4d2ac2
L		 1062 int is_rela,
1063 int is_dynsym)
4d6ed7c8 1064{
b34976b6 1065 unsigned int i;
2cf0635d 1066 Elf_Internal_Rela * rels;
103f02d3 1067
4d6ed7c8
NC		 1068 if (is_rela == UNKNOWN)
1069 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1070
4d6ed7c8
NC		 1071 if (is_rela)
1072 {
c8286bd1 1073 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1074 return;
4d6ed7c8
NC		 1075 }
1076 else
1077 {
1078 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1079 return;
252b5132
RH		 1080 }
1081
410f7a12
L		 1082 if (is_32bit_elf)
1083 {
1084 if (is_rela)
2c71103e
NC		 1085 {
1086 if (do_wide)
1087 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1088 else
1089 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1090 }
410f7a12 1091 else
2c71103e
NC		 1092 {
1093 if (do_wide)
1094 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1095 else
1096 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1097 }
410f7a12 1098 }
252b5132 1099 else
410f7a12
L		 1100 {
1101 if (is_rela)
2c71103e
NC		 1102 {
1103 if (do_wide)
8beeaeb7 1104 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1105 else
1106 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1107 }
410f7a12 1108 else
2c71103e
NC		 1109 {
1110 if (do_wide)
8beeaeb7 1111 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1112 else
1113 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1114 }
410f7a12 1115 }
252b5132
RH		 1116
1117 for (i = 0; i < rel_size; i++)
1118 {
2cf0635d 1119 const char * rtype;
b34976b6 1120 bfd_vma offset;
91d6fa6a 1121 bfd_vma inf;
b34976b6
AM		 1122 bfd_vma symtab_index;
1123 bfd_vma type;
103f02d3 1124
b34976b6 1125 offset = rels[i].r_offset;
91d6fa6a 1126 inf = rels[i].r_info;
103f02d3 1127
91d6fa6a
NC		 1128 type = get_reloc_type (inf);
1129 symtab_index = get_reloc_symindex (inf);
252b5132 1130
410f7a12
L		 1131 if (is_32bit_elf)
1132 {
39dbeff8
AM		 1133 printf ("%8.8lx %8.8lx ",
1134 (unsigned long) offset & 0xffffffff,
91d6fa6a 1135 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1136 }
1137 else
1138 {
39dbeff8
AM		 1139#if BFD_HOST_64BIT_LONG
1140 printf (do_wide
1141 ? "%16.16lx %16.16lx "
1142 : "%12.12lx %12.12lx ",
91d6fa6a 1143 offset, inf);
39dbeff8 1144#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1145#ifndef __MSVCRT__
39dbeff8
AM		 1146 printf (do_wide
1147 ? "%16.16llx %16.16llx "
1148 : "%12.12llx %12.12llx ",
91d6fa6a 1149 offset, inf);
6e3d6dc1
NC		 1150#else
1151 printf (do_wide
1152 ? "%16.16I64x %16.16I64x "
1153 : "%12.12I64x %12.12I64x ",
91d6fa6a 1154 offset, inf);
6e3d6dc1 1155#endif
39dbeff8 1156#else
2c71103e
NC		 1157 printf (do_wide
1158 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1159 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1160 _bfd_int64_high (offset),
1161 _bfd_int64_low (offset),
91d6fa6a
NC		 1162 _bfd_int64_high (inf),
1163 _bfd_int64_low (inf));
9ea033b2 1164#endif
410f7a12 1165 }
103f02d3 1166
252b5132
RH		 1167 switch (elf_header.e_machine)
1168 {
1169 default:
1170 rtype = NULL;
1171 break;
1172
a06ea964
NC		 1173 case EM_AARCH64:
1174 rtype = elf_aarch64_reloc_type (type);
1175 break;
1176
2b0337b0 1177 case EM_M32R:
252b5132 1178 case EM_CYGNUS_M32R:
9ea033b2 1179 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1180 break;
1181
1182 case EM_386:
1183 case EM_486:
9ea033b2 1184 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1185 break;
1186
ba2685cc
AM		 1187 case EM_68HC11:
1188 case EM_68HC12:
1189 rtype = elf_m68hc11_reloc_type (type);
1190 break;
75751cd9 1191
252b5132 1192 case EM_68K:
9ea033b2 1193 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1194 break;
1195
63fcb9e9 1196 case EM_960:
9ea033b2 1197 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1198 break;
1199
adde6300 1200 case EM_AVR:
2b0337b0 1201 case EM_AVR_OLD:
adde6300
AM		 1202 rtype = elf_avr_reloc_type (type);
1203 break;
1204
9ea033b2
NC		 1205 case EM_OLD_SPARCV9:
1206 case EM_SPARC32PLUS:
1207 case EM_SPARCV9:
252b5132 1208 case EM_SPARC:
9ea033b2 1209 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1210 break;
1211
e9f53129
AM		 1212 case EM_SPU:
1213 rtype = elf_spu_reloc_type (type);
1214 break;
1215
708e2187
NC		 1216 case EM_V800:
1217 rtype = v800_reloc_type (type);
1218 break;
2b0337b0 1219 case EM_V850:
252b5132 1220 case EM_CYGNUS_V850:
9ea033b2 1221 rtype = v850_reloc_type (type);
252b5132
RH		 1222 break;
1223
2b0337b0 1224 case EM_D10V:
252b5132 1225 case EM_CYGNUS_D10V:
9ea033b2 1226 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1227 break;
1228
2b0337b0 1229 case EM_D30V:
252b5132 1230 case EM_CYGNUS_D30V:
9ea033b2 1231 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1232 break;
1233
d172d4ba
NC		 1234 case EM_DLX:
1235 rtype = elf_dlx_reloc_type (type);
1236 break;
1237
252b5132 1238 case EM_SH:
9ea033b2 1239 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1240 break;
1241
2b0337b0 1242 case EM_MN10300:
252b5132 1243 case EM_CYGNUS_MN10300:
9ea033b2 1244 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1245 break;
1246
2b0337b0 1247 case EM_MN10200:
252b5132 1248 case EM_CYGNUS_MN10200:
9ea033b2 1249 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1250 break;
1251
2b0337b0 1252 case EM_FR30:
252b5132 1253 case EM_CYGNUS_FR30:
9ea033b2 1254 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1255 break;
1256
ba2685cc
AM		 1257 case EM_CYGNUS_FRV:
1258 rtype = elf_frv_reloc_type (type);
1259 break;
5c70f934 1260
3f8107ab
AM		 1261 case EM_FT32:
1262 rtype = elf_ft32_reloc_type (type);
1263 break;
1264
252b5132 1265 case EM_MCORE:
9ea033b2 1266 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1267 break;
1268
3c3bdf30
NC		 1269 case EM_MMIX:
1270 rtype = elf_mmix_reloc_type (type);
1271 break;
1272
5506d11a
AM		 1273 case EM_MOXIE:
1274 rtype = elf_moxie_reloc_type (type);
1275 break;
1276
2469cfa2 1277 case EM_MSP430:
13761a11
NC		 1278 if (uses_msp430x_relocs ())
1279 {
1280 rtype = elf_msp430x_reloc_type (type);
1281 break;
1282 }
2469cfa2
NC		 1283 case EM_MSP430_OLD:
1284 rtype = elf_msp430_reloc_type (type);
1285 break;
1286
35c08157
KLC		 1287 case EM_NDS32:
1288 rtype = elf_nds32_reloc_type (type);
1289 break;
1290
252b5132 1291 case EM_PPC:
9ea033b2 1292 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1293 break;
1294
c833c019
AM		 1295 case EM_PPC64:
1296 rtype = elf_ppc64_reloc_type (type);
1297 break;
1298
252b5132 1299 case EM_MIPS:
4fe85591 1300 case EM_MIPS_RS3_LE:
9ea033b2 1301 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1302 break;
1303
1304 case EM_ALPHA:
9ea033b2 1305 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1306 break;
1307
1308 case EM_ARM:
9ea033b2 1309 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1310 break;
1311
584da044 1312 case EM_ARC:
9ea033b2 1313 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1314 break;
1315
1316 case EM_PARISC:
69e617ca 1317 rtype = elf_hppa_reloc_type (type);
252b5132 1318 break;
7d466069 1319
b8720f9d
JL		 1320 case EM_H8_300:
1321 case EM_H8_300H:
1322 case EM_H8S:
1323 rtype = elf_h8_reloc_type (type);
1324 break;
1325
73589c9d
CS		 1326 case EM_OR1K:
1327 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1328 break;
1329
7d466069 1330 case EM_PJ:
2b0337b0 1331 case EM_PJ_OLD:
7d466069
ILT		 1332 rtype = elf_pj_reloc_type (type);
1333 break;
800eeca4
JW		 1334 case EM_IA_64:
1335 rtype = elf_ia64_reloc_type (type);
1336 break;
1b61cf92
HPN		 1337
1338 case EM_CRIS:
1339 rtype = elf_cris_reloc_type (type);
1340 break;
535c37ff
JE		 1341
1342 case EM_860:
1343 rtype = elf_i860_reloc_type (type);
1344 break;
bcedfee6
NC		 1345
1346 case EM_X86_64:
8a9036a4 1347 case EM_L1OM:
7a9068fe 1348 case EM_K1OM:
bcedfee6
NC		 1349 rtype = elf_x86_64_reloc_type (type);
1350 break;
a85d7ed0 1351
35b1837e
AM		 1352 case EM_S370:
1353 rtype = i370_reloc_type (type);
1354 break;
1355
53c7db4b
KH		 1356 case EM_S390_OLD:
1357 case EM_S390:
1358 rtype = elf_s390_reloc_type (type);
1359 break;
93fbbb04 1360
1c0d3aa6
NC		 1361 case EM_SCORE:
1362 rtype = elf_score_reloc_type (type);
1363 break;
1364
93fbbb04
GK		 1365 case EM_XSTORMY16:
1366 rtype = elf_xstormy16_reloc_type (type);
1367 break;
179d3252 1368
1fe1f39c
NC		 1369 case EM_CRX:
1370 rtype = elf_crx_reloc_type (type);
1371 break;
1372
179d3252
JT		 1373 case EM_VAX:
1374 rtype = elf_vax_reloc_type (type);
1375 break;
1e4cf259 1376
619ed720
EB		 1377 case EM_VISIUM:
1378 rtype = elf_visium_reloc_type (type);
1379 break;
1380
cfb8c092
NC		 1381 case EM_ADAPTEVA_EPIPHANY:
1382 rtype = elf_epiphany_reloc_type (type);
1383 break;
1384
1e4cf259
NC		 1385 case EM_IP2K:
1386 case EM_IP2K_OLD:
1387 rtype = elf_ip2k_reloc_type (type);
1388 break;
3b36097d
SC		 1389
1390 case EM_IQ2000:
1391 rtype = elf_iq2000_reloc_type (type);
1392 break;
88da6820
NC		 1393
1394 case EM_XTENSA_OLD:
1395 case EM_XTENSA:
1396 rtype = elf_xtensa_reloc_type (type);
1397 break;
a34e3ecb 1398
84e94c90
NC		 1399 case EM_LATTICEMICO32:
1400 rtype = elf_lm32_reloc_type (type);
1401 break;
1402
ff7eeb89 1403 case EM_M32C_OLD:
49f58d10
JB		 1404 case EM_M32C:
1405 rtype = elf_m32c_reloc_type (type);
1406 break;
1407
d031aafb
NS		 1408 case EM_MT:
1409 rtype = elf_mt_reloc_type (type);
a34e3ecb 1410 break;
1d65ded4
CM		 1411
1412 case EM_BLACKFIN:
1413 rtype = elf_bfin_reloc_type (type);
1414 break;
15ab5209
DB		 1415
1416 case EM_CYGNUS_MEP:
1417 rtype = elf_mep_reloc_type (type);
1418 break;
60bca95a
NC		 1419
1420 case EM_CR16:
1421 rtype = elf_cr16_reloc_type (type);
1422 break;
dd24e3da 1423
7ba29e2a
NC		 1424 case EM_MICROBLAZE:
1425 case EM_MICROBLAZE_OLD:
1426 rtype = elf_microblaze_reloc_type (type);
1427 break;
c7927a3c 1428
99c513f6
DD		 1429 case EM_RL78:
1430 rtype = elf_rl78_reloc_type (type);
1431 break;
1432
c7927a3c
NC		 1433 case EM_RX:
1434 rtype = elf_rx_reloc_type (type);
1435 break;
c29aca4a 1436
a3c62988
NC		 1437 case EM_METAG:
1438 rtype = elf_metag_reloc_type (type);
1439 break;
1440
c29aca4a
NC		 1441 case EM_XC16X:
1442 case EM_C166:
1443 rtype = elf_xc16x_reloc_type (type);
1444 break;
40b36596
JM		 1445
1446 case EM_TI_C6000:
1447 rtype = elf_tic6x_reloc_type (type);
1448 break;
aa137e4d
NC		 1449
1450 case EM_TILEGX:
1451 rtype = elf_tilegx_reloc_type (type);
1452 break;
1453
1454 case EM_TILEPRO:
1455 rtype = elf_tilepro_reloc_type (type);
1456 break;
f6c1a2d5
NC		 1457
1458 case EM_XGATE:
1459 rtype = elf_xgate_reloc_type (type);
1460 break;
36591ba1
SL		 1461
1462 case EM_ALTERA_NIOS2:
1463 rtype = elf_nios2_reloc_type (type);
1464 break;
252b5132
RH		 1465 }
1466
1467 if (rtype == NULL)
39dbeff8 1468 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1469 else
8beeaeb7 1470 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1471
7ace3541 1472 if (elf_header.e_machine == EM_ALPHA
157c2599 1473 && rtype != NULL
7ace3541
RH		 1474 && streq (rtype, "R_ALPHA_LITUSE")
1475 && is_rela)
1476 {
1477 switch (rels[i].r_addend)
1478 {
1479 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1480 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1481 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1482 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1483 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1484 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1485 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1486 default: rtype = NULL;
1487 }
1488 if (rtype)
1489 printf (" (%s)", rtype);
1490 else
1491 {
1492 putchar (' ');
1493 printf (_("<unknown addend: %lx>"),
1494 (unsigned long) rels[i].r_addend);
1495 }
1496 }
1497 else if (symtab_index)
252b5132 1498 {
af3fc3bc 1499 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1500 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1501 else
19936277 1502 {
2cf0635d 1503 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1504 const char * version_string;
1505 enum versioned_symbol_info sym_info;
1506 unsigned short vna_other;
19936277 1507
af3fc3bc 1508 psym = symtab + symtab_index;
103f02d3 1509
bb4d2ac2
L		 1510 version_string
1511 = get_symbol_version_string (file, is_dynsym,
1512 strtab, strtablen,
1513 symtab_index,
1514 psym,
1515 &sym_info,
1516 &vna_other);
1517
af3fc3bc 1518 printf (" ");
171191ba 1519
d8045f23
NC		 1520 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1521 {
1522 const char * name;
1523 unsigned int len;
1524 unsigned int width = is_32bit_elf ? 8 : 14;
1525
1526 /* Relocations against GNU_IFUNC symbols do not use the value
1527 of the symbol as the address to relocate against. Instead
1528 they invoke the function named by the symbol and use its
1529 result as the address for relocation.
1530
1531 To indicate this to the user, do not display the value of
1532 the symbol in the "Symbols's Value" field. Instead show
1533 its name followed by () as a hint that the symbol is
1534 invoked. */
1535
1536 if (strtab == NULL
1537 || psym->st_name == 0
1538 || psym->st_name >= strtablen)
1539 name = "??";
1540 else
1541 name = strtab + psym->st_name;
1542
1543 len = print_symbol (width, name);
bb4d2ac2
L		 1544 if (version_string)
1545 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1546 version_string);
d8045f23
NC		 1547 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1548 }
1549 else
1550 {
1551 print_vma (psym->st_value, LONG_HEX);
171191ba 1552
d8045f23
NC		 1553 printf (is_32bit_elf ? " " : " ");
1554 }
103f02d3 1555
af3fc3bc 1556 if (psym->st_name == 0)
f1ef08cb 1557 {
2cf0635d 1558 const char * sec_name = "<null>";
f1ef08cb
AM		 1559 char name_buf[40];
1560
1561 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1562 {
4fbb74a6 1563 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1564 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1565 else if (psym->st_shndx == SHN_ABS)
1566 sec_name = "ABS";
1567 else if (psym->st_shndx == SHN_COMMON)
1568 sec_name = "COMMON";
ac145307
BS		 1569 else if ((elf_header.e_machine == EM_MIPS
1570 && psym->st_shndx == SHN_MIPS_SCOMMON)
1571 || (elf_header.e_machine == EM_TI_C6000
1572 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1573 sec_name = "SCOMMON";
1574 else if (elf_header.e_machine == EM_MIPS
1575 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1576 sec_name = "SUNDEF";
8a9036a4 1577 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1578 || elf_header.e_machine == EM_L1OM
1579 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1580 && psym->st_shndx == SHN_X86_64_LCOMMON)
1581 sec_name = "LARGE_COMMON";
9ce701e2
L		 1582 else if (elf_header.e_machine == EM_IA_64
1583 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1584 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1585 sec_name = "ANSI_COM";
28f997cf 1586 else if (is_ia64_vms ()
148b93f2
NC		 1587 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1588 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1589 else
1590 {
1591 sprintf (name_buf, "<section 0x%x>",
1592 (unsigned int) psym->st_shndx);
1593 sec_name = name_buf;
1594 }
1595 }
1596 print_symbol (22, sec_name);
1597 }
af3fc3bc 1598 else if (strtab == NULL)
d79b3d50 1599 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1600 else if (psym->st_name >= strtablen)
d79b3d50 1601 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1602 else
bb4d2ac2
L		 1603 {
1604 print_symbol (22, strtab + psym->st_name);
1605 if (version_string)
1606 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1607 version_string);
1608 }
103f02d3 1609
af3fc3bc 1610 if (is_rela)
171191ba 1611 {
598aaa76 1612 bfd_signed_vma off = rels[i].r_addend;
171191ba 1613
834f871c
NC		 1614 /* PR 17531: file: 2e63226f. */
1615 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1616 printf (" + %" BFD_VMA_FMT "x", off);
1617 else if (off < 0)
598aaa76 1618 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1619 else
598aaa76 1620 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1621 }
19936277 1622 }
252b5132 1623 }
1b228002 1624 else if (is_rela)
f7a99963 1625 {
e04d7088
L		 1626 bfd_signed_vma off = rels[i].r_addend;
1627
1628 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
834f871c
NC		 1629 /* PR 17531: file: 2e63226f. */
1630 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1631 printf ("%" BFD_VMA_FMT "x", off);
1632 else if (off < 0)
e04d7088
L		 1633 printf ("-%" BFD_VMA_FMT "x", - off);
1634 else
1635 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1636 }
252b5132 1637
157c2599
NC		 1638 if (elf_header.e_machine == EM_SPARCV9
1639 && rtype != NULL
1640 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1641 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1642
252b5132 1643 putchar ('\n');
2c71103e 1644
aca88567 1645#ifdef BFD64
53c7db4b 1646 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1647 {
91d6fa6a
NC		 1648 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1649 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1650 const char * rtype2 = elf_mips_reloc_type (type2);
1651 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1652
2c71103e
NC		 1653 printf (" Type2: ");
1654
1655 if (rtype2 == NULL)
39dbeff8
AM		 1656 printf (_("unrecognized: %-7lx"),
1657 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1658 else
1659 printf ("%-17.17s", rtype2);
1660
18bd398b 1661 printf ("\n Type3: ");
2c71103e
NC		 1662
1663 if (rtype3 == NULL)
39dbeff8
AM		 1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1666 else
1667 printf ("%-17.17s", rtype3);
1668
53c7db4b 1669 putchar ('\n');
2c71103e 1670 }
aca88567 1671#endif /* BFD64 */
252b5132
RH		 1672 }
1673
c8286bd1 1674 free (rels);
252b5132
RH		 1675}
1676
1677static const char *
d3ba0551 1678get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1679{
1680 switch (type)
1681 {
1682 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1683 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1684 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1685 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1686 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1687 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1688 case DT_MIPS_MSYM: return "MIPS_MSYM";
1689 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1690 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1691 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1692 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1693 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1694 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1695 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1696 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1697 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1698 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1699 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1700 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1701 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1702 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1703 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1704 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1705 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1706 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1707 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1708 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1709 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1710 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1711 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1712 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1713 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1714 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1715 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1716 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1717 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1718 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1719 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1720 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1722 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1723 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1724 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1725 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1726 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1727 default:
1728 return NULL;
1729 }
1730}
1731
9a097730 1732static const char *
d3ba0551 1733get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1734{
1735 switch (type)
1736 {
1737 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1738 default:
1739 return NULL;
1740 }
103f02d3
UD		 1741}
1742
7490d522
AM		 1743static const char *
1744get_ppc_dynamic_type (unsigned long type)
1745{
1746 switch (type)
1747 {
a7f2871e 1748 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1749 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1750 default:
1751 return NULL;
1752 }
1753}
1754
f1cb7e17 1755static const char *
d3ba0551 1756get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1757{
1758 switch (type)
1759 {
a7f2871e
AM		 1760 case DT_PPC64_GLINK: return "PPC64_GLINK";
1761 case DT_PPC64_OPD: return "PPC64_OPD";
1762 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1763 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1764 default:
1765 return NULL;
1766 }
1767}
1768
103f02d3 1769static const char *
d3ba0551 1770get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1771{
1772 switch (type)
1773 {
1774 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1775 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1776 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1777 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1778 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1779 case DT_HP_PREINIT: return "HP_PREINIT";
1780 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1781 case DT_HP_NEEDED: return "HP_NEEDED";
1782 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1783 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1784 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1785 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1786 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1787 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1788 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1789 case DT_HP_FILTERED: return "HP_FILTERED";
1790 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1791 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1792 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1793 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1794 case DT_PLT: return "PLT";
1795 case DT_PLT_SIZE: return "PLT_SIZE";
1796 case DT_DLT: return "DLT";
1797 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1798 default:
1799 return NULL;
1800 }
1801}
9a097730 1802
ecc51f48 1803static const char *
d3ba0551 1804get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1805{
1806 switch (type)
1807 {
148b93f2
NC		 1808 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1809 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1810 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1811 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1812 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1813 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1814 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1815 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1816 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1818 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1819 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1820 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1821 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1822 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1823 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1824 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1825 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1826 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1827 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1828 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1829 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1830 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1831 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1832 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1833 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1834 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1835 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1836 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1837 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1838 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1839 default:
1840 return NULL;
1841 }
1842}
1843
fabcb361
RH		 1844static const char *
1845get_alpha_dynamic_type (unsigned long type)
1846{
1847 switch (type)
1848 {
1849 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1850 default:
1851 return NULL;
1852 }
1853}
1854
1c0d3aa6
NC		 1855static const char *
1856get_score_dynamic_type (unsigned long type)
1857{
1858 switch (type)
1859 {
1860 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1861 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1862 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1863 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1864 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1865 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1866 default:
1867 return NULL;
1868 }
1869}
1870
40b36596
JM		 1871static const char *
1872get_tic6x_dynamic_type (unsigned long type)
1873{
1874 switch (type)
1875 {
1876 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1877 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1878 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1879 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1880 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1881 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1882 default:
1883 return NULL;
1884 }
1885}
1c0d3aa6 1886
36591ba1
SL		 1887static const char *
1888get_nios2_dynamic_type (unsigned long type)
1889{
1890 switch (type)
1891 {
1892 case DT_NIOS2_GP: return "NIOS2_GP";
1893 default:
1894 return NULL;
1895 }
1896}
1897
252b5132 1898static const char *
d3ba0551 1899get_dynamic_type (unsigned long type)
252b5132 1900{
e9e44622 1901 static char buff[64];
252b5132
RH		 1902
1903 switch (type)
1904 {
1905 case DT_NULL: return "NULL";
1906 case DT_NEEDED: return "NEEDED";
1907 case DT_PLTRELSZ: return "PLTRELSZ";
1908 case DT_PLTGOT: return "PLTGOT";
1909 case DT_HASH: return "HASH";
1910 case DT_STRTAB: return "STRTAB";
1911 case DT_SYMTAB: return "SYMTAB";
1912 case DT_RELA: return "RELA";
1913 case DT_RELASZ: return "RELASZ";
1914 case DT_RELAENT: return "RELAENT";
1915 case DT_STRSZ: return "STRSZ";
1916 case DT_SYMENT: return "SYMENT";
1917 case DT_INIT: return "INIT";
1918 case DT_FINI: return "FINI";
1919 case DT_SONAME: return "SONAME";
1920 case DT_RPATH: return "RPATH";
1921 case DT_SYMBOLIC: return "SYMBOLIC";
1922 case DT_REL: return "REL";
1923 case DT_RELSZ: return "RELSZ";
1924 case DT_RELENT: return "RELENT";
1925 case DT_PLTREL: return "PLTREL";
1926 case DT_DEBUG: return "DEBUG";
1927 case DT_TEXTREL: return "TEXTREL";
1928 case DT_JMPREL: return "JMPREL";
1929 case DT_BIND_NOW: return "BIND_NOW";
1930 case DT_INIT_ARRAY: return "INIT_ARRAY";
1931 case DT_FINI_ARRAY: return "FINI_ARRAY";
1932 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1933 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1934 case DT_RUNPATH: return "RUNPATH";
1935 case DT_FLAGS: return "FLAGS";
2d0e6f43 1936
d1133906
NC		 1937 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1938 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1939
05107a46 1940 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1941 case DT_PLTPADSZ: return "PLTPADSZ";
1942 case DT_MOVEENT: return "MOVEENT";
1943 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1944 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1945 case DT_POSFLAG_1: return "POSFLAG_1";
1946 case DT_SYMINSZ: return "SYMINSZ";
1947 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1948
252b5132 1949 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1950 case DT_CONFIG: return "CONFIG";
1951 case DT_DEPAUDIT: return "DEPAUDIT";
1952 case DT_AUDIT: return "AUDIT";
1953 case DT_PLTPAD: return "PLTPAD";
1954 case DT_MOVETAB: return "MOVETAB";
252b5132 1955 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1956
252b5132 1957 case DT_VERSYM: return "VERSYM";
103f02d3 1958
67a4f2b7
AO		 1959 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1960 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1961 case DT_RELACOUNT: return "RELACOUNT";
1962 case DT_RELCOUNT: return "RELCOUNT";
1963 case DT_FLAGS_1: return "FLAGS_1";
1964 case DT_VERDEF: return "VERDEF";
1965 case DT_VERDEFNUM: return "VERDEFNUM";
1966 case DT_VERNEED: return "VERNEED";
1967 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1968
019148e4 1969 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1970 case DT_USED: return "USED";
1971 case DT_FILTER: return "FILTER";
103f02d3 1972
047b2264
JJ		 1973 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1974 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1975 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1976 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1977 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1978 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1979
252b5132
RH		 1980 default:
1981 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1982 {
2cf0635d 1983 const char * result;
103f02d3 1984
252b5132
RH		 1985 switch (elf_header.e_machine)
1986 {
1987 case EM_MIPS:
4fe85591 1988 case EM_MIPS_RS3_LE:
252b5132
RH		 1989 result = get_mips_dynamic_type (type);
1990 break;
9a097730
RH		 1991 case EM_SPARCV9:
1992 result = get_sparc64_dynamic_type (type);
1993 break;
7490d522
AM		 1994 case EM_PPC:
1995 result = get_ppc_dynamic_type (type);
1996 break;
f1cb7e17
AM		 1997 case EM_PPC64:
1998 result = get_ppc64_dynamic_type (type);
1999 break;
ecc51f48
NC		 2000 case EM_IA_64:
2001 result = get_ia64_dynamic_type (type);
2002 break;
fabcb361
RH		 2003 case EM_ALPHA:
2004 result = get_alpha_dynamic_type (type);
2005 break;
1c0d3aa6
NC		 2006 case EM_SCORE:
2007 result = get_score_dynamic_type (type);
2008 break;
40b36596
JM		 2009 case EM_TI_C6000:
2010 result = get_tic6x_dynamic_type (type);
2011 break;
36591ba1
SL		 2012 case EM_ALTERA_NIOS2:
2013 result = get_nios2_dynamic_type (type);
2014 break;
252b5132
RH		 2015 default:
2016 result = NULL;
2017 break;
2018 }
2019
2020 if (result != NULL)
2021 return result;
2022
e9e44622 2023 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2024 }
eec8f817
DA		 2025 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2026 || (elf_header.e_machine == EM_PARISC
2027 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2028 {
2cf0635d 2029 const char * result;
103f02d3
UD		 2030
2031 switch (elf_header.e_machine)
2032 {
2033 case EM_PARISC:
2034 result = get_parisc_dynamic_type (type);
2035 break;
148b93f2
NC		 2036 case EM_IA_64:
2037 result = get_ia64_dynamic_type (type);
2038 break;
103f02d3
UD		 2039 default:
2040 result = NULL;
2041 break;
2042 }
2043
2044 if (result != NULL)
2045 return result;
2046
e9e44622
JJ		 2047 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2048 type);
103f02d3 2049 }
252b5132 2050 else
e9e44622 2051 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2052
252b5132
RH		 2053 return buff;
2054 }
2055}
2056
2057static char *
d3ba0551 2058get_file_type (unsigned e_type)
252b5132 2059{
b34976b6 2060 static char buff[32];
252b5132
RH		 2061
2062 switch (e_type)
2063 {
2064 case ET_NONE: return _("NONE (None)");
2065 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2066 case ET_EXEC: return _("EXEC (Executable file)");
2067 case ET_DYN: return _("DYN (Shared object file)");
2068 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2069
2070 default:
2071 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2072 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2073 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2074 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2075 else
e9e44622 2076 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2077 return buff;
2078 }
2079}
2080
2081static char *
d3ba0551 2082get_machine_name (unsigned e_machine)
252b5132 2083{
b34976b6 2084 static char buff[64]; /* XXX */
252b5132
RH		 2085
2086 switch (e_machine)
2087 {
c45021f2 2088 case EM_NONE: return _("None");
a06ea964 2089 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2090 case EM_M32: return "WE32100";
2091 case EM_SPARC: return "Sparc";
e9f53129 2092 case EM_SPU: return "SPU";
c45021f2
NC		 2093 case EM_386: return "Intel 80386";
2094 case EM_68K: return "MC68000";
2095 case EM_88K: return "MC88000";
2096 case EM_486: return "Intel 80486";
2097 case EM_860: return "Intel 80860";
2098 case EM_MIPS: return "MIPS R3000";
2099 case EM_S370: return "IBM System/370";
7036c0e1 2100 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2101 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2102 case EM_PARISC: return "HPPA";
252b5132 2103 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2104 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2105 case EM_960: return "Intel 90860";
2106 case EM_PPC: return "PowerPC";
285d1771 2107 case EM_PPC64: return "PowerPC64";
c45021f2 2108 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2109 case EM_FT32: return "FTDI FT32";
c45021f2 2110 case EM_RH32: return "TRW RH32";
b34976b6 2111 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2112 case EM_ARM: return "ARM";
2113 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2114 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2115 case EM_SPARCV9: return "Sparc v9";
2116 case EM_TRICORE: return "Siemens Tricore";
584da044 2117 case EM_ARC: return "ARC";
c2dcd04e
NC		 2118 case EM_H8_300: return "Renesas H8/300";
2119 case EM_H8_300H: return "Renesas H8/300H";
2120 case EM_H8S: return "Renesas H8S";
2121 case EM_H8_500: return "Renesas H8/500";
30800947 2122 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2123 case EM_MIPS_X: return "Stanford MIPS-X";
2124 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2125 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2126 case EM_CYGNUS_D10V:
2127 case EM_D10V: return "d10v";
2128 case EM_CYGNUS_D30V:
b34976b6 2129 case EM_D30V: return "d30v";
2b0337b0 2130 case EM_CYGNUS_M32R:
26597c86 2131 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2132 case EM_CYGNUS_V850:
708e2187 2133 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2134 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2135 case EM_CYGNUS_MN10300:
2136 case EM_MN10300: return "mn10300";
2137 case EM_CYGNUS_MN10200:
2138 case EM_MN10200: return "mn10200";
5506d11a 2139 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2140 case EM_CYGNUS_FR30:
2141 case EM_FR30: return "Fujitsu FR30";
b34976b6 2142 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2143 case EM_PJ_OLD:
b34976b6 2144 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2145 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2146 case EM_PCP: return "Siemens PCP";
2147 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2148 case EM_NDR1: return "Denso NDR1 microprocesspr";
2149 case EM_STARCORE: return "Motorola Star*Core processor";
2150 case EM_ME16: return "Toyota ME16 processor";
2151 case EM_ST100: return "STMicroelectronics ST100 processor";
2152 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2153 case EM_PDSP: return "Sony DSP processor";
2154 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2155 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2156 case EM_FX66: return "Siemens FX66 microcontroller";
2157 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2159 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2160 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2161 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2162 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2163 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2164 case EM_SVX: return "Silicon Graphics SVx";
2165 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2166 case EM_VAX: return "Digital VAX";
619ed720 2167 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2168 case EM_AVR_OLD:
b34976b6 2169 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2170 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2171 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2172 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2173 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2174 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2175 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2176 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2177 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2178 case EM_L1OM: return "Intel L1OM";
7a9068fe 2179 case EM_K1OM: return "Intel K1OM";
b7498e0e 2180 case EM_S390_OLD:
b34976b6 2181 case EM_S390: return "IBM S/390";
1c0d3aa6 2182 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2183 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2184 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2185 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2186 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2187 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2188 case EM_DLX: return "OpenDLX";
1e4cf259 2189 case EM_IP2K_OLD:
b34976b6 2190 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2191 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2192 case EM_XTENSA_OLD:
2193 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2194 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2195 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2196 case EM_NS32K: return "National Semiconductor 32000 series";
2197 case EM_TPC: return "Tenor Network TPC processor";
2198 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2199 case EM_MAX: return "MAX Processor";
2200 case EM_CR: return "National Semiconductor CompactRISC";
2201 case EM_F2MC16: return "Fujitsu F2MC16";
2202 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2203 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2204 case EM_M32C_OLD:
49f58d10 2205 case EM_M32C: return "Renesas M32c";
d031aafb 2206 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2207 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2208 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2209 case EM_SEP: return "Sharp embedded microprocessor";
2210 case EM_ARCA: return "Arca RISC microprocessor";
2211 case EM_UNICORE: return "Unicore";
2212 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2213 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2214 case EM_NIOS32: return "Altera Nios";
2215 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2216 case EM_C166:
d70c5fc7 2217 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2218 case EM_M16C: return "Renesas M16C series microprocessors";
2219 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2220 case EM_CE: return "Freescale Communication Engine RISC core";
2221 case EM_TSK3000: return "Altium TSK3000 core";
2222 case EM_RS08: return "Freescale RS08 embedded processor";
2223 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2224 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2225 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2226 case EM_SE_C17: return "Seiko Epson C17 family";
2227 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2228 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2229 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2230 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2232 case EM_R32C: return "Renesas R32C series microprocessors";
2233 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2234 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2235 case EM_8051: return "Intel 8051 and variants";
2236 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2237 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2238 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2239 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2241 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2242 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2243 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2244 case EM_CR16:
f6c1a2d5 2245 case EM_MICROBLAZE:
7ba29e2a 2246 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2247 case EM_RL78: return "Renesas RL78";
c7927a3c 2248 case EM_RX: return "Renesas RX";
a3c62988 2249 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2250 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2251 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2252 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2253 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2254 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2255 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2256 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2257 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2258 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2259 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2260 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2261 default:
35d9dd2f 2262 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2263 return buff;
2264 }
2265}
2266
f3485b74 2267static void
d3ba0551 2268decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2269{
2270 unsigned eabi;
2271 int unknown = 0;
2272
2273 eabi = EF_ARM_EABI_VERSION (e_flags);
2274 e_flags &= ~ EF_ARM_EABIMASK;
2275
2276 /* Handle "generic" ARM flags. */
2277 if (e_flags & EF_ARM_RELEXEC)
2278 {
2279 strcat (buf, ", relocatable executable");
2280 e_flags &= ~ EF_ARM_RELEXEC;
2281 }
76da6bbe 2282
f3485b74
NC		 2283 /* Now handle EABI specific flags. */
2284 switch (eabi)
2285 {
2286 default:
2c71103e 2287 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2288 if (e_flags)
2289 unknown = 1;
2290 break;
2291
2292 case EF_ARM_EABI_VER1:
a5bcd848 2293 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2294 while (e_flags)
2295 {
2296 unsigned flag;
76da6bbe 2297
f3485b74
NC		 2298 /* Process flags one bit at a time. */
2299 flag = e_flags & - e_flags;
2300 e_flags &= ~ flag;
76da6bbe 2301
f3485b74
NC		 2302 switch (flag)
2303 {
a5bcd848 2304 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2305 strcat (buf, ", sorted symbol tables");
2306 break;
76da6bbe 2307
f3485b74
NC		 2308 default:
2309 unknown = 1;
2310 break;
2311 }
2312 }
2313 break;
76da6bbe 2314
a5bcd848
PB		 2315 case EF_ARM_EABI_VER2:
2316 strcat (buf, ", Version2 EABI");
2317 while (e_flags)
2318 {
2319 unsigned flag;
2320
2321 /* Process flags one bit at a time. */
2322 flag = e_flags & - e_flags;
2323 e_flags &= ~ flag;
2324
2325 switch (flag)
2326 {
2327 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2328 strcat (buf, ", sorted symbol tables");
2329 break;
2330
2331 case EF_ARM_DYNSYMSUSESEGIDX:
2332 strcat (buf, ", dynamic symbols use segment index");
2333 break;
2334
2335 case EF_ARM_MAPSYMSFIRST:
2336 strcat (buf, ", mapping symbols precede others");
2337 break;
2338
2339 default:
2340 unknown = 1;
2341 break;
2342 }
2343 }
2344 break;
2345
d507cf36
PB		 2346 case EF_ARM_EABI_VER3:
2347 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2348 break;
2349
2350 case EF_ARM_EABI_VER4:
2351 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2352 while (e_flags)
2353 {
2354 unsigned flag;
2355
2356 /* Process flags one bit at a time. */
2357 flag = e_flags & - e_flags;
2358 e_flags &= ~ flag;
2359
2360 switch (flag)
2361 {
2362 case EF_ARM_BE8:
2363 strcat (buf, ", BE8");
2364 break;
2365
2366 case EF_ARM_LE8:
2367 strcat (buf, ", LE8");
2368 break;
2369
2370 default:
2371 unknown = 1;
2372 break;
2373 }
2374 break;
2375 }
2376 break;
3a4a14e9
PB		 2377
2378 case EF_ARM_EABI_VER5:
2379 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2380 while (e_flags)
2381 {
2382 unsigned flag;
2383
2384 /* Process flags one bit at a time. */
2385 flag = e_flags & - e_flags;
2386 e_flags &= ~ flag;
2387
2388 switch (flag)
2389 {
2390 case EF_ARM_BE8:
2391 strcat (buf, ", BE8");
2392 break;
2393
2394 case EF_ARM_LE8:
2395 strcat (buf, ", LE8");
2396 break;
2397
3bfcb652
NC		 2398 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2399 strcat (buf, ", soft-float ABI");
2400 break;
2401
2402 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2403 strcat (buf, ", hard-float ABI");
2404 break;
2405
d507cf36
PB		 2406 default:
2407 unknown = 1;
2408 break;
2409 }
2410 }
2411 break;
2412
f3485b74 2413 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2414 strcat (buf, ", GNU EABI");
f3485b74
NC		 2415 while (e_flags)
2416 {
2417 unsigned flag;
76da6bbe 2418
f3485b74
NC		 2419 /* Process flags one bit at a time. */
2420 flag = e_flags & - e_flags;
2421 e_flags &= ~ flag;
76da6bbe 2422
f3485b74
NC		 2423 switch (flag)
2424 {
a5bcd848 2425 case EF_ARM_INTERWORK:
f3485b74
NC		 2426 strcat (buf, ", interworking enabled");
2427 break;
76da6bbe 2428
a5bcd848 2429 case EF_ARM_APCS_26:
f3485b74
NC		 2430 strcat (buf, ", uses APCS/26");
2431 break;
76da6bbe 2432
a5bcd848 2433 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2434 strcat (buf, ", uses APCS/float");
2435 break;
76da6bbe 2436
a5bcd848 2437 case EF_ARM_PIC:
f3485b74
NC		 2438 strcat (buf, ", position independent");
2439 break;
76da6bbe 2440
a5bcd848 2441 case EF_ARM_ALIGN8:
f3485b74
NC		 2442 strcat (buf, ", 8 bit structure alignment");
2443 break;
76da6bbe 2444
a5bcd848 2445 case EF_ARM_NEW_ABI:
f3485b74
NC		 2446 strcat (buf, ", uses new ABI");
2447 break;
76da6bbe 2448
a5bcd848 2449 case EF_ARM_OLD_ABI:
f3485b74
NC		 2450 strcat (buf, ", uses old ABI");
2451 break;
76da6bbe 2452
a5bcd848 2453 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2454 strcat (buf, ", software FP");
2455 break;
76da6bbe 2456
90e01f86
ILT		 2457 case EF_ARM_VFP_FLOAT:
2458 strcat (buf, ", VFP");
2459 break;
2460
fde78edd
NC		 2461 case EF_ARM_MAVERICK_FLOAT:
2462 strcat (buf, ", Maverick FP");
2463 break;
2464
f3485b74
NC		 2465 default:
2466 unknown = 1;
2467 break;
2468 }
2469 }
2470 }
f3485b74
NC		 2471
2472 if (unknown)
2b692964 2473 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2474}
2475
343433df
AB		 2476static void
2477decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2478{
2479 --size; /* Leave space for null terminator. */
2480
2481 switch (e_flags & EF_AVR_MACH)
2482 {
2483 case E_AVR_MACH_AVR1:
2484 strncat (buf, ", avr:1", size);
2485 break;
2486 case E_AVR_MACH_AVR2:
2487 strncat (buf, ", avr:2", size);
2488 break;
2489 case E_AVR_MACH_AVR25:
2490 strncat (buf, ", avr:25", size);
2491 break;
2492 case E_AVR_MACH_AVR3:
2493 strncat (buf, ", avr:3", size);
2494 break;
2495 case E_AVR_MACH_AVR31:
2496 strncat (buf, ", avr:31", size);
2497 break;
2498 case E_AVR_MACH_AVR35:
2499 strncat (buf, ", avr:35", size);
2500 break;
2501 case E_AVR_MACH_AVR4:
2502 strncat (buf, ", avr:4", size);
2503 break;
2504 case E_AVR_MACH_AVR5:
2505 strncat (buf, ", avr:5", size);
2506 break;
2507 case E_AVR_MACH_AVR51:
2508 strncat (buf, ", avr:51", size);
2509 break;
2510 case E_AVR_MACH_AVR6:
2511 strncat (buf, ", avr:6", size);
2512 break;
2513 case E_AVR_MACH_AVRTINY:
2514 strncat (buf, ", avr:100", size);
2515 break;
2516 case E_AVR_MACH_XMEGA1:
2517 strncat (buf, ", avr:101", size);
2518 break;
2519 case E_AVR_MACH_XMEGA2:
2520 strncat (buf, ", avr:102", size);
2521 break;
2522 case E_AVR_MACH_XMEGA3:
2523 strncat (buf, ", avr:103", size);
2524 break;
2525 case E_AVR_MACH_XMEGA4:
2526 strncat (buf, ", avr:104", size);
2527 break;
2528 case E_AVR_MACH_XMEGA5:
2529 strncat (buf, ", avr:105", size);
2530 break;
2531 case E_AVR_MACH_XMEGA6:
2532 strncat (buf, ", avr:106", size);
2533 break;
2534 case E_AVR_MACH_XMEGA7:
2535 strncat (buf, ", avr:107", size);
2536 break;
2537 default:
2538 strncat (buf, ", avr:<unknown>", size);
2539 break;
2540 }
2541
2542 size -= strlen (buf);
2543 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2544 strncat (buf, ", link-relax", size);
2545}
2546
35c08157
KLC		 2547static void
2548decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2549{
2550 unsigned abi;
2551 unsigned arch;
2552 unsigned config;
2553 unsigned version;
2554 int has_fpu = 0;
2555 int r = 0;
2556
2557 static const char *ABI_STRINGS[] =
2558 {
2559 "ABI v0", /* use r5 as return register; only used in N1213HC */
2560 "ABI v1", /* use r0 as return register */
2561 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2562 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2563 "AABI",
2564 "ABI2 FP+"
35c08157
KLC		 2565 };
2566 static const char *VER_STRINGS[] =
2567 {
2568 "Andes ELF V1.3 or older",
2569 "Andes ELF V1.3.1",
2570 "Andes ELF V1.4"
2571 };
2572 static const char *ARCH_STRINGS[] =
2573 {
2574 "",
2575 "Andes Star v1.0",
2576 "Andes Star v2.0",
2577 "Andes Star v3.0",
2578 "Andes Star v3.0m"
2579 };
2580
2581 abi = EF_NDS_ABI & e_flags;
2582 arch = EF_NDS_ARCH & e_flags;
2583 config = EF_NDS_INST & e_flags;
2584 version = EF_NDS32_ELF_VERSION & e_flags;
2585
2586 memset (buf, 0, size);
2587
2588 switch (abi)
2589 {
2590 case E_NDS_ABI_V0:
2591 case E_NDS_ABI_V1:
2592 case E_NDS_ABI_V2:
2593 case E_NDS_ABI_V2FP:
2594 case E_NDS_ABI_AABI:
40c7a7cb 2595 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2596 /* In case there are holes in the array. */
2597 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2598 break;
2599
2600 default:
2601 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2602 break;
2603 }
2604
2605 switch (version)
2606 {
2607 case E_NDS32_ELF_VER_1_2:
2608 case E_NDS32_ELF_VER_1_3:
2609 case E_NDS32_ELF_VER_1_4:
2610 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2611 break;
2612
2613 default:
2614 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2615 break;
2616 }
2617
2618 if (E_NDS_ABI_V0 == abi)
2619 {
2620 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2621 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2622 if (arch == E_NDS_ARCH_STAR_V1_0)
2623 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2624 return;
2625 }
2626
2627 switch (arch)
2628 {
2629 case E_NDS_ARCH_STAR_V1_0:
2630 case E_NDS_ARCH_STAR_V2_0:
2631 case E_NDS_ARCH_STAR_V3_0:
2632 case E_NDS_ARCH_STAR_V3_M:
2633 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2634 break;
2635
2636 default:
2637 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2638 /* ARCH version determines how the e_flags are interpreted.
2639 If it is unknown, we cannot proceed. */
2640 return;
2641 }
2642
2643 /* Newer ABI; Now handle architecture specific flags. */
2644 if (arch == E_NDS_ARCH_STAR_V1_0)
2645 {
2646 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2647 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2648
2649 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2650 r += snprintf (buf + r, size -r, ", MAC");
2651
2652 if (config & E_NDS32_HAS_DIV_INST)
2653 r += snprintf (buf + r, size -r, ", DIV");
2654
2655 if (config & E_NDS32_HAS_16BIT_INST)
2656 r += snprintf (buf + r, size -r, ", 16b");
2657 }
2658 else
2659 {
2660 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2661 {
2662 if (version <= E_NDS32_ELF_VER_1_3)
2663 r += snprintf (buf + r, size -r, ", [B8]");
2664 else
2665 r += snprintf (buf + r, size -r, ", EX9");
2666 }
2667
2668 if (config & E_NDS32_HAS_MAC_DX_INST)
2669 r += snprintf (buf + r, size -r, ", MAC_DX");
2670
2671 if (config & E_NDS32_HAS_DIV_DX_INST)
2672 r += snprintf (buf + r, size -r, ", DIV_DX");
2673
2674 if (config & E_NDS32_HAS_16BIT_INST)
2675 {
2676 if (version <= E_NDS32_ELF_VER_1_3)
2677 r += snprintf (buf + r, size -r, ", 16b");
2678 else
2679 r += snprintf (buf + r, size -r, ", IFC");
2680 }
2681 }
2682
2683 if (config & E_NDS32_HAS_EXT_INST)
2684 r += snprintf (buf + r, size -r, ", PERF1");
2685
2686 if (config & E_NDS32_HAS_EXT2_INST)
2687 r += snprintf (buf + r, size -r, ", PERF2");
2688
2689 if (config & E_NDS32_HAS_FPU_INST)
2690 {
2691 has_fpu = 1;
2692 r += snprintf (buf + r, size -r, ", FPU_SP");
2693 }
2694
2695 if (config & E_NDS32_HAS_FPU_DP_INST)
2696 {
2697 has_fpu = 1;
2698 r += snprintf (buf + r, size -r, ", FPU_DP");
2699 }
2700
2701 if (config & E_NDS32_HAS_FPU_MAC_INST)
2702 {
2703 has_fpu = 1;
2704 r += snprintf (buf + r, size -r, ", FPU_MAC");
2705 }
2706
2707 if (has_fpu)
2708 {
2709 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2710 {
2711 case E_NDS32_FPU_REG_8SP_4DP:
2712 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2713 break;
2714 case E_NDS32_FPU_REG_16SP_8DP:
2715 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2716 break;
2717 case E_NDS32_FPU_REG_32SP_16DP:
2718 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2719 break;
2720 case E_NDS32_FPU_REG_32SP_32DP:
2721 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2722 break;
2723 }
2724 }
2725
2726 if (config & E_NDS32_HAS_AUDIO_INST)
2727 r += snprintf (buf + r, size -r, ", AUDIO");
2728
2729 if (config & E_NDS32_HAS_STRING_INST)
2730 r += snprintf (buf + r, size -r, ", STR");
2731
2732 if (config & E_NDS32_HAS_REDUCED_REGS)
2733 r += snprintf (buf + r, size -r, ", 16REG");
2734
2735 if (config & E_NDS32_HAS_VIDEO_INST)
2736 {
2737 if (version <= E_NDS32_ELF_VER_1_3)
2738 r += snprintf (buf + r, size -r, ", VIDEO");
2739 else
2740 r += snprintf (buf + r, size -r, ", SATURATION");
2741 }
2742
2743 if (config & E_NDS32_HAS_ENCRIPT_INST)
2744 r += snprintf (buf + r, size -r, ", ENCRP");
2745
2746 if (config & E_NDS32_HAS_L2C_INST)
2747 r += snprintf (buf + r, size -r, ", L2C");
2748}
2749
252b5132 2750static char *
d3ba0551 2751get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2752{
b34976b6 2753 static char buf[1024];
252b5132
RH		 2754
2755 buf[0] = '\0';
76da6bbe 2756
252b5132
RH		 2757 if (e_flags)
2758 {
2759 switch (e_machine)
2760 {
2761 default:
2762 break;
2763
f3485b74
NC		 2764 case EM_ARM:
2765 decode_ARM_machine_flags (e_flags, buf);
2766 break;
76da6bbe 2767
343433df
AB		 2768 case EM_AVR:
2769 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2770 break;
2771
781303ce
MF		 2772 case EM_BLACKFIN:
2773 if (e_flags & EF_BFIN_PIC)
2774 strcat (buf, ", PIC");
2775
2776 if (e_flags & EF_BFIN_FDPIC)
2777 strcat (buf, ", FDPIC");
2778
2779 if (e_flags & EF_BFIN_CODE_IN_L1)
2780 strcat (buf, ", code in L1");
2781
2782 if (e_flags & EF_BFIN_DATA_IN_L1)
2783 strcat (buf, ", data in L1");
2784
2785 break;
2786
ec2dfb42
AO		 2787 case EM_CYGNUS_FRV:
2788 switch (e_flags & EF_FRV_CPU_MASK)
2789 {
2790 case EF_FRV_CPU_GENERIC:
2791 break;
2792
2793 default:
2794 strcat (buf, ", fr???");
2795 break;
57346661 2796
ec2dfb42
AO		 2797 case EF_FRV_CPU_FR300:
2798 strcat (buf, ", fr300");
2799 break;
2800
2801 case EF_FRV_CPU_FR400:
2802 strcat (buf, ", fr400");
2803 break;
2804 case EF_FRV_CPU_FR405:
2805 strcat (buf, ", fr405");
2806 break;
2807
2808 case EF_FRV_CPU_FR450:
2809 strcat (buf, ", fr450");
2810 break;
2811
2812 case EF_FRV_CPU_FR500:
2813 strcat (buf, ", fr500");
2814 break;
2815 case EF_FRV_CPU_FR550:
2816 strcat (buf, ", fr550");
2817 break;
2818
2819 case EF_FRV_CPU_SIMPLE:
2820 strcat (buf, ", simple");
2821 break;
2822 case EF_FRV_CPU_TOMCAT:
2823 strcat (buf, ", tomcat");
2824 break;
2825 }
1c877e87 2826 break;
ec2dfb42 2827
53c7db4b 2828 case EM_68K:
425c6cb0 2829 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2830 strcat (buf, ", m68000");
425c6cb0 2831 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2832 strcat (buf, ", cpu32");
2833 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2834 strcat (buf, ", fido_a");
425c6cb0 2835 else
266abb8f 2836 {
2cf0635d
NC		 2837 char const * isa = _("unknown");
2838 char const * mac = _("unknown mac");
2839 char const * additional = NULL;
0112cd26 2840
c694fd50 2841 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2842 {
c694fd50 2843 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2844 isa = "A";
2845 additional = ", nodiv";
2846 break;
c694fd50 2847 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2848 isa = "A";
2849 break;
c694fd50 2850 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2851 isa = "A+";
2852 break;
c694fd50 2853 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2854 isa = "B";
2855 additional = ", nousp";
2856 break;
c694fd50 2857 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2858 isa = "B";
2859 break;
f608cd77
NS		 2860 case EF_M68K_CF_ISA_C:
2861 isa = "C";
2862 break;
2863 case EF_M68K_CF_ISA_C_NODIV:
2864 isa = "C";
2865 additional = ", nodiv";
2866 break;
266abb8f
NS		 2867 }
2868 strcat (buf, ", cf, isa ");
2869 strcat (buf, isa);
0b2e31dc
NS		 2870 if (additional)
2871 strcat (buf, additional);
c694fd50 2872 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2873 strcat (buf, ", float");
c694fd50 2874 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2875 {
2876 case 0:
2877 mac = NULL;
2878 break;
c694fd50 2879 case EF_M68K_CF_MAC:
266abb8f
NS		 2880 mac = "mac";
2881 break;
c694fd50 2882 case EF_M68K_CF_EMAC:
266abb8f
NS		 2883 mac = "emac";
2884 break;
f608cd77
NS		 2885 case EF_M68K_CF_EMAC_B:
2886 mac = "emac_b";
2887 break;
266abb8f
NS		 2888 }
2889 if (mac)
2890 {
2891 strcat (buf, ", ");
2892 strcat (buf, mac);
2893 }
266abb8f 2894 }
53c7db4b 2895 break;
33c63f9d 2896
252b5132
RH		 2897 case EM_PPC:
2898 if (e_flags & EF_PPC_EMB)
2899 strcat (buf, ", emb");
2900
2901 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2902 strcat (buf, _(", relocatable"));
252b5132
RH		 2903
2904 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2905 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2906 break;
2907
ee67d69a
AM		 2908 case EM_PPC64:
2909 if (e_flags & EF_PPC64_ABI)
2910 {
2911 char abi[] = ", abiv0";
2912
2913 abi[6] += e_flags & EF_PPC64_ABI;
2914 strcat (buf, abi);
2915 }
2916 break;
2917
708e2187
NC		 2918 case EM_V800:
2919 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2920 strcat (buf, ", RH850 ABI");
0b4362b0 2921
708e2187
NC		 2922 if (e_flags & EF_V800_850E3)
2923 strcat (buf, ", V3 architecture");
2924
2925 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2926 strcat (buf, ", FPU not used");
2927
2928 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2929 strcat (buf, ", regmode: COMMON");
2930
2931 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2932 strcat (buf, ", r4 not used");
2933
2934 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2935 strcat (buf, ", r30 not used");
2936
2937 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2938 strcat (buf, ", r5 not used");
2939
2940 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2941 strcat (buf, ", r2 not used");
2942
2943 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2944 {
2945 switch (e_flags & - e_flags)
2946 {
2947 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2948 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2949 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2950 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2951 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2952 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2953 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2954 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2955 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2956 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2957 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2958 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2959 default: break;
2960 }
2961 }
2962 break;
2963
2b0337b0 2964 case EM_V850:
252b5132
RH		 2965 case EM_CYGNUS_V850:
2966 switch (e_flags & EF_V850_ARCH)
2967 {
78c8d46c
NC		 2968 case E_V850E3V5_ARCH:
2969 strcat (buf, ", v850e3v5");
2970 break;
1cd986c5
NC		 2971 case E_V850E2V3_ARCH:
2972 strcat (buf, ", v850e2v3");
2973 break;
2974 case E_V850E2_ARCH:
2975 strcat (buf, ", v850e2");
2976 break;
2977 case E_V850E1_ARCH:
2978 strcat (buf, ", v850e1");
8ad30312 2979 break;
252b5132
RH		 2980 case E_V850E_ARCH:
2981 strcat (buf, ", v850e");
2982 break;
252b5132
RH		 2983 case E_V850_ARCH:
2984 strcat (buf, ", v850");
2985 break;
2986 default:
2b692964 2987 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2988 break;
2989 }
2990 break;
2991
2b0337b0 2992 case EM_M32R:
252b5132
RH		 2993 case EM_CYGNUS_M32R:
2994 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2995 strcat (buf, ", m32r");
252b5132
RH		 2996 break;
2997
2998 case EM_MIPS:
4fe85591 2999 case EM_MIPS_RS3_LE:
252b5132
RH		 3000 if (e_flags & EF_MIPS_NOREORDER)
3001 strcat (buf, ", noreorder");
3002
3003 if (e_flags & EF_MIPS_PIC)
3004 strcat (buf, ", pic");
3005
3006 if (e_flags & EF_MIPS_CPIC)
3007 strcat (buf, ", cpic");
3008
d1bdd336
TS		 3009 if (e_flags & EF_MIPS_UCODE)
3010 strcat (buf, ", ugen_reserved");
3011
252b5132
RH		 3012 if (e_flags & EF_MIPS_ABI2)
3013 strcat (buf, ", abi2");
3014
43521d43
TS		 3015 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3016 strcat (buf, ", odk first");
3017
a5d22d2a
TS		 3018 if (e_flags & EF_MIPS_32BITMODE)
3019 strcat (buf, ", 32bitmode");
3020
ba92f887
MR		 3021 if (e_flags & EF_MIPS_NAN2008)
3022 strcat (buf, ", nan2008");
3023
fef1b0b3
SE		 3024 if (e_flags & EF_MIPS_FP64)
3025 strcat (buf, ", fp64");
3026
156c2f8b
NC		 3027 switch ((e_flags & EF_MIPS_MACH))
3028 {
3029 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3030 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3031 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3032 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3033 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3034 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3035 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3036 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3037 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3038 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3039 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3040 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3041 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3042 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3043 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3044 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3045 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3046 case 0:
3047 /* We simply ignore the field in this case to avoid confusion:
3048 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3049 extension. */
3050 break;
2b692964 3051 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3052 }
43521d43
TS		 3053
3054 switch ((e_flags & EF_MIPS_ABI))
3055 {
3056 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3057 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3058 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3059 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3060 case 0:
3061 /* We simply ignore the field in this case to avoid confusion:
3062 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3063 This means it is likely to be an o32 file, but not for
3064 sure. */
3065 break;
2b692964 3066 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3067 }
3068
3069 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3070 strcat (buf, ", mdmx");
3071
3072 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3073 strcat (buf, ", mips16");
3074
df58fc94
RS		 3075 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3076 strcat (buf, ", micromips");
3077
43521d43
TS		 3078 switch ((e_flags & EF_MIPS_ARCH))
3079 {
3080 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3081 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3082 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3083 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3084 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3085 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3086 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3087 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3088 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3089 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3090 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3091 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3092 }
252b5132 3093 break;
351b4b40 3094
35c08157
KLC		 3095 case EM_NDS32:
3096 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3097 break;
3098
ccde1100
AO		 3099 case EM_SH:
3100 switch ((e_flags & EF_SH_MACH_MASK))
3101 {
3102 case EF_SH1: strcat (buf, ", sh1"); break;
3103 case EF_SH2: strcat (buf, ", sh2"); break;
3104 case EF_SH3: strcat (buf, ", sh3"); break;
3105 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3106 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3107 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3108 case EF_SH3E: strcat (buf, ", sh3e"); break;
3109 case EF_SH4: strcat (buf, ", sh4"); break;
3110 case EF_SH5: strcat (buf, ", sh5"); break;
3111 case EF_SH2E: strcat (buf, ", sh2e"); break;
3112 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3113 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3114 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3115 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3116 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3117 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3118 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3119 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3120 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3121 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3122 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3123 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3124 }
3125
cec6a5b8
MR		 3126 if (e_flags & EF_SH_PIC)
3127 strcat (buf, ", pic");
3128
3129 if (e_flags & EF_SH_FDPIC)
3130 strcat (buf, ", fdpic");
ccde1100 3131 break;
948f632f 3132
73589c9d
CS		 3133 case EM_OR1K:
3134 if (e_flags & EF_OR1K_NODELAY)
3135 strcat (buf, ", no delay");
3136 break;
57346661 3137
351b4b40
RH		 3138 case EM_SPARCV9:
3139 if (e_flags & EF_SPARC_32PLUS)
3140 strcat (buf, ", v8+");
3141
3142 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3143 strcat (buf, ", ultrasparcI");
3144
3145 if (e_flags & EF_SPARC_SUN_US3)
3146 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3147
3148 if (e_flags & EF_SPARC_HAL_R1)
3149 strcat (buf, ", halr1");
3150
3151 if (e_flags & EF_SPARC_LEDATA)
3152 strcat (buf, ", ledata");
3153
3154 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3155 strcat (buf, ", tso");
3156
3157 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3158 strcat (buf, ", pso");
3159
3160 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3161 strcat (buf, ", rmo");
3162 break;
7d466069 3163
103f02d3
UD		 3164 case EM_PARISC:
3165 switch (e_flags & EF_PARISC_ARCH)
3166 {
3167 case EFA_PARISC_1_0:
3168 strcpy (buf, ", PA-RISC 1.0");
3169 break;
3170 case EFA_PARISC_1_1:
3171 strcpy (buf, ", PA-RISC 1.1");
3172 break;
3173 case EFA_PARISC_2_0:
3174 strcpy (buf, ", PA-RISC 2.0");
3175 break;
3176 default:
3177 break;
3178 }
3179 if (e_flags & EF_PARISC_TRAPNIL)
3180 strcat (buf, ", trapnil");
3181 if (e_flags & EF_PARISC_EXT)
3182 strcat (buf, ", ext");
3183 if (e_flags & EF_PARISC_LSB)
3184 strcat (buf, ", lsb");
3185 if (e_flags & EF_PARISC_WIDE)
3186 strcat (buf, ", wide");
3187 if (e_flags & EF_PARISC_NO_KABP)
3188 strcat (buf, ", no kabp");
3189 if (e_flags & EF_PARISC_LAZYSWAP)
3190 strcat (buf, ", lazyswap");
30800947 3191 break;
76da6bbe 3192
7d466069 3193 case EM_PJ:
2b0337b0 3194 case EM_PJ_OLD:
7d466069
ILT		 3195 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3196 strcat (buf, ", new calling convention");
3197
3198 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3199 strcat (buf, ", gnu calling convention");
3200 break;
4d6ed7c8
NC		 3201
3202 case EM_IA_64:
3203 if ((e_flags & EF_IA_64_ABI64))
3204 strcat (buf, ", 64-bit");
3205 else
3206 strcat (buf, ", 32-bit");
3207 if ((e_flags & EF_IA_64_REDUCEDFP))
3208 strcat (buf, ", reduced fp model");
3209 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3210 strcat (buf, ", no function descriptors, constant gp");
3211 else if ((e_flags & EF_IA_64_CONS_GP))
3212 strcat (buf, ", constant gp");
3213 if ((e_flags & EF_IA_64_ABSOLUTE))
3214 strcat (buf, ", absolute");
28f997cf
TG		 3215 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3216 {
3217 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3218 strcat (buf, ", vms_linkages");
3219 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3220 {
3221 case EF_IA_64_VMS_COMCOD_SUCCESS:
3222 break;
3223 case EF_IA_64_VMS_COMCOD_WARNING:
3224 strcat (buf, ", warning");
3225 break;
3226 case EF_IA_64_VMS_COMCOD_ERROR:
3227 strcat (buf, ", error");
3228 break;
3229 case EF_IA_64_VMS_COMCOD_ABORT:
3230 strcat (buf, ", abort");
3231 break;
3232 default:
bee0ee85
NC		 3233 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3234 e_flags & EF_IA_64_VMS_COMCOD);
3235 strcat (buf, ", <unknown>");
28f997cf
TG		 3236 }
3237 }
4d6ed7c8 3238 break;
179d3252
JT		 3239
3240 case EM_VAX:
3241 if ((e_flags & EF_VAX_NONPIC))
3242 strcat (buf, ", non-PIC");
3243 if ((e_flags & EF_VAX_DFLOAT))
3244 strcat (buf, ", D-Float");
3245 if ((e_flags & EF_VAX_GFLOAT))
3246 strcat (buf, ", G-Float");
3247 break;
c7927a3c 3248
619ed720
EB		 3249 case EM_VISIUM:
3250 if (e_flags & EF_VISIUM_ARCH_MCM)
3251 strcat (buf, ", mcm");
3252 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3253 strcat (buf, ", mcm24");
3254 if (e_flags & EF_VISIUM_ARCH_GR6)
3255 strcat (buf, ", gr6");
3256 break;
3257
4046d87a
NC		 3258 case EM_RL78:
3259 if (e_flags & E_FLAG_RL78_G10)
3260 strcat (buf, ", G10");
856ea05c
KP		 3261 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3262 strcat (buf, ", 64-bit doubles");
4046d87a 3263 break;
0b4362b0 3264
c7927a3c
NC		 3265 case EM_RX:
3266 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3267 strcat (buf, ", 64-bit doubles");
3268 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3269 strcat (buf, ", dsp");
d4cb0ea0 3270 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3271 strcat (buf, ", pid");
708e2187
NC		 3272 if (e_flags & E_FLAG_RX_ABI)
3273 strcat (buf, ", RX ABI");
d4cb0ea0 3274 break;
55786da2
AK		 3275
3276 case EM_S390:
3277 if (e_flags & EF_S390_HIGH_GPRS)
3278 strcat (buf, ", highgprs");
d4cb0ea0 3279 break;
40b36596
JM		 3280
3281 case EM_TI_C6000:
3282 if ((e_flags & EF_C6000_REL))
3283 strcat (buf, ", relocatable module");
d4cb0ea0 3284 break;
13761a11
NC		 3285
3286 case EM_MSP430:
3287 strcat (buf, _(": architecture variant: "));
3288 switch (e_flags & EF_MSP430_MACH)
3289 {
3290 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3291 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3292 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3293 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3294 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3295 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3296 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3297 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3298 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3299 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3300 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3301 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3302 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3303 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3304 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3305 default:
3306 strcat (buf, _(": unknown")); break;
3307 }
3308
3309 if (e_flags & ~ EF_MSP430_MACH)
3310 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3311 }
3312 }
3313
3314 return buf;
3315}
3316
252b5132 3317static const char *
d3ba0551
AM		 3318get_osabi_name (unsigned int osabi)
3319{
3320 static char buff[32];
3321
3322 switch (osabi)
3323 {
3324 case ELFOSABI_NONE: return "UNIX - System V";
3325 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3326 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3327 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3328 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3329 case ELFOSABI_AIX: return "UNIX - AIX";
3330 case ELFOSABI_IRIX: return "UNIX - IRIX";
3331 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3332 case ELFOSABI_TRU64: return "UNIX - TRU64";
3333 case ELFOSABI_MODESTO: return "Novell - Modesto";
3334 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3335 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3336 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3337 case ELFOSABI_AROS: return "AROS";
11636f9e 3338 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3339 default:
40b36596
JM		 3340 if (osabi >= 64)
3341 switch (elf_header.e_machine)
3342 {
3343 case EM_ARM:
3344 switch (osabi)
3345 {
3346 case ELFOSABI_ARM: return "ARM";
3347 default:
3348 break;
3349 }
3350 break;
3351
3352 case EM_MSP430:
3353 case EM_MSP430_OLD:
619ed720 3354 case EM_VISIUM:
40b36596
JM		 3355 switch (osabi)
3356 {
3357 case ELFOSABI_STANDALONE: return _("Standalone App");
3358 default:
3359 break;
3360 }
3361 break;
3362
3363 case EM_TI_C6000:
3364 switch (osabi)
3365 {
3366 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3367 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3368 default:
3369 break;
3370 }
3371 break;
3372
3373 default:
3374 break;
3375 }
e9e44622 3376 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3377 return buff;
3378 }
3379}
3380
a06ea964
NC		 3381static const char *
3382get_aarch64_segment_type (unsigned long type)
3383{
3384 switch (type)
3385 {
3386 case PT_AARCH64_ARCHEXT:
3387 return "AARCH64_ARCHEXT";
3388 default:
3389 break;
3390 }
3391
3392 return NULL;
3393}
3394
b294bdf8
MM		 3395static const char *
3396get_arm_segment_type (unsigned long type)
3397{
3398 switch (type)
3399 {
3400 case PT_ARM_EXIDX:
3401 return "EXIDX";
3402 default:
3403 break;
3404 }
3405
3406 return NULL;
3407}
3408
d3ba0551
AM		 3409static const char *
3410get_mips_segment_type (unsigned long type)
252b5132
RH		 3411{
3412 switch (type)
3413 {
3414 case PT_MIPS_REGINFO:
3415 return "REGINFO";
3416 case PT_MIPS_RTPROC:
3417 return "RTPROC";
3418 case PT_MIPS_OPTIONS:
3419 return "OPTIONS";
351cdf24
MF		 3420 case PT_MIPS_ABIFLAGS:
3421 return "ABIFLAGS";
252b5132
RH		 3422 default:
3423 break;
3424 }
3425
3426 return NULL;
3427}
3428
103f02d3 3429static const char *
d3ba0551 3430get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3431{
3432 switch (type)
3433 {
3434 case PT_HP_TLS: return "HP_TLS";
3435 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3436 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3437 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3438 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3439 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3440 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3441 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3442 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3443 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3444 case PT_HP_PARALLEL: return "HP_PARALLEL";
3445 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3446 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3447 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3448 case PT_HP_STACK: return "HP_STACK";
3449 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3450 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3451 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3452 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3453 default:
3454 break;
3455 }
3456
3457 return NULL;
3458}
3459
4d6ed7c8 3460static const char *
d3ba0551 3461get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3462{
3463 switch (type)
3464 {
3465 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3466 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3467 case PT_HP_TLS: return "HP_TLS";
3468 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3469 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3470 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3471 default:
3472 break;
3473 }
3474
3475 return NULL;
3476}
3477
40b36596
JM		 3478static const char *
3479get_tic6x_segment_type (unsigned long type)
3480{
3481 switch (type)
3482 {
3483 case PT_C6000_PHATTR: return "C6000_PHATTR";
3484 default:
3485 break;
3486 }
3487
3488 return NULL;
3489}
3490
252b5132 3491static const char *
d3ba0551 3492get_segment_type (unsigned long p_type)
252b5132 3493{
b34976b6 3494 static char buff[32];
252b5132
RH		 3495
3496 switch (p_type)
3497 {
b34976b6
AM		 3498 case PT_NULL: return "NULL";
3499 case PT_LOAD: return "LOAD";
252b5132 3500 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3501 case PT_INTERP: return "INTERP";
3502 case PT_NOTE: return "NOTE";
3503 case PT_SHLIB: return "SHLIB";
3504 case PT_PHDR: return "PHDR";
13ae64f3 3505 case PT_TLS: return "TLS";
252b5132 3506
65765700
JJ		 3507 case PT_GNU_EH_FRAME:
3508 return "GNU_EH_FRAME";
2b05f1b7 3509 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3510 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3511
252b5132
RH		 3512 default:
3513 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3514 {
2cf0635d 3515 const char * result;
103f02d3 3516
252b5132
RH		 3517 switch (elf_header.e_machine)
3518 {
a06ea964
NC		 3519 case EM_AARCH64:
3520 result = get_aarch64_segment_type (p_type);
3521 break;
b294bdf8
MM		 3522 case EM_ARM:
3523 result = get_arm_segment_type (p_type);
3524 break;
252b5132 3525 case EM_MIPS:
4fe85591 3526 case EM_MIPS_RS3_LE:
252b5132
RH		 3527 result = get_mips_segment_type (p_type);
3528 break;
103f02d3
UD		 3529 case EM_PARISC:
3530 result = get_parisc_segment_type (p_type);
3531 break;
4d6ed7c8
NC		 3532 case EM_IA_64:
3533 result = get_ia64_segment_type (p_type);
3534 break;
40b36596
JM		 3535 case EM_TI_C6000:
3536 result = get_tic6x_segment_type (p_type);
3537 break;
252b5132
RH		 3538 default:
3539 result = NULL;
3540 break;
3541 }
103f02d3 3542
252b5132
RH		 3543 if (result != NULL)
3544 return result;
103f02d3 3545
252b5132
RH		 3546 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3547 }
3548 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3549 {
2cf0635d 3550 const char * result;
103f02d3
UD		 3551
3552 switch (elf_header.e_machine)
3553 {
3554 case EM_PARISC:
3555 result = get_parisc_segment_type (p_type);
3556 break;
00428cca
AM		 3557 case EM_IA_64:
3558 result = get_ia64_segment_type (p_type);
3559 break;
103f02d3
UD		 3560 default:
3561 result = NULL;
3562 break;
3563 }
3564
3565 if (result != NULL)
3566 return result;
3567
3568 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3569 }
252b5132 3570 else
e9e44622 3571 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3572
3573 return buff;
3574 }
3575}
3576
3577static const char *
d3ba0551 3578get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3579{
3580 switch (sh_type)
3581 {
b34976b6
AM		 3582 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3583 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3584 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3585 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3586 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3587 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3588 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3589 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3590 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3591 case SHT_MIPS_RELD: return "MIPS_RELD";
3592 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3593 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3594 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3595 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3596 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3597 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3598 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3599 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3600 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3601 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3602 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3603 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3604 case SHT_MIPS_LINE: return "MIPS_LINE";
3605 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3606 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3607 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3608 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3609 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3610 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3611 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3612 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3613 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3614 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3615 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3616 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3617 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3618 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3619 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3620 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3621 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3622 default:
3623 break;
3624 }
3625 return NULL;
3626}
3627
103f02d3 3628static const char *
d3ba0551 3629get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3630{
3631 switch (sh_type)
3632 {
3633 case SHT_PARISC_EXT: return "PARISC_EXT";
3634 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3635 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3636 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3637 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3638 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3639 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3640 default:
3641 break;
3642 }
3643 return NULL;
3644}
3645
4d6ed7c8 3646static const char *
d3ba0551 3647get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3648{
18bd398b 3649 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3650 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3651 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3652
4d6ed7c8
NC		 3653 switch (sh_type)
3654 {
148b93f2
NC		 3655 case SHT_IA_64_EXT: return "IA_64_EXT";
3656 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3657 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3658 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3659 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3660 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3661 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3662 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3663 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3664 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3665 default:
3666 break;
3667 }
3668 return NULL;
3669}
3670
d2b2c203
DJ		 3671static const char *
3672get_x86_64_section_type_name (unsigned int sh_type)
3673{
3674 switch (sh_type)
3675 {
3676 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3677 default:
3678 break;
3679 }
3680 return NULL;
3681}
3682
a06ea964
NC		 3683static const char *
3684get_aarch64_section_type_name (unsigned int sh_type)
3685{
3686 switch (sh_type)
3687 {
3688 case SHT_AARCH64_ATTRIBUTES:
3689 return "AARCH64_ATTRIBUTES";
3690 default:
3691 break;
3692 }
3693 return NULL;
3694}
3695
40a18ebd
NC		 3696static const char *
3697get_arm_section_type_name (unsigned int sh_type)
3698{
3699 switch (sh_type)
3700 {
7f6fed87
NC		 3701 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3702 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3703 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3704 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3705 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3706 default:
3707 break;
3708 }
3709 return NULL;
3710}
3711
40b36596
JM		 3712static const char *
3713get_tic6x_section_type_name (unsigned int sh_type)
3714{
3715 switch (sh_type)
3716 {
3717 case SHT_C6000_UNWIND:
3718 return "C6000_UNWIND";
3719 case SHT_C6000_PREEMPTMAP:
3720 return "C6000_PREEMPTMAP";
3721 case SHT_C6000_ATTRIBUTES:
3722 return "C6000_ATTRIBUTES";
3723 case SHT_TI_ICODE:
3724 return "TI_ICODE";
3725 case SHT_TI_XREF:
3726 return "TI_XREF";
3727 case SHT_TI_HANDLER:
3728 return "TI_HANDLER";
3729 case SHT_TI_INITINFO:
3730 return "TI_INITINFO";
3731 case SHT_TI_PHATTRS:
3732 return "TI_PHATTRS";
3733 default:
3734 break;
3735 }
3736 return NULL;
3737}
3738
13761a11
NC		 3739static const char *
3740get_msp430x_section_type_name (unsigned int sh_type)
3741{
3742 switch (sh_type)
3743 {
3744 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3745 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3746 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3747 default: return NULL;
3748 }
3749}
3750
685080f2
NC		 3751static const char *
3752get_v850_section_type_name (unsigned int sh_type)
3753{
3754 switch (sh_type)
3755 {
3756 case SHT_V850_SCOMMON: return "V850 Small Common";
3757 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3758 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3759 case SHT_RENESAS_IOP: return "RENESAS IOP";
3760 case SHT_RENESAS_INFO: return "RENESAS INFO";
3761 default: return NULL;
3762 }
3763}
3764
252b5132 3765static const char *
d3ba0551 3766get_section_type_name (unsigned int sh_type)
252b5132 3767{
b34976b6 3768 static char buff[32];
252b5132
RH		 3769
3770 switch (sh_type)
3771 {
3772 case SHT_NULL: return "NULL";
3773 case SHT_PROGBITS: return "PROGBITS";
3774 case SHT_SYMTAB: return "SYMTAB";
3775 case SHT_STRTAB: return "STRTAB";
3776 case SHT_RELA: return "RELA";
3777 case SHT_HASH: return "HASH";
3778 case SHT_DYNAMIC: return "DYNAMIC";
3779 case SHT_NOTE: return "NOTE";
3780 case SHT_NOBITS: return "NOBITS";
3781 case SHT_REL: return "REL";
3782 case SHT_SHLIB: return "SHLIB";
3783 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3784 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3785 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3786 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3787 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3788 case SHT_GROUP: return "GROUP";
3789 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3790 case SHT_GNU_verdef: return "VERDEF";
3791 case SHT_GNU_verneed: return "VERNEED";
3792 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3793 case 0x6ffffff0: return "VERSYM";
3794 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3795 case 0x7ffffffd: return "AUXILIARY";
3796 case 0x7fffffff: return "FILTER";
047b2264 3797 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3798
3799 default:
3800 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3801 {
2cf0635d 3802 const char * result;
252b5132
RH		 3803
3804 switch (elf_header.e_machine)
3805 {
3806 case EM_MIPS:
4fe85591 3807 case EM_MIPS_RS3_LE:
252b5132
RH		 3808 result = get_mips_section_type_name (sh_type);
3809 break;
103f02d3
UD		 3810 case EM_PARISC:
3811 result = get_parisc_section_type_name (sh_type);
3812 break;
4d6ed7c8
NC		 3813 case EM_IA_64:
3814 result = get_ia64_section_type_name (sh_type);
3815 break;
d2b2c203 3816 case EM_X86_64:
8a9036a4 3817 case EM_L1OM:
7a9068fe 3818 case EM_K1OM:
d2b2c203
DJ		 3819 result = get_x86_64_section_type_name (sh_type);
3820 break;
a06ea964
NC		 3821 case EM_AARCH64:
3822 result = get_aarch64_section_type_name (sh_type);
3823 break;
40a18ebd
NC		 3824 case EM_ARM:
3825 result = get_arm_section_type_name (sh_type);
3826 break;
40b36596
JM		 3827 case EM_TI_C6000:
3828 result = get_tic6x_section_type_name (sh_type);
3829 break;
13761a11
NC		 3830 case EM_MSP430:
3831 result = get_msp430x_section_type_name (sh_type);
3832 break;
685080f2
NC		 3833 case EM_V800:
3834 case EM_V850:
3835 case EM_CYGNUS_V850:
3836 result = get_v850_section_type_name (sh_type);
3837 break;
252b5132
RH		 3838 default:
3839 result = NULL;
3840 break;
3841 }
3842
3843 if (result != NULL)
3844 return result;
3845
c91d0dfb 3846 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3847 }
3848 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3849 {
2cf0635d 3850 const char * result;
148b93f2
NC		 3851
3852 switch (elf_header.e_machine)
3853 {
3854 case EM_IA_64:
3855 result = get_ia64_section_type_name (sh_type);
3856 break;
3857 default:
3858 result = NULL;
3859 break;
3860 }
3861
3862 if (result != NULL)
3863 return result;
3864
3865 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3866 }
252b5132 3867 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3868 {
3869 switch (elf_header.e_machine)
3870 {
3871 case EM_V800:
3872 case EM_V850:
3873 case EM_CYGNUS_V850:
3874 return get_v850_section_type_name (sh_type);
3875 default:
3876 break;
3877 }
3878
3879 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3880 }
252b5132 3881 else
a7dbfd1c
NC		 3882 /* This message is probably going to be displayed in a 15
3883 character wide field, so put the hex value first. */
3884 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3885
252b5132
RH		 3886 return buff;
3887 }
3888}
3889
2979dc34 3890#define OPTION_DEBUG_DUMP 512
2c610e4b 3891#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3892#define OPTION_DWARF_DEPTH 514
3893#define OPTION_DWARF_START 515
4723351a 3894#define OPTION_DWARF_CHECK 516
2979dc34 3895
85b1c36d 3896static struct option options[] =
252b5132 3897{
b34976b6 3898 {"all", no_argument, 0, 'a'},
252b5132
RH		 3899 {"file-header", no_argument, 0, 'h'},
3900 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3901 {"headers", no_argument, 0, 'e'},
3902 {"histogram", no_argument, 0, 'I'},
3903 {"segments", no_argument, 0, 'l'},
3904 {"sections", no_argument, 0, 'S'},
252b5132 3905 {"section-headers", no_argument, 0, 'S'},
f5842774 3906 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3907 {"section-details", no_argument, 0, 't'},
595cf52e 3908 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3909 {"symbols", no_argument, 0, 's'},
3910 {"syms", no_argument, 0, 's'},
2c610e4b 3911 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3912 {"relocs", no_argument, 0, 'r'},
3913 {"notes", no_argument, 0, 'n'},
3914 {"dynamic", no_argument, 0, 'd'},
a952a375 3915 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3916 {"version-info", no_argument, 0, 'V'},
3917 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3918 {"unwind", no_argument, 0, 'u'},
4145f1d5 3919 {"archive-index", no_argument, 0, 'c'},
b34976b6 3920 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3921 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3922 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3923#ifdef SUPPORT_DISASSEMBLY
3924 {"instruction-dump", required_argument, 0, 'i'},
3925#endif
cf13d699 3926 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3927
fd2f0033
TT		 3928 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3929 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3930 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3931
b34976b6
AM		 3932 {"version", no_argument, 0, 'v'},
3933 {"wide", no_argument, 0, 'W'},
3934 {"help", no_argument, 0, 'H'},
3935 {0, no_argument, 0, 0}
252b5132
RH		 3936};
3937
3938static void
2cf0635d 3939usage (FILE * stream)
252b5132 3940{
92f01d61
JM		 3941 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3942 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3943 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3944 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3945 -h --file-header Display the ELF file header\n\
3946 -l --program-headers Display the program headers\n\
3947 --segments An alias for --program-headers\n\
3948 -S --section-headers Display the sections' header\n\
3949 --sections An alias for --section-headers\n\
f5842774 3950 -g --section-groups Display the section groups\n\
5477e8a0 3951 -t --section-details Display the section details\n\
8b53311e
NC		 3952 -e --headers Equivalent to: -h -l -S\n\
3953 -s --syms Display the symbol table\n\
3f08eb35 3954 --symbols An alias for --syms\n\
2c610e4b 3955 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3956 -n --notes Display the core notes (if present)\n\
3957 -r --relocs Display the relocations (if present)\n\
3958 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3959 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3960 -V --version-info Display the version sections (if present)\n\
1b31d05e 3961 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3962 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3963 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3964 -x --hex-dump=<number|name>\n\
3965 Dump the contents of section <number|name> as bytes\n\
3966 -p --string-dump=<number|name>\n\
3967 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3968 -R --relocated-dump=<number|name>\n\
3969 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3970 -w[lLiaprmfFsoRt] or\n\
1ed06042 3971 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3972 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3973 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3974 =addr,=cu_index]\n\
8b53311e 3975 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3976 fprintf (stream, _("\
3977 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3978 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3979 or deeper\n"));
252b5132 3980#ifdef SUPPORT_DISASSEMBLY
92f01d61 3981 fprintf (stream, _("\
09c11c86
NC		 3982 -i --instruction-dump=<number|name>\n\
3983 Disassemble the contents of section <number|name>\n"));
252b5132 3984#endif
92f01d61 3985 fprintf (stream, _("\
8b53311e
NC		 3986 -I --histogram Display histogram of bucket list lengths\n\
3987 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3988 @<file> Read options from <file>\n\
8b53311e
NC		 3989 -H --help Display this information\n\
3990 -v --version Display the version number of readelf\n"));
1118d252 3991
92f01d61
JM		 3992 if (REPORT_BUGS_TO[0] && stream == stdout)
3993 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3994
92f01d61 3995 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3996}
3997
18bd398b
NC		 3998/* Record the fact that the user wants the contents of section number
3999 SECTION to be displayed using the method(s) encoded as flags bits
4000 in TYPE. Note, TYPE can be zero if we are creating the array for
4001 the first time. */
4002
252b5132 4003static void
09c11c86 4004request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4005{
4006 if (section >= num_dump_sects)
4007 {
2cf0635d 4008 dump_type * new_dump_sects;
252b5132 4009
3f5e193b
NC		 4010 new_dump_sects = (dump_type *) calloc (section + 1,
4011 sizeof (* dump_sects));
252b5132
RH		 4012
4013 if (new_dump_sects == NULL)
591a748a 4014 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4015 else
4016 {
4017 /* Copy current flag settings. */
09c11c86 4018 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4019
4020 free (dump_sects);
4021
4022 dump_sects = new_dump_sects;
4023 num_dump_sects = section + 1;
4024 }
4025 }
4026
4027 if (dump_sects)
b34976b6 4028 dump_sects[section] |= type;
252b5132
RH		 4029
4030 return;
4031}
4032
aef1f6d0
DJ		 4033/* Request a dump by section name. */
4034
4035static void
2cf0635d 4036request_dump_byname (const char * section, dump_type type)
aef1f6d0 4037{
2cf0635d 4038 struct dump_list_entry * new_request;
aef1f6d0 4039
3f5e193b
NC		 4040 new_request = (struct dump_list_entry *)
4041 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4042 if (!new_request)
591a748a 4043 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4044
4045 new_request->name = strdup (section);
4046 if (!new_request->name)
591a748a 4047 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4048
4049 new_request->type = type;
4050
4051 new_request->next = dump_sects_byname;
4052 dump_sects_byname = new_request;
4053}
4054
cf13d699
NC		 4055static inline void
4056request_dump (dump_type type)
4057{
4058 int section;
4059 char * cp;
4060
4061 do_dump++;
4062 section = strtoul (optarg, & cp, 0);
4063
4064 if (! *cp && section >= 0)
4065 request_dump_bynumber (section, type);
4066 else
4067 request_dump_byname (optarg, type);
4068}
4069
4070
252b5132 4071static void
2cf0635d 4072parse_args (int argc, char ** argv)
252b5132
RH		 4073{
4074 int c;
4075
4076 if (argc < 2)
92f01d61 4077 usage (stderr);
252b5132
RH		 4078
4079 while ((c = getopt_long
cf13d699 4080 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 4081 {
252b5132
RH		 4082 switch (c)
4083 {
4084 case 0:
4085 /* Long options. */
4086 break;
4087 case 'H':
92f01d61 4088 usage (stdout);
252b5132
RH		 4089 break;
4090
4091 case 'a':
b34976b6
AM		 4092 do_syms++;
4093 do_reloc++;
4094 do_unwind++;
4095 do_dynamic++;
4096 do_header++;
4097 do_sections++;
f5842774 4098 do_section_groups++;
b34976b6
AM		 4099 do_segments++;
4100 do_version++;
4101 do_histogram++;
4102 do_arch++;
4103 do_notes++;
252b5132 4104 break;
f5842774
L		 4105 case 'g':
4106 do_section_groups++;
4107 break;
5477e8a0 4108 case 't':
595cf52e 4109 case 'N':
5477e8a0
L		 4110 do_sections++;
4111 do_section_details++;
595cf52e 4112 break;
252b5132 4113 case 'e':
b34976b6
AM		 4114 do_header++;
4115 do_sections++;
4116 do_segments++;
252b5132 4117 break;
a952a375 4118 case 'A':
b34976b6 4119 do_arch++;
a952a375 4120 break;
252b5132 4121 case 'D':
b34976b6 4122 do_using_dynamic++;
252b5132
RH		 4123 break;
4124 case 'r':
b34976b6 4125 do_reloc++;
252b5132 4126 break;
4d6ed7c8 4127 case 'u':
b34976b6 4128 do_unwind++;
4d6ed7c8 4129 break;
252b5132 4130 case 'h':
b34976b6 4131 do_header++;
252b5132
RH		 4132 break;
4133 case 'l':
b34976b6 4134 do_segments++;
252b5132
RH		 4135 break;
4136 case 's':
b34976b6 4137 do_syms++;
252b5132
RH		 4138 break;
4139 case 'S':
b34976b6 4140 do_sections++;
252b5132
RH		 4141 break;
4142 case 'd':
b34976b6 4143 do_dynamic++;
252b5132 4144 break;
a952a375 4145 case 'I':
b34976b6 4146 do_histogram++;
a952a375 4147 break;
779fe533 4148 case 'n':
b34976b6 4149 do_notes++;
779fe533 4150 break;
4145f1d5
NC		 4151 case 'c':
4152 do_archive_index++;
4153 break;
252b5132 4154 case 'x':
cf13d699 4155 request_dump (HEX_DUMP);
aef1f6d0 4156 break;
09c11c86 4157 case 'p':
cf13d699
NC		 4158 request_dump (STRING_DUMP);
4159 break;
4160 case 'R':
4161 request_dump (RELOC_DUMP);
09c11c86 4162 break;
252b5132 4163 case 'w':
b34976b6 4164 do_dump++;
252b5132 4165 if (optarg == 0)
613ff48b
CC		 4166 {
4167 do_debugging = 1;
4168 dwarf_select_sections_all ();
4169 }
252b5132
RH		 4170 else
4171 {
4172 do_debugging = 0;
4cb93e3b 4173 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4174 }
4175 break;
2979dc34 4176 case OPTION_DEBUG_DUMP:
b34976b6 4177 do_dump++;
2979dc34
JJ		 4178 if (optarg == 0)
4179 do_debugging = 1;
4180 else
4181 {
2979dc34 4182 do_debugging = 0;
4cb93e3b 4183 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4184 }
4185 break;
fd2f0033
TT		 4186 case OPTION_DWARF_DEPTH:
4187 {
4188 char *cp;
4189
4190 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4191 }
4192 break;
4193 case OPTION_DWARF_START:
4194 {
4195 char *cp;
4196
4197 dwarf_start_die = strtoul (optarg, & cp, 0);
4198 }
4199 break;
4723351a
CC		 4200 case OPTION_DWARF_CHECK:
4201 dwarf_check = 1;
4202 break;
2c610e4b
L		 4203 case OPTION_DYN_SYMS:
4204 do_dyn_syms++;
4205 break;
252b5132
RH		 4206#ifdef SUPPORT_DISASSEMBLY
4207 case 'i':
cf13d699
NC		 4208 request_dump (DISASS_DUMP);
4209 break;
252b5132
RH		 4210#endif
4211 case 'v':
4212 print_version (program_name);
4213 break;
4214 case 'V':
b34976b6 4215 do_version++;
252b5132 4216 break;
d974e256 4217 case 'W':
b34976b6 4218 do_wide++;
d974e256 4219 break;
252b5132 4220 default:
252b5132
RH		 4221 /* xgettext:c-format */
4222 error (_("Invalid option '-%c'\n"), c);
4223 /* Drop through. */
4224 case '?':
92f01d61 4225 usage (stderr);
252b5132
RH		 4226 }
4227 }
4228
4d6ed7c8 4229 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4230 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4231 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4232 && !do_section_groups && !do_archive_index
4233 && !do_dyn_syms)
92f01d61 4234 usage (stderr);
252b5132
RH		 4235}
4236
4237static const char *
d3ba0551 4238get_elf_class (unsigned int elf_class)
252b5132 4239{
b34976b6 4240 static char buff[32];
103f02d3 4241
252b5132
RH		 4242 switch (elf_class)
4243 {
4244 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4245 case ELFCLASS32: return "ELF32";
4246 case ELFCLASS64: return "ELF64";
ab5e7794 4247 default:
e9e44622 4248 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4249 return buff;
252b5132
RH		 4250 }
4251}
4252
4253static const char *
d3ba0551 4254get_data_encoding (unsigned int encoding)
252b5132 4255{
b34976b6 4256 static char buff[32];
103f02d3 4257
252b5132
RH		 4258 switch (encoding)
4259 {
4260 case ELFDATANONE: return _("none");
33c63f9d
CM		 4261 case ELFDATA2LSB: return _("2's complement, little endian");
4262 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4263 default:
e9e44622 4264 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4265 return buff;
252b5132
RH		 4266 }
4267}
4268
252b5132 4269/* Decode the data held in 'elf_header'. */
ee42cf8c 4270
252b5132 4271static int
d3ba0551 4272process_file_header (void)
252b5132 4273{
b34976b6
AM		 4274 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4275 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4276 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4277 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4278 {
4279 error
4280 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4281 return 0;
4282 }
4283
2dc4cec1
L		 4284 init_dwarf_regnames (elf_header.e_machine);
4285
252b5132
RH		 4286 if (do_header)
4287 {
4288 int i;
4289
4290 printf (_("ELF Header:\n"));
4291 printf (_(" Magic: "));
b34976b6
AM		 4292 for (i = 0; i < EI_NIDENT; i++)
4293 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4294 printf ("\n");
4295 printf (_(" Class: %s\n"),
b34976b6 4296 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4297 printf (_(" Data: %s\n"),
b34976b6 4298 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4299 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4300 elf_header.e_ident[EI_VERSION],
4301 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4302 ? "(current)"
b34976b6 4303 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4304 ? _("<unknown: %lx>")
789be9f7 4305 : "")));
252b5132 4306 printf (_(" OS/ABI: %s\n"),
b34976b6 4307 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4308 printf (_(" ABI Version: %d\n"),
b34976b6 4309 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4310 printf (_(" Type: %s\n"),
4311 get_file_type (elf_header.e_type));
4312 printf (_(" Machine: %s\n"),
4313 get_machine_name (elf_header.e_machine));
4314 printf (_(" Version: 0x%lx\n"),
4315 (unsigned long) elf_header.e_version);
76da6bbe 4316
f7a99963
NC		 4317 printf (_(" Entry point address: "));
4318 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4319 printf (_("\n Start of program headers: "));
4320 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4321 printf (_(" (bytes into file)\n Start of section headers: "));
4322 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4323 printf (_(" (bytes into file)\n"));
76da6bbe 4324
252b5132
RH		 4325 printf (_(" Flags: 0x%lx%s\n"),
4326 (unsigned long) elf_header.e_flags,
4327 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4328 printf (_(" Size of this header: %ld (bytes)\n"),
4329 (long) elf_header.e_ehsize);
4330 printf (_(" Size of program headers: %ld (bytes)\n"),
4331 (long) elf_header.e_phentsize);
2046a35d 4332 printf (_(" Number of program headers: %ld"),
252b5132 4333 (long) elf_header.e_phnum);
2046a35d
AM		 4334 if (section_headers != NULL
4335 && elf_header.e_phnum == PN_XNUM
4336 && section_headers[0].sh_info != 0)
cc5914eb 4337 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4338 putc ('\n', stdout);
252b5132
RH		 4339 printf (_(" Size of section headers: %ld (bytes)\n"),
4340 (long) elf_header.e_shentsize);
560f3c1c 4341 printf (_(" Number of section headers: %ld"),
252b5132 4342 (long) elf_header.e_shnum);
4fbb74a6 4343 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4344 printf (" (%ld)", (long) section_headers[0].sh_size);
4345 putc ('\n', stdout);
4346 printf (_(" Section header string table index: %ld"),
252b5132 4347 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4348 if (section_headers != NULL
4349 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4350 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4351 else if (elf_header.e_shstrndx != SHN_UNDEF
4352 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4353 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4354 putc ('\n', stdout);
4355 }
4356
4357 if (section_headers != NULL)
4358 {
2046a35d
AM		 4359 if (elf_header.e_phnum == PN_XNUM
4360 && section_headers[0].sh_info != 0)
4361 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4362 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4363 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4364 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4365 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4366 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4367 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4368 free (section_headers);
4369 section_headers = NULL;
252b5132 4370 }
103f02d3 4371
9ea033b2
NC		 4372 return 1;
4373}
4374
e0a31db1 4375static bfd_boolean
91d6fa6a 4376get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4377{
2cf0635d
NC		 4378 Elf32_External_Phdr * phdrs;
4379 Elf32_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 = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4397 size, num, _("program headers"));
4398 if (phdrs == NULL)
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++)
252b5132 4404 {
9ea033b2
NC		 4405 internal->p_type = BYTE_GET (external->p_type);
4406 internal->p_offset = BYTE_GET (external->p_offset);
4407 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4408 internal->p_paddr = BYTE_GET (external->p_paddr);
4409 internal->p_filesz = BYTE_GET (external->p_filesz);
4410 internal->p_memsz = BYTE_GET (external->p_memsz);
4411 internal->p_flags = BYTE_GET (external->p_flags);
4412 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4413 }
4414
9ea033b2 4415 free (phdrs);
e0a31db1 4416 return TRUE;
252b5132
RH		 4417}
4418
e0a31db1 4419static bfd_boolean
91d6fa6a 4420get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4421{
2cf0635d
NC		 4422 Elf64_External_Phdr * phdrs;
4423 Elf64_External_Phdr * external;
4424 Elf_Internal_Phdr * internal;
b34976b6 4425 unsigned int i;
e0a31db1
NC		 4426 unsigned int size = elf_header.e_phentsize;
4427 unsigned int num = elf_header.e_phnum;
4428
4429 /* PR binutils/17531: Cope with unexpected section header sizes. */
4430 if (size == 0 || num == 0)
4431 return FALSE;
4432 if (size < sizeof * phdrs)
4433 {
4434 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4435 return FALSE;
4436 }
4437 if (size > sizeof * phdrs)
4438 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4439
3f5e193b 4440 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4441 size, num, _("program headers"));
a6e9f9df 4442 if (!phdrs)
e0a31db1 4443 return FALSE;
9ea033b2 4444
91d6fa6a 4445 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4446 i < elf_header.e_phnum;
b34976b6 4447 i++, internal++, external++)
9ea033b2
NC		 4448 {
4449 internal->p_type = BYTE_GET (external->p_type);
4450 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4451 internal->p_offset = BYTE_GET (external->p_offset);
4452 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4453 internal->p_paddr = BYTE_GET (external->p_paddr);
4454 internal->p_filesz = BYTE_GET (external->p_filesz);
4455 internal->p_memsz = BYTE_GET (external->p_memsz);
4456 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4457 }
4458
4459 free (phdrs);
e0a31db1 4460 return TRUE;
9ea033b2 4461}
252b5132 4462
d93f0186
NC		 4463/* Returns 1 if the program headers were read into `program_headers'. */
4464
4465static int
2cf0635d 4466get_program_headers (FILE * file)
d93f0186 4467{
2cf0635d 4468 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4469
4470 /* Check cache of prior read. */
4471 if (program_headers != NULL)
4472 return 1;
4473
3f5e193b
NC		 4474 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4475 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4476
4477 if (phdrs == NULL)
4478 {
8b73c356
NC		 4479 error (_("Out of memory reading %u program headers\n"),
4480 elf_header.e_phnum);
d93f0186
NC		 4481 return 0;
4482 }
4483
4484 if (is_32bit_elf
4485 ? get_32bit_program_headers (file, phdrs)
4486 : get_64bit_program_headers (file, phdrs))
4487 {
4488 program_headers = phdrs;
4489 return 1;
4490 }
4491
4492 free (phdrs);
4493 return 0;
4494}
4495
2f62977e
NC		 4496/* Returns 1 if the program headers were loaded. */
4497
252b5132 4498static int
2cf0635d 4499process_program_headers (FILE * file)
252b5132 4500{
2cf0635d 4501 Elf_Internal_Phdr * segment;
b34976b6 4502 unsigned int i;
252b5132
RH		 4503
4504 if (elf_header.e_phnum == 0)
4505 {
82f2dbf7
NC		 4506 /* PR binutils/12467. */
4507 if (elf_header.e_phoff != 0)
4508 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4509 " header offset, but no program headers\n"));
82f2dbf7 4510 else if (do_segments)
252b5132 4511 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4512 return 0;
252b5132
RH		 4513 }
4514
4515 if (do_segments && !do_header)
4516 {
f7a99963
NC		 4517 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4518 printf (_("Entry point "));
4519 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4520 printf (_("\nThere are %d program headers, starting at offset "),
4521 elf_header.e_phnum);
4522 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4523 printf ("\n");
252b5132
RH		 4524 }
4525
d93f0186 4526 if (! get_program_headers (file))
252b5132 4527 return 0;
103f02d3 4528
252b5132
RH		 4529 if (do_segments)
4530 {
3a1a2036
NC		 4531 if (elf_header.e_phnum > 1)
4532 printf (_("\nProgram Headers:\n"));
4533 else
4534 printf (_("\nProgram Headers:\n"));
76da6bbe 4535
f7a99963
NC		 4536 if (is_32bit_elf)
4537 printf
4538 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4539 else if (do_wide)
4540 printf
4541 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4542 else
4543 {
4544 printf
4545 (_(" Type Offset VirtAddr PhysAddr\n"));
4546 printf
4547 (_(" FileSiz MemSiz Flags Align\n"));
4548 }
252b5132
RH		 4549 }
4550
252b5132 4551 dynamic_addr = 0;
1b228002 4552 dynamic_size = 0;
252b5132
RH		 4553
4554 for (i = 0, segment = program_headers;
4555 i < elf_header.e_phnum;
b34976b6 4556 i++, segment++)
252b5132
RH		 4557 {
4558 if (do_segments)
4559 {
103f02d3 4560 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4561
4562 if (is_32bit_elf)
4563 {
4564 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4565 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4566 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4567 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4568 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4569 printf ("%c%c%c ",
4570 (segment->p_flags & PF_R ? 'R' : ' '),
4571 (segment->p_flags & PF_W ? 'W' : ' '),
4572 (segment->p_flags & PF_X ? 'E' : ' '));
4573 printf ("%#lx", (unsigned long) segment->p_align);
4574 }
d974e256
JJ		 4575 else if (do_wide)
4576 {
4577 if ((unsigned long) segment->p_offset == segment->p_offset)
4578 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4579 else
4580 {
4581 print_vma (segment->p_offset, FULL_HEX);
4582 putchar (' ');
4583 }
4584
4585 print_vma (segment->p_vaddr, FULL_HEX);
4586 putchar (' ');
4587 print_vma (segment->p_paddr, FULL_HEX);
4588 putchar (' ');
4589
4590 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4591 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4592 else
4593 {
4594 print_vma (segment->p_filesz, FULL_HEX);
4595 putchar (' ');
4596 }
4597
4598 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4599 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4600 else
4601 {
f48e6c45 4602 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4603 }
4604
4605 printf (" %c%c%c ",
4606 (segment->p_flags & PF_R ? 'R' : ' '),
4607 (segment->p_flags & PF_W ? 'W' : ' '),
4608 (segment->p_flags & PF_X ? 'E' : ' '));
4609
4610 if ((unsigned long) segment->p_align == segment->p_align)
4611 printf ("%#lx", (unsigned long) segment->p_align);
4612 else
4613 {
4614 print_vma (segment->p_align, PREFIX_HEX);
4615 }
4616 }
f7a99963
NC		 4617 else
4618 {
4619 print_vma (segment->p_offset, FULL_HEX);
4620 putchar (' ');
4621 print_vma (segment->p_vaddr, FULL_HEX);
4622 putchar (' ');
4623 print_vma (segment->p_paddr, FULL_HEX);
4624 printf ("\n ");
4625 print_vma (segment->p_filesz, FULL_HEX);
4626 putchar (' ');
4627 print_vma (segment->p_memsz, FULL_HEX);
4628 printf (" %c%c%c ",
4629 (segment->p_flags & PF_R ? 'R' : ' '),
4630 (segment->p_flags & PF_W ? 'W' : ' '),
4631 (segment->p_flags & PF_X ? 'E' : ' '));
4632 print_vma (segment->p_align, HEX);
4633 }
252b5132
RH		 4634 }
4635
f54498b4
NC		 4636 if (do_segments)
4637 putc ('\n', stdout);
4638
252b5132
RH		 4639 switch (segment->p_type)
4640 {
252b5132
RH		 4641 case PT_DYNAMIC:
4642 if (dynamic_addr)
4643 error (_("more than one dynamic segment\n"));
4644
20737c13
AM		 4645 /* By default, assume that the .dynamic section is the first
4646 section in the DYNAMIC segment. */
4647 dynamic_addr = segment->p_offset;
4648 dynamic_size = segment->p_filesz;
f54498b4
NC		 4649 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4650 if (dynamic_addr + dynamic_size >= current_file_size)
4651 {
4652 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4653 dynamic_addr = dynamic_size = 0;
4654 }
20737c13 4655
b2d38a17
NC		 4656 /* Try to locate the .dynamic section. If there is
4657 a section header table, we can easily locate it. */
4658 if (section_headers != NULL)
4659 {
2cf0635d 4660 Elf_Internal_Shdr * sec;
b2d38a17 4661
89fac5e3
RS		 4662 sec = find_section (".dynamic");
4663 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4664 {
28f997cf
TG		 4665 /* A corresponding .dynamic section is expected, but on
4666 IA-64/OpenVMS it is OK for it to be missing. */
4667 if (!is_ia64_vms ())
4668 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4669 break;
4670 }
4671
42bb2e33 4672 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4673 {
4674 dynamic_size = 0;
4675 break;
4676 }
42bb2e33 4677
b2d38a17
NC		 4678 dynamic_addr = sec->sh_offset;
4679 dynamic_size = sec->sh_size;
4680
4681 if (dynamic_addr < segment->p_offset
4682 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4683 warn (_("the .dynamic section is not contained"
4684 " within the dynamic segment\n"));
b2d38a17 4685 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4686 warn (_("the .dynamic section is not the first section"
4687 " in the dynamic segment.\n"));
b2d38a17 4688 }
252b5132
RH		 4689 break;
4690
4691 case PT_INTERP:
fb52b2f4
NC		 4692 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4693 SEEK_SET))
252b5132
RH		 4694 error (_("Unable to find program interpreter name\n"));
4695 else
4696 {
f8eae8b2 4697 char fmt [32];
9495b2e6 4698 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4699
4700 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4701 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4702
252b5132 4703 program_interpreter[0] = 0;
7bd7b3ef
AM		 4704 if (fscanf (file, fmt, program_interpreter) <= 0)
4705 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4706
4707 if (do_segments)
f54498b4 4708 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4709 program_interpreter);
4710 }
4711 break;
4712 }
252b5132
RH		 4713 }
4714
c256ffe7 4715 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4716 {
4717 printf (_("\n Section to Segment mapping:\n"));
4718 printf (_(" Segment Sections...\n"));
4719
252b5132
RH		 4720 for (i = 0; i < elf_header.e_phnum; i++)
4721 {
9ad5cbcf 4722 unsigned int j;
2cf0635d 4723 Elf_Internal_Shdr * section;
252b5132
RH		 4724
4725 segment = program_headers + i;
b391a3e3 4726 section = section_headers + 1;
252b5132
RH		 4727
4728 printf (" %2.2d ", i);
4729
b34976b6 4730 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4731 {
f4638467
AM		 4732 if (!ELF_TBSS_SPECIAL (section, segment)
4733 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4734 printf ("%s ", printable_section_name (section));
252b5132
RH		 4735 }
4736
4737 putc ('\n',stdout);
4738 }
4739 }
4740
252b5132
RH		 4741 return 1;
4742}
4743
4744
d93f0186
NC		 4745/* Find the file offset corresponding to VMA by using the program headers. */
4746
4747static long
2cf0635d 4748offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4749{
2cf0635d 4750 Elf_Internal_Phdr * seg;
d93f0186
NC		 4751
4752 if (! get_program_headers (file))
4753 {
4754 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4755 return (long) vma;
4756 }
4757
4758 for (seg = program_headers;
4759 seg < program_headers + elf_header.e_phnum;
4760 ++seg)
4761 {
4762 if (seg->p_type != PT_LOAD)
4763 continue;
4764
4765 if (vma >= (seg->p_vaddr & -seg->p_align)
4766 && vma + size <= seg->p_vaddr + seg->p_filesz)
4767 return vma - seg->p_vaddr + seg->p_offset;
4768 }
4769
4770 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4771 (unsigned long) vma);
d93f0186
NC		 4772 return (long) vma;
4773}
4774
4775
049b0c3a
NC		 4776/* Allocate memory and load the sections headers into the global pointer
4777 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4778 generate any error messages if the load fails. */
4779
4780static bfd_boolean
4781get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4782{
2cf0635d
NC		 4783 Elf32_External_Shdr * shdrs;
4784 Elf_Internal_Shdr * internal;
b34976b6 4785 unsigned int i;
049b0c3a
NC		 4786 unsigned int size = elf_header.e_shentsize;
4787 unsigned int num = probe ? 1 : elf_header.e_shnum;
4788
4789 /* PR binutils/17531: Cope with unexpected section header sizes. */
4790 if (size == 0 || num == 0)
4791 return FALSE;
4792 if (size < sizeof * shdrs)
4793 {
4794 if (! probe)
4795 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4796 return FALSE;
4797 }
4798 if (!probe && size > sizeof * shdrs)
4799 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4800
3f5e193b 4801 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4802 size, num,
4803 probe ? NULL : _("section headers"));
4804 if (shdrs == NULL)
4805 return FALSE;
252b5132 4806
049b0c3a
NC		 4807 if (section_headers != NULL)
4808 free (section_headers);
3f5e193b
NC		 4809 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4810 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4811 if (section_headers == NULL)
4812 {
049b0c3a 4813 if (!probe)
8b73c356 4814 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4815 return FALSE;
252b5132
RH		 4816 }
4817
4818 for (i = 0, internal = section_headers;
560f3c1c 4819 i < num;
b34976b6 4820 i++, internal++)
252b5132
RH		 4821 {
4822 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4823 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4824 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4825 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4826 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4827 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4828 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4829 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4830 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4831 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4832 }
4833
4834 free (shdrs);
049b0c3a 4835 return TRUE;
252b5132
RH		 4836}
4837
049b0c3a
NC		 4838static bfd_boolean
4839get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4840{
2cf0635d
NC		 4841 Elf64_External_Shdr * shdrs;
4842 Elf_Internal_Shdr * internal;
b34976b6 4843 unsigned int i;
049b0c3a
NC		 4844 unsigned int size = elf_header.e_shentsize;
4845 unsigned int num = probe ? 1 : elf_header.e_shnum;
4846
4847 /* PR binutils/17531: Cope with unexpected section header sizes. */
4848 if (size == 0 || num == 0)
4849 return FALSE;
4850 if (size < sizeof * shdrs)
4851 {
4852 if (! probe)
4853 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4854 return FALSE;
4855 }
4856 if (! probe && size > sizeof * shdrs)
4857 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4858
3f5e193b 4859 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4860 size, num,
4861 probe ? NULL : _("section headers"));
4862 if (shdrs == NULL)
4863 return FALSE;
9ea033b2 4864
049b0c3a
NC		 4865 if (section_headers != NULL)
4866 free (section_headers);
3f5e193b
NC		 4867 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4868 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4869 if (section_headers == NULL)
4870 {
049b0c3a 4871 if (! probe)
8b73c356 4872 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4873 return FALSE;
9ea033b2
NC		 4874 }
4875
4876 for (i = 0, internal = section_headers;
560f3c1c 4877 i < num;
b34976b6 4878 i++, internal++)
9ea033b2
NC		 4879 {
4880 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4881 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4882 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4883 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4884 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4885 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4886 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4887 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4888 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4889 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4890 }
4891
4892 free (shdrs);
049b0c3a 4893 return TRUE;
9ea033b2
NC		 4894}
4895
252b5132 4896static Elf_Internal_Sym *
ba5cdace
NC		 4897get_32bit_elf_symbols (FILE * file,
4898 Elf_Internal_Shdr * section,
4899 unsigned long * num_syms_return)
252b5132 4900{
ba5cdace 4901 unsigned long number = 0;
dd24e3da 4902 Elf32_External_Sym * esyms = NULL;
ba5cdace 4903 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4904 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4905 Elf_Internal_Sym * psym;
b34976b6 4906 unsigned int j;
252b5132 4907
c9c1d674
EG		 4908 if (section->sh_size == 0)
4909 {
4910 if (num_syms_return != NULL)
4911 * num_syms_return = 0;
4912 return NULL;
4913 }
4914
dd24e3da 4915 /* Run some sanity checks first. */
c9c1d674 4916 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4917 {
c9c1d674
EG		 4918 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4919 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4920 goto exit_point;
dd24e3da
NC		 4921 }
4922
f54498b4
NC		 4923 if (section->sh_size > current_file_size)
4924 {
4925 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4926 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4927 goto exit_point;
4928 }
4929
dd24e3da
NC		 4930 number = section->sh_size / section->sh_entsize;
4931
4932 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4933 {
c9c1d674 4934 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4935 (unsigned long) section->sh_size,
4936 printable_section_name (section),
4937 (unsigned long) section->sh_entsize);
ba5cdace 4938 goto exit_point;
dd24e3da
NC		 4939 }
4940
3f5e193b
NC		 4941 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4942 section->sh_size, _("symbols"));
dd24e3da 4943 if (esyms == NULL)
ba5cdace 4944 goto exit_point;
252b5132 4945
9ad5cbcf
AM		 4946 shndx = NULL;
4947 if (symtab_shndx_hdr != NULL
4948 && (symtab_shndx_hdr->sh_link
4fbb74a6 4949 == (unsigned long) (section - section_headers)))
9ad5cbcf 4950 {
3f5e193b
NC		 4951 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4952 symtab_shndx_hdr->sh_offset,
4953 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4954 _("symbol table section indicies"));
dd24e3da
NC		 4955 if (shndx == NULL)
4956 goto exit_point;
c9c1d674
EG		 4957 /* PR17531: file: heap-buffer-overflow */
4958 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4959 {
4960 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4961 printable_section_name (symtab_shndx_hdr),
4962 (unsigned long) symtab_shndx_hdr->sh_size,
4963 (unsigned long) section->sh_size);
4964 goto exit_point;
4965 }
9ad5cbcf
AM		 4966 }
4967
3f5e193b 4968 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4969
4970 if (isyms == NULL)
4971 {
8b73c356
NC		 4972 error (_("Out of memory reading %lu symbols\n"),
4973 (unsigned long) number);
dd24e3da 4974 goto exit_point;
252b5132
RH		 4975 }
4976
dd24e3da 4977 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4978 {
4979 psym->st_name = BYTE_GET (esyms[j].st_name);
4980 psym->st_value = BYTE_GET (esyms[j].st_value);
4981 psym->st_size = BYTE_GET (esyms[j].st_size);
4982 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4983 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4984 psym->st_shndx
4985 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4986 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4987 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4988 psym->st_info = BYTE_GET (esyms[j].st_info);
4989 psym->st_other = BYTE_GET (esyms[j].st_other);
4990 }
4991
dd24e3da 4992 exit_point:
ba5cdace 4993 if (shndx != NULL)
9ad5cbcf 4994 free (shndx);
ba5cdace 4995 if (esyms != NULL)
dd24e3da 4996 free (esyms);
252b5132 4997
ba5cdace
NC		 4998 if (num_syms_return != NULL)
4999 * num_syms_return = isyms == NULL ? 0 : number;
5000
252b5132
RH		 5001 return isyms;
5002}
5003
9ea033b2 5004static Elf_Internal_Sym *
ba5cdace
NC		 5005get_64bit_elf_symbols (FILE * file,
5006 Elf_Internal_Shdr * section,
5007 unsigned long * num_syms_return)
9ea033b2 5008{
ba5cdace
NC		 5009 unsigned long number = 0;
5010 Elf64_External_Sym * esyms = NULL;
5011 Elf_External_Sym_Shndx * shndx = NULL;
5012 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5013 Elf_Internal_Sym * psym;
b34976b6 5014 unsigned int j;
9ea033b2 5015
c9c1d674
EG		 5016 if (section->sh_size == 0)
5017 {
5018 if (num_syms_return != NULL)
5019 * num_syms_return = 0;
5020 return NULL;
5021 }
5022
dd24e3da 5023 /* Run some sanity checks first. */
c9c1d674 5024 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5025 {
c9c1d674 5026 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5027 printable_section_name (section),
5028 (unsigned long) section->sh_entsize);
ba5cdace 5029 goto exit_point;
dd24e3da
NC		 5030 }
5031
f54498b4
NC		 5032 if (section->sh_size > current_file_size)
5033 {
5034 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5035 printable_section_name (section),
5036 (unsigned long) section->sh_size);
f54498b4
NC		 5037 goto exit_point;
5038 }
5039
dd24e3da
NC		 5040 number = section->sh_size / section->sh_entsize;
5041
5042 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5043 {
c9c1d674 5044 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5045 (unsigned long) section->sh_size,
5046 printable_section_name (section),
5047 (unsigned long) section->sh_entsize);
ba5cdace 5048 goto exit_point;
dd24e3da
NC		 5049 }
5050
3f5e193b
NC		 5051 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5052 section->sh_size, _("symbols"));
a6e9f9df 5053 if (!esyms)
ba5cdace 5054 goto exit_point;
9ea033b2 5055
9ad5cbcf
AM		 5056 if (symtab_shndx_hdr != NULL
5057 && (symtab_shndx_hdr->sh_link
4fbb74a6 5058 == (unsigned long) (section - section_headers)))
9ad5cbcf 5059 {
3f5e193b
NC		 5060 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5061 symtab_shndx_hdr->sh_offset,
5062 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5063 _("symbol table section indicies"));
ba5cdace
NC		 5064 if (shndx == NULL)
5065 goto exit_point;
c9c1d674
EG		 5066 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5067 {
5068 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5069 printable_section_name (symtab_shndx_hdr),
5070 (unsigned long) symtab_shndx_hdr->sh_size,
5071 (unsigned long) section->sh_size);
5072 goto exit_point;
5073 }
9ad5cbcf
AM		 5074 }
5075
3f5e193b 5076 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5077
5078 if (isyms == NULL)
5079 {
8b73c356
NC		 5080 error (_("Out of memory reading %lu symbols\n"),
5081 (unsigned long) number);
ba5cdace 5082 goto exit_point;
9ea033b2
NC		 5083 }
5084
ba5cdace 5085 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5086 {
5087 psym->st_name = BYTE_GET (esyms[j].st_name);
5088 psym->st_info = BYTE_GET (esyms[j].st_info);
5089 psym->st_other = BYTE_GET (esyms[j].st_other);
5090 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5091
4fbb74a6 5092 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5093 psym->st_shndx
5094 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5095 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5096 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5097
66543521
AM		 5098 psym->st_value = BYTE_GET (esyms[j].st_value);
5099 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5100 }
5101
ba5cdace
NC		 5102 exit_point:
5103 if (shndx != NULL)
9ad5cbcf 5104 free (shndx);
ba5cdace
NC		 5105 if (esyms != NULL)
5106 free (esyms);
5107
5108 if (num_syms_return != NULL)
5109 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5110
5111 return isyms;
5112}
5113
d1133906 5114static const char *
d3ba0551 5115get_elf_section_flags (bfd_vma sh_flags)
d1133906 5116{
5477e8a0 5117 static char buff[1024];
2cf0635d 5118 char * p = buff;
8d5ff12c 5119 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5120 int sindex;
5121 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5122 bfd_vma os_flags = 0;
5123 bfd_vma proc_flags = 0;
5124 bfd_vma unknown_flags = 0;
148b93f2 5125 static const struct
5477e8a0 5126 {
2cf0635d 5127 const char * str;
5477e8a0
L		 5128 int len;
5129 }
5130 flags [] =
5131 {
cfcac11d
NC		 5132 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5133 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5134 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5135 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5136 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5137 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5138 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5139 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5140 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5141 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5142 /* IA-64 specific. */
5143 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5144 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5145 /* IA-64 OpenVMS specific. */
5146 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5147 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5148 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5149 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5150 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5151 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5152 /* Generic. */
cfcac11d 5153 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5154 /* SPARC specific. */
cfcac11d 5155 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 5156 };
5157
5158 if (do_section_details)
5159 {
8d5ff12c
L		 5160 sprintf (buff, "[%*.*lx]: ",
5161 field_size, field_size, (unsigned long) sh_flags);
5162 p += field_size + 4;
5477e8a0 5163 }
76da6bbe 5164
d1133906
NC		 5165 while (sh_flags)
5166 {
5167 bfd_vma flag;
5168
5169 flag = sh_flags & - sh_flags;
5170 sh_flags &= ~ flag;
76da6bbe 5171
5477e8a0 5172 if (do_section_details)
d1133906 5173 {
5477e8a0
L		 5174 switch (flag)
5175 {
91d6fa6a
NC		 5176 case SHF_WRITE: sindex = 0; break;
5177 case SHF_ALLOC: sindex = 1; break;
5178 case SHF_EXECINSTR: sindex = 2; break;
5179 case SHF_MERGE: sindex = 3; break;
5180 case SHF_STRINGS: sindex = 4; break;
5181 case SHF_INFO_LINK: sindex = 5; break;
5182 case SHF_LINK_ORDER: sindex = 6; break;
5183 case SHF_OS_NONCONFORMING: sindex = 7; break;
5184 case SHF_GROUP: sindex = 8; break;
5185 case SHF_TLS: sindex = 9; break;
18ae9cc1 5186 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 5187
5477e8a0 5188 default:
91d6fa6a 5189 sindex = -1;
cfcac11d 5190 switch (elf_header.e_machine)
148b93f2 5191 {
cfcac11d 5192 case EM_IA_64:
148b93f2 5193 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5194 sindex = 10;
148b93f2 5195 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5196 sindex = 11;
148b93f2
NC		 5197#ifdef BFD64
5198 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5199 switch (flag)
5200 {
91d6fa6a
NC		 5201 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5202 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5203 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5204 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5205 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5206 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5207 default: break;
5208 }
5209#endif
cfcac11d
NC		 5210 break;
5211
caa83f8b
NC		 5212 case EM_386:
5213 case EM_486:
5214 case EM_X86_64:
7f502d6c 5215 case EM_L1OM:
7a9068fe 5216 case EM_K1OM:
cfcac11d
NC		 5217 case EM_OLD_SPARCV9:
5218 case EM_SPARC32PLUS:
5219 case EM_SPARCV9:
5220 case EM_SPARC:
18ae9cc1 5221 if (flag == SHF_ORDERED)
91d6fa6a 5222 sindex = 19;
cfcac11d
NC		 5223 break;
5224 default:
5225 break;
148b93f2 5226 }
5477e8a0
L		 5227 }
5228
91d6fa6a 5229 if (sindex != -1)
5477e8a0 5230 {
8d5ff12c
L		 5231 if (p != buff + field_size + 4)
5232 {
5233 if (size < (10 + 2))
bee0ee85
NC		 5234 {
5235 warn (_("Internal error: not enough buffer room for section flag info"));
5236 return _("<unknown>");
5237 }
8d5ff12c
L		 5238 size -= 2;
5239 *p++ = ',';
5240 *p++ = ' ';
5241 }
5242
91d6fa6a
NC		 5243 size -= flags [sindex].len;
5244 p = stpcpy (p, flags [sindex].str);
5477e8a0 5245 }
3b22753a 5246 else if (flag & SHF_MASKOS)
8d5ff12c 5247 os_flags |= flag;
d1133906 5248 else if (flag & SHF_MASKPROC)
8d5ff12c 5249 proc_flags |= flag;
d1133906 5250 else
8d5ff12c 5251 unknown_flags |= flag;
5477e8a0
L		 5252 }
5253 else
5254 {
5255 switch (flag)
5256 {
5257 case SHF_WRITE: *p = 'W'; break;
5258 case SHF_ALLOC: *p = 'A'; break;
5259 case SHF_EXECINSTR: *p = 'X'; break;
5260 case SHF_MERGE: *p = 'M'; break;
5261 case SHF_STRINGS: *p = 'S'; break;
5262 case SHF_INFO_LINK: *p = 'I'; break;
5263 case SHF_LINK_ORDER: *p = 'L'; break;
5264 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5265 case SHF_GROUP: *p = 'G'; break;
5266 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5267 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 5268
5269 default:
8a9036a4 5270 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5271 || elf_header.e_machine == EM_L1OM
5272 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5273 && flag == SHF_X86_64_LARGE)
5274 *p = 'l';
5275 else if (flag & SHF_MASKOS)
5276 {
5277 *p = 'o';
5278 sh_flags &= ~ SHF_MASKOS;
5279 }
5280 else if (flag & SHF_MASKPROC)
5281 {
5282 *p = 'p';
5283 sh_flags &= ~ SHF_MASKPROC;
5284 }
5285 else
5286 *p = 'x';
5287 break;
5288 }
5289 p++;
d1133906
NC		 5290 }
5291 }
76da6bbe 5292
8d5ff12c
L		 5293 if (do_section_details)
5294 {
5295 if (os_flags)
5296 {
5297 size -= 5 + field_size;
5298 if (p != buff + field_size + 4)
5299 {
5300 if (size < (2 + 1))
bee0ee85
NC		 5301 {
5302 warn (_("Internal error: not enough buffer room for section flag info"));
5303 return _("<unknown>");
5304 }
8d5ff12c
L		 5305 size -= 2;
5306 *p++ = ',';
5307 *p++ = ' ';
5308 }
5309 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5310 (unsigned long) os_flags);
5311 p += 5 + field_size;
5312 }
5313 if (proc_flags)
5314 {
5315 size -= 7 + field_size;
5316 if (p != buff + field_size + 4)
5317 {
5318 if (size < (2 + 1))
bee0ee85
NC		 5319 {
5320 warn (_("Internal error: not enough buffer room for section flag info"));
5321 return _("<unknown>");
5322 }
8d5ff12c
L		 5323 size -= 2;
5324 *p++ = ',';
5325 *p++ = ' ';
5326 }
5327 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5328 (unsigned long) proc_flags);
5329 p += 7 + field_size;
5330 }
5331 if (unknown_flags)
5332 {
5333 size -= 10 + field_size;
5334 if (p != buff + field_size + 4)
5335 {
5336 if (size < (2 + 1))
bee0ee85
NC		 5337 {
5338 warn (_("Internal error: not enough buffer room for section flag info"));
5339 return _("<unknown>");
5340 }
8d5ff12c
L		 5341 size -= 2;
5342 *p++ = ',';
5343 *p++ = ' ';
5344 }
2b692964 5345 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5346 (unsigned long) unknown_flags);
5347 p += 10 + field_size;
5348 }
5349 }
5350
e9e44622 5351 *p = '\0';
d1133906
NC		 5352 return buff;
5353}
5354
252b5132 5355static int
2cf0635d 5356process_section_headers (FILE * file)
252b5132 5357{
2cf0635d 5358 Elf_Internal_Shdr * section;
b34976b6 5359 unsigned int i;
252b5132
RH		 5360
5361 section_headers = NULL;
5362
5363 if (elf_header.e_shnum == 0)
5364 {
82f2dbf7
NC		 5365 /* PR binutils/12467. */
5366 if (elf_header.e_shoff != 0)
5367 warn (_("possibly corrupt ELF file header - it has a non-zero"
5368 " section header offset, but no section headers\n"));
5369 else if (do_sections)
252b5132
RH		 5370 printf (_("\nThere are no sections in this file.\n"));
5371
5372 return 1;
5373 }
5374
5375 if (do_sections && !do_header)
9ea033b2 5376 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5377 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5378
9ea033b2
NC		 5379 if (is_32bit_elf)
5380 {
049b0c3a 5381 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5382 return 0;
5383 }
049b0c3a 5384 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5385 return 0;
5386
5387 /* Read in the string table, so that we have names to display. */
0b49d371 5388 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5389 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5390 {
4fbb74a6 5391 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5392
c256ffe7
JJ		 5393 if (section->sh_size != 0)
5394 {
3f5e193b
NC		 5395 string_table = (char *) get_data (NULL, file, section->sh_offset,
5396 1, section->sh_size,
5397 _("string table"));
0de14b54 5398
c256ffe7
JJ		 5399 string_table_length = string_table != NULL ? section->sh_size : 0;
5400 }
252b5132
RH		 5401 }
5402
5403 /* Scan the sections for the dynamic symbol table
e3c8793a 5404 and dynamic string table and debug sections. */
252b5132
RH		 5405 dynamic_symbols = NULL;
5406 dynamic_strings = NULL;
5407 dynamic_syminfo = NULL;
f1ef08cb 5408 symtab_shndx_hdr = NULL;
103f02d3 5409
89fac5e3
RS		 5410 eh_addr_size = is_32bit_elf ? 4 : 8;
5411 switch (elf_header.e_machine)
5412 {
5413 case EM_MIPS:
5414 case EM_MIPS_RS3_LE:
5415 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5416 FDE addresses. However, the ABI also has a semi-official ILP32
5417 variant for which the normal FDE address size rules apply.
5418
5419 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5420 section, where XX is the size of longs in bits. Unfortunately,
5421 earlier compilers provided no way of distinguishing ILP32 objects
5422 from LP64 objects, so if there's any doubt, we should assume that
5423 the official LP64 form is being used. */
5424 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5425 && find_section (".gcc_compiled_long32") == NULL)
5426 eh_addr_size = 8;
5427 break;
0f56a26a
DD		 5428
5429 case EM_H8_300:
5430 case EM_H8_300H:
5431 switch (elf_header.e_flags & EF_H8_MACH)
5432 {
5433 case E_H8_MACH_H8300:
5434 case E_H8_MACH_H8300HN:
5435 case E_H8_MACH_H8300SN:
5436 case E_H8_MACH_H8300SXN:
5437 eh_addr_size = 2;
5438 break;
5439 case E_H8_MACH_H8300H:
5440 case E_H8_MACH_H8300S:
5441 case E_H8_MACH_H8300SX:
5442 eh_addr_size = 4;
5443 break;
5444 }
f4236fe4
DD		 5445 break;
5446
ff7eeb89 5447 case EM_M32C_OLD:
f4236fe4
DD		 5448 case EM_M32C:
5449 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5450 {
5451 case EF_M32C_CPU_M16C:
5452 eh_addr_size = 2;
5453 break;
5454 }
5455 break;
89fac5e3
RS		 5456 }
5457
76ca31c0
NC		 5458#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5459 do \
5460 { \
5461 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5462 if (section->sh_entsize != expected_entsize) \
9dd3a467 5463 { \
76ca31c0
NC		 5464 char buf[40]; \
5465 sprintf_vma (buf, section->sh_entsize); \
5466 /* Note: coded this way so that there is a single string for \
5467 translation. */ \
5468 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5469 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5470 (unsigned) expected_entsize); \
9dd3a467 5471 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5472 } \
5473 } \
08d8fa11 5474 while (0)
9dd3a467
NC		 5475
5476#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5477 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5478 sizeof (Elf64_External_##type))
5479
252b5132
RH		 5480 for (i = 0, section = section_headers;
5481 i < elf_header.e_shnum;
b34976b6 5482 i++, section++)
252b5132 5483 {
2cf0635d 5484 char * name = SECTION_NAME (section);
252b5132
RH		 5485
5486 if (section->sh_type == SHT_DYNSYM)
5487 {
5488 if (dynamic_symbols != NULL)
5489 {
5490 error (_("File contains multiple dynamic symbol tables\n"));
5491 continue;
5492 }
5493
08d8fa11 5494 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5495 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5496 }
5497 else if (section->sh_type == SHT_STRTAB
18bd398b 5498 && streq (name, ".dynstr"))
252b5132
RH		 5499 {
5500 if (dynamic_strings != NULL)
5501 {
5502 error (_("File contains multiple dynamic string tables\n"));
5503 continue;
5504 }
5505
3f5e193b
NC		 5506 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5507 1, section->sh_size,
5508 _("dynamic strings"));
59245841 5509 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5510 }
9ad5cbcf
AM		 5511 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5512 {
5513 if (symtab_shndx_hdr != NULL)
5514 {
5515 error (_("File contains multiple symtab shndx tables\n"));
5516 continue;
5517 }
5518 symtab_shndx_hdr = section;
5519 }
08d8fa11
JJ		 5520 else if (section->sh_type == SHT_SYMTAB)
5521 CHECK_ENTSIZE (section, i, Sym);
5522 else if (section->sh_type == SHT_GROUP)
5523 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5524 else if (section->sh_type == SHT_REL)
5525 CHECK_ENTSIZE (section, i, Rel);
5526 else if (section->sh_type == SHT_RELA)
5527 CHECK_ENTSIZE (section, i, Rela);
252b5132 5528 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5529 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5530 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5531 || do_debug_str || do_debug_loc || do_debug_ranges
5532 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5533 && (const_strneq (name, ".debug_")
5534 || const_strneq (name, ".zdebug_")))
252b5132 5535 {
1b315056
CS		 5536 if (name[1] == 'z')
5537 name += sizeof (".zdebug_") - 1;
5538 else
5539 name += sizeof (".debug_") - 1;
252b5132
RH		 5540
5541 if (do_debugging
4723351a
CC		 5542 || (do_debug_info && const_strneq (name, "info"))
5543 || (do_debug_info && const_strneq (name, "types"))
5544 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5545 || (do_debug_lines && strcmp (name, "line") == 0)
5546 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5547 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5548 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5549 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5550 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5551 || (do_debug_aranges && const_strneq (name, "aranges"))
5552 || (do_debug_ranges && const_strneq (name, "ranges"))
5553 || (do_debug_frames && const_strneq (name, "frame"))
5554 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5555 || (do_debug_macinfo && const_strneq (name, "macro"))
5556 || (do_debug_str && const_strneq (name, "str"))
5557 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5558 || (do_debug_addr && const_strneq (name, "addr"))
5559 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5560 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5561 )
09c11c86 5562 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5563 }
a262ae96 5564 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5565 else if ((do_debugging || do_debug_info)
0112cd26 5566 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5567 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5568 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5569 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5570 else if (do_gdb_index && streq (name, ".gdb_index"))
5571 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5572 /* Trace sections for Itanium VMS. */
5573 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5574 || do_trace_aranges)
5575 && const_strneq (name, ".trace_"))
5576 {
5577 name += sizeof (".trace_") - 1;
5578
5579 if (do_debugging
5580 || (do_trace_info && streq (name, "info"))
5581 || (do_trace_abbrevs && streq (name, "abbrev"))
5582 || (do_trace_aranges && streq (name, "aranges"))
5583 )
5584 request_dump_bynumber (i, DEBUG_DUMP);
5585 }
252b5132
RH		 5586 }
5587
5588 if (! do_sections)
5589 return 1;
5590
3a1a2036
NC		 5591 if (elf_header.e_shnum > 1)
5592 printf (_("\nSection Headers:\n"));
5593 else
5594 printf (_("\nSection Header:\n"));
76da6bbe 5595
f7a99963 5596 if (is_32bit_elf)
595cf52e 5597 {
5477e8a0 5598 if (do_section_details)
595cf52e
L		 5599 {
5600 printf (_(" [Nr] Name\n"));
5477e8a0 5601 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5602 }
5603 else
5604 printf
5605 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5606 }
d974e256 5607 else if (do_wide)
595cf52e 5608 {
5477e8a0 5609 if (do_section_details)
595cf52e
L		 5610 {
5611 printf (_(" [Nr] Name\n"));
5477e8a0 5612 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5613 }
5614 else
5615 printf
5616 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5617 }
f7a99963
NC		 5618 else
5619 {
5477e8a0 5620 if (do_section_details)
595cf52e
L		 5621 {
5622 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5623 printf (_(" Type Address Offset Link\n"));
5624 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5625 }
5626 else
5627 {
5628 printf (_(" [Nr] Name Type Address Offset\n"));
5629 printf (_(" Size EntSize Flags Link Info Align\n"));
5630 }
f7a99963 5631 }
252b5132 5632
5477e8a0
L		 5633 if (do_section_details)
5634 printf (_(" Flags\n"));
5635
252b5132
RH		 5636 for (i = 0, section = section_headers;
5637 i < elf_header.e_shnum;
b34976b6 5638 i++, section++)
252b5132 5639 {
7bfd842d 5640 printf (" [%2u] ", i);
5477e8a0 5641 if (do_section_details)
74e1a04b 5642 printf ("%s\n ", printable_section_name (section));
595cf52e 5643 else
74e1a04b 5644 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5645
ea52a088
NC		 5646 printf (do_wide ? " %-15s " : " %-15.15s ",
5647 get_section_type_name (section->sh_type));
0b4362b0 5648
f7a99963
NC		 5649 if (is_32bit_elf)
5650 {
cfcac11d
NC		 5651 const char * link_too_big = NULL;
5652
f7a99963 5653 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5654
f7a99963
NC		 5655 printf ( " %6.6lx %6.6lx %2.2lx",
5656 (unsigned long) section->sh_offset,
5657 (unsigned long) section->sh_size,
5658 (unsigned long) section->sh_entsize);
d1133906 5659
5477e8a0
L		 5660 if (do_section_details)
5661 fputs (" ", stdout);
5662 else
5663 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5664
cfcac11d
NC		 5665 if (section->sh_link >= elf_header.e_shnum)
5666 {
5667 link_too_big = "";
5668 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5669 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5670 switch (elf_header.e_machine)
5671 {
caa83f8b
NC		 5672 case EM_386:
5673 case EM_486:
5674 case EM_X86_64:
7f502d6c 5675 case EM_L1OM:
7a9068fe 5676 case EM_K1OM:
cfcac11d
NC		 5677 case EM_OLD_SPARCV9:
5678 case EM_SPARC32PLUS:
5679 case EM_SPARCV9:
5680 case EM_SPARC:
5681 if (section->sh_link == (SHN_BEFORE & 0xffff))
5682 link_too_big = "BEFORE";
5683 else if (section->sh_link == (SHN_AFTER & 0xffff))
5684 link_too_big = "AFTER";
5685 break;
5686 default:
5687 break;
5688 }
5689 }
5690
5691 if (do_section_details)
5692 {
5693 if (link_too_big != NULL && * link_too_big)
5694 printf ("<%s> ", link_too_big);
5695 else
5696 printf ("%2u ", section->sh_link);
5697 printf ("%3u %2lu\n", section->sh_info,
5698 (unsigned long) section->sh_addralign);
5699 }
5700 else
5701 printf ("%2u %3u %2lu\n",
5702 section->sh_link,
5703 section->sh_info,
5704 (unsigned long) section->sh_addralign);
5705
5706 if (link_too_big && ! * link_too_big)
5707 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5708 i, section->sh_link);
f7a99963 5709 }
d974e256
JJ		 5710 else if (do_wide)
5711 {
5712 print_vma (section->sh_addr, LONG_HEX);
5713
5714 if ((long) section->sh_offset == section->sh_offset)
5715 printf (" %6.6lx", (unsigned long) section->sh_offset);
5716 else
5717 {
5718 putchar (' ');
5719 print_vma (section->sh_offset, LONG_HEX);
5720 }
5721
5722 if ((unsigned long) section->sh_size == section->sh_size)
5723 printf (" %6.6lx", (unsigned long) section->sh_size);
5724 else
5725 {
5726 putchar (' ');
5727 print_vma (section->sh_size, LONG_HEX);
5728 }
5729
5730 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5731 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5732 else
5733 {
5734 putchar (' ');
5735 print_vma (section->sh_entsize, LONG_HEX);
5736 }
5737
5477e8a0
L		 5738 if (do_section_details)
5739 fputs (" ", stdout);
5740 else
5741 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5742
72de5009 5743 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5744
5745 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5746 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5747 else
5748 {
5749 print_vma (section->sh_addralign, DEC);
5750 putchar ('\n');
5751 }
5752 }
5477e8a0 5753 else if (do_section_details)
595cf52e 5754 {
5477e8a0 5755 printf (" %-15.15s ",
595cf52e 5756 get_section_type_name (section->sh_type));
595cf52e
L		 5757 print_vma (section->sh_addr, LONG_HEX);
5758 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5759 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5760 else
5761 {
5762 printf (" ");
5763 print_vma (section->sh_offset, LONG_HEX);
5764 }
72de5009 5765 printf (" %u\n ", section->sh_link);
595cf52e 5766 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5767 putchar (' ');
595cf52e
L		 5768 print_vma (section->sh_entsize, LONG_HEX);
5769
72de5009
AM		 5770 printf (" %-16u %lu\n",
5771 section->sh_info,
595cf52e
L		 5772 (unsigned long) section->sh_addralign);
5773 }
f7a99963
NC		 5774 else
5775 {
5776 putchar (' ');
5777 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5778 if ((long) section->sh_offset == section->sh_offset)
5779 printf (" %8.8lx", (unsigned long) section->sh_offset);
5780 else
5781 {
5782 printf (" ");
5783 print_vma (section->sh_offset, LONG_HEX);
5784 }
f7a99963
NC		 5785 printf ("\n ");
5786 print_vma (section->sh_size, LONG_HEX);
5787 printf (" ");
5788 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5789
d1133906 5790 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5791
72de5009
AM		 5792 printf (" %2u %3u %lu\n",
5793 section->sh_link,
5794 section->sh_info,
f7a99963
NC		 5795 (unsigned long) section->sh_addralign);
5796 }
5477e8a0
L		 5797
5798 if (do_section_details)
5799 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5800 }
5801
5477e8a0 5802 if (!do_section_details)
3dbcc61d
NC		 5803 {
5804 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5805 || elf_header.e_machine == EM_L1OM
5806 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5807 printf (_("Key to Flags:\n\
5808 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5809 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5810 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5811 else
5812 printf (_("Key to Flags:\n\
e3c8793a 5813 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5814 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5815 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5816 }
d1133906 5817
252b5132
RH		 5818 return 1;
5819}
5820
f5842774
L		 5821static const char *
5822get_group_flags (unsigned int flags)
5823{
5824 static char buff[32];
5825 switch (flags)
5826 {
220453ec
AM		 5827 case 0:
5828 return "";
5829
f5842774 5830 case GRP_COMDAT:
220453ec 5831 return "COMDAT ";
f5842774
L		 5832
5833 default:
220453ec 5834 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5835 break;
5836 }
5837 return buff;
5838}
5839
5840static int
2cf0635d 5841process_section_groups (FILE * file)
f5842774 5842{
2cf0635d 5843 Elf_Internal_Shdr * section;
f5842774 5844 unsigned int i;
2cf0635d
NC		 5845 struct group * group;
5846 Elf_Internal_Shdr * symtab_sec;
5847 Elf_Internal_Shdr * strtab_sec;
5848 Elf_Internal_Sym * symtab;
ba5cdace 5849 unsigned long num_syms;
2cf0635d 5850 char * strtab;
c256ffe7 5851 size_t strtab_size;
d1f5c6e3
L		 5852
5853 /* Don't process section groups unless needed. */
5854 if (!do_unwind && !do_section_groups)
5855 return 1;
f5842774
L		 5856
5857 if (elf_header.e_shnum == 0)
5858 {
5859 if (do_section_groups)
82f2dbf7 5860 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5861
5862 return 1;
5863 }
5864
5865 if (section_headers == NULL)
5866 {
5867 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5868 /* PR 13622: This can happen with a corrupt ELF header. */
5869 return 0;
f5842774
L		 5870 }
5871
3f5e193b
NC		 5872 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5873 sizeof (struct group *));
e4b17d5c
L		 5874
5875 if (section_headers_groups == NULL)
5876 {
8b73c356
NC		 5877 error (_("Out of memory reading %u section group headers\n"),
5878 elf_header.e_shnum);
e4b17d5c
L		 5879 return 0;
5880 }
5881
f5842774 5882 /* Scan the sections for the group section. */
d1f5c6e3 5883 group_count = 0;
f5842774
L		 5884 for (i = 0, section = section_headers;
5885 i < elf_header.e_shnum;
5886 i++, section++)
e4b17d5c
L		 5887 if (section->sh_type == SHT_GROUP)
5888 group_count++;
5889
d1f5c6e3
L		 5890 if (group_count == 0)
5891 {
5892 if (do_section_groups)
5893 printf (_("\nThere are no section groups in this file.\n"));
5894
5895 return 1;
5896 }
5897
3f5e193b 5898 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5899
5900 if (section_groups == NULL)
5901 {
8b73c356
NC		 5902 error (_("Out of memory reading %lu groups\n"),
5903 (unsigned long) group_count);
e4b17d5c
L		 5904 return 0;
5905 }
5906
d1f5c6e3
L		 5907 symtab_sec = NULL;
5908 strtab_sec = NULL;
5909 symtab = NULL;
ba5cdace 5910 num_syms = 0;
d1f5c6e3 5911 strtab = NULL;
c256ffe7 5912 strtab_size = 0;
e4b17d5c
L		 5913 for (i = 0, section = section_headers, group = section_groups;
5914 i < elf_header.e_shnum;
5915 i++, section++)
f5842774
L		 5916 {
5917 if (section->sh_type == SHT_GROUP)
5918 {
74e1a04b
NC		 5919 const char * name = printable_section_name (section);
5920 const char * group_name;
2cf0635d
NC		 5921 unsigned char * start;
5922 unsigned char * indices;
f5842774 5923 unsigned int entry, j, size;
2cf0635d
NC		 5924 Elf_Internal_Shdr * sec;
5925 Elf_Internal_Sym * sym;
f5842774
L		 5926
5927 /* Get the symbol table. */
4fbb74a6
AM		 5928 if (section->sh_link >= elf_header.e_shnum
5929 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5930 != SHT_SYMTAB))
f5842774
L		 5931 {
5932 error (_("Bad sh_link in group section `%s'\n"), name);
5933 continue;
5934 }
d1f5c6e3
L		 5935
5936 if (symtab_sec != sec)
5937 {
5938 symtab_sec = sec;
5939 if (symtab)
5940 free (symtab);
ba5cdace 5941 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5942 }
f5842774 5943
dd24e3da
NC		 5944 if (symtab == NULL)
5945 {
5946 error (_("Corrupt header in group section `%s'\n"), name);
5947 continue;
5948 }
5949
ba5cdace
NC		 5950 if (section->sh_info >= num_syms)
5951 {
5952 error (_("Bad sh_info in group section `%s'\n"), name);
5953 continue;
5954 }
5955
f5842774
L		 5956 sym = symtab + section->sh_info;
5957
5958 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5959 {
4fbb74a6
AM		 5960 if (sym->st_shndx == 0
5961 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5962 {
5963 error (_("Bad sh_info in group section `%s'\n"), name);
5964 continue;
5965 }
ba2685cc 5966
4fbb74a6 5967 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5968 strtab_sec = NULL;
5969 if (strtab)
5970 free (strtab);
f5842774 5971 strtab = NULL;
c256ffe7 5972 strtab_size = 0;
f5842774
L		 5973 }
5974 else
5975 {
5976 /* Get the string table. */
4fbb74a6 5977 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5978 {
5979 strtab_sec = NULL;
5980 if (strtab)
5981 free (strtab);
5982 strtab = NULL;
5983 strtab_size = 0;
5984 }
5985 else if (strtab_sec
4fbb74a6 5986 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5987 {
5988 strtab_sec = sec;
5989 if (strtab)
5990 free (strtab);
071436c6 5991
3f5e193b 5992 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 5993 1, strtab_sec->sh_size,
5994 _("string table"));
c256ffe7 5995 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5996 }
c256ffe7 5997 group_name = sym->st_name < strtab_size
2b692964 5998 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5999 }
6000
c9c1d674
EG		 6001 /* PR 17531: file: loop. */
6002 if (section->sh_entsize > section->sh_size)
6003 {
6004 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6005 printable_section_name (section),
8066deb1
AM		 6006 (unsigned long) section->sh_entsize,
6007 (unsigned long) section->sh_size);
c9c1d674
EG		 6008 break;
6009 }
6010
3f5e193b
NC		 6011 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6012 1, section->sh_size,
6013 _("section data"));
59245841
NC		 6014 if (start == NULL)
6015 continue;
f5842774
L		 6016
6017 indices = start;
6018 size = (section->sh_size / section->sh_entsize) - 1;
6019 entry = byte_get (indices, 4);
6020 indices += 4;
e4b17d5c
L		 6021
6022 if (do_section_groups)
6023 {
2b692964 6024 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6025 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6026
e4b17d5c
L		 6027 printf (_(" [Index] Name\n"));
6028 }
6029
6030 group->group_index = i;
6031
f5842774
L		 6032 for (j = 0; j < size; j++)
6033 {
2cf0635d 6034 struct group_list * g;
e4b17d5c 6035
f5842774
L		 6036 entry = byte_get (indices, 4);
6037 indices += 4;
6038
4fbb74a6 6039 if (entry >= elf_header.e_shnum)
391cb864 6040 {
57028622
NC		 6041 static unsigned num_group_errors = 0;
6042
6043 if (num_group_errors ++ < 10)
6044 {
6045 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6046 entry, i, elf_header.e_shnum - 1);
6047 if (num_group_errors == 10)
6048 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6049 }
391cb864
L		 6050 continue;
6051 }
391cb864 6052
4fbb74a6 6053 if (section_headers_groups [entry] != NULL)
e4b17d5c 6054 {
d1f5c6e3
L		 6055 if (entry)
6056 {
57028622
NC		 6057 static unsigned num_errs = 0;
6058
6059 if (num_errs ++ < 10)
6060 {
6061 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6062 entry, i,
6063 section_headers_groups [entry]->group_index);
6064 if (num_errs == 10)
6065 warn (_("Further error messages about already contained group sections suppressed\n"));
6066 }
d1f5c6e3
L		 6067 continue;
6068 }
6069 else
6070 {
6071 /* Intel C/C++ compiler may put section 0 in a
6072 section group. We just warn it the first time
6073 and ignore it afterwards. */
6074 static int warned = 0;
6075 if (!warned)
6076 {
6077 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6078 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6079 warned++;
6080 }
6081 }
e4b17d5c
L		 6082 }
6083
4fbb74a6 6084 section_headers_groups [entry] = group;
e4b17d5c
L		 6085
6086 if (do_section_groups)
6087 {
4fbb74a6 6088 sec = section_headers + entry;
74e1a04b 6089 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6090 }
6091
3f5e193b 6092 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6093 g->section_index = entry;
6094 g->next = group->root;
6095 group->root = g;
f5842774
L		 6096 }
6097
f5842774
L		 6098 if (start)
6099 free (start);
e4b17d5c
L		 6100
6101 group++;
f5842774
L		 6102 }
6103 }
6104
d1f5c6e3
L		 6105 if (symtab)
6106 free (symtab);
6107 if (strtab)
6108 free (strtab);
f5842774
L		 6109 return 1;
6110}
6111
28f997cf
TG		 6112/* Data used to display dynamic fixups. */
6113
6114struct ia64_vms_dynfixup
6115{
6116 bfd_vma needed_ident; /* Library ident number. */
6117 bfd_vma needed; /* Index in the dstrtab of the library name. */
6118 bfd_vma fixup_needed; /* Index of the library. */
6119 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6120 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6121};
6122
6123/* Data used to display dynamic relocations. */
6124
6125struct ia64_vms_dynimgrela
6126{
6127 bfd_vma img_rela_cnt; /* Number of relocations. */
6128 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6129};
6130
6131/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6132 library). */
6133
6134static void
6135dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6136 const char *strtab, unsigned int strtab_sz)
6137{
6138 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6139 long i;
6140 const char *lib_name;
6141
6142 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6143 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6144 _("dynamic section image fixups"));
6145 if (!imfs)
6146 return;
6147
6148 if (fixup->needed < strtab_sz)
6149 lib_name = strtab + fixup->needed;
6150 else
6151 {
6152 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6153 (unsigned long) fixup->needed);
28f997cf
TG		 6154 lib_name = "???";
6155 }
6156 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6157 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6158 printf
6159 (_("Seg Offset Type SymVec DataType\n"));
6160
6161 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6162 {
6163 unsigned int type;
6164 const char *rtype;
6165
6166 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6167 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6168 type = BYTE_GET (imfs [i].type);
6169 rtype = elf_ia64_reloc_type (type);
6170 if (rtype == NULL)
6171 printf (" 0x%08x ", type);
6172 else
6173 printf (" %-32s ", rtype);
6174 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6175 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6176 }
6177
6178 free (imfs);
6179}
6180
6181/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6182
6183static void
6184dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6185{
6186 Elf64_External_VMS_IMAGE_RELA *imrs;
6187 long i;
6188
6189 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6190 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6191 _("dynamic section image relocations"));
28f997cf
TG		 6192 if (!imrs)
6193 return;
6194
6195 printf (_("\nImage relocs\n"));
6196 printf
6197 (_("Seg Offset Type Addend Seg Sym Off\n"));
6198
6199 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6200 {
6201 unsigned int type;
6202 const char *rtype;
6203
6204 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6205 printf ("%08" BFD_VMA_FMT "x ",
6206 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6207 type = BYTE_GET (imrs [i].type);
6208 rtype = elf_ia64_reloc_type (type);
6209 if (rtype == NULL)
6210 printf ("0x%08x ", type);
6211 else
6212 printf ("%-31s ", rtype);
6213 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6214 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6215 printf ("%08" BFD_VMA_FMT "x\n",
6216 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6217 }
6218
6219 free (imrs);
6220}
6221
6222/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6223
6224static int
6225process_ia64_vms_dynamic_relocs (FILE *file)
6226{
6227 struct ia64_vms_dynfixup fixup;
6228 struct ia64_vms_dynimgrela imgrela;
6229 Elf_Internal_Dyn *entry;
6230 int res = 0;
6231 bfd_vma strtab_off = 0;
6232 bfd_vma strtab_sz = 0;
6233 char *strtab = NULL;
6234
6235 memset (&fixup, 0, sizeof (fixup));
6236 memset (&imgrela, 0, sizeof (imgrela));
6237
6238 /* Note: the order of the entries is specified by the OpenVMS specs. */
6239 for (entry = dynamic_section;
6240 entry < dynamic_section + dynamic_nent;
6241 entry++)
6242 {
6243 switch (entry->d_tag)
6244 {
6245 case DT_IA_64_VMS_STRTAB_OFFSET:
6246 strtab_off = entry->d_un.d_val;
6247 break;
6248 case DT_STRSZ:
6249 strtab_sz = entry->d_un.d_val;
6250 if (strtab == NULL)
6251 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6252 1, strtab_sz, _("dynamic string section"));
6253 break;
6254
6255 case DT_IA_64_VMS_NEEDED_IDENT:
6256 fixup.needed_ident = entry->d_un.d_val;
6257 break;
6258 case DT_NEEDED:
6259 fixup.needed = entry->d_un.d_val;
6260 break;
6261 case DT_IA_64_VMS_FIXUP_NEEDED:
6262 fixup.fixup_needed = entry->d_un.d_val;
6263 break;
6264 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6265 fixup.fixup_rela_cnt = entry->d_un.d_val;
6266 break;
6267 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6268 fixup.fixup_rela_off = entry->d_un.d_val;
6269 res++;
6270 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6271 break;
6272
6273 case DT_IA_64_VMS_IMG_RELA_CNT:
6274 imgrela.img_rela_cnt = entry->d_un.d_val;
6275 break;
6276 case DT_IA_64_VMS_IMG_RELA_OFF:
6277 imgrela.img_rela_off = entry->d_un.d_val;
6278 res++;
6279 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6280 break;
6281
6282 default:
6283 break;
6284 }
6285 }
6286
6287 if (strtab != NULL)
6288 free (strtab);
6289
6290 return res;
6291}
6292
85b1c36d 6293static struct
566b0d53 6294{
2cf0635d 6295 const char * name;
566b0d53
L		 6296 int reloc;
6297 int size;
6298 int rela;
6299} dynamic_relocations [] =
6300{
6301 { "REL", DT_REL, DT_RELSZ, FALSE },
6302 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6303 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6304};
6305
252b5132 6306/* Process the reloc section. */
18bd398b 6307
252b5132 6308static int
2cf0635d 6309process_relocs (FILE * file)
252b5132 6310{
b34976b6
AM		 6311 unsigned long rel_size;
6312 unsigned long rel_offset;
252b5132
RH		 6313
6314
6315 if (!do_reloc)
6316 return 1;
6317
6318 if (do_using_dynamic)
6319 {
566b0d53 6320 int is_rela;
2cf0635d 6321 const char * name;
566b0d53
L		 6322 int has_dynamic_reloc;
6323 unsigned int i;
0de14b54 6324
566b0d53 6325 has_dynamic_reloc = 0;
252b5132 6326
566b0d53 6327 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6328 {
566b0d53
L		 6329 is_rela = dynamic_relocations [i].rela;
6330 name = dynamic_relocations [i].name;
6331 rel_size = dynamic_info [dynamic_relocations [i].size];
6332 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6333
566b0d53
L		 6334 has_dynamic_reloc |= rel_size;
6335
6336 if (is_rela == UNKNOWN)
aa903cfb 6337 {
566b0d53
L		 6338 if (dynamic_relocations [i].reloc == DT_JMPREL)
6339 switch (dynamic_info[DT_PLTREL])
6340 {
6341 case DT_REL:
6342 is_rela = FALSE;
6343 break;
6344 case DT_RELA:
6345 is_rela = TRUE;
6346 break;
6347 }
aa903cfb 6348 }
252b5132 6349
566b0d53
L		 6350 if (rel_size)
6351 {
6352 printf
6353 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6354 name, rel_offset, rel_size);
252b5132 6355
d93f0186
NC		 6356 dump_relocations (file,
6357 offset_from_vma (file, rel_offset, rel_size),
6358 rel_size,
566b0d53 6359 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6360 dynamic_strings, dynamic_strings_length,
6361 is_rela, 1);
566b0d53 6362 }
252b5132 6363 }
566b0d53 6364
28f997cf
TG		 6365 if (is_ia64_vms ())
6366 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6367
566b0d53 6368 if (! has_dynamic_reloc)
252b5132
RH		 6369 printf (_("\nThere are no dynamic relocations in this file.\n"));
6370 }
6371 else
6372 {
2cf0635d 6373 Elf_Internal_Shdr * section;
b34976b6
AM		 6374 unsigned long i;
6375 int found = 0;
252b5132
RH		 6376
6377 for (i = 0, section = section_headers;
6378 i < elf_header.e_shnum;
b34976b6 6379 i++, section++)
252b5132
RH		 6380 {
6381 if ( section->sh_type != SHT_RELA
6382 && section->sh_type != SHT_REL)
6383 continue;
6384
6385 rel_offset = section->sh_offset;
6386 rel_size = section->sh_size;
6387
6388 if (rel_size)
6389 {
2cf0635d 6390 Elf_Internal_Shdr * strsec;
b34976b6 6391 int is_rela;
103f02d3 6392
252b5132
RH		 6393 printf (_("\nRelocation section "));
6394
6395 if (string_table == NULL)
19936277 6396 printf ("%d", section->sh_name);
252b5132 6397 else
74e1a04b 6398 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6399
6400 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6401 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6402
d79b3d50
NC		 6403 is_rela = section->sh_type == SHT_RELA;
6404
4fbb74a6
AM		 6405 if (section->sh_link != 0
6406 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6407 {
2cf0635d
NC		 6408 Elf_Internal_Shdr * symsec;
6409 Elf_Internal_Sym * symtab;
d79b3d50 6410 unsigned long nsyms;
c256ffe7 6411 unsigned long strtablen = 0;
2cf0635d 6412 char * strtab = NULL;
57346661 6413
4fbb74a6 6414 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6415 if (symsec->sh_type != SHT_SYMTAB
6416 && symsec->sh_type != SHT_DYNSYM)
6417 continue;
6418
ba5cdace 6419 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6420
af3fc3bc
AM		 6421 if (symtab == NULL)
6422 continue;
252b5132 6423
4fbb74a6
AM		 6424 if (symsec->sh_link != 0
6425 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6426 {
4fbb74a6 6427 strsec = section_headers + symsec->sh_link;
103f02d3 6428
3f5e193b 6429 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6430 1, strsec->sh_size,
6431 _("string table"));
c256ffe7
JJ		 6432 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6433 }
252b5132 6434
d79b3d50 6435 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6436 symtab, nsyms, strtab, strtablen,
6437 is_rela,
6438 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6439 if (strtab)
6440 free (strtab);
6441 free (symtab);
6442 }
6443 else
6444 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6445 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6446
6447 found = 1;
6448 }
6449 }
6450
6451 if (! found)
6452 printf (_("\nThere are no relocations in this file.\n"));
6453 }
6454
6455 return 1;
6456}
6457
4d6ed7c8
NC		 6458/* An absolute address consists of a section and an offset. If the
6459 section is NULL, the offset itself is the address, otherwise, the
6460 address equals to LOAD_ADDRESS(section) + offset. */
6461
6462struct absaddr
948f632f
DA		 6463{
6464 unsigned short section;
6465 bfd_vma offset;
6466};
4d6ed7c8 6467
1949de15
L		 6468#define ABSADDR(a) \
6469 ((a).section \
6470 ? section_headers [(a).section].sh_addr + (a).offset \
6471 : (a).offset)
6472
948f632f
DA		 6473/* Find the nearest symbol at or below ADDR. Returns the symbol
6474 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6475
4d6ed7c8 6476static void
2cf0635d 6477find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6478 unsigned long nsyms,
6479 const char * strtab,
6480 unsigned long strtab_size,
6481 struct absaddr addr,
6482 const char ** symname,
6483 bfd_vma * offset)
4d6ed7c8 6484{
d3ba0551 6485 bfd_vma dist = 0x100000;
2cf0635d 6486 Elf_Internal_Sym * sym;
948f632f
DA		 6487 Elf_Internal_Sym * beg;
6488 Elf_Internal_Sym * end;
2cf0635d 6489 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6490
0b6ae522 6491 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6492 beg = symtab;
6493 end = symtab + nsyms;
0b6ae522 6494
948f632f 6495 while (beg < end)
4d6ed7c8 6496 {
948f632f
DA		 6497 bfd_vma value;
6498
6499 sym = beg + (end - beg) / 2;
0b6ae522 6500
948f632f 6501 value = sym->st_value;
0b6ae522
DJ		 6502 REMOVE_ARCH_BITS (value);
6503
948f632f 6504 if (sym->st_name != 0
4d6ed7c8 6505 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6506 && addr.offset >= value
6507 && addr.offset - value < dist)
4d6ed7c8
NC		 6508 {
6509 best = sym;
0b6ae522 6510 dist = addr.offset - value;
4d6ed7c8
NC		 6511 if (!dist)
6512 break;
6513 }
948f632f
DA		 6514
6515 if (addr.offset < value)
6516 end = sym;
6517 else
6518 beg = sym + 1;
4d6ed7c8 6519 }
1b31d05e 6520
4d6ed7c8
NC		 6521 if (best)
6522 {
57346661 6523 *symname = (best->st_name >= strtab_size
2b692964 6524 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6525 *offset = dist;
6526 return;
6527 }
1b31d05e 6528
4d6ed7c8
NC		 6529 *symname = NULL;
6530 *offset = addr.offset;
6531}
6532
948f632f
DA		 6533static int
6534symcmp (const void *p, const void *q)
6535{
6536 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6537 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6538
6539 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6540}
6541
6542/* Process the unwind section. */
6543
6544#include "unwind-ia64.h"
6545
6546struct ia64_unw_table_entry
6547{
6548 struct absaddr start;
6549 struct absaddr end;
6550 struct absaddr info;
6551};
6552
6553struct ia64_unw_aux_info
6554{
6555 struct ia64_unw_table_entry *table; /* Unwind table. */
6556 unsigned long table_len; /* Length of unwind table. */
6557 unsigned char * info; /* Unwind info. */
6558 unsigned long info_size; /* Size of unwind info. */
6559 bfd_vma info_addr; /* Starting address of unwind info. */
6560 bfd_vma seg_base; /* Starting address of segment. */
6561 Elf_Internal_Sym * symtab; /* The symbol table. */
6562 unsigned long nsyms; /* Number of symbols. */
6563 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6564 unsigned long nfuns; /* Number of entries in funtab. */
6565 char * strtab; /* The string table. */
6566 unsigned long strtab_size; /* Size of string table. */
6567};
6568
4d6ed7c8 6569static void
2cf0635d 6570dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6571{
2cf0635d 6572 struct ia64_unw_table_entry * tp;
948f632f 6573 unsigned long j, nfuns;
4d6ed7c8 6574 int in_body;
7036c0e1 6575
948f632f
DA		 6576 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6577 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6578 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6579 aux->funtab[nfuns++] = aux->symtab[j];
6580 aux->nfuns = nfuns;
6581 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6582
4d6ed7c8
NC		 6583 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6584 {
6585 bfd_vma stamp;
6586 bfd_vma offset;
2cf0635d
NC		 6587 const unsigned char * dp;
6588 const unsigned char * head;
53774b7e 6589 const unsigned char * end;
2cf0635d 6590 const char * procname;
4d6ed7c8 6591
948f632f 6592 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6593 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6594
6595 fputs ("\n<", stdout);
6596
6597 if (procname)
6598 {
6599 fputs (procname, stdout);
6600
6601 if (offset)
6602 printf ("+%lx", (unsigned long) offset);
6603 }
6604
6605 fputs (">: [", stdout);
6606 print_vma (tp->start.offset, PREFIX_HEX);
6607 fputc ('-', stdout);
6608 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6609 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6610 (unsigned long) (tp->info.offset - aux->seg_base));
6611
53774b7e
NC		 6612 /* PR 17531: file: 86232b32. */
6613 if (aux->info == NULL)
6614 continue;
6615
6616 /* PR 17531: file: 0997b4d1. */
6617 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6618 {
6619 warn (_("Invalid offset %lx in table entry %ld\n"),
6620 (long) tp->info.offset, (long) (tp - aux->table));
6621 continue;
6622 }
6623
1949de15 6624 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6625 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6626
86f55779 6627 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6628 (unsigned) UNW_VER (stamp),
6629 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6630 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6631 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6632 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6633
6634 if (UNW_VER (stamp) != 1)
6635 {
2b692964 6636 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6637 continue;
6638 }
6639
6640 in_body = 0;
53774b7e
NC		 6641 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6642 /* PR 17531: file: 16ceda89. */
6643 if (end > aux->info + aux->info_size)
6644 end = aux->info + aux->info_size;
6645 for (dp = head + 8; dp < end;)
4d6ed7c8
NC		 6646 dp = unw_decode (dp, in_body, & in_body);
6647 }
948f632f
DA		 6648
6649 free (aux->funtab);
4d6ed7c8
NC		 6650}
6651
53774b7e 6652static bfd_boolean
2cf0635d
NC		 6653slurp_ia64_unwind_table (FILE * file,
6654 struct ia64_unw_aux_info * aux,
6655 Elf_Internal_Shdr * sec)
4d6ed7c8 6656{
89fac5e3 6657 unsigned long size, nrelas, i;
2cf0635d
NC		 6658 Elf_Internal_Phdr * seg;
6659 struct ia64_unw_table_entry * tep;
6660 Elf_Internal_Shdr * relsec;
6661 Elf_Internal_Rela * rela;
6662 Elf_Internal_Rela * rp;
6663 unsigned char * table;
6664 unsigned char * tp;
6665 Elf_Internal_Sym * sym;
6666 const char * relname;
4d6ed7c8 6667
53774b7e
NC		 6668 aux->table_len = 0;
6669
4d6ed7c8
NC		 6670 /* First, find the starting address of the segment that includes
6671 this section: */
6672
6673 if (elf_header.e_phnum)
6674 {
d93f0186 6675 if (! get_program_headers (file))
53774b7e 6676 return FALSE;
4d6ed7c8 6677
d93f0186
NC		 6678 for (seg = program_headers;
6679 seg < program_headers + elf_header.e_phnum;
6680 ++seg)
4d6ed7c8
NC		 6681 {
6682 if (seg->p_type != PT_LOAD)
6683 continue;
6684
6685 if (sec->sh_addr >= seg->p_vaddr
6686 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6687 {
6688 aux->seg_base = seg->p_vaddr;
6689 break;
6690 }
6691 }
4d6ed7c8
NC		 6692 }
6693
6694 /* Second, build the unwind table from the contents of the unwind section: */
6695 size = sec->sh_size;
3f5e193b
NC		 6696 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6697 _("unwind table"));
a6e9f9df 6698 if (!table)
53774b7e 6699 return FALSE;
4d6ed7c8 6700
53774b7e 6701 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6702 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6703 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6704 tep = aux->table;
53774b7e
NC		 6705
6706 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6707 {
6708 tep->start.section = SHN_UNDEF;
6709 tep->end.section = SHN_UNDEF;
6710 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6711 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6712 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6713 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6714 tep->start.offset += aux->seg_base;
6715 tep->end.offset += aux->seg_base;
6716 tep->info.offset += aux->seg_base;
6717 }
6718 free (table);
6719
41e92641 6720 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6721 for (relsec = section_headers;
6722 relsec < section_headers + elf_header.e_shnum;
6723 ++relsec)
6724 {
6725 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6726 || relsec->sh_info >= elf_header.e_shnum
6727 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6728 continue;
6729
6730 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6731 & rela, & nrelas))
53774b7e
NC		 6732 {
6733 free (aux->table);
6734 aux->table = NULL;
6735 aux->table_len = 0;
6736 return FALSE;
6737 }
4d6ed7c8
NC		 6738
6739 for (rp = rela; rp < rela + nrelas; ++rp)
6740 {
aca88567
NC		 6741 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6742 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6743
82b1b41b
NC		 6744 /* PR 17531: file: 9fa67536. */
6745 if (relname == NULL)
6746 {
6747 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6748 continue;
6749 }
948f632f 6750
0112cd26 6751 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6752 {
82b1b41b 6753 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6754 continue;
6755 }
6756
89fac5e3 6757 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6758
53774b7e
NC		 6759 /* PR 17531: file: 5bc8d9bf. */
6760 if (i >= aux->table_len)
6761 {
6762 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6763 continue;
6764 }
6765
6766 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6767 {
6768 case 0:
6769 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6770 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6771 break;
6772 case 1:
6773 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6774 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6775 break;
6776 case 2:
6777 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6778 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6779 break;
6780 default:
6781 break;
6782 }
6783 }
6784
6785 free (rela);
6786 }
6787
53774b7e 6788 return TRUE;
4d6ed7c8
NC		 6789}
6790
1b31d05e 6791static void
2cf0635d 6792ia64_process_unwind (FILE * file)
4d6ed7c8 6793{
2cf0635d
NC		 6794 Elf_Internal_Shdr * sec;
6795 Elf_Internal_Shdr * unwsec = NULL;
6796 Elf_Internal_Shdr * strsec;
89fac5e3 6797 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6798 struct ia64_unw_aux_info aux;
f1467e33 6799
4d6ed7c8
NC		 6800 memset (& aux, 0, sizeof (aux));
6801
4d6ed7c8
NC		 6802 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6803 {
c256ffe7 6804 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6805 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6806 {
ba5cdace 6807 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6808
4fbb74a6 6809 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6810 if (aux.strtab != NULL)
6811 {
6812 error (_("Multiple auxillary string tables encountered\n"));
6813 free (aux.strtab);
6814 }
3f5e193b
NC		 6815 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6816 1, strsec->sh_size,
6817 _("string table"));
c256ffe7 6818 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6819 }
6820 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6821 unwcount++;
6822 }
6823
6824 if (!unwcount)
6825 printf (_("\nThere are no unwind sections in this file.\n"));
6826
6827 while (unwcount-- > 0)
6828 {
2cf0635d 6829 char * suffix;
579f31ac
JJ		 6830 size_t len, len2;
6831
4082ef84 6832 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6833 i < elf_header.e_shnum; ++i, ++sec)
6834 if (sec->sh_type == SHT_IA_64_UNWIND)
6835 {
6836 unwsec = sec;
6837 break;
6838 }
4082ef84
NC		 6839 /* We have already counted the number of SHT_IA64_UNWIND
6840 sections so the loop above should never fail. */
6841 assert (unwsec != NULL);
579f31ac
JJ		 6842
6843 unwstart = i + 1;
6844 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6845
e4b17d5c
L		 6846 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6847 {
6848 /* We need to find which section group it is in. */
4082ef84 6849 struct group_list * g;
e4b17d5c 6850
4082ef84
NC		 6851 if (section_headers_groups == NULL
6852 || section_headers_groups [i] == NULL)
6853 i = elf_header.e_shnum;
6854 else
e4b17d5c 6855 {
4082ef84 6856 g = section_headers_groups [i]->root;
18bd398b 6857
4082ef84
NC		 6858 for (; g != NULL; g = g->next)
6859 {
6860 sec = section_headers + g->section_index;
e4b17d5c 6861
4082ef84
NC		 6862 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6863 break;
6864 }
6865
6866 if (g == NULL)
6867 i = elf_header.e_shnum;
6868 }
e4b17d5c 6869 }
18bd398b 6870 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6871 {
18bd398b 6872 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6873 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6874 suffix = SECTION_NAME (unwsec) + len;
6875 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6876 ++i, ++sec)
18bd398b
NC		 6877 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6878 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6879 break;
6880 }
6881 else
6882 {
6883 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6884 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6885 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6886 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6887 suffix = "";
18bd398b 6888 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6889 suffix = SECTION_NAME (unwsec) + len;
6890 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6891 ++i, ++sec)
18bd398b
NC		 6892 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6893 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6894 break;
6895 }
6896
6897 if (i == elf_header.e_shnum)
6898 {
6899 printf (_("\nCould not find unwind info section for "));
6900
6901 if (string_table == NULL)
6902 printf ("%d", unwsec->sh_name);
6903 else
74e1a04b 6904 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6905 }
6906 else
4d6ed7c8 6907 {
4d6ed7c8 6908 aux.info_addr = sec->sh_addr;
3f5e193b 6909 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6910 sec->sh_size,
6911 _("unwind info"));
59245841 6912 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6913
579f31ac 6914 printf (_("\nUnwind section "));
4d6ed7c8 6915
579f31ac
JJ		 6916 if (string_table == NULL)
6917 printf ("%d", unwsec->sh_name);
6918 else
74e1a04b 6919 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 6920
579f31ac 6921 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6922 (unsigned long) unwsec->sh_offset,
89fac5e3 6923 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6924
53774b7e
NC		 6925 if (slurp_ia64_unwind_table (file, & aux, unwsec)
6926 && aux.table_len > 0)
579f31ac
JJ		 6927 dump_ia64_unwind (& aux);
6928
6929 if (aux.table)
6930 free ((char *) aux.table);
6931 if (aux.info)
6932 free ((char *) aux.info);
6933 aux.table = NULL;
6934 aux.info = NULL;
6935 }
4d6ed7c8 6936 }
4d6ed7c8 6937
4d6ed7c8
NC		 6938 if (aux.symtab)
6939 free (aux.symtab);
6940 if (aux.strtab)
6941 free ((char *) aux.strtab);
4d6ed7c8
NC		 6942}
6943
3f5e193b
NC		 6944struct hppa_unw_table_entry
6945 {
6946 struct absaddr start;
6947 struct absaddr end;
948f632f 6948 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 6949 unsigned int Millicode:1; /* 1 */
6950 unsigned int Millicode_save_sr0:1; /* 2 */
6951 unsigned int Region_description:2; /* 3..4 */
6952 unsigned int reserved1:1; /* 5 */
6953 unsigned int Entry_SR:1; /* 6 */
6954 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6955 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6956 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 6957 unsigned int Variable_Frame:1; /* 17 */
6958 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 6959 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 6960 unsigned int Stack_Overflow_Check:1; /* 20 */
6961 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 6962 unsigned int Ada_Region:1; /* 22 */
6963 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 6964 unsigned int cxx_try_catch:1; /* 24 */
6965 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 6966 unsigned int reserved2:1; /* 26 */
948f632f
DA		 6967 unsigned int Save_SP:1; /* 27 */
6968 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 6969 unsigned int Save_MRP_in_frame:1; /* 29 */
6970 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 6971 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 6972
948f632f
DA		 6973 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6974 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 6975 unsigned int Large_frame:1; /* 2 */
948f632f 6976 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 6977 unsigned int reserved4:1; /* 4 */
6978 unsigned int Total_frame_size:27; /* 5..31 */
6979 };
6980
57346661 6981struct hppa_unw_aux_info
948f632f
DA		 6982{
6983 struct hppa_unw_table_entry * table; /* Unwind table. */
6984 unsigned long table_len; /* Length of unwind table. */
6985 bfd_vma seg_base; /* Starting address of segment. */
6986 Elf_Internal_Sym * symtab; /* The symbol table. */
6987 unsigned long nsyms; /* Number of symbols. */
6988 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6989 unsigned long nfuns; /* Number of entries in funtab. */
6990 char * strtab; /* The string table. */
6991 unsigned long strtab_size; /* Size of string table. */
6992};
57346661
AM		 6993
6994static void
2cf0635d 6995dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6996{
2cf0635d 6997 struct hppa_unw_table_entry * tp;
948f632f
DA		 6998 unsigned long j, nfuns;
6999
7000 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7001 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7002 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7003 aux->funtab[nfuns++] = aux->symtab[j];
7004 aux->nfuns = nfuns;
7005 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7006
57346661
AM		 7007 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7008 {
7009 bfd_vma offset;
2cf0635d 7010 const char * procname;
57346661 7011
948f632f 7012 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7013 aux->strtab_size, tp->start, &procname,
7014 &offset);
7015
7016 fputs ("\n<", stdout);
7017
7018 if (procname)
7019 {
7020 fputs (procname, stdout);
7021
7022 if (offset)
7023 printf ("+%lx", (unsigned long) offset);
7024 }
7025
7026 fputs (">: [", stdout);
7027 print_vma (tp->start.offset, PREFIX_HEX);
7028 fputc ('-', stdout);
7029 print_vma (tp->end.offset, PREFIX_HEX);
7030 printf ("]\n\t");
7031
18bd398b
NC		 7032#define PF(_m) if (tp->_m) printf (#_m " ");
7033#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7034 PF(Cannot_unwind);
7035 PF(Millicode);
7036 PF(Millicode_save_sr0);
18bd398b 7037 /* PV(Region_description); */
57346661
AM		 7038 PF(Entry_SR);
7039 PV(Entry_FR);
7040 PV(Entry_GR);
7041 PF(Args_stored);
7042 PF(Variable_Frame);
7043 PF(Separate_Package_Body);
7044 PF(Frame_Extension_Millicode);
7045 PF(Stack_Overflow_Check);
7046 PF(Two_Instruction_SP_Increment);
7047 PF(Ada_Region);
7048 PF(cxx_info);
7049 PF(cxx_try_catch);
7050 PF(sched_entry_seq);
7051 PF(Save_SP);
7052 PF(Save_RP);
7053 PF(Save_MRP_in_frame);
7054 PF(extn_ptr_defined);
7055 PF(Cleanup_defined);
7056 PF(MPE_XL_interrupt_marker);
7057 PF(HP_UX_interrupt_marker);
7058 PF(Large_frame);
7059 PF(Pseudo_SP_Set);
7060 PV(Total_frame_size);
7061#undef PF
7062#undef PV
7063 }
7064
18bd398b 7065 printf ("\n");
948f632f
DA		 7066
7067 free (aux->funtab);
57346661
AM		 7068}
7069
7070static int
2cf0635d
NC		 7071slurp_hppa_unwind_table (FILE * file,
7072 struct hppa_unw_aux_info * aux,
7073 Elf_Internal_Shdr * sec)
57346661 7074{
1c0751b2 7075 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7076 Elf_Internal_Phdr * seg;
7077 struct hppa_unw_table_entry * tep;
7078 Elf_Internal_Shdr * relsec;
7079 Elf_Internal_Rela * rela;
7080 Elf_Internal_Rela * rp;
7081 unsigned char * table;
7082 unsigned char * tp;
7083 Elf_Internal_Sym * sym;
7084 const char * relname;
57346661 7085
57346661
AM		 7086 /* First, find the starting address of the segment that includes
7087 this section. */
7088
7089 if (elf_header.e_phnum)
7090 {
7091 if (! get_program_headers (file))
7092 return 0;
7093
7094 for (seg = program_headers;
7095 seg < program_headers + elf_header.e_phnum;
7096 ++seg)
7097 {
7098 if (seg->p_type != PT_LOAD)
7099 continue;
7100
7101 if (sec->sh_addr >= seg->p_vaddr
7102 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7103 {
7104 aux->seg_base = seg->p_vaddr;
7105 break;
7106 }
7107 }
7108 }
7109
7110 /* Second, build the unwind table from the contents of the unwind
7111 section. */
7112 size = sec->sh_size;
3f5e193b
NC		 7113 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7114 _("unwind table"));
57346661
AM		 7115 if (!table)
7116 return 0;
7117
1c0751b2
DA		 7118 unw_ent_size = 16;
7119 nentries = size / unw_ent_size;
7120 size = unw_ent_size * nentries;
57346661 7121
3f5e193b
NC		 7122 tep = aux->table = (struct hppa_unw_table_entry *)
7123 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7124
1c0751b2 7125 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7126 {
7127 unsigned int tmp1, tmp2;
7128
7129 tep->start.section = SHN_UNDEF;
7130 tep->end.section = SHN_UNDEF;
7131
1c0751b2
DA		 7132 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7133 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7134 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7135 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7136
7137 tep->start.offset += aux->seg_base;
7138 tep->end.offset += aux->seg_base;
57346661
AM		 7139
7140 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7141 tep->Millicode = (tmp1 >> 30) & 0x1;
7142 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7143 tep->Region_description = (tmp1 >> 27) & 0x3;
7144 tep->reserved1 = (tmp1 >> 26) & 0x1;
7145 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7146 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7147 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7148 tep->Args_stored = (tmp1 >> 15) & 0x1;
7149 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7150 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7151 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7152 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7153 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7154 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7155 tep->cxx_info = (tmp1 >> 8) & 0x1;
7156 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7157 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7158 tep->reserved2 = (tmp1 >> 5) & 0x1;
7159 tep->Save_SP = (tmp1 >> 4) & 0x1;
7160 tep->Save_RP = (tmp1 >> 3) & 0x1;
7161 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7162 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7163 tep->Cleanup_defined = tmp1 & 0x1;
7164
7165 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7166 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7167 tep->Large_frame = (tmp2 >> 29) & 0x1;
7168 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7169 tep->reserved4 = (tmp2 >> 27) & 0x1;
7170 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7171 }
7172 free (table);
7173
7174 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7175 for (relsec = section_headers;
7176 relsec < section_headers + elf_header.e_shnum;
7177 ++relsec)
7178 {
7179 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7180 || relsec->sh_info >= elf_header.e_shnum
7181 || section_headers + relsec->sh_info != sec)
57346661
AM		 7182 continue;
7183
7184 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7185 & rela, & nrelas))
7186 return 0;
7187
7188 for (rp = rela; rp < rela + nrelas; ++rp)
7189 {
aca88567
NC		 7190 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7191 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7192
7193 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7194 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7195 {
7196 warn (_("Skipping unexpected relocation type %s\n"), relname);
7197 continue;
7198 }
7199
7200 i = rp->r_offset / unw_ent_size;
7201
89fac5e3 7202 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7203 {
7204 case 0:
7205 aux->table[i].start.section = sym->st_shndx;
1e456d54 7206 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7207 break;
7208 case 1:
7209 aux->table[i].end.section = sym->st_shndx;
1e456d54 7210 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7211 break;
7212 default:
7213 break;
7214 }
7215 }
7216
7217 free (rela);
7218 }
7219
1c0751b2 7220 aux->table_len = nentries;
57346661
AM		 7221
7222 return 1;
7223}
7224
1b31d05e 7225static void
2cf0635d 7226hppa_process_unwind (FILE * file)
57346661 7227{
57346661 7228 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7229 Elf_Internal_Shdr * unwsec = NULL;
7230 Elf_Internal_Shdr * strsec;
7231 Elf_Internal_Shdr * sec;
18bd398b 7232 unsigned long i;
57346661 7233
c256ffe7 7234 if (string_table == NULL)
1b31d05e
NC		 7235 return;
7236
7237 memset (& aux, 0, sizeof (aux));
57346661
AM		 7238
7239 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7240 {
c256ffe7 7241 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7242 && sec->sh_link < elf_header.e_shnum)
57346661 7243 {
ba5cdace 7244 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7245
4fbb74a6 7246 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7247 if (aux.strtab != NULL)
7248 {
7249 error (_("Multiple auxillary string tables encountered\n"));
7250 free (aux.strtab);
7251 }
3f5e193b
NC		 7252 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7253 1, strsec->sh_size,
7254 _("string table"));
c256ffe7 7255 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7256 }
18bd398b 7257 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7258 unwsec = sec;
7259 }
7260
7261 if (!unwsec)
7262 printf (_("\nThere are no unwind sections in this file.\n"));
7263
7264 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7265 {
18bd398b 7266 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7267 {
74e1a04b
NC		 7268 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7269 printable_section_name (sec),
57346661 7270 (unsigned long) sec->sh_offset,
89fac5e3 7271 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7272
7273 slurp_hppa_unwind_table (file, &aux, sec);
7274 if (aux.table_len > 0)
7275 dump_hppa_unwind (&aux);
7276
7277 if (aux.table)
7278 free ((char *) aux.table);
7279 aux.table = NULL;
7280 }
7281 }
7282
7283 if (aux.symtab)
7284 free (aux.symtab);
7285 if (aux.strtab)
7286 free ((char *) aux.strtab);
57346661
AM		 7287}
7288
0b6ae522
DJ		 7289struct arm_section
7290{
a734115a
NC		 7291 unsigned char * data; /* The unwind data. */
7292 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7293 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7294 unsigned long nrelas; /* The number of relocations. */
7295 unsigned int rel_type; /* REL or RELA ? */
7296 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7297};
7298
7299struct arm_unw_aux_info
7300{
a734115a
NC		 7301 FILE * file; /* The file containing the unwind sections. */
7302 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7303 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7304 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7305 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7306 char * strtab; /* The file's string table. */
7307 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7308};
7309
7310static const char *
7311arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7312 bfd_vma fn, struct absaddr addr)
7313{
7314 const char *procname;
7315 bfd_vma sym_offset;
7316
7317 if (addr.section == SHN_UNDEF)
7318 addr.offset = fn;
7319
948f632f 7320 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7321 aux->strtab_size, addr, &procname,
7322 &sym_offset);
7323
7324 print_vma (fn, PREFIX_HEX);
7325
7326 if (procname)
7327 {
7328 fputs (" <", stdout);
7329 fputs (procname, stdout);
7330
7331 if (sym_offset)
7332 printf ("+0x%lx", (unsigned long) sym_offset);
7333 fputc ('>', stdout);
7334 }
7335
7336 return procname;
7337}
7338
7339static void
7340arm_free_section (struct arm_section *arm_sec)
7341{
7342 if (arm_sec->data != NULL)
7343 free (arm_sec->data);
7344
7345 if (arm_sec->rela != NULL)
7346 free (arm_sec->rela);
7347}
7348
a734115a
NC		 7349/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7350 cached section and install SEC instead.
7351 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7352 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7353 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7354 relocation's offset in ADDR.
1b31d05e
NC		 7355 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7356 into the string table of the symbol associated with the reloc. If no
7357 reloc was applied store -1 there.
7358 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7359
7360static bfd_boolean
1b31d05e
NC		 7361get_unwind_section_word (struct arm_unw_aux_info * aux,
7362 struct arm_section * arm_sec,
7363 Elf_Internal_Shdr * sec,
7364 bfd_vma word_offset,
7365 unsigned int * wordp,
7366 struct absaddr * addr,
7367 bfd_vma * sym_name)
0b6ae522
DJ		 7368{
7369 Elf_Internal_Rela *rp;
7370 Elf_Internal_Sym *sym;
7371 const char * relname;
7372 unsigned int word;
7373 bfd_boolean wrapped;
7374
e0a31db1
NC		 7375 if (sec == NULL || arm_sec == NULL)
7376 return FALSE;
7377
0b6ae522
DJ		 7378 addr->section = SHN_UNDEF;
7379 addr->offset = 0;
7380
1b31d05e
NC		 7381 if (sym_name != NULL)
7382 *sym_name = (bfd_vma) -1;
7383
a734115a 7384 /* If necessary, update the section cache. */
0b6ae522
DJ		 7385 if (sec != arm_sec->sec)
7386 {
7387 Elf_Internal_Shdr *relsec;
7388
7389 arm_free_section (arm_sec);
7390
7391 arm_sec->sec = sec;
7392 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7393 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7394 arm_sec->rela = NULL;
7395 arm_sec->nrelas = 0;
7396
7397 for (relsec = section_headers;
7398 relsec < section_headers + elf_header.e_shnum;
7399 ++relsec)
7400 {
7401 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7402 || section_headers + relsec->sh_info != sec
7403 /* PR 15745: Check the section type as well. */
7404 || (relsec->sh_type != SHT_REL
7405 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7406 continue;
7407
a734115a 7408 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7409 if (relsec->sh_type == SHT_REL)
7410 {
7411 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7412 relsec->sh_size,
7413 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7414 return FALSE;
0b6ae522 7415 }
1ae40aa4 7416 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7417 {
7418 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7419 relsec->sh_size,
7420 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7421 return FALSE;
0b6ae522 7422 }
1ae40aa4 7423 break;
0b6ae522
DJ		 7424 }
7425
7426 arm_sec->next_rela = arm_sec->rela;
7427 }
7428
a734115a 7429 /* If there is no unwind data we can do nothing. */
0b6ae522 7430 if (arm_sec->data == NULL)
a734115a 7431 return FALSE;
0b6ae522 7432
e0a31db1
NC		 7433 /* If the offset is invalid then fail. */
7434 if (word_offset > sec->sh_size - 4)
7435 return FALSE;
7436
a734115a 7437 /* Get the word at the required offset. */
0b6ae522
DJ		 7438 word = byte_get (arm_sec->data + word_offset, 4);
7439
0eff7165
NC		 7440 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7441 if (arm_sec->rela == NULL)
7442 {
7443 * wordp = word;
7444 return TRUE;
7445 }
7446
a734115a 7447 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7448 wrapped = FALSE;
7449 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7450 {
7451 bfd_vma prelval, offset;
7452
7453 if (rp->r_offset > word_offset && !wrapped)
7454 {
7455 rp = arm_sec->rela;
7456 wrapped = TRUE;
7457 }
7458 if (rp->r_offset > word_offset)
7459 break;
7460
7461 if (rp->r_offset & 3)
7462 {
7463 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7464 (unsigned long) rp->r_offset);
7465 continue;
7466 }
7467
7468 if (rp->r_offset < word_offset)
7469 continue;
7470
74e1a04b
NC		 7471 /* PR 17531: file: 027-161405-0.004 */
7472 if (aux->symtab == NULL)
7473 continue;
7474
0b6ae522
DJ		 7475 if (arm_sec->rel_type == SHT_REL)
7476 {
7477 offset = word & 0x7fffffff;
7478 if (offset & 0x40000000)
7479 offset |= ~ (bfd_vma) 0x7fffffff;
7480 }
a734115a 7481 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7482 offset = rp->r_addend;
a734115a 7483 else
74e1a04b
NC		 7484 {
7485 error (_("Unknown section relocation type %d encountered\n"),
7486 arm_sec->rel_type);
7487 break;
7488 }
0b6ae522 7489
071436c6
NC		 7490 /* PR 17531 file: 027-1241568-0.004. */
7491 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7492 {
7493 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7494 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7495 break;
7496 }
7497
7498 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7499 offset += sym->st_value;
7500 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7501
a734115a
NC		 7502 /* Check that we are processing the expected reloc type. */
7503 if (elf_header.e_machine == EM_ARM)
7504 {
7505 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7506 if (relname == NULL)
7507 {
7508 warn (_("Skipping unknown ARM relocation type: %d\n"),
7509 (int) ELF32_R_TYPE (rp->r_info));
7510 continue;
7511 }
a734115a
NC		 7512
7513 if (streq (relname, "R_ARM_NONE"))
7514 continue;
0b4362b0 7515
a734115a
NC		 7516 if (! streq (relname, "R_ARM_PREL31"))
7517 {
071436c6 7518 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7519 continue;
7520 }
7521 }
7522 else if (elf_header.e_machine == EM_TI_C6000)
7523 {
7524 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7525 if (relname == NULL)
7526 {
7527 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7528 (int) ELF32_R_TYPE (rp->r_info));
7529 continue;
7530 }
0b4362b0 7531
a734115a
NC		 7532 if (streq (relname, "R_C6000_NONE"))
7533 continue;
7534
7535 if (! streq (relname, "R_C6000_PREL31"))
7536 {
071436c6 7537 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7538 continue;
7539 }
7540
7541 prelval >>= 1;
7542 }
7543 else
74e1a04b
NC		 7544 {
7545 /* This function currently only supports ARM and TI unwinders. */
7546 warn (_("Only TI and ARM unwinders are currently supported\n"));
7547 break;
7548 }
fa197c1c 7549
0b6ae522
DJ		 7550 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7551 addr->section = sym->st_shndx;
7552 addr->offset = offset;
74e1a04b 7553
1b31d05e
NC		 7554 if (sym_name)
7555 * sym_name = sym->st_name;
0b6ae522
DJ		 7556 break;
7557 }
7558
7559 *wordp = word;
7560 arm_sec->next_rela = rp;
7561
a734115a 7562 return TRUE;
0b6ae522
DJ		 7563}
7564
a734115a
NC		 7565static const char *tic6x_unwind_regnames[16] =
7566{
0b4362b0
RM		 7567 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7568 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7569 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7570};
fa197c1c 7571
0b6ae522 7572static void
fa197c1c 7573decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7574{
fa197c1c
PB		 7575 int i;
7576
7577 for (i = 12; mask; mask >>= 1, i--)
7578 {
7579 if (mask & 1)
7580 {
7581 fputs (tic6x_unwind_regnames[i], stdout);
7582 if (mask > 1)
7583 fputs (", ", stdout);
7584 }
7585 }
7586}
0b6ae522
DJ		 7587
7588#define ADVANCE \
7589 if (remaining == 0 && more_words) \
7590 { \
7591 data_offset += 4; \
1b31d05e
NC		 7592 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7593 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7594 return; \
7595 remaining = 4; \
7596 more_words--; \
7597 } \
7598
7599#define GET_OP(OP) \
7600 ADVANCE; \
7601 if (remaining) \
7602 { \
7603 remaining--; \
7604 (OP) = word >> 24; \
7605 word <<= 8; \
7606 } \
7607 else \
7608 { \
2b692964 7609 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7610 return; \
7611 } \
cc5914eb 7612 printf ("0x%02x ", OP)
0b6ae522 7613
fa197c1c 7614static void
948f632f
DA		 7615decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7616 unsigned int word,
7617 unsigned int remaining,
7618 unsigned int more_words,
7619 bfd_vma data_offset,
7620 Elf_Internal_Shdr * data_sec,
7621 struct arm_section * data_arm_sec)
fa197c1c
PB		 7622{
7623 struct absaddr addr;
0b6ae522
DJ		 7624
7625 /* Decode the unwinding instructions. */
7626 while (1)
7627 {
7628 unsigned int op, op2;
7629
7630 ADVANCE;
7631 if (remaining == 0)
7632 break;
7633 remaining--;
7634 op = word >> 24;
7635 word <<= 8;
7636
cc5914eb 7637 printf (" 0x%02x ", op);
0b6ae522
DJ		 7638
7639 if ((op & 0xc0) == 0x00)
7640 {
7641 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7642
cc5914eb 7643 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7644 }
7645 else if ((op & 0xc0) == 0x40)
7646 {
7647 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7648
cc5914eb 7649 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7650 }
7651 else if ((op & 0xf0) == 0x80)
7652 {
7653 GET_OP (op2);
7654 if (op == 0x80 && op2 == 0)
7655 printf (_("Refuse to unwind"));
7656 else
7657 {
7658 unsigned int mask = ((op & 0x0f) << 8) | op2;
7659 int first = 1;
7660 int i;
2b692964 7661
0b6ae522
DJ		 7662 printf ("pop {");
7663 for (i = 0; i < 12; i++)
7664 if (mask & (1 << i))
7665 {
7666 if (first)
7667 first = 0;
7668 else
7669 printf (", ");
7670 printf ("r%d", 4 + i);
7671 }
7672 printf ("}");
7673 }
7674 }
7675 else if ((op & 0xf0) == 0x90)
7676 {
7677 if (op == 0x9d || op == 0x9f)
7678 printf (_(" [Reserved]"));
7679 else
cc5914eb 7680 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7681 }
7682 else if ((op & 0xf0) == 0xa0)
7683 {
7684 int end = 4 + (op & 0x07);
7685 int first = 1;
7686 int i;
61865e30 7687
0b6ae522
DJ		 7688 printf (" pop {");
7689 for (i = 4; i <= end; i++)
7690 {
7691 if (first)
7692 first = 0;
7693 else
7694 printf (", ");
7695 printf ("r%d", i);
7696 }
7697 if (op & 0x08)
7698 {
1b31d05e 7699 if (!first)
0b6ae522
DJ		 7700 printf (", ");
7701 printf ("r14");
7702 }
7703 printf ("}");
7704 }
7705 else if (op == 0xb0)
7706 printf (_(" finish"));
7707 else if (op == 0xb1)
7708 {
7709 GET_OP (op2);
7710 if (op2 == 0 || (op2 & 0xf0) != 0)
7711 printf (_("[Spare]"));
7712 else
7713 {
7714 unsigned int mask = op2 & 0x0f;
7715 int first = 1;
7716 int i;
61865e30 7717
0b6ae522
DJ		 7718 printf ("pop {");
7719 for (i = 0; i < 12; i++)
7720 if (mask & (1 << i))
7721 {
7722 if (first)
7723 first = 0;
7724 else
7725 printf (", ");
7726 printf ("r%d", i);
7727 }
7728 printf ("}");
7729 }
7730 }
7731 else if (op == 0xb2)
7732 {
b115cf96 7733 unsigned char buf[9];
0b6ae522
DJ		 7734 unsigned int i, len;
7735 unsigned long offset;
61865e30 7736
b115cf96 7737 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7738 {
7739 GET_OP (buf[i]);
7740 if ((buf[i] & 0x80) == 0)
7741 break;
7742 }
4082ef84
NC		 7743 if (i == sizeof (buf))
7744 printf (_("corrupt change to vsp"));
7745 else
7746 {
7747 offset = read_uleb128 (buf, &len, buf + i + 1);
7748 assert (len == i + 1);
7749 offset = offset * 4 + 0x204;
7750 printf ("vsp = vsp + %ld", offset);
7751 }
0b6ae522 7752 }
61865e30 7753 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7754 {
61865e30
NC		 7755 unsigned int first, last;
7756
7757 GET_OP (op2);
7758 first = op2 >> 4;
7759 last = op2 & 0x0f;
7760 if (op == 0xc8)
7761 first = first + 16;
7762 printf ("pop {D%d", first);
7763 if (last)
7764 printf ("-D%d", first + last);
7765 printf ("}");
7766 }
7767 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7768 {
7769 unsigned int count = op & 0x07;
7770
7771 printf ("pop {D8");
7772 if (count)
7773 printf ("-D%d", 8 + count);
7774 printf ("}");
7775 }
7776 else if (op >= 0xc0 && op <= 0xc5)
7777 {
7778 unsigned int count = op & 0x07;
7779
7780 printf (" pop {wR10");
7781 if (count)
7782 printf ("-wR%d", 10 + count);
7783 printf ("}");
7784 }
7785 else if (op == 0xc6)
7786 {
7787 unsigned int first, last;
7788
7789 GET_OP (op2);
7790 first = op2 >> 4;
7791 last = op2 & 0x0f;
7792 printf ("pop {wR%d", first);
7793 if (last)
7794 printf ("-wR%d", first + last);
7795 printf ("}");
7796 }
7797 else if (op == 0xc7)
7798 {
7799 GET_OP (op2);
7800 if (op2 == 0 || (op2 & 0xf0) != 0)
7801 printf (_("[Spare]"));
0b6ae522
DJ		 7802 else
7803 {
61865e30
NC		 7804 unsigned int mask = op2 & 0x0f;
7805 int first = 1;
7806 int i;
7807
7808 printf ("pop {");
7809 for (i = 0; i < 4; i++)
7810 if (mask & (1 << i))
7811 {
7812 if (first)
7813 first = 0;
7814 else
7815 printf (", ");
7816 printf ("wCGR%d", i);
7817 }
7818 printf ("}");
0b6ae522
DJ		 7819 }
7820 }
61865e30
NC		 7821 else
7822 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7823 printf ("\n");
7824 }
fa197c1c
PB		 7825}
7826
7827static void
948f632f
DA		 7828decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7829 unsigned int word,
7830 unsigned int remaining,
7831 unsigned int more_words,
7832 bfd_vma data_offset,
7833 Elf_Internal_Shdr * data_sec,
7834 struct arm_section * data_arm_sec)
fa197c1c
PB		 7835{
7836 struct absaddr addr;
7837
7838 /* Decode the unwinding instructions. */
7839 while (1)
7840 {
7841 unsigned int op, op2;
7842
7843 ADVANCE;
7844 if (remaining == 0)
7845 break;
7846 remaining--;
7847 op = word >> 24;
7848 word <<= 8;
7849
9cf03b7e 7850 printf (" 0x%02x ", op);
fa197c1c
PB		 7851
7852 if ((op & 0xc0) == 0x00)
7853 {
7854 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7855 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7856 }
7857 else if ((op & 0xc0) == 0x80)
7858 {
7859 GET_OP (op2);
7860 if (op == 0x80 && op2 == 0)
7861 printf (_("Refuse to unwind"));
7862 else
7863 {
7864 unsigned int mask = ((op & 0x1f) << 8) | op2;
7865 if (op & 0x20)
7866 printf ("pop compact {");
7867 else
7868 printf ("pop {");
7869
7870 decode_tic6x_unwind_regmask (mask);
7871 printf("}");
7872 }
7873 }
7874 else if ((op & 0xf0) == 0xc0)
7875 {
7876 unsigned int reg;
7877 unsigned int nregs;
7878 unsigned int i;
7879 const char *name;
a734115a
NC		 7880 struct
7881 {
fa197c1c
PB		 7882 unsigned int offset;
7883 unsigned int reg;
7884 } regpos[16];
7885
7886 /* Scan entire instruction first so that GET_OP output is not
7887 interleaved with disassembly. */
7888 nregs = 0;
7889 for (i = 0; nregs < (op & 0xf); i++)
7890 {
7891 GET_OP (op2);
7892 reg = op2 >> 4;
7893 if (reg != 0xf)
7894 {
7895 regpos[nregs].offset = i * 2;
7896 regpos[nregs].reg = reg;
7897 nregs++;
7898 }
7899
7900 reg = op2 & 0xf;
7901 if (reg != 0xf)
7902 {
7903 regpos[nregs].offset = i * 2 + 1;
7904 regpos[nregs].reg = reg;
7905 nregs++;
7906 }
7907 }
7908
7909 printf (_("pop frame {"));
7910 reg = nregs - 1;
7911 for (i = i * 2; i > 0; i--)
7912 {
7913 if (regpos[reg].offset == i - 1)
7914 {
7915 name = tic6x_unwind_regnames[regpos[reg].reg];
7916 if (reg > 0)
7917 reg--;
7918 }
7919 else
7920 name = _("[pad]");
7921
7922 fputs (name, stdout);
7923 if (i > 1)
7924 printf (", ");
7925 }
7926
7927 printf ("}");
7928 }
7929 else if (op == 0xd0)
7930 printf (" MOV FP, SP");
7931 else if (op == 0xd1)
7932 printf (" __c6xabi_pop_rts");
7933 else if (op == 0xd2)
7934 {
7935 unsigned char buf[9];
7936 unsigned int i, len;
7937 unsigned long offset;
a734115a 7938
fa197c1c
PB		 7939 for (i = 0; i < sizeof (buf); i++)
7940 {
7941 GET_OP (buf[i]);
7942 if ((buf[i] & 0x80) == 0)
7943 break;
7944 }
0eff7165
NC		 7945 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7946 if (i == sizeof (buf))
7947 {
7948 printf ("<corrupt sp adjust>\n");
7949 warn (_("Corrupt stack pointer adjustment detected\n"));
7950 return;
7951 }
948f632f 7952
f6f0e17b 7953 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7954 assert (len == i + 1);
7955 offset = offset * 8 + 0x408;
7956 printf (_("sp = sp + %ld"), offset);
7957 }
7958 else if ((op & 0xf0) == 0xe0)
7959 {
7960 if ((op & 0x0f) == 7)
7961 printf (" RETURN");
7962 else
7963 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7964 }
7965 else
7966 {
7967 printf (_(" [unsupported opcode]"));
7968 }
7969 putchar ('\n');
7970 }
7971}
7972
7973static bfd_vma
a734115a 7974arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7975{
7976 bfd_vma offset;
7977
7978 offset = word & 0x7fffffff;
7979 if (offset & 0x40000000)
7980 offset |= ~ (bfd_vma) 0x7fffffff;
7981
7982 if (elf_header.e_machine == EM_TI_C6000)
7983 offset <<= 1;
7984
7985 return offset + where;
7986}
7987
7988static void
1b31d05e
NC		 7989decode_arm_unwind (struct arm_unw_aux_info * aux,
7990 unsigned int word,
7991 unsigned int remaining,
7992 bfd_vma data_offset,
7993 Elf_Internal_Shdr * data_sec,
7994 struct arm_section * data_arm_sec)
fa197c1c
PB		 7995{
7996 int per_index;
7997 unsigned int more_words = 0;
37e14bc3 7998 struct absaddr addr;
1b31d05e 7999 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8000
8001 if (remaining == 0)
8002 {
1b31d05e
NC		 8003 /* Fetch the first word.
8004 Note - when decoding an object file the address extracted
8005 here will always be 0. So we also pass in the sym_name
8006 parameter so that we can find the symbol associated with
8007 the personality routine. */
8008 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8009 & word, & addr, & sym_name))
fa197c1c 8010 return;
1b31d05e 8011
fa197c1c
PB		 8012 remaining = 4;
8013 }
8014
8015 if ((word & 0x80000000) == 0)
8016 {
8017 /* Expand prel31 for personality routine. */
8018 bfd_vma fn;
8019 const char *procname;
8020
a734115a 8021 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8022 printf (_(" Personality routine: "));
1b31d05e
NC		 8023 if (fn == 0
8024 && addr.section == SHN_UNDEF && addr.offset == 0
8025 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8026 {
8027 procname = aux->strtab + sym_name;
8028 print_vma (fn, PREFIX_HEX);
8029 if (procname)
8030 {
8031 fputs (" <", stdout);
8032 fputs (procname, stdout);
8033 fputc ('>', stdout);
8034 }
8035 }
8036 else
8037 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8038 fputc ('\n', stdout);
8039
8040 /* The GCC personality routines use the standard compact
8041 encoding, starting with one byte giving the number of
8042 words. */
8043 if (procname != NULL
8044 && (const_strneq (procname, "__gcc_personality_v0")
8045 || const_strneq (procname, "__gxx_personality_v0")
8046 || const_strneq (procname, "__gcj_personality_v0")
8047 || const_strneq (procname, "__gnu_objc_personality_v0")))
8048 {
8049 remaining = 0;
8050 more_words = 1;
8051 ADVANCE;
8052 if (!remaining)
8053 {
8054 printf (_(" [Truncated data]\n"));
8055 return;
8056 }
8057 more_words = word >> 24;
8058 word <<= 8;
8059 remaining--;
8060 per_index = -1;
8061 }
8062 else
8063 return;
8064 }
8065 else
8066 {
1b31d05e 8067 /* ARM EHABI Section 6.3:
0b4362b0 8068
1b31d05e 8069 An exception-handling table entry for the compact model looks like:
0b4362b0 8070
1b31d05e
NC		 8071 31 30-28 27-24 23-0
8072 -- ----- ----- ----
8073 1 0 index Data for personalityRoutine[index] */
8074
8075 if (elf_header.e_machine == EM_ARM
8076 && (word & 0x70000000))
83c257ca 8077 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8078
fa197c1c 8079 per_index = (word >> 24) & 0x7f;
1b31d05e 8080 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8081 if (per_index == 0)
8082 {
8083 more_words = 0;
8084 word <<= 8;
8085 remaining--;
8086 }
8087 else if (per_index < 3)
8088 {
8089 more_words = (word >> 16) & 0xff;
8090 word <<= 16;
8091 remaining -= 2;
8092 }
8093 }
8094
8095 switch (elf_header.e_machine)
8096 {
8097 case EM_ARM:
8098 if (per_index < 3)
8099 {
8100 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8101 data_offset, data_sec, data_arm_sec);
8102 }
8103 else
1b31d05e
NC		 8104 {
8105 warn (_("Unknown ARM compact model index encountered\n"));
8106 printf (_(" [reserved]\n"));
8107 }
fa197c1c
PB		 8108 break;
8109
8110 case EM_TI_C6000:
8111 if (per_index < 3)
8112 {
8113 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8114 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8115 }
8116 else if (per_index < 5)
8117 {
8118 if (((word >> 17) & 0x7f) == 0x7f)
8119 printf (_(" Restore stack from frame pointer\n"));
8120 else
8121 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8122 printf (_(" Registers restored: "));
8123 if (per_index == 4)
8124 printf (" (compact) ");
8125 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8126 putchar ('\n');
8127 printf (_(" Return register: %s\n"),
8128 tic6x_unwind_regnames[word & 0xf]);
8129 }
8130 else
1b31d05e 8131 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8132 break;
8133
8134 default:
74e1a04b 8135 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8136 elf_header.e_machine);
fa197c1c 8137 }
0b6ae522
DJ		 8138
8139 /* Decode the descriptors. Not implemented. */
8140}
8141
8142static void
8143dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8144{
8145 struct arm_section exidx_arm_sec, extab_arm_sec;
8146 unsigned int i, exidx_len;
948f632f 8147 unsigned long j, nfuns;
0b6ae522
DJ		 8148
8149 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8150 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8151 exidx_len = exidx_sec->sh_size / 8;
8152
948f632f
DA		 8153 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8154 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8155 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8156 aux->funtab[nfuns++] = aux->symtab[j];
8157 aux->nfuns = nfuns;
8158 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8159
0b6ae522
DJ		 8160 for (i = 0; i < exidx_len; i++)
8161 {
8162 unsigned int exidx_fn, exidx_entry;
8163 struct absaddr fn_addr, entry_addr;
8164 bfd_vma fn;
8165
8166 fputc ('\n', stdout);
8167
1b31d05e
NC		 8168 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8169 8 * i, & exidx_fn, & fn_addr, NULL)
8170 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8171 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8172 {
948f632f 8173 free (aux->funtab);
1b31d05e
NC		 8174 arm_free_section (& exidx_arm_sec);
8175 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8176 return;
8177 }
8178
83c257ca
NC		 8179 /* ARM EHABI, Section 5:
8180 An index table entry consists of 2 words.
8181 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8182 if (exidx_fn & 0x80000000)
8183 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8184
a734115a 8185 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8186
a734115a 8187 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8188 fputs (": ", stdout);
8189
8190 if (exidx_entry == 1)
8191 {
8192 print_vma (exidx_entry, PREFIX_HEX);
8193 fputs (" [cantunwind]\n", stdout);
8194 }
8195 else if (exidx_entry & 0x80000000)
8196 {
8197 print_vma (exidx_entry, PREFIX_HEX);
8198 fputc ('\n', stdout);
8199 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8200 }
8201 else
8202 {
8f73510c 8203 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8204 Elf_Internal_Shdr *table_sec;
8205
8206 fputs ("@", stdout);
a734115a 8207 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8208 print_vma (table, PREFIX_HEX);
8209 printf ("\n");
8210
8211 /* Locate the matching .ARM.extab. */
8212 if (entry_addr.section != SHN_UNDEF
8213 && entry_addr.section < elf_header.e_shnum)
8214 {
8215 table_sec = section_headers + entry_addr.section;
8216 table_offset = entry_addr.offset;
8217 }
8218 else
8219 {
8220 table_sec = find_section_by_address (table);
8221 if (table_sec != NULL)
8222 table_offset = table - table_sec->sh_addr;
8223 }
8224 if (table_sec == NULL)
8225 {
8226 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8227 (unsigned long) table);
8228 continue;
8229 }
8230 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8231 &extab_arm_sec);
8232 }
8233 }
8234
8235 printf ("\n");
8236
948f632f 8237 free (aux->funtab);
0b6ae522
DJ		 8238 arm_free_section (&exidx_arm_sec);
8239 arm_free_section (&extab_arm_sec);
8240}
8241
fa197c1c 8242/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8243
8244static void
0b6ae522
DJ		 8245arm_process_unwind (FILE *file)
8246{
8247 struct arm_unw_aux_info aux;
8248 Elf_Internal_Shdr *unwsec = NULL;
8249 Elf_Internal_Shdr *strsec;
8250 Elf_Internal_Shdr *sec;
8251 unsigned long i;
fa197c1c 8252 unsigned int sec_type;
0b6ae522 8253
fa197c1c
PB		 8254 switch (elf_header.e_machine)
8255 {
8256 case EM_ARM:
8257 sec_type = SHT_ARM_EXIDX;
8258 break;
8259
8260 case EM_TI_C6000:
8261 sec_type = SHT_C6000_UNWIND;
8262 break;
8263
0b4362b0 8264 default:
74e1a04b 8265 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8266 elf_header.e_machine);
8267 return;
fa197c1c
PB		 8268 }
8269
0b6ae522 8270 if (string_table == NULL)
1b31d05e
NC		 8271 return;
8272
8273 memset (& aux, 0, sizeof (aux));
8274 aux.file = file;
0b6ae522
DJ		 8275
8276 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8277 {
8278 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8279 {
ba5cdace 8280 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8281
8282 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8283
8284 /* PR binutils/17531 file: 011-12666-0.004. */
8285 if (aux.strtab != NULL)
8286 {
4082ef84 8287 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8288 free (aux.strtab);
8289 }
0b6ae522
DJ		 8290 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8291 1, strsec->sh_size, _("string table"));
8292 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8293 }
fa197c1c 8294 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8295 unwsec = sec;
8296 }
8297
1b31d05e 8298 if (unwsec == NULL)
0b6ae522 8299 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8300 else
8301 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8302 {
8303 if (sec->sh_type == sec_type)
8304 {
8305 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8306 printable_section_name (sec),
1b31d05e
NC		 8307 (unsigned long) sec->sh_offset,
8308 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8309
1b31d05e
NC		 8310 dump_arm_unwind (&aux, sec);
8311 }
8312 }
0b6ae522
DJ		 8313
8314 if (aux.symtab)
8315 free (aux.symtab);
8316 if (aux.strtab)
8317 free ((char *) aux.strtab);
0b6ae522
DJ		 8318}
8319
1b31d05e 8320static void
2cf0635d 8321process_unwind (FILE * file)
57346661 8322{
2cf0635d
NC		 8323 struct unwind_handler
8324 {
57346661 8325 int machtype;
1b31d05e 8326 void (* handler)(FILE *);
2cf0635d
NC		 8327 } handlers[] =
8328 {
0b6ae522 8329 { EM_ARM, arm_process_unwind },
57346661
AM		 8330 { EM_IA_64, ia64_process_unwind },
8331 { EM_PARISC, hppa_process_unwind },
fa197c1c 8332 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8333 { 0, 0 }
8334 };
8335 int i;
8336
8337 if (!do_unwind)
1b31d05e 8338 return;
57346661
AM		 8339
8340 for (i = 0; handlers[i].handler != NULL; i++)
8341 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8342 {
8343 handlers[i].handler (file);
8344 return;
8345 }
57346661 8346
1b31d05e
NC		 8347 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8348 get_machine_name (elf_header.e_machine));
57346661
AM		 8349}
8350
252b5132 8351static void
2cf0635d 8352dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8353{
8354 switch (entry->d_tag)
8355 {
8356 case DT_MIPS_FLAGS:
8357 if (entry->d_un.d_val == 0)
4b68bca3 8358 printf (_("NONE"));
252b5132
RH		 8359 else
8360 {
8361 static const char * opts[] =
8362 {
8363 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8364 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8365 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8366 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8367 "RLD_ORDER_SAFE"
8368 };
8369 unsigned int cnt;
8370 int first = 1;
2b692964 8371
60bca95a 8372 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8373 if (entry->d_un.d_val & (1 << cnt))
8374 {
8375 printf ("%s%s", first ? "" : " ", opts[cnt]);
8376 first = 0;
8377 }
252b5132
RH		 8378 }
8379 break;
103f02d3 8380
252b5132 8381 case DT_MIPS_IVERSION:
d79b3d50 8382 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8383 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8384 else
76ca31c0
NC		 8385 {
8386 char buf[40];
8387 sprintf_vma (buf, entry->d_un.d_ptr);
8388 /* Note: coded this way so that there is a single string for translation. */
8389 printf (_("<corrupt: %s>"), buf);
8390 }
252b5132 8391 break;
103f02d3 8392
252b5132
RH		 8393 case DT_MIPS_TIME_STAMP:
8394 {
8395 char timebuf[20];
2cf0635d 8396 struct tm * tmp;
91d6fa6a 8397 time_t atime = entry->d_un.d_val;
82b1b41b 8398
91d6fa6a 8399 tmp = gmtime (&atime);
82b1b41b
NC		 8400 /* PR 17531: file: 6accc532. */
8401 if (tmp == NULL)
8402 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8403 else
8404 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8405 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8406 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8407 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8408 }
8409 break;
103f02d3 8410
252b5132
RH		 8411 case DT_MIPS_RLD_VERSION:
8412 case DT_MIPS_LOCAL_GOTNO:
8413 case DT_MIPS_CONFLICTNO:
8414 case DT_MIPS_LIBLISTNO:
8415 case DT_MIPS_SYMTABNO:
8416 case DT_MIPS_UNREFEXTNO:
8417 case DT_MIPS_HIPAGENO:
8418 case DT_MIPS_DELTA_CLASS_NO:
8419 case DT_MIPS_DELTA_INSTANCE_NO:
8420 case DT_MIPS_DELTA_RELOC_NO:
8421 case DT_MIPS_DELTA_SYM_NO:
8422 case DT_MIPS_DELTA_CLASSSYM_NO:
8423 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8424 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8425 break;
103f02d3
UD		 8426
8427 default:
4b68bca3 8428 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8429 }
4b68bca3 8430 putchar ('\n');
103f02d3
UD		 8431}
8432
103f02d3 8433static void
2cf0635d 8434dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8435{
8436 switch (entry->d_tag)
8437 {
8438 case DT_HP_DLD_FLAGS:
8439 {
8440 static struct
8441 {
8442 long int bit;
2cf0635d 8443 const char * str;
5e220199
NC		 8444 }
8445 flags[] =
8446 {
8447 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8448 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8449 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8450 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8451 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8452 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8453 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8454 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8455 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8456 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8457 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8458 { DT_HP_GST, "HP_GST" },
8459 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8460 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8461 { DT_HP_NODELETE, "HP_NODELETE" },
8462 { DT_HP_GROUP, "HP_GROUP" },
8463 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8464 };
103f02d3 8465 int first = 1;
5e220199 8466 size_t cnt;
f7a99963 8467 bfd_vma val = entry->d_un.d_val;
103f02d3 8468
60bca95a 8469 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8470 if (val & flags[cnt].bit)
30800947
NC		 8471 {
8472 if (! first)
8473 putchar (' ');
8474 fputs (flags[cnt].str, stdout);
8475 first = 0;
8476 val ^= flags[cnt].bit;
8477 }
76da6bbe 8478
103f02d3 8479 if (val != 0 || first)
f7a99963
NC		 8480 {
8481 if (! first)
8482 putchar (' ');
8483 print_vma (val, HEX);
8484 }
103f02d3
UD		 8485 }
8486 break;
76da6bbe 8487
252b5132 8488 default:
f7a99963
NC		 8489 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8490 break;
252b5132 8491 }
35b1837e 8492 putchar ('\n');
252b5132
RH		 8493}
8494
28f997cf
TG		 8495#ifdef BFD64
8496
8497/* VMS vs Unix time offset and factor. */
8498
8499#define VMS_EPOCH_OFFSET 35067168000000000LL
8500#define VMS_GRANULARITY_FACTOR 10000000
8501
8502/* Display a VMS time in a human readable format. */
8503
8504static void
8505print_vms_time (bfd_int64_t vmstime)
8506{
8507 struct tm *tm;
8508 time_t unxtime;
8509
8510 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8511 tm = gmtime (&unxtime);
8512 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8513 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8514 tm->tm_hour, tm->tm_min, tm->tm_sec);
8515}
8516#endif /* BFD64 */
8517
ecc51f48 8518static void
2cf0635d 8519dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8520{
8521 switch (entry->d_tag)
8522 {
0de14b54 8523 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8524 /* First 3 slots reserved. */
ecc51f48
NC		 8525 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8526 printf (" -- ");
8527 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8528 break;
8529
28f997cf
TG		 8530 case DT_IA_64_VMS_LINKTIME:
8531#ifdef BFD64
8532 print_vms_time (entry->d_un.d_val);
8533#endif
8534 break;
8535
8536 case DT_IA_64_VMS_LNKFLAGS:
8537 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8538 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8539 printf (" CALL_DEBUG");
8540 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8541 printf (" NOP0BUFS");
8542 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8543 printf (" P0IMAGE");
8544 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8545 printf (" MKTHREADS");
8546 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8547 printf (" UPCALLS");
8548 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8549 printf (" IMGSTA");
8550 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8551 printf (" INITIALIZE");
8552 if (entry->d_un.d_val & VMS_LF_MAIN)
8553 printf (" MAIN");
8554 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8555 printf (" EXE_INIT");
8556 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8557 printf (" TBK_IN_IMG");
8558 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8559 printf (" DBG_IN_IMG");
8560 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8561 printf (" TBK_IN_DSF");
8562 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8563 printf (" DBG_IN_DSF");
8564 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8565 printf (" SIGNATURES");
8566 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8567 printf (" REL_SEG_OFF");
8568 break;
8569
bdf4d63a
JJ		 8570 default:
8571 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8572 break;
ecc51f48 8573 }
bdf4d63a 8574 putchar ('\n');
ecc51f48
NC		 8575}
8576
252b5132 8577static int
2cf0635d 8578get_32bit_dynamic_section (FILE * file)
252b5132 8579{
2cf0635d
NC		 8580 Elf32_External_Dyn * edyn;
8581 Elf32_External_Dyn * ext;
8582 Elf_Internal_Dyn * entry;
103f02d3 8583
3f5e193b
NC		 8584 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8585 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8586 if (!edyn)
8587 return 0;
103f02d3 8588
071436c6
NC		 8589 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8590 might not have the luxury of section headers. Look for the DT_NULL
8591 terminator to determine the number of entries. */
ba2685cc 8592 for (ext = edyn, dynamic_nent = 0;
071436c6 8593 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8594 ext++)
8595 {
8596 dynamic_nent++;
8597 if (BYTE_GET (ext->d_tag) == DT_NULL)
8598 break;
8599 }
252b5132 8600
3f5e193b
NC		 8601 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8602 sizeof (* entry));
b2d38a17 8603 if (dynamic_section == NULL)
252b5132 8604 {
8b73c356
NC		 8605 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8606 (unsigned long) dynamic_nent);
9ea033b2
NC		 8607 free (edyn);
8608 return 0;
8609 }
252b5132 8610
fb514b26 8611 for (ext = edyn, entry = dynamic_section;
ba2685cc 8612 entry < dynamic_section + dynamic_nent;
fb514b26 8613 ext++, entry++)
9ea033b2 8614 {
fb514b26
AM		 8615 entry->d_tag = BYTE_GET (ext->d_tag);
8616 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8617 }
8618
9ea033b2
NC		 8619 free (edyn);
8620
8621 return 1;
8622}
8623
8624static int
2cf0635d 8625get_64bit_dynamic_section (FILE * file)
9ea033b2 8626{
2cf0635d
NC		 8627 Elf64_External_Dyn * edyn;
8628 Elf64_External_Dyn * ext;
8629 Elf_Internal_Dyn * entry;
103f02d3 8630
071436c6 8631 /* Read in the data. */
3f5e193b
NC		 8632 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8633 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8634 if (!edyn)
8635 return 0;
103f02d3 8636
071436c6
NC		 8637 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8638 might not have the luxury of section headers. Look for the DT_NULL
8639 terminator to determine the number of entries. */
ba2685cc 8640 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8641 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8642 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8643 ext++)
8644 {
8645 dynamic_nent++;
66543521 8646 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8647 break;
8648 }
252b5132 8649
3f5e193b
NC		 8650 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8651 sizeof (* entry));
b2d38a17 8652 if (dynamic_section == NULL)
252b5132 8653 {
8b73c356
NC		 8654 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8655 (unsigned long) dynamic_nent);
252b5132
RH		 8656 free (edyn);
8657 return 0;
8658 }
8659
071436c6 8660 /* Convert from external to internal formats. */
fb514b26 8661 for (ext = edyn, entry = dynamic_section;
ba2685cc 8662 entry < dynamic_section + dynamic_nent;
fb514b26 8663 ext++, entry++)
252b5132 8664 {
66543521
AM		 8665 entry->d_tag = BYTE_GET (ext->d_tag);
8666 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8667 }
8668
8669 free (edyn);
8670
9ea033b2
NC		 8671 return 1;
8672}
8673
e9e44622
JJ		 8674static void
8675print_dynamic_flags (bfd_vma flags)
d1133906 8676{
e9e44622 8677 int first = 1;
13ae64f3 8678
d1133906
NC		 8679 while (flags)
8680 {
8681 bfd_vma flag;
8682
8683 flag = flags & - flags;
8684 flags &= ~ flag;
8685
e9e44622
JJ		 8686 if (first)
8687 first = 0;
8688 else
8689 putc (' ', stdout);
13ae64f3 8690
d1133906
NC		 8691 switch (flag)
8692 {
e9e44622
JJ		 8693 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8694 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8695 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8696 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8697 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8698 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8699 }
8700 }
e9e44622 8701 puts ("");
d1133906
NC		 8702}
8703
b2d38a17
NC		 8704/* Parse and display the contents of the dynamic section. */
8705
9ea033b2 8706static int
2cf0635d 8707process_dynamic_section (FILE * file)
9ea033b2 8708{
2cf0635d 8709 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8710
8711 if (dynamic_size == 0)
8712 {
8713 if (do_dynamic)
b2d38a17 8714 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8715
8716 return 1;
8717 }
8718
8719 if (is_32bit_elf)
8720 {
b2d38a17 8721 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8722 return 0;
8723 }
b2d38a17 8724 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8725 return 0;
8726
252b5132
RH		 8727 /* Find the appropriate symbol table. */
8728 if (dynamic_symbols == NULL)
8729 {
86dba8ee
AM		 8730 for (entry = dynamic_section;
8731 entry < dynamic_section + dynamic_nent;
8732 ++entry)
252b5132 8733 {
c8286bd1 8734 Elf_Internal_Shdr section;
252b5132
RH		 8735
8736 if (entry->d_tag != DT_SYMTAB)
8737 continue;
8738
8739 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8740
8741 /* Since we do not know how big the symbol table is,
8742 we default to reading in the entire file (!) and
8743 processing that. This is overkill, I know, but it
e3c8793a 8744 should work. */
d93f0186 8745 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8746
fb52b2f4
NC		 8747 if (archive_file_offset != 0)
8748 section.sh_size = archive_file_size - section.sh_offset;
8749 else
8750 {
8751 if (fseek (file, 0, SEEK_END))
591a748a 8752 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8753
8754 section.sh_size = ftell (file) - section.sh_offset;
8755 }
252b5132 8756
9ea033b2 8757 if (is_32bit_elf)
9ad5cbcf 8758 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8759 else
9ad5cbcf 8760 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8761 section.sh_name = string_table_length;
252b5132 8762
ba5cdace 8763 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8764 if (num_dynamic_syms < 1)
252b5132
RH		 8765 {
8766 error (_("Unable to determine the number of symbols to load\n"));
8767 continue;
8768 }
252b5132
RH		 8769 }
8770 }
8771
8772 /* Similarly find a string table. */
8773 if (dynamic_strings == NULL)
8774 {
86dba8ee
AM		 8775 for (entry = dynamic_section;
8776 entry < dynamic_section + dynamic_nent;
8777 ++entry)
252b5132
RH		 8778 {
8779 unsigned long offset;
b34976b6 8780 long str_tab_len;
252b5132
RH		 8781
8782 if (entry->d_tag != DT_STRTAB)
8783 continue;
8784
8785 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8786
8787 /* Since we do not know how big the string table is,
8788 we default to reading in the entire file (!) and
8789 processing that. This is overkill, I know, but it
e3c8793a 8790 should work. */
252b5132 8791
d93f0186 8792 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8793
8794 if (archive_file_offset != 0)
8795 str_tab_len = archive_file_size - offset;
8796 else
8797 {
8798 if (fseek (file, 0, SEEK_END))
8799 error (_("Unable to seek to end of file\n"));
8800 str_tab_len = ftell (file) - offset;
8801 }
252b5132
RH		 8802
8803 if (str_tab_len < 1)
8804 {
8805 error
8806 (_("Unable to determine the length of the dynamic string table\n"));
8807 continue;
8808 }
8809
3f5e193b
NC		 8810 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8811 str_tab_len,
8812 _("dynamic string table"));
59245841 8813 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8814 break;
8815 }
8816 }
8817
8818 /* And find the syminfo section if available. */
8819 if (dynamic_syminfo == NULL)
8820 {
3e8bba36 8821 unsigned long syminsz = 0;
252b5132 8822
86dba8ee
AM		 8823 for (entry = dynamic_section;
8824 entry < dynamic_section + dynamic_nent;
8825 ++entry)
252b5132
RH		 8826 {
8827 if (entry->d_tag == DT_SYMINENT)
8828 {
8829 /* Note: these braces are necessary to avoid a syntax
8830 error from the SunOS4 C compiler. */
049b0c3a
NC		 8831 /* PR binutils/17531: A corrupt file can trigger this test.
8832 So do not use an assert, instead generate an error message. */
8833 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8834 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8835 (int) entry->d_un.d_val);
252b5132
RH		 8836 }
8837 else if (entry->d_tag == DT_SYMINSZ)
8838 syminsz = entry->d_un.d_val;
8839 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8840 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8841 syminsz);
252b5132
RH		 8842 }
8843
8844 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8845 {
2cf0635d
NC		 8846 Elf_External_Syminfo * extsyminfo;
8847 Elf_External_Syminfo * extsym;
8848 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8849
8850 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8851 extsyminfo = (Elf_External_Syminfo *)
8852 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8853 _("symbol information"));
a6e9f9df
AM		 8854 if (!extsyminfo)
8855 return 0;
252b5132 8856
3f5e193b 8857 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8858 if (dynamic_syminfo == NULL)
8859 {
8b73c356
NC		 8860 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8861 (unsigned long) syminsz);
252b5132
RH		 8862 return 0;
8863 }
8864
8865 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8866 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8867 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8868 ++syminfo, ++extsym)
252b5132 8869 {
86dba8ee
AM		 8870 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8871 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8872 }
8873
8874 free (extsyminfo);
8875 }
8876 }
8877
8878 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8879 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8880 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8881 if (do_dynamic)
8882 printf (_(" Tag Type Name/Value\n"));
8883
86dba8ee
AM		 8884 for (entry = dynamic_section;
8885 entry < dynamic_section + dynamic_nent;
8886 entry++)
252b5132
RH		 8887 {
8888 if (do_dynamic)
f7a99963 8889 {
2cf0635d 8890 const char * dtype;
e699b9ff 8891
f7a99963
NC		 8892 putchar (' ');
8893 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8894 dtype = get_dynamic_type (entry->d_tag);
8895 printf (" (%s)%*s", dtype,
8896 ((is_32bit_elf ? 27 : 19)
8897 - (int) strlen (dtype)),
f7a99963
NC		 8898 " ");
8899 }
252b5132
RH		 8900
8901 switch (entry->d_tag)
8902 {
d1133906
NC		 8903 case DT_FLAGS:
8904 if (do_dynamic)
e9e44622 8905 print_dynamic_flags (entry->d_un.d_val);
d1133906 8906 break;
76da6bbe 8907
252b5132
RH		 8908 case DT_AUXILIARY:
8909 case DT_FILTER:
019148e4
L		 8910 case DT_CONFIG:
8911 case DT_DEPAUDIT:
8912 case DT_AUDIT:
252b5132
RH		 8913 if (do_dynamic)
8914 {
019148e4 8915 switch (entry->d_tag)
b34976b6 8916 {
019148e4
L		 8917 case DT_AUXILIARY:
8918 printf (_("Auxiliary library"));
8919 break;
8920
8921 case DT_FILTER:
8922 printf (_("Filter library"));
8923 break;
8924
b34976b6 8925 case DT_CONFIG:
019148e4
L		 8926 printf (_("Configuration file"));
8927 break;
8928
8929 case DT_DEPAUDIT:
8930 printf (_("Dependency audit library"));
8931 break;
8932
8933 case DT_AUDIT:
8934 printf (_("Audit library"));
8935 break;
8936 }
252b5132 8937
d79b3d50
NC		 8938 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8939 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8940 else
f7a99963
NC		 8941 {
8942 printf (": ");
8943 print_vma (entry->d_un.d_val, PREFIX_HEX);
8944 putchar ('\n');
8945 }
252b5132
RH		 8946 }
8947 break;
8948
dcefbbbd 8949 case DT_FEATURE:
252b5132
RH		 8950 if (do_dynamic)
8951 {
8952 printf (_("Flags:"));
86f55779 8953
252b5132
RH		 8954 if (entry->d_un.d_val == 0)
8955 printf (_(" None\n"));
8956 else
8957 {
8958 unsigned long int val = entry->d_un.d_val;
86f55779 8959
252b5132
RH		 8960 if (val & DTF_1_PARINIT)
8961 {
8962 printf (" PARINIT");
8963 val ^= DTF_1_PARINIT;
8964 }
dcefbbbd
L		 8965 if (val & DTF_1_CONFEXP)
8966 {
8967 printf (" CONFEXP");
8968 val ^= DTF_1_CONFEXP;
8969 }
252b5132
RH		 8970 if (val != 0)
8971 printf (" %lx", val);
8972 puts ("");
8973 }
8974 }
8975 break;
8976
8977 case DT_POSFLAG_1:
8978 if (do_dynamic)
8979 {
8980 printf (_("Flags:"));
86f55779 8981
252b5132
RH		 8982 if (entry->d_un.d_val == 0)
8983 printf (_(" None\n"));
8984 else
8985 {
8986 unsigned long int val = entry->d_un.d_val;
86f55779 8987
252b5132
RH		 8988 if (val & DF_P1_LAZYLOAD)
8989 {
8990 printf (" LAZYLOAD");
8991 val ^= DF_P1_LAZYLOAD;
8992 }
8993 if (val & DF_P1_GROUPPERM)
8994 {
8995 printf (" GROUPPERM");
8996 val ^= DF_P1_GROUPPERM;
8997 }
8998 if (val != 0)
8999 printf (" %lx", val);
9000 puts ("");
9001 }
9002 }
9003 break;
9004
9005 case DT_FLAGS_1:
9006 if (do_dynamic)
9007 {
9008 printf (_("Flags:"));
9009 if (entry->d_un.d_val == 0)
9010 printf (_(" None\n"));
9011 else
9012 {
9013 unsigned long int val = entry->d_un.d_val;
86f55779 9014
252b5132
RH		 9015 if (val & DF_1_NOW)
9016 {
9017 printf (" NOW");
9018 val ^= DF_1_NOW;
9019 }
9020 if (val & DF_1_GLOBAL)
9021 {
9022 printf (" GLOBAL");
9023 val ^= DF_1_GLOBAL;
9024 }
9025 if (val & DF_1_GROUP)
9026 {
9027 printf (" GROUP");
9028 val ^= DF_1_GROUP;
9029 }
9030 if (val & DF_1_NODELETE)
9031 {
9032 printf (" NODELETE");
9033 val ^= DF_1_NODELETE;
9034 }
9035 if (val & DF_1_LOADFLTR)
9036 {
9037 printf (" LOADFLTR");
9038 val ^= DF_1_LOADFLTR;
9039 }
9040 if (val & DF_1_INITFIRST)
9041 {
9042 printf (" INITFIRST");
9043 val ^= DF_1_INITFIRST;
9044 }
9045 if (val & DF_1_NOOPEN)
9046 {
9047 printf (" NOOPEN");
9048 val ^= DF_1_NOOPEN;
9049 }
9050 if (val & DF_1_ORIGIN)
9051 {
9052 printf (" ORIGIN");
9053 val ^= DF_1_ORIGIN;
9054 }
9055 if (val & DF_1_DIRECT)
9056 {
9057 printf (" DIRECT");
9058 val ^= DF_1_DIRECT;
9059 }
9060 if (val & DF_1_TRANS)
9061 {
9062 printf (" TRANS");
9063 val ^= DF_1_TRANS;
9064 }
9065 if (val & DF_1_INTERPOSE)
9066 {
9067 printf (" INTERPOSE");
9068 val ^= DF_1_INTERPOSE;
9069 }
f7db6139 9070 if (val & DF_1_NODEFLIB)
dcefbbbd 9071 {
f7db6139
L		 9072 printf (" NODEFLIB");
9073 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9074 }
9075 if (val & DF_1_NODUMP)
9076 {
9077 printf (" NODUMP");
9078 val ^= DF_1_NODUMP;
9079 }
34b60028 9080 if (val & DF_1_CONFALT)
dcefbbbd 9081 {
34b60028
L		 9082 printf (" CONFALT");
9083 val ^= DF_1_CONFALT;
9084 }
9085 if (val & DF_1_ENDFILTEE)
9086 {
9087 printf (" ENDFILTEE");
9088 val ^= DF_1_ENDFILTEE;
9089 }
9090 if (val & DF_1_DISPRELDNE)
9091 {
9092 printf (" DISPRELDNE");
9093 val ^= DF_1_DISPRELDNE;
9094 }
9095 if (val & DF_1_DISPRELPND)
9096 {
9097 printf (" DISPRELPND");
9098 val ^= DF_1_DISPRELPND;
9099 }
9100 if (val & DF_1_NODIRECT)
9101 {
9102 printf (" NODIRECT");
9103 val ^= DF_1_NODIRECT;
9104 }
9105 if (val & DF_1_IGNMULDEF)
9106 {
9107 printf (" IGNMULDEF");
9108 val ^= DF_1_IGNMULDEF;
9109 }
9110 if (val & DF_1_NOKSYMS)
9111 {
9112 printf (" NOKSYMS");
9113 val ^= DF_1_NOKSYMS;
9114 }
9115 if (val & DF_1_NOHDR)
9116 {
9117 printf (" NOHDR");
9118 val ^= DF_1_NOHDR;
9119 }
9120 if (val & DF_1_EDITED)
9121 {
9122 printf (" EDITED");
9123 val ^= DF_1_EDITED;
9124 }
9125 if (val & DF_1_NORELOC)
9126 {
9127 printf (" NORELOC");
9128 val ^= DF_1_NORELOC;
9129 }
9130 if (val & DF_1_SYMINTPOSE)
9131 {
9132 printf (" SYMINTPOSE");
9133 val ^= DF_1_SYMINTPOSE;
9134 }
9135 if (val & DF_1_GLOBAUDIT)
9136 {
9137 printf (" GLOBAUDIT");
9138 val ^= DF_1_GLOBAUDIT;
9139 }
9140 if (val & DF_1_SINGLETON)
9141 {
9142 printf (" SINGLETON");
9143 val ^= DF_1_SINGLETON;
dcefbbbd 9144 }
252b5132
RH		 9145 if (val != 0)
9146 printf (" %lx", val);
9147 puts ("");
9148 }
9149 }
9150 break;
9151
9152 case DT_PLTREL:
566b0d53 9153 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9154 if (do_dynamic)
9155 puts (get_dynamic_type (entry->d_un.d_val));
9156 break;
9157
9158 case DT_NULL :
9159 case DT_NEEDED :
9160 case DT_PLTGOT :
9161 case DT_HASH :
9162 case DT_STRTAB :
9163 case DT_SYMTAB :
9164 case DT_RELA :
9165 case DT_INIT :
9166 case DT_FINI :
9167 case DT_SONAME :
9168 case DT_RPATH :
9169 case DT_SYMBOLIC:
9170 case DT_REL :
9171 case DT_DEBUG :
9172 case DT_TEXTREL :
9173 case DT_JMPREL :
019148e4 9174 case DT_RUNPATH :
252b5132
RH		 9175 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9176
9177 if (do_dynamic)
9178 {
2cf0635d 9179 char * name;
252b5132 9180
d79b3d50
NC		 9181 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9182 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9183 else
d79b3d50 9184 name = NULL;
252b5132
RH		 9185
9186 if (name)
9187 {
9188 switch (entry->d_tag)
9189 {
9190 case DT_NEEDED:
9191 printf (_("Shared library: [%s]"), name);
9192
18bd398b 9193 if (streq (name, program_interpreter))
f7a99963 9194 printf (_(" program interpreter"));
252b5132
RH		 9195 break;
9196
9197 case DT_SONAME:
f7a99963 9198 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9199 break;
9200
9201 case DT_RPATH:
f7a99963 9202 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9203 break;
9204
019148e4
L		 9205 case DT_RUNPATH:
9206 printf (_("Library runpath: [%s]"), name);
9207 break;
9208
252b5132 9209 default:
f7a99963
NC		 9210 print_vma (entry->d_un.d_val, PREFIX_HEX);
9211 break;
252b5132
RH		 9212 }
9213 }
9214 else
f7a99963
NC		 9215 print_vma (entry->d_un.d_val, PREFIX_HEX);
9216
9217 putchar ('\n');
252b5132
RH		 9218 }
9219 break;
9220
9221 case DT_PLTRELSZ:
9222 case DT_RELASZ :
9223 case DT_STRSZ :
9224 case DT_RELSZ :
9225 case DT_RELAENT :
9226 case DT_SYMENT :
9227 case DT_RELENT :
566b0d53 9228 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9229 case DT_PLTPADSZ:
9230 case DT_MOVEENT :
9231 case DT_MOVESZ :
9232 case DT_INIT_ARRAYSZ:
9233 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9234 case DT_GNU_CONFLICTSZ:
9235 case DT_GNU_LIBLISTSZ:
252b5132 9236 if (do_dynamic)
f7a99963
NC		 9237 {
9238 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9239 printf (_(" (bytes)\n"));
f7a99963 9240 }
252b5132
RH		 9241 break;
9242
9243 case DT_VERDEFNUM:
9244 case DT_VERNEEDNUM:
9245 case DT_RELACOUNT:
9246 case DT_RELCOUNT:
9247 if (do_dynamic)
f7a99963
NC		 9248 {
9249 print_vma (entry->d_un.d_val, UNSIGNED);
9250 putchar ('\n');
9251 }
252b5132
RH		 9252 break;
9253
9254 case DT_SYMINSZ:
9255 case DT_SYMINENT:
9256 case DT_SYMINFO:
9257 case DT_USED:
9258 case DT_INIT_ARRAY:
9259 case DT_FINI_ARRAY:
9260 if (do_dynamic)
9261 {
d79b3d50
NC		 9262 if (entry->d_tag == DT_USED
9263 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9264 {
2cf0635d 9265 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9266
b34976b6 9267 if (*name)
252b5132
RH		 9268 {
9269 printf (_("Not needed object: [%s]\n"), name);
9270 break;
9271 }
9272 }
103f02d3 9273
f7a99963
NC		 9274 print_vma (entry->d_un.d_val, PREFIX_HEX);
9275 putchar ('\n');
252b5132
RH		 9276 }
9277 break;
9278
9279 case DT_BIND_NOW:
9280 /* The value of this entry is ignored. */
35b1837e
AM		 9281 if (do_dynamic)
9282 putchar ('\n');
252b5132 9283 break;
103f02d3 9284
047b2264
JJ		 9285 case DT_GNU_PRELINKED:
9286 if (do_dynamic)
9287 {
2cf0635d 9288 struct tm * tmp;
91d6fa6a 9289 time_t atime = entry->d_un.d_val;
047b2264 9290
91d6fa6a 9291 tmp = gmtime (&atime);
071436c6
NC		 9292 /* PR 17533 file: 041-1244816-0.004. */
9293 if (tmp == NULL)
5a2cbcf4
L		 9294 printf (_("<corrupt time val: %lx"),
9295 (unsigned long) atime);
071436c6
NC		 9296 else
9297 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9298 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9299 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9300
9301 }
9302 break;
9303
fdc90cb4
JJ		 9304 case DT_GNU_HASH:
9305 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9306 if (do_dynamic)
9307 {
9308 print_vma (entry->d_un.d_val, PREFIX_HEX);
9309 putchar ('\n');
9310 }
9311 break;
9312
252b5132
RH		 9313 default:
9314 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9315 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9316 entry->d_un.d_val;
9317
9318 if (do_dynamic)
9319 {
9320 switch (elf_header.e_machine)
9321 {
9322 case EM_MIPS:
4fe85591 9323 case EM_MIPS_RS3_LE:
b2d38a17 9324 dynamic_section_mips_val (entry);
252b5132 9325 break;
103f02d3 9326 case EM_PARISC:
b2d38a17 9327 dynamic_section_parisc_val (entry);
103f02d3 9328 break;
ecc51f48 9329 case EM_IA_64:
b2d38a17 9330 dynamic_section_ia64_val (entry);
ecc51f48 9331 break;
252b5132 9332 default:
f7a99963
NC		 9333 print_vma (entry->d_un.d_val, PREFIX_HEX);
9334 putchar ('\n');
252b5132
RH		 9335 }
9336 }
9337 break;
9338 }
9339 }
9340
9341 return 1;
9342}
9343
9344static char *
d3ba0551 9345get_ver_flags (unsigned int flags)
252b5132 9346{
b34976b6 9347 static char buff[32];
252b5132
RH		 9348
9349 buff[0] = 0;
9350
9351 if (flags == 0)
9352 return _("none");
9353
9354 if (flags & VER_FLG_BASE)
9355 strcat (buff, "BASE ");
9356
9357 if (flags & VER_FLG_WEAK)
9358 {
9359 if (flags & VER_FLG_BASE)
9360 strcat (buff, "| ");
9361
9362 strcat (buff, "WEAK ");
9363 }
9364
44ec90b9
RO		 9365 if (flags & VER_FLG_INFO)
9366 {
9367 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9368 strcat (buff, "| ");
9369
9370 strcat (buff, "INFO ");
9371 }
9372
9373 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9374 strcat (buff, _("| <unknown>"));
252b5132
RH		 9375
9376 return buff;
9377}
9378
9379/* Display the contents of the version sections. */
98fb390a 9380
252b5132 9381static int
2cf0635d 9382process_version_sections (FILE * file)
252b5132 9383{
2cf0635d 9384 Elf_Internal_Shdr * section;
b34976b6
AM		 9385 unsigned i;
9386 int found = 0;
252b5132
RH		 9387
9388 if (! do_version)
9389 return 1;
9390
9391 for (i = 0, section = section_headers;
9392 i < elf_header.e_shnum;
b34976b6 9393 i++, section++)
252b5132
RH		 9394 {
9395 switch (section->sh_type)
9396 {
9397 case SHT_GNU_verdef:
9398 {
2cf0635d 9399 Elf_External_Verdef * edefs;
b34976b6
AM		 9400 unsigned int idx;
9401 unsigned int cnt;
2cf0635d 9402 char * endbuf;
252b5132
RH		 9403
9404 found = 1;
9405
74e1a04b
NC		 9406 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9407 printable_section_name (section),
9408 section->sh_info);
252b5132
RH		 9409
9410 printf (_(" Addr: 0x"));
9411 printf_vma (section->sh_addr);
74e1a04b 9412 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9413 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9414 printable_section_name_from_index (section->sh_link));
252b5132 9415
3f5e193b
NC		 9416 edefs = (Elf_External_Verdef *)
9417 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9418 _("version definition section"));
a6e9f9df
AM		 9419 if (!edefs)
9420 break;
59245841 9421 endbuf = (char *) edefs + section->sh_size;
252b5132 9422
b34976b6 9423 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9424 {
2cf0635d
NC		 9425 char * vstart;
9426 Elf_External_Verdef * edef;
b34976b6 9427 Elf_Internal_Verdef ent;
2cf0635d 9428 Elf_External_Verdaux * eaux;
b34976b6
AM		 9429 Elf_Internal_Verdaux aux;
9430 int j;
9431 int isum;
103f02d3 9432
7e26601c
NC		 9433 /* Check for very large indicies. */
9434 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9435 break;
9436
252b5132 9437 vstart = ((char *) edefs) + idx;
54806181
AM		 9438 if (vstart + sizeof (*edef) > endbuf)
9439 break;
252b5132
RH		 9440
9441 edef = (Elf_External_Verdef *) vstart;
9442
9443 ent.vd_version = BYTE_GET (edef->vd_version);
9444 ent.vd_flags = BYTE_GET (edef->vd_flags);
9445 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9446 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9447 ent.vd_hash = BYTE_GET (edef->vd_hash);
9448 ent.vd_aux = BYTE_GET (edef->vd_aux);
9449 ent.vd_next = BYTE_GET (edef->vd_next);
9450
9451 printf (_(" %#06x: Rev: %d Flags: %s"),
9452 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9453
9454 printf (_(" Index: %d Cnt: %d "),
9455 ent.vd_ndx, ent.vd_cnt);
9456
dd24e3da 9457 /* Check for overflow. */
7e26601c 9458 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9459 break;
9460
252b5132
RH		 9461 vstart += ent.vd_aux;
9462
9463 eaux = (Elf_External_Verdaux *) vstart;
9464
9465 aux.vda_name = BYTE_GET (eaux->vda_name);
9466 aux.vda_next = BYTE_GET (eaux->vda_next);
9467
d79b3d50
NC		 9468 if (VALID_DYNAMIC_NAME (aux.vda_name))
9469 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9470 else
9471 printf (_("Name index: %ld\n"), aux.vda_name);
9472
9473 isum = idx + ent.vd_aux;
9474
b34976b6 9475 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9476 {
dd24e3da 9477 /* Check for overflow. */
7e26601c 9478 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9479 break;
9480
252b5132
RH		 9481 isum += aux.vda_next;
9482 vstart += aux.vda_next;
9483
9484 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9485 if (vstart + sizeof (*eaux) > endbuf)
9486 break;
252b5132
RH		 9487
9488 aux.vda_name = BYTE_GET (eaux->vda_name);
9489 aux.vda_next = BYTE_GET (eaux->vda_next);
9490
d79b3d50 9491 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9492 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9493 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9494 else
9495 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9496 isum, j, aux.vda_name);
9497 }
dd24e3da 9498
54806181
AM		 9499 if (j < ent.vd_cnt)
9500 printf (_(" Version def aux past end of section\n"));
252b5132 9501
5d921cbd
NC		 9502 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9503 if (idx + ent.vd_next <= idx)
9504 break;
9505
252b5132
RH		 9506 idx += ent.vd_next;
9507 }
dd24e3da 9508
54806181
AM		 9509 if (cnt < section->sh_info)
9510 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9511
9512 free (edefs);
9513 }
9514 break;
103f02d3 9515
252b5132
RH		 9516 case SHT_GNU_verneed:
9517 {
2cf0635d 9518 Elf_External_Verneed * eneed;
b34976b6
AM		 9519 unsigned int idx;
9520 unsigned int cnt;
2cf0635d 9521 char * endbuf;
252b5132
RH		 9522
9523 found = 1;
9524
72de5009 9525 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9526 printable_section_name (section), section->sh_info);
252b5132
RH		 9527
9528 printf (_(" Addr: 0x"));
9529 printf_vma (section->sh_addr);
72de5009 9530 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9531 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9532 printable_section_name_from_index (section->sh_link));
252b5132 9533
3f5e193b
NC		 9534 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9535 section->sh_offset, 1,
9536 section->sh_size,
9cf03b7e 9537 _("Version Needs section"));
a6e9f9df
AM		 9538 if (!eneed)
9539 break;
59245841 9540 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9541
9542 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9543 {
2cf0635d 9544 Elf_External_Verneed * entry;
b34976b6
AM		 9545 Elf_Internal_Verneed ent;
9546 int j;
9547 int isum;
2cf0635d 9548 char * vstart;
252b5132 9549
7e26601c 9550 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9551 break;
9552
252b5132 9553 vstart = ((char *) eneed) + idx;
54806181
AM		 9554 if (vstart + sizeof (*entry) > endbuf)
9555 break;
252b5132
RH		 9556
9557 entry = (Elf_External_Verneed *) vstart;
9558
9559 ent.vn_version = BYTE_GET (entry->vn_version);
9560 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9561 ent.vn_file = BYTE_GET (entry->vn_file);
9562 ent.vn_aux = BYTE_GET (entry->vn_aux);
9563 ent.vn_next = BYTE_GET (entry->vn_next);
9564
9565 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9566
d79b3d50
NC		 9567 if (VALID_DYNAMIC_NAME (ent.vn_file))
9568 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9569 else
9570 printf (_(" File: %lx"), ent.vn_file);
9571
9572 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9573
dd24e3da 9574 /* Check for overflow. */
7e26601c 9575 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9576 break;
252b5132
RH		 9577 vstart += ent.vn_aux;
9578
9579 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9580 {
2cf0635d 9581 Elf_External_Vernaux * eaux;
b34976b6 9582 Elf_Internal_Vernaux aux;
252b5132 9583
54806181
AM		 9584 if (vstart + sizeof (*eaux) > endbuf)
9585 break;
252b5132
RH		 9586 eaux = (Elf_External_Vernaux *) vstart;
9587
9588 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9589 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9590 aux.vna_other = BYTE_GET (eaux->vna_other);
9591 aux.vna_name = BYTE_GET (eaux->vna_name);
9592 aux.vna_next = BYTE_GET (eaux->vna_next);
9593
d79b3d50 9594 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9595 printf (_(" %#06x: Name: %s"),
d79b3d50 9596 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9597 else
ecc2063b 9598 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9599 isum, aux.vna_name);
9600
9601 printf (_(" Flags: %s Version: %d\n"),
9602 get_ver_flags (aux.vna_flags), aux.vna_other);
9603
dd24e3da 9604 /* Check for overflow. */
53774b7e
NC		 9605 if (aux.vna_next > (size_t) (endbuf - vstart)
9606 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9607 {
9608 warn (_("Invalid vna_next field of %lx\n"),
9609 aux.vna_next);
9610 j = ent.vn_cnt;
9611 break;
9612 }
252b5132
RH		 9613 isum += aux.vna_next;
9614 vstart += aux.vna_next;
9615 }
9cf03b7e 9616
54806181 9617 if (j < ent.vn_cnt)
9cf03b7e 9618 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9619
bcf83b2a 9620 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9621 {
9622 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9623 cnt = section->sh_info;
9624 break;
9625 }
252b5132
RH		 9626 idx += ent.vn_next;
9627 }
9cf03b7e 9628
54806181 9629 if (cnt < section->sh_info)
9cf03b7e 9630 warn (_("Missing Version Needs information\n"));
103f02d3 9631
252b5132
RH		 9632 free (eneed);
9633 }
9634 break;
9635
9636 case SHT_GNU_versym:
9637 {
2cf0635d 9638 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9639 size_t total;
9640 unsigned int cnt;
2cf0635d
NC		 9641 unsigned char * edata;
9642 unsigned short * data;
9643 char * strtab;
9644 Elf_Internal_Sym * symbols;
9645 Elf_Internal_Shdr * string_sec;
ba5cdace 9646 unsigned long num_syms;
d3ba0551 9647 long off;
252b5132 9648
4fbb74a6 9649 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9650 break;
9651
4fbb74a6 9652 link_section = section_headers + section->sh_link;
08d8fa11 9653 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9654
4fbb74a6 9655 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9656 break;
9657
252b5132
RH		 9658 found = 1;
9659
ba5cdace 9660 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9661 if (symbols == NULL)
9662 break;
252b5132 9663
4fbb74a6 9664 string_sec = section_headers + link_section->sh_link;
252b5132 9665
3f5e193b
NC		 9666 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9667 string_sec->sh_size,
9668 _("version string table"));
a6e9f9df 9669 if (!strtab)
0429c154
MS		 9670 {
9671 free (symbols);
9672 break;
9673 }
252b5132 9674
8b73c356
NC		 9675 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9676 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9677
9678 printf (_(" Addr: "));
9679 printf_vma (section->sh_addr);
72de5009 9680 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9681 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9682 printable_section_name (link_section));
252b5132 9683
d3ba0551
AM		 9684 off = offset_from_vma (file,
9685 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9686 total * sizeof (short));
3f5e193b
NC		 9687 edata = (unsigned char *) get_data (NULL, file, off, total,
9688 sizeof (short),
9689 _("version symbol data"));
a6e9f9df
AM		 9690 if (!edata)
9691 {
9692 free (strtab);
0429c154 9693 free (symbols);
a6e9f9df
AM		 9694 break;
9695 }
252b5132 9696
3f5e193b 9697 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9698
9699 for (cnt = total; cnt --;)
b34976b6
AM		 9700 data[cnt] = byte_get (edata + cnt * sizeof (short),
9701 sizeof (short));
252b5132
RH		 9702
9703 free (edata);
9704
9705 for (cnt = 0; cnt < total; cnt += 4)
9706 {
9707 int j, nn;
00d93f34 9708 int check_def, check_need;
2cf0635d 9709 char * name;
252b5132
RH		 9710
9711 printf (" %03x:", cnt);
9712
9713 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9714 switch (data[cnt + j])
252b5132
RH		 9715 {
9716 case 0:
9717 fputs (_(" 0 (*local*) "), stdout);
9718 break;
9719
9720 case 1:
9721 fputs (_(" 1 (*global*) "), stdout);
9722 break;
9723
9724 default:
c244d050
NC		 9725 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9726 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9727
dd24e3da 9728 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9729 array, break to avoid an out-of-bounds read. */
9730 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9731 {
9732 warn (_("invalid index into symbol array\n"));
9733 break;
9734 }
9735
00d93f34
JJ		 9736 check_def = 1;
9737 check_need = 1;
4fbb74a6
AM		 9738 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9739 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9740 != SHT_NOBITS)
252b5132 9741 {
b34976b6 9742 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9743 check_def = 0;
9744 else
9745 check_need = 0;
252b5132 9746 }
00d93f34
JJ		 9747
9748 if (check_need
b34976b6 9749 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9750 {
b34976b6
AM		 9751 Elf_Internal_Verneed ivn;
9752 unsigned long offset;
252b5132 9753
d93f0186
NC		 9754 offset = offset_from_vma
9755 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9756 sizeof (Elf_External_Verneed));
252b5132 9757
b34976b6 9758 do
252b5132 9759 {
b34976b6
AM		 9760 Elf_Internal_Vernaux ivna;
9761 Elf_External_Verneed evn;
9762 Elf_External_Vernaux evna;
9763 unsigned long a_off;
252b5132 9764
59245841
NC		 9765 if (get_data (&evn, file, offset, sizeof (evn), 1,
9766 _("version need")) == NULL)
9767 break;
0b4362b0 9768
252b5132
RH		 9769 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9770 ivn.vn_next = BYTE_GET (evn.vn_next);
9771
9772 a_off = offset + ivn.vn_aux;
9773
9774 do
9775 {
59245841
NC		 9776 if (get_data (&evna, file, a_off, sizeof (evna),
9777 1, _("version need aux (2)")) == NULL)
9778 {
9779 ivna.vna_next = 0;
9780 ivna.vna_other = 0;
9781 }
9782 else
9783 {
9784 ivna.vna_next = BYTE_GET (evna.vna_next);
9785 ivna.vna_other = BYTE_GET (evna.vna_other);
9786 }
252b5132
RH		 9787
9788 a_off += ivna.vna_next;
9789 }
b34976b6 9790 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9791 && ivna.vna_next != 0);
9792
b34976b6 9793 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9794 {
9795 ivna.vna_name = BYTE_GET (evna.vna_name);
9796
54806181
AM		 9797 if (ivna.vna_name >= string_sec->sh_size)
9798 name = _("*invalid*");
9799 else
9800 name = strtab + ivna.vna_name;
252b5132 9801 nn += printf ("(%s%-*s",
16062207
ILT		 9802 name,
9803 12 - (int) strlen (name),
252b5132 9804 ")");
00d93f34 9805 check_def = 0;
252b5132
RH		 9806 break;
9807 }
9808
9809 offset += ivn.vn_next;
9810 }
9811 while (ivn.vn_next);
9812 }
00d93f34 9813
b34976b6
AM		 9814 if (check_def && data[cnt + j] != 0x8001
9815 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9816 {
b34976b6
AM		 9817 Elf_Internal_Verdef ivd;
9818 Elf_External_Verdef evd;
9819 unsigned long offset;
252b5132 9820
d93f0186
NC		 9821 offset = offset_from_vma
9822 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9823 sizeof evd);
252b5132
RH		 9824
9825 do
9826 {
59245841
NC		 9827 if (get_data (&evd, file, offset, sizeof (evd), 1,
9828 _("version def")) == NULL)
9829 {
9830 ivd.vd_next = 0;
948f632f 9831 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9832 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9833 break;
59245841
NC		 9834 }
9835 else
9836 {
9837 ivd.vd_next = BYTE_GET (evd.vd_next);
9838 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9839 }
252b5132
RH		 9840
9841 offset += ivd.vd_next;
9842 }
c244d050 9843 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9844 && ivd.vd_next != 0);
9845
c244d050 9846 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9847 {
b34976b6
AM		 9848 Elf_External_Verdaux evda;
9849 Elf_Internal_Verdaux ivda;
252b5132
RH		 9850
9851 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9852
59245841
NC		 9853 if (get_data (&evda, file,
9854 offset - ivd.vd_next + ivd.vd_aux,
9855 sizeof (evda), 1,
9856 _("version def aux")) == NULL)
9857 break;
252b5132
RH		 9858
9859 ivda.vda_name = BYTE_GET (evda.vda_name);
9860
54806181
AM		 9861 if (ivda.vda_name >= string_sec->sh_size)
9862 name = _("*invalid*");
9863 else
9864 name = strtab + ivda.vda_name;
252b5132 9865 nn += printf ("(%s%-*s",
16062207
ILT		 9866 name,
9867 12 - (int) strlen (name),
252b5132
RH		 9868 ")");
9869 }
9870 }
9871
9872 if (nn < 18)
9873 printf ("%*c", 18 - nn, ' ');
9874 }
9875
9876 putchar ('\n');
9877 }
9878
9879 free (data);
9880 free (strtab);
9881 free (symbols);
9882 }
9883 break;
103f02d3 9884
252b5132
RH		 9885 default:
9886 break;
9887 }
9888 }
9889
9890 if (! found)
9891 printf (_("\nNo version information found in this file.\n"));
9892
9893 return 1;
9894}
9895
d1133906 9896static const char *
d3ba0551 9897get_symbol_binding (unsigned int binding)
252b5132 9898{
b34976b6 9899 static char buff[32];
252b5132
RH		 9900
9901 switch (binding)
9902 {
b34976b6
AM		 9903 case STB_LOCAL: return "LOCAL";
9904 case STB_GLOBAL: return "GLOBAL";
9905 case STB_WEAK: return "WEAK";
252b5132
RH		 9906 default:
9907 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9908 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9909 binding);
252b5132 9910 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9911 {
9912 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9913 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9914 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9915 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9916 return "UNIQUE";
9917 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9918 }
252b5132 9919 else
e9e44622 9920 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9921 return buff;
9922 }
9923}
9924
d1133906 9925static const char *
d3ba0551 9926get_symbol_type (unsigned int type)
252b5132 9927{
b34976b6 9928 static char buff[32];
252b5132
RH		 9929
9930 switch (type)
9931 {
b34976b6
AM		 9932 case STT_NOTYPE: return "NOTYPE";
9933 case STT_OBJECT: return "OBJECT";
9934 case STT_FUNC: return "FUNC";
9935 case STT_SECTION: return "SECTION";
9936 case STT_FILE: return "FILE";
9937 case STT_COMMON: return "COMMON";
9938 case STT_TLS: return "TLS";
15ab5209
DB		 9939 case STT_RELC: return "RELC";
9940 case STT_SRELC: return "SRELC";
252b5132
RH		 9941 default:
9942 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9943 {
3510a7b8
NC		 9944 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9945 return "THUMB_FUNC";
103f02d3 9946
351b4b40 9947 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9948 return "REGISTER";
9949
9950 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9951 return "PARISC_MILLI";
9952
e9e44622 9953 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9954 }
252b5132 9955 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9956 {
9957 if (elf_header.e_machine == EM_PARISC)
9958 {
9959 if (type == STT_HP_OPAQUE)
9960 return "HP_OPAQUE";
9961 if (type == STT_HP_STUB)
9962 return "HP_STUB";
9963 }
9964
d8045f23 9965 if (type == STT_GNU_IFUNC
9c55345c 9966 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9967 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9968 /* GNU is still using the default value 0. */
d8045f23
NC		 9969 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9970 return "IFUNC";
9971
e9e44622 9972 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9973 }
252b5132 9974 else
e9e44622 9975 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9976 return buff;
9977 }
9978}
9979
d1133906 9980static const char *
d3ba0551 9981get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9982{
9983 switch (visibility)
9984 {
b34976b6
AM		 9985 case STV_DEFAULT: return "DEFAULT";
9986 case STV_INTERNAL: return "INTERNAL";
9987 case STV_HIDDEN: return "HIDDEN";
d1133906 9988 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 9989 default:
9990 error (_("Unrecognized visibility value: %u"), visibility);
9991 return _("<unknown>");
d1133906
NC		 9992 }
9993}
9994
5e2b0d47
NC		 9995static const char *
9996get_mips_symbol_other (unsigned int other)
9997{
9998 switch (other)
9999 {
df58fc94
RS		 10000 case STO_OPTIONAL:
10001 return "OPTIONAL";
10002 case STO_MIPS_PLT:
10003 return "MIPS PLT";
10004 case STO_MIPS_PIC:
10005 return "MIPS PIC";
10006 case STO_MICROMIPS:
10007 return "MICROMIPS";
10008 case STO_MICROMIPS | STO_MIPS_PIC:
10009 return "MICROMIPS, MIPS PIC";
10010 case STO_MIPS16:
10011 return "MIPS16";
10012 default:
10013 return NULL;
5e2b0d47
NC		 10014 }
10015}
10016
28f997cf
TG		 10017static const char *
10018get_ia64_symbol_other (unsigned int other)
10019{
10020 if (is_ia64_vms ())
10021 {
10022 static char res[32];
10023
10024 res[0] = 0;
10025
10026 /* Function types is for images and .STB files only. */
10027 switch (elf_header.e_type)
10028 {
10029 case ET_DYN:
10030 case ET_EXEC:
10031 switch (VMS_ST_FUNC_TYPE (other))
10032 {
10033 case VMS_SFT_CODE_ADDR:
10034 strcat (res, " CA");
10035 break;
10036 case VMS_SFT_SYMV_IDX:
10037 strcat (res, " VEC");
10038 break;
10039 case VMS_SFT_FD:
10040 strcat (res, " FD");
10041 break;
10042 case VMS_SFT_RESERVE:
10043 strcat (res, " RSV");
10044 break;
10045 default:
bee0ee85
NC		 10046 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10047 VMS_ST_FUNC_TYPE (other));
10048 strcat (res, " <unknown>");
10049 break;
28f997cf
TG		 10050 }
10051 break;
10052 default:
10053 break;
10054 }
10055 switch (VMS_ST_LINKAGE (other))
10056 {
10057 case VMS_STL_IGNORE:
10058 strcat (res, " IGN");
10059 break;
10060 case VMS_STL_RESERVE:
10061 strcat (res, " RSV");
10062 break;
10063 case VMS_STL_STD:
10064 strcat (res, " STD");
10065 break;
10066 case VMS_STL_LNK:
10067 strcat (res, " LNK");
10068 break;
10069 default:
bee0ee85
NC		 10070 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10071 VMS_ST_LINKAGE (other));
10072 strcat (res, " <unknown>");
10073 break;
28f997cf
TG		 10074 }
10075
10076 if (res[0] != 0)
10077 return res + 1;
10078 else
10079 return res;
10080 }
10081 return NULL;
10082}
10083
6911b7dc
AM		 10084static const char *
10085get_ppc64_symbol_other (unsigned int other)
10086{
10087 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10088 {
10089 static char buf[32];
10090 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10091 PPC64_LOCAL_ENTRY_OFFSET (other));
10092 return buf;
10093 }
10094 return NULL;
10095}
10096
5e2b0d47
NC		 10097static const char *
10098get_symbol_other (unsigned int other)
10099{
10100 const char * result = NULL;
10101 static char buff [32];
10102
10103 if (other == 0)
10104 return "";
10105
10106 switch (elf_header.e_machine)
10107 {
10108 case EM_MIPS:
10109 result = get_mips_symbol_other (other);
28f997cf
TG		 10110 break;
10111 case EM_IA_64:
10112 result = get_ia64_symbol_other (other);
10113 break;
6911b7dc
AM		 10114 case EM_PPC64:
10115 result = get_ppc64_symbol_other (other);
10116 break;
5e2b0d47
NC		 10117 default:
10118 break;
10119 }
10120
10121 if (result)
10122 return result;
10123
10124 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10125 return buff;
10126}
10127
d1133906 10128static const char *
d3ba0551 10129get_symbol_index_type (unsigned int type)
252b5132 10130{
b34976b6 10131 static char buff[32];
5cf1065c 10132
252b5132
RH		 10133 switch (type)
10134 {
b34976b6
AM		 10135 case SHN_UNDEF: return "UND";
10136 case SHN_ABS: return "ABS";
10137 case SHN_COMMON: return "COM";
252b5132 10138 default:
9ce701e2
L		 10139 if (type == SHN_IA_64_ANSI_COMMON
10140 && elf_header.e_machine == EM_IA_64
10141 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10142 return "ANSI_COM";
8a9036a4 10143 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10144 || elf_header.e_machine == EM_L1OM
10145 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10146 && type == SHN_X86_64_LCOMMON)
10147 return "LARGE_COM";
ac145307
BS		 10148 else if ((type == SHN_MIPS_SCOMMON
10149 && elf_header.e_machine == EM_MIPS)
10150 || (type == SHN_TIC6X_SCOMMON
10151 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10152 return "SCOM";
10153 else if (type == SHN_MIPS_SUNDEFINED
10154 && elf_header.e_machine == EM_MIPS)
10155 return "SUND";
9ce701e2 10156 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10157 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10158 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10159 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10160 else if (type >= SHN_LORESERVE)
10161 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10162 else if (type >= elf_header.e_shnum)
e0a31db1 10163 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10164 else
232e7cb8 10165 sprintf (buff, "%3d", type);
5cf1065c 10166 break;
252b5132 10167 }
5cf1065c
NC		 10168
10169 return buff;
252b5132
RH		 10170}
10171
66543521 10172static bfd_vma *
57028622 10173get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10174{
2cf0635d
NC		 10175 unsigned char * e_data;
10176 bfd_vma * i_data;
252b5132 10177
57028622
NC		 10178 /* If the size_t type is smaller than the bfd_size_type, eg because
10179 you are building a 32-bit tool on a 64-bit host, then make sure
10180 that when (number) is cast to (size_t) no information is lost. */
10181 if (sizeof (size_t) < sizeof (bfd_size_type)
10182 && (bfd_size_type) ((size_t) number) != number)
10183 {
10184 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10185 (unsigned long long) number, ent_size);
10186 return NULL;
10187 }
948f632f 10188
3102e897
NC		 10189 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10190 attempting to allocate memory when the read is bound to fail. */
10191 if (ent_size * number > current_file_size)
10192 {
57028622
NC		 10193 error (_("Invalid number of dynamic entries: %llu\n"),
10194 (unsigned long long) number);
3102e897
NC		 10195 return NULL;
10196 }
10197
57028622 10198 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10199 if (e_data == NULL)
10200 {
57028622
NC		 10201 error (_("Out of memory reading %llu dynamic entries\n"),
10202 (unsigned long long) number);
252b5132
RH		 10203 return NULL;
10204 }
10205
57028622 10206 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10207 {
57028622
NC		 10208 error (_("Unable to read in %llu bytes of dynamic data\n"),
10209 (unsigned long long) (number * ent_size));
3102e897 10210 free (e_data);
252b5132
RH		 10211 return NULL;
10212 }
10213
57028622 10214 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10215 if (i_data == NULL)
10216 {
57028622
NC		 10217 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10218 (unsigned long long) number);
252b5132
RH		 10219 free (e_data);
10220 return NULL;
10221 }
10222
10223 while (number--)
66543521 10224 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10225
10226 free (e_data);
10227
10228 return i_data;
10229}
10230
6bd1a22c
L		 10231static void
10232print_dynamic_symbol (bfd_vma si, unsigned long hn)
10233{
2cf0635d 10234 Elf_Internal_Sym * psym;
6bd1a22c
L		 10235 int n;
10236
6bd1a22c
L		 10237 n = print_vma (si, DEC_5);
10238 if (n < 5)
0b4362b0 10239 fputs (&" "[n], stdout);
6bd1a22c 10240 printf (" %3lu: ", hn);
e0a31db1
NC		 10241
10242 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10243 {
3102e897
NC		 10244 printf (_("<No info available for dynamic symbol number %lu>\n"),
10245 (unsigned long) si);
e0a31db1
NC		 10246 return;
10247 }
10248
10249 psym = dynamic_symbols + si;
6bd1a22c
L		 10250 print_vma (psym->st_value, LONG_HEX);
10251 putchar (' ');
10252 print_vma (psym->st_size, DEC_5);
10253
f4be36b3
AM		 10254 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10255 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10256 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10257 /* Check to see if any other bits in the st_other field are set.
10258 Note - displaying this information disrupts the layout of the
10259 table being generated, but for the moment this case is very
10260 rare. */
10261 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10262 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10263 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10264 if (VALID_DYNAMIC_NAME (psym->st_name))
10265 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10266 else
2b692964 10267 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10268 putchar ('\n');
10269}
10270
bb4d2ac2
L		 10271static const char *
10272get_symbol_version_string (FILE *file, int is_dynsym,
10273 const char *strtab,
10274 unsigned long int strtab_size,
10275 unsigned int si, Elf_Internal_Sym *psym,
10276 enum versioned_symbol_info *sym_info,
10277 unsigned short *vna_other)
10278{
10279 const char *version_string = NULL;
10280
10281 if (is_dynsym
10282 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10283 {
10284 unsigned char data[2];
10285 unsigned short vers_data;
10286 unsigned long offset;
10287 int is_nobits;
10288 int check_def;
10289
10290 offset = offset_from_vma
10291 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10292 sizeof data + si * sizeof (vers_data));
10293
10294 if (get_data (&data, file, offset + si * sizeof (vers_data),
10295 sizeof (data), 1, _("version data")) == NULL)
10296 return NULL;
10297
10298 vers_data = byte_get (data, 2);
10299
53774b7e
NC		 10300 is_nobits = (section_headers != NULL
10301 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10302 && section_headers[psym->st_shndx].sh_type
10303 == SHT_NOBITS);
10304
10305 check_def = (psym->st_shndx != SHN_UNDEF);
10306
10307 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10308 {
10309 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10310 && (is_nobits || ! check_def))
10311 {
10312 Elf_External_Verneed evn;
10313 Elf_Internal_Verneed ivn;
10314 Elf_Internal_Vernaux ivna;
10315
10316 /* We must test both. */
10317 offset = offset_from_vma
10318 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10319 sizeof evn);
10320
10321 do
10322 {
10323 unsigned long vna_off;
10324
10325 if (get_data (&evn, file, offset, sizeof (evn), 1,
10326 _("version need")) == NULL)
10327 {
10328 ivna.vna_next = 0;
10329 ivna.vna_other = 0;
10330 ivna.vna_name = 0;
10331 break;
10332 }
10333
10334 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10335 ivn.vn_next = BYTE_GET (evn.vn_next);
10336
10337 vna_off = offset + ivn.vn_aux;
10338
10339 do
10340 {
10341 Elf_External_Vernaux evna;
10342
10343 if (get_data (&evna, file, vna_off,
10344 sizeof (evna), 1,
10345 _("version need aux (3)")) == NULL)
10346 {
10347 ivna.vna_next = 0;
10348 ivna.vna_other = 0;
10349 ivna.vna_name = 0;
10350 }
10351 else
10352 {
10353 ivna.vna_other = BYTE_GET (evna.vna_other);
10354 ivna.vna_next = BYTE_GET (evna.vna_next);
10355 ivna.vna_name = BYTE_GET (evna.vna_name);
10356 }
10357
10358 vna_off += ivna.vna_next;
10359 }
10360 while (ivna.vna_other != vers_data
10361 && ivna.vna_next != 0);
10362
10363 if (ivna.vna_other == vers_data)
10364 break;
10365
10366 offset += ivn.vn_next;
10367 }
10368 while (ivn.vn_next != 0);
10369
10370 if (ivna.vna_other == vers_data)
10371 {
10372 *sym_info = symbol_undefined;
10373 *vna_other = ivna.vna_other;
10374 version_string = (ivna.vna_name < strtab_size
10375 ? strtab + ivna.vna_name
10376 : _("<corrupt>"));
10377 check_def = 0;
10378 }
10379 else if (! is_nobits)
10380 error (_("bad dynamic symbol\n"));
10381 else
10382 check_def = 1;
10383 }
10384
10385 if (check_def)
10386 {
10387 if (vers_data != 0x8001
10388 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10389 {
10390 Elf_Internal_Verdef ivd;
10391 Elf_Internal_Verdaux ivda;
10392 Elf_External_Verdaux evda;
10393 unsigned long off;
10394
10395 off = offset_from_vma
10396 (file,
10397 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10398 sizeof (Elf_External_Verdef));
10399
10400 do
10401 {
10402 Elf_External_Verdef evd;
10403
10404 if (get_data (&evd, file, off, sizeof (evd),
10405 1, _("version def")) == NULL)
10406 {
10407 ivd.vd_ndx = 0;
10408 ivd.vd_aux = 0;
10409 ivd.vd_next = 0;
10410 }
10411 else
10412 {
10413 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10414 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10415 ivd.vd_next = BYTE_GET (evd.vd_next);
10416 }
10417
10418 off += ivd.vd_next;
10419 }
10420 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10421 && ivd.vd_next != 0);
10422
10423 off -= ivd.vd_next;
10424 off += ivd.vd_aux;
10425
10426 if (get_data (&evda, file, off, sizeof (evda),
10427 1, _("version def aux")) == NULL)
10428 return version_string;
10429
10430 ivda.vda_name = BYTE_GET (evda.vda_name);
10431
10432 if (psym->st_name != ivda.vda_name)
10433 {
10434 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10435 ? symbol_hidden : symbol_public);
10436 version_string = (ivda.vda_name < strtab_size
10437 ? strtab + ivda.vda_name
10438 : _("<corrupt>"));
10439 }
10440 }
10441 }
10442 }
10443 }
10444 return version_string;
10445}
10446
e3c8793a 10447/* Dump the symbol table. */
252b5132 10448static int
2cf0635d 10449process_symbol_table (FILE * file)
252b5132 10450{
2cf0635d 10451 Elf_Internal_Shdr * section;
8b73c356
NC		 10452 bfd_size_type nbuckets = 0;
10453 bfd_size_type nchains = 0;
2cf0635d
NC		 10454 bfd_vma * buckets = NULL;
10455 bfd_vma * chains = NULL;
fdc90cb4 10456 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10457 bfd_vma * gnubuckets = NULL;
10458 bfd_vma * gnuchains = NULL;
6bd1a22c 10459 bfd_vma gnusymidx = 0;
071436c6 10460 bfd_size_type ngnuchains = 0;
252b5132 10461
2c610e4b 10462 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10463 return 1;
10464
6bd1a22c
L		 10465 if (dynamic_info[DT_HASH]
10466 && (do_histogram
2c610e4b
L		 10467 || (do_using_dynamic
10468 && !do_dyn_syms
10469 && dynamic_strings != NULL)))
252b5132 10470 {
66543521
AM		 10471 unsigned char nb[8];
10472 unsigned char nc[8];
8b73c356 10473 unsigned int hash_ent_size = 4;
66543521
AM		 10474
10475 if ((elf_header.e_machine == EM_ALPHA
10476 || elf_header.e_machine == EM_S390
10477 || elf_header.e_machine == EM_S390_OLD)
10478 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10479 hash_ent_size = 8;
10480
fb52b2f4
NC		 10481 if (fseek (file,
10482 (archive_file_offset
10483 + offset_from_vma (file, dynamic_info[DT_HASH],
10484 sizeof nb + sizeof nc)),
d93f0186 10485 SEEK_SET))
252b5132 10486 {
591a748a 10487 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10488 goto no_hash;
252b5132
RH		 10489 }
10490
66543521 10491 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10492 {
10493 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10494 goto no_hash;
252b5132
RH		 10495 }
10496
66543521 10497 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10498 {
10499 error (_("Failed to read in number of chains\n"));
d3a44ec6 10500 goto no_hash;
252b5132
RH		 10501 }
10502
66543521
AM		 10503 nbuckets = byte_get (nb, hash_ent_size);
10504 nchains = byte_get (nc, hash_ent_size);
252b5132 10505
66543521
AM		 10506 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10507 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10508
d3a44ec6 10509 no_hash:
252b5132 10510 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10511 {
10512 if (do_using_dynamic)
10513 return 0;
10514 free (buckets);
10515 free (chains);
10516 buckets = NULL;
10517 chains = NULL;
10518 nbuckets = 0;
10519 nchains = 0;
10520 }
252b5132
RH		 10521 }
10522
6bd1a22c
L		 10523 if (dynamic_info_DT_GNU_HASH
10524 && (do_histogram
2c610e4b
L		 10525 || (do_using_dynamic
10526 && !do_dyn_syms
10527 && dynamic_strings != NULL)))
252b5132 10528 {
6bd1a22c
L		 10529 unsigned char nb[16];
10530 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10531 bfd_vma buckets_vma;
10532
10533 if (fseek (file,
10534 (archive_file_offset
10535 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10536 sizeof nb)),
10537 SEEK_SET))
10538 {
10539 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10540 goto no_gnu_hash;
6bd1a22c 10541 }
252b5132 10542
6bd1a22c
L		 10543 if (fread (nb, 16, 1, file) != 1)
10544 {
10545 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10546 goto no_gnu_hash;
6bd1a22c
L		 10547 }
10548
10549 ngnubuckets = byte_get (nb, 4);
10550 gnusymidx = byte_get (nb + 4, 4);
10551 bitmaskwords = byte_get (nb + 8, 4);
10552 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10553 if (is_32bit_elf)
6bd1a22c 10554 buckets_vma += bitmaskwords * 4;
f7a99963 10555 else
6bd1a22c 10556 buckets_vma += bitmaskwords * 8;
252b5132 10557
6bd1a22c
L		 10558 if (fseek (file,
10559 (archive_file_offset
10560 + offset_from_vma (file, buckets_vma, 4)),
10561 SEEK_SET))
252b5132 10562 {
6bd1a22c 10563 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10564 goto no_gnu_hash;
6bd1a22c
L		 10565 }
10566
10567 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10568
6bd1a22c 10569 if (gnubuckets == NULL)
d3a44ec6 10570 goto no_gnu_hash;
6bd1a22c
L		 10571
10572 for (i = 0; i < ngnubuckets; i++)
10573 if (gnubuckets[i] != 0)
10574 {
10575 if (gnubuckets[i] < gnusymidx)
10576 return 0;
10577
10578 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10579 maxchain = gnubuckets[i];
10580 }
10581
10582 if (maxchain == 0xffffffff)
d3a44ec6 10583 goto no_gnu_hash;
6bd1a22c
L		 10584
10585 maxchain -= gnusymidx;
10586
10587 if (fseek (file,
10588 (archive_file_offset
10589 + offset_from_vma (file, buckets_vma
10590 + 4 * (ngnubuckets + maxchain), 4)),
10591 SEEK_SET))
10592 {
10593 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10594 goto no_gnu_hash;
6bd1a22c
L		 10595 }
10596
10597 do
10598 {
10599 if (fread (nb, 4, 1, file) != 1)
252b5132 10600 {
6bd1a22c 10601 error (_("Failed to determine last chain length\n"));
d3a44ec6 10602 goto no_gnu_hash;
6bd1a22c 10603 }
252b5132 10604
6bd1a22c 10605 if (maxchain + 1 == 0)
d3a44ec6 10606 goto no_gnu_hash;
252b5132 10607
6bd1a22c
L		 10608 ++maxchain;
10609 }
10610 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10611
6bd1a22c
L		 10612 if (fseek (file,
10613 (archive_file_offset
10614 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10615 SEEK_SET))
10616 {
10617 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10618 goto no_gnu_hash;
6bd1a22c
L		 10619 }
10620
10621 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10622 ngnuchains = maxchain;
6bd1a22c 10623
d3a44ec6 10624 no_gnu_hash:
6bd1a22c 10625 if (gnuchains == NULL)
d3a44ec6
JJ		 10626 {
10627 free (gnubuckets);
d3a44ec6
JJ		 10628 gnubuckets = NULL;
10629 ngnubuckets = 0;
f64fddf1
NC		 10630 if (do_using_dynamic)
10631 return 0;
d3a44ec6 10632 }
6bd1a22c
L		 10633 }
10634
10635 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10636 && do_syms
10637 && do_using_dynamic
3102e897
NC		 10638 && dynamic_strings != NULL
10639 && dynamic_symbols != NULL)
6bd1a22c
L		 10640 {
10641 unsigned long hn;
10642
10643 if (dynamic_info[DT_HASH])
10644 {
10645 bfd_vma si;
10646
10647 printf (_("\nSymbol table for image:\n"));
10648 if (is_32bit_elf)
10649 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10650 else
10651 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10652
10653 for (hn = 0; hn < nbuckets; hn++)
10654 {
10655 if (! buckets[hn])
10656 continue;
10657
10658 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10659 print_dynamic_symbol (si, hn);
252b5132
RH		 10660 }
10661 }
6bd1a22c
L		 10662
10663 if (dynamic_info_DT_GNU_HASH)
10664 {
10665 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10666 if (is_32bit_elf)
10667 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10668 else
10669 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10670
10671 for (hn = 0; hn < ngnubuckets; ++hn)
10672 if (gnubuckets[hn] != 0)
10673 {
10674 bfd_vma si = gnubuckets[hn];
10675 bfd_vma off = si - gnusymidx;
10676
10677 do
10678 {
10679 print_dynamic_symbol (si, hn);
10680 si++;
10681 }
071436c6 10682 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10683 }
10684 }
252b5132 10685 }
8b73c356
NC		 10686 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10687 && section_headers != NULL)
252b5132 10688 {
b34976b6 10689 unsigned int i;
252b5132
RH		 10690
10691 for (i = 0, section = section_headers;
10692 i < elf_header.e_shnum;
10693 i++, section++)
10694 {
b34976b6 10695 unsigned int si;
2cf0635d 10696 char * strtab = NULL;
c256ffe7 10697 unsigned long int strtab_size = 0;
2cf0635d
NC		 10698 Elf_Internal_Sym * symtab;
10699 Elf_Internal_Sym * psym;
ba5cdace 10700 unsigned long num_syms;
252b5132 10701
2c610e4b
L		 10702 if ((section->sh_type != SHT_SYMTAB
10703 && section->sh_type != SHT_DYNSYM)
10704 || (!do_syms
10705 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10706 continue;
10707
dd24e3da
NC		 10708 if (section->sh_entsize == 0)
10709 {
10710 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10711 printable_section_name (section));
dd24e3da
NC		 10712 continue;
10713 }
10714
252b5132 10715 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10716 printable_section_name (section),
252b5132 10717 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10718
f7a99963 10719 if (is_32bit_elf)
ca47b30c 10720 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10721 else
ca47b30c 10722 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10723
ba5cdace 10724 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10725 if (symtab == NULL)
10726 continue;
10727
10728 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10729 {
10730 strtab = string_table;
10731 strtab_size = string_table_length;
10732 }
4fbb74a6 10733 else if (section->sh_link < elf_header.e_shnum)
252b5132 10734 {
2cf0635d 10735 Elf_Internal_Shdr * string_sec;
252b5132 10736
4fbb74a6 10737 string_sec = section_headers + section->sh_link;
252b5132 10738
3f5e193b
NC		 10739 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10740 1, string_sec->sh_size,
10741 _("string table"));
c256ffe7 10742 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10743 }
10744
ba5cdace 10745 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10746 {
bb4d2ac2
L		 10747 const char *version_string;
10748 enum versioned_symbol_info sym_info;
10749 unsigned short vna_other;
10750
5e220199 10751 printf ("%6d: ", si);
f7a99963
NC		 10752 print_vma (psym->st_value, LONG_HEX);
10753 putchar (' ');
10754 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10755 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10756 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10757 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10758 /* Check to see if any other bits in the st_other field are set.
10759 Note - displaying this information disrupts the layout of the
10760 table being generated, but for the moment this case is very rare. */
10761 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10762 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10763 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10764 print_symbol (25, psym->st_name < strtab_size
2b692964 10765 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10766
bb4d2ac2
L		 10767 version_string
10768 = get_symbol_version_string (file,
10769 section->sh_type == SHT_DYNSYM,
10770 strtab, strtab_size, si,
10771 psym, &sym_info, &vna_other);
10772 if (version_string)
252b5132 10773 {
bb4d2ac2
L		 10774 if (sym_info == symbol_undefined)
10775 printf ("@%s (%d)", version_string, vna_other);
10776 else
10777 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10778 version_string);
252b5132
RH		 10779 }
10780
10781 putchar ('\n');
10782 }
10783
10784 free (symtab);
10785 if (strtab != string_table)
10786 free (strtab);
10787 }
10788 }
10789 else if (do_syms)
10790 printf
10791 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10792
10793 if (do_histogram && buckets != NULL)
10794 {
2cf0635d
NC		 10795 unsigned long * lengths;
10796 unsigned long * counts;
66543521
AM		 10797 unsigned long hn;
10798 bfd_vma si;
10799 unsigned long maxlength = 0;
10800 unsigned long nzero_counts = 0;
10801 unsigned long nsyms = 0;
94d15024 10802 unsigned long chained;
252b5132 10803
66543521
AM		 10804 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10805 (unsigned long) nbuckets);
252b5132 10806
3f5e193b 10807 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10808 if (lengths == NULL)
10809 {
8b73c356 10810 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10811 return 0;
10812 }
8b73c356
NC		 10813
10814 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10815 for (hn = 0; hn < nbuckets; ++hn)
10816 {
94d15024
MF		 10817 for (si = buckets[hn], chained = 0;
10818 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10819 si = chains[si], ++chained)
252b5132 10820 {
b34976b6 10821 ++nsyms;
252b5132 10822 if (maxlength < ++lengths[hn])
b34976b6 10823 ++maxlength;
252b5132 10824 }
94d15024
MF		 10825
10826 /* PR binutils/17531: A corrupt binary could contain broken
10827 histogram data. Do not go into an infinite loop trying
10828 to process it. */
10829 if (chained > nchains)
10830 {
10831 error (_("histogram chain is corrupt\n"));
10832 break;
10833 }
252b5132
RH		 10834 }
10835
3f5e193b 10836 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10837 if (counts == NULL)
10838 {
b2e951ec 10839 free (lengths);
8b73c356 10840 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10841 return 0;
10842 }
10843
10844 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10845 ++counts[lengths[hn]];
252b5132 10846
103f02d3 10847 if (nbuckets > 0)
252b5132 10848 {
66543521
AM		 10849 unsigned long i;
10850 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10851 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10852 for (i = 1; i <= maxlength; ++i)
103f02d3 10853 {
66543521
AM		 10854 nzero_counts += counts[i] * i;
10855 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10856 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10857 (nzero_counts * 100.0) / nsyms);
10858 }
252b5132
RH		 10859 }
10860
10861 free (counts);
10862 free (lengths);
10863 }
10864
10865 if (buckets != NULL)
10866 {
10867 free (buckets);
10868 free (chains);
10869 }
10870
d3a44ec6 10871 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10872 {
2cf0635d
NC		 10873 unsigned long * lengths;
10874 unsigned long * counts;
fdc90cb4
JJ		 10875 unsigned long hn;
10876 unsigned long maxlength = 0;
10877 unsigned long nzero_counts = 0;
10878 unsigned long nsyms = 0;
fdc90cb4 10879
8b73c356
NC		 10880 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10881 (unsigned long) ngnubuckets);
10882
3f5e193b 10883 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10884 if (lengths == NULL)
10885 {
8b73c356 10886 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10887 return 0;
10888 }
10889
fdc90cb4
JJ		 10890 printf (_(" Length Number %% of total Coverage\n"));
10891
10892 for (hn = 0; hn < ngnubuckets; ++hn)
10893 if (gnubuckets[hn] != 0)
10894 {
10895 bfd_vma off, length = 1;
10896
6bd1a22c 10897 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10898 /* PR 17531 file: 010-77222-0.004. */
10899 off < ngnuchains && (gnuchains[off] & 1) == 0;
10900 ++off)
fdc90cb4
JJ		 10901 ++length;
10902 lengths[hn] = length;
10903 if (length > maxlength)
10904 maxlength = length;
10905 nsyms += length;
10906 }
10907
3f5e193b 10908 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10909 if (counts == NULL)
10910 {
b2e951ec 10911 free (lengths);
8b73c356 10912 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 10913 return 0;
10914 }
10915
10916 for (hn = 0; hn < ngnubuckets; ++hn)
10917 ++counts[lengths[hn]];
10918
10919 if (ngnubuckets > 0)
10920 {
10921 unsigned long j;
10922 printf (" 0 %-10lu (%5.1f%%)\n",
10923 counts[0], (counts[0] * 100.0) / ngnubuckets);
10924 for (j = 1; j <= maxlength; ++j)
10925 {
10926 nzero_counts += counts[j] * j;
10927 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10928 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10929 (nzero_counts * 100.0) / nsyms);
10930 }
10931 }
10932
10933 free (counts);
10934 free (lengths);
10935 free (gnubuckets);
10936 free (gnuchains);
10937 }
10938
252b5132
RH		 10939 return 1;
10940}
10941
10942static int
2cf0635d 10943process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10944{
b4c96d0d 10945 unsigned int i;
252b5132
RH		 10946
10947 if (dynamic_syminfo == NULL
10948 || !do_dynamic)
10949 /* No syminfo, this is ok. */
10950 return 1;
10951
10952 /* There better should be a dynamic symbol section. */
10953 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10954 return 0;
10955
10956 if (dynamic_addr)
10957 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10958 dynamic_syminfo_offset, dynamic_syminfo_nent);
10959
10960 printf (_(" Num: Name BoundTo Flags\n"));
10961 for (i = 0; i < dynamic_syminfo_nent; ++i)
10962 {
10963 unsigned short int flags = dynamic_syminfo[i].si_flags;
10964
31104126 10965 printf ("%4d: ", i);
4082ef84
NC		 10966 if (i >= num_dynamic_syms)
10967 printf (_("<corrupt index>"));
10968 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 10969 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10970 else
2b692964 10971 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10972 putchar (' ');
252b5132
RH		 10973
10974 switch (dynamic_syminfo[i].si_boundto)
10975 {
10976 case SYMINFO_BT_SELF:
10977 fputs ("SELF ", stdout);
10978 break;
10979 case SYMINFO_BT_PARENT:
10980 fputs ("PARENT ", stdout);
10981 break;
10982 default:
10983 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10984 && dynamic_syminfo[i].si_boundto < dynamic_nent
10985 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10986 {
d79b3d50 10987 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10988 putchar (' ' );
10989 }
252b5132
RH		 10990 else
10991 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10992 break;
10993 }
10994
10995 if (flags & SYMINFO_FLG_DIRECT)
10996 printf (" DIRECT");
10997 if (flags & SYMINFO_FLG_PASSTHRU)
10998 printf (" PASSTHRU");
10999 if (flags & SYMINFO_FLG_COPY)
11000 printf (" COPY");
11001 if (flags & SYMINFO_FLG_LAZYLOAD)
11002 printf (" LAZYLOAD");
11003
11004 puts ("");
11005 }
11006
11007 return 1;
11008}
11009
cf13d699
NC		 11010/* Check to see if the given reloc needs to be handled in a target specific
11011 manner. If so then process the reloc and return TRUE otherwise return
11012 FALSE. */
09c11c86 11013
cf13d699
NC		 11014static bfd_boolean
11015target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11016 unsigned char * start,
11017 Elf_Internal_Sym * symtab)
252b5132 11018{
cf13d699 11019 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11020
cf13d699 11021 switch (elf_header.e_machine)
252b5132 11022 {
13761a11
NC		 11023 case EM_MSP430:
11024 case EM_MSP430_OLD:
11025 {
11026 static Elf_Internal_Sym * saved_sym = NULL;
11027
11028 switch (reloc_type)
11029 {
11030 case 10: /* R_MSP430_SYM_DIFF */
11031 if (uses_msp430x_relocs ())
11032 break;
11033 case 21: /* R_MSP430X_SYM_DIFF */
11034 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11035 return TRUE;
11036
11037 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11038 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11039 goto handle_sym_diff;
0b4362b0 11040
13761a11
NC		 11041 case 5: /* R_MSP430_16_BYTE */
11042 case 9: /* R_MSP430_8 */
11043 if (uses_msp430x_relocs ())
11044 break;
11045 goto handle_sym_diff;
11046
11047 case 2: /* R_MSP430_ABS16 */
11048 case 15: /* R_MSP430X_ABS16 */
11049 if (! uses_msp430x_relocs ())
11050 break;
11051 goto handle_sym_diff;
0b4362b0 11052
13761a11
NC		 11053 handle_sym_diff:
11054 if (saved_sym != NULL)
11055 {
11056 bfd_vma value;
11057
11058 value = reloc->r_addend
11059 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11060 - saved_sym->st_value);
11061
11062 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11063
11064 saved_sym = NULL;
11065 return TRUE;
11066 }
11067 break;
11068
11069 default:
11070 if (saved_sym != NULL)
071436c6 11071 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11072 break;
11073 }
11074 break;
11075 }
11076
cf13d699
NC		 11077 case EM_MN10300:
11078 case EM_CYGNUS_MN10300:
11079 {
11080 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11081
cf13d699
NC		 11082 switch (reloc_type)
11083 {
11084 case 34: /* R_MN10300_ALIGN */
11085 return TRUE;
11086 case 33: /* R_MN10300_SYM_DIFF */
11087 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11088 return TRUE;
11089 case 1: /* R_MN10300_32 */
11090 case 2: /* R_MN10300_16 */
11091 if (saved_sym != NULL)
11092 {
11093 bfd_vma value;
252b5132 11094
cf13d699
NC		 11095 value = reloc->r_addend
11096 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11097 - saved_sym->st_value);
252b5132 11098
cf13d699 11099 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11100
cf13d699
NC		 11101 saved_sym = NULL;
11102 return TRUE;
11103 }
11104 break;
11105 default:
11106 if (saved_sym != NULL)
071436c6 11107 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11108 break;
11109 }
11110 break;
11111 }
252b5132
RH		 11112 }
11113
cf13d699 11114 return FALSE;
252b5132
RH		 11115}
11116
aca88567
NC		 11117/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11118 DWARF debug sections. This is a target specific test. Note - we do not
11119 go through the whole including-target-headers-multiple-times route, (as
11120 we have already done with <elf/h8.h>) because this would become very
11121 messy and even then this function would have to contain target specific
11122 information (the names of the relocs instead of their numeric values).
11123 FIXME: This is not the correct way to solve this problem. The proper way
11124 is to have target specific reloc sizing and typing functions created by
11125 the reloc-macros.h header, in the same way that it already creates the
11126 reloc naming functions. */
11127
11128static bfd_boolean
11129is_32bit_abs_reloc (unsigned int reloc_type)
11130{
11131 switch (elf_header.e_machine)
11132 {
41e92641
NC		 11133 case EM_386:
11134 case EM_486:
11135 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11136 case EM_68K:
11137 return reloc_type == 1; /* R_68K_32. */
11138 case EM_860:
11139 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11140 case EM_960:
11141 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11142 case EM_AARCH64:
11143 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11144 case EM_ALPHA:
137b6b5f 11145 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11146 case EM_ARC:
11147 return reloc_type == 1; /* R_ARC_32. */
11148 case EM_ARM:
11149 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11150 case EM_AVR_OLD:
aca88567
NC		 11151 case EM_AVR:
11152 return reloc_type == 1;
cfb8c092
NC		 11153 case EM_ADAPTEVA_EPIPHANY:
11154 return reloc_type == 3;
aca88567
NC		 11155 case EM_BLACKFIN:
11156 return reloc_type == 0x12; /* R_byte4_data. */
11157 case EM_CRIS:
11158 return reloc_type == 3; /* R_CRIS_32. */
11159 case EM_CR16:
11160 return reloc_type == 3; /* R_CR16_NUM32. */
11161 case EM_CRX:
11162 return reloc_type == 15; /* R_CRX_NUM32. */
11163 case EM_CYGNUS_FRV:
11164 return reloc_type == 1;
41e92641
NC		 11165 case EM_CYGNUS_D10V:
11166 case EM_D10V:
11167 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11168 case EM_CYGNUS_D30V:
11169 case EM_D30V:
11170 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11171 case EM_DLX:
11172 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11173 case EM_CYGNUS_FR30:
11174 case EM_FR30:
11175 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11176 case EM_FT32:
11177 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11178 case EM_H8S:
11179 case EM_H8_300:
11180 case EM_H8_300H:
11181 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 11182 case EM_IA_64:
11183 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 11184 case EM_IP2K_OLD:
11185 case EM_IP2K:
11186 return reloc_type == 2; /* R_IP2K_32. */
11187 case EM_IQ2000:
11188 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11189 case EM_LATTICEMICO32:
11190 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11191 case EM_M32C_OLD:
aca88567
NC		 11192 case EM_M32C:
11193 return reloc_type == 3; /* R_M32C_32. */
11194 case EM_M32R:
11195 return reloc_type == 34; /* R_M32R_32_RELA. */
11196 case EM_MCORE:
11197 return reloc_type == 1; /* R_MCORE_ADDR32. */
11198 case EM_CYGNUS_MEP:
11199 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11200 case EM_METAG:
11201 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11202 case EM_MICROBLAZE:
11203 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11204 case EM_MIPS:
11205 return reloc_type == 2; /* R_MIPS_32. */
11206 case EM_MMIX:
11207 return reloc_type == 4; /* R_MMIX_32. */
11208 case EM_CYGNUS_MN10200:
11209 case EM_MN10200:
11210 return reloc_type == 1; /* R_MN10200_32. */
11211 case EM_CYGNUS_MN10300:
11212 case EM_MN10300:
11213 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11214 case EM_MOXIE:
11215 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11216 case EM_MSP430_OLD:
11217 case EM_MSP430:
13761a11 11218 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11219 case EM_MT:
11220 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11221 case EM_NDS32:
11222 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11223 case EM_ALTERA_NIOS2:
36591ba1 11224 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11225 case EM_NIOS32:
11226 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11227 case EM_OR1K:
11228 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11229 case EM_PARISC:
5fda8eca
NC		 11230 return (reloc_type == 1 /* R_PARISC_DIR32. */
11231 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11232 case EM_PJ:
11233 case EM_PJ_OLD:
11234 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11235 case EM_PPC64:
11236 return reloc_type == 1; /* R_PPC64_ADDR32. */
11237 case EM_PPC:
11238 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11239 case EM_RL78:
11240 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11241 case EM_RX:
11242 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11243 case EM_S370:
11244 return reloc_type == 1; /* R_I370_ADDR31. */
11245 case EM_S390_OLD:
11246 case EM_S390:
11247 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11248 case EM_SCORE:
11249 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11250 case EM_SH:
11251 return reloc_type == 1; /* R_SH_DIR32. */
11252 case EM_SPARC32PLUS:
11253 case EM_SPARCV9:
11254 case EM_SPARC:
11255 return reloc_type == 3 /* R_SPARC_32. */
11256 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11257 case EM_SPU:
11258 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11259 case EM_TI_C6000:
11260 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11261 case EM_TILEGX:
11262 return reloc_type == 2; /* R_TILEGX_32. */
11263 case EM_TILEPRO:
11264 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11265 case EM_CYGNUS_V850:
11266 case EM_V850:
11267 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11268 case EM_V800:
11269 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11270 case EM_VAX:
11271 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11272 case EM_VISIUM:
11273 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11274 case EM_X86_64:
8a9036a4 11275 case EM_L1OM:
7a9068fe 11276 case EM_K1OM:
aca88567 11277 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11278 case EM_XC16X:
11279 case EM_C166:
11280 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11281 case EM_XGATE:
11282 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11283 case EM_XSTORMY16:
11284 return reloc_type == 1; /* R_XSTROMY16_32. */
11285 case EM_XTENSA_OLD:
11286 case EM_XTENSA:
11287 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11288 default:
bee0ee85
NC		 11289 {
11290 static unsigned int prev_warn = 0;
11291
11292 /* Avoid repeating the same warning multiple times. */
11293 if (prev_warn != elf_header.e_machine)
11294 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11295 elf_header.e_machine);
11296 prev_warn = elf_header.e_machine;
11297 return FALSE;
11298 }
aca88567
NC		 11299 }
11300}
11301
11302/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11303 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11304
11305static bfd_boolean
11306is_32bit_pcrel_reloc (unsigned int reloc_type)
11307{
11308 switch (elf_header.e_machine)
11309 {
41e92641
NC		 11310 case EM_386:
11311 case EM_486:
3e0873ac 11312 return reloc_type == 2; /* R_386_PC32. */
aca88567 11313 case EM_68K:
3e0873ac 11314 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11315 case EM_AARCH64:
11316 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11317 case EM_ADAPTEVA_EPIPHANY:
11318 return reloc_type == 6;
aca88567
NC		 11319 case EM_ALPHA:
11320 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11321 case EM_ARM:
3e0873ac 11322 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11323 case EM_MICROBLAZE:
11324 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11325 case EM_OR1K:
11326 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11327 case EM_PARISC:
85acf597 11328 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11329 case EM_PPC:
11330 return reloc_type == 26; /* R_PPC_REL32. */
11331 case EM_PPC64:
3e0873ac 11332 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11333 case EM_S390_OLD:
11334 case EM_S390:
3e0873ac 11335 return reloc_type == 5; /* R_390_PC32. */
aca88567 11336 case EM_SH:
3e0873ac 11337 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11338 case EM_SPARC32PLUS:
11339 case EM_SPARCV9:
11340 case EM_SPARC:
3e0873ac 11341 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11342 case EM_SPU:
11343 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11344 case EM_TILEGX:
11345 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11346 case EM_TILEPRO:
11347 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11348 case EM_VISIUM:
11349 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11350 case EM_X86_64:
8a9036a4 11351 case EM_L1OM:
7a9068fe 11352 case EM_K1OM:
3e0873ac 11353 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11354 case EM_XTENSA_OLD:
11355 case EM_XTENSA:
11356 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11357 default:
11358 /* Do not abort or issue an error message here. Not all targets use
11359 pc-relative 32-bit relocs in their DWARF debug information and we
11360 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11361 more helpful warning message will be generated by apply_relocations
11362 anyway, so just return. */
aca88567
NC		 11363 return FALSE;
11364 }
11365}
11366
11367/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11368 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11369
11370static bfd_boolean
11371is_64bit_abs_reloc (unsigned int reloc_type)
11372{
11373 switch (elf_header.e_machine)
11374 {
a06ea964
NC		 11375 case EM_AARCH64:
11376 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11377 case EM_ALPHA:
11378 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11379 case EM_IA_64:
11380 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11381 case EM_PARISC:
11382 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11383 case EM_PPC64:
11384 return reloc_type == 38; /* R_PPC64_ADDR64. */
11385 case EM_SPARC32PLUS:
11386 case EM_SPARCV9:
11387 case EM_SPARC:
11388 return reloc_type == 54; /* R_SPARC_UA64. */
11389 case EM_X86_64:
8a9036a4 11390 case EM_L1OM:
7a9068fe 11391 case EM_K1OM:
aca88567 11392 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11393 case EM_S390_OLD:
11394 case EM_S390:
aa137e4d
NC		 11395 return reloc_type == 22; /* R_S390_64. */
11396 case EM_TILEGX:
11397 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11398 case EM_MIPS:
aa137e4d 11399 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11400 default:
11401 return FALSE;
11402 }
11403}
11404
85acf597
RH		 11405/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11406 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11407
11408static bfd_boolean
11409is_64bit_pcrel_reloc (unsigned int reloc_type)
11410{
11411 switch (elf_header.e_machine)
11412 {
a06ea964
NC		 11413 case EM_AARCH64:
11414 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11415 case EM_ALPHA:
aa137e4d 11416 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11417 case EM_IA_64:
aa137e4d 11418 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11419 case EM_PARISC:
aa137e4d 11420 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11421 case EM_PPC64:
aa137e4d 11422 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11423 case EM_SPARC32PLUS:
11424 case EM_SPARCV9:
11425 case EM_SPARC:
aa137e4d 11426 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11427 case EM_X86_64:
8a9036a4 11428 case EM_L1OM:
7a9068fe 11429 case EM_K1OM:
aa137e4d 11430 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11431 case EM_S390_OLD:
11432 case EM_S390:
aa137e4d
NC		 11433 return reloc_type == 23; /* R_S390_PC64. */
11434 case EM_TILEGX:
11435 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11436 default:
11437 return FALSE;
11438 }
11439}
11440
4dc3c23d
AM		 11441/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11442 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11443
11444static bfd_boolean
11445is_24bit_abs_reloc (unsigned int reloc_type)
11446{
11447 switch (elf_header.e_machine)
11448 {
11449 case EM_CYGNUS_MN10200:
11450 case EM_MN10200:
11451 return reloc_type == 4; /* R_MN10200_24. */
11452 default:
11453 return FALSE;
11454 }
11455}
11456
aca88567
NC		 11457/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11458 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11459
11460static bfd_boolean
11461is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11462{
11463 switch (elf_header.e_machine)
11464 {
aca88567
NC		 11465 case EM_AVR_OLD:
11466 case EM_AVR:
11467 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11468 case EM_ADAPTEVA_EPIPHANY:
11469 return reloc_type == 5;
41e92641
NC		 11470 case EM_CYGNUS_D10V:
11471 case EM_D10V:
11472 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11473 case EM_H8S:
11474 case EM_H8_300:
11475 case EM_H8_300H:
aca88567
NC		 11476 return reloc_type == R_H8_DIR16;
11477 case EM_IP2K_OLD:
11478 case EM_IP2K:
11479 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11480 case EM_M32C_OLD:
f4236fe4
DD		 11481 case EM_M32C:
11482 return reloc_type == 1; /* R_M32C_16 */
aca88567 11483 case EM_MSP430:
13761a11
NC		 11484 if (uses_msp430x_relocs ())
11485 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11486 case EM_MSP430_OLD:
aca88567 11487 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11488 case EM_NDS32:
11489 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11490 case EM_ALTERA_NIOS2:
36591ba1 11491 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11492 case EM_NIOS32:
11493 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11494 case EM_OR1K:
11495 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11496 case EM_TI_C6000:
11497 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11498 case EM_XC16X:
11499 case EM_C166:
11500 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11501 case EM_CYGNUS_MN10200:
11502 case EM_MN10200:
11503 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11504 case EM_CYGNUS_MN10300:
11505 case EM_MN10300:
11506 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11507 case EM_VISIUM:
11508 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11509 case EM_XGATE:
11510 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11511 default:
aca88567 11512 return FALSE;
4b78141a
NC		 11513 }
11514}
11515
2a7b2e88
JK		 11516/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11517 relocation entries (possibly formerly used for SHT_GROUP sections). */
11518
11519static bfd_boolean
11520is_none_reloc (unsigned int reloc_type)
11521{
11522 switch (elf_header.e_machine)
11523 {
cb8f3167
NC		 11524 case EM_68K: /* R_68K_NONE. */
11525 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11526 case EM_SPARC32PLUS:
11527 case EM_SPARCV9:
cb8f3167
NC		 11528 case EM_SPARC: /* R_SPARC_NONE. */
11529 case EM_MIPS: /* R_MIPS_NONE. */
11530 case EM_PARISC: /* R_PARISC_NONE. */
11531 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11532 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11533 case EM_PPC: /* R_PPC_NONE. */
11534 case EM_PPC64: /* R_PPC64_NONE. */
11535 case EM_ARM: /* R_ARM_NONE. */
11536 case EM_IA_64: /* R_IA64_NONE. */
11537 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11538 case EM_S390_OLD:
cb8f3167
NC		 11539 case EM_S390: /* R_390_NONE. */
11540 case EM_CRIS: /* R_CRIS_NONE. */
11541 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11542 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11543 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11544 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11545 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11546 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11547 case EM_M32R: /* R_M32R_NONE. */
40b36596 11548 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11549 case EM_TILEGX: /* R_TILEGX_NONE. */
11550 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11551 case EM_XC16X:
11552 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11553 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11554 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11555 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11556 return reloc_type == 0;
a06ea964
NC		 11557 case EM_AARCH64:
11558 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11559 case EM_NDS32:
11560 return (reloc_type == 0 /* R_XTENSA_NONE. */
11561 || reloc_type == 204 /* R_NDS32_DIFF8. */
11562 || reloc_type == 205 /* R_NDS32_DIFF16. */
11563 || reloc_type == 206 /* R_NDS32_DIFF32. */
11564 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11565 case EM_XTENSA_OLD:
11566 case EM_XTENSA:
4dc3c23d
AM		 11567 return (reloc_type == 0 /* R_XTENSA_NONE. */
11568 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11569 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11570 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11571 case EM_METAG:
11572 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11573 }
11574 return FALSE;
11575}
11576
cf13d699
NC		 11577/* Apply relocations to a section.
11578 Note: So far support has been added only for those relocations
11579 which can be found in debug sections.
11580 FIXME: Add support for more relocations ? */
1b315056 11581
cf13d699
NC		 11582static void
11583apply_relocations (void * file,
11584 Elf_Internal_Shdr * section,
11585 unsigned char * start)
1b315056 11586{
cf13d699
NC		 11587 Elf_Internal_Shdr * relsec;
11588 unsigned char * end = start + section->sh_size;
cb8f3167 11589
cf13d699
NC		 11590 if (elf_header.e_type != ET_REL)
11591 return;
1b315056 11592
cf13d699 11593 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11594 for (relsec = section_headers;
11595 relsec < section_headers + elf_header.e_shnum;
11596 ++relsec)
252b5132 11597 {
41e92641
NC		 11598 bfd_boolean is_rela;
11599 unsigned long num_relocs;
2cf0635d
NC		 11600 Elf_Internal_Rela * relocs;
11601 Elf_Internal_Rela * rp;
11602 Elf_Internal_Shdr * symsec;
11603 Elf_Internal_Sym * symtab;
ba5cdace 11604 unsigned long num_syms;
2cf0635d 11605 Elf_Internal_Sym * sym;
252b5132 11606
41e92641 11607 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11608 || relsec->sh_info >= elf_header.e_shnum
11609 || section_headers + relsec->sh_info != section
c256ffe7 11610 || relsec->sh_size == 0
4fbb74a6 11611 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11612 continue;
428409d5 11613
41e92641
NC		 11614 is_rela = relsec->sh_type == SHT_RELA;
11615
11616 if (is_rela)
11617 {
3f5e193b
NC		 11618 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11619 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11620 return;
11621 }
11622 else
11623 {
3f5e193b
NC		 11624 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11625 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11626 return;
11627 }
11628
11629 /* SH uses RELA but uses in place value instead of the addend field. */
11630 if (elf_header.e_machine == EM_SH)
11631 is_rela = FALSE;
428409d5 11632
4fbb74a6 11633 symsec = section_headers + relsec->sh_link;
ba5cdace 11634 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11635
41e92641 11636 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11637 {
41e92641
NC		 11638 bfd_vma addend;
11639 unsigned int reloc_type;
11640 unsigned int reloc_size;
91d6fa6a 11641 unsigned char * rloc;
ba5cdace 11642 unsigned long sym_index;
4b78141a 11643
aca88567 11644 reloc_type = get_reloc_type (rp->r_info);
41e92641 11645
98fb390a 11646 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11647 continue;
98fb390a
NC		 11648 else if (is_none_reloc (reloc_type))
11649 continue;
11650 else if (is_32bit_abs_reloc (reloc_type)
11651 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11652 reloc_size = 4;
85acf597
RH		 11653 else if (is_64bit_abs_reloc (reloc_type)
11654 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11655 reloc_size = 8;
4dc3c23d
AM		 11656 else if (is_24bit_abs_reloc (reloc_type))
11657 reloc_size = 3;
aca88567
NC		 11658 else if (is_16bit_abs_reloc (reloc_type))
11659 reloc_size = 2;
11660 else
4b78141a 11661 {
bee0ee85
NC		 11662 static unsigned int prev_reloc = 0;
11663 if (reloc_type != prev_reloc)
11664 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11665 reloc_type, printable_section_name (section));
11666 prev_reloc = reloc_type;
4b78141a
NC		 11667 continue;
11668 }
103f02d3 11669
91d6fa6a 11670 rloc = start + rp->r_offset;
c8da6823 11671 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11672 {
11673 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11674 (unsigned long) rp->r_offset,
74e1a04b 11675 printable_section_name (section));
700dd8b7
L		 11676 continue;
11677 }
103f02d3 11678
ba5cdace
NC		 11679 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11680 if (sym_index >= num_syms)
11681 {
11682 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11683 sym_index, printable_section_name (section));
ba5cdace
NC		 11684 continue;
11685 }
11686 sym = symtab + sym_index;
41e92641
NC		 11687
11688 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11689 make sure that it is of an appropriate type.
11690
11691 Relocations against symbols without type can happen.
11692 Gcc -feliminate-dwarf2-dups may generate symbols
11693 without type for debug info.
11694
11695 Icc generates relocations against function symbols
11696 instead of local labels.
11697
11698 Relocations against object symbols can happen, eg when
11699 referencing a global array. For an example of this see
11700 the _clz.o binary in libgcc.a. */
aca88567 11701 if (sym != symtab
55f25fc3 11702 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11703 {
41e92641 11704 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11705 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11706 (long int)(rp - relocs),
74e1a04b 11707 printable_section_name (relsec));
aca88567 11708 continue;
5b18a4bc 11709 }
252b5132 11710
4dc3c23d
AM		 11711 addend = 0;
11712 if (is_rela)
11713 addend += rp->r_addend;
c47320c3
AM		 11714 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11715 partial_inplace. */
4dc3c23d
AM		 11716 if (!is_rela
11717 || (elf_header.e_machine == EM_XTENSA
11718 && reloc_type == 1)
11719 || ((elf_header.e_machine == EM_PJ
11720 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11721 && reloc_type == 1)
11722 || ((elf_header.e_machine == EM_D30V
11723 || elf_header.e_machine == EM_CYGNUS_D30V)
11724 && reloc_type == 12))
91d6fa6a 11725 addend += byte_get (rloc, reloc_size);
cb8f3167 11726
85acf597
RH		 11727 if (is_32bit_pcrel_reloc (reloc_type)
11728 || is_64bit_pcrel_reloc (reloc_type))
11729 {
11730 /* On HPPA, all pc-relative relocations are biased by 8. */
11731 if (elf_header.e_machine == EM_PARISC)
11732 addend -= 8;
91d6fa6a 11733 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11734 reloc_size);
11735 }
41e92641 11736 else
91d6fa6a 11737 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11738 }
252b5132 11739
5b18a4bc 11740 free (symtab);
41e92641 11741 free (relocs);
5b18a4bc
NC		 11742 break;
11743 }
5b18a4bc 11744}
103f02d3 11745
cf13d699
NC		 11746#ifdef SUPPORT_DISASSEMBLY
11747static int
11748disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11749{
74e1a04b 11750 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11751
74e1a04b 11752 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11753
11754 return 1;
11755}
11756#endif
11757
11758/* Reads in the contents of SECTION from FILE, returning a pointer
11759 to a malloc'ed buffer or NULL if something went wrong. */
11760
11761static char *
11762get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11763{
11764 bfd_size_type num_bytes;
11765
11766 num_bytes = section->sh_size;
11767
11768 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11769 {
11770 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11771 printable_section_name (section));
cf13d699
NC		 11772 return NULL;
11773 }
11774
3f5e193b
NC		 11775 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11776 _("section contents"));
cf13d699
NC		 11777}
11778
dd24e3da 11779
cf13d699
NC		 11780static void
11781dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11782{
11783 Elf_Internal_Shdr * relsec;
11784 bfd_size_type num_bytes;
cf13d699
NC		 11785 char * data;
11786 char * end;
11787 char * start;
cf13d699
NC		 11788 bfd_boolean some_strings_shown;
11789
11790 start = get_section_contents (section, file);
11791 if (start == NULL)
11792 return;
11793
74e1a04b 11794 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11795
11796 /* If the section being dumped has relocations against it the user might
11797 be expecting these relocations to have been applied. Check for this
11798 case and issue a warning message in order to avoid confusion.
11799 FIXME: Maybe we ought to have an option that dumps a section with
11800 relocs applied ? */
11801 for (relsec = section_headers;
11802 relsec < section_headers + elf_header.e_shnum;
11803 ++relsec)
11804 {
11805 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11806 || relsec->sh_info >= elf_header.e_shnum
11807 || section_headers + relsec->sh_info != section
11808 || relsec->sh_size == 0
11809 || relsec->sh_link >= elf_header.e_shnum)
11810 continue;
11811
11812 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11813 break;
11814 }
11815
11816 num_bytes = section->sh_size;
cf13d699
NC		 11817 data = start;
11818 end = start + num_bytes;
11819 some_strings_shown = FALSE;
11820
11821 while (data < end)
11822 {
11823 while (!ISPRINT (* data))
11824 if (++ data >= end)
11825 break;
11826
11827 if (data < end)
11828 {
071436c6
NC		 11829 size_t maxlen = end - data;
11830
cf13d699 11831#ifndef __MSVCRT__
c975cc98
NC		 11832 /* PR 11128: Use two separate invocations in order to work
11833 around bugs in the Solaris 8 implementation of printf. */
11834 printf (" [%6tx] ", data - start);
cf13d699 11835#else
071436c6 11836 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 11837#endif
4082ef84
NC		 11838 if (maxlen > 0)
11839 {
11840 print_symbol ((int) maxlen, data);
11841 putchar ('\n');
11842 data += strnlen (data, maxlen);
11843 }
11844 else
11845 {
11846 printf (_("<corrupt>\n"));
11847 data = end;
11848 }
cf13d699
NC		 11849 some_strings_shown = TRUE;
11850 }
11851 }
11852
11853 if (! some_strings_shown)
11854 printf (_(" No strings found in this section."));
11855
11856 free (start);
11857
11858 putchar ('\n');
11859}
11860
11861static void
11862dump_section_as_bytes (Elf_Internal_Shdr * section,
11863 FILE * file,
11864 bfd_boolean relocate)
11865{
11866 Elf_Internal_Shdr * relsec;
11867 bfd_size_type bytes;
11868 bfd_vma addr;
11869 unsigned char * data;
11870 unsigned char * start;
11871
11872 start = (unsigned char *) get_section_contents (section, file);
11873 if (start == NULL)
11874 return;
11875
74e1a04b 11876 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11877
11878 if (relocate)
11879 {
11880 apply_relocations (file, section, start);
11881 }
11882 else
11883 {
11884 /* If the section being dumped has relocations against it the user might
11885 be expecting these relocations to have been applied. Check for this
11886 case and issue a warning message in order to avoid confusion.
11887 FIXME: Maybe we ought to have an option that dumps a section with
11888 relocs applied ? */
11889 for (relsec = section_headers;
11890 relsec < section_headers + elf_header.e_shnum;
11891 ++relsec)
11892 {
11893 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11894 || relsec->sh_info >= elf_header.e_shnum
11895 || section_headers + relsec->sh_info != section
11896 || relsec->sh_size == 0
11897 || relsec->sh_link >= elf_header.e_shnum)
11898 continue;
11899
11900 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11901 break;
11902 }
11903 }
11904
11905 addr = section->sh_addr;
11906 bytes = section->sh_size;
11907 data = start;
11908
11909 while (bytes)
11910 {
11911 int j;
11912 int k;
11913 int lbytes;
11914
11915 lbytes = (bytes > 16 ? 16 : bytes);
11916
11917 printf (" 0x%8.8lx ", (unsigned long) addr);
11918
11919 for (j = 0; j < 16; j++)
11920 {
11921 if (j < lbytes)
11922 printf ("%2.2x", data[j]);
11923 else
11924 printf (" ");
11925
11926 if ((j & 3) == 3)
11927 printf (" ");
11928 }
11929
11930 for (j = 0; j < lbytes; j++)
11931 {
11932 k = data[j];
11933 if (k >= ' ' && k < 0x7f)
11934 printf ("%c", k);
11935 else
11936 printf (".");
11937 }
11938
11939 putchar ('\n');
11940
11941 data += lbytes;
11942 addr += lbytes;
11943 bytes -= lbytes;
11944 }
11945
11946 free (start);
11947
11948 putchar ('\n');
11949}
11950
4a114e3e 11951/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11952
11953static int
d3dbc530
AM		 11954uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11955 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 11956{
11957#ifndef HAVE_ZLIB_H
cf13d699
NC		 11958 return FALSE;
11959#else
11960 dwarf_size_type compressed_size = *size;
11961 unsigned char * compressed_buffer = *buffer;
11962 dwarf_size_type uncompressed_size;
11963 unsigned char * uncompressed_buffer;
11964 z_stream strm;
11965 int rc;
11966 dwarf_size_type header_size = 12;
11967
11968 /* Read the zlib header. In this case, it should be "ZLIB" followed
11969 by the uncompressed section size, 8 bytes in big-endian order. */
11970 if (compressed_size < header_size
11971 || ! streq ((char *) compressed_buffer, "ZLIB"))
11972 return 0;
11973
11974 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11975 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11976 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11977 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11978 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11979 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11980 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11981 uncompressed_size += compressed_buffer[11];
11982
11983 /* It is possible the section consists of several compressed
11984 buffers concatenated together, so we uncompress in a loop. */
11985 strm.zalloc = NULL;
11986 strm.zfree = NULL;
11987 strm.opaque = NULL;
11988 strm.avail_in = compressed_size - header_size;
11989 strm.next_in = (Bytef *) compressed_buffer + header_size;
11990 strm.avail_out = uncompressed_size;
3f5e193b 11991 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 11992
11993 rc = inflateInit (& strm);
11994 while (strm.avail_in > 0)
11995 {
11996 if (rc != Z_OK)
11997 goto fail;
11998 strm.next_out = ((Bytef *) uncompressed_buffer
11999 + (uncompressed_size - strm.avail_out));
12000 rc = inflate (&strm, Z_FINISH);
12001 if (rc != Z_STREAM_END)
12002 goto fail;
12003 rc = inflateReset (& strm);
12004 }
12005 rc = inflateEnd (& strm);
12006 if (rc != Z_OK
12007 || strm.avail_out != 0)
12008 goto fail;
12009
12010 free (compressed_buffer);
12011 *buffer = uncompressed_buffer;
12012 *size = uncompressed_size;
12013 return 1;
12014
12015 fail:
12016 free (uncompressed_buffer);
4a114e3e
L		 12017 /* Indicate decompression failure. */
12018 *buffer = NULL;
cf13d699
NC		 12019 return 0;
12020#endif /* HAVE_ZLIB_H */
12021}
12022
d966045b
DJ		 12023static int
12024load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 12025 Elf_Internal_Shdr * sec, void * file)
1007acb3 12026{
2cf0635d 12027 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12028 char buf [64];
1007acb3 12029
19e6b90e
L		 12030 /* If it is already loaded, do nothing. */
12031 if (section->start != NULL)
12032 return 1;
1007acb3 12033
19e6b90e
L		 12034 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12035 section->address = sec->sh_addr;
06614111 12036 section->user_data = NULL;
3f5e193b
NC		 12037 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12038 sec->sh_offset, 1,
12039 sec->sh_size, buf);
59245841
NC		 12040 if (section->start == NULL)
12041 section->size = 0;
12042 else
12043 {
12044 section->size = sec->sh_size;
12045 if (uncompress_section_contents (&section->start, &section->size))
12046 sec->sh_size = section->size;
12047 }
4a114e3e 12048
1b315056
CS		 12049 if (section->start == NULL)
12050 return 0;
12051
19e6b90e 12052 if (debug_displays [debug].relocate)
3f5e193b 12053 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 12054
1b315056 12055 return 1;
1007acb3
L		 12056}
12057
657d0d47
CC		 12058/* If this is not NULL, load_debug_section will only look for sections
12059 within the list of sections given here. */
12060unsigned int *section_subset = NULL;
12061
d966045b 12062int
2cf0635d 12063load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12064{
2cf0635d
NC		 12065 struct dwarf_section * section = &debug_displays [debug].section;
12066 Elf_Internal_Shdr * sec;
d966045b
DJ		 12067
12068 /* Locate the debug section. */
657d0d47 12069 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12070 if (sec != NULL)
12071 section->name = section->uncompressed_name;
12072 else
12073 {
657d0d47 12074 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12075 if (sec != NULL)
12076 section->name = section->compressed_name;
12077 }
12078 if (sec == NULL)
12079 return 0;
12080
657d0d47
CC		 12081 /* If we're loading from a subset of sections, and we've loaded
12082 a section matching this name before, it's likely that it's a
12083 different one. */
12084 if (section_subset != NULL)
12085 free_debug_section (debug);
12086
3f5e193b 12087 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12088}
12089
19e6b90e
L		 12090void
12091free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12092{
2cf0635d 12093 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12094
19e6b90e
L		 12095 if (section->start == NULL)
12096 return;
1007acb3 12097
19e6b90e
L		 12098 free ((char *) section->start);
12099 section->start = NULL;
12100 section->address = 0;
12101 section->size = 0;
1007acb3
L		 12102}
12103
1007acb3 12104static int
657d0d47 12105display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12106{
2cf0635d 12107 char * name = SECTION_NAME (section);
74e1a04b 12108 const char * print_name = printable_section_name (section);
19e6b90e
L		 12109 bfd_size_type length;
12110 int result = 1;
3f5e193b 12111 int i;
1007acb3 12112
19e6b90e
L		 12113 length = section->sh_size;
12114 if (length == 0)
1007acb3 12115 {
74e1a04b 12116 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12117 return 0;
1007acb3 12118 }
5dff79d8
NC		 12119 if (section->sh_type == SHT_NOBITS)
12120 {
12121 /* There is no point in dumping the contents of a debugging section
12122 which has the NOBITS type - the bits in the file will be random.
12123 This can happen when a file containing a .eh_frame section is
12124 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12125 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12126 print_name);
5dff79d8
NC		 12127 return 0;
12128 }
1007acb3 12129
0112cd26 12130 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12131 name = ".debug_info";
1007acb3 12132
19e6b90e
L		 12133 /* See if we know how to display the contents of this section. */
12134 for (i = 0; i < max; i++)
1b315056 12135 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12136 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12137 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12138 {
2cf0635d 12139 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12140 int secondary = (section != find_section (name));
12141
12142 if (secondary)
3f5e193b 12143 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12144
b40bf0a2
NC		 12145 if (i == line && const_strneq (name, ".debug_line."))
12146 sec->name = name;
12147 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12148 sec->name = sec->uncompressed_name;
12149 else
12150 sec->name = sec->compressed_name;
3f5e193b
NC		 12151 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12152 section, file))
19e6b90e 12153 {
657d0d47
CC		 12154 /* If this debug section is part of a CU/TU set in a .dwp file,
12155 restrict load_debug_section to the sections in that set. */
12156 section_subset = find_cu_tu_set (file, shndx);
12157
19e6b90e 12158 result &= debug_displays[i].display (sec, file);
1007acb3 12159
657d0d47
CC		 12160 section_subset = NULL;
12161
d966045b 12162 if (secondary || (i != info && i != abbrev))
3f5e193b 12163 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12164 }
1007acb3 12165
19e6b90e
L		 12166 break;
12167 }
1007acb3 12168
19e6b90e 12169 if (i == max)
1007acb3 12170 {
74e1a04b 12171 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12172 result = 0;
1007acb3
L		 12173 }
12174
19e6b90e 12175 return result;
5b18a4bc 12176}
103f02d3 12177
aef1f6d0
DJ		 12178/* Set DUMP_SECTS for all sections where dumps were requested
12179 based on section name. */
12180
12181static void
12182initialise_dumps_byname (void)
12183{
2cf0635d 12184 struct dump_list_entry * cur;
aef1f6d0
DJ		 12185
12186 for (cur = dump_sects_byname; cur; cur = cur->next)
12187 {
12188 unsigned int i;
12189 int any;
12190
12191 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12192 if (streq (SECTION_NAME (section_headers + i), cur->name))
12193 {
09c11c86 12194 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12195 any = 1;
12196 }
12197
12198 if (!any)
12199 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12200 cur->name);
12201 }
12202}
12203
5b18a4bc 12204static void
2cf0635d 12205process_section_contents (FILE * file)
5b18a4bc 12206{
2cf0635d 12207 Elf_Internal_Shdr * section;
19e6b90e 12208 unsigned int i;
103f02d3 12209
19e6b90e
L		 12210 if (! do_dump)
12211 return;
103f02d3 12212
aef1f6d0
DJ		 12213 initialise_dumps_byname ();
12214
19e6b90e
L		 12215 for (i = 0, section = section_headers;
12216 i < elf_header.e_shnum && i < num_dump_sects;
12217 i++, section++)
12218 {
12219#ifdef SUPPORT_DISASSEMBLY
12220 if (dump_sects[i] & DISASS_DUMP)
12221 disassemble_section (section, file);
12222#endif
12223 if (dump_sects[i] & HEX_DUMP)
cf13d699 12224 dump_section_as_bytes (section, file, FALSE);
103f02d3 12225
cf13d699
NC		 12226 if (dump_sects[i] & RELOC_DUMP)
12227 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12228
12229 if (dump_sects[i] & STRING_DUMP)
12230 dump_section_as_strings (section, file);
cf13d699
NC		 12231
12232 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12233 display_debug_section (i, section, file);
5b18a4bc 12234 }
103f02d3 12235
19e6b90e
L		 12236 /* Check to see if the user requested a
12237 dump of a section that does not exist. */
12238 while (i++ < num_dump_sects)
12239 if (dump_sects[i])
12240 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12241}
103f02d3 12242
5b18a4bc 12243static void
19e6b90e 12244process_mips_fpe_exception (int mask)
5b18a4bc 12245{
19e6b90e
L		 12246 if (mask)
12247 {
12248 int first = 1;
12249 if (mask & OEX_FPU_INEX)
12250 fputs ("INEX", stdout), first = 0;
12251 if (mask & OEX_FPU_UFLO)
12252 printf ("%sUFLO", first ? "" : "|"), first = 0;
12253 if (mask & OEX_FPU_OFLO)
12254 printf ("%sOFLO", first ? "" : "|"), first = 0;
12255 if (mask & OEX_FPU_DIV0)
12256 printf ("%sDIV0", first ? "" : "|"), first = 0;
12257 if (mask & OEX_FPU_INVAL)
12258 printf ("%sINVAL", first ? "" : "|");
12259 }
5b18a4bc 12260 else
19e6b90e 12261 fputs ("0", stdout);
5b18a4bc 12262}
103f02d3 12263
f6f0e17b
NC		 12264/* Display's the value of TAG at location P. If TAG is
12265 greater than 0 it is assumed to be an unknown tag, and
12266 a message is printed to this effect. Otherwise it is
12267 assumed that a message has already been printed.
12268
12269 If the bottom bit of TAG is set it assumed to have a
12270 string value, otherwise it is assumed to have an integer
12271 value.
12272
12273 Returns an updated P pointing to the first unread byte
12274 beyond the end of TAG's value.
12275
12276 Reads at or beyond END will not be made. */
12277
12278static unsigned char *
12279display_tag_value (int tag,
12280 unsigned char * p,
12281 const unsigned char * const end)
12282{
12283 unsigned long val;
12284
12285 if (tag > 0)
12286 printf (" Tag_unknown_%d: ", tag);
12287
12288 if (p >= end)
12289 {
4082ef84 12290 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12291 }
12292 else if (tag & 1)
12293 {
071436c6
NC		 12294 /* PR 17531 file: 027-19978-0.004. */
12295 size_t maxlen = (end - p) - 1;
12296
12297 putchar ('"');
4082ef84
NC		 12298 if (maxlen > 0)
12299 {
12300 print_symbol ((int) maxlen, (const char *) p);
12301 p += strnlen ((char *) p, maxlen) + 1;
12302 }
12303 else
12304 {
12305 printf (_("<corrupt string tag>"));
12306 p = (unsigned char *) end;
12307 }
071436c6 12308 printf ("\"\n");
f6f0e17b
NC		 12309 }
12310 else
12311 {
12312 unsigned int len;
12313
12314 val = read_uleb128 (p, &len, end);
12315 p += len;
12316 printf ("%ld (0x%lx)\n", val, val);
12317 }
12318
4082ef84 12319 assert (p <= end);
f6f0e17b
NC		 12320 return p;
12321}
12322
11c1ff18
PB		 12323/* ARM EABI attributes section. */
12324typedef struct
12325{
70e99720 12326 unsigned int tag;
2cf0635d 12327 const char * name;
11c1ff18 12328 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12329 unsigned int type;
2cf0635d 12330 const char ** table;
11c1ff18
PB		 12331} arm_attr_public_tag;
12332
2cf0635d 12333static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12334 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12335 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12336static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12337static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12338 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12339static const char * arm_attr_tag_FP_arch[] =
bca38921 12340 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12341 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12342static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12343static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12344 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12345static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12346 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12347 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12348static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12349 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12350static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12351 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12352static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12353 {"Absolute", "PC-relative", "None"};
2cf0635d 12354static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12355 {"None", "direct", "GOT-indirect"};
2cf0635d 12356static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12357 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12358static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12359static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12360 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12361static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12362static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12363static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12364 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12365static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12366 {"Unused", "small", "int", "forced to int"};
2cf0635d 12367static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12368 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12369static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12370 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12371static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12372 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12373static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12374 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12375 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12376static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12377 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12378 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12379static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12380static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12381 {"Not Allowed", "Allowed"};
2cf0635d 12382static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12383 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12384static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12385 {"Not Allowed", "Allowed"};
12386static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12387 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12388 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12389static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12390static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12391 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12392 "TrustZone and Virtualization Extensions"};
dd24e3da 12393static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12394 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12395
12396#define LOOKUP(id, name) \
12397 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12398static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12399{
12400 {4, "CPU_raw_name", 1, NULL},
12401 {5, "CPU_name", 1, NULL},
12402 LOOKUP(6, CPU_arch),
12403 {7, "CPU_arch_profile", 0, NULL},
12404 LOOKUP(8, ARM_ISA_use),
12405 LOOKUP(9, THUMB_ISA_use),
75375b3e 12406 LOOKUP(10, FP_arch),
11c1ff18 12407 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12408 LOOKUP(12, Advanced_SIMD_arch),
12409 LOOKUP(13, PCS_config),
11c1ff18
PB		 12410 LOOKUP(14, ABI_PCS_R9_use),
12411 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12412 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12413 LOOKUP(17, ABI_PCS_GOT_use),
12414 LOOKUP(18, ABI_PCS_wchar_t),
12415 LOOKUP(19, ABI_FP_rounding),
12416 LOOKUP(20, ABI_FP_denormal),
12417 LOOKUP(21, ABI_FP_exceptions),
12418 LOOKUP(22, ABI_FP_user_exceptions),
12419 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12420 {24, "ABI_align_needed", 0, NULL},
12421 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12422 LOOKUP(26, ABI_enum_size),
12423 LOOKUP(27, ABI_HardFP_use),
12424 LOOKUP(28, ABI_VFP_args),
12425 LOOKUP(29, ABI_WMMX_args),
12426 LOOKUP(30, ABI_optimization_goals),
12427 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12428 {32, "compatibility", 0, NULL},
f5f53991 12429 LOOKUP(34, CPU_unaligned_access),
75375b3e 12430 LOOKUP(36, FP_HP_extension),
8e79c3df 12431 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12432 LOOKUP(42, MPextension_use),
12433 LOOKUP(44, DIV_use),
f5f53991
AS		 12434 {64, "nodefaults", 0, NULL},
12435 {65, "also_compatible_with", 0, NULL},
12436 LOOKUP(66, T2EE_use),
12437 {67, "conformance", 1, NULL},
12438 LOOKUP(68, Virtualization_use),
cd21e546 12439 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12440};
12441#undef LOOKUP
12442
11c1ff18 12443static unsigned char *
f6f0e17b
NC		 12444display_arm_attribute (unsigned char * p,
12445 const unsigned char * const end)
11c1ff18 12446{
70e99720 12447 unsigned int tag;
11c1ff18 12448 unsigned int len;
70e99720 12449 unsigned int val;
2cf0635d 12450 arm_attr_public_tag * attr;
11c1ff18 12451 unsigned i;
70e99720 12452 unsigned int type;
11c1ff18 12453
f6f0e17b 12454 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12455 p += len;
12456 attr = NULL;
2cf0635d 12457 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12458 {
12459 if (arm_attr_public_tags[i].tag == tag)
12460 {
12461 attr = &arm_attr_public_tags[i];
12462 break;
12463 }
12464 }
12465
12466 if (attr)
12467 {
12468 printf (" Tag_%s: ", attr->name);
12469 switch (attr->type)
12470 {
12471 case 0:
12472 switch (tag)
12473 {
12474 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12475 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12476 p += len;
12477 switch (val)
12478 {
2b692964
NC		 12479 case 0: printf (_("None\n")); break;
12480 case 'A': printf (_("Application\n")); break;
12481 case 'R': printf (_("Realtime\n")); break;
12482 case 'M': printf (_("Microcontroller\n")); break;
12483 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12484 default: printf ("??? (%d)\n", val); break;
12485 }
12486 break;
12487
75375b3e 12488 case 24: /* Tag_align_needed. */
f6f0e17b 12489 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12490 p += len;
12491 switch (val)
12492 {
2b692964
NC		 12493 case 0: printf (_("None\n")); break;
12494 case 1: printf (_("8-byte\n")); break;
12495 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12496 case 3: printf ("??? 3\n"); break;
12497 default:
12498 if (val <= 12)
dd24e3da 12499 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12500 1 << val);
12501 else
12502 printf ("??? (%d)\n", val);
12503 break;
12504 }
12505 break;
12506
12507 case 25: /* Tag_align_preserved. */
f6f0e17b 12508 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12509 p += len;
12510 switch (val)
12511 {
2b692964
NC		 12512 case 0: printf (_("None\n")); break;
12513 case 1: printf (_("8-byte, except leaf SP\n")); break;
12514 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12515 case 3: printf ("??? 3\n"); break;
12516 default:
12517 if (val <= 12)
dd24e3da 12518 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12519 1 << val);
12520 else
12521 printf ("??? (%d)\n", val);
12522 break;
12523 }
12524 break;
12525
11c1ff18 12526 case 32: /* Tag_compatibility. */
071436c6 12527 {
071436c6
NC		 12528 val = read_uleb128 (p, &len, end);
12529 p += len;
071436c6 12530 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12531 if (p < end - 1)
12532 {
12533 size_t maxlen = (end - p) - 1;
12534
12535 print_symbol ((int) maxlen, (const char *) p);
12536 p += strnlen ((char *) p, maxlen) + 1;
12537 }
12538 else
12539 {
12540 printf (_("<corrupt>"));
12541 p = (unsigned char *) end;
12542 }
071436c6 12543 putchar ('\n');
071436c6 12544 }
11c1ff18
PB		 12545 break;
12546
f5f53991 12547 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12548 /* PR 17531: file: 001-505008-0.01. */
12549 if (p < end)
12550 p++;
2b692964 12551 printf (_("True\n"));
f5f53991
AS		 12552 break;
12553
12554 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12555 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12556 p += len;
12557 if (val == 6 /* Tag_CPU_arch. */)
12558 {
f6f0e17b 12559 val = read_uleb128 (p, &len, end);
f5f53991 12560 p += len;
071436c6 12561 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12562 printf ("??? (%d)\n", val);
12563 else
12564 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12565 }
12566 else
12567 printf ("???\n");
071436c6
NC		 12568 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12569 ;
f5f53991
AS		 12570 break;
12571
11c1ff18 12572 default:
bee0ee85
NC		 12573 printf (_("<unknown: %d>\n"), tag);
12574 break;
11c1ff18
PB		 12575 }
12576 return p;
12577
12578 case 1:
f6f0e17b 12579 return display_tag_value (-1, p, end);
11c1ff18 12580 case 2:
f6f0e17b 12581 return display_tag_value (0, p, end);
11c1ff18
PB		 12582
12583 default:
12584 assert (attr->type & 0x80);
f6f0e17b 12585 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12586 p += len;
12587 type = attr->type & 0x7f;
12588 if (val >= type)
12589 printf ("??? (%d)\n", val);
12590 else
12591 printf ("%s\n", attr->table[val]);
12592 return p;
12593 }
12594 }
11c1ff18 12595
f6f0e17b 12596 return display_tag_value (tag, p, end);
11c1ff18
PB		 12597}
12598
104d59d1 12599static unsigned char *
60bca95a 12600display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12601 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12602 const unsigned char * const end)
104d59d1
JM		 12603{
12604 int tag;
12605 unsigned int len;
12606 int val;
104d59d1 12607
f6f0e17b 12608 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12609 p += len;
12610
12611 /* Tag_compatibility is the only generic GNU attribute defined at
12612 present. */
12613 if (tag == 32)
12614 {
f6f0e17b 12615 val = read_uleb128 (p, &len, end);
104d59d1 12616 p += len;
071436c6
NC		 12617
12618 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12619 if (p == end)
12620 {
071436c6 12621 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12622 warn (_("corrupt vendor attribute\n"));
12623 }
12624 else
12625 {
4082ef84
NC		 12626 if (p < end - 1)
12627 {
12628 size_t maxlen = (end - p) - 1;
071436c6 12629
4082ef84
NC		 12630 print_symbol ((int) maxlen, (const char *) p);
12631 p += strnlen ((char *) p, maxlen) + 1;
12632 }
12633 else
12634 {
12635 printf (_("<corrupt>"));
12636 p = (unsigned char *) end;
12637 }
071436c6 12638 putchar ('\n');
f6f0e17b 12639 }
104d59d1
JM		 12640 return p;
12641 }
12642
12643 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12644 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12645
f6f0e17b 12646 return display_tag_value (tag, p, end);
104d59d1
JM		 12647}
12648
34c8bcba 12649static unsigned char *
f6f0e17b
NC		 12650display_power_gnu_attribute (unsigned char * p,
12651 int tag,
12652 const unsigned char * const end)
34c8bcba 12653{
34c8bcba
JM		 12654 unsigned int len;
12655 int val;
12656
12657 if (tag == Tag_GNU_Power_ABI_FP)
12658 {
f6f0e17b 12659 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12660 p += len;
12661 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12662
34c8bcba
JM		 12663 switch (val)
12664 {
12665 case 0:
2b692964 12666 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12667 break;
12668 case 1:
2b692964 12669 printf (_("Hard float\n"));
34c8bcba
JM		 12670 break;
12671 case 2:
2b692964 12672 printf (_("Soft float\n"));
34c8bcba 12673 break;
3c7b9897 12674 case 3:
2b692964 12675 printf (_("Single-precision hard float\n"));
3c7b9897 12676 break;
34c8bcba
JM		 12677 default:
12678 printf ("??? (%d)\n", val);
12679 break;
12680 }
12681 return p;
12682 }
12683
c6e65352
DJ		 12684 if (tag == Tag_GNU_Power_ABI_Vector)
12685 {
f6f0e17b 12686 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12687 p += len;
12688 printf (" Tag_GNU_Power_ABI_Vector: ");
12689 switch (val)
12690 {
12691 case 0:
2b692964 12692 printf (_("Any\n"));
c6e65352
DJ		 12693 break;
12694 case 1:
2b692964 12695 printf (_("Generic\n"));
c6e65352
DJ		 12696 break;
12697 case 2:
12698 printf ("AltiVec\n");
12699 break;
12700 case 3:
12701 printf ("SPE\n");
12702 break;
12703 default:
12704 printf ("??? (%d)\n", val);
12705 break;
12706 }
12707 return p;
12708 }
12709
f82e0623
NF		 12710 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12711 {
f6f0e17b
NC		 12712 if (p == end)
12713 {
071436c6 12714 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12715 return p;
12716 }
0b4362b0 12717
f6f0e17b 12718 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12719 p += len;
12720 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12721 switch (val)
12722 {
12723 case 0:
2b692964 12724 printf (_("Any\n"));
f82e0623
NF		 12725 break;
12726 case 1:
12727 printf ("r3/r4\n");
12728 break;
12729 case 2:
2b692964 12730 printf (_("Memory\n"));
f82e0623
NF		 12731 break;
12732 default:
12733 printf ("??? (%d)\n", val);
12734 break;
12735 }
12736 return p;
12737 }
12738
f6f0e17b 12739 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12740}
12741
9e8c70f9
DM		 12742static void
12743display_sparc_hwcaps (int mask)
12744{
12745 if (mask)
12746 {
12747 int first = 1;
071436c6 12748
9e8c70f9
DM		 12749 if (mask & ELF_SPARC_HWCAP_MUL32)
12750 fputs ("mul32", stdout), first = 0;
12751 if (mask & ELF_SPARC_HWCAP_DIV32)
12752 printf ("%sdiv32", first ? "" : "|"), first = 0;
12753 if (mask & ELF_SPARC_HWCAP_FSMULD)
12754 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12755 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12756 printf ("%sv8plus", first ? "" : "|"), first = 0;
12757 if (mask & ELF_SPARC_HWCAP_POPC)
12758 printf ("%spopc", first ? "" : "|"), first = 0;
12759 if (mask & ELF_SPARC_HWCAP_VIS)
12760 printf ("%svis", first ? "" : "|"), first = 0;
12761 if (mask & ELF_SPARC_HWCAP_VIS2)
12762 printf ("%svis2", first ? "" : "|"), first = 0;
12763 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12764 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12765 if (mask & ELF_SPARC_HWCAP_FMAF)
12766 printf ("%sfmaf", first ? "" : "|"), first = 0;
12767 if (mask & ELF_SPARC_HWCAP_VIS3)
12768 printf ("%svis3", first ? "" : "|"), first = 0;
12769 if (mask & ELF_SPARC_HWCAP_HPC)
12770 printf ("%shpc", first ? "" : "|"), first = 0;
12771 if (mask & ELF_SPARC_HWCAP_RANDOM)
12772 printf ("%srandom", first ? "" : "|"), first = 0;
12773 if (mask & ELF_SPARC_HWCAP_TRANS)
12774 printf ("%strans", first ? "" : "|"), first = 0;
12775 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12776 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12777 if (mask & ELF_SPARC_HWCAP_IMA)
12778 printf ("%sima", first ? "" : "|"), first = 0;
12779 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12780 printf ("%scspare", first ? "" : "|"), first = 0;
12781 }
12782 else
071436c6
NC		 12783 fputc ('0', stdout);
12784 fputc ('\n', stdout);
9e8c70f9
DM		 12785}
12786
3d68f91c
JM		 12787static void
12788display_sparc_hwcaps2 (int mask)
12789{
12790 if (mask)
12791 {
12792 int first = 1;
071436c6 12793
3d68f91c
JM		 12794 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12795 fputs ("fjathplus", stdout), first = 0;
12796 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12797 printf ("%svis3b", first ? "" : "|"), first = 0;
12798 if (mask & ELF_SPARC_HWCAP2_ADP)
12799 printf ("%sadp", first ? "" : "|"), first = 0;
12800 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12801 printf ("%ssparc5", first ? "" : "|"), first = 0;
12802 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12803 printf ("%smwait", first ? "" : "|"), first = 0;
12804 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12805 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12806 if (mask & ELF_SPARC_HWCAP2_XMONT)
12807 printf ("%sxmont2", first ? "" : "|"), first = 0;
12808 if (mask & ELF_SPARC_HWCAP2_NSEC)
12809 printf ("%snsec", first ? "" : "|"), first = 0;
12810 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12811 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12812 if (mask & ELF_SPARC_HWCAP2_FJDES)
12813 printf ("%sfjdes", first ? "" : "|"), first = 0;
12814 if (mask & ELF_SPARC_HWCAP2_FJAES)
12815 printf ("%sfjaes", first ? "" : "|"), first = 0;
12816 }
12817 else
071436c6
NC		 12818 fputc ('0', stdout);
12819 fputc ('\n', stdout);
3d68f91c
JM		 12820}
12821
9e8c70f9 12822static unsigned char *
f6f0e17b
NC		 12823display_sparc_gnu_attribute (unsigned char * p,
12824 int tag,
12825 const unsigned char * const end)
9e8c70f9 12826{
3d68f91c
JM		 12827 unsigned int len;
12828 int val;
12829
9e8c70f9
DM		 12830 if (tag == Tag_GNU_Sparc_HWCAPS)
12831 {
f6f0e17b 12832 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12833 p += len;
12834 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12835 display_sparc_hwcaps (val);
12836 return p;
3d68f91c
JM		 12837 }
12838 if (tag == Tag_GNU_Sparc_HWCAPS2)
12839 {
12840 val = read_uleb128 (p, &len, end);
12841 p += len;
12842 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12843 display_sparc_hwcaps2 (val);
12844 return p;
12845 }
9e8c70f9 12846
f6f0e17b 12847 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12848}
12849
351cdf24
MF		 12850static void
12851print_mips_fp_abi_value (int val)
12852{
12853 switch (val)
12854 {
12855 case Val_GNU_MIPS_ABI_FP_ANY:
12856 printf (_("Hard or soft float\n"));
12857 break;
12858 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12859 printf (_("Hard float (double precision)\n"));
12860 break;
12861 case Val_GNU_MIPS_ABI_FP_SINGLE:
12862 printf (_("Hard float (single precision)\n"));
12863 break;
12864 case Val_GNU_MIPS_ABI_FP_SOFT:
12865 printf (_("Soft float\n"));
12866 break;
12867 case Val_GNU_MIPS_ABI_FP_OLD_64:
12868 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12869 break;
12870 case Val_GNU_MIPS_ABI_FP_XX:
12871 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12872 break;
12873 case Val_GNU_MIPS_ABI_FP_64:
12874 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12875 break;
12876 case Val_GNU_MIPS_ABI_FP_64A:
12877 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12878 break;
12879 default:
12880 printf ("??? (%d)\n", val);
12881 break;
12882 }
12883}
12884
2cf19d5c 12885static unsigned char *
f6f0e17b
NC		 12886display_mips_gnu_attribute (unsigned char * p,
12887 int tag,
12888 const unsigned char * const end)
2cf19d5c 12889{
2cf19d5c
JM		 12890 if (tag == Tag_GNU_MIPS_ABI_FP)
12891 {
f6f0e17b
NC		 12892 unsigned int len;
12893 int val;
12894
12895 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12896 p += len;
12897 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12898
351cdf24
MF		 12899 print_mips_fp_abi_value (val);
12900
2cf19d5c
JM		 12901 return p;
12902 }
12903
a9f58168
CF		 12904 if (tag == Tag_GNU_MIPS_ABI_MSA)
12905 {
12906 unsigned int len;
12907 int val;
12908
12909 val = read_uleb128 (p, &len, end);
12910 p += len;
12911 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12912
12913 switch (val)
12914 {
12915 case Val_GNU_MIPS_ABI_MSA_ANY:
12916 printf (_("Any MSA or not\n"));
12917 break;
12918 case Val_GNU_MIPS_ABI_MSA_128:
12919 printf (_("128-bit MSA\n"));
12920 break;
12921 default:
12922 printf ("??? (%d)\n", val);
12923 break;
12924 }
12925 return p;
12926 }
12927
f6f0e17b 12928 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12929}
12930
59e6276b 12931static unsigned char *
f6f0e17b
NC		 12932display_tic6x_attribute (unsigned char * p,
12933 const unsigned char * const end)
59e6276b
JM		 12934{
12935 int tag;
12936 unsigned int len;
12937 int val;
12938
f6f0e17b 12939 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12940 p += len;
12941
12942 switch (tag)
12943 {
75fa6dc1 12944 case Tag_ISA:
f6f0e17b 12945 val = read_uleb128 (p, &len, end);
59e6276b 12946 p += len;
75fa6dc1 12947 printf (" Tag_ISA: ");
59e6276b
JM		 12948
12949 switch (val)
12950 {
75fa6dc1 12951 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12952 printf (_("None\n"));
12953 break;
75fa6dc1 12954 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12955 printf ("C62x\n");
12956 break;
75fa6dc1 12957 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12958 printf ("C67x\n");
12959 break;
75fa6dc1 12960 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12961 printf ("C67x+\n");
12962 break;
75fa6dc1 12963 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12964 printf ("C64x\n");
12965 break;
75fa6dc1 12966 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12967 printf ("C64x+\n");
12968 break;
75fa6dc1 12969 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12970 printf ("C674x\n");
12971 break;
12972 default:
12973 printf ("??? (%d)\n", val);
12974 break;
12975 }
12976 return p;
12977
87779176 12978 case Tag_ABI_wchar_t:
f6f0e17b 12979 val = read_uleb128 (p, &len, end);
87779176
JM		 12980 p += len;
12981 printf (" Tag_ABI_wchar_t: ");
12982 switch (val)
12983 {
12984 case 0:
12985 printf (_("Not used\n"));
12986 break;
12987 case 1:
12988 printf (_("2 bytes\n"));
12989 break;
12990 case 2:
12991 printf (_("4 bytes\n"));
12992 break;
12993 default:
12994 printf ("??? (%d)\n", val);
12995 break;
12996 }
12997 return p;
12998
12999 case Tag_ABI_stack_align_needed:
f6f0e17b 13000 val = read_uleb128 (p, &len, end);
87779176
JM		 13001 p += len;
13002 printf (" Tag_ABI_stack_align_needed: ");
13003 switch (val)
13004 {
13005 case 0:
13006 printf (_("8-byte\n"));
13007 break;
13008 case 1:
13009 printf (_("16-byte\n"));
13010 break;
13011 default:
13012 printf ("??? (%d)\n", val);
13013 break;
13014 }
13015 return p;
13016
13017 case Tag_ABI_stack_align_preserved:
f6f0e17b 13018 val = read_uleb128 (p, &len, end);
87779176
JM		 13019 p += len;
13020 printf (" Tag_ABI_stack_align_preserved: ");
13021 switch (val)
13022 {
13023 case 0:
13024 printf (_("8-byte\n"));
13025 break;
13026 case 1:
13027 printf (_("16-byte\n"));
13028 break;
13029 default:
13030 printf ("??? (%d)\n", val);
13031 break;
13032 }
13033 return p;
13034
b5593623 13035 case Tag_ABI_DSBT:
f6f0e17b 13036 val = read_uleb128 (p, &len, end);
b5593623
JM		 13037 p += len;
13038 printf (" Tag_ABI_DSBT: ");
13039 switch (val)
13040 {
13041 case 0:
13042 printf (_("DSBT addressing not used\n"));
13043 break;
13044 case 1:
13045 printf (_("DSBT addressing used\n"));
13046 break;
13047 default:
13048 printf ("??? (%d)\n", val);
13049 break;
13050 }
13051 return p;
13052
87779176 13053 case Tag_ABI_PID:
f6f0e17b 13054 val = read_uleb128 (p, &len, end);
87779176
JM		 13055 p += len;
13056 printf (" Tag_ABI_PID: ");
13057 switch (val)
13058 {
13059 case 0:
13060 printf (_("Data addressing position-dependent\n"));
13061 break;
13062 case 1:
13063 printf (_("Data addressing position-independent, GOT near DP\n"));
13064 break;
13065 case 2:
13066 printf (_("Data addressing position-independent, GOT far from DP\n"));
13067 break;
13068 default:
13069 printf ("??? (%d)\n", val);
13070 break;
13071 }
13072 return p;
13073
13074 case Tag_ABI_PIC:
f6f0e17b 13075 val = read_uleb128 (p, &len, end);
87779176
JM		 13076 p += len;
13077 printf (" Tag_ABI_PIC: ");
13078 switch (val)
13079 {
13080 case 0:
13081 printf (_("Code addressing position-dependent\n"));
13082 break;
13083 case 1:
13084 printf (_("Code addressing position-independent\n"));
13085 break;
13086 default:
13087 printf ("??? (%d)\n", val);
13088 break;
13089 }
13090 return p;
13091
13092 case Tag_ABI_array_object_alignment:
f6f0e17b 13093 val = read_uleb128 (p, &len, end);
87779176
JM		 13094 p += len;
13095 printf (" Tag_ABI_array_object_alignment: ");
13096 switch (val)
13097 {
13098 case 0:
13099 printf (_("8-byte\n"));
13100 break;
13101 case 1:
13102 printf (_("4-byte\n"));
13103 break;
13104 case 2:
13105 printf (_("16-byte\n"));
13106 break;
13107 default:
13108 printf ("??? (%d)\n", val);
13109 break;
13110 }
13111 return p;
13112
13113 case Tag_ABI_array_object_align_expected:
f6f0e17b 13114 val = read_uleb128 (p, &len, end);
87779176
JM		 13115 p += len;
13116 printf (" Tag_ABI_array_object_align_expected: ");
13117 switch (val)
13118 {
13119 case 0:
13120 printf (_("8-byte\n"));
13121 break;
13122 case 1:
13123 printf (_("4-byte\n"));
13124 break;
13125 case 2:
13126 printf (_("16-byte\n"));
13127 break;
13128 default:
13129 printf ("??? (%d)\n", val);
13130 break;
13131 }
13132 return p;
13133
3cbd1c06 13134 case Tag_ABI_compatibility:
071436c6 13135 {
071436c6
NC		 13136 val = read_uleb128 (p, &len, end);
13137 p += len;
13138 printf (" Tag_ABI_compatibility: ");
071436c6 13139 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13140 if (p < end - 1)
13141 {
13142 size_t maxlen = (end - p) - 1;
13143
13144 print_symbol ((int) maxlen, (const char *) p);
13145 p += strnlen ((char *) p, maxlen) + 1;
13146 }
13147 else
13148 {
13149 printf (_("<corrupt>"));
13150 p = (unsigned char *) end;
13151 }
071436c6 13152 putchar ('\n');
071436c6
NC		 13153 return p;
13154 }
87779176
JM		 13155
13156 case Tag_ABI_conformance:
071436c6 13157 {
4082ef84
NC		 13158 printf (" Tag_ABI_conformance: \"");
13159 if (p < end - 1)
13160 {
13161 size_t maxlen = (end - p) - 1;
071436c6 13162
4082ef84
NC		 13163 print_symbol ((int) maxlen, (const char *) p);
13164 p += strnlen ((char *) p, maxlen) + 1;
13165 }
13166 else
13167 {
13168 printf (_("<corrupt>"));
13169 p = (unsigned char *) end;
13170 }
071436c6 13171 printf ("\"\n");
071436c6
NC		 13172 return p;
13173 }
59e6276b
JM		 13174 }
13175
f6f0e17b
NC		 13176 return display_tag_value (tag, p, end);
13177}
59e6276b 13178
f6f0e17b
NC		 13179static void
13180display_raw_attribute (unsigned char * p, unsigned char * end)
13181{
13182 unsigned long addr = 0;
13183 size_t bytes = end - p;
13184
e0a31db1 13185 assert (end > p);
f6f0e17b 13186 while (bytes)
87779176 13187 {
f6f0e17b
NC		 13188 int j;
13189 int k;
13190 int lbytes = (bytes > 16 ? 16 : bytes);
13191
13192 printf (" 0x%8.8lx ", addr);
13193
13194 for (j = 0; j < 16; j++)
13195 {
13196 if (j < lbytes)
13197 printf ("%2.2x", p[j]);
13198 else
13199 printf (" ");
13200
13201 if ((j & 3) == 3)
13202 printf (" ");
13203 }
13204
13205 for (j = 0; j < lbytes; j++)
13206 {
13207 k = p[j];
13208 if (k >= ' ' && k < 0x7f)
13209 printf ("%c", k);
13210 else
13211 printf (".");
13212 }
13213
13214 putchar ('\n');
13215
13216 p += lbytes;
13217 bytes -= lbytes;
13218 addr += lbytes;
87779176 13219 }
59e6276b 13220
f6f0e17b 13221 putchar ('\n');
59e6276b
JM		 13222}
13223
13761a11
NC		 13224static unsigned char *
13225display_msp430x_attribute (unsigned char * p,
13226 const unsigned char * const end)
13227{
13228 unsigned int len;
13229 int val;
13230 int tag;
13231
13232 tag = read_uleb128 (p, & len, end);
13233 p += len;
0b4362b0 13234
13761a11
NC		 13235 switch (tag)
13236 {
13237 case OFBA_MSPABI_Tag_ISA:
13238 val = read_uleb128 (p, &len, end);
13239 p += len;
13240 printf (" Tag_ISA: ");
13241 switch (val)
13242 {
13243 case 0: printf (_("None\n")); break;
13244 case 1: printf (_("MSP430\n")); break;
13245 case 2: printf (_("MSP430X\n")); break;
13246 default: printf ("??? (%d)\n", val); break;
13247 }
13248 break;
13249
13250 case OFBA_MSPABI_Tag_Code_Model:
13251 val = read_uleb128 (p, &len, end);
13252 p += len;
13253 printf (" Tag_Code_Model: ");
13254 switch (val)
13255 {
13256 case 0: printf (_("None\n")); break;
13257 case 1: printf (_("Small\n")); break;
13258 case 2: printf (_("Large\n")); break;
13259 default: printf ("??? (%d)\n", val); break;
13260 }
13261 break;
13262
13263 case OFBA_MSPABI_Tag_Data_Model:
13264 val = read_uleb128 (p, &len, end);
13265 p += len;
13266 printf (" Tag_Data_Model: ");
13267 switch (val)
13268 {
13269 case 0: printf (_("None\n")); break;
13270 case 1: printf (_("Small\n")); break;
13271 case 2: printf (_("Large\n")); break;
13272 case 3: printf (_("Restricted Large\n")); break;
13273 default: printf ("??? (%d)\n", val); break;
13274 }
13275 break;
13276
13277 default:
13278 printf (_(" <unknown tag %d>: "), tag);
13279
13280 if (tag & 1)
13281 {
071436c6 13282 putchar ('"');
4082ef84
NC		 13283 if (p < end - 1)
13284 {
13285 size_t maxlen = (end - p) - 1;
13286
13287 print_symbol ((int) maxlen, (const char *) p);
13288 p += strnlen ((char *) p, maxlen) + 1;
13289 }
13290 else
13291 {
13292 printf (_("<corrupt>"));
13293 p = (unsigned char *) end;
13294 }
071436c6 13295 printf ("\"\n");
13761a11
NC		 13296 }
13297 else
13298 {
13299 val = read_uleb128 (p, &len, end);
13300 p += len;
13301 printf ("%d (0x%x)\n", val, val);
13302 }
13303 break;
13304 }
13305
4082ef84 13306 assert (p <= end);
13761a11
NC		 13307 return p;
13308}
13309
11c1ff18 13310static int
60bca95a
NC		 13311process_attributes (FILE * file,
13312 const char * public_name,
104d59d1 13313 unsigned int proc_type,
f6f0e17b
NC		 13314 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13315 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13316{
2cf0635d 13317 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13318 unsigned i;
13319
13320 /* Find the section header so that we get the size. */
13321 for (i = 0, sect = section_headers;
13322 i < elf_header.e_shnum;
13323 i++, sect++)
13324 {
071436c6
NC		 13325 unsigned char * contents;
13326 unsigned char * p;
13327
104d59d1 13328 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13329 continue;
13330
3f5e193b
NC		 13331 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13332 sect->sh_size, _("attributes"));
60bca95a 13333 if (contents == NULL)
11c1ff18 13334 continue;
60bca95a 13335
11c1ff18
PB		 13336 p = contents;
13337 if (*p == 'A')
13338 {
071436c6
NC		 13339 bfd_vma section_len;
13340
13341 section_len = sect->sh_size - 1;
11c1ff18 13342 p++;
60bca95a 13343
071436c6 13344 while (section_len > 0)
11c1ff18 13345 {
071436c6 13346 bfd_vma attr_len;
e9847026 13347 unsigned int namelen;
11c1ff18 13348 bfd_boolean public_section;
104d59d1 13349 bfd_boolean gnu_section;
11c1ff18 13350
071436c6 13351 if (section_len <= 4)
e0a31db1
NC		 13352 {
13353 error (_("Tag section ends prematurely\n"));
13354 break;
13355 }
071436c6 13356 attr_len = byte_get (p, 4);
11c1ff18 13357 p += 4;
60bca95a 13358
071436c6 13359 if (attr_len > section_len)
11c1ff18 13360 {
071436c6
NC		 13361 error (_("Bad attribute length (%u > %u)\n"),
13362 (unsigned) attr_len, (unsigned) section_len);
13363 attr_len = section_len;
11c1ff18 13364 }
74e1a04b 13365 /* PR 17531: file: 001-101425-0.004 */
071436c6 13366 else if (attr_len < 5)
74e1a04b 13367 {
071436c6 13368 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13369 break;
13370 }
e9847026 13371
071436c6
NC		 13372 section_len -= attr_len;
13373 attr_len -= 4;
13374
13375 namelen = strnlen ((char *) p, attr_len) + 1;
13376 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13377 {
13378 error (_("Corrupt attribute section name\n"));
13379 break;
13380 }
13381
071436c6
NC		 13382 printf (_("Attribute Section: "));
13383 print_symbol (INT_MAX, (const char *) p);
13384 putchar ('\n');
60bca95a
NC		 13385
13386 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13387 public_section = TRUE;
13388 else
13389 public_section = FALSE;
60bca95a
NC		 13390
13391 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13392 gnu_section = TRUE;
13393 else
13394 gnu_section = FALSE;
60bca95a 13395
11c1ff18 13396 p += namelen;
071436c6 13397 attr_len -= namelen;
e0a31db1 13398
071436c6 13399 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13400 {
e0a31db1 13401 int tag;
11c1ff18
PB		 13402 int val;
13403 bfd_vma size;
071436c6 13404 unsigned char * end;
60bca95a 13405
e0a31db1 13406 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13407 if (attr_len < 6)
e0a31db1
NC		 13408 {
13409 error (_("Unused bytes at end of section\n"));
13410 section_len = 0;
13411 break;
13412 }
13413
13414 tag = *(p++);
11c1ff18 13415 size = byte_get (p, 4);
071436c6 13416 if (size > attr_len)
11c1ff18 13417 {
e9847026 13418 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13419 (unsigned) size, (unsigned) attr_len);
13420 size = attr_len;
11c1ff18 13421 }
e0a31db1
NC		 13422 /* PR binutils/17531: Safe handling of corrupt files. */
13423 if (size < 6)
13424 {
13425 error (_("Bad subsection length (%u < 6)\n"),
13426 (unsigned) size);
13427 section_len = 0;
13428 break;
13429 }
60bca95a 13430
071436c6 13431 attr_len -= size;
11c1ff18 13432 end = p + size - 1;
071436c6 13433 assert (end <= contents + sect->sh_size);
11c1ff18 13434 p += 4;
60bca95a 13435
11c1ff18
PB		 13436 switch (tag)
13437 {
13438 case 1:
2b692964 13439 printf (_("File Attributes\n"));
11c1ff18
PB		 13440 break;
13441 case 2:
2b692964 13442 printf (_("Section Attributes:"));
11c1ff18
PB		 13443 goto do_numlist;
13444 case 3:
2b692964 13445 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13446 do_numlist:
13447 for (;;)
13448 {
91d6fa6a 13449 unsigned int j;
60bca95a 13450
f6f0e17b 13451 val = read_uleb128 (p, &j, end);
91d6fa6a 13452 p += j;
11c1ff18
PB		 13453 if (val == 0)
13454 break;
13455 printf (" %d", val);
13456 }
13457 printf ("\n");
13458 break;
13459 default:
2b692964 13460 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13461 public_section = FALSE;
13462 break;
13463 }
60bca95a 13464
071436c6 13465 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13466 {
13467 while (p < end)
f6f0e17b 13468 p = display_pub_attribute (p, end);
071436c6 13469 assert (p <= end);
104d59d1 13470 }
071436c6 13471 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13472 {
13473 while (p < end)
13474 p = display_gnu_attribute (p,
f6f0e17b
NC		 13475 display_proc_gnu_attribute,
13476 end);
071436c6 13477 assert (p <= end);
11c1ff18 13478 }
071436c6 13479 else if (p < end)
11c1ff18 13480 {
071436c6 13481 printf (_(" Unknown attribute:\n"));
f6f0e17b 13482 display_raw_attribute (p, end);
11c1ff18
PB		 13483 p = end;
13484 }
071436c6
NC		 13485 else
13486 attr_len = 0;
11c1ff18
PB		 13487 }
13488 }
13489 }
13490 else
e9847026 13491 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13492
60bca95a 13493 free (contents);
11c1ff18
PB		 13494 }
13495 return 1;
13496}
13497
104d59d1 13498static int
2cf0635d 13499process_arm_specific (FILE * file)
104d59d1
JM		 13500{
13501 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13502 display_arm_attribute, NULL);
13503}
13504
34c8bcba 13505static int
2cf0635d 13506process_power_specific (FILE * file)
34c8bcba
JM		 13507{
13508 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13509 display_power_gnu_attribute);
13510}
13511
9e8c70f9
DM		 13512static int
13513process_sparc_specific (FILE * file)
13514{
13515 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13516 display_sparc_gnu_attribute);
13517}
13518
59e6276b
JM		 13519static int
13520process_tic6x_specific (FILE * file)
13521{
13522 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13523 display_tic6x_attribute, NULL);
13524}
13525
13761a11
NC		 13526static int
13527process_msp430x_specific (FILE * file)
13528{
13529 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13530 display_msp430x_attribute, NULL);
13531}
13532
ccb4c951
RS		 13533/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13534 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13535 and return the VMA of the next entry, or -1 if there was a problem.
13536 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13537
13538static bfd_vma
82b1b41b
NC		 13539print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13540 unsigned char * data_end)
ccb4c951
RS		 13541{
13542 printf (" ");
13543 print_vma (addr, LONG_HEX);
13544 printf (" ");
13545 if (addr < pltgot + 0xfff0)
13546 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13547 else
13548 printf ("%10s", "");
13549 printf (" ");
13550 if (data == NULL)
2b692964 13551 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13552 else
13553 {
13554 bfd_vma entry;
82b1b41b 13555 unsigned char * from = data + addr - pltgot;
ccb4c951 13556
82b1b41b
NC		 13557 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13558 {
13559 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13560 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13561 return (bfd_vma) -1;
13562 }
13563 else
13564 {
13565 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13566 print_vma (entry, LONG_HEX);
13567 }
ccb4c951
RS		 13568 }
13569 return addr + (is_32bit_elf ? 4 : 8);
13570}
13571
861fb55a
DJ		 13572/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13573 PLTGOT. Print the Address and Initial fields of an entry at VMA
13574 ADDR and return the VMA of the next entry. */
13575
13576static bfd_vma
2cf0635d 13577print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13578{
13579 printf (" ");
13580 print_vma (addr, LONG_HEX);
13581 printf (" ");
13582 if (data == NULL)
2b692964 13583 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13584 else
13585 {
13586 bfd_vma entry;
13587
13588 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13589 print_vma (entry, LONG_HEX);
13590 }
13591 return addr + (is_32bit_elf ? 4 : 8);
13592}
13593
351cdf24
MF		 13594static void
13595print_mips_ases (unsigned int mask)
13596{
13597 if (mask & AFL_ASE_DSP)
13598 fputs ("\n\tDSP ASE", stdout);
13599 if (mask & AFL_ASE_DSPR2)
13600 fputs ("\n\tDSP R2 ASE", stdout);
13601 if (mask & AFL_ASE_EVA)
13602 fputs ("\n\tEnhanced VA Scheme", stdout);
13603 if (mask & AFL_ASE_MCU)
13604 fputs ("\n\tMCU (MicroController) ASE", stdout);
13605 if (mask & AFL_ASE_MDMX)
13606 fputs ("\n\tMDMX ASE", stdout);
13607 if (mask & AFL_ASE_MIPS3D)
13608 fputs ("\n\tMIPS-3D ASE", stdout);
13609 if (mask & AFL_ASE_MT)
13610 fputs ("\n\tMT ASE", stdout);
13611 if (mask & AFL_ASE_SMARTMIPS)
13612 fputs ("\n\tSmartMIPS ASE", stdout);
13613 if (mask & AFL_ASE_VIRT)
13614 fputs ("\n\tVZ ASE", stdout);
13615 if (mask & AFL_ASE_MSA)
13616 fputs ("\n\tMSA ASE", stdout);
13617 if (mask & AFL_ASE_MIPS16)
13618 fputs ("\n\tMIPS16 ASE", stdout);
13619 if (mask & AFL_ASE_MICROMIPS)
13620 fputs ("\n\tMICROMIPS ASE", stdout);
13621 if (mask & AFL_ASE_XPA)
13622 fputs ("\n\tXPA ASE", stdout);
13623 if (mask == 0)
13624 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13625 else if ((mask & ~AFL_ASE_MASK) != 0)
13626 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13627}
13628
13629static void
13630print_mips_isa_ext (unsigned int isa_ext)
13631{
13632 switch (isa_ext)
13633 {
13634 case 0:
13635 fputs (_("None"), stdout);
13636 break;
13637 case AFL_EXT_XLR:
13638 fputs ("RMI XLR", stdout);
13639 break;
2c629856
N		 13640 case AFL_EXT_OCTEON3:
13641 fputs ("Cavium Networks Octeon3", stdout);
13642 break;
351cdf24
MF		 13643 case AFL_EXT_OCTEON2:
13644 fputs ("Cavium Networks Octeon2", stdout);
13645 break;
13646 case AFL_EXT_OCTEONP:
13647 fputs ("Cavium Networks OcteonP", stdout);
13648 break;
13649 case AFL_EXT_LOONGSON_3A:
13650 fputs ("Loongson 3A", stdout);
13651 break;
13652 case AFL_EXT_OCTEON:
13653 fputs ("Cavium Networks Octeon", stdout);
13654 break;
13655 case AFL_EXT_5900:
13656 fputs ("Toshiba R5900", stdout);
13657 break;
13658 case AFL_EXT_4650:
13659 fputs ("MIPS R4650", stdout);
13660 break;
13661 case AFL_EXT_4010:
13662 fputs ("LSI R4010", stdout);
13663 break;
13664 case AFL_EXT_4100:
13665 fputs ("NEC VR4100", stdout);
13666 break;
13667 case AFL_EXT_3900:
13668 fputs ("Toshiba R3900", stdout);
13669 break;
13670 case AFL_EXT_10000:
13671 fputs ("MIPS R10000", stdout);
13672 break;
13673 case AFL_EXT_SB1:
13674 fputs ("Broadcom SB-1", stdout);
13675 break;
13676 case AFL_EXT_4111:
13677 fputs ("NEC VR4111/VR4181", stdout);
13678 break;
13679 case AFL_EXT_4120:
13680 fputs ("NEC VR4120", stdout);
13681 break;
13682 case AFL_EXT_5400:
13683 fputs ("NEC VR5400", stdout);
13684 break;
13685 case AFL_EXT_5500:
13686 fputs ("NEC VR5500", stdout);
13687 break;
13688 case AFL_EXT_LOONGSON_2E:
13689 fputs ("ST Microelectronics Loongson 2E", stdout);
13690 break;
13691 case AFL_EXT_LOONGSON_2F:
13692 fputs ("ST Microelectronics Loongson 2F", stdout);
13693 break;
13694 default:
00ac7aa0 13695 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13696 }
13697}
13698
13699static int
13700get_mips_reg_size (int reg_size)
13701{
13702 return (reg_size == AFL_REG_NONE) ? 0
13703 : (reg_size == AFL_REG_32) ? 32
13704 : (reg_size == AFL_REG_64) ? 64
13705 : (reg_size == AFL_REG_128) ? 128
13706 : -1;
13707}
13708
19e6b90e 13709static int
2cf0635d 13710process_mips_specific (FILE * file)
5b18a4bc 13711{
2cf0635d 13712 Elf_Internal_Dyn * entry;
351cdf24 13713 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13714 size_t liblist_offset = 0;
13715 size_t liblistno = 0;
13716 size_t conflictsno = 0;
13717 size_t options_offset = 0;
13718 size_t conflicts_offset = 0;
861fb55a
DJ		 13719 size_t pltrelsz = 0;
13720 size_t pltrel = 0;
ccb4c951 13721 bfd_vma pltgot = 0;
861fb55a
DJ		 13722 bfd_vma mips_pltgot = 0;
13723 bfd_vma jmprel = 0;
ccb4c951
RS		 13724 bfd_vma local_gotno = 0;
13725 bfd_vma gotsym = 0;
13726 bfd_vma symtabno = 0;
103f02d3 13727
2cf19d5c
JM		 13728 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13729 display_mips_gnu_attribute);
13730
351cdf24
MF		 13731 sect = find_section (".MIPS.abiflags");
13732
13733 if (sect != NULL)
13734 {
13735 Elf_External_ABIFlags_v0 *abiflags_ext;
13736 Elf_Internal_ABIFlags_v0 abiflags_in;
13737
13738 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13739 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13740 else
13741 {
13742 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13743 sect->sh_size, _("MIPS ABI Flags section"));
13744 if (abiflags_ext)
13745 {
13746 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13747 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13748 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13749 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13750 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13751 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13752 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13753 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13754 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13755 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13756 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13757
13758 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13759 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13760 if (abiflags_in.isa_rev > 1)
13761 printf ("r%d", abiflags_in.isa_rev);
13762 printf ("\nGPR size: %d",
13763 get_mips_reg_size (abiflags_in.gpr_size));
13764 printf ("\nCPR1 size: %d",
13765 get_mips_reg_size (abiflags_in.cpr1_size));
13766 printf ("\nCPR2 size: %d",
13767 get_mips_reg_size (abiflags_in.cpr2_size));
13768 fputs ("\nFP ABI: ", stdout);
13769 print_mips_fp_abi_value (abiflags_in.fp_abi);
13770 fputs ("ISA Extension: ", stdout);
13771 print_mips_isa_ext (abiflags_in.isa_ext);
13772 fputs ("\nASEs:", stdout);
13773 print_mips_ases (abiflags_in.ases);
13774 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13775 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13776 fputc ('\n', stdout);
13777 free (abiflags_ext);
13778 }
13779 }
13780 }
13781
19e6b90e
L		 13782 /* We have a lot of special sections. Thanks SGI! */
13783 if (dynamic_section == NULL)
13784 /* No information available. */
13785 return 0;
252b5132 13786
071436c6
NC		 13787 for (entry = dynamic_section;
13788 /* PR 17531 file: 012-50589-0.004. */
13789 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13790 ++entry)
252b5132
RH		 13791 switch (entry->d_tag)
13792 {
13793 case DT_MIPS_LIBLIST:
d93f0186
NC		 13794 liblist_offset
13795 = offset_from_vma (file, entry->d_un.d_val,
13796 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13797 break;
13798 case DT_MIPS_LIBLISTNO:
13799 liblistno = entry->d_un.d_val;
13800 break;
13801 case DT_MIPS_OPTIONS:
d93f0186 13802 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13803 break;
13804 case DT_MIPS_CONFLICT:
d93f0186
NC		 13805 conflicts_offset
13806 = offset_from_vma (file, entry->d_un.d_val,
13807 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13808 break;
13809 case DT_MIPS_CONFLICTNO:
13810 conflictsno = entry->d_un.d_val;
13811 break;
ccb4c951 13812 case DT_PLTGOT:
861fb55a
DJ		 13813 pltgot = entry->d_un.d_ptr;
13814 break;
ccb4c951
RS		 13815 case DT_MIPS_LOCAL_GOTNO:
13816 local_gotno = entry->d_un.d_val;
13817 break;
13818 case DT_MIPS_GOTSYM:
13819 gotsym = entry->d_un.d_val;
13820 break;
13821 case DT_MIPS_SYMTABNO:
13822 symtabno = entry->d_un.d_val;
13823 break;
861fb55a
DJ		 13824 case DT_MIPS_PLTGOT:
13825 mips_pltgot = entry->d_un.d_ptr;
13826 break;
13827 case DT_PLTREL:
13828 pltrel = entry->d_un.d_val;
13829 break;
13830 case DT_PLTRELSZ:
13831 pltrelsz = entry->d_un.d_val;
13832 break;
13833 case DT_JMPREL:
13834 jmprel = entry->d_un.d_ptr;
13835 break;
252b5132
RH		 13836 default:
13837 break;
13838 }
13839
13840 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13841 {
2cf0635d 13842 Elf32_External_Lib * elib;
252b5132
RH		 13843 size_t cnt;
13844
3f5e193b
NC		 13845 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13846 liblistno,
13847 sizeof (Elf32_External_Lib),
9cf03b7e 13848 _("liblist section data"));
a6e9f9df 13849 if (elib)
252b5132 13850 {
2b692964 13851 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13852 (unsigned long) liblistno);
2b692964 13853 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13854 stdout);
13855
13856 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13857 {
a6e9f9df 13858 Elf32_Lib liblist;
91d6fa6a 13859 time_t atime;
a6e9f9df 13860 char timebuf[20];
2cf0635d 13861 struct tm * tmp;
a6e9f9df
AM		 13862
13863 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13864 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13865 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13866 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13867 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13868
91d6fa6a 13869 tmp = gmtime (&atime);
e9e44622
JJ		 13870 snprintf (timebuf, sizeof (timebuf),
13871 "%04u-%02u-%02uT%02u:%02u:%02u",
13872 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13873 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13874
31104126 13875 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13876 if (VALID_DYNAMIC_NAME (liblist.l_name))
13877 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13878 else
2b692964 13879 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13880 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13881 liblist.l_version);
a6e9f9df
AM		 13882
13883 if (liblist.l_flags == 0)
2b692964 13884 puts (_(" NONE"));
a6e9f9df
AM		 13885 else
13886 {
13887 static const struct
252b5132 13888 {
2cf0635d 13889 const char * name;
a6e9f9df 13890 int bit;
252b5132 13891 }
a6e9f9df
AM		 13892 l_flags_vals[] =
13893 {
13894 { " EXACT_MATCH", LL_EXACT_MATCH },
13895 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13896 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13897 { " EXPORTS", LL_EXPORTS },
13898 { " DELAY_LOAD", LL_DELAY_LOAD },
13899 { " DELTA", LL_DELTA }
13900 };
13901 int flags = liblist.l_flags;
13902 size_t fcnt;
13903
60bca95a 13904 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13905 if ((flags & l_flags_vals[fcnt].bit) != 0)
13906 {
13907 fputs (l_flags_vals[fcnt].name, stdout);
13908 flags ^= l_flags_vals[fcnt].bit;
13909 }
13910 if (flags != 0)
13911 printf (" %#x", (unsigned int) flags);
252b5132 13912
a6e9f9df
AM		 13913 puts ("");
13914 }
252b5132 13915 }
252b5132 13916
a6e9f9df
AM		 13917 free (elib);
13918 }
252b5132
RH		 13919 }
13920
13921 if (options_offset != 0)
13922 {
2cf0635d 13923 Elf_External_Options * eopt;
2cf0635d
NC		 13924 Elf_Internal_Options * iopt;
13925 Elf_Internal_Options * option;
252b5132
RH		 13926 size_t offset;
13927 int cnt;
351cdf24 13928 sect = section_headers;
252b5132
RH		 13929
13930 /* Find the section header so that we get the size. */
071436c6 13931 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 13932 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 13933 if (sect == NULL)
13934 {
13935 error (_("No MIPS_OPTIONS header found\n"));
13936 return 0;
13937 }
252b5132 13938
3f5e193b
NC		 13939 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13940 sect->sh_size, _("options"));
a6e9f9df 13941 if (eopt)
252b5132 13942 {
3f5e193b
NC		 13943 iopt = (Elf_Internal_Options *)
13944 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13945 if (iopt == NULL)
13946 {
8b73c356 13947 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 13948 return 0;
13949 }
76da6bbe 13950
a6e9f9df
AM		 13951 offset = cnt = 0;
13952 option = iopt;
252b5132 13953
82b1b41b 13954 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 13955 {
2cf0635d 13956 Elf_External_Options * eoption;
252b5132 13957
a6e9f9df 13958 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13959
a6e9f9df
AM		 13960 option->kind = BYTE_GET (eoption->kind);
13961 option->size = BYTE_GET (eoption->size);
13962 option->section = BYTE_GET (eoption->section);
13963 option->info = BYTE_GET (eoption->info);
76da6bbe 13964
82b1b41b
NC		 13965 /* PR 17531: file: ffa0fa3b. */
13966 if (option->size < sizeof (* eopt)
13967 || offset + option->size > sect->sh_size)
13968 {
55325047
NC		 13969 error (_("Invalid size (%u) for MIPS option\n"), option->size);
13970 return 0;
82b1b41b 13971 }
a6e9f9df 13972 offset += option->size;
82b1b41b 13973
a6e9f9df
AM		 13974 ++option;
13975 ++cnt;
13976 }
252b5132 13977
a6e9f9df 13978 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 13979 printable_section_name (sect), cnt);
76da6bbe 13980
a6e9f9df 13981 option = iopt;
82b1b41b 13982 offset = 0;
252b5132 13983
a6e9f9df 13984 while (cnt-- > 0)
252b5132 13985 {
a6e9f9df
AM		 13986 size_t len;
13987
13988 switch (option->kind)
252b5132 13989 {
a6e9f9df
AM		 13990 case ODK_NULL:
13991 /* This shouldn't happen. */
13992 printf (" NULL %d %lx", option->section, option->info);
13993 break;
13994 case ODK_REGINFO:
13995 printf (" REGINFO ");
13996 if (elf_header.e_machine == EM_MIPS)
13997 {
13998 /* 32bit form. */
2cf0635d 13999 Elf32_External_RegInfo * ereg;
b34976b6 14000 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14001
14002 ereg = (Elf32_External_RegInfo *) (option + 1);
14003 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14004 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14005 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14006 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14007 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14008 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14009
14010 printf ("GPR %08lx GP 0x%lx\n",
14011 reginfo.ri_gprmask,
14012 (unsigned long) reginfo.ri_gp_value);
14013 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14014 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14015 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14016 }
14017 else
14018 {
14019 /* 64 bit form. */
2cf0635d 14020 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14021 Elf64_Internal_RegInfo reginfo;
14022
14023 ereg = (Elf64_External_RegInfo *) (option + 1);
14024 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14025 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14026 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14027 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14028 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14029 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14030
14031 printf ("GPR %08lx GP 0x",
14032 reginfo.ri_gprmask);
14033 printf_vma (reginfo.ri_gp_value);
14034 printf ("\n");
14035
14036 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14037 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14038 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14039 }
14040 ++option;
14041 continue;
14042 case ODK_EXCEPTIONS:
14043 fputs (" EXCEPTIONS fpe_min(", stdout);
14044 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14045 fputs (") fpe_max(", stdout);
14046 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14047 fputs (")", stdout);
14048
14049 if (option->info & OEX_PAGE0)
14050 fputs (" PAGE0", stdout);
14051 if (option->info & OEX_SMM)
14052 fputs (" SMM", stdout);
14053 if (option->info & OEX_FPDBUG)
14054 fputs (" FPDBUG", stdout);
14055 if (option->info & OEX_DISMISS)
14056 fputs (" DISMISS", stdout);
14057 break;
14058 case ODK_PAD:
14059 fputs (" PAD ", stdout);
14060 if (option->info & OPAD_PREFIX)
14061 fputs (" PREFIX", stdout);
14062 if (option->info & OPAD_POSTFIX)
14063 fputs (" POSTFIX", stdout);
14064 if (option->info & OPAD_SYMBOL)
14065 fputs (" SYMBOL", stdout);
14066 break;
14067 case ODK_HWPATCH:
14068 fputs (" HWPATCH ", stdout);
14069 if (option->info & OHW_R4KEOP)
14070 fputs (" R4KEOP", stdout);
14071 if (option->info & OHW_R8KPFETCH)
14072 fputs (" R8KPFETCH", stdout);
14073 if (option->info & OHW_R5KEOP)
14074 fputs (" R5KEOP", stdout);
14075 if (option->info & OHW_R5KCVTL)
14076 fputs (" R5KCVTL", stdout);
14077 break;
14078 case ODK_FILL:
14079 fputs (" FILL ", stdout);
14080 /* XXX Print content of info word? */
14081 break;
14082 case ODK_TAGS:
14083 fputs (" TAGS ", stdout);
14084 /* XXX Print content of info word? */
14085 break;
14086 case ODK_HWAND:
14087 fputs (" HWAND ", stdout);
14088 if (option->info & OHWA0_R4KEOP_CHECKED)
14089 fputs (" R4KEOP_CHECKED", stdout);
14090 if (option->info & OHWA0_R4KEOP_CLEAN)
14091 fputs (" R4KEOP_CLEAN", stdout);
14092 break;
14093 case ODK_HWOR:
14094 fputs (" HWOR ", stdout);
14095 if (option->info & OHWA0_R4KEOP_CHECKED)
14096 fputs (" R4KEOP_CHECKED", stdout);
14097 if (option->info & OHWA0_R4KEOP_CLEAN)
14098 fputs (" R4KEOP_CLEAN", stdout);
14099 break;
14100 case ODK_GP_GROUP:
14101 printf (" GP_GROUP %#06lx self-contained %#06lx",
14102 option->info & OGP_GROUP,
14103 (option->info & OGP_SELF) >> 16);
14104 break;
14105 case ODK_IDENT:
14106 printf (" IDENT %#06lx self-contained %#06lx",
14107 option->info & OGP_GROUP,
14108 (option->info & OGP_SELF) >> 16);
14109 break;
14110 default:
14111 /* This shouldn't happen. */
14112 printf (" %3d ??? %d %lx",
14113 option->kind, option->section, option->info);
14114 break;
252b5132 14115 }
a6e9f9df 14116
2cf0635d 14117 len = sizeof (* eopt);
a6e9f9df 14118 while (len < option->size)
82b1b41b
NC		 14119 {
14120 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14121
82b1b41b
NC		 14122 if (ISPRINT (datum))
14123 printf ("%c", datum);
14124 else
14125 printf ("\\%03o", datum);
14126 len ++;
14127 }
a6e9f9df 14128 fputs ("\n", stdout);
82b1b41b
NC		 14129
14130 offset += option->size;
252b5132 14131 ++option;
252b5132
RH		 14132 }
14133
a6e9f9df 14134 free (eopt);
252b5132 14135 }
252b5132
RH		 14136 }
14137
14138 if (conflicts_offset != 0 && conflictsno != 0)
14139 {
2cf0635d 14140 Elf32_Conflict * iconf;
252b5132
RH		 14141 size_t cnt;
14142
14143 if (dynamic_symbols == NULL)
14144 {
591a748a 14145 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14146 return 0;
14147 }
14148
3f5e193b 14149 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14150 if (iconf == NULL)
14151 {
8b73c356 14152 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14153 return 0;
14154 }
14155
9ea033b2 14156 if (is_32bit_elf)
252b5132 14157 {
2cf0635d 14158 Elf32_External_Conflict * econf32;
a6e9f9df 14159
3f5e193b
NC		 14160 econf32 = (Elf32_External_Conflict *)
14161 get_data (NULL, file, conflicts_offset, conflictsno,
14162 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14163 if (!econf32)
14164 return 0;
252b5132
RH		 14165
14166 for (cnt = 0; cnt < conflictsno; ++cnt)
14167 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14168
14169 free (econf32);
252b5132
RH		 14170 }
14171 else
14172 {
2cf0635d 14173 Elf64_External_Conflict * econf64;
a6e9f9df 14174
3f5e193b
NC		 14175 econf64 = (Elf64_External_Conflict *)
14176 get_data (NULL, file, conflicts_offset, conflictsno,
14177 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14178 if (!econf64)
14179 return 0;
252b5132
RH		 14180
14181 for (cnt = 0; cnt < conflictsno; ++cnt)
14182 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14183
14184 free (econf64);
252b5132
RH		 14185 }
14186
c7e7ca54
NC		 14187 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14188 (unsigned long) conflictsno);
252b5132
RH		 14189 puts (_(" Num: Index Value Name"));
14190
14191 for (cnt = 0; cnt < conflictsno; ++cnt)
14192 {
b34976b6 14193 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14194
14195 if (iconf[cnt] >= num_dynamic_syms)
14196 printf (_("<corrupt symbol index>"));
d79b3d50 14197 else
e0a31db1
NC		 14198 {
14199 Elf_Internal_Sym * psym;
14200
14201 psym = & dynamic_symbols[iconf[cnt]];
14202 print_vma (psym->st_value, FULL_HEX);
14203 putchar (' ');
14204 if (VALID_DYNAMIC_NAME (psym->st_name))
14205 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14206 else
14207 printf (_("<corrupt: %14ld>"), psym->st_name);
14208 }
31104126 14209 putchar ('\n');
252b5132
RH		 14210 }
14211
252b5132
RH		 14212 free (iconf);
14213 }
14214
ccb4c951
RS		 14215 if (pltgot != 0 && local_gotno != 0)
14216 {
91d6fa6a 14217 bfd_vma ent, local_end, global_end;
bbeee7ea 14218 size_t i, offset;
2cf0635d 14219 unsigned char * data;
82b1b41b 14220 unsigned char * data_end;
bbeee7ea 14221 int addr_size;
ccb4c951 14222
91d6fa6a 14223 ent = pltgot;
ccb4c951
RS		 14224 addr_size = (is_32bit_elf ? 4 : 8);
14225 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14226
74e1a04b
NC		 14227 /* PR binutils/17533 file: 012-111227-0.004 */
14228 if (symtabno < gotsym)
14229 {
14230 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14231 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14232 return 0;
14233 }
82b1b41b 14234
74e1a04b 14235 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14236 /* PR 17531: file: 54c91a34. */
14237 if (global_end < local_end)
14238 {
14239 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14240 return 0;
14241 }
948f632f 14242
ccb4c951 14243 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14244 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14245 global_end - pltgot, 1,
14246 _("Global Offset Table data"));
59245841
NC		 14247 if (data == NULL)
14248 return 0;
82b1b41b 14249 data_end = data + (global_end - pltgot);
59245841 14250
ccb4c951
RS		 14251 printf (_("\nPrimary GOT:\n"));
14252 printf (_(" Canonical gp value: "));
14253 print_vma (pltgot + 0x7ff0, LONG_HEX);
14254 printf ("\n\n");
14255
14256 printf (_(" Reserved entries:\n"));
14257 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14258 addr_size * 2, _("Address"), _("Access"),
14259 addr_size * 2, _("Initial"));
82b1b41b 14260 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14261 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14262 if (ent == (bfd_vma) -1)
14263 goto got_print_fail;
ccb4c951 14264 if (data
91d6fa6a 14265 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14266 >> (addr_size * 8 - 1)) != 0)
14267 {
82b1b41b 14268 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14269 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14270 if (ent == (bfd_vma) -1)
14271 goto got_print_fail;
ccb4c951
RS		 14272 }
14273 printf ("\n");
14274
91d6fa6a 14275 if (ent < local_end)
ccb4c951
RS		 14276 {
14277 printf (_(" Local entries:\n"));
cc5914eb 14278 printf (" %*s %10s %*s\n",
2b692964
NC		 14279 addr_size * 2, _("Address"), _("Access"),
14280 addr_size * 2, _("Initial"));
91d6fa6a 14281 while (ent < local_end)
ccb4c951 14282 {
82b1b41b 14283 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14284 printf ("\n");
82b1b41b
NC		 14285 if (ent == (bfd_vma) -1)
14286 goto got_print_fail;
ccb4c951
RS		 14287 }
14288 printf ("\n");
14289 }
14290
14291 if (gotsym < symtabno)
14292 {
14293 int sym_width;
14294
14295 printf (_(" Global entries:\n"));
cc5914eb 14296 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14297 addr_size * 2, _("Address"),
14298 _("Access"),
2b692964 14299 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14300 addr_size * 2, _("Sym.Val."),
14301 _("Type"),
14302 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14303 _("Ndx"), _("Name"));
0b4362b0 14304
ccb4c951 14305 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14306
ccb4c951
RS		 14307 for (i = gotsym; i < symtabno; i++)
14308 {
82b1b41b 14309 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14310 printf (" ");
e0a31db1
NC		 14311
14312 if (dynamic_symbols == NULL)
14313 printf (_("<no dynamic symbols>"));
14314 else if (i < num_dynamic_syms)
14315 {
14316 Elf_Internal_Sym * psym = dynamic_symbols + i;
14317
14318 print_vma (psym->st_value, LONG_HEX);
14319 printf (" %-7s %3s ",
14320 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14321 get_symbol_index_type (psym->st_shndx));
14322
14323 if (VALID_DYNAMIC_NAME (psym->st_name))
14324 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14325 else
14326 printf (_("<corrupt: %14ld>"), psym->st_name);
14327 }
ccb4c951 14328 else
7fc5ac57
JBG		 14329 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14330 (unsigned long) i);
e0a31db1 14331
ccb4c951 14332 printf ("\n");
82b1b41b
NC		 14333 if (ent == (bfd_vma) -1)
14334 break;
ccb4c951
RS		 14335 }
14336 printf ("\n");
14337 }
14338
82b1b41b 14339 got_print_fail:
ccb4c951
RS		 14340 if (data)
14341 free (data);
14342 }
14343
861fb55a
DJ		 14344 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14345 {
91d6fa6a 14346 bfd_vma ent, end;
861fb55a
DJ		 14347 size_t offset, rel_offset;
14348 unsigned long count, i;
2cf0635d 14349 unsigned char * data;
861fb55a 14350 int addr_size, sym_width;
2cf0635d 14351 Elf_Internal_Rela * rels;
861fb55a
DJ		 14352
14353 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14354 if (pltrel == DT_RELA)
14355 {
14356 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14357 return 0;
14358 }
14359 else
14360 {
14361 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14362 return 0;
14363 }
14364
91d6fa6a 14365 ent = mips_pltgot;
861fb55a
DJ		 14366 addr_size = (is_32bit_elf ? 4 : 8);
14367 end = mips_pltgot + (2 + count) * addr_size;
14368
14369 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14370 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14371 1, _("Procedure Linkage Table data"));
59245841
NC		 14372 if (data == NULL)
14373 return 0;
14374
9cf03b7e 14375 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14376 printf (_(" Reserved entries:\n"));
14377 printf (_(" %*s %*s Purpose\n"),
2b692964 14378 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14379 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14380 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14381 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14382 printf (_(" Module pointer\n"));
861fb55a
DJ		 14383 printf ("\n");
14384
14385 printf (_(" Entries:\n"));
cc5914eb 14386 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14387 addr_size * 2, _("Address"),
14388 addr_size * 2, _("Initial"),
14389 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14390 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14391 for (i = 0; i < count; i++)
14392 {
df97ab2a 14393 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14394
91d6fa6a 14395 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14396 printf (" ");
e0a31db1 14397
df97ab2a
MF		 14398 if (idx >= num_dynamic_syms)
14399 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14400 else
e0a31db1 14401 {
df97ab2a 14402 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14403
14404 print_vma (psym->st_value, LONG_HEX);
14405 printf (" %-7s %3s ",
14406 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14407 get_symbol_index_type (psym->st_shndx));
14408 if (VALID_DYNAMIC_NAME (psym->st_name))
14409 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14410 else
14411 printf (_("<corrupt: %14ld>"), psym->st_name);
14412 }
861fb55a
DJ		 14413 printf ("\n");
14414 }
14415 printf ("\n");
14416
14417 if (data)
14418 free (data);
14419 free (rels);
14420 }
14421
252b5132
RH		 14422 return 1;
14423}
14424
35c08157
KLC		 14425static int
14426process_nds32_specific (FILE * file)
14427{
14428 Elf_Internal_Shdr *sect = NULL;
14429
14430 sect = find_section (".nds32_e_flags");
14431 if (sect != NULL)
14432 {
14433 unsigned int *flag;
14434
14435 printf ("\nNDS32 elf flags section:\n");
14436 flag = get_data (NULL, file, sect->sh_offset, 1,
14437 sect->sh_size, _("NDS32 elf flags section"));
14438
14439 switch ((*flag) & 0x3)
14440 {
14441 case 0:
14442 printf ("(VEC_SIZE):\tNo entry.\n");
14443 break;
14444 case 1:
14445 printf ("(VEC_SIZE):\t4 bytes\n");
14446 break;
14447 case 2:
14448 printf ("(VEC_SIZE):\t16 bytes\n");
14449 break;
14450 case 3:
14451 printf ("(VEC_SIZE):\treserved\n");
14452 break;
14453 }
14454 }
14455
14456 return TRUE;
14457}
14458
047b2264 14459static int
2cf0635d 14460process_gnu_liblist (FILE * file)
047b2264 14461{
2cf0635d
NC		 14462 Elf_Internal_Shdr * section;
14463 Elf_Internal_Shdr * string_sec;
14464 Elf32_External_Lib * elib;
14465 char * strtab;
c256ffe7 14466 size_t strtab_size;
047b2264
JJ		 14467 size_t cnt;
14468 unsigned i;
14469
14470 if (! do_arch)
14471 return 0;
14472
14473 for (i = 0, section = section_headers;
14474 i < elf_header.e_shnum;
b34976b6 14475 i++, section++)
047b2264
JJ		 14476 {
14477 switch (section->sh_type)
14478 {
14479 case SHT_GNU_LIBLIST:
4fbb74a6 14480 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14481 break;
14482
3f5e193b
NC		 14483 elib = (Elf32_External_Lib *)
14484 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14485 _("liblist section data"));
047b2264
JJ		 14486
14487 if (elib == NULL)
14488 break;
4fbb74a6 14489 string_sec = section_headers + section->sh_link;
047b2264 14490
3f5e193b
NC		 14491 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14492 string_sec->sh_size,
14493 _("liblist string table"));
047b2264
JJ		 14494 if (strtab == NULL
14495 || section->sh_entsize != sizeof (Elf32_External_Lib))
14496 {
14497 free (elib);
2842702f 14498 free (strtab);
047b2264
JJ		 14499 break;
14500 }
59245841 14501 strtab_size = string_sec->sh_size;
047b2264
JJ		 14502
14503 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14504 printable_section_name (section),
0af1713e 14505 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14506
2b692964 14507 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14508
14509 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14510 ++cnt)
14511 {
14512 Elf32_Lib liblist;
91d6fa6a 14513 time_t atime;
047b2264 14514 char timebuf[20];
2cf0635d 14515 struct tm * tmp;
047b2264
JJ		 14516
14517 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14518 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14519 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14520 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14521 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14522
91d6fa6a 14523 tmp = gmtime (&atime);
e9e44622
JJ		 14524 snprintf (timebuf, sizeof (timebuf),
14525 "%04u-%02u-%02uT%02u:%02u:%02u",
14526 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14527 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14528
14529 printf ("%3lu: ", (unsigned long) cnt);
14530 if (do_wide)
c256ffe7 14531 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14532 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14533 else
c256ffe7 14534 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14535 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14536 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14537 liblist.l_version, liblist.l_flags);
14538 }
14539
14540 free (elib);
2842702f 14541 free (strtab);
047b2264
JJ		 14542 }
14543 }
14544
14545 return 1;
14546}
14547
9437c45b 14548static const char *
d3ba0551 14549get_note_type (unsigned e_type)
779fe533
NC		 14550{
14551 static char buff[64];
103f02d3 14552
1ec5cd37
NC		 14553 if (elf_header.e_type == ET_CORE)
14554 switch (e_type)
14555 {
57346661 14556 case NT_AUXV:
1ec5cd37 14557 return _("NT_AUXV (auxiliary vector)");
57346661 14558 case NT_PRSTATUS:
1ec5cd37 14559 return _("NT_PRSTATUS (prstatus structure)");
57346661 14560 case NT_FPREGSET:
1ec5cd37 14561 return _("NT_FPREGSET (floating point registers)");
57346661 14562 case NT_PRPSINFO:
1ec5cd37 14563 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14564 case NT_TASKSTRUCT:
1ec5cd37 14565 return _("NT_TASKSTRUCT (task structure)");
57346661 14566 case NT_PRXFPREG:
1ec5cd37 14567 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14568 case NT_PPC_VMX:
14569 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14570 case NT_PPC_VSX:
14571 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14572 case NT_386_TLS:
14573 return _("NT_386_TLS (x86 TLS information)");
14574 case NT_386_IOPERM:
14575 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14576 case NT_X86_XSTATE:
14577 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14578 case NT_S390_HIGH_GPRS:
14579 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14580 case NT_S390_TIMER:
14581 return _("NT_S390_TIMER (s390 timer register)");
14582 case NT_S390_TODCMP:
14583 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14584 case NT_S390_TODPREG:
14585 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14586 case NT_S390_CTRS:
14587 return _("NT_S390_CTRS (s390 control registers)");
14588 case NT_S390_PREFIX:
14589 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14590 case NT_S390_LAST_BREAK:
14591 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14592 case NT_S390_SYSTEM_CALL:
14593 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14594 case NT_S390_TDB:
14595 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14596 case NT_S390_VXRS_LOW:
14597 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14598 case NT_S390_VXRS_HIGH:
14599 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14600 case NT_ARM_VFP:
14601 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14602 case NT_ARM_TLS:
14603 return _("NT_ARM_TLS (AArch TLS registers)");
14604 case NT_ARM_HW_BREAK:
14605 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14606 case NT_ARM_HW_WATCH:
14607 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14608 case NT_PSTATUS:
1ec5cd37 14609 return _("NT_PSTATUS (pstatus structure)");
57346661 14610 case NT_FPREGS:
1ec5cd37 14611 return _("NT_FPREGS (floating point registers)");
57346661 14612 case NT_PSINFO:
1ec5cd37 14613 return _("NT_PSINFO (psinfo structure)");
57346661 14614 case NT_LWPSTATUS:
1ec5cd37 14615 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14616 case NT_LWPSINFO:
1ec5cd37 14617 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14618 case NT_WIN32PSTATUS:
1ec5cd37 14619 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14620 case NT_SIGINFO:
14621 return _("NT_SIGINFO (siginfo_t data)");
14622 case NT_FILE:
14623 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14624 default:
14625 break;
14626 }
14627 else
14628 switch (e_type)
14629 {
14630 case NT_VERSION:
14631 return _("NT_VERSION (version)");
14632 case NT_ARCH:
14633 return _("NT_ARCH (architecture)");
14634 default:
14635 break;
14636 }
14637
e9e44622 14638 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14639 return buff;
779fe533
NC		 14640}
14641
9ece1fa9
TT		 14642static int
14643print_core_note (Elf_Internal_Note *pnote)
14644{
14645 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14646 bfd_vma count, page_size;
14647 unsigned char *descdata, *filenames, *descend;
14648
14649 if (pnote->type != NT_FILE)
14650 return 1;
14651
14652#ifndef BFD64
14653 if (!is_32bit_elf)
14654 {
14655 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14656 /* Still "successful". */
14657 return 1;
14658 }
14659#endif
14660
14661 if (pnote->descsz < 2 * addr_size)
14662 {
14663 printf (_(" Malformed note - too short for header\n"));
14664 return 0;
14665 }
14666
14667 descdata = (unsigned char *) pnote->descdata;
14668 descend = descdata + pnote->descsz;
14669
14670 if (descdata[pnote->descsz - 1] != '\0')
14671 {
14672 printf (_(" Malformed note - does not end with \\0\n"));
14673 return 0;
14674 }
14675
14676 count = byte_get (descdata, addr_size);
14677 descdata += addr_size;
14678
14679 page_size = byte_get (descdata, addr_size);
14680 descdata += addr_size;
14681
14682 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14683 {
14684 printf (_(" Malformed note - too short for supplied file count\n"));
14685 return 0;
14686 }
14687
14688 printf (_(" Page size: "));
14689 print_vma (page_size, DEC);
14690 printf ("\n");
14691
14692 printf (_(" %*s%*s%*s\n"),
14693 (int) (2 + 2 * addr_size), _("Start"),
14694 (int) (4 + 2 * addr_size), _("End"),
14695 (int) (4 + 2 * addr_size), _("Page Offset"));
14696 filenames = descdata + count * 3 * addr_size;
14697 while (--count > 0)
14698 {
14699 bfd_vma start, end, file_ofs;
14700
14701 if (filenames == descend)
14702 {
14703 printf (_(" Malformed note - filenames end too early\n"));
14704 return 0;
14705 }
14706
14707 start = byte_get (descdata, addr_size);
14708 descdata += addr_size;
14709 end = byte_get (descdata, addr_size);
14710 descdata += addr_size;
14711 file_ofs = byte_get (descdata, addr_size);
14712 descdata += addr_size;
14713
14714 printf (" ");
14715 print_vma (start, FULL_HEX);
14716 printf (" ");
14717 print_vma (end, FULL_HEX);
14718 printf (" ");
14719 print_vma (file_ofs, FULL_HEX);
14720 printf ("\n %s\n", filenames);
14721
14722 filenames += 1 + strlen ((char *) filenames);
14723 }
14724
14725 return 1;
14726}
14727
1118d252
RM		 14728static const char *
14729get_gnu_elf_note_type (unsigned e_type)
14730{
14731 static char buff[64];
14732
14733 switch (e_type)
14734 {
14735 case NT_GNU_ABI_TAG:
14736 return _("NT_GNU_ABI_TAG (ABI version tag)");
14737 case NT_GNU_HWCAP:
14738 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14739 case NT_GNU_BUILD_ID:
14740 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14741 case NT_GNU_GOLD_VERSION:
14742 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14743 default:
14744 break;
14745 }
14746
14747 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14748 return buff;
14749}
14750
664f90a3
TT		 14751static int
14752print_gnu_note (Elf_Internal_Note *pnote)
14753{
14754 switch (pnote->type)
14755 {
14756 case NT_GNU_BUILD_ID:
14757 {
14758 unsigned long i;
14759
14760 printf (_(" Build ID: "));
14761 for (i = 0; i < pnote->descsz; ++i)
14762 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14763 printf ("\n");
664f90a3
TT		 14764 }
14765 break;
14766
14767 case NT_GNU_ABI_TAG:
14768 {
14769 unsigned long os, major, minor, subminor;
14770 const char *osname;
14771
3102e897
NC		 14772 /* PR 17531: file: 030-599401-0.004. */
14773 if (pnote->descsz < 16)
14774 {
14775 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14776 break;
14777 }
14778
664f90a3
TT		 14779 os = byte_get ((unsigned char *) pnote->descdata, 4);
14780 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14781 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14782 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14783
14784 switch (os)
14785 {
14786 case GNU_ABI_TAG_LINUX:
14787 osname = "Linux";
14788 break;
14789 case GNU_ABI_TAG_HURD:
14790 osname = "Hurd";
14791 break;
14792 case GNU_ABI_TAG_SOLARIS:
14793 osname = "Solaris";
14794 break;
14795 case GNU_ABI_TAG_FREEBSD:
14796 osname = "FreeBSD";
14797 break;
14798 case GNU_ABI_TAG_NETBSD:
14799 osname = "NetBSD";
14800 break;
14801 default:
14802 osname = "Unknown";
14803 break;
14804 }
14805
14806 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14807 major, minor, subminor);
14808 }
14809 break;
926c5385
CC		 14810
14811 case NT_GNU_GOLD_VERSION:
14812 {
14813 unsigned long i;
14814
14815 printf (_(" Version: "));
14816 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14817 printf ("%c", pnote->descdata[i]);
14818 printf ("\n");
14819 }
14820 break;
664f90a3
TT		 14821 }
14822
14823 return 1;
14824}
14825
685080f2
NC		 14826static const char *
14827get_v850_elf_note_type (enum v850_notes n_type)
14828{
14829 static char buff[64];
14830
14831 switch (n_type)
14832 {
14833 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
14834 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
14835 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
14836 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
14837 case V850_NOTE_CACHE_INFO: return _("Use of cache");
14838 case V850_NOTE_MMU_INFO: return _("Use of MMU");
14839 default:
14840 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
14841 return buff;
14842 }
14843}
14844
14845static int
14846print_v850_note (Elf_Internal_Note * pnote)
14847{
14848 unsigned int val;
14849
14850 if (pnote->descsz != 4)
14851 return 0;
14852 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
14853
14854 if (val == 0)
14855 {
14856 printf (_("not set\n"));
14857 return 1;
14858 }
14859
14860 switch (pnote->type)
14861 {
14862 case V850_NOTE_ALIGNMENT:
14863 switch (val)
14864 {
14865 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
14866 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
14867 }
14868 break;
14869
14870 case V850_NOTE_DATA_SIZE:
14871 switch (val)
14872 {
14873 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
14874 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
14875 }
14876 break;
14877
14878 case V850_NOTE_FPU_INFO:
14879 switch (val)
14880 {
14881 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
14882 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
14883 }
14884 break;
14885
14886 case V850_NOTE_MMU_INFO:
14887 case V850_NOTE_CACHE_INFO:
14888 case V850_NOTE_SIMD_INFO:
14889 if (val == EF_RH850_SIMD)
14890 {
14891 printf (_("yes\n"));
14892 return 1;
14893 }
14894 break;
14895
14896 default:
14897 /* An 'unknown note type' message will already have been displayed. */
14898 break;
14899 }
14900
14901 printf (_("unknown value: %x\n"), val);
14902 return 0;
14903}
14904
9437c45b 14905static const char *
d3ba0551 14906get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14907{
14908 static char buff[64];
14909
b4db1224 14910 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14911 {
14912 /* NetBSD core "procinfo" structure. */
14913 return _("NetBSD procinfo structure");
14914 }
14915
14916 /* As of Jan 2002 there are no other machine-independent notes
14917 defined for NetBSD core files. If the note type is less
14918 than the start of the machine-dependent note types, we don't
14919 understand it. */
14920
b4db1224 14921 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14922 {
e9e44622 14923 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14924 return buff;
14925 }
14926
14927 switch (elf_header.e_machine)
14928 {
14929 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14930 and PT_GETFPREGS == mach+2. */
14931
14932 case EM_OLD_ALPHA:
14933 case EM_ALPHA:
14934 case EM_SPARC:
14935 case EM_SPARC32PLUS:
14936 case EM_SPARCV9:
14937 switch (e_type)
14938 {
2b692964 14939 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 14940 return _("PT_GETREGS (reg structure)");
2b692964 14941 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 14942 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14943 default:
14944 break;
14945 }
14946 break;
14947
14948 /* On all other arch's, PT_GETREGS == mach+1 and
14949 PT_GETFPREGS == mach+3. */
14950 default:
14951 switch (e_type)
14952 {
2b692964 14953 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 14954 return _("PT_GETREGS (reg structure)");
2b692964 14955 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 14956 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14957 default:
14958 break;
14959 }
14960 }
14961
9cf03b7e 14962 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 14963 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 14964 return buff;
14965}
14966
70616151
TT		 14967static const char *
14968get_stapsdt_note_type (unsigned e_type)
14969{
14970 static char buff[64];
14971
14972 switch (e_type)
14973 {
14974 case NT_STAPSDT:
14975 return _("NT_STAPSDT (SystemTap probe descriptors)");
14976
14977 default:
14978 break;
14979 }
14980
14981 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14982 return buff;
14983}
14984
c6a9fc58
TT		 14985static int
14986print_stapsdt_note (Elf_Internal_Note *pnote)
14987{
14988 int addr_size = is_32bit_elf ? 4 : 8;
14989 char *data = pnote->descdata;
14990 char *data_end = pnote->descdata + pnote->descsz;
14991 bfd_vma pc, base_addr, semaphore;
14992 char *provider, *probe, *arg_fmt;
14993
14994 pc = byte_get ((unsigned char *) data, addr_size);
14995 data += addr_size;
14996 base_addr = byte_get ((unsigned char *) data, addr_size);
14997 data += addr_size;
14998 semaphore = byte_get ((unsigned char *) data, addr_size);
14999 data += addr_size;
15000
15001 provider = data;
15002 data += strlen (data) + 1;
15003 probe = data;
15004 data += strlen (data) + 1;
15005 arg_fmt = data;
15006 data += strlen (data) + 1;
15007
15008 printf (_(" Provider: %s\n"), provider);
15009 printf (_(" Name: %s\n"), probe);
15010 printf (_(" Location: "));
15011 print_vma (pc, FULL_HEX);
15012 printf (_(", Base: "));
15013 print_vma (base_addr, FULL_HEX);
15014 printf (_(", Semaphore: "));
15015 print_vma (semaphore, FULL_HEX);
9cf03b7e 15016 printf ("\n");
c6a9fc58
TT		 15017 printf (_(" Arguments: %s\n"), arg_fmt);
15018
15019 return data == data_end;
15020}
15021
00e98fc7
TG		 15022static const char *
15023get_ia64_vms_note_type (unsigned e_type)
15024{
15025 static char buff[64];
15026
15027 switch (e_type)
15028 {
15029 case NT_VMS_MHD:
15030 return _("NT_VMS_MHD (module header)");
15031 case NT_VMS_LNM:
15032 return _("NT_VMS_LNM (language name)");
15033 case NT_VMS_SRC:
15034 return _("NT_VMS_SRC (source files)");
15035 case NT_VMS_TITLE:
9cf03b7e 15036 return "NT_VMS_TITLE";
00e98fc7
TG		 15037 case NT_VMS_EIDC:
15038 return _("NT_VMS_EIDC (consistency check)");
15039 case NT_VMS_FPMODE:
15040 return _("NT_VMS_FPMODE (FP mode)");
15041 case NT_VMS_LINKTIME:
9cf03b7e 15042 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15043 case NT_VMS_IMGNAM:
15044 return _("NT_VMS_IMGNAM (image name)");
15045 case NT_VMS_IMGID:
15046 return _("NT_VMS_IMGID (image id)");
15047 case NT_VMS_LINKID:
15048 return _("NT_VMS_LINKID (link id)");
15049 case NT_VMS_IMGBID:
15050 return _("NT_VMS_IMGBID (build id)");
15051 case NT_VMS_GSTNAM:
15052 return _("NT_VMS_GSTNAM (sym table name)");
15053 case NT_VMS_ORIG_DYN:
9cf03b7e 15054 return "NT_VMS_ORIG_DYN";
00e98fc7 15055 case NT_VMS_PATCHTIME:
9cf03b7e 15056 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15057 default:
15058 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15059 return buff;
15060 }
15061}
15062
15063static int
15064print_ia64_vms_note (Elf_Internal_Note * pnote)
15065{
15066 switch (pnote->type)
15067 {
15068 case NT_VMS_MHD:
15069 if (pnote->descsz > 36)
15070 {
15071 size_t l = strlen (pnote->descdata + 34);
15072 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15073 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15074 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15075 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15076 }
15077 else
15078 printf (_(" Invalid size\n"));
15079 break;
15080 case NT_VMS_LNM:
15081 printf (_(" Language: %s\n"), pnote->descdata);
15082 break;
15083#ifdef BFD64
15084 case NT_VMS_FPMODE:
9cf03b7e 15085 printf (_(" Floating Point mode: "));
4a5cb34f 15086 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15087 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15088 break;
15089 case NT_VMS_LINKTIME:
15090 printf (_(" Link time: "));
15091 print_vms_time
15092 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15093 printf ("\n");
15094 break;
15095 case NT_VMS_PATCHTIME:
15096 printf (_(" Patch time: "));
15097 print_vms_time
15098 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15099 printf ("\n");
15100 break;
15101 case NT_VMS_ORIG_DYN:
15102 printf (_(" Major id: %u, minor id: %u\n"),
15103 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15104 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15105 printf (_(" Last modified : "));
00e98fc7
TG		 15106 print_vms_time
15107 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15108 printf (_("\n Link flags : "));
4a5cb34f 15109 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15110 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15111 printf (_(" Header flags: 0x%08x\n"),
948f632f 15112 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15113 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15114 break;
15115#endif
15116 case NT_VMS_IMGNAM:
15117 printf (_(" Image name: %s\n"), pnote->descdata);
15118 break;
15119 case NT_VMS_GSTNAM:
15120 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15121 break;
15122 case NT_VMS_IMGID:
15123 printf (_(" Image id: %s\n"), pnote->descdata);
15124 break;
15125 case NT_VMS_LINKID:
15126 printf (_(" Linker id: %s\n"), pnote->descdata);
15127 break;
15128 default:
15129 break;
15130 }
15131 return 1;
15132}
15133
6d118b09
NC		 15134/* Note that by the ELF standard, the name field is already null byte
15135 terminated, and namesz includes the terminating null byte.
15136 I.E. the value of namesz for the name "FSF" is 4.
15137
e3c8793a 15138 If the value of namesz is zero, there is no name present. */
779fe533 15139static int
2cf0635d 15140process_note (Elf_Internal_Note * pnote)
779fe533 15141{
2cf0635d
NC		 15142 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15143 const char * nt;
9437c45b
JT		 15144
15145 if (pnote->namesz == 0)
1ec5cd37
NC		 15146 /* If there is no note name, then use the default set of
15147 note type strings. */
15148 nt = get_note_type (pnote->type);
15149
1118d252
RM		 15150 else if (const_strneq (pnote->namedata, "GNU"))
15151 /* GNU-specific object file notes. */
15152 nt = get_gnu_elf_note_type (pnote->type);
15153
0112cd26 15154 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15155 /* NetBSD-specific core file notes. */
15156 nt = get_netbsd_elfcore_note_type (pnote->type);
15157
b15fa79e
AM		 15158 else if (strneq (pnote->namedata, "SPU/", 4))
15159 {
15160 /* SPU-specific core file notes. */
15161 nt = pnote->namedata + 4;
15162 name = "SPU";
15163 }
15164
00e98fc7
TG		 15165 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15166 /* VMS/ia64-specific file notes. */
15167 nt = get_ia64_vms_note_type (pnote->type);
15168
70616151
TT		 15169 else if (const_strneq (pnote->namedata, "stapsdt"))
15170 nt = get_stapsdt_note_type (pnote->type);
15171
9437c45b 15172 else
1ec5cd37
NC		 15173 /* Don't recognize this note name; just use the default set of
15174 note type strings. */
00e98fc7 15175 nt = get_note_type (pnote->type);
9437c45b 15176
2aee03ae 15177 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15178
15179 if (const_strneq (pnote->namedata, "IPF/VMS"))
15180 return print_ia64_vms_note (pnote);
664f90a3
TT		 15181 else if (const_strneq (pnote->namedata, "GNU"))
15182 return print_gnu_note (pnote);
c6a9fc58
TT		 15183 else if (const_strneq (pnote->namedata, "stapsdt"))
15184 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15185 else if (const_strneq (pnote->namedata, "CORE"))
15186 return print_core_note (pnote);
00e98fc7
TG		 15187 else
15188 return 1;
779fe533
NC		 15189}
15190
6d118b09 15191
779fe533 15192static int
2cf0635d 15193process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15194{
2cf0635d
NC		 15195 Elf_External_Note * pnotes;
15196 Elf_External_Note * external;
c8071705 15197 char * end;
b34976b6 15198 int res = 1;
103f02d3 15199
779fe533
NC		 15200 if (length <= 0)
15201 return 0;
103f02d3 15202
3f5e193b 15203 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15204 _("notes"));
dd24e3da 15205 if (pnotes == NULL)
a6e9f9df 15206 return 0;
779fe533 15207
103f02d3 15208 external = pnotes;
103f02d3 15209
9dd3a467 15210 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15211 (unsigned long) offset, (unsigned long) length);
2aee03ae 15212 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15213
c8071705
NC		 15214 end = (char *) pnotes + length;
15215 while ((char *) external < end)
779fe533 15216 {
b34976b6 15217 Elf_Internal_Note inote;
15b42fb0
AM		 15218 size_t min_notesz;
15219 char *next;
2cf0635d 15220 char * temp = NULL;
c8071705 15221 size_t data_remaining = end - (char *) external;
6d118b09 15222
00e98fc7 15223 if (!is_ia64_vms ())
15b42fb0 15224 {
9dd3a467
NC		 15225 /* PR binutils/15191
15226 Make sure that there is enough data to read. */
15b42fb0
AM		 15227 min_notesz = offsetof (Elf_External_Note, name);
15228 if (data_remaining < min_notesz)
9dd3a467
NC		 15229 {
15230 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15231 (int) data_remaining);
15232 break;
15233 }
15b42fb0
AM		 15234 inote.type = BYTE_GET (external->type);
15235 inote.namesz = BYTE_GET (external->namesz);
15236 inote.namedata = external->name;
15237 inote.descsz = BYTE_GET (external->descsz);
15238 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15239 /* PR 17531: file: 3443835e. */
c8071705 15240 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15241 {
15242 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15243 inote.descdata = inote.namedata;
15244 inote.namesz = 0;
15245 }
c8071705 15246
15b42fb0
AM		 15247 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15248 next = inote.descdata + align_power (inote.descsz, 2);
15249 }
00e98fc7 15250 else
15b42fb0
AM		 15251 {
15252 Elf64_External_VMS_Note *vms_external;
00e98fc7 15253
9dd3a467
NC		 15254 /* PR binutils/15191
15255 Make sure that there is enough data to read. */
15b42fb0
AM		 15256 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15257 if (data_remaining < min_notesz)
9dd3a467
NC		 15258 {
15259 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15260 (int) data_remaining);
15261 break;
15262 }
3e55a963 15263
15b42fb0
AM		 15264 vms_external = (Elf64_External_VMS_Note *) external;
15265 inote.type = BYTE_GET (vms_external->type);
15266 inote.namesz = BYTE_GET (vms_external->namesz);
15267 inote.namedata = vms_external->name;
15268 inote.descsz = BYTE_GET (vms_external->descsz);
15269 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15270 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15271 next = inote.descdata + align_power (inote.descsz, 3);
15272 }
15273
15274 if (inote.descdata < (char *) external + min_notesz
15275 || next < (char *) external + min_notesz
5d921cbd
NC		 15276 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15277 || inote.namedata + inote.namesz < inote.namedata
15278 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15279 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15280 {
15b42fb0 15281 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15282 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15283 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15284 inote.type, inote.namesz, inote.descsz);
15285 break;
15286 }
15287
15b42fb0 15288 external = (Elf_External_Note *) next;
dd24e3da 15289
6d118b09
NC		 15290 /* Verify that name is null terminated. It appears that at least
15291 one version of Linux (RedHat 6.0) generates corefiles that don't
15292 comply with the ELF spec by failing to include the null byte in
15293 namesz. */
8b971f9f 15294 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15295 {
3f5e193b 15296 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15297 if (temp == NULL)
15298 {
8b73c356 15299 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15300 res = 0;
15301 break;
15302 }
76da6bbe 15303
6d118b09
NC		 15304 strncpy (temp, inote.namedata, inote.namesz);
15305 temp[inote.namesz] = 0;
76da6bbe 15306
6d118b09
NC		 15307 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15308 inote.namedata = temp;
15309 }
15310
15311 res &= process_note (& inote);
103f02d3 15312
6d118b09
NC		 15313 if (temp != NULL)
15314 {
15315 free (temp);
15316 temp = NULL;
15317 }
779fe533
NC		 15318 }
15319
15320 free (pnotes);
103f02d3 15321
779fe533
NC		 15322 return res;
15323}
15324
15325static int
2cf0635d 15326process_corefile_note_segments (FILE * file)
779fe533 15327{
2cf0635d 15328 Elf_Internal_Phdr * segment;
b34976b6
AM		 15329 unsigned int i;
15330 int res = 1;
103f02d3 15331
d93f0186 15332 if (! get_program_headers (file))
779fe533 15333 return 0;
103f02d3 15334
779fe533
NC		 15335 for (i = 0, segment = program_headers;
15336 i < elf_header.e_phnum;
b34976b6 15337 i++, segment++)
779fe533
NC		 15338 {
15339 if (segment->p_type == PT_NOTE)
103f02d3 15340 res &= process_corefile_note_segment (file,
30800947
NC		 15341 (bfd_vma) segment->p_offset,
15342 (bfd_vma) segment->p_filesz);
779fe533 15343 }
103f02d3 15344
779fe533
NC		 15345 return res;
15346}
15347
685080f2
NC		 15348static int
15349process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15350{
15351 Elf_External_Note * pnotes;
15352 Elf_External_Note * external;
c8071705 15353 char * end;
685080f2
NC		 15354 int res = 1;
15355
15356 if (length <= 0)
15357 return 0;
15358
15359 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15360 _("v850 notes"));
15361 if (pnotes == NULL)
15362 return 0;
15363
15364 external = pnotes;
c8071705 15365 end = (char*) pnotes + length;
685080f2
NC		 15366
15367 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15368 (unsigned long) offset, (unsigned long) length);
15369
c8071705 15370 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15371 {
15372 Elf_External_Note * next;
15373 Elf_Internal_Note inote;
15374
15375 inote.type = BYTE_GET (external->type);
15376 inote.namesz = BYTE_GET (external->namesz);
15377 inote.namedata = external->name;
15378 inote.descsz = BYTE_GET (external->descsz);
15379 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15380 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15381
c8071705
NC		 15382 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15383 {
15384 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15385 inote.descdata = inote.namedata;
15386 inote.namesz = 0;
15387 }
15388
685080f2
NC		 15389 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15390
c8071705 15391 if ( ((char *) next > end)
685080f2
NC		 15392 || ((char *) next < (char *) pnotes))
15393 {
15394 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15395 (unsigned long) ((char *) external - (char *) pnotes));
15396 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15397 inote.type, inote.namesz, inote.descsz);
15398 break;
15399 }
15400
15401 external = next;
15402
15403 /* Prevent out-of-bounds indexing. */
c8071705 15404 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15405 || inote.namedata + inote.namesz < inote.namedata)
15406 {
15407 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15408 (unsigned long) ((char *) external - (char *) pnotes));
15409 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15410 inote.type, inote.namesz, inote.descsz);
15411 break;
15412 }
15413
15414 printf (" %s: ", get_v850_elf_note_type (inote.type));
15415
15416 if (! print_v850_note (& inote))
15417 {
15418 res = 0;
15419 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15420 inote.namesz, inote.descsz);
15421 }
15422 }
15423
15424 free (pnotes);
15425
15426 return res;
15427}
15428
779fe533 15429static int
2cf0635d 15430process_note_sections (FILE * file)
1ec5cd37 15431{
2cf0635d 15432 Elf_Internal_Shdr * section;
1ec5cd37 15433 unsigned long i;
df565f32 15434 int n = 0;
1ec5cd37
NC		 15435 int res = 1;
15436
15437 for (i = 0, section = section_headers;
fa1908fd 15438 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15439 i++, section++)
685080f2
NC		 15440 {
15441 if (section->sh_type == SHT_NOTE)
15442 {
15443 res &= process_corefile_note_segment (file,
15444 (bfd_vma) section->sh_offset,
15445 (bfd_vma) section->sh_size);
15446 n++;
15447 }
15448
15449 if (( elf_header.e_machine == EM_V800
15450 || elf_header.e_machine == EM_V850
15451 || elf_header.e_machine == EM_CYGNUS_V850)
15452 && section->sh_type == SHT_RENESAS_INFO)
15453 {
15454 res &= process_v850_notes (file,
15455 (bfd_vma) section->sh_offset,
15456 (bfd_vma) section->sh_size);
15457 n++;
15458 }
15459 }
df565f32
NC		 15460
15461 if (n == 0)
15462 /* Try processing NOTE segments instead. */
15463 return process_corefile_note_segments (file);
1ec5cd37
NC		 15464
15465 return res;
15466}
15467
15468static int
2cf0635d 15469process_notes (FILE * file)
779fe533
NC		 15470{
15471 /* If we have not been asked to display the notes then do nothing. */
15472 if (! do_notes)
15473 return 1;
103f02d3 15474
779fe533 15475 if (elf_header.e_type != ET_CORE)
1ec5cd37 15476 return process_note_sections (file);
103f02d3 15477
779fe533 15478 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15479 if (elf_header.e_phnum > 0)
15480 return process_corefile_note_segments (file);
779fe533 15481
1ec5cd37
NC		 15482 printf (_("No note segments present in the core file.\n"));
15483 return 1;
779fe533
NC		 15484}
15485
252b5132 15486static int
2cf0635d 15487process_arch_specific (FILE * file)
252b5132 15488{
a952a375
NC		 15489 if (! do_arch)
15490 return 1;
15491
252b5132
RH		 15492 switch (elf_header.e_machine)
15493 {
11c1ff18
PB		 15494 case EM_ARM:
15495 return process_arm_specific (file);
252b5132 15496 case EM_MIPS:
4fe85591 15497 case EM_MIPS_RS3_LE:
252b5132
RH		 15498 return process_mips_specific (file);
15499 break;
35c08157
KLC		 15500 case EM_NDS32:
15501 return process_nds32_specific (file);
15502 break;
34c8bcba
JM		 15503 case EM_PPC:
15504 return process_power_specific (file);
15505 break;
9e8c70f9
DM		 15506 case EM_SPARC:
15507 case EM_SPARC32PLUS:
15508 case EM_SPARCV9:
15509 return process_sparc_specific (file);
15510 break;
59e6276b
JM		 15511 case EM_TI_C6000:
15512 return process_tic6x_specific (file);
15513 break;
13761a11
NC		 15514 case EM_MSP430:
15515 return process_msp430x_specific (file);
252b5132
RH		 15516 default:
15517 break;
15518 }
15519 return 1;
15520}
15521
15522static int
2cf0635d 15523get_file_header (FILE * file)
252b5132 15524{
9ea033b2
NC		 15525 /* Read in the identity array. */
15526 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15527 return 0;
15528
9ea033b2 15529 /* Determine how to read the rest of the header. */
b34976b6 15530 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15531 {
15532 default: /* fall through */
15533 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15534 case ELFDATA2LSB:
15535 byte_get = byte_get_little_endian;
15536 byte_put = byte_put_little_endian;
15537 break;
15538 case ELFDATA2MSB:
15539 byte_get = byte_get_big_endian;
15540 byte_put = byte_put_big_endian;
15541 break;
9ea033b2
NC		 15542 }
15543
15544 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15545 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15546
15547 /* Read in the rest of the header. */
15548 if (is_32bit_elf)
15549 {
15550 Elf32_External_Ehdr ehdr32;
252b5132 15551
9ea033b2
NC		 15552 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15553 return 0;
103f02d3 15554
9ea033b2
NC		 15555 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15556 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15557 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15558 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15559 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15560 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15561 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15562 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15563 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15564 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15565 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15566 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15567 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15568 }
252b5132 15569 else
9ea033b2
NC		 15570 {
15571 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15572
15573 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15574 we will not be able to cope with the 64bit data found in
15575 64 ELF files. Detect this now and abort before we start
50c2245b 15576 overwriting things. */
a952a375
NC		 15577 if (sizeof (bfd_vma) < 8)
15578 {
e3c8793a
NC		 15579 error (_("This instance of readelf has been built without support for a\n\
1558064 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15581 return 0;
15582 }
103f02d3 15583
9ea033b2
NC		 15584 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15585 return 0;
103f02d3 15586
9ea033b2
NC		 15587 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15588 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15589 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15590 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15591 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15592 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15593 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15594 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15595 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15596 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15597 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15598 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15599 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15600 }
252b5132 15601
7ece0d85
JJ		 15602 if (elf_header.e_shoff)
15603 {
15604 /* There may be some extensions in the first section header. Don't
15605 bomb if we can't read it. */
15606 if (is_32bit_elf)
049b0c3a 15607 get_32bit_section_headers (file, TRUE);
7ece0d85 15608 else
049b0c3a 15609 get_64bit_section_headers (file, TRUE);
7ece0d85 15610 }
560f3c1c 15611
252b5132
RH		 15612 return 1;
15613}
15614
fb52b2f4
NC		 15615/* Process one ELF object file according to the command line options.
15616 This file may actually be stored in an archive. The file is
15617 positioned at the start of the ELF object. */
15618
ff78d6d6 15619static int
2cf0635d 15620process_object (char * file_name, FILE * file)
252b5132 15621{
252b5132
RH		 15622 unsigned int i;
15623
252b5132
RH		 15624 if (! get_file_header (file))
15625 {
15626 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15627 return 1;
252b5132
RH		 15628 }
15629
15630 /* Initialise per file variables. */
60bca95a 15631 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15632 version_info[i] = 0;
15633
60bca95a 15634 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15635 dynamic_info[i] = 0;
5115b233 15636 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15637
15638 /* Process the file. */
15639 if (show_name)
15640 printf (_("\nFile: %s\n"), file_name);
15641
18bd398b
NC		 15642 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15643 Note we do this even if cmdline_dump_sects is empty because we
15644 must make sure that the dump_sets array is zeroed out before each
15645 object file is processed. */
15646 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15647 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15648
15649 if (num_cmdline_dump_sects > 0)
15650 {
15651 if (num_dump_sects == 0)
15652 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15653 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15654
15655 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15656 memcpy (dump_sects, cmdline_dump_sects,
15657 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15658 }
d70c5fc7 15659
252b5132 15660 if (! process_file_header ())
fb52b2f4 15661 return 1;
252b5132 15662
d1f5c6e3 15663 if (! process_section_headers (file))
2f62977e 15664 {
d1f5c6e3
L		 15665 /* Without loaded section headers we cannot process lots of
15666 things. */
2f62977e 15667 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15668
2f62977e 15669 if (! do_using_dynamic)
2c610e4b 15670 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15671 }
252b5132 15672
d1f5c6e3
L		 15673 if (! process_section_groups (file))
15674 {
15675 /* Without loaded section groups we cannot process unwind. */
15676 do_unwind = 0;
15677 }
15678
2f62977e 15679 if (process_program_headers (file))
b2d38a17 15680 process_dynamic_section (file);
252b5132
RH		 15681
15682 process_relocs (file);
15683
4d6ed7c8
NC		 15684 process_unwind (file);
15685
252b5132
RH		 15686 process_symbol_table (file);
15687
15688 process_syminfo (file);
15689
15690 process_version_sections (file);
15691
15692 process_section_contents (file);
f5842774 15693
1ec5cd37 15694 process_notes (file);
103f02d3 15695
047b2264
JJ		 15696 process_gnu_liblist (file);
15697
252b5132
RH		 15698 process_arch_specific (file);
15699
d93f0186
NC		 15700 if (program_headers)
15701 {
15702 free (program_headers);
15703 program_headers = NULL;
15704 }
15705
252b5132
RH		 15706 if (section_headers)
15707 {
15708 free (section_headers);
15709 section_headers = NULL;
15710 }
15711
15712 if (string_table)
15713 {
15714 free (string_table);
15715 string_table = NULL;
d40ac9bd 15716 string_table_length = 0;
252b5132
RH		 15717 }
15718
15719 if (dynamic_strings)
15720 {
15721 free (dynamic_strings);
15722 dynamic_strings = NULL;
d79b3d50 15723 dynamic_strings_length = 0;
252b5132
RH		 15724 }
15725
15726 if (dynamic_symbols)
15727 {
15728 free (dynamic_symbols);
15729 dynamic_symbols = NULL;
19936277 15730 num_dynamic_syms = 0;
252b5132
RH		 15731 }
15732
15733 if (dynamic_syminfo)
15734 {
15735 free (dynamic_syminfo);
15736 dynamic_syminfo = NULL;
15737 }
ff78d6d6 15738
293c573e
MR		 15739 if (dynamic_section)
15740 {
15741 free (dynamic_section);
15742 dynamic_section = NULL;
15743 }
15744
e4b17d5c
L		 15745 if (section_headers_groups)
15746 {
15747 free (section_headers_groups);
15748 section_headers_groups = NULL;
15749 }
15750
15751 if (section_groups)
15752 {
2cf0635d
NC		 15753 struct group_list * g;
15754 struct group_list * next;
e4b17d5c
L		 15755
15756 for (i = 0; i < group_count; i++)
15757 {
15758 for (g = section_groups [i].root; g != NULL; g = next)
15759 {
15760 next = g->next;
15761 free (g);
15762 }
15763 }
15764
15765 free (section_groups);
15766 section_groups = NULL;
15767 }
15768
19e6b90e 15769 free_debug_memory ();
18bd398b 15770
ff78d6d6 15771 return 0;
252b5132
RH		 15772}
15773
2cf0635d
NC		 15774/* Process an ELF archive.
15775 On entry the file is positioned just after the ARMAG string. */
15776
15777static int
15778process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15779{
15780 struct archive_info arch;
15781 struct archive_info nested_arch;
15782 size_t got;
2cf0635d
NC		 15783 int ret;
15784
15785 show_name = 1;
15786
15787 /* The ARCH structure is used to hold information about this archive. */
15788 arch.file_name = NULL;
15789 arch.file = NULL;
15790 arch.index_array = NULL;
15791 arch.sym_table = NULL;
15792 arch.longnames = NULL;
15793
15794 /* The NESTED_ARCH structure is used as a single-item cache of information
15795 about a nested archive (when members of a thin archive reside within
15796 another regular archive file). */
15797 nested_arch.file_name = NULL;
15798 nested_arch.file = NULL;
15799 nested_arch.index_array = NULL;
15800 nested_arch.sym_table = NULL;
15801 nested_arch.longnames = NULL;
15802
15803 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15804 {
15805 ret = 1;
15806 goto out;
4145f1d5 15807 }
fb52b2f4 15808
4145f1d5
NC		 15809 if (do_archive_index)
15810 {
2cf0635d 15811 if (arch.sym_table == NULL)
4145f1d5
NC		 15812 error (_("%s: unable to dump the index as none was found\n"), file_name);
15813 else
15814 {
591f7597 15815 unsigned long i, l;
4145f1d5
NC		 15816 unsigned long current_pos;
15817
591f7597
NC		 15818 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15819 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 15820 current_pos = ftell (file);
15821
2cf0635d 15822 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 15823 {
2cf0635d
NC		 15824 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15825 {
15826 char * member_name;
4145f1d5 15827
2cf0635d
NC		 15828 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15829
15830 if (member_name != NULL)
15831 {
15832 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15833
15834 if (qualified_name != NULL)
15835 {
c2a7d3f5
NC		 15836 printf (_("Contents of binary %s at offset "), qualified_name);
15837 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15838 putchar ('\n');
2cf0635d
NC		 15839 free (qualified_name);
15840 }
4145f1d5
NC		 15841 }
15842 }
2cf0635d
NC		 15843
15844 if (l >= arch.sym_size)
4145f1d5
NC		 15845 {
15846 error (_("%s: end of the symbol table reached before the end of the index\n"),
15847 file_name);
cb8f3167 15848 break;
4145f1d5 15849 }
591f7597
NC		 15850 /* PR 17531: file: 0b6630b2. */
15851 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15852 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 15853 }
15854
c2a7d3f5
NC		 15855 if (arch.uses_64bit_indicies)
15856 l = (l + 7) & ~ 7;
15857 else
15858 l += l & 1;
15859
2cf0635d 15860 if (l < arch.sym_size)
c2a7d3f5
NC		 15861 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15862 file_name, arch.sym_size - l);
4145f1d5 15863
4145f1d5
NC		 15864 if (fseek (file, current_pos, SEEK_SET) != 0)
15865 {
15866 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 15867 ret = 1;
15868 goto out;
4145f1d5 15869 }
fb52b2f4 15870 }
4145f1d5
NC		 15871
15872 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15873 && !do_segments && !do_header && !do_dump && !do_version
15874 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 15875 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 15876 {
15877 ret = 0; /* Archive index only. */
15878 goto out;
15879 }
fb52b2f4
NC		 15880 }
15881
d989285c 15882 ret = 0;
fb52b2f4
NC		 15883
15884 while (1)
15885 {
2cf0635d
NC		 15886 char * name;
15887 size_t namelen;
15888 char * qualified_name;
15889
15890 /* Read the next archive header. */
15891 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15892 {
15893 error (_("%s: failed to seek to next archive header\n"), file_name);
15894 return 1;
15895 }
15896 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15897 if (got != sizeof arch.arhdr)
15898 {
15899 if (got == 0)
15900 break;
15901 error (_("%s: failed to read archive header\n"), file_name);
15902 ret = 1;
15903 break;
15904 }
15905 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15906 {
15907 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15908 ret = 1;
15909 break;
15910 }
15911
15912 arch.next_arhdr_offset += sizeof arch.arhdr;
15913
15914 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15915 if (archive_file_size & 01)
15916 ++archive_file_size;
15917
15918 name = get_archive_member_name (&arch, &nested_arch);
15919 if (name == NULL)
fb52b2f4 15920 {
0fd3a477 15921 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15922 ret = 1;
15923 break;
fb52b2f4 15924 }
2cf0635d 15925 namelen = strlen (name);
fb52b2f4 15926
2cf0635d
NC		 15927 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15928 if (qualified_name == NULL)
fb52b2f4 15929 {
2cf0635d 15930 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15931 ret = 1;
15932 break;
fb52b2f4
NC		 15933 }
15934
2cf0635d
NC		 15935 if (is_thin_archive && arch.nested_member_origin == 0)
15936 {
15937 /* This is a proxy for an external member of a thin archive. */
15938 FILE * member_file;
15939 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15940 if (member_file_name == NULL)
15941 {
15942 ret = 1;
15943 break;
15944 }
15945
15946 member_file = fopen (member_file_name, "rb");
15947 if (member_file == NULL)
15948 {
15949 error (_("Input file '%s' is not readable.\n"), member_file_name);
15950 free (member_file_name);
15951 ret = 1;
15952 break;
15953 }
15954
15955 archive_file_offset = arch.nested_member_origin;
15956
15957 ret |= process_object (qualified_name, member_file);
15958
15959 fclose (member_file);
15960 free (member_file_name);
15961 }
15962 else if (is_thin_archive)
15963 {
a043396b
NC		 15964 /* PR 15140: Allow for corrupt thin archives. */
15965 if (nested_arch.file == NULL)
15966 {
15967 error (_("%s: contains corrupt thin archive: %s\n"),
15968 file_name, name);
15969 ret = 1;
15970 break;
15971 }
15972
2cf0635d
NC		 15973 /* This is a proxy for a member of a nested archive. */
15974 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15975
15976 /* The nested archive file will have been opened and setup by
15977 get_archive_member_name. */
15978 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15979 {
15980 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15981 ret = 1;
15982 break;
15983 }
15984
15985 ret |= process_object (qualified_name, nested_arch.file);
15986 }
15987 else
15988 {
15989 archive_file_offset = arch.next_arhdr_offset;
15990 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 15991
2cf0635d
NC		 15992 ret |= process_object (qualified_name, file);
15993 }
fb52b2f4 15994
2b52916e
L		 15995 if (dump_sects != NULL)
15996 {
15997 free (dump_sects);
15998 dump_sects = NULL;
15999 num_dump_sects = 0;
16000 }
16001
2cf0635d 16002 free (qualified_name);
fb52b2f4
NC		 16003 }
16004
4145f1d5 16005 out:
2cf0635d
NC		 16006 if (nested_arch.file != NULL)
16007 fclose (nested_arch.file);
16008 release_archive (&nested_arch);
16009 release_archive (&arch);
fb52b2f4 16010
d989285c 16011 return ret;
fb52b2f4
NC		 16012}
16013
16014static int
2cf0635d 16015process_file (char * file_name)
fb52b2f4 16016{
2cf0635d 16017 FILE * file;
fb52b2f4
NC		 16018 struct stat statbuf;
16019 char armag[SARMAG];
16020 int ret;
16021
16022 if (stat (file_name, &statbuf) < 0)
16023 {
f24ddbdd
NC		 16024 if (errno == ENOENT)
16025 error (_("'%s': No such file\n"), file_name);
16026 else
16027 error (_("Could not locate '%s'. System error message: %s\n"),
16028 file_name, strerror (errno));
16029 return 1;
16030 }
16031
16032 if (! S_ISREG (statbuf.st_mode))
16033 {
16034 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16035 return 1;
16036 }
16037
16038 file = fopen (file_name, "rb");
16039 if (file == NULL)
16040 {
f24ddbdd 16041 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16042 return 1;
16043 }
16044
16045 if (fread (armag, SARMAG, 1, file) != 1)
16046 {
4145f1d5 16047 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16048 fclose (file);
16049 return 1;
16050 }
16051
f54498b4
NC		 16052 current_file_size = (bfd_size_type) statbuf.st_size;
16053
fb52b2f4 16054 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16055 ret = process_archive (file_name, file, FALSE);
16056 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16057 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16058 else
16059 {
4145f1d5
NC		 16060 if (do_archive_index)
16061 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16062 file_name);
16063
fb52b2f4
NC		 16064 rewind (file);
16065 archive_file_size = archive_file_offset = 0;
16066 ret = process_object (file_name, file);
16067 }
16068
16069 fclose (file);
16070
f54498b4 16071 current_file_size = 0;
fb52b2f4
NC		 16072 return ret;
16073}
16074
252b5132
RH		 16075#ifdef SUPPORT_DISASSEMBLY
16076/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16077 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16078 symbols. */
252b5132
RH		 16079
16080void
2cf0635d 16081print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16082{
16083 fprintf (outfile,"0x%8.8x", addr);
16084}
16085
e3c8793a 16086/* Needed by the i386 disassembler. */
252b5132
RH		 16087void
16088db_task_printsym (unsigned int addr)
16089{
16090 print_address (addr, stderr);
16091}
16092#endif
16093
16094int
2cf0635d 16095main (int argc, char ** argv)
252b5132 16096{
ff78d6d6
L		 16097 int err;
16098
252b5132
RH		 16099#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16100 setlocale (LC_MESSAGES, "");
3882b010
L		 16101#endif
16102#if defined (HAVE_SETLOCALE)
16103 setlocale (LC_CTYPE, "");
252b5132
RH		 16104#endif
16105 bindtextdomain (PACKAGE, LOCALEDIR);
16106 textdomain (PACKAGE);
16107
869b9d07
MM		 16108 expandargv (&argc, &argv);
16109
252b5132
RH		 16110 parse_args (argc, argv);
16111
18bd398b 16112 if (num_dump_sects > 0)
59f14fc0 16113 {
18bd398b 16114 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16115 cmdline_dump_sects = (dump_type *)
16116 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16117 if (cmdline_dump_sects == NULL)
591a748a 16118 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16119 else
16120 {
09c11c86
NC		 16121 memcpy (cmdline_dump_sects, dump_sects,
16122 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16123 num_cmdline_dump_sects = num_dump_sects;
16124 }
16125 }
16126
18bd398b
NC		 16127 if (optind < (argc - 1))
16128 show_name = 1;
5656ba2c
L		 16129 else if (optind >= argc)
16130 {
16131 warn (_("Nothing to do.\n"));
16132 usage (stderr);
16133 }
18bd398b 16134
ff78d6d6 16135 err = 0;
252b5132 16136 while (optind < argc)
18bd398b 16137 err |= process_file (argv[optind++]);
252b5132
RH		 16138
16139 if (dump_sects != NULL)
16140 free (dump_sects);
59f14fc0
AS		 16141 if (cmdline_dump_sects != NULL)
16142 free (cmdline_dump_sects);
252b5132 16143
ff78d6d6 16144 return err;
252b5132 16145}
A mirror of the official binutils-gdb repository