]> 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
This patch modifies the AVR linker script templates to use __<name>_REGION_LENGTH__...
[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;
570
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 if (e_flags & EF_ARM_HASENTRY)
2284 {
2285 strcat (buf, ", has entry point");
2286 e_flags &= ~ EF_ARM_HASENTRY;
2287 }
76da6bbe 2288
f3485b74
NC		 2289 /* Now handle EABI specific flags. */
2290 switch (eabi)
2291 {
2292 default:
2c71103e 2293 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2294 if (e_flags)
2295 unknown = 1;
2296 break;
2297
2298 case EF_ARM_EABI_VER1:
a5bcd848 2299 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2300 while (e_flags)
2301 {
2302 unsigned flag;
76da6bbe 2303
f3485b74
NC		 2304 /* Process flags one bit at a time. */
2305 flag = e_flags & - e_flags;
2306 e_flags &= ~ flag;
76da6bbe 2307
f3485b74
NC		 2308 switch (flag)
2309 {
a5bcd848 2310 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2311 strcat (buf, ", sorted symbol tables");
2312 break;
76da6bbe 2313
f3485b74
NC		 2314 default:
2315 unknown = 1;
2316 break;
2317 }
2318 }
2319 break;
76da6bbe 2320
a5bcd848
PB		 2321 case EF_ARM_EABI_VER2:
2322 strcat (buf, ", Version2 EABI");
2323 while (e_flags)
2324 {
2325 unsigned flag;
2326
2327 /* Process flags one bit at a time. */
2328 flag = e_flags & - e_flags;
2329 e_flags &= ~ flag;
2330
2331 switch (flag)
2332 {
2333 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2334 strcat (buf, ", sorted symbol tables");
2335 break;
2336
2337 case EF_ARM_DYNSYMSUSESEGIDX:
2338 strcat (buf, ", dynamic symbols use segment index");
2339 break;
2340
2341 case EF_ARM_MAPSYMSFIRST:
2342 strcat (buf, ", mapping symbols precede others");
2343 break;
2344
2345 default:
2346 unknown = 1;
2347 break;
2348 }
2349 }
2350 break;
2351
d507cf36
PB		 2352 case EF_ARM_EABI_VER3:
2353 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2354 break;
2355
2356 case EF_ARM_EABI_VER4:
2357 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2358 while (e_flags)
2359 {
2360 unsigned flag;
2361
2362 /* Process flags one bit at a time. */
2363 flag = e_flags & - e_flags;
2364 e_flags &= ~ flag;
2365
2366 switch (flag)
2367 {
2368 case EF_ARM_BE8:
2369 strcat (buf, ", BE8");
2370 break;
2371
2372 case EF_ARM_LE8:
2373 strcat (buf, ", LE8");
2374 break;
2375
2376 default:
2377 unknown = 1;
2378 break;
2379 }
2380 break;
2381 }
2382 break;
3a4a14e9
PB		 2383
2384 case EF_ARM_EABI_VER5:
2385 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2386 while (e_flags)
2387 {
2388 unsigned flag;
2389
2390 /* Process flags one bit at a time. */
2391 flag = e_flags & - e_flags;
2392 e_flags &= ~ flag;
2393
2394 switch (flag)
2395 {
2396 case EF_ARM_BE8:
2397 strcat (buf, ", BE8");
2398 break;
2399
2400 case EF_ARM_LE8:
2401 strcat (buf, ", LE8");
2402 break;
2403
3bfcb652
NC		 2404 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2405 strcat (buf, ", soft-float ABI");
2406 break;
2407
2408 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2409 strcat (buf, ", hard-float ABI");
2410 break;
2411
d507cf36
PB		 2412 default:
2413 unknown = 1;
2414 break;
2415 }
2416 }
2417 break;
2418
f3485b74 2419 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2420 strcat (buf, ", GNU EABI");
f3485b74
NC		 2421 while (e_flags)
2422 {
2423 unsigned flag;
76da6bbe 2424
f3485b74
NC		 2425 /* Process flags one bit at a time. */
2426 flag = e_flags & - e_flags;
2427 e_flags &= ~ flag;
76da6bbe 2428
f3485b74
NC		 2429 switch (flag)
2430 {
a5bcd848 2431 case EF_ARM_INTERWORK:
f3485b74
NC		 2432 strcat (buf, ", interworking enabled");
2433 break;
76da6bbe 2434
a5bcd848 2435 case EF_ARM_APCS_26:
f3485b74
NC		 2436 strcat (buf, ", uses APCS/26");
2437 break;
76da6bbe 2438
a5bcd848 2439 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2440 strcat (buf, ", uses APCS/float");
2441 break;
76da6bbe 2442
a5bcd848 2443 case EF_ARM_PIC:
f3485b74
NC		 2444 strcat (buf, ", position independent");
2445 break;
76da6bbe 2446
a5bcd848 2447 case EF_ARM_ALIGN8:
f3485b74
NC		 2448 strcat (buf, ", 8 bit structure alignment");
2449 break;
76da6bbe 2450
a5bcd848 2451 case EF_ARM_NEW_ABI:
f3485b74
NC		 2452 strcat (buf, ", uses new ABI");
2453 break;
76da6bbe 2454
a5bcd848 2455 case EF_ARM_OLD_ABI:
f3485b74
NC		 2456 strcat (buf, ", uses old ABI");
2457 break;
76da6bbe 2458
a5bcd848 2459 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2460 strcat (buf, ", software FP");
2461 break;
76da6bbe 2462
90e01f86
ILT		 2463 case EF_ARM_VFP_FLOAT:
2464 strcat (buf, ", VFP");
2465 break;
2466
fde78edd
NC		 2467 case EF_ARM_MAVERICK_FLOAT:
2468 strcat (buf, ", Maverick FP");
2469 break;
2470
f3485b74
NC		 2471 default:
2472 unknown = 1;
2473 break;
2474 }
2475 }
2476 }
f3485b74
NC		 2477
2478 if (unknown)
2b692964 2479 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2480}
2481
343433df
AB		 2482static void
2483decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2484{
2485 --size; /* Leave space for null terminator. */
2486
2487 switch (e_flags & EF_AVR_MACH)
2488 {
2489 case E_AVR_MACH_AVR1:
2490 strncat (buf, ", avr:1", size);
2491 break;
2492 case E_AVR_MACH_AVR2:
2493 strncat (buf, ", avr:2", size);
2494 break;
2495 case E_AVR_MACH_AVR25:
2496 strncat (buf, ", avr:25", size);
2497 break;
2498 case E_AVR_MACH_AVR3:
2499 strncat (buf, ", avr:3", size);
2500 break;
2501 case E_AVR_MACH_AVR31:
2502 strncat (buf, ", avr:31", size);
2503 break;
2504 case E_AVR_MACH_AVR35:
2505 strncat (buf, ", avr:35", size);
2506 break;
2507 case E_AVR_MACH_AVR4:
2508 strncat (buf, ", avr:4", size);
2509 break;
2510 case E_AVR_MACH_AVR5:
2511 strncat (buf, ", avr:5", size);
2512 break;
2513 case E_AVR_MACH_AVR51:
2514 strncat (buf, ", avr:51", size);
2515 break;
2516 case E_AVR_MACH_AVR6:
2517 strncat (buf, ", avr:6", size);
2518 break;
2519 case E_AVR_MACH_AVRTINY:
2520 strncat (buf, ", avr:100", size);
2521 break;
2522 case E_AVR_MACH_XMEGA1:
2523 strncat (buf, ", avr:101", size);
2524 break;
2525 case E_AVR_MACH_XMEGA2:
2526 strncat (buf, ", avr:102", size);
2527 break;
2528 case E_AVR_MACH_XMEGA3:
2529 strncat (buf, ", avr:103", size);
2530 break;
2531 case E_AVR_MACH_XMEGA4:
2532 strncat (buf, ", avr:104", size);
2533 break;
2534 case E_AVR_MACH_XMEGA5:
2535 strncat (buf, ", avr:105", size);
2536 break;
2537 case E_AVR_MACH_XMEGA6:
2538 strncat (buf, ", avr:106", size);
2539 break;
2540 case E_AVR_MACH_XMEGA7:
2541 strncat (buf, ", avr:107", size);
2542 break;
2543 default:
2544 strncat (buf, ", avr:<unknown>", size);
2545 break;
2546 }
2547
2548 size -= strlen (buf);
2549 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2550 strncat (buf, ", link-relax", size);
2551}
2552
35c08157
KLC		 2553static void
2554decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2555{
2556 unsigned abi;
2557 unsigned arch;
2558 unsigned config;
2559 unsigned version;
2560 int has_fpu = 0;
2561 int r = 0;
2562
2563 static const char *ABI_STRINGS[] =
2564 {
2565 "ABI v0", /* use r5 as return register; only used in N1213HC */
2566 "ABI v1", /* use r0 as return register */
2567 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2569 "AABI",
2570 "ABI2 FP+"
35c08157
KLC		 2571 };
2572 static const char *VER_STRINGS[] =
2573 {
2574 "Andes ELF V1.3 or older",
2575 "Andes ELF V1.3.1",
2576 "Andes ELF V1.4"
2577 };
2578 static const char *ARCH_STRINGS[] =
2579 {
2580 "",
2581 "Andes Star v1.0",
2582 "Andes Star v2.0",
2583 "Andes Star v3.0",
2584 "Andes Star v3.0m"
2585 };
2586
2587 abi = EF_NDS_ABI & e_flags;
2588 arch = EF_NDS_ARCH & e_flags;
2589 config = EF_NDS_INST & e_flags;
2590 version = EF_NDS32_ELF_VERSION & e_flags;
2591
2592 memset (buf, 0, size);
2593
2594 switch (abi)
2595 {
2596 case E_NDS_ABI_V0:
2597 case E_NDS_ABI_V1:
2598 case E_NDS_ABI_V2:
2599 case E_NDS_ABI_V2FP:
2600 case E_NDS_ABI_AABI:
40c7a7cb 2601 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2602 /* In case there are holes in the array. */
2603 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2604 break;
2605
2606 default:
2607 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2608 break;
2609 }
2610
2611 switch (version)
2612 {
2613 case E_NDS32_ELF_VER_1_2:
2614 case E_NDS32_ELF_VER_1_3:
2615 case E_NDS32_ELF_VER_1_4:
2616 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2617 break;
2618
2619 default:
2620 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2621 break;
2622 }
2623
2624 if (E_NDS_ABI_V0 == abi)
2625 {
2626 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2627 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628 if (arch == E_NDS_ARCH_STAR_V1_0)
2629 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2630 return;
2631 }
2632
2633 switch (arch)
2634 {
2635 case E_NDS_ARCH_STAR_V1_0:
2636 case E_NDS_ARCH_STAR_V2_0:
2637 case E_NDS_ARCH_STAR_V3_0:
2638 case E_NDS_ARCH_STAR_V3_M:
2639 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2640 break;
2641
2642 default:
2643 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2644 /* ARCH version determines how the e_flags are interpreted.
2645 If it is unknown, we cannot proceed. */
2646 return;
2647 }
2648
2649 /* Newer ABI; Now handle architecture specific flags. */
2650 if (arch == E_NDS_ARCH_STAR_V1_0)
2651 {
2652 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2653 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2654
2655 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2656 r += snprintf (buf + r, size -r, ", MAC");
2657
2658 if (config & E_NDS32_HAS_DIV_INST)
2659 r += snprintf (buf + r, size -r, ", DIV");
2660
2661 if (config & E_NDS32_HAS_16BIT_INST)
2662 r += snprintf (buf + r, size -r, ", 16b");
2663 }
2664 else
2665 {
2666 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2667 {
2668 if (version <= E_NDS32_ELF_VER_1_3)
2669 r += snprintf (buf + r, size -r, ", [B8]");
2670 else
2671 r += snprintf (buf + r, size -r, ", EX9");
2672 }
2673
2674 if (config & E_NDS32_HAS_MAC_DX_INST)
2675 r += snprintf (buf + r, size -r, ", MAC_DX");
2676
2677 if (config & E_NDS32_HAS_DIV_DX_INST)
2678 r += snprintf (buf + r, size -r, ", DIV_DX");
2679
2680 if (config & E_NDS32_HAS_16BIT_INST)
2681 {
2682 if (version <= E_NDS32_ELF_VER_1_3)
2683 r += snprintf (buf + r, size -r, ", 16b");
2684 else
2685 r += snprintf (buf + r, size -r, ", IFC");
2686 }
2687 }
2688
2689 if (config & E_NDS32_HAS_EXT_INST)
2690 r += snprintf (buf + r, size -r, ", PERF1");
2691
2692 if (config & E_NDS32_HAS_EXT2_INST)
2693 r += snprintf (buf + r, size -r, ", PERF2");
2694
2695 if (config & E_NDS32_HAS_FPU_INST)
2696 {
2697 has_fpu = 1;
2698 r += snprintf (buf + r, size -r, ", FPU_SP");
2699 }
2700
2701 if (config & E_NDS32_HAS_FPU_DP_INST)
2702 {
2703 has_fpu = 1;
2704 r += snprintf (buf + r, size -r, ", FPU_DP");
2705 }
2706
2707 if (config & E_NDS32_HAS_FPU_MAC_INST)
2708 {
2709 has_fpu = 1;
2710 r += snprintf (buf + r, size -r, ", FPU_MAC");
2711 }
2712
2713 if (has_fpu)
2714 {
2715 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2716 {
2717 case E_NDS32_FPU_REG_8SP_4DP:
2718 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2719 break;
2720 case E_NDS32_FPU_REG_16SP_8DP:
2721 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2722 break;
2723 case E_NDS32_FPU_REG_32SP_16DP:
2724 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2725 break;
2726 case E_NDS32_FPU_REG_32SP_32DP:
2727 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2728 break;
2729 }
2730 }
2731
2732 if (config & E_NDS32_HAS_AUDIO_INST)
2733 r += snprintf (buf + r, size -r, ", AUDIO");
2734
2735 if (config & E_NDS32_HAS_STRING_INST)
2736 r += snprintf (buf + r, size -r, ", STR");
2737
2738 if (config & E_NDS32_HAS_REDUCED_REGS)
2739 r += snprintf (buf + r, size -r, ", 16REG");
2740
2741 if (config & E_NDS32_HAS_VIDEO_INST)
2742 {
2743 if (version <= E_NDS32_ELF_VER_1_3)
2744 r += snprintf (buf + r, size -r, ", VIDEO");
2745 else
2746 r += snprintf (buf + r, size -r, ", SATURATION");
2747 }
2748
2749 if (config & E_NDS32_HAS_ENCRIPT_INST)
2750 r += snprintf (buf + r, size -r, ", ENCRP");
2751
2752 if (config & E_NDS32_HAS_L2C_INST)
2753 r += snprintf (buf + r, size -r, ", L2C");
2754}
2755
252b5132 2756static char *
d3ba0551 2757get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2758{
b34976b6 2759 static char buf[1024];
252b5132
RH		 2760
2761 buf[0] = '\0';
76da6bbe 2762
252b5132
RH		 2763 if (e_flags)
2764 {
2765 switch (e_machine)
2766 {
2767 default:
2768 break;
2769
f3485b74
NC		 2770 case EM_ARM:
2771 decode_ARM_machine_flags (e_flags, buf);
2772 break;
76da6bbe 2773
343433df
AB		 2774 case EM_AVR:
2775 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2776 break;
2777
781303ce
MF		 2778 case EM_BLACKFIN:
2779 if (e_flags & EF_BFIN_PIC)
2780 strcat (buf, ", PIC");
2781
2782 if (e_flags & EF_BFIN_FDPIC)
2783 strcat (buf, ", FDPIC");
2784
2785 if (e_flags & EF_BFIN_CODE_IN_L1)
2786 strcat (buf, ", code in L1");
2787
2788 if (e_flags & EF_BFIN_DATA_IN_L1)
2789 strcat (buf, ", data in L1");
2790
2791 break;
2792
ec2dfb42
AO		 2793 case EM_CYGNUS_FRV:
2794 switch (e_flags & EF_FRV_CPU_MASK)
2795 {
2796 case EF_FRV_CPU_GENERIC:
2797 break;
2798
2799 default:
2800 strcat (buf, ", fr???");
2801 break;
57346661 2802
ec2dfb42
AO		 2803 case EF_FRV_CPU_FR300:
2804 strcat (buf, ", fr300");
2805 break;
2806
2807 case EF_FRV_CPU_FR400:
2808 strcat (buf, ", fr400");
2809 break;
2810 case EF_FRV_CPU_FR405:
2811 strcat (buf, ", fr405");
2812 break;
2813
2814 case EF_FRV_CPU_FR450:
2815 strcat (buf, ", fr450");
2816 break;
2817
2818 case EF_FRV_CPU_FR500:
2819 strcat (buf, ", fr500");
2820 break;
2821 case EF_FRV_CPU_FR550:
2822 strcat (buf, ", fr550");
2823 break;
2824
2825 case EF_FRV_CPU_SIMPLE:
2826 strcat (buf, ", simple");
2827 break;
2828 case EF_FRV_CPU_TOMCAT:
2829 strcat (buf, ", tomcat");
2830 break;
2831 }
1c877e87 2832 break;
ec2dfb42 2833
53c7db4b 2834 case EM_68K:
425c6cb0 2835 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2836 strcat (buf, ", m68000");
425c6cb0 2837 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2838 strcat (buf, ", cpu32");
2839 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2840 strcat (buf, ", fido_a");
425c6cb0 2841 else
266abb8f 2842 {
2cf0635d
NC		 2843 char const * isa = _("unknown");
2844 char const * mac = _("unknown mac");
2845 char const * additional = NULL;
0112cd26 2846
c694fd50 2847 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2848 {
c694fd50 2849 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2850 isa = "A";
2851 additional = ", nodiv";
2852 break;
c694fd50 2853 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2854 isa = "A";
2855 break;
c694fd50 2856 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2857 isa = "A+";
2858 break;
c694fd50 2859 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2860 isa = "B";
2861 additional = ", nousp";
2862 break;
c694fd50 2863 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2864 isa = "B";
2865 break;
f608cd77
NS		 2866 case EF_M68K_CF_ISA_C:
2867 isa = "C";
2868 break;
2869 case EF_M68K_CF_ISA_C_NODIV:
2870 isa = "C";
2871 additional = ", nodiv";
2872 break;
266abb8f
NS		 2873 }
2874 strcat (buf, ", cf, isa ");
2875 strcat (buf, isa);
0b2e31dc
NS		 2876 if (additional)
2877 strcat (buf, additional);
c694fd50 2878 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2879 strcat (buf, ", float");
c694fd50 2880 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2881 {
2882 case 0:
2883 mac = NULL;
2884 break;
c694fd50 2885 case EF_M68K_CF_MAC:
266abb8f
NS		 2886 mac = "mac";
2887 break;
c694fd50 2888 case EF_M68K_CF_EMAC:
266abb8f
NS		 2889 mac = "emac";
2890 break;
f608cd77
NS		 2891 case EF_M68K_CF_EMAC_B:
2892 mac = "emac_b";
2893 break;
266abb8f
NS		 2894 }
2895 if (mac)
2896 {
2897 strcat (buf, ", ");
2898 strcat (buf, mac);
2899 }
266abb8f 2900 }
53c7db4b 2901 break;
33c63f9d 2902
252b5132
RH		 2903 case EM_PPC:
2904 if (e_flags & EF_PPC_EMB)
2905 strcat (buf, ", emb");
2906
2907 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2908 strcat (buf, _(", relocatable"));
252b5132
RH		 2909
2910 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2911 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2912 break;
2913
ee67d69a
AM		 2914 case EM_PPC64:
2915 if (e_flags & EF_PPC64_ABI)
2916 {
2917 char abi[] = ", abiv0";
2918
2919 abi[6] += e_flags & EF_PPC64_ABI;
2920 strcat (buf, abi);
2921 }
2922 break;
2923
708e2187
NC		 2924 case EM_V800:
2925 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2926 strcat (buf, ", RH850 ABI");
0b4362b0 2927
708e2187
NC		 2928 if (e_flags & EF_V800_850E3)
2929 strcat (buf, ", V3 architecture");
2930
2931 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2932 strcat (buf, ", FPU not used");
2933
2934 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2935 strcat (buf, ", regmode: COMMON");
2936
2937 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2938 strcat (buf, ", r4 not used");
2939
2940 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2941 strcat (buf, ", r30 not used");
2942
2943 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2944 strcat (buf, ", r5 not used");
2945
2946 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2947 strcat (buf, ", r2 not used");
2948
2949 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2950 {
2951 switch (e_flags & - e_flags)
2952 {
2953 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2954 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2955 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2956 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2957 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2958 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2959 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2960 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2961 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2962 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2963 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2964 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2965 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2966 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2967 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2968 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2969 default: break;
2970 }
2971 }
2972 break;
2973
2b0337b0 2974 case EM_V850:
252b5132
RH		 2975 case EM_CYGNUS_V850:
2976 switch (e_flags & EF_V850_ARCH)
2977 {
78c8d46c
NC		 2978 case E_V850E3V5_ARCH:
2979 strcat (buf, ", v850e3v5");
2980 break;
1cd986c5
NC		 2981 case E_V850E2V3_ARCH:
2982 strcat (buf, ", v850e2v3");
2983 break;
2984 case E_V850E2_ARCH:
2985 strcat (buf, ", v850e2");
2986 break;
2987 case E_V850E1_ARCH:
2988 strcat (buf, ", v850e1");
8ad30312 2989 break;
252b5132
RH		 2990 case E_V850E_ARCH:
2991 strcat (buf, ", v850e");
2992 break;
252b5132
RH		 2993 case E_V850_ARCH:
2994 strcat (buf, ", v850");
2995 break;
2996 default:
2b692964 2997 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2998 break;
2999 }
3000 break;
3001
2b0337b0 3002 case EM_M32R:
252b5132
RH		 3003 case EM_CYGNUS_M32R:
3004 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3005 strcat (buf, ", m32r");
252b5132
RH		 3006 break;
3007
3008 case EM_MIPS:
4fe85591 3009 case EM_MIPS_RS3_LE:
252b5132
RH		 3010 if (e_flags & EF_MIPS_NOREORDER)
3011 strcat (buf, ", noreorder");
3012
3013 if (e_flags & EF_MIPS_PIC)
3014 strcat (buf, ", pic");
3015
3016 if (e_flags & EF_MIPS_CPIC)
3017 strcat (buf, ", cpic");
3018
d1bdd336
TS		 3019 if (e_flags & EF_MIPS_UCODE)
3020 strcat (buf, ", ugen_reserved");
3021
252b5132
RH		 3022 if (e_flags & EF_MIPS_ABI2)
3023 strcat (buf, ", abi2");
3024
43521d43
TS		 3025 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3026 strcat (buf, ", odk first");
3027
a5d22d2a
TS		 3028 if (e_flags & EF_MIPS_32BITMODE)
3029 strcat (buf, ", 32bitmode");
3030
ba92f887
MR		 3031 if (e_flags & EF_MIPS_NAN2008)
3032 strcat (buf, ", nan2008");
3033
fef1b0b3
SE		 3034 if (e_flags & EF_MIPS_FP64)
3035 strcat (buf, ", fp64");
3036
156c2f8b
NC		 3037 switch ((e_flags & EF_MIPS_MACH))
3038 {
3039 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3040 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3041 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3042 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3043 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3044 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3045 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3046 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3047 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3048 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3049 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3050 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3051 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3052 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3053 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3054 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3055 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3056 case 0:
3057 /* We simply ignore the field in this case to avoid confusion:
3058 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3059 extension. */
3060 break;
2b692964 3061 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3062 }
43521d43
TS		 3063
3064 switch ((e_flags & EF_MIPS_ABI))
3065 {
3066 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3067 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3068 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3069 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3070 case 0:
3071 /* We simply ignore the field in this case to avoid confusion:
3072 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3073 This means it is likely to be an o32 file, but not for
3074 sure. */
3075 break;
2b692964 3076 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3077 }
3078
3079 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3080 strcat (buf, ", mdmx");
3081
3082 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3083 strcat (buf, ", mips16");
3084
df58fc94
RS		 3085 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3086 strcat (buf, ", micromips");
3087
43521d43
TS		 3088 switch ((e_flags & EF_MIPS_ARCH))
3089 {
3090 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3091 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3092 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3093 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3094 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3095 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3096 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3097 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3098 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3099 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3100 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3101 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3102 }
252b5132 3103 break;
351b4b40 3104
35c08157
KLC		 3105 case EM_NDS32:
3106 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3107 break;
3108
ccde1100
AO		 3109 case EM_SH:
3110 switch ((e_flags & EF_SH_MACH_MASK))
3111 {
3112 case EF_SH1: strcat (buf, ", sh1"); break;
3113 case EF_SH2: strcat (buf, ", sh2"); break;
3114 case EF_SH3: strcat (buf, ", sh3"); break;
3115 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3116 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3117 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3118 case EF_SH3E: strcat (buf, ", sh3e"); break;
3119 case EF_SH4: strcat (buf, ", sh4"); break;
3120 case EF_SH5: strcat (buf, ", sh5"); break;
3121 case EF_SH2E: strcat (buf, ", sh2e"); break;
3122 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3123 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3124 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3125 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3126 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3127 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3128 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3129 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3130 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3131 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3132 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3133 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3134 }
3135
cec6a5b8
MR		 3136 if (e_flags & EF_SH_PIC)
3137 strcat (buf, ", pic");
3138
3139 if (e_flags & EF_SH_FDPIC)
3140 strcat (buf, ", fdpic");
ccde1100 3141 break;
73589c9d
CS		 3142
3143 case EM_OR1K:
3144 if (e_flags & EF_OR1K_NODELAY)
3145 strcat (buf, ", no delay");
3146 break;
57346661 3147
351b4b40
RH		 3148 case EM_SPARCV9:
3149 if (e_flags & EF_SPARC_32PLUS)
3150 strcat (buf, ", v8+");
3151
3152 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3153 strcat (buf, ", ultrasparcI");
3154
3155 if (e_flags & EF_SPARC_SUN_US3)
3156 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3157
3158 if (e_flags & EF_SPARC_HAL_R1)
3159 strcat (buf, ", halr1");
3160
3161 if (e_flags & EF_SPARC_LEDATA)
3162 strcat (buf, ", ledata");
3163
3164 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3165 strcat (buf, ", tso");
3166
3167 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3168 strcat (buf, ", pso");
3169
3170 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3171 strcat (buf, ", rmo");
3172 break;
7d466069 3173
103f02d3
UD		 3174 case EM_PARISC:
3175 switch (e_flags & EF_PARISC_ARCH)
3176 {
3177 case EFA_PARISC_1_0:
3178 strcpy (buf, ", PA-RISC 1.0");
3179 break;
3180 case EFA_PARISC_1_1:
3181 strcpy (buf, ", PA-RISC 1.1");
3182 break;
3183 case EFA_PARISC_2_0:
3184 strcpy (buf, ", PA-RISC 2.0");
3185 break;
3186 default:
3187 break;
3188 }
3189 if (e_flags & EF_PARISC_TRAPNIL)
3190 strcat (buf, ", trapnil");
3191 if (e_flags & EF_PARISC_EXT)
3192 strcat (buf, ", ext");
3193 if (e_flags & EF_PARISC_LSB)
3194 strcat (buf, ", lsb");
3195 if (e_flags & EF_PARISC_WIDE)
3196 strcat (buf, ", wide");
3197 if (e_flags & EF_PARISC_NO_KABP)
3198 strcat (buf, ", no kabp");
3199 if (e_flags & EF_PARISC_LAZYSWAP)
3200 strcat (buf, ", lazyswap");
30800947 3201 break;
76da6bbe 3202
7d466069 3203 case EM_PJ:
2b0337b0 3204 case EM_PJ_OLD:
7d466069
ILT		 3205 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3206 strcat (buf, ", new calling convention");
3207
3208 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3209 strcat (buf, ", gnu calling convention");
3210 break;
4d6ed7c8
NC		 3211
3212 case EM_IA_64:
3213 if ((e_flags & EF_IA_64_ABI64))
3214 strcat (buf, ", 64-bit");
3215 else
3216 strcat (buf, ", 32-bit");
3217 if ((e_flags & EF_IA_64_REDUCEDFP))
3218 strcat (buf, ", reduced fp model");
3219 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3220 strcat (buf, ", no function descriptors, constant gp");
3221 else if ((e_flags & EF_IA_64_CONS_GP))
3222 strcat (buf, ", constant gp");
3223 if ((e_flags & EF_IA_64_ABSOLUTE))
3224 strcat (buf, ", absolute");
28f997cf
TG		 3225 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3226 {
3227 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3228 strcat (buf, ", vms_linkages");
3229 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3230 {
3231 case EF_IA_64_VMS_COMCOD_SUCCESS:
3232 break;
3233 case EF_IA_64_VMS_COMCOD_WARNING:
3234 strcat (buf, ", warning");
3235 break;
3236 case EF_IA_64_VMS_COMCOD_ERROR:
3237 strcat (buf, ", error");
3238 break;
3239 case EF_IA_64_VMS_COMCOD_ABORT:
3240 strcat (buf, ", abort");
3241 break;
3242 default:
bee0ee85
NC		 3243 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3244 e_flags & EF_IA_64_VMS_COMCOD);
3245 strcat (buf, ", <unknown>");
28f997cf
TG		 3246 }
3247 }
4d6ed7c8 3248 break;
179d3252
JT		 3249
3250 case EM_VAX:
3251 if ((e_flags & EF_VAX_NONPIC))
3252 strcat (buf, ", non-PIC");
3253 if ((e_flags & EF_VAX_DFLOAT))
3254 strcat (buf, ", D-Float");
3255 if ((e_flags & EF_VAX_GFLOAT))
3256 strcat (buf, ", G-Float");
3257 break;
c7927a3c 3258
619ed720
EB		 3259 case EM_VISIUM:
3260 if (e_flags & EF_VISIUM_ARCH_MCM)
3261 strcat (buf, ", mcm");
3262 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3263 strcat (buf, ", mcm24");
3264 if (e_flags & EF_VISIUM_ARCH_GR6)
3265 strcat (buf, ", gr6");
3266 break;
3267
4046d87a
NC		 3268 case EM_RL78:
3269 if (e_flags & E_FLAG_RL78_G10)
3270 strcat (buf, ", G10");
856ea05c
KP		 3271 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3272 strcat (buf, ", 64-bit doubles");
4046d87a 3273 break;
0b4362b0 3274
c7927a3c
NC		 3275 case EM_RX:
3276 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3277 strcat (buf, ", 64-bit doubles");
3278 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3279 strcat (buf, ", dsp");
d4cb0ea0 3280 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3281 strcat (buf, ", pid");
708e2187
NC		 3282 if (e_flags & E_FLAG_RX_ABI)
3283 strcat (buf, ", RX ABI");
d4cb0ea0 3284 break;
55786da2
AK		 3285
3286 case EM_S390:
3287 if (e_flags & EF_S390_HIGH_GPRS)
3288 strcat (buf, ", highgprs");
d4cb0ea0 3289 break;
40b36596
JM		 3290
3291 case EM_TI_C6000:
3292 if ((e_flags & EF_C6000_REL))
3293 strcat (buf, ", relocatable module");
d4cb0ea0 3294 break;
13761a11
NC		 3295
3296 case EM_MSP430:
3297 strcat (buf, _(": architecture variant: "));
3298 switch (e_flags & EF_MSP430_MACH)
3299 {
3300 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3301 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3302 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3303 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3304 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3305 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3306 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3307 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3308 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3309 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3310 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3311 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3312 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3313 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3314 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3315 default:
3316 strcat (buf, _(": unknown")); break;
3317 }
3318
3319 if (e_flags & ~ EF_MSP430_MACH)
3320 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3321 }
3322 }
3323
3324 return buf;
3325}
3326
252b5132 3327static const char *
d3ba0551
AM		 3328get_osabi_name (unsigned int osabi)
3329{
3330 static char buff[32];
3331
3332 switch (osabi)
3333 {
3334 case ELFOSABI_NONE: return "UNIX - System V";
3335 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3336 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3337 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3338 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3339 case ELFOSABI_AIX: return "UNIX - AIX";
3340 case ELFOSABI_IRIX: return "UNIX - IRIX";
3341 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3342 case ELFOSABI_TRU64: return "UNIX - TRU64";
3343 case ELFOSABI_MODESTO: return "Novell - Modesto";
3344 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3345 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3346 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3347 case ELFOSABI_AROS: return "AROS";
11636f9e 3348 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3349 default:
40b36596
JM		 3350 if (osabi >= 64)
3351 switch (elf_header.e_machine)
3352 {
3353 case EM_ARM:
3354 switch (osabi)
3355 {
3356 case ELFOSABI_ARM: return "ARM";
3357 default:
3358 break;
3359 }
3360 break;
3361
3362 case EM_MSP430:
3363 case EM_MSP430_OLD:
619ed720 3364 case EM_VISIUM:
40b36596
JM		 3365 switch (osabi)
3366 {
3367 case ELFOSABI_STANDALONE: return _("Standalone App");
3368 default:
3369 break;
3370 }
3371 break;
3372
3373 case EM_TI_C6000:
3374 switch (osabi)
3375 {
3376 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3377 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3378 default:
3379 break;
3380 }
3381 break;
3382
3383 default:
3384 break;
3385 }
e9e44622 3386 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3387 return buff;
3388 }
3389}
3390
a06ea964
NC		 3391static const char *
3392get_aarch64_segment_type (unsigned long type)
3393{
3394 switch (type)
3395 {
3396 case PT_AARCH64_ARCHEXT:
3397 return "AARCH64_ARCHEXT";
3398 default:
3399 break;
3400 }
3401
3402 return NULL;
3403}
3404
b294bdf8
MM		 3405static const char *
3406get_arm_segment_type (unsigned long type)
3407{
3408 switch (type)
3409 {
3410 case PT_ARM_EXIDX:
3411 return "EXIDX";
3412 default:
3413 break;
3414 }
3415
3416 return NULL;
3417}
3418
d3ba0551
AM		 3419static const char *
3420get_mips_segment_type (unsigned long type)
252b5132
RH		 3421{
3422 switch (type)
3423 {
3424 case PT_MIPS_REGINFO:
3425 return "REGINFO";
3426 case PT_MIPS_RTPROC:
3427 return "RTPROC";
3428 case PT_MIPS_OPTIONS:
3429 return "OPTIONS";
351cdf24
MF		 3430 case PT_MIPS_ABIFLAGS:
3431 return "ABIFLAGS";
252b5132
RH		 3432 default:
3433 break;
3434 }
3435
3436 return NULL;
3437}
3438
103f02d3 3439static const char *
d3ba0551 3440get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3441{
3442 switch (type)
3443 {
3444 case PT_HP_TLS: return "HP_TLS";
3445 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3446 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3447 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3448 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3449 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3450 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3451 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3452 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3453 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3454 case PT_HP_PARALLEL: return "HP_PARALLEL";
3455 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3456 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3457 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3458 case PT_HP_STACK: return "HP_STACK";
3459 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3460 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3461 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3462 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3463 default:
3464 break;
3465 }
3466
3467 return NULL;
3468}
3469
4d6ed7c8 3470static const char *
d3ba0551 3471get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3472{
3473 switch (type)
3474 {
3475 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3476 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3477 case PT_HP_TLS: return "HP_TLS";
3478 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3479 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3480 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3481 default:
3482 break;
3483 }
3484
3485 return NULL;
3486}
3487
40b36596
JM		 3488static const char *
3489get_tic6x_segment_type (unsigned long type)
3490{
3491 switch (type)
3492 {
3493 case PT_C6000_PHATTR: return "C6000_PHATTR";
3494 default:
3495 break;
3496 }
3497
3498 return NULL;
3499}
3500
252b5132 3501static const char *
d3ba0551 3502get_segment_type (unsigned long p_type)
252b5132 3503{
b34976b6 3504 static char buff[32];
252b5132
RH		 3505
3506 switch (p_type)
3507 {
b34976b6
AM		 3508 case PT_NULL: return "NULL";
3509 case PT_LOAD: return "LOAD";
252b5132 3510 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3511 case PT_INTERP: return "INTERP";
3512 case PT_NOTE: return "NOTE";
3513 case PT_SHLIB: return "SHLIB";
3514 case PT_PHDR: return "PHDR";
13ae64f3 3515 case PT_TLS: return "TLS";
252b5132 3516
65765700
JJ		 3517 case PT_GNU_EH_FRAME:
3518 return "GNU_EH_FRAME";
2b05f1b7 3519 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3520 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3521
252b5132
RH		 3522 default:
3523 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3524 {
2cf0635d 3525 const char * result;
103f02d3 3526
252b5132
RH		 3527 switch (elf_header.e_machine)
3528 {
a06ea964
NC		 3529 case EM_AARCH64:
3530 result = get_aarch64_segment_type (p_type);
3531 break;
b294bdf8
MM		 3532 case EM_ARM:
3533 result = get_arm_segment_type (p_type);
3534 break;
252b5132 3535 case EM_MIPS:
4fe85591 3536 case EM_MIPS_RS3_LE:
252b5132
RH		 3537 result = get_mips_segment_type (p_type);
3538 break;
103f02d3
UD		 3539 case EM_PARISC:
3540 result = get_parisc_segment_type (p_type);
3541 break;
4d6ed7c8
NC		 3542 case EM_IA_64:
3543 result = get_ia64_segment_type (p_type);
3544 break;
40b36596
JM		 3545 case EM_TI_C6000:
3546 result = get_tic6x_segment_type (p_type);
3547 break;
252b5132
RH		 3548 default:
3549 result = NULL;
3550 break;
3551 }
103f02d3 3552
252b5132
RH		 3553 if (result != NULL)
3554 return result;
103f02d3 3555
252b5132
RH		 3556 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3557 }
3558 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3559 {
2cf0635d 3560 const char * result;
103f02d3
UD		 3561
3562 switch (elf_header.e_machine)
3563 {
3564 case EM_PARISC:
3565 result = get_parisc_segment_type (p_type);
3566 break;
00428cca
AM		 3567 case EM_IA_64:
3568 result = get_ia64_segment_type (p_type);
3569 break;
103f02d3
UD		 3570 default:
3571 result = NULL;
3572 break;
3573 }
3574
3575 if (result != NULL)
3576 return result;
3577
3578 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3579 }
252b5132 3580 else
e9e44622 3581 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3582
3583 return buff;
3584 }
3585}
3586
3587static const char *
d3ba0551 3588get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3589{
3590 switch (sh_type)
3591 {
b34976b6
AM		 3592 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3593 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3594 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3595 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3596 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3597 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3598 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3599 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3600 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3601 case SHT_MIPS_RELD: return "MIPS_RELD";
3602 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3603 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3604 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3605 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3606 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3607 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3608 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3609 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3610 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3611 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3612 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3613 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3614 case SHT_MIPS_LINE: return "MIPS_LINE";
3615 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3616 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3617 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3618 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3619 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3620 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3621 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3622 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3623 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3624 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3625 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3626 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3627 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3628 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3629 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3630 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3631 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3632 default:
3633 break;
3634 }
3635 return NULL;
3636}
3637
103f02d3 3638static const char *
d3ba0551 3639get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3640{
3641 switch (sh_type)
3642 {
3643 case SHT_PARISC_EXT: return "PARISC_EXT";
3644 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3645 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3646 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3647 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3648 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3649 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3650 default:
3651 break;
3652 }
3653 return NULL;
3654}
3655
4d6ed7c8 3656static const char *
d3ba0551 3657get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3658{
18bd398b 3659 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3660 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3661 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3662
4d6ed7c8
NC		 3663 switch (sh_type)
3664 {
148b93f2
NC		 3665 case SHT_IA_64_EXT: return "IA_64_EXT";
3666 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3667 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3668 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3669 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3670 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3671 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3672 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3673 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3674 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3675 default:
3676 break;
3677 }
3678 return NULL;
3679}
3680
d2b2c203
DJ		 3681static const char *
3682get_x86_64_section_type_name (unsigned int sh_type)
3683{
3684 switch (sh_type)
3685 {
3686 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3687 default:
3688 break;
3689 }
3690 return NULL;
3691}
3692
a06ea964
NC		 3693static const char *
3694get_aarch64_section_type_name (unsigned int sh_type)
3695{
3696 switch (sh_type)
3697 {
3698 case SHT_AARCH64_ATTRIBUTES:
3699 return "AARCH64_ATTRIBUTES";
3700 default:
3701 break;
3702 }
3703 return NULL;
3704}
3705
40a18ebd
NC		 3706static const char *
3707get_arm_section_type_name (unsigned int sh_type)
3708{
3709 switch (sh_type)
3710 {
7f6fed87
NC		 3711 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3712 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3713 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3714 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3715 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3716 default:
3717 break;
3718 }
3719 return NULL;
3720}
3721
40b36596
JM		 3722static const char *
3723get_tic6x_section_type_name (unsigned int sh_type)
3724{
3725 switch (sh_type)
3726 {
3727 case SHT_C6000_UNWIND:
3728 return "C6000_UNWIND";
3729 case SHT_C6000_PREEMPTMAP:
3730 return "C6000_PREEMPTMAP";
3731 case SHT_C6000_ATTRIBUTES:
3732 return "C6000_ATTRIBUTES";
3733 case SHT_TI_ICODE:
3734 return "TI_ICODE";
3735 case SHT_TI_XREF:
3736 return "TI_XREF";
3737 case SHT_TI_HANDLER:
3738 return "TI_HANDLER";
3739 case SHT_TI_INITINFO:
3740 return "TI_INITINFO";
3741 case SHT_TI_PHATTRS:
3742 return "TI_PHATTRS";
3743 default:
3744 break;
3745 }
3746 return NULL;
3747}
3748
13761a11
NC		 3749static const char *
3750get_msp430x_section_type_name (unsigned int sh_type)
3751{
3752 switch (sh_type)
3753 {
3754 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3755 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3756 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3757 default: return NULL;
3758 }
3759}
3760
252b5132 3761static const char *
d3ba0551 3762get_section_type_name (unsigned int sh_type)
252b5132 3763{
b34976b6 3764 static char buff[32];
252b5132
RH		 3765
3766 switch (sh_type)
3767 {
3768 case SHT_NULL: return "NULL";
3769 case SHT_PROGBITS: return "PROGBITS";
3770 case SHT_SYMTAB: return "SYMTAB";
3771 case SHT_STRTAB: return "STRTAB";
3772 case SHT_RELA: return "RELA";
3773 case SHT_HASH: return "HASH";
3774 case SHT_DYNAMIC: return "DYNAMIC";
3775 case SHT_NOTE: return "NOTE";
3776 case SHT_NOBITS: return "NOBITS";
3777 case SHT_REL: return "REL";
3778 case SHT_SHLIB: return "SHLIB";
3779 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3780 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3781 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3782 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3783 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3784 case SHT_GROUP: return "GROUP";
3785 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3786 case SHT_GNU_verdef: return "VERDEF";
3787 case SHT_GNU_verneed: return "VERNEED";
3788 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3789 case 0x6ffffff0: return "VERSYM";
3790 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3791 case 0x7ffffffd: return "AUXILIARY";
3792 case 0x7fffffff: return "FILTER";
047b2264 3793 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3794
3795 default:
3796 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3797 {
2cf0635d 3798 const char * result;
252b5132
RH		 3799
3800 switch (elf_header.e_machine)
3801 {
3802 case EM_MIPS:
4fe85591 3803 case EM_MIPS_RS3_LE:
252b5132
RH		 3804 result = get_mips_section_type_name (sh_type);
3805 break;
103f02d3
UD		 3806 case EM_PARISC:
3807 result = get_parisc_section_type_name (sh_type);
3808 break;
4d6ed7c8
NC		 3809 case EM_IA_64:
3810 result = get_ia64_section_type_name (sh_type);
3811 break;
d2b2c203 3812 case EM_X86_64:
8a9036a4 3813 case EM_L1OM:
7a9068fe 3814 case EM_K1OM:
d2b2c203
DJ		 3815 result = get_x86_64_section_type_name (sh_type);
3816 break;
a06ea964
NC		 3817 case EM_AARCH64:
3818 result = get_aarch64_section_type_name (sh_type);
3819 break;
40a18ebd
NC		 3820 case EM_ARM:
3821 result = get_arm_section_type_name (sh_type);
3822 break;
40b36596
JM		 3823 case EM_TI_C6000:
3824 result = get_tic6x_section_type_name (sh_type);
3825 break;
13761a11
NC		 3826 case EM_MSP430:
3827 result = get_msp430x_section_type_name (sh_type);
3828 break;
252b5132
RH		 3829 default:
3830 result = NULL;
3831 break;
3832 }
3833
3834 if (result != NULL)
3835 return result;
3836
c91d0dfb 3837 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3838 }
3839 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3840 {
2cf0635d 3841 const char * result;
148b93f2
NC		 3842
3843 switch (elf_header.e_machine)
3844 {
3845 case EM_IA_64:
3846 result = get_ia64_section_type_name (sh_type);
3847 break;
3848 default:
3849 result = NULL;
3850 break;
3851 }
3852
3853 if (result != NULL)
3854 return result;
3855
3856 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3857 }
252b5132 3858 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3859 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3860 else
a7dbfd1c
NC		 3861 /* This message is probably going to be displayed in a 15
3862 character wide field, so put the hex value first. */
3863 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3864
252b5132
RH		 3865 return buff;
3866 }
3867}
3868
2979dc34 3869#define OPTION_DEBUG_DUMP 512
2c610e4b 3870#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3871#define OPTION_DWARF_DEPTH 514
3872#define OPTION_DWARF_START 515
4723351a 3873#define OPTION_DWARF_CHECK 516
2979dc34 3874
85b1c36d 3875static struct option options[] =
252b5132 3876{
b34976b6 3877 {"all", no_argument, 0, 'a'},
252b5132
RH		 3878 {"file-header", no_argument, 0, 'h'},
3879 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3880 {"headers", no_argument, 0, 'e'},
3881 {"histogram", no_argument, 0, 'I'},
3882 {"segments", no_argument, 0, 'l'},
3883 {"sections", no_argument, 0, 'S'},
252b5132 3884 {"section-headers", no_argument, 0, 'S'},
f5842774 3885 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3886 {"section-details", no_argument, 0, 't'},
595cf52e 3887 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3888 {"symbols", no_argument, 0, 's'},
3889 {"syms", no_argument, 0, 's'},
2c610e4b 3890 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3891 {"relocs", no_argument, 0, 'r'},
3892 {"notes", no_argument, 0, 'n'},
3893 {"dynamic", no_argument, 0, 'd'},
a952a375 3894 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3895 {"version-info", no_argument, 0, 'V'},
3896 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3897 {"unwind", no_argument, 0, 'u'},
4145f1d5 3898 {"archive-index", no_argument, 0, 'c'},
b34976b6 3899 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3900 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3901 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3902#ifdef SUPPORT_DISASSEMBLY
3903 {"instruction-dump", required_argument, 0, 'i'},
3904#endif
cf13d699 3905 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3906
fd2f0033
TT		 3907 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3908 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3909 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3910
b34976b6
AM		 3911 {"version", no_argument, 0, 'v'},
3912 {"wide", no_argument, 0, 'W'},
3913 {"help", no_argument, 0, 'H'},
3914 {0, no_argument, 0, 0}
252b5132
RH		 3915};
3916
3917static void
2cf0635d 3918usage (FILE * stream)
252b5132 3919{
92f01d61
JM		 3920 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3921 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3922 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3923 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3924 -h --file-header Display the ELF file header\n\
3925 -l --program-headers Display the program headers\n\
3926 --segments An alias for --program-headers\n\
3927 -S --section-headers Display the sections' header\n\
3928 --sections An alias for --section-headers\n\
f5842774 3929 -g --section-groups Display the section groups\n\
5477e8a0 3930 -t --section-details Display the section details\n\
8b53311e
NC		 3931 -e --headers Equivalent to: -h -l -S\n\
3932 -s --syms Display the symbol table\n\
3f08eb35 3933 --symbols An alias for --syms\n\
2c610e4b 3934 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3935 -n --notes Display the core notes (if present)\n\
3936 -r --relocs Display the relocations (if present)\n\
3937 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3938 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3939 -V --version-info Display the version sections (if present)\n\
1b31d05e 3940 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3941 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3942 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3943 -x --hex-dump=<number|name>\n\
3944 Dump the contents of section <number|name> as bytes\n\
3945 -p --string-dump=<number|name>\n\
3946 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3947 -R --relocated-dump=<number|name>\n\
3948 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3949 -w[lLiaprmfFsoRt] or\n\
1ed06042 3950 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3951 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3952 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3953 =addr,=cu_index]\n\
8b53311e 3954 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3955 fprintf (stream, _("\
3956 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3957 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3958 or deeper\n"));
252b5132 3959#ifdef SUPPORT_DISASSEMBLY
92f01d61 3960 fprintf (stream, _("\
09c11c86
NC		 3961 -i --instruction-dump=<number|name>\n\
3962 Disassemble the contents of section <number|name>\n"));
252b5132 3963#endif
92f01d61 3964 fprintf (stream, _("\
8b53311e
NC		 3965 -I --histogram Display histogram of bucket list lengths\n\
3966 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3967 @<file> Read options from <file>\n\
8b53311e
NC		 3968 -H --help Display this information\n\
3969 -v --version Display the version number of readelf\n"));
1118d252 3970
92f01d61
JM		 3971 if (REPORT_BUGS_TO[0] && stream == stdout)
3972 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3973
92f01d61 3974 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3975}
3976
18bd398b
NC		 3977/* Record the fact that the user wants the contents of section number
3978 SECTION to be displayed using the method(s) encoded as flags bits
3979 in TYPE. Note, TYPE can be zero if we are creating the array for
3980 the first time. */
3981
252b5132 3982static void
09c11c86 3983request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3984{
3985 if (section >= num_dump_sects)
3986 {
2cf0635d 3987 dump_type * new_dump_sects;
252b5132 3988
3f5e193b
NC		 3989 new_dump_sects = (dump_type *) calloc (section + 1,
3990 sizeof (* dump_sects));
252b5132
RH		 3991
3992 if (new_dump_sects == NULL)
591a748a 3993 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3994 else
3995 {
3996 /* Copy current flag settings. */
09c11c86 3997 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3998
3999 free (dump_sects);
4000
4001 dump_sects = new_dump_sects;
4002 num_dump_sects = section + 1;
4003 }
4004 }
4005
4006 if (dump_sects)
b34976b6 4007 dump_sects[section] |= type;
252b5132
RH		 4008
4009 return;
4010}
4011
aef1f6d0
DJ		 4012/* Request a dump by section name. */
4013
4014static void
2cf0635d 4015request_dump_byname (const char * section, dump_type type)
aef1f6d0 4016{
2cf0635d 4017 struct dump_list_entry * new_request;
aef1f6d0 4018
3f5e193b
NC		 4019 new_request = (struct dump_list_entry *)
4020 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4021 if (!new_request)
591a748a 4022 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4023
4024 new_request->name = strdup (section);
4025 if (!new_request->name)
591a748a 4026 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4027
4028 new_request->type = type;
4029
4030 new_request->next = dump_sects_byname;
4031 dump_sects_byname = new_request;
4032}
4033
cf13d699
NC		 4034static inline void
4035request_dump (dump_type type)
4036{
4037 int section;
4038 char * cp;
4039
4040 do_dump++;
4041 section = strtoul (optarg, & cp, 0);
4042
4043 if (! *cp && section >= 0)
4044 request_dump_bynumber (section, type);
4045 else
4046 request_dump_byname (optarg, type);
4047}
4048
4049
252b5132 4050static void
2cf0635d 4051parse_args (int argc, char ** argv)
252b5132
RH		 4052{
4053 int c;
4054
4055 if (argc < 2)
92f01d61 4056 usage (stderr);
252b5132
RH		 4057
4058 while ((c = getopt_long
cf13d699 4059 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 4060 {
252b5132
RH		 4061 switch (c)
4062 {
4063 case 0:
4064 /* Long options. */
4065 break;
4066 case 'H':
92f01d61 4067 usage (stdout);
252b5132
RH		 4068 break;
4069
4070 case 'a':
b34976b6
AM		 4071 do_syms++;
4072 do_reloc++;
4073 do_unwind++;
4074 do_dynamic++;
4075 do_header++;
4076 do_sections++;
f5842774 4077 do_section_groups++;
b34976b6
AM		 4078 do_segments++;
4079 do_version++;
4080 do_histogram++;
4081 do_arch++;
4082 do_notes++;
252b5132 4083 break;
f5842774
L		 4084 case 'g':
4085 do_section_groups++;
4086 break;
5477e8a0 4087 case 't':
595cf52e 4088 case 'N':
5477e8a0
L		 4089 do_sections++;
4090 do_section_details++;
595cf52e 4091 break;
252b5132 4092 case 'e':
b34976b6
AM		 4093 do_header++;
4094 do_sections++;
4095 do_segments++;
252b5132 4096 break;
a952a375 4097 case 'A':
b34976b6 4098 do_arch++;
a952a375 4099 break;
252b5132 4100 case 'D':
b34976b6 4101 do_using_dynamic++;
252b5132
RH		 4102 break;
4103 case 'r':
b34976b6 4104 do_reloc++;
252b5132 4105 break;
4d6ed7c8 4106 case 'u':
b34976b6 4107 do_unwind++;
4d6ed7c8 4108 break;
252b5132 4109 case 'h':
b34976b6 4110 do_header++;
252b5132
RH		 4111 break;
4112 case 'l':
b34976b6 4113 do_segments++;
252b5132
RH		 4114 break;
4115 case 's':
b34976b6 4116 do_syms++;
252b5132
RH		 4117 break;
4118 case 'S':
b34976b6 4119 do_sections++;
252b5132
RH		 4120 break;
4121 case 'd':
b34976b6 4122 do_dynamic++;
252b5132 4123 break;
a952a375 4124 case 'I':
b34976b6 4125 do_histogram++;
a952a375 4126 break;
779fe533 4127 case 'n':
b34976b6 4128 do_notes++;
779fe533 4129 break;
4145f1d5
NC		 4130 case 'c':
4131 do_archive_index++;
4132 break;
252b5132 4133 case 'x':
cf13d699 4134 request_dump (HEX_DUMP);
aef1f6d0 4135 break;
09c11c86 4136 case 'p':
cf13d699
NC		 4137 request_dump (STRING_DUMP);
4138 break;
4139 case 'R':
4140 request_dump (RELOC_DUMP);
09c11c86 4141 break;
252b5132 4142 case 'w':
b34976b6 4143 do_dump++;
252b5132 4144 if (optarg == 0)
613ff48b
CC		 4145 {
4146 do_debugging = 1;
4147 dwarf_select_sections_all ();
4148 }
252b5132
RH		 4149 else
4150 {
4151 do_debugging = 0;
4cb93e3b 4152 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4153 }
4154 break;
2979dc34 4155 case OPTION_DEBUG_DUMP:
b34976b6 4156 do_dump++;
2979dc34
JJ		 4157 if (optarg == 0)
4158 do_debugging = 1;
4159 else
4160 {
2979dc34 4161 do_debugging = 0;
4cb93e3b 4162 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4163 }
4164 break;
fd2f0033
TT		 4165 case OPTION_DWARF_DEPTH:
4166 {
4167 char *cp;
4168
4169 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4170 }
4171 break;
4172 case OPTION_DWARF_START:
4173 {
4174 char *cp;
4175
4176 dwarf_start_die = strtoul (optarg, & cp, 0);
4177 }
4178 break;
4723351a
CC		 4179 case OPTION_DWARF_CHECK:
4180 dwarf_check = 1;
4181 break;
2c610e4b
L		 4182 case OPTION_DYN_SYMS:
4183 do_dyn_syms++;
4184 break;
252b5132
RH		 4185#ifdef SUPPORT_DISASSEMBLY
4186 case 'i':
cf13d699
NC		 4187 request_dump (DISASS_DUMP);
4188 break;
252b5132
RH		 4189#endif
4190 case 'v':
4191 print_version (program_name);
4192 break;
4193 case 'V':
b34976b6 4194 do_version++;
252b5132 4195 break;
d974e256 4196 case 'W':
b34976b6 4197 do_wide++;
d974e256 4198 break;
252b5132 4199 default:
252b5132
RH		 4200 /* xgettext:c-format */
4201 error (_("Invalid option '-%c'\n"), c);
4202 /* Drop through. */
4203 case '?':
92f01d61 4204 usage (stderr);
252b5132
RH		 4205 }
4206 }
4207
4d6ed7c8 4208 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4209 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4210 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4211 && !do_section_groups && !do_archive_index
4212 && !do_dyn_syms)
92f01d61 4213 usage (stderr);
252b5132
RH		 4214 else if (argc < 3)
4215 {
4216 warn (_("Nothing to do.\n"));
92f01d61 4217 usage (stderr);
252b5132
RH		 4218 }
4219}
4220
4221static const char *
d3ba0551 4222get_elf_class (unsigned int elf_class)
252b5132 4223{
b34976b6 4224 static char buff[32];
103f02d3 4225
252b5132
RH		 4226 switch (elf_class)
4227 {
4228 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4229 case ELFCLASS32: return "ELF32";
4230 case ELFCLASS64: return "ELF64";
ab5e7794 4231 default:
e9e44622 4232 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4233 return buff;
252b5132
RH		 4234 }
4235}
4236
4237static const char *
d3ba0551 4238get_data_encoding (unsigned int encoding)
252b5132 4239{
b34976b6 4240 static char buff[32];
103f02d3 4241
252b5132
RH		 4242 switch (encoding)
4243 {
4244 case ELFDATANONE: return _("none");
33c63f9d
CM		 4245 case ELFDATA2LSB: return _("2's complement, little endian");
4246 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4247 default:
e9e44622 4248 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4249 return buff;
252b5132
RH		 4250 }
4251}
4252
252b5132 4253/* Decode the data held in 'elf_header'. */
ee42cf8c 4254
252b5132 4255static int
d3ba0551 4256process_file_header (void)
252b5132 4257{
b34976b6
AM		 4258 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4259 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4260 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4261 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4262 {
4263 error
4264 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4265 return 0;
4266 }
4267
2dc4cec1
L		 4268 init_dwarf_regnames (elf_header.e_machine);
4269
252b5132
RH		 4270 if (do_header)
4271 {
4272 int i;
4273
4274 printf (_("ELF Header:\n"));
4275 printf (_(" Magic: "));
b34976b6
AM		 4276 for (i = 0; i < EI_NIDENT; i++)
4277 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4278 printf ("\n");
4279 printf (_(" Class: %s\n"),
b34976b6 4280 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4281 printf (_(" Data: %s\n"),
b34976b6 4282 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4283 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4284 elf_header.e_ident[EI_VERSION],
4285 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4286 ? "(current)"
b34976b6 4287 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4288 ? _("<unknown: %lx>")
789be9f7 4289 : "")));
252b5132 4290 printf (_(" OS/ABI: %s\n"),
b34976b6 4291 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4292 printf (_(" ABI Version: %d\n"),
b34976b6 4293 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4294 printf (_(" Type: %s\n"),
4295 get_file_type (elf_header.e_type));
4296 printf (_(" Machine: %s\n"),
4297 get_machine_name (elf_header.e_machine));
4298 printf (_(" Version: 0x%lx\n"),
4299 (unsigned long) elf_header.e_version);
76da6bbe 4300
f7a99963
NC		 4301 printf (_(" Entry point address: "));
4302 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4303 printf (_("\n Start of program headers: "));
4304 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4305 printf (_(" (bytes into file)\n Start of section headers: "));
4306 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4307 printf (_(" (bytes into file)\n"));
76da6bbe 4308
252b5132
RH		 4309 printf (_(" Flags: 0x%lx%s\n"),
4310 (unsigned long) elf_header.e_flags,
4311 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4312 printf (_(" Size of this header: %ld (bytes)\n"),
4313 (long) elf_header.e_ehsize);
4314 printf (_(" Size of program headers: %ld (bytes)\n"),
4315 (long) elf_header.e_phentsize);
2046a35d 4316 printf (_(" Number of program headers: %ld"),
252b5132 4317 (long) elf_header.e_phnum);
2046a35d
AM		 4318 if (section_headers != NULL
4319 && elf_header.e_phnum == PN_XNUM
4320 && section_headers[0].sh_info != 0)
cc5914eb 4321 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4322 putc ('\n', stdout);
252b5132
RH		 4323 printf (_(" Size of section headers: %ld (bytes)\n"),
4324 (long) elf_header.e_shentsize);
560f3c1c 4325 printf (_(" Number of section headers: %ld"),
252b5132 4326 (long) elf_header.e_shnum);
4fbb74a6 4327 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4328 printf (" (%ld)", (long) section_headers[0].sh_size);
4329 putc ('\n', stdout);
4330 printf (_(" Section header string table index: %ld"),
252b5132 4331 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4332 if (section_headers != NULL
4333 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4334 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4335 else if (elf_header.e_shstrndx != SHN_UNDEF
4336 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4337 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4338 putc ('\n', stdout);
4339 }
4340
4341 if (section_headers != NULL)
4342 {
2046a35d
AM		 4343 if (elf_header.e_phnum == PN_XNUM
4344 && section_headers[0].sh_info != 0)
4345 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4346 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4347 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4348 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4349 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4350 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4351 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4352 free (section_headers);
4353 section_headers = NULL;
252b5132 4354 }
103f02d3 4355
9ea033b2
NC		 4356 return 1;
4357}
4358
e0a31db1 4359static bfd_boolean
91d6fa6a 4360get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4361{
2cf0635d
NC		 4362 Elf32_External_Phdr * phdrs;
4363 Elf32_External_Phdr * external;
4364 Elf_Internal_Phdr * internal;
b34976b6 4365 unsigned int i;
e0a31db1
NC		 4366 unsigned int size = elf_header.e_phentsize;
4367 unsigned int num = elf_header.e_phnum;
4368
4369 /* PR binutils/17531: Cope with unexpected section header sizes. */
4370 if (size == 0 || num == 0)
4371 return FALSE;
4372 if (size < sizeof * phdrs)
4373 {
4374 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4375 return FALSE;
4376 }
4377 if (size > sizeof * phdrs)
4378 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4379
3f5e193b 4380 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4381 size, num, _("program headers"));
4382 if (phdrs == NULL)
4383 return FALSE;
9ea033b2 4384
91d6fa6a 4385 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4386 i < elf_header.e_phnum;
b34976b6 4387 i++, internal++, external++)
252b5132 4388 {
9ea033b2
NC		 4389 internal->p_type = BYTE_GET (external->p_type);
4390 internal->p_offset = BYTE_GET (external->p_offset);
4391 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4392 internal->p_paddr = BYTE_GET (external->p_paddr);
4393 internal->p_filesz = BYTE_GET (external->p_filesz);
4394 internal->p_memsz = BYTE_GET (external->p_memsz);
4395 internal->p_flags = BYTE_GET (external->p_flags);
4396 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4397 }
4398
9ea033b2 4399 free (phdrs);
e0a31db1 4400 return TRUE;
252b5132
RH		 4401}
4402
e0a31db1 4403static bfd_boolean
91d6fa6a 4404get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4405{
2cf0635d
NC		 4406 Elf64_External_Phdr * phdrs;
4407 Elf64_External_Phdr * external;
4408 Elf_Internal_Phdr * internal;
b34976b6 4409 unsigned int i;
e0a31db1
NC		 4410 unsigned int size = elf_header.e_phentsize;
4411 unsigned int num = elf_header.e_phnum;
4412
4413 /* PR binutils/17531: Cope with unexpected section header sizes. */
4414 if (size == 0 || num == 0)
4415 return FALSE;
4416 if (size < sizeof * phdrs)
4417 {
4418 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4419 return FALSE;
4420 }
4421 if (size > sizeof * phdrs)
4422 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4423
3f5e193b 4424 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4425 size, num, _("program headers"));
a6e9f9df 4426 if (!phdrs)
e0a31db1 4427 return FALSE;
9ea033b2 4428
91d6fa6a 4429 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4430 i < elf_header.e_phnum;
b34976b6 4431 i++, internal++, external++)
9ea033b2
NC		 4432 {
4433 internal->p_type = BYTE_GET (external->p_type);
4434 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4435 internal->p_offset = BYTE_GET (external->p_offset);
4436 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4437 internal->p_paddr = BYTE_GET (external->p_paddr);
4438 internal->p_filesz = BYTE_GET (external->p_filesz);
4439 internal->p_memsz = BYTE_GET (external->p_memsz);
4440 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4441 }
4442
4443 free (phdrs);
e0a31db1 4444 return TRUE;
9ea033b2 4445}
252b5132 4446
d93f0186
NC		 4447/* Returns 1 if the program headers were read into `program_headers'. */
4448
4449static int
2cf0635d 4450get_program_headers (FILE * file)
d93f0186 4451{
2cf0635d 4452 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4453
4454 /* Check cache of prior read. */
4455 if (program_headers != NULL)
4456 return 1;
4457
3f5e193b
NC		 4458 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4459 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4460
4461 if (phdrs == NULL)
4462 {
8b73c356
NC		 4463 error (_("Out of memory reading %u program headers\n"),
4464 elf_header.e_phnum);
d93f0186
NC		 4465 return 0;
4466 }
4467
4468 if (is_32bit_elf
4469 ? get_32bit_program_headers (file, phdrs)
4470 : get_64bit_program_headers (file, phdrs))
4471 {
4472 program_headers = phdrs;
4473 return 1;
4474 }
4475
4476 free (phdrs);
4477 return 0;
4478}
4479
2f62977e
NC		 4480/* Returns 1 if the program headers were loaded. */
4481
252b5132 4482static int
2cf0635d 4483process_program_headers (FILE * file)
252b5132 4484{
2cf0635d 4485 Elf_Internal_Phdr * segment;
b34976b6 4486 unsigned int i;
252b5132
RH		 4487
4488 if (elf_header.e_phnum == 0)
4489 {
82f2dbf7
NC		 4490 /* PR binutils/12467. */
4491 if (elf_header.e_phoff != 0)
4492 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4493 " header offset, but no program headers\n"));
82f2dbf7 4494 else if (do_segments)
252b5132 4495 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4496 return 0;
252b5132
RH		 4497 }
4498
4499 if (do_segments && !do_header)
4500 {
f7a99963
NC		 4501 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4502 printf (_("Entry point "));
4503 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4504 printf (_("\nThere are %d program headers, starting at offset "),
4505 elf_header.e_phnum);
4506 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4507 printf ("\n");
252b5132
RH		 4508 }
4509
d93f0186 4510 if (! get_program_headers (file))
252b5132 4511 return 0;
103f02d3 4512
252b5132
RH		 4513 if (do_segments)
4514 {
3a1a2036
NC		 4515 if (elf_header.e_phnum > 1)
4516 printf (_("\nProgram Headers:\n"));
4517 else
4518 printf (_("\nProgram Headers:\n"));
76da6bbe 4519
f7a99963
NC		 4520 if (is_32bit_elf)
4521 printf
4522 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4523 else if (do_wide)
4524 printf
4525 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4526 else
4527 {
4528 printf
4529 (_(" Type Offset VirtAddr PhysAddr\n"));
4530 printf
4531 (_(" FileSiz MemSiz Flags Align\n"));
4532 }
252b5132
RH		 4533 }
4534
252b5132 4535 dynamic_addr = 0;
1b228002 4536 dynamic_size = 0;
252b5132
RH		 4537
4538 for (i = 0, segment = program_headers;
4539 i < elf_header.e_phnum;
b34976b6 4540 i++, segment++)
252b5132
RH		 4541 {
4542 if (do_segments)
4543 {
103f02d3 4544 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4545
4546 if (is_32bit_elf)
4547 {
4548 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4549 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4550 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4551 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4552 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4553 printf ("%c%c%c ",
4554 (segment->p_flags & PF_R ? 'R' : ' '),
4555 (segment->p_flags & PF_W ? 'W' : ' '),
4556 (segment->p_flags & PF_X ? 'E' : ' '));
4557 printf ("%#lx", (unsigned long) segment->p_align);
4558 }
d974e256
JJ		 4559 else if (do_wide)
4560 {
4561 if ((unsigned long) segment->p_offset == segment->p_offset)
4562 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4563 else
4564 {
4565 print_vma (segment->p_offset, FULL_HEX);
4566 putchar (' ');
4567 }
4568
4569 print_vma (segment->p_vaddr, FULL_HEX);
4570 putchar (' ');
4571 print_vma (segment->p_paddr, FULL_HEX);
4572 putchar (' ');
4573
4574 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4575 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4576 else
4577 {
4578 print_vma (segment->p_filesz, FULL_HEX);
4579 putchar (' ');
4580 }
4581
4582 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4583 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4584 else
4585 {
f48e6c45 4586 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4587 }
4588
4589 printf (" %c%c%c ",
4590 (segment->p_flags & PF_R ? 'R' : ' '),
4591 (segment->p_flags & PF_W ? 'W' : ' '),
4592 (segment->p_flags & PF_X ? 'E' : ' '));
4593
4594 if ((unsigned long) segment->p_align == segment->p_align)
4595 printf ("%#lx", (unsigned long) segment->p_align);
4596 else
4597 {
4598 print_vma (segment->p_align, PREFIX_HEX);
4599 }
4600 }
f7a99963
NC		 4601 else
4602 {
4603 print_vma (segment->p_offset, FULL_HEX);
4604 putchar (' ');
4605 print_vma (segment->p_vaddr, FULL_HEX);
4606 putchar (' ');
4607 print_vma (segment->p_paddr, FULL_HEX);
4608 printf ("\n ");
4609 print_vma (segment->p_filesz, FULL_HEX);
4610 putchar (' ');
4611 print_vma (segment->p_memsz, FULL_HEX);
4612 printf (" %c%c%c ",
4613 (segment->p_flags & PF_R ? 'R' : ' '),
4614 (segment->p_flags & PF_W ? 'W' : ' '),
4615 (segment->p_flags & PF_X ? 'E' : ' '));
4616 print_vma (segment->p_align, HEX);
4617 }
252b5132
RH		 4618 }
4619
f54498b4
NC		 4620 if (do_segments)
4621 putc ('\n', stdout);
4622
252b5132
RH		 4623 switch (segment->p_type)
4624 {
252b5132
RH		 4625 case PT_DYNAMIC:
4626 if (dynamic_addr)
4627 error (_("more than one dynamic segment\n"));
4628
20737c13
AM		 4629 /* By default, assume that the .dynamic section is the first
4630 section in the DYNAMIC segment. */
4631 dynamic_addr = segment->p_offset;
4632 dynamic_size = segment->p_filesz;
f54498b4
NC		 4633 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4634 if (dynamic_addr + dynamic_size >= current_file_size)
4635 {
4636 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4637 dynamic_addr = dynamic_size = 0;
4638 }
20737c13 4639
b2d38a17
NC		 4640 /* Try to locate the .dynamic section. If there is
4641 a section header table, we can easily locate it. */
4642 if (section_headers != NULL)
4643 {
2cf0635d 4644 Elf_Internal_Shdr * sec;
b2d38a17 4645
89fac5e3
RS		 4646 sec = find_section (".dynamic");
4647 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4648 {
28f997cf
TG		 4649 /* A corresponding .dynamic section is expected, but on
4650 IA-64/OpenVMS it is OK for it to be missing. */
4651 if (!is_ia64_vms ())
4652 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4653 break;
4654 }
4655
42bb2e33 4656 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4657 {
4658 dynamic_size = 0;
4659 break;
4660 }
42bb2e33 4661
b2d38a17
NC		 4662 dynamic_addr = sec->sh_offset;
4663 dynamic_size = sec->sh_size;
4664
4665 if (dynamic_addr < segment->p_offset
4666 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4667 warn (_("the .dynamic section is not contained"
4668 " within the dynamic segment\n"));
b2d38a17 4669 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4670 warn (_("the .dynamic section is not the first section"
4671 " in the dynamic segment.\n"));
b2d38a17 4672 }
252b5132
RH		 4673 break;
4674
4675 case PT_INTERP:
fb52b2f4
NC		 4676 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4677 SEEK_SET))
252b5132
RH		 4678 error (_("Unable to find program interpreter name\n"));
4679 else
4680 {
f8eae8b2 4681 char fmt [32];
9495b2e6 4682 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4683
4684 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4685 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4686
252b5132 4687 program_interpreter[0] = 0;
7bd7b3ef
AM		 4688 if (fscanf (file, fmt, program_interpreter) <= 0)
4689 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4690
4691 if (do_segments)
f54498b4 4692 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4693 program_interpreter);
4694 }
4695 break;
4696 }
252b5132
RH		 4697 }
4698
c256ffe7 4699 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4700 {
4701 printf (_("\n Section to Segment mapping:\n"));
4702 printf (_(" Segment Sections...\n"));
4703
252b5132
RH		 4704 for (i = 0; i < elf_header.e_phnum; i++)
4705 {
9ad5cbcf 4706 unsigned int j;
2cf0635d 4707 Elf_Internal_Shdr * section;
252b5132
RH		 4708
4709 segment = program_headers + i;
b391a3e3 4710 section = section_headers + 1;
252b5132
RH		 4711
4712 printf (" %2.2d ", i);
4713
b34976b6 4714 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4715 {
f4638467
AM		 4716 if (!ELF_TBSS_SPECIAL (section, segment)
4717 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4718 printf ("%s ", printable_section_name (section));
252b5132
RH		 4719 }
4720
4721 putc ('\n',stdout);
4722 }
4723 }
4724
252b5132
RH		 4725 return 1;
4726}
4727
4728
d93f0186
NC		 4729/* Find the file offset corresponding to VMA by using the program headers. */
4730
4731static long
2cf0635d 4732offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4733{
2cf0635d 4734 Elf_Internal_Phdr * seg;
d93f0186
NC		 4735
4736 if (! get_program_headers (file))
4737 {
4738 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4739 return (long) vma;
4740 }
4741
4742 for (seg = program_headers;
4743 seg < program_headers + elf_header.e_phnum;
4744 ++seg)
4745 {
4746 if (seg->p_type != PT_LOAD)
4747 continue;
4748
4749 if (vma >= (seg->p_vaddr & -seg->p_align)
4750 && vma + size <= seg->p_vaddr + seg->p_filesz)
4751 return vma - seg->p_vaddr + seg->p_offset;
4752 }
4753
4754 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4755 (unsigned long) vma);
d93f0186
NC		 4756 return (long) vma;
4757}
4758
4759
049b0c3a
NC		 4760/* Allocate memory and load the sections headers into the global pointer
4761 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4762 generate any error messages if the load fails. */
4763
4764static bfd_boolean
4765get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4766{
2cf0635d
NC		 4767 Elf32_External_Shdr * shdrs;
4768 Elf_Internal_Shdr * internal;
b34976b6 4769 unsigned int i;
049b0c3a
NC		 4770 unsigned int size = elf_header.e_shentsize;
4771 unsigned int num = probe ? 1 : elf_header.e_shnum;
4772
4773 /* PR binutils/17531: Cope with unexpected section header sizes. */
4774 if (size == 0 || num == 0)
4775 return FALSE;
4776 if (size < sizeof * shdrs)
4777 {
4778 if (! probe)
4779 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4780 return FALSE;
4781 }
4782 if (!probe && size > sizeof * shdrs)
4783 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4784
3f5e193b 4785 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4786 size, num,
4787 probe ? NULL : _("section headers"));
4788 if (shdrs == NULL)
4789 return FALSE;
252b5132 4790
049b0c3a
NC		 4791 if (section_headers != NULL)
4792 free (section_headers);
3f5e193b
NC		 4793 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4794 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4795 if (section_headers == NULL)
4796 {
049b0c3a 4797 if (!probe)
8b73c356 4798 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4799 return FALSE;
252b5132
RH		 4800 }
4801
4802 for (i = 0, internal = section_headers;
560f3c1c 4803 i < num;
b34976b6 4804 i++, internal++)
252b5132
RH		 4805 {
4806 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4807 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4808 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4809 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4810 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4811 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4812 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4813 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4814 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4815 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4816 }
4817
4818 free (shdrs);
049b0c3a 4819 return TRUE;
252b5132
RH		 4820}
4821
049b0c3a
NC		 4822static bfd_boolean
4823get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4824{
2cf0635d
NC		 4825 Elf64_External_Shdr * shdrs;
4826 Elf_Internal_Shdr * internal;
b34976b6 4827 unsigned int i;
049b0c3a
NC		 4828 unsigned int size = elf_header.e_shentsize;
4829 unsigned int num = probe ? 1 : elf_header.e_shnum;
4830
4831 /* PR binutils/17531: Cope with unexpected section header sizes. */
4832 if (size == 0 || num == 0)
4833 return FALSE;
4834 if (size < sizeof * shdrs)
4835 {
4836 if (! probe)
4837 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4838 return FALSE;
4839 }
4840 if (! probe && size > sizeof * shdrs)
4841 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4842
3f5e193b 4843 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4844 size, num,
4845 probe ? NULL : _("section headers"));
4846 if (shdrs == NULL)
4847 return FALSE;
9ea033b2 4848
049b0c3a
NC		 4849 if (section_headers != NULL)
4850 free (section_headers);
3f5e193b
NC		 4851 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4852 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4853 if (section_headers == NULL)
4854 {
049b0c3a 4855 if (! probe)
8b73c356 4856 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4857 return FALSE;
9ea033b2
NC		 4858 }
4859
4860 for (i = 0, internal = section_headers;
560f3c1c 4861 i < num;
b34976b6 4862 i++, internal++)
9ea033b2
NC		 4863 {
4864 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4865 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4866 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4867 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4868 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4869 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4870 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4871 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4872 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4873 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4874 }
4875
4876 free (shdrs);
049b0c3a 4877 return TRUE;
9ea033b2
NC		 4878}
4879
252b5132 4880static Elf_Internal_Sym *
ba5cdace
NC		 4881get_32bit_elf_symbols (FILE * file,
4882 Elf_Internal_Shdr * section,
4883 unsigned long * num_syms_return)
252b5132 4884{
ba5cdace 4885 unsigned long number = 0;
dd24e3da 4886 Elf32_External_Sym * esyms = NULL;
ba5cdace 4887 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4888 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4889 Elf_Internal_Sym * psym;
b34976b6 4890 unsigned int j;
252b5132 4891
c9c1d674
EG		 4892 if (section->sh_size == 0)
4893 {
4894 if (num_syms_return != NULL)
4895 * num_syms_return = 0;
4896 return NULL;
4897 }
4898
dd24e3da 4899 /* Run some sanity checks first. */
c9c1d674 4900 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4901 {
c9c1d674
EG		 4902 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4903 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4904 goto exit_point;
dd24e3da
NC		 4905 }
4906
f54498b4
NC		 4907 if (section->sh_size > current_file_size)
4908 {
4909 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4910 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4911 goto exit_point;
4912 }
4913
dd24e3da
NC		 4914 number = section->sh_size / section->sh_entsize;
4915
4916 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4917 {
c9c1d674 4918 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4919 (unsigned long) section->sh_size,
4920 printable_section_name (section),
4921 (unsigned long) section->sh_entsize);
ba5cdace 4922 goto exit_point;
dd24e3da
NC		 4923 }
4924
3f5e193b
NC		 4925 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4926 section->sh_size, _("symbols"));
dd24e3da 4927 if (esyms == NULL)
ba5cdace 4928 goto exit_point;
252b5132 4929
9ad5cbcf
AM		 4930 shndx = NULL;
4931 if (symtab_shndx_hdr != NULL
4932 && (symtab_shndx_hdr->sh_link
4fbb74a6 4933 == (unsigned long) (section - section_headers)))
9ad5cbcf 4934 {
3f5e193b
NC		 4935 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4936 symtab_shndx_hdr->sh_offset,
4937 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4938 _("symbol table section indicies"));
dd24e3da
NC		 4939 if (shndx == NULL)
4940 goto exit_point;
c9c1d674
EG		 4941 /* PR17531: file: heap-buffer-overflow */
4942 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4943 {
4944 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4945 printable_section_name (symtab_shndx_hdr),
4946 (unsigned long) symtab_shndx_hdr->sh_size,
4947 (unsigned long) section->sh_size);
4948 goto exit_point;
4949 }
9ad5cbcf
AM		 4950 }
4951
3f5e193b 4952 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4953
4954 if (isyms == NULL)
4955 {
8b73c356
NC		 4956 error (_("Out of memory reading %lu symbols\n"),
4957 (unsigned long) number);
dd24e3da 4958 goto exit_point;
252b5132
RH		 4959 }
4960
dd24e3da 4961 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4962 {
4963 psym->st_name = BYTE_GET (esyms[j].st_name);
4964 psym->st_value = BYTE_GET (esyms[j].st_value);
4965 psym->st_size = BYTE_GET (esyms[j].st_size);
4966 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4967 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4968 psym->st_shndx
4969 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4970 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4971 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4972 psym->st_info = BYTE_GET (esyms[j].st_info);
4973 psym->st_other = BYTE_GET (esyms[j].st_other);
4974 }
4975
dd24e3da 4976 exit_point:
ba5cdace 4977 if (shndx != NULL)
9ad5cbcf 4978 free (shndx);
ba5cdace 4979 if (esyms != NULL)
dd24e3da 4980 free (esyms);
252b5132 4981
ba5cdace
NC		 4982 if (num_syms_return != NULL)
4983 * num_syms_return = isyms == NULL ? 0 : number;
4984
252b5132
RH		 4985 return isyms;
4986}
4987
9ea033b2 4988static Elf_Internal_Sym *
ba5cdace
NC		 4989get_64bit_elf_symbols (FILE * file,
4990 Elf_Internal_Shdr * section,
4991 unsigned long * num_syms_return)
9ea033b2 4992{
ba5cdace
NC		 4993 unsigned long number = 0;
4994 Elf64_External_Sym * esyms = NULL;
4995 Elf_External_Sym_Shndx * shndx = NULL;
4996 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4997 Elf_Internal_Sym * psym;
b34976b6 4998 unsigned int j;
9ea033b2 4999
c9c1d674
EG		 5000 if (section->sh_size == 0)
5001 {
5002 if (num_syms_return != NULL)
5003 * num_syms_return = 0;
5004 return NULL;
5005 }
5006
dd24e3da 5007 /* Run some sanity checks first. */
c9c1d674 5008 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5009 {
c9c1d674 5010 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5011 printable_section_name (section),
5012 (unsigned long) section->sh_entsize);
ba5cdace 5013 goto exit_point;
dd24e3da
NC		 5014 }
5015
f54498b4
NC		 5016 if (section->sh_size > current_file_size)
5017 {
5018 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5019 printable_section_name (section),
5020 (unsigned long) section->sh_size);
f54498b4
NC		 5021 goto exit_point;
5022 }
5023
dd24e3da
NC		 5024 number = section->sh_size / section->sh_entsize;
5025
5026 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5027 {
c9c1d674 5028 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5029 (unsigned long) section->sh_size,
5030 printable_section_name (section),
5031 (unsigned long) section->sh_entsize);
ba5cdace 5032 goto exit_point;
dd24e3da
NC		 5033 }
5034
3f5e193b
NC		 5035 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5036 section->sh_size, _("symbols"));
a6e9f9df 5037 if (!esyms)
ba5cdace 5038 goto exit_point;
9ea033b2 5039
9ad5cbcf
AM		 5040 if (symtab_shndx_hdr != NULL
5041 && (symtab_shndx_hdr->sh_link
4fbb74a6 5042 == (unsigned long) (section - section_headers)))
9ad5cbcf 5043 {
3f5e193b
NC		 5044 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5045 symtab_shndx_hdr->sh_offset,
5046 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5047 _("symbol table section indicies"));
ba5cdace
NC		 5048 if (shndx == NULL)
5049 goto exit_point;
c9c1d674
EG		 5050 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5051 {
5052 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5053 printable_section_name (symtab_shndx_hdr),
5054 (unsigned long) symtab_shndx_hdr->sh_size,
5055 (unsigned long) section->sh_size);
5056 goto exit_point;
5057 }
9ad5cbcf
AM		 5058 }
5059
3f5e193b 5060 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5061
5062 if (isyms == NULL)
5063 {
8b73c356
NC		 5064 error (_("Out of memory reading %lu symbols\n"),
5065 (unsigned long) number);
ba5cdace 5066 goto exit_point;
9ea033b2
NC		 5067 }
5068
ba5cdace 5069 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5070 {
5071 psym->st_name = BYTE_GET (esyms[j].st_name);
5072 psym->st_info = BYTE_GET (esyms[j].st_info);
5073 psym->st_other = BYTE_GET (esyms[j].st_other);
5074 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5075
4fbb74a6 5076 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5077 psym->st_shndx
5078 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5079 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5080 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5081
66543521
AM		 5082 psym->st_value = BYTE_GET (esyms[j].st_value);
5083 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5084 }
5085
ba5cdace
NC		 5086 exit_point:
5087 if (shndx != NULL)
9ad5cbcf 5088 free (shndx);
ba5cdace
NC		 5089 if (esyms != NULL)
5090 free (esyms);
5091
5092 if (num_syms_return != NULL)
5093 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5094
5095 return isyms;
5096}
5097
d1133906 5098static const char *
d3ba0551 5099get_elf_section_flags (bfd_vma sh_flags)
d1133906 5100{
5477e8a0 5101 static char buff[1024];
2cf0635d 5102 char * p = buff;
8d5ff12c 5103 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5104 int sindex;
5105 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5106 bfd_vma os_flags = 0;
5107 bfd_vma proc_flags = 0;
5108 bfd_vma unknown_flags = 0;
148b93f2 5109 static const struct
5477e8a0 5110 {
2cf0635d 5111 const char * str;
5477e8a0
L		 5112 int len;
5113 }
5114 flags [] =
5115 {
cfcac11d
NC		 5116 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5117 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5118 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5119 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5120 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5121 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5122 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5123 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5124 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5125 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5126 /* IA-64 specific. */
5127 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5128 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5129 /* IA-64 OpenVMS specific. */
5130 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5131 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5132 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5133 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5134 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5135 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5136 /* Generic. */
cfcac11d 5137 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5138 /* SPARC specific. */
cfcac11d 5139 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 5140 };
5141
5142 if (do_section_details)
5143 {
8d5ff12c
L		 5144 sprintf (buff, "[%*.*lx]: ",
5145 field_size, field_size, (unsigned long) sh_flags);
5146 p += field_size + 4;
5477e8a0 5147 }
76da6bbe 5148
d1133906
NC		 5149 while (sh_flags)
5150 {
5151 bfd_vma flag;
5152
5153 flag = sh_flags & - sh_flags;
5154 sh_flags &= ~ flag;
76da6bbe 5155
5477e8a0 5156 if (do_section_details)
d1133906 5157 {
5477e8a0
L		 5158 switch (flag)
5159 {
91d6fa6a
NC		 5160 case SHF_WRITE: sindex = 0; break;
5161 case SHF_ALLOC: sindex = 1; break;
5162 case SHF_EXECINSTR: sindex = 2; break;
5163 case SHF_MERGE: sindex = 3; break;
5164 case SHF_STRINGS: sindex = 4; break;
5165 case SHF_INFO_LINK: sindex = 5; break;
5166 case SHF_LINK_ORDER: sindex = 6; break;
5167 case SHF_OS_NONCONFORMING: sindex = 7; break;
5168 case SHF_GROUP: sindex = 8; break;
5169 case SHF_TLS: sindex = 9; break;
18ae9cc1 5170 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 5171
5477e8a0 5172 default:
91d6fa6a 5173 sindex = -1;
cfcac11d 5174 switch (elf_header.e_machine)
148b93f2 5175 {
cfcac11d 5176 case EM_IA_64:
148b93f2 5177 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5178 sindex = 10;
148b93f2 5179 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5180 sindex = 11;
148b93f2
NC		 5181#ifdef BFD64
5182 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5183 switch (flag)
5184 {
91d6fa6a
NC		 5185 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5186 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5187 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5188 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5189 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5190 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5191 default: break;
5192 }
5193#endif
cfcac11d
NC		 5194 break;
5195
caa83f8b
NC		 5196 case EM_386:
5197 case EM_486:
5198 case EM_X86_64:
7f502d6c 5199 case EM_L1OM:
7a9068fe 5200 case EM_K1OM:
cfcac11d
NC		 5201 case EM_OLD_SPARCV9:
5202 case EM_SPARC32PLUS:
5203 case EM_SPARCV9:
5204 case EM_SPARC:
18ae9cc1 5205 if (flag == SHF_ORDERED)
91d6fa6a 5206 sindex = 19;
cfcac11d
NC		 5207 break;
5208 default:
5209 break;
148b93f2 5210 }
5477e8a0
L		 5211 }
5212
91d6fa6a 5213 if (sindex != -1)
5477e8a0 5214 {
8d5ff12c
L		 5215 if (p != buff + field_size + 4)
5216 {
5217 if (size < (10 + 2))
bee0ee85
NC		 5218 {
5219 warn (_("Internal error: not enough buffer room for section flag info"));
5220 return _("<unknown>");
5221 }
8d5ff12c
L		 5222 size -= 2;
5223 *p++ = ',';
5224 *p++ = ' ';
5225 }
5226
91d6fa6a
NC		 5227 size -= flags [sindex].len;
5228 p = stpcpy (p, flags [sindex].str);
5477e8a0 5229 }
3b22753a 5230 else if (flag & SHF_MASKOS)
8d5ff12c 5231 os_flags |= flag;
d1133906 5232 else if (flag & SHF_MASKPROC)
8d5ff12c 5233 proc_flags |= flag;
d1133906 5234 else
8d5ff12c 5235 unknown_flags |= flag;
5477e8a0
L		 5236 }
5237 else
5238 {
5239 switch (flag)
5240 {
5241 case SHF_WRITE: *p = 'W'; break;
5242 case SHF_ALLOC: *p = 'A'; break;
5243 case SHF_EXECINSTR: *p = 'X'; break;
5244 case SHF_MERGE: *p = 'M'; break;
5245 case SHF_STRINGS: *p = 'S'; break;
5246 case SHF_INFO_LINK: *p = 'I'; break;
5247 case SHF_LINK_ORDER: *p = 'L'; break;
5248 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5249 case SHF_GROUP: *p = 'G'; break;
5250 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5251 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 5252
5253 default:
8a9036a4 5254 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5255 || elf_header.e_machine == EM_L1OM
5256 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5257 && flag == SHF_X86_64_LARGE)
5258 *p = 'l';
5259 else if (flag & SHF_MASKOS)
5260 {
5261 *p = 'o';
5262 sh_flags &= ~ SHF_MASKOS;
5263 }
5264 else if (flag & SHF_MASKPROC)
5265 {
5266 *p = 'p';
5267 sh_flags &= ~ SHF_MASKPROC;
5268 }
5269 else
5270 *p = 'x';
5271 break;
5272 }
5273 p++;
d1133906
NC		 5274 }
5275 }
76da6bbe 5276
8d5ff12c
L		 5277 if (do_section_details)
5278 {
5279 if (os_flags)
5280 {
5281 size -= 5 + field_size;
5282 if (p != buff + field_size + 4)
5283 {
5284 if (size < (2 + 1))
bee0ee85
NC		 5285 {
5286 warn (_("Internal error: not enough buffer room for section flag info"));
5287 return _("<unknown>");
5288 }
8d5ff12c
L		 5289 size -= 2;
5290 *p++ = ',';
5291 *p++ = ' ';
5292 }
5293 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5294 (unsigned long) os_flags);
5295 p += 5 + field_size;
5296 }
5297 if (proc_flags)
5298 {
5299 size -= 7 + field_size;
5300 if (p != buff + field_size + 4)
5301 {
5302 if (size < (2 + 1))
bee0ee85
NC		 5303 {
5304 warn (_("Internal error: not enough buffer room for section flag info"));
5305 return _("<unknown>");
5306 }
8d5ff12c
L		 5307 size -= 2;
5308 *p++ = ',';
5309 *p++ = ' ';
5310 }
5311 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5312 (unsigned long) proc_flags);
5313 p += 7 + field_size;
5314 }
5315 if (unknown_flags)
5316 {
5317 size -= 10 + field_size;
5318 if (p != buff + field_size + 4)
5319 {
5320 if (size < (2 + 1))
bee0ee85
NC		 5321 {
5322 warn (_("Internal error: not enough buffer room for section flag info"));
5323 return _("<unknown>");
5324 }
8d5ff12c
L		 5325 size -= 2;
5326 *p++ = ',';
5327 *p++ = ' ';
5328 }
2b692964 5329 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5330 (unsigned long) unknown_flags);
5331 p += 10 + field_size;
5332 }
5333 }
5334
e9e44622 5335 *p = '\0';
d1133906
NC		 5336 return buff;
5337}
5338
252b5132 5339static int
2cf0635d 5340process_section_headers (FILE * file)
252b5132 5341{
2cf0635d 5342 Elf_Internal_Shdr * section;
b34976b6 5343 unsigned int i;
252b5132
RH		 5344
5345 section_headers = NULL;
5346
5347 if (elf_header.e_shnum == 0)
5348 {
82f2dbf7
NC		 5349 /* PR binutils/12467. */
5350 if (elf_header.e_shoff != 0)
5351 warn (_("possibly corrupt ELF file header - it has a non-zero"
5352 " section header offset, but no section headers\n"));
5353 else if (do_sections)
252b5132
RH		 5354 printf (_("\nThere are no sections in this file.\n"));
5355
5356 return 1;
5357 }
5358
5359 if (do_sections && !do_header)
9ea033b2 5360 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5361 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5362
9ea033b2
NC		 5363 if (is_32bit_elf)
5364 {
049b0c3a 5365 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5366 return 0;
5367 }
049b0c3a 5368 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5369 return 0;
5370
5371 /* Read in the string table, so that we have names to display. */
0b49d371 5372 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5373 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5374 {
4fbb74a6 5375 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5376
c256ffe7
JJ		 5377 if (section->sh_size != 0)
5378 {
3f5e193b
NC		 5379 string_table = (char *) get_data (NULL, file, section->sh_offset,
5380 1, section->sh_size,
5381 _("string table"));
0de14b54 5382
c256ffe7
JJ		 5383 string_table_length = string_table != NULL ? section->sh_size : 0;
5384 }
252b5132
RH		 5385 }
5386
5387 /* Scan the sections for the dynamic symbol table
e3c8793a 5388 and dynamic string table and debug sections. */
252b5132
RH		 5389 dynamic_symbols = NULL;
5390 dynamic_strings = NULL;
5391 dynamic_syminfo = NULL;
f1ef08cb 5392 symtab_shndx_hdr = NULL;
103f02d3 5393
89fac5e3
RS		 5394 eh_addr_size = is_32bit_elf ? 4 : 8;
5395 switch (elf_header.e_machine)
5396 {
5397 case EM_MIPS:
5398 case EM_MIPS_RS3_LE:
5399 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5400 FDE addresses. However, the ABI also has a semi-official ILP32
5401 variant for which the normal FDE address size rules apply.
5402
5403 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5404 section, where XX is the size of longs in bits. Unfortunately,
5405 earlier compilers provided no way of distinguishing ILP32 objects
5406 from LP64 objects, so if there's any doubt, we should assume that
5407 the official LP64 form is being used. */
5408 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5409 && find_section (".gcc_compiled_long32") == NULL)
5410 eh_addr_size = 8;
5411 break;
0f56a26a
DD		 5412
5413 case EM_H8_300:
5414 case EM_H8_300H:
5415 switch (elf_header.e_flags & EF_H8_MACH)
5416 {
5417 case E_H8_MACH_H8300:
5418 case E_H8_MACH_H8300HN:
5419 case E_H8_MACH_H8300SN:
5420 case E_H8_MACH_H8300SXN:
5421 eh_addr_size = 2;
5422 break;
5423 case E_H8_MACH_H8300H:
5424 case E_H8_MACH_H8300S:
5425 case E_H8_MACH_H8300SX:
5426 eh_addr_size = 4;
5427 break;
5428 }
f4236fe4
DD		 5429 break;
5430
ff7eeb89 5431 case EM_M32C_OLD:
f4236fe4
DD		 5432 case EM_M32C:
5433 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5434 {
5435 case EF_M32C_CPU_M16C:
5436 eh_addr_size = 2;
5437 break;
5438 }
5439 break;
89fac5e3
RS		 5440 }
5441
76ca31c0
NC		 5442#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5443 do \
5444 { \
5445 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5446 if (section->sh_entsize != expected_entsize) \
9dd3a467 5447 { \
76ca31c0
NC		 5448 char buf[40]; \
5449 sprintf_vma (buf, section->sh_entsize); \
5450 /* Note: coded this way so that there is a single string for \
5451 translation. */ \
5452 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5453 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5454 (unsigned) expected_entsize); \
9dd3a467 5455 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5456 } \
5457 } \
08d8fa11 5458 while (0)
9dd3a467
NC		 5459
5460#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5461 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5462 sizeof (Elf64_External_##type))
5463
252b5132
RH		 5464 for (i = 0, section = section_headers;
5465 i < elf_header.e_shnum;
b34976b6 5466 i++, section++)
252b5132 5467 {
2cf0635d 5468 char * name = SECTION_NAME (section);
252b5132
RH		 5469
5470 if (section->sh_type == SHT_DYNSYM)
5471 {
5472 if (dynamic_symbols != NULL)
5473 {
5474 error (_("File contains multiple dynamic symbol tables\n"));
5475 continue;
5476 }
5477
08d8fa11 5478 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5479 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5480 }
5481 else if (section->sh_type == SHT_STRTAB
18bd398b 5482 && streq (name, ".dynstr"))
252b5132
RH		 5483 {
5484 if (dynamic_strings != NULL)
5485 {
5486 error (_("File contains multiple dynamic string tables\n"));
5487 continue;
5488 }
5489
3f5e193b
NC		 5490 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5491 1, section->sh_size,
5492 _("dynamic strings"));
59245841 5493 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5494 }
9ad5cbcf
AM		 5495 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5496 {
5497 if (symtab_shndx_hdr != NULL)
5498 {
5499 error (_("File contains multiple symtab shndx tables\n"));
5500 continue;
5501 }
5502 symtab_shndx_hdr = section;
5503 }
08d8fa11
JJ		 5504 else if (section->sh_type == SHT_SYMTAB)
5505 CHECK_ENTSIZE (section, i, Sym);
5506 else if (section->sh_type == SHT_GROUP)
5507 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5508 else if (section->sh_type == SHT_REL)
5509 CHECK_ENTSIZE (section, i, Rel);
5510 else if (section->sh_type == SHT_RELA)
5511 CHECK_ENTSIZE (section, i, Rela);
252b5132 5512 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5513 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5514 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5515 || do_debug_str || do_debug_loc || do_debug_ranges
5516 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5517 && (const_strneq (name, ".debug_")
5518 || const_strneq (name, ".zdebug_")))
252b5132 5519 {
1b315056
CS		 5520 if (name[1] == 'z')
5521 name += sizeof (".zdebug_") - 1;
5522 else
5523 name += sizeof (".debug_") - 1;
252b5132
RH		 5524
5525 if (do_debugging
4723351a
CC		 5526 || (do_debug_info && const_strneq (name, "info"))
5527 || (do_debug_info && const_strneq (name, "types"))
5528 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5529 || (do_debug_lines && strcmp (name, "line") == 0)
5530 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5531 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5532 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5533 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5534 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5535 || (do_debug_aranges && const_strneq (name, "aranges"))
5536 || (do_debug_ranges && const_strneq (name, "ranges"))
5537 || (do_debug_frames && const_strneq (name, "frame"))
5538 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5539 || (do_debug_macinfo && const_strneq (name, "macro"))
5540 || (do_debug_str && const_strneq (name, "str"))
5541 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5542 || (do_debug_addr && const_strneq (name, "addr"))
5543 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5544 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5545 )
09c11c86 5546 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5547 }
a262ae96 5548 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5549 else if ((do_debugging || do_debug_info)
0112cd26 5550 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5551 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5552 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5553 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5554 else if (do_gdb_index && streq (name, ".gdb_index"))
5555 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5556 /* Trace sections for Itanium VMS. */
5557 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5558 || do_trace_aranges)
5559 && const_strneq (name, ".trace_"))
5560 {
5561 name += sizeof (".trace_") - 1;
5562
5563 if (do_debugging
5564 || (do_trace_info && streq (name, "info"))
5565 || (do_trace_abbrevs && streq (name, "abbrev"))
5566 || (do_trace_aranges && streq (name, "aranges"))
5567 )
5568 request_dump_bynumber (i, DEBUG_DUMP);
5569 }
252b5132
RH		 5570 }
5571
5572 if (! do_sections)
5573 return 1;
5574
3a1a2036
NC		 5575 if (elf_header.e_shnum > 1)
5576 printf (_("\nSection Headers:\n"));
5577 else
5578 printf (_("\nSection Header:\n"));
76da6bbe 5579
f7a99963 5580 if (is_32bit_elf)
595cf52e 5581 {
5477e8a0 5582 if (do_section_details)
595cf52e
L		 5583 {
5584 printf (_(" [Nr] Name\n"));
5477e8a0 5585 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5586 }
5587 else
5588 printf
5589 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5590 }
d974e256 5591 else if (do_wide)
595cf52e 5592 {
5477e8a0 5593 if (do_section_details)
595cf52e
L		 5594 {
5595 printf (_(" [Nr] Name\n"));
5477e8a0 5596 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5597 }
5598 else
5599 printf
5600 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5601 }
f7a99963
NC		 5602 else
5603 {
5477e8a0 5604 if (do_section_details)
595cf52e
L		 5605 {
5606 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5607 printf (_(" Type Address Offset Link\n"));
5608 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5609 }
5610 else
5611 {
5612 printf (_(" [Nr] Name Type Address Offset\n"));
5613 printf (_(" Size EntSize Flags Link Info Align\n"));
5614 }
f7a99963 5615 }
252b5132 5616
5477e8a0
L		 5617 if (do_section_details)
5618 printf (_(" Flags\n"));
5619
252b5132
RH		 5620 for (i = 0, section = section_headers;
5621 i < elf_header.e_shnum;
b34976b6 5622 i++, section++)
252b5132 5623 {
7bfd842d 5624 printf (" [%2u] ", i);
5477e8a0 5625 if (do_section_details)
74e1a04b 5626 printf ("%s\n ", printable_section_name (section));
595cf52e 5627 else
74e1a04b 5628 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5629
ea52a088
NC		 5630 printf (do_wide ? " %-15s " : " %-15.15s ",
5631 get_section_type_name (section->sh_type));
0b4362b0 5632
f7a99963
NC		 5633 if (is_32bit_elf)
5634 {
cfcac11d
NC		 5635 const char * link_too_big = NULL;
5636
f7a99963 5637 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5638
f7a99963
NC		 5639 printf ( " %6.6lx %6.6lx %2.2lx",
5640 (unsigned long) section->sh_offset,
5641 (unsigned long) section->sh_size,
5642 (unsigned long) section->sh_entsize);
d1133906 5643
5477e8a0
L		 5644 if (do_section_details)
5645 fputs (" ", stdout);
5646 else
5647 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5648
cfcac11d
NC		 5649 if (section->sh_link >= elf_header.e_shnum)
5650 {
5651 link_too_big = "";
5652 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5653 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5654 switch (elf_header.e_machine)
5655 {
caa83f8b
NC		 5656 case EM_386:
5657 case EM_486:
5658 case EM_X86_64:
7f502d6c 5659 case EM_L1OM:
7a9068fe 5660 case EM_K1OM:
cfcac11d
NC		 5661 case EM_OLD_SPARCV9:
5662 case EM_SPARC32PLUS:
5663 case EM_SPARCV9:
5664 case EM_SPARC:
5665 if (section->sh_link == (SHN_BEFORE & 0xffff))
5666 link_too_big = "BEFORE";
5667 else if (section->sh_link == (SHN_AFTER & 0xffff))
5668 link_too_big = "AFTER";
5669 break;
5670 default:
5671 break;
5672 }
5673 }
5674
5675 if (do_section_details)
5676 {
5677 if (link_too_big != NULL && * link_too_big)
5678 printf ("<%s> ", link_too_big);
5679 else
5680 printf ("%2u ", section->sh_link);
5681 printf ("%3u %2lu\n", section->sh_info,
5682 (unsigned long) section->sh_addralign);
5683 }
5684 else
5685 printf ("%2u %3u %2lu\n",
5686 section->sh_link,
5687 section->sh_info,
5688 (unsigned long) section->sh_addralign);
5689
5690 if (link_too_big && ! * link_too_big)
5691 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5692 i, section->sh_link);
f7a99963 5693 }
d974e256
JJ		 5694 else if (do_wide)
5695 {
5696 print_vma (section->sh_addr, LONG_HEX);
5697
5698 if ((long) section->sh_offset == section->sh_offset)
5699 printf (" %6.6lx", (unsigned long) section->sh_offset);
5700 else
5701 {
5702 putchar (' ');
5703 print_vma (section->sh_offset, LONG_HEX);
5704 }
5705
5706 if ((unsigned long) section->sh_size == section->sh_size)
5707 printf (" %6.6lx", (unsigned long) section->sh_size);
5708 else
5709 {
5710 putchar (' ');
5711 print_vma (section->sh_size, LONG_HEX);
5712 }
5713
5714 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5715 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5716 else
5717 {
5718 putchar (' ');
5719 print_vma (section->sh_entsize, LONG_HEX);
5720 }
5721
5477e8a0
L		 5722 if (do_section_details)
5723 fputs (" ", stdout);
5724 else
5725 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5726
72de5009 5727 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5728
5729 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5730 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5731 else
5732 {
5733 print_vma (section->sh_addralign, DEC);
5734 putchar ('\n');
5735 }
5736 }
5477e8a0 5737 else if (do_section_details)
595cf52e 5738 {
5477e8a0 5739 printf (" %-15.15s ",
595cf52e 5740 get_section_type_name (section->sh_type));
595cf52e
L		 5741 print_vma (section->sh_addr, LONG_HEX);
5742 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5743 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5744 else
5745 {
5746 printf (" ");
5747 print_vma (section->sh_offset, LONG_HEX);
5748 }
72de5009 5749 printf (" %u\n ", section->sh_link);
595cf52e 5750 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5751 putchar (' ');
595cf52e
L		 5752 print_vma (section->sh_entsize, LONG_HEX);
5753
72de5009
AM		 5754 printf (" %-16u %lu\n",
5755 section->sh_info,
595cf52e
L		 5756 (unsigned long) section->sh_addralign);
5757 }
f7a99963
NC		 5758 else
5759 {
5760 putchar (' ');
5761 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5762 if ((long) section->sh_offset == section->sh_offset)
5763 printf (" %8.8lx", (unsigned long) section->sh_offset);
5764 else
5765 {
5766 printf (" ");
5767 print_vma (section->sh_offset, LONG_HEX);
5768 }
f7a99963
NC		 5769 printf ("\n ");
5770 print_vma (section->sh_size, LONG_HEX);
5771 printf (" ");
5772 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5773
d1133906 5774 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5775
72de5009
AM		 5776 printf (" %2u %3u %lu\n",
5777 section->sh_link,
5778 section->sh_info,
f7a99963
NC		 5779 (unsigned long) section->sh_addralign);
5780 }
5477e8a0
L		 5781
5782 if (do_section_details)
5783 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5784 }
5785
5477e8a0 5786 if (!do_section_details)
3dbcc61d
NC		 5787 {
5788 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5789 || elf_header.e_machine == EM_L1OM
5790 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5791 printf (_("Key to Flags:\n\
5792 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5793 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5794 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5795 else
5796 printf (_("Key to Flags:\n\
e3c8793a 5797 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5798 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5799 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5800 }
d1133906 5801
252b5132
RH		 5802 return 1;
5803}
5804
f5842774
L		 5805static const char *
5806get_group_flags (unsigned int flags)
5807{
5808 static char buff[32];
5809 switch (flags)
5810 {
220453ec
AM		 5811 case 0:
5812 return "";
5813
f5842774 5814 case GRP_COMDAT:
220453ec 5815 return "COMDAT ";
f5842774
L		 5816
5817 default:
220453ec 5818 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5819 break;
5820 }
5821 return buff;
5822}
5823
5824static int
2cf0635d 5825process_section_groups (FILE * file)
f5842774 5826{
2cf0635d 5827 Elf_Internal_Shdr * section;
f5842774 5828 unsigned int i;
2cf0635d
NC		 5829 struct group * group;
5830 Elf_Internal_Shdr * symtab_sec;
5831 Elf_Internal_Shdr * strtab_sec;
5832 Elf_Internal_Sym * symtab;
ba5cdace 5833 unsigned long num_syms;
2cf0635d 5834 char * strtab;
c256ffe7 5835 size_t strtab_size;
d1f5c6e3
L		 5836
5837 /* Don't process section groups unless needed. */
5838 if (!do_unwind && !do_section_groups)
5839 return 1;
f5842774
L		 5840
5841 if (elf_header.e_shnum == 0)
5842 {
5843 if (do_section_groups)
82f2dbf7 5844 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5845
5846 return 1;
5847 }
5848
5849 if (section_headers == NULL)
5850 {
5851 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5852 /* PR 13622: This can happen with a corrupt ELF header. */
5853 return 0;
f5842774
L		 5854 }
5855
3f5e193b
NC		 5856 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5857 sizeof (struct group *));
e4b17d5c
L		 5858
5859 if (section_headers_groups == NULL)
5860 {
8b73c356
NC		 5861 error (_("Out of memory reading %u section group headers\n"),
5862 elf_header.e_shnum);
e4b17d5c
L		 5863 return 0;
5864 }
5865
f5842774 5866 /* Scan the sections for the group section. */
d1f5c6e3 5867 group_count = 0;
f5842774
L		 5868 for (i = 0, section = section_headers;
5869 i < elf_header.e_shnum;
5870 i++, section++)
e4b17d5c
L		 5871 if (section->sh_type == SHT_GROUP)
5872 group_count++;
5873
d1f5c6e3
L		 5874 if (group_count == 0)
5875 {
5876 if (do_section_groups)
5877 printf (_("\nThere are no section groups in this file.\n"));
5878
5879 return 1;
5880 }
5881
3f5e193b 5882 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5883
5884 if (section_groups == NULL)
5885 {
8b73c356
NC		 5886 error (_("Out of memory reading %lu groups\n"),
5887 (unsigned long) group_count);
e4b17d5c
L		 5888 return 0;
5889 }
5890
d1f5c6e3
L		 5891 symtab_sec = NULL;
5892 strtab_sec = NULL;
5893 symtab = NULL;
ba5cdace 5894 num_syms = 0;
d1f5c6e3 5895 strtab = NULL;
c256ffe7 5896 strtab_size = 0;
e4b17d5c
L		 5897 for (i = 0, section = section_headers, group = section_groups;
5898 i < elf_header.e_shnum;
5899 i++, section++)
f5842774
L		 5900 {
5901 if (section->sh_type == SHT_GROUP)
5902 {
74e1a04b
NC		 5903 const char * name = printable_section_name (section);
5904 const char * group_name;
2cf0635d
NC		 5905 unsigned char * start;
5906 unsigned char * indices;
f5842774 5907 unsigned int entry, j, size;
2cf0635d
NC		 5908 Elf_Internal_Shdr * sec;
5909 Elf_Internal_Sym * sym;
f5842774
L		 5910
5911 /* Get the symbol table. */
4fbb74a6
AM		 5912 if (section->sh_link >= elf_header.e_shnum
5913 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5914 != SHT_SYMTAB))
f5842774
L		 5915 {
5916 error (_("Bad sh_link in group section `%s'\n"), name);
5917 continue;
5918 }
d1f5c6e3
L		 5919
5920 if (symtab_sec != sec)
5921 {
5922 symtab_sec = sec;
5923 if (symtab)
5924 free (symtab);
ba5cdace 5925 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5926 }
f5842774 5927
dd24e3da
NC		 5928 if (symtab == NULL)
5929 {
5930 error (_("Corrupt header in group section `%s'\n"), name);
5931 continue;
5932 }
5933
ba5cdace
NC		 5934 if (section->sh_info >= num_syms)
5935 {
5936 error (_("Bad sh_info in group section `%s'\n"), name);
5937 continue;
5938 }
5939
f5842774
L		 5940 sym = symtab + section->sh_info;
5941
5942 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5943 {
4fbb74a6
AM		 5944 if (sym->st_shndx == 0
5945 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5946 {
5947 error (_("Bad sh_info in group section `%s'\n"), name);
5948 continue;
5949 }
ba2685cc 5950
4fbb74a6 5951 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5952 strtab_sec = NULL;
5953 if (strtab)
5954 free (strtab);
f5842774 5955 strtab = NULL;
c256ffe7 5956 strtab_size = 0;
f5842774
L		 5957 }
5958 else
5959 {
5960 /* Get the string table. */
4fbb74a6 5961 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5962 {
5963 strtab_sec = NULL;
5964 if (strtab)
5965 free (strtab);
5966 strtab = NULL;
5967 strtab_size = 0;
5968 }
5969 else if (strtab_sec
4fbb74a6 5970 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5971 {
5972 strtab_sec = sec;
5973 if (strtab)
5974 free (strtab);
071436c6 5975
3f5e193b 5976 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 5977 1, strtab_sec->sh_size,
5978 _("string table"));
c256ffe7 5979 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5980 }
c256ffe7 5981 group_name = sym->st_name < strtab_size
2b692964 5982 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5983 }
5984
c9c1d674
EG		 5985 /* PR 17531: file: loop. */
5986 if (section->sh_entsize > section->sh_size)
5987 {
5988 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5989 printable_section_name (section),
8066deb1
AM		 5990 (unsigned long) section->sh_entsize,
5991 (unsigned long) section->sh_size);
c9c1d674
EG		 5992 break;
5993 }
5994
3f5e193b
NC		 5995 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5996 1, section->sh_size,
5997 _("section data"));
59245841
NC		 5998 if (start == NULL)
5999 continue;
f5842774
L		 6000
6001 indices = start;
6002 size = (section->sh_size / section->sh_entsize) - 1;
6003 entry = byte_get (indices, 4);
6004 indices += 4;
e4b17d5c
L		 6005
6006 if (do_section_groups)
6007 {
2b692964 6008 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6009 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6010
e4b17d5c
L		 6011 printf (_(" [Index] Name\n"));
6012 }
6013
6014 group->group_index = i;
6015
f5842774
L		 6016 for (j = 0; j < size; j++)
6017 {
2cf0635d 6018 struct group_list * g;
e4b17d5c 6019
f5842774
L		 6020 entry = byte_get (indices, 4);
6021 indices += 4;
6022
4fbb74a6 6023 if (entry >= elf_header.e_shnum)
391cb864 6024 {
57028622
NC		 6025 static unsigned num_group_errors = 0;
6026
6027 if (num_group_errors ++ < 10)
6028 {
6029 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6030 entry, i, elf_header.e_shnum - 1);
6031 if (num_group_errors == 10)
6032 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6033 }
391cb864
L		 6034 continue;
6035 }
391cb864 6036
4fbb74a6 6037 if (section_headers_groups [entry] != NULL)
e4b17d5c 6038 {
d1f5c6e3
L		 6039 if (entry)
6040 {
57028622
NC		 6041 static unsigned num_errs = 0;
6042
6043 if (num_errs ++ < 10)
6044 {
6045 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6046 entry, i,
6047 section_headers_groups [entry]->group_index);
6048 if (num_errs == 10)
6049 warn (_("Further error messages about already contained group sections suppressed\n"));
6050 }
d1f5c6e3
L		 6051 continue;
6052 }
6053 else
6054 {
6055 /* Intel C/C++ compiler may put section 0 in a
6056 section group. We just warn it the first time
6057 and ignore it afterwards. */
6058 static int warned = 0;
6059 if (!warned)
6060 {
6061 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6062 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6063 warned++;
6064 }
6065 }
e4b17d5c
L		 6066 }
6067
4fbb74a6 6068 section_headers_groups [entry] = group;
e4b17d5c
L		 6069
6070 if (do_section_groups)
6071 {
4fbb74a6 6072 sec = section_headers + entry;
74e1a04b 6073 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6074 }
6075
3f5e193b 6076 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6077 g->section_index = entry;
6078 g->next = group->root;
6079 group->root = g;
f5842774
L		 6080 }
6081
f5842774
L		 6082 if (start)
6083 free (start);
e4b17d5c
L		 6084
6085 group++;
f5842774
L		 6086 }
6087 }
6088
d1f5c6e3
L		 6089 if (symtab)
6090 free (symtab);
6091 if (strtab)
6092 free (strtab);
f5842774
L		 6093 return 1;
6094}
6095
28f997cf
TG		 6096/* Data used to display dynamic fixups. */
6097
6098struct ia64_vms_dynfixup
6099{
6100 bfd_vma needed_ident; /* Library ident number. */
6101 bfd_vma needed; /* Index in the dstrtab of the library name. */
6102 bfd_vma fixup_needed; /* Index of the library. */
6103 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6104 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6105};
6106
6107/* Data used to display dynamic relocations. */
6108
6109struct ia64_vms_dynimgrela
6110{
6111 bfd_vma img_rela_cnt; /* Number of relocations. */
6112 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6113};
6114
6115/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6116 library). */
6117
6118static void
6119dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6120 const char *strtab, unsigned int strtab_sz)
6121{
6122 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6123 long i;
6124 const char *lib_name;
6125
6126 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6127 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6128 _("dynamic section image fixups"));
6129 if (!imfs)
6130 return;
6131
6132 if (fixup->needed < strtab_sz)
6133 lib_name = strtab + fixup->needed;
6134 else
6135 {
6136 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6137 (unsigned long) fixup->needed);
28f997cf
TG		 6138 lib_name = "???";
6139 }
6140 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6141 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6142 printf
6143 (_("Seg Offset Type SymVec DataType\n"));
6144
6145 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6146 {
6147 unsigned int type;
6148 const char *rtype;
6149
6150 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6151 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6152 type = BYTE_GET (imfs [i].type);
6153 rtype = elf_ia64_reloc_type (type);
6154 if (rtype == NULL)
6155 printf (" 0x%08x ", type);
6156 else
6157 printf (" %-32s ", rtype);
6158 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6159 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6160 }
6161
6162 free (imfs);
6163}
6164
6165/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6166
6167static void
6168dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6169{
6170 Elf64_External_VMS_IMAGE_RELA *imrs;
6171 long i;
6172
6173 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6174 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6175 _("dynamic section image relocations"));
28f997cf
TG		 6176 if (!imrs)
6177 return;
6178
6179 printf (_("\nImage relocs\n"));
6180 printf
6181 (_("Seg Offset Type Addend Seg Sym Off\n"));
6182
6183 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6184 {
6185 unsigned int type;
6186 const char *rtype;
6187
6188 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6189 printf ("%08" BFD_VMA_FMT "x ",
6190 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6191 type = BYTE_GET (imrs [i].type);
6192 rtype = elf_ia64_reloc_type (type);
6193 if (rtype == NULL)
6194 printf ("0x%08x ", type);
6195 else
6196 printf ("%-31s ", rtype);
6197 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6198 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6199 printf ("%08" BFD_VMA_FMT "x\n",
6200 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6201 }
6202
6203 free (imrs);
6204}
6205
6206/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6207
6208static int
6209process_ia64_vms_dynamic_relocs (FILE *file)
6210{
6211 struct ia64_vms_dynfixup fixup;
6212 struct ia64_vms_dynimgrela imgrela;
6213 Elf_Internal_Dyn *entry;
6214 int res = 0;
6215 bfd_vma strtab_off = 0;
6216 bfd_vma strtab_sz = 0;
6217 char *strtab = NULL;
6218
6219 memset (&fixup, 0, sizeof (fixup));
6220 memset (&imgrela, 0, sizeof (imgrela));
6221
6222 /* Note: the order of the entries is specified by the OpenVMS specs. */
6223 for (entry = dynamic_section;
6224 entry < dynamic_section + dynamic_nent;
6225 entry++)
6226 {
6227 switch (entry->d_tag)
6228 {
6229 case DT_IA_64_VMS_STRTAB_OFFSET:
6230 strtab_off = entry->d_un.d_val;
6231 break;
6232 case DT_STRSZ:
6233 strtab_sz = entry->d_un.d_val;
6234 if (strtab == NULL)
6235 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6236 1, strtab_sz, _("dynamic string section"));
6237 break;
6238
6239 case DT_IA_64_VMS_NEEDED_IDENT:
6240 fixup.needed_ident = entry->d_un.d_val;
6241 break;
6242 case DT_NEEDED:
6243 fixup.needed = entry->d_un.d_val;
6244 break;
6245 case DT_IA_64_VMS_FIXUP_NEEDED:
6246 fixup.fixup_needed = entry->d_un.d_val;
6247 break;
6248 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6249 fixup.fixup_rela_cnt = entry->d_un.d_val;
6250 break;
6251 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6252 fixup.fixup_rela_off = entry->d_un.d_val;
6253 res++;
6254 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6255 break;
6256
6257 case DT_IA_64_VMS_IMG_RELA_CNT:
6258 imgrela.img_rela_cnt = entry->d_un.d_val;
6259 break;
6260 case DT_IA_64_VMS_IMG_RELA_OFF:
6261 imgrela.img_rela_off = entry->d_un.d_val;
6262 res++;
6263 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6264 break;
6265
6266 default:
6267 break;
6268 }
6269 }
6270
6271 if (strtab != NULL)
6272 free (strtab);
6273
6274 return res;
6275}
6276
85b1c36d 6277static struct
566b0d53 6278{
2cf0635d 6279 const char * name;
566b0d53
L		 6280 int reloc;
6281 int size;
6282 int rela;
6283} dynamic_relocations [] =
6284{
6285 { "REL", DT_REL, DT_RELSZ, FALSE },
6286 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6287 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6288};
6289
252b5132 6290/* Process the reloc section. */
18bd398b 6291
252b5132 6292static int
2cf0635d 6293process_relocs (FILE * file)
252b5132 6294{
b34976b6
AM		 6295 unsigned long rel_size;
6296 unsigned long rel_offset;
252b5132
RH		 6297
6298
6299 if (!do_reloc)
6300 return 1;
6301
6302 if (do_using_dynamic)
6303 {
566b0d53 6304 int is_rela;
2cf0635d 6305 const char * name;
566b0d53
L		 6306 int has_dynamic_reloc;
6307 unsigned int i;
0de14b54 6308
566b0d53 6309 has_dynamic_reloc = 0;
252b5132 6310
566b0d53 6311 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6312 {
566b0d53
L		 6313 is_rela = dynamic_relocations [i].rela;
6314 name = dynamic_relocations [i].name;
6315 rel_size = dynamic_info [dynamic_relocations [i].size];
6316 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6317
566b0d53
L		 6318 has_dynamic_reloc |= rel_size;
6319
6320 if (is_rela == UNKNOWN)
aa903cfb 6321 {
566b0d53
L		 6322 if (dynamic_relocations [i].reloc == DT_JMPREL)
6323 switch (dynamic_info[DT_PLTREL])
6324 {
6325 case DT_REL:
6326 is_rela = FALSE;
6327 break;
6328 case DT_RELA:
6329 is_rela = TRUE;
6330 break;
6331 }
aa903cfb 6332 }
252b5132 6333
566b0d53
L		 6334 if (rel_size)
6335 {
6336 printf
6337 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6338 name, rel_offset, rel_size);
252b5132 6339
d93f0186
NC		 6340 dump_relocations (file,
6341 offset_from_vma (file, rel_offset, rel_size),
6342 rel_size,
566b0d53 6343 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6344 dynamic_strings, dynamic_strings_length,
6345 is_rela, 1);
566b0d53 6346 }
252b5132 6347 }
566b0d53 6348
28f997cf
TG		 6349 if (is_ia64_vms ())
6350 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6351
566b0d53 6352 if (! has_dynamic_reloc)
252b5132
RH		 6353 printf (_("\nThere are no dynamic relocations in this file.\n"));
6354 }
6355 else
6356 {
2cf0635d 6357 Elf_Internal_Shdr * section;
b34976b6
AM		 6358 unsigned long i;
6359 int found = 0;
252b5132
RH		 6360
6361 for (i = 0, section = section_headers;
6362 i < elf_header.e_shnum;
b34976b6 6363 i++, section++)
252b5132
RH		 6364 {
6365 if ( section->sh_type != SHT_RELA
6366 && section->sh_type != SHT_REL)
6367 continue;
6368
6369 rel_offset = section->sh_offset;
6370 rel_size = section->sh_size;
6371
6372 if (rel_size)
6373 {
2cf0635d 6374 Elf_Internal_Shdr * strsec;
b34976b6 6375 int is_rela;
103f02d3 6376
252b5132
RH		 6377 printf (_("\nRelocation section "));
6378
6379 if (string_table == NULL)
19936277 6380 printf ("%d", section->sh_name);
252b5132 6381 else
74e1a04b 6382 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6383
6384 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6385 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6386
d79b3d50
NC		 6387 is_rela = section->sh_type == SHT_RELA;
6388
4fbb74a6
AM		 6389 if (section->sh_link != 0
6390 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6391 {
2cf0635d
NC		 6392 Elf_Internal_Shdr * symsec;
6393 Elf_Internal_Sym * symtab;
d79b3d50 6394 unsigned long nsyms;
c256ffe7 6395 unsigned long strtablen = 0;
2cf0635d 6396 char * strtab = NULL;
57346661 6397
4fbb74a6 6398 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6399 if (symsec->sh_type != SHT_SYMTAB
6400 && symsec->sh_type != SHT_DYNSYM)
6401 continue;
6402
ba5cdace 6403 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6404
af3fc3bc
AM		 6405 if (symtab == NULL)
6406 continue;
252b5132 6407
4fbb74a6
AM		 6408 if (symsec->sh_link != 0
6409 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6410 {
4fbb74a6 6411 strsec = section_headers + symsec->sh_link;
103f02d3 6412
3f5e193b 6413 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6414 1, strsec->sh_size,
6415 _("string table"));
c256ffe7
JJ		 6416 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6417 }
252b5132 6418
d79b3d50 6419 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6420 symtab, nsyms, strtab, strtablen,
6421 is_rela,
6422 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6423 if (strtab)
6424 free (strtab);
6425 free (symtab);
6426 }
6427 else
6428 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6429 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6430
6431 found = 1;
6432 }
6433 }
6434
6435 if (! found)
6436 printf (_("\nThere are no relocations in this file.\n"));
6437 }
6438
6439 return 1;
6440}
6441
57346661
AM		 6442/* Process the unwind section. */
6443
4d6ed7c8
NC		 6444#include "unwind-ia64.h"
6445
6446/* An absolute address consists of a section and an offset. If the
6447 section is NULL, the offset itself is the address, otherwise, the
6448 address equals to LOAD_ADDRESS(section) + offset. */
6449
6450struct absaddr
6451 {
6452 unsigned short section;
6453 bfd_vma offset;
6454 };
6455
1949de15
L		 6456#define ABSADDR(a) \
6457 ((a).section \
6458 ? section_headers [(a).section].sh_addr + (a).offset \
6459 : (a).offset)
6460
3f5e193b
NC		 6461struct ia64_unw_table_entry
6462 {
6463 struct absaddr start;
6464 struct absaddr end;
6465 struct absaddr info;
6466 };
6467
57346661 6468struct ia64_unw_aux_info
4d6ed7c8 6469 {
3f5e193b
NC		 6470
6471 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 6472 unsigned long table_len; /* Length of unwind table. */
2cf0635d 6473 unsigned char * info; /* Unwind info. */
b34976b6
AM		 6474 unsigned long info_size; /* Size of unwind info. */
6475 bfd_vma info_addr; /* starting address of unwind info. */
6476 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6477 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 6478 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6479 char * strtab; /* The string table. */
b34976b6 6480 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 6481 };
6482
4d6ed7c8 6483static void
2cf0635d 6484find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 6485 unsigned long nsyms,
2cf0635d 6486 const char * strtab,
57346661 6487 unsigned long strtab_size,
d3ba0551 6488 struct absaddr addr,
2cf0635d
NC		 6489 const char ** symname,
6490 bfd_vma * offset)
4d6ed7c8 6491{
d3ba0551 6492 bfd_vma dist = 0x100000;
2cf0635d
NC		 6493 Elf_Internal_Sym * sym;
6494 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 6495 unsigned long i;
6496
0b6ae522
DJ		 6497 REMOVE_ARCH_BITS (addr.offset);
6498
57346661 6499 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 6500 {
0b6ae522
DJ		 6501 bfd_vma value = sym->st_value;
6502
6503 REMOVE_ARCH_BITS (value);
6504
4d6ed7c8
NC		 6505 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6506 && sym->st_name != 0
6507 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6508 && addr.offset >= value
6509 && addr.offset - value < dist)
4d6ed7c8
NC		 6510 {
6511 best = sym;
0b6ae522 6512 dist = addr.offset - value;
4d6ed7c8
NC		 6513 if (!dist)
6514 break;
6515 }
6516 }
1b31d05e 6517
4d6ed7c8
NC		 6518 if (best)
6519 {
57346661 6520 *symname = (best->st_name >= strtab_size
2b692964 6521 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6522 *offset = dist;
6523 return;
6524 }
1b31d05e 6525
4d6ed7c8
NC		 6526 *symname = NULL;
6527 *offset = addr.offset;
6528}
6529
6530static void
2cf0635d 6531dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6532{
2cf0635d 6533 struct ia64_unw_table_entry * tp;
4d6ed7c8 6534 int in_body;
7036c0e1 6535
4d6ed7c8
NC		 6536 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6537 {
6538 bfd_vma stamp;
6539 bfd_vma offset;
2cf0635d
NC		 6540 const unsigned char * dp;
6541 const unsigned char * head;
53774b7e 6542 const unsigned char * end;
2cf0635d 6543 const char * procname;
4d6ed7c8 6544
57346661
AM		 6545 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6546 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6547
6548 fputs ("\n<", stdout);
6549
6550 if (procname)
6551 {
6552 fputs (procname, stdout);
6553
6554 if (offset)
6555 printf ("+%lx", (unsigned long) offset);
6556 }
6557
6558 fputs (">: [", stdout);
6559 print_vma (tp->start.offset, PREFIX_HEX);
6560 fputc ('-', stdout);
6561 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6562 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6563 (unsigned long) (tp->info.offset - aux->seg_base));
6564
53774b7e
NC		 6565 /* PR 17531: file: 86232b32. */
6566 if (aux->info == NULL)
6567 continue;
6568
6569 /* PR 17531: file: 0997b4d1. */
6570 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6571 {
6572 warn (_("Invalid offset %lx in table entry %ld\n"),
6573 (long) tp->info.offset, (long) (tp - aux->table));
6574 continue;
6575 }
6576
1949de15 6577 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6578 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6579
86f55779 6580 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6581 (unsigned) UNW_VER (stamp),
6582 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6583 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6584 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6585 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6586
6587 if (UNW_VER (stamp) != 1)
6588 {
2b692964 6589 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6590 continue;
6591 }
6592
6593 in_body = 0;
53774b7e
NC		 6594 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6595 /* PR 17531: file: 16ceda89. */
6596 if (end > aux->info + aux->info_size)
6597 end = aux->info + aux->info_size;
6598 for (dp = head + 8; dp < end;)
4d6ed7c8
NC		 6599 dp = unw_decode (dp, in_body, & in_body);
6600 }
6601}
6602
53774b7e 6603static bfd_boolean
2cf0635d
NC		 6604slurp_ia64_unwind_table (FILE * file,
6605 struct ia64_unw_aux_info * aux,
6606 Elf_Internal_Shdr * sec)
4d6ed7c8 6607{
89fac5e3 6608 unsigned long size, nrelas, i;
2cf0635d
NC		 6609 Elf_Internal_Phdr * seg;
6610 struct ia64_unw_table_entry * tep;
6611 Elf_Internal_Shdr * relsec;
6612 Elf_Internal_Rela * rela;
6613 Elf_Internal_Rela * rp;
6614 unsigned char * table;
6615 unsigned char * tp;
6616 Elf_Internal_Sym * sym;
6617 const char * relname;
4d6ed7c8 6618
53774b7e
NC		 6619 aux->table_len = 0;
6620
4d6ed7c8
NC		 6621 /* First, find the starting address of the segment that includes
6622 this section: */
6623
6624 if (elf_header.e_phnum)
6625 {
d93f0186 6626 if (! get_program_headers (file))
53774b7e 6627 return FALSE;
4d6ed7c8 6628
d93f0186
NC		 6629 for (seg = program_headers;
6630 seg < program_headers + elf_header.e_phnum;
6631 ++seg)
4d6ed7c8
NC		 6632 {
6633 if (seg->p_type != PT_LOAD)
6634 continue;
6635
6636 if (sec->sh_addr >= seg->p_vaddr
6637 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6638 {
6639 aux->seg_base = seg->p_vaddr;
6640 break;
6641 }
6642 }
4d6ed7c8
NC		 6643 }
6644
6645 /* Second, build the unwind table from the contents of the unwind section: */
6646 size = sec->sh_size;
3f5e193b
NC		 6647 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6648 _("unwind table"));
a6e9f9df 6649 if (!table)
53774b7e 6650 return FALSE;
4d6ed7c8 6651
53774b7e 6652 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6653 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6654 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6655 tep = aux->table;
53774b7e
NC		 6656
6657 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6658 {
6659 tep->start.section = SHN_UNDEF;
6660 tep->end.section = SHN_UNDEF;
6661 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6662 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6663 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6664 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6665 tep->start.offset += aux->seg_base;
6666 tep->end.offset += aux->seg_base;
6667 tep->info.offset += aux->seg_base;
6668 }
6669 free (table);
6670
41e92641 6671 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6672 for (relsec = section_headers;
6673 relsec < section_headers + elf_header.e_shnum;
6674 ++relsec)
6675 {
6676 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6677 || relsec->sh_info >= elf_header.e_shnum
6678 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6679 continue;
6680
6681 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6682 & rela, & nrelas))
53774b7e
NC		 6683 {
6684 free (aux->table);
6685 aux->table = NULL;
6686 aux->table_len = 0;
6687 return FALSE;
6688 }
4d6ed7c8
NC		 6689
6690 for (rp = rela; rp < rela + nrelas; ++rp)
6691 {
aca88567
NC		 6692 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6693 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6694
82b1b41b
NC		 6695 /* PR 17531: file: 9fa67536. */
6696 if (relname == NULL)
6697 {
6698 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6699 continue;
6700 }
6701
0112cd26 6702 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6703 {
82b1b41b 6704 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6705 continue;
6706 }
6707
89fac5e3 6708 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6709
53774b7e
NC		 6710 /* PR 17531: file: 5bc8d9bf. */
6711 if (i >= aux->table_len)
6712 {
6713 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6714 continue;
6715 }
6716
6717 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6718 {
6719 case 0:
6720 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6721 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6722 break;
6723 case 1:
6724 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6725 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6726 break;
6727 case 2:
6728 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6729 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6730 break;
6731 default:
6732 break;
6733 }
6734 }
6735
6736 free (rela);
6737 }
6738
53774b7e 6739 return TRUE;
4d6ed7c8
NC		 6740}
6741
1b31d05e 6742static void
2cf0635d 6743ia64_process_unwind (FILE * file)
4d6ed7c8 6744{
2cf0635d
NC		 6745 Elf_Internal_Shdr * sec;
6746 Elf_Internal_Shdr * unwsec = NULL;
6747 Elf_Internal_Shdr * strsec;
89fac5e3 6748 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6749 struct ia64_unw_aux_info aux;
f1467e33 6750
4d6ed7c8
NC		 6751 memset (& aux, 0, sizeof (aux));
6752
4d6ed7c8
NC		 6753 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6754 {
c256ffe7 6755 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6756 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6757 {
ba5cdace 6758 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6759
4fbb74a6 6760 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6761 if (aux.strtab != NULL)
6762 {
6763 error (_("Multiple auxillary string tables encountered\n"));
6764 free (aux.strtab);
6765 }
3f5e193b
NC		 6766 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6767 1, strsec->sh_size,
6768 _("string table"));
c256ffe7 6769 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6770 }
6771 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6772 unwcount++;
6773 }
6774
6775 if (!unwcount)
6776 printf (_("\nThere are no unwind sections in this file.\n"));
6777
6778 while (unwcount-- > 0)
6779 {
2cf0635d 6780 char * suffix;
579f31ac
JJ		 6781 size_t len, len2;
6782
4082ef84 6783 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6784 i < elf_header.e_shnum; ++i, ++sec)
6785 if (sec->sh_type == SHT_IA_64_UNWIND)
6786 {
6787 unwsec = sec;
6788 break;
6789 }
4082ef84
NC		 6790 /* We have already counted the number of SHT_IA64_UNWIND
6791 sections so the loop above should never fail. */
6792 assert (unwsec != NULL);
579f31ac
JJ		 6793
6794 unwstart = i + 1;
6795 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6796
e4b17d5c
L		 6797 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6798 {
6799 /* We need to find which section group it is in. */
4082ef84 6800 struct group_list * g;
e4b17d5c 6801
4082ef84
NC		 6802 if (section_headers_groups == NULL
6803 || section_headers_groups [i] == NULL)
6804 i = elf_header.e_shnum;
6805 else
e4b17d5c 6806 {
4082ef84 6807 g = section_headers_groups [i]->root;
18bd398b 6808
4082ef84
NC		 6809 for (; g != NULL; g = g->next)
6810 {
6811 sec = section_headers + g->section_index;
e4b17d5c 6812
4082ef84
NC		 6813 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6814 break;
6815 }
6816
6817 if (g == NULL)
6818 i = elf_header.e_shnum;
6819 }
e4b17d5c 6820 }
18bd398b 6821 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6822 {
18bd398b 6823 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6824 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6825 suffix = SECTION_NAME (unwsec) + len;
6826 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6827 ++i, ++sec)
18bd398b
NC		 6828 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6829 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6830 break;
6831 }
6832 else
6833 {
6834 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6835 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6836 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6837 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6838 suffix = "";
18bd398b 6839 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6840 suffix = SECTION_NAME (unwsec) + len;
6841 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6842 ++i, ++sec)
18bd398b
NC		 6843 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6844 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6845 break;
6846 }
6847
6848 if (i == elf_header.e_shnum)
6849 {
6850 printf (_("\nCould not find unwind info section for "));
6851
6852 if (string_table == NULL)
6853 printf ("%d", unwsec->sh_name);
6854 else
74e1a04b 6855 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6856 }
6857 else
4d6ed7c8 6858 {
4d6ed7c8 6859 aux.info_addr = sec->sh_addr;
3f5e193b 6860 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6861 sec->sh_size,
6862 _("unwind info"));
59245841 6863 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6864
579f31ac 6865 printf (_("\nUnwind section "));
4d6ed7c8 6866
579f31ac
JJ		 6867 if (string_table == NULL)
6868 printf ("%d", unwsec->sh_name);
6869 else
74e1a04b 6870 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 6871
579f31ac 6872 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6873 (unsigned long) unwsec->sh_offset,
89fac5e3 6874 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6875
53774b7e
NC		 6876 if (slurp_ia64_unwind_table (file, & aux, unwsec)
6877 && aux.table_len > 0)
579f31ac
JJ		 6878 dump_ia64_unwind (& aux);
6879
6880 if (aux.table)
6881 free ((char *) aux.table);
6882 if (aux.info)
6883 free ((char *) aux.info);
6884 aux.table = NULL;
6885 aux.info = NULL;
6886 }
4d6ed7c8 6887 }
4d6ed7c8 6888
4d6ed7c8
NC		 6889 if (aux.symtab)
6890 free (aux.symtab);
6891 if (aux.strtab)
6892 free ((char *) aux.strtab);
4d6ed7c8
NC		 6893}
6894
3f5e193b
NC		 6895struct hppa_unw_table_entry
6896 {
6897 struct absaddr start;
6898 struct absaddr end;
6899 unsigned int Cannot_unwind:1; /* 0 */
6900 unsigned int Millicode:1; /* 1 */
6901 unsigned int Millicode_save_sr0:1; /* 2 */
6902 unsigned int Region_description:2; /* 3..4 */
6903 unsigned int reserved1:1; /* 5 */
6904 unsigned int Entry_SR:1; /* 6 */
6905 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6906 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6907 unsigned int Args_stored:1; /* 16 */
6908 unsigned int Variable_Frame:1; /* 17 */
6909 unsigned int Separate_Package_Body:1; /* 18 */
6910 unsigned int Frame_Extension_Millicode:1; /* 19 */
6911 unsigned int Stack_Overflow_Check:1; /* 20 */
6912 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6913 unsigned int Ada_Region:1; /* 22 */
6914 unsigned int cxx_info:1; /* 23 */
6915 unsigned int cxx_try_catch:1; /* 24 */
6916 unsigned int sched_entry_seq:1; /* 25 */
6917 unsigned int reserved2:1; /* 26 */
6918 unsigned int Save_SP:1; /* 27 */
6919 unsigned int Save_RP:1; /* 28 */
6920 unsigned int Save_MRP_in_frame:1; /* 29 */
6921 unsigned int extn_ptr_defined:1; /* 30 */
6922 unsigned int Cleanup_defined:1; /* 31 */
6923
6924 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6925 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6926 unsigned int Large_frame:1; /* 2 */
6927 unsigned int Pseudo_SP_Set:1; /* 3 */
6928 unsigned int reserved4:1; /* 4 */
6929 unsigned int Total_frame_size:27; /* 5..31 */
6930 };
6931
57346661
AM		 6932struct hppa_unw_aux_info
6933 {
3f5e193b 6934 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6935 unsigned long table_len; /* Length of unwind table. */
6936 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6937 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6938 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6939 char * strtab; /* The string table. */
57346661
AM		 6940 unsigned long strtab_size; /* Size of string table. */
6941 };
6942
6943static void
2cf0635d 6944dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6945{
2cf0635d 6946 struct hppa_unw_table_entry * tp;
57346661 6947
57346661
AM		 6948 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6949 {
6950 bfd_vma offset;
2cf0635d 6951 const char * procname;
57346661
AM		 6952
6953 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6954 aux->strtab_size, tp->start, &procname,
6955 &offset);
6956
6957 fputs ("\n<", stdout);
6958
6959 if (procname)
6960 {
6961 fputs (procname, stdout);
6962
6963 if (offset)
6964 printf ("+%lx", (unsigned long) offset);
6965 }
6966
6967 fputs (">: [", stdout);
6968 print_vma (tp->start.offset, PREFIX_HEX);
6969 fputc ('-', stdout);
6970 print_vma (tp->end.offset, PREFIX_HEX);
6971 printf ("]\n\t");
6972
18bd398b
NC		 6973#define PF(_m) if (tp->_m) printf (#_m " ");
6974#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6975 PF(Cannot_unwind);
6976 PF(Millicode);
6977 PF(Millicode_save_sr0);
18bd398b 6978 /* PV(Region_description); */
57346661
AM		 6979 PF(Entry_SR);
6980 PV(Entry_FR);
6981 PV(Entry_GR);
6982 PF(Args_stored);
6983 PF(Variable_Frame);
6984 PF(Separate_Package_Body);
6985 PF(Frame_Extension_Millicode);
6986 PF(Stack_Overflow_Check);
6987 PF(Two_Instruction_SP_Increment);
6988 PF(Ada_Region);
6989 PF(cxx_info);
6990 PF(cxx_try_catch);
6991 PF(sched_entry_seq);
6992 PF(Save_SP);
6993 PF(Save_RP);
6994 PF(Save_MRP_in_frame);
6995 PF(extn_ptr_defined);
6996 PF(Cleanup_defined);
6997 PF(MPE_XL_interrupt_marker);
6998 PF(HP_UX_interrupt_marker);
6999 PF(Large_frame);
7000 PF(Pseudo_SP_Set);
7001 PV(Total_frame_size);
7002#undef PF
7003#undef PV
7004 }
7005
18bd398b 7006 printf ("\n");
57346661
AM		 7007}
7008
7009static int
2cf0635d
NC		 7010slurp_hppa_unwind_table (FILE * file,
7011 struct hppa_unw_aux_info * aux,
7012 Elf_Internal_Shdr * sec)
57346661 7013{
1c0751b2 7014 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7015 Elf_Internal_Phdr * seg;
7016 struct hppa_unw_table_entry * tep;
7017 Elf_Internal_Shdr * relsec;
7018 Elf_Internal_Rela * rela;
7019 Elf_Internal_Rela * rp;
7020 unsigned char * table;
7021 unsigned char * tp;
7022 Elf_Internal_Sym * sym;
7023 const char * relname;
57346661 7024
57346661
AM		 7025 /* First, find the starting address of the segment that includes
7026 this section. */
7027
7028 if (elf_header.e_phnum)
7029 {
7030 if (! get_program_headers (file))
7031 return 0;
7032
7033 for (seg = program_headers;
7034 seg < program_headers + elf_header.e_phnum;
7035 ++seg)
7036 {
7037 if (seg->p_type != PT_LOAD)
7038 continue;
7039
7040 if (sec->sh_addr >= seg->p_vaddr
7041 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7042 {
7043 aux->seg_base = seg->p_vaddr;
7044 break;
7045 }
7046 }
7047 }
7048
7049 /* Second, build the unwind table from the contents of the unwind
7050 section. */
7051 size = sec->sh_size;
3f5e193b
NC		 7052 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7053 _("unwind table"));
57346661
AM		 7054 if (!table)
7055 return 0;
7056
1c0751b2
DA		 7057 unw_ent_size = 16;
7058 nentries = size / unw_ent_size;
7059 size = unw_ent_size * nentries;
57346661 7060
3f5e193b
NC		 7061 tep = aux->table = (struct hppa_unw_table_entry *)
7062 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7063
1c0751b2 7064 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7065 {
7066 unsigned int tmp1, tmp2;
7067
7068 tep->start.section = SHN_UNDEF;
7069 tep->end.section = SHN_UNDEF;
7070
1c0751b2
DA		 7071 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7072 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7073 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7074 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7075
7076 tep->start.offset += aux->seg_base;
7077 tep->end.offset += aux->seg_base;
57346661
AM		 7078
7079 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7080 tep->Millicode = (tmp1 >> 30) & 0x1;
7081 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7082 tep->Region_description = (tmp1 >> 27) & 0x3;
7083 tep->reserved1 = (tmp1 >> 26) & 0x1;
7084 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7085 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7086 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7087 tep->Args_stored = (tmp1 >> 15) & 0x1;
7088 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7089 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7090 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7091 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7092 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7093 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7094 tep->cxx_info = (tmp1 >> 8) & 0x1;
7095 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7096 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7097 tep->reserved2 = (tmp1 >> 5) & 0x1;
7098 tep->Save_SP = (tmp1 >> 4) & 0x1;
7099 tep->Save_RP = (tmp1 >> 3) & 0x1;
7100 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7101 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7102 tep->Cleanup_defined = tmp1 & 0x1;
7103
7104 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7105 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7106 tep->Large_frame = (tmp2 >> 29) & 0x1;
7107 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7108 tep->reserved4 = (tmp2 >> 27) & 0x1;
7109 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7110 }
7111 free (table);
7112
7113 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7114 for (relsec = section_headers;
7115 relsec < section_headers + elf_header.e_shnum;
7116 ++relsec)
7117 {
7118 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7119 || relsec->sh_info >= elf_header.e_shnum
7120 || section_headers + relsec->sh_info != sec)
57346661
AM		 7121 continue;
7122
7123 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7124 & rela, & nrelas))
7125 return 0;
7126
7127 for (rp = rela; rp < rela + nrelas; ++rp)
7128 {
aca88567
NC		 7129 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7130 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7131
7132 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7133 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7134 {
7135 warn (_("Skipping unexpected relocation type %s\n"), relname);
7136 continue;
7137 }
7138
7139 i = rp->r_offset / unw_ent_size;
7140
89fac5e3 7141 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7142 {
7143 case 0:
7144 aux->table[i].start.section = sym->st_shndx;
1e456d54 7145 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7146 break;
7147 case 1:
7148 aux->table[i].end.section = sym->st_shndx;
1e456d54 7149 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7150 break;
7151 default:
7152 break;
7153 }
7154 }
7155
7156 free (rela);
7157 }
7158
1c0751b2 7159 aux->table_len = nentries;
57346661
AM		 7160
7161 return 1;
7162}
7163
1b31d05e 7164static void
2cf0635d 7165hppa_process_unwind (FILE * file)
57346661 7166{
57346661 7167 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7168 Elf_Internal_Shdr * unwsec = NULL;
7169 Elf_Internal_Shdr * strsec;
7170 Elf_Internal_Shdr * sec;
18bd398b 7171 unsigned long i;
57346661 7172
c256ffe7 7173 if (string_table == NULL)
1b31d05e
NC		 7174 return;
7175
7176 memset (& aux, 0, sizeof (aux));
57346661
AM		 7177
7178 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7179 {
c256ffe7 7180 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7181 && sec->sh_link < elf_header.e_shnum)
57346661 7182 {
ba5cdace 7183 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7184
4fbb74a6 7185 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7186 if (aux.strtab != NULL)
7187 {
7188 error (_("Multiple auxillary string tables encountered\n"));
7189 free (aux.strtab);
7190 }
3f5e193b
NC		 7191 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7192 1, strsec->sh_size,
7193 _("string table"));
c256ffe7 7194 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7195 }
18bd398b 7196 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7197 unwsec = sec;
7198 }
7199
7200 if (!unwsec)
7201 printf (_("\nThere are no unwind sections in this file.\n"));
7202
7203 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7204 {
18bd398b 7205 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7206 {
74e1a04b
NC		 7207 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7208 printable_section_name (sec),
57346661 7209 (unsigned long) sec->sh_offset,
89fac5e3 7210 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7211
7212 slurp_hppa_unwind_table (file, &aux, sec);
7213 if (aux.table_len > 0)
7214 dump_hppa_unwind (&aux);
7215
7216 if (aux.table)
7217 free ((char *) aux.table);
7218 aux.table = NULL;
7219 }
7220 }
7221
7222 if (aux.symtab)
7223 free (aux.symtab);
7224 if (aux.strtab)
7225 free ((char *) aux.strtab);
57346661
AM		 7226}
7227
0b6ae522
DJ		 7228struct arm_section
7229{
a734115a
NC		 7230 unsigned char * data; /* The unwind data. */
7231 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7232 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7233 unsigned long nrelas; /* The number of relocations. */
7234 unsigned int rel_type; /* REL or RELA ? */
7235 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7236};
7237
7238struct arm_unw_aux_info
7239{
a734115a
NC		 7240 FILE * file; /* The file containing the unwind sections. */
7241 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7242 unsigned long nsyms; /* Number of symbols. */
7243 char * strtab; /* The file's string table. */
7244 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7245};
7246
7247static const char *
7248arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7249 bfd_vma fn, struct absaddr addr)
7250{
7251 const char *procname;
7252 bfd_vma sym_offset;
7253
7254 if (addr.section == SHN_UNDEF)
7255 addr.offset = fn;
7256
7257 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7258 aux->strtab_size, addr, &procname,
7259 &sym_offset);
7260
7261 print_vma (fn, PREFIX_HEX);
7262
7263 if (procname)
7264 {
7265 fputs (" <", stdout);
7266 fputs (procname, stdout);
7267
7268 if (sym_offset)
7269 printf ("+0x%lx", (unsigned long) sym_offset);
7270 fputc ('>', stdout);
7271 }
7272
7273 return procname;
7274}
7275
7276static void
7277arm_free_section (struct arm_section *arm_sec)
7278{
7279 if (arm_sec->data != NULL)
7280 free (arm_sec->data);
7281
7282 if (arm_sec->rela != NULL)
7283 free (arm_sec->rela);
7284}
7285
a734115a
NC		 7286/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7287 cached section and install SEC instead.
7288 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7289 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7290 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7291 relocation's offset in ADDR.
1b31d05e
NC		 7292 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7293 into the string table of the symbol associated with the reloc. If no
7294 reloc was applied store -1 there.
7295 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7296
7297static bfd_boolean
1b31d05e
NC		 7298get_unwind_section_word (struct arm_unw_aux_info * aux,
7299 struct arm_section * arm_sec,
7300 Elf_Internal_Shdr * sec,
7301 bfd_vma word_offset,
7302 unsigned int * wordp,
7303 struct absaddr * addr,
7304 bfd_vma * sym_name)
0b6ae522
DJ		 7305{
7306 Elf_Internal_Rela *rp;
7307 Elf_Internal_Sym *sym;
7308 const char * relname;
7309 unsigned int word;
7310 bfd_boolean wrapped;
7311
e0a31db1
NC		 7312 if (sec == NULL || arm_sec == NULL)
7313 return FALSE;
7314
0b6ae522
DJ		 7315 addr->section = SHN_UNDEF;
7316 addr->offset = 0;
7317
1b31d05e
NC		 7318 if (sym_name != NULL)
7319 *sym_name = (bfd_vma) -1;
7320
a734115a 7321 /* If necessary, update the section cache. */
0b6ae522
DJ		 7322 if (sec != arm_sec->sec)
7323 {
7324 Elf_Internal_Shdr *relsec;
7325
7326 arm_free_section (arm_sec);
7327
7328 arm_sec->sec = sec;
7329 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7330 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7331 arm_sec->rela = NULL;
7332 arm_sec->nrelas = 0;
7333
7334 for (relsec = section_headers;
7335 relsec < section_headers + elf_header.e_shnum;
7336 ++relsec)
7337 {
7338 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7339 || section_headers + relsec->sh_info != sec
7340 /* PR 15745: Check the section type as well. */
7341 || (relsec->sh_type != SHT_REL
7342 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7343 continue;
7344
a734115a 7345 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7346 if (relsec->sh_type == SHT_REL)
7347 {
7348 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7349 relsec->sh_size,
7350 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7351 return FALSE;
0b6ae522 7352 }
1ae40aa4 7353 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7354 {
7355 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7356 relsec->sh_size,
7357 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7358 return FALSE;
0b6ae522 7359 }
1ae40aa4 7360 break;
0b6ae522
DJ		 7361 }
7362
7363 arm_sec->next_rela = arm_sec->rela;
7364 }
7365
a734115a 7366 /* If there is no unwind data we can do nothing. */
0b6ae522 7367 if (arm_sec->data == NULL)
a734115a 7368 return FALSE;
0b6ae522 7369
e0a31db1
NC		 7370 /* If the offset is invalid then fail. */
7371 if (word_offset > sec->sh_size - 4)
7372 return FALSE;
7373
a734115a 7374 /* Get the word at the required offset. */
0b6ae522
DJ		 7375 word = byte_get (arm_sec->data + word_offset, 4);
7376
0eff7165
NC		 7377 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7378 if (arm_sec->rela == NULL)
7379 {
7380 * wordp = word;
7381 return TRUE;
7382 }
7383
a734115a 7384 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7385 wrapped = FALSE;
7386 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7387 {
7388 bfd_vma prelval, offset;
7389
7390 if (rp->r_offset > word_offset && !wrapped)
7391 {
7392 rp = arm_sec->rela;
7393 wrapped = TRUE;
7394 }
7395 if (rp->r_offset > word_offset)
7396 break;
7397
7398 if (rp->r_offset & 3)
7399 {
7400 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7401 (unsigned long) rp->r_offset);
7402 continue;
7403 }
7404
7405 if (rp->r_offset < word_offset)
7406 continue;
7407
74e1a04b
NC		 7408 /* PR 17531: file: 027-161405-0.004 */
7409 if (aux->symtab == NULL)
7410 continue;
7411
0b6ae522
DJ		 7412 if (arm_sec->rel_type == SHT_REL)
7413 {
7414 offset = word & 0x7fffffff;
7415 if (offset & 0x40000000)
7416 offset |= ~ (bfd_vma) 0x7fffffff;
7417 }
a734115a 7418 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7419 offset = rp->r_addend;
a734115a 7420 else
74e1a04b
NC		 7421 {
7422 error (_("Unknown section relocation type %d encountered\n"),
7423 arm_sec->rel_type);
7424 break;
7425 }
0b6ae522 7426
071436c6
NC		 7427 /* PR 17531 file: 027-1241568-0.004. */
7428 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7429 {
7430 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7431 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7432 break;
7433 }
7434
7435 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7436 offset += sym->st_value;
7437 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7438
a734115a
NC		 7439 /* Check that we are processing the expected reloc type. */
7440 if (elf_header.e_machine == EM_ARM)
7441 {
7442 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7443 if (relname == NULL)
7444 {
7445 warn (_("Skipping unknown ARM relocation type: %d\n"),
7446 (int) ELF32_R_TYPE (rp->r_info));
7447 continue;
7448 }
a734115a
NC		 7449
7450 if (streq (relname, "R_ARM_NONE"))
7451 continue;
0b4362b0 7452
a734115a
NC		 7453 if (! streq (relname, "R_ARM_PREL31"))
7454 {
071436c6 7455 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7456 continue;
7457 }
7458 }
7459 else if (elf_header.e_machine == EM_TI_C6000)
7460 {
7461 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7462 if (relname == NULL)
7463 {
7464 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7465 (int) ELF32_R_TYPE (rp->r_info));
7466 continue;
7467 }
0b4362b0 7468
a734115a
NC		 7469 if (streq (relname, "R_C6000_NONE"))
7470 continue;
7471
7472 if (! streq (relname, "R_C6000_PREL31"))
7473 {
071436c6 7474 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7475 continue;
7476 }
7477
7478 prelval >>= 1;
7479 }
7480 else
74e1a04b
NC		 7481 {
7482 /* This function currently only supports ARM and TI unwinders. */
7483 warn (_("Only TI and ARM unwinders are currently supported\n"));
7484 break;
7485 }
fa197c1c 7486
0b6ae522
DJ		 7487 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7488 addr->section = sym->st_shndx;
7489 addr->offset = offset;
74e1a04b 7490
1b31d05e
NC		 7491 if (sym_name)
7492 * sym_name = sym->st_name;
0b6ae522
DJ		 7493 break;
7494 }
7495
7496 *wordp = word;
7497 arm_sec->next_rela = rp;
7498
a734115a 7499 return TRUE;
0b6ae522
DJ		 7500}
7501
a734115a
NC		 7502static const char *tic6x_unwind_regnames[16] =
7503{
0b4362b0
RM		 7504 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7505 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7506 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7507};
fa197c1c 7508
0b6ae522 7509static void
fa197c1c 7510decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7511{
fa197c1c
PB		 7512 int i;
7513
7514 for (i = 12; mask; mask >>= 1, i--)
7515 {
7516 if (mask & 1)
7517 {
7518 fputs (tic6x_unwind_regnames[i], stdout);
7519 if (mask > 1)
7520 fputs (", ", stdout);
7521 }
7522 }
7523}
0b6ae522
DJ		 7524
7525#define ADVANCE \
7526 if (remaining == 0 && more_words) \
7527 { \
7528 data_offset += 4; \
1b31d05e
NC		 7529 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7530 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7531 return; \
7532 remaining = 4; \
7533 more_words--; \
7534 } \
7535
7536#define GET_OP(OP) \
7537 ADVANCE; \
7538 if (remaining) \
7539 { \
7540 remaining--; \
7541 (OP) = word >> 24; \
7542 word <<= 8; \
7543 } \
7544 else \
7545 { \
2b692964 7546 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7547 return; \
7548 } \
cc5914eb 7549 printf ("0x%02x ", OP)
0b6ae522 7550
fa197c1c
PB		 7551static void
7552decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7553 unsigned int word, unsigned int remaining,
7554 unsigned int more_words,
7555 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7556 struct arm_section *data_arm_sec)
7557{
7558 struct absaddr addr;
0b6ae522
DJ		 7559
7560 /* Decode the unwinding instructions. */
7561 while (1)
7562 {
7563 unsigned int op, op2;
7564
7565 ADVANCE;
7566 if (remaining == 0)
7567 break;
7568 remaining--;
7569 op = word >> 24;
7570 word <<= 8;
7571
cc5914eb 7572 printf (" 0x%02x ", op);
0b6ae522
DJ		 7573
7574 if ((op & 0xc0) == 0x00)
7575 {
7576 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7577
cc5914eb 7578 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7579 }
7580 else if ((op & 0xc0) == 0x40)
7581 {
7582 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7583
cc5914eb 7584 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7585 }
7586 else if ((op & 0xf0) == 0x80)
7587 {
7588 GET_OP (op2);
7589 if (op == 0x80 && op2 == 0)
7590 printf (_("Refuse to unwind"));
7591 else
7592 {
7593 unsigned int mask = ((op & 0x0f) << 8) | op2;
7594 int first = 1;
7595 int i;
2b692964 7596
0b6ae522
DJ		 7597 printf ("pop {");
7598 for (i = 0; i < 12; i++)
7599 if (mask & (1 << i))
7600 {
7601 if (first)
7602 first = 0;
7603 else
7604 printf (", ");
7605 printf ("r%d", 4 + i);
7606 }
7607 printf ("}");
7608 }
7609 }
7610 else if ((op & 0xf0) == 0x90)
7611 {
7612 if (op == 0x9d || op == 0x9f)
7613 printf (_(" [Reserved]"));
7614 else
cc5914eb 7615 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7616 }
7617 else if ((op & 0xf0) == 0xa0)
7618 {
7619 int end = 4 + (op & 0x07);
7620 int first = 1;
7621 int i;
61865e30 7622
0b6ae522
DJ		 7623 printf (" pop {");
7624 for (i = 4; i <= end; i++)
7625 {
7626 if (first)
7627 first = 0;
7628 else
7629 printf (", ");
7630 printf ("r%d", i);
7631 }
7632 if (op & 0x08)
7633 {
1b31d05e 7634 if (!first)
0b6ae522
DJ		 7635 printf (", ");
7636 printf ("r14");
7637 }
7638 printf ("}");
7639 }
7640 else if (op == 0xb0)
7641 printf (_(" finish"));
7642 else if (op == 0xb1)
7643 {
7644 GET_OP (op2);
7645 if (op2 == 0 || (op2 & 0xf0) != 0)
7646 printf (_("[Spare]"));
7647 else
7648 {
7649 unsigned int mask = op2 & 0x0f;
7650 int first = 1;
7651 int i;
61865e30 7652
0b6ae522
DJ		 7653 printf ("pop {");
7654 for (i = 0; i < 12; i++)
7655 if (mask & (1 << i))
7656 {
7657 if (first)
7658 first = 0;
7659 else
7660 printf (", ");
7661 printf ("r%d", i);
7662 }
7663 printf ("}");
7664 }
7665 }
7666 else if (op == 0xb2)
7667 {
b115cf96 7668 unsigned char buf[9];
0b6ae522
DJ		 7669 unsigned int i, len;
7670 unsigned long offset;
61865e30 7671
b115cf96 7672 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7673 {
7674 GET_OP (buf[i]);
7675 if ((buf[i] & 0x80) == 0)
7676 break;
7677 }
4082ef84
NC		 7678 if (i == sizeof (buf))
7679 printf (_("corrupt change to vsp"));
7680 else
7681 {
7682 offset = read_uleb128 (buf, &len, buf + i + 1);
7683 assert (len == i + 1);
7684 offset = offset * 4 + 0x204;
7685 printf ("vsp = vsp + %ld", offset);
7686 }
0b6ae522 7687 }
61865e30 7688 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7689 {
61865e30
NC		 7690 unsigned int first, last;
7691
7692 GET_OP (op2);
7693 first = op2 >> 4;
7694 last = op2 & 0x0f;
7695 if (op == 0xc8)
7696 first = first + 16;
7697 printf ("pop {D%d", first);
7698 if (last)
7699 printf ("-D%d", first + last);
7700 printf ("}");
7701 }
7702 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7703 {
7704 unsigned int count = op & 0x07;
7705
7706 printf ("pop {D8");
7707 if (count)
7708 printf ("-D%d", 8 + count);
7709 printf ("}");
7710 }
7711 else if (op >= 0xc0 && op <= 0xc5)
7712 {
7713 unsigned int count = op & 0x07;
7714
7715 printf (" pop {wR10");
7716 if (count)
7717 printf ("-wR%d", 10 + count);
7718 printf ("}");
7719 }
7720 else if (op == 0xc6)
7721 {
7722 unsigned int first, last;
7723
7724 GET_OP (op2);
7725 first = op2 >> 4;
7726 last = op2 & 0x0f;
7727 printf ("pop {wR%d", first);
7728 if (last)
7729 printf ("-wR%d", first + last);
7730 printf ("}");
7731 }
7732 else if (op == 0xc7)
7733 {
7734 GET_OP (op2);
7735 if (op2 == 0 || (op2 & 0xf0) != 0)
7736 printf (_("[Spare]"));
0b6ae522
DJ		 7737 else
7738 {
61865e30
NC		 7739 unsigned int mask = op2 & 0x0f;
7740 int first = 1;
7741 int i;
7742
7743 printf ("pop {");
7744 for (i = 0; i < 4; i++)
7745 if (mask & (1 << i))
7746 {
7747 if (first)
7748 first = 0;
7749 else
7750 printf (", ");
7751 printf ("wCGR%d", i);
7752 }
7753 printf ("}");
0b6ae522
DJ		 7754 }
7755 }
61865e30
NC		 7756 else
7757 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7758 printf ("\n");
7759 }
fa197c1c
PB		 7760}
7761
7762static void
7763decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7764 unsigned int word, unsigned int remaining,
7765 unsigned int more_words,
7766 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7767 struct arm_section *data_arm_sec)
7768{
7769 struct absaddr addr;
7770
7771 /* Decode the unwinding instructions. */
7772 while (1)
7773 {
7774 unsigned int op, op2;
7775
7776 ADVANCE;
7777 if (remaining == 0)
7778 break;
7779 remaining--;
7780 op = word >> 24;
7781 word <<= 8;
7782
9cf03b7e 7783 printf (" 0x%02x ", op);
fa197c1c
PB		 7784
7785 if ((op & 0xc0) == 0x00)
7786 {
7787 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7788 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7789 }
7790 else if ((op & 0xc0) == 0x80)
7791 {
7792 GET_OP (op2);
7793 if (op == 0x80 && op2 == 0)
7794 printf (_("Refuse to unwind"));
7795 else
7796 {
7797 unsigned int mask = ((op & 0x1f) << 8) | op2;
7798 if (op & 0x20)
7799 printf ("pop compact {");
7800 else
7801 printf ("pop {");
7802
7803 decode_tic6x_unwind_regmask (mask);
7804 printf("}");
7805 }
7806 }
7807 else if ((op & 0xf0) == 0xc0)
7808 {
7809 unsigned int reg;
7810 unsigned int nregs;
7811 unsigned int i;
7812 const char *name;
a734115a
NC		 7813 struct
7814 {
fa197c1c
PB		 7815 unsigned int offset;
7816 unsigned int reg;
7817 } regpos[16];
7818
7819 /* Scan entire instruction first so that GET_OP output is not
7820 interleaved with disassembly. */
7821 nregs = 0;
7822 for (i = 0; nregs < (op & 0xf); i++)
7823 {
7824 GET_OP (op2);
7825 reg = op2 >> 4;
7826 if (reg != 0xf)
7827 {
7828 regpos[nregs].offset = i * 2;
7829 regpos[nregs].reg = reg;
7830 nregs++;
7831 }
7832
7833 reg = op2 & 0xf;
7834 if (reg != 0xf)
7835 {
7836 regpos[nregs].offset = i * 2 + 1;
7837 regpos[nregs].reg = reg;
7838 nregs++;
7839 }
7840 }
7841
7842 printf (_("pop frame {"));
7843 reg = nregs - 1;
7844 for (i = i * 2; i > 0; i--)
7845 {
7846 if (regpos[reg].offset == i - 1)
7847 {
7848 name = tic6x_unwind_regnames[regpos[reg].reg];
7849 if (reg > 0)
7850 reg--;
7851 }
7852 else
7853 name = _("[pad]");
7854
7855 fputs (name, stdout);
7856 if (i > 1)
7857 printf (", ");
7858 }
7859
7860 printf ("}");
7861 }
7862 else if (op == 0xd0)
7863 printf (" MOV FP, SP");
7864 else if (op == 0xd1)
7865 printf (" __c6xabi_pop_rts");
7866 else if (op == 0xd2)
7867 {
7868 unsigned char buf[9];
7869 unsigned int i, len;
7870 unsigned long offset;
a734115a 7871
fa197c1c
PB		 7872 for (i = 0; i < sizeof (buf); i++)
7873 {
7874 GET_OP (buf[i]);
7875 if ((buf[i] & 0x80) == 0)
7876 break;
7877 }
0eff7165
NC		 7878 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7879 if (i == sizeof (buf))
7880 {
7881 printf ("<corrupt sp adjust>\n");
7882 warn (_("Corrupt stack pointer adjustment detected\n"));
7883 return;
7884 }
7885
f6f0e17b 7886 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7887 assert (len == i + 1);
7888 offset = offset * 8 + 0x408;
7889 printf (_("sp = sp + %ld"), offset);
7890 }
7891 else if ((op & 0xf0) == 0xe0)
7892 {
7893 if ((op & 0x0f) == 7)
7894 printf (" RETURN");
7895 else
7896 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7897 }
7898 else
7899 {
7900 printf (_(" [unsupported opcode]"));
7901 }
7902 putchar ('\n');
7903 }
7904}
7905
7906static bfd_vma
a734115a 7907arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7908{
7909 bfd_vma offset;
7910
7911 offset = word & 0x7fffffff;
7912 if (offset & 0x40000000)
7913 offset |= ~ (bfd_vma) 0x7fffffff;
7914
7915 if (elf_header.e_machine == EM_TI_C6000)
7916 offset <<= 1;
7917
7918 return offset + where;
7919}
7920
7921static void
1b31d05e
NC		 7922decode_arm_unwind (struct arm_unw_aux_info * aux,
7923 unsigned int word,
7924 unsigned int remaining,
7925 bfd_vma data_offset,
7926 Elf_Internal_Shdr * data_sec,
7927 struct arm_section * data_arm_sec)
fa197c1c
PB		 7928{
7929 int per_index;
7930 unsigned int more_words = 0;
37e14bc3 7931 struct absaddr addr;
1b31d05e 7932 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7933
7934 if (remaining == 0)
7935 {
1b31d05e
NC		 7936 /* Fetch the first word.
7937 Note - when decoding an object file the address extracted
7938 here will always be 0. So we also pass in the sym_name
7939 parameter so that we can find the symbol associated with
7940 the personality routine. */
7941 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7942 & word, & addr, & sym_name))
fa197c1c 7943 return;
1b31d05e 7944
fa197c1c
PB		 7945 remaining = 4;
7946 }
7947
7948 if ((word & 0x80000000) == 0)
7949 {
7950 /* Expand prel31 for personality routine. */
7951 bfd_vma fn;
7952 const char *procname;
7953
a734115a 7954 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7955 printf (_(" Personality routine: "));
1b31d05e
NC		 7956 if (fn == 0
7957 && addr.section == SHN_UNDEF && addr.offset == 0
7958 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7959 {
7960 procname = aux->strtab + sym_name;
7961 print_vma (fn, PREFIX_HEX);
7962 if (procname)
7963 {
7964 fputs (" <", stdout);
7965 fputs (procname, stdout);
7966 fputc ('>', stdout);
7967 }
7968 }
7969 else
7970 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7971 fputc ('\n', stdout);
7972
7973 /* The GCC personality routines use the standard compact
7974 encoding, starting with one byte giving the number of
7975 words. */
7976 if (procname != NULL
7977 && (const_strneq (procname, "__gcc_personality_v0")
7978 || const_strneq (procname, "__gxx_personality_v0")
7979 || const_strneq (procname, "__gcj_personality_v0")
7980 || const_strneq (procname, "__gnu_objc_personality_v0")))
7981 {
7982 remaining = 0;
7983 more_words = 1;
7984 ADVANCE;
7985 if (!remaining)
7986 {
7987 printf (_(" [Truncated data]\n"));
7988 return;
7989 }
7990 more_words = word >> 24;
7991 word <<= 8;
7992 remaining--;
7993 per_index = -1;
7994 }
7995 else
7996 return;
7997 }
7998 else
7999 {
1b31d05e 8000 /* ARM EHABI Section 6.3:
0b4362b0 8001
1b31d05e 8002 An exception-handling table entry for the compact model looks like:
0b4362b0 8003
1b31d05e
NC		 8004 31 30-28 27-24 23-0
8005 -- ----- ----- ----
8006 1 0 index Data for personalityRoutine[index] */
8007
8008 if (elf_header.e_machine == EM_ARM
8009 && (word & 0x70000000))
83c257ca 8010 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8011
fa197c1c 8012 per_index = (word >> 24) & 0x7f;
1b31d05e 8013 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8014 if (per_index == 0)
8015 {
8016 more_words = 0;
8017 word <<= 8;
8018 remaining--;
8019 }
8020 else if (per_index < 3)
8021 {
8022 more_words = (word >> 16) & 0xff;
8023 word <<= 16;
8024 remaining -= 2;
8025 }
8026 }
8027
8028 switch (elf_header.e_machine)
8029 {
8030 case EM_ARM:
8031 if (per_index < 3)
8032 {
8033 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8034 data_offset, data_sec, data_arm_sec);
8035 }
8036 else
1b31d05e
NC		 8037 {
8038 warn (_("Unknown ARM compact model index encountered\n"));
8039 printf (_(" [reserved]\n"));
8040 }
fa197c1c
PB		 8041 break;
8042
8043 case EM_TI_C6000:
8044 if (per_index < 3)
8045 {
8046 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8047 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8048 }
8049 else if (per_index < 5)
8050 {
8051 if (((word >> 17) & 0x7f) == 0x7f)
8052 printf (_(" Restore stack from frame pointer\n"));
8053 else
8054 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8055 printf (_(" Registers restored: "));
8056 if (per_index == 4)
8057 printf (" (compact) ");
8058 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8059 putchar ('\n');
8060 printf (_(" Return register: %s\n"),
8061 tic6x_unwind_regnames[word & 0xf]);
8062 }
8063 else
1b31d05e 8064 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8065 break;
8066
8067 default:
74e1a04b 8068 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8069 elf_header.e_machine);
fa197c1c 8070 }
0b6ae522
DJ		 8071
8072 /* Decode the descriptors. Not implemented. */
8073}
8074
8075static void
8076dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8077{
8078 struct arm_section exidx_arm_sec, extab_arm_sec;
8079 unsigned int i, exidx_len;
8080
8081 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8082 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8083 exidx_len = exidx_sec->sh_size / 8;
8084
8085 for (i = 0; i < exidx_len; i++)
8086 {
8087 unsigned int exidx_fn, exidx_entry;
8088 struct absaddr fn_addr, entry_addr;
8089 bfd_vma fn;
8090
8091 fputc ('\n', stdout);
8092
1b31d05e
NC		 8093 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8094 8 * i, & exidx_fn, & fn_addr, NULL)
8095 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8096 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8097 {
1b31d05e
NC		 8098 arm_free_section (& exidx_arm_sec);
8099 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8100 return;
8101 }
8102
83c257ca
NC		 8103 /* ARM EHABI, Section 5:
8104 An index table entry consists of 2 words.
8105 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8106 if (exidx_fn & 0x80000000)
8107 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8108
a734115a 8109 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8110
a734115a 8111 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8112 fputs (": ", stdout);
8113
8114 if (exidx_entry == 1)
8115 {
8116 print_vma (exidx_entry, PREFIX_HEX);
8117 fputs (" [cantunwind]\n", stdout);
8118 }
8119 else if (exidx_entry & 0x80000000)
8120 {
8121 print_vma (exidx_entry, PREFIX_HEX);
8122 fputc ('\n', stdout);
8123 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8124 }
8125 else
8126 {
8f73510c 8127 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8128 Elf_Internal_Shdr *table_sec;
8129
8130 fputs ("@", stdout);
a734115a 8131 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8132 print_vma (table, PREFIX_HEX);
8133 printf ("\n");
8134
8135 /* Locate the matching .ARM.extab. */
8136 if (entry_addr.section != SHN_UNDEF
8137 && entry_addr.section < elf_header.e_shnum)
8138 {
8139 table_sec = section_headers + entry_addr.section;
8140 table_offset = entry_addr.offset;
8141 }
8142 else
8143 {
8144 table_sec = find_section_by_address (table);
8145 if (table_sec != NULL)
8146 table_offset = table - table_sec->sh_addr;
8147 }
8148 if (table_sec == NULL)
8149 {
8150 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8151 (unsigned long) table);
8152 continue;
8153 }
8154 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8155 &extab_arm_sec);
8156 }
8157 }
8158
8159 printf ("\n");
8160
8161 arm_free_section (&exidx_arm_sec);
8162 arm_free_section (&extab_arm_sec);
8163}
8164
fa197c1c 8165/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8166
8167static void
0b6ae522
DJ		 8168arm_process_unwind (FILE *file)
8169{
8170 struct arm_unw_aux_info aux;
8171 Elf_Internal_Shdr *unwsec = NULL;
8172 Elf_Internal_Shdr *strsec;
8173 Elf_Internal_Shdr *sec;
8174 unsigned long i;
fa197c1c 8175 unsigned int sec_type;
0b6ae522 8176
fa197c1c
PB		 8177 switch (elf_header.e_machine)
8178 {
8179 case EM_ARM:
8180 sec_type = SHT_ARM_EXIDX;
8181 break;
8182
8183 case EM_TI_C6000:
8184 sec_type = SHT_C6000_UNWIND;
8185 break;
8186
0b4362b0 8187 default:
74e1a04b 8188 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8189 elf_header.e_machine);
8190 return;
fa197c1c
PB		 8191 }
8192
0b6ae522 8193 if (string_table == NULL)
1b31d05e
NC		 8194 return;
8195
8196 memset (& aux, 0, sizeof (aux));
8197 aux.file = file;
0b6ae522
DJ		 8198
8199 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8200 {
8201 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8202 {
ba5cdace 8203 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8204
8205 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8206
8207 /* PR binutils/17531 file: 011-12666-0.004. */
8208 if (aux.strtab != NULL)
8209 {
4082ef84 8210 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8211 free (aux.strtab);
8212 }
0b6ae522
DJ		 8213 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8214 1, strsec->sh_size, _("string table"));
8215 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8216 }
fa197c1c 8217 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8218 unwsec = sec;
8219 }
8220
1b31d05e 8221 if (unwsec == NULL)
0b6ae522 8222 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8223 else
8224 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8225 {
8226 if (sec->sh_type == sec_type)
8227 {
8228 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8229 printable_section_name (sec),
1b31d05e
NC		 8230 (unsigned long) sec->sh_offset,
8231 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8232
1b31d05e
NC		 8233 dump_arm_unwind (&aux, sec);
8234 }
8235 }
0b6ae522
DJ		 8236
8237 if (aux.symtab)
8238 free (aux.symtab);
8239 if (aux.strtab)
8240 free ((char *) aux.strtab);
0b6ae522
DJ		 8241}
8242
1b31d05e 8243static void
2cf0635d 8244process_unwind (FILE * file)
57346661 8245{
2cf0635d
NC		 8246 struct unwind_handler
8247 {
57346661 8248 int machtype;
1b31d05e 8249 void (* handler)(FILE *);
2cf0635d
NC		 8250 } handlers[] =
8251 {
0b6ae522 8252 { EM_ARM, arm_process_unwind },
57346661
AM		 8253 { EM_IA_64, ia64_process_unwind },
8254 { EM_PARISC, hppa_process_unwind },
fa197c1c 8255 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8256 { 0, 0 }
8257 };
8258 int i;
8259
8260 if (!do_unwind)
1b31d05e 8261 return;
57346661
AM		 8262
8263 for (i = 0; handlers[i].handler != NULL; i++)
8264 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8265 {
8266 handlers[i].handler (file);
8267 return;
8268 }
57346661 8269
1b31d05e
NC		 8270 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8271 get_machine_name (elf_header.e_machine));
57346661
AM		 8272}
8273
252b5132 8274static void
2cf0635d 8275dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8276{
8277 switch (entry->d_tag)
8278 {
8279 case DT_MIPS_FLAGS:
8280 if (entry->d_un.d_val == 0)
4b68bca3 8281 printf (_("NONE"));
252b5132
RH		 8282 else
8283 {
8284 static const char * opts[] =
8285 {
8286 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8287 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8288 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8289 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8290 "RLD_ORDER_SAFE"
8291 };
8292 unsigned int cnt;
8293 int first = 1;
2b692964 8294
60bca95a 8295 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8296 if (entry->d_un.d_val & (1 << cnt))
8297 {
8298 printf ("%s%s", first ? "" : " ", opts[cnt]);
8299 first = 0;
8300 }
252b5132
RH		 8301 }
8302 break;
103f02d3 8303
252b5132 8304 case DT_MIPS_IVERSION:
d79b3d50 8305 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8306 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8307 else
76ca31c0
NC		 8308 {
8309 char buf[40];
8310 sprintf_vma (buf, entry->d_un.d_ptr);
8311 /* Note: coded this way so that there is a single string for translation. */
8312 printf (_("<corrupt: %s>"), buf);
8313 }
252b5132 8314 break;
103f02d3 8315
252b5132
RH		 8316 case DT_MIPS_TIME_STAMP:
8317 {
8318 char timebuf[20];
2cf0635d 8319 struct tm * tmp;
91d6fa6a 8320 time_t atime = entry->d_un.d_val;
82b1b41b 8321
91d6fa6a 8322 tmp = gmtime (&atime);
82b1b41b
NC		 8323 /* PR 17531: file: 6accc532. */
8324 if (tmp == NULL)
8325 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8326 else
8327 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8328 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8329 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8330 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8331 }
8332 break;
103f02d3 8333
252b5132
RH		 8334 case DT_MIPS_RLD_VERSION:
8335 case DT_MIPS_LOCAL_GOTNO:
8336 case DT_MIPS_CONFLICTNO:
8337 case DT_MIPS_LIBLISTNO:
8338 case DT_MIPS_SYMTABNO:
8339 case DT_MIPS_UNREFEXTNO:
8340 case DT_MIPS_HIPAGENO:
8341 case DT_MIPS_DELTA_CLASS_NO:
8342 case DT_MIPS_DELTA_INSTANCE_NO:
8343 case DT_MIPS_DELTA_RELOC_NO:
8344 case DT_MIPS_DELTA_SYM_NO:
8345 case DT_MIPS_DELTA_CLASSSYM_NO:
8346 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8347 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8348 break;
103f02d3
UD		 8349
8350 default:
4b68bca3 8351 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8352 }
4b68bca3 8353 putchar ('\n');
103f02d3
UD		 8354}
8355
103f02d3 8356static void
2cf0635d 8357dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8358{
8359 switch (entry->d_tag)
8360 {
8361 case DT_HP_DLD_FLAGS:
8362 {
8363 static struct
8364 {
8365 long int bit;
2cf0635d 8366 const char * str;
5e220199
NC		 8367 }
8368 flags[] =
8369 {
8370 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8371 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8372 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8373 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8374 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8375 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8376 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8377 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8378 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8379 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8380 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8381 { DT_HP_GST, "HP_GST" },
8382 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8383 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8384 { DT_HP_NODELETE, "HP_NODELETE" },
8385 { DT_HP_GROUP, "HP_GROUP" },
8386 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8387 };
103f02d3 8388 int first = 1;
5e220199 8389 size_t cnt;
f7a99963 8390 bfd_vma val = entry->d_un.d_val;
103f02d3 8391
60bca95a 8392 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8393 if (val & flags[cnt].bit)
30800947
NC		 8394 {
8395 if (! first)
8396 putchar (' ');
8397 fputs (flags[cnt].str, stdout);
8398 first = 0;
8399 val ^= flags[cnt].bit;
8400 }
76da6bbe 8401
103f02d3 8402 if (val != 0 || first)
f7a99963
NC		 8403 {
8404 if (! first)
8405 putchar (' ');
8406 print_vma (val, HEX);
8407 }
103f02d3
UD		 8408 }
8409 break;
76da6bbe 8410
252b5132 8411 default:
f7a99963
NC		 8412 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8413 break;
252b5132 8414 }
35b1837e 8415 putchar ('\n');
252b5132
RH		 8416}
8417
28f997cf
TG		 8418#ifdef BFD64
8419
8420/* VMS vs Unix time offset and factor. */
8421
8422#define VMS_EPOCH_OFFSET 35067168000000000LL
8423#define VMS_GRANULARITY_FACTOR 10000000
8424
8425/* Display a VMS time in a human readable format. */
8426
8427static void
8428print_vms_time (bfd_int64_t vmstime)
8429{
8430 struct tm *tm;
8431 time_t unxtime;
8432
8433 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8434 tm = gmtime (&unxtime);
8435 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8436 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8437 tm->tm_hour, tm->tm_min, tm->tm_sec);
8438}
8439#endif /* BFD64 */
8440
ecc51f48 8441static void
2cf0635d 8442dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8443{
8444 switch (entry->d_tag)
8445 {
0de14b54 8446 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8447 /* First 3 slots reserved. */
ecc51f48
NC		 8448 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8449 printf (" -- ");
8450 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8451 break;
8452
28f997cf
TG		 8453 case DT_IA_64_VMS_LINKTIME:
8454#ifdef BFD64
8455 print_vms_time (entry->d_un.d_val);
8456#endif
8457 break;
8458
8459 case DT_IA_64_VMS_LNKFLAGS:
8460 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8461 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8462 printf (" CALL_DEBUG");
8463 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8464 printf (" NOP0BUFS");
8465 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8466 printf (" P0IMAGE");
8467 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8468 printf (" MKTHREADS");
8469 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8470 printf (" UPCALLS");
8471 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8472 printf (" IMGSTA");
8473 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8474 printf (" INITIALIZE");
8475 if (entry->d_un.d_val & VMS_LF_MAIN)
8476 printf (" MAIN");
8477 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8478 printf (" EXE_INIT");
8479 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8480 printf (" TBK_IN_IMG");
8481 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8482 printf (" DBG_IN_IMG");
8483 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8484 printf (" TBK_IN_DSF");
8485 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8486 printf (" DBG_IN_DSF");
8487 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8488 printf (" SIGNATURES");
8489 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8490 printf (" REL_SEG_OFF");
8491 break;
8492
bdf4d63a
JJ		 8493 default:
8494 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8495 break;
ecc51f48 8496 }
bdf4d63a 8497 putchar ('\n');
ecc51f48
NC		 8498}
8499
252b5132 8500static int
2cf0635d 8501get_32bit_dynamic_section (FILE * file)
252b5132 8502{
2cf0635d
NC		 8503 Elf32_External_Dyn * edyn;
8504 Elf32_External_Dyn * ext;
8505 Elf_Internal_Dyn * entry;
103f02d3 8506
3f5e193b
NC		 8507 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8508 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8509 if (!edyn)
8510 return 0;
103f02d3 8511
071436c6
NC		 8512 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8513 might not have the luxury of section headers. Look for the DT_NULL
8514 terminator to determine the number of entries. */
ba2685cc 8515 for (ext = edyn, dynamic_nent = 0;
071436c6 8516 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8517 ext++)
8518 {
8519 dynamic_nent++;
8520 if (BYTE_GET (ext->d_tag) == DT_NULL)
8521 break;
8522 }
252b5132 8523
3f5e193b
NC		 8524 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8525 sizeof (* entry));
b2d38a17 8526 if (dynamic_section == NULL)
252b5132 8527 {
8b73c356
NC		 8528 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8529 (unsigned long) dynamic_nent);
9ea033b2
NC		 8530 free (edyn);
8531 return 0;
8532 }
252b5132 8533
fb514b26 8534 for (ext = edyn, entry = dynamic_section;
ba2685cc 8535 entry < dynamic_section + dynamic_nent;
fb514b26 8536 ext++, entry++)
9ea033b2 8537 {
fb514b26
AM		 8538 entry->d_tag = BYTE_GET (ext->d_tag);
8539 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8540 }
8541
9ea033b2
NC		 8542 free (edyn);
8543
8544 return 1;
8545}
8546
8547static int
2cf0635d 8548get_64bit_dynamic_section (FILE * file)
9ea033b2 8549{
2cf0635d
NC		 8550 Elf64_External_Dyn * edyn;
8551 Elf64_External_Dyn * ext;
8552 Elf_Internal_Dyn * entry;
103f02d3 8553
071436c6 8554 /* Read in the data. */
3f5e193b
NC		 8555 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8556 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8557 if (!edyn)
8558 return 0;
103f02d3 8559
071436c6
NC		 8560 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8561 might not have the luxury of section headers. Look for the DT_NULL
8562 terminator to determine the number of entries. */
ba2685cc 8563 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8564 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8565 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8566 ext++)
8567 {
8568 dynamic_nent++;
66543521 8569 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8570 break;
8571 }
252b5132 8572
3f5e193b
NC		 8573 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8574 sizeof (* entry));
b2d38a17 8575 if (dynamic_section == NULL)
252b5132 8576 {
8b73c356
NC		 8577 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8578 (unsigned long) dynamic_nent);
252b5132
RH		 8579 free (edyn);
8580 return 0;
8581 }
8582
071436c6 8583 /* Convert from external to internal formats. */
fb514b26 8584 for (ext = edyn, entry = dynamic_section;
ba2685cc 8585 entry < dynamic_section + dynamic_nent;
fb514b26 8586 ext++, entry++)
252b5132 8587 {
66543521
AM		 8588 entry->d_tag = BYTE_GET (ext->d_tag);
8589 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8590 }
8591
8592 free (edyn);
8593
9ea033b2
NC		 8594 return 1;
8595}
8596
e9e44622
JJ		 8597static void
8598print_dynamic_flags (bfd_vma flags)
d1133906 8599{
e9e44622 8600 int first = 1;
13ae64f3 8601
d1133906
NC		 8602 while (flags)
8603 {
8604 bfd_vma flag;
8605
8606 flag = flags & - flags;
8607 flags &= ~ flag;
8608
e9e44622
JJ		 8609 if (first)
8610 first = 0;
8611 else
8612 putc (' ', stdout);
13ae64f3 8613
d1133906
NC		 8614 switch (flag)
8615 {
e9e44622
JJ		 8616 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8617 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8618 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8619 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8620 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8621 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8622 }
8623 }
e9e44622 8624 puts ("");
d1133906
NC		 8625}
8626
b2d38a17
NC		 8627/* Parse and display the contents of the dynamic section. */
8628
9ea033b2 8629static int
2cf0635d 8630process_dynamic_section (FILE * file)
9ea033b2 8631{
2cf0635d 8632 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8633
8634 if (dynamic_size == 0)
8635 {
8636 if (do_dynamic)
b2d38a17 8637 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8638
8639 return 1;
8640 }
8641
8642 if (is_32bit_elf)
8643 {
b2d38a17 8644 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8645 return 0;
8646 }
b2d38a17 8647 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8648 return 0;
8649
252b5132
RH		 8650 /* Find the appropriate symbol table. */
8651 if (dynamic_symbols == NULL)
8652 {
86dba8ee
AM		 8653 for (entry = dynamic_section;
8654 entry < dynamic_section + dynamic_nent;
8655 ++entry)
252b5132 8656 {
c8286bd1 8657 Elf_Internal_Shdr section;
252b5132
RH		 8658
8659 if (entry->d_tag != DT_SYMTAB)
8660 continue;
8661
8662 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8663
8664 /* Since we do not know how big the symbol table is,
8665 we default to reading in the entire file (!) and
8666 processing that. This is overkill, I know, but it
e3c8793a 8667 should work. */
d93f0186 8668 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8669
fb52b2f4
NC		 8670 if (archive_file_offset != 0)
8671 section.sh_size = archive_file_size - section.sh_offset;
8672 else
8673 {
8674 if (fseek (file, 0, SEEK_END))
591a748a 8675 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8676
8677 section.sh_size = ftell (file) - section.sh_offset;
8678 }
252b5132 8679
9ea033b2 8680 if (is_32bit_elf)
9ad5cbcf 8681 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8682 else
9ad5cbcf 8683 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8684 section.sh_name = string_table_length;
252b5132 8685
ba5cdace 8686 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8687 if (num_dynamic_syms < 1)
252b5132
RH		 8688 {
8689 error (_("Unable to determine the number of symbols to load\n"));
8690 continue;
8691 }
252b5132
RH		 8692 }
8693 }
8694
8695 /* Similarly find a string table. */
8696 if (dynamic_strings == NULL)
8697 {
86dba8ee
AM		 8698 for (entry = dynamic_section;
8699 entry < dynamic_section + dynamic_nent;
8700 ++entry)
252b5132
RH		 8701 {
8702 unsigned long offset;
b34976b6 8703 long str_tab_len;
252b5132
RH		 8704
8705 if (entry->d_tag != DT_STRTAB)
8706 continue;
8707
8708 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8709
8710 /* Since we do not know how big the string table is,
8711 we default to reading in the entire file (!) and
8712 processing that. This is overkill, I know, but it
e3c8793a 8713 should work. */
252b5132 8714
d93f0186 8715 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8716
8717 if (archive_file_offset != 0)
8718 str_tab_len = archive_file_size - offset;
8719 else
8720 {
8721 if (fseek (file, 0, SEEK_END))
8722 error (_("Unable to seek to end of file\n"));
8723 str_tab_len = ftell (file) - offset;
8724 }
252b5132
RH		 8725
8726 if (str_tab_len < 1)
8727 {
8728 error
8729 (_("Unable to determine the length of the dynamic string table\n"));
8730 continue;
8731 }
8732
3f5e193b
NC		 8733 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8734 str_tab_len,
8735 _("dynamic string table"));
59245841 8736 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8737 break;
8738 }
8739 }
8740
8741 /* And find the syminfo section if available. */
8742 if (dynamic_syminfo == NULL)
8743 {
3e8bba36 8744 unsigned long syminsz = 0;
252b5132 8745
86dba8ee
AM		 8746 for (entry = dynamic_section;
8747 entry < dynamic_section + dynamic_nent;
8748 ++entry)
252b5132
RH		 8749 {
8750 if (entry->d_tag == DT_SYMINENT)
8751 {
8752 /* Note: these braces are necessary to avoid a syntax
8753 error from the SunOS4 C compiler. */
049b0c3a
NC		 8754 /* PR binutils/17531: A corrupt file can trigger this test.
8755 So do not use an assert, instead generate an error message. */
8756 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8757 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8758 (int) entry->d_un.d_val);
252b5132
RH		 8759 }
8760 else if (entry->d_tag == DT_SYMINSZ)
8761 syminsz = entry->d_un.d_val;
8762 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8763 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8764 syminsz);
252b5132
RH		 8765 }
8766
8767 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8768 {
2cf0635d
NC		 8769 Elf_External_Syminfo * extsyminfo;
8770 Elf_External_Syminfo * extsym;
8771 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8772
8773 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8774 extsyminfo = (Elf_External_Syminfo *)
8775 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8776 _("symbol information"));
a6e9f9df
AM		 8777 if (!extsyminfo)
8778 return 0;
252b5132 8779
3f5e193b 8780 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8781 if (dynamic_syminfo == NULL)
8782 {
8b73c356
NC		 8783 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8784 (unsigned long) syminsz);
252b5132
RH		 8785 return 0;
8786 }
8787
8788 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8789 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8790 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8791 ++syminfo, ++extsym)
252b5132 8792 {
86dba8ee
AM		 8793 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8794 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8795 }
8796
8797 free (extsyminfo);
8798 }
8799 }
8800
8801 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8802 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8803 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8804 if (do_dynamic)
8805 printf (_(" Tag Type Name/Value\n"));
8806
86dba8ee
AM		 8807 for (entry = dynamic_section;
8808 entry < dynamic_section + dynamic_nent;
8809 entry++)
252b5132
RH		 8810 {
8811 if (do_dynamic)
f7a99963 8812 {
2cf0635d 8813 const char * dtype;
e699b9ff 8814
f7a99963
NC		 8815 putchar (' ');
8816 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8817 dtype = get_dynamic_type (entry->d_tag);
8818 printf (" (%s)%*s", dtype,
8819 ((is_32bit_elf ? 27 : 19)
8820 - (int) strlen (dtype)),
f7a99963
NC		 8821 " ");
8822 }
252b5132
RH		 8823
8824 switch (entry->d_tag)
8825 {
d1133906
NC		 8826 case DT_FLAGS:
8827 if (do_dynamic)
e9e44622 8828 print_dynamic_flags (entry->d_un.d_val);
d1133906 8829 break;
76da6bbe 8830
252b5132
RH		 8831 case DT_AUXILIARY:
8832 case DT_FILTER:
019148e4
L		 8833 case DT_CONFIG:
8834 case DT_DEPAUDIT:
8835 case DT_AUDIT:
252b5132
RH		 8836 if (do_dynamic)
8837 {
019148e4 8838 switch (entry->d_tag)
b34976b6 8839 {
019148e4
L		 8840 case DT_AUXILIARY:
8841 printf (_("Auxiliary library"));
8842 break;
8843
8844 case DT_FILTER:
8845 printf (_("Filter library"));
8846 break;
8847
b34976b6 8848 case DT_CONFIG:
019148e4
L		 8849 printf (_("Configuration file"));
8850 break;
8851
8852 case DT_DEPAUDIT:
8853 printf (_("Dependency audit library"));
8854 break;
8855
8856 case DT_AUDIT:
8857 printf (_("Audit library"));
8858 break;
8859 }
252b5132 8860
d79b3d50
NC		 8861 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8862 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8863 else
f7a99963
NC		 8864 {
8865 printf (": ");
8866 print_vma (entry->d_un.d_val, PREFIX_HEX);
8867 putchar ('\n');
8868 }
252b5132
RH		 8869 }
8870 break;
8871
dcefbbbd 8872 case DT_FEATURE:
252b5132
RH		 8873 if (do_dynamic)
8874 {
8875 printf (_("Flags:"));
86f55779 8876
252b5132
RH		 8877 if (entry->d_un.d_val == 0)
8878 printf (_(" None\n"));
8879 else
8880 {
8881 unsigned long int val = entry->d_un.d_val;
86f55779 8882
252b5132
RH		 8883 if (val & DTF_1_PARINIT)
8884 {
8885 printf (" PARINIT");
8886 val ^= DTF_1_PARINIT;
8887 }
dcefbbbd
L		 8888 if (val & DTF_1_CONFEXP)
8889 {
8890 printf (" CONFEXP");
8891 val ^= DTF_1_CONFEXP;
8892 }
252b5132
RH		 8893 if (val != 0)
8894 printf (" %lx", val);
8895 puts ("");
8896 }
8897 }
8898 break;
8899
8900 case DT_POSFLAG_1:
8901 if (do_dynamic)
8902 {
8903 printf (_("Flags:"));
86f55779 8904
252b5132
RH		 8905 if (entry->d_un.d_val == 0)
8906 printf (_(" None\n"));
8907 else
8908 {
8909 unsigned long int val = entry->d_un.d_val;
86f55779 8910
252b5132
RH		 8911 if (val & DF_P1_LAZYLOAD)
8912 {
8913 printf (" LAZYLOAD");
8914 val ^= DF_P1_LAZYLOAD;
8915 }
8916 if (val & DF_P1_GROUPPERM)
8917 {
8918 printf (" GROUPPERM");
8919 val ^= DF_P1_GROUPPERM;
8920 }
8921 if (val != 0)
8922 printf (" %lx", val);
8923 puts ("");
8924 }
8925 }
8926 break;
8927
8928 case DT_FLAGS_1:
8929 if (do_dynamic)
8930 {
8931 printf (_("Flags:"));
8932 if (entry->d_un.d_val == 0)
8933 printf (_(" None\n"));
8934 else
8935 {
8936 unsigned long int val = entry->d_un.d_val;
86f55779 8937
252b5132
RH		 8938 if (val & DF_1_NOW)
8939 {
8940 printf (" NOW");
8941 val ^= DF_1_NOW;
8942 }
8943 if (val & DF_1_GLOBAL)
8944 {
8945 printf (" GLOBAL");
8946 val ^= DF_1_GLOBAL;
8947 }
8948 if (val & DF_1_GROUP)
8949 {
8950 printf (" GROUP");
8951 val ^= DF_1_GROUP;
8952 }
8953 if (val & DF_1_NODELETE)
8954 {
8955 printf (" NODELETE");
8956 val ^= DF_1_NODELETE;
8957 }
8958 if (val & DF_1_LOADFLTR)
8959 {
8960 printf (" LOADFLTR");
8961 val ^= DF_1_LOADFLTR;
8962 }
8963 if (val & DF_1_INITFIRST)
8964 {
8965 printf (" INITFIRST");
8966 val ^= DF_1_INITFIRST;
8967 }
8968 if (val & DF_1_NOOPEN)
8969 {
8970 printf (" NOOPEN");
8971 val ^= DF_1_NOOPEN;
8972 }
8973 if (val & DF_1_ORIGIN)
8974 {
8975 printf (" ORIGIN");
8976 val ^= DF_1_ORIGIN;
8977 }
8978 if (val & DF_1_DIRECT)
8979 {
8980 printf (" DIRECT");
8981 val ^= DF_1_DIRECT;
8982 }
8983 if (val & DF_1_TRANS)
8984 {
8985 printf (" TRANS");
8986 val ^= DF_1_TRANS;
8987 }
8988 if (val & DF_1_INTERPOSE)
8989 {
8990 printf (" INTERPOSE");
8991 val ^= DF_1_INTERPOSE;
8992 }
f7db6139 8993 if (val & DF_1_NODEFLIB)
dcefbbbd 8994 {
f7db6139
L		 8995 printf (" NODEFLIB");
8996 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8997 }
8998 if (val & DF_1_NODUMP)
8999 {
9000 printf (" NODUMP");
9001 val ^= DF_1_NODUMP;
9002 }
34b60028 9003 if (val & DF_1_CONFALT)
dcefbbbd 9004 {
34b60028
L		 9005 printf (" CONFALT");
9006 val ^= DF_1_CONFALT;
9007 }
9008 if (val & DF_1_ENDFILTEE)
9009 {
9010 printf (" ENDFILTEE");
9011 val ^= DF_1_ENDFILTEE;
9012 }
9013 if (val & DF_1_DISPRELDNE)
9014 {
9015 printf (" DISPRELDNE");
9016 val ^= DF_1_DISPRELDNE;
9017 }
9018 if (val & DF_1_DISPRELPND)
9019 {
9020 printf (" DISPRELPND");
9021 val ^= DF_1_DISPRELPND;
9022 }
9023 if (val & DF_1_NODIRECT)
9024 {
9025 printf (" NODIRECT");
9026 val ^= DF_1_NODIRECT;
9027 }
9028 if (val & DF_1_IGNMULDEF)
9029 {
9030 printf (" IGNMULDEF");
9031 val ^= DF_1_IGNMULDEF;
9032 }
9033 if (val & DF_1_NOKSYMS)
9034 {
9035 printf (" NOKSYMS");
9036 val ^= DF_1_NOKSYMS;
9037 }
9038 if (val & DF_1_NOHDR)
9039 {
9040 printf (" NOHDR");
9041 val ^= DF_1_NOHDR;
9042 }
9043 if (val & DF_1_EDITED)
9044 {
9045 printf (" EDITED");
9046 val ^= DF_1_EDITED;
9047 }
9048 if (val & DF_1_NORELOC)
9049 {
9050 printf (" NORELOC");
9051 val ^= DF_1_NORELOC;
9052 }
9053 if (val & DF_1_SYMINTPOSE)
9054 {
9055 printf (" SYMINTPOSE");
9056 val ^= DF_1_SYMINTPOSE;
9057 }
9058 if (val & DF_1_GLOBAUDIT)
9059 {
9060 printf (" GLOBAUDIT");
9061 val ^= DF_1_GLOBAUDIT;
9062 }
9063 if (val & DF_1_SINGLETON)
9064 {
9065 printf (" SINGLETON");
9066 val ^= DF_1_SINGLETON;
dcefbbbd 9067 }
252b5132
RH		 9068 if (val != 0)
9069 printf (" %lx", val);
9070 puts ("");
9071 }
9072 }
9073 break;
9074
9075 case DT_PLTREL:
566b0d53 9076 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9077 if (do_dynamic)
9078 puts (get_dynamic_type (entry->d_un.d_val));
9079 break;
9080
9081 case DT_NULL :
9082 case DT_NEEDED :
9083 case DT_PLTGOT :
9084 case DT_HASH :
9085 case DT_STRTAB :
9086 case DT_SYMTAB :
9087 case DT_RELA :
9088 case DT_INIT :
9089 case DT_FINI :
9090 case DT_SONAME :
9091 case DT_RPATH :
9092 case DT_SYMBOLIC:
9093 case DT_REL :
9094 case DT_DEBUG :
9095 case DT_TEXTREL :
9096 case DT_JMPREL :
019148e4 9097 case DT_RUNPATH :
252b5132
RH		 9098 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9099
9100 if (do_dynamic)
9101 {
2cf0635d 9102 char * name;
252b5132 9103
d79b3d50
NC		 9104 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9105 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9106 else
d79b3d50 9107 name = NULL;
252b5132
RH		 9108
9109 if (name)
9110 {
9111 switch (entry->d_tag)
9112 {
9113 case DT_NEEDED:
9114 printf (_("Shared library: [%s]"), name);
9115
18bd398b 9116 if (streq (name, program_interpreter))
f7a99963 9117 printf (_(" program interpreter"));
252b5132
RH		 9118 break;
9119
9120 case DT_SONAME:
f7a99963 9121 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9122 break;
9123
9124 case DT_RPATH:
f7a99963 9125 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9126 break;
9127
019148e4
L		 9128 case DT_RUNPATH:
9129 printf (_("Library runpath: [%s]"), name);
9130 break;
9131
252b5132 9132 default:
f7a99963
NC		 9133 print_vma (entry->d_un.d_val, PREFIX_HEX);
9134 break;
252b5132
RH		 9135 }
9136 }
9137 else
f7a99963
NC		 9138 print_vma (entry->d_un.d_val, PREFIX_HEX);
9139
9140 putchar ('\n');
252b5132
RH		 9141 }
9142 break;
9143
9144 case DT_PLTRELSZ:
9145 case DT_RELASZ :
9146 case DT_STRSZ :
9147 case DT_RELSZ :
9148 case DT_RELAENT :
9149 case DT_SYMENT :
9150 case DT_RELENT :
566b0d53 9151 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9152 case DT_PLTPADSZ:
9153 case DT_MOVEENT :
9154 case DT_MOVESZ :
9155 case DT_INIT_ARRAYSZ:
9156 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9157 case DT_GNU_CONFLICTSZ:
9158 case DT_GNU_LIBLISTSZ:
252b5132 9159 if (do_dynamic)
f7a99963
NC		 9160 {
9161 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9162 printf (_(" (bytes)\n"));
f7a99963 9163 }
252b5132
RH		 9164 break;
9165
9166 case DT_VERDEFNUM:
9167 case DT_VERNEEDNUM:
9168 case DT_RELACOUNT:
9169 case DT_RELCOUNT:
9170 if (do_dynamic)
f7a99963
NC		 9171 {
9172 print_vma (entry->d_un.d_val, UNSIGNED);
9173 putchar ('\n');
9174 }
252b5132
RH		 9175 break;
9176
9177 case DT_SYMINSZ:
9178 case DT_SYMINENT:
9179 case DT_SYMINFO:
9180 case DT_USED:
9181 case DT_INIT_ARRAY:
9182 case DT_FINI_ARRAY:
9183 if (do_dynamic)
9184 {
d79b3d50
NC		 9185 if (entry->d_tag == DT_USED
9186 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9187 {
2cf0635d 9188 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9189
b34976b6 9190 if (*name)
252b5132
RH		 9191 {
9192 printf (_("Not needed object: [%s]\n"), name);
9193 break;
9194 }
9195 }
103f02d3 9196
f7a99963
NC		 9197 print_vma (entry->d_un.d_val, PREFIX_HEX);
9198 putchar ('\n');
252b5132
RH		 9199 }
9200 break;
9201
9202 case DT_BIND_NOW:
9203 /* The value of this entry is ignored. */
35b1837e
AM		 9204 if (do_dynamic)
9205 putchar ('\n');
252b5132 9206 break;
103f02d3 9207
047b2264
JJ		 9208 case DT_GNU_PRELINKED:
9209 if (do_dynamic)
9210 {
2cf0635d 9211 struct tm * tmp;
91d6fa6a 9212 time_t atime = entry->d_un.d_val;
047b2264 9213
91d6fa6a 9214 tmp = gmtime (&atime);
071436c6
NC		 9215 /* PR 17533 file: 041-1244816-0.004. */
9216 if (tmp == NULL)
5a2cbcf4
L		 9217 printf (_("<corrupt time val: %lx"),
9218 (unsigned long) atime);
071436c6
NC		 9219 else
9220 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9221 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9222 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9223
9224 }
9225 break;
9226
fdc90cb4
JJ		 9227 case DT_GNU_HASH:
9228 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9229 if (do_dynamic)
9230 {
9231 print_vma (entry->d_un.d_val, PREFIX_HEX);
9232 putchar ('\n');
9233 }
9234 break;
9235
252b5132
RH		 9236 default:
9237 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9238 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9239 entry->d_un.d_val;
9240
9241 if (do_dynamic)
9242 {
9243 switch (elf_header.e_machine)
9244 {
9245 case EM_MIPS:
4fe85591 9246 case EM_MIPS_RS3_LE:
b2d38a17 9247 dynamic_section_mips_val (entry);
252b5132 9248 break;
103f02d3 9249 case EM_PARISC:
b2d38a17 9250 dynamic_section_parisc_val (entry);
103f02d3 9251 break;
ecc51f48 9252 case EM_IA_64:
b2d38a17 9253 dynamic_section_ia64_val (entry);
ecc51f48 9254 break;
252b5132 9255 default:
f7a99963
NC		 9256 print_vma (entry->d_un.d_val, PREFIX_HEX);
9257 putchar ('\n');
252b5132
RH		 9258 }
9259 }
9260 break;
9261 }
9262 }
9263
9264 return 1;
9265}
9266
9267static char *
d3ba0551 9268get_ver_flags (unsigned int flags)
252b5132 9269{
b34976b6 9270 static char buff[32];
252b5132
RH		 9271
9272 buff[0] = 0;
9273
9274 if (flags == 0)
9275 return _("none");
9276
9277 if (flags & VER_FLG_BASE)
9278 strcat (buff, "BASE ");
9279
9280 if (flags & VER_FLG_WEAK)
9281 {
9282 if (flags & VER_FLG_BASE)
9283 strcat (buff, "| ");
9284
9285 strcat (buff, "WEAK ");
9286 }
9287
44ec90b9
RO		 9288 if (flags & VER_FLG_INFO)
9289 {
9290 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9291 strcat (buff, "| ");
9292
9293 strcat (buff, "INFO ");
9294 }
9295
9296 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9297 strcat (buff, _("| <unknown>"));
252b5132
RH		 9298
9299 return buff;
9300}
9301
9302/* Display the contents of the version sections. */
98fb390a 9303
252b5132 9304static int
2cf0635d 9305process_version_sections (FILE * file)
252b5132 9306{
2cf0635d 9307 Elf_Internal_Shdr * section;
b34976b6
AM		 9308 unsigned i;
9309 int found = 0;
252b5132
RH		 9310
9311 if (! do_version)
9312 return 1;
9313
9314 for (i = 0, section = section_headers;
9315 i < elf_header.e_shnum;
b34976b6 9316 i++, section++)
252b5132
RH		 9317 {
9318 switch (section->sh_type)
9319 {
9320 case SHT_GNU_verdef:
9321 {
2cf0635d 9322 Elf_External_Verdef * edefs;
b34976b6
AM		 9323 unsigned int idx;
9324 unsigned int cnt;
2cf0635d 9325 char * endbuf;
252b5132
RH		 9326
9327 found = 1;
9328
74e1a04b
NC		 9329 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9330 printable_section_name (section),
9331 section->sh_info);
252b5132
RH		 9332
9333 printf (_(" Addr: 0x"));
9334 printf_vma (section->sh_addr);
74e1a04b 9335 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9336 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9337 printable_section_name_from_index (section->sh_link));
252b5132 9338
3f5e193b
NC		 9339 edefs = (Elf_External_Verdef *)
9340 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9341 _("version definition section"));
a6e9f9df
AM		 9342 if (!edefs)
9343 break;
59245841 9344 endbuf = (char *) edefs + section->sh_size;
252b5132 9345
b34976b6 9346 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9347 {
2cf0635d
NC		 9348 char * vstart;
9349 Elf_External_Verdef * edef;
b34976b6 9350 Elf_Internal_Verdef ent;
2cf0635d 9351 Elf_External_Verdaux * eaux;
b34976b6
AM		 9352 Elf_Internal_Verdaux aux;
9353 int j;
9354 int isum;
103f02d3 9355
7e26601c
NC		 9356 /* Check for very large indicies. */
9357 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9358 break;
9359
252b5132 9360 vstart = ((char *) edefs) + idx;
54806181
AM		 9361 if (vstart + sizeof (*edef) > endbuf)
9362 break;
252b5132
RH		 9363
9364 edef = (Elf_External_Verdef *) vstart;
9365
9366 ent.vd_version = BYTE_GET (edef->vd_version);
9367 ent.vd_flags = BYTE_GET (edef->vd_flags);
9368 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9369 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9370 ent.vd_hash = BYTE_GET (edef->vd_hash);
9371 ent.vd_aux = BYTE_GET (edef->vd_aux);
9372 ent.vd_next = BYTE_GET (edef->vd_next);
9373
9374 printf (_(" %#06x: Rev: %d Flags: %s"),
9375 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9376
9377 printf (_(" Index: %d Cnt: %d "),
9378 ent.vd_ndx, ent.vd_cnt);
9379
dd24e3da 9380 /* Check for overflow. */
7e26601c 9381 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9382 break;
9383
252b5132
RH		 9384 vstart += ent.vd_aux;
9385
9386 eaux = (Elf_External_Verdaux *) vstart;
9387
9388 aux.vda_name = BYTE_GET (eaux->vda_name);
9389 aux.vda_next = BYTE_GET (eaux->vda_next);
9390
d79b3d50
NC		 9391 if (VALID_DYNAMIC_NAME (aux.vda_name))
9392 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9393 else
9394 printf (_("Name index: %ld\n"), aux.vda_name);
9395
9396 isum = idx + ent.vd_aux;
9397
b34976b6 9398 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9399 {
dd24e3da 9400 /* Check for overflow. */
7e26601c 9401 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9402 break;
9403
252b5132
RH		 9404 isum += aux.vda_next;
9405 vstart += aux.vda_next;
9406
9407 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9408 if (vstart + sizeof (*eaux) > endbuf)
9409 break;
252b5132
RH		 9410
9411 aux.vda_name = BYTE_GET (eaux->vda_name);
9412 aux.vda_next = BYTE_GET (eaux->vda_next);
9413
d79b3d50 9414 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9415 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9416 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9417 else
9418 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9419 isum, j, aux.vda_name);
9420 }
dd24e3da 9421
54806181
AM		 9422 if (j < ent.vd_cnt)
9423 printf (_(" Version def aux past end of section\n"));
252b5132 9424
5d921cbd
NC		 9425 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9426 if (idx + ent.vd_next <= idx)
9427 break;
9428
252b5132
RH		 9429 idx += ent.vd_next;
9430 }
dd24e3da 9431
54806181
AM		 9432 if (cnt < section->sh_info)
9433 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9434
9435 free (edefs);
9436 }
9437 break;
103f02d3 9438
252b5132
RH		 9439 case SHT_GNU_verneed:
9440 {
2cf0635d 9441 Elf_External_Verneed * eneed;
b34976b6
AM		 9442 unsigned int idx;
9443 unsigned int cnt;
2cf0635d 9444 char * endbuf;
252b5132
RH		 9445
9446 found = 1;
9447
72de5009 9448 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9449 printable_section_name (section), section->sh_info);
252b5132
RH		 9450
9451 printf (_(" Addr: 0x"));
9452 printf_vma (section->sh_addr);
72de5009 9453 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9454 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9455 printable_section_name_from_index (section->sh_link));
252b5132 9456
3f5e193b
NC		 9457 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9458 section->sh_offset, 1,
9459 section->sh_size,
9cf03b7e 9460 _("Version Needs section"));
a6e9f9df
AM		 9461 if (!eneed)
9462 break;
59245841 9463 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9464
9465 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9466 {
2cf0635d 9467 Elf_External_Verneed * entry;
b34976b6
AM		 9468 Elf_Internal_Verneed ent;
9469 int j;
9470 int isum;
2cf0635d 9471 char * vstart;
252b5132 9472
7e26601c 9473 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9474 break;
9475
252b5132 9476 vstart = ((char *) eneed) + idx;
54806181
AM		 9477 if (vstart + sizeof (*entry) > endbuf)
9478 break;
252b5132
RH		 9479
9480 entry = (Elf_External_Verneed *) vstart;
9481
9482 ent.vn_version = BYTE_GET (entry->vn_version);
9483 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9484 ent.vn_file = BYTE_GET (entry->vn_file);
9485 ent.vn_aux = BYTE_GET (entry->vn_aux);
9486 ent.vn_next = BYTE_GET (entry->vn_next);
9487
9488 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9489
d79b3d50
NC		 9490 if (VALID_DYNAMIC_NAME (ent.vn_file))
9491 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9492 else
9493 printf (_(" File: %lx"), ent.vn_file);
9494
9495 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9496
dd24e3da 9497 /* Check for overflow. */
7e26601c 9498 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9499 break;
252b5132
RH		 9500 vstart += ent.vn_aux;
9501
9502 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9503 {
2cf0635d 9504 Elf_External_Vernaux * eaux;
b34976b6 9505 Elf_Internal_Vernaux aux;
252b5132 9506
54806181
AM		 9507 if (vstart + sizeof (*eaux) > endbuf)
9508 break;
252b5132
RH		 9509 eaux = (Elf_External_Vernaux *) vstart;
9510
9511 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9512 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9513 aux.vna_other = BYTE_GET (eaux->vna_other);
9514 aux.vna_name = BYTE_GET (eaux->vna_name);
9515 aux.vna_next = BYTE_GET (eaux->vna_next);
9516
d79b3d50 9517 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9518 printf (_(" %#06x: Name: %s"),
d79b3d50 9519 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9520 else
ecc2063b 9521 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9522 isum, aux.vna_name);
9523
9524 printf (_(" Flags: %s Version: %d\n"),
9525 get_ver_flags (aux.vna_flags), aux.vna_other);
9526
dd24e3da 9527 /* Check for overflow. */
53774b7e
NC		 9528 if (aux.vna_next > (size_t) (endbuf - vstart)
9529 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9530 {
9531 warn (_("Invalid vna_next field of %lx\n"),
9532 aux.vna_next);
9533 j = ent.vn_cnt;
9534 break;
9535 }
252b5132
RH		 9536 isum += aux.vna_next;
9537 vstart += aux.vna_next;
9538 }
9cf03b7e 9539
54806181 9540 if (j < ent.vn_cnt)
9cf03b7e 9541 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9542
bcf83b2a 9543 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9544 {
9545 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9546 cnt = section->sh_info;
9547 break;
9548 }
252b5132
RH		 9549 idx += ent.vn_next;
9550 }
9cf03b7e 9551
54806181 9552 if (cnt < section->sh_info)
9cf03b7e 9553 warn (_("Missing Version Needs information\n"));
103f02d3 9554
252b5132
RH		 9555 free (eneed);
9556 }
9557 break;
9558
9559 case SHT_GNU_versym:
9560 {
2cf0635d 9561 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9562 size_t total;
9563 unsigned int cnt;
2cf0635d
NC		 9564 unsigned char * edata;
9565 unsigned short * data;
9566 char * strtab;
9567 Elf_Internal_Sym * symbols;
9568 Elf_Internal_Shdr * string_sec;
ba5cdace 9569 unsigned long num_syms;
d3ba0551 9570 long off;
252b5132 9571
4fbb74a6 9572 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9573 break;
9574
4fbb74a6 9575 link_section = section_headers + section->sh_link;
08d8fa11 9576 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9577
4fbb74a6 9578 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9579 break;
9580
252b5132
RH		 9581 found = 1;
9582
ba5cdace 9583 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9584 if (symbols == NULL)
9585 break;
252b5132 9586
4fbb74a6 9587 string_sec = section_headers + link_section->sh_link;
252b5132 9588
3f5e193b
NC		 9589 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9590 string_sec->sh_size,
9591 _("version string table"));
a6e9f9df 9592 if (!strtab)
0429c154
MS		 9593 {
9594 free (symbols);
9595 break;
9596 }
252b5132 9597
8b73c356
NC		 9598 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9599 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9600
9601 printf (_(" Addr: "));
9602 printf_vma (section->sh_addr);
72de5009 9603 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9604 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9605 printable_section_name (link_section));
252b5132 9606
d3ba0551
AM		 9607 off = offset_from_vma (file,
9608 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9609 total * sizeof (short));
3f5e193b
NC		 9610 edata = (unsigned char *) get_data (NULL, file, off, total,
9611 sizeof (short),
9612 _("version symbol data"));
a6e9f9df
AM		 9613 if (!edata)
9614 {
9615 free (strtab);
0429c154 9616 free (symbols);
a6e9f9df
AM		 9617 break;
9618 }
252b5132 9619
3f5e193b 9620 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9621
9622 for (cnt = total; cnt --;)
b34976b6
AM		 9623 data[cnt] = byte_get (edata + cnt * sizeof (short),
9624 sizeof (short));
252b5132
RH		 9625
9626 free (edata);
9627
9628 for (cnt = 0; cnt < total; cnt += 4)
9629 {
9630 int j, nn;
00d93f34 9631 int check_def, check_need;
2cf0635d 9632 char * name;
252b5132
RH		 9633
9634 printf (" %03x:", cnt);
9635
9636 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9637 switch (data[cnt + j])
252b5132
RH		 9638 {
9639 case 0:
9640 fputs (_(" 0 (*local*) "), stdout);
9641 break;
9642
9643 case 1:
9644 fputs (_(" 1 (*global*) "), stdout);
9645 break;
9646
9647 default:
c244d050
NC		 9648 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9649 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9650
dd24e3da 9651 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9652 array, break to avoid an out-of-bounds read. */
9653 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9654 {
9655 warn (_("invalid index into symbol array\n"));
9656 break;
9657 }
9658
00d93f34
JJ		 9659 check_def = 1;
9660 check_need = 1;
4fbb74a6
AM		 9661 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9662 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9663 != SHT_NOBITS)
252b5132 9664 {
b34976b6 9665 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9666 check_def = 0;
9667 else
9668 check_need = 0;
252b5132 9669 }
00d93f34
JJ		 9670
9671 if (check_need
b34976b6 9672 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9673 {
b34976b6
AM		 9674 Elf_Internal_Verneed ivn;
9675 unsigned long offset;
252b5132 9676
d93f0186
NC		 9677 offset = offset_from_vma
9678 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9679 sizeof (Elf_External_Verneed));
252b5132 9680
b34976b6 9681 do
252b5132 9682 {
b34976b6
AM		 9683 Elf_Internal_Vernaux ivna;
9684 Elf_External_Verneed evn;
9685 Elf_External_Vernaux evna;
9686 unsigned long a_off;
252b5132 9687
59245841
NC		 9688 if (get_data (&evn, file, offset, sizeof (evn), 1,
9689 _("version need")) == NULL)
9690 break;
0b4362b0 9691
252b5132
RH		 9692 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9693 ivn.vn_next = BYTE_GET (evn.vn_next);
9694
9695 a_off = offset + ivn.vn_aux;
9696
9697 do
9698 {
59245841
NC		 9699 if (get_data (&evna, file, a_off, sizeof (evna),
9700 1, _("version need aux (2)")) == NULL)
9701 {
9702 ivna.vna_next = 0;
9703 ivna.vna_other = 0;
9704 }
9705 else
9706 {
9707 ivna.vna_next = BYTE_GET (evna.vna_next);
9708 ivna.vna_other = BYTE_GET (evna.vna_other);
9709 }
252b5132
RH		 9710
9711 a_off += ivna.vna_next;
9712 }
b34976b6 9713 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9714 && ivna.vna_next != 0);
9715
b34976b6 9716 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9717 {
9718 ivna.vna_name = BYTE_GET (evna.vna_name);
9719
54806181
AM		 9720 if (ivna.vna_name >= string_sec->sh_size)
9721 name = _("*invalid*");
9722 else
9723 name = strtab + ivna.vna_name;
252b5132 9724 nn += printf ("(%s%-*s",
16062207
ILT		 9725 name,
9726 12 - (int) strlen (name),
252b5132 9727 ")");
00d93f34 9728 check_def = 0;
252b5132
RH		 9729 break;
9730 }
9731
9732 offset += ivn.vn_next;
9733 }
9734 while (ivn.vn_next);
9735 }
00d93f34 9736
b34976b6
AM		 9737 if (check_def && data[cnt + j] != 0x8001
9738 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9739 {
b34976b6
AM		 9740 Elf_Internal_Verdef ivd;
9741 Elf_External_Verdef evd;
9742 unsigned long offset;
252b5132 9743
d93f0186
NC		 9744 offset = offset_from_vma
9745 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9746 sizeof evd);
252b5132
RH		 9747
9748 do
9749 {
59245841
NC		 9750 if (get_data (&evd, file, offset, sizeof (evd), 1,
9751 _("version def")) == NULL)
9752 {
9753 ivd.vd_next = 0;
3102e897
NC		 9754 /* PR 17531: file: 046-1082287-0.004. */
9755 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9756 break;
59245841
NC		 9757 }
9758 else
9759 {
9760 ivd.vd_next = BYTE_GET (evd.vd_next);
9761 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9762 }
252b5132
RH		 9763
9764 offset += ivd.vd_next;
9765 }
c244d050 9766 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9767 && ivd.vd_next != 0);
9768
c244d050 9769 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9770 {
b34976b6
AM		 9771 Elf_External_Verdaux evda;
9772 Elf_Internal_Verdaux ivda;
252b5132
RH		 9773
9774 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9775
59245841
NC		 9776 if (get_data (&evda, file,
9777 offset - ivd.vd_next + ivd.vd_aux,
9778 sizeof (evda), 1,
9779 _("version def aux")) == NULL)
9780 break;
252b5132
RH		 9781
9782 ivda.vda_name = BYTE_GET (evda.vda_name);
9783
54806181
AM		 9784 if (ivda.vda_name >= string_sec->sh_size)
9785 name = _("*invalid*");
9786 else
9787 name = strtab + ivda.vda_name;
252b5132 9788 nn += printf ("(%s%-*s",
16062207
ILT		 9789 name,
9790 12 - (int) strlen (name),
252b5132
RH		 9791 ")");
9792 }
9793 }
9794
9795 if (nn < 18)
9796 printf ("%*c", 18 - nn, ' ');
9797 }
9798
9799 putchar ('\n');
9800 }
9801
9802 free (data);
9803 free (strtab);
9804 free (symbols);
9805 }
9806 break;
103f02d3 9807
252b5132
RH		 9808 default:
9809 break;
9810 }
9811 }
9812
9813 if (! found)
9814 printf (_("\nNo version information found in this file.\n"));
9815
9816 return 1;
9817}
9818
d1133906 9819static const char *
d3ba0551 9820get_symbol_binding (unsigned int binding)
252b5132 9821{
b34976b6 9822 static char buff[32];
252b5132
RH		 9823
9824 switch (binding)
9825 {
b34976b6
AM		 9826 case STB_LOCAL: return "LOCAL";
9827 case STB_GLOBAL: return "GLOBAL";
9828 case STB_WEAK: return "WEAK";
252b5132
RH		 9829 default:
9830 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9831 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9832 binding);
252b5132 9833 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9834 {
9835 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9836 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9837 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9838 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9839 return "UNIQUE";
9840 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9841 }
252b5132 9842 else
e9e44622 9843 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9844 return buff;
9845 }
9846}
9847
d1133906 9848static const char *
d3ba0551 9849get_symbol_type (unsigned int type)
252b5132 9850{
b34976b6 9851 static char buff[32];
252b5132
RH		 9852
9853 switch (type)
9854 {
b34976b6
AM		 9855 case STT_NOTYPE: return "NOTYPE";
9856 case STT_OBJECT: return "OBJECT";
9857 case STT_FUNC: return "FUNC";
9858 case STT_SECTION: return "SECTION";
9859 case STT_FILE: return "FILE";
9860 case STT_COMMON: return "COMMON";
9861 case STT_TLS: return "TLS";
15ab5209
DB		 9862 case STT_RELC: return "RELC";
9863 case STT_SRELC: return "SRELC";
252b5132
RH		 9864 default:
9865 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9866 {
3510a7b8
NC		 9867 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9868 return "THUMB_FUNC";
103f02d3 9869
351b4b40 9870 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9871 return "REGISTER";
9872
9873 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9874 return "PARISC_MILLI";
9875
e9e44622 9876 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9877 }
252b5132 9878 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9879 {
9880 if (elf_header.e_machine == EM_PARISC)
9881 {
9882 if (type == STT_HP_OPAQUE)
9883 return "HP_OPAQUE";
9884 if (type == STT_HP_STUB)
9885 return "HP_STUB";
9886 }
9887
d8045f23 9888 if (type == STT_GNU_IFUNC
9c55345c 9889 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9890 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9891 /* GNU is still using the default value 0. */
d8045f23
NC		 9892 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9893 return "IFUNC";
9894
e9e44622 9895 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9896 }
252b5132 9897 else
e9e44622 9898 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9899 return buff;
9900 }
9901}
9902
d1133906 9903static const char *
d3ba0551 9904get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9905{
9906 switch (visibility)
9907 {
b34976b6
AM		 9908 case STV_DEFAULT: return "DEFAULT";
9909 case STV_INTERNAL: return "INTERNAL";
9910 case STV_HIDDEN: return "HIDDEN";
d1133906 9911 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 9912 default:
9913 error (_("Unrecognized visibility value: %u"), visibility);
9914 return _("<unknown>");
d1133906
NC		 9915 }
9916}
9917
5e2b0d47
NC		 9918static const char *
9919get_mips_symbol_other (unsigned int other)
9920{
9921 switch (other)
9922 {
df58fc94
RS		 9923 case STO_OPTIONAL:
9924 return "OPTIONAL";
9925 case STO_MIPS_PLT:
9926 return "MIPS PLT";
9927 case STO_MIPS_PIC:
9928 return "MIPS PIC";
9929 case STO_MICROMIPS:
9930 return "MICROMIPS";
9931 case STO_MICROMIPS | STO_MIPS_PIC:
9932 return "MICROMIPS, MIPS PIC";
9933 case STO_MIPS16:
9934 return "MIPS16";
9935 default:
9936 return NULL;
5e2b0d47
NC		 9937 }
9938}
9939
28f997cf
TG		 9940static const char *
9941get_ia64_symbol_other (unsigned int other)
9942{
9943 if (is_ia64_vms ())
9944 {
9945 static char res[32];
9946
9947 res[0] = 0;
9948
9949 /* Function types is for images and .STB files only. */
9950 switch (elf_header.e_type)
9951 {
9952 case ET_DYN:
9953 case ET_EXEC:
9954 switch (VMS_ST_FUNC_TYPE (other))
9955 {
9956 case VMS_SFT_CODE_ADDR:
9957 strcat (res, " CA");
9958 break;
9959 case VMS_SFT_SYMV_IDX:
9960 strcat (res, " VEC");
9961 break;
9962 case VMS_SFT_FD:
9963 strcat (res, " FD");
9964 break;
9965 case VMS_SFT_RESERVE:
9966 strcat (res, " RSV");
9967 break;
9968 default:
bee0ee85
NC		 9969 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9970 VMS_ST_FUNC_TYPE (other));
9971 strcat (res, " <unknown>");
9972 break;
28f997cf
TG		 9973 }
9974 break;
9975 default:
9976 break;
9977 }
9978 switch (VMS_ST_LINKAGE (other))
9979 {
9980 case VMS_STL_IGNORE:
9981 strcat (res, " IGN");
9982 break;
9983 case VMS_STL_RESERVE:
9984 strcat (res, " RSV");
9985 break;
9986 case VMS_STL_STD:
9987 strcat (res, " STD");
9988 break;
9989 case VMS_STL_LNK:
9990 strcat (res, " LNK");
9991 break;
9992 default:
bee0ee85
NC		 9993 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9994 VMS_ST_LINKAGE (other));
9995 strcat (res, " <unknown>");
9996 break;
28f997cf
TG		 9997 }
9998
9999 if (res[0] != 0)
10000 return res + 1;
10001 else
10002 return res;
10003 }
10004 return NULL;
10005}
10006
6911b7dc
AM		 10007static const char *
10008get_ppc64_symbol_other (unsigned int other)
10009{
10010 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10011 {
10012 static char buf[32];
10013 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10014 PPC64_LOCAL_ENTRY_OFFSET (other));
10015 return buf;
10016 }
10017 return NULL;
10018}
10019
5e2b0d47
NC		 10020static const char *
10021get_symbol_other (unsigned int other)
10022{
10023 const char * result = NULL;
10024 static char buff [32];
10025
10026 if (other == 0)
10027 return "";
10028
10029 switch (elf_header.e_machine)
10030 {
10031 case EM_MIPS:
10032 result = get_mips_symbol_other (other);
28f997cf
TG		 10033 break;
10034 case EM_IA_64:
10035 result = get_ia64_symbol_other (other);
10036 break;
6911b7dc
AM		 10037 case EM_PPC64:
10038 result = get_ppc64_symbol_other (other);
10039 break;
5e2b0d47
NC		 10040 default:
10041 break;
10042 }
10043
10044 if (result)
10045 return result;
10046
10047 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10048 return buff;
10049}
10050
d1133906 10051static const char *
d3ba0551 10052get_symbol_index_type (unsigned int type)
252b5132 10053{
b34976b6 10054 static char buff[32];
5cf1065c 10055
252b5132
RH		 10056 switch (type)
10057 {
b34976b6
AM		 10058 case SHN_UNDEF: return "UND";
10059 case SHN_ABS: return "ABS";
10060 case SHN_COMMON: return "COM";
252b5132 10061 default:
9ce701e2
L		 10062 if (type == SHN_IA_64_ANSI_COMMON
10063 && elf_header.e_machine == EM_IA_64
10064 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10065 return "ANSI_COM";
8a9036a4 10066 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10067 || elf_header.e_machine == EM_L1OM
10068 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10069 && type == SHN_X86_64_LCOMMON)
10070 return "LARGE_COM";
ac145307
BS		 10071 else if ((type == SHN_MIPS_SCOMMON
10072 && elf_header.e_machine == EM_MIPS)
10073 || (type == SHN_TIC6X_SCOMMON
10074 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10075 return "SCOM";
10076 else if (type == SHN_MIPS_SUNDEFINED
10077 && elf_header.e_machine == EM_MIPS)
10078 return "SUND";
9ce701e2 10079 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10080 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10081 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10082 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10083 else if (type >= SHN_LORESERVE)
10084 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10085 else if (type >= elf_header.e_shnum)
e0a31db1 10086 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10087 else
232e7cb8 10088 sprintf (buff, "%3d", type);
5cf1065c 10089 break;
252b5132 10090 }
5cf1065c
NC		 10091
10092 return buff;
252b5132
RH		 10093}
10094
66543521 10095static bfd_vma *
57028622 10096get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10097{
2cf0635d
NC		 10098 unsigned char * e_data;
10099 bfd_vma * i_data;
252b5132 10100
57028622
NC		 10101 /* If the size_t type is smaller than the bfd_size_type, eg because
10102 you are building a 32-bit tool on a 64-bit host, then make sure
10103 that when (number) is cast to (size_t) no information is lost. */
10104 if (sizeof (size_t) < sizeof (bfd_size_type)
10105 && (bfd_size_type) ((size_t) number) != number)
10106 {
10107 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10108 (unsigned long long) number, ent_size);
10109 return NULL;
10110 }
10111
3102e897
NC		 10112 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10113 attempting to allocate memory when the read is bound to fail. */
10114 if (ent_size * number > current_file_size)
10115 {
57028622
NC		 10116 error (_("Invalid number of dynamic entries: %llu\n"),
10117 (unsigned long long) number);
3102e897
NC		 10118 return NULL;
10119 }
10120
57028622 10121 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10122 if (e_data == NULL)
10123 {
57028622
NC		 10124 error (_("Out of memory reading %llu dynamic entries\n"),
10125 (unsigned long long) number);
252b5132
RH		 10126 return NULL;
10127 }
10128
57028622 10129 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10130 {
57028622
NC		 10131 error (_("Unable to read in %llu bytes of dynamic data\n"),
10132 (unsigned long long) (number * ent_size));
3102e897 10133 free (e_data);
252b5132
RH		 10134 return NULL;
10135 }
10136
57028622 10137 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10138 if (i_data == NULL)
10139 {
57028622
NC		 10140 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10141 (unsigned long long) number);
252b5132
RH		 10142 free (e_data);
10143 return NULL;
10144 }
10145
10146 while (number--)
66543521 10147 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10148
10149 free (e_data);
10150
10151 return i_data;
10152}
10153
6bd1a22c
L		 10154static void
10155print_dynamic_symbol (bfd_vma si, unsigned long hn)
10156{
2cf0635d 10157 Elf_Internal_Sym * psym;
6bd1a22c
L		 10158 int n;
10159
6bd1a22c
L		 10160 n = print_vma (si, DEC_5);
10161 if (n < 5)
0b4362b0 10162 fputs (&" "[n], stdout);
6bd1a22c 10163 printf (" %3lu: ", hn);
e0a31db1
NC		 10164
10165 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10166 {
3102e897
NC		 10167 printf (_("<No info available for dynamic symbol number %lu>\n"),
10168 (unsigned long) si);
e0a31db1
NC		 10169 return;
10170 }
10171
10172 psym = dynamic_symbols + si;
6bd1a22c
L		 10173 print_vma (psym->st_value, LONG_HEX);
10174 putchar (' ');
10175 print_vma (psym->st_size, DEC_5);
10176
f4be36b3
AM		 10177 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10178 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10179 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10180 /* Check to see if any other bits in the st_other field are set.
10181 Note - displaying this information disrupts the layout of the
10182 table being generated, but for the moment this case is very
10183 rare. */
10184 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10185 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10186 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10187 if (VALID_DYNAMIC_NAME (psym->st_name))
10188 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10189 else
2b692964 10190 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10191 putchar ('\n');
10192}
10193
bb4d2ac2
L		 10194static const char *
10195get_symbol_version_string (FILE *file, int is_dynsym,
10196 const char *strtab,
10197 unsigned long int strtab_size,
10198 unsigned int si, Elf_Internal_Sym *psym,
10199 enum versioned_symbol_info *sym_info,
10200 unsigned short *vna_other)
10201{
10202 const char *version_string = NULL;
10203
10204 if (is_dynsym
10205 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10206 {
10207 unsigned char data[2];
10208 unsigned short vers_data;
10209 unsigned long offset;
10210 int is_nobits;
10211 int check_def;
10212
10213 offset = offset_from_vma
10214 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10215 sizeof data + si * sizeof (vers_data));
10216
10217 if (get_data (&data, file, offset + si * sizeof (vers_data),
10218 sizeof (data), 1, _("version data")) == NULL)
10219 return NULL;
10220
10221 vers_data = byte_get (data, 2);
10222
53774b7e
NC		 10223 is_nobits = (section_headers != NULL
10224 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10225 && section_headers[psym->st_shndx].sh_type
10226 == SHT_NOBITS);
10227
10228 check_def = (psym->st_shndx != SHN_UNDEF);
10229
10230 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10231 {
10232 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10233 && (is_nobits || ! check_def))
10234 {
10235 Elf_External_Verneed evn;
10236 Elf_Internal_Verneed ivn;
10237 Elf_Internal_Vernaux ivna;
10238
10239 /* We must test both. */
10240 offset = offset_from_vma
10241 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10242 sizeof evn);
10243
10244 do
10245 {
10246 unsigned long vna_off;
10247
10248 if (get_data (&evn, file, offset, sizeof (evn), 1,
10249 _("version need")) == NULL)
10250 {
10251 ivna.vna_next = 0;
10252 ivna.vna_other = 0;
10253 ivna.vna_name = 0;
10254 break;
10255 }
10256
10257 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10258 ivn.vn_next = BYTE_GET (evn.vn_next);
10259
10260 vna_off = offset + ivn.vn_aux;
10261
10262 do
10263 {
10264 Elf_External_Vernaux evna;
10265
10266 if (get_data (&evna, file, vna_off,
10267 sizeof (evna), 1,
10268 _("version need aux (3)")) == NULL)
10269 {
10270 ivna.vna_next = 0;
10271 ivna.vna_other = 0;
10272 ivna.vna_name = 0;
10273 }
10274 else
10275 {
10276 ivna.vna_other = BYTE_GET (evna.vna_other);
10277 ivna.vna_next = BYTE_GET (evna.vna_next);
10278 ivna.vna_name = BYTE_GET (evna.vna_name);
10279 }
10280
10281 vna_off += ivna.vna_next;
10282 }
10283 while (ivna.vna_other != vers_data
10284 && ivna.vna_next != 0);
10285
10286 if (ivna.vna_other == vers_data)
10287 break;
10288
10289 offset += ivn.vn_next;
10290 }
10291 while (ivn.vn_next != 0);
10292
10293 if (ivna.vna_other == vers_data)
10294 {
10295 *sym_info = symbol_undefined;
10296 *vna_other = ivna.vna_other;
10297 version_string = (ivna.vna_name < strtab_size
10298 ? strtab + ivna.vna_name
10299 : _("<corrupt>"));
10300 check_def = 0;
10301 }
10302 else if (! is_nobits)
10303 error (_("bad dynamic symbol\n"));
10304 else
10305 check_def = 1;
10306 }
10307
10308 if (check_def)
10309 {
10310 if (vers_data != 0x8001
10311 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10312 {
10313 Elf_Internal_Verdef ivd;
10314 Elf_Internal_Verdaux ivda;
10315 Elf_External_Verdaux evda;
10316 unsigned long off;
10317
10318 off = offset_from_vma
10319 (file,
10320 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10321 sizeof (Elf_External_Verdef));
10322
10323 do
10324 {
10325 Elf_External_Verdef evd;
10326
10327 if (get_data (&evd, file, off, sizeof (evd),
10328 1, _("version def")) == NULL)
10329 {
10330 ivd.vd_ndx = 0;
10331 ivd.vd_aux = 0;
10332 ivd.vd_next = 0;
10333 }
10334 else
10335 {
10336 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10337 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10338 ivd.vd_next = BYTE_GET (evd.vd_next);
10339 }
10340
10341 off += ivd.vd_next;
10342 }
10343 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10344 && ivd.vd_next != 0);
10345
10346 off -= ivd.vd_next;
10347 off += ivd.vd_aux;
10348
10349 if (get_data (&evda, file, off, sizeof (evda),
10350 1, _("version def aux")) == NULL)
10351 return version_string;
10352
10353 ivda.vda_name = BYTE_GET (evda.vda_name);
10354
10355 if (psym->st_name != ivda.vda_name)
10356 {
10357 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10358 ? symbol_hidden : symbol_public);
10359 version_string = (ivda.vda_name < strtab_size
10360 ? strtab + ivda.vda_name
10361 : _("<corrupt>"));
10362 }
10363 }
10364 }
10365 }
10366 }
10367 return version_string;
10368}
10369
e3c8793a 10370/* Dump the symbol table. */
252b5132 10371static int
2cf0635d 10372process_symbol_table (FILE * file)
252b5132 10373{
2cf0635d 10374 Elf_Internal_Shdr * section;
8b73c356
NC		 10375 bfd_size_type nbuckets = 0;
10376 bfd_size_type nchains = 0;
2cf0635d
NC		 10377 bfd_vma * buckets = NULL;
10378 bfd_vma * chains = NULL;
fdc90cb4 10379 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10380 bfd_vma * gnubuckets = NULL;
10381 bfd_vma * gnuchains = NULL;
6bd1a22c 10382 bfd_vma gnusymidx = 0;
071436c6 10383 bfd_size_type ngnuchains = 0;
252b5132 10384
2c610e4b 10385 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10386 return 1;
10387
6bd1a22c
L		 10388 if (dynamic_info[DT_HASH]
10389 && (do_histogram
2c610e4b
L		 10390 || (do_using_dynamic
10391 && !do_dyn_syms
10392 && dynamic_strings != NULL)))
252b5132 10393 {
66543521
AM		 10394 unsigned char nb[8];
10395 unsigned char nc[8];
8b73c356 10396 unsigned int hash_ent_size = 4;
66543521
AM		 10397
10398 if ((elf_header.e_machine == EM_ALPHA
10399 || elf_header.e_machine == EM_S390
10400 || elf_header.e_machine == EM_S390_OLD)
10401 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10402 hash_ent_size = 8;
10403
fb52b2f4
NC		 10404 if (fseek (file,
10405 (archive_file_offset
10406 + offset_from_vma (file, dynamic_info[DT_HASH],
10407 sizeof nb + sizeof nc)),
d93f0186 10408 SEEK_SET))
252b5132 10409 {
591a748a 10410 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10411 goto no_hash;
252b5132
RH		 10412 }
10413
66543521 10414 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10415 {
10416 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10417 goto no_hash;
252b5132
RH		 10418 }
10419
66543521 10420 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10421 {
10422 error (_("Failed to read in number of chains\n"));
d3a44ec6 10423 goto no_hash;
252b5132
RH		 10424 }
10425
66543521
AM		 10426 nbuckets = byte_get (nb, hash_ent_size);
10427 nchains = byte_get (nc, hash_ent_size);
252b5132 10428
66543521
AM		 10429 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10430 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10431
d3a44ec6 10432 no_hash:
252b5132 10433 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10434 {
10435 if (do_using_dynamic)
10436 return 0;
10437 free (buckets);
10438 free (chains);
10439 buckets = NULL;
10440 chains = NULL;
10441 nbuckets = 0;
10442 nchains = 0;
10443 }
252b5132
RH		 10444 }
10445
6bd1a22c
L		 10446 if (dynamic_info_DT_GNU_HASH
10447 && (do_histogram
2c610e4b
L		 10448 || (do_using_dynamic
10449 && !do_dyn_syms
10450 && dynamic_strings != NULL)))
252b5132 10451 {
6bd1a22c
L		 10452 unsigned char nb[16];
10453 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10454 bfd_vma buckets_vma;
10455
10456 if (fseek (file,
10457 (archive_file_offset
10458 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10459 sizeof nb)),
10460 SEEK_SET))
10461 {
10462 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10463 goto no_gnu_hash;
6bd1a22c 10464 }
252b5132 10465
6bd1a22c
L		 10466 if (fread (nb, 16, 1, file) != 1)
10467 {
10468 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10469 goto no_gnu_hash;
6bd1a22c
L		 10470 }
10471
10472 ngnubuckets = byte_get (nb, 4);
10473 gnusymidx = byte_get (nb + 4, 4);
10474 bitmaskwords = byte_get (nb + 8, 4);
10475 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10476 if (is_32bit_elf)
6bd1a22c 10477 buckets_vma += bitmaskwords * 4;
f7a99963 10478 else
6bd1a22c 10479 buckets_vma += bitmaskwords * 8;
252b5132 10480
6bd1a22c
L		 10481 if (fseek (file,
10482 (archive_file_offset
10483 + offset_from_vma (file, buckets_vma, 4)),
10484 SEEK_SET))
252b5132 10485 {
6bd1a22c 10486 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10487 goto no_gnu_hash;
6bd1a22c
L		 10488 }
10489
10490 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10491
6bd1a22c 10492 if (gnubuckets == NULL)
d3a44ec6 10493 goto no_gnu_hash;
6bd1a22c
L		 10494
10495 for (i = 0; i < ngnubuckets; i++)
10496 if (gnubuckets[i] != 0)
10497 {
10498 if (gnubuckets[i] < gnusymidx)
10499 return 0;
10500
10501 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10502 maxchain = gnubuckets[i];
10503 }
10504
10505 if (maxchain == 0xffffffff)
d3a44ec6 10506 goto no_gnu_hash;
6bd1a22c
L		 10507
10508 maxchain -= gnusymidx;
10509
10510 if (fseek (file,
10511 (archive_file_offset
10512 + offset_from_vma (file, buckets_vma
10513 + 4 * (ngnubuckets + maxchain), 4)),
10514 SEEK_SET))
10515 {
10516 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10517 goto no_gnu_hash;
6bd1a22c
L		 10518 }
10519
10520 do
10521 {
10522 if (fread (nb, 4, 1, file) != 1)
252b5132 10523 {
6bd1a22c 10524 error (_("Failed to determine last chain length\n"));
d3a44ec6 10525 goto no_gnu_hash;
6bd1a22c 10526 }
252b5132 10527
6bd1a22c 10528 if (maxchain + 1 == 0)
d3a44ec6 10529 goto no_gnu_hash;
252b5132 10530
6bd1a22c
L		 10531 ++maxchain;
10532 }
10533 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10534
6bd1a22c
L		 10535 if (fseek (file,
10536 (archive_file_offset
10537 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10538 SEEK_SET))
10539 {
10540 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10541 goto no_gnu_hash;
6bd1a22c
L		 10542 }
10543
10544 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10545 ngnuchains = maxchain;
6bd1a22c 10546
d3a44ec6 10547 no_gnu_hash:
6bd1a22c 10548 if (gnuchains == NULL)
d3a44ec6
JJ		 10549 {
10550 free (gnubuckets);
d3a44ec6
JJ		 10551 gnubuckets = NULL;
10552 ngnubuckets = 0;
f64fddf1
NC		 10553 if (do_using_dynamic)
10554 return 0;
d3a44ec6 10555 }
6bd1a22c
L		 10556 }
10557
10558 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10559 && do_syms
10560 && do_using_dynamic
3102e897
NC		 10561 && dynamic_strings != NULL
10562 && dynamic_symbols != NULL)
6bd1a22c
L		 10563 {
10564 unsigned long hn;
10565
10566 if (dynamic_info[DT_HASH])
10567 {
10568 bfd_vma si;
10569
10570 printf (_("\nSymbol table for image:\n"));
10571 if (is_32bit_elf)
10572 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10573 else
10574 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10575
10576 for (hn = 0; hn < nbuckets; hn++)
10577 {
10578 if (! buckets[hn])
10579 continue;
10580
10581 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10582 print_dynamic_symbol (si, hn);
252b5132
RH		 10583 }
10584 }
6bd1a22c
L		 10585
10586 if (dynamic_info_DT_GNU_HASH)
10587 {
10588 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10589 if (is_32bit_elf)
10590 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10591 else
10592 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10593
10594 for (hn = 0; hn < ngnubuckets; ++hn)
10595 if (gnubuckets[hn] != 0)
10596 {
10597 bfd_vma si = gnubuckets[hn];
10598 bfd_vma off = si - gnusymidx;
10599
10600 do
10601 {
10602 print_dynamic_symbol (si, hn);
10603 si++;
10604 }
071436c6 10605 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10606 }
10607 }
252b5132 10608 }
8b73c356
NC		 10609 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10610 && section_headers != NULL)
252b5132 10611 {
b34976b6 10612 unsigned int i;
252b5132
RH		 10613
10614 for (i = 0, section = section_headers;
10615 i < elf_header.e_shnum;
10616 i++, section++)
10617 {
b34976b6 10618 unsigned int si;
2cf0635d 10619 char * strtab = NULL;
c256ffe7 10620 unsigned long int strtab_size = 0;
2cf0635d
NC		 10621 Elf_Internal_Sym * symtab;
10622 Elf_Internal_Sym * psym;
ba5cdace 10623 unsigned long num_syms;
252b5132 10624
2c610e4b
L		 10625 if ((section->sh_type != SHT_SYMTAB
10626 && section->sh_type != SHT_DYNSYM)
10627 || (!do_syms
10628 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10629 continue;
10630
dd24e3da
NC		 10631 if (section->sh_entsize == 0)
10632 {
10633 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10634 printable_section_name (section));
dd24e3da
NC		 10635 continue;
10636 }
10637
252b5132 10638 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10639 printable_section_name (section),
252b5132 10640 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10641
f7a99963 10642 if (is_32bit_elf)
ca47b30c 10643 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10644 else
ca47b30c 10645 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10646
ba5cdace 10647 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10648 if (symtab == NULL)
10649 continue;
10650
10651 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10652 {
10653 strtab = string_table;
10654 strtab_size = string_table_length;
10655 }
4fbb74a6 10656 else if (section->sh_link < elf_header.e_shnum)
252b5132 10657 {
2cf0635d 10658 Elf_Internal_Shdr * string_sec;
252b5132 10659
4fbb74a6 10660 string_sec = section_headers + section->sh_link;
252b5132 10661
3f5e193b
NC		 10662 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10663 1, string_sec->sh_size,
10664 _("string table"));
c256ffe7 10665 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10666 }
10667
ba5cdace 10668 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10669 {
bb4d2ac2
L		 10670 const char *version_string;
10671 enum versioned_symbol_info sym_info;
10672 unsigned short vna_other;
10673
5e220199 10674 printf ("%6d: ", si);
f7a99963
NC		 10675 print_vma (psym->st_value, LONG_HEX);
10676 putchar (' ');
10677 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10678 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10679 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10680 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10681 /* Check to see if any other bits in the st_other field are set.
10682 Note - displaying this information disrupts the layout of the
10683 table being generated, but for the moment this case is very rare. */
10684 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10685 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10686 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10687 print_symbol (25, psym->st_name < strtab_size
2b692964 10688 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10689
bb4d2ac2
L		 10690 version_string
10691 = get_symbol_version_string (file,
10692 section->sh_type == SHT_DYNSYM,
10693 strtab, strtab_size, si,
10694 psym, &sym_info, &vna_other);
10695 if (version_string)
252b5132 10696 {
bb4d2ac2
L		 10697 if (sym_info == symbol_undefined)
10698 printf ("@%s (%d)", version_string, vna_other);
10699 else
10700 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10701 version_string);
252b5132
RH		 10702 }
10703
10704 putchar ('\n');
10705 }
10706
10707 free (symtab);
10708 if (strtab != string_table)
10709 free (strtab);
10710 }
10711 }
10712 else if (do_syms)
10713 printf
10714 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10715
10716 if (do_histogram && buckets != NULL)
10717 {
2cf0635d
NC		 10718 unsigned long * lengths;
10719 unsigned long * counts;
66543521
AM		 10720 unsigned long hn;
10721 bfd_vma si;
10722 unsigned long maxlength = 0;
10723 unsigned long nzero_counts = 0;
10724 unsigned long nsyms = 0;
252b5132 10725
66543521
AM		 10726 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10727 (unsigned long) nbuckets);
252b5132 10728
3f5e193b 10729 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10730 if (lengths == NULL)
10731 {
8b73c356 10732 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10733 return 0;
10734 }
8b73c356
NC		 10735
10736 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10737 for (hn = 0; hn < nbuckets; ++hn)
10738 {
57028622 10739 for (si = buckets[hn]; si > 0 && si < nchains && si < nbuckets; si = chains[si])
252b5132 10740 {
b34976b6 10741 ++nsyms;
252b5132 10742 if (maxlength < ++lengths[hn])
b34976b6 10743 ++maxlength;
049b0c3a
NC		 10744
10745 /* PR binutils/17531: A corrupt binary could contain broken
10746 histogram data. Do not go into an infinite loop trying
10747 to process it. */
10748 if (chains[si] == si)
10749 {
10750 error (_("histogram chain links to itself\n"));
10751 break;
10752 }
252b5132
RH		 10753 }
10754 }
10755
3f5e193b 10756 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10757 if (counts == NULL)
10758 {
b2e951ec 10759 free (lengths);
8b73c356 10760 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10761 return 0;
10762 }
10763
10764 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10765 ++counts[lengths[hn]];
252b5132 10766
103f02d3 10767 if (nbuckets > 0)
252b5132 10768 {
66543521
AM		 10769 unsigned long i;
10770 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10771 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10772 for (i = 1; i <= maxlength; ++i)
103f02d3 10773 {
66543521
AM		 10774 nzero_counts += counts[i] * i;
10775 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10776 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10777 (nzero_counts * 100.0) / nsyms);
10778 }
252b5132
RH		 10779 }
10780
10781 free (counts);
10782 free (lengths);
10783 }
10784
10785 if (buckets != NULL)
10786 {
10787 free (buckets);
10788 free (chains);
10789 }
10790
d3a44ec6 10791 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10792 {
2cf0635d
NC		 10793 unsigned long * lengths;
10794 unsigned long * counts;
fdc90cb4
JJ		 10795 unsigned long hn;
10796 unsigned long maxlength = 0;
10797 unsigned long nzero_counts = 0;
10798 unsigned long nsyms = 0;
fdc90cb4 10799
8b73c356
NC		 10800 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10801 (unsigned long) ngnubuckets);
10802
3f5e193b 10803 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10804 if (lengths == NULL)
10805 {
8b73c356 10806 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10807 return 0;
10808 }
10809
fdc90cb4
JJ		 10810 printf (_(" Length Number %% of total Coverage\n"));
10811
10812 for (hn = 0; hn < ngnubuckets; ++hn)
10813 if (gnubuckets[hn] != 0)
10814 {
10815 bfd_vma off, length = 1;
10816
6bd1a22c 10817 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10818 /* PR 17531 file: 010-77222-0.004. */
10819 off < ngnuchains && (gnuchains[off] & 1) == 0;
10820 ++off)
fdc90cb4
JJ		 10821 ++length;
10822 lengths[hn] = length;
10823 if (length > maxlength)
10824 maxlength = length;
10825 nsyms += length;
10826 }
10827
3f5e193b 10828 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10829 if (counts == NULL)
10830 {
b2e951ec 10831 free (lengths);
8b73c356 10832 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 10833 return 0;
10834 }
10835
10836 for (hn = 0; hn < ngnubuckets; ++hn)
10837 ++counts[lengths[hn]];
10838
10839 if (ngnubuckets > 0)
10840 {
10841 unsigned long j;
10842 printf (" 0 %-10lu (%5.1f%%)\n",
10843 counts[0], (counts[0] * 100.0) / ngnubuckets);
10844 for (j = 1; j <= maxlength; ++j)
10845 {
10846 nzero_counts += counts[j] * j;
10847 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10848 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10849 (nzero_counts * 100.0) / nsyms);
10850 }
10851 }
10852
10853 free (counts);
10854 free (lengths);
10855 free (gnubuckets);
10856 free (gnuchains);
10857 }
10858
252b5132
RH		 10859 return 1;
10860}
10861
10862static int
2cf0635d 10863process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10864{
b4c96d0d 10865 unsigned int i;
252b5132
RH		 10866
10867 if (dynamic_syminfo == NULL
10868 || !do_dynamic)
10869 /* No syminfo, this is ok. */
10870 return 1;
10871
10872 /* There better should be a dynamic symbol section. */
10873 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10874 return 0;
10875
10876 if (dynamic_addr)
10877 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10878 dynamic_syminfo_offset, dynamic_syminfo_nent);
10879
10880 printf (_(" Num: Name BoundTo Flags\n"));
10881 for (i = 0; i < dynamic_syminfo_nent; ++i)
10882 {
10883 unsigned short int flags = dynamic_syminfo[i].si_flags;
10884
31104126 10885 printf ("%4d: ", i);
4082ef84
NC		 10886 if (i >= num_dynamic_syms)
10887 printf (_("<corrupt index>"));
10888 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 10889 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10890 else
2b692964 10891 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10892 putchar (' ');
252b5132
RH		 10893
10894 switch (dynamic_syminfo[i].si_boundto)
10895 {
10896 case SYMINFO_BT_SELF:
10897 fputs ("SELF ", stdout);
10898 break;
10899 case SYMINFO_BT_PARENT:
10900 fputs ("PARENT ", stdout);
10901 break;
10902 default:
10903 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10904 && dynamic_syminfo[i].si_boundto < dynamic_nent
10905 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10906 {
d79b3d50 10907 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10908 putchar (' ' );
10909 }
252b5132
RH		 10910 else
10911 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10912 break;
10913 }
10914
10915 if (flags & SYMINFO_FLG_DIRECT)
10916 printf (" DIRECT");
10917 if (flags & SYMINFO_FLG_PASSTHRU)
10918 printf (" PASSTHRU");
10919 if (flags & SYMINFO_FLG_COPY)
10920 printf (" COPY");
10921 if (flags & SYMINFO_FLG_LAZYLOAD)
10922 printf (" LAZYLOAD");
10923
10924 puts ("");
10925 }
10926
10927 return 1;
10928}
10929
cf13d699
NC		 10930/* Check to see if the given reloc needs to be handled in a target specific
10931 manner. If so then process the reloc and return TRUE otherwise return
10932 FALSE. */
09c11c86 10933
cf13d699
NC		 10934static bfd_boolean
10935target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10936 unsigned char * start,
10937 Elf_Internal_Sym * symtab)
252b5132 10938{
cf13d699 10939 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 10940
cf13d699 10941 switch (elf_header.e_machine)
252b5132 10942 {
13761a11
NC		 10943 case EM_MSP430:
10944 case EM_MSP430_OLD:
10945 {
10946 static Elf_Internal_Sym * saved_sym = NULL;
10947
10948 switch (reloc_type)
10949 {
10950 case 10: /* R_MSP430_SYM_DIFF */
10951 if (uses_msp430x_relocs ())
10952 break;
10953 case 21: /* R_MSP430X_SYM_DIFF */
10954 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10955 return TRUE;
10956
10957 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10958 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10959 goto handle_sym_diff;
0b4362b0 10960
13761a11
NC		 10961 case 5: /* R_MSP430_16_BYTE */
10962 case 9: /* R_MSP430_8 */
10963 if (uses_msp430x_relocs ())
10964 break;
10965 goto handle_sym_diff;
10966
10967 case 2: /* R_MSP430_ABS16 */
10968 case 15: /* R_MSP430X_ABS16 */
10969 if (! uses_msp430x_relocs ())
10970 break;
10971 goto handle_sym_diff;
0b4362b0 10972
13761a11
NC		 10973 handle_sym_diff:
10974 if (saved_sym != NULL)
10975 {
10976 bfd_vma value;
10977
10978 value = reloc->r_addend
10979 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10980 - saved_sym->st_value);
10981
10982 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10983
10984 saved_sym = NULL;
10985 return TRUE;
10986 }
10987 break;
10988
10989 default:
10990 if (saved_sym != NULL)
071436c6 10991 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 10992 break;
10993 }
10994 break;
10995 }
10996
cf13d699
NC		 10997 case EM_MN10300:
10998 case EM_CYGNUS_MN10300:
10999 {
11000 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11001
cf13d699
NC		 11002 switch (reloc_type)
11003 {
11004 case 34: /* R_MN10300_ALIGN */
11005 return TRUE;
11006 case 33: /* R_MN10300_SYM_DIFF */
11007 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11008 return TRUE;
11009 case 1: /* R_MN10300_32 */
11010 case 2: /* R_MN10300_16 */
11011 if (saved_sym != NULL)
11012 {
11013 bfd_vma value;
252b5132 11014
cf13d699
NC		 11015 value = reloc->r_addend
11016 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11017 - saved_sym->st_value);
252b5132 11018
cf13d699 11019 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11020
cf13d699
NC		 11021 saved_sym = NULL;
11022 return TRUE;
11023 }
11024 break;
11025 default:
11026 if (saved_sym != NULL)
071436c6 11027 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11028 break;
11029 }
11030 break;
11031 }
252b5132
RH		 11032 }
11033
cf13d699 11034 return FALSE;
252b5132
RH		 11035}
11036
aca88567
NC		 11037/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11038 DWARF debug sections. This is a target specific test. Note - we do not
11039 go through the whole including-target-headers-multiple-times route, (as
11040 we have already done with <elf/h8.h>) because this would become very
11041 messy and even then this function would have to contain target specific
11042 information (the names of the relocs instead of their numeric values).
11043 FIXME: This is not the correct way to solve this problem. The proper way
11044 is to have target specific reloc sizing and typing functions created by
11045 the reloc-macros.h header, in the same way that it already creates the
11046 reloc naming functions. */
11047
11048static bfd_boolean
11049is_32bit_abs_reloc (unsigned int reloc_type)
11050{
11051 switch (elf_header.e_machine)
11052 {
41e92641
NC		 11053 case EM_386:
11054 case EM_486:
11055 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11056 case EM_68K:
11057 return reloc_type == 1; /* R_68K_32. */
11058 case EM_860:
11059 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11060 case EM_960:
11061 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11062 case EM_AARCH64:
11063 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11064 case EM_ALPHA:
137b6b5f 11065 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11066 case EM_ARC:
11067 return reloc_type == 1; /* R_ARC_32. */
11068 case EM_ARM:
11069 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11070 case EM_AVR_OLD:
aca88567
NC		 11071 case EM_AVR:
11072 return reloc_type == 1;
cfb8c092
NC		 11073 case EM_ADAPTEVA_EPIPHANY:
11074 return reloc_type == 3;
aca88567
NC		 11075 case EM_BLACKFIN:
11076 return reloc_type == 0x12; /* R_byte4_data. */
11077 case EM_CRIS:
11078 return reloc_type == 3; /* R_CRIS_32. */
11079 case EM_CR16:
11080 return reloc_type == 3; /* R_CR16_NUM32. */
11081 case EM_CRX:
11082 return reloc_type == 15; /* R_CRX_NUM32. */
11083 case EM_CYGNUS_FRV:
11084 return reloc_type == 1;
41e92641
NC		 11085 case EM_CYGNUS_D10V:
11086 case EM_D10V:
11087 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11088 case EM_CYGNUS_D30V:
11089 case EM_D30V:
11090 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11091 case EM_DLX:
11092 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11093 case EM_CYGNUS_FR30:
11094 case EM_FR30:
11095 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11096 case EM_FT32:
11097 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11098 case EM_H8S:
11099 case EM_H8_300:
11100 case EM_H8_300H:
11101 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 11102 case EM_IA_64:
11103 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 11104 case EM_IP2K_OLD:
11105 case EM_IP2K:
11106 return reloc_type == 2; /* R_IP2K_32. */
11107 case EM_IQ2000:
11108 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11109 case EM_LATTICEMICO32:
11110 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11111 case EM_M32C_OLD:
aca88567
NC		 11112 case EM_M32C:
11113 return reloc_type == 3; /* R_M32C_32. */
11114 case EM_M32R:
11115 return reloc_type == 34; /* R_M32R_32_RELA. */
11116 case EM_MCORE:
11117 return reloc_type == 1; /* R_MCORE_ADDR32. */
11118 case EM_CYGNUS_MEP:
11119 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11120 case EM_METAG:
11121 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11122 case EM_MICROBLAZE:
11123 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11124 case EM_MIPS:
11125 return reloc_type == 2; /* R_MIPS_32. */
11126 case EM_MMIX:
11127 return reloc_type == 4; /* R_MMIX_32. */
11128 case EM_CYGNUS_MN10200:
11129 case EM_MN10200:
11130 return reloc_type == 1; /* R_MN10200_32. */
11131 case EM_CYGNUS_MN10300:
11132 case EM_MN10300:
11133 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11134 case EM_MOXIE:
11135 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11136 case EM_MSP430_OLD:
11137 case EM_MSP430:
13761a11 11138 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11139 case EM_MT:
11140 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11141 case EM_NDS32:
11142 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11143 case EM_ALTERA_NIOS2:
36591ba1 11144 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11145 case EM_NIOS32:
11146 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11147 case EM_OR1K:
11148 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11149 case EM_PARISC:
5fda8eca
NC		 11150 return (reloc_type == 1 /* R_PARISC_DIR32. */
11151 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11152 case EM_PJ:
11153 case EM_PJ_OLD:
11154 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11155 case EM_PPC64:
11156 return reloc_type == 1; /* R_PPC64_ADDR32. */
11157 case EM_PPC:
11158 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11159 case EM_RL78:
11160 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11161 case EM_RX:
11162 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11163 case EM_S370:
11164 return reloc_type == 1; /* R_I370_ADDR31. */
11165 case EM_S390_OLD:
11166 case EM_S390:
11167 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11168 case EM_SCORE:
11169 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11170 case EM_SH:
11171 return reloc_type == 1; /* R_SH_DIR32. */
11172 case EM_SPARC32PLUS:
11173 case EM_SPARCV9:
11174 case EM_SPARC:
11175 return reloc_type == 3 /* R_SPARC_32. */
11176 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11177 case EM_SPU:
11178 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11179 case EM_TI_C6000:
11180 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11181 case EM_TILEGX:
11182 return reloc_type == 2; /* R_TILEGX_32. */
11183 case EM_TILEPRO:
11184 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11185 case EM_CYGNUS_V850:
11186 case EM_V850:
11187 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11188 case EM_V800:
11189 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11190 case EM_VAX:
11191 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11192 case EM_VISIUM:
11193 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11194 case EM_X86_64:
8a9036a4 11195 case EM_L1OM:
7a9068fe 11196 case EM_K1OM:
aca88567 11197 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11198 case EM_XC16X:
11199 case EM_C166:
11200 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11201 case EM_XGATE:
11202 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11203 case EM_XSTORMY16:
11204 return reloc_type == 1; /* R_XSTROMY16_32. */
11205 case EM_XTENSA_OLD:
11206 case EM_XTENSA:
11207 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11208 default:
bee0ee85
NC		 11209 {
11210 static unsigned int prev_warn = 0;
11211
11212 /* Avoid repeating the same warning multiple times. */
11213 if (prev_warn != elf_header.e_machine)
11214 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11215 elf_header.e_machine);
11216 prev_warn = elf_header.e_machine;
11217 return FALSE;
11218 }
aca88567
NC		 11219 }
11220}
11221
11222/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11223 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11224
11225static bfd_boolean
11226is_32bit_pcrel_reloc (unsigned int reloc_type)
11227{
11228 switch (elf_header.e_machine)
11229 {
41e92641
NC		 11230 case EM_386:
11231 case EM_486:
3e0873ac 11232 return reloc_type == 2; /* R_386_PC32. */
aca88567 11233 case EM_68K:
3e0873ac 11234 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11235 case EM_AARCH64:
11236 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11237 case EM_ADAPTEVA_EPIPHANY:
11238 return reloc_type == 6;
aca88567
NC		 11239 case EM_ALPHA:
11240 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11241 case EM_ARM:
3e0873ac 11242 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11243 case EM_MICROBLAZE:
11244 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11245 case EM_OR1K:
11246 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11247 case EM_PARISC:
85acf597 11248 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11249 case EM_PPC:
11250 return reloc_type == 26; /* R_PPC_REL32. */
11251 case EM_PPC64:
3e0873ac 11252 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11253 case EM_S390_OLD:
11254 case EM_S390:
3e0873ac 11255 return reloc_type == 5; /* R_390_PC32. */
aca88567 11256 case EM_SH:
3e0873ac 11257 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11258 case EM_SPARC32PLUS:
11259 case EM_SPARCV9:
11260 case EM_SPARC:
3e0873ac 11261 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11262 case EM_SPU:
11263 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11264 case EM_TILEGX:
11265 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11266 case EM_TILEPRO:
11267 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11268 case EM_VISIUM:
11269 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11270 case EM_X86_64:
8a9036a4 11271 case EM_L1OM:
7a9068fe 11272 case EM_K1OM:
3e0873ac 11273 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11274 case EM_XTENSA_OLD:
11275 case EM_XTENSA:
11276 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11277 default:
11278 /* Do not abort or issue an error message here. Not all targets use
11279 pc-relative 32-bit relocs in their DWARF debug information and we
11280 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11281 more helpful warning message will be generated by apply_relocations
11282 anyway, so just return. */
aca88567
NC		 11283 return FALSE;
11284 }
11285}
11286
11287/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11288 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11289
11290static bfd_boolean
11291is_64bit_abs_reloc (unsigned int reloc_type)
11292{
11293 switch (elf_header.e_machine)
11294 {
a06ea964
NC		 11295 case EM_AARCH64:
11296 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11297 case EM_ALPHA:
11298 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11299 case EM_IA_64:
11300 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11301 case EM_PARISC:
11302 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11303 case EM_PPC64:
11304 return reloc_type == 38; /* R_PPC64_ADDR64. */
11305 case EM_SPARC32PLUS:
11306 case EM_SPARCV9:
11307 case EM_SPARC:
11308 return reloc_type == 54; /* R_SPARC_UA64. */
11309 case EM_X86_64:
8a9036a4 11310 case EM_L1OM:
7a9068fe 11311 case EM_K1OM:
aca88567 11312 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11313 case EM_S390_OLD:
11314 case EM_S390:
aa137e4d
NC		 11315 return reloc_type == 22; /* R_S390_64. */
11316 case EM_TILEGX:
11317 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11318 case EM_MIPS:
aa137e4d 11319 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11320 default:
11321 return FALSE;
11322 }
11323}
11324
85acf597
RH		 11325/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11326 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11327
11328static bfd_boolean
11329is_64bit_pcrel_reloc (unsigned int reloc_type)
11330{
11331 switch (elf_header.e_machine)
11332 {
a06ea964
NC		 11333 case EM_AARCH64:
11334 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11335 case EM_ALPHA:
aa137e4d 11336 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11337 case EM_IA_64:
aa137e4d 11338 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11339 case EM_PARISC:
aa137e4d 11340 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11341 case EM_PPC64:
aa137e4d 11342 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11343 case EM_SPARC32PLUS:
11344 case EM_SPARCV9:
11345 case EM_SPARC:
aa137e4d 11346 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11347 case EM_X86_64:
8a9036a4 11348 case EM_L1OM:
7a9068fe 11349 case EM_K1OM:
aa137e4d 11350 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11351 case EM_S390_OLD:
11352 case EM_S390:
aa137e4d
NC		 11353 return reloc_type == 23; /* R_S390_PC64. */
11354 case EM_TILEGX:
11355 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11356 default:
11357 return FALSE;
11358 }
11359}
11360
4dc3c23d
AM		 11361/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11362 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11363
11364static bfd_boolean
11365is_24bit_abs_reloc (unsigned int reloc_type)
11366{
11367 switch (elf_header.e_machine)
11368 {
11369 case EM_CYGNUS_MN10200:
11370 case EM_MN10200:
11371 return reloc_type == 4; /* R_MN10200_24. */
11372 default:
11373 return FALSE;
11374 }
11375}
11376
aca88567
NC		 11377/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11378 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11379
11380static bfd_boolean
11381is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11382{
11383 switch (elf_header.e_machine)
11384 {
aca88567
NC		 11385 case EM_AVR_OLD:
11386 case EM_AVR:
11387 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11388 case EM_ADAPTEVA_EPIPHANY:
11389 return reloc_type == 5;
41e92641
NC		 11390 case EM_CYGNUS_D10V:
11391 case EM_D10V:
11392 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11393 case EM_H8S:
11394 case EM_H8_300:
11395 case EM_H8_300H:
aca88567
NC		 11396 return reloc_type == R_H8_DIR16;
11397 case EM_IP2K_OLD:
11398 case EM_IP2K:
11399 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11400 case EM_M32C_OLD:
f4236fe4
DD		 11401 case EM_M32C:
11402 return reloc_type == 1; /* R_M32C_16 */
aca88567 11403 case EM_MSP430:
13761a11
NC		 11404 if (uses_msp430x_relocs ())
11405 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11406 case EM_MSP430_OLD:
aca88567 11407 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11408 case EM_NDS32:
11409 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11410 case EM_ALTERA_NIOS2:
36591ba1 11411 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11412 case EM_NIOS32:
11413 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11414 case EM_OR1K:
11415 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11416 case EM_TI_C6000:
11417 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11418 case EM_XC16X:
11419 case EM_C166:
11420 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11421 case EM_CYGNUS_MN10200:
11422 case EM_MN10200:
11423 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11424 case EM_CYGNUS_MN10300:
11425 case EM_MN10300:
11426 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11427 case EM_VISIUM:
11428 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11429 case EM_XGATE:
11430 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11431 default:
aca88567 11432 return FALSE;
4b78141a
NC		 11433 }
11434}
11435
2a7b2e88
JK		 11436/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11437 relocation entries (possibly formerly used for SHT_GROUP sections). */
11438
11439static bfd_boolean
11440is_none_reloc (unsigned int reloc_type)
11441{
11442 switch (elf_header.e_machine)
11443 {
cb8f3167
NC		 11444 case EM_68K: /* R_68K_NONE. */
11445 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11446 case EM_SPARC32PLUS:
11447 case EM_SPARCV9:
cb8f3167
NC		 11448 case EM_SPARC: /* R_SPARC_NONE. */
11449 case EM_MIPS: /* R_MIPS_NONE. */
11450 case EM_PARISC: /* R_PARISC_NONE. */
11451 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11452 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11453 case EM_PPC: /* R_PPC_NONE. */
11454 case EM_PPC64: /* R_PPC64_NONE. */
11455 case EM_ARM: /* R_ARM_NONE. */
11456 case EM_IA_64: /* R_IA64_NONE. */
11457 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11458 case EM_S390_OLD:
cb8f3167
NC		 11459 case EM_S390: /* R_390_NONE. */
11460 case EM_CRIS: /* R_CRIS_NONE. */
11461 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11462 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11463 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11464 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11465 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11466 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11467 case EM_M32R: /* R_M32R_NONE. */
40b36596 11468 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11469 case EM_TILEGX: /* R_TILEGX_NONE. */
11470 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11471 case EM_XC16X:
11472 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11473 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11474 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11475 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11476 return reloc_type == 0;
a06ea964
NC		 11477 case EM_AARCH64:
11478 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11479 case EM_NDS32:
11480 return (reloc_type == 0 /* R_XTENSA_NONE. */
11481 || reloc_type == 204 /* R_NDS32_DIFF8. */
11482 || reloc_type == 205 /* R_NDS32_DIFF16. */
11483 || reloc_type == 206 /* R_NDS32_DIFF32. */
11484 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11485 case EM_XTENSA_OLD:
11486 case EM_XTENSA:
4dc3c23d
AM		 11487 return (reloc_type == 0 /* R_XTENSA_NONE. */
11488 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11489 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11490 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11491 case EM_METAG:
11492 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11493 }
11494 return FALSE;
11495}
11496
cf13d699
NC		 11497/* Apply relocations to a section.
11498 Note: So far support has been added only for those relocations
11499 which can be found in debug sections.
11500 FIXME: Add support for more relocations ? */
1b315056 11501
cf13d699
NC		 11502static void
11503apply_relocations (void * file,
11504 Elf_Internal_Shdr * section,
11505 unsigned char * start)
1b315056 11506{
cf13d699
NC		 11507 Elf_Internal_Shdr * relsec;
11508 unsigned char * end = start + section->sh_size;
cb8f3167 11509
cf13d699
NC		 11510 if (elf_header.e_type != ET_REL)
11511 return;
1b315056 11512
cf13d699 11513 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11514 for (relsec = section_headers;
11515 relsec < section_headers + elf_header.e_shnum;
11516 ++relsec)
252b5132 11517 {
41e92641
NC		 11518 bfd_boolean is_rela;
11519 unsigned long num_relocs;
2cf0635d
NC		 11520 Elf_Internal_Rela * relocs;
11521 Elf_Internal_Rela * rp;
11522 Elf_Internal_Shdr * symsec;
11523 Elf_Internal_Sym * symtab;
ba5cdace 11524 unsigned long num_syms;
2cf0635d 11525 Elf_Internal_Sym * sym;
252b5132 11526
41e92641 11527 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11528 || relsec->sh_info >= elf_header.e_shnum
11529 || section_headers + relsec->sh_info != section
c256ffe7 11530 || relsec->sh_size == 0
4fbb74a6 11531 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11532 continue;
428409d5 11533
41e92641
NC		 11534 is_rela = relsec->sh_type == SHT_RELA;
11535
11536 if (is_rela)
11537 {
3f5e193b
NC		 11538 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11539 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11540 return;
11541 }
11542 else
11543 {
3f5e193b
NC		 11544 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11545 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11546 return;
11547 }
11548
11549 /* SH uses RELA but uses in place value instead of the addend field. */
11550 if (elf_header.e_machine == EM_SH)
11551 is_rela = FALSE;
428409d5 11552
4fbb74a6 11553 symsec = section_headers + relsec->sh_link;
ba5cdace 11554 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11555
41e92641 11556 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11557 {
41e92641
NC		 11558 bfd_vma addend;
11559 unsigned int reloc_type;
11560 unsigned int reloc_size;
91d6fa6a 11561 unsigned char * rloc;
ba5cdace 11562 unsigned long sym_index;
4b78141a 11563
aca88567 11564 reloc_type = get_reloc_type (rp->r_info);
41e92641 11565
98fb390a 11566 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11567 continue;
98fb390a
NC		 11568 else if (is_none_reloc (reloc_type))
11569 continue;
11570 else if (is_32bit_abs_reloc (reloc_type)
11571 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11572 reloc_size = 4;
85acf597
RH		 11573 else if (is_64bit_abs_reloc (reloc_type)
11574 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11575 reloc_size = 8;
4dc3c23d
AM		 11576 else if (is_24bit_abs_reloc (reloc_type))
11577 reloc_size = 3;
aca88567
NC		 11578 else if (is_16bit_abs_reloc (reloc_type))
11579 reloc_size = 2;
11580 else
4b78141a 11581 {
bee0ee85
NC		 11582 static unsigned int prev_reloc = 0;
11583 if (reloc_type != prev_reloc)
11584 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11585 reloc_type, printable_section_name (section));
11586 prev_reloc = reloc_type;
4b78141a
NC		 11587 continue;
11588 }
103f02d3 11589
91d6fa6a 11590 rloc = start + rp->r_offset;
c8da6823 11591 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11592 {
11593 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11594 (unsigned long) rp->r_offset,
74e1a04b 11595 printable_section_name (section));
700dd8b7
L		 11596 continue;
11597 }
103f02d3 11598
ba5cdace
NC		 11599 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11600 if (sym_index >= num_syms)
11601 {
11602 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11603 sym_index, printable_section_name (section));
ba5cdace
NC		 11604 continue;
11605 }
11606 sym = symtab + sym_index;
41e92641
NC		 11607
11608 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11609 make sure that it is of an appropriate type.
11610
11611 Relocations against symbols without type can happen.
11612 Gcc -feliminate-dwarf2-dups may generate symbols
11613 without type for debug info.
11614
11615 Icc generates relocations against function symbols
11616 instead of local labels.
11617
11618 Relocations against object symbols can happen, eg when
11619 referencing a global array. For an example of this see
11620 the _clz.o binary in libgcc.a. */
aca88567 11621 if (sym != symtab
55f25fc3 11622 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11623 {
41e92641 11624 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11625 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11626 (long int)(rp - relocs),
74e1a04b 11627 printable_section_name (relsec));
aca88567 11628 continue;
5b18a4bc 11629 }
252b5132 11630
4dc3c23d
AM		 11631 addend = 0;
11632 if (is_rela)
11633 addend += rp->r_addend;
c47320c3
AM		 11634 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11635 partial_inplace. */
4dc3c23d
AM		 11636 if (!is_rela
11637 || (elf_header.e_machine == EM_XTENSA
11638 && reloc_type == 1)
11639 || ((elf_header.e_machine == EM_PJ
11640 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11641 && reloc_type == 1)
11642 || ((elf_header.e_machine == EM_D30V
11643 || elf_header.e_machine == EM_CYGNUS_D30V)
11644 && reloc_type == 12))
91d6fa6a 11645 addend += byte_get (rloc, reloc_size);
cb8f3167 11646
85acf597
RH		 11647 if (is_32bit_pcrel_reloc (reloc_type)
11648 || is_64bit_pcrel_reloc (reloc_type))
11649 {
11650 /* On HPPA, all pc-relative relocations are biased by 8. */
11651 if (elf_header.e_machine == EM_PARISC)
11652 addend -= 8;
91d6fa6a 11653 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11654 reloc_size);
11655 }
41e92641 11656 else
91d6fa6a 11657 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11658 }
252b5132 11659
5b18a4bc 11660 free (symtab);
41e92641 11661 free (relocs);
5b18a4bc
NC		 11662 break;
11663 }
5b18a4bc 11664}
103f02d3 11665
cf13d699
NC		 11666#ifdef SUPPORT_DISASSEMBLY
11667static int
11668disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11669{
74e1a04b 11670 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11671
74e1a04b 11672 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11673
11674 return 1;
11675}
11676#endif
11677
11678/* Reads in the contents of SECTION from FILE, returning a pointer
11679 to a malloc'ed buffer or NULL if something went wrong. */
11680
11681static char *
11682get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11683{
11684 bfd_size_type num_bytes;
11685
11686 num_bytes = section->sh_size;
11687
11688 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11689 {
11690 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11691 printable_section_name (section));
cf13d699
NC		 11692 return NULL;
11693 }
11694
3f5e193b
NC		 11695 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11696 _("section contents"));
cf13d699
NC		 11697}
11698
dd24e3da 11699
cf13d699
NC		 11700static void
11701dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11702{
11703 Elf_Internal_Shdr * relsec;
11704 bfd_size_type num_bytes;
cf13d699
NC		 11705 char * data;
11706 char * end;
11707 char * start;
cf13d699
NC		 11708 bfd_boolean some_strings_shown;
11709
11710 start = get_section_contents (section, file);
11711 if (start == NULL)
11712 return;
11713
74e1a04b 11714 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11715
11716 /* If the section being dumped has relocations against it the user might
11717 be expecting these relocations to have been applied. Check for this
11718 case and issue a warning message in order to avoid confusion.
11719 FIXME: Maybe we ought to have an option that dumps a section with
11720 relocs applied ? */
11721 for (relsec = section_headers;
11722 relsec < section_headers + elf_header.e_shnum;
11723 ++relsec)
11724 {
11725 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11726 || relsec->sh_info >= elf_header.e_shnum
11727 || section_headers + relsec->sh_info != section
11728 || relsec->sh_size == 0
11729 || relsec->sh_link >= elf_header.e_shnum)
11730 continue;
11731
11732 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11733 break;
11734 }
11735
11736 num_bytes = section->sh_size;
cf13d699
NC		 11737 data = start;
11738 end = start + num_bytes;
11739 some_strings_shown = FALSE;
11740
11741 while (data < end)
11742 {
11743 while (!ISPRINT (* data))
11744 if (++ data >= end)
11745 break;
11746
11747 if (data < end)
11748 {
071436c6
NC		 11749 size_t maxlen = end - data;
11750
cf13d699 11751#ifndef __MSVCRT__
c975cc98
NC		 11752 /* PR 11128: Use two separate invocations in order to work
11753 around bugs in the Solaris 8 implementation of printf. */
11754 printf (" [%6tx] ", data - start);
cf13d699 11755#else
071436c6 11756 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 11757#endif
4082ef84
NC		 11758 if (maxlen > 0)
11759 {
11760 print_symbol ((int) maxlen, data);
11761 putchar ('\n');
11762 data += strnlen (data, maxlen);
11763 }
11764 else
11765 {
11766 printf (_("<corrupt>\n"));
11767 data = end;
11768 }
cf13d699
NC		 11769 some_strings_shown = TRUE;
11770 }
11771 }
11772
11773 if (! some_strings_shown)
11774 printf (_(" No strings found in this section."));
11775
11776 free (start);
11777
11778 putchar ('\n');
11779}
11780
11781static void
11782dump_section_as_bytes (Elf_Internal_Shdr * section,
11783 FILE * file,
11784 bfd_boolean relocate)
11785{
11786 Elf_Internal_Shdr * relsec;
11787 bfd_size_type bytes;
11788 bfd_vma addr;
11789 unsigned char * data;
11790 unsigned char * start;
11791
11792 start = (unsigned char *) get_section_contents (section, file);
11793 if (start == NULL)
11794 return;
11795
74e1a04b 11796 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11797
11798 if (relocate)
11799 {
11800 apply_relocations (file, section, start);
11801 }
11802 else
11803 {
11804 /* If the section being dumped has relocations against it the user might
11805 be expecting these relocations to have been applied. Check for this
11806 case and issue a warning message in order to avoid confusion.
11807 FIXME: Maybe we ought to have an option that dumps a section with
11808 relocs applied ? */
11809 for (relsec = section_headers;
11810 relsec < section_headers + elf_header.e_shnum;
11811 ++relsec)
11812 {
11813 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11814 || relsec->sh_info >= elf_header.e_shnum
11815 || section_headers + relsec->sh_info != section
11816 || relsec->sh_size == 0
11817 || relsec->sh_link >= elf_header.e_shnum)
11818 continue;
11819
11820 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11821 break;
11822 }
11823 }
11824
11825 addr = section->sh_addr;
11826 bytes = section->sh_size;
11827 data = start;
11828
11829 while (bytes)
11830 {
11831 int j;
11832 int k;
11833 int lbytes;
11834
11835 lbytes = (bytes > 16 ? 16 : bytes);
11836
11837 printf (" 0x%8.8lx ", (unsigned long) addr);
11838
11839 for (j = 0; j < 16; j++)
11840 {
11841 if (j < lbytes)
11842 printf ("%2.2x", data[j]);
11843 else
11844 printf (" ");
11845
11846 if ((j & 3) == 3)
11847 printf (" ");
11848 }
11849
11850 for (j = 0; j < lbytes; j++)
11851 {
11852 k = data[j];
11853 if (k >= ' ' && k < 0x7f)
11854 printf ("%c", k);
11855 else
11856 printf (".");
11857 }
11858
11859 putchar ('\n');
11860
11861 data += lbytes;
11862 addr += lbytes;
11863 bytes -= lbytes;
11864 }
11865
11866 free (start);
11867
11868 putchar ('\n');
11869}
11870
4a114e3e 11871/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11872
11873static int
d3dbc530
AM		 11874uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11875 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 11876{
11877#ifndef HAVE_ZLIB_H
cf13d699
NC		 11878 return FALSE;
11879#else
11880 dwarf_size_type compressed_size = *size;
11881 unsigned char * compressed_buffer = *buffer;
11882 dwarf_size_type uncompressed_size;
11883 unsigned char * uncompressed_buffer;
11884 z_stream strm;
11885 int rc;
11886 dwarf_size_type header_size = 12;
11887
11888 /* Read the zlib header. In this case, it should be "ZLIB" followed
11889 by the uncompressed section size, 8 bytes in big-endian order. */
11890 if (compressed_size < header_size
11891 || ! streq ((char *) compressed_buffer, "ZLIB"))
11892 return 0;
11893
11894 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11895 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11896 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11897 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11898 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11899 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11900 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11901 uncompressed_size += compressed_buffer[11];
11902
11903 /* It is possible the section consists of several compressed
11904 buffers concatenated together, so we uncompress in a loop. */
11905 strm.zalloc = NULL;
11906 strm.zfree = NULL;
11907 strm.opaque = NULL;
11908 strm.avail_in = compressed_size - header_size;
11909 strm.next_in = (Bytef *) compressed_buffer + header_size;
11910 strm.avail_out = uncompressed_size;
3f5e193b 11911 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 11912
11913 rc = inflateInit (& strm);
11914 while (strm.avail_in > 0)
11915 {
11916 if (rc != Z_OK)
11917 goto fail;
11918 strm.next_out = ((Bytef *) uncompressed_buffer
11919 + (uncompressed_size - strm.avail_out));
11920 rc = inflate (&strm, Z_FINISH);
11921 if (rc != Z_STREAM_END)
11922 goto fail;
11923 rc = inflateReset (& strm);
11924 }
11925 rc = inflateEnd (& strm);
11926 if (rc != Z_OK
11927 || strm.avail_out != 0)
11928 goto fail;
11929
11930 free (compressed_buffer);
11931 *buffer = uncompressed_buffer;
11932 *size = uncompressed_size;
11933 return 1;
11934
11935 fail:
11936 free (uncompressed_buffer);
4a114e3e
L		 11937 /* Indicate decompression failure. */
11938 *buffer = NULL;
cf13d699
NC		 11939 return 0;
11940#endif /* HAVE_ZLIB_H */
11941}
11942
d966045b
DJ		 11943static int
11944load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 11945 Elf_Internal_Shdr * sec, void * file)
1007acb3 11946{
2cf0635d 11947 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 11948 char buf [64];
1007acb3 11949
19e6b90e
L		 11950 /* If it is already loaded, do nothing. */
11951 if (section->start != NULL)
11952 return 1;
1007acb3 11953
19e6b90e
L		 11954 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11955 section->address = sec->sh_addr;
06614111 11956 section->user_data = NULL;
3f5e193b
NC		 11957 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11958 sec->sh_offset, 1,
11959 sec->sh_size, buf);
59245841
NC		 11960 if (section->start == NULL)
11961 section->size = 0;
11962 else
11963 {
11964 section->size = sec->sh_size;
11965 if (uncompress_section_contents (&section->start, &section->size))
11966 sec->sh_size = section->size;
11967 }
4a114e3e 11968
1b315056
CS		 11969 if (section->start == NULL)
11970 return 0;
11971
19e6b90e 11972 if (debug_displays [debug].relocate)
3f5e193b 11973 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11974
1b315056 11975 return 1;
1007acb3
L		 11976}
11977
657d0d47
CC		 11978/* If this is not NULL, load_debug_section will only look for sections
11979 within the list of sections given here. */
11980unsigned int *section_subset = NULL;
11981
d966045b 11982int
2cf0635d 11983load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11984{
2cf0635d
NC		 11985 struct dwarf_section * section = &debug_displays [debug].section;
11986 Elf_Internal_Shdr * sec;
d966045b
DJ		 11987
11988 /* Locate the debug section. */
657d0d47 11989 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 11990 if (sec != NULL)
11991 section->name = section->uncompressed_name;
11992 else
11993 {
657d0d47 11994 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 11995 if (sec != NULL)
11996 section->name = section->compressed_name;
11997 }
11998 if (sec == NULL)
11999 return 0;
12000
657d0d47
CC		 12001 /* If we're loading from a subset of sections, and we've loaded
12002 a section matching this name before, it's likely that it's a
12003 different one. */
12004 if (section_subset != NULL)
12005 free_debug_section (debug);
12006
3f5e193b 12007 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12008}
12009
19e6b90e
L		 12010void
12011free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12012{
2cf0635d 12013 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12014
19e6b90e
L		 12015 if (section->start == NULL)
12016 return;
1007acb3 12017
19e6b90e
L		 12018 free ((char *) section->start);
12019 section->start = NULL;
12020 section->address = 0;
12021 section->size = 0;
1007acb3
L		 12022}
12023
1007acb3 12024static int
657d0d47 12025display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12026{
2cf0635d 12027 char * name = SECTION_NAME (section);
74e1a04b 12028 const char * print_name = printable_section_name (section);
19e6b90e
L		 12029 bfd_size_type length;
12030 int result = 1;
3f5e193b 12031 int i;
1007acb3 12032
19e6b90e
L		 12033 length = section->sh_size;
12034 if (length == 0)
1007acb3 12035 {
74e1a04b 12036 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12037 return 0;
1007acb3 12038 }
5dff79d8
NC		 12039 if (section->sh_type == SHT_NOBITS)
12040 {
12041 /* There is no point in dumping the contents of a debugging section
12042 which has the NOBITS type - the bits in the file will be random.
12043 This can happen when a file containing a .eh_frame section is
12044 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12045 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12046 print_name);
5dff79d8
NC		 12047 return 0;
12048 }
1007acb3 12049
0112cd26 12050 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12051 name = ".debug_info";
1007acb3 12052
19e6b90e
L		 12053 /* See if we know how to display the contents of this section. */
12054 for (i = 0; i < max; i++)
1b315056 12055 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12056 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12057 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12058 {
2cf0635d 12059 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12060 int secondary = (section != find_section (name));
12061
12062 if (secondary)
3f5e193b 12063 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12064
b40bf0a2
NC		 12065 if (i == line && const_strneq (name, ".debug_line."))
12066 sec->name = name;
12067 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12068 sec->name = sec->uncompressed_name;
12069 else
12070 sec->name = sec->compressed_name;
3f5e193b
NC		 12071 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12072 section, file))
19e6b90e 12073 {
657d0d47
CC		 12074 /* If this debug section is part of a CU/TU set in a .dwp file,
12075 restrict load_debug_section to the sections in that set. */
12076 section_subset = find_cu_tu_set (file, shndx);
12077
19e6b90e 12078 result &= debug_displays[i].display (sec, file);
1007acb3 12079
657d0d47
CC		 12080 section_subset = NULL;
12081
d966045b 12082 if (secondary || (i != info && i != abbrev))
3f5e193b 12083 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12084 }
1007acb3 12085
19e6b90e
L		 12086 break;
12087 }
1007acb3 12088
19e6b90e 12089 if (i == max)
1007acb3 12090 {
74e1a04b 12091 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12092 result = 0;
1007acb3
L		 12093 }
12094
19e6b90e 12095 return result;
5b18a4bc 12096}
103f02d3 12097
aef1f6d0
DJ		 12098/* Set DUMP_SECTS for all sections where dumps were requested
12099 based on section name. */
12100
12101static void
12102initialise_dumps_byname (void)
12103{
2cf0635d 12104 struct dump_list_entry * cur;
aef1f6d0
DJ		 12105
12106 for (cur = dump_sects_byname; cur; cur = cur->next)
12107 {
12108 unsigned int i;
12109 int any;
12110
12111 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12112 if (streq (SECTION_NAME (section_headers + i), cur->name))
12113 {
09c11c86 12114 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12115 any = 1;
12116 }
12117
12118 if (!any)
12119 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12120 cur->name);
12121 }
12122}
12123
5b18a4bc 12124static void
2cf0635d 12125process_section_contents (FILE * file)
5b18a4bc 12126{
2cf0635d 12127 Elf_Internal_Shdr * section;
19e6b90e 12128 unsigned int i;
103f02d3 12129
19e6b90e
L		 12130 if (! do_dump)
12131 return;
103f02d3 12132
aef1f6d0
DJ		 12133 initialise_dumps_byname ();
12134
19e6b90e
L		 12135 for (i = 0, section = section_headers;
12136 i < elf_header.e_shnum && i < num_dump_sects;
12137 i++, section++)
12138 {
12139#ifdef SUPPORT_DISASSEMBLY
12140 if (dump_sects[i] & DISASS_DUMP)
12141 disassemble_section (section, file);
12142#endif
12143 if (dump_sects[i] & HEX_DUMP)
cf13d699 12144 dump_section_as_bytes (section, file, FALSE);
103f02d3 12145
cf13d699
NC		 12146 if (dump_sects[i] & RELOC_DUMP)
12147 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12148
12149 if (dump_sects[i] & STRING_DUMP)
12150 dump_section_as_strings (section, file);
cf13d699
NC		 12151
12152 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12153 display_debug_section (i, section, file);
5b18a4bc 12154 }
103f02d3 12155
19e6b90e
L		 12156 /* Check to see if the user requested a
12157 dump of a section that does not exist. */
12158 while (i++ < num_dump_sects)
12159 if (dump_sects[i])
12160 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12161}
103f02d3 12162
5b18a4bc 12163static void
19e6b90e 12164process_mips_fpe_exception (int mask)
5b18a4bc 12165{
19e6b90e
L		 12166 if (mask)
12167 {
12168 int first = 1;
12169 if (mask & OEX_FPU_INEX)
12170 fputs ("INEX", stdout), first = 0;
12171 if (mask & OEX_FPU_UFLO)
12172 printf ("%sUFLO", first ? "" : "|"), first = 0;
12173 if (mask & OEX_FPU_OFLO)
12174 printf ("%sOFLO", first ? "" : "|"), first = 0;
12175 if (mask & OEX_FPU_DIV0)
12176 printf ("%sDIV0", first ? "" : "|"), first = 0;
12177 if (mask & OEX_FPU_INVAL)
12178 printf ("%sINVAL", first ? "" : "|");
12179 }
5b18a4bc 12180 else
19e6b90e 12181 fputs ("0", stdout);
5b18a4bc 12182}
103f02d3 12183
f6f0e17b
NC		 12184/* Display's the value of TAG at location P. If TAG is
12185 greater than 0 it is assumed to be an unknown tag, and
12186 a message is printed to this effect. Otherwise it is
12187 assumed that a message has already been printed.
12188
12189 If the bottom bit of TAG is set it assumed to have a
12190 string value, otherwise it is assumed to have an integer
12191 value.
12192
12193 Returns an updated P pointing to the first unread byte
12194 beyond the end of TAG's value.
12195
12196 Reads at or beyond END will not be made. */
12197
12198static unsigned char *
12199display_tag_value (int tag,
12200 unsigned char * p,
12201 const unsigned char * const end)
12202{
12203 unsigned long val;
12204
12205 if (tag > 0)
12206 printf (" Tag_unknown_%d: ", tag);
12207
12208 if (p >= end)
12209 {
4082ef84 12210 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12211 }
12212 else if (tag & 1)
12213 {
071436c6
NC		 12214 /* PR 17531 file: 027-19978-0.004. */
12215 size_t maxlen = (end - p) - 1;
12216
12217 putchar ('"');
4082ef84
NC		 12218 if (maxlen > 0)
12219 {
12220 print_symbol ((int) maxlen, (const char *) p);
12221 p += strnlen ((char *) p, maxlen) + 1;
12222 }
12223 else
12224 {
12225 printf (_("<corrupt string tag>"));
12226 p = (unsigned char *) end;
12227 }
071436c6 12228 printf ("\"\n");
f6f0e17b
NC		 12229 }
12230 else
12231 {
12232 unsigned int len;
12233
12234 val = read_uleb128 (p, &len, end);
12235 p += len;
12236 printf ("%ld (0x%lx)\n", val, val);
12237 }
12238
4082ef84 12239 assert (p <= end);
f6f0e17b
NC		 12240 return p;
12241}
12242
11c1ff18
PB		 12243/* ARM EABI attributes section. */
12244typedef struct
12245{
70e99720 12246 unsigned int tag;
2cf0635d 12247 const char * name;
11c1ff18 12248 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12249 unsigned int type;
2cf0635d 12250 const char ** table;
11c1ff18
PB		 12251} arm_attr_public_tag;
12252
2cf0635d 12253static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12254 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12255 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12256static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12257static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12258 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12259static const char * arm_attr_tag_FP_arch[] =
bca38921 12260 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12261 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12262static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12263static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12264 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12265static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12266 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12267 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12268static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12269 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12270static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12271 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12272static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12273 {"Absolute", "PC-relative", "None"};
2cf0635d 12274static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12275 {"None", "direct", "GOT-indirect"};
2cf0635d 12276static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12277 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12278static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12279static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12280 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12281static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12282static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12283static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12284 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12285static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12286 {"Unused", "small", "int", "forced to int"};
2cf0635d 12287static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 12288 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 12289static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12290 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12291static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12292 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12293static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12294 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12295 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12296static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12297 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12298 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12299static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12300static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12301 {"Not Allowed", "Allowed"};
2cf0635d 12302static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12303 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12304static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12305 {"Not Allowed", "Allowed"};
12306static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12307 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12308 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12309static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12310static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12311 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12312 "TrustZone and Virtualization Extensions"};
dd24e3da 12313static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12314 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12315
12316#define LOOKUP(id, name) \
12317 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12318static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12319{
12320 {4, "CPU_raw_name", 1, NULL},
12321 {5, "CPU_name", 1, NULL},
12322 LOOKUP(6, CPU_arch),
12323 {7, "CPU_arch_profile", 0, NULL},
12324 LOOKUP(8, ARM_ISA_use),
12325 LOOKUP(9, THUMB_ISA_use),
75375b3e 12326 LOOKUP(10, FP_arch),
11c1ff18 12327 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12328 LOOKUP(12, Advanced_SIMD_arch),
12329 LOOKUP(13, PCS_config),
11c1ff18
PB		 12330 LOOKUP(14, ABI_PCS_R9_use),
12331 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12332 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12333 LOOKUP(17, ABI_PCS_GOT_use),
12334 LOOKUP(18, ABI_PCS_wchar_t),
12335 LOOKUP(19, ABI_FP_rounding),
12336 LOOKUP(20, ABI_FP_denormal),
12337 LOOKUP(21, ABI_FP_exceptions),
12338 LOOKUP(22, ABI_FP_user_exceptions),
12339 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12340 {24, "ABI_align_needed", 0, NULL},
12341 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12342 LOOKUP(26, ABI_enum_size),
12343 LOOKUP(27, ABI_HardFP_use),
12344 LOOKUP(28, ABI_VFP_args),
12345 LOOKUP(29, ABI_WMMX_args),
12346 LOOKUP(30, ABI_optimization_goals),
12347 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12348 {32, "compatibility", 0, NULL},
f5f53991 12349 LOOKUP(34, CPU_unaligned_access),
75375b3e 12350 LOOKUP(36, FP_HP_extension),
8e79c3df 12351 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12352 LOOKUP(42, MPextension_use),
12353 LOOKUP(44, DIV_use),
f5f53991
AS		 12354 {64, "nodefaults", 0, NULL},
12355 {65, "also_compatible_with", 0, NULL},
12356 LOOKUP(66, T2EE_use),
12357 {67, "conformance", 1, NULL},
12358 LOOKUP(68, Virtualization_use),
cd21e546 12359 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12360};
12361#undef LOOKUP
12362
11c1ff18 12363static unsigned char *
f6f0e17b
NC		 12364display_arm_attribute (unsigned char * p,
12365 const unsigned char * const end)
11c1ff18 12366{
70e99720 12367 unsigned int tag;
11c1ff18 12368 unsigned int len;
70e99720 12369 unsigned int val;
2cf0635d 12370 arm_attr_public_tag * attr;
11c1ff18 12371 unsigned i;
70e99720 12372 unsigned int type;
11c1ff18 12373
f6f0e17b 12374 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12375 p += len;
12376 attr = NULL;
2cf0635d 12377 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12378 {
12379 if (arm_attr_public_tags[i].tag == tag)
12380 {
12381 attr = &arm_attr_public_tags[i];
12382 break;
12383 }
12384 }
12385
12386 if (attr)
12387 {
12388 printf (" Tag_%s: ", attr->name);
12389 switch (attr->type)
12390 {
12391 case 0:
12392 switch (tag)
12393 {
12394 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12395 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12396 p += len;
12397 switch (val)
12398 {
2b692964
NC		 12399 case 0: printf (_("None\n")); break;
12400 case 'A': printf (_("Application\n")); break;
12401 case 'R': printf (_("Realtime\n")); break;
12402 case 'M': printf (_("Microcontroller\n")); break;
12403 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12404 default: printf ("??? (%d)\n", val); break;
12405 }
12406 break;
12407
75375b3e 12408 case 24: /* Tag_align_needed. */
f6f0e17b 12409 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12410 p += len;
12411 switch (val)
12412 {
2b692964
NC		 12413 case 0: printf (_("None\n")); break;
12414 case 1: printf (_("8-byte\n")); break;
12415 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12416 case 3: printf ("??? 3\n"); break;
12417 default:
12418 if (val <= 12)
dd24e3da 12419 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12420 1 << val);
12421 else
12422 printf ("??? (%d)\n", val);
12423 break;
12424 }
12425 break;
12426
12427 case 25: /* Tag_align_preserved. */
f6f0e17b 12428 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12429 p += len;
12430 switch (val)
12431 {
2b692964
NC		 12432 case 0: printf (_("None\n")); break;
12433 case 1: printf (_("8-byte, except leaf SP\n")); break;
12434 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12435 case 3: printf ("??? 3\n"); break;
12436 default:
12437 if (val <= 12)
dd24e3da 12438 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12439 1 << val);
12440 else
12441 printf ("??? (%d)\n", val);
12442 break;
12443 }
12444 break;
12445
11c1ff18 12446 case 32: /* Tag_compatibility. */
071436c6 12447 {
071436c6
NC		 12448 val = read_uleb128 (p, &len, end);
12449 p += len;
071436c6 12450 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12451 if (p < end - 1)
12452 {
12453 size_t maxlen = (end - p) - 1;
12454
12455 print_symbol ((int) maxlen, (const char *) p);
12456 p += strnlen ((char *) p, maxlen) + 1;
12457 }
12458 else
12459 {
12460 printf (_("<corrupt>"));
12461 p = (unsigned char *) end;
12462 }
071436c6 12463 putchar ('\n');
071436c6 12464 }
11c1ff18
PB		 12465 break;
12466
f5f53991 12467 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12468 /* PR 17531: file: 001-505008-0.01. */
12469 if (p < end)
12470 p++;
2b692964 12471 printf (_("True\n"));
f5f53991
AS		 12472 break;
12473
12474 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12475 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12476 p += len;
12477 if (val == 6 /* Tag_CPU_arch. */)
12478 {
f6f0e17b 12479 val = read_uleb128 (p, &len, end);
f5f53991 12480 p += len;
071436c6 12481 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12482 printf ("??? (%d)\n", val);
12483 else
12484 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12485 }
12486 else
12487 printf ("???\n");
071436c6
NC		 12488 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12489 ;
f5f53991
AS		 12490 break;
12491
11c1ff18 12492 default:
bee0ee85
NC		 12493 printf (_("<unknown: %d>\n"), tag);
12494 break;
11c1ff18
PB		 12495 }
12496 return p;
12497
12498 case 1:
f6f0e17b 12499 return display_tag_value (-1, p, end);
11c1ff18 12500 case 2:
f6f0e17b 12501 return display_tag_value (0, p, end);
11c1ff18
PB		 12502
12503 default:
12504 assert (attr->type & 0x80);
f6f0e17b 12505 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12506 p += len;
12507 type = attr->type & 0x7f;
12508 if (val >= type)
12509 printf ("??? (%d)\n", val);
12510 else
12511 printf ("%s\n", attr->table[val]);
12512 return p;
12513 }
12514 }
11c1ff18 12515
f6f0e17b 12516 return display_tag_value (tag, p, end);
11c1ff18
PB		 12517}
12518
104d59d1 12519static unsigned char *
60bca95a 12520display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12521 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12522 const unsigned char * const end)
104d59d1
JM		 12523{
12524 int tag;
12525 unsigned int len;
12526 int val;
104d59d1 12527
f6f0e17b 12528 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12529 p += len;
12530
12531 /* Tag_compatibility is the only generic GNU attribute defined at
12532 present. */
12533 if (tag == 32)
12534 {
f6f0e17b 12535 val = read_uleb128 (p, &len, end);
104d59d1 12536 p += len;
071436c6
NC		 12537
12538 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12539 if (p == end)
12540 {
071436c6 12541 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12542 warn (_("corrupt vendor attribute\n"));
12543 }
12544 else
12545 {
4082ef84
NC		 12546 if (p < end - 1)
12547 {
12548 size_t maxlen = (end - p) - 1;
071436c6 12549
4082ef84
NC		 12550 print_symbol ((int) maxlen, (const char *) p);
12551 p += strnlen ((char *) p, maxlen) + 1;
12552 }
12553 else
12554 {
12555 printf (_("<corrupt>"));
12556 p = (unsigned char *) end;
12557 }
071436c6 12558 putchar ('\n');
f6f0e17b 12559 }
104d59d1
JM		 12560 return p;
12561 }
12562
12563 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12564 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12565
f6f0e17b 12566 return display_tag_value (tag, p, end);
104d59d1
JM		 12567}
12568
34c8bcba 12569static unsigned char *
f6f0e17b
NC		 12570display_power_gnu_attribute (unsigned char * p,
12571 int tag,
12572 const unsigned char * const end)
34c8bcba 12573{
34c8bcba
JM		 12574 unsigned int len;
12575 int val;
12576
12577 if (tag == Tag_GNU_Power_ABI_FP)
12578 {
f6f0e17b 12579 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12580 p += len;
12581 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12582
34c8bcba
JM		 12583 switch (val)
12584 {
12585 case 0:
2b692964 12586 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12587 break;
12588 case 1:
2b692964 12589 printf (_("Hard float\n"));
34c8bcba
JM		 12590 break;
12591 case 2:
2b692964 12592 printf (_("Soft float\n"));
34c8bcba 12593 break;
3c7b9897 12594 case 3:
2b692964 12595 printf (_("Single-precision hard float\n"));
3c7b9897 12596 break;
34c8bcba
JM		 12597 default:
12598 printf ("??? (%d)\n", val);
12599 break;
12600 }
12601 return p;
12602 }
12603
c6e65352
DJ		 12604 if (tag == Tag_GNU_Power_ABI_Vector)
12605 {
f6f0e17b 12606 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12607 p += len;
12608 printf (" Tag_GNU_Power_ABI_Vector: ");
12609 switch (val)
12610 {
12611 case 0:
2b692964 12612 printf (_("Any\n"));
c6e65352
DJ		 12613 break;
12614 case 1:
2b692964 12615 printf (_("Generic\n"));
c6e65352
DJ		 12616 break;
12617 case 2:
12618 printf ("AltiVec\n");
12619 break;
12620 case 3:
12621 printf ("SPE\n");
12622 break;
12623 default:
12624 printf ("??? (%d)\n", val);
12625 break;
12626 }
12627 return p;
12628 }
12629
f82e0623
NF		 12630 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12631 {
f6f0e17b
NC		 12632 if (p == end)
12633 {
071436c6 12634 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12635 return p;
12636 }
0b4362b0 12637
f6f0e17b 12638 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12639 p += len;
12640 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12641 switch (val)
12642 {
12643 case 0:
2b692964 12644 printf (_("Any\n"));
f82e0623
NF		 12645 break;
12646 case 1:
12647 printf ("r3/r4\n");
12648 break;
12649 case 2:
2b692964 12650 printf (_("Memory\n"));
f82e0623
NF		 12651 break;
12652 default:
12653 printf ("??? (%d)\n", val);
12654 break;
12655 }
12656 return p;
12657 }
12658
f6f0e17b 12659 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12660}
12661
9e8c70f9
DM		 12662static void
12663display_sparc_hwcaps (int mask)
12664{
12665 if (mask)
12666 {
12667 int first = 1;
071436c6 12668
9e8c70f9
DM		 12669 if (mask & ELF_SPARC_HWCAP_MUL32)
12670 fputs ("mul32", stdout), first = 0;
12671 if (mask & ELF_SPARC_HWCAP_DIV32)
12672 printf ("%sdiv32", first ? "" : "|"), first = 0;
12673 if (mask & ELF_SPARC_HWCAP_FSMULD)
12674 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12675 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12676 printf ("%sv8plus", first ? "" : "|"), first = 0;
12677 if (mask & ELF_SPARC_HWCAP_POPC)
12678 printf ("%spopc", first ? "" : "|"), first = 0;
12679 if (mask & ELF_SPARC_HWCAP_VIS)
12680 printf ("%svis", first ? "" : "|"), first = 0;
12681 if (mask & ELF_SPARC_HWCAP_VIS2)
12682 printf ("%svis2", first ? "" : "|"), first = 0;
12683 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12684 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12685 if (mask & ELF_SPARC_HWCAP_FMAF)
12686 printf ("%sfmaf", first ? "" : "|"), first = 0;
12687 if (mask & ELF_SPARC_HWCAP_VIS3)
12688 printf ("%svis3", first ? "" : "|"), first = 0;
12689 if (mask & ELF_SPARC_HWCAP_HPC)
12690 printf ("%shpc", first ? "" : "|"), first = 0;
12691 if (mask & ELF_SPARC_HWCAP_RANDOM)
12692 printf ("%srandom", first ? "" : "|"), first = 0;
12693 if (mask & ELF_SPARC_HWCAP_TRANS)
12694 printf ("%strans", first ? "" : "|"), first = 0;
12695 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12696 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12697 if (mask & ELF_SPARC_HWCAP_IMA)
12698 printf ("%sima", first ? "" : "|"), first = 0;
12699 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12700 printf ("%scspare", first ? "" : "|"), first = 0;
12701 }
12702 else
071436c6
NC		 12703 fputc ('0', stdout);
12704 fputc ('\n', stdout);
9e8c70f9
DM		 12705}
12706
3d68f91c
JM		 12707static void
12708display_sparc_hwcaps2 (int mask)
12709{
12710 if (mask)
12711 {
12712 int first = 1;
071436c6 12713
3d68f91c
JM		 12714 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12715 fputs ("fjathplus", stdout), first = 0;
12716 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12717 printf ("%svis3b", first ? "" : "|"), first = 0;
12718 if (mask & ELF_SPARC_HWCAP2_ADP)
12719 printf ("%sadp", first ? "" : "|"), first = 0;
12720 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12721 printf ("%ssparc5", first ? "" : "|"), first = 0;
12722 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12723 printf ("%smwait", first ? "" : "|"), first = 0;
12724 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12725 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12726 if (mask & ELF_SPARC_HWCAP2_XMONT)
12727 printf ("%sxmont2", first ? "" : "|"), first = 0;
12728 if (mask & ELF_SPARC_HWCAP2_NSEC)
12729 printf ("%snsec", first ? "" : "|"), first = 0;
12730 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12731 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12732 if (mask & ELF_SPARC_HWCAP2_FJDES)
12733 printf ("%sfjdes", first ? "" : "|"), first = 0;
12734 if (mask & ELF_SPARC_HWCAP2_FJAES)
12735 printf ("%sfjaes", first ? "" : "|"), first = 0;
12736 }
12737 else
071436c6
NC		 12738 fputc ('0', stdout);
12739 fputc ('\n', stdout);
3d68f91c
JM		 12740}
12741
9e8c70f9 12742static unsigned char *
f6f0e17b
NC		 12743display_sparc_gnu_attribute (unsigned char * p,
12744 int tag,
12745 const unsigned char * const end)
9e8c70f9 12746{
3d68f91c
JM		 12747 unsigned int len;
12748 int val;
12749
9e8c70f9
DM		 12750 if (tag == Tag_GNU_Sparc_HWCAPS)
12751 {
f6f0e17b 12752 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12753 p += len;
12754 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12755 display_sparc_hwcaps (val);
12756 return p;
3d68f91c
JM		 12757 }
12758 if (tag == Tag_GNU_Sparc_HWCAPS2)
12759 {
12760 val = read_uleb128 (p, &len, end);
12761 p += len;
12762 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12763 display_sparc_hwcaps2 (val);
12764 return p;
12765 }
9e8c70f9 12766
f6f0e17b 12767 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12768}
12769
351cdf24
MF		 12770static void
12771print_mips_fp_abi_value (int val)
12772{
12773 switch (val)
12774 {
12775 case Val_GNU_MIPS_ABI_FP_ANY:
12776 printf (_("Hard or soft float\n"));
12777 break;
12778 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12779 printf (_("Hard float (double precision)\n"));
12780 break;
12781 case Val_GNU_MIPS_ABI_FP_SINGLE:
12782 printf (_("Hard float (single precision)\n"));
12783 break;
12784 case Val_GNU_MIPS_ABI_FP_SOFT:
12785 printf (_("Soft float\n"));
12786 break;
12787 case Val_GNU_MIPS_ABI_FP_OLD_64:
12788 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12789 break;
12790 case Val_GNU_MIPS_ABI_FP_XX:
12791 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12792 break;
12793 case Val_GNU_MIPS_ABI_FP_64:
12794 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12795 break;
12796 case Val_GNU_MIPS_ABI_FP_64A:
12797 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12798 break;
12799 default:
12800 printf ("??? (%d)\n", val);
12801 break;
12802 }
12803}
12804
2cf19d5c 12805static unsigned char *
f6f0e17b
NC		 12806display_mips_gnu_attribute (unsigned char * p,
12807 int tag,
12808 const unsigned char * const end)
2cf19d5c 12809{
2cf19d5c
JM		 12810 if (tag == Tag_GNU_MIPS_ABI_FP)
12811 {
f6f0e17b
NC		 12812 unsigned int len;
12813 int val;
12814
12815 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12816 p += len;
12817 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12818
351cdf24
MF		 12819 print_mips_fp_abi_value (val);
12820
2cf19d5c
JM		 12821 return p;
12822 }
12823
a9f58168
CF		 12824 if (tag == Tag_GNU_MIPS_ABI_MSA)
12825 {
12826 unsigned int len;
12827 int val;
12828
12829 val = read_uleb128 (p, &len, end);
12830 p += len;
12831 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12832
12833 switch (val)
12834 {
12835 case Val_GNU_MIPS_ABI_MSA_ANY:
12836 printf (_("Any MSA or not\n"));
12837 break;
12838 case Val_GNU_MIPS_ABI_MSA_128:
12839 printf (_("128-bit MSA\n"));
12840 break;
12841 default:
12842 printf ("??? (%d)\n", val);
12843 break;
12844 }
12845 return p;
12846 }
12847
f6f0e17b 12848 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12849}
12850
59e6276b 12851static unsigned char *
f6f0e17b
NC		 12852display_tic6x_attribute (unsigned char * p,
12853 const unsigned char * const end)
59e6276b
JM		 12854{
12855 int tag;
12856 unsigned int len;
12857 int val;
12858
f6f0e17b 12859 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12860 p += len;
12861
12862 switch (tag)
12863 {
75fa6dc1 12864 case Tag_ISA:
f6f0e17b 12865 val = read_uleb128 (p, &len, end);
59e6276b 12866 p += len;
75fa6dc1 12867 printf (" Tag_ISA: ");
59e6276b
JM		 12868
12869 switch (val)
12870 {
75fa6dc1 12871 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12872 printf (_("None\n"));
12873 break;
75fa6dc1 12874 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12875 printf ("C62x\n");
12876 break;
75fa6dc1 12877 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12878 printf ("C67x\n");
12879 break;
75fa6dc1 12880 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12881 printf ("C67x+\n");
12882 break;
75fa6dc1 12883 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12884 printf ("C64x\n");
12885 break;
75fa6dc1 12886 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12887 printf ("C64x+\n");
12888 break;
75fa6dc1 12889 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12890 printf ("C674x\n");
12891 break;
12892 default:
12893 printf ("??? (%d)\n", val);
12894 break;
12895 }
12896 return p;
12897
87779176 12898 case Tag_ABI_wchar_t:
f6f0e17b 12899 val = read_uleb128 (p, &len, end);
87779176
JM		 12900 p += len;
12901 printf (" Tag_ABI_wchar_t: ");
12902 switch (val)
12903 {
12904 case 0:
12905 printf (_("Not used\n"));
12906 break;
12907 case 1:
12908 printf (_("2 bytes\n"));
12909 break;
12910 case 2:
12911 printf (_("4 bytes\n"));
12912 break;
12913 default:
12914 printf ("??? (%d)\n", val);
12915 break;
12916 }
12917 return p;
12918
12919 case Tag_ABI_stack_align_needed:
f6f0e17b 12920 val = read_uleb128 (p, &len, end);
87779176
JM		 12921 p += len;
12922 printf (" Tag_ABI_stack_align_needed: ");
12923 switch (val)
12924 {
12925 case 0:
12926 printf (_("8-byte\n"));
12927 break;
12928 case 1:
12929 printf (_("16-byte\n"));
12930 break;
12931 default:
12932 printf ("??? (%d)\n", val);
12933 break;
12934 }
12935 return p;
12936
12937 case Tag_ABI_stack_align_preserved:
f6f0e17b 12938 val = read_uleb128 (p, &len, end);
87779176
JM		 12939 p += len;
12940 printf (" Tag_ABI_stack_align_preserved: ");
12941 switch (val)
12942 {
12943 case 0:
12944 printf (_("8-byte\n"));
12945 break;
12946 case 1:
12947 printf (_("16-byte\n"));
12948 break;
12949 default:
12950 printf ("??? (%d)\n", val);
12951 break;
12952 }
12953 return p;
12954
b5593623 12955 case Tag_ABI_DSBT:
f6f0e17b 12956 val = read_uleb128 (p, &len, end);
b5593623
JM		 12957 p += len;
12958 printf (" Tag_ABI_DSBT: ");
12959 switch (val)
12960 {
12961 case 0:
12962 printf (_("DSBT addressing not used\n"));
12963 break;
12964 case 1:
12965 printf (_("DSBT addressing used\n"));
12966 break;
12967 default:
12968 printf ("??? (%d)\n", val);
12969 break;
12970 }
12971 return p;
12972
87779176 12973 case Tag_ABI_PID:
f6f0e17b 12974 val = read_uleb128 (p, &len, end);
87779176
JM		 12975 p += len;
12976 printf (" Tag_ABI_PID: ");
12977 switch (val)
12978 {
12979 case 0:
12980 printf (_("Data addressing position-dependent\n"));
12981 break;
12982 case 1:
12983 printf (_("Data addressing position-independent, GOT near DP\n"));
12984 break;
12985 case 2:
12986 printf (_("Data addressing position-independent, GOT far from DP\n"));
12987 break;
12988 default:
12989 printf ("??? (%d)\n", val);
12990 break;
12991 }
12992 return p;
12993
12994 case Tag_ABI_PIC:
f6f0e17b 12995 val = read_uleb128 (p, &len, end);
87779176
JM		 12996 p += len;
12997 printf (" Tag_ABI_PIC: ");
12998 switch (val)
12999 {
13000 case 0:
13001 printf (_("Code addressing position-dependent\n"));
13002 break;
13003 case 1:
13004 printf (_("Code addressing position-independent\n"));
13005 break;
13006 default:
13007 printf ("??? (%d)\n", val);
13008 break;
13009 }
13010 return p;
13011
13012 case Tag_ABI_array_object_alignment:
f6f0e17b 13013 val = read_uleb128 (p, &len, end);
87779176
JM		 13014 p += len;
13015 printf (" Tag_ABI_array_object_alignment: ");
13016 switch (val)
13017 {
13018 case 0:
13019 printf (_("8-byte\n"));
13020 break;
13021 case 1:
13022 printf (_("4-byte\n"));
13023 break;
13024 case 2:
13025 printf (_("16-byte\n"));
13026 break;
13027 default:
13028 printf ("??? (%d)\n", val);
13029 break;
13030 }
13031 return p;
13032
13033 case Tag_ABI_array_object_align_expected:
f6f0e17b 13034 val = read_uleb128 (p, &len, end);
87779176
JM		 13035 p += len;
13036 printf (" Tag_ABI_array_object_align_expected: ");
13037 switch (val)
13038 {
13039 case 0:
13040 printf (_("8-byte\n"));
13041 break;
13042 case 1:
13043 printf (_("4-byte\n"));
13044 break;
13045 case 2:
13046 printf (_("16-byte\n"));
13047 break;
13048 default:
13049 printf ("??? (%d)\n", val);
13050 break;
13051 }
13052 return p;
13053
3cbd1c06 13054 case Tag_ABI_compatibility:
071436c6 13055 {
071436c6
NC		 13056 val = read_uleb128 (p, &len, end);
13057 p += len;
13058 printf (" Tag_ABI_compatibility: ");
071436c6 13059 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13060 if (p < end - 1)
13061 {
13062 size_t maxlen = (end - p) - 1;
13063
13064 print_symbol ((int) maxlen, (const char *) p);
13065 p += strnlen ((char *) p, maxlen) + 1;
13066 }
13067 else
13068 {
13069 printf (_("<corrupt>"));
13070 p = (unsigned char *) end;
13071 }
071436c6 13072 putchar ('\n');
071436c6
NC		 13073 return p;
13074 }
87779176
JM		 13075
13076 case Tag_ABI_conformance:
071436c6 13077 {
4082ef84
NC		 13078 printf (" Tag_ABI_conformance: \"");
13079 if (p < end - 1)
13080 {
13081 size_t maxlen = (end - p) - 1;
071436c6 13082
4082ef84
NC		 13083 print_symbol ((int) maxlen, (const char *) p);
13084 p += strnlen ((char *) p, maxlen) + 1;
13085 }
13086 else
13087 {
13088 printf (_("<corrupt>"));
13089 p = (unsigned char *) end;
13090 }
071436c6 13091 printf ("\"\n");
071436c6
NC		 13092 return p;
13093 }
59e6276b
JM		 13094 }
13095
f6f0e17b
NC		 13096 return display_tag_value (tag, p, end);
13097}
59e6276b 13098
f6f0e17b
NC		 13099static void
13100display_raw_attribute (unsigned char * p, unsigned char * end)
13101{
13102 unsigned long addr = 0;
13103 size_t bytes = end - p;
13104
e0a31db1 13105 assert (end > p);
f6f0e17b 13106 while (bytes)
87779176 13107 {
f6f0e17b
NC		 13108 int j;
13109 int k;
13110 int lbytes = (bytes > 16 ? 16 : bytes);
13111
13112 printf (" 0x%8.8lx ", addr);
13113
13114 for (j = 0; j < 16; j++)
13115 {
13116 if (j < lbytes)
13117 printf ("%2.2x", p[j]);
13118 else
13119 printf (" ");
13120
13121 if ((j & 3) == 3)
13122 printf (" ");
13123 }
13124
13125 for (j = 0; j < lbytes; j++)
13126 {
13127 k = p[j];
13128 if (k >= ' ' && k < 0x7f)
13129 printf ("%c", k);
13130 else
13131 printf (".");
13132 }
13133
13134 putchar ('\n');
13135
13136 p += lbytes;
13137 bytes -= lbytes;
13138 addr += lbytes;
87779176 13139 }
59e6276b 13140
f6f0e17b 13141 putchar ('\n');
59e6276b
JM		 13142}
13143
13761a11
NC		 13144static unsigned char *
13145display_msp430x_attribute (unsigned char * p,
13146 const unsigned char * const end)
13147{
13148 unsigned int len;
13149 int val;
13150 int tag;
13151
13152 tag = read_uleb128 (p, & len, end);
13153 p += len;
0b4362b0 13154
13761a11
NC		 13155 switch (tag)
13156 {
13157 case OFBA_MSPABI_Tag_ISA:
13158 val = read_uleb128 (p, &len, end);
13159 p += len;
13160 printf (" Tag_ISA: ");
13161 switch (val)
13162 {
13163 case 0: printf (_("None\n")); break;
13164 case 1: printf (_("MSP430\n")); break;
13165 case 2: printf (_("MSP430X\n")); break;
13166 default: printf ("??? (%d)\n", val); break;
13167 }
13168 break;
13169
13170 case OFBA_MSPABI_Tag_Code_Model:
13171 val = read_uleb128 (p, &len, end);
13172 p += len;
13173 printf (" Tag_Code_Model: ");
13174 switch (val)
13175 {
13176 case 0: printf (_("None\n")); break;
13177 case 1: printf (_("Small\n")); break;
13178 case 2: printf (_("Large\n")); break;
13179 default: printf ("??? (%d)\n", val); break;
13180 }
13181 break;
13182
13183 case OFBA_MSPABI_Tag_Data_Model:
13184 val = read_uleb128 (p, &len, end);
13185 p += len;
13186 printf (" Tag_Data_Model: ");
13187 switch (val)
13188 {
13189 case 0: printf (_("None\n")); break;
13190 case 1: printf (_("Small\n")); break;
13191 case 2: printf (_("Large\n")); break;
13192 case 3: printf (_("Restricted Large\n")); break;
13193 default: printf ("??? (%d)\n", val); break;
13194 }
13195 break;
13196
13197 default:
13198 printf (_(" <unknown tag %d>: "), tag);
13199
13200 if (tag & 1)
13201 {
071436c6 13202 putchar ('"');
4082ef84
NC		 13203 if (p < end - 1)
13204 {
13205 size_t maxlen = (end - p) - 1;
13206
13207 print_symbol ((int) maxlen, (const char *) p);
13208 p += strnlen ((char *) p, maxlen) + 1;
13209 }
13210 else
13211 {
13212 printf (_("<corrupt>"));
13213 p = (unsigned char *) end;
13214 }
071436c6 13215 printf ("\"\n");
13761a11
NC		 13216 }
13217 else
13218 {
13219 val = read_uleb128 (p, &len, end);
13220 p += len;
13221 printf ("%d (0x%x)\n", val, val);
13222 }
13223 break;
13224 }
13225
4082ef84 13226 assert (p <= end);
13761a11
NC		 13227 return p;
13228}
13229
11c1ff18 13230static int
60bca95a
NC		 13231process_attributes (FILE * file,
13232 const char * public_name,
104d59d1 13233 unsigned int proc_type,
f6f0e17b
NC		 13234 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13235 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13236{
2cf0635d 13237 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13238 unsigned i;
13239
13240 /* Find the section header so that we get the size. */
13241 for (i = 0, sect = section_headers;
13242 i < elf_header.e_shnum;
13243 i++, sect++)
13244 {
071436c6
NC		 13245 unsigned char * contents;
13246 unsigned char * p;
13247
104d59d1 13248 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13249 continue;
13250
3f5e193b
NC		 13251 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13252 sect->sh_size, _("attributes"));
60bca95a 13253 if (contents == NULL)
11c1ff18 13254 continue;
60bca95a 13255
11c1ff18
PB		 13256 p = contents;
13257 if (*p == 'A')
13258 {
071436c6
NC		 13259 bfd_vma section_len;
13260
13261 section_len = sect->sh_size - 1;
11c1ff18 13262 p++;
60bca95a 13263
071436c6 13264 while (section_len > 0)
11c1ff18 13265 {
071436c6 13266 bfd_vma attr_len;
e9847026 13267 unsigned int namelen;
11c1ff18 13268 bfd_boolean public_section;
104d59d1 13269 bfd_boolean gnu_section;
11c1ff18 13270
071436c6 13271 if (section_len <= 4)
e0a31db1
NC		 13272 {
13273 error (_("Tag section ends prematurely\n"));
13274 break;
13275 }
071436c6 13276 attr_len = byte_get (p, 4);
11c1ff18 13277 p += 4;
60bca95a 13278
071436c6 13279 if (attr_len > section_len)
11c1ff18 13280 {
071436c6
NC		 13281 error (_("Bad attribute length (%u > %u)\n"),
13282 (unsigned) attr_len, (unsigned) section_len);
13283 attr_len = section_len;
11c1ff18 13284 }
74e1a04b 13285 /* PR 17531: file: 001-101425-0.004 */
071436c6 13286 else if (attr_len < 5)
74e1a04b 13287 {
071436c6 13288 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13289 break;
13290 }
e9847026 13291
071436c6
NC		 13292 section_len -= attr_len;
13293 attr_len -= 4;
13294
13295 namelen = strnlen ((char *) p, attr_len) + 1;
13296 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13297 {
13298 error (_("Corrupt attribute section name\n"));
13299 break;
13300 }
13301
071436c6
NC		 13302 printf (_("Attribute Section: "));
13303 print_symbol (INT_MAX, (const char *) p);
13304 putchar ('\n');
60bca95a
NC		 13305
13306 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13307 public_section = TRUE;
13308 else
13309 public_section = FALSE;
60bca95a
NC		 13310
13311 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13312 gnu_section = TRUE;
13313 else
13314 gnu_section = FALSE;
60bca95a 13315
11c1ff18 13316 p += namelen;
071436c6 13317 attr_len -= namelen;
e0a31db1 13318
071436c6 13319 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13320 {
e0a31db1 13321 int tag;
11c1ff18
PB		 13322 int val;
13323 bfd_vma size;
071436c6 13324 unsigned char * end;
60bca95a 13325
e0a31db1 13326 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13327 if (attr_len < 6)
e0a31db1
NC		 13328 {
13329 error (_("Unused bytes at end of section\n"));
13330 section_len = 0;
13331 break;
13332 }
13333
13334 tag = *(p++);
11c1ff18 13335 size = byte_get (p, 4);
071436c6 13336 if (size > attr_len)
11c1ff18 13337 {
e9847026 13338 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13339 (unsigned) size, (unsigned) attr_len);
13340 size = attr_len;
11c1ff18 13341 }
e0a31db1
NC		 13342 /* PR binutils/17531: Safe handling of corrupt files. */
13343 if (size < 6)
13344 {
13345 error (_("Bad subsection length (%u < 6)\n"),
13346 (unsigned) size);
13347 section_len = 0;
13348 break;
13349 }
60bca95a 13350
071436c6 13351 attr_len -= size;
11c1ff18 13352 end = p + size - 1;
071436c6 13353 assert (end <= contents + sect->sh_size);
11c1ff18 13354 p += 4;
60bca95a 13355
11c1ff18
PB		 13356 switch (tag)
13357 {
13358 case 1:
2b692964 13359 printf (_("File Attributes\n"));
11c1ff18
PB		 13360 break;
13361 case 2:
2b692964 13362 printf (_("Section Attributes:"));
11c1ff18
PB		 13363 goto do_numlist;
13364 case 3:
2b692964 13365 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13366 do_numlist:
13367 for (;;)
13368 {
91d6fa6a 13369 unsigned int j;
60bca95a 13370
f6f0e17b 13371 val = read_uleb128 (p, &j, end);
91d6fa6a 13372 p += j;
11c1ff18
PB		 13373 if (val == 0)
13374 break;
13375 printf (" %d", val);
13376 }
13377 printf ("\n");
13378 break;
13379 default:
2b692964 13380 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13381 public_section = FALSE;
13382 break;
13383 }
60bca95a 13384
071436c6 13385 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13386 {
13387 while (p < end)
f6f0e17b 13388 p = display_pub_attribute (p, end);
071436c6 13389 assert (p <= end);
104d59d1 13390 }
071436c6 13391 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13392 {
13393 while (p < end)
13394 p = display_gnu_attribute (p,
f6f0e17b
NC		 13395 display_proc_gnu_attribute,
13396 end);
071436c6 13397 assert (p <= end);
11c1ff18 13398 }
071436c6 13399 else if (p < end)
11c1ff18 13400 {
071436c6 13401 printf (_(" Unknown attribute:\n"));
f6f0e17b 13402 display_raw_attribute (p, end);
11c1ff18
PB		 13403 p = end;
13404 }
071436c6
NC		 13405 else
13406 attr_len = 0;
11c1ff18
PB		 13407 }
13408 }
13409 }
13410 else
e9847026 13411 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13412
60bca95a 13413 free (contents);
11c1ff18
PB		 13414 }
13415 return 1;
13416}
13417
104d59d1 13418static int
2cf0635d 13419process_arm_specific (FILE * file)
104d59d1
JM		 13420{
13421 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13422 display_arm_attribute, NULL);
13423}
13424
34c8bcba 13425static int
2cf0635d 13426process_power_specific (FILE * file)
34c8bcba
JM		 13427{
13428 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13429 display_power_gnu_attribute);
13430}
13431
9e8c70f9
DM		 13432static int
13433process_sparc_specific (FILE * file)
13434{
13435 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13436 display_sparc_gnu_attribute);
13437}
13438
59e6276b
JM		 13439static int
13440process_tic6x_specific (FILE * file)
13441{
13442 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13443 display_tic6x_attribute, NULL);
13444}
13445
13761a11
NC		 13446static int
13447process_msp430x_specific (FILE * file)
13448{
13449 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13450 display_msp430x_attribute, NULL);
13451}
13452
ccb4c951
RS		 13453/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13454 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13455 and return the VMA of the next entry, or -1 if there was a problem.
13456 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13457
13458static bfd_vma
82b1b41b
NC		 13459print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13460 unsigned char * data_end)
ccb4c951
RS		 13461{
13462 printf (" ");
13463 print_vma (addr, LONG_HEX);
13464 printf (" ");
13465 if (addr < pltgot + 0xfff0)
13466 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13467 else
13468 printf ("%10s", "");
13469 printf (" ");
13470 if (data == NULL)
2b692964 13471 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13472 else
13473 {
13474 bfd_vma entry;
82b1b41b 13475 unsigned char * from = data + addr - pltgot;
ccb4c951 13476
82b1b41b
NC		 13477 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13478 {
13479 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13480 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13481 return (bfd_vma) -1;
13482 }
13483 else
13484 {
13485 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13486 print_vma (entry, LONG_HEX);
13487 }
ccb4c951
RS		 13488 }
13489 return addr + (is_32bit_elf ? 4 : 8);
13490}
13491
861fb55a
DJ		 13492/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13493 PLTGOT. Print the Address and Initial fields of an entry at VMA
13494 ADDR and return the VMA of the next entry. */
13495
13496static bfd_vma
2cf0635d 13497print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13498{
13499 printf (" ");
13500 print_vma (addr, LONG_HEX);
13501 printf (" ");
13502 if (data == NULL)
2b692964 13503 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13504 else
13505 {
13506 bfd_vma entry;
13507
13508 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13509 print_vma (entry, LONG_HEX);
13510 }
13511 return addr + (is_32bit_elf ? 4 : 8);
13512}
13513
351cdf24
MF		 13514static void
13515print_mips_ases (unsigned int mask)
13516{
13517 if (mask & AFL_ASE_DSP)
13518 fputs ("\n\tDSP ASE", stdout);
13519 if (mask & AFL_ASE_DSPR2)
13520 fputs ("\n\tDSP R2 ASE", stdout);
13521 if (mask & AFL_ASE_EVA)
13522 fputs ("\n\tEnhanced VA Scheme", stdout);
13523 if (mask & AFL_ASE_MCU)
13524 fputs ("\n\tMCU (MicroController) ASE", stdout);
13525 if (mask & AFL_ASE_MDMX)
13526 fputs ("\n\tMDMX ASE", stdout);
13527 if (mask & AFL_ASE_MIPS3D)
13528 fputs ("\n\tMIPS-3D ASE", stdout);
13529 if (mask & AFL_ASE_MT)
13530 fputs ("\n\tMT ASE", stdout);
13531 if (mask & AFL_ASE_SMARTMIPS)
13532 fputs ("\n\tSmartMIPS ASE", stdout);
13533 if (mask & AFL_ASE_VIRT)
13534 fputs ("\n\tVZ ASE", stdout);
13535 if (mask & AFL_ASE_MSA)
13536 fputs ("\n\tMSA ASE", stdout);
13537 if (mask & AFL_ASE_MIPS16)
13538 fputs ("\n\tMIPS16 ASE", stdout);
13539 if (mask & AFL_ASE_MICROMIPS)
13540 fputs ("\n\tMICROMIPS ASE", stdout);
13541 if (mask & AFL_ASE_XPA)
13542 fputs ("\n\tXPA ASE", stdout);
13543 if (mask == 0)
13544 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13545 else if ((mask & ~AFL_ASE_MASK) != 0)
13546 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13547}
13548
13549static void
13550print_mips_isa_ext (unsigned int isa_ext)
13551{
13552 switch (isa_ext)
13553 {
13554 case 0:
13555 fputs (_("None"), stdout);
13556 break;
13557 case AFL_EXT_XLR:
13558 fputs ("RMI XLR", stdout);
13559 break;
2c629856
N		 13560 case AFL_EXT_OCTEON3:
13561 fputs ("Cavium Networks Octeon3", stdout);
13562 break;
351cdf24
MF		 13563 case AFL_EXT_OCTEON2:
13564 fputs ("Cavium Networks Octeon2", stdout);
13565 break;
13566 case AFL_EXT_OCTEONP:
13567 fputs ("Cavium Networks OcteonP", stdout);
13568 break;
13569 case AFL_EXT_LOONGSON_3A:
13570 fputs ("Loongson 3A", stdout);
13571 break;
13572 case AFL_EXT_OCTEON:
13573 fputs ("Cavium Networks Octeon", stdout);
13574 break;
13575 case AFL_EXT_5900:
13576 fputs ("Toshiba R5900", stdout);
13577 break;
13578 case AFL_EXT_4650:
13579 fputs ("MIPS R4650", stdout);
13580 break;
13581 case AFL_EXT_4010:
13582 fputs ("LSI R4010", stdout);
13583 break;
13584 case AFL_EXT_4100:
13585 fputs ("NEC VR4100", stdout);
13586 break;
13587 case AFL_EXT_3900:
13588 fputs ("Toshiba R3900", stdout);
13589 break;
13590 case AFL_EXT_10000:
13591 fputs ("MIPS R10000", stdout);
13592 break;
13593 case AFL_EXT_SB1:
13594 fputs ("Broadcom SB-1", stdout);
13595 break;
13596 case AFL_EXT_4111:
13597 fputs ("NEC VR4111/VR4181", stdout);
13598 break;
13599 case AFL_EXT_4120:
13600 fputs ("NEC VR4120", stdout);
13601 break;
13602 case AFL_EXT_5400:
13603 fputs ("NEC VR5400", stdout);
13604 break;
13605 case AFL_EXT_5500:
13606 fputs ("NEC VR5500", stdout);
13607 break;
13608 case AFL_EXT_LOONGSON_2E:
13609 fputs ("ST Microelectronics Loongson 2E", stdout);
13610 break;
13611 case AFL_EXT_LOONGSON_2F:
13612 fputs ("ST Microelectronics Loongson 2F", stdout);
13613 break;
13614 default:
00ac7aa0 13615 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13616 }
13617}
13618
13619static int
13620get_mips_reg_size (int reg_size)
13621{
13622 return (reg_size == AFL_REG_NONE) ? 0
13623 : (reg_size == AFL_REG_32) ? 32
13624 : (reg_size == AFL_REG_64) ? 64
13625 : (reg_size == AFL_REG_128) ? 128
13626 : -1;
13627}
13628
19e6b90e 13629static int
2cf0635d 13630process_mips_specific (FILE * file)
5b18a4bc 13631{
2cf0635d 13632 Elf_Internal_Dyn * entry;
351cdf24 13633 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13634 size_t liblist_offset = 0;
13635 size_t liblistno = 0;
13636 size_t conflictsno = 0;
13637 size_t options_offset = 0;
13638 size_t conflicts_offset = 0;
861fb55a
DJ		 13639 size_t pltrelsz = 0;
13640 size_t pltrel = 0;
ccb4c951 13641 bfd_vma pltgot = 0;
861fb55a
DJ		 13642 bfd_vma mips_pltgot = 0;
13643 bfd_vma jmprel = 0;
ccb4c951
RS		 13644 bfd_vma local_gotno = 0;
13645 bfd_vma gotsym = 0;
13646 bfd_vma symtabno = 0;
103f02d3 13647
2cf19d5c
JM		 13648 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13649 display_mips_gnu_attribute);
13650
351cdf24
MF		 13651 sect = find_section (".MIPS.abiflags");
13652
13653 if (sect != NULL)
13654 {
13655 Elf_External_ABIFlags_v0 *abiflags_ext;
13656 Elf_Internal_ABIFlags_v0 abiflags_in;
13657
13658 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13659 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13660 else
13661 {
13662 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13663 sect->sh_size, _("MIPS ABI Flags section"));
13664 if (abiflags_ext)
13665 {
13666 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13667 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13668 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13669 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13670 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13671 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13672 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13673 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13674 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13675 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13676 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13677
13678 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13679 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13680 if (abiflags_in.isa_rev > 1)
13681 printf ("r%d", abiflags_in.isa_rev);
13682 printf ("\nGPR size: %d",
13683 get_mips_reg_size (abiflags_in.gpr_size));
13684 printf ("\nCPR1 size: %d",
13685 get_mips_reg_size (abiflags_in.cpr1_size));
13686 printf ("\nCPR2 size: %d",
13687 get_mips_reg_size (abiflags_in.cpr2_size));
13688 fputs ("\nFP ABI: ", stdout);
13689 print_mips_fp_abi_value (abiflags_in.fp_abi);
13690 fputs ("ISA Extension: ", stdout);
13691 print_mips_isa_ext (abiflags_in.isa_ext);
13692 fputs ("\nASEs:", stdout);
13693 print_mips_ases (abiflags_in.ases);
13694 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13695 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13696 fputc ('\n', stdout);
13697 free (abiflags_ext);
13698 }
13699 }
13700 }
13701
19e6b90e
L		 13702 /* We have a lot of special sections. Thanks SGI! */
13703 if (dynamic_section == NULL)
13704 /* No information available. */
13705 return 0;
252b5132 13706
071436c6
NC		 13707 for (entry = dynamic_section;
13708 /* PR 17531 file: 012-50589-0.004. */
13709 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13710 ++entry)
252b5132
RH		 13711 switch (entry->d_tag)
13712 {
13713 case DT_MIPS_LIBLIST:
d93f0186
NC		 13714 liblist_offset
13715 = offset_from_vma (file, entry->d_un.d_val,
13716 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13717 break;
13718 case DT_MIPS_LIBLISTNO:
13719 liblistno = entry->d_un.d_val;
13720 break;
13721 case DT_MIPS_OPTIONS:
d93f0186 13722 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13723 break;
13724 case DT_MIPS_CONFLICT:
d93f0186
NC		 13725 conflicts_offset
13726 = offset_from_vma (file, entry->d_un.d_val,
13727 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13728 break;
13729 case DT_MIPS_CONFLICTNO:
13730 conflictsno = entry->d_un.d_val;
13731 break;
ccb4c951 13732 case DT_PLTGOT:
861fb55a
DJ		 13733 pltgot = entry->d_un.d_ptr;
13734 break;
ccb4c951
RS		 13735 case DT_MIPS_LOCAL_GOTNO:
13736 local_gotno = entry->d_un.d_val;
13737 break;
13738 case DT_MIPS_GOTSYM:
13739 gotsym = entry->d_un.d_val;
13740 break;
13741 case DT_MIPS_SYMTABNO:
13742 symtabno = entry->d_un.d_val;
13743 break;
861fb55a
DJ		 13744 case DT_MIPS_PLTGOT:
13745 mips_pltgot = entry->d_un.d_ptr;
13746 break;
13747 case DT_PLTREL:
13748 pltrel = entry->d_un.d_val;
13749 break;
13750 case DT_PLTRELSZ:
13751 pltrelsz = entry->d_un.d_val;
13752 break;
13753 case DT_JMPREL:
13754 jmprel = entry->d_un.d_ptr;
13755 break;
252b5132
RH		 13756 default:
13757 break;
13758 }
13759
13760 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13761 {
2cf0635d 13762 Elf32_External_Lib * elib;
252b5132
RH		 13763 size_t cnt;
13764
3f5e193b
NC		 13765 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13766 liblistno,
13767 sizeof (Elf32_External_Lib),
9cf03b7e 13768 _("liblist section data"));
a6e9f9df 13769 if (elib)
252b5132 13770 {
2b692964 13771 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13772 (unsigned long) liblistno);
2b692964 13773 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13774 stdout);
13775
13776 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13777 {
a6e9f9df 13778 Elf32_Lib liblist;
91d6fa6a 13779 time_t atime;
a6e9f9df 13780 char timebuf[20];
2cf0635d 13781 struct tm * tmp;
a6e9f9df
AM		 13782
13783 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13784 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13785 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13786 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13787 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13788
91d6fa6a 13789 tmp = gmtime (&atime);
e9e44622
JJ		 13790 snprintf (timebuf, sizeof (timebuf),
13791 "%04u-%02u-%02uT%02u:%02u:%02u",
13792 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13793 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13794
31104126 13795 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13796 if (VALID_DYNAMIC_NAME (liblist.l_name))
13797 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13798 else
2b692964 13799 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13800 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13801 liblist.l_version);
a6e9f9df
AM		 13802
13803 if (liblist.l_flags == 0)
2b692964 13804 puts (_(" NONE"));
a6e9f9df
AM		 13805 else
13806 {
13807 static const struct
252b5132 13808 {
2cf0635d 13809 const char * name;
a6e9f9df 13810 int bit;
252b5132 13811 }
a6e9f9df
AM		 13812 l_flags_vals[] =
13813 {
13814 { " EXACT_MATCH", LL_EXACT_MATCH },
13815 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13816 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13817 { " EXPORTS", LL_EXPORTS },
13818 { " DELAY_LOAD", LL_DELAY_LOAD },
13819 { " DELTA", LL_DELTA }
13820 };
13821 int flags = liblist.l_flags;
13822 size_t fcnt;
13823
60bca95a 13824 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13825 if ((flags & l_flags_vals[fcnt].bit) != 0)
13826 {
13827 fputs (l_flags_vals[fcnt].name, stdout);
13828 flags ^= l_flags_vals[fcnt].bit;
13829 }
13830 if (flags != 0)
13831 printf (" %#x", (unsigned int) flags);
252b5132 13832
a6e9f9df
AM		 13833 puts ("");
13834 }
252b5132 13835 }
252b5132 13836
a6e9f9df
AM		 13837 free (elib);
13838 }
252b5132
RH		 13839 }
13840
13841 if (options_offset != 0)
13842 {
2cf0635d 13843 Elf_External_Options * eopt;
2cf0635d
NC		 13844 Elf_Internal_Options * iopt;
13845 Elf_Internal_Options * option;
252b5132
RH		 13846 size_t offset;
13847 int cnt;
351cdf24 13848 sect = section_headers;
252b5132
RH		 13849
13850 /* Find the section header so that we get the size. */
071436c6
NC		 13851 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13852 /* PR 17533 file: 012-277276-0.004. */
13853 if (sect == NULL)
13854 {
13855 error (_("No MIPS_OPTIONS header found\n"));
13856 return 0;
13857 }
252b5132 13858
3f5e193b
NC		 13859 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13860 sect->sh_size, _("options"));
a6e9f9df 13861 if (eopt)
252b5132 13862 {
3f5e193b
NC		 13863 iopt = (Elf_Internal_Options *)
13864 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13865 if (iopt == NULL)
13866 {
8b73c356 13867 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 13868 return 0;
13869 }
76da6bbe 13870
a6e9f9df
AM		 13871 offset = cnt = 0;
13872 option = iopt;
252b5132 13873
82b1b41b 13874 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 13875 {
2cf0635d 13876 Elf_External_Options * eoption;
252b5132 13877
a6e9f9df 13878 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13879
a6e9f9df
AM		 13880 option->kind = BYTE_GET (eoption->kind);
13881 option->size = BYTE_GET (eoption->size);
13882 option->section = BYTE_GET (eoption->section);
13883 option->info = BYTE_GET (eoption->info);
76da6bbe 13884
82b1b41b
NC		 13885 /* PR 17531: file: ffa0fa3b. */
13886 if (option->size < sizeof (* eopt)
13887 || offset + option->size > sect->sh_size)
13888 {
55325047
NC		 13889 error (_("Invalid size (%u) for MIPS option\n"), option->size);
13890 return 0;
82b1b41b 13891 }
a6e9f9df 13892 offset += option->size;
82b1b41b 13893
a6e9f9df
AM		 13894 ++option;
13895 ++cnt;
13896 }
252b5132 13897
a6e9f9df 13898 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 13899 printable_section_name (sect), cnt);
76da6bbe 13900
a6e9f9df 13901 option = iopt;
82b1b41b 13902 offset = 0;
252b5132 13903
a6e9f9df 13904 while (cnt-- > 0)
252b5132 13905 {
a6e9f9df
AM		 13906 size_t len;
13907
13908 switch (option->kind)
252b5132 13909 {
a6e9f9df
AM		 13910 case ODK_NULL:
13911 /* This shouldn't happen. */
13912 printf (" NULL %d %lx", option->section, option->info);
13913 break;
13914 case ODK_REGINFO:
13915 printf (" REGINFO ");
13916 if (elf_header.e_machine == EM_MIPS)
13917 {
13918 /* 32bit form. */
2cf0635d 13919 Elf32_External_RegInfo * ereg;
b34976b6 13920 Elf32_RegInfo reginfo;
a6e9f9df
AM		 13921
13922 ereg = (Elf32_External_RegInfo *) (option + 1);
13923 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13924 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13925 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13926 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13927 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13928 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13929
13930 printf ("GPR %08lx GP 0x%lx\n",
13931 reginfo.ri_gprmask,
13932 (unsigned long) reginfo.ri_gp_value);
13933 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13934 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13935 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13936 }
13937 else
13938 {
13939 /* 64 bit form. */
2cf0635d 13940 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 13941 Elf64_Internal_RegInfo reginfo;
13942
13943 ereg = (Elf64_External_RegInfo *) (option + 1);
13944 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13945 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13946 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13947 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13948 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 13949 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 13950
13951 printf ("GPR %08lx GP 0x",
13952 reginfo.ri_gprmask);
13953 printf_vma (reginfo.ri_gp_value);
13954 printf ("\n");
13955
13956 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13957 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13958 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13959 }
13960 ++option;
13961 continue;
13962 case ODK_EXCEPTIONS:
13963 fputs (" EXCEPTIONS fpe_min(", stdout);
13964 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13965 fputs (") fpe_max(", stdout);
13966 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13967 fputs (")", stdout);
13968
13969 if (option->info & OEX_PAGE0)
13970 fputs (" PAGE0", stdout);
13971 if (option->info & OEX_SMM)
13972 fputs (" SMM", stdout);
13973 if (option->info & OEX_FPDBUG)
13974 fputs (" FPDBUG", stdout);
13975 if (option->info & OEX_DISMISS)
13976 fputs (" DISMISS", stdout);
13977 break;
13978 case ODK_PAD:
13979 fputs (" PAD ", stdout);
13980 if (option->info & OPAD_PREFIX)
13981 fputs (" PREFIX", stdout);
13982 if (option->info & OPAD_POSTFIX)
13983 fputs (" POSTFIX", stdout);
13984 if (option->info & OPAD_SYMBOL)
13985 fputs (" SYMBOL", stdout);
13986 break;
13987 case ODK_HWPATCH:
13988 fputs (" HWPATCH ", stdout);
13989 if (option->info & OHW_R4KEOP)
13990 fputs (" R4KEOP", stdout);
13991 if (option->info & OHW_R8KPFETCH)
13992 fputs (" R8KPFETCH", stdout);
13993 if (option->info & OHW_R5KEOP)
13994 fputs (" R5KEOP", stdout);
13995 if (option->info & OHW_R5KCVTL)
13996 fputs (" R5KCVTL", stdout);
13997 break;
13998 case ODK_FILL:
13999 fputs (" FILL ", stdout);
14000 /* XXX Print content of info word? */
14001 break;
14002 case ODK_TAGS:
14003 fputs (" TAGS ", stdout);
14004 /* XXX Print content of info word? */
14005 break;
14006 case ODK_HWAND:
14007 fputs (" HWAND ", stdout);
14008 if (option->info & OHWA0_R4KEOP_CHECKED)
14009 fputs (" R4KEOP_CHECKED", stdout);
14010 if (option->info & OHWA0_R4KEOP_CLEAN)
14011 fputs (" R4KEOP_CLEAN", stdout);
14012 break;
14013 case ODK_HWOR:
14014 fputs (" HWOR ", stdout);
14015 if (option->info & OHWA0_R4KEOP_CHECKED)
14016 fputs (" R4KEOP_CHECKED", stdout);
14017 if (option->info & OHWA0_R4KEOP_CLEAN)
14018 fputs (" R4KEOP_CLEAN", stdout);
14019 break;
14020 case ODK_GP_GROUP:
14021 printf (" GP_GROUP %#06lx self-contained %#06lx",
14022 option->info & OGP_GROUP,
14023 (option->info & OGP_SELF) >> 16);
14024 break;
14025 case ODK_IDENT:
14026 printf (" IDENT %#06lx self-contained %#06lx",
14027 option->info & OGP_GROUP,
14028 (option->info & OGP_SELF) >> 16);
14029 break;
14030 default:
14031 /* This shouldn't happen. */
14032 printf (" %3d ??? %d %lx",
14033 option->kind, option->section, option->info);
14034 break;
252b5132 14035 }
a6e9f9df 14036
2cf0635d 14037 len = sizeof (* eopt);
a6e9f9df 14038 while (len < option->size)
82b1b41b
NC		 14039 {
14040 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14041
82b1b41b
NC		 14042 if (ISPRINT (datum))
14043 printf ("%c", datum);
14044 else
14045 printf ("\\%03o", datum);
14046 len ++;
14047 }
a6e9f9df 14048 fputs ("\n", stdout);
82b1b41b
NC		 14049
14050 offset += option->size;
252b5132 14051 ++option;
252b5132
RH		 14052 }
14053
a6e9f9df 14054 free (eopt);
252b5132 14055 }
252b5132
RH		 14056 }
14057
14058 if (conflicts_offset != 0 && conflictsno != 0)
14059 {
2cf0635d 14060 Elf32_Conflict * iconf;
252b5132
RH		 14061 size_t cnt;
14062
14063 if (dynamic_symbols == NULL)
14064 {
591a748a 14065 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14066 return 0;
14067 }
14068
3f5e193b 14069 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14070 if (iconf == NULL)
14071 {
8b73c356 14072 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14073 return 0;
14074 }
14075
9ea033b2 14076 if (is_32bit_elf)
252b5132 14077 {
2cf0635d 14078 Elf32_External_Conflict * econf32;
a6e9f9df 14079
3f5e193b
NC		 14080 econf32 = (Elf32_External_Conflict *)
14081 get_data (NULL, file, conflicts_offset, conflictsno,
14082 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14083 if (!econf32)
14084 return 0;
252b5132
RH		 14085
14086 for (cnt = 0; cnt < conflictsno; ++cnt)
14087 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14088
14089 free (econf32);
252b5132
RH		 14090 }
14091 else
14092 {
2cf0635d 14093 Elf64_External_Conflict * econf64;
a6e9f9df 14094
3f5e193b
NC		 14095 econf64 = (Elf64_External_Conflict *)
14096 get_data (NULL, file, conflicts_offset, conflictsno,
14097 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14098 if (!econf64)
14099 return 0;
252b5132
RH		 14100
14101 for (cnt = 0; cnt < conflictsno; ++cnt)
14102 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14103
14104 free (econf64);
252b5132
RH		 14105 }
14106
c7e7ca54
NC		 14107 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14108 (unsigned long) conflictsno);
252b5132
RH		 14109 puts (_(" Num: Index Value Name"));
14110
14111 for (cnt = 0; cnt < conflictsno; ++cnt)
14112 {
b34976b6 14113 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14114
14115 if (iconf[cnt] >= num_dynamic_syms)
14116 printf (_("<corrupt symbol index>"));
d79b3d50 14117 else
e0a31db1
NC		 14118 {
14119 Elf_Internal_Sym * psym;
14120
14121 psym = & dynamic_symbols[iconf[cnt]];
14122 print_vma (psym->st_value, FULL_HEX);
14123 putchar (' ');
14124 if (VALID_DYNAMIC_NAME (psym->st_name))
14125 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14126 else
14127 printf (_("<corrupt: %14ld>"), psym->st_name);
14128 }
31104126 14129 putchar ('\n');
252b5132
RH		 14130 }
14131
252b5132
RH		 14132 free (iconf);
14133 }
14134
ccb4c951
RS		 14135 if (pltgot != 0 && local_gotno != 0)
14136 {
91d6fa6a 14137 bfd_vma ent, local_end, global_end;
bbeee7ea 14138 size_t i, offset;
2cf0635d 14139 unsigned char * data;
82b1b41b 14140 unsigned char * data_end;
bbeee7ea 14141 int addr_size;
ccb4c951 14142
91d6fa6a 14143 ent = pltgot;
ccb4c951
RS		 14144 addr_size = (is_32bit_elf ? 4 : 8);
14145 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14146
74e1a04b
NC		 14147 /* PR binutils/17533 file: 012-111227-0.004 */
14148 if (symtabno < gotsym)
14149 {
14150 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14151 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14152 return 0;
14153 }
82b1b41b 14154
74e1a04b 14155 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14156 /* PR 17531: file: 54c91a34. */
14157 if (global_end < local_end)
14158 {
14159 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14160 return 0;
14161 }
14162
ccb4c951 14163 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14164 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14165 global_end - pltgot, 1,
14166 _("Global Offset Table data"));
59245841
NC		 14167 if (data == NULL)
14168 return 0;
82b1b41b 14169 data_end = data + (global_end - pltgot);
59245841 14170
ccb4c951
RS		 14171 printf (_("\nPrimary GOT:\n"));
14172 printf (_(" Canonical gp value: "));
14173 print_vma (pltgot + 0x7ff0, LONG_HEX);
14174 printf ("\n\n");
14175
14176 printf (_(" Reserved entries:\n"));
14177 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14178 addr_size * 2, _("Address"), _("Access"),
14179 addr_size * 2, _("Initial"));
82b1b41b 14180 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14181 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14182 if (ent == (bfd_vma) -1)
14183 goto got_print_fail;
ccb4c951 14184 if (data
91d6fa6a 14185 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14186 >> (addr_size * 8 - 1)) != 0)
14187 {
82b1b41b 14188 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14189 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14190 if (ent == (bfd_vma) -1)
14191 goto got_print_fail;
ccb4c951
RS		 14192 }
14193 printf ("\n");
14194
91d6fa6a 14195 if (ent < local_end)
ccb4c951
RS		 14196 {
14197 printf (_(" Local entries:\n"));
cc5914eb 14198 printf (" %*s %10s %*s\n",
2b692964
NC		 14199 addr_size * 2, _("Address"), _("Access"),
14200 addr_size * 2, _("Initial"));
91d6fa6a 14201 while (ent < local_end)
ccb4c951 14202 {
82b1b41b 14203 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14204 printf ("\n");
82b1b41b
NC		 14205 if (ent == (bfd_vma) -1)
14206 goto got_print_fail;
ccb4c951
RS		 14207 }
14208 printf ("\n");
14209 }
14210
14211 if (gotsym < symtabno)
14212 {
14213 int sym_width;
14214
14215 printf (_(" Global entries:\n"));
cc5914eb 14216 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14217 addr_size * 2, _("Address"),
14218 _("Access"),
2b692964 14219 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14220 addr_size * 2, _("Sym.Val."),
14221 _("Type"),
14222 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14223 _("Ndx"), _("Name"));
0b4362b0 14224
ccb4c951 14225 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14226
ccb4c951
RS		 14227 for (i = gotsym; i < symtabno; i++)
14228 {
82b1b41b 14229 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14230 printf (" ");
e0a31db1
NC		 14231
14232 if (dynamic_symbols == NULL)
14233 printf (_("<no dynamic symbols>"));
14234 else if (i < num_dynamic_syms)
14235 {
14236 Elf_Internal_Sym * psym = dynamic_symbols + i;
14237
14238 print_vma (psym->st_value, LONG_HEX);
14239 printf (" %-7s %3s ",
14240 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14241 get_symbol_index_type (psym->st_shndx));
14242
14243 if (VALID_DYNAMIC_NAME (psym->st_name))
14244 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14245 else
14246 printf (_("<corrupt: %14ld>"), psym->st_name);
14247 }
ccb4c951 14248 else
7fc5ac57
JBG		 14249 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14250 (unsigned long) i);
e0a31db1 14251
ccb4c951 14252 printf ("\n");
82b1b41b
NC		 14253 if (ent == (bfd_vma) -1)
14254 break;
ccb4c951
RS		 14255 }
14256 printf ("\n");
14257 }
14258
82b1b41b 14259 got_print_fail:
ccb4c951
RS		 14260 if (data)
14261 free (data);
14262 }
14263
861fb55a
DJ		 14264 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14265 {
91d6fa6a 14266 bfd_vma ent, end;
861fb55a
DJ		 14267 size_t offset, rel_offset;
14268 unsigned long count, i;
2cf0635d 14269 unsigned char * data;
861fb55a 14270 int addr_size, sym_width;
2cf0635d 14271 Elf_Internal_Rela * rels;
861fb55a
DJ		 14272
14273 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14274 if (pltrel == DT_RELA)
14275 {
14276 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14277 return 0;
14278 }
14279 else
14280 {
14281 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14282 return 0;
14283 }
14284
91d6fa6a 14285 ent = mips_pltgot;
861fb55a
DJ		 14286 addr_size = (is_32bit_elf ? 4 : 8);
14287 end = mips_pltgot + (2 + count) * addr_size;
14288
14289 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14290 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14291 1, _("Procedure Linkage Table data"));
59245841
NC		 14292 if (data == NULL)
14293 return 0;
14294
9cf03b7e 14295 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14296 printf (_(" Reserved entries:\n"));
14297 printf (_(" %*s %*s Purpose\n"),
2b692964 14298 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14299 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14300 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14301 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14302 printf (_(" Module pointer\n"));
861fb55a
DJ		 14303 printf ("\n");
14304
14305 printf (_(" Entries:\n"));
cc5914eb 14306 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14307 addr_size * 2, _("Address"),
14308 addr_size * 2, _("Initial"),
14309 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14310 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14311 for (i = 0; i < count; i++)
14312 {
df97ab2a 14313 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14314
91d6fa6a 14315 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14316 printf (" ");
e0a31db1 14317
df97ab2a
MF		 14318 if (idx >= num_dynamic_syms)
14319 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14320 else
e0a31db1 14321 {
df97ab2a 14322 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14323
14324 print_vma (psym->st_value, LONG_HEX);
14325 printf (" %-7s %3s ",
14326 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14327 get_symbol_index_type (psym->st_shndx));
14328 if (VALID_DYNAMIC_NAME (psym->st_name))
14329 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14330 else
14331 printf (_("<corrupt: %14ld>"), psym->st_name);
14332 }
861fb55a
DJ		 14333 printf ("\n");
14334 }
14335 printf ("\n");
14336
14337 if (data)
14338 free (data);
14339 free (rels);
14340 }
14341
252b5132
RH		 14342 return 1;
14343}
14344
35c08157
KLC		 14345static int
14346process_nds32_specific (FILE * file)
14347{
14348 Elf_Internal_Shdr *sect = NULL;
14349
14350 sect = find_section (".nds32_e_flags");
14351 if (sect != NULL)
14352 {
14353 unsigned int *flag;
14354
14355 printf ("\nNDS32 elf flags section:\n");
14356 flag = get_data (NULL, file, sect->sh_offset, 1,
14357 sect->sh_size, _("NDS32 elf flags section"));
14358
14359 switch ((*flag) & 0x3)
14360 {
14361 case 0:
14362 printf ("(VEC_SIZE):\tNo entry.\n");
14363 break;
14364 case 1:
14365 printf ("(VEC_SIZE):\t4 bytes\n");
14366 break;
14367 case 2:
14368 printf ("(VEC_SIZE):\t16 bytes\n");
14369 break;
14370 case 3:
14371 printf ("(VEC_SIZE):\treserved\n");
14372 break;
14373 }
14374 }
14375
14376 return TRUE;
14377}
14378
047b2264 14379static int
2cf0635d 14380process_gnu_liblist (FILE * file)
047b2264 14381{
2cf0635d
NC		 14382 Elf_Internal_Shdr * section;
14383 Elf_Internal_Shdr * string_sec;
14384 Elf32_External_Lib * elib;
14385 char * strtab;
c256ffe7 14386 size_t strtab_size;
047b2264
JJ		 14387 size_t cnt;
14388 unsigned i;
14389
14390 if (! do_arch)
14391 return 0;
14392
14393 for (i = 0, section = section_headers;
14394 i < elf_header.e_shnum;
b34976b6 14395 i++, section++)
047b2264
JJ		 14396 {
14397 switch (section->sh_type)
14398 {
14399 case SHT_GNU_LIBLIST:
4fbb74a6 14400 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14401 break;
14402
3f5e193b
NC		 14403 elib = (Elf32_External_Lib *)
14404 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14405 _("liblist section data"));
047b2264
JJ		 14406
14407 if (elib == NULL)
14408 break;
4fbb74a6 14409 string_sec = section_headers + section->sh_link;
047b2264 14410
3f5e193b
NC		 14411 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14412 string_sec->sh_size,
14413 _("liblist string table"));
047b2264
JJ		 14414 if (strtab == NULL
14415 || section->sh_entsize != sizeof (Elf32_External_Lib))
14416 {
14417 free (elib);
2842702f 14418 free (strtab);
047b2264
JJ		 14419 break;
14420 }
59245841 14421 strtab_size = string_sec->sh_size;
047b2264
JJ		 14422
14423 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14424 printable_section_name (section),
0af1713e 14425 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14426
2b692964 14427 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14428
14429 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14430 ++cnt)
14431 {
14432 Elf32_Lib liblist;
91d6fa6a 14433 time_t atime;
047b2264 14434 char timebuf[20];
2cf0635d 14435 struct tm * tmp;
047b2264
JJ		 14436
14437 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14438 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14439 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14440 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14441 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14442
91d6fa6a 14443 tmp = gmtime (&atime);
e9e44622
JJ		 14444 snprintf (timebuf, sizeof (timebuf),
14445 "%04u-%02u-%02uT%02u:%02u:%02u",
14446 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14447 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14448
14449 printf ("%3lu: ", (unsigned long) cnt);
14450 if (do_wide)
c256ffe7 14451 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14452 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14453 else
c256ffe7 14454 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14455 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14456 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14457 liblist.l_version, liblist.l_flags);
14458 }
14459
14460 free (elib);
2842702f 14461 free (strtab);
047b2264
JJ		 14462 }
14463 }
14464
14465 return 1;
14466}
14467
9437c45b 14468static const char *
d3ba0551 14469get_note_type (unsigned e_type)
779fe533
NC		 14470{
14471 static char buff[64];
103f02d3 14472
1ec5cd37
NC		 14473 if (elf_header.e_type == ET_CORE)
14474 switch (e_type)
14475 {
57346661 14476 case NT_AUXV:
1ec5cd37 14477 return _("NT_AUXV (auxiliary vector)");
57346661 14478 case NT_PRSTATUS:
1ec5cd37 14479 return _("NT_PRSTATUS (prstatus structure)");
57346661 14480 case NT_FPREGSET:
1ec5cd37 14481 return _("NT_FPREGSET (floating point registers)");
57346661 14482 case NT_PRPSINFO:
1ec5cd37 14483 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14484 case NT_TASKSTRUCT:
1ec5cd37 14485 return _("NT_TASKSTRUCT (task structure)");
57346661 14486 case NT_PRXFPREG:
1ec5cd37 14487 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14488 case NT_PPC_VMX:
14489 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14490 case NT_PPC_VSX:
14491 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14492 case NT_386_TLS:
14493 return _("NT_386_TLS (x86 TLS information)");
14494 case NT_386_IOPERM:
14495 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14496 case NT_X86_XSTATE:
14497 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14498 case NT_S390_HIGH_GPRS:
14499 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14500 case NT_S390_TIMER:
14501 return _("NT_S390_TIMER (s390 timer register)");
14502 case NT_S390_TODCMP:
14503 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14504 case NT_S390_TODPREG:
14505 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14506 case NT_S390_CTRS:
14507 return _("NT_S390_CTRS (s390 control registers)");
14508 case NT_S390_PREFIX:
14509 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14510 case NT_S390_LAST_BREAK:
14511 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14512 case NT_S390_SYSTEM_CALL:
14513 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14514 case NT_S390_TDB:
14515 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14516 case NT_S390_VXRS_LOW:
14517 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14518 case NT_S390_VXRS_HIGH:
14519 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14520 case NT_ARM_VFP:
14521 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14522 case NT_ARM_TLS:
14523 return _("NT_ARM_TLS (AArch TLS registers)");
14524 case NT_ARM_HW_BREAK:
14525 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14526 case NT_ARM_HW_WATCH:
14527 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14528 case NT_PSTATUS:
1ec5cd37 14529 return _("NT_PSTATUS (pstatus structure)");
57346661 14530 case NT_FPREGS:
1ec5cd37 14531 return _("NT_FPREGS (floating point registers)");
57346661 14532 case NT_PSINFO:
1ec5cd37 14533 return _("NT_PSINFO (psinfo structure)");
57346661 14534 case NT_LWPSTATUS:
1ec5cd37 14535 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14536 case NT_LWPSINFO:
1ec5cd37 14537 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14538 case NT_WIN32PSTATUS:
1ec5cd37 14539 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14540 case NT_SIGINFO:
14541 return _("NT_SIGINFO (siginfo_t data)");
14542 case NT_FILE:
14543 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14544 default:
14545 break;
14546 }
14547 else
14548 switch (e_type)
14549 {
14550 case NT_VERSION:
14551 return _("NT_VERSION (version)");
14552 case NT_ARCH:
14553 return _("NT_ARCH (architecture)");
14554 default:
14555 break;
14556 }
14557
e9e44622 14558 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14559 return buff;
779fe533
NC		 14560}
14561
9ece1fa9
TT		 14562static int
14563print_core_note (Elf_Internal_Note *pnote)
14564{
14565 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14566 bfd_vma count, page_size;
14567 unsigned char *descdata, *filenames, *descend;
14568
14569 if (pnote->type != NT_FILE)
14570 return 1;
14571
14572#ifndef BFD64
14573 if (!is_32bit_elf)
14574 {
14575 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14576 /* Still "successful". */
14577 return 1;
14578 }
14579#endif
14580
14581 if (pnote->descsz < 2 * addr_size)
14582 {
14583 printf (_(" Malformed note - too short for header\n"));
14584 return 0;
14585 }
14586
14587 descdata = (unsigned char *) pnote->descdata;
14588 descend = descdata + pnote->descsz;
14589
14590 if (descdata[pnote->descsz - 1] != '\0')
14591 {
14592 printf (_(" Malformed note - does not end with \\0\n"));
14593 return 0;
14594 }
14595
14596 count = byte_get (descdata, addr_size);
14597 descdata += addr_size;
14598
14599 page_size = byte_get (descdata, addr_size);
14600 descdata += addr_size;
14601
14602 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14603 {
14604 printf (_(" Malformed note - too short for supplied file count\n"));
14605 return 0;
14606 }
14607
14608 printf (_(" Page size: "));
14609 print_vma (page_size, DEC);
14610 printf ("\n");
14611
14612 printf (_(" %*s%*s%*s\n"),
14613 (int) (2 + 2 * addr_size), _("Start"),
14614 (int) (4 + 2 * addr_size), _("End"),
14615 (int) (4 + 2 * addr_size), _("Page Offset"));
14616 filenames = descdata + count * 3 * addr_size;
14617 while (--count > 0)
14618 {
14619 bfd_vma start, end, file_ofs;
14620
14621 if (filenames == descend)
14622 {
14623 printf (_(" Malformed note - filenames end too early\n"));
14624 return 0;
14625 }
14626
14627 start = byte_get (descdata, addr_size);
14628 descdata += addr_size;
14629 end = byte_get (descdata, addr_size);
14630 descdata += addr_size;
14631 file_ofs = byte_get (descdata, addr_size);
14632 descdata += addr_size;
14633
14634 printf (" ");
14635 print_vma (start, FULL_HEX);
14636 printf (" ");
14637 print_vma (end, FULL_HEX);
14638 printf (" ");
14639 print_vma (file_ofs, FULL_HEX);
14640 printf ("\n %s\n", filenames);
14641
14642 filenames += 1 + strlen ((char *) filenames);
14643 }
14644
14645 return 1;
14646}
14647
1118d252
RM		 14648static const char *
14649get_gnu_elf_note_type (unsigned e_type)
14650{
14651 static char buff[64];
14652
14653 switch (e_type)
14654 {
14655 case NT_GNU_ABI_TAG:
14656 return _("NT_GNU_ABI_TAG (ABI version tag)");
14657 case NT_GNU_HWCAP:
14658 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14659 case NT_GNU_BUILD_ID:
14660 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14661 case NT_GNU_GOLD_VERSION:
14662 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14663 default:
14664 break;
14665 }
14666
14667 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14668 return buff;
14669}
14670
664f90a3
TT		 14671static int
14672print_gnu_note (Elf_Internal_Note *pnote)
14673{
14674 switch (pnote->type)
14675 {
14676 case NT_GNU_BUILD_ID:
14677 {
14678 unsigned long i;
14679
14680 printf (_(" Build ID: "));
14681 for (i = 0; i < pnote->descsz; ++i)
14682 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14683 printf ("\n");
664f90a3
TT		 14684 }
14685 break;
14686
14687 case NT_GNU_ABI_TAG:
14688 {
14689 unsigned long os, major, minor, subminor;
14690 const char *osname;
14691
3102e897
NC		 14692 /* PR 17531: file: 030-599401-0.004. */
14693 if (pnote->descsz < 16)
14694 {
14695 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14696 break;
14697 }
14698
664f90a3
TT		 14699 os = byte_get ((unsigned char *) pnote->descdata, 4);
14700 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14701 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14702 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14703
14704 switch (os)
14705 {
14706 case GNU_ABI_TAG_LINUX:
14707 osname = "Linux";
14708 break;
14709 case GNU_ABI_TAG_HURD:
14710 osname = "Hurd";
14711 break;
14712 case GNU_ABI_TAG_SOLARIS:
14713 osname = "Solaris";
14714 break;
14715 case GNU_ABI_TAG_FREEBSD:
14716 osname = "FreeBSD";
14717 break;
14718 case GNU_ABI_TAG_NETBSD:
14719 osname = "NetBSD";
14720 break;
14721 default:
14722 osname = "Unknown";
14723 break;
14724 }
14725
14726 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14727 major, minor, subminor);
14728 }
14729 break;
926c5385
CC		 14730
14731 case NT_GNU_GOLD_VERSION:
14732 {
14733 unsigned long i;
14734
14735 printf (_(" Version: "));
14736 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14737 printf ("%c", pnote->descdata[i]);
14738 printf ("\n");
14739 }
14740 break;
664f90a3
TT		 14741 }
14742
14743 return 1;
14744}
14745
9437c45b 14746static const char *
d3ba0551 14747get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14748{
14749 static char buff[64];
14750
b4db1224 14751 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14752 {
14753 /* NetBSD core "procinfo" structure. */
14754 return _("NetBSD procinfo structure");
14755 }
14756
14757 /* As of Jan 2002 there are no other machine-independent notes
14758 defined for NetBSD core files. If the note type is less
14759 than the start of the machine-dependent note types, we don't
14760 understand it. */
14761
b4db1224 14762 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14763 {
e9e44622 14764 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14765 return buff;
14766 }
14767
14768 switch (elf_header.e_machine)
14769 {
14770 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14771 and PT_GETFPREGS == mach+2. */
14772
14773 case EM_OLD_ALPHA:
14774 case EM_ALPHA:
14775 case EM_SPARC:
14776 case EM_SPARC32PLUS:
14777 case EM_SPARCV9:
14778 switch (e_type)
14779 {
2b692964 14780 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 14781 return _("PT_GETREGS (reg structure)");
2b692964 14782 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 14783 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14784 default:
14785 break;
14786 }
14787 break;
14788
14789 /* On all other arch's, PT_GETREGS == mach+1 and
14790 PT_GETFPREGS == mach+3. */
14791 default:
14792 switch (e_type)
14793 {
2b692964 14794 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 14795 return _("PT_GETREGS (reg structure)");
2b692964 14796 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 14797 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14798 default:
14799 break;
14800 }
14801 }
14802
9cf03b7e 14803 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 14804 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 14805 return buff;
14806}
14807
70616151
TT		 14808static const char *
14809get_stapsdt_note_type (unsigned e_type)
14810{
14811 static char buff[64];
14812
14813 switch (e_type)
14814 {
14815 case NT_STAPSDT:
14816 return _("NT_STAPSDT (SystemTap probe descriptors)");
14817
14818 default:
14819 break;
14820 }
14821
14822 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14823 return buff;
14824}
14825
c6a9fc58
TT		 14826static int
14827print_stapsdt_note (Elf_Internal_Note *pnote)
14828{
14829 int addr_size = is_32bit_elf ? 4 : 8;
14830 char *data = pnote->descdata;
14831 char *data_end = pnote->descdata + pnote->descsz;
14832 bfd_vma pc, base_addr, semaphore;
14833 char *provider, *probe, *arg_fmt;
14834
14835 pc = byte_get ((unsigned char *) data, addr_size);
14836 data += addr_size;
14837 base_addr = byte_get ((unsigned char *) data, addr_size);
14838 data += addr_size;
14839 semaphore = byte_get ((unsigned char *) data, addr_size);
14840 data += addr_size;
14841
14842 provider = data;
14843 data += strlen (data) + 1;
14844 probe = data;
14845 data += strlen (data) + 1;
14846 arg_fmt = data;
14847 data += strlen (data) + 1;
14848
14849 printf (_(" Provider: %s\n"), provider);
14850 printf (_(" Name: %s\n"), probe);
14851 printf (_(" Location: "));
14852 print_vma (pc, FULL_HEX);
14853 printf (_(", Base: "));
14854 print_vma (base_addr, FULL_HEX);
14855 printf (_(", Semaphore: "));
14856 print_vma (semaphore, FULL_HEX);
9cf03b7e 14857 printf ("\n");
c6a9fc58
TT		 14858 printf (_(" Arguments: %s\n"), arg_fmt);
14859
14860 return data == data_end;
14861}
14862
00e98fc7
TG		 14863static const char *
14864get_ia64_vms_note_type (unsigned e_type)
14865{
14866 static char buff[64];
14867
14868 switch (e_type)
14869 {
14870 case NT_VMS_MHD:
14871 return _("NT_VMS_MHD (module header)");
14872 case NT_VMS_LNM:
14873 return _("NT_VMS_LNM (language name)");
14874 case NT_VMS_SRC:
14875 return _("NT_VMS_SRC (source files)");
14876 case NT_VMS_TITLE:
9cf03b7e 14877 return "NT_VMS_TITLE";
00e98fc7
TG		 14878 case NT_VMS_EIDC:
14879 return _("NT_VMS_EIDC (consistency check)");
14880 case NT_VMS_FPMODE:
14881 return _("NT_VMS_FPMODE (FP mode)");
14882 case NT_VMS_LINKTIME:
9cf03b7e 14883 return "NT_VMS_LINKTIME";
00e98fc7
TG		 14884 case NT_VMS_IMGNAM:
14885 return _("NT_VMS_IMGNAM (image name)");
14886 case NT_VMS_IMGID:
14887 return _("NT_VMS_IMGID (image id)");
14888 case NT_VMS_LINKID:
14889 return _("NT_VMS_LINKID (link id)");
14890 case NT_VMS_IMGBID:
14891 return _("NT_VMS_IMGBID (build id)");
14892 case NT_VMS_GSTNAM:
14893 return _("NT_VMS_GSTNAM (sym table name)");
14894 case NT_VMS_ORIG_DYN:
9cf03b7e 14895 return "NT_VMS_ORIG_DYN";
00e98fc7 14896 case NT_VMS_PATCHTIME:
9cf03b7e 14897 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 14898 default:
14899 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14900 return buff;
14901 }
14902}
14903
14904static int
14905print_ia64_vms_note (Elf_Internal_Note * pnote)
14906{
14907 switch (pnote->type)
14908 {
14909 case NT_VMS_MHD:
14910 if (pnote->descsz > 36)
14911 {
14912 size_t l = strlen (pnote->descdata + 34);
14913 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14914 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14915 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14916 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14917 }
14918 else
14919 printf (_(" Invalid size\n"));
14920 break;
14921 case NT_VMS_LNM:
14922 printf (_(" Language: %s\n"), pnote->descdata);
14923 break;
14924#ifdef BFD64
14925 case NT_VMS_FPMODE:
9cf03b7e 14926 printf (_(" Floating Point mode: "));
4a5cb34f 14927 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14928 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14929 break;
14930 case NT_VMS_LINKTIME:
14931 printf (_(" Link time: "));
14932 print_vms_time
14933 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14934 printf ("\n");
14935 break;
14936 case NT_VMS_PATCHTIME:
14937 printf (_(" Patch time: "));
14938 print_vms_time
14939 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14940 printf ("\n");
14941 break;
14942 case NT_VMS_ORIG_DYN:
14943 printf (_(" Major id: %u, minor id: %u\n"),
14944 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14945 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 14946 printf (_(" Last modified : "));
00e98fc7
TG		 14947 print_vms_time
14948 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 14949 printf (_("\n Link flags : "));
4a5cb34f 14950 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14951 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14952 printf (_(" Header flags: 0x%08x\n"),
14953 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14954 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14955 break;
14956#endif
14957 case NT_VMS_IMGNAM:
14958 printf (_(" Image name: %s\n"), pnote->descdata);
14959 break;
14960 case NT_VMS_GSTNAM:
14961 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14962 break;
14963 case NT_VMS_IMGID:
14964 printf (_(" Image id: %s\n"), pnote->descdata);
14965 break;
14966 case NT_VMS_LINKID:
14967 printf (_(" Linker id: %s\n"), pnote->descdata);
14968 break;
14969 default:
14970 break;
14971 }
14972 return 1;
14973}
14974
6d118b09
NC		 14975/* Note that by the ELF standard, the name field is already null byte
14976 terminated, and namesz includes the terminating null byte.
14977 I.E. the value of namesz for the name "FSF" is 4.
14978
e3c8793a 14979 If the value of namesz is zero, there is no name present. */
779fe533 14980static int
2cf0635d 14981process_note (Elf_Internal_Note * pnote)
779fe533 14982{
2cf0635d
NC		 14983 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14984 const char * nt;
9437c45b
JT		 14985
14986 if (pnote->namesz == 0)
1ec5cd37
NC		 14987 /* If there is no note name, then use the default set of
14988 note type strings. */
14989 nt = get_note_type (pnote->type);
14990
1118d252
RM		 14991 else if (const_strneq (pnote->namedata, "GNU"))
14992 /* GNU-specific object file notes. */
14993 nt = get_gnu_elf_note_type (pnote->type);
14994
0112cd26 14995 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 14996 /* NetBSD-specific core file notes. */
14997 nt = get_netbsd_elfcore_note_type (pnote->type);
14998
b15fa79e
AM		 14999 else if (strneq (pnote->namedata, "SPU/", 4))
15000 {
15001 /* SPU-specific core file notes. */
15002 nt = pnote->namedata + 4;
15003 name = "SPU";
15004 }
15005
00e98fc7
TG		 15006 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15007 /* VMS/ia64-specific file notes. */
15008 nt = get_ia64_vms_note_type (pnote->type);
15009
70616151
TT		 15010 else if (const_strneq (pnote->namedata, "stapsdt"))
15011 nt = get_stapsdt_note_type (pnote->type);
15012
9437c45b 15013 else
1ec5cd37
NC		 15014 /* Don't recognize this note name; just use the default set of
15015 note type strings. */
00e98fc7 15016 nt = get_note_type (pnote->type);
9437c45b 15017
2aee03ae 15018 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15019
15020 if (const_strneq (pnote->namedata, "IPF/VMS"))
15021 return print_ia64_vms_note (pnote);
664f90a3
TT		 15022 else if (const_strneq (pnote->namedata, "GNU"))
15023 return print_gnu_note (pnote);
c6a9fc58
TT		 15024 else if (const_strneq (pnote->namedata, "stapsdt"))
15025 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15026 else if (const_strneq (pnote->namedata, "CORE"))
15027 return print_core_note (pnote);
00e98fc7
TG		 15028 else
15029 return 1;
779fe533
NC		 15030}
15031
6d118b09 15032
779fe533 15033static int
2cf0635d 15034process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15035{
2cf0635d
NC		 15036 Elf_External_Note * pnotes;
15037 Elf_External_Note * external;
b34976b6 15038 int res = 1;
103f02d3 15039
779fe533
NC		 15040 if (length <= 0)
15041 return 0;
103f02d3 15042
3f5e193b 15043 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15044 _("notes"));
dd24e3da 15045 if (pnotes == NULL)
a6e9f9df 15046 return 0;
779fe533 15047
103f02d3 15048 external = pnotes;
103f02d3 15049
9dd3a467 15050 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15051 (unsigned long) offset, (unsigned long) length);
2aee03ae 15052 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15053
15b42fb0 15054 while ((char *) external < (char *) pnotes + length)
779fe533 15055 {
b34976b6 15056 Elf_Internal_Note inote;
15b42fb0
AM		 15057 size_t min_notesz;
15058 char *next;
2cf0635d 15059 char * temp = NULL;
15b42fb0 15060 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 15061
00e98fc7 15062 if (!is_ia64_vms ())
15b42fb0 15063 {
9dd3a467
NC		 15064 /* PR binutils/15191
15065 Make sure that there is enough data to read. */
15b42fb0
AM		 15066 min_notesz = offsetof (Elf_External_Note, name);
15067 if (data_remaining < min_notesz)
9dd3a467
NC		 15068 {
15069 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15070 (int) data_remaining);
15071 break;
15072 }
15b42fb0
AM		 15073 inote.type = BYTE_GET (external->type);
15074 inote.namesz = BYTE_GET (external->namesz);
15075 inote.namedata = external->name;
15076 inote.descsz = BYTE_GET (external->descsz);
15077 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c
NC		 15078 /* PR 17531: file: 3443835e. */
15079 if (inote.descdata < (char *) pnotes)
15080 {
15081 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15082 inote.descdata = inote.namedata;
15083 inote.namesz = 0;
15084 }
15b42fb0
AM		 15085 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15086 next = inote.descdata + align_power (inote.descsz, 2);
15087 }
00e98fc7 15088 else
15b42fb0
AM		 15089 {
15090 Elf64_External_VMS_Note *vms_external;
00e98fc7 15091
9dd3a467
NC		 15092 /* PR binutils/15191
15093 Make sure that there is enough data to read. */
15b42fb0
AM		 15094 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15095 if (data_remaining < min_notesz)
9dd3a467
NC		 15096 {
15097 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15098 (int) data_remaining);
15099 break;
15100 }
3e55a963 15101
15b42fb0
AM		 15102 vms_external = (Elf64_External_VMS_Note *) external;
15103 inote.type = BYTE_GET (vms_external->type);
15104 inote.namesz = BYTE_GET (vms_external->namesz);
15105 inote.namedata = vms_external->name;
15106 inote.descsz = BYTE_GET (vms_external->descsz);
15107 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15108 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15109 next = inote.descdata + align_power (inote.descsz, 3);
15110 }
15111
15112 if (inote.descdata < (char *) external + min_notesz
15113 || next < (char *) external + min_notesz
5d921cbd
NC		 15114 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15115 || inote.namedata + inote.namesz < inote.namedata
15116 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15117 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15118 {
15b42fb0 15119 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15120 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15121 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15122 inote.type, inote.namesz, inote.descsz);
15123 break;
15124 }
15125
15b42fb0 15126 external = (Elf_External_Note *) next;
dd24e3da 15127
6d118b09
NC		 15128 /* Verify that name is null terminated. It appears that at least
15129 one version of Linux (RedHat 6.0) generates corefiles that don't
15130 comply with the ELF spec by failing to include the null byte in
15131 namesz. */
8b971f9f 15132 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15133 {
3f5e193b 15134 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15135 if (temp == NULL)
15136 {
8b73c356 15137 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15138 res = 0;
15139 break;
15140 }
76da6bbe 15141
6d118b09
NC		 15142 strncpy (temp, inote.namedata, inote.namesz);
15143 temp[inote.namesz] = 0;
76da6bbe 15144
6d118b09
NC		 15145 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15146 inote.namedata = temp;
15147 }
15148
15149 res &= process_note (& inote);
103f02d3 15150
6d118b09
NC		 15151 if (temp != NULL)
15152 {
15153 free (temp);
15154 temp = NULL;
15155 }
779fe533
NC		 15156 }
15157
15158 free (pnotes);
103f02d3 15159
779fe533
NC		 15160 return res;
15161}
15162
15163static int
2cf0635d 15164process_corefile_note_segments (FILE * file)
779fe533 15165{
2cf0635d 15166 Elf_Internal_Phdr * segment;
b34976b6
AM		 15167 unsigned int i;
15168 int res = 1;
103f02d3 15169
d93f0186 15170 if (! get_program_headers (file))
779fe533 15171 return 0;
103f02d3 15172
779fe533
NC		 15173 for (i = 0, segment = program_headers;
15174 i < elf_header.e_phnum;
b34976b6 15175 i++, segment++)
779fe533
NC		 15176 {
15177 if (segment->p_type == PT_NOTE)
103f02d3 15178 res &= process_corefile_note_segment (file,
30800947
NC		 15179 (bfd_vma) segment->p_offset,
15180 (bfd_vma) segment->p_filesz);
779fe533 15181 }
103f02d3 15182
779fe533
NC		 15183 return res;
15184}
15185
15186static int
2cf0635d 15187process_note_sections (FILE * file)
1ec5cd37 15188{
2cf0635d 15189 Elf_Internal_Shdr * section;
1ec5cd37 15190 unsigned long i;
df565f32 15191 int n = 0;
1ec5cd37
NC		 15192 int res = 1;
15193
15194 for (i = 0, section = section_headers;
fa1908fd 15195 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 15196 i++, section++)
15197 if (section->sh_type == SHT_NOTE)
df565f32
NC		 15198 {
15199 res &= process_corefile_note_segment (file,
15200 (bfd_vma) section->sh_offset,
15201 (bfd_vma) section->sh_size);
15202 n++;
15203 }
15204
15205 if (n == 0)
15206 /* Try processing NOTE segments instead. */
15207 return process_corefile_note_segments (file);
1ec5cd37
NC		 15208
15209 return res;
15210}
15211
15212static int
2cf0635d 15213process_notes (FILE * file)
779fe533
NC		 15214{
15215 /* If we have not been asked to display the notes then do nothing. */
15216 if (! do_notes)
15217 return 1;
103f02d3 15218
779fe533 15219 if (elf_header.e_type != ET_CORE)
1ec5cd37 15220 return process_note_sections (file);
103f02d3 15221
779fe533 15222 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15223 if (elf_header.e_phnum > 0)
15224 return process_corefile_note_segments (file);
779fe533 15225
1ec5cd37
NC		 15226 printf (_("No note segments present in the core file.\n"));
15227 return 1;
779fe533
NC		 15228}
15229
252b5132 15230static int
2cf0635d 15231process_arch_specific (FILE * file)
252b5132 15232{
a952a375
NC		 15233 if (! do_arch)
15234 return 1;
15235
252b5132
RH		 15236 switch (elf_header.e_machine)
15237 {
11c1ff18
PB		 15238 case EM_ARM:
15239 return process_arm_specific (file);
252b5132 15240 case EM_MIPS:
4fe85591 15241 case EM_MIPS_RS3_LE:
252b5132
RH		 15242 return process_mips_specific (file);
15243 break;
35c08157
KLC		 15244 case EM_NDS32:
15245 return process_nds32_specific (file);
15246 break;
34c8bcba
JM		 15247 case EM_PPC:
15248 return process_power_specific (file);
15249 break;
9e8c70f9
DM		 15250 case EM_SPARC:
15251 case EM_SPARC32PLUS:
15252 case EM_SPARCV9:
15253 return process_sparc_specific (file);
15254 break;
59e6276b
JM		 15255 case EM_TI_C6000:
15256 return process_tic6x_specific (file);
15257 break;
13761a11
NC		 15258 case EM_MSP430:
15259 return process_msp430x_specific (file);
252b5132
RH		 15260 default:
15261 break;
15262 }
15263 return 1;
15264}
15265
15266static int
2cf0635d 15267get_file_header (FILE * file)
252b5132 15268{
9ea033b2
NC		 15269 /* Read in the identity array. */
15270 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15271 return 0;
15272
9ea033b2 15273 /* Determine how to read the rest of the header. */
b34976b6 15274 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15275 {
15276 default: /* fall through */
15277 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15278 case ELFDATA2LSB:
15279 byte_get = byte_get_little_endian;
15280 byte_put = byte_put_little_endian;
15281 break;
15282 case ELFDATA2MSB:
15283 byte_get = byte_get_big_endian;
15284 byte_put = byte_put_big_endian;
15285 break;
9ea033b2
NC		 15286 }
15287
15288 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15289 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15290
15291 /* Read in the rest of the header. */
15292 if (is_32bit_elf)
15293 {
15294 Elf32_External_Ehdr ehdr32;
252b5132 15295
9ea033b2
NC		 15296 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15297 return 0;
103f02d3 15298
9ea033b2
NC		 15299 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15300 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15301 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15302 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15303 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15304 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15305 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15306 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15307 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15308 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15309 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15310 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15311 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15312 }
252b5132 15313 else
9ea033b2
NC		 15314 {
15315 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15316
15317 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15318 we will not be able to cope with the 64bit data found in
15319 64 ELF files. Detect this now and abort before we start
50c2245b 15320 overwriting things. */
a952a375
NC		 15321 if (sizeof (bfd_vma) < 8)
15322 {
e3c8793a
NC		 15323 error (_("This instance of readelf has been built without support for a\n\
1532464 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15325 return 0;
15326 }
103f02d3 15327
9ea033b2
NC		 15328 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15329 return 0;
103f02d3 15330
9ea033b2
NC		 15331 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15332 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15333 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15334 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15335 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15336 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15337 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15338 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15339 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15340 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15341 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15342 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15343 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15344 }
252b5132 15345
7ece0d85
JJ		 15346 if (elf_header.e_shoff)
15347 {
15348 /* There may be some extensions in the first section header. Don't
15349 bomb if we can't read it. */
15350 if (is_32bit_elf)
049b0c3a 15351 get_32bit_section_headers (file, TRUE);
7ece0d85 15352 else
049b0c3a 15353 get_64bit_section_headers (file, TRUE);
7ece0d85 15354 }
560f3c1c 15355
252b5132
RH		 15356 return 1;
15357}
15358
fb52b2f4
NC		 15359/* Process one ELF object file according to the command line options.
15360 This file may actually be stored in an archive. The file is
15361 positioned at the start of the ELF object. */
15362
ff78d6d6 15363static int
2cf0635d 15364process_object (char * file_name, FILE * file)
252b5132 15365{
252b5132
RH		 15366 unsigned int i;
15367
252b5132
RH		 15368 if (! get_file_header (file))
15369 {
15370 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15371 return 1;
252b5132
RH		 15372 }
15373
15374 /* Initialise per file variables. */
60bca95a 15375 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15376 version_info[i] = 0;
15377
60bca95a 15378 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15379 dynamic_info[i] = 0;
5115b233 15380 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15381
15382 /* Process the file. */
15383 if (show_name)
15384 printf (_("\nFile: %s\n"), file_name);
15385
18bd398b
NC		 15386 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15387 Note we do this even if cmdline_dump_sects is empty because we
15388 must make sure that the dump_sets array is zeroed out before each
15389 object file is processed. */
15390 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15391 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15392
15393 if (num_cmdline_dump_sects > 0)
15394 {
15395 if (num_dump_sects == 0)
15396 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15397 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15398
15399 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15400 memcpy (dump_sects, cmdline_dump_sects,
15401 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15402 }
d70c5fc7 15403
252b5132 15404 if (! process_file_header ())
fb52b2f4 15405 return 1;
252b5132 15406
d1f5c6e3 15407 if (! process_section_headers (file))
2f62977e 15408 {
d1f5c6e3
L		 15409 /* Without loaded section headers we cannot process lots of
15410 things. */
2f62977e 15411 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15412
2f62977e 15413 if (! do_using_dynamic)
2c610e4b 15414 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15415 }
252b5132 15416
d1f5c6e3
L		 15417 if (! process_section_groups (file))
15418 {
15419 /* Without loaded section groups we cannot process unwind. */
15420 do_unwind = 0;
15421 }
15422
2f62977e 15423 if (process_program_headers (file))
b2d38a17 15424 process_dynamic_section (file);
252b5132
RH		 15425
15426 process_relocs (file);
15427
4d6ed7c8
NC		 15428 process_unwind (file);
15429
252b5132
RH		 15430 process_symbol_table (file);
15431
15432 process_syminfo (file);
15433
15434 process_version_sections (file);
15435
15436 process_section_contents (file);
f5842774 15437
1ec5cd37 15438 process_notes (file);
103f02d3 15439
047b2264
JJ		 15440 process_gnu_liblist (file);
15441
252b5132
RH		 15442 process_arch_specific (file);
15443
d93f0186
NC		 15444 if (program_headers)
15445 {
15446 free (program_headers);
15447 program_headers = NULL;
15448 }
15449
252b5132
RH		 15450 if (section_headers)
15451 {
15452 free (section_headers);
15453 section_headers = NULL;
15454 }
15455
15456 if (string_table)
15457 {
15458 free (string_table);
15459 string_table = NULL;
d40ac9bd 15460 string_table_length = 0;
252b5132
RH		 15461 }
15462
15463 if (dynamic_strings)
15464 {
15465 free (dynamic_strings);
15466 dynamic_strings = NULL;
d79b3d50 15467 dynamic_strings_length = 0;
252b5132
RH		 15468 }
15469
15470 if (dynamic_symbols)
15471 {
15472 free (dynamic_symbols);
15473 dynamic_symbols = NULL;
19936277 15474 num_dynamic_syms = 0;
252b5132
RH		 15475 }
15476
15477 if (dynamic_syminfo)
15478 {
15479 free (dynamic_syminfo);
15480 dynamic_syminfo = NULL;
15481 }
ff78d6d6 15482
293c573e
MR		 15483 if (dynamic_section)
15484 {
15485 free (dynamic_section);
15486 dynamic_section = NULL;
15487 }
15488
e4b17d5c
L		 15489 if (section_headers_groups)
15490 {
15491 free (section_headers_groups);
15492 section_headers_groups = NULL;
15493 }
15494
15495 if (section_groups)
15496 {
2cf0635d
NC		 15497 struct group_list * g;
15498 struct group_list * next;
e4b17d5c
L		 15499
15500 for (i = 0; i < group_count; i++)
15501 {
15502 for (g = section_groups [i].root; g != NULL; g = next)
15503 {
15504 next = g->next;
15505 free (g);
15506 }
15507 }
15508
15509 free (section_groups);
15510 section_groups = NULL;
15511 }
15512
19e6b90e 15513 free_debug_memory ();
18bd398b 15514
ff78d6d6 15515 return 0;
252b5132
RH		 15516}
15517
2cf0635d
NC		 15518/* Process an ELF archive.
15519 On entry the file is positioned just after the ARMAG string. */
15520
15521static int
15522process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15523{
15524 struct archive_info arch;
15525 struct archive_info nested_arch;
15526 size_t got;
2cf0635d
NC		 15527 int ret;
15528
15529 show_name = 1;
15530
15531 /* The ARCH structure is used to hold information about this archive. */
15532 arch.file_name = NULL;
15533 arch.file = NULL;
15534 arch.index_array = NULL;
15535 arch.sym_table = NULL;
15536 arch.longnames = NULL;
15537
15538 /* The NESTED_ARCH structure is used as a single-item cache of information
15539 about a nested archive (when members of a thin archive reside within
15540 another regular archive file). */
15541 nested_arch.file_name = NULL;
15542 nested_arch.file = NULL;
15543 nested_arch.index_array = NULL;
15544 nested_arch.sym_table = NULL;
15545 nested_arch.longnames = NULL;
15546
15547 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15548 {
15549 ret = 1;
15550 goto out;
4145f1d5 15551 }
fb52b2f4 15552
4145f1d5
NC		 15553 if (do_archive_index)
15554 {
2cf0635d 15555 if (arch.sym_table == NULL)
4145f1d5
NC		 15556 error (_("%s: unable to dump the index as none was found\n"), file_name);
15557 else
15558 {
591f7597 15559 unsigned long i, l;
4145f1d5
NC		 15560 unsigned long current_pos;
15561
591f7597
NC		 15562 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15563 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 15564 current_pos = ftell (file);
15565
2cf0635d 15566 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 15567 {
2cf0635d
NC		 15568 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15569 {
15570 char * member_name;
4145f1d5 15571
2cf0635d
NC		 15572 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15573
15574 if (member_name != NULL)
15575 {
15576 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15577
15578 if (qualified_name != NULL)
15579 {
c2a7d3f5
NC		 15580 printf (_("Contents of binary %s at offset "), qualified_name);
15581 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15582 putchar ('\n');
2cf0635d
NC		 15583 free (qualified_name);
15584 }
4145f1d5
NC		 15585 }
15586 }
2cf0635d
NC		 15587
15588 if (l >= arch.sym_size)
4145f1d5
NC		 15589 {
15590 error (_("%s: end of the symbol table reached before the end of the index\n"),
15591 file_name);
cb8f3167 15592 break;
4145f1d5 15593 }
591f7597
NC		 15594 /* PR 17531: file: 0b6630b2. */
15595 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15596 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 15597 }
15598
c2a7d3f5
NC		 15599 if (arch.uses_64bit_indicies)
15600 l = (l + 7) & ~ 7;
15601 else
15602 l += l & 1;
15603
2cf0635d 15604 if (l < arch.sym_size)
c2a7d3f5
NC		 15605 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15606 file_name, arch.sym_size - l);
4145f1d5 15607
4145f1d5
NC		 15608 if (fseek (file, current_pos, SEEK_SET) != 0)
15609 {
15610 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 15611 ret = 1;
15612 goto out;
4145f1d5 15613 }
fb52b2f4 15614 }
4145f1d5
NC		 15615
15616 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15617 && !do_segments && !do_header && !do_dump && !do_version
15618 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 15619 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 15620 {
15621 ret = 0; /* Archive index only. */
15622 goto out;
15623 }
fb52b2f4
NC		 15624 }
15625
d989285c 15626 ret = 0;
fb52b2f4
NC		 15627
15628 while (1)
15629 {
2cf0635d
NC		 15630 char * name;
15631 size_t namelen;
15632 char * qualified_name;
15633
15634 /* Read the next archive header. */
15635 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15636 {
15637 error (_("%s: failed to seek to next archive header\n"), file_name);
15638 return 1;
15639 }
15640 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15641 if (got != sizeof arch.arhdr)
15642 {
15643 if (got == 0)
15644 break;
15645 error (_("%s: failed to read archive header\n"), file_name);
15646 ret = 1;
15647 break;
15648 }
15649 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15650 {
15651 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15652 ret = 1;
15653 break;
15654 }
15655
15656 arch.next_arhdr_offset += sizeof arch.arhdr;
15657
15658 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15659 if (archive_file_size & 01)
15660 ++archive_file_size;
15661
15662 name = get_archive_member_name (&arch, &nested_arch);
15663 if (name == NULL)
fb52b2f4 15664 {
0fd3a477 15665 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15666 ret = 1;
15667 break;
fb52b2f4 15668 }
2cf0635d 15669 namelen = strlen (name);
fb52b2f4 15670
2cf0635d
NC		 15671 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15672 if (qualified_name == NULL)
fb52b2f4 15673 {
2cf0635d 15674 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15675 ret = 1;
15676 break;
fb52b2f4
NC		 15677 }
15678
2cf0635d
NC		 15679 if (is_thin_archive && arch.nested_member_origin == 0)
15680 {
15681 /* This is a proxy for an external member of a thin archive. */
15682 FILE * member_file;
15683 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15684 if (member_file_name == NULL)
15685 {
15686 ret = 1;
15687 break;
15688 }
15689
15690 member_file = fopen (member_file_name, "rb");
15691 if (member_file == NULL)
15692 {
15693 error (_("Input file '%s' is not readable.\n"), member_file_name);
15694 free (member_file_name);
15695 ret = 1;
15696 break;
15697 }
15698
15699 archive_file_offset = arch.nested_member_origin;
15700
15701 ret |= process_object (qualified_name, member_file);
15702
15703 fclose (member_file);
15704 free (member_file_name);
15705 }
15706 else if (is_thin_archive)
15707 {
a043396b
NC		 15708 /* PR 15140: Allow for corrupt thin archives. */
15709 if (nested_arch.file == NULL)
15710 {
15711 error (_("%s: contains corrupt thin archive: %s\n"),
15712 file_name, name);
15713 ret = 1;
15714 break;
15715 }
15716
2cf0635d
NC		 15717 /* This is a proxy for a member of a nested archive. */
15718 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15719
15720 /* The nested archive file will have been opened and setup by
15721 get_archive_member_name. */
15722 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15723 {
15724 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15725 ret = 1;
15726 break;
15727 }
15728
15729 ret |= process_object (qualified_name, nested_arch.file);
15730 }
15731 else
15732 {
15733 archive_file_offset = arch.next_arhdr_offset;
15734 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 15735
2cf0635d
NC		 15736 ret |= process_object (qualified_name, file);
15737 }
fb52b2f4 15738
2b52916e
L		 15739 if (dump_sects != NULL)
15740 {
15741 free (dump_sects);
15742 dump_sects = NULL;
15743 num_dump_sects = 0;
15744 }
15745
2cf0635d 15746 free (qualified_name);
fb52b2f4
NC		 15747 }
15748
4145f1d5 15749 out:
2cf0635d
NC		 15750 if (nested_arch.file != NULL)
15751 fclose (nested_arch.file);
15752 release_archive (&nested_arch);
15753 release_archive (&arch);
fb52b2f4 15754
d989285c 15755 return ret;
fb52b2f4
NC		 15756}
15757
15758static int
2cf0635d 15759process_file (char * file_name)
fb52b2f4 15760{
2cf0635d 15761 FILE * file;
fb52b2f4
NC		 15762 struct stat statbuf;
15763 char armag[SARMAG];
15764 int ret;
15765
15766 if (stat (file_name, &statbuf) < 0)
15767 {
f24ddbdd
NC		 15768 if (errno == ENOENT)
15769 error (_("'%s': No such file\n"), file_name);
15770 else
15771 error (_("Could not locate '%s'. System error message: %s\n"),
15772 file_name, strerror (errno));
15773 return 1;
15774 }
15775
15776 if (! S_ISREG (statbuf.st_mode))
15777 {
15778 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 15779 return 1;
15780 }
15781
15782 file = fopen (file_name, "rb");
15783 if (file == NULL)
15784 {
f24ddbdd 15785 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 15786 return 1;
15787 }
15788
15789 if (fread (armag, SARMAG, 1, file) != 1)
15790 {
4145f1d5 15791 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 15792 fclose (file);
15793 return 1;
15794 }
15795
f54498b4
NC		 15796 current_file_size = (bfd_size_type) statbuf.st_size;
15797
fb52b2f4 15798 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 15799 ret = process_archive (file_name, file, FALSE);
15800 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15801 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 15802 else
15803 {
4145f1d5
NC		 15804 if (do_archive_index)
15805 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15806 file_name);
15807
fb52b2f4
NC		 15808 rewind (file);
15809 archive_file_size = archive_file_offset = 0;
15810 ret = process_object (file_name, file);
15811 }
15812
15813 fclose (file);
15814
f54498b4 15815 current_file_size = 0;
fb52b2f4
NC		 15816 return ret;
15817}
15818
252b5132
RH		 15819#ifdef SUPPORT_DISASSEMBLY
15820/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 15821 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 15822 symbols. */
252b5132
RH		 15823
15824void
2cf0635d 15825print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 15826{
15827 fprintf (outfile,"0x%8.8x", addr);
15828}
15829
e3c8793a 15830/* Needed by the i386 disassembler. */
252b5132
RH		 15831void
15832db_task_printsym (unsigned int addr)
15833{
15834 print_address (addr, stderr);
15835}
15836#endif
15837
15838int
2cf0635d 15839main (int argc, char ** argv)
252b5132 15840{
ff78d6d6
L		 15841 int err;
15842
252b5132
RH		 15843#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15844 setlocale (LC_MESSAGES, "");
3882b010
L		 15845#endif
15846#if defined (HAVE_SETLOCALE)
15847 setlocale (LC_CTYPE, "");
252b5132
RH		 15848#endif
15849 bindtextdomain (PACKAGE, LOCALEDIR);
15850 textdomain (PACKAGE);
15851
869b9d07
MM		 15852 expandargv (&argc, &argv);
15853
252b5132
RH		 15854 parse_args (argc, argv);
15855
18bd398b 15856 if (num_dump_sects > 0)
59f14fc0 15857 {
18bd398b 15858 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 15859 cmdline_dump_sects = (dump_type *)
15860 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 15861 if (cmdline_dump_sects == NULL)
591a748a 15862 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 15863 else
15864 {
09c11c86
NC		 15865 memcpy (cmdline_dump_sects, dump_sects,
15866 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 15867 num_cmdline_dump_sects = num_dump_sects;
15868 }
15869 }
15870
18bd398b
NC		 15871 if (optind < (argc - 1))
15872 show_name = 1;
15873
ff78d6d6 15874 err = 0;
252b5132 15875 while (optind < argc)
18bd398b 15876 err |= process_file (argv[optind++]);
252b5132
RH		 15877
15878 if (dump_sects != NULL)
15879 free (dump_sects);
59f14fc0
AS		 15880 if (cmdline_dump_sects != NULL)
15881 free (cmdline_dump_sects);
252b5132 15882
ff78d6d6 15883 return err;
252b5132 15884}
A mirror of the official binutils-gdb repository