projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Replace $zlibdir with $ZLIBDIR in LDFLAGS
[deliverable/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
b90efa5b 2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
2cf0635d 167char * program_name = "readelf";
c9c1d674 168static unsigned long archive_file_offset;
85b1c36d 169static unsigned long archive_file_size;
f54498b4 170static bfd_size_type current_file_size;
85b1c36d
BE		 171static unsigned long dynamic_addr;
172static bfd_size_type dynamic_size;
8b73c356 173static size_t dynamic_nent;
2cf0635d 174static char * dynamic_strings;
85b1c36d 175static unsigned long dynamic_strings_length;
2cf0635d 176static char * string_table;
85b1c36d
BE		 177static unsigned long string_table_length;
178static unsigned long num_dynamic_syms;
2cf0635d
NC		 179static Elf_Internal_Sym * dynamic_symbols;
180static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 181static unsigned long dynamic_syminfo_offset;
182static unsigned int dynamic_syminfo_nent;
f8eae8b2 183static char program_interpreter[PATH_MAX];
bb8a0291 184static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 185static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 186static bfd_vma version_info[16];
187static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 188static Elf_Internal_Shdr * section_headers;
189static Elf_Internal_Phdr * program_headers;
190static Elf_Internal_Dyn * dynamic_section;
191static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 192static int show_name;
193static int do_dynamic;
194static int do_syms;
2c610e4b 195static int do_dyn_syms;
85b1c36d
BE		 196static int do_reloc;
197static int do_sections;
198static int do_section_groups;
5477e8a0 199static int do_section_details;
85b1c36d
BE		 200static int do_segments;
201static int do_unwind;
202static int do_using_dynamic;
203static int do_header;
204static int do_dump;
205static int do_version;
85b1c36d
BE		 206static int do_histogram;
207static int do_debugging;
85b1c36d
BE		 208static int do_arch;
209static int do_notes;
4145f1d5 210static int do_archive_index;
85b1c36d 211static int is_32bit_elf;
252b5132 212
e4b17d5c
L		 213struct group_list
214{
2cf0635d 215 struct group_list * next;
e4b17d5c
L		 216 unsigned int section_index;
217};
218
219struct group
220{
2cf0635d 221 struct group_list * root;
e4b17d5c
L		 222 unsigned int group_index;
223};
224
85b1c36d 225static size_t group_count;
2cf0635d
NC		 226static struct group * section_groups;
227static struct group ** section_headers_groups;
e4b17d5c 228
09c11c86
NC		 229
230/* Flag bits indicating particular types of dump. */
231#define HEX_DUMP (1 << 0) /* The -x command line switch. */
232#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
233#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
234#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 235#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 236
237typedef unsigned char dump_type;
238
239/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 240struct dump_list_entry
241{
2cf0635d 242 char * name;
09c11c86 243 dump_type type;
2cf0635d 244 struct dump_list_entry * next;
aef1f6d0 245};
2cf0635d 246static struct dump_list_entry * dump_sects_byname;
aef1f6d0 247
09c11c86
NC		 248/* A dynamic array of flags indicating for which sections a dump
249 has been requested via command line switches. */
250static dump_type * cmdline_dump_sects = NULL;
251static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 252
253/* A dynamic array of flags indicating for which sections a dump of
254 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 255 basis and then initialised from the cmdline_dump_sects array,
256 the results of interpreting the -w switch, and the
257 dump_sects_byname list. */
09c11c86
NC		 258static dump_type * dump_sects = NULL;
259static unsigned int num_dump_sects = 0;
252b5132 260
252b5132 261
c256ffe7 262/* How to print a vma value. */
843dd992
NC		 263typedef enum print_mode
264{
265 HEX,
266 DEC,
267 DEC_5,
268 UNSIGNED,
269 PREFIX_HEX,
270 FULL_HEX,
271 LONG_HEX
272}
273print_mode;
274
bb4d2ac2
L		 275/* Versioned symbol info. */
276enum versioned_symbol_info
277{
278 symbol_undefined,
279 symbol_hidden,
280 symbol_public
281};
282
283static const char *get_symbol_version_string
284 (FILE *file, int is_dynsym, const char *strtab,
285 unsigned long int strtab_size, unsigned int si,
286 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
287 unsigned short *vna_other);
288
9c19a809
NC		 289#define UNKNOWN -1
290
2b692964
NC		 291#define SECTION_NAME(X) \
292 ((X) == NULL ? _("<none>") \
293 : string_table == NULL ? _("<no-name>") \
294 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 295 : string_table + (X)->sh_name))
252b5132 296
ee42cf8c 297#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 298
ba5cdace
NC		 299#define GET_ELF_SYMBOLS(file, section, sym_count) \
300 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
301 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 302
d79b3d50
NC		 303#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
304/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
305 already been called and verified that the string exists. */
306#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 307
61865e30
NC		 308#define REMOVE_ARCH_BITS(ADDR) \
309 do \
310 { \
311 if (elf_header.e_machine == EM_ARM) \
312 (ADDR) &= ~1; \
313 } \
314 while (0)
d79b3d50 315\f
c9c1d674
EG		 316/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
317 the offset of the current archive member, if we are examining an archive.
59245841
NC		 318 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
319 using malloc and fill that. In either case return the pointer to the start of
320 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 321 and REASON is not NULL then emit an error message using REASON as part of the
322 context. */
59245841 323
c256ffe7 324static void *
57028622
NC		 325get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
326 bfd_size_type nmemb, const char * reason)
a6e9f9df 327{
2cf0635d 328 void * mvar;
57028622 329 bfd_size_type amt = size * nmemb;
a6e9f9df 330
c256ffe7 331 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 332 return NULL;
333
57028622
NC		 334 /* If the size_t type is smaller than the bfd_size_type, eg because
335 you are building a 32-bit tool on a 64-bit host, then make sure
336 that when the sizes are cast to (size_t) no information is lost. */
337 if (sizeof (size_t) < sizeof (bfd_size_type)
338 && ( (bfd_size_type) ((size_t) size) != size
339 || (bfd_size_type) ((size_t) nmemb) != nmemb))
340 {
341 if (reason)
342 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
343 (unsigned long long) nmemb, (unsigned long long) size, reason);
344 return NULL;
345 }
346
347 /* Check for size overflow. */
348 if (amt < nmemb)
349 {
350 if (reason)
351 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
352 (unsigned long long) nmemb, (unsigned long long) size, reason);
353 return NULL;
354 }
355
c9c1d674
EG		 356 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
357 attempting to allocate memory when the read is bound to fail. */
358 if (amt > current_file_size
359 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 360 {
049b0c3a 361 if (reason)
57028622
NC		 362 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
363 (unsigned long long) amt, reason);
a6e9f9df
AM		 364 return NULL;
365 }
366
c9c1d674 367 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 368 {
369 if (reason)
c9c1d674
EG		 370 error (_("Unable to seek to 0x%lx for %s\n"),
371 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 372 return NULL;
373 }
374
a6e9f9df
AM		 375 mvar = var;
376 if (mvar == NULL)
377 {
c256ffe7 378 /* Check for overflow. */
57028622 379 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 380 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 381 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 382
383 if (mvar == NULL)
384 {
049b0c3a 385 if (reason)
57028622
NC		 386 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
387 (unsigned long long) amt, reason);
a6e9f9df
AM		 388 return NULL;
389 }
c256ffe7 390
c9c1d674 391 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 392 }
393
57028622 394 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 395 {
049b0c3a 396 if (reason)
57028622
NC		 397 error (_("Unable to read in 0x%llx bytes of %s\n"),
398 (unsigned long long) amt, reason);
a6e9f9df
AM		 399 if (mvar != var)
400 free (mvar);
401 return NULL;
402 }
403
404 return mvar;
405}
406
14a91970 407/* Print a VMA value. */
cb8f3167 408
66543521 409static int
14a91970 410print_vma (bfd_vma vma, print_mode mode)
66543521 411{
66543521
AM		 412 int nc = 0;
413
14a91970 414 switch (mode)
66543521 415 {
14a91970
AM		 416 case FULL_HEX:
417 nc = printf ("0x");
418 /* Drop through. */
66543521 419
14a91970 420 case LONG_HEX:
f7a99963 421#ifdef BFD64
14a91970 422 if (is_32bit_elf)
437c2fb7 423 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 424#endif
14a91970
AM		 425 printf_vma (vma);
426 return nc + 16;
b19aac67 427
14a91970
AM		 428 case DEC_5:
429 if (vma <= 99999)
430 return printf ("%5" BFD_VMA_FMT "d", vma);
431 /* Drop through. */
66543521 432
14a91970
AM		 433 case PREFIX_HEX:
434 nc = printf ("0x");
435 /* Drop through. */
66543521 436
14a91970
AM		 437 case HEX:
438 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 439
14a91970
AM		 440 case DEC:
441 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 442
14a91970
AM		 443 case UNSIGNED:
444 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 445 }
66543521 446 return 0;
f7a99963
NC		 447}
448
7bfd842d 449/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 450 multibye characters (assuming the host environment supports them).
31104126 451
7bfd842d
NC		 452 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
453
454 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
455 padding as necessary.
171191ba
NC		 456
457 Returns the number of emitted characters. */
458
459static unsigned int
7a88bc9c 460print_symbol (int width, const char *symbol)
31104126 461{
171191ba 462 bfd_boolean extra_padding = FALSE;
7bfd842d 463 int num_printed = 0;
3bfcb652 464#ifdef HAVE_MBSTATE_T
7bfd842d 465 mbstate_t state;
3bfcb652 466#endif
7bfd842d 467 int width_remaining;
961c521f 468
7bfd842d 469 if (width < 0)
961c521f 470 {
961c521f
NC		 471 /* Keep the width positive. This also helps. */
472 width = - width;
171191ba 473 extra_padding = TRUE;
0b4362b0 474 }
74e1a04b 475 assert (width != 0);
961c521f 476
7bfd842d
NC		 477 if (do_wide)
478 /* Set the remaining width to a very large value.
479 This simplifies the code below. */
480 width_remaining = INT_MAX;
481 else
482 width_remaining = width;
cb8f3167 483
3bfcb652 484#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 485 /* Initialise the multibyte conversion state. */
486 memset (& state, 0, sizeof (state));
3bfcb652 487#endif
961c521f 488
7bfd842d
NC		 489 while (width_remaining)
490 {
491 size_t n;
7bfd842d 492 const char c = *symbol++;
961c521f 493
7bfd842d 494 if (c == 0)
961c521f
NC		 495 break;
496
7bfd842d
NC		 497 /* Do not print control characters directly as they can affect terminal
498 settings. Such characters usually appear in the names generated
499 by the assembler for local labels. */
500 if (ISCNTRL (c))
961c521f 501 {
7bfd842d 502 if (width_remaining < 2)
961c521f
NC		 503 break;
504
7bfd842d
NC		 505 printf ("^%c", c + 0x40);
506 width_remaining -= 2;
171191ba 507 num_printed += 2;
961c521f 508 }
7bfd842d
NC		 509 else if (ISPRINT (c))
510 {
511 putchar (c);
512 width_remaining --;
513 num_printed ++;
514 }
961c521f
NC		 515 else
516 {
3bfcb652
NC		 517#ifdef HAVE_MBSTATE_T
518 wchar_t w;
519#endif
7bfd842d
NC		 520 /* Let printf do the hard work of displaying multibyte characters. */
521 printf ("%.1s", symbol - 1);
522 width_remaining --;
523 num_printed ++;
524
3bfcb652 525#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 526 /* Try to find out how many bytes made up the character that was
527 just printed. Advance the symbol pointer past the bytes that
528 were displayed. */
529 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 530#else
531 n = 1;
532#endif
7bfd842d
NC		 533 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
534 symbol += (n - 1);
961c521f 535 }
961c521f 536 }
171191ba 537
7bfd842d 538 if (extra_padding && num_printed < width)
171191ba
NC		 539 {
540 /* Fill in the remaining spaces. */
7bfd842d
NC		 541 printf ("%-*s", width - num_printed, " ");
542 num_printed = width;
171191ba
NC		 543 }
544
545 return num_printed;
31104126
NC		 546}
547
74e1a04b
NC		 548/* Returns a pointer to a static buffer containing a printable version of
549 the given section's name. Like print_symbol, except that it does not try
550 to print multibyte characters, it just interprets them as hex values. */
551
552static const char *
553printable_section_name (Elf_Internal_Shdr * sec)
554{
555#define MAX_PRINT_SEC_NAME_LEN 128
556 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
557 const char * name = SECTION_NAME (sec);
558 char * buf = sec_name_buf;
559 char c;
560 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
561
562 while ((c = * name ++) != 0)
563 {
564 if (ISCNTRL (c))
565 {
566 if (remaining < 2)
567 break;
948f632f 568
74e1a04b
NC		 569 * buf ++ = '^';
570 * buf ++ = c + 0x40;
571 remaining -= 2;
572 }
573 else if (ISPRINT (c))
574 {
575 * buf ++ = c;
576 remaining -= 1;
577 }
578 else
579 {
580 static char hex[17] = "0123456789ABCDEF";
581
582 if (remaining < 4)
583 break;
584 * buf ++ = '<';
585 * buf ++ = hex[(c & 0xf0) >> 4];
586 * buf ++ = hex[c & 0x0f];
587 * buf ++ = '>';
588 remaining -= 4;
589 }
590
591 if (remaining == 0)
592 break;
593 }
594
595 * buf = 0;
596 return sec_name_buf;
597}
598
599static const char *
600printable_section_name_from_index (unsigned long ndx)
601{
602 if (ndx >= elf_header.e_shnum)
603 return _("<corrupt>");
604
605 return printable_section_name (section_headers + ndx);
606}
607
89fac5e3
RS		 608/* Return a pointer to section NAME, or NULL if no such section exists. */
609
610static Elf_Internal_Shdr *
2cf0635d 611find_section (const char * name)
89fac5e3
RS		 612{
613 unsigned int i;
614
615 for (i = 0; i < elf_header.e_shnum; i++)
616 if (streq (SECTION_NAME (section_headers + i), name))
617 return section_headers + i;
618
619 return NULL;
620}
621
0b6ae522
DJ		 622/* Return a pointer to a section containing ADDR, or NULL if no such
623 section exists. */
624
625static Elf_Internal_Shdr *
626find_section_by_address (bfd_vma addr)
627{
628 unsigned int i;
629
630 for (i = 0; i < elf_header.e_shnum; i++)
631 {
632 Elf_Internal_Shdr *sec = section_headers + i;
633 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
634 return sec;
635 }
636
637 return NULL;
638}
639
071436c6
NC		 640static Elf_Internal_Shdr *
641find_section_by_type (unsigned int type)
642{
643 unsigned int i;
644
645 for (i = 0; i < elf_header.e_shnum; i++)
646 {
647 Elf_Internal_Shdr *sec = section_headers + i;
648 if (sec->sh_type == type)
649 return sec;
650 }
651
652 return NULL;
653}
654
657d0d47
CC		 655/* Return a pointer to section NAME, or NULL if no such section exists,
656 restricted to the list of sections given in SET. */
657
658static Elf_Internal_Shdr *
659find_section_in_set (const char * name, unsigned int * set)
660{
661 unsigned int i;
662
663 if (set != NULL)
664 {
665 while ((i = *set++) > 0)
666 if (streq (SECTION_NAME (section_headers + i), name))
667 return section_headers + i;
668 }
669
670 return find_section (name);
671}
672
0b6ae522
DJ		 673/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
674 bytes read. */
675
f6f0e17b
NC		 676static inline unsigned long
677read_uleb128 (unsigned char *data,
678 unsigned int *length_return,
679 const unsigned char * const end)
0b6ae522 680{
f6f0e17b 681 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 682}
683
28f997cf
TG		 684/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
685 This OS has so many departures from the ELF standard that we test it at
686 many places. */
687
688static inline int
689is_ia64_vms (void)
690{
691 return elf_header.e_machine == EM_IA_64
692 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
693}
694
bcedfee6 695/* Guess the relocation size commonly used by the specific machines. */
252b5132 696
252b5132 697static int
2dc4cec1 698guess_is_rela (unsigned int e_machine)
252b5132 699{
9c19a809 700 switch (e_machine)
252b5132
RH		 701 {
702 /* Targets that use REL relocations. */
252b5132
RH		 703 case EM_386:
704 case EM_486:
63fcb9e9 705 case EM_960:
e9f53129 706 case EM_ARM:
2b0337b0 707 case EM_D10V:
252b5132 708 case EM_CYGNUS_D10V:
e9f53129 709 case EM_DLX:
252b5132 710 case EM_MIPS:
4fe85591 711 case EM_MIPS_RS3_LE:
e9f53129 712 case EM_CYGNUS_M32R:
1c0d3aa6 713 case EM_SCORE:
f6c1a2d5 714 case EM_XGATE:
9c19a809 715 return FALSE;
103f02d3 716
252b5132
RH		 717 /* Targets that use RELA relocations. */
718 case EM_68K:
e9f53129 719 case EM_860:
a06ea964 720 case EM_AARCH64:
cfb8c092 721 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 722 case EM_ALPHA:
723 case EM_ALTERA_NIOS2:
724 case EM_AVR:
725 case EM_AVR_OLD:
726 case EM_BLACKFIN:
60bca95a 727 case EM_CR16:
e9f53129
AM		 728 case EM_CRIS:
729 case EM_CRX:
2b0337b0 730 case EM_D30V:
252b5132 731 case EM_CYGNUS_D30V:
2b0337b0 732 case EM_FR30:
3f8107ab 733 case EM_FT32:
252b5132 734 case EM_CYGNUS_FR30:
5c70f934 735 case EM_CYGNUS_FRV:
e9f53129
AM		 736 case EM_H8S:
737 case EM_H8_300:
738 case EM_H8_300H:
800eeca4 739 case EM_IA_64:
1e4cf259
NC		 740 case EM_IP2K:
741 case EM_IP2K_OLD:
3b36097d 742 case EM_IQ2000:
84e94c90 743 case EM_LATTICEMICO32:
ff7eeb89 744 case EM_M32C_OLD:
49f58d10 745 case EM_M32C:
e9f53129
AM		 746 case EM_M32R:
747 case EM_MCORE:
15ab5209 748 case EM_CYGNUS_MEP:
a3c62988 749 case EM_METAG:
e9f53129
AM		 750 case EM_MMIX:
751 case EM_MN10200:
752 case EM_CYGNUS_MN10200:
753 case EM_MN10300:
754 case EM_CYGNUS_MN10300:
5506d11a 755 case EM_MOXIE:
e9f53129
AM		 756 case EM_MSP430:
757 case EM_MSP430_OLD:
d031aafb 758 case EM_MT:
35c08157 759 case EM_NDS32:
64fd6348 760 case EM_NIOS32:
73589c9d 761 case EM_OR1K:
e9f53129
AM		 762 case EM_PPC64:
763 case EM_PPC:
99c513f6 764 case EM_RL78:
c7927a3c 765 case EM_RX:
e9f53129
AM		 766 case EM_S390:
767 case EM_S390_OLD:
768 case EM_SH:
769 case EM_SPARC:
770 case EM_SPARC32PLUS:
771 case EM_SPARCV9:
772 case EM_SPU:
40b36596 773 case EM_TI_C6000:
aa137e4d
NC		 774 case EM_TILEGX:
775 case EM_TILEPRO:
708e2187 776 case EM_V800:
e9f53129
AM		 777 case EM_V850:
778 case EM_CYGNUS_V850:
779 case EM_VAX:
619ed720 780 case EM_VISIUM:
e9f53129 781 case EM_X86_64:
8a9036a4 782 case EM_L1OM:
7a9068fe 783 case EM_K1OM:
e9f53129
AM		 784 case EM_XSTORMY16:
785 case EM_XTENSA:
786 case EM_XTENSA_OLD:
7ba29e2a
NC		 787 case EM_MICROBLAZE:
788 case EM_MICROBLAZE_OLD:
9c19a809 789 return TRUE;
103f02d3 790
e9f53129
AM		 791 case EM_68HC05:
792 case EM_68HC08:
793 case EM_68HC11:
794 case EM_68HC16:
795 case EM_FX66:
796 case EM_ME16:
d1133906 797 case EM_MMA:
d1133906
NC		 798 case EM_NCPU:
799 case EM_NDR1:
e9f53129 800 case EM_PCP:
d1133906 801 case EM_ST100:
e9f53129 802 case EM_ST19:
d1133906 803 case EM_ST7:
e9f53129
AM		 804 case EM_ST9PLUS:
805 case EM_STARCORE:
d1133906 806 case EM_SVX:
e9f53129 807 case EM_TINYJ:
9c19a809
NC		 808 default:
809 warn (_("Don't know about relocations on this machine architecture\n"));
810 return FALSE;
811 }
812}
252b5132 813
9c19a809 814static int
2cf0635d 815slurp_rela_relocs (FILE * file,
d3ba0551
AM		 816 unsigned long rel_offset,
817 unsigned long rel_size,
2cf0635d
NC		 818 Elf_Internal_Rela ** relasp,
819 unsigned long * nrelasp)
9c19a809 820{
2cf0635d 821 Elf_Internal_Rela * relas;
8b73c356 822 size_t nrelas;
4d6ed7c8 823 unsigned int i;
252b5132 824
4d6ed7c8
NC		 825 if (is_32bit_elf)
826 {
2cf0635d 827 Elf32_External_Rela * erelas;
103f02d3 828
3f5e193b 829 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 830 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 831 if (!erelas)
832 return 0;
252b5132 833
4d6ed7c8 834 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 835
3f5e193b
NC		 836 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
837 sizeof (Elf_Internal_Rela));
103f02d3 838
4d6ed7c8
NC		 839 if (relas == NULL)
840 {
c256ffe7 841 free (erelas);
591a748a 842 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 843 return 0;
844 }
103f02d3 845
4d6ed7c8
NC		 846 for (i = 0; i < nrelas; i++)
847 {
848 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
849 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 850 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 851 }
103f02d3 852
4d6ed7c8
NC		 853 free (erelas);
854 }
855 else
856 {
2cf0635d 857 Elf64_External_Rela * erelas;
103f02d3 858
3f5e193b 859 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 860 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 861 if (!erelas)
862 return 0;
4d6ed7c8
NC		 863
864 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 865
3f5e193b
NC		 866 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
867 sizeof (Elf_Internal_Rela));
103f02d3 868
4d6ed7c8
NC		 869 if (relas == NULL)
870 {
c256ffe7 871 free (erelas);
591a748a 872 error (_("out of memory parsing relocs\n"));
4d6ed7c8 873 return 0;
9c19a809 874 }
4d6ed7c8
NC		 875
876 for (i = 0; i < nrelas; i++)
9c19a809 877 {
66543521
AM		 878 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
879 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 880 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 881
882 /* The #ifdef BFD64 below is to prevent a compile time
883 warning. We know that if we do not have a 64 bit data
884 type that we will never execute this code anyway. */
885#ifdef BFD64
886 if (elf_header.e_machine == EM_MIPS
887 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
888 {
889 /* In little-endian objects, r_info isn't really a
890 64-bit little-endian value: it has a 32-bit
891 little-endian symbol index followed by four
892 individual byte fields. Reorder INFO
893 accordingly. */
91d6fa6a
NC		 894 bfd_vma inf = relas[i].r_info;
895 inf = (((inf & 0xffffffff) << 32)
896 | ((inf >> 56) & 0xff)
897 | ((inf >> 40) & 0xff00)
898 | ((inf >> 24) & 0xff0000)
899 | ((inf >> 8) & 0xff000000));
900 relas[i].r_info = inf;
861fb55a
DJ		 901 }
902#endif /* BFD64 */
4d6ed7c8 903 }
103f02d3 904
4d6ed7c8
NC		 905 free (erelas);
906 }
907 *relasp = relas;
908 *nrelasp = nrelas;
909 return 1;
910}
103f02d3 911
4d6ed7c8 912static int
2cf0635d 913slurp_rel_relocs (FILE * file,
d3ba0551
AM		 914 unsigned long rel_offset,
915 unsigned long rel_size,
2cf0635d
NC		 916 Elf_Internal_Rela ** relsp,
917 unsigned long * nrelsp)
4d6ed7c8 918{
2cf0635d 919 Elf_Internal_Rela * rels;
8b73c356 920 size_t nrels;
4d6ed7c8 921 unsigned int i;
103f02d3 922
4d6ed7c8
NC		 923 if (is_32bit_elf)
924 {
2cf0635d 925 Elf32_External_Rel * erels;
103f02d3 926
3f5e193b 927 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 928 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 929 if (!erels)
930 return 0;
103f02d3 931
4d6ed7c8 932 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 933
3f5e193b 934 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 935
4d6ed7c8
NC		 936 if (rels == NULL)
937 {
c256ffe7 938 free (erels);
591a748a 939 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 940 return 0;
941 }
942
943 for (i = 0; i < nrels; i++)
944 {
945 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
946 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 947 rels[i].r_addend = 0;
9ea033b2 948 }
4d6ed7c8
NC		 949
950 free (erels);
9c19a809
NC		 951 }
952 else
953 {
2cf0635d 954 Elf64_External_Rel * erels;
9ea033b2 955
3f5e193b 956 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 957 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 958 if (!erels)
959 return 0;
103f02d3 960
4d6ed7c8 961 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 962
3f5e193b 963 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 964
4d6ed7c8 965 if (rels == NULL)
9c19a809 966 {
c256ffe7 967 free (erels);
591a748a 968 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 969 return 0;
970 }
103f02d3 971
4d6ed7c8
NC		 972 for (i = 0; i < nrels; i++)
973 {
66543521
AM		 974 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
975 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 976 rels[i].r_addend = 0;
861fb55a
DJ		 977
978 /* The #ifdef BFD64 below is to prevent a compile time
979 warning. We know that if we do not have a 64 bit data
980 type that we will never execute this code anyway. */
981#ifdef BFD64
982 if (elf_header.e_machine == EM_MIPS
983 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
984 {
985 /* In little-endian objects, r_info isn't really a
986 64-bit little-endian value: it has a 32-bit
987 little-endian symbol index followed by four
988 individual byte fields. Reorder INFO
989 accordingly. */
91d6fa6a
NC		 990 bfd_vma inf = rels[i].r_info;
991 inf = (((inf & 0xffffffff) << 32)
992 | ((inf >> 56) & 0xff)
993 | ((inf >> 40) & 0xff00)
994 | ((inf >> 24) & 0xff0000)
995 | ((inf >> 8) & 0xff000000));
996 rels[i].r_info = inf;
861fb55a
DJ		 997 }
998#endif /* BFD64 */
4d6ed7c8 999 }
103f02d3 1000
4d6ed7c8
NC		 1001 free (erels);
1002 }
1003 *relsp = rels;
1004 *nrelsp = nrels;
1005 return 1;
1006}
103f02d3 1007
aca88567
NC		 1008/* Returns the reloc type extracted from the reloc info field. */
1009
1010static unsigned int
1011get_reloc_type (bfd_vma reloc_info)
1012{
1013 if (is_32bit_elf)
1014 return ELF32_R_TYPE (reloc_info);
1015
1016 switch (elf_header.e_machine)
1017 {
1018 case EM_MIPS:
1019 /* Note: We assume that reloc_info has already been adjusted for us. */
1020 return ELF64_MIPS_R_TYPE (reloc_info);
1021
1022 case EM_SPARCV9:
1023 return ELF64_R_TYPE_ID (reloc_info);
1024
1025 default:
1026 return ELF64_R_TYPE (reloc_info);
1027 }
1028}
1029
1030/* Return the symbol index extracted from the reloc info field. */
1031
1032static bfd_vma
1033get_reloc_symindex (bfd_vma reloc_info)
1034{
1035 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1036}
1037
13761a11
NC		 1038static inline bfd_boolean
1039uses_msp430x_relocs (void)
1040{
1041 return
1042 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1043 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1044 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1045 /* TI compiler uses ELFOSABI_NONE. */
1046 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1047}
1048
d3ba0551
AM		 1049/* Display the contents of the relocation data found at the specified
1050 offset. */
ee42cf8c 1051
41e92641 1052static void
2cf0635d 1053dump_relocations (FILE * file,
d3ba0551
AM		 1054 unsigned long rel_offset,
1055 unsigned long rel_size,
2cf0635d 1056 Elf_Internal_Sym * symtab,
d3ba0551 1057 unsigned long nsyms,
2cf0635d 1058 char * strtab,
d79b3d50 1059 unsigned long strtablen,
bb4d2ac2
L		 1060 int is_rela,
1061 int is_dynsym)
4d6ed7c8 1062{
b34976b6 1063 unsigned int i;
2cf0635d 1064 Elf_Internal_Rela * rels;
103f02d3 1065
4d6ed7c8
NC		 1066 if (is_rela == UNKNOWN)
1067 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1068
4d6ed7c8
NC		 1069 if (is_rela)
1070 {
c8286bd1 1071 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1072 return;
4d6ed7c8
NC		 1073 }
1074 else
1075 {
1076 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1077 return;
252b5132
RH		 1078 }
1079
410f7a12
L		 1080 if (is_32bit_elf)
1081 {
1082 if (is_rela)
2c71103e
NC		 1083 {
1084 if (do_wide)
1085 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1086 else
1087 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1088 }
410f7a12 1089 else
2c71103e
NC		 1090 {
1091 if (do_wide)
1092 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1093 else
1094 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1095 }
410f7a12 1096 }
252b5132 1097 else
410f7a12
L		 1098 {
1099 if (is_rela)
2c71103e
NC		 1100 {
1101 if (do_wide)
8beeaeb7 1102 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1103 else
1104 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1105 }
410f7a12 1106 else
2c71103e
NC		 1107 {
1108 if (do_wide)
8beeaeb7 1109 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1110 else
1111 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1112 }
410f7a12 1113 }
252b5132
RH		 1114
1115 for (i = 0; i < rel_size; i++)
1116 {
2cf0635d 1117 const char * rtype;
b34976b6 1118 bfd_vma offset;
91d6fa6a 1119 bfd_vma inf;
b34976b6
AM		 1120 bfd_vma symtab_index;
1121 bfd_vma type;
103f02d3 1122
b34976b6 1123 offset = rels[i].r_offset;
91d6fa6a 1124 inf = rels[i].r_info;
103f02d3 1125
91d6fa6a
NC		 1126 type = get_reloc_type (inf);
1127 symtab_index = get_reloc_symindex (inf);
252b5132 1128
410f7a12
L		 1129 if (is_32bit_elf)
1130 {
39dbeff8
AM		 1131 printf ("%8.8lx %8.8lx ",
1132 (unsigned long) offset & 0xffffffff,
91d6fa6a 1133 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1134 }
1135 else
1136 {
39dbeff8
AM		 1137#if BFD_HOST_64BIT_LONG
1138 printf (do_wide
1139 ? "%16.16lx %16.16lx "
1140 : "%12.12lx %12.12lx ",
91d6fa6a 1141 offset, inf);
39dbeff8 1142#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1143#ifndef __MSVCRT__
39dbeff8
AM		 1144 printf (do_wide
1145 ? "%16.16llx %16.16llx "
1146 : "%12.12llx %12.12llx ",
91d6fa6a 1147 offset, inf);
6e3d6dc1
NC		 1148#else
1149 printf (do_wide
1150 ? "%16.16I64x %16.16I64x "
1151 : "%12.12I64x %12.12I64x ",
91d6fa6a 1152 offset, inf);
6e3d6dc1 1153#endif
39dbeff8 1154#else
2c71103e
NC		 1155 printf (do_wide
1156 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1157 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1158 _bfd_int64_high (offset),
1159 _bfd_int64_low (offset),
91d6fa6a
NC		 1160 _bfd_int64_high (inf),
1161 _bfd_int64_low (inf));
9ea033b2 1162#endif
410f7a12 1163 }
103f02d3 1164
252b5132
RH		 1165 switch (elf_header.e_machine)
1166 {
1167 default:
1168 rtype = NULL;
1169 break;
1170
a06ea964
NC		 1171 case EM_AARCH64:
1172 rtype = elf_aarch64_reloc_type (type);
1173 break;
1174
2b0337b0 1175 case EM_M32R:
252b5132 1176 case EM_CYGNUS_M32R:
9ea033b2 1177 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1178 break;
1179
1180 case EM_386:
1181 case EM_486:
9ea033b2 1182 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1183 break;
1184
ba2685cc
AM		 1185 case EM_68HC11:
1186 case EM_68HC12:
1187 rtype = elf_m68hc11_reloc_type (type);
1188 break;
75751cd9 1189
252b5132 1190 case EM_68K:
9ea033b2 1191 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1192 break;
1193
63fcb9e9 1194 case EM_960:
9ea033b2 1195 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1196 break;
1197
adde6300 1198 case EM_AVR:
2b0337b0 1199 case EM_AVR_OLD:
adde6300
AM		 1200 rtype = elf_avr_reloc_type (type);
1201 break;
1202
9ea033b2
NC		 1203 case EM_OLD_SPARCV9:
1204 case EM_SPARC32PLUS:
1205 case EM_SPARCV9:
252b5132 1206 case EM_SPARC:
9ea033b2 1207 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1208 break;
1209
e9f53129
AM		 1210 case EM_SPU:
1211 rtype = elf_spu_reloc_type (type);
1212 break;
1213
708e2187
NC		 1214 case EM_V800:
1215 rtype = v800_reloc_type (type);
1216 break;
2b0337b0 1217 case EM_V850:
252b5132 1218 case EM_CYGNUS_V850:
9ea033b2 1219 rtype = v850_reloc_type (type);
252b5132
RH		 1220 break;
1221
2b0337b0 1222 case EM_D10V:
252b5132 1223 case EM_CYGNUS_D10V:
9ea033b2 1224 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1225 break;
1226
2b0337b0 1227 case EM_D30V:
252b5132 1228 case EM_CYGNUS_D30V:
9ea033b2 1229 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1230 break;
1231
d172d4ba
NC		 1232 case EM_DLX:
1233 rtype = elf_dlx_reloc_type (type);
1234 break;
1235
252b5132 1236 case EM_SH:
9ea033b2 1237 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1238 break;
1239
2b0337b0 1240 case EM_MN10300:
252b5132 1241 case EM_CYGNUS_MN10300:
9ea033b2 1242 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1243 break;
1244
2b0337b0 1245 case EM_MN10200:
252b5132 1246 case EM_CYGNUS_MN10200:
9ea033b2 1247 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1248 break;
1249
2b0337b0 1250 case EM_FR30:
252b5132 1251 case EM_CYGNUS_FR30:
9ea033b2 1252 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1253 break;
1254
ba2685cc
AM		 1255 case EM_CYGNUS_FRV:
1256 rtype = elf_frv_reloc_type (type);
1257 break;
5c70f934 1258
3f8107ab
AM		 1259 case EM_FT32:
1260 rtype = elf_ft32_reloc_type (type);
1261 break;
1262
252b5132 1263 case EM_MCORE:
9ea033b2 1264 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1265 break;
1266
3c3bdf30
NC		 1267 case EM_MMIX:
1268 rtype = elf_mmix_reloc_type (type);
1269 break;
1270
5506d11a
AM		 1271 case EM_MOXIE:
1272 rtype = elf_moxie_reloc_type (type);
1273 break;
1274
2469cfa2 1275 case EM_MSP430:
13761a11
NC		 1276 if (uses_msp430x_relocs ())
1277 {
1278 rtype = elf_msp430x_reloc_type (type);
1279 break;
1280 }
2469cfa2
NC		 1281 case EM_MSP430_OLD:
1282 rtype = elf_msp430_reloc_type (type);
1283 break;
1284
35c08157
KLC		 1285 case EM_NDS32:
1286 rtype = elf_nds32_reloc_type (type);
1287 break;
1288
252b5132 1289 case EM_PPC:
9ea033b2 1290 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1291 break;
1292
c833c019
AM		 1293 case EM_PPC64:
1294 rtype = elf_ppc64_reloc_type (type);
1295 break;
1296
252b5132 1297 case EM_MIPS:
4fe85591 1298 case EM_MIPS_RS3_LE:
9ea033b2 1299 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1300 break;
1301
1302 case EM_ALPHA:
9ea033b2 1303 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1304 break;
1305
1306 case EM_ARM:
9ea033b2 1307 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1308 break;
1309
584da044 1310 case EM_ARC:
9ea033b2 1311 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1312 break;
1313
1314 case EM_PARISC:
69e617ca 1315 rtype = elf_hppa_reloc_type (type);
252b5132 1316 break;
7d466069 1317
b8720f9d
JL		 1318 case EM_H8_300:
1319 case EM_H8_300H:
1320 case EM_H8S:
1321 rtype = elf_h8_reloc_type (type);
1322 break;
1323
73589c9d
CS		 1324 case EM_OR1K:
1325 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1326 break;
1327
7d466069 1328 case EM_PJ:
2b0337b0 1329 case EM_PJ_OLD:
7d466069
ILT		 1330 rtype = elf_pj_reloc_type (type);
1331 break;
800eeca4
JW		 1332 case EM_IA_64:
1333 rtype = elf_ia64_reloc_type (type);
1334 break;
1b61cf92
HPN		 1335
1336 case EM_CRIS:
1337 rtype = elf_cris_reloc_type (type);
1338 break;
535c37ff
JE		 1339
1340 case EM_860:
1341 rtype = elf_i860_reloc_type (type);
1342 break;
bcedfee6
NC		 1343
1344 case EM_X86_64:
8a9036a4 1345 case EM_L1OM:
7a9068fe 1346 case EM_K1OM:
bcedfee6
NC		 1347 rtype = elf_x86_64_reloc_type (type);
1348 break;
a85d7ed0 1349
35b1837e
AM		 1350 case EM_S370:
1351 rtype = i370_reloc_type (type);
1352 break;
1353
53c7db4b
KH		 1354 case EM_S390_OLD:
1355 case EM_S390:
1356 rtype = elf_s390_reloc_type (type);
1357 break;
93fbbb04 1358
1c0d3aa6
NC		 1359 case EM_SCORE:
1360 rtype = elf_score_reloc_type (type);
1361 break;
1362
93fbbb04
GK		 1363 case EM_XSTORMY16:
1364 rtype = elf_xstormy16_reloc_type (type);
1365 break;
179d3252 1366
1fe1f39c
NC		 1367 case EM_CRX:
1368 rtype = elf_crx_reloc_type (type);
1369 break;
1370
179d3252
JT		 1371 case EM_VAX:
1372 rtype = elf_vax_reloc_type (type);
1373 break;
1e4cf259 1374
619ed720
EB		 1375 case EM_VISIUM:
1376 rtype = elf_visium_reloc_type (type);
1377 break;
1378
cfb8c092
NC		 1379 case EM_ADAPTEVA_EPIPHANY:
1380 rtype = elf_epiphany_reloc_type (type);
1381 break;
1382
1e4cf259
NC		 1383 case EM_IP2K:
1384 case EM_IP2K_OLD:
1385 rtype = elf_ip2k_reloc_type (type);
1386 break;
3b36097d
SC		 1387
1388 case EM_IQ2000:
1389 rtype = elf_iq2000_reloc_type (type);
1390 break;
88da6820
NC		 1391
1392 case EM_XTENSA_OLD:
1393 case EM_XTENSA:
1394 rtype = elf_xtensa_reloc_type (type);
1395 break;
a34e3ecb 1396
84e94c90
NC		 1397 case EM_LATTICEMICO32:
1398 rtype = elf_lm32_reloc_type (type);
1399 break;
1400
ff7eeb89 1401 case EM_M32C_OLD:
49f58d10
JB		 1402 case EM_M32C:
1403 rtype = elf_m32c_reloc_type (type);
1404 break;
1405
d031aafb
NS		 1406 case EM_MT:
1407 rtype = elf_mt_reloc_type (type);
a34e3ecb 1408 break;
1d65ded4
CM		 1409
1410 case EM_BLACKFIN:
1411 rtype = elf_bfin_reloc_type (type);
1412 break;
15ab5209
DB		 1413
1414 case EM_CYGNUS_MEP:
1415 rtype = elf_mep_reloc_type (type);
1416 break;
60bca95a
NC		 1417
1418 case EM_CR16:
1419 rtype = elf_cr16_reloc_type (type);
1420 break;
dd24e3da 1421
7ba29e2a
NC		 1422 case EM_MICROBLAZE:
1423 case EM_MICROBLAZE_OLD:
1424 rtype = elf_microblaze_reloc_type (type);
1425 break;
c7927a3c 1426
99c513f6
DD		 1427 case EM_RL78:
1428 rtype = elf_rl78_reloc_type (type);
1429 break;
1430
c7927a3c
NC		 1431 case EM_RX:
1432 rtype = elf_rx_reloc_type (type);
1433 break;
c29aca4a 1434
a3c62988
NC		 1435 case EM_METAG:
1436 rtype = elf_metag_reloc_type (type);
1437 break;
1438
c29aca4a
NC		 1439 case EM_XC16X:
1440 case EM_C166:
1441 rtype = elf_xc16x_reloc_type (type);
1442 break;
40b36596
JM		 1443
1444 case EM_TI_C6000:
1445 rtype = elf_tic6x_reloc_type (type);
1446 break;
aa137e4d
NC		 1447
1448 case EM_TILEGX:
1449 rtype = elf_tilegx_reloc_type (type);
1450 break;
1451
1452 case EM_TILEPRO:
1453 rtype = elf_tilepro_reloc_type (type);
1454 break;
f6c1a2d5
NC		 1455
1456 case EM_XGATE:
1457 rtype = elf_xgate_reloc_type (type);
1458 break;
36591ba1
SL		 1459
1460 case EM_ALTERA_NIOS2:
1461 rtype = elf_nios2_reloc_type (type);
1462 break;
252b5132
RH		 1463 }
1464
1465 if (rtype == NULL)
39dbeff8 1466 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1467 else
8beeaeb7 1468 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1469
7ace3541 1470 if (elf_header.e_machine == EM_ALPHA
157c2599 1471 && rtype != NULL
7ace3541
RH		 1472 && streq (rtype, "R_ALPHA_LITUSE")
1473 && is_rela)
1474 {
1475 switch (rels[i].r_addend)
1476 {
1477 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1478 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1479 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1480 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1481 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1482 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1483 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1484 default: rtype = NULL;
1485 }
1486 if (rtype)
1487 printf (" (%s)", rtype);
1488 else
1489 {
1490 putchar (' ');
1491 printf (_("<unknown addend: %lx>"),
1492 (unsigned long) rels[i].r_addend);
1493 }
1494 }
1495 else if (symtab_index)
252b5132 1496 {
af3fc3bc 1497 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1498 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1499 else
19936277 1500 {
2cf0635d 1501 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1502 const char * version_string;
1503 enum versioned_symbol_info sym_info;
1504 unsigned short vna_other;
19936277 1505
af3fc3bc 1506 psym = symtab + symtab_index;
103f02d3 1507
bb4d2ac2
L		 1508 version_string
1509 = get_symbol_version_string (file, is_dynsym,
1510 strtab, strtablen,
1511 symtab_index,
1512 psym,
1513 &sym_info,
1514 &vna_other);
1515
af3fc3bc 1516 printf (" ");
171191ba 1517
d8045f23
NC		 1518 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1519 {
1520 const char * name;
1521 unsigned int len;
1522 unsigned int width = is_32bit_elf ? 8 : 14;
1523
1524 /* Relocations against GNU_IFUNC symbols do not use the value
1525 of the symbol as the address to relocate against. Instead
1526 they invoke the function named by the symbol and use its
1527 result as the address for relocation.
1528
1529 To indicate this to the user, do not display the value of
1530 the symbol in the "Symbols's Value" field. Instead show
1531 its name followed by () as a hint that the symbol is
1532 invoked. */
1533
1534 if (strtab == NULL
1535 || psym->st_name == 0
1536 || psym->st_name >= strtablen)
1537 name = "??";
1538 else
1539 name = strtab + psym->st_name;
1540
1541 len = print_symbol (width, name);
bb4d2ac2
L		 1542 if (version_string)
1543 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1544 version_string);
d8045f23
NC		 1545 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1546 }
1547 else
1548 {
1549 print_vma (psym->st_value, LONG_HEX);
171191ba 1550
d8045f23
NC		 1551 printf (is_32bit_elf ? " " : " ");
1552 }
103f02d3 1553
af3fc3bc 1554 if (psym->st_name == 0)
f1ef08cb 1555 {
2cf0635d 1556 const char * sec_name = "<null>";
f1ef08cb
AM		 1557 char name_buf[40];
1558
1559 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1560 {
4fbb74a6 1561 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1562 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1563 else if (psym->st_shndx == SHN_ABS)
1564 sec_name = "ABS";
1565 else if (psym->st_shndx == SHN_COMMON)
1566 sec_name = "COMMON";
ac145307
BS		 1567 else if ((elf_header.e_machine == EM_MIPS
1568 && psym->st_shndx == SHN_MIPS_SCOMMON)
1569 || (elf_header.e_machine == EM_TI_C6000
1570 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1571 sec_name = "SCOMMON";
1572 else if (elf_header.e_machine == EM_MIPS
1573 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1574 sec_name = "SUNDEF";
8a9036a4 1575 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1576 || elf_header.e_machine == EM_L1OM
1577 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1578 && psym->st_shndx == SHN_X86_64_LCOMMON)
1579 sec_name = "LARGE_COMMON";
9ce701e2
L		 1580 else if (elf_header.e_machine == EM_IA_64
1581 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1582 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1583 sec_name = "ANSI_COM";
28f997cf 1584 else if (is_ia64_vms ()
148b93f2
NC		 1585 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1586 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1587 else
1588 {
1589 sprintf (name_buf, "<section 0x%x>",
1590 (unsigned int) psym->st_shndx);
1591 sec_name = name_buf;
1592 }
1593 }
1594 print_symbol (22, sec_name);
1595 }
af3fc3bc 1596 else if (strtab == NULL)
d79b3d50 1597 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1598 else if (psym->st_name >= strtablen)
d79b3d50 1599 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1600 else
bb4d2ac2
L		 1601 {
1602 print_symbol (22, strtab + psym->st_name);
1603 if (version_string)
1604 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1605 version_string);
1606 }
103f02d3 1607
af3fc3bc 1608 if (is_rela)
171191ba 1609 {
598aaa76 1610 bfd_signed_vma off = rels[i].r_addend;
171191ba 1611
834f871c
NC		 1612 /* PR 17531: file: 2e63226f. */
1613 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1614 printf (" + %" BFD_VMA_FMT "x", off);
1615 else if (off < 0)
598aaa76 1616 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1617 else
598aaa76 1618 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1619 }
19936277 1620 }
252b5132 1621 }
1b228002 1622 else if (is_rela)
f7a99963 1623 {
e04d7088
L		 1624 bfd_signed_vma off = rels[i].r_addend;
1625
1626 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
834f871c
NC		 1627 /* PR 17531: file: 2e63226f. */
1628 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1629 printf ("%" BFD_VMA_FMT "x", off);
1630 else if (off < 0)
e04d7088
L		 1631 printf ("-%" BFD_VMA_FMT "x", - off);
1632 else
1633 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1634 }
252b5132 1635
157c2599
NC		 1636 if (elf_header.e_machine == EM_SPARCV9
1637 && rtype != NULL
1638 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1639 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1640
252b5132 1641 putchar ('\n');
2c71103e 1642
aca88567 1643#ifdef BFD64
53c7db4b 1644 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1645 {
91d6fa6a
NC		 1646 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1647 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1648 const char * rtype2 = elf_mips_reloc_type (type2);
1649 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1650
2c71103e
NC		 1651 printf (" Type2: ");
1652
1653 if (rtype2 == NULL)
39dbeff8
AM		 1654 printf (_("unrecognized: %-7lx"),
1655 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1656 else
1657 printf ("%-17.17s", rtype2);
1658
18bd398b 1659 printf ("\n Type3: ");
2c71103e
NC		 1660
1661 if (rtype3 == NULL)
39dbeff8
AM		 1662 printf (_("unrecognized: %-7lx"),
1663 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1664 else
1665 printf ("%-17.17s", rtype3);
1666
53c7db4b 1667 putchar ('\n');
2c71103e 1668 }
aca88567 1669#endif /* BFD64 */
252b5132
RH		 1670 }
1671
c8286bd1 1672 free (rels);
252b5132
RH		 1673}
1674
1675static const char *
d3ba0551 1676get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1677{
1678 switch (type)
1679 {
1680 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1681 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1682 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1683 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1684 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1685 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1686 case DT_MIPS_MSYM: return "MIPS_MSYM";
1687 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1688 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1689 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1690 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1691 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1692 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1693 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1694 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1695 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1696 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1697 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1698 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1699 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1700 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1701 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1702 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1703 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1704 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1705 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1706 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1707 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1708 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1709 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1710 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1711 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1712 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1713 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1714 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1715 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1716 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1717 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1718 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1719 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1720 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1721 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1722 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1723 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1724 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1725 default:
1726 return NULL;
1727 }
1728}
1729
9a097730 1730static const char *
d3ba0551 1731get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1732{
1733 switch (type)
1734 {
1735 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1736 default:
1737 return NULL;
1738 }
103f02d3
UD		 1739}
1740
7490d522
AM		 1741static const char *
1742get_ppc_dynamic_type (unsigned long type)
1743{
1744 switch (type)
1745 {
a7f2871e 1746 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1747 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1748 default:
1749 return NULL;
1750 }
1751}
1752
f1cb7e17 1753static const char *
d3ba0551 1754get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1755{
1756 switch (type)
1757 {
a7f2871e
AM		 1758 case DT_PPC64_GLINK: return "PPC64_GLINK";
1759 case DT_PPC64_OPD: return "PPC64_OPD";
1760 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1761 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1762 default:
1763 return NULL;
1764 }
1765}
1766
103f02d3 1767static const char *
d3ba0551 1768get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1769{
1770 switch (type)
1771 {
1772 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1773 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1774 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1775 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1776 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1777 case DT_HP_PREINIT: return "HP_PREINIT";
1778 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1779 case DT_HP_NEEDED: return "HP_NEEDED";
1780 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1781 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1782 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1783 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1784 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1785 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1786 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1787 case DT_HP_FILTERED: return "HP_FILTERED";
1788 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1789 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1790 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1791 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1792 case DT_PLT: return "PLT";
1793 case DT_PLT_SIZE: return "PLT_SIZE";
1794 case DT_DLT: return "DLT";
1795 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1796 default:
1797 return NULL;
1798 }
1799}
9a097730 1800
ecc51f48 1801static const char *
d3ba0551 1802get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1803{
1804 switch (type)
1805 {
148b93f2
NC		 1806 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1807 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1808 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1809 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1810 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1811 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1812 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1813 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1814 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1815 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1816 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1817 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1818 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1819 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1820 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1821 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1822 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1823 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1824 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1825 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1826 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1827 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1828 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1829 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1830 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1831 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1832 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1833 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1834 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1835 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1836 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1837 default:
1838 return NULL;
1839 }
1840}
1841
fabcb361
RH		 1842static const char *
1843get_alpha_dynamic_type (unsigned long type)
1844{
1845 switch (type)
1846 {
1847 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1848 default:
1849 return NULL;
1850 }
1851}
1852
1c0d3aa6
NC		 1853static const char *
1854get_score_dynamic_type (unsigned long type)
1855{
1856 switch (type)
1857 {
1858 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1859 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1860 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1861 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1862 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1863 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1864 default:
1865 return NULL;
1866 }
1867}
1868
40b36596
JM		 1869static const char *
1870get_tic6x_dynamic_type (unsigned long type)
1871{
1872 switch (type)
1873 {
1874 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1875 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1876 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1877 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1878 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1879 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1880 default:
1881 return NULL;
1882 }
1883}
1c0d3aa6 1884
36591ba1
SL		 1885static const char *
1886get_nios2_dynamic_type (unsigned long type)
1887{
1888 switch (type)
1889 {
1890 case DT_NIOS2_GP: return "NIOS2_GP";
1891 default:
1892 return NULL;
1893 }
1894}
1895
252b5132 1896static const char *
d3ba0551 1897get_dynamic_type (unsigned long type)
252b5132 1898{
e9e44622 1899 static char buff[64];
252b5132
RH		 1900
1901 switch (type)
1902 {
1903 case DT_NULL: return "NULL";
1904 case DT_NEEDED: return "NEEDED";
1905 case DT_PLTRELSZ: return "PLTRELSZ";
1906 case DT_PLTGOT: return "PLTGOT";
1907 case DT_HASH: return "HASH";
1908 case DT_STRTAB: return "STRTAB";
1909 case DT_SYMTAB: return "SYMTAB";
1910 case DT_RELA: return "RELA";
1911 case DT_RELASZ: return "RELASZ";
1912 case DT_RELAENT: return "RELAENT";
1913 case DT_STRSZ: return "STRSZ";
1914 case DT_SYMENT: return "SYMENT";
1915 case DT_INIT: return "INIT";
1916 case DT_FINI: return "FINI";
1917 case DT_SONAME: return "SONAME";
1918 case DT_RPATH: return "RPATH";
1919 case DT_SYMBOLIC: return "SYMBOLIC";
1920 case DT_REL: return "REL";
1921 case DT_RELSZ: return "RELSZ";
1922 case DT_RELENT: return "RELENT";
1923 case DT_PLTREL: return "PLTREL";
1924 case DT_DEBUG: return "DEBUG";
1925 case DT_TEXTREL: return "TEXTREL";
1926 case DT_JMPREL: return "JMPREL";
1927 case DT_BIND_NOW: return "BIND_NOW";
1928 case DT_INIT_ARRAY: return "INIT_ARRAY";
1929 case DT_FINI_ARRAY: return "FINI_ARRAY";
1930 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1931 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1932 case DT_RUNPATH: return "RUNPATH";
1933 case DT_FLAGS: return "FLAGS";
2d0e6f43 1934
d1133906
NC		 1935 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1936 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1937
05107a46 1938 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1939 case DT_PLTPADSZ: return "PLTPADSZ";
1940 case DT_MOVEENT: return "MOVEENT";
1941 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1942 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1943 case DT_POSFLAG_1: return "POSFLAG_1";
1944 case DT_SYMINSZ: return "SYMINSZ";
1945 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1946
252b5132 1947 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1948 case DT_CONFIG: return "CONFIG";
1949 case DT_DEPAUDIT: return "DEPAUDIT";
1950 case DT_AUDIT: return "AUDIT";
1951 case DT_PLTPAD: return "PLTPAD";
1952 case DT_MOVETAB: return "MOVETAB";
252b5132 1953 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1954
252b5132 1955 case DT_VERSYM: return "VERSYM";
103f02d3 1956
67a4f2b7
AO		 1957 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1958 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1959 case DT_RELACOUNT: return "RELACOUNT";
1960 case DT_RELCOUNT: return "RELCOUNT";
1961 case DT_FLAGS_1: return "FLAGS_1";
1962 case DT_VERDEF: return "VERDEF";
1963 case DT_VERDEFNUM: return "VERDEFNUM";
1964 case DT_VERNEED: return "VERNEED";
1965 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1966
019148e4 1967 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1968 case DT_USED: return "USED";
1969 case DT_FILTER: return "FILTER";
103f02d3 1970
047b2264
JJ		 1971 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1972 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1973 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1974 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1975 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1976 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1977
252b5132
RH		 1978 default:
1979 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1980 {
2cf0635d 1981 const char * result;
103f02d3 1982
252b5132
RH		 1983 switch (elf_header.e_machine)
1984 {
1985 case EM_MIPS:
4fe85591 1986 case EM_MIPS_RS3_LE:
252b5132
RH		 1987 result = get_mips_dynamic_type (type);
1988 break;
9a097730
RH		 1989 case EM_SPARCV9:
1990 result = get_sparc64_dynamic_type (type);
1991 break;
7490d522
AM		 1992 case EM_PPC:
1993 result = get_ppc_dynamic_type (type);
1994 break;
f1cb7e17
AM		 1995 case EM_PPC64:
1996 result = get_ppc64_dynamic_type (type);
1997 break;
ecc51f48
NC		 1998 case EM_IA_64:
1999 result = get_ia64_dynamic_type (type);
2000 break;
fabcb361
RH		 2001 case EM_ALPHA:
2002 result = get_alpha_dynamic_type (type);
2003 break;
1c0d3aa6
NC		 2004 case EM_SCORE:
2005 result = get_score_dynamic_type (type);
2006 break;
40b36596
JM		 2007 case EM_TI_C6000:
2008 result = get_tic6x_dynamic_type (type);
2009 break;
36591ba1
SL		 2010 case EM_ALTERA_NIOS2:
2011 result = get_nios2_dynamic_type (type);
2012 break;
252b5132
RH		 2013 default:
2014 result = NULL;
2015 break;
2016 }
2017
2018 if (result != NULL)
2019 return result;
2020
e9e44622 2021 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2022 }
eec8f817
DA		 2023 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2024 || (elf_header.e_machine == EM_PARISC
2025 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2026 {
2cf0635d 2027 const char * result;
103f02d3
UD		 2028
2029 switch (elf_header.e_machine)
2030 {
2031 case EM_PARISC:
2032 result = get_parisc_dynamic_type (type);
2033 break;
148b93f2
NC		 2034 case EM_IA_64:
2035 result = get_ia64_dynamic_type (type);
2036 break;
103f02d3
UD		 2037 default:
2038 result = NULL;
2039 break;
2040 }
2041
2042 if (result != NULL)
2043 return result;
2044
e9e44622
JJ		 2045 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2046 type);
103f02d3 2047 }
252b5132 2048 else
e9e44622 2049 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2050
252b5132
RH		 2051 return buff;
2052 }
2053}
2054
2055static char *
d3ba0551 2056get_file_type (unsigned e_type)
252b5132 2057{
b34976b6 2058 static char buff[32];
252b5132
RH		 2059
2060 switch (e_type)
2061 {
2062 case ET_NONE: return _("NONE (None)");
2063 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2064 case ET_EXEC: return _("EXEC (Executable file)");
2065 case ET_DYN: return _("DYN (Shared object file)");
2066 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2067
2068 default:
2069 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2070 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2071 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2072 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2073 else
e9e44622 2074 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2075 return buff;
2076 }
2077}
2078
2079static char *
d3ba0551 2080get_machine_name (unsigned e_machine)
252b5132 2081{
b34976b6 2082 static char buff[64]; /* XXX */
252b5132
RH		 2083
2084 switch (e_machine)
2085 {
c45021f2 2086 case EM_NONE: return _("None");
a06ea964 2087 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2088 case EM_M32: return "WE32100";
2089 case EM_SPARC: return "Sparc";
e9f53129 2090 case EM_SPU: return "SPU";
c45021f2
NC		 2091 case EM_386: return "Intel 80386";
2092 case EM_68K: return "MC68000";
2093 case EM_88K: return "MC88000";
2094 case EM_486: return "Intel 80486";
2095 case EM_860: return "Intel 80860";
2096 case EM_MIPS: return "MIPS R3000";
2097 case EM_S370: return "IBM System/370";
7036c0e1 2098 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2099 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2100 case EM_PARISC: return "HPPA";
252b5132 2101 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2102 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2103 case EM_960: return "Intel 90860";
2104 case EM_PPC: return "PowerPC";
285d1771 2105 case EM_PPC64: return "PowerPC64";
c45021f2 2106 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2107 case EM_FT32: return "FTDI FT32";
c45021f2 2108 case EM_RH32: return "TRW RH32";
b34976b6 2109 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2110 case EM_ARM: return "ARM";
2111 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2112 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2113 case EM_SPARCV9: return "Sparc v9";
2114 case EM_TRICORE: return "Siemens Tricore";
584da044 2115 case EM_ARC: return "ARC";
c2dcd04e
NC		 2116 case EM_H8_300: return "Renesas H8/300";
2117 case EM_H8_300H: return "Renesas H8/300H";
2118 case EM_H8S: return "Renesas H8S";
2119 case EM_H8_500: return "Renesas H8/500";
30800947 2120 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2121 case EM_MIPS_X: return "Stanford MIPS-X";
2122 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2123 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2124 case EM_CYGNUS_D10V:
2125 case EM_D10V: return "d10v";
2126 case EM_CYGNUS_D30V:
b34976b6 2127 case EM_D30V: return "d30v";
2b0337b0 2128 case EM_CYGNUS_M32R:
26597c86 2129 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2130 case EM_CYGNUS_V850:
708e2187 2131 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2132 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2133 case EM_CYGNUS_MN10300:
2134 case EM_MN10300: return "mn10300";
2135 case EM_CYGNUS_MN10200:
2136 case EM_MN10200: return "mn10200";
5506d11a 2137 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2138 case EM_CYGNUS_FR30:
2139 case EM_FR30: return "Fujitsu FR30";
b34976b6 2140 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2141 case EM_PJ_OLD:
b34976b6 2142 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2143 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2144 case EM_PCP: return "Siemens PCP";
2145 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2146 case EM_NDR1: return "Denso NDR1 microprocesspr";
2147 case EM_STARCORE: return "Motorola Star*Core processor";
2148 case EM_ME16: return "Toyota ME16 processor";
2149 case EM_ST100: return "STMicroelectronics ST100 processor";
2150 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2151 case EM_PDSP: return "Sony DSP processor";
2152 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2153 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2154 case EM_FX66: return "Siemens FX66 microcontroller";
2155 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2156 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2157 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2158 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2159 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2160 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2161 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2162 case EM_SVX: return "Silicon Graphics SVx";
2163 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2164 case EM_VAX: return "Digital VAX";
619ed720 2165 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2166 case EM_AVR_OLD:
b34976b6 2167 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2168 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2169 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2170 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2171 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2172 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2173 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2174 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2175 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2176 case EM_L1OM: return "Intel L1OM";
7a9068fe 2177 case EM_K1OM: return "Intel K1OM";
b7498e0e 2178 case EM_S390_OLD:
b34976b6 2179 case EM_S390: return "IBM S/390";
1c0d3aa6 2180 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2181 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2182 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2183 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2184 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2185 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2186 case EM_DLX: return "OpenDLX";
1e4cf259 2187 case EM_IP2K_OLD:
b34976b6 2188 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2189 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2190 case EM_XTENSA_OLD:
2191 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2192 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2193 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2194 case EM_NS32K: return "National Semiconductor 32000 series";
2195 case EM_TPC: return "Tenor Network TPC processor";
2196 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2197 case EM_MAX: return "MAX Processor";
2198 case EM_CR: return "National Semiconductor CompactRISC";
2199 case EM_F2MC16: return "Fujitsu F2MC16";
2200 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2201 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2202 case EM_M32C_OLD:
49f58d10 2203 case EM_M32C: return "Renesas M32c";
d031aafb 2204 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2205 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2206 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2207 case EM_SEP: return "Sharp embedded microprocessor";
2208 case EM_ARCA: return "Arca RISC microprocessor";
2209 case EM_UNICORE: return "Unicore";
2210 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2211 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2212 case EM_NIOS32: return "Altera Nios";
2213 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2214 case EM_C166:
d70c5fc7 2215 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2216 case EM_M16C: return "Renesas M16C series microprocessors";
2217 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2218 case EM_CE: return "Freescale Communication Engine RISC core";
2219 case EM_TSK3000: return "Altium TSK3000 core";
2220 case EM_RS08: return "Freescale RS08 embedded processor";
2221 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2222 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2223 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2224 case EM_SE_C17: return "Seiko Epson C17 family";
2225 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2226 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2227 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2228 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2229 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2230 case EM_R32C: return "Renesas R32C series microprocessors";
2231 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2232 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2233 case EM_8051: return "Intel 8051 and variants";
2234 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2235 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2236 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2237 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2238 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2239 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2240 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2241 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2242 case EM_CR16:
f6c1a2d5 2243 case EM_MICROBLAZE:
7ba29e2a 2244 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2245 case EM_RL78: return "Renesas RL78";
c7927a3c 2246 case EM_RX: return "Renesas RX";
a3c62988 2247 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2248 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2249 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2250 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2251 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2252 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2253 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2254 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2255 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2256 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2257 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2258 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2259 default:
35d9dd2f 2260 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2261 return buff;
2262 }
2263}
2264
f3485b74 2265static void
d3ba0551 2266decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2267{
2268 unsigned eabi;
2269 int unknown = 0;
2270
2271 eabi = EF_ARM_EABI_VERSION (e_flags);
2272 e_flags &= ~ EF_ARM_EABIMASK;
2273
2274 /* Handle "generic" ARM flags. */
2275 if (e_flags & EF_ARM_RELEXEC)
2276 {
2277 strcat (buf, ", relocatable executable");
2278 e_flags &= ~ EF_ARM_RELEXEC;
2279 }
76da6bbe 2280
f3485b74
NC		 2281 /* Now handle EABI specific flags. */
2282 switch (eabi)
2283 {
2284 default:
2c71103e 2285 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2286 if (e_flags)
2287 unknown = 1;
2288 break;
2289
2290 case EF_ARM_EABI_VER1:
a5bcd848 2291 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2292 while (e_flags)
2293 {
2294 unsigned flag;
76da6bbe 2295
f3485b74
NC		 2296 /* Process flags one bit at a time. */
2297 flag = e_flags & - e_flags;
2298 e_flags &= ~ flag;
76da6bbe 2299
f3485b74
NC		 2300 switch (flag)
2301 {
a5bcd848 2302 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2303 strcat (buf, ", sorted symbol tables");
2304 break;
76da6bbe 2305
f3485b74
NC		 2306 default:
2307 unknown = 1;
2308 break;
2309 }
2310 }
2311 break;
76da6bbe 2312
a5bcd848
PB		 2313 case EF_ARM_EABI_VER2:
2314 strcat (buf, ", Version2 EABI");
2315 while (e_flags)
2316 {
2317 unsigned flag;
2318
2319 /* Process flags one bit at a time. */
2320 flag = e_flags & - e_flags;
2321 e_flags &= ~ flag;
2322
2323 switch (flag)
2324 {
2325 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2326 strcat (buf, ", sorted symbol tables");
2327 break;
2328
2329 case EF_ARM_DYNSYMSUSESEGIDX:
2330 strcat (buf, ", dynamic symbols use segment index");
2331 break;
2332
2333 case EF_ARM_MAPSYMSFIRST:
2334 strcat (buf, ", mapping symbols precede others");
2335 break;
2336
2337 default:
2338 unknown = 1;
2339 break;
2340 }
2341 }
2342 break;
2343
d507cf36
PB		 2344 case EF_ARM_EABI_VER3:
2345 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2346 break;
2347
2348 case EF_ARM_EABI_VER4:
2349 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2350 while (e_flags)
2351 {
2352 unsigned flag;
2353
2354 /* Process flags one bit at a time. */
2355 flag = e_flags & - e_flags;
2356 e_flags &= ~ flag;
2357
2358 switch (flag)
2359 {
2360 case EF_ARM_BE8:
2361 strcat (buf, ", BE8");
2362 break;
2363
2364 case EF_ARM_LE8:
2365 strcat (buf, ", LE8");
2366 break;
2367
2368 default:
2369 unknown = 1;
2370 break;
2371 }
2372 break;
2373 }
2374 break;
3a4a14e9
PB		 2375
2376 case EF_ARM_EABI_VER5:
2377 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2378 while (e_flags)
2379 {
2380 unsigned flag;
2381
2382 /* Process flags one bit at a time. */
2383 flag = e_flags & - e_flags;
2384 e_flags &= ~ flag;
2385
2386 switch (flag)
2387 {
2388 case EF_ARM_BE8:
2389 strcat (buf, ", BE8");
2390 break;
2391
2392 case EF_ARM_LE8:
2393 strcat (buf, ", LE8");
2394 break;
2395
3bfcb652
NC		 2396 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2397 strcat (buf, ", soft-float ABI");
2398 break;
2399
2400 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2401 strcat (buf, ", hard-float ABI");
2402 break;
2403
d507cf36
PB		 2404 default:
2405 unknown = 1;
2406 break;
2407 }
2408 }
2409 break;
2410
f3485b74 2411 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2412 strcat (buf, ", GNU EABI");
f3485b74
NC		 2413 while (e_flags)
2414 {
2415 unsigned flag;
76da6bbe 2416
f3485b74
NC		 2417 /* Process flags one bit at a time. */
2418 flag = e_flags & - e_flags;
2419 e_flags &= ~ flag;
76da6bbe 2420
f3485b74
NC		 2421 switch (flag)
2422 {
a5bcd848 2423 case EF_ARM_INTERWORK:
f3485b74
NC		 2424 strcat (buf, ", interworking enabled");
2425 break;
76da6bbe 2426
a5bcd848 2427 case EF_ARM_APCS_26:
f3485b74
NC		 2428 strcat (buf, ", uses APCS/26");
2429 break;
76da6bbe 2430
a5bcd848 2431 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2432 strcat (buf, ", uses APCS/float");
2433 break;
76da6bbe 2434
a5bcd848 2435 case EF_ARM_PIC:
f3485b74
NC		 2436 strcat (buf, ", position independent");
2437 break;
76da6bbe 2438
a5bcd848 2439 case EF_ARM_ALIGN8:
f3485b74
NC		 2440 strcat (buf, ", 8 bit structure alignment");
2441 break;
76da6bbe 2442
a5bcd848 2443 case EF_ARM_NEW_ABI:
f3485b74
NC		 2444 strcat (buf, ", uses new ABI");
2445 break;
76da6bbe 2446
a5bcd848 2447 case EF_ARM_OLD_ABI:
f3485b74
NC		 2448 strcat (buf, ", uses old ABI");
2449 break;
76da6bbe 2450
a5bcd848 2451 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2452 strcat (buf, ", software FP");
2453 break;
76da6bbe 2454
90e01f86
ILT		 2455 case EF_ARM_VFP_FLOAT:
2456 strcat (buf, ", VFP");
2457 break;
2458
fde78edd
NC		 2459 case EF_ARM_MAVERICK_FLOAT:
2460 strcat (buf, ", Maverick FP");
2461 break;
2462
f3485b74
NC		 2463 default:
2464 unknown = 1;
2465 break;
2466 }
2467 }
2468 }
f3485b74
NC		 2469
2470 if (unknown)
2b692964 2471 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2472}
2473
343433df
AB		 2474static void
2475decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2476{
2477 --size; /* Leave space for null terminator. */
2478
2479 switch (e_flags & EF_AVR_MACH)
2480 {
2481 case E_AVR_MACH_AVR1:
2482 strncat (buf, ", avr:1", size);
2483 break;
2484 case E_AVR_MACH_AVR2:
2485 strncat (buf, ", avr:2", size);
2486 break;
2487 case E_AVR_MACH_AVR25:
2488 strncat (buf, ", avr:25", size);
2489 break;
2490 case E_AVR_MACH_AVR3:
2491 strncat (buf, ", avr:3", size);
2492 break;
2493 case E_AVR_MACH_AVR31:
2494 strncat (buf, ", avr:31", size);
2495 break;
2496 case E_AVR_MACH_AVR35:
2497 strncat (buf, ", avr:35", size);
2498 break;
2499 case E_AVR_MACH_AVR4:
2500 strncat (buf, ", avr:4", size);
2501 break;
2502 case E_AVR_MACH_AVR5:
2503 strncat (buf, ", avr:5", size);
2504 break;
2505 case E_AVR_MACH_AVR51:
2506 strncat (buf, ", avr:51", size);
2507 break;
2508 case E_AVR_MACH_AVR6:
2509 strncat (buf, ", avr:6", size);
2510 break;
2511 case E_AVR_MACH_AVRTINY:
2512 strncat (buf, ", avr:100", size);
2513 break;
2514 case E_AVR_MACH_XMEGA1:
2515 strncat (buf, ", avr:101", size);
2516 break;
2517 case E_AVR_MACH_XMEGA2:
2518 strncat (buf, ", avr:102", size);
2519 break;
2520 case E_AVR_MACH_XMEGA3:
2521 strncat (buf, ", avr:103", size);
2522 break;
2523 case E_AVR_MACH_XMEGA4:
2524 strncat (buf, ", avr:104", size);
2525 break;
2526 case E_AVR_MACH_XMEGA5:
2527 strncat (buf, ", avr:105", size);
2528 break;
2529 case E_AVR_MACH_XMEGA6:
2530 strncat (buf, ", avr:106", size);
2531 break;
2532 case E_AVR_MACH_XMEGA7:
2533 strncat (buf, ", avr:107", size);
2534 break;
2535 default:
2536 strncat (buf, ", avr:<unknown>", size);
2537 break;
2538 }
2539
2540 size -= strlen (buf);
2541 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2542 strncat (buf, ", link-relax", size);
2543}
2544
35c08157
KLC		 2545static void
2546decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2547{
2548 unsigned abi;
2549 unsigned arch;
2550 unsigned config;
2551 unsigned version;
2552 int has_fpu = 0;
2553 int r = 0;
2554
2555 static const char *ABI_STRINGS[] =
2556 {
2557 "ABI v0", /* use r5 as return register; only used in N1213HC */
2558 "ABI v1", /* use r0 as return register */
2559 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2560 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2561 "AABI",
2562 "ABI2 FP+"
35c08157
KLC		 2563 };
2564 static const char *VER_STRINGS[] =
2565 {
2566 "Andes ELF V1.3 or older",
2567 "Andes ELF V1.3.1",
2568 "Andes ELF V1.4"
2569 };
2570 static const char *ARCH_STRINGS[] =
2571 {
2572 "",
2573 "Andes Star v1.0",
2574 "Andes Star v2.0",
2575 "Andes Star v3.0",
2576 "Andes Star v3.0m"
2577 };
2578
2579 abi = EF_NDS_ABI & e_flags;
2580 arch = EF_NDS_ARCH & e_flags;
2581 config = EF_NDS_INST & e_flags;
2582 version = EF_NDS32_ELF_VERSION & e_flags;
2583
2584 memset (buf, 0, size);
2585
2586 switch (abi)
2587 {
2588 case E_NDS_ABI_V0:
2589 case E_NDS_ABI_V1:
2590 case E_NDS_ABI_V2:
2591 case E_NDS_ABI_V2FP:
2592 case E_NDS_ABI_AABI:
40c7a7cb 2593 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2594 /* In case there are holes in the array. */
2595 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2596 break;
2597
2598 default:
2599 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2600 break;
2601 }
2602
2603 switch (version)
2604 {
2605 case E_NDS32_ELF_VER_1_2:
2606 case E_NDS32_ELF_VER_1_3:
2607 case E_NDS32_ELF_VER_1_4:
2608 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2609 break;
2610
2611 default:
2612 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2613 break;
2614 }
2615
2616 if (E_NDS_ABI_V0 == abi)
2617 {
2618 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2619 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2620 if (arch == E_NDS_ARCH_STAR_V1_0)
2621 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2622 return;
2623 }
2624
2625 switch (arch)
2626 {
2627 case E_NDS_ARCH_STAR_V1_0:
2628 case E_NDS_ARCH_STAR_V2_0:
2629 case E_NDS_ARCH_STAR_V3_0:
2630 case E_NDS_ARCH_STAR_V3_M:
2631 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2632 break;
2633
2634 default:
2635 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2636 /* ARCH version determines how the e_flags are interpreted.
2637 If it is unknown, we cannot proceed. */
2638 return;
2639 }
2640
2641 /* Newer ABI; Now handle architecture specific flags. */
2642 if (arch == E_NDS_ARCH_STAR_V1_0)
2643 {
2644 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2645 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2646
2647 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2648 r += snprintf (buf + r, size -r, ", MAC");
2649
2650 if (config & E_NDS32_HAS_DIV_INST)
2651 r += snprintf (buf + r, size -r, ", DIV");
2652
2653 if (config & E_NDS32_HAS_16BIT_INST)
2654 r += snprintf (buf + r, size -r, ", 16b");
2655 }
2656 else
2657 {
2658 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2659 {
2660 if (version <= E_NDS32_ELF_VER_1_3)
2661 r += snprintf (buf + r, size -r, ", [B8]");
2662 else
2663 r += snprintf (buf + r, size -r, ", EX9");
2664 }
2665
2666 if (config & E_NDS32_HAS_MAC_DX_INST)
2667 r += snprintf (buf + r, size -r, ", MAC_DX");
2668
2669 if (config & E_NDS32_HAS_DIV_DX_INST)
2670 r += snprintf (buf + r, size -r, ", DIV_DX");
2671
2672 if (config & E_NDS32_HAS_16BIT_INST)
2673 {
2674 if (version <= E_NDS32_ELF_VER_1_3)
2675 r += snprintf (buf + r, size -r, ", 16b");
2676 else
2677 r += snprintf (buf + r, size -r, ", IFC");
2678 }
2679 }
2680
2681 if (config & E_NDS32_HAS_EXT_INST)
2682 r += snprintf (buf + r, size -r, ", PERF1");
2683
2684 if (config & E_NDS32_HAS_EXT2_INST)
2685 r += snprintf (buf + r, size -r, ", PERF2");
2686
2687 if (config & E_NDS32_HAS_FPU_INST)
2688 {
2689 has_fpu = 1;
2690 r += snprintf (buf + r, size -r, ", FPU_SP");
2691 }
2692
2693 if (config & E_NDS32_HAS_FPU_DP_INST)
2694 {
2695 has_fpu = 1;
2696 r += snprintf (buf + r, size -r, ", FPU_DP");
2697 }
2698
2699 if (config & E_NDS32_HAS_FPU_MAC_INST)
2700 {
2701 has_fpu = 1;
2702 r += snprintf (buf + r, size -r, ", FPU_MAC");
2703 }
2704
2705 if (has_fpu)
2706 {
2707 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2708 {
2709 case E_NDS32_FPU_REG_8SP_4DP:
2710 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2711 break;
2712 case E_NDS32_FPU_REG_16SP_8DP:
2713 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2714 break;
2715 case E_NDS32_FPU_REG_32SP_16DP:
2716 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2717 break;
2718 case E_NDS32_FPU_REG_32SP_32DP:
2719 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2720 break;
2721 }
2722 }
2723
2724 if (config & E_NDS32_HAS_AUDIO_INST)
2725 r += snprintf (buf + r, size -r, ", AUDIO");
2726
2727 if (config & E_NDS32_HAS_STRING_INST)
2728 r += snprintf (buf + r, size -r, ", STR");
2729
2730 if (config & E_NDS32_HAS_REDUCED_REGS)
2731 r += snprintf (buf + r, size -r, ", 16REG");
2732
2733 if (config & E_NDS32_HAS_VIDEO_INST)
2734 {
2735 if (version <= E_NDS32_ELF_VER_1_3)
2736 r += snprintf (buf + r, size -r, ", VIDEO");
2737 else
2738 r += snprintf (buf + r, size -r, ", SATURATION");
2739 }
2740
2741 if (config & E_NDS32_HAS_ENCRIPT_INST)
2742 r += snprintf (buf + r, size -r, ", ENCRP");
2743
2744 if (config & E_NDS32_HAS_L2C_INST)
2745 r += snprintf (buf + r, size -r, ", L2C");
2746}
2747
252b5132 2748static char *
d3ba0551 2749get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2750{
b34976b6 2751 static char buf[1024];
252b5132
RH		 2752
2753 buf[0] = '\0';
76da6bbe 2754
252b5132
RH		 2755 if (e_flags)
2756 {
2757 switch (e_machine)
2758 {
2759 default:
2760 break;
2761
f3485b74
NC		 2762 case EM_ARM:
2763 decode_ARM_machine_flags (e_flags, buf);
2764 break;
76da6bbe 2765
343433df
AB		 2766 case EM_AVR:
2767 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2768 break;
2769
781303ce
MF		 2770 case EM_BLACKFIN:
2771 if (e_flags & EF_BFIN_PIC)
2772 strcat (buf, ", PIC");
2773
2774 if (e_flags & EF_BFIN_FDPIC)
2775 strcat (buf, ", FDPIC");
2776
2777 if (e_flags & EF_BFIN_CODE_IN_L1)
2778 strcat (buf, ", code in L1");
2779
2780 if (e_flags & EF_BFIN_DATA_IN_L1)
2781 strcat (buf, ", data in L1");
2782
2783 break;
2784
ec2dfb42
AO		 2785 case EM_CYGNUS_FRV:
2786 switch (e_flags & EF_FRV_CPU_MASK)
2787 {
2788 case EF_FRV_CPU_GENERIC:
2789 break;
2790
2791 default:
2792 strcat (buf, ", fr???");
2793 break;
57346661 2794
ec2dfb42
AO		 2795 case EF_FRV_CPU_FR300:
2796 strcat (buf, ", fr300");
2797 break;
2798
2799 case EF_FRV_CPU_FR400:
2800 strcat (buf, ", fr400");
2801 break;
2802 case EF_FRV_CPU_FR405:
2803 strcat (buf, ", fr405");
2804 break;
2805
2806 case EF_FRV_CPU_FR450:
2807 strcat (buf, ", fr450");
2808 break;
2809
2810 case EF_FRV_CPU_FR500:
2811 strcat (buf, ", fr500");
2812 break;
2813 case EF_FRV_CPU_FR550:
2814 strcat (buf, ", fr550");
2815 break;
2816
2817 case EF_FRV_CPU_SIMPLE:
2818 strcat (buf, ", simple");
2819 break;
2820 case EF_FRV_CPU_TOMCAT:
2821 strcat (buf, ", tomcat");
2822 break;
2823 }
1c877e87 2824 break;
ec2dfb42 2825
53c7db4b 2826 case EM_68K:
425c6cb0 2827 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2828 strcat (buf, ", m68000");
425c6cb0 2829 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2830 strcat (buf, ", cpu32");
2831 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2832 strcat (buf, ", fido_a");
425c6cb0 2833 else
266abb8f 2834 {
2cf0635d
NC		 2835 char const * isa = _("unknown");
2836 char const * mac = _("unknown mac");
2837 char const * additional = NULL;
0112cd26 2838
c694fd50 2839 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2840 {
c694fd50 2841 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2842 isa = "A";
2843 additional = ", nodiv";
2844 break;
c694fd50 2845 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2846 isa = "A";
2847 break;
c694fd50 2848 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2849 isa = "A+";
2850 break;
c694fd50 2851 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2852 isa = "B";
2853 additional = ", nousp";
2854 break;
c694fd50 2855 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2856 isa = "B";
2857 break;
f608cd77
NS		 2858 case EF_M68K_CF_ISA_C:
2859 isa = "C";
2860 break;
2861 case EF_M68K_CF_ISA_C_NODIV:
2862 isa = "C";
2863 additional = ", nodiv";
2864 break;
266abb8f
NS		 2865 }
2866 strcat (buf, ", cf, isa ");
2867 strcat (buf, isa);
0b2e31dc
NS		 2868 if (additional)
2869 strcat (buf, additional);
c694fd50 2870 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2871 strcat (buf, ", float");
c694fd50 2872 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2873 {
2874 case 0:
2875 mac = NULL;
2876 break;
c694fd50 2877 case EF_M68K_CF_MAC:
266abb8f
NS		 2878 mac = "mac";
2879 break;
c694fd50 2880 case EF_M68K_CF_EMAC:
266abb8f
NS		 2881 mac = "emac";
2882 break;
f608cd77
NS		 2883 case EF_M68K_CF_EMAC_B:
2884 mac = "emac_b";
2885 break;
266abb8f
NS		 2886 }
2887 if (mac)
2888 {
2889 strcat (buf, ", ");
2890 strcat (buf, mac);
2891 }
266abb8f 2892 }
53c7db4b 2893 break;
33c63f9d 2894
252b5132
RH		 2895 case EM_PPC:
2896 if (e_flags & EF_PPC_EMB)
2897 strcat (buf, ", emb");
2898
2899 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2900 strcat (buf, _(", relocatable"));
252b5132
RH		 2901
2902 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2903 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2904 break;
2905
ee67d69a
AM		 2906 case EM_PPC64:
2907 if (e_flags & EF_PPC64_ABI)
2908 {
2909 char abi[] = ", abiv0";
2910
2911 abi[6] += e_flags & EF_PPC64_ABI;
2912 strcat (buf, abi);
2913 }
2914 break;
2915
708e2187
NC		 2916 case EM_V800:
2917 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2918 strcat (buf, ", RH850 ABI");
0b4362b0 2919
708e2187
NC		 2920 if (e_flags & EF_V800_850E3)
2921 strcat (buf, ", V3 architecture");
2922
2923 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2924 strcat (buf, ", FPU not used");
2925
2926 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2927 strcat (buf, ", regmode: COMMON");
2928
2929 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2930 strcat (buf, ", r4 not used");
2931
2932 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2933 strcat (buf, ", r30 not used");
2934
2935 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2936 strcat (buf, ", r5 not used");
2937
2938 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2939 strcat (buf, ", r2 not used");
2940
2941 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2942 {
2943 switch (e_flags & - e_flags)
2944 {
2945 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2946 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2947 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2948 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2949 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2950 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2951 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2952 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2953 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2954 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2955 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2956 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2957 default: break;
2958 }
2959 }
2960 break;
2961
2b0337b0 2962 case EM_V850:
252b5132
RH		 2963 case EM_CYGNUS_V850:
2964 switch (e_flags & EF_V850_ARCH)
2965 {
78c8d46c
NC		 2966 case E_V850E3V5_ARCH:
2967 strcat (buf, ", v850e3v5");
2968 break;
1cd986c5
NC		 2969 case E_V850E2V3_ARCH:
2970 strcat (buf, ", v850e2v3");
2971 break;
2972 case E_V850E2_ARCH:
2973 strcat (buf, ", v850e2");
2974 break;
2975 case E_V850E1_ARCH:
2976 strcat (buf, ", v850e1");
8ad30312 2977 break;
252b5132
RH		 2978 case E_V850E_ARCH:
2979 strcat (buf, ", v850e");
2980 break;
252b5132
RH		 2981 case E_V850_ARCH:
2982 strcat (buf, ", v850");
2983 break;
2984 default:
2b692964 2985 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2986 break;
2987 }
2988 break;
2989
2b0337b0 2990 case EM_M32R:
252b5132
RH		 2991 case EM_CYGNUS_M32R:
2992 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2993 strcat (buf, ", m32r");
252b5132
RH		 2994 break;
2995
2996 case EM_MIPS:
4fe85591 2997 case EM_MIPS_RS3_LE:
252b5132
RH		 2998 if (e_flags & EF_MIPS_NOREORDER)
2999 strcat (buf, ", noreorder");
3000
3001 if (e_flags & EF_MIPS_PIC)
3002 strcat (buf, ", pic");
3003
3004 if (e_flags & EF_MIPS_CPIC)
3005 strcat (buf, ", cpic");
3006
d1bdd336
TS		 3007 if (e_flags & EF_MIPS_UCODE)
3008 strcat (buf, ", ugen_reserved");
3009
252b5132
RH		 3010 if (e_flags & EF_MIPS_ABI2)
3011 strcat (buf, ", abi2");
3012
43521d43
TS		 3013 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3014 strcat (buf, ", odk first");
3015
a5d22d2a
TS		 3016 if (e_flags & EF_MIPS_32BITMODE)
3017 strcat (buf, ", 32bitmode");
3018
ba92f887
MR		 3019 if (e_flags & EF_MIPS_NAN2008)
3020 strcat (buf, ", nan2008");
3021
fef1b0b3
SE		 3022 if (e_flags & EF_MIPS_FP64)
3023 strcat (buf, ", fp64");
3024
156c2f8b
NC		 3025 switch ((e_flags & EF_MIPS_MACH))
3026 {
3027 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3028 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3029 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3030 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3031 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3032 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3033 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3034 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3035 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3036 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3037 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3038 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3039 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3040 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3041 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3042 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3043 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3044 case 0:
3045 /* We simply ignore the field in this case to avoid confusion:
3046 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3047 extension. */
3048 break;
2b692964 3049 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3050 }
43521d43
TS		 3051
3052 switch ((e_flags & EF_MIPS_ABI))
3053 {
3054 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3055 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3056 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3057 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3058 case 0:
3059 /* We simply ignore the field in this case to avoid confusion:
3060 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3061 This means it is likely to be an o32 file, but not for
3062 sure. */
3063 break;
2b692964 3064 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3065 }
3066
3067 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3068 strcat (buf, ", mdmx");
3069
3070 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3071 strcat (buf, ", mips16");
3072
df58fc94
RS		 3073 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3074 strcat (buf, ", micromips");
3075
43521d43
TS		 3076 switch ((e_flags & EF_MIPS_ARCH))
3077 {
3078 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3079 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3080 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3081 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3082 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3083 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3084 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3085 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3086 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3087 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3088 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3089 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3090 }
252b5132 3091 break;
351b4b40 3092
35c08157
KLC		 3093 case EM_NDS32:
3094 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3095 break;
3096
ccde1100
AO		 3097 case EM_SH:
3098 switch ((e_flags & EF_SH_MACH_MASK))
3099 {
3100 case EF_SH1: strcat (buf, ", sh1"); break;
3101 case EF_SH2: strcat (buf, ", sh2"); break;
3102 case EF_SH3: strcat (buf, ", sh3"); break;
3103 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3104 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3105 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3106 case EF_SH3E: strcat (buf, ", sh3e"); break;
3107 case EF_SH4: strcat (buf, ", sh4"); break;
3108 case EF_SH5: strcat (buf, ", sh5"); break;
3109 case EF_SH2E: strcat (buf, ", sh2e"); break;
3110 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3111 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3112 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3113 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3114 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3115 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3116 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3117 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3118 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3119 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3120 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3121 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3122 }
3123
cec6a5b8
MR		 3124 if (e_flags & EF_SH_PIC)
3125 strcat (buf, ", pic");
3126
3127 if (e_flags & EF_SH_FDPIC)
3128 strcat (buf, ", fdpic");
ccde1100 3129 break;
948f632f 3130
73589c9d
CS		 3131 case EM_OR1K:
3132 if (e_flags & EF_OR1K_NODELAY)
3133 strcat (buf, ", no delay");
3134 break;
57346661 3135
351b4b40
RH		 3136 case EM_SPARCV9:
3137 if (e_flags & EF_SPARC_32PLUS)
3138 strcat (buf, ", v8+");
3139
3140 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3141 strcat (buf, ", ultrasparcI");
3142
3143 if (e_flags & EF_SPARC_SUN_US3)
3144 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3145
3146 if (e_flags & EF_SPARC_HAL_R1)
3147 strcat (buf, ", halr1");
3148
3149 if (e_flags & EF_SPARC_LEDATA)
3150 strcat (buf, ", ledata");
3151
3152 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3153 strcat (buf, ", tso");
3154
3155 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3156 strcat (buf, ", pso");
3157
3158 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3159 strcat (buf, ", rmo");
3160 break;
7d466069 3161
103f02d3
UD		 3162 case EM_PARISC:
3163 switch (e_flags & EF_PARISC_ARCH)
3164 {
3165 case EFA_PARISC_1_0:
3166 strcpy (buf, ", PA-RISC 1.0");
3167 break;
3168 case EFA_PARISC_1_1:
3169 strcpy (buf, ", PA-RISC 1.1");
3170 break;
3171 case EFA_PARISC_2_0:
3172 strcpy (buf, ", PA-RISC 2.0");
3173 break;
3174 default:
3175 break;
3176 }
3177 if (e_flags & EF_PARISC_TRAPNIL)
3178 strcat (buf, ", trapnil");
3179 if (e_flags & EF_PARISC_EXT)
3180 strcat (buf, ", ext");
3181 if (e_flags & EF_PARISC_LSB)
3182 strcat (buf, ", lsb");
3183 if (e_flags & EF_PARISC_WIDE)
3184 strcat (buf, ", wide");
3185 if (e_flags & EF_PARISC_NO_KABP)
3186 strcat (buf, ", no kabp");
3187 if (e_flags & EF_PARISC_LAZYSWAP)
3188 strcat (buf, ", lazyswap");
30800947 3189 break;
76da6bbe 3190
7d466069 3191 case EM_PJ:
2b0337b0 3192 case EM_PJ_OLD:
7d466069
ILT		 3193 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3194 strcat (buf, ", new calling convention");
3195
3196 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3197 strcat (buf, ", gnu calling convention");
3198 break;
4d6ed7c8
NC		 3199
3200 case EM_IA_64:
3201 if ((e_flags & EF_IA_64_ABI64))
3202 strcat (buf, ", 64-bit");
3203 else
3204 strcat (buf, ", 32-bit");
3205 if ((e_flags & EF_IA_64_REDUCEDFP))
3206 strcat (buf, ", reduced fp model");
3207 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3208 strcat (buf, ", no function descriptors, constant gp");
3209 else if ((e_flags & EF_IA_64_CONS_GP))
3210 strcat (buf, ", constant gp");
3211 if ((e_flags & EF_IA_64_ABSOLUTE))
3212 strcat (buf, ", absolute");
28f997cf
TG		 3213 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3214 {
3215 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3216 strcat (buf, ", vms_linkages");
3217 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3218 {
3219 case EF_IA_64_VMS_COMCOD_SUCCESS:
3220 break;
3221 case EF_IA_64_VMS_COMCOD_WARNING:
3222 strcat (buf, ", warning");
3223 break;
3224 case EF_IA_64_VMS_COMCOD_ERROR:
3225 strcat (buf, ", error");
3226 break;
3227 case EF_IA_64_VMS_COMCOD_ABORT:
3228 strcat (buf, ", abort");
3229 break;
3230 default:
bee0ee85
NC		 3231 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3232 e_flags & EF_IA_64_VMS_COMCOD);
3233 strcat (buf, ", <unknown>");
28f997cf
TG		 3234 }
3235 }
4d6ed7c8 3236 break;
179d3252
JT		 3237
3238 case EM_VAX:
3239 if ((e_flags & EF_VAX_NONPIC))
3240 strcat (buf, ", non-PIC");
3241 if ((e_flags & EF_VAX_DFLOAT))
3242 strcat (buf, ", D-Float");
3243 if ((e_flags & EF_VAX_GFLOAT))
3244 strcat (buf, ", G-Float");
3245 break;
c7927a3c 3246
619ed720
EB		 3247 case EM_VISIUM:
3248 if (e_flags & EF_VISIUM_ARCH_MCM)
3249 strcat (buf, ", mcm");
3250 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3251 strcat (buf, ", mcm24");
3252 if (e_flags & EF_VISIUM_ARCH_GR6)
3253 strcat (buf, ", gr6");
3254 break;
3255
4046d87a 3256 case EM_RL78:
1740ba0c
NC		 3257 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3258 {
3259 case E_FLAG_RL78_ANY_CPU: break;
3260 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3261 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3262 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3263 }
856ea05c
KP		 3264 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3265 strcat (buf, ", 64-bit doubles");
4046d87a 3266 break;
0b4362b0 3267
c7927a3c
NC		 3268 case EM_RX:
3269 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3270 strcat (buf, ", 64-bit doubles");
3271 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3272 strcat (buf, ", dsp");
d4cb0ea0 3273 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3274 strcat (buf, ", pid");
708e2187
NC		 3275 if (e_flags & E_FLAG_RX_ABI)
3276 strcat (buf, ", RX ABI");
d4cb0ea0 3277 break;
55786da2
AK		 3278
3279 case EM_S390:
3280 if (e_flags & EF_S390_HIGH_GPRS)
3281 strcat (buf, ", highgprs");
d4cb0ea0 3282 break;
40b36596
JM		 3283
3284 case EM_TI_C6000:
3285 if ((e_flags & EF_C6000_REL))
3286 strcat (buf, ", relocatable module");
d4cb0ea0 3287 break;
13761a11
NC		 3288
3289 case EM_MSP430:
3290 strcat (buf, _(": architecture variant: "));
3291 switch (e_flags & EF_MSP430_MACH)
3292 {
3293 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3294 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3295 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3296 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3297 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3298 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3299 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3300 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3301 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3302 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3303 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3304 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3305 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3306 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3307 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3308 default:
3309 strcat (buf, _(": unknown")); break;
3310 }
3311
3312 if (e_flags & ~ EF_MSP430_MACH)
3313 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3314 }
3315 }
3316
3317 return buf;
3318}
3319
252b5132 3320static const char *
d3ba0551
AM		 3321get_osabi_name (unsigned int osabi)
3322{
3323 static char buff[32];
3324
3325 switch (osabi)
3326 {
3327 case ELFOSABI_NONE: return "UNIX - System V";
3328 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3329 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3330 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3331 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3332 case ELFOSABI_AIX: return "UNIX - AIX";
3333 case ELFOSABI_IRIX: return "UNIX - IRIX";
3334 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3335 case ELFOSABI_TRU64: return "UNIX - TRU64";
3336 case ELFOSABI_MODESTO: return "Novell - Modesto";
3337 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3338 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3339 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3340 case ELFOSABI_AROS: return "AROS";
11636f9e 3341 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3342 default:
40b36596
JM		 3343 if (osabi >= 64)
3344 switch (elf_header.e_machine)
3345 {
3346 case EM_ARM:
3347 switch (osabi)
3348 {
3349 case ELFOSABI_ARM: return "ARM";
3350 default:
3351 break;
3352 }
3353 break;
3354
3355 case EM_MSP430:
3356 case EM_MSP430_OLD:
619ed720 3357 case EM_VISIUM:
40b36596
JM		 3358 switch (osabi)
3359 {
3360 case ELFOSABI_STANDALONE: return _("Standalone App");
3361 default:
3362 break;
3363 }
3364 break;
3365
3366 case EM_TI_C6000:
3367 switch (osabi)
3368 {
3369 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3370 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3371 default:
3372 break;
3373 }
3374 break;
3375
3376 default:
3377 break;
3378 }
e9e44622 3379 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3380 return buff;
3381 }
3382}
3383
a06ea964
NC		 3384static const char *
3385get_aarch64_segment_type (unsigned long type)
3386{
3387 switch (type)
3388 {
3389 case PT_AARCH64_ARCHEXT:
3390 return "AARCH64_ARCHEXT";
3391 default:
3392 break;
3393 }
3394
3395 return NULL;
3396}
3397
b294bdf8
MM		 3398static const char *
3399get_arm_segment_type (unsigned long type)
3400{
3401 switch (type)
3402 {
3403 case PT_ARM_EXIDX:
3404 return "EXIDX";
3405 default:
3406 break;
3407 }
3408
3409 return NULL;
3410}
3411
d3ba0551
AM		 3412static const char *
3413get_mips_segment_type (unsigned long type)
252b5132
RH		 3414{
3415 switch (type)
3416 {
3417 case PT_MIPS_REGINFO:
3418 return "REGINFO";
3419 case PT_MIPS_RTPROC:
3420 return "RTPROC";
3421 case PT_MIPS_OPTIONS:
3422 return "OPTIONS";
351cdf24
MF		 3423 case PT_MIPS_ABIFLAGS:
3424 return "ABIFLAGS";
252b5132
RH		 3425 default:
3426 break;
3427 }
3428
3429 return NULL;
3430}
3431
103f02d3 3432static const char *
d3ba0551 3433get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3434{
3435 switch (type)
3436 {
3437 case PT_HP_TLS: return "HP_TLS";
3438 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3439 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3440 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3441 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3442 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3443 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3444 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3445 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3446 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3447 case PT_HP_PARALLEL: return "HP_PARALLEL";
3448 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3449 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3450 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3451 case PT_HP_STACK: return "HP_STACK";
3452 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3453 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3454 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3455 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3456 default:
3457 break;
3458 }
3459
3460 return NULL;
3461}
3462
4d6ed7c8 3463static const char *
d3ba0551 3464get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3465{
3466 switch (type)
3467 {
3468 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3469 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3470 case PT_HP_TLS: return "HP_TLS";
3471 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3472 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3473 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3474 default:
3475 break;
3476 }
3477
3478 return NULL;
3479}
3480
40b36596
JM		 3481static const char *
3482get_tic6x_segment_type (unsigned long type)
3483{
3484 switch (type)
3485 {
3486 case PT_C6000_PHATTR: return "C6000_PHATTR";
3487 default:
3488 break;
3489 }
3490
3491 return NULL;
3492}
3493
252b5132 3494static const char *
d3ba0551 3495get_segment_type (unsigned long p_type)
252b5132 3496{
b34976b6 3497 static char buff[32];
252b5132
RH		 3498
3499 switch (p_type)
3500 {
b34976b6
AM		 3501 case PT_NULL: return "NULL";
3502 case PT_LOAD: return "LOAD";
252b5132 3503 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3504 case PT_INTERP: return "INTERP";
3505 case PT_NOTE: return "NOTE";
3506 case PT_SHLIB: return "SHLIB";
3507 case PT_PHDR: return "PHDR";
13ae64f3 3508 case PT_TLS: return "TLS";
252b5132 3509
65765700
JJ		 3510 case PT_GNU_EH_FRAME:
3511 return "GNU_EH_FRAME";
2b05f1b7 3512 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3513 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3514
252b5132
RH		 3515 default:
3516 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3517 {
2cf0635d 3518 const char * result;
103f02d3 3519
252b5132
RH		 3520 switch (elf_header.e_machine)
3521 {
a06ea964
NC		 3522 case EM_AARCH64:
3523 result = get_aarch64_segment_type (p_type);
3524 break;
b294bdf8
MM		 3525 case EM_ARM:
3526 result = get_arm_segment_type (p_type);
3527 break;
252b5132 3528 case EM_MIPS:
4fe85591 3529 case EM_MIPS_RS3_LE:
252b5132
RH		 3530 result = get_mips_segment_type (p_type);
3531 break;
103f02d3
UD		 3532 case EM_PARISC:
3533 result = get_parisc_segment_type (p_type);
3534 break;
4d6ed7c8
NC		 3535 case EM_IA_64:
3536 result = get_ia64_segment_type (p_type);
3537 break;
40b36596
JM		 3538 case EM_TI_C6000:
3539 result = get_tic6x_segment_type (p_type);
3540 break;
252b5132
RH		 3541 default:
3542 result = NULL;
3543 break;
3544 }
103f02d3 3545
252b5132
RH		 3546 if (result != NULL)
3547 return result;
103f02d3 3548
252b5132
RH		 3549 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3550 }
3551 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3552 {
2cf0635d 3553 const char * result;
103f02d3
UD		 3554
3555 switch (elf_header.e_machine)
3556 {
3557 case EM_PARISC:
3558 result = get_parisc_segment_type (p_type);
3559 break;
00428cca
AM		 3560 case EM_IA_64:
3561 result = get_ia64_segment_type (p_type);
3562 break;
103f02d3
UD		 3563 default:
3564 result = NULL;
3565 break;
3566 }
3567
3568 if (result != NULL)
3569 return result;
3570
3571 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3572 }
252b5132 3573 else
e9e44622 3574 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3575
3576 return buff;
3577 }
3578}
3579
3580static const char *
d3ba0551 3581get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3582{
3583 switch (sh_type)
3584 {
b34976b6
AM		 3585 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3586 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3587 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3588 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3589 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3590 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3591 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3592 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3593 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3594 case SHT_MIPS_RELD: return "MIPS_RELD";
3595 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3596 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3597 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3598 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3599 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3600 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3601 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3602 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3603 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3604 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3605 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3606 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3607 case SHT_MIPS_LINE: return "MIPS_LINE";
3608 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3609 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3610 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3611 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3612 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3613 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3614 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3615 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3616 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3617 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3618 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3619 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3620 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3621 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3622 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3623 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3624 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3625 default:
3626 break;
3627 }
3628 return NULL;
3629}
3630
103f02d3 3631static const char *
d3ba0551 3632get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3633{
3634 switch (sh_type)
3635 {
3636 case SHT_PARISC_EXT: return "PARISC_EXT";
3637 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3638 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3639 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3640 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3641 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3642 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3643 default:
3644 break;
3645 }
3646 return NULL;
3647}
3648
4d6ed7c8 3649static const char *
d3ba0551 3650get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3651{
18bd398b 3652 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3653 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3654 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3655
4d6ed7c8
NC		 3656 switch (sh_type)
3657 {
148b93f2
NC		 3658 case SHT_IA_64_EXT: return "IA_64_EXT";
3659 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3660 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3661 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3662 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3663 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3664 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3665 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3666 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3667 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3668 default:
3669 break;
3670 }
3671 return NULL;
3672}
3673
d2b2c203
DJ		 3674static const char *
3675get_x86_64_section_type_name (unsigned int sh_type)
3676{
3677 switch (sh_type)
3678 {
3679 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3680 default:
3681 break;
3682 }
3683 return NULL;
3684}
3685
a06ea964
NC		 3686static const char *
3687get_aarch64_section_type_name (unsigned int sh_type)
3688{
3689 switch (sh_type)
3690 {
3691 case SHT_AARCH64_ATTRIBUTES:
3692 return "AARCH64_ATTRIBUTES";
3693 default:
3694 break;
3695 }
3696 return NULL;
3697}
3698
40a18ebd
NC		 3699static const char *
3700get_arm_section_type_name (unsigned int sh_type)
3701{
3702 switch (sh_type)
3703 {
7f6fed87
NC		 3704 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3705 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3706 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3707 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3708 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3709 default:
3710 break;
3711 }
3712 return NULL;
3713}
3714
40b36596
JM		 3715static const char *
3716get_tic6x_section_type_name (unsigned int sh_type)
3717{
3718 switch (sh_type)
3719 {
3720 case SHT_C6000_UNWIND:
3721 return "C6000_UNWIND";
3722 case SHT_C6000_PREEMPTMAP:
3723 return "C6000_PREEMPTMAP";
3724 case SHT_C6000_ATTRIBUTES:
3725 return "C6000_ATTRIBUTES";
3726 case SHT_TI_ICODE:
3727 return "TI_ICODE";
3728 case SHT_TI_XREF:
3729 return "TI_XREF";
3730 case SHT_TI_HANDLER:
3731 return "TI_HANDLER";
3732 case SHT_TI_INITINFO:
3733 return "TI_INITINFO";
3734 case SHT_TI_PHATTRS:
3735 return "TI_PHATTRS";
3736 default:
3737 break;
3738 }
3739 return NULL;
3740}
3741
13761a11
NC		 3742static const char *
3743get_msp430x_section_type_name (unsigned int sh_type)
3744{
3745 switch (sh_type)
3746 {
3747 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3748 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3749 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3750 default: return NULL;
3751 }
3752}
3753
685080f2
NC		 3754static const char *
3755get_v850_section_type_name (unsigned int sh_type)
3756{
3757 switch (sh_type)
3758 {
3759 case SHT_V850_SCOMMON: return "V850 Small Common";
3760 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3761 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3762 case SHT_RENESAS_IOP: return "RENESAS IOP";
3763 case SHT_RENESAS_INFO: return "RENESAS INFO";
3764 default: return NULL;
3765 }
3766}
3767
252b5132 3768static const char *
d3ba0551 3769get_section_type_name (unsigned int sh_type)
252b5132 3770{
b34976b6 3771 static char buff[32];
252b5132
RH		 3772
3773 switch (sh_type)
3774 {
3775 case SHT_NULL: return "NULL";
3776 case SHT_PROGBITS: return "PROGBITS";
3777 case SHT_SYMTAB: return "SYMTAB";
3778 case SHT_STRTAB: return "STRTAB";
3779 case SHT_RELA: return "RELA";
3780 case SHT_HASH: return "HASH";
3781 case SHT_DYNAMIC: return "DYNAMIC";
3782 case SHT_NOTE: return "NOTE";
3783 case SHT_NOBITS: return "NOBITS";
3784 case SHT_REL: return "REL";
3785 case SHT_SHLIB: return "SHLIB";
3786 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3787 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3788 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3789 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3790 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3791 case SHT_GROUP: return "GROUP";
3792 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3793 case SHT_GNU_verdef: return "VERDEF";
3794 case SHT_GNU_verneed: return "VERNEED";
3795 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3796 case 0x6ffffff0: return "VERSYM";
3797 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3798 case 0x7ffffffd: return "AUXILIARY";
3799 case 0x7fffffff: return "FILTER";
047b2264 3800 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3801
3802 default:
3803 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3804 {
2cf0635d 3805 const char * result;
252b5132
RH		 3806
3807 switch (elf_header.e_machine)
3808 {
3809 case EM_MIPS:
4fe85591 3810 case EM_MIPS_RS3_LE:
252b5132
RH		 3811 result = get_mips_section_type_name (sh_type);
3812 break;
103f02d3
UD		 3813 case EM_PARISC:
3814 result = get_parisc_section_type_name (sh_type);
3815 break;
4d6ed7c8
NC		 3816 case EM_IA_64:
3817 result = get_ia64_section_type_name (sh_type);
3818 break;
d2b2c203 3819 case EM_X86_64:
8a9036a4 3820 case EM_L1OM:
7a9068fe 3821 case EM_K1OM:
d2b2c203
DJ		 3822 result = get_x86_64_section_type_name (sh_type);
3823 break;
a06ea964
NC		 3824 case EM_AARCH64:
3825 result = get_aarch64_section_type_name (sh_type);
3826 break;
40a18ebd
NC		 3827 case EM_ARM:
3828 result = get_arm_section_type_name (sh_type);
3829 break;
40b36596
JM		 3830 case EM_TI_C6000:
3831 result = get_tic6x_section_type_name (sh_type);
3832 break;
13761a11
NC		 3833 case EM_MSP430:
3834 result = get_msp430x_section_type_name (sh_type);
3835 break;
685080f2
NC		 3836 case EM_V800:
3837 case EM_V850:
3838 case EM_CYGNUS_V850:
3839 result = get_v850_section_type_name (sh_type);
3840 break;
252b5132
RH		 3841 default:
3842 result = NULL;
3843 break;
3844 }
3845
3846 if (result != NULL)
3847 return result;
3848
c91d0dfb 3849 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3850 }
3851 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3852 {
2cf0635d 3853 const char * result;
148b93f2
NC		 3854
3855 switch (elf_header.e_machine)
3856 {
3857 case EM_IA_64:
3858 result = get_ia64_section_type_name (sh_type);
3859 break;
3860 default:
3861 result = NULL;
3862 break;
3863 }
3864
3865 if (result != NULL)
3866 return result;
3867
3868 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3869 }
252b5132 3870 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3871 {
3872 switch (elf_header.e_machine)
3873 {
3874 case EM_V800:
3875 case EM_V850:
3876 case EM_CYGNUS_V850:
3877 return get_v850_section_type_name (sh_type);
3878 default:
3879 break;
3880 }
3881
3882 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3883 }
252b5132 3884 else
a7dbfd1c
NC		 3885 /* This message is probably going to be displayed in a 15
3886 character wide field, so put the hex value first. */
3887 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3888
252b5132
RH		 3889 return buff;
3890 }
3891}
3892
2979dc34 3893#define OPTION_DEBUG_DUMP 512
2c610e4b 3894#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3895#define OPTION_DWARF_DEPTH 514
3896#define OPTION_DWARF_START 515
4723351a 3897#define OPTION_DWARF_CHECK 516
2979dc34 3898
85b1c36d 3899static struct option options[] =
252b5132 3900{
b34976b6 3901 {"all", no_argument, 0, 'a'},
252b5132
RH		 3902 {"file-header", no_argument, 0, 'h'},
3903 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3904 {"headers", no_argument, 0, 'e'},
3905 {"histogram", no_argument, 0, 'I'},
3906 {"segments", no_argument, 0, 'l'},
3907 {"sections", no_argument, 0, 'S'},
252b5132 3908 {"section-headers", no_argument, 0, 'S'},
f5842774 3909 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3910 {"section-details", no_argument, 0, 't'},
595cf52e 3911 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3912 {"symbols", no_argument, 0, 's'},
3913 {"syms", no_argument, 0, 's'},
2c610e4b 3914 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3915 {"relocs", no_argument, 0, 'r'},
3916 {"notes", no_argument, 0, 'n'},
3917 {"dynamic", no_argument, 0, 'd'},
a952a375 3918 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3919 {"version-info", no_argument, 0, 'V'},
3920 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3921 {"unwind", no_argument, 0, 'u'},
4145f1d5 3922 {"archive-index", no_argument, 0, 'c'},
b34976b6 3923 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3924 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3925 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3926#ifdef SUPPORT_DISASSEMBLY
3927 {"instruction-dump", required_argument, 0, 'i'},
3928#endif
cf13d699 3929 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3930
fd2f0033
TT		 3931 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3932 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3933 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3934
b34976b6
AM		 3935 {"version", no_argument, 0, 'v'},
3936 {"wide", no_argument, 0, 'W'},
3937 {"help", no_argument, 0, 'H'},
3938 {0, no_argument, 0, 0}
252b5132
RH		 3939};
3940
3941static void
2cf0635d 3942usage (FILE * stream)
252b5132 3943{
92f01d61
JM		 3944 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3945 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3946 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3947 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3948 -h --file-header Display the ELF file header\n\
3949 -l --program-headers Display the program headers\n\
3950 --segments An alias for --program-headers\n\
3951 -S --section-headers Display the sections' header\n\
3952 --sections An alias for --section-headers\n\
f5842774 3953 -g --section-groups Display the section groups\n\
5477e8a0 3954 -t --section-details Display the section details\n\
8b53311e
NC		 3955 -e --headers Equivalent to: -h -l -S\n\
3956 -s --syms Display the symbol table\n\
3f08eb35 3957 --symbols An alias for --syms\n\
2c610e4b 3958 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3959 -n --notes Display the core notes (if present)\n\
3960 -r --relocs Display the relocations (if present)\n\
3961 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3962 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3963 -V --version-info Display the version sections (if present)\n\
1b31d05e 3964 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3965 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3966 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3967 -x --hex-dump=<number|name>\n\
3968 Dump the contents of section <number|name> as bytes\n\
3969 -p --string-dump=<number|name>\n\
3970 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3971 -R --relocated-dump=<number|name>\n\
3972 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3973 -w[lLiaprmfFsoRt] or\n\
1ed06042 3974 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3975 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3976 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3977 =addr,=cu_index]\n\
8b53311e 3978 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3979 fprintf (stream, _("\
3980 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3981 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3982 or deeper\n"));
252b5132 3983#ifdef SUPPORT_DISASSEMBLY
92f01d61 3984 fprintf (stream, _("\
09c11c86
NC		 3985 -i --instruction-dump=<number|name>\n\
3986 Disassemble the contents of section <number|name>\n"));
252b5132 3987#endif
92f01d61 3988 fprintf (stream, _("\
8b53311e
NC		 3989 -I --histogram Display histogram of bucket list lengths\n\
3990 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3991 @<file> Read options from <file>\n\
8b53311e
NC		 3992 -H --help Display this information\n\
3993 -v --version Display the version number of readelf\n"));
1118d252 3994
92f01d61
JM		 3995 if (REPORT_BUGS_TO[0] && stream == stdout)
3996 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3997
92f01d61 3998 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3999}
4000
18bd398b
NC		 4001/* Record the fact that the user wants the contents of section number
4002 SECTION to be displayed using the method(s) encoded as flags bits
4003 in TYPE. Note, TYPE can be zero if we are creating the array for
4004 the first time. */
4005
252b5132 4006static void
09c11c86 4007request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4008{
4009 if (section >= num_dump_sects)
4010 {
2cf0635d 4011 dump_type * new_dump_sects;
252b5132 4012
3f5e193b
NC		 4013 new_dump_sects = (dump_type *) calloc (section + 1,
4014 sizeof (* dump_sects));
252b5132
RH		 4015
4016 if (new_dump_sects == NULL)
591a748a 4017 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4018 else
4019 {
4020 /* Copy current flag settings. */
09c11c86 4021 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4022
4023 free (dump_sects);
4024
4025 dump_sects = new_dump_sects;
4026 num_dump_sects = section + 1;
4027 }
4028 }
4029
4030 if (dump_sects)
b34976b6 4031 dump_sects[section] |= type;
252b5132
RH		 4032
4033 return;
4034}
4035
aef1f6d0
DJ		 4036/* Request a dump by section name. */
4037
4038static void
2cf0635d 4039request_dump_byname (const char * section, dump_type type)
aef1f6d0 4040{
2cf0635d 4041 struct dump_list_entry * new_request;
aef1f6d0 4042
3f5e193b
NC		 4043 new_request = (struct dump_list_entry *)
4044 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4045 if (!new_request)
591a748a 4046 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4047
4048 new_request->name = strdup (section);
4049 if (!new_request->name)
591a748a 4050 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4051
4052 new_request->type = type;
4053
4054 new_request->next = dump_sects_byname;
4055 dump_sects_byname = new_request;
4056}
4057
cf13d699
NC		 4058static inline void
4059request_dump (dump_type type)
4060{
4061 int section;
4062 char * cp;
4063
4064 do_dump++;
4065 section = strtoul (optarg, & cp, 0);
4066
4067 if (! *cp && section >= 0)
4068 request_dump_bynumber (section, type);
4069 else
4070 request_dump_byname (optarg, type);
4071}
4072
4073
252b5132 4074static void
2cf0635d 4075parse_args (int argc, char ** argv)
252b5132
RH		 4076{
4077 int c;
4078
4079 if (argc < 2)
92f01d61 4080 usage (stderr);
252b5132
RH		 4081
4082 while ((c = getopt_long
cf13d699 4083 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 4084 {
252b5132
RH		 4085 switch (c)
4086 {
4087 case 0:
4088 /* Long options. */
4089 break;
4090 case 'H':
92f01d61 4091 usage (stdout);
252b5132
RH		 4092 break;
4093
4094 case 'a':
b34976b6
AM		 4095 do_syms++;
4096 do_reloc++;
4097 do_unwind++;
4098 do_dynamic++;
4099 do_header++;
4100 do_sections++;
f5842774 4101 do_section_groups++;
b34976b6
AM		 4102 do_segments++;
4103 do_version++;
4104 do_histogram++;
4105 do_arch++;
4106 do_notes++;
252b5132 4107 break;
f5842774
L		 4108 case 'g':
4109 do_section_groups++;
4110 break;
5477e8a0 4111 case 't':
595cf52e 4112 case 'N':
5477e8a0
L		 4113 do_sections++;
4114 do_section_details++;
595cf52e 4115 break;
252b5132 4116 case 'e':
b34976b6
AM		 4117 do_header++;
4118 do_sections++;
4119 do_segments++;
252b5132 4120 break;
a952a375 4121 case 'A':
b34976b6 4122 do_arch++;
a952a375 4123 break;
252b5132 4124 case 'D':
b34976b6 4125 do_using_dynamic++;
252b5132
RH		 4126 break;
4127 case 'r':
b34976b6 4128 do_reloc++;
252b5132 4129 break;
4d6ed7c8 4130 case 'u':
b34976b6 4131 do_unwind++;
4d6ed7c8 4132 break;
252b5132 4133 case 'h':
b34976b6 4134 do_header++;
252b5132
RH		 4135 break;
4136 case 'l':
b34976b6 4137 do_segments++;
252b5132
RH		 4138 break;
4139 case 's':
b34976b6 4140 do_syms++;
252b5132
RH		 4141 break;
4142 case 'S':
b34976b6 4143 do_sections++;
252b5132
RH		 4144 break;
4145 case 'd':
b34976b6 4146 do_dynamic++;
252b5132 4147 break;
a952a375 4148 case 'I':
b34976b6 4149 do_histogram++;
a952a375 4150 break;
779fe533 4151 case 'n':
b34976b6 4152 do_notes++;
779fe533 4153 break;
4145f1d5
NC		 4154 case 'c':
4155 do_archive_index++;
4156 break;
252b5132 4157 case 'x':
cf13d699 4158 request_dump (HEX_DUMP);
aef1f6d0 4159 break;
09c11c86 4160 case 'p':
cf13d699
NC		 4161 request_dump (STRING_DUMP);
4162 break;
4163 case 'R':
4164 request_dump (RELOC_DUMP);
09c11c86 4165 break;
252b5132 4166 case 'w':
b34976b6 4167 do_dump++;
252b5132 4168 if (optarg == 0)
613ff48b
CC		 4169 {
4170 do_debugging = 1;
4171 dwarf_select_sections_all ();
4172 }
252b5132
RH		 4173 else
4174 {
4175 do_debugging = 0;
4cb93e3b 4176 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4177 }
4178 break;
2979dc34 4179 case OPTION_DEBUG_DUMP:
b34976b6 4180 do_dump++;
2979dc34
JJ		 4181 if (optarg == 0)
4182 do_debugging = 1;
4183 else
4184 {
2979dc34 4185 do_debugging = 0;
4cb93e3b 4186 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4187 }
4188 break;
fd2f0033
TT		 4189 case OPTION_DWARF_DEPTH:
4190 {
4191 char *cp;
4192
4193 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4194 }
4195 break;
4196 case OPTION_DWARF_START:
4197 {
4198 char *cp;
4199
4200 dwarf_start_die = strtoul (optarg, & cp, 0);
4201 }
4202 break;
4723351a
CC		 4203 case OPTION_DWARF_CHECK:
4204 dwarf_check = 1;
4205 break;
2c610e4b
L		 4206 case OPTION_DYN_SYMS:
4207 do_dyn_syms++;
4208 break;
252b5132
RH		 4209#ifdef SUPPORT_DISASSEMBLY
4210 case 'i':
cf13d699
NC		 4211 request_dump (DISASS_DUMP);
4212 break;
252b5132
RH		 4213#endif
4214 case 'v':
4215 print_version (program_name);
4216 break;
4217 case 'V':
b34976b6 4218 do_version++;
252b5132 4219 break;
d974e256 4220 case 'W':
b34976b6 4221 do_wide++;
d974e256 4222 break;
252b5132 4223 default:
252b5132
RH		 4224 /* xgettext:c-format */
4225 error (_("Invalid option '-%c'\n"), c);
4226 /* Drop through. */
4227 case '?':
92f01d61 4228 usage (stderr);
252b5132
RH		 4229 }
4230 }
4231
4d6ed7c8 4232 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4233 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4234 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4235 && !do_section_groups && !do_archive_index
4236 && !do_dyn_syms)
92f01d61 4237 usage (stderr);
252b5132
RH		 4238}
4239
4240static const char *
d3ba0551 4241get_elf_class (unsigned int elf_class)
252b5132 4242{
b34976b6 4243 static char buff[32];
103f02d3 4244
252b5132
RH		 4245 switch (elf_class)
4246 {
4247 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4248 case ELFCLASS32: return "ELF32";
4249 case ELFCLASS64: return "ELF64";
ab5e7794 4250 default:
e9e44622 4251 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4252 return buff;
252b5132
RH		 4253 }
4254}
4255
4256static const char *
d3ba0551 4257get_data_encoding (unsigned int encoding)
252b5132 4258{
b34976b6 4259 static char buff[32];
103f02d3 4260
252b5132
RH		 4261 switch (encoding)
4262 {
4263 case ELFDATANONE: return _("none");
33c63f9d
CM		 4264 case ELFDATA2LSB: return _("2's complement, little endian");
4265 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4266 default:
e9e44622 4267 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4268 return buff;
252b5132
RH		 4269 }
4270}
4271
252b5132 4272/* Decode the data held in 'elf_header'. */
ee42cf8c 4273
252b5132 4274static int
d3ba0551 4275process_file_header (void)
252b5132 4276{
b34976b6
AM		 4277 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4278 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4279 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4280 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4281 {
4282 error
4283 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4284 return 0;
4285 }
4286
2dc4cec1
L		 4287 init_dwarf_regnames (elf_header.e_machine);
4288
252b5132
RH		 4289 if (do_header)
4290 {
4291 int i;
4292
4293 printf (_("ELF Header:\n"));
4294 printf (_(" Magic: "));
b34976b6
AM		 4295 for (i = 0; i < EI_NIDENT; i++)
4296 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4297 printf ("\n");
4298 printf (_(" Class: %s\n"),
b34976b6 4299 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4300 printf (_(" Data: %s\n"),
b34976b6 4301 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4302 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4303 elf_header.e_ident[EI_VERSION],
4304 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4305 ? "(current)"
b34976b6 4306 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4307 ? _("<unknown: %lx>")
789be9f7 4308 : "")));
252b5132 4309 printf (_(" OS/ABI: %s\n"),
b34976b6 4310 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4311 printf (_(" ABI Version: %d\n"),
b34976b6 4312 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4313 printf (_(" Type: %s\n"),
4314 get_file_type (elf_header.e_type));
4315 printf (_(" Machine: %s\n"),
4316 get_machine_name (elf_header.e_machine));
4317 printf (_(" Version: 0x%lx\n"),
4318 (unsigned long) elf_header.e_version);
76da6bbe 4319
f7a99963
NC		 4320 printf (_(" Entry point address: "));
4321 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4322 printf (_("\n Start of program headers: "));
4323 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4324 printf (_(" (bytes into file)\n Start of section headers: "));
4325 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4326 printf (_(" (bytes into file)\n"));
76da6bbe 4327
252b5132
RH		 4328 printf (_(" Flags: 0x%lx%s\n"),
4329 (unsigned long) elf_header.e_flags,
4330 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4331 printf (_(" Size of this header: %ld (bytes)\n"),
4332 (long) elf_header.e_ehsize);
4333 printf (_(" Size of program headers: %ld (bytes)\n"),
4334 (long) elf_header.e_phentsize);
2046a35d 4335 printf (_(" Number of program headers: %ld"),
252b5132 4336 (long) elf_header.e_phnum);
2046a35d
AM		 4337 if (section_headers != NULL
4338 && elf_header.e_phnum == PN_XNUM
4339 && section_headers[0].sh_info != 0)
cc5914eb 4340 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4341 putc ('\n', stdout);
252b5132
RH		 4342 printf (_(" Size of section headers: %ld (bytes)\n"),
4343 (long) elf_header.e_shentsize);
560f3c1c 4344 printf (_(" Number of section headers: %ld"),
252b5132 4345 (long) elf_header.e_shnum);
4fbb74a6 4346 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4347 printf (" (%ld)", (long) section_headers[0].sh_size);
4348 putc ('\n', stdout);
4349 printf (_(" Section header string table index: %ld"),
252b5132 4350 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4351 if (section_headers != NULL
4352 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4353 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4354 else if (elf_header.e_shstrndx != SHN_UNDEF
4355 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4356 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4357 putc ('\n', stdout);
4358 }
4359
4360 if (section_headers != NULL)
4361 {
2046a35d
AM		 4362 if (elf_header.e_phnum == PN_XNUM
4363 && section_headers[0].sh_info != 0)
4364 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4365 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4366 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4367 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4368 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4369 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4370 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4371 free (section_headers);
4372 section_headers = NULL;
252b5132 4373 }
103f02d3 4374
9ea033b2
NC		 4375 return 1;
4376}
4377
e0a31db1 4378static bfd_boolean
91d6fa6a 4379get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4380{
2cf0635d
NC		 4381 Elf32_External_Phdr * phdrs;
4382 Elf32_External_Phdr * external;
4383 Elf_Internal_Phdr * internal;
b34976b6 4384 unsigned int i;
e0a31db1
NC		 4385 unsigned int size = elf_header.e_phentsize;
4386 unsigned int num = elf_header.e_phnum;
4387
4388 /* PR binutils/17531: Cope with unexpected section header sizes. */
4389 if (size == 0 || num == 0)
4390 return FALSE;
4391 if (size < sizeof * phdrs)
4392 {
4393 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4394 return FALSE;
4395 }
4396 if (size > sizeof * phdrs)
4397 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4398
3f5e193b 4399 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4400 size, num, _("program headers"));
4401 if (phdrs == NULL)
4402 return FALSE;
9ea033b2 4403
91d6fa6a 4404 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4405 i < elf_header.e_phnum;
b34976b6 4406 i++, internal++, external++)
252b5132 4407 {
9ea033b2
NC		 4408 internal->p_type = BYTE_GET (external->p_type);
4409 internal->p_offset = BYTE_GET (external->p_offset);
4410 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4411 internal->p_paddr = BYTE_GET (external->p_paddr);
4412 internal->p_filesz = BYTE_GET (external->p_filesz);
4413 internal->p_memsz = BYTE_GET (external->p_memsz);
4414 internal->p_flags = BYTE_GET (external->p_flags);
4415 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4416 }
4417
9ea033b2 4418 free (phdrs);
e0a31db1 4419 return TRUE;
252b5132
RH		 4420}
4421
e0a31db1 4422static bfd_boolean
91d6fa6a 4423get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4424{
2cf0635d
NC		 4425 Elf64_External_Phdr * phdrs;
4426 Elf64_External_Phdr * external;
4427 Elf_Internal_Phdr * internal;
b34976b6 4428 unsigned int i;
e0a31db1
NC		 4429 unsigned int size = elf_header.e_phentsize;
4430 unsigned int num = elf_header.e_phnum;
4431
4432 /* PR binutils/17531: Cope with unexpected section header sizes. */
4433 if (size == 0 || num == 0)
4434 return FALSE;
4435 if (size < sizeof * phdrs)
4436 {
4437 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4438 return FALSE;
4439 }
4440 if (size > sizeof * phdrs)
4441 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4442
3f5e193b 4443 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4444 size, num, _("program headers"));
a6e9f9df 4445 if (!phdrs)
e0a31db1 4446 return FALSE;
9ea033b2 4447
91d6fa6a 4448 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4449 i < elf_header.e_phnum;
b34976b6 4450 i++, internal++, external++)
9ea033b2
NC		 4451 {
4452 internal->p_type = BYTE_GET (external->p_type);
4453 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4454 internal->p_offset = BYTE_GET (external->p_offset);
4455 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4456 internal->p_paddr = BYTE_GET (external->p_paddr);
4457 internal->p_filesz = BYTE_GET (external->p_filesz);
4458 internal->p_memsz = BYTE_GET (external->p_memsz);
4459 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4460 }
4461
4462 free (phdrs);
e0a31db1 4463 return TRUE;
9ea033b2 4464}
252b5132 4465
d93f0186
NC		 4466/* Returns 1 if the program headers were read into `program_headers'. */
4467
4468static int
2cf0635d 4469get_program_headers (FILE * file)
d93f0186 4470{
2cf0635d 4471 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4472
4473 /* Check cache of prior read. */
4474 if (program_headers != NULL)
4475 return 1;
4476
3f5e193b
NC		 4477 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4478 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4479
4480 if (phdrs == NULL)
4481 {
8b73c356
NC		 4482 error (_("Out of memory reading %u program headers\n"),
4483 elf_header.e_phnum);
d93f0186
NC		 4484 return 0;
4485 }
4486
4487 if (is_32bit_elf
4488 ? get_32bit_program_headers (file, phdrs)
4489 : get_64bit_program_headers (file, phdrs))
4490 {
4491 program_headers = phdrs;
4492 return 1;
4493 }
4494
4495 free (phdrs);
4496 return 0;
4497}
4498
2f62977e
NC		 4499/* Returns 1 if the program headers were loaded. */
4500
252b5132 4501static int
2cf0635d 4502process_program_headers (FILE * file)
252b5132 4503{
2cf0635d 4504 Elf_Internal_Phdr * segment;
b34976b6 4505 unsigned int i;
252b5132
RH		 4506
4507 if (elf_header.e_phnum == 0)
4508 {
82f2dbf7
NC		 4509 /* PR binutils/12467. */
4510 if (elf_header.e_phoff != 0)
4511 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4512 " header offset, but no program headers\n"));
82f2dbf7 4513 else if (do_segments)
252b5132 4514 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4515 return 0;
252b5132
RH		 4516 }
4517
4518 if (do_segments && !do_header)
4519 {
f7a99963
NC		 4520 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4521 printf (_("Entry point "));
4522 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4523 printf (_("\nThere are %d program headers, starting at offset "),
4524 elf_header.e_phnum);
4525 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4526 printf ("\n");
252b5132
RH		 4527 }
4528
d93f0186 4529 if (! get_program_headers (file))
252b5132 4530 return 0;
103f02d3 4531
252b5132
RH		 4532 if (do_segments)
4533 {
3a1a2036
NC		 4534 if (elf_header.e_phnum > 1)
4535 printf (_("\nProgram Headers:\n"));
4536 else
4537 printf (_("\nProgram Headers:\n"));
76da6bbe 4538
f7a99963
NC		 4539 if (is_32bit_elf)
4540 printf
4541 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4542 else if (do_wide)
4543 printf
4544 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4545 else
4546 {
4547 printf
4548 (_(" Type Offset VirtAddr PhysAddr\n"));
4549 printf
4550 (_(" FileSiz MemSiz Flags Align\n"));
4551 }
252b5132
RH		 4552 }
4553
252b5132 4554 dynamic_addr = 0;
1b228002 4555 dynamic_size = 0;
252b5132
RH		 4556
4557 for (i = 0, segment = program_headers;
4558 i < elf_header.e_phnum;
b34976b6 4559 i++, segment++)
252b5132
RH		 4560 {
4561 if (do_segments)
4562 {
103f02d3 4563 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4564
4565 if (is_32bit_elf)
4566 {
4567 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4568 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4569 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4570 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4571 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4572 printf ("%c%c%c ",
4573 (segment->p_flags & PF_R ? 'R' : ' '),
4574 (segment->p_flags & PF_W ? 'W' : ' '),
4575 (segment->p_flags & PF_X ? 'E' : ' '));
4576 printf ("%#lx", (unsigned long) segment->p_align);
4577 }
d974e256
JJ		 4578 else if (do_wide)
4579 {
4580 if ((unsigned long) segment->p_offset == segment->p_offset)
4581 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4582 else
4583 {
4584 print_vma (segment->p_offset, FULL_HEX);
4585 putchar (' ');
4586 }
4587
4588 print_vma (segment->p_vaddr, FULL_HEX);
4589 putchar (' ');
4590 print_vma (segment->p_paddr, FULL_HEX);
4591 putchar (' ');
4592
4593 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4594 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4595 else
4596 {
4597 print_vma (segment->p_filesz, FULL_HEX);
4598 putchar (' ');
4599 }
4600
4601 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4602 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4603 else
4604 {
f48e6c45 4605 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4606 }
4607
4608 printf (" %c%c%c ",
4609 (segment->p_flags & PF_R ? 'R' : ' '),
4610 (segment->p_flags & PF_W ? 'W' : ' '),
4611 (segment->p_flags & PF_X ? 'E' : ' '));
4612
4613 if ((unsigned long) segment->p_align == segment->p_align)
4614 printf ("%#lx", (unsigned long) segment->p_align);
4615 else
4616 {
4617 print_vma (segment->p_align, PREFIX_HEX);
4618 }
4619 }
f7a99963
NC		 4620 else
4621 {
4622 print_vma (segment->p_offset, FULL_HEX);
4623 putchar (' ');
4624 print_vma (segment->p_vaddr, FULL_HEX);
4625 putchar (' ');
4626 print_vma (segment->p_paddr, FULL_HEX);
4627 printf ("\n ");
4628 print_vma (segment->p_filesz, FULL_HEX);
4629 putchar (' ');
4630 print_vma (segment->p_memsz, FULL_HEX);
4631 printf (" %c%c%c ",
4632 (segment->p_flags & PF_R ? 'R' : ' '),
4633 (segment->p_flags & PF_W ? 'W' : ' '),
4634 (segment->p_flags & PF_X ? 'E' : ' '));
4635 print_vma (segment->p_align, HEX);
4636 }
252b5132
RH		 4637 }
4638
f54498b4
NC		 4639 if (do_segments)
4640 putc ('\n', stdout);
4641
252b5132
RH		 4642 switch (segment->p_type)
4643 {
252b5132
RH		 4644 case PT_DYNAMIC:
4645 if (dynamic_addr)
4646 error (_("more than one dynamic segment\n"));
4647
20737c13
AM		 4648 /* By default, assume that the .dynamic section is the first
4649 section in the DYNAMIC segment. */
4650 dynamic_addr = segment->p_offset;
4651 dynamic_size = segment->p_filesz;
f54498b4
NC		 4652 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4653 if (dynamic_addr + dynamic_size >= current_file_size)
4654 {
4655 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4656 dynamic_addr = dynamic_size = 0;
4657 }
20737c13 4658
b2d38a17
NC		 4659 /* Try to locate the .dynamic section. If there is
4660 a section header table, we can easily locate it. */
4661 if (section_headers != NULL)
4662 {
2cf0635d 4663 Elf_Internal_Shdr * sec;
b2d38a17 4664
89fac5e3
RS		 4665 sec = find_section (".dynamic");
4666 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4667 {
28f997cf
TG		 4668 /* A corresponding .dynamic section is expected, but on
4669 IA-64/OpenVMS it is OK for it to be missing. */
4670 if (!is_ia64_vms ())
4671 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4672 break;
4673 }
4674
42bb2e33 4675 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4676 {
4677 dynamic_size = 0;
4678 break;
4679 }
42bb2e33 4680
b2d38a17
NC		 4681 dynamic_addr = sec->sh_offset;
4682 dynamic_size = sec->sh_size;
4683
4684 if (dynamic_addr < segment->p_offset
4685 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4686 warn (_("the .dynamic section is not contained"
4687 " within the dynamic segment\n"));
b2d38a17 4688 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4689 warn (_("the .dynamic section is not the first section"
4690 " in the dynamic segment.\n"));
b2d38a17 4691 }
252b5132
RH		 4692 break;
4693
4694 case PT_INTERP:
fb52b2f4
NC		 4695 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4696 SEEK_SET))
252b5132
RH		 4697 error (_("Unable to find program interpreter name\n"));
4698 else
4699 {
f8eae8b2 4700 char fmt [32];
9495b2e6 4701 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4702
4703 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4704 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4705
252b5132 4706 program_interpreter[0] = 0;
7bd7b3ef
AM		 4707 if (fscanf (file, fmt, program_interpreter) <= 0)
4708 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4709
4710 if (do_segments)
f54498b4 4711 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4712 program_interpreter);
4713 }
4714 break;
4715 }
252b5132
RH		 4716 }
4717
c256ffe7 4718 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4719 {
4720 printf (_("\n Section to Segment mapping:\n"));
4721 printf (_(" Segment Sections...\n"));
4722
252b5132
RH		 4723 for (i = 0; i < elf_header.e_phnum; i++)
4724 {
9ad5cbcf 4725 unsigned int j;
2cf0635d 4726 Elf_Internal_Shdr * section;
252b5132
RH		 4727
4728 segment = program_headers + i;
b391a3e3 4729 section = section_headers + 1;
252b5132
RH		 4730
4731 printf (" %2.2d ", i);
4732
b34976b6 4733 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4734 {
f4638467
AM		 4735 if (!ELF_TBSS_SPECIAL (section, segment)
4736 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4737 printf ("%s ", printable_section_name (section));
252b5132
RH		 4738 }
4739
4740 putc ('\n',stdout);
4741 }
4742 }
4743
252b5132
RH		 4744 return 1;
4745}
4746
4747
d93f0186
NC		 4748/* Find the file offset corresponding to VMA by using the program headers. */
4749
4750static long
2cf0635d 4751offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4752{
2cf0635d 4753 Elf_Internal_Phdr * seg;
d93f0186
NC		 4754
4755 if (! get_program_headers (file))
4756 {
4757 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4758 return (long) vma;
4759 }
4760
4761 for (seg = program_headers;
4762 seg < program_headers + elf_header.e_phnum;
4763 ++seg)
4764 {
4765 if (seg->p_type != PT_LOAD)
4766 continue;
4767
4768 if (vma >= (seg->p_vaddr & -seg->p_align)
4769 && vma + size <= seg->p_vaddr + seg->p_filesz)
4770 return vma - seg->p_vaddr + seg->p_offset;
4771 }
4772
4773 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4774 (unsigned long) vma);
d93f0186
NC		 4775 return (long) vma;
4776}
4777
4778
049b0c3a
NC		 4779/* Allocate memory and load the sections headers into the global pointer
4780 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4781 generate any error messages if the load fails. */
4782
4783static bfd_boolean
4784get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4785{
2cf0635d
NC		 4786 Elf32_External_Shdr * shdrs;
4787 Elf_Internal_Shdr * internal;
b34976b6 4788 unsigned int i;
049b0c3a
NC		 4789 unsigned int size = elf_header.e_shentsize;
4790 unsigned int num = probe ? 1 : elf_header.e_shnum;
4791
4792 /* PR binutils/17531: Cope with unexpected section header sizes. */
4793 if (size == 0 || num == 0)
4794 return FALSE;
4795 if (size < sizeof * shdrs)
4796 {
4797 if (! probe)
4798 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4799 return FALSE;
4800 }
4801 if (!probe && size > sizeof * shdrs)
4802 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4803
3f5e193b 4804 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4805 size, num,
4806 probe ? NULL : _("section headers"));
4807 if (shdrs == NULL)
4808 return FALSE;
252b5132 4809
049b0c3a
NC		 4810 if (section_headers != NULL)
4811 free (section_headers);
3f5e193b
NC		 4812 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4813 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4814 if (section_headers == NULL)
4815 {
049b0c3a 4816 if (!probe)
8b73c356 4817 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4818 return FALSE;
252b5132
RH		 4819 }
4820
4821 for (i = 0, internal = section_headers;
560f3c1c 4822 i < num;
b34976b6 4823 i++, internal++)
252b5132
RH		 4824 {
4825 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4826 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4827 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4828 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4829 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4830 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4831 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4832 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4833 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4834 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4835 }
4836
4837 free (shdrs);
049b0c3a 4838 return TRUE;
252b5132
RH		 4839}
4840
049b0c3a
NC		 4841static bfd_boolean
4842get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4843{
2cf0635d
NC		 4844 Elf64_External_Shdr * shdrs;
4845 Elf_Internal_Shdr * internal;
b34976b6 4846 unsigned int i;
049b0c3a
NC		 4847 unsigned int size = elf_header.e_shentsize;
4848 unsigned int num = probe ? 1 : elf_header.e_shnum;
4849
4850 /* PR binutils/17531: Cope with unexpected section header sizes. */
4851 if (size == 0 || num == 0)
4852 return FALSE;
4853 if (size < sizeof * shdrs)
4854 {
4855 if (! probe)
4856 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4857 return FALSE;
4858 }
4859 if (! probe && size > sizeof * shdrs)
4860 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4861
3f5e193b 4862 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4863 size, num,
4864 probe ? NULL : _("section headers"));
4865 if (shdrs == NULL)
4866 return FALSE;
9ea033b2 4867
049b0c3a
NC		 4868 if (section_headers != NULL)
4869 free (section_headers);
3f5e193b
NC		 4870 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4871 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4872 if (section_headers == NULL)
4873 {
049b0c3a 4874 if (! probe)
8b73c356 4875 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4876 return FALSE;
9ea033b2
NC		 4877 }
4878
4879 for (i = 0, internal = section_headers;
560f3c1c 4880 i < num;
b34976b6 4881 i++, internal++)
9ea033b2
NC		 4882 {
4883 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4884 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4885 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4886 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4887 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4888 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4889 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4890 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4891 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4892 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4893 }
4894
4895 free (shdrs);
049b0c3a 4896 return TRUE;
9ea033b2
NC		 4897}
4898
252b5132 4899static Elf_Internal_Sym *
ba5cdace
NC		 4900get_32bit_elf_symbols (FILE * file,
4901 Elf_Internal_Shdr * section,
4902 unsigned long * num_syms_return)
252b5132 4903{
ba5cdace 4904 unsigned long number = 0;
dd24e3da 4905 Elf32_External_Sym * esyms = NULL;
ba5cdace 4906 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4907 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4908 Elf_Internal_Sym * psym;
b34976b6 4909 unsigned int j;
252b5132 4910
c9c1d674
EG		 4911 if (section->sh_size == 0)
4912 {
4913 if (num_syms_return != NULL)
4914 * num_syms_return = 0;
4915 return NULL;
4916 }
4917
dd24e3da 4918 /* Run some sanity checks first. */
c9c1d674 4919 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4920 {
c9c1d674
EG		 4921 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4922 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4923 goto exit_point;
dd24e3da
NC		 4924 }
4925
f54498b4
NC		 4926 if (section->sh_size > current_file_size)
4927 {
4928 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4929 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4930 goto exit_point;
4931 }
4932
dd24e3da
NC		 4933 number = section->sh_size / section->sh_entsize;
4934
4935 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4936 {
c9c1d674 4937 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4938 (unsigned long) section->sh_size,
4939 printable_section_name (section),
4940 (unsigned long) section->sh_entsize);
ba5cdace 4941 goto exit_point;
dd24e3da
NC		 4942 }
4943
3f5e193b
NC		 4944 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4945 section->sh_size, _("symbols"));
dd24e3da 4946 if (esyms == NULL)
ba5cdace 4947 goto exit_point;
252b5132 4948
9ad5cbcf
AM		 4949 shndx = NULL;
4950 if (symtab_shndx_hdr != NULL
4951 && (symtab_shndx_hdr->sh_link
4fbb74a6 4952 == (unsigned long) (section - section_headers)))
9ad5cbcf 4953 {
3f5e193b
NC		 4954 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4955 symtab_shndx_hdr->sh_offset,
4956 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4957 _("symbol table section indicies"));
dd24e3da
NC		 4958 if (shndx == NULL)
4959 goto exit_point;
c9c1d674
EG		 4960 /* PR17531: file: heap-buffer-overflow */
4961 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4962 {
4963 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4964 printable_section_name (symtab_shndx_hdr),
4965 (unsigned long) symtab_shndx_hdr->sh_size,
4966 (unsigned long) section->sh_size);
4967 goto exit_point;
4968 }
9ad5cbcf
AM		 4969 }
4970
3f5e193b 4971 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4972
4973 if (isyms == NULL)
4974 {
8b73c356
NC		 4975 error (_("Out of memory reading %lu symbols\n"),
4976 (unsigned long) number);
dd24e3da 4977 goto exit_point;
252b5132
RH		 4978 }
4979
dd24e3da 4980 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4981 {
4982 psym->st_name = BYTE_GET (esyms[j].st_name);
4983 psym->st_value = BYTE_GET (esyms[j].st_value);
4984 psym->st_size = BYTE_GET (esyms[j].st_size);
4985 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4986 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4987 psym->st_shndx
4988 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4989 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4990 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4991 psym->st_info = BYTE_GET (esyms[j].st_info);
4992 psym->st_other = BYTE_GET (esyms[j].st_other);
4993 }
4994
dd24e3da 4995 exit_point:
ba5cdace 4996 if (shndx != NULL)
9ad5cbcf 4997 free (shndx);
ba5cdace 4998 if (esyms != NULL)
dd24e3da 4999 free (esyms);
252b5132 5000
ba5cdace
NC		 5001 if (num_syms_return != NULL)
5002 * num_syms_return = isyms == NULL ? 0 : number;
5003
252b5132
RH		 5004 return isyms;
5005}
5006
9ea033b2 5007static Elf_Internal_Sym *
ba5cdace
NC		 5008get_64bit_elf_symbols (FILE * file,
5009 Elf_Internal_Shdr * section,
5010 unsigned long * num_syms_return)
9ea033b2 5011{
ba5cdace
NC		 5012 unsigned long number = 0;
5013 Elf64_External_Sym * esyms = NULL;
5014 Elf_External_Sym_Shndx * shndx = NULL;
5015 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5016 Elf_Internal_Sym * psym;
b34976b6 5017 unsigned int j;
9ea033b2 5018
c9c1d674
EG		 5019 if (section->sh_size == 0)
5020 {
5021 if (num_syms_return != NULL)
5022 * num_syms_return = 0;
5023 return NULL;
5024 }
5025
dd24e3da 5026 /* Run some sanity checks first. */
c9c1d674 5027 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5028 {
c9c1d674 5029 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5030 printable_section_name (section),
5031 (unsigned long) section->sh_entsize);
ba5cdace 5032 goto exit_point;
dd24e3da
NC		 5033 }
5034
f54498b4
NC		 5035 if (section->sh_size > current_file_size)
5036 {
5037 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5038 printable_section_name (section),
5039 (unsigned long) section->sh_size);
f54498b4
NC		 5040 goto exit_point;
5041 }
5042
dd24e3da
NC		 5043 number = section->sh_size / section->sh_entsize;
5044
5045 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5046 {
c9c1d674 5047 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5048 (unsigned long) section->sh_size,
5049 printable_section_name (section),
5050 (unsigned long) section->sh_entsize);
ba5cdace 5051 goto exit_point;
dd24e3da
NC		 5052 }
5053
3f5e193b
NC		 5054 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5055 section->sh_size, _("symbols"));
a6e9f9df 5056 if (!esyms)
ba5cdace 5057 goto exit_point;
9ea033b2 5058
9ad5cbcf
AM		 5059 if (symtab_shndx_hdr != NULL
5060 && (symtab_shndx_hdr->sh_link
4fbb74a6 5061 == (unsigned long) (section - section_headers)))
9ad5cbcf 5062 {
3f5e193b
NC		 5063 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5064 symtab_shndx_hdr->sh_offset,
5065 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5066 _("symbol table section indicies"));
ba5cdace
NC		 5067 if (shndx == NULL)
5068 goto exit_point;
c9c1d674
EG		 5069 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5070 {
5071 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5072 printable_section_name (symtab_shndx_hdr),
5073 (unsigned long) symtab_shndx_hdr->sh_size,
5074 (unsigned long) section->sh_size);
5075 goto exit_point;
5076 }
9ad5cbcf
AM		 5077 }
5078
3f5e193b 5079 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5080
5081 if (isyms == NULL)
5082 {
8b73c356
NC		 5083 error (_("Out of memory reading %lu symbols\n"),
5084 (unsigned long) number);
ba5cdace 5085 goto exit_point;
9ea033b2
NC		 5086 }
5087
ba5cdace 5088 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5089 {
5090 psym->st_name = BYTE_GET (esyms[j].st_name);
5091 psym->st_info = BYTE_GET (esyms[j].st_info);
5092 psym->st_other = BYTE_GET (esyms[j].st_other);
5093 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5094
4fbb74a6 5095 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5096 psym->st_shndx
5097 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5098 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5099 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5100
66543521
AM		 5101 psym->st_value = BYTE_GET (esyms[j].st_value);
5102 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5103 }
5104
ba5cdace
NC		 5105 exit_point:
5106 if (shndx != NULL)
9ad5cbcf 5107 free (shndx);
ba5cdace
NC		 5108 if (esyms != NULL)
5109 free (esyms);
5110
5111 if (num_syms_return != NULL)
5112 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5113
5114 return isyms;
5115}
5116
d1133906 5117static const char *
d3ba0551 5118get_elf_section_flags (bfd_vma sh_flags)
d1133906 5119{
5477e8a0 5120 static char buff[1024];
2cf0635d 5121 char * p = buff;
8d5ff12c 5122 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5123 int sindex;
5124 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5125 bfd_vma os_flags = 0;
5126 bfd_vma proc_flags = 0;
5127 bfd_vma unknown_flags = 0;
148b93f2 5128 static const struct
5477e8a0 5129 {
2cf0635d 5130 const char * str;
5477e8a0
L		 5131 int len;
5132 }
5133 flags [] =
5134 {
cfcac11d
NC		 5135 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5136 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5137 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5138 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5139 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5140 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5141 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5142 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5143 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5144 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5145 /* IA-64 specific. */
5146 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5147 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5148 /* IA-64 OpenVMS specific. */
5149 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5150 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5151 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5152 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5153 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5154 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5155 /* Generic. */
cfcac11d 5156 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5157 /* SPARC specific. */
77115a4a
L		 5158 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5159 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5160 };
5161
5162 if (do_section_details)
5163 {
8d5ff12c
L		 5164 sprintf (buff, "[%*.*lx]: ",
5165 field_size, field_size, (unsigned long) sh_flags);
5166 p += field_size + 4;
5477e8a0 5167 }
76da6bbe 5168
d1133906
NC		 5169 while (sh_flags)
5170 {
5171 bfd_vma flag;
5172
5173 flag = sh_flags & - sh_flags;
5174 sh_flags &= ~ flag;
76da6bbe 5175
5477e8a0 5176 if (do_section_details)
d1133906 5177 {
5477e8a0
L		 5178 switch (flag)
5179 {
91d6fa6a
NC		 5180 case SHF_WRITE: sindex = 0; break;
5181 case SHF_ALLOC: sindex = 1; break;
5182 case SHF_EXECINSTR: sindex = 2; break;
5183 case SHF_MERGE: sindex = 3; break;
5184 case SHF_STRINGS: sindex = 4; break;
5185 case SHF_INFO_LINK: sindex = 5; break;
5186 case SHF_LINK_ORDER: sindex = 6; break;
5187 case SHF_OS_NONCONFORMING: sindex = 7; break;
5188 case SHF_GROUP: sindex = 8; break;
5189 case SHF_TLS: sindex = 9; break;
18ae9cc1 5190 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5191 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5192
5477e8a0 5193 default:
91d6fa6a 5194 sindex = -1;
cfcac11d 5195 switch (elf_header.e_machine)
148b93f2 5196 {
cfcac11d 5197 case EM_IA_64:
148b93f2 5198 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5199 sindex = 10;
148b93f2 5200 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5201 sindex = 11;
148b93f2
NC		 5202#ifdef BFD64
5203 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5204 switch (flag)
5205 {
91d6fa6a
NC		 5206 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5207 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5208 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5209 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5210 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5211 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5212 default: break;
5213 }
5214#endif
cfcac11d
NC		 5215 break;
5216
caa83f8b
NC		 5217 case EM_386:
5218 case EM_486:
5219 case EM_X86_64:
7f502d6c 5220 case EM_L1OM:
7a9068fe 5221 case EM_K1OM:
cfcac11d
NC		 5222 case EM_OLD_SPARCV9:
5223 case EM_SPARC32PLUS:
5224 case EM_SPARCV9:
5225 case EM_SPARC:
18ae9cc1 5226 if (flag == SHF_ORDERED)
91d6fa6a 5227 sindex = 19;
cfcac11d
NC		 5228 break;
5229 default:
5230 break;
148b93f2 5231 }
5477e8a0
L		 5232 }
5233
91d6fa6a 5234 if (sindex != -1)
5477e8a0 5235 {
8d5ff12c
L		 5236 if (p != buff + field_size + 4)
5237 {
5238 if (size < (10 + 2))
bee0ee85
NC		 5239 {
5240 warn (_("Internal error: not enough buffer room for section flag info"));
5241 return _("<unknown>");
5242 }
8d5ff12c
L		 5243 size -= 2;
5244 *p++ = ',';
5245 *p++ = ' ';
5246 }
5247
91d6fa6a
NC		 5248 size -= flags [sindex].len;
5249 p = stpcpy (p, flags [sindex].str);
5477e8a0 5250 }
3b22753a 5251 else if (flag & SHF_MASKOS)
8d5ff12c 5252 os_flags |= flag;
d1133906 5253 else if (flag & SHF_MASKPROC)
8d5ff12c 5254 proc_flags |= flag;
d1133906 5255 else
8d5ff12c 5256 unknown_flags |= flag;
5477e8a0
L		 5257 }
5258 else
5259 {
5260 switch (flag)
5261 {
5262 case SHF_WRITE: *p = 'W'; break;
5263 case SHF_ALLOC: *p = 'A'; break;
5264 case SHF_EXECINSTR: *p = 'X'; break;
5265 case SHF_MERGE: *p = 'M'; break;
5266 case SHF_STRINGS: *p = 'S'; break;
5267 case SHF_INFO_LINK: *p = 'I'; break;
5268 case SHF_LINK_ORDER: *p = 'L'; break;
5269 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5270 case SHF_GROUP: *p = 'G'; break;
5271 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5272 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5273 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5274
5275 default:
8a9036a4 5276 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5277 || elf_header.e_machine == EM_L1OM
5278 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5279 && flag == SHF_X86_64_LARGE)
5280 *p = 'l';
5281 else if (flag & SHF_MASKOS)
5282 {
5283 *p = 'o';
5284 sh_flags &= ~ SHF_MASKOS;
5285 }
5286 else if (flag & SHF_MASKPROC)
5287 {
5288 *p = 'p';
5289 sh_flags &= ~ SHF_MASKPROC;
5290 }
5291 else
5292 *p = 'x';
5293 break;
5294 }
5295 p++;
d1133906
NC		 5296 }
5297 }
76da6bbe 5298
8d5ff12c
L		 5299 if (do_section_details)
5300 {
5301 if (os_flags)
5302 {
5303 size -= 5 + field_size;
5304 if (p != buff + field_size + 4)
5305 {
5306 if (size < (2 + 1))
bee0ee85
NC		 5307 {
5308 warn (_("Internal error: not enough buffer room for section flag info"));
5309 return _("<unknown>");
5310 }
8d5ff12c
L		 5311 size -= 2;
5312 *p++ = ',';
5313 *p++ = ' ';
5314 }
5315 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5316 (unsigned long) os_flags);
5317 p += 5 + field_size;
5318 }
5319 if (proc_flags)
5320 {
5321 size -= 7 + field_size;
5322 if (p != buff + field_size + 4)
5323 {
5324 if (size < (2 + 1))
bee0ee85
NC		 5325 {
5326 warn (_("Internal error: not enough buffer room for section flag info"));
5327 return _("<unknown>");
5328 }
8d5ff12c
L		 5329 size -= 2;
5330 *p++ = ',';
5331 *p++ = ' ';
5332 }
5333 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5334 (unsigned long) proc_flags);
5335 p += 7 + field_size;
5336 }
5337 if (unknown_flags)
5338 {
5339 size -= 10 + field_size;
5340 if (p != buff + field_size + 4)
5341 {
5342 if (size < (2 + 1))
bee0ee85
NC		 5343 {
5344 warn (_("Internal error: not enough buffer room for section flag info"));
5345 return _("<unknown>");
5346 }
8d5ff12c
L		 5347 size -= 2;
5348 *p++ = ',';
5349 *p++ = ' ';
5350 }
2b692964 5351 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5352 (unsigned long) unknown_flags);
5353 p += 10 + field_size;
5354 }
5355 }
5356
e9e44622 5357 *p = '\0';
d1133906
NC		 5358 return buff;
5359}
5360
77115a4a
L		 5361static unsigned int
5362get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5363{
5364 if (is_32bit_elf)
5365 {
5366 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5367 chdr->ch_type = BYTE_GET (echdr->ch_type);
5368 chdr->ch_size = BYTE_GET (echdr->ch_size);
5369 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5370 return sizeof (*echdr);
5371 }
5372 else
5373 {
5374 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5375 chdr->ch_type = BYTE_GET (echdr->ch_type);
5376 chdr->ch_size = BYTE_GET (echdr->ch_size);
5377 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5378 return sizeof (*echdr);
5379 }
5380}
5381
252b5132 5382static int
2cf0635d 5383process_section_headers (FILE * file)
252b5132 5384{
2cf0635d 5385 Elf_Internal_Shdr * section;
b34976b6 5386 unsigned int i;
252b5132
RH		 5387
5388 section_headers = NULL;
5389
5390 if (elf_header.e_shnum == 0)
5391 {
82f2dbf7
NC		 5392 /* PR binutils/12467. */
5393 if (elf_header.e_shoff != 0)
5394 warn (_("possibly corrupt ELF file header - it has a non-zero"
5395 " section header offset, but no section headers\n"));
5396 else if (do_sections)
252b5132
RH		 5397 printf (_("\nThere are no sections in this file.\n"));
5398
5399 return 1;
5400 }
5401
5402 if (do_sections && !do_header)
9ea033b2 5403 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5404 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5405
9ea033b2
NC		 5406 if (is_32bit_elf)
5407 {
049b0c3a 5408 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5409 return 0;
5410 }
049b0c3a 5411 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5412 return 0;
5413
5414 /* Read in the string table, so that we have names to display. */
0b49d371 5415 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5416 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5417 {
4fbb74a6 5418 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5419
c256ffe7
JJ		 5420 if (section->sh_size != 0)
5421 {
3f5e193b
NC		 5422 string_table = (char *) get_data (NULL, file, section->sh_offset,
5423 1, section->sh_size,
5424 _("string table"));
0de14b54 5425
c256ffe7
JJ		 5426 string_table_length = string_table != NULL ? section->sh_size : 0;
5427 }
252b5132
RH		 5428 }
5429
5430 /* Scan the sections for the dynamic symbol table
e3c8793a 5431 and dynamic string table and debug sections. */
252b5132
RH		 5432 dynamic_symbols = NULL;
5433 dynamic_strings = NULL;
5434 dynamic_syminfo = NULL;
f1ef08cb 5435 symtab_shndx_hdr = NULL;
103f02d3 5436
89fac5e3
RS		 5437 eh_addr_size = is_32bit_elf ? 4 : 8;
5438 switch (elf_header.e_machine)
5439 {
5440 case EM_MIPS:
5441 case EM_MIPS_RS3_LE:
5442 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5443 FDE addresses. However, the ABI also has a semi-official ILP32
5444 variant for which the normal FDE address size rules apply.
5445
5446 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5447 section, where XX is the size of longs in bits. Unfortunately,
5448 earlier compilers provided no way of distinguishing ILP32 objects
5449 from LP64 objects, so if there's any doubt, we should assume that
5450 the official LP64 form is being used. */
5451 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5452 && find_section (".gcc_compiled_long32") == NULL)
5453 eh_addr_size = 8;
5454 break;
0f56a26a
DD		 5455
5456 case EM_H8_300:
5457 case EM_H8_300H:
5458 switch (elf_header.e_flags & EF_H8_MACH)
5459 {
5460 case E_H8_MACH_H8300:
5461 case E_H8_MACH_H8300HN:
5462 case E_H8_MACH_H8300SN:
5463 case E_H8_MACH_H8300SXN:
5464 eh_addr_size = 2;
5465 break;
5466 case E_H8_MACH_H8300H:
5467 case E_H8_MACH_H8300S:
5468 case E_H8_MACH_H8300SX:
5469 eh_addr_size = 4;
5470 break;
5471 }
f4236fe4
DD		 5472 break;
5473
ff7eeb89 5474 case EM_M32C_OLD:
f4236fe4
DD		 5475 case EM_M32C:
5476 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5477 {
5478 case EF_M32C_CPU_M16C:
5479 eh_addr_size = 2;
5480 break;
5481 }
5482 break;
89fac5e3
RS		 5483 }
5484
76ca31c0
NC		 5485#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5486 do \
5487 { \
5488 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5489 if (section->sh_entsize != expected_entsize) \
9dd3a467 5490 { \
76ca31c0
NC		 5491 char buf[40]; \
5492 sprintf_vma (buf, section->sh_entsize); \
5493 /* Note: coded this way so that there is a single string for \
5494 translation. */ \
5495 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5496 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5497 (unsigned) expected_entsize); \
9dd3a467 5498 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5499 } \
5500 } \
08d8fa11 5501 while (0)
9dd3a467
NC		 5502
5503#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5504 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5505 sizeof (Elf64_External_##type))
5506
252b5132
RH		 5507 for (i = 0, section = section_headers;
5508 i < elf_header.e_shnum;
b34976b6 5509 i++, section++)
252b5132 5510 {
2cf0635d 5511 char * name = SECTION_NAME (section);
252b5132
RH		 5512
5513 if (section->sh_type == SHT_DYNSYM)
5514 {
5515 if (dynamic_symbols != NULL)
5516 {
5517 error (_("File contains multiple dynamic symbol tables\n"));
5518 continue;
5519 }
5520
08d8fa11 5521 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5522 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5523 }
5524 else if (section->sh_type == SHT_STRTAB
18bd398b 5525 && streq (name, ".dynstr"))
252b5132
RH		 5526 {
5527 if (dynamic_strings != NULL)
5528 {
5529 error (_("File contains multiple dynamic string tables\n"));
5530 continue;
5531 }
5532
3f5e193b
NC		 5533 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5534 1, section->sh_size,
5535 _("dynamic strings"));
59245841 5536 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5537 }
9ad5cbcf
AM		 5538 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5539 {
5540 if (symtab_shndx_hdr != NULL)
5541 {
5542 error (_("File contains multiple symtab shndx tables\n"));
5543 continue;
5544 }
5545 symtab_shndx_hdr = section;
5546 }
08d8fa11
JJ		 5547 else if (section->sh_type == SHT_SYMTAB)
5548 CHECK_ENTSIZE (section, i, Sym);
5549 else if (section->sh_type == SHT_GROUP)
5550 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5551 else if (section->sh_type == SHT_REL)
5552 CHECK_ENTSIZE (section, i, Rel);
5553 else if (section->sh_type == SHT_RELA)
5554 CHECK_ENTSIZE (section, i, Rela);
252b5132 5555 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5556 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5557 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5558 || do_debug_str || do_debug_loc || do_debug_ranges
5559 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5560 && (const_strneq (name, ".debug_")
5561 || const_strneq (name, ".zdebug_")))
252b5132 5562 {
1b315056
CS		 5563 if (name[1] == 'z')
5564 name += sizeof (".zdebug_") - 1;
5565 else
5566 name += sizeof (".debug_") - 1;
252b5132
RH		 5567
5568 if (do_debugging
4723351a
CC		 5569 || (do_debug_info && const_strneq (name, "info"))
5570 || (do_debug_info && const_strneq (name, "types"))
5571 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5572 || (do_debug_lines && strcmp (name, "line") == 0)
5573 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5574 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5575 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5576 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5577 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5578 || (do_debug_aranges && const_strneq (name, "aranges"))
5579 || (do_debug_ranges && const_strneq (name, "ranges"))
5580 || (do_debug_frames && const_strneq (name, "frame"))
5581 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5582 || (do_debug_macinfo && const_strneq (name, "macro"))
5583 || (do_debug_str && const_strneq (name, "str"))
5584 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5585 || (do_debug_addr && const_strneq (name, "addr"))
5586 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5587 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5588 )
09c11c86 5589 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5590 }
a262ae96 5591 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5592 else if ((do_debugging || do_debug_info)
0112cd26 5593 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5594 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5595 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5596 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5597 else if (do_gdb_index && streq (name, ".gdb_index"))
5598 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5599 /* Trace sections for Itanium VMS. */
5600 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5601 || do_trace_aranges)
5602 && const_strneq (name, ".trace_"))
5603 {
5604 name += sizeof (".trace_") - 1;
5605
5606 if (do_debugging
5607 || (do_trace_info && streq (name, "info"))
5608 || (do_trace_abbrevs && streq (name, "abbrev"))
5609 || (do_trace_aranges && streq (name, "aranges"))
5610 )
5611 request_dump_bynumber (i, DEBUG_DUMP);
5612 }
252b5132
RH		 5613 }
5614
5615 if (! do_sections)
5616 return 1;
5617
3a1a2036
NC		 5618 if (elf_header.e_shnum > 1)
5619 printf (_("\nSection Headers:\n"));
5620 else
5621 printf (_("\nSection Header:\n"));
76da6bbe 5622
f7a99963 5623 if (is_32bit_elf)
595cf52e 5624 {
5477e8a0 5625 if (do_section_details)
595cf52e
L		 5626 {
5627 printf (_(" [Nr] Name\n"));
5477e8a0 5628 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5629 }
5630 else
5631 printf
5632 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5633 }
d974e256 5634 else if (do_wide)
595cf52e 5635 {
5477e8a0 5636 if (do_section_details)
595cf52e
L		 5637 {
5638 printf (_(" [Nr] Name\n"));
5477e8a0 5639 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5640 }
5641 else
5642 printf
5643 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5644 }
f7a99963
NC		 5645 else
5646 {
5477e8a0 5647 if (do_section_details)
595cf52e
L		 5648 {
5649 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5650 printf (_(" Type Address Offset Link\n"));
5651 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5652 }
5653 else
5654 {
5655 printf (_(" [Nr] Name Type Address Offset\n"));
5656 printf (_(" Size EntSize Flags Link Info Align\n"));
5657 }
f7a99963 5658 }
252b5132 5659
5477e8a0
L		 5660 if (do_section_details)
5661 printf (_(" Flags\n"));
5662
252b5132
RH		 5663 for (i = 0, section = section_headers;
5664 i < elf_header.e_shnum;
b34976b6 5665 i++, section++)
252b5132 5666 {
7bfd842d 5667 printf (" [%2u] ", i);
5477e8a0 5668 if (do_section_details)
74e1a04b 5669 printf ("%s\n ", printable_section_name (section));
595cf52e 5670 else
74e1a04b 5671 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5672
ea52a088
NC		 5673 printf (do_wide ? " %-15s " : " %-15.15s ",
5674 get_section_type_name (section->sh_type));
0b4362b0 5675
f7a99963
NC		 5676 if (is_32bit_elf)
5677 {
cfcac11d
NC		 5678 const char * link_too_big = NULL;
5679
f7a99963 5680 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5681
f7a99963
NC		 5682 printf ( " %6.6lx %6.6lx %2.2lx",
5683 (unsigned long) section->sh_offset,
5684 (unsigned long) section->sh_size,
5685 (unsigned long) section->sh_entsize);
d1133906 5686
5477e8a0
L		 5687 if (do_section_details)
5688 fputs (" ", stdout);
5689 else
5690 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5691
cfcac11d
NC		 5692 if (section->sh_link >= elf_header.e_shnum)
5693 {
5694 link_too_big = "";
5695 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5696 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5697 switch (elf_header.e_machine)
5698 {
caa83f8b
NC		 5699 case EM_386:
5700 case EM_486:
5701 case EM_X86_64:
7f502d6c 5702 case EM_L1OM:
7a9068fe 5703 case EM_K1OM:
cfcac11d
NC		 5704 case EM_OLD_SPARCV9:
5705 case EM_SPARC32PLUS:
5706 case EM_SPARCV9:
5707 case EM_SPARC:
5708 if (section->sh_link == (SHN_BEFORE & 0xffff))
5709 link_too_big = "BEFORE";
5710 else if (section->sh_link == (SHN_AFTER & 0xffff))
5711 link_too_big = "AFTER";
5712 break;
5713 default:
5714 break;
5715 }
5716 }
5717
5718 if (do_section_details)
5719 {
5720 if (link_too_big != NULL && * link_too_big)
5721 printf ("<%s> ", link_too_big);
5722 else
5723 printf ("%2u ", section->sh_link);
5724 printf ("%3u %2lu\n", section->sh_info,
5725 (unsigned long) section->sh_addralign);
5726 }
5727 else
5728 printf ("%2u %3u %2lu\n",
5729 section->sh_link,
5730 section->sh_info,
5731 (unsigned long) section->sh_addralign);
5732
5733 if (link_too_big && ! * link_too_big)
5734 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5735 i, section->sh_link);
f7a99963 5736 }
d974e256
JJ		 5737 else if (do_wide)
5738 {
5739 print_vma (section->sh_addr, LONG_HEX);
5740
5741 if ((long) section->sh_offset == section->sh_offset)
5742 printf (" %6.6lx", (unsigned long) section->sh_offset);
5743 else
5744 {
5745 putchar (' ');
5746 print_vma (section->sh_offset, LONG_HEX);
5747 }
5748
5749 if ((unsigned long) section->sh_size == section->sh_size)
5750 printf (" %6.6lx", (unsigned long) section->sh_size);
5751 else
5752 {
5753 putchar (' ');
5754 print_vma (section->sh_size, LONG_HEX);
5755 }
5756
5757 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5758 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5759 else
5760 {
5761 putchar (' ');
5762 print_vma (section->sh_entsize, LONG_HEX);
5763 }
5764
5477e8a0
L		 5765 if (do_section_details)
5766 fputs (" ", stdout);
5767 else
5768 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5769
72de5009 5770 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5771
5772 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5773 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5774 else
5775 {
5776 print_vma (section->sh_addralign, DEC);
5777 putchar ('\n');
5778 }
5779 }
5477e8a0 5780 else if (do_section_details)
595cf52e 5781 {
5477e8a0 5782 printf (" %-15.15s ",
595cf52e 5783 get_section_type_name (section->sh_type));
595cf52e
L		 5784 print_vma (section->sh_addr, LONG_HEX);
5785 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5786 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5787 else
5788 {
5789 printf (" ");
5790 print_vma (section->sh_offset, LONG_HEX);
5791 }
72de5009 5792 printf (" %u\n ", section->sh_link);
595cf52e 5793 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5794 putchar (' ');
595cf52e
L		 5795 print_vma (section->sh_entsize, LONG_HEX);
5796
72de5009
AM		 5797 printf (" %-16u %lu\n",
5798 section->sh_info,
595cf52e
L		 5799 (unsigned long) section->sh_addralign);
5800 }
f7a99963
NC		 5801 else
5802 {
5803 putchar (' ');
5804 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5805 if ((long) section->sh_offset == section->sh_offset)
5806 printf (" %8.8lx", (unsigned long) section->sh_offset);
5807 else
5808 {
5809 printf (" ");
5810 print_vma (section->sh_offset, LONG_HEX);
5811 }
f7a99963
NC		 5812 printf ("\n ");
5813 print_vma (section->sh_size, LONG_HEX);
5814 printf (" ");
5815 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5816
d1133906 5817 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5818
72de5009
AM		 5819 printf (" %2u %3u %lu\n",
5820 section->sh_link,
5821 section->sh_info,
f7a99963
NC		 5822 (unsigned long) section->sh_addralign);
5823 }
5477e8a0
L		 5824
5825 if (do_section_details)
77115a4a
L		 5826 {
5827 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5828 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5829 {
5830 /* Minimum section size is 12 bytes for 32-bit compression
5831 header + 12 bytes for compressed data header. */
5832 unsigned char buf[24];
5833 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5834 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5835 sizeof (buf), _("compression header")))
5836 {
5837 Elf_Internal_Chdr chdr;
5838 get_compression_header (&chdr, buf);
5839 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5840 printf (" ZLIB, ");
5841 else
5842 printf (_(" [<unknown>: 0x%x], "),
5843 chdr.ch_type);
5844 print_vma (chdr.ch_size, LONG_HEX);
5845 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5846 }
5847 }
5848 }
252b5132
RH		 5849 }
5850
5477e8a0 5851 if (!do_section_details)
3dbcc61d
NC		 5852 {
5853 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5854 || elf_header.e_machine == EM_L1OM
5855 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5856 printf (_("Key to Flags:\n\
5857 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5858 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5859 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5860 else
5861 printf (_("Key to Flags:\n\
e3c8793a 5862 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5863 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5864 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5865 }
d1133906 5866
252b5132
RH		 5867 return 1;
5868}
5869
f5842774
L		 5870static const char *
5871get_group_flags (unsigned int flags)
5872{
5873 static char buff[32];
5874 switch (flags)
5875 {
220453ec
AM		 5876 case 0:
5877 return "";
5878
f5842774 5879 case GRP_COMDAT:
220453ec 5880 return "COMDAT ";
f5842774
L		 5881
5882 default:
220453ec 5883 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5884 break;
5885 }
5886 return buff;
5887}
5888
5889static int
2cf0635d 5890process_section_groups (FILE * file)
f5842774 5891{
2cf0635d 5892 Elf_Internal_Shdr * section;
f5842774 5893 unsigned int i;
2cf0635d
NC		 5894 struct group * group;
5895 Elf_Internal_Shdr * symtab_sec;
5896 Elf_Internal_Shdr * strtab_sec;
5897 Elf_Internal_Sym * symtab;
ba5cdace 5898 unsigned long num_syms;
2cf0635d 5899 char * strtab;
c256ffe7 5900 size_t strtab_size;
d1f5c6e3
L		 5901
5902 /* Don't process section groups unless needed. */
5903 if (!do_unwind && !do_section_groups)
5904 return 1;
f5842774
L		 5905
5906 if (elf_header.e_shnum == 0)
5907 {
5908 if (do_section_groups)
82f2dbf7 5909 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5910
5911 return 1;
5912 }
5913
5914 if (section_headers == NULL)
5915 {
5916 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5917 /* PR 13622: This can happen with a corrupt ELF header. */
5918 return 0;
f5842774
L		 5919 }
5920
3f5e193b
NC		 5921 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5922 sizeof (struct group *));
e4b17d5c
L		 5923
5924 if (section_headers_groups == NULL)
5925 {
8b73c356
NC		 5926 error (_("Out of memory reading %u section group headers\n"),
5927 elf_header.e_shnum);
e4b17d5c
L		 5928 return 0;
5929 }
5930
f5842774 5931 /* Scan the sections for the group section. */
d1f5c6e3 5932 group_count = 0;
f5842774
L		 5933 for (i = 0, section = section_headers;
5934 i < elf_header.e_shnum;
5935 i++, section++)
e4b17d5c
L		 5936 if (section->sh_type == SHT_GROUP)
5937 group_count++;
5938
d1f5c6e3
L		 5939 if (group_count == 0)
5940 {
5941 if (do_section_groups)
5942 printf (_("\nThere are no section groups in this file.\n"));
5943
5944 return 1;
5945 }
5946
3f5e193b 5947 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5948
5949 if (section_groups == NULL)
5950 {
8b73c356
NC		 5951 error (_("Out of memory reading %lu groups\n"),
5952 (unsigned long) group_count);
e4b17d5c
L		 5953 return 0;
5954 }
5955
d1f5c6e3
L		 5956 symtab_sec = NULL;
5957 strtab_sec = NULL;
5958 symtab = NULL;
ba5cdace 5959 num_syms = 0;
d1f5c6e3 5960 strtab = NULL;
c256ffe7 5961 strtab_size = 0;
e4b17d5c
L		 5962 for (i = 0, section = section_headers, group = section_groups;
5963 i < elf_header.e_shnum;
5964 i++, section++)
f5842774
L		 5965 {
5966 if (section->sh_type == SHT_GROUP)
5967 {
74e1a04b
NC		 5968 const char * name = printable_section_name (section);
5969 const char * group_name;
2cf0635d
NC		 5970 unsigned char * start;
5971 unsigned char * indices;
f5842774 5972 unsigned int entry, j, size;
2cf0635d
NC		 5973 Elf_Internal_Shdr * sec;
5974 Elf_Internal_Sym * sym;
f5842774
L		 5975
5976 /* Get the symbol table. */
4fbb74a6
AM		 5977 if (section->sh_link >= elf_header.e_shnum
5978 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5979 != SHT_SYMTAB))
f5842774
L		 5980 {
5981 error (_("Bad sh_link in group section `%s'\n"), name);
5982 continue;
5983 }
d1f5c6e3
L		 5984
5985 if (symtab_sec != sec)
5986 {
5987 symtab_sec = sec;
5988 if (symtab)
5989 free (symtab);
ba5cdace 5990 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5991 }
f5842774 5992
dd24e3da
NC		 5993 if (symtab == NULL)
5994 {
5995 error (_("Corrupt header in group section `%s'\n"), name);
5996 continue;
5997 }
5998
ba5cdace
NC		 5999 if (section->sh_info >= num_syms)
6000 {
6001 error (_("Bad sh_info in group section `%s'\n"), name);
6002 continue;
6003 }
6004
f5842774
L		 6005 sym = symtab + section->sh_info;
6006
6007 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6008 {
4fbb74a6
AM		 6009 if (sym->st_shndx == 0
6010 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6011 {
6012 error (_("Bad sh_info in group section `%s'\n"), name);
6013 continue;
6014 }
ba2685cc 6015
4fbb74a6 6016 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6017 strtab_sec = NULL;
6018 if (strtab)
6019 free (strtab);
f5842774 6020 strtab = NULL;
c256ffe7 6021 strtab_size = 0;
f5842774
L		 6022 }
6023 else
6024 {
6025 /* Get the string table. */
4fbb74a6 6026 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6027 {
6028 strtab_sec = NULL;
6029 if (strtab)
6030 free (strtab);
6031 strtab = NULL;
6032 strtab_size = 0;
6033 }
6034 else if (strtab_sec
4fbb74a6 6035 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6036 {
6037 strtab_sec = sec;
6038 if (strtab)
6039 free (strtab);
071436c6 6040
3f5e193b 6041 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6042 1, strtab_sec->sh_size,
6043 _("string table"));
c256ffe7 6044 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6045 }
c256ffe7 6046 group_name = sym->st_name < strtab_size
2b692964 6047 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6048 }
6049
c9c1d674
EG		 6050 /* PR 17531: file: loop. */
6051 if (section->sh_entsize > section->sh_size)
6052 {
6053 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6054 printable_section_name (section),
8066deb1
AM		 6055 (unsigned long) section->sh_entsize,
6056 (unsigned long) section->sh_size);
c9c1d674
EG		 6057 break;
6058 }
6059
3f5e193b
NC		 6060 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6061 1, section->sh_size,
6062 _("section data"));
59245841
NC		 6063 if (start == NULL)
6064 continue;
f5842774
L		 6065
6066 indices = start;
6067 size = (section->sh_size / section->sh_entsize) - 1;
6068 entry = byte_get (indices, 4);
6069 indices += 4;
e4b17d5c
L		 6070
6071 if (do_section_groups)
6072 {
2b692964 6073 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6074 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6075
e4b17d5c
L		 6076 printf (_(" [Index] Name\n"));
6077 }
6078
6079 group->group_index = i;
6080
f5842774
L		 6081 for (j = 0; j < size; j++)
6082 {
2cf0635d 6083 struct group_list * g;
e4b17d5c 6084
f5842774
L		 6085 entry = byte_get (indices, 4);
6086 indices += 4;
6087
4fbb74a6 6088 if (entry >= elf_header.e_shnum)
391cb864 6089 {
57028622
NC		 6090 static unsigned num_group_errors = 0;
6091
6092 if (num_group_errors ++ < 10)
6093 {
6094 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6095 entry, i, elf_header.e_shnum - 1);
6096 if (num_group_errors == 10)
6097 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6098 }
391cb864
L		 6099 continue;
6100 }
391cb864 6101
4fbb74a6 6102 if (section_headers_groups [entry] != NULL)
e4b17d5c 6103 {
d1f5c6e3
L		 6104 if (entry)
6105 {
57028622
NC		 6106 static unsigned num_errs = 0;
6107
6108 if (num_errs ++ < 10)
6109 {
6110 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6111 entry, i,
6112 section_headers_groups [entry]->group_index);
6113 if (num_errs == 10)
6114 warn (_("Further error messages about already contained group sections suppressed\n"));
6115 }
d1f5c6e3
L		 6116 continue;
6117 }
6118 else
6119 {
6120 /* Intel C/C++ compiler may put section 0 in a
6121 section group. We just warn it the first time
6122 and ignore it afterwards. */
6123 static int warned = 0;
6124 if (!warned)
6125 {
6126 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6127 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6128 warned++;
6129 }
6130 }
e4b17d5c
L		 6131 }
6132
4fbb74a6 6133 section_headers_groups [entry] = group;
e4b17d5c
L		 6134
6135 if (do_section_groups)
6136 {
4fbb74a6 6137 sec = section_headers + entry;
74e1a04b 6138 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6139 }
6140
3f5e193b 6141 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6142 g->section_index = entry;
6143 g->next = group->root;
6144 group->root = g;
f5842774
L		 6145 }
6146
f5842774
L		 6147 if (start)
6148 free (start);
e4b17d5c
L		 6149
6150 group++;
f5842774
L		 6151 }
6152 }
6153
d1f5c6e3
L		 6154 if (symtab)
6155 free (symtab);
6156 if (strtab)
6157 free (strtab);
f5842774
L		 6158 return 1;
6159}
6160
28f997cf
TG		 6161/* Data used to display dynamic fixups. */
6162
6163struct ia64_vms_dynfixup
6164{
6165 bfd_vma needed_ident; /* Library ident number. */
6166 bfd_vma needed; /* Index in the dstrtab of the library name. */
6167 bfd_vma fixup_needed; /* Index of the library. */
6168 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6169 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6170};
6171
6172/* Data used to display dynamic relocations. */
6173
6174struct ia64_vms_dynimgrela
6175{
6176 bfd_vma img_rela_cnt; /* Number of relocations. */
6177 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6178};
6179
6180/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6181 library). */
6182
6183static void
6184dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6185 const char *strtab, unsigned int strtab_sz)
6186{
6187 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6188 long i;
6189 const char *lib_name;
6190
6191 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6192 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6193 _("dynamic section image fixups"));
6194 if (!imfs)
6195 return;
6196
6197 if (fixup->needed < strtab_sz)
6198 lib_name = strtab + fixup->needed;
6199 else
6200 {
6201 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6202 (unsigned long) fixup->needed);
28f997cf
TG		 6203 lib_name = "???";
6204 }
6205 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6206 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6207 printf
6208 (_("Seg Offset Type SymVec DataType\n"));
6209
6210 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6211 {
6212 unsigned int type;
6213 const char *rtype;
6214
6215 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6216 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6217 type = BYTE_GET (imfs [i].type);
6218 rtype = elf_ia64_reloc_type (type);
6219 if (rtype == NULL)
6220 printf (" 0x%08x ", type);
6221 else
6222 printf (" %-32s ", rtype);
6223 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6224 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6225 }
6226
6227 free (imfs);
6228}
6229
6230/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6231
6232static void
6233dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6234{
6235 Elf64_External_VMS_IMAGE_RELA *imrs;
6236 long i;
6237
6238 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6239 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6240 _("dynamic section image relocations"));
28f997cf
TG		 6241 if (!imrs)
6242 return;
6243
6244 printf (_("\nImage relocs\n"));
6245 printf
6246 (_("Seg Offset Type Addend Seg Sym Off\n"));
6247
6248 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6249 {
6250 unsigned int type;
6251 const char *rtype;
6252
6253 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6254 printf ("%08" BFD_VMA_FMT "x ",
6255 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6256 type = BYTE_GET (imrs [i].type);
6257 rtype = elf_ia64_reloc_type (type);
6258 if (rtype == NULL)
6259 printf ("0x%08x ", type);
6260 else
6261 printf ("%-31s ", rtype);
6262 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6263 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6264 printf ("%08" BFD_VMA_FMT "x\n",
6265 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6266 }
6267
6268 free (imrs);
6269}
6270
6271/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6272
6273static int
6274process_ia64_vms_dynamic_relocs (FILE *file)
6275{
6276 struct ia64_vms_dynfixup fixup;
6277 struct ia64_vms_dynimgrela imgrela;
6278 Elf_Internal_Dyn *entry;
6279 int res = 0;
6280 bfd_vma strtab_off = 0;
6281 bfd_vma strtab_sz = 0;
6282 char *strtab = NULL;
6283
6284 memset (&fixup, 0, sizeof (fixup));
6285 memset (&imgrela, 0, sizeof (imgrela));
6286
6287 /* Note: the order of the entries is specified by the OpenVMS specs. */
6288 for (entry = dynamic_section;
6289 entry < dynamic_section + dynamic_nent;
6290 entry++)
6291 {
6292 switch (entry->d_tag)
6293 {
6294 case DT_IA_64_VMS_STRTAB_OFFSET:
6295 strtab_off = entry->d_un.d_val;
6296 break;
6297 case DT_STRSZ:
6298 strtab_sz = entry->d_un.d_val;
6299 if (strtab == NULL)
6300 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6301 1, strtab_sz, _("dynamic string section"));
6302 break;
6303
6304 case DT_IA_64_VMS_NEEDED_IDENT:
6305 fixup.needed_ident = entry->d_un.d_val;
6306 break;
6307 case DT_NEEDED:
6308 fixup.needed = entry->d_un.d_val;
6309 break;
6310 case DT_IA_64_VMS_FIXUP_NEEDED:
6311 fixup.fixup_needed = entry->d_un.d_val;
6312 break;
6313 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6314 fixup.fixup_rela_cnt = entry->d_un.d_val;
6315 break;
6316 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6317 fixup.fixup_rela_off = entry->d_un.d_val;
6318 res++;
6319 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6320 break;
6321
6322 case DT_IA_64_VMS_IMG_RELA_CNT:
6323 imgrela.img_rela_cnt = entry->d_un.d_val;
6324 break;
6325 case DT_IA_64_VMS_IMG_RELA_OFF:
6326 imgrela.img_rela_off = entry->d_un.d_val;
6327 res++;
6328 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6329 break;
6330
6331 default:
6332 break;
6333 }
6334 }
6335
6336 if (strtab != NULL)
6337 free (strtab);
6338
6339 return res;
6340}
6341
85b1c36d 6342static struct
566b0d53 6343{
2cf0635d 6344 const char * name;
566b0d53
L		 6345 int reloc;
6346 int size;
6347 int rela;
6348} dynamic_relocations [] =
6349{
6350 { "REL", DT_REL, DT_RELSZ, FALSE },
6351 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6352 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6353};
6354
252b5132 6355/* Process the reloc section. */
18bd398b 6356
252b5132 6357static int
2cf0635d 6358process_relocs (FILE * file)
252b5132 6359{
b34976b6
AM		 6360 unsigned long rel_size;
6361 unsigned long rel_offset;
252b5132
RH		 6362
6363
6364 if (!do_reloc)
6365 return 1;
6366
6367 if (do_using_dynamic)
6368 {
566b0d53 6369 int is_rela;
2cf0635d 6370 const char * name;
566b0d53
L		 6371 int has_dynamic_reloc;
6372 unsigned int i;
0de14b54 6373
566b0d53 6374 has_dynamic_reloc = 0;
252b5132 6375
566b0d53 6376 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6377 {
566b0d53
L		 6378 is_rela = dynamic_relocations [i].rela;
6379 name = dynamic_relocations [i].name;
6380 rel_size = dynamic_info [dynamic_relocations [i].size];
6381 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6382
566b0d53
L		 6383 has_dynamic_reloc |= rel_size;
6384
6385 if (is_rela == UNKNOWN)
aa903cfb 6386 {
566b0d53
L		 6387 if (dynamic_relocations [i].reloc == DT_JMPREL)
6388 switch (dynamic_info[DT_PLTREL])
6389 {
6390 case DT_REL:
6391 is_rela = FALSE;
6392 break;
6393 case DT_RELA:
6394 is_rela = TRUE;
6395 break;
6396 }
aa903cfb 6397 }
252b5132 6398
566b0d53
L		 6399 if (rel_size)
6400 {
6401 printf
6402 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6403 name, rel_offset, rel_size);
252b5132 6404
d93f0186
NC		 6405 dump_relocations (file,
6406 offset_from_vma (file, rel_offset, rel_size),
6407 rel_size,
566b0d53 6408 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6409 dynamic_strings, dynamic_strings_length,
6410 is_rela, 1);
566b0d53 6411 }
252b5132 6412 }
566b0d53 6413
28f997cf
TG		 6414 if (is_ia64_vms ())
6415 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6416
566b0d53 6417 if (! has_dynamic_reloc)
252b5132
RH		 6418 printf (_("\nThere are no dynamic relocations in this file.\n"));
6419 }
6420 else
6421 {
2cf0635d 6422 Elf_Internal_Shdr * section;
b34976b6
AM		 6423 unsigned long i;
6424 int found = 0;
252b5132
RH		 6425
6426 for (i = 0, section = section_headers;
6427 i < elf_header.e_shnum;
b34976b6 6428 i++, section++)
252b5132
RH		 6429 {
6430 if ( section->sh_type != SHT_RELA
6431 && section->sh_type != SHT_REL)
6432 continue;
6433
6434 rel_offset = section->sh_offset;
6435 rel_size = section->sh_size;
6436
6437 if (rel_size)
6438 {
2cf0635d 6439 Elf_Internal_Shdr * strsec;
b34976b6 6440 int is_rela;
103f02d3 6441
252b5132
RH		 6442 printf (_("\nRelocation section "));
6443
6444 if (string_table == NULL)
19936277 6445 printf ("%d", section->sh_name);
252b5132 6446 else
74e1a04b 6447 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6448
6449 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6450 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6451
d79b3d50
NC		 6452 is_rela = section->sh_type == SHT_RELA;
6453
4fbb74a6
AM		 6454 if (section->sh_link != 0
6455 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6456 {
2cf0635d
NC		 6457 Elf_Internal_Shdr * symsec;
6458 Elf_Internal_Sym * symtab;
d79b3d50 6459 unsigned long nsyms;
c256ffe7 6460 unsigned long strtablen = 0;
2cf0635d 6461 char * strtab = NULL;
57346661 6462
4fbb74a6 6463 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6464 if (symsec->sh_type != SHT_SYMTAB
6465 && symsec->sh_type != SHT_DYNSYM)
6466 continue;
6467
ba5cdace 6468 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6469
af3fc3bc
AM		 6470 if (symtab == NULL)
6471 continue;
252b5132 6472
4fbb74a6
AM		 6473 if (symsec->sh_link != 0
6474 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6475 {
4fbb74a6 6476 strsec = section_headers + symsec->sh_link;
103f02d3 6477
3f5e193b 6478 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6479 1, strsec->sh_size,
6480 _("string table"));
c256ffe7
JJ		 6481 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6482 }
252b5132 6483
d79b3d50 6484 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6485 symtab, nsyms, strtab, strtablen,
6486 is_rela,
6487 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6488 if (strtab)
6489 free (strtab);
6490 free (symtab);
6491 }
6492 else
6493 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6494 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6495
6496 found = 1;
6497 }
6498 }
6499
6500 if (! found)
6501 printf (_("\nThere are no relocations in this file.\n"));
6502 }
6503
6504 return 1;
6505}
6506
4d6ed7c8
NC		 6507/* An absolute address consists of a section and an offset. If the
6508 section is NULL, the offset itself is the address, otherwise, the
6509 address equals to LOAD_ADDRESS(section) + offset. */
6510
6511struct absaddr
948f632f
DA		 6512{
6513 unsigned short section;
6514 bfd_vma offset;
6515};
4d6ed7c8 6516
1949de15
L		 6517#define ABSADDR(a) \
6518 ((a).section \
6519 ? section_headers [(a).section].sh_addr + (a).offset \
6520 : (a).offset)
6521
948f632f
DA		 6522/* Find the nearest symbol at or below ADDR. Returns the symbol
6523 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6524
4d6ed7c8 6525static void
2cf0635d 6526find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6527 unsigned long nsyms,
6528 const char * strtab,
6529 unsigned long strtab_size,
6530 struct absaddr addr,
6531 const char ** symname,
6532 bfd_vma * offset)
4d6ed7c8 6533{
d3ba0551 6534 bfd_vma dist = 0x100000;
2cf0635d 6535 Elf_Internal_Sym * sym;
948f632f
DA		 6536 Elf_Internal_Sym * beg;
6537 Elf_Internal_Sym * end;
2cf0635d 6538 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6539
0b6ae522 6540 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6541 beg = symtab;
6542 end = symtab + nsyms;
0b6ae522 6543
948f632f 6544 while (beg < end)
4d6ed7c8 6545 {
948f632f
DA		 6546 bfd_vma value;
6547
6548 sym = beg + (end - beg) / 2;
0b6ae522 6549
948f632f 6550 value = sym->st_value;
0b6ae522
DJ		 6551 REMOVE_ARCH_BITS (value);
6552
948f632f 6553 if (sym->st_name != 0
4d6ed7c8 6554 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6555 && addr.offset >= value
6556 && addr.offset - value < dist)
4d6ed7c8
NC		 6557 {
6558 best = sym;
0b6ae522 6559 dist = addr.offset - value;
4d6ed7c8
NC		 6560 if (!dist)
6561 break;
6562 }
948f632f
DA		 6563
6564 if (addr.offset < value)
6565 end = sym;
6566 else
6567 beg = sym + 1;
4d6ed7c8 6568 }
1b31d05e 6569
4d6ed7c8
NC		 6570 if (best)
6571 {
57346661 6572 *symname = (best->st_name >= strtab_size
2b692964 6573 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6574 *offset = dist;
6575 return;
6576 }
1b31d05e 6577
4d6ed7c8
NC		 6578 *symname = NULL;
6579 *offset = addr.offset;
6580}
6581
948f632f
DA		 6582static int
6583symcmp (const void *p, const void *q)
6584{
6585 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6586 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6587
6588 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6589}
6590
6591/* Process the unwind section. */
6592
6593#include "unwind-ia64.h"
6594
6595struct ia64_unw_table_entry
6596{
6597 struct absaddr start;
6598 struct absaddr end;
6599 struct absaddr info;
6600};
6601
6602struct ia64_unw_aux_info
6603{
6604 struct ia64_unw_table_entry *table; /* Unwind table. */
6605 unsigned long table_len; /* Length of unwind table. */
6606 unsigned char * info; /* Unwind info. */
6607 unsigned long info_size; /* Size of unwind info. */
6608 bfd_vma info_addr; /* Starting address of unwind info. */
6609 bfd_vma seg_base; /* Starting address of segment. */
6610 Elf_Internal_Sym * symtab; /* The symbol table. */
6611 unsigned long nsyms; /* Number of symbols. */
6612 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6613 unsigned long nfuns; /* Number of entries in funtab. */
6614 char * strtab; /* The string table. */
6615 unsigned long strtab_size; /* Size of string table. */
6616};
6617
4d6ed7c8 6618static void
2cf0635d 6619dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6620{
2cf0635d 6621 struct ia64_unw_table_entry * tp;
948f632f 6622 unsigned long j, nfuns;
4d6ed7c8 6623 int in_body;
7036c0e1 6624
948f632f
DA		 6625 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6626 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6627 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6628 aux->funtab[nfuns++] = aux->symtab[j];
6629 aux->nfuns = nfuns;
6630 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6631
4d6ed7c8
NC		 6632 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6633 {
6634 bfd_vma stamp;
6635 bfd_vma offset;
2cf0635d
NC		 6636 const unsigned char * dp;
6637 const unsigned char * head;
53774b7e 6638 const unsigned char * end;
2cf0635d 6639 const char * procname;
4d6ed7c8 6640
948f632f 6641 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6642 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6643
6644 fputs ("\n<", stdout);
6645
6646 if (procname)
6647 {
6648 fputs (procname, stdout);
6649
6650 if (offset)
6651 printf ("+%lx", (unsigned long) offset);
6652 }
6653
6654 fputs (">: [", stdout);
6655 print_vma (tp->start.offset, PREFIX_HEX);
6656 fputc ('-', stdout);
6657 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6658 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6659 (unsigned long) (tp->info.offset - aux->seg_base));
6660
53774b7e
NC		 6661 /* PR 17531: file: 86232b32. */
6662 if (aux->info == NULL)
6663 continue;
6664
6665 /* PR 17531: file: 0997b4d1. */
6666 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6667 {
6668 warn (_("Invalid offset %lx in table entry %ld\n"),
6669 (long) tp->info.offset, (long) (tp - aux->table));
6670 continue;
6671 }
6672
1949de15 6673 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6674 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6675
86f55779 6676 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6677 (unsigned) UNW_VER (stamp),
6678 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6679 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6680 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6681 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6682
6683 if (UNW_VER (stamp) != 1)
6684 {
2b692964 6685 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6686 continue;
6687 }
6688
6689 in_body = 0;
53774b7e
NC		 6690 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6691 /* PR 17531: file: 16ceda89. */
6692 if (end > aux->info + aux->info_size)
6693 end = aux->info + aux->info_size;
6694 for (dp = head + 8; dp < end;)
4d6ed7c8
NC		 6695 dp = unw_decode (dp, in_body, & in_body);
6696 }
948f632f
DA		 6697
6698 free (aux->funtab);
4d6ed7c8
NC		 6699}
6700
53774b7e 6701static bfd_boolean
2cf0635d
NC		 6702slurp_ia64_unwind_table (FILE * file,
6703 struct ia64_unw_aux_info * aux,
6704 Elf_Internal_Shdr * sec)
4d6ed7c8 6705{
89fac5e3 6706 unsigned long size, nrelas, i;
2cf0635d
NC		 6707 Elf_Internal_Phdr * seg;
6708 struct ia64_unw_table_entry * tep;
6709 Elf_Internal_Shdr * relsec;
6710 Elf_Internal_Rela * rela;
6711 Elf_Internal_Rela * rp;
6712 unsigned char * table;
6713 unsigned char * tp;
6714 Elf_Internal_Sym * sym;
6715 const char * relname;
4d6ed7c8 6716
53774b7e
NC		 6717 aux->table_len = 0;
6718
4d6ed7c8
NC		 6719 /* First, find the starting address of the segment that includes
6720 this section: */
6721
6722 if (elf_header.e_phnum)
6723 {
d93f0186 6724 if (! get_program_headers (file))
53774b7e 6725 return FALSE;
4d6ed7c8 6726
d93f0186
NC		 6727 for (seg = program_headers;
6728 seg < program_headers + elf_header.e_phnum;
6729 ++seg)
4d6ed7c8
NC		 6730 {
6731 if (seg->p_type != PT_LOAD)
6732 continue;
6733
6734 if (sec->sh_addr >= seg->p_vaddr
6735 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6736 {
6737 aux->seg_base = seg->p_vaddr;
6738 break;
6739 }
6740 }
4d6ed7c8
NC		 6741 }
6742
6743 /* Second, build the unwind table from the contents of the unwind section: */
6744 size = sec->sh_size;
3f5e193b
NC		 6745 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6746 _("unwind table"));
a6e9f9df 6747 if (!table)
53774b7e 6748 return FALSE;
4d6ed7c8 6749
53774b7e 6750 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6751 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6752 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6753 tep = aux->table;
53774b7e
NC		 6754
6755 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6756 {
6757 tep->start.section = SHN_UNDEF;
6758 tep->end.section = SHN_UNDEF;
6759 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6760 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6761 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6762 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6763 tep->start.offset += aux->seg_base;
6764 tep->end.offset += aux->seg_base;
6765 tep->info.offset += aux->seg_base;
6766 }
6767 free (table);
6768
41e92641 6769 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6770 for (relsec = section_headers;
6771 relsec < section_headers + elf_header.e_shnum;
6772 ++relsec)
6773 {
6774 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6775 || relsec->sh_info >= elf_header.e_shnum
6776 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6777 continue;
6778
6779 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6780 & rela, & nrelas))
53774b7e
NC		 6781 {
6782 free (aux->table);
6783 aux->table = NULL;
6784 aux->table_len = 0;
6785 return FALSE;
6786 }
4d6ed7c8
NC		 6787
6788 for (rp = rela; rp < rela + nrelas; ++rp)
6789 {
aca88567
NC		 6790 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6791 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6792
82b1b41b
NC		 6793 /* PR 17531: file: 9fa67536. */
6794 if (relname == NULL)
6795 {
6796 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6797 continue;
6798 }
948f632f 6799
0112cd26 6800 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6801 {
82b1b41b 6802 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6803 continue;
6804 }
6805
89fac5e3 6806 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6807
53774b7e
NC		 6808 /* PR 17531: file: 5bc8d9bf. */
6809 if (i >= aux->table_len)
6810 {
6811 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6812 continue;
6813 }
6814
6815 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6816 {
6817 case 0:
6818 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6819 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6820 break;
6821 case 1:
6822 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6823 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6824 break;
6825 case 2:
6826 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6827 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6828 break;
6829 default:
6830 break;
6831 }
6832 }
6833
6834 free (rela);
6835 }
6836
53774b7e 6837 return TRUE;
4d6ed7c8
NC		 6838}
6839
1b31d05e 6840static void
2cf0635d 6841ia64_process_unwind (FILE * file)
4d6ed7c8 6842{
2cf0635d
NC		 6843 Elf_Internal_Shdr * sec;
6844 Elf_Internal_Shdr * unwsec = NULL;
6845 Elf_Internal_Shdr * strsec;
89fac5e3 6846 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6847 struct ia64_unw_aux_info aux;
f1467e33 6848
4d6ed7c8
NC		 6849 memset (& aux, 0, sizeof (aux));
6850
4d6ed7c8
NC		 6851 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6852 {
c256ffe7 6853 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6854 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6855 {
ba5cdace 6856 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6857
4fbb74a6 6858 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6859 if (aux.strtab != NULL)
6860 {
6861 error (_("Multiple auxillary string tables encountered\n"));
6862 free (aux.strtab);
6863 }
3f5e193b
NC		 6864 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6865 1, strsec->sh_size,
6866 _("string table"));
c256ffe7 6867 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6868 }
6869 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6870 unwcount++;
6871 }
6872
6873 if (!unwcount)
6874 printf (_("\nThere are no unwind sections in this file.\n"));
6875
6876 while (unwcount-- > 0)
6877 {
2cf0635d 6878 char * suffix;
579f31ac
JJ		 6879 size_t len, len2;
6880
4082ef84 6881 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6882 i < elf_header.e_shnum; ++i, ++sec)
6883 if (sec->sh_type == SHT_IA_64_UNWIND)
6884 {
6885 unwsec = sec;
6886 break;
6887 }
4082ef84
NC		 6888 /* We have already counted the number of SHT_IA64_UNWIND
6889 sections so the loop above should never fail. */
6890 assert (unwsec != NULL);
579f31ac
JJ		 6891
6892 unwstart = i + 1;
6893 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6894
e4b17d5c
L		 6895 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6896 {
6897 /* We need to find which section group it is in. */
4082ef84 6898 struct group_list * g;
e4b17d5c 6899
4082ef84
NC		 6900 if (section_headers_groups == NULL
6901 || section_headers_groups [i] == NULL)
6902 i = elf_header.e_shnum;
6903 else
e4b17d5c 6904 {
4082ef84 6905 g = section_headers_groups [i]->root;
18bd398b 6906
4082ef84
NC		 6907 for (; g != NULL; g = g->next)
6908 {
6909 sec = section_headers + g->section_index;
e4b17d5c 6910
4082ef84
NC		 6911 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6912 break;
6913 }
6914
6915 if (g == NULL)
6916 i = elf_header.e_shnum;
6917 }
e4b17d5c 6918 }
18bd398b 6919 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6920 {
18bd398b 6921 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6922 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6923 suffix = SECTION_NAME (unwsec) + len;
6924 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6925 ++i, ++sec)
18bd398b
NC		 6926 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6927 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6928 break;
6929 }
6930 else
6931 {
6932 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6933 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6934 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6935 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6936 suffix = "";
18bd398b 6937 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6938 suffix = SECTION_NAME (unwsec) + len;
6939 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6940 ++i, ++sec)
18bd398b
NC		 6941 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6942 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6943 break;
6944 }
6945
6946 if (i == elf_header.e_shnum)
6947 {
6948 printf (_("\nCould not find unwind info section for "));
6949
6950 if (string_table == NULL)
6951 printf ("%d", unwsec->sh_name);
6952 else
74e1a04b 6953 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6954 }
6955 else
4d6ed7c8 6956 {
4d6ed7c8 6957 aux.info_addr = sec->sh_addr;
3f5e193b 6958 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6959 sec->sh_size,
6960 _("unwind info"));
59245841 6961 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6962
579f31ac 6963 printf (_("\nUnwind section "));
4d6ed7c8 6964
579f31ac
JJ		 6965 if (string_table == NULL)
6966 printf ("%d", unwsec->sh_name);
6967 else
74e1a04b 6968 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 6969
579f31ac 6970 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6971 (unsigned long) unwsec->sh_offset,
89fac5e3 6972 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6973
53774b7e
NC		 6974 if (slurp_ia64_unwind_table (file, & aux, unwsec)
6975 && aux.table_len > 0)
579f31ac
JJ		 6976 dump_ia64_unwind (& aux);
6977
6978 if (aux.table)
6979 free ((char *) aux.table);
6980 if (aux.info)
6981 free ((char *) aux.info);
6982 aux.table = NULL;
6983 aux.info = NULL;
6984 }
4d6ed7c8 6985 }
4d6ed7c8 6986
4d6ed7c8
NC		 6987 if (aux.symtab)
6988 free (aux.symtab);
6989 if (aux.strtab)
6990 free ((char *) aux.strtab);
4d6ed7c8
NC		 6991}
6992
3f5e193b
NC		 6993struct hppa_unw_table_entry
6994 {
6995 struct absaddr start;
6996 struct absaddr end;
948f632f 6997 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 6998 unsigned int Millicode:1; /* 1 */
6999 unsigned int Millicode_save_sr0:1; /* 2 */
7000 unsigned int Region_description:2; /* 3..4 */
7001 unsigned int reserved1:1; /* 5 */
7002 unsigned int Entry_SR:1; /* 6 */
7003 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7004 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7005 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7006 unsigned int Variable_Frame:1; /* 17 */
7007 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7008 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7009 unsigned int Stack_Overflow_Check:1; /* 20 */
7010 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7011 unsigned int Ada_Region:1; /* 22 */
7012 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7013 unsigned int cxx_try_catch:1; /* 24 */
7014 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7015 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7016 unsigned int Save_SP:1; /* 27 */
7017 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7018 unsigned int Save_MRP_in_frame:1; /* 29 */
7019 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7020 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7021
948f632f
DA		 7022 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7023 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7024 unsigned int Large_frame:1; /* 2 */
948f632f 7025 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7026 unsigned int reserved4:1; /* 4 */
7027 unsigned int Total_frame_size:27; /* 5..31 */
7028 };
7029
57346661 7030struct hppa_unw_aux_info
948f632f
DA		 7031{
7032 struct hppa_unw_table_entry * table; /* Unwind table. */
7033 unsigned long table_len; /* Length of unwind table. */
7034 bfd_vma seg_base; /* Starting address of segment. */
7035 Elf_Internal_Sym * symtab; /* The symbol table. */
7036 unsigned long nsyms; /* Number of symbols. */
7037 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7038 unsigned long nfuns; /* Number of entries in funtab. */
7039 char * strtab; /* The string table. */
7040 unsigned long strtab_size; /* Size of string table. */
7041};
57346661
AM		 7042
7043static void
2cf0635d 7044dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7045{
2cf0635d 7046 struct hppa_unw_table_entry * tp;
948f632f
DA		 7047 unsigned long j, nfuns;
7048
7049 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7050 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7051 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7052 aux->funtab[nfuns++] = aux->symtab[j];
7053 aux->nfuns = nfuns;
7054 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7055
57346661
AM		 7056 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7057 {
7058 bfd_vma offset;
2cf0635d 7059 const char * procname;
57346661 7060
948f632f 7061 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7062 aux->strtab_size, tp->start, &procname,
7063 &offset);
7064
7065 fputs ("\n<", stdout);
7066
7067 if (procname)
7068 {
7069 fputs (procname, stdout);
7070
7071 if (offset)
7072 printf ("+%lx", (unsigned long) offset);
7073 }
7074
7075 fputs (">: [", stdout);
7076 print_vma (tp->start.offset, PREFIX_HEX);
7077 fputc ('-', stdout);
7078 print_vma (tp->end.offset, PREFIX_HEX);
7079 printf ("]\n\t");
7080
18bd398b
NC		 7081#define PF(_m) if (tp->_m) printf (#_m " ");
7082#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7083 PF(Cannot_unwind);
7084 PF(Millicode);
7085 PF(Millicode_save_sr0);
18bd398b 7086 /* PV(Region_description); */
57346661
AM		 7087 PF(Entry_SR);
7088 PV(Entry_FR);
7089 PV(Entry_GR);
7090 PF(Args_stored);
7091 PF(Variable_Frame);
7092 PF(Separate_Package_Body);
7093 PF(Frame_Extension_Millicode);
7094 PF(Stack_Overflow_Check);
7095 PF(Two_Instruction_SP_Increment);
7096 PF(Ada_Region);
7097 PF(cxx_info);
7098 PF(cxx_try_catch);
7099 PF(sched_entry_seq);
7100 PF(Save_SP);
7101 PF(Save_RP);
7102 PF(Save_MRP_in_frame);
7103 PF(extn_ptr_defined);
7104 PF(Cleanup_defined);
7105 PF(MPE_XL_interrupt_marker);
7106 PF(HP_UX_interrupt_marker);
7107 PF(Large_frame);
7108 PF(Pseudo_SP_Set);
7109 PV(Total_frame_size);
7110#undef PF
7111#undef PV
7112 }
7113
18bd398b 7114 printf ("\n");
948f632f
DA		 7115
7116 free (aux->funtab);
57346661
AM		 7117}
7118
7119static int
2cf0635d
NC		 7120slurp_hppa_unwind_table (FILE * file,
7121 struct hppa_unw_aux_info * aux,
7122 Elf_Internal_Shdr * sec)
57346661 7123{
1c0751b2 7124 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7125 Elf_Internal_Phdr * seg;
7126 struct hppa_unw_table_entry * tep;
7127 Elf_Internal_Shdr * relsec;
7128 Elf_Internal_Rela * rela;
7129 Elf_Internal_Rela * rp;
7130 unsigned char * table;
7131 unsigned char * tp;
7132 Elf_Internal_Sym * sym;
7133 const char * relname;
57346661 7134
57346661
AM		 7135 /* First, find the starting address of the segment that includes
7136 this section. */
7137
7138 if (elf_header.e_phnum)
7139 {
7140 if (! get_program_headers (file))
7141 return 0;
7142
7143 for (seg = program_headers;
7144 seg < program_headers + elf_header.e_phnum;
7145 ++seg)
7146 {
7147 if (seg->p_type != PT_LOAD)
7148 continue;
7149
7150 if (sec->sh_addr >= seg->p_vaddr
7151 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7152 {
7153 aux->seg_base = seg->p_vaddr;
7154 break;
7155 }
7156 }
7157 }
7158
7159 /* Second, build the unwind table from the contents of the unwind
7160 section. */
7161 size = sec->sh_size;
3f5e193b
NC		 7162 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7163 _("unwind table"));
57346661
AM		 7164 if (!table)
7165 return 0;
7166
1c0751b2
DA		 7167 unw_ent_size = 16;
7168 nentries = size / unw_ent_size;
7169 size = unw_ent_size * nentries;
57346661 7170
3f5e193b
NC		 7171 tep = aux->table = (struct hppa_unw_table_entry *)
7172 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7173
1c0751b2 7174 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7175 {
7176 unsigned int tmp1, tmp2;
7177
7178 tep->start.section = SHN_UNDEF;
7179 tep->end.section = SHN_UNDEF;
7180
1c0751b2
DA		 7181 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7182 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7183 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7184 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7185
7186 tep->start.offset += aux->seg_base;
7187 tep->end.offset += aux->seg_base;
57346661
AM		 7188
7189 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7190 tep->Millicode = (tmp1 >> 30) & 0x1;
7191 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7192 tep->Region_description = (tmp1 >> 27) & 0x3;
7193 tep->reserved1 = (tmp1 >> 26) & 0x1;
7194 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7195 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7196 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7197 tep->Args_stored = (tmp1 >> 15) & 0x1;
7198 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7199 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7200 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7201 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7202 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7203 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7204 tep->cxx_info = (tmp1 >> 8) & 0x1;
7205 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7206 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7207 tep->reserved2 = (tmp1 >> 5) & 0x1;
7208 tep->Save_SP = (tmp1 >> 4) & 0x1;
7209 tep->Save_RP = (tmp1 >> 3) & 0x1;
7210 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7211 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7212 tep->Cleanup_defined = tmp1 & 0x1;
7213
7214 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7215 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7216 tep->Large_frame = (tmp2 >> 29) & 0x1;
7217 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7218 tep->reserved4 = (tmp2 >> 27) & 0x1;
7219 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7220 }
7221 free (table);
7222
7223 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7224 for (relsec = section_headers;
7225 relsec < section_headers + elf_header.e_shnum;
7226 ++relsec)
7227 {
7228 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7229 || relsec->sh_info >= elf_header.e_shnum
7230 || section_headers + relsec->sh_info != sec)
57346661
AM		 7231 continue;
7232
7233 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7234 & rela, & nrelas))
7235 return 0;
7236
7237 for (rp = rela; rp < rela + nrelas; ++rp)
7238 {
aca88567
NC		 7239 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7240 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7241
7242 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7243 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7244 {
7245 warn (_("Skipping unexpected relocation type %s\n"), relname);
7246 continue;
7247 }
7248
7249 i = rp->r_offset / unw_ent_size;
7250
89fac5e3 7251 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7252 {
7253 case 0:
7254 aux->table[i].start.section = sym->st_shndx;
1e456d54 7255 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7256 break;
7257 case 1:
7258 aux->table[i].end.section = sym->st_shndx;
1e456d54 7259 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7260 break;
7261 default:
7262 break;
7263 }
7264 }
7265
7266 free (rela);
7267 }
7268
1c0751b2 7269 aux->table_len = nentries;
57346661
AM		 7270
7271 return 1;
7272}
7273
1b31d05e 7274static void
2cf0635d 7275hppa_process_unwind (FILE * file)
57346661 7276{
57346661 7277 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7278 Elf_Internal_Shdr * unwsec = NULL;
7279 Elf_Internal_Shdr * strsec;
7280 Elf_Internal_Shdr * sec;
18bd398b 7281 unsigned long i;
57346661 7282
c256ffe7 7283 if (string_table == NULL)
1b31d05e
NC		 7284 return;
7285
7286 memset (& aux, 0, sizeof (aux));
57346661
AM		 7287
7288 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7289 {
c256ffe7 7290 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7291 && sec->sh_link < elf_header.e_shnum)
57346661 7292 {
ba5cdace 7293 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7294
4fbb74a6 7295 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7296 if (aux.strtab != NULL)
7297 {
7298 error (_("Multiple auxillary string tables encountered\n"));
7299 free (aux.strtab);
7300 }
3f5e193b
NC		 7301 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7302 1, strsec->sh_size,
7303 _("string table"));
c256ffe7 7304 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7305 }
18bd398b 7306 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7307 unwsec = sec;
7308 }
7309
7310 if (!unwsec)
7311 printf (_("\nThere are no unwind sections in this file.\n"));
7312
7313 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7314 {
18bd398b 7315 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7316 {
74e1a04b
NC		 7317 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7318 printable_section_name (sec),
57346661 7319 (unsigned long) sec->sh_offset,
89fac5e3 7320 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7321
7322 slurp_hppa_unwind_table (file, &aux, sec);
7323 if (aux.table_len > 0)
7324 dump_hppa_unwind (&aux);
7325
7326 if (aux.table)
7327 free ((char *) aux.table);
7328 aux.table = NULL;
7329 }
7330 }
7331
7332 if (aux.symtab)
7333 free (aux.symtab);
7334 if (aux.strtab)
7335 free ((char *) aux.strtab);
57346661
AM		 7336}
7337
0b6ae522
DJ		 7338struct arm_section
7339{
a734115a
NC		 7340 unsigned char * data; /* The unwind data. */
7341 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7342 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7343 unsigned long nrelas; /* The number of relocations. */
7344 unsigned int rel_type; /* REL or RELA ? */
7345 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7346};
7347
7348struct arm_unw_aux_info
7349{
a734115a
NC		 7350 FILE * file; /* The file containing the unwind sections. */
7351 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7352 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7353 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7354 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7355 char * strtab; /* The file's string table. */
7356 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7357};
7358
7359static const char *
7360arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7361 bfd_vma fn, struct absaddr addr)
7362{
7363 const char *procname;
7364 bfd_vma sym_offset;
7365
7366 if (addr.section == SHN_UNDEF)
7367 addr.offset = fn;
7368
948f632f 7369 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7370 aux->strtab_size, addr, &procname,
7371 &sym_offset);
7372
7373 print_vma (fn, PREFIX_HEX);
7374
7375 if (procname)
7376 {
7377 fputs (" <", stdout);
7378 fputs (procname, stdout);
7379
7380 if (sym_offset)
7381 printf ("+0x%lx", (unsigned long) sym_offset);
7382 fputc ('>', stdout);
7383 }
7384
7385 return procname;
7386}
7387
7388static void
7389arm_free_section (struct arm_section *arm_sec)
7390{
7391 if (arm_sec->data != NULL)
7392 free (arm_sec->data);
7393
7394 if (arm_sec->rela != NULL)
7395 free (arm_sec->rela);
7396}
7397
a734115a
NC		 7398/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7399 cached section and install SEC instead.
7400 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7401 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7402 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7403 relocation's offset in ADDR.
1b31d05e
NC		 7404 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7405 into the string table of the symbol associated with the reloc. If no
7406 reloc was applied store -1 there.
7407 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7408
7409static bfd_boolean
1b31d05e
NC		 7410get_unwind_section_word (struct arm_unw_aux_info * aux,
7411 struct arm_section * arm_sec,
7412 Elf_Internal_Shdr * sec,
7413 bfd_vma word_offset,
7414 unsigned int * wordp,
7415 struct absaddr * addr,
7416 bfd_vma * sym_name)
0b6ae522
DJ		 7417{
7418 Elf_Internal_Rela *rp;
7419 Elf_Internal_Sym *sym;
7420 const char * relname;
7421 unsigned int word;
7422 bfd_boolean wrapped;
7423
e0a31db1
NC		 7424 if (sec == NULL || arm_sec == NULL)
7425 return FALSE;
7426
0b6ae522
DJ		 7427 addr->section = SHN_UNDEF;
7428 addr->offset = 0;
7429
1b31d05e
NC		 7430 if (sym_name != NULL)
7431 *sym_name = (bfd_vma) -1;
7432
a734115a 7433 /* If necessary, update the section cache. */
0b6ae522
DJ		 7434 if (sec != arm_sec->sec)
7435 {
7436 Elf_Internal_Shdr *relsec;
7437
7438 arm_free_section (arm_sec);
7439
7440 arm_sec->sec = sec;
7441 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7442 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7443 arm_sec->rela = NULL;
7444 arm_sec->nrelas = 0;
7445
7446 for (relsec = section_headers;
7447 relsec < section_headers + elf_header.e_shnum;
7448 ++relsec)
7449 {
7450 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7451 || section_headers + relsec->sh_info != sec
7452 /* PR 15745: Check the section type as well. */
7453 || (relsec->sh_type != SHT_REL
7454 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7455 continue;
7456
a734115a 7457 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7458 if (relsec->sh_type == SHT_REL)
7459 {
7460 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7461 relsec->sh_size,
7462 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7463 return FALSE;
0b6ae522 7464 }
1ae40aa4 7465 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7466 {
7467 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7468 relsec->sh_size,
7469 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7470 return FALSE;
0b6ae522 7471 }
1ae40aa4 7472 break;
0b6ae522
DJ		 7473 }
7474
7475 arm_sec->next_rela = arm_sec->rela;
7476 }
7477
a734115a 7478 /* If there is no unwind data we can do nothing. */
0b6ae522 7479 if (arm_sec->data == NULL)
a734115a 7480 return FALSE;
0b6ae522 7481
e0a31db1
NC		 7482 /* If the offset is invalid then fail. */
7483 if (word_offset > sec->sh_size - 4)
7484 return FALSE;
7485
a734115a 7486 /* Get the word at the required offset. */
0b6ae522
DJ		 7487 word = byte_get (arm_sec->data + word_offset, 4);
7488
0eff7165
NC		 7489 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7490 if (arm_sec->rela == NULL)
7491 {
7492 * wordp = word;
7493 return TRUE;
7494 }
7495
a734115a 7496 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7497 wrapped = FALSE;
7498 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7499 {
7500 bfd_vma prelval, offset;
7501
7502 if (rp->r_offset > word_offset && !wrapped)
7503 {
7504 rp = arm_sec->rela;
7505 wrapped = TRUE;
7506 }
7507 if (rp->r_offset > word_offset)
7508 break;
7509
7510 if (rp->r_offset & 3)
7511 {
7512 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7513 (unsigned long) rp->r_offset);
7514 continue;
7515 }
7516
7517 if (rp->r_offset < word_offset)
7518 continue;
7519
74e1a04b
NC		 7520 /* PR 17531: file: 027-161405-0.004 */
7521 if (aux->symtab == NULL)
7522 continue;
7523
0b6ae522
DJ		 7524 if (arm_sec->rel_type == SHT_REL)
7525 {
7526 offset = word & 0x7fffffff;
7527 if (offset & 0x40000000)
7528 offset |= ~ (bfd_vma) 0x7fffffff;
7529 }
a734115a 7530 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7531 offset = rp->r_addend;
a734115a 7532 else
74e1a04b
NC		 7533 {
7534 error (_("Unknown section relocation type %d encountered\n"),
7535 arm_sec->rel_type);
7536 break;
7537 }
0b6ae522 7538
071436c6
NC		 7539 /* PR 17531 file: 027-1241568-0.004. */
7540 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7541 {
7542 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7543 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7544 break;
7545 }
7546
7547 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7548 offset += sym->st_value;
7549 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7550
a734115a
NC		 7551 /* Check that we are processing the expected reloc type. */
7552 if (elf_header.e_machine == EM_ARM)
7553 {
7554 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7555 if (relname == NULL)
7556 {
7557 warn (_("Skipping unknown ARM relocation type: %d\n"),
7558 (int) ELF32_R_TYPE (rp->r_info));
7559 continue;
7560 }
a734115a
NC		 7561
7562 if (streq (relname, "R_ARM_NONE"))
7563 continue;
0b4362b0 7564
a734115a
NC		 7565 if (! streq (relname, "R_ARM_PREL31"))
7566 {
071436c6 7567 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7568 continue;
7569 }
7570 }
7571 else if (elf_header.e_machine == EM_TI_C6000)
7572 {
7573 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7574 if (relname == NULL)
7575 {
7576 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7577 (int) ELF32_R_TYPE (rp->r_info));
7578 continue;
7579 }
0b4362b0 7580
a734115a
NC		 7581 if (streq (relname, "R_C6000_NONE"))
7582 continue;
7583
7584 if (! streq (relname, "R_C6000_PREL31"))
7585 {
071436c6 7586 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7587 continue;
7588 }
7589
7590 prelval >>= 1;
7591 }
7592 else
74e1a04b
NC		 7593 {
7594 /* This function currently only supports ARM and TI unwinders. */
7595 warn (_("Only TI and ARM unwinders are currently supported\n"));
7596 break;
7597 }
fa197c1c 7598
0b6ae522
DJ		 7599 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7600 addr->section = sym->st_shndx;
7601 addr->offset = offset;
74e1a04b 7602
1b31d05e
NC		 7603 if (sym_name)
7604 * sym_name = sym->st_name;
0b6ae522
DJ		 7605 break;
7606 }
7607
7608 *wordp = word;
7609 arm_sec->next_rela = rp;
7610
a734115a 7611 return TRUE;
0b6ae522
DJ		 7612}
7613
a734115a
NC		 7614static const char *tic6x_unwind_regnames[16] =
7615{
0b4362b0
RM		 7616 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7617 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7618 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7619};
fa197c1c 7620
0b6ae522 7621static void
fa197c1c 7622decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7623{
fa197c1c
PB		 7624 int i;
7625
7626 for (i = 12; mask; mask >>= 1, i--)
7627 {
7628 if (mask & 1)
7629 {
7630 fputs (tic6x_unwind_regnames[i], stdout);
7631 if (mask > 1)
7632 fputs (", ", stdout);
7633 }
7634 }
7635}
0b6ae522
DJ		 7636
7637#define ADVANCE \
7638 if (remaining == 0 && more_words) \
7639 { \
7640 data_offset += 4; \
1b31d05e
NC		 7641 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7642 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7643 return; \
7644 remaining = 4; \
7645 more_words--; \
7646 } \
7647
7648#define GET_OP(OP) \
7649 ADVANCE; \
7650 if (remaining) \
7651 { \
7652 remaining--; \
7653 (OP) = word >> 24; \
7654 word <<= 8; \
7655 } \
7656 else \
7657 { \
2b692964 7658 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7659 return; \
7660 } \
cc5914eb 7661 printf ("0x%02x ", OP)
0b6ae522 7662
fa197c1c 7663static void
948f632f
DA		 7664decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7665 unsigned int word,
7666 unsigned int remaining,
7667 unsigned int more_words,
7668 bfd_vma data_offset,
7669 Elf_Internal_Shdr * data_sec,
7670 struct arm_section * data_arm_sec)
fa197c1c
PB		 7671{
7672 struct absaddr addr;
0b6ae522
DJ		 7673
7674 /* Decode the unwinding instructions. */
7675 while (1)
7676 {
7677 unsigned int op, op2;
7678
7679 ADVANCE;
7680 if (remaining == 0)
7681 break;
7682 remaining--;
7683 op = word >> 24;
7684 word <<= 8;
7685
cc5914eb 7686 printf (" 0x%02x ", op);
0b6ae522
DJ		 7687
7688 if ((op & 0xc0) == 0x00)
7689 {
7690 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7691
cc5914eb 7692 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7693 }
7694 else if ((op & 0xc0) == 0x40)
7695 {
7696 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7697
cc5914eb 7698 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7699 }
7700 else if ((op & 0xf0) == 0x80)
7701 {
7702 GET_OP (op2);
7703 if (op == 0x80 && op2 == 0)
7704 printf (_("Refuse to unwind"));
7705 else
7706 {
7707 unsigned int mask = ((op & 0x0f) << 8) | op2;
7708 int first = 1;
7709 int i;
2b692964 7710
0b6ae522
DJ		 7711 printf ("pop {");
7712 for (i = 0; i < 12; i++)
7713 if (mask & (1 << i))
7714 {
7715 if (first)
7716 first = 0;
7717 else
7718 printf (", ");
7719 printf ("r%d", 4 + i);
7720 }
7721 printf ("}");
7722 }
7723 }
7724 else if ((op & 0xf0) == 0x90)
7725 {
7726 if (op == 0x9d || op == 0x9f)
7727 printf (_(" [Reserved]"));
7728 else
cc5914eb 7729 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7730 }
7731 else if ((op & 0xf0) == 0xa0)
7732 {
7733 int end = 4 + (op & 0x07);
7734 int first = 1;
7735 int i;
61865e30 7736
0b6ae522
DJ		 7737 printf (" pop {");
7738 for (i = 4; i <= end; i++)
7739 {
7740 if (first)
7741 first = 0;
7742 else
7743 printf (", ");
7744 printf ("r%d", i);
7745 }
7746 if (op & 0x08)
7747 {
1b31d05e 7748 if (!first)
0b6ae522
DJ		 7749 printf (", ");
7750 printf ("r14");
7751 }
7752 printf ("}");
7753 }
7754 else if (op == 0xb0)
7755 printf (_(" finish"));
7756 else if (op == 0xb1)
7757 {
7758 GET_OP (op2);
7759 if (op2 == 0 || (op2 & 0xf0) != 0)
7760 printf (_("[Spare]"));
7761 else
7762 {
7763 unsigned int mask = op2 & 0x0f;
7764 int first = 1;
7765 int i;
61865e30 7766
0b6ae522
DJ		 7767 printf ("pop {");
7768 for (i = 0; i < 12; i++)
7769 if (mask & (1 << i))
7770 {
7771 if (first)
7772 first = 0;
7773 else
7774 printf (", ");
7775 printf ("r%d", i);
7776 }
7777 printf ("}");
7778 }
7779 }
7780 else if (op == 0xb2)
7781 {
b115cf96 7782 unsigned char buf[9];
0b6ae522
DJ		 7783 unsigned int i, len;
7784 unsigned long offset;
61865e30 7785
b115cf96 7786 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7787 {
7788 GET_OP (buf[i]);
7789 if ((buf[i] & 0x80) == 0)
7790 break;
7791 }
4082ef84
NC		 7792 if (i == sizeof (buf))
7793 printf (_("corrupt change to vsp"));
7794 else
7795 {
7796 offset = read_uleb128 (buf, &len, buf + i + 1);
7797 assert (len == i + 1);
7798 offset = offset * 4 + 0x204;
7799 printf ("vsp = vsp + %ld", offset);
7800 }
0b6ae522 7801 }
61865e30 7802 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7803 {
61865e30
NC		 7804 unsigned int first, last;
7805
7806 GET_OP (op2);
7807 first = op2 >> 4;
7808 last = op2 & 0x0f;
7809 if (op == 0xc8)
7810 first = first + 16;
7811 printf ("pop {D%d", first);
7812 if (last)
7813 printf ("-D%d", first + last);
7814 printf ("}");
7815 }
7816 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7817 {
7818 unsigned int count = op & 0x07;
7819
7820 printf ("pop {D8");
7821 if (count)
7822 printf ("-D%d", 8 + count);
7823 printf ("}");
7824 }
7825 else if (op >= 0xc0 && op <= 0xc5)
7826 {
7827 unsigned int count = op & 0x07;
7828
7829 printf (" pop {wR10");
7830 if (count)
7831 printf ("-wR%d", 10 + count);
7832 printf ("}");
7833 }
7834 else if (op == 0xc6)
7835 {
7836 unsigned int first, last;
7837
7838 GET_OP (op2);
7839 first = op2 >> 4;
7840 last = op2 & 0x0f;
7841 printf ("pop {wR%d", first);
7842 if (last)
7843 printf ("-wR%d", first + last);
7844 printf ("}");
7845 }
7846 else if (op == 0xc7)
7847 {
7848 GET_OP (op2);
7849 if (op2 == 0 || (op2 & 0xf0) != 0)
7850 printf (_("[Spare]"));
0b6ae522
DJ		 7851 else
7852 {
61865e30
NC		 7853 unsigned int mask = op2 & 0x0f;
7854 int first = 1;
7855 int i;
7856
7857 printf ("pop {");
7858 for (i = 0; i < 4; i++)
7859 if (mask & (1 << i))
7860 {
7861 if (first)
7862 first = 0;
7863 else
7864 printf (", ");
7865 printf ("wCGR%d", i);
7866 }
7867 printf ("}");
0b6ae522
DJ		 7868 }
7869 }
61865e30
NC		 7870 else
7871 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7872 printf ("\n");
7873 }
fa197c1c
PB		 7874}
7875
7876static void
948f632f
DA		 7877decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7878 unsigned int word,
7879 unsigned int remaining,
7880 unsigned int more_words,
7881 bfd_vma data_offset,
7882 Elf_Internal_Shdr * data_sec,
7883 struct arm_section * data_arm_sec)
fa197c1c
PB		 7884{
7885 struct absaddr addr;
7886
7887 /* Decode the unwinding instructions. */
7888 while (1)
7889 {
7890 unsigned int op, op2;
7891
7892 ADVANCE;
7893 if (remaining == 0)
7894 break;
7895 remaining--;
7896 op = word >> 24;
7897 word <<= 8;
7898
9cf03b7e 7899 printf (" 0x%02x ", op);
fa197c1c
PB		 7900
7901 if ((op & 0xc0) == 0x00)
7902 {
7903 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7904 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7905 }
7906 else if ((op & 0xc0) == 0x80)
7907 {
7908 GET_OP (op2);
7909 if (op == 0x80 && op2 == 0)
7910 printf (_("Refuse to unwind"));
7911 else
7912 {
7913 unsigned int mask = ((op & 0x1f) << 8) | op2;
7914 if (op & 0x20)
7915 printf ("pop compact {");
7916 else
7917 printf ("pop {");
7918
7919 decode_tic6x_unwind_regmask (mask);
7920 printf("}");
7921 }
7922 }
7923 else if ((op & 0xf0) == 0xc0)
7924 {
7925 unsigned int reg;
7926 unsigned int nregs;
7927 unsigned int i;
7928 const char *name;
a734115a
NC		 7929 struct
7930 {
fa197c1c
PB		 7931 unsigned int offset;
7932 unsigned int reg;
7933 } regpos[16];
7934
7935 /* Scan entire instruction first so that GET_OP output is not
7936 interleaved with disassembly. */
7937 nregs = 0;
7938 for (i = 0; nregs < (op & 0xf); i++)
7939 {
7940 GET_OP (op2);
7941 reg = op2 >> 4;
7942 if (reg != 0xf)
7943 {
7944 regpos[nregs].offset = i * 2;
7945 regpos[nregs].reg = reg;
7946 nregs++;
7947 }
7948
7949 reg = op2 & 0xf;
7950 if (reg != 0xf)
7951 {
7952 regpos[nregs].offset = i * 2 + 1;
7953 regpos[nregs].reg = reg;
7954 nregs++;
7955 }
7956 }
7957
7958 printf (_("pop frame {"));
7959 reg = nregs - 1;
7960 for (i = i * 2; i > 0; i--)
7961 {
7962 if (regpos[reg].offset == i - 1)
7963 {
7964 name = tic6x_unwind_regnames[regpos[reg].reg];
7965 if (reg > 0)
7966 reg--;
7967 }
7968 else
7969 name = _("[pad]");
7970
7971 fputs (name, stdout);
7972 if (i > 1)
7973 printf (", ");
7974 }
7975
7976 printf ("}");
7977 }
7978 else if (op == 0xd0)
7979 printf (" MOV FP, SP");
7980 else if (op == 0xd1)
7981 printf (" __c6xabi_pop_rts");
7982 else if (op == 0xd2)
7983 {
7984 unsigned char buf[9];
7985 unsigned int i, len;
7986 unsigned long offset;
a734115a 7987
fa197c1c
PB		 7988 for (i = 0; i < sizeof (buf); i++)
7989 {
7990 GET_OP (buf[i]);
7991 if ((buf[i] & 0x80) == 0)
7992 break;
7993 }
0eff7165
NC		 7994 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7995 if (i == sizeof (buf))
7996 {
7997 printf ("<corrupt sp adjust>\n");
7998 warn (_("Corrupt stack pointer adjustment detected\n"));
7999 return;
8000 }
948f632f 8001
f6f0e17b 8002 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8003 assert (len == i + 1);
8004 offset = offset * 8 + 0x408;
8005 printf (_("sp = sp + %ld"), offset);
8006 }
8007 else if ((op & 0xf0) == 0xe0)
8008 {
8009 if ((op & 0x0f) == 7)
8010 printf (" RETURN");
8011 else
8012 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8013 }
8014 else
8015 {
8016 printf (_(" [unsupported opcode]"));
8017 }
8018 putchar ('\n');
8019 }
8020}
8021
8022static bfd_vma
a734115a 8023arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8024{
8025 bfd_vma offset;
8026
8027 offset = word & 0x7fffffff;
8028 if (offset & 0x40000000)
8029 offset |= ~ (bfd_vma) 0x7fffffff;
8030
8031 if (elf_header.e_machine == EM_TI_C6000)
8032 offset <<= 1;
8033
8034 return offset + where;
8035}
8036
8037static void
1b31d05e
NC		 8038decode_arm_unwind (struct arm_unw_aux_info * aux,
8039 unsigned int word,
8040 unsigned int remaining,
8041 bfd_vma data_offset,
8042 Elf_Internal_Shdr * data_sec,
8043 struct arm_section * data_arm_sec)
fa197c1c
PB		 8044{
8045 int per_index;
8046 unsigned int more_words = 0;
37e14bc3 8047 struct absaddr addr;
1b31d05e 8048 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8049
8050 if (remaining == 0)
8051 {
1b31d05e
NC		 8052 /* Fetch the first word.
8053 Note - when decoding an object file the address extracted
8054 here will always be 0. So we also pass in the sym_name
8055 parameter so that we can find the symbol associated with
8056 the personality routine. */
8057 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8058 & word, & addr, & sym_name))
fa197c1c 8059 return;
1b31d05e 8060
fa197c1c
PB		 8061 remaining = 4;
8062 }
8063
8064 if ((word & 0x80000000) == 0)
8065 {
8066 /* Expand prel31 for personality routine. */
8067 bfd_vma fn;
8068 const char *procname;
8069
a734115a 8070 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8071 printf (_(" Personality routine: "));
1b31d05e
NC		 8072 if (fn == 0
8073 && addr.section == SHN_UNDEF && addr.offset == 0
8074 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8075 {
8076 procname = aux->strtab + sym_name;
8077 print_vma (fn, PREFIX_HEX);
8078 if (procname)
8079 {
8080 fputs (" <", stdout);
8081 fputs (procname, stdout);
8082 fputc ('>', stdout);
8083 }
8084 }
8085 else
8086 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8087 fputc ('\n', stdout);
8088
8089 /* The GCC personality routines use the standard compact
8090 encoding, starting with one byte giving the number of
8091 words. */
8092 if (procname != NULL
8093 && (const_strneq (procname, "__gcc_personality_v0")
8094 || const_strneq (procname, "__gxx_personality_v0")
8095 || const_strneq (procname, "__gcj_personality_v0")
8096 || const_strneq (procname, "__gnu_objc_personality_v0")))
8097 {
8098 remaining = 0;
8099 more_words = 1;
8100 ADVANCE;
8101 if (!remaining)
8102 {
8103 printf (_(" [Truncated data]\n"));
8104 return;
8105 }
8106 more_words = word >> 24;
8107 word <<= 8;
8108 remaining--;
8109 per_index = -1;
8110 }
8111 else
8112 return;
8113 }
8114 else
8115 {
1b31d05e 8116 /* ARM EHABI Section 6.3:
0b4362b0 8117
1b31d05e 8118 An exception-handling table entry for the compact model looks like:
0b4362b0 8119
1b31d05e
NC		 8120 31 30-28 27-24 23-0
8121 -- ----- ----- ----
8122 1 0 index Data for personalityRoutine[index] */
8123
8124 if (elf_header.e_machine == EM_ARM
8125 && (word & 0x70000000))
83c257ca 8126 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8127
fa197c1c 8128 per_index = (word >> 24) & 0x7f;
1b31d05e 8129 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8130 if (per_index == 0)
8131 {
8132 more_words = 0;
8133 word <<= 8;
8134 remaining--;
8135 }
8136 else if (per_index < 3)
8137 {
8138 more_words = (word >> 16) & 0xff;
8139 word <<= 16;
8140 remaining -= 2;
8141 }
8142 }
8143
8144 switch (elf_header.e_machine)
8145 {
8146 case EM_ARM:
8147 if (per_index < 3)
8148 {
8149 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8150 data_offset, data_sec, data_arm_sec);
8151 }
8152 else
1b31d05e
NC		 8153 {
8154 warn (_("Unknown ARM compact model index encountered\n"));
8155 printf (_(" [reserved]\n"));
8156 }
fa197c1c
PB		 8157 break;
8158
8159 case EM_TI_C6000:
8160 if (per_index < 3)
8161 {
8162 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8163 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8164 }
8165 else if (per_index < 5)
8166 {
8167 if (((word >> 17) & 0x7f) == 0x7f)
8168 printf (_(" Restore stack from frame pointer\n"));
8169 else
8170 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8171 printf (_(" Registers restored: "));
8172 if (per_index == 4)
8173 printf (" (compact) ");
8174 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8175 putchar ('\n');
8176 printf (_(" Return register: %s\n"),
8177 tic6x_unwind_regnames[word & 0xf]);
8178 }
8179 else
1b31d05e 8180 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8181 break;
8182
8183 default:
74e1a04b 8184 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8185 elf_header.e_machine);
fa197c1c 8186 }
0b6ae522
DJ		 8187
8188 /* Decode the descriptors. Not implemented. */
8189}
8190
8191static void
8192dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8193{
8194 struct arm_section exidx_arm_sec, extab_arm_sec;
8195 unsigned int i, exidx_len;
948f632f 8196 unsigned long j, nfuns;
0b6ae522
DJ		 8197
8198 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8199 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8200 exidx_len = exidx_sec->sh_size / 8;
8201
948f632f
DA		 8202 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8203 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8204 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8205 aux->funtab[nfuns++] = aux->symtab[j];
8206 aux->nfuns = nfuns;
8207 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8208
0b6ae522
DJ		 8209 for (i = 0; i < exidx_len; i++)
8210 {
8211 unsigned int exidx_fn, exidx_entry;
8212 struct absaddr fn_addr, entry_addr;
8213 bfd_vma fn;
8214
8215 fputc ('\n', stdout);
8216
1b31d05e
NC		 8217 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8218 8 * i, & exidx_fn, & fn_addr, NULL)
8219 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8220 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8221 {
948f632f 8222 free (aux->funtab);
1b31d05e
NC		 8223 arm_free_section (& exidx_arm_sec);
8224 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8225 return;
8226 }
8227
83c257ca
NC		 8228 /* ARM EHABI, Section 5:
8229 An index table entry consists of 2 words.
8230 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8231 if (exidx_fn & 0x80000000)
8232 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8233
a734115a 8234 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8235
a734115a 8236 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8237 fputs (": ", stdout);
8238
8239 if (exidx_entry == 1)
8240 {
8241 print_vma (exidx_entry, PREFIX_HEX);
8242 fputs (" [cantunwind]\n", stdout);
8243 }
8244 else if (exidx_entry & 0x80000000)
8245 {
8246 print_vma (exidx_entry, PREFIX_HEX);
8247 fputc ('\n', stdout);
8248 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8249 }
8250 else
8251 {
8f73510c 8252 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8253 Elf_Internal_Shdr *table_sec;
8254
8255 fputs ("@", stdout);
a734115a 8256 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8257 print_vma (table, PREFIX_HEX);
8258 printf ("\n");
8259
8260 /* Locate the matching .ARM.extab. */
8261 if (entry_addr.section != SHN_UNDEF
8262 && entry_addr.section < elf_header.e_shnum)
8263 {
8264 table_sec = section_headers + entry_addr.section;
8265 table_offset = entry_addr.offset;
8266 }
8267 else
8268 {
8269 table_sec = find_section_by_address (table);
8270 if (table_sec != NULL)
8271 table_offset = table - table_sec->sh_addr;
8272 }
8273 if (table_sec == NULL)
8274 {
8275 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8276 (unsigned long) table);
8277 continue;
8278 }
8279 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8280 &extab_arm_sec);
8281 }
8282 }
8283
8284 printf ("\n");
8285
948f632f 8286 free (aux->funtab);
0b6ae522
DJ		 8287 arm_free_section (&exidx_arm_sec);
8288 arm_free_section (&extab_arm_sec);
8289}
8290
fa197c1c 8291/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8292
8293static void
0b6ae522
DJ		 8294arm_process_unwind (FILE *file)
8295{
8296 struct arm_unw_aux_info aux;
8297 Elf_Internal_Shdr *unwsec = NULL;
8298 Elf_Internal_Shdr *strsec;
8299 Elf_Internal_Shdr *sec;
8300 unsigned long i;
fa197c1c 8301 unsigned int sec_type;
0b6ae522 8302
fa197c1c
PB		 8303 switch (elf_header.e_machine)
8304 {
8305 case EM_ARM:
8306 sec_type = SHT_ARM_EXIDX;
8307 break;
8308
8309 case EM_TI_C6000:
8310 sec_type = SHT_C6000_UNWIND;
8311 break;
8312
0b4362b0 8313 default:
74e1a04b 8314 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8315 elf_header.e_machine);
8316 return;
fa197c1c
PB		 8317 }
8318
0b6ae522 8319 if (string_table == NULL)
1b31d05e
NC		 8320 return;
8321
8322 memset (& aux, 0, sizeof (aux));
8323 aux.file = file;
0b6ae522
DJ		 8324
8325 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8326 {
8327 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8328 {
ba5cdace 8329 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8330
8331 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8332
8333 /* PR binutils/17531 file: 011-12666-0.004. */
8334 if (aux.strtab != NULL)
8335 {
4082ef84 8336 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8337 free (aux.strtab);
8338 }
0b6ae522
DJ		 8339 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8340 1, strsec->sh_size, _("string table"));
8341 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8342 }
fa197c1c 8343 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8344 unwsec = sec;
8345 }
8346
1b31d05e 8347 if (unwsec == NULL)
0b6ae522 8348 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8349 else
8350 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8351 {
8352 if (sec->sh_type == sec_type)
8353 {
8354 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8355 printable_section_name (sec),
1b31d05e
NC		 8356 (unsigned long) sec->sh_offset,
8357 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8358
1b31d05e
NC		 8359 dump_arm_unwind (&aux, sec);
8360 }
8361 }
0b6ae522
DJ		 8362
8363 if (aux.symtab)
8364 free (aux.symtab);
8365 if (aux.strtab)
8366 free ((char *) aux.strtab);
0b6ae522
DJ		 8367}
8368
1b31d05e 8369static void
2cf0635d 8370process_unwind (FILE * file)
57346661 8371{
2cf0635d
NC		 8372 struct unwind_handler
8373 {
57346661 8374 int machtype;
1b31d05e 8375 void (* handler)(FILE *);
2cf0635d
NC		 8376 } handlers[] =
8377 {
0b6ae522 8378 { EM_ARM, arm_process_unwind },
57346661
AM		 8379 { EM_IA_64, ia64_process_unwind },
8380 { EM_PARISC, hppa_process_unwind },
fa197c1c 8381 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8382 { 0, 0 }
8383 };
8384 int i;
8385
8386 if (!do_unwind)
1b31d05e 8387 return;
57346661
AM		 8388
8389 for (i = 0; handlers[i].handler != NULL; i++)
8390 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8391 {
8392 handlers[i].handler (file);
8393 return;
8394 }
57346661 8395
1b31d05e
NC		 8396 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8397 get_machine_name (elf_header.e_machine));
57346661
AM		 8398}
8399
252b5132 8400static void
2cf0635d 8401dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8402{
8403 switch (entry->d_tag)
8404 {
8405 case DT_MIPS_FLAGS:
8406 if (entry->d_un.d_val == 0)
4b68bca3 8407 printf (_("NONE"));
252b5132
RH		 8408 else
8409 {
8410 static const char * opts[] =
8411 {
8412 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8413 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8414 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8415 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8416 "RLD_ORDER_SAFE"
8417 };
8418 unsigned int cnt;
8419 int first = 1;
2b692964 8420
60bca95a 8421 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8422 if (entry->d_un.d_val & (1 << cnt))
8423 {
8424 printf ("%s%s", first ? "" : " ", opts[cnt]);
8425 first = 0;
8426 }
252b5132
RH		 8427 }
8428 break;
103f02d3 8429
252b5132 8430 case DT_MIPS_IVERSION:
d79b3d50 8431 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8432 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8433 else
76ca31c0
NC		 8434 {
8435 char buf[40];
8436 sprintf_vma (buf, entry->d_un.d_ptr);
8437 /* Note: coded this way so that there is a single string for translation. */
8438 printf (_("<corrupt: %s>"), buf);
8439 }
252b5132 8440 break;
103f02d3 8441
252b5132
RH		 8442 case DT_MIPS_TIME_STAMP:
8443 {
8444 char timebuf[20];
2cf0635d 8445 struct tm * tmp;
91d6fa6a 8446 time_t atime = entry->d_un.d_val;
82b1b41b 8447
91d6fa6a 8448 tmp = gmtime (&atime);
82b1b41b
NC		 8449 /* PR 17531: file: 6accc532. */
8450 if (tmp == NULL)
8451 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8452 else
8453 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8454 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8455 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8456 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8457 }
8458 break;
103f02d3 8459
252b5132
RH		 8460 case DT_MIPS_RLD_VERSION:
8461 case DT_MIPS_LOCAL_GOTNO:
8462 case DT_MIPS_CONFLICTNO:
8463 case DT_MIPS_LIBLISTNO:
8464 case DT_MIPS_SYMTABNO:
8465 case DT_MIPS_UNREFEXTNO:
8466 case DT_MIPS_HIPAGENO:
8467 case DT_MIPS_DELTA_CLASS_NO:
8468 case DT_MIPS_DELTA_INSTANCE_NO:
8469 case DT_MIPS_DELTA_RELOC_NO:
8470 case DT_MIPS_DELTA_SYM_NO:
8471 case DT_MIPS_DELTA_CLASSSYM_NO:
8472 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8473 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8474 break;
103f02d3
UD		 8475
8476 default:
4b68bca3 8477 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8478 }
4b68bca3 8479 putchar ('\n');
103f02d3
UD		 8480}
8481
103f02d3 8482static void
2cf0635d 8483dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8484{
8485 switch (entry->d_tag)
8486 {
8487 case DT_HP_DLD_FLAGS:
8488 {
8489 static struct
8490 {
8491 long int bit;
2cf0635d 8492 const char * str;
5e220199
NC		 8493 }
8494 flags[] =
8495 {
8496 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8497 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8498 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8499 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8500 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8501 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8502 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8503 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8504 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8505 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8506 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8507 { DT_HP_GST, "HP_GST" },
8508 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8509 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8510 { DT_HP_NODELETE, "HP_NODELETE" },
8511 { DT_HP_GROUP, "HP_GROUP" },
8512 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8513 };
103f02d3 8514 int first = 1;
5e220199 8515 size_t cnt;
f7a99963 8516 bfd_vma val = entry->d_un.d_val;
103f02d3 8517
60bca95a 8518 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8519 if (val & flags[cnt].bit)
30800947
NC		 8520 {
8521 if (! first)
8522 putchar (' ');
8523 fputs (flags[cnt].str, stdout);
8524 first = 0;
8525 val ^= flags[cnt].bit;
8526 }
76da6bbe 8527
103f02d3 8528 if (val != 0 || first)
f7a99963
NC		 8529 {
8530 if (! first)
8531 putchar (' ');
8532 print_vma (val, HEX);
8533 }
103f02d3
UD		 8534 }
8535 break;
76da6bbe 8536
252b5132 8537 default:
f7a99963
NC		 8538 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8539 break;
252b5132 8540 }
35b1837e 8541 putchar ('\n');
252b5132
RH		 8542}
8543
28f997cf
TG		 8544#ifdef BFD64
8545
8546/* VMS vs Unix time offset and factor. */
8547
8548#define VMS_EPOCH_OFFSET 35067168000000000LL
8549#define VMS_GRANULARITY_FACTOR 10000000
8550
8551/* Display a VMS time in a human readable format. */
8552
8553static void
8554print_vms_time (bfd_int64_t vmstime)
8555{
8556 struct tm *tm;
8557 time_t unxtime;
8558
8559 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8560 tm = gmtime (&unxtime);
8561 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8562 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8563 tm->tm_hour, tm->tm_min, tm->tm_sec);
8564}
8565#endif /* BFD64 */
8566
ecc51f48 8567static void
2cf0635d 8568dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8569{
8570 switch (entry->d_tag)
8571 {
0de14b54 8572 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8573 /* First 3 slots reserved. */
ecc51f48
NC		 8574 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8575 printf (" -- ");
8576 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8577 break;
8578
28f997cf
TG		 8579 case DT_IA_64_VMS_LINKTIME:
8580#ifdef BFD64
8581 print_vms_time (entry->d_un.d_val);
8582#endif
8583 break;
8584
8585 case DT_IA_64_VMS_LNKFLAGS:
8586 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8587 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8588 printf (" CALL_DEBUG");
8589 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8590 printf (" NOP0BUFS");
8591 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8592 printf (" P0IMAGE");
8593 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8594 printf (" MKTHREADS");
8595 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8596 printf (" UPCALLS");
8597 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8598 printf (" IMGSTA");
8599 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8600 printf (" INITIALIZE");
8601 if (entry->d_un.d_val & VMS_LF_MAIN)
8602 printf (" MAIN");
8603 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8604 printf (" EXE_INIT");
8605 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8606 printf (" TBK_IN_IMG");
8607 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8608 printf (" DBG_IN_IMG");
8609 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8610 printf (" TBK_IN_DSF");
8611 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8612 printf (" DBG_IN_DSF");
8613 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8614 printf (" SIGNATURES");
8615 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8616 printf (" REL_SEG_OFF");
8617 break;
8618
bdf4d63a
JJ		 8619 default:
8620 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8621 break;
ecc51f48 8622 }
bdf4d63a 8623 putchar ('\n');
ecc51f48
NC		 8624}
8625
252b5132 8626static int
2cf0635d 8627get_32bit_dynamic_section (FILE * file)
252b5132 8628{
2cf0635d
NC		 8629 Elf32_External_Dyn * edyn;
8630 Elf32_External_Dyn * ext;
8631 Elf_Internal_Dyn * entry;
103f02d3 8632
3f5e193b
NC		 8633 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8634 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8635 if (!edyn)
8636 return 0;
103f02d3 8637
071436c6
NC		 8638 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8639 might not have the luxury of section headers. Look for the DT_NULL
8640 terminator to determine the number of entries. */
ba2685cc 8641 for (ext = edyn, dynamic_nent = 0;
071436c6 8642 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8643 ext++)
8644 {
8645 dynamic_nent++;
8646 if (BYTE_GET (ext->d_tag) == DT_NULL)
8647 break;
8648 }
252b5132 8649
3f5e193b
NC		 8650 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8651 sizeof (* entry));
b2d38a17 8652 if (dynamic_section == NULL)
252b5132 8653 {
8b73c356
NC		 8654 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8655 (unsigned long) dynamic_nent);
9ea033b2
NC		 8656 free (edyn);
8657 return 0;
8658 }
252b5132 8659
fb514b26 8660 for (ext = edyn, entry = dynamic_section;
ba2685cc 8661 entry < dynamic_section + dynamic_nent;
fb514b26 8662 ext++, entry++)
9ea033b2 8663 {
fb514b26
AM		 8664 entry->d_tag = BYTE_GET (ext->d_tag);
8665 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8666 }
8667
9ea033b2
NC		 8668 free (edyn);
8669
8670 return 1;
8671}
8672
8673static int
2cf0635d 8674get_64bit_dynamic_section (FILE * file)
9ea033b2 8675{
2cf0635d
NC		 8676 Elf64_External_Dyn * edyn;
8677 Elf64_External_Dyn * ext;
8678 Elf_Internal_Dyn * entry;
103f02d3 8679
071436c6 8680 /* Read in the data. */
3f5e193b
NC		 8681 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8682 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8683 if (!edyn)
8684 return 0;
103f02d3 8685
071436c6
NC		 8686 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8687 might not have the luxury of section headers. Look for the DT_NULL
8688 terminator to determine the number of entries. */
ba2685cc 8689 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8690 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8691 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8692 ext++)
8693 {
8694 dynamic_nent++;
66543521 8695 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8696 break;
8697 }
252b5132 8698
3f5e193b
NC		 8699 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8700 sizeof (* entry));
b2d38a17 8701 if (dynamic_section == NULL)
252b5132 8702 {
8b73c356
NC		 8703 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8704 (unsigned long) dynamic_nent);
252b5132
RH		 8705 free (edyn);
8706 return 0;
8707 }
8708
071436c6 8709 /* Convert from external to internal formats. */
fb514b26 8710 for (ext = edyn, entry = dynamic_section;
ba2685cc 8711 entry < dynamic_section + dynamic_nent;
fb514b26 8712 ext++, entry++)
252b5132 8713 {
66543521
AM		 8714 entry->d_tag = BYTE_GET (ext->d_tag);
8715 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8716 }
8717
8718 free (edyn);
8719
9ea033b2
NC		 8720 return 1;
8721}
8722
e9e44622
JJ		 8723static void
8724print_dynamic_flags (bfd_vma flags)
d1133906 8725{
e9e44622 8726 int first = 1;
13ae64f3 8727
d1133906
NC		 8728 while (flags)
8729 {
8730 bfd_vma flag;
8731
8732 flag = flags & - flags;
8733 flags &= ~ flag;
8734
e9e44622
JJ		 8735 if (first)
8736 first = 0;
8737 else
8738 putc (' ', stdout);
13ae64f3 8739
d1133906
NC		 8740 switch (flag)
8741 {
e9e44622
JJ		 8742 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8743 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8744 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8745 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8746 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8747 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8748 }
8749 }
e9e44622 8750 puts ("");
d1133906
NC		 8751}
8752
b2d38a17
NC		 8753/* Parse and display the contents of the dynamic section. */
8754
9ea033b2 8755static int
2cf0635d 8756process_dynamic_section (FILE * file)
9ea033b2 8757{
2cf0635d 8758 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8759
8760 if (dynamic_size == 0)
8761 {
8762 if (do_dynamic)
b2d38a17 8763 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8764
8765 return 1;
8766 }
8767
8768 if (is_32bit_elf)
8769 {
b2d38a17 8770 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8771 return 0;
8772 }
b2d38a17 8773 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8774 return 0;
8775
252b5132
RH		 8776 /* Find the appropriate symbol table. */
8777 if (dynamic_symbols == NULL)
8778 {
86dba8ee
AM		 8779 for (entry = dynamic_section;
8780 entry < dynamic_section + dynamic_nent;
8781 ++entry)
252b5132 8782 {
c8286bd1 8783 Elf_Internal_Shdr section;
252b5132
RH		 8784
8785 if (entry->d_tag != DT_SYMTAB)
8786 continue;
8787
8788 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8789
8790 /* Since we do not know how big the symbol table is,
8791 we default to reading in the entire file (!) and
8792 processing that. This is overkill, I know, but it
e3c8793a 8793 should work. */
d93f0186 8794 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8795
fb52b2f4
NC		 8796 if (archive_file_offset != 0)
8797 section.sh_size = archive_file_size - section.sh_offset;
8798 else
8799 {
8800 if (fseek (file, 0, SEEK_END))
591a748a 8801 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8802
8803 section.sh_size = ftell (file) - section.sh_offset;
8804 }
252b5132 8805
9ea033b2 8806 if (is_32bit_elf)
9ad5cbcf 8807 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8808 else
9ad5cbcf 8809 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8810 section.sh_name = string_table_length;
252b5132 8811
ba5cdace 8812 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8813 if (num_dynamic_syms < 1)
252b5132
RH		 8814 {
8815 error (_("Unable to determine the number of symbols to load\n"));
8816 continue;
8817 }
252b5132
RH		 8818 }
8819 }
8820
8821 /* Similarly find a string table. */
8822 if (dynamic_strings == NULL)
8823 {
86dba8ee
AM		 8824 for (entry = dynamic_section;
8825 entry < dynamic_section + dynamic_nent;
8826 ++entry)
252b5132
RH		 8827 {
8828 unsigned long offset;
b34976b6 8829 long str_tab_len;
252b5132
RH		 8830
8831 if (entry->d_tag != DT_STRTAB)
8832 continue;
8833
8834 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8835
8836 /* Since we do not know how big the string table is,
8837 we default to reading in the entire file (!) and
8838 processing that. This is overkill, I know, but it
e3c8793a 8839 should work. */
252b5132 8840
d93f0186 8841 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8842
8843 if (archive_file_offset != 0)
8844 str_tab_len = archive_file_size - offset;
8845 else
8846 {
8847 if (fseek (file, 0, SEEK_END))
8848 error (_("Unable to seek to end of file\n"));
8849 str_tab_len = ftell (file) - offset;
8850 }
252b5132
RH		 8851
8852 if (str_tab_len < 1)
8853 {
8854 error
8855 (_("Unable to determine the length of the dynamic string table\n"));
8856 continue;
8857 }
8858
3f5e193b
NC		 8859 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8860 str_tab_len,
8861 _("dynamic string table"));
59245841 8862 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8863 break;
8864 }
8865 }
8866
8867 /* And find the syminfo section if available. */
8868 if (dynamic_syminfo == NULL)
8869 {
3e8bba36 8870 unsigned long syminsz = 0;
252b5132 8871
86dba8ee
AM		 8872 for (entry = dynamic_section;
8873 entry < dynamic_section + dynamic_nent;
8874 ++entry)
252b5132
RH		 8875 {
8876 if (entry->d_tag == DT_SYMINENT)
8877 {
8878 /* Note: these braces are necessary to avoid a syntax
8879 error from the SunOS4 C compiler. */
049b0c3a
NC		 8880 /* PR binutils/17531: A corrupt file can trigger this test.
8881 So do not use an assert, instead generate an error message. */
8882 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8883 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8884 (int) entry->d_un.d_val);
252b5132
RH		 8885 }
8886 else if (entry->d_tag == DT_SYMINSZ)
8887 syminsz = entry->d_un.d_val;
8888 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8889 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8890 syminsz);
252b5132
RH		 8891 }
8892
8893 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8894 {
2cf0635d
NC		 8895 Elf_External_Syminfo * extsyminfo;
8896 Elf_External_Syminfo * extsym;
8897 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8898
8899 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8900 extsyminfo = (Elf_External_Syminfo *)
8901 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8902 _("symbol information"));
a6e9f9df
AM		 8903 if (!extsyminfo)
8904 return 0;
252b5132 8905
3f5e193b 8906 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8907 if (dynamic_syminfo == NULL)
8908 {
8b73c356
NC		 8909 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8910 (unsigned long) syminsz);
252b5132
RH		 8911 return 0;
8912 }
8913
8914 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8915 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8916 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8917 ++syminfo, ++extsym)
252b5132 8918 {
86dba8ee
AM		 8919 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8920 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8921 }
8922
8923 free (extsyminfo);
8924 }
8925 }
8926
8927 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8928 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8929 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8930 if (do_dynamic)
8931 printf (_(" Tag Type Name/Value\n"));
8932
86dba8ee
AM		 8933 for (entry = dynamic_section;
8934 entry < dynamic_section + dynamic_nent;
8935 entry++)
252b5132
RH		 8936 {
8937 if (do_dynamic)
f7a99963 8938 {
2cf0635d 8939 const char * dtype;
e699b9ff 8940
f7a99963
NC		 8941 putchar (' ');
8942 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8943 dtype = get_dynamic_type (entry->d_tag);
8944 printf (" (%s)%*s", dtype,
8945 ((is_32bit_elf ? 27 : 19)
8946 - (int) strlen (dtype)),
f7a99963
NC		 8947 " ");
8948 }
252b5132
RH		 8949
8950 switch (entry->d_tag)
8951 {
d1133906
NC		 8952 case DT_FLAGS:
8953 if (do_dynamic)
e9e44622 8954 print_dynamic_flags (entry->d_un.d_val);
d1133906 8955 break;
76da6bbe 8956
252b5132
RH		 8957 case DT_AUXILIARY:
8958 case DT_FILTER:
019148e4
L		 8959 case DT_CONFIG:
8960 case DT_DEPAUDIT:
8961 case DT_AUDIT:
252b5132
RH		 8962 if (do_dynamic)
8963 {
019148e4 8964 switch (entry->d_tag)
b34976b6 8965 {
019148e4
L		 8966 case DT_AUXILIARY:
8967 printf (_("Auxiliary library"));
8968 break;
8969
8970 case DT_FILTER:
8971 printf (_("Filter library"));
8972 break;
8973
b34976b6 8974 case DT_CONFIG:
019148e4
L		 8975 printf (_("Configuration file"));
8976 break;
8977
8978 case DT_DEPAUDIT:
8979 printf (_("Dependency audit library"));
8980 break;
8981
8982 case DT_AUDIT:
8983 printf (_("Audit library"));
8984 break;
8985 }
252b5132 8986
d79b3d50
NC		 8987 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8988 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8989 else
f7a99963
NC		 8990 {
8991 printf (": ");
8992 print_vma (entry->d_un.d_val, PREFIX_HEX);
8993 putchar ('\n');
8994 }
252b5132
RH		 8995 }
8996 break;
8997
dcefbbbd 8998 case DT_FEATURE:
252b5132
RH		 8999 if (do_dynamic)
9000 {
9001 printf (_("Flags:"));
86f55779 9002
252b5132
RH		 9003 if (entry->d_un.d_val == 0)
9004 printf (_(" None\n"));
9005 else
9006 {
9007 unsigned long int val = entry->d_un.d_val;
86f55779 9008
252b5132
RH		 9009 if (val & DTF_1_PARINIT)
9010 {
9011 printf (" PARINIT");
9012 val ^= DTF_1_PARINIT;
9013 }
dcefbbbd
L		 9014 if (val & DTF_1_CONFEXP)
9015 {
9016 printf (" CONFEXP");
9017 val ^= DTF_1_CONFEXP;
9018 }
252b5132
RH		 9019 if (val != 0)
9020 printf (" %lx", val);
9021 puts ("");
9022 }
9023 }
9024 break;
9025
9026 case DT_POSFLAG_1:
9027 if (do_dynamic)
9028 {
9029 printf (_("Flags:"));
86f55779 9030
252b5132
RH		 9031 if (entry->d_un.d_val == 0)
9032 printf (_(" None\n"));
9033 else
9034 {
9035 unsigned long int val = entry->d_un.d_val;
86f55779 9036
252b5132
RH		 9037 if (val & DF_P1_LAZYLOAD)
9038 {
9039 printf (" LAZYLOAD");
9040 val ^= DF_P1_LAZYLOAD;
9041 }
9042 if (val & DF_P1_GROUPPERM)
9043 {
9044 printf (" GROUPPERM");
9045 val ^= DF_P1_GROUPPERM;
9046 }
9047 if (val != 0)
9048 printf (" %lx", val);
9049 puts ("");
9050 }
9051 }
9052 break;
9053
9054 case DT_FLAGS_1:
9055 if (do_dynamic)
9056 {
9057 printf (_("Flags:"));
9058 if (entry->d_un.d_val == 0)
9059 printf (_(" None\n"));
9060 else
9061 {
9062 unsigned long int val = entry->d_un.d_val;
86f55779 9063
252b5132
RH		 9064 if (val & DF_1_NOW)
9065 {
9066 printf (" NOW");
9067 val ^= DF_1_NOW;
9068 }
9069 if (val & DF_1_GLOBAL)
9070 {
9071 printf (" GLOBAL");
9072 val ^= DF_1_GLOBAL;
9073 }
9074 if (val & DF_1_GROUP)
9075 {
9076 printf (" GROUP");
9077 val ^= DF_1_GROUP;
9078 }
9079 if (val & DF_1_NODELETE)
9080 {
9081 printf (" NODELETE");
9082 val ^= DF_1_NODELETE;
9083 }
9084 if (val & DF_1_LOADFLTR)
9085 {
9086 printf (" LOADFLTR");
9087 val ^= DF_1_LOADFLTR;
9088 }
9089 if (val & DF_1_INITFIRST)
9090 {
9091 printf (" INITFIRST");
9092 val ^= DF_1_INITFIRST;
9093 }
9094 if (val & DF_1_NOOPEN)
9095 {
9096 printf (" NOOPEN");
9097 val ^= DF_1_NOOPEN;
9098 }
9099 if (val & DF_1_ORIGIN)
9100 {
9101 printf (" ORIGIN");
9102 val ^= DF_1_ORIGIN;
9103 }
9104 if (val & DF_1_DIRECT)
9105 {
9106 printf (" DIRECT");
9107 val ^= DF_1_DIRECT;
9108 }
9109 if (val & DF_1_TRANS)
9110 {
9111 printf (" TRANS");
9112 val ^= DF_1_TRANS;
9113 }
9114 if (val & DF_1_INTERPOSE)
9115 {
9116 printf (" INTERPOSE");
9117 val ^= DF_1_INTERPOSE;
9118 }
f7db6139 9119 if (val & DF_1_NODEFLIB)
dcefbbbd 9120 {
f7db6139
L		 9121 printf (" NODEFLIB");
9122 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9123 }
9124 if (val & DF_1_NODUMP)
9125 {
9126 printf (" NODUMP");
9127 val ^= DF_1_NODUMP;
9128 }
34b60028 9129 if (val & DF_1_CONFALT)
dcefbbbd 9130 {
34b60028
L		 9131 printf (" CONFALT");
9132 val ^= DF_1_CONFALT;
9133 }
9134 if (val & DF_1_ENDFILTEE)
9135 {
9136 printf (" ENDFILTEE");
9137 val ^= DF_1_ENDFILTEE;
9138 }
9139 if (val & DF_1_DISPRELDNE)
9140 {
9141 printf (" DISPRELDNE");
9142 val ^= DF_1_DISPRELDNE;
9143 }
9144 if (val & DF_1_DISPRELPND)
9145 {
9146 printf (" DISPRELPND");
9147 val ^= DF_1_DISPRELPND;
9148 }
9149 if (val & DF_1_NODIRECT)
9150 {
9151 printf (" NODIRECT");
9152 val ^= DF_1_NODIRECT;
9153 }
9154 if (val & DF_1_IGNMULDEF)
9155 {
9156 printf (" IGNMULDEF");
9157 val ^= DF_1_IGNMULDEF;
9158 }
9159 if (val & DF_1_NOKSYMS)
9160 {
9161 printf (" NOKSYMS");
9162 val ^= DF_1_NOKSYMS;
9163 }
9164 if (val & DF_1_NOHDR)
9165 {
9166 printf (" NOHDR");
9167 val ^= DF_1_NOHDR;
9168 }
9169 if (val & DF_1_EDITED)
9170 {
9171 printf (" EDITED");
9172 val ^= DF_1_EDITED;
9173 }
9174 if (val & DF_1_NORELOC)
9175 {
9176 printf (" NORELOC");
9177 val ^= DF_1_NORELOC;
9178 }
9179 if (val & DF_1_SYMINTPOSE)
9180 {
9181 printf (" SYMINTPOSE");
9182 val ^= DF_1_SYMINTPOSE;
9183 }
9184 if (val & DF_1_GLOBAUDIT)
9185 {
9186 printf (" GLOBAUDIT");
9187 val ^= DF_1_GLOBAUDIT;
9188 }
9189 if (val & DF_1_SINGLETON)
9190 {
9191 printf (" SINGLETON");
9192 val ^= DF_1_SINGLETON;
dcefbbbd 9193 }
252b5132
RH		 9194 if (val != 0)
9195 printf (" %lx", val);
9196 puts ("");
9197 }
9198 }
9199 break;
9200
9201 case DT_PLTREL:
566b0d53 9202 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9203 if (do_dynamic)
9204 puts (get_dynamic_type (entry->d_un.d_val));
9205 break;
9206
9207 case DT_NULL :
9208 case DT_NEEDED :
9209 case DT_PLTGOT :
9210 case DT_HASH :
9211 case DT_STRTAB :
9212 case DT_SYMTAB :
9213 case DT_RELA :
9214 case DT_INIT :
9215 case DT_FINI :
9216 case DT_SONAME :
9217 case DT_RPATH :
9218 case DT_SYMBOLIC:
9219 case DT_REL :
9220 case DT_DEBUG :
9221 case DT_TEXTREL :
9222 case DT_JMPREL :
019148e4 9223 case DT_RUNPATH :
252b5132
RH		 9224 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9225
9226 if (do_dynamic)
9227 {
2cf0635d 9228 char * name;
252b5132 9229
d79b3d50
NC		 9230 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9231 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9232 else
d79b3d50 9233 name = NULL;
252b5132
RH		 9234
9235 if (name)
9236 {
9237 switch (entry->d_tag)
9238 {
9239 case DT_NEEDED:
9240 printf (_("Shared library: [%s]"), name);
9241
18bd398b 9242 if (streq (name, program_interpreter))
f7a99963 9243 printf (_(" program interpreter"));
252b5132
RH		 9244 break;
9245
9246 case DT_SONAME:
f7a99963 9247 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9248 break;
9249
9250 case DT_RPATH:
f7a99963 9251 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9252 break;
9253
019148e4
L		 9254 case DT_RUNPATH:
9255 printf (_("Library runpath: [%s]"), name);
9256 break;
9257
252b5132 9258 default:
f7a99963
NC		 9259 print_vma (entry->d_un.d_val, PREFIX_HEX);
9260 break;
252b5132
RH		 9261 }
9262 }
9263 else
f7a99963
NC		 9264 print_vma (entry->d_un.d_val, PREFIX_HEX);
9265
9266 putchar ('\n');
252b5132
RH		 9267 }
9268 break;
9269
9270 case DT_PLTRELSZ:
9271 case DT_RELASZ :
9272 case DT_STRSZ :
9273 case DT_RELSZ :
9274 case DT_RELAENT :
9275 case DT_SYMENT :
9276 case DT_RELENT :
566b0d53 9277 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9278 case DT_PLTPADSZ:
9279 case DT_MOVEENT :
9280 case DT_MOVESZ :
9281 case DT_INIT_ARRAYSZ:
9282 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9283 case DT_GNU_CONFLICTSZ:
9284 case DT_GNU_LIBLISTSZ:
252b5132 9285 if (do_dynamic)
f7a99963
NC		 9286 {
9287 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9288 printf (_(" (bytes)\n"));
f7a99963 9289 }
252b5132
RH		 9290 break;
9291
9292 case DT_VERDEFNUM:
9293 case DT_VERNEEDNUM:
9294 case DT_RELACOUNT:
9295 case DT_RELCOUNT:
9296 if (do_dynamic)
f7a99963
NC		 9297 {
9298 print_vma (entry->d_un.d_val, UNSIGNED);
9299 putchar ('\n');
9300 }
252b5132
RH		 9301 break;
9302
9303 case DT_SYMINSZ:
9304 case DT_SYMINENT:
9305 case DT_SYMINFO:
9306 case DT_USED:
9307 case DT_INIT_ARRAY:
9308 case DT_FINI_ARRAY:
9309 if (do_dynamic)
9310 {
d79b3d50
NC		 9311 if (entry->d_tag == DT_USED
9312 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9313 {
2cf0635d 9314 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9315
b34976b6 9316 if (*name)
252b5132
RH		 9317 {
9318 printf (_("Not needed object: [%s]\n"), name);
9319 break;
9320 }
9321 }
103f02d3 9322
f7a99963
NC		 9323 print_vma (entry->d_un.d_val, PREFIX_HEX);
9324 putchar ('\n');
252b5132
RH		 9325 }
9326 break;
9327
9328 case DT_BIND_NOW:
9329 /* The value of this entry is ignored. */
35b1837e
AM		 9330 if (do_dynamic)
9331 putchar ('\n');
252b5132 9332 break;
103f02d3 9333
047b2264
JJ		 9334 case DT_GNU_PRELINKED:
9335 if (do_dynamic)
9336 {
2cf0635d 9337 struct tm * tmp;
91d6fa6a 9338 time_t atime = entry->d_un.d_val;
047b2264 9339
91d6fa6a 9340 tmp = gmtime (&atime);
071436c6
NC		 9341 /* PR 17533 file: 041-1244816-0.004. */
9342 if (tmp == NULL)
5a2cbcf4
L		 9343 printf (_("<corrupt time val: %lx"),
9344 (unsigned long) atime);
071436c6
NC		 9345 else
9346 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9347 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9348 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9349
9350 }
9351 break;
9352
fdc90cb4
JJ		 9353 case DT_GNU_HASH:
9354 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9355 if (do_dynamic)
9356 {
9357 print_vma (entry->d_un.d_val, PREFIX_HEX);
9358 putchar ('\n');
9359 }
9360 break;
9361
252b5132
RH		 9362 default:
9363 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9364 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9365 entry->d_un.d_val;
9366
9367 if (do_dynamic)
9368 {
9369 switch (elf_header.e_machine)
9370 {
9371 case EM_MIPS:
4fe85591 9372 case EM_MIPS_RS3_LE:
b2d38a17 9373 dynamic_section_mips_val (entry);
252b5132 9374 break;
103f02d3 9375 case EM_PARISC:
b2d38a17 9376 dynamic_section_parisc_val (entry);
103f02d3 9377 break;
ecc51f48 9378 case EM_IA_64:
b2d38a17 9379 dynamic_section_ia64_val (entry);
ecc51f48 9380 break;
252b5132 9381 default:
f7a99963
NC		 9382 print_vma (entry->d_un.d_val, PREFIX_HEX);
9383 putchar ('\n');
252b5132
RH		 9384 }
9385 }
9386 break;
9387 }
9388 }
9389
9390 return 1;
9391}
9392
9393static char *
d3ba0551 9394get_ver_flags (unsigned int flags)
252b5132 9395{
b34976b6 9396 static char buff[32];
252b5132
RH		 9397
9398 buff[0] = 0;
9399
9400 if (flags == 0)
9401 return _("none");
9402
9403 if (flags & VER_FLG_BASE)
9404 strcat (buff, "BASE ");
9405
9406 if (flags & VER_FLG_WEAK)
9407 {
9408 if (flags & VER_FLG_BASE)
9409 strcat (buff, "| ");
9410
9411 strcat (buff, "WEAK ");
9412 }
9413
44ec90b9
RO		 9414 if (flags & VER_FLG_INFO)
9415 {
9416 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9417 strcat (buff, "| ");
9418
9419 strcat (buff, "INFO ");
9420 }
9421
9422 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9423 strcat (buff, _("| <unknown>"));
252b5132
RH		 9424
9425 return buff;
9426}
9427
9428/* Display the contents of the version sections. */
98fb390a 9429
252b5132 9430static int
2cf0635d 9431process_version_sections (FILE * file)
252b5132 9432{
2cf0635d 9433 Elf_Internal_Shdr * section;
b34976b6
AM		 9434 unsigned i;
9435 int found = 0;
252b5132
RH		 9436
9437 if (! do_version)
9438 return 1;
9439
9440 for (i = 0, section = section_headers;
9441 i < elf_header.e_shnum;
b34976b6 9442 i++, section++)
252b5132
RH		 9443 {
9444 switch (section->sh_type)
9445 {
9446 case SHT_GNU_verdef:
9447 {
2cf0635d 9448 Elf_External_Verdef * edefs;
b34976b6
AM		 9449 unsigned int idx;
9450 unsigned int cnt;
2cf0635d 9451 char * endbuf;
252b5132
RH		 9452
9453 found = 1;
9454
74e1a04b
NC		 9455 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9456 printable_section_name (section),
9457 section->sh_info);
252b5132
RH		 9458
9459 printf (_(" Addr: 0x"));
9460 printf_vma (section->sh_addr);
74e1a04b 9461 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9462 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9463 printable_section_name_from_index (section->sh_link));
252b5132 9464
3f5e193b
NC		 9465 edefs = (Elf_External_Verdef *)
9466 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9467 _("version definition section"));
a6e9f9df
AM		 9468 if (!edefs)
9469 break;
59245841 9470 endbuf = (char *) edefs + section->sh_size;
252b5132 9471
b34976b6 9472 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9473 {
2cf0635d
NC		 9474 char * vstart;
9475 Elf_External_Verdef * edef;
b34976b6 9476 Elf_Internal_Verdef ent;
2cf0635d 9477 Elf_External_Verdaux * eaux;
b34976b6
AM		 9478 Elf_Internal_Verdaux aux;
9479 int j;
9480 int isum;
103f02d3 9481
7e26601c
NC		 9482 /* Check for very large indicies. */
9483 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9484 break;
9485
252b5132 9486 vstart = ((char *) edefs) + idx;
54806181
AM		 9487 if (vstart + sizeof (*edef) > endbuf)
9488 break;
252b5132
RH		 9489
9490 edef = (Elf_External_Verdef *) vstart;
9491
9492 ent.vd_version = BYTE_GET (edef->vd_version);
9493 ent.vd_flags = BYTE_GET (edef->vd_flags);
9494 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9495 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9496 ent.vd_hash = BYTE_GET (edef->vd_hash);
9497 ent.vd_aux = BYTE_GET (edef->vd_aux);
9498 ent.vd_next = BYTE_GET (edef->vd_next);
9499
9500 printf (_(" %#06x: Rev: %d Flags: %s"),
9501 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9502
9503 printf (_(" Index: %d Cnt: %d "),
9504 ent.vd_ndx, ent.vd_cnt);
9505
dd24e3da 9506 /* Check for overflow. */
7e26601c 9507 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9508 break;
9509
252b5132
RH		 9510 vstart += ent.vd_aux;
9511
9512 eaux = (Elf_External_Verdaux *) vstart;
9513
9514 aux.vda_name = BYTE_GET (eaux->vda_name);
9515 aux.vda_next = BYTE_GET (eaux->vda_next);
9516
d79b3d50
NC		 9517 if (VALID_DYNAMIC_NAME (aux.vda_name))
9518 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9519 else
9520 printf (_("Name index: %ld\n"), aux.vda_name);
9521
9522 isum = idx + ent.vd_aux;
9523
b34976b6 9524 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9525 {
dd24e3da 9526 /* Check for overflow. */
7e26601c 9527 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9528 break;
9529
252b5132
RH		 9530 isum += aux.vda_next;
9531 vstart += aux.vda_next;
9532
9533 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9534 if (vstart + sizeof (*eaux) > endbuf)
9535 break;
252b5132
RH		 9536
9537 aux.vda_name = BYTE_GET (eaux->vda_name);
9538 aux.vda_next = BYTE_GET (eaux->vda_next);
9539
d79b3d50 9540 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9541 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9542 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9543 else
9544 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9545 isum, j, aux.vda_name);
9546 }
dd24e3da 9547
54806181
AM		 9548 if (j < ent.vd_cnt)
9549 printf (_(" Version def aux past end of section\n"));
252b5132 9550
5d921cbd
NC		 9551 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9552 if (idx + ent.vd_next <= idx)
9553 break;
9554
252b5132
RH		 9555 idx += ent.vd_next;
9556 }
dd24e3da 9557
54806181
AM		 9558 if (cnt < section->sh_info)
9559 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9560
9561 free (edefs);
9562 }
9563 break;
103f02d3 9564
252b5132
RH		 9565 case SHT_GNU_verneed:
9566 {
2cf0635d 9567 Elf_External_Verneed * eneed;
b34976b6
AM		 9568 unsigned int idx;
9569 unsigned int cnt;
2cf0635d 9570 char * endbuf;
252b5132
RH		 9571
9572 found = 1;
9573
72de5009 9574 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9575 printable_section_name (section), section->sh_info);
252b5132
RH		 9576
9577 printf (_(" Addr: 0x"));
9578 printf_vma (section->sh_addr);
72de5009 9579 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9580 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9581 printable_section_name_from_index (section->sh_link));
252b5132 9582
3f5e193b
NC		 9583 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9584 section->sh_offset, 1,
9585 section->sh_size,
9cf03b7e 9586 _("Version Needs section"));
a6e9f9df
AM		 9587 if (!eneed)
9588 break;
59245841 9589 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9590
9591 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9592 {
2cf0635d 9593 Elf_External_Verneed * entry;
b34976b6
AM		 9594 Elf_Internal_Verneed ent;
9595 int j;
9596 int isum;
2cf0635d 9597 char * vstart;
252b5132 9598
7e26601c 9599 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9600 break;
9601
252b5132 9602 vstart = ((char *) eneed) + idx;
54806181
AM		 9603 if (vstart + sizeof (*entry) > endbuf)
9604 break;
252b5132
RH		 9605
9606 entry = (Elf_External_Verneed *) vstart;
9607
9608 ent.vn_version = BYTE_GET (entry->vn_version);
9609 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9610 ent.vn_file = BYTE_GET (entry->vn_file);
9611 ent.vn_aux = BYTE_GET (entry->vn_aux);
9612 ent.vn_next = BYTE_GET (entry->vn_next);
9613
9614 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9615
d79b3d50
NC		 9616 if (VALID_DYNAMIC_NAME (ent.vn_file))
9617 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9618 else
9619 printf (_(" File: %lx"), ent.vn_file);
9620
9621 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9622
dd24e3da 9623 /* Check for overflow. */
7e26601c 9624 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9625 break;
252b5132
RH		 9626 vstart += ent.vn_aux;
9627
9628 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9629 {
2cf0635d 9630 Elf_External_Vernaux * eaux;
b34976b6 9631 Elf_Internal_Vernaux aux;
252b5132 9632
54806181
AM		 9633 if (vstart + sizeof (*eaux) > endbuf)
9634 break;
252b5132
RH		 9635 eaux = (Elf_External_Vernaux *) vstart;
9636
9637 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9638 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9639 aux.vna_other = BYTE_GET (eaux->vna_other);
9640 aux.vna_name = BYTE_GET (eaux->vna_name);
9641 aux.vna_next = BYTE_GET (eaux->vna_next);
9642
d79b3d50 9643 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9644 printf (_(" %#06x: Name: %s"),
d79b3d50 9645 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9646 else
ecc2063b 9647 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9648 isum, aux.vna_name);
9649
9650 printf (_(" Flags: %s Version: %d\n"),
9651 get_ver_flags (aux.vna_flags), aux.vna_other);
9652
dd24e3da 9653 /* Check for overflow. */
53774b7e
NC		 9654 if (aux.vna_next > (size_t) (endbuf - vstart)
9655 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9656 {
9657 warn (_("Invalid vna_next field of %lx\n"),
9658 aux.vna_next);
9659 j = ent.vn_cnt;
9660 break;
9661 }
252b5132
RH		 9662 isum += aux.vna_next;
9663 vstart += aux.vna_next;
9664 }
9cf03b7e 9665
54806181 9666 if (j < ent.vn_cnt)
9cf03b7e 9667 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9668
bcf83b2a 9669 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9670 {
9671 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9672 cnt = section->sh_info;
9673 break;
9674 }
252b5132
RH		 9675 idx += ent.vn_next;
9676 }
9cf03b7e 9677
54806181 9678 if (cnt < section->sh_info)
9cf03b7e 9679 warn (_("Missing Version Needs information\n"));
103f02d3 9680
252b5132
RH		 9681 free (eneed);
9682 }
9683 break;
9684
9685 case SHT_GNU_versym:
9686 {
2cf0635d 9687 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9688 size_t total;
9689 unsigned int cnt;
2cf0635d
NC		 9690 unsigned char * edata;
9691 unsigned short * data;
9692 char * strtab;
9693 Elf_Internal_Sym * symbols;
9694 Elf_Internal_Shdr * string_sec;
ba5cdace 9695 unsigned long num_syms;
d3ba0551 9696 long off;
252b5132 9697
4fbb74a6 9698 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9699 break;
9700
4fbb74a6 9701 link_section = section_headers + section->sh_link;
08d8fa11 9702 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9703
4fbb74a6 9704 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9705 break;
9706
252b5132
RH		 9707 found = 1;
9708
ba5cdace 9709 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9710 if (symbols == NULL)
9711 break;
252b5132 9712
4fbb74a6 9713 string_sec = section_headers + link_section->sh_link;
252b5132 9714
3f5e193b
NC		 9715 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9716 string_sec->sh_size,
9717 _("version string table"));
a6e9f9df 9718 if (!strtab)
0429c154
MS		 9719 {
9720 free (symbols);
9721 break;
9722 }
252b5132 9723
8b73c356
NC		 9724 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9725 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9726
9727 printf (_(" Addr: "));
9728 printf_vma (section->sh_addr);
72de5009 9729 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9730 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9731 printable_section_name (link_section));
252b5132 9732
d3ba0551
AM		 9733 off = offset_from_vma (file,
9734 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9735 total * sizeof (short));
3f5e193b
NC		 9736 edata = (unsigned char *) get_data (NULL, file, off, total,
9737 sizeof (short),
9738 _("version symbol data"));
a6e9f9df
AM		 9739 if (!edata)
9740 {
9741 free (strtab);
0429c154 9742 free (symbols);
a6e9f9df
AM		 9743 break;
9744 }
252b5132 9745
3f5e193b 9746 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9747
9748 for (cnt = total; cnt --;)
b34976b6
AM		 9749 data[cnt] = byte_get (edata + cnt * sizeof (short),
9750 sizeof (short));
252b5132
RH		 9751
9752 free (edata);
9753
9754 for (cnt = 0; cnt < total; cnt += 4)
9755 {
9756 int j, nn;
00d93f34 9757 int check_def, check_need;
2cf0635d 9758 char * name;
252b5132
RH		 9759
9760 printf (" %03x:", cnt);
9761
9762 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9763 switch (data[cnt + j])
252b5132
RH		 9764 {
9765 case 0:
9766 fputs (_(" 0 (*local*) "), stdout);
9767 break;
9768
9769 case 1:
9770 fputs (_(" 1 (*global*) "), stdout);
9771 break;
9772
9773 default:
c244d050
NC		 9774 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9775 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9776
dd24e3da 9777 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9778 array, break to avoid an out-of-bounds read. */
9779 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9780 {
9781 warn (_("invalid index into symbol array\n"));
9782 break;
9783 }
9784
00d93f34
JJ		 9785 check_def = 1;
9786 check_need = 1;
4fbb74a6
AM		 9787 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9788 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9789 != SHT_NOBITS)
252b5132 9790 {
b34976b6 9791 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9792 check_def = 0;
9793 else
9794 check_need = 0;
252b5132 9795 }
00d93f34
JJ		 9796
9797 if (check_need
b34976b6 9798 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9799 {
b34976b6
AM		 9800 Elf_Internal_Verneed ivn;
9801 unsigned long offset;
252b5132 9802
d93f0186
NC		 9803 offset = offset_from_vma
9804 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9805 sizeof (Elf_External_Verneed));
252b5132 9806
b34976b6 9807 do
252b5132 9808 {
b34976b6
AM		 9809 Elf_Internal_Vernaux ivna;
9810 Elf_External_Verneed evn;
9811 Elf_External_Vernaux evna;
9812 unsigned long a_off;
252b5132 9813
59245841
NC		 9814 if (get_data (&evn, file, offset, sizeof (evn), 1,
9815 _("version need")) == NULL)
9816 break;
0b4362b0 9817
252b5132
RH		 9818 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9819 ivn.vn_next = BYTE_GET (evn.vn_next);
9820
9821 a_off = offset + ivn.vn_aux;
9822
9823 do
9824 {
59245841
NC		 9825 if (get_data (&evna, file, a_off, sizeof (evna),
9826 1, _("version need aux (2)")) == NULL)
9827 {
9828 ivna.vna_next = 0;
9829 ivna.vna_other = 0;
9830 }
9831 else
9832 {
9833 ivna.vna_next = BYTE_GET (evna.vna_next);
9834 ivna.vna_other = BYTE_GET (evna.vna_other);
9835 }
252b5132
RH		 9836
9837 a_off += ivna.vna_next;
9838 }
b34976b6 9839 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9840 && ivna.vna_next != 0);
9841
b34976b6 9842 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9843 {
9844 ivna.vna_name = BYTE_GET (evna.vna_name);
9845
54806181
AM		 9846 if (ivna.vna_name >= string_sec->sh_size)
9847 name = _("*invalid*");
9848 else
9849 name = strtab + ivna.vna_name;
252b5132 9850 nn += printf ("(%s%-*s",
16062207
ILT		 9851 name,
9852 12 - (int) strlen (name),
252b5132 9853 ")");
00d93f34 9854 check_def = 0;
252b5132
RH		 9855 break;
9856 }
9857
9858 offset += ivn.vn_next;
9859 }
9860 while (ivn.vn_next);
9861 }
00d93f34 9862
b34976b6
AM		 9863 if (check_def && data[cnt + j] != 0x8001
9864 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9865 {
b34976b6
AM		 9866 Elf_Internal_Verdef ivd;
9867 Elf_External_Verdef evd;
9868 unsigned long offset;
252b5132 9869
d93f0186
NC		 9870 offset = offset_from_vma
9871 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9872 sizeof evd);
252b5132
RH		 9873
9874 do
9875 {
59245841
NC		 9876 if (get_data (&evd, file, offset, sizeof (evd), 1,
9877 _("version def")) == NULL)
9878 {
9879 ivd.vd_next = 0;
948f632f 9880 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9881 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9882 break;
59245841
NC		 9883 }
9884 else
9885 {
9886 ivd.vd_next = BYTE_GET (evd.vd_next);
9887 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9888 }
252b5132
RH		 9889
9890 offset += ivd.vd_next;
9891 }
c244d050 9892 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9893 && ivd.vd_next != 0);
9894
c244d050 9895 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9896 {
b34976b6
AM		 9897 Elf_External_Verdaux evda;
9898 Elf_Internal_Verdaux ivda;
252b5132
RH		 9899
9900 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9901
59245841
NC		 9902 if (get_data (&evda, file,
9903 offset - ivd.vd_next + ivd.vd_aux,
9904 sizeof (evda), 1,
9905 _("version def aux")) == NULL)
9906 break;
252b5132
RH		 9907
9908 ivda.vda_name = BYTE_GET (evda.vda_name);
9909
54806181
AM		 9910 if (ivda.vda_name >= string_sec->sh_size)
9911 name = _("*invalid*");
9912 else
9913 name = strtab + ivda.vda_name;
252b5132 9914 nn += printf ("(%s%-*s",
16062207
ILT		 9915 name,
9916 12 - (int) strlen (name),
252b5132
RH		 9917 ")");
9918 }
9919 }
9920
9921 if (nn < 18)
9922 printf ("%*c", 18 - nn, ' ');
9923 }
9924
9925 putchar ('\n');
9926 }
9927
9928 free (data);
9929 free (strtab);
9930 free (symbols);
9931 }
9932 break;
103f02d3 9933
252b5132
RH		 9934 default:
9935 break;
9936 }
9937 }
9938
9939 if (! found)
9940 printf (_("\nNo version information found in this file.\n"));
9941
9942 return 1;
9943}
9944
d1133906 9945static const char *
d3ba0551 9946get_symbol_binding (unsigned int binding)
252b5132 9947{
b34976b6 9948 static char buff[32];
252b5132
RH		 9949
9950 switch (binding)
9951 {
b34976b6
AM		 9952 case STB_LOCAL: return "LOCAL";
9953 case STB_GLOBAL: return "GLOBAL";
9954 case STB_WEAK: return "WEAK";
252b5132
RH		 9955 default:
9956 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9957 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9958 binding);
252b5132 9959 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9960 {
9961 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9962 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9963 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9964 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9965 return "UNIQUE";
9966 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9967 }
252b5132 9968 else
e9e44622 9969 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9970 return buff;
9971 }
9972}
9973
d1133906 9974static const char *
d3ba0551 9975get_symbol_type (unsigned int type)
252b5132 9976{
b34976b6 9977 static char buff[32];
252b5132
RH		 9978
9979 switch (type)
9980 {
b34976b6
AM		 9981 case STT_NOTYPE: return "NOTYPE";
9982 case STT_OBJECT: return "OBJECT";
9983 case STT_FUNC: return "FUNC";
9984 case STT_SECTION: return "SECTION";
9985 case STT_FILE: return "FILE";
9986 case STT_COMMON: return "COMMON";
9987 case STT_TLS: return "TLS";
15ab5209
DB		 9988 case STT_RELC: return "RELC";
9989 case STT_SRELC: return "SRELC";
252b5132
RH		 9990 default:
9991 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9992 {
3510a7b8
NC		 9993 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9994 return "THUMB_FUNC";
103f02d3 9995
351b4b40 9996 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9997 return "REGISTER";
9998
9999 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10000 return "PARISC_MILLI";
10001
e9e44622 10002 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10003 }
252b5132 10004 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10005 {
10006 if (elf_header.e_machine == EM_PARISC)
10007 {
10008 if (type == STT_HP_OPAQUE)
10009 return "HP_OPAQUE";
10010 if (type == STT_HP_STUB)
10011 return "HP_STUB";
10012 }
10013
d8045f23 10014 if (type == STT_GNU_IFUNC
9c55345c 10015 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10016 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10017 /* GNU is still using the default value 0. */
d8045f23
NC		 10018 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10019 return "IFUNC";
10020
e9e44622 10021 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10022 }
252b5132 10023 else
e9e44622 10024 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10025 return buff;
10026 }
10027}
10028
d1133906 10029static const char *
d3ba0551 10030get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10031{
10032 switch (visibility)
10033 {
b34976b6
AM		 10034 case STV_DEFAULT: return "DEFAULT";
10035 case STV_INTERNAL: return "INTERNAL";
10036 case STV_HIDDEN: return "HIDDEN";
d1133906 10037 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10038 default:
10039 error (_("Unrecognized visibility value: %u"), visibility);
10040 return _("<unknown>");
d1133906
NC		 10041 }
10042}
10043
5e2b0d47
NC		 10044static const char *
10045get_mips_symbol_other (unsigned int other)
10046{
10047 switch (other)
10048 {
df58fc94
RS		 10049 case STO_OPTIONAL:
10050 return "OPTIONAL";
10051 case STO_MIPS_PLT:
10052 return "MIPS PLT";
10053 case STO_MIPS_PIC:
10054 return "MIPS PIC";
10055 case STO_MICROMIPS:
10056 return "MICROMIPS";
10057 case STO_MICROMIPS | STO_MIPS_PIC:
10058 return "MICROMIPS, MIPS PIC";
10059 case STO_MIPS16:
10060 return "MIPS16";
10061 default:
10062 return NULL;
5e2b0d47
NC		 10063 }
10064}
10065
28f997cf
TG		 10066static const char *
10067get_ia64_symbol_other (unsigned int other)
10068{
10069 if (is_ia64_vms ())
10070 {
10071 static char res[32];
10072
10073 res[0] = 0;
10074
10075 /* Function types is for images and .STB files only. */
10076 switch (elf_header.e_type)
10077 {
10078 case ET_DYN:
10079 case ET_EXEC:
10080 switch (VMS_ST_FUNC_TYPE (other))
10081 {
10082 case VMS_SFT_CODE_ADDR:
10083 strcat (res, " CA");
10084 break;
10085 case VMS_SFT_SYMV_IDX:
10086 strcat (res, " VEC");
10087 break;
10088 case VMS_SFT_FD:
10089 strcat (res, " FD");
10090 break;
10091 case VMS_SFT_RESERVE:
10092 strcat (res, " RSV");
10093 break;
10094 default:
bee0ee85
NC		 10095 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10096 VMS_ST_FUNC_TYPE (other));
10097 strcat (res, " <unknown>");
10098 break;
28f997cf
TG		 10099 }
10100 break;
10101 default:
10102 break;
10103 }
10104 switch (VMS_ST_LINKAGE (other))
10105 {
10106 case VMS_STL_IGNORE:
10107 strcat (res, " IGN");
10108 break;
10109 case VMS_STL_RESERVE:
10110 strcat (res, " RSV");
10111 break;
10112 case VMS_STL_STD:
10113 strcat (res, " STD");
10114 break;
10115 case VMS_STL_LNK:
10116 strcat (res, " LNK");
10117 break;
10118 default:
bee0ee85
NC		 10119 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10120 VMS_ST_LINKAGE (other));
10121 strcat (res, " <unknown>");
10122 break;
28f997cf
TG		 10123 }
10124
10125 if (res[0] != 0)
10126 return res + 1;
10127 else
10128 return res;
10129 }
10130 return NULL;
10131}
10132
6911b7dc
AM		 10133static const char *
10134get_ppc64_symbol_other (unsigned int other)
10135{
10136 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10137 {
10138 static char buf[32];
10139 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10140 PPC64_LOCAL_ENTRY_OFFSET (other));
10141 return buf;
10142 }
10143 return NULL;
10144}
10145
5e2b0d47
NC		 10146static const char *
10147get_symbol_other (unsigned int other)
10148{
10149 const char * result = NULL;
10150 static char buff [32];
10151
10152 if (other == 0)
10153 return "";
10154
10155 switch (elf_header.e_machine)
10156 {
10157 case EM_MIPS:
10158 result = get_mips_symbol_other (other);
28f997cf
TG		 10159 break;
10160 case EM_IA_64:
10161 result = get_ia64_symbol_other (other);
10162 break;
6911b7dc
AM		 10163 case EM_PPC64:
10164 result = get_ppc64_symbol_other (other);
10165 break;
5e2b0d47
NC		 10166 default:
10167 break;
10168 }
10169
10170 if (result)
10171 return result;
10172
10173 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10174 return buff;
10175}
10176
d1133906 10177static const char *
d3ba0551 10178get_symbol_index_type (unsigned int type)
252b5132 10179{
b34976b6 10180 static char buff[32];
5cf1065c 10181
252b5132
RH		 10182 switch (type)
10183 {
b34976b6
AM		 10184 case SHN_UNDEF: return "UND";
10185 case SHN_ABS: return "ABS";
10186 case SHN_COMMON: return "COM";
252b5132 10187 default:
9ce701e2
L		 10188 if (type == SHN_IA_64_ANSI_COMMON
10189 && elf_header.e_machine == EM_IA_64
10190 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10191 return "ANSI_COM";
8a9036a4 10192 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10193 || elf_header.e_machine == EM_L1OM
10194 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10195 && type == SHN_X86_64_LCOMMON)
10196 return "LARGE_COM";
ac145307
BS		 10197 else if ((type == SHN_MIPS_SCOMMON
10198 && elf_header.e_machine == EM_MIPS)
10199 || (type == SHN_TIC6X_SCOMMON
10200 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10201 return "SCOM";
10202 else if (type == SHN_MIPS_SUNDEFINED
10203 && elf_header.e_machine == EM_MIPS)
10204 return "SUND";
9ce701e2 10205 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10206 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10207 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10208 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10209 else if (type >= SHN_LORESERVE)
10210 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10211 else if (type >= elf_header.e_shnum)
e0a31db1 10212 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10213 else
232e7cb8 10214 sprintf (buff, "%3d", type);
5cf1065c 10215 break;
252b5132 10216 }
5cf1065c
NC		 10217
10218 return buff;
252b5132
RH		 10219}
10220
66543521 10221static bfd_vma *
57028622 10222get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10223{
2cf0635d
NC		 10224 unsigned char * e_data;
10225 bfd_vma * i_data;
252b5132 10226
57028622
NC		 10227 /* If the size_t type is smaller than the bfd_size_type, eg because
10228 you are building a 32-bit tool on a 64-bit host, then make sure
10229 that when (number) is cast to (size_t) no information is lost. */
10230 if (sizeof (size_t) < sizeof (bfd_size_type)
10231 && (bfd_size_type) ((size_t) number) != number)
10232 {
10233 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10234 (unsigned long long) number, ent_size);
10235 return NULL;
10236 }
948f632f 10237
3102e897
NC		 10238 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10239 attempting to allocate memory when the read is bound to fail. */
10240 if (ent_size * number > current_file_size)
10241 {
57028622
NC		 10242 error (_("Invalid number of dynamic entries: %llu\n"),
10243 (unsigned long long) number);
3102e897
NC		 10244 return NULL;
10245 }
10246
57028622 10247 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10248 if (e_data == NULL)
10249 {
57028622
NC		 10250 error (_("Out of memory reading %llu dynamic entries\n"),
10251 (unsigned long long) number);
252b5132
RH		 10252 return NULL;
10253 }
10254
57028622 10255 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10256 {
57028622
NC		 10257 error (_("Unable to read in %llu bytes of dynamic data\n"),
10258 (unsigned long long) (number * ent_size));
3102e897 10259 free (e_data);
252b5132
RH		 10260 return NULL;
10261 }
10262
57028622 10263 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10264 if (i_data == NULL)
10265 {
57028622
NC		 10266 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10267 (unsigned long long) number);
252b5132
RH		 10268 free (e_data);
10269 return NULL;
10270 }
10271
10272 while (number--)
66543521 10273 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10274
10275 free (e_data);
10276
10277 return i_data;
10278}
10279
6bd1a22c
L		 10280static void
10281print_dynamic_symbol (bfd_vma si, unsigned long hn)
10282{
2cf0635d 10283 Elf_Internal_Sym * psym;
6bd1a22c
L		 10284 int n;
10285
6bd1a22c
L		 10286 n = print_vma (si, DEC_5);
10287 if (n < 5)
0b4362b0 10288 fputs (&" "[n], stdout);
6bd1a22c 10289 printf (" %3lu: ", hn);
e0a31db1
NC		 10290
10291 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10292 {
3102e897
NC		 10293 printf (_("<No info available for dynamic symbol number %lu>\n"),
10294 (unsigned long) si);
e0a31db1
NC		 10295 return;
10296 }
10297
10298 psym = dynamic_symbols + si;
6bd1a22c
L		 10299 print_vma (psym->st_value, LONG_HEX);
10300 putchar (' ');
10301 print_vma (psym->st_size, DEC_5);
10302
f4be36b3
AM		 10303 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10304 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10305 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10306 /* Check to see if any other bits in the st_other field are set.
10307 Note - displaying this information disrupts the layout of the
10308 table being generated, but for the moment this case is very
10309 rare. */
10310 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10311 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10312 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10313 if (VALID_DYNAMIC_NAME (psym->st_name))
10314 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10315 else
2b692964 10316 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10317 putchar ('\n');
10318}
10319
bb4d2ac2
L		 10320static const char *
10321get_symbol_version_string (FILE *file, int is_dynsym,
10322 const char *strtab,
10323 unsigned long int strtab_size,
10324 unsigned int si, Elf_Internal_Sym *psym,
10325 enum versioned_symbol_info *sym_info,
10326 unsigned short *vna_other)
10327{
10328 const char *version_string = NULL;
10329
10330 if (is_dynsym
10331 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10332 {
10333 unsigned char data[2];
10334 unsigned short vers_data;
10335 unsigned long offset;
10336 int is_nobits;
10337 int check_def;
10338
10339 offset = offset_from_vma
10340 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10341 sizeof data + si * sizeof (vers_data));
10342
10343 if (get_data (&data, file, offset + si * sizeof (vers_data),
10344 sizeof (data), 1, _("version data")) == NULL)
10345 return NULL;
10346
10347 vers_data = byte_get (data, 2);
10348
53774b7e
NC		 10349 is_nobits = (section_headers != NULL
10350 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10351 && section_headers[psym->st_shndx].sh_type
10352 == SHT_NOBITS);
10353
10354 check_def = (psym->st_shndx != SHN_UNDEF);
10355
10356 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10357 {
10358 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10359 && (is_nobits || ! check_def))
10360 {
10361 Elf_External_Verneed evn;
10362 Elf_Internal_Verneed ivn;
10363 Elf_Internal_Vernaux ivna;
10364
10365 /* We must test both. */
10366 offset = offset_from_vma
10367 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10368 sizeof evn);
10369
10370 do
10371 {
10372 unsigned long vna_off;
10373
10374 if (get_data (&evn, file, offset, sizeof (evn), 1,
10375 _("version need")) == NULL)
10376 {
10377 ivna.vna_next = 0;
10378 ivna.vna_other = 0;
10379 ivna.vna_name = 0;
10380 break;
10381 }
10382
10383 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10384 ivn.vn_next = BYTE_GET (evn.vn_next);
10385
10386 vna_off = offset + ivn.vn_aux;
10387
10388 do
10389 {
10390 Elf_External_Vernaux evna;
10391
10392 if (get_data (&evna, file, vna_off,
10393 sizeof (evna), 1,
10394 _("version need aux (3)")) == NULL)
10395 {
10396 ivna.vna_next = 0;
10397 ivna.vna_other = 0;
10398 ivna.vna_name = 0;
10399 }
10400 else
10401 {
10402 ivna.vna_other = BYTE_GET (evna.vna_other);
10403 ivna.vna_next = BYTE_GET (evna.vna_next);
10404 ivna.vna_name = BYTE_GET (evna.vna_name);
10405 }
10406
10407 vna_off += ivna.vna_next;
10408 }
10409 while (ivna.vna_other != vers_data
10410 && ivna.vna_next != 0);
10411
10412 if (ivna.vna_other == vers_data)
10413 break;
10414
10415 offset += ivn.vn_next;
10416 }
10417 while (ivn.vn_next != 0);
10418
10419 if (ivna.vna_other == vers_data)
10420 {
10421 *sym_info = symbol_undefined;
10422 *vna_other = ivna.vna_other;
10423 version_string = (ivna.vna_name < strtab_size
10424 ? strtab + ivna.vna_name
10425 : _("<corrupt>"));
10426 check_def = 0;
10427 }
10428 else if (! is_nobits)
10429 error (_("bad dynamic symbol\n"));
10430 else
10431 check_def = 1;
10432 }
10433
10434 if (check_def)
10435 {
10436 if (vers_data != 0x8001
10437 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10438 {
10439 Elf_Internal_Verdef ivd;
10440 Elf_Internal_Verdaux ivda;
10441 Elf_External_Verdaux evda;
10442 unsigned long off;
10443
10444 off = offset_from_vma
10445 (file,
10446 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10447 sizeof (Elf_External_Verdef));
10448
10449 do
10450 {
10451 Elf_External_Verdef evd;
10452
10453 if (get_data (&evd, file, off, sizeof (evd),
10454 1, _("version def")) == NULL)
10455 {
10456 ivd.vd_ndx = 0;
10457 ivd.vd_aux = 0;
10458 ivd.vd_next = 0;
10459 }
10460 else
10461 {
10462 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10463 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10464 ivd.vd_next = BYTE_GET (evd.vd_next);
10465 }
10466
10467 off += ivd.vd_next;
10468 }
10469 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10470 && ivd.vd_next != 0);
10471
10472 off -= ivd.vd_next;
10473 off += ivd.vd_aux;
10474
10475 if (get_data (&evda, file, off, sizeof (evda),
10476 1, _("version def aux")) == NULL)
10477 return version_string;
10478
10479 ivda.vda_name = BYTE_GET (evda.vda_name);
10480
10481 if (psym->st_name != ivda.vda_name)
10482 {
10483 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10484 ? symbol_hidden : symbol_public);
10485 version_string = (ivda.vda_name < strtab_size
10486 ? strtab + ivda.vda_name
10487 : _("<corrupt>"));
10488 }
10489 }
10490 }
10491 }
10492 }
10493 return version_string;
10494}
10495
e3c8793a 10496/* Dump the symbol table. */
252b5132 10497static int
2cf0635d 10498process_symbol_table (FILE * file)
252b5132 10499{
2cf0635d 10500 Elf_Internal_Shdr * section;
8b73c356
NC		 10501 bfd_size_type nbuckets = 0;
10502 bfd_size_type nchains = 0;
2cf0635d
NC		 10503 bfd_vma * buckets = NULL;
10504 bfd_vma * chains = NULL;
fdc90cb4 10505 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10506 bfd_vma * gnubuckets = NULL;
10507 bfd_vma * gnuchains = NULL;
6bd1a22c 10508 bfd_vma gnusymidx = 0;
071436c6 10509 bfd_size_type ngnuchains = 0;
252b5132 10510
2c610e4b 10511 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10512 return 1;
10513
6bd1a22c
L		 10514 if (dynamic_info[DT_HASH]
10515 && (do_histogram
2c610e4b
L		 10516 || (do_using_dynamic
10517 && !do_dyn_syms
10518 && dynamic_strings != NULL)))
252b5132 10519 {
66543521
AM		 10520 unsigned char nb[8];
10521 unsigned char nc[8];
8b73c356 10522 unsigned int hash_ent_size = 4;
66543521
AM		 10523
10524 if ((elf_header.e_machine == EM_ALPHA
10525 || elf_header.e_machine == EM_S390
10526 || elf_header.e_machine == EM_S390_OLD)
10527 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10528 hash_ent_size = 8;
10529
fb52b2f4
NC		 10530 if (fseek (file,
10531 (archive_file_offset
10532 + offset_from_vma (file, dynamic_info[DT_HASH],
10533 sizeof nb + sizeof nc)),
d93f0186 10534 SEEK_SET))
252b5132 10535 {
591a748a 10536 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10537 goto no_hash;
252b5132
RH		 10538 }
10539
66543521 10540 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10541 {
10542 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10543 goto no_hash;
252b5132
RH		 10544 }
10545
66543521 10546 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10547 {
10548 error (_("Failed to read in number of chains\n"));
d3a44ec6 10549 goto no_hash;
252b5132
RH		 10550 }
10551
66543521
AM		 10552 nbuckets = byte_get (nb, hash_ent_size);
10553 nchains = byte_get (nc, hash_ent_size);
252b5132 10554
66543521
AM		 10555 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10556 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10557
d3a44ec6 10558 no_hash:
252b5132 10559 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10560 {
10561 if (do_using_dynamic)
10562 return 0;
10563 free (buckets);
10564 free (chains);
10565 buckets = NULL;
10566 chains = NULL;
10567 nbuckets = 0;
10568 nchains = 0;
10569 }
252b5132
RH		 10570 }
10571
6bd1a22c
L		 10572 if (dynamic_info_DT_GNU_HASH
10573 && (do_histogram
2c610e4b
L		 10574 || (do_using_dynamic
10575 && !do_dyn_syms
10576 && dynamic_strings != NULL)))
252b5132 10577 {
6bd1a22c
L		 10578 unsigned char nb[16];
10579 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10580 bfd_vma buckets_vma;
10581
10582 if (fseek (file,
10583 (archive_file_offset
10584 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10585 sizeof nb)),
10586 SEEK_SET))
10587 {
10588 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10589 goto no_gnu_hash;
6bd1a22c 10590 }
252b5132 10591
6bd1a22c
L		 10592 if (fread (nb, 16, 1, file) != 1)
10593 {
10594 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10595 goto no_gnu_hash;
6bd1a22c
L		 10596 }
10597
10598 ngnubuckets = byte_get (nb, 4);
10599 gnusymidx = byte_get (nb + 4, 4);
10600 bitmaskwords = byte_get (nb + 8, 4);
10601 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10602 if (is_32bit_elf)
6bd1a22c 10603 buckets_vma += bitmaskwords * 4;
f7a99963 10604 else
6bd1a22c 10605 buckets_vma += bitmaskwords * 8;
252b5132 10606
6bd1a22c
L		 10607 if (fseek (file,
10608 (archive_file_offset
10609 + offset_from_vma (file, buckets_vma, 4)),
10610 SEEK_SET))
252b5132 10611 {
6bd1a22c 10612 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10613 goto no_gnu_hash;
6bd1a22c
L		 10614 }
10615
10616 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10617
6bd1a22c 10618 if (gnubuckets == NULL)
d3a44ec6 10619 goto no_gnu_hash;
6bd1a22c
L		 10620
10621 for (i = 0; i < ngnubuckets; i++)
10622 if (gnubuckets[i] != 0)
10623 {
10624 if (gnubuckets[i] < gnusymidx)
10625 return 0;
10626
10627 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10628 maxchain = gnubuckets[i];
10629 }
10630
10631 if (maxchain == 0xffffffff)
d3a44ec6 10632 goto no_gnu_hash;
6bd1a22c
L		 10633
10634 maxchain -= gnusymidx;
10635
10636 if (fseek (file,
10637 (archive_file_offset
10638 + offset_from_vma (file, buckets_vma
10639 + 4 * (ngnubuckets + maxchain), 4)),
10640 SEEK_SET))
10641 {
10642 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10643 goto no_gnu_hash;
6bd1a22c
L		 10644 }
10645
10646 do
10647 {
10648 if (fread (nb, 4, 1, file) != 1)
252b5132 10649 {
6bd1a22c 10650 error (_("Failed to determine last chain length\n"));
d3a44ec6 10651 goto no_gnu_hash;
6bd1a22c 10652 }
252b5132 10653
6bd1a22c 10654 if (maxchain + 1 == 0)
d3a44ec6 10655 goto no_gnu_hash;
252b5132 10656
6bd1a22c
L		 10657 ++maxchain;
10658 }
10659 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10660
6bd1a22c
L		 10661 if (fseek (file,
10662 (archive_file_offset
10663 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10664 SEEK_SET))
10665 {
10666 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10667 goto no_gnu_hash;
6bd1a22c
L		 10668 }
10669
10670 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10671 ngnuchains = maxchain;
6bd1a22c 10672
d3a44ec6 10673 no_gnu_hash:
6bd1a22c 10674 if (gnuchains == NULL)
d3a44ec6
JJ		 10675 {
10676 free (gnubuckets);
d3a44ec6
JJ		 10677 gnubuckets = NULL;
10678 ngnubuckets = 0;
f64fddf1
NC		 10679 if (do_using_dynamic)
10680 return 0;
d3a44ec6 10681 }
6bd1a22c
L		 10682 }
10683
10684 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10685 && do_syms
10686 && do_using_dynamic
3102e897
NC		 10687 && dynamic_strings != NULL
10688 && dynamic_symbols != NULL)
6bd1a22c
L		 10689 {
10690 unsigned long hn;
10691
10692 if (dynamic_info[DT_HASH])
10693 {
10694 bfd_vma si;
10695
10696 printf (_("\nSymbol table for image:\n"));
10697 if (is_32bit_elf)
10698 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10699 else
10700 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10701
10702 for (hn = 0; hn < nbuckets; hn++)
10703 {
10704 if (! buckets[hn])
10705 continue;
10706
10707 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10708 print_dynamic_symbol (si, hn);
252b5132
RH		 10709 }
10710 }
6bd1a22c
L		 10711
10712 if (dynamic_info_DT_GNU_HASH)
10713 {
10714 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10715 if (is_32bit_elf)
10716 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10717 else
10718 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10719
10720 for (hn = 0; hn < ngnubuckets; ++hn)
10721 if (gnubuckets[hn] != 0)
10722 {
10723 bfd_vma si = gnubuckets[hn];
10724 bfd_vma off = si - gnusymidx;
10725
10726 do
10727 {
10728 print_dynamic_symbol (si, hn);
10729 si++;
10730 }
071436c6 10731 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10732 }
10733 }
252b5132 10734 }
8b73c356
NC		 10735 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10736 && section_headers != NULL)
252b5132 10737 {
b34976b6 10738 unsigned int i;
252b5132
RH		 10739
10740 for (i = 0, section = section_headers;
10741 i < elf_header.e_shnum;
10742 i++, section++)
10743 {
b34976b6 10744 unsigned int si;
2cf0635d 10745 char * strtab = NULL;
c256ffe7 10746 unsigned long int strtab_size = 0;
2cf0635d
NC		 10747 Elf_Internal_Sym * symtab;
10748 Elf_Internal_Sym * psym;
ba5cdace 10749 unsigned long num_syms;
252b5132 10750
2c610e4b
L		 10751 if ((section->sh_type != SHT_SYMTAB
10752 && section->sh_type != SHT_DYNSYM)
10753 || (!do_syms
10754 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10755 continue;
10756
dd24e3da
NC		 10757 if (section->sh_entsize == 0)
10758 {
10759 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10760 printable_section_name (section));
dd24e3da
NC		 10761 continue;
10762 }
10763
252b5132 10764 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10765 printable_section_name (section),
252b5132 10766 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10767
f7a99963 10768 if (is_32bit_elf)
ca47b30c 10769 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10770 else
ca47b30c 10771 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10772
ba5cdace 10773 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10774 if (symtab == NULL)
10775 continue;
10776
10777 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10778 {
10779 strtab = string_table;
10780 strtab_size = string_table_length;
10781 }
4fbb74a6 10782 else if (section->sh_link < elf_header.e_shnum)
252b5132 10783 {
2cf0635d 10784 Elf_Internal_Shdr * string_sec;
252b5132 10785
4fbb74a6 10786 string_sec = section_headers + section->sh_link;
252b5132 10787
3f5e193b
NC		 10788 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10789 1, string_sec->sh_size,
10790 _("string table"));
c256ffe7 10791 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10792 }
10793
ba5cdace 10794 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10795 {
bb4d2ac2
L		 10796 const char *version_string;
10797 enum versioned_symbol_info sym_info;
10798 unsigned short vna_other;
10799
5e220199 10800 printf ("%6d: ", si);
f7a99963
NC		 10801 print_vma (psym->st_value, LONG_HEX);
10802 putchar (' ');
10803 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10804 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10805 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10806 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10807 /* Check to see if any other bits in the st_other field are set.
10808 Note - displaying this information disrupts the layout of the
10809 table being generated, but for the moment this case is very rare. */
10810 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10811 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10812 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10813 print_symbol (25, psym->st_name < strtab_size
2b692964 10814 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10815
bb4d2ac2
L		 10816 version_string
10817 = get_symbol_version_string (file,
10818 section->sh_type == SHT_DYNSYM,
10819 strtab, strtab_size, si,
10820 psym, &sym_info, &vna_other);
10821 if (version_string)
252b5132 10822 {
bb4d2ac2
L		 10823 if (sym_info == symbol_undefined)
10824 printf ("@%s (%d)", version_string, vna_other);
10825 else
10826 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10827 version_string);
252b5132
RH		 10828 }
10829
10830 putchar ('\n');
10831 }
10832
10833 free (symtab);
10834 if (strtab != string_table)
10835 free (strtab);
10836 }
10837 }
10838 else if (do_syms)
10839 printf
10840 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10841
10842 if (do_histogram && buckets != NULL)
10843 {
2cf0635d
NC		 10844 unsigned long * lengths;
10845 unsigned long * counts;
66543521
AM		 10846 unsigned long hn;
10847 bfd_vma si;
10848 unsigned long maxlength = 0;
10849 unsigned long nzero_counts = 0;
10850 unsigned long nsyms = 0;
94d15024 10851 unsigned long chained;
252b5132 10852
66543521
AM		 10853 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10854 (unsigned long) nbuckets);
252b5132 10855
3f5e193b 10856 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10857 if (lengths == NULL)
10858 {
8b73c356 10859 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10860 return 0;
10861 }
8b73c356
NC		 10862
10863 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10864 for (hn = 0; hn < nbuckets; ++hn)
10865 {
94d15024
MF		 10866 for (si = buckets[hn], chained = 0;
10867 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10868 si = chains[si], ++chained)
252b5132 10869 {
b34976b6 10870 ++nsyms;
252b5132 10871 if (maxlength < ++lengths[hn])
b34976b6 10872 ++maxlength;
252b5132 10873 }
94d15024
MF		 10874
10875 /* PR binutils/17531: A corrupt binary could contain broken
10876 histogram data. Do not go into an infinite loop trying
10877 to process it. */
10878 if (chained > nchains)
10879 {
10880 error (_("histogram chain is corrupt\n"));
10881 break;
10882 }
252b5132
RH		 10883 }
10884
3f5e193b 10885 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10886 if (counts == NULL)
10887 {
b2e951ec 10888 free (lengths);
8b73c356 10889 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10890 return 0;
10891 }
10892
10893 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10894 ++counts[lengths[hn]];
252b5132 10895
103f02d3 10896 if (nbuckets > 0)
252b5132 10897 {
66543521
AM		 10898 unsigned long i;
10899 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10900 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10901 for (i = 1; i <= maxlength; ++i)
103f02d3 10902 {
66543521
AM		 10903 nzero_counts += counts[i] * i;
10904 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10905 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10906 (nzero_counts * 100.0) / nsyms);
10907 }
252b5132
RH		 10908 }
10909
10910 free (counts);
10911 free (lengths);
10912 }
10913
10914 if (buckets != NULL)
10915 {
10916 free (buckets);
10917 free (chains);
10918 }
10919
d3a44ec6 10920 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10921 {
2cf0635d
NC		 10922 unsigned long * lengths;
10923 unsigned long * counts;
fdc90cb4
JJ		 10924 unsigned long hn;
10925 unsigned long maxlength = 0;
10926 unsigned long nzero_counts = 0;
10927 unsigned long nsyms = 0;
fdc90cb4 10928
8b73c356
NC		 10929 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10930 (unsigned long) ngnubuckets);
10931
3f5e193b 10932 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10933 if (lengths == NULL)
10934 {
8b73c356 10935 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10936 return 0;
10937 }
10938
fdc90cb4
JJ		 10939 printf (_(" Length Number %% of total Coverage\n"));
10940
10941 for (hn = 0; hn < ngnubuckets; ++hn)
10942 if (gnubuckets[hn] != 0)
10943 {
10944 bfd_vma off, length = 1;
10945
6bd1a22c 10946 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10947 /* PR 17531 file: 010-77222-0.004. */
10948 off < ngnuchains && (gnuchains[off] & 1) == 0;
10949 ++off)
fdc90cb4
JJ		 10950 ++length;
10951 lengths[hn] = length;
10952 if (length > maxlength)
10953 maxlength = length;
10954 nsyms += length;
10955 }
10956
3f5e193b 10957 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10958 if (counts == NULL)
10959 {
b2e951ec 10960 free (lengths);
8b73c356 10961 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 10962 return 0;
10963 }
10964
10965 for (hn = 0; hn < ngnubuckets; ++hn)
10966 ++counts[lengths[hn]];
10967
10968 if (ngnubuckets > 0)
10969 {
10970 unsigned long j;
10971 printf (" 0 %-10lu (%5.1f%%)\n",
10972 counts[0], (counts[0] * 100.0) / ngnubuckets);
10973 for (j = 1; j <= maxlength; ++j)
10974 {
10975 nzero_counts += counts[j] * j;
10976 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10977 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10978 (nzero_counts * 100.0) / nsyms);
10979 }
10980 }
10981
10982 free (counts);
10983 free (lengths);
10984 free (gnubuckets);
10985 free (gnuchains);
10986 }
10987
252b5132
RH		 10988 return 1;
10989}
10990
10991static int
2cf0635d 10992process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10993{
b4c96d0d 10994 unsigned int i;
252b5132
RH		 10995
10996 if (dynamic_syminfo == NULL
10997 || !do_dynamic)
10998 /* No syminfo, this is ok. */
10999 return 1;
11000
11001 /* There better should be a dynamic symbol section. */
11002 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11003 return 0;
11004
11005 if (dynamic_addr)
11006 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11007 dynamic_syminfo_offset, dynamic_syminfo_nent);
11008
11009 printf (_(" Num: Name BoundTo Flags\n"));
11010 for (i = 0; i < dynamic_syminfo_nent; ++i)
11011 {
11012 unsigned short int flags = dynamic_syminfo[i].si_flags;
11013
31104126 11014 printf ("%4d: ", i);
4082ef84
NC		 11015 if (i >= num_dynamic_syms)
11016 printf (_("<corrupt index>"));
11017 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11018 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11019 else
2b692964 11020 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11021 putchar (' ');
252b5132
RH		 11022
11023 switch (dynamic_syminfo[i].si_boundto)
11024 {
11025 case SYMINFO_BT_SELF:
11026 fputs ("SELF ", stdout);
11027 break;
11028 case SYMINFO_BT_PARENT:
11029 fputs ("PARENT ", stdout);
11030 break;
11031 default:
11032 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11033 && dynamic_syminfo[i].si_boundto < dynamic_nent
11034 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11035 {
d79b3d50 11036 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11037 putchar (' ' );
11038 }
252b5132
RH		 11039 else
11040 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11041 break;
11042 }
11043
11044 if (flags & SYMINFO_FLG_DIRECT)
11045 printf (" DIRECT");
11046 if (flags & SYMINFO_FLG_PASSTHRU)
11047 printf (" PASSTHRU");
11048 if (flags & SYMINFO_FLG_COPY)
11049 printf (" COPY");
11050 if (flags & SYMINFO_FLG_LAZYLOAD)
11051 printf (" LAZYLOAD");
11052
11053 puts ("");
11054 }
11055
11056 return 1;
11057}
11058
cf13d699
NC		 11059/* Check to see if the given reloc needs to be handled in a target specific
11060 manner. If so then process the reloc and return TRUE otherwise return
11061 FALSE. */
09c11c86 11062
cf13d699
NC		 11063static bfd_boolean
11064target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11065 unsigned char * start,
11066 Elf_Internal_Sym * symtab)
252b5132 11067{
cf13d699 11068 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11069
cf13d699 11070 switch (elf_header.e_machine)
252b5132 11071 {
13761a11
NC		 11072 case EM_MSP430:
11073 case EM_MSP430_OLD:
11074 {
11075 static Elf_Internal_Sym * saved_sym = NULL;
11076
11077 switch (reloc_type)
11078 {
11079 case 10: /* R_MSP430_SYM_DIFF */
11080 if (uses_msp430x_relocs ())
11081 break;
11082 case 21: /* R_MSP430X_SYM_DIFF */
11083 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11084 return TRUE;
11085
11086 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11087 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11088 goto handle_sym_diff;
0b4362b0 11089
13761a11
NC		 11090 case 5: /* R_MSP430_16_BYTE */
11091 case 9: /* R_MSP430_8 */
11092 if (uses_msp430x_relocs ())
11093 break;
11094 goto handle_sym_diff;
11095
11096 case 2: /* R_MSP430_ABS16 */
11097 case 15: /* R_MSP430X_ABS16 */
11098 if (! uses_msp430x_relocs ())
11099 break;
11100 goto handle_sym_diff;
0b4362b0 11101
13761a11
NC		 11102 handle_sym_diff:
11103 if (saved_sym != NULL)
11104 {
11105 bfd_vma value;
11106
11107 value = reloc->r_addend
11108 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11109 - saved_sym->st_value);
11110
11111 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11112
11113 saved_sym = NULL;
11114 return TRUE;
11115 }
11116 break;
11117
11118 default:
11119 if (saved_sym != NULL)
071436c6 11120 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11121 break;
11122 }
11123 break;
11124 }
11125
cf13d699
NC		 11126 case EM_MN10300:
11127 case EM_CYGNUS_MN10300:
11128 {
11129 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11130
cf13d699
NC		 11131 switch (reloc_type)
11132 {
11133 case 34: /* R_MN10300_ALIGN */
11134 return TRUE;
11135 case 33: /* R_MN10300_SYM_DIFF */
11136 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11137 return TRUE;
11138 case 1: /* R_MN10300_32 */
11139 case 2: /* R_MN10300_16 */
11140 if (saved_sym != NULL)
11141 {
11142 bfd_vma value;
252b5132 11143
cf13d699
NC		 11144 value = reloc->r_addend
11145 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11146 - saved_sym->st_value);
252b5132 11147
cf13d699 11148 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11149
cf13d699
NC		 11150 saved_sym = NULL;
11151 return TRUE;
11152 }
11153 break;
11154 default:
11155 if (saved_sym != NULL)
071436c6 11156 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11157 break;
11158 }
11159 break;
11160 }
252b5132
RH		 11161 }
11162
cf13d699 11163 return FALSE;
252b5132
RH		 11164}
11165
aca88567
NC		 11166/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11167 DWARF debug sections. This is a target specific test. Note - we do not
11168 go through the whole including-target-headers-multiple-times route, (as
11169 we have already done with <elf/h8.h>) because this would become very
11170 messy and even then this function would have to contain target specific
11171 information (the names of the relocs instead of their numeric values).
11172 FIXME: This is not the correct way to solve this problem. The proper way
11173 is to have target specific reloc sizing and typing functions created by
11174 the reloc-macros.h header, in the same way that it already creates the
11175 reloc naming functions. */
11176
11177static bfd_boolean
11178is_32bit_abs_reloc (unsigned int reloc_type)
11179{
11180 switch (elf_header.e_machine)
11181 {
41e92641
NC		 11182 case EM_386:
11183 case EM_486:
11184 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11185 case EM_68K:
11186 return reloc_type == 1; /* R_68K_32. */
11187 case EM_860:
11188 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11189 case EM_960:
11190 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11191 case EM_AARCH64:
11192 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11193 case EM_ALPHA:
137b6b5f 11194 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11195 case EM_ARC:
11196 return reloc_type == 1; /* R_ARC_32. */
11197 case EM_ARM:
11198 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11199 case EM_AVR_OLD:
aca88567
NC		 11200 case EM_AVR:
11201 return reloc_type == 1;
cfb8c092
NC		 11202 case EM_ADAPTEVA_EPIPHANY:
11203 return reloc_type == 3;
aca88567
NC		 11204 case EM_BLACKFIN:
11205 return reloc_type == 0x12; /* R_byte4_data. */
11206 case EM_CRIS:
11207 return reloc_type == 3; /* R_CRIS_32. */
11208 case EM_CR16:
11209 return reloc_type == 3; /* R_CR16_NUM32. */
11210 case EM_CRX:
11211 return reloc_type == 15; /* R_CRX_NUM32. */
11212 case EM_CYGNUS_FRV:
11213 return reloc_type == 1;
41e92641
NC		 11214 case EM_CYGNUS_D10V:
11215 case EM_D10V:
11216 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11217 case EM_CYGNUS_D30V:
11218 case EM_D30V:
11219 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11220 case EM_DLX:
11221 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11222 case EM_CYGNUS_FR30:
11223 case EM_FR30:
11224 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11225 case EM_FT32:
11226 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11227 case EM_H8S:
11228 case EM_H8_300:
11229 case EM_H8_300H:
11230 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 11231 case EM_IA_64:
11232 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 11233 case EM_IP2K_OLD:
11234 case EM_IP2K:
11235 return reloc_type == 2; /* R_IP2K_32. */
11236 case EM_IQ2000:
11237 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11238 case EM_LATTICEMICO32:
11239 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11240 case EM_M32C_OLD:
aca88567
NC		 11241 case EM_M32C:
11242 return reloc_type == 3; /* R_M32C_32. */
11243 case EM_M32R:
11244 return reloc_type == 34; /* R_M32R_32_RELA. */
11245 case EM_MCORE:
11246 return reloc_type == 1; /* R_MCORE_ADDR32. */
11247 case EM_CYGNUS_MEP:
11248 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11249 case EM_METAG:
11250 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11251 case EM_MICROBLAZE:
11252 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11253 case EM_MIPS:
11254 return reloc_type == 2; /* R_MIPS_32. */
11255 case EM_MMIX:
11256 return reloc_type == 4; /* R_MMIX_32. */
11257 case EM_CYGNUS_MN10200:
11258 case EM_MN10200:
11259 return reloc_type == 1; /* R_MN10200_32. */
11260 case EM_CYGNUS_MN10300:
11261 case EM_MN10300:
11262 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11263 case EM_MOXIE:
11264 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11265 case EM_MSP430_OLD:
11266 case EM_MSP430:
13761a11 11267 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11268 case EM_MT:
11269 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11270 case EM_NDS32:
11271 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11272 case EM_ALTERA_NIOS2:
36591ba1 11273 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11274 case EM_NIOS32:
11275 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11276 case EM_OR1K:
11277 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11278 case EM_PARISC:
5fda8eca
NC		 11279 return (reloc_type == 1 /* R_PARISC_DIR32. */
11280 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11281 case EM_PJ:
11282 case EM_PJ_OLD:
11283 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11284 case EM_PPC64:
11285 return reloc_type == 1; /* R_PPC64_ADDR32. */
11286 case EM_PPC:
11287 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11288 case EM_RL78:
11289 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11290 case EM_RX:
11291 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11292 case EM_S370:
11293 return reloc_type == 1; /* R_I370_ADDR31. */
11294 case EM_S390_OLD:
11295 case EM_S390:
11296 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11297 case EM_SCORE:
11298 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11299 case EM_SH:
11300 return reloc_type == 1; /* R_SH_DIR32. */
11301 case EM_SPARC32PLUS:
11302 case EM_SPARCV9:
11303 case EM_SPARC:
11304 return reloc_type == 3 /* R_SPARC_32. */
11305 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11306 case EM_SPU:
11307 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11308 case EM_TI_C6000:
11309 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11310 case EM_TILEGX:
11311 return reloc_type == 2; /* R_TILEGX_32. */
11312 case EM_TILEPRO:
11313 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11314 case EM_CYGNUS_V850:
11315 case EM_V850:
11316 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11317 case EM_V800:
11318 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11319 case EM_VAX:
11320 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11321 case EM_VISIUM:
11322 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11323 case EM_X86_64:
8a9036a4 11324 case EM_L1OM:
7a9068fe 11325 case EM_K1OM:
aca88567 11326 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11327 case EM_XC16X:
11328 case EM_C166:
11329 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11330 case EM_XGATE:
11331 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11332 case EM_XSTORMY16:
11333 return reloc_type == 1; /* R_XSTROMY16_32. */
11334 case EM_XTENSA_OLD:
11335 case EM_XTENSA:
11336 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11337 default:
bee0ee85
NC		 11338 {
11339 static unsigned int prev_warn = 0;
11340
11341 /* Avoid repeating the same warning multiple times. */
11342 if (prev_warn != elf_header.e_machine)
11343 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11344 elf_header.e_machine);
11345 prev_warn = elf_header.e_machine;
11346 return FALSE;
11347 }
aca88567
NC		 11348 }
11349}
11350
11351/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11352 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11353
11354static bfd_boolean
11355is_32bit_pcrel_reloc (unsigned int reloc_type)
11356{
11357 switch (elf_header.e_machine)
11358 {
41e92641
NC		 11359 case EM_386:
11360 case EM_486:
3e0873ac 11361 return reloc_type == 2; /* R_386_PC32. */
aca88567 11362 case EM_68K:
3e0873ac 11363 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11364 case EM_AARCH64:
11365 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11366 case EM_ADAPTEVA_EPIPHANY:
11367 return reloc_type == 6;
aca88567
NC		 11368 case EM_ALPHA:
11369 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11370 case EM_ARM:
3e0873ac 11371 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11372 case EM_MICROBLAZE:
11373 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11374 case EM_OR1K:
11375 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11376 case EM_PARISC:
85acf597 11377 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11378 case EM_PPC:
11379 return reloc_type == 26; /* R_PPC_REL32. */
11380 case EM_PPC64:
3e0873ac 11381 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11382 case EM_S390_OLD:
11383 case EM_S390:
3e0873ac 11384 return reloc_type == 5; /* R_390_PC32. */
aca88567 11385 case EM_SH:
3e0873ac 11386 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11387 case EM_SPARC32PLUS:
11388 case EM_SPARCV9:
11389 case EM_SPARC:
3e0873ac 11390 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11391 case EM_SPU:
11392 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11393 case EM_TILEGX:
11394 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11395 case EM_TILEPRO:
11396 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11397 case EM_VISIUM:
11398 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11399 case EM_X86_64:
8a9036a4 11400 case EM_L1OM:
7a9068fe 11401 case EM_K1OM:
3e0873ac 11402 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11403 case EM_XTENSA_OLD:
11404 case EM_XTENSA:
11405 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11406 default:
11407 /* Do not abort or issue an error message here. Not all targets use
11408 pc-relative 32-bit relocs in their DWARF debug information and we
11409 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11410 more helpful warning message will be generated by apply_relocations
11411 anyway, so just return. */
aca88567
NC		 11412 return FALSE;
11413 }
11414}
11415
11416/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11417 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11418
11419static bfd_boolean
11420is_64bit_abs_reloc (unsigned int reloc_type)
11421{
11422 switch (elf_header.e_machine)
11423 {
a06ea964
NC		 11424 case EM_AARCH64:
11425 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11426 case EM_ALPHA:
11427 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11428 case EM_IA_64:
11429 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11430 case EM_PARISC:
11431 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11432 case EM_PPC64:
11433 return reloc_type == 38; /* R_PPC64_ADDR64. */
11434 case EM_SPARC32PLUS:
11435 case EM_SPARCV9:
11436 case EM_SPARC:
11437 return reloc_type == 54; /* R_SPARC_UA64. */
11438 case EM_X86_64:
8a9036a4 11439 case EM_L1OM:
7a9068fe 11440 case EM_K1OM:
aca88567 11441 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11442 case EM_S390_OLD:
11443 case EM_S390:
aa137e4d
NC		 11444 return reloc_type == 22; /* R_S390_64. */
11445 case EM_TILEGX:
11446 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11447 case EM_MIPS:
aa137e4d 11448 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11449 default:
11450 return FALSE;
11451 }
11452}
11453
85acf597
RH		 11454/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11455 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11456
11457static bfd_boolean
11458is_64bit_pcrel_reloc (unsigned int reloc_type)
11459{
11460 switch (elf_header.e_machine)
11461 {
a06ea964
NC		 11462 case EM_AARCH64:
11463 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11464 case EM_ALPHA:
aa137e4d 11465 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11466 case EM_IA_64:
aa137e4d 11467 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11468 case EM_PARISC:
aa137e4d 11469 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11470 case EM_PPC64:
aa137e4d 11471 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11472 case EM_SPARC32PLUS:
11473 case EM_SPARCV9:
11474 case EM_SPARC:
aa137e4d 11475 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11476 case EM_X86_64:
8a9036a4 11477 case EM_L1OM:
7a9068fe 11478 case EM_K1OM:
aa137e4d 11479 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11480 case EM_S390_OLD:
11481 case EM_S390:
aa137e4d
NC		 11482 return reloc_type == 23; /* R_S390_PC64. */
11483 case EM_TILEGX:
11484 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11485 default:
11486 return FALSE;
11487 }
11488}
11489
4dc3c23d
AM		 11490/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11491 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11492
11493static bfd_boolean
11494is_24bit_abs_reloc (unsigned int reloc_type)
11495{
11496 switch (elf_header.e_machine)
11497 {
11498 case EM_CYGNUS_MN10200:
11499 case EM_MN10200:
11500 return reloc_type == 4; /* R_MN10200_24. */
11501 default:
11502 return FALSE;
11503 }
11504}
11505
aca88567
NC		 11506/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11507 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11508
11509static bfd_boolean
11510is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11511{
11512 switch (elf_header.e_machine)
11513 {
aca88567
NC		 11514 case EM_AVR_OLD:
11515 case EM_AVR:
11516 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11517 case EM_ADAPTEVA_EPIPHANY:
11518 return reloc_type == 5;
41e92641
NC		 11519 case EM_CYGNUS_D10V:
11520 case EM_D10V:
11521 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11522 case EM_H8S:
11523 case EM_H8_300:
11524 case EM_H8_300H:
aca88567
NC		 11525 return reloc_type == R_H8_DIR16;
11526 case EM_IP2K_OLD:
11527 case EM_IP2K:
11528 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11529 case EM_M32C_OLD:
f4236fe4
DD		 11530 case EM_M32C:
11531 return reloc_type == 1; /* R_M32C_16 */
aca88567 11532 case EM_MSP430:
13761a11
NC		 11533 if (uses_msp430x_relocs ())
11534 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11535 case EM_MSP430_OLD:
aca88567 11536 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11537 case EM_NDS32:
11538 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11539 case EM_ALTERA_NIOS2:
36591ba1 11540 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11541 case EM_NIOS32:
11542 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11543 case EM_OR1K:
11544 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11545 case EM_TI_C6000:
11546 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11547 case EM_XC16X:
11548 case EM_C166:
11549 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11550 case EM_CYGNUS_MN10200:
11551 case EM_MN10200:
11552 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11553 case EM_CYGNUS_MN10300:
11554 case EM_MN10300:
11555 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11556 case EM_VISIUM:
11557 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11558 case EM_XGATE:
11559 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11560 default:
aca88567 11561 return FALSE;
4b78141a
NC		 11562 }
11563}
11564
2a7b2e88
JK		 11565/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11566 relocation entries (possibly formerly used for SHT_GROUP sections). */
11567
11568static bfd_boolean
11569is_none_reloc (unsigned int reloc_type)
11570{
11571 switch (elf_header.e_machine)
11572 {
cb8f3167
NC		 11573 case EM_68K: /* R_68K_NONE. */
11574 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11575 case EM_SPARC32PLUS:
11576 case EM_SPARCV9:
cb8f3167
NC		 11577 case EM_SPARC: /* R_SPARC_NONE. */
11578 case EM_MIPS: /* R_MIPS_NONE. */
11579 case EM_PARISC: /* R_PARISC_NONE. */
11580 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11581 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11582 case EM_PPC: /* R_PPC_NONE. */
11583 case EM_PPC64: /* R_PPC64_NONE. */
11584 case EM_ARM: /* R_ARM_NONE. */
11585 case EM_IA_64: /* R_IA64_NONE. */
11586 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11587 case EM_S390_OLD:
cb8f3167
NC		 11588 case EM_S390: /* R_390_NONE. */
11589 case EM_CRIS: /* R_CRIS_NONE. */
11590 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11591 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11592 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11593 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11594 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11595 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11596 case EM_M32R: /* R_M32R_NONE. */
40b36596 11597 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11598 case EM_TILEGX: /* R_TILEGX_NONE. */
11599 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11600 case EM_XC16X:
11601 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11602 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11603 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11604 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11605 return reloc_type == 0;
a06ea964
NC		 11606 case EM_AARCH64:
11607 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11608 case EM_NDS32:
11609 return (reloc_type == 0 /* R_XTENSA_NONE. */
11610 || reloc_type == 204 /* R_NDS32_DIFF8. */
11611 || reloc_type == 205 /* R_NDS32_DIFF16. */
11612 || reloc_type == 206 /* R_NDS32_DIFF32. */
11613 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11614 case EM_XTENSA_OLD:
11615 case EM_XTENSA:
4dc3c23d
AM		 11616 return (reloc_type == 0 /* R_XTENSA_NONE. */
11617 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11618 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11619 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11620 case EM_METAG:
11621 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11622 }
11623 return FALSE;
11624}
11625
cf13d699
NC		 11626/* Apply relocations to a section.
11627 Note: So far support has been added only for those relocations
11628 which can be found in debug sections.
11629 FIXME: Add support for more relocations ? */
1b315056 11630
cf13d699
NC		 11631static void
11632apply_relocations (void * file,
11633 Elf_Internal_Shdr * section,
11634 unsigned char * start)
1b315056 11635{
cf13d699
NC		 11636 Elf_Internal_Shdr * relsec;
11637 unsigned char * end = start + section->sh_size;
cb8f3167 11638
cf13d699
NC		 11639 if (elf_header.e_type != ET_REL)
11640 return;
1b315056 11641
cf13d699 11642 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11643 for (relsec = section_headers;
11644 relsec < section_headers + elf_header.e_shnum;
11645 ++relsec)
252b5132 11646 {
41e92641
NC		 11647 bfd_boolean is_rela;
11648 unsigned long num_relocs;
2cf0635d
NC		 11649 Elf_Internal_Rela * relocs;
11650 Elf_Internal_Rela * rp;
11651 Elf_Internal_Shdr * symsec;
11652 Elf_Internal_Sym * symtab;
ba5cdace 11653 unsigned long num_syms;
2cf0635d 11654 Elf_Internal_Sym * sym;
252b5132 11655
41e92641 11656 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11657 || relsec->sh_info >= elf_header.e_shnum
11658 || section_headers + relsec->sh_info != section
c256ffe7 11659 || relsec->sh_size == 0
4fbb74a6 11660 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11661 continue;
428409d5 11662
41e92641
NC		 11663 is_rela = relsec->sh_type == SHT_RELA;
11664
11665 if (is_rela)
11666 {
3f5e193b
NC		 11667 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11668 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11669 return;
11670 }
11671 else
11672 {
3f5e193b
NC		 11673 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11674 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11675 return;
11676 }
11677
11678 /* SH uses RELA but uses in place value instead of the addend field. */
11679 if (elf_header.e_machine == EM_SH)
11680 is_rela = FALSE;
428409d5 11681
4fbb74a6 11682 symsec = section_headers + relsec->sh_link;
ba5cdace 11683 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11684
41e92641 11685 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11686 {
41e92641
NC		 11687 bfd_vma addend;
11688 unsigned int reloc_type;
11689 unsigned int reloc_size;
91d6fa6a 11690 unsigned char * rloc;
ba5cdace 11691 unsigned long sym_index;
4b78141a 11692
aca88567 11693 reloc_type = get_reloc_type (rp->r_info);
41e92641 11694
98fb390a 11695 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11696 continue;
98fb390a
NC		 11697 else if (is_none_reloc (reloc_type))
11698 continue;
11699 else if (is_32bit_abs_reloc (reloc_type)
11700 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11701 reloc_size = 4;
85acf597
RH		 11702 else if (is_64bit_abs_reloc (reloc_type)
11703 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11704 reloc_size = 8;
4dc3c23d
AM		 11705 else if (is_24bit_abs_reloc (reloc_type))
11706 reloc_size = 3;
aca88567
NC		 11707 else if (is_16bit_abs_reloc (reloc_type))
11708 reloc_size = 2;
11709 else
4b78141a 11710 {
bee0ee85
NC		 11711 static unsigned int prev_reloc = 0;
11712 if (reloc_type != prev_reloc)
11713 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11714 reloc_type, printable_section_name (section));
11715 prev_reloc = reloc_type;
4b78141a
NC		 11716 continue;
11717 }
103f02d3 11718
91d6fa6a 11719 rloc = start + rp->r_offset;
c8da6823 11720 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11721 {
11722 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11723 (unsigned long) rp->r_offset,
74e1a04b 11724 printable_section_name (section));
700dd8b7
L		 11725 continue;
11726 }
103f02d3 11727
ba5cdace
NC		 11728 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11729 if (sym_index >= num_syms)
11730 {
11731 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11732 sym_index, printable_section_name (section));
ba5cdace
NC		 11733 continue;
11734 }
11735 sym = symtab + sym_index;
41e92641
NC		 11736
11737 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11738 make sure that it is of an appropriate type.
11739
11740 Relocations against symbols without type can happen.
11741 Gcc -feliminate-dwarf2-dups may generate symbols
11742 without type for debug info.
11743
11744 Icc generates relocations against function symbols
11745 instead of local labels.
11746
11747 Relocations against object symbols can happen, eg when
11748 referencing a global array. For an example of this see
11749 the _clz.o binary in libgcc.a. */
aca88567 11750 if (sym != symtab
55f25fc3 11751 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11752 {
41e92641 11753 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11754 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11755 (long int)(rp - relocs),
74e1a04b 11756 printable_section_name (relsec));
aca88567 11757 continue;
5b18a4bc 11758 }
252b5132 11759
4dc3c23d
AM		 11760 addend = 0;
11761 if (is_rela)
11762 addend += rp->r_addend;
c47320c3
AM		 11763 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11764 partial_inplace. */
4dc3c23d
AM		 11765 if (!is_rela
11766 || (elf_header.e_machine == EM_XTENSA
11767 && reloc_type == 1)
11768 || ((elf_header.e_machine == EM_PJ
11769 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11770 && reloc_type == 1)
11771 || ((elf_header.e_machine == EM_D30V
11772 || elf_header.e_machine == EM_CYGNUS_D30V)
11773 && reloc_type == 12))
91d6fa6a 11774 addend += byte_get (rloc, reloc_size);
cb8f3167 11775
85acf597
RH		 11776 if (is_32bit_pcrel_reloc (reloc_type)
11777 || is_64bit_pcrel_reloc (reloc_type))
11778 {
11779 /* On HPPA, all pc-relative relocations are biased by 8. */
11780 if (elf_header.e_machine == EM_PARISC)
11781 addend -= 8;
91d6fa6a 11782 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11783 reloc_size);
11784 }
41e92641 11785 else
91d6fa6a 11786 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11787 }
252b5132 11788
5b18a4bc 11789 free (symtab);
41e92641 11790 free (relocs);
5b18a4bc
NC		 11791 break;
11792 }
5b18a4bc 11793}
103f02d3 11794
cf13d699
NC		 11795#ifdef SUPPORT_DISASSEMBLY
11796static int
11797disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11798{
74e1a04b 11799 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11800
74e1a04b 11801 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11802
11803 return 1;
11804}
11805#endif
11806
11807/* Reads in the contents of SECTION from FILE, returning a pointer
11808 to a malloc'ed buffer or NULL if something went wrong. */
11809
11810static char *
11811get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11812{
11813 bfd_size_type num_bytes;
11814
11815 num_bytes = section->sh_size;
11816
11817 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11818 {
11819 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11820 printable_section_name (section));
cf13d699
NC		 11821 return NULL;
11822 }
11823
3f5e193b
NC		 11824 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11825 _("section contents"));
cf13d699
NC		 11826}
11827
dd24e3da 11828
cf13d699
NC		 11829static void
11830dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11831{
11832 Elf_Internal_Shdr * relsec;
11833 bfd_size_type num_bytes;
cf13d699
NC		 11834 char * data;
11835 char * end;
11836 char * start;
cf13d699
NC		 11837 bfd_boolean some_strings_shown;
11838
11839 start = get_section_contents (section, file);
11840 if (start == NULL)
11841 return;
11842
74e1a04b 11843 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11844
11845 /* If the section being dumped has relocations against it the user might
11846 be expecting these relocations to have been applied. Check for this
11847 case and issue a warning message in order to avoid confusion.
11848 FIXME: Maybe we ought to have an option that dumps a section with
11849 relocs applied ? */
11850 for (relsec = section_headers;
11851 relsec < section_headers + elf_header.e_shnum;
11852 ++relsec)
11853 {
11854 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11855 || relsec->sh_info >= elf_header.e_shnum
11856 || section_headers + relsec->sh_info != section
11857 || relsec->sh_size == 0
11858 || relsec->sh_link >= elf_header.e_shnum)
11859 continue;
11860
11861 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11862 break;
11863 }
11864
11865 num_bytes = section->sh_size;
cf13d699
NC		 11866 data = start;
11867 end = start + num_bytes;
11868 some_strings_shown = FALSE;
11869
11870 while (data < end)
11871 {
11872 while (!ISPRINT (* data))
11873 if (++ data >= end)
11874 break;
11875
11876 if (data < end)
11877 {
071436c6
NC		 11878 size_t maxlen = end - data;
11879
cf13d699 11880#ifndef __MSVCRT__
c975cc98
NC		 11881 /* PR 11128: Use two separate invocations in order to work
11882 around bugs in the Solaris 8 implementation of printf. */
11883 printf (" [%6tx] ", data - start);
cf13d699 11884#else
071436c6 11885 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 11886#endif
4082ef84
NC		 11887 if (maxlen > 0)
11888 {
11889 print_symbol ((int) maxlen, data);
11890 putchar ('\n');
11891 data += strnlen (data, maxlen);
11892 }
11893 else
11894 {
11895 printf (_("<corrupt>\n"));
11896 data = end;
11897 }
cf13d699
NC		 11898 some_strings_shown = TRUE;
11899 }
11900 }
11901
11902 if (! some_strings_shown)
11903 printf (_(" No strings found in this section."));
11904
11905 free (start);
11906
11907 putchar ('\n');
11908}
11909
11910static void
11911dump_section_as_bytes (Elf_Internal_Shdr * section,
11912 FILE * file,
11913 bfd_boolean relocate)
11914{
11915 Elf_Internal_Shdr * relsec;
11916 bfd_size_type bytes;
11917 bfd_vma addr;
11918 unsigned char * data;
11919 unsigned char * start;
11920
11921 start = (unsigned char *) get_section_contents (section, file);
11922 if (start == NULL)
11923 return;
11924
74e1a04b 11925 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11926
11927 if (relocate)
11928 {
11929 apply_relocations (file, section, start);
11930 }
11931 else
11932 {
11933 /* If the section being dumped has relocations against it the user might
11934 be expecting these relocations to have been applied. Check for this
11935 case and issue a warning message in order to avoid confusion.
11936 FIXME: Maybe we ought to have an option that dumps a section with
11937 relocs applied ? */
11938 for (relsec = section_headers;
11939 relsec < section_headers + elf_header.e_shnum;
11940 ++relsec)
11941 {
11942 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11943 || relsec->sh_info >= elf_header.e_shnum
11944 || section_headers + relsec->sh_info != section
11945 || relsec->sh_size == 0
11946 || relsec->sh_link >= elf_header.e_shnum)
11947 continue;
11948
11949 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11950 break;
11951 }
11952 }
11953
11954 addr = section->sh_addr;
11955 bytes = section->sh_size;
11956 data = start;
11957
11958 while (bytes)
11959 {
11960 int j;
11961 int k;
11962 int lbytes;
11963
11964 lbytes = (bytes > 16 ? 16 : bytes);
11965
11966 printf (" 0x%8.8lx ", (unsigned long) addr);
11967
11968 for (j = 0; j < 16; j++)
11969 {
11970 if (j < lbytes)
11971 printf ("%2.2x", data[j]);
11972 else
11973 printf (" ");
11974
11975 if ((j & 3) == 3)
11976 printf (" ");
11977 }
11978
11979 for (j = 0; j < lbytes; j++)
11980 {
11981 k = data[j];
11982 if (k >= ' ' && k < 0x7f)
11983 printf ("%c", k);
11984 else
11985 printf (".");
11986 }
11987
11988 putchar ('\n');
11989
11990 data += lbytes;
11991 addr += lbytes;
11992 bytes -= lbytes;
11993 }
11994
11995 free (start);
11996
11997 putchar ('\n');
11998}
11999
4a114e3e 12000/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 12001
12002static int
0ee42ecd
L		 12003uncompress_section_contents (unsigned char **buffer,
12004 dwarf_size_type *size)
cf13d699 12005{
cf13d699
NC		 12006 dwarf_size_type compressed_size = *size;
12007 unsigned char * compressed_buffer = *buffer;
12008 dwarf_size_type uncompressed_size;
12009 unsigned char * uncompressed_buffer;
12010 z_stream strm;
12011 int rc;
12012 dwarf_size_type header_size = 12;
12013
12014 /* Read the zlib header. In this case, it should be "ZLIB" followed
12015 by the uncompressed section size, 8 bytes in big-endian order. */
12016 if (compressed_size < header_size
12017 || ! streq ((char *) compressed_buffer, "ZLIB"))
12018 return 0;
12019
12020 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
12021 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
12022 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
12023 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
12024 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
12025 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
12026 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
12027 uncompressed_size += compressed_buffer[11];
12028
12029 /* It is possible the section consists of several compressed
12030 buffers concatenated together, so we uncompress in a loop. */
12031 strm.zalloc = NULL;
12032 strm.zfree = NULL;
12033 strm.opaque = NULL;
12034 strm.avail_in = compressed_size - header_size;
12035 strm.next_in = (Bytef *) compressed_buffer + header_size;
12036 strm.avail_out = uncompressed_size;
3f5e193b 12037 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 12038
12039 rc = inflateInit (& strm);
12040 while (strm.avail_in > 0)
12041 {
12042 if (rc != Z_OK)
12043 goto fail;
12044 strm.next_out = ((Bytef *) uncompressed_buffer
12045 + (uncompressed_size - strm.avail_out));
12046 rc = inflate (&strm, Z_FINISH);
12047 if (rc != Z_STREAM_END)
12048 goto fail;
12049 rc = inflateReset (& strm);
12050 }
12051 rc = inflateEnd (& strm);
12052 if (rc != Z_OK
12053 || strm.avail_out != 0)
12054 goto fail;
12055
cf13d699
NC		 12056 *buffer = uncompressed_buffer;
12057 *size = uncompressed_size;
12058 return 1;
12059
12060 fail:
12061 free (uncompressed_buffer);
4a114e3e
L		 12062 /* Indicate decompression failure. */
12063 *buffer = NULL;
cf13d699 12064 return 0;
cf13d699
NC		 12065}
12066
d966045b
DJ		 12067static int
12068load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 12069 Elf_Internal_Shdr * sec, void * file)
1007acb3 12070{
2cf0635d 12071 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12072 char buf [64];
1007acb3 12073
19e6b90e
L		 12074 /* If it is already loaded, do nothing. */
12075 if (section->start != NULL)
12076 return 1;
1007acb3 12077
19e6b90e
L		 12078 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12079 section->address = sec->sh_addr;
06614111 12080 section->user_data = NULL;
3f5e193b
NC		 12081 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12082 sec->sh_offset, 1,
12083 sec->sh_size, buf);
59245841
NC		 12084 if (section->start == NULL)
12085 section->size = 0;
12086 else
12087 {
77115a4a
L		 12088 unsigned char *start = section->start;
12089 dwarf_size_type size = sec->sh_size;
12090
12091 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12092 {
12093 Elf_Internal_Chdr chdr;
12094 unsigned int compression_header_size
12095 = get_compression_header (&chdr, start);
12096 if (chdr.ch_type != ELFCOMPRESS_ZLIB
12097 || chdr.ch_addralign != sec->sh_addralign)
12098 return 0;
12099 start += compression_header_size;
12100 size -= compression_header_size;
12101 }
12102
12103 if (uncompress_section_contents (&start, &size))
12104 {
12105 /* Free the compressed buffer, update the section buffer
12106 and the section size if uncompress is successful. */
12107 free (section->start);
12108 section->start = start;
12109 sec->sh_size = size;
12110 }
12111 section->size = size;
59245841 12112 }
4a114e3e 12113
1b315056
CS		 12114 if (section->start == NULL)
12115 return 0;
12116
19e6b90e 12117 if (debug_displays [debug].relocate)
3f5e193b 12118 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 12119
1b315056 12120 return 1;
1007acb3
L		 12121}
12122
657d0d47
CC		 12123/* If this is not NULL, load_debug_section will only look for sections
12124 within the list of sections given here. */
12125unsigned int *section_subset = NULL;
12126
d966045b 12127int
2cf0635d 12128load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12129{
2cf0635d
NC		 12130 struct dwarf_section * section = &debug_displays [debug].section;
12131 Elf_Internal_Shdr * sec;
d966045b
DJ		 12132
12133 /* Locate the debug section. */
657d0d47 12134 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12135 if (sec != NULL)
12136 section->name = section->uncompressed_name;
12137 else
12138 {
657d0d47 12139 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12140 if (sec != NULL)
12141 section->name = section->compressed_name;
12142 }
12143 if (sec == NULL)
12144 return 0;
12145
657d0d47
CC		 12146 /* If we're loading from a subset of sections, and we've loaded
12147 a section matching this name before, it's likely that it's a
12148 different one. */
12149 if (section_subset != NULL)
12150 free_debug_section (debug);
12151
3f5e193b 12152 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12153}
12154
19e6b90e
L		 12155void
12156free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12157{
2cf0635d 12158 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12159
19e6b90e
L		 12160 if (section->start == NULL)
12161 return;
1007acb3 12162
19e6b90e
L		 12163 free ((char *) section->start);
12164 section->start = NULL;
12165 section->address = 0;
12166 section->size = 0;
1007acb3
L		 12167}
12168
1007acb3 12169static int
657d0d47 12170display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12171{
2cf0635d 12172 char * name = SECTION_NAME (section);
74e1a04b 12173 const char * print_name = printable_section_name (section);
19e6b90e
L		 12174 bfd_size_type length;
12175 int result = 1;
3f5e193b 12176 int i;
1007acb3 12177
19e6b90e
L		 12178 length = section->sh_size;
12179 if (length == 0)
1007acb3 12180 {
74e1a04b 12181 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12182 return 0;
1007acb3 12183 }
5dff79d8
NC		 12184 if (section->sh_type == SHT_NOBITS)
12185 {
12186 /* There is no point in dumping the contents of a debugging section
12187 which has the NOBITS type - the bits in the file will be random.
12188 This can happen when a file containing a .eh_frame section is
12189 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12190 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12191 print_name);
5dff79d8
NC		 12192 return 0;
12193 }
1007acb3 12194
0112cd26 12195 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12196 name = ".debug_info";
1007acb3 12197
19e6b90e
L		 12198 /* See if we know how to display the contents of this section. */
12199 for (i = 0; i < max; i++)
1b315056 12200 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12201 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12202 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12203 {
2cf0635d 12204 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12205 int secondary = (section != find_section (name));
12206
12207 if (secondary)
3f5e193b 12208 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12209
b40bf0a2
NC		 12210 if (i == line && const_strneq (name, ".debug_line."))
12211 sec->name = name;
12212 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12213 sec->name = sec->uncompressed_name;
12214 else
12215 sec->name = sec->compressed_name;
3f5e193b
NC		 12216 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12217 section, file))
19e6b90e 12218 {
657d0d47
CC		 12219 /* If this debug section is part of a CU/TU set in a .dwp file,
12220 restrict load_debug_section to the sections in that set. */
12221 section_subset = find_cu_tu_set (file, shndx);
12222
19e6b90e 12223 result &= debug_displays[i].display (sec, file);
1007acb3 12224
657d0d47
CC		 12225 section_subset = NULL;
12226
d966045b 12227 if (secondary || (i != info && i != abbrev))
3f5e193b 12228 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12229 }
1007acb3 12230
19e6b90e
L		 12231 break;
12232 }
1007acb3 12233
19e6b90e 12234 if (i == max)
1007acb3 12235 {
74e1a04b 12236 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12237 result = 0;
1007acb3
L		 12238 }
12239
19e6b90e 12240 return result;
5b18a4bc 12241}
103f02d3 12242
aef1f6d0
DJ		 12243/* Set DUMP_SECTS for all sections where dumps were requested
12244 based on section name. */
12245
12246static void
12247initialise_dumps_byname (void)
12248{
2cf0635d 12249 struct dump_list_entry * cur;
aef1f6d0
DJ		 12250
12251 for (cur = dump_sects_byname; cur; cur = cur->next)
12252 {
12253 unsigned int i;
12254 int any;
12255
12256 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12257 if (streq (SECTION_NAME (section_headers + i), cur->name))
12258 {
09c11c86 12259 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12260 any = 1;
12261 }
12262
12263 if (!any)
12264 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12265 cur->name);
12266 }
12267}
12268
5b18a4bc 12269static void
2cf0635d 12270process_section_contents (FILE * file)
5b18a4bc 12271{
2cf0635d 12272 Elf_Internal_Shdr * section;
19e6b90e 12273 unsigned int i;
103f02d3 12274
19e6b90e
L		 12275 if (! do_dump)
12276 return;
103f02d3 12277
aef1f6d0
DJ		 12278 initialise_dumps_byname ();
12279
19e6b90e
L		 12280 for (i = 0, section = section_headers;
12281 i < elf_header.e_shnum && i < num_dump_sects;
12282 i++, section++)
12283 {
12284#ifdef SUPPORT_DISASSEMBLY
12285 if (dump_sects[i] & DISASS_DUMP)
12286 disassemble_section (section, file);
12287#endif
12288 if (dump_sects[i] & HEX_DUMP)
cf13d699 12289 dump_section_as_bytes (section, file, FALSE);
103f02d3 12290
cf13d699
NC		 12291 if (dump_sects[i] & RELOC_DUMP)
12292 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12293
12294 if (dump_sects[i] & STRING_DUMP)
12295 dump_section_as_strings (section, file);
cf13d699
NC		 12296
12297 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12298 display_debug_section (i, section, file);
5b18a4bc 12299 }
103f02d3 12300
19e6b90e
L		 12301 /* Check to see if the user requested a
12302 dump of a section that does not exist. */
12303 while (i++ < num_dump_sects)
12304 if (dump_sects[i])
12305 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12306}
103f02d3 12307
5b18a4bc 12308static void
19e6b90e 12309process_mips_fpe_exception (int mask)
5b18a4bc 12310{
19e6b90e
L		 12311 if (mask)
12312 {
12313 int first = 1;
12314 if (mask & OEX_FPU_INEX)
12315 fputs ("INEX", stdout), first = 0;
12316 if (mask & OEX_FPU_UFLO)
12317 printf ("%sUFLO", first ? "" : "|"), first = 0;
12318 if (mask & OEX_FPU_OFLO)
12319 printf ("%sOFLO", first ? "" : "|"), first = 0;
12320 if (mask & OEX_FPU_DIV0)
12321 printf ("%sDIV0", first ? "" : "|"), first = 0;
12322 if (mask & OEX_FPU_INVAL)
12323 printf ("%sINVAL", first ? "" : "|");
12324 }
5b18a4bc 12325 else
19e6b90e 12326 fputs ("0", stdout);
5b18a4bc 12327}
103f02d3 12328
f6f0e17b
NC		 12329/* Display's the value of TAG at location P. If TAG is
12330 greater than 0 it is assumed to be an unknown tag, and
12331 a message is printed to this effect. Otherwise it is
12332 assumed that a message has already been printed.
12333
12334 If the bottom bit of TAG is set it assumed to have a
12335 string value, otherwise it is assumed to have an integer
12336 value.
12337
12338 Returns an updated P pointing to the first unread byte
12339 beyond the end of TAG's value.
12340
12341 Reads at or beyond END will not be made. */
12342
12343static unsigned char *
12344display_tag_value (int tag,
12345 unsigned char * p,
12346 const unsigned char * const end)
12347{
12348 unsigned long val;
12349
12350 if (tag > 0)
12351 printf (" Tag_unknown_%d: ", tag);
12352
12353 if (p >= end)
12354 {
4082ef84 12355 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12356 }
12357 else if (tag & 1)
12358 {
071436c6
NC		 12359 /* PR 17531 file: 027-19978-0.004. */
12360 size_t maxlen = (end - p) - 1;
12361
12362 putchar ('"');
4082ef84
NC		 12363 if (maxlen > 0)
12364 {
12365 print_symbol ((int) maxlen, (const char *) p);
12366 p += strnlen ((char *) p, maxlen) + 1;
12367 }
12368 else
12369 {
12370 printf (_("<corrupt string tag>"));
12371 p = (unsigned char *) end;
12372 }
071436c6 12373 printf ("\"\n");
f6f0e17b
NC		 12374 }
12375 else
12376 {
12377 unsigned int len;
12378
12379 val = read_uleb128 (p, &len, end);
12380 p += len;
12381 printf ("%ld (0x%lx)\n", val, val);
12382 }
12383
4082ef84 12384 assert (p <= end);
f6f0e17b
NC		 12385 return p;
12386}
12387
11c1ff18
PB		 12388/* ARM EABI attributes section. */
12389typedef struct
12390{
70e99720 12391 unsigned int tag;
2cf0635d 12392 const char * name;
11c1ff18 12393 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12394 unsigned int type;
2cf0635d 12395 const char ** table;
11c1ff18
PB		 12396} arm_attr_public_tag;
12397
2cf0635d 12398static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12399 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12400 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12401static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12402static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12403 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12404static const char * arm_attr_tag_FP_arch[] =
bca38921 12405 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12406 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12407static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12408static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12409 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12410static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12411 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12412 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12413static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12414 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12415static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12416 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12417static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12418 {"Absolute", "PC-relative", "None"};
2cf0635d 12419static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12420 {"None", "direct", "GOT-indirect"};
2cf0635d 12421static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12422 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12423static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12424static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12425 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12426static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12427static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12428static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12429 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12430static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12431 {"Unused", "small", "int", "forced to int"};
2cf0635d 12432static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12433 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12434static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12435 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12436static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12437 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12438static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12439 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12440 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12441static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12442 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12443 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12444static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12445static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12446 {"Not Allowed", "Allowed"};
2cf0635d 12447static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12448 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12449static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12450 {"Not Allowed", "Allowed"};
12451static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12452 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12453 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12454static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12455static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12456 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12457 "TrustZone and Virtualization Extensions"};
dd24e3da 12458static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12459 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12460
12461#define LOOKUP(id, name) \
12462 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12463static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12464{
12465 {4, "CPU_raw_name", 1, NULL},
12466 {5, "CPU_name", 1, NULL},
12467 LOOKUP(6, CPU_arch),
12468 {7, "CPU_arch_profile", 0, NULL},
12469 LOOKUP(8, ARM_ISA_use),
12470 LOOKUP(9, THUMB_ISA_use),
75375b3e 12471 LOOKUP(10, FP_arch),
11c1ff18 12472 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12473 LOOKUP(12, Advanced_SIMD_arch),
12474 LOOKUP(13, PCS_config),
11c1ff18
PB		 12475 LOOKUP(14, ABI_PCS_R9_use),
12476 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12477 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12478 LOOKUP(17, ABI_PCS_GOT_use),
12479 LOOKUP(18, ABI_PCS_wchar_t),
12480 LOOKUP(19, ABI_FP_rounding),
12481 LOOKUP(20, ABI_FP_denormal),
12482 LOOKUP(21, ABI_FP_exceptions),
12483 LOOKUP(22, ABI_FP_user_exceptions),
12484 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12485 {24, "ABI_align_needed", 0, NULL},
12486 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12487 LOOKUP(26, ABI_enum_size),
12488 LOOKUP(27, ABI_HardFP_use),
12489 LOOKUP(28, ABI_VFP_args),
12490 LOOKUP(29, ABI_WMMX_args),
12491 LOOKUP(30, ABI_optimization_goals),
12492 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12493 {32, "compatibility", 0, NULL},
f5f53991 12494 LOOKUP(34, CPU_unaligned_access),
75375b3e 12495 LOOKUP(36, FP_HP_extension),
8e79c3df 12496 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12497 LOOKUP(42, MPextension_use),
12498 LOOKUP(44, DIV_use),
f5f53991
AS		 12499 {64, "nodefaults", 0, NULL},
12500 {65, "also_compatible_with", 0, NULL},
12501 LOOKUP(66, T2EE_use),
12502 {67, "conformance", 1, NULL},
12503 LOOKUP(68, Virtualization_use),
cd21e546 12504 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12505};
12506#undef LOOKUP
12507
11c1ff18 12508static unsigned char *
f6f0e17b
NC		 12509display_arm_attribute (unsigned char * p,
12510 const unsigned char * const end)
11c1ff18 12511{
70e99720 12512 unsigned int tag;
11c1ff18 12513 unsigned int len;
70e99720 12514 unsigned int val;
2cf0635d 12515 arm_attr_public_tag * attr;
11c1ff18 12516 unsigned i;
70e99720 12517 unsigned int type;
11c1ff18 12518
f6f0e17b 12519 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12520 p += len;
12521 attr = NULL;
2cf0635d 12522 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12523 {
12524 if (arm_attr_public_tags[i].tag == tag)
12525 {
12526 attr = &arm_attr_public_tags[i];
12527 break;
12528 }
12529 }
12530
12531 if (attr)
12532 {
12533 printf (" Tag_%s: ", attr->name);
12534 switch (attr->type)
12535 {
12536 case 0:
12537 switch (tag)
12538 {
12539 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12540 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12541 p += len;
12542 switch (val)
12543 {
2b692964
NC		 12544 case 0: printf (_("None\n")); break;
12545 case 'A': printf (_("Application\n")); break;
12546 case 'R': printf (_("Realtime\n")); break;
12547 case 'M': printf (_("Microcontroller\n")); break;
12548 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12549 default: printf ("??? (%d)\n", val); break;
12550 }
12551 break;
12552
75375b3e 12553 case 24: /* Tag_align_needed. */
f6f0e17b 12554 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12555 p += len;
12556 switch (val)
12557 {
2b692964
NC		 12558 case 0: printf (_("None\n")); break;
12559 case 1: printf (_("8-byte\n")); break;
12560 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12561 case 3: printf ("??? 3\n"); break;
12562 default:
12563 if (val <= 12)
dd24e3da 12564 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12565 1 << val);
12566 else
12567 printf ("??? (%d)\n", val);
12568 break;
12569 }
12570 break;
12571
12572 case 25: /* Tag_align_preserved. */
f6f0e17b 12573 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12574 p += len;
12575 switch (val)
12576 {
2b692964
NC		 12577 case 0: printf (_("None\n")); break;
12578 case 1: printf (_("8-byte, except leaf SP\n")); break;
12579 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12580 case 3: printf ("??? 3\n"); break;
12581 default:
12582 if (val <= 12)
dd24e3da 12583 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12584 1 << val);
12585 else
12586 printf ("??? (%d)\n", val);
12587 break;
12588 }
12589 break;
12590
11c1ff18 12591 case 32: /* Tag_compatibility. */
071436c6 12592 {
071436c6
NC		 12593 val = read_uleb128 (p, &len, end);
12594 p += len;
071436c6 12595 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12596 if (p < end - 1)
12597 {
12598 size_t maxlen = (end - p) - 1;
12599
12600 print_symbol ((int) maxlen, (const char *) p);
12601 p += strnlen ((char *) p, maxlen) + 1;
12602 }
12603 else
12604 {
12605 printf (_("<corrupt>"));
12606 p = (unsigned char *) end;
12607 }
071436c6 12608 putchar ('\n');
071436c6 12609 }
11c1ff18
PB		 12610 break;
12611
f5f53991 12612 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12613 /* PR 17531: file: 001-505008-0.01. */
12614 if (p < end)
12615 p++;
2b692964 12616 printf (_("True\n"));
f5f53991
AS		 12617 break;
12618
12619 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12620 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12621 p += len;
12622 if (val == 6 /* Tag_CPU_arch. */)
12623 {
f6f0e17b 12624 val = read_uleb128 (p, &len, end);
f5f53991 12625 p += len;
071436c6 12626 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12627 printf ("??? (%d)\n", val);
12628 else
12629 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12630 }
12631 else
12632 printf ("???\n");
071436c6
NC		 12633 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12634 ;
f5f53991
AS		 12635 break;
12636
11c1ff18 12637 default:
bee0ee85
NC		 12638 printf (_("<unknown: %d>\n"), tag);
12639 break;
11c1ff18
PB		 12640 }
12641 return p;
12642
12643 case 1:
f6f0e17b 12644 return display_tag_value (-1, p, end);
11c1ff18 12645 case 2:
f6f0e17b 12646 return display_tag_value (0, p, end);
11c1ff18
PB		 12647
12648 default:
12649 assert (attr->type & 0x80);
f6f0e17b 12650 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12651 p += len;
12652 type = attr->type & 0x7f;
12653 if (val >= type)
12654 printf ("??? (%d)\n", val);
12655 else
12656 printf ("%s\n", attr->table[val]);
12657 return p;
12658 }
12659 }
11c1ff18 12660
f6f0e17b 12661 return display_tag_value (tag, p, end);
11c1ff18
PB		 12662}
12663
104d59d1 12664static unsigned char *
60bca95a 12665display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12666 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12667 const unsigned char * const end)
104d59d1
JM		 12668{
12669 int tag;
12670 unsigned int len;
12671 int val;
104d59d1 12672
f6f0e17b 12673 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12674 p += len;
12675
12676 /* Tag_compatibility is the only generic GNU attribute defined at
12677 present. */
12678 if (tag == 32)
12679 {
f6f0e17b 12680 val = read_uleb128 (p, &len, end);
104d59d1 12681 p += len;
071436c6
NC		 12682
12683 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12684 if (p == end)
12685 {
071436c6 12686 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12687 warn (_("corrupt vendor attribute\n"));
12688 }
12689 else
12690 {
4082ef84
NC		 12691 if (p < end - 1)
12692 {
12693 size_t maxlen = (end - p) - 1;
071436c6 12694
4082ef84
NC		 12695 print_symbol ((int) maxlen, (const char *) p);
12696 p += strnlen ((char *) p, maxlen) + 1;
12697 }
12698 else
12699 {
12700 printf (_("<corrupt>"));
12701 p = (unsigned char *) end;
12702 }
071436c6 12703 putchar ('\n');
f6f0e17b 12704 }
104d59d1
JM		 12705 return p;
12706 }
12707
12708 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12709 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12710
f6f0e17b 12711 return display_tag_value (tag, p, end);
104d59d1
JM		 12712}
12713
34c8bcba 12714static unsigned char *
f6f0e17b
NC		 12715display_power_gnu_attribute (unsigned char * p,
12716 int tag,
12717 const unsigned char * const end)
34c8bcba 12718{
34c8bcba
JM		 12719 unsigned int len;
12720 int val;
12721
12722 if (tag == Tag_GNU_Power_ABI_FP)
12723 {
f6f0e17b 12724 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12725 p += len;
12726 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12727
34c8bcba
JM		 12728 switch (val)
12729 {
12730 case 0:
2b692964 12731 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12732 break;
12733 case 1:
2b692964 12734 printf (_("Hard float\n"));
34c8bcba
JM		 12735 break;
12736 case 2:
2b692964 12737 printf (_("Soft float\n"));
34c8bcba 12738 break;
3c7b9897 12739 case 3:
2b692964 12740 printf (_("Single-precision hard float\n"));
3c7b9897 12741 break;
34c8bcba
JM		 12742 default:
12743 printf ("??? (%d)\n", val);
12744 break;
12745 }
12746 return p;
12747 }
12748
c6e65352
DJ		 12749 if (tag == Tag_GNU_Power_ABI_Vector)
12750 {
f6f0e17b 12751 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12752 p += len;
12753 printf (" Tag_GNU_Power_ABI_Vector: ");
12754 switch (val)
12755 {
12756 case 0:
2b692964 12757 printf (_("Any\n"));
c6e65352
DJ		 12758 break;
12759 case 1:
2b692964 12760 printf (_("Generic\n"));
c6e65352
DJ		 12761 break;
12762 case 2:
12763 printf ("AltiVec\n");
12764 break;
12765 case 3:
12766 printf ("SPE\n");
12767 break;
12768 default:
12769 printf ("??? (%d)\n", val);
12770 break;
12771 }
12772 return p;
12773 }
12774
f82e0623
NF		 12775 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12776 {
f6f0e17b
NC		 12777 if (p == end)
12778 {
071436c6 12779 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12780 return p;
12781 }
0b4362b0 12782
f6f0e17b 12783 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12784 p += len;
12785 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12786 switch (val)
12787 {
12788 case 0:
2b692964 12789 printf (_("Any\n"));
f82e0623
NF		 12790 break;
12791 case 1:
12792 printf ("r3/r4\n");
12793 break;
12794 case 2:
2b692964 12795 printf (_("Memory\n"));
f82e0623
NF		 12796 break;
12797 default:
12798 printf ("??? (%d)\n", val);
12799 break;
12800 }
12801 return p;
12802 }
12803
f6f0e17b 12804 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12805}
12806
9e8c70f9
DM		 12807static void
12808display_sparc_hwcaps (int mask)
12809{
12810 if (mask)
12811 {
12812 int first = 1;
071436c6 12813
9e8c70f9
DM		 12814 if (mask & ELF_SPARC_HWCAP_MUL32)
12815 fputs ("mul32", stdout), first = 0;
12816 if (mask & ELF_SPARC_HWCAP_DIV32)
12817 printf ("%sdiv32", first ? "" : "|"), first = 0;
12818 if (mask & ELF_SPARC_HWCAP_FSMULD)
12819 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12820 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12821 printf ("%sv8plus", first ? "" : "|"), first = 0;
12822 if (mask & ELF_SPARC_HWCAP_POPC)
12823 printf ("%spopc", first ? "" : "|"), first = 0;
12824 if (mask & ELF_SPARC_HWCAP_VIS)
12825 printf ("%svis", first ? "" : "|"), first = 0;
12826 if (mask & ELF_SPARC_HWCAP_VIS2)
12827 printf ("%svis2", first ? "" : "|"), first = 0;
12828 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12829 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12830 if (mask & ELF_SPARC_HWCAP_FMAF)
12831 printf ("%sfmaf", first ? "" : "|"), first = 0;
12832 if (mask & ELF_SPARC_HWCAP_VIS3)
12833 printf ("%svis3", first ? "" : "|"), first = 0;
12834 if (mask & ELF_SPARC_HWCAP_HPC)
12835 printf ("%shpc", first ? "" : "|"), first = 0;
12836 if (mask & ELF_SPARC_HWCAP_RANDOM)
12837 printf ("%srandom", first ? "" : "|"), first = 0;
12838 if (mask & ELF_SPARC_HWCAP_TRANS)
12839 printf ("%strans", first ? "" : "|"), first = 0;
12840 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12841 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12842 if (mask & ELF_SPARC_HWCAP_IMA)
12843 printf ("%sima", first ? "" : "|"), first = 0;
12844 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12845 printf ("%scspare", first ? "" : "|"), first = 0;
12846 }
12847 else
071436c6
NC		 12848 fputc ('0', stdout);
12849 fputc ('\n', stdout);
9e8c70f9
DM		 12850}
12851
3d68f91c
JM		 12852static void
12853display_sparc_hwcaps2 (int mask)
12854{
12855 if (mask)
12856 {
12857 int first = 1;
071436c6 12858
3d68f91c
JM		 12859 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12860 fputs ("fjathplus", stdout), first = 0;
12861 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12862 printf ("%svis3b", first ? "" : "|"), first = 0;
12863 if (mask & ELF_SPARC_HWCAP2_ADP)
12864 printf ("%sadp", first ? "" : "|"), first = 0;
12865 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12866 printf ("%ssparc5", first ? "" : "|"), first = 0;
12867 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12868 printf ("%smwait", first ? "" : "|"), first = 0;
12869 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12870 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12871 if (mask & ELF_SPARC_HWCAP2_XMONT)
12872 printf ("%sxmont2", first ? "" : "|"), first = 0;
12873 if (mask & ELF_SPARC_HWCAP2_NSEC)
12874 printf ("%snsec", first ? "" : "|"), first = 0;
12875 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12876 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12877 if (mask & ELF_SPARC_HWCAP2_FJDES)
12878 printf ("%sfjdes", first ? "" : "|"), first = 0;
12879 if (mask & ELF_SPARC_HWCAP2_FJAES)
12880 printf ("%sfjaes", first ? "" : "|"), first = 0;
12881 }
12882 else
071436c6
NC		 12883 fputc ('0', stdout);
12884 fputc ('\n', stdout);
3d68f91c
JM		 12885}
12886
9e8c70f9 12887static unsigned char *
f6f0e17b
NC		 12888display_sparc_gnu_attribute (unsigned char * p,
12889 int tag,
12890 const unsigned char * const end)
9e8c70f9 12891{
3d68f91c
JM		 12892 unsigned int len;
12893 int val;
12894
9e8c70f9
DM		 12895 if (tag == Tag_GNU_Sparc_HWCAPS)
12896 {
f6f0e17b 12897 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12898 p += len;
12899 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12900 display_sparc_hwcaps (val);
12901 return p;
3d68f91c
JM		 12902 }
12903 if (tag == Tag_GNU_Sparc_HWCAPS2)
12904 {
12905 val = read_uleb128 (p, &len, end);
12906 p += len;
12907 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12908 display_sparc_hwcaps2 (val);
12909 return p;
12910 }
9e8c70f9 12911
f6f0e17b 12912 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12913}
12914
351cdf24
MF		 12915static void
12916print_mips_fp_abi_value (int val)
12917{
12918 switch (val)
12919 {
12920 case Val_GNU_MIPS_ABI_FP_ANY:
12921 printf (_("Hard or soft float\n"));
12922 break;
12923 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12924 printf (_("Hard float (double precision)\n"));
12925 break;
12926 case Val_GNU_MIPS_ABI_FP_SINGLE:
12927 printf (_("Hard float (single precision)\n"));
12928 break;
12929 case Val_GNU_MIPS_ABI_FP_SOFT:
12930 printf (_("Soft float\n"));
12931 break;
12932 case Val_GNU_MIPS_ABI_FP_OLD_64:
12933 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12934 break;
12935 case Val_GNU_MIPS_ABI_FP_XX:
12936 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12937 break;
12938 case Val_GNU_MIPS_ABI_FP_64:
12939 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12940 break;
12941 case Val_GNU_MIPS_ABI_FP_64A:
12942 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12943 break;
12944 default:
12945 printf ("??? (%d)\n", val);
12946 break;
12947 }
12948}
12949
2cf19d5c 12950static unsigned char *
f6f0e17b
NC		 12951display_mips_gnu_attribute (unsigned char * p,
12952 int tag,
12953 const unsigned char * const end)
2cf19d5c 12954{
2cf19d5c
JM		 12955 if (tag == Tag_GNU_MIPS_ABI_FP)
12956 {
f6f0e17b
NC		 12957 unsigned int len;
12958 int val;
12959
12960 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12961 p += len;
12962 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12963
351cdf24
MF		 12964 print_mips_fp_abi_value (val);
12965
2cf19d5c
JM		 12966 return p;
12967 }
12968
a9f58168
CF		 12969 if (tag == Tag_GNU_MIPS_ABI_MSA)
12970 {
12971 unsigned int len;
12972 int val;
12973
12974 val = read_uleb128 (p, &len, end);
12975 p += len;
12976 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12977
12978 switch (val)
12979 {
12980 case Val_GNU_MIPS_ABI_MSA_ANY:
12981 printf (_("Any MSA or not\n"));
12982 break;
12983 case Val_GNU_MIPS_ABI_MSA_128:
12984 printf (_("128-bit MSA\n"));
12985 break;
12986 default:
12987 printf ("??? (%d)\n", val);
12988 break;
12989 }
12990 return p;
12991 }
12992
f6f0e17b 12993 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12994}
12995
59e6276b 12996static unsigned char *
f6f0e17b
NC		 12997display_tic6x_attribute (unsigned char * p,
12998 const unsigned char * const end)
59e6276b
JM		 12999{
13000 int tag;
13001 unsigned int len;
13002 int val;
13003
f6f0e17b 13004 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13005 p += len;
13006
13007 switch (tag)
13008 {
75fa6dc1 13009 case Tag_ISA:
f6f0e17b 13010 val = read_uleb128 (p, &len, end);
59e6276b 13011 p += len;
75fa6dc1 13012 printf (" Tag_ISA: ");
59e6276b
JM		 13013
13014 switch (val)
13015 {
75fa6dc1 13016 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13017 printf (_("None\n"));
13018 break;
75fa6dc1 13019 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13020 printf ("C62x\n");
13021 break;
75fa6dc1 13022 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13023 printf ("C67x\n");
13024 break;
75fa6dc1 13025 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13026 printf ("C67x+\n");
13027 break;
75fa6dc1 13028 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13029 printf ("C64x\n");
13030 break;
75fa6dc1 13031 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13032 printf ("C64x+\n");
13033 break;
75fa6dc1 13034 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13035 printf ("C674x\n");
13036 break;
13037 default:
13038 printf ("??? (%d)\n", val);
13039 break;
13040 }
13041 return p;
13042
87779176 13043 case Tag_ABI_wchar_t:
f6f0e17b 13044 val = read_uleb128 (p, &len, end);
87779176
JM		 13045 p += len;
13046 printf (" Tag_ABI_wchar_t: ");
13047 switch (val)
13048 {
13049 case 0:
13050 printf (_("Not used\n"));
13051 break;
13052 case 1:
13053 printf (_("2 bytes\n"));
13054 break;
13055 case 2:
13056 printf (_("4 bytes\n"));
13057 break;
13058 default:
13059 printf ("??? (%d)\n", val);
13060 break;
13061 }
13062 return p;
13063
13064 case Tag_ABI_stack_align_needed:
f6f0e17b 13065 val = read_uleb128 (p, &len, end);
87779176
JM		 13066 p += len;
13067 printf (" Tag_ABI_stack_align_needed: ");
13068 switch (val)
13069 {
13070 case 0:
13071 printf (_("8-byte\n"));
13072 break;
13073 case 1:
13074 printf (_("16-byte\n"));
13075 break;
13076 default:
13077 printf ("??? (%d)\n", val);
13078 break;
13079 }
13080 return p;
13081
13082 case Tag_ABI_stack_align_preserved:
f6f0e17b 13083 val = read_uleb128 (p, &len, end);
87779176
JM		 13084 p += len;
13085 printf (" Tag_ABI_stack_align_preserved: ");
13086 switch (val)
13087 {
13088 case 0:
13089 printf (_("8-byte\n"));
13090 break;
13091 case 1:
13092 printf (_("16-byte\n"));
13093 break;
13094 default:
13095 printf ("??? (%d)\n", val);
13096 break;
13097 }
13098 return p;
13099
b5593623 13100 case Tag_ABI_DSBT:
f6f0e17b 13101 val = read_uleb128 (p, &len, end);
b5593623
JM		 13102 p += len;
13103 printf (" Tag_ABI_DSBT: ");
13104 switch (val)
13105 {
13106 case 0:
13107 printf (_("DSBT addressing not used\n"));
13108 break;
13109 case 1:
13110 printf (_("DSBT addressing used\n"));
13111 break;
13112 default:
13113 printf ("??? (%d)\n", val);
13114 break;
13115 }
13116 return p;
13117
87779176 13118 case Tag_ABI_PID:
f6f0e17b 13119 val = read_uleb128 (p, &len, end);
87779176
JM		 13120 p += len;
13121 printf (" Tag_ABI_PID: ");
13122 switch (val)
13123 {
13124 case 0:
13125 printf (_("Data addressing position-dependent\n"));
13126 break;
13127 case 1:
13128 printf (_("Data addressing position-independent, GOT near DP\n"));
13129 break;
13130 case 2:
13131 printf (_("Data addressing position-independent, GOT far from DP\n"));
13132 break;
13133 default:
13134 printf ("??? (%d)\n", val);
13135 break;
13136 }
13137 return p;
13138
13139 case Tag_ABI_PIC:
f6f0e17b 13140 val = read_uleb128 (p, &len, end);
87779176
JM		 13141 p += len;
13142 printf (" Tag_ABI_PIC: ");
13143 switch (val)
13144 {
13145 case 0:
13146 printf (_("Code addressing position-dependent\n"));
13147 break;
13148 case 1:
13149 printf (_("Code addressing position-independent\n"));
13150 break;
13151 default:
13152 printf ("??? (%d)\n", val);
13153 break;
13154 }
13155 return p;
13156
13157 case Tag_ABI_array_object_alignment:
f6f0e17b 13158 val = read_uleb128 (p, &len, end);
87779176
JM		 13159 p += len;
13160 printf (" Tag_ABI_array_object_alignment: ");
13161 switch (val)
13162 {
13163 case 0:
13164 printf (_("8-byte\n"));
13165 break;
13166 case 1:
13167 printf (_("4-byte\n"));
13168 break;
13169 case 2:
13170 printf (_("16-byte\n"));
13171 break;
13172 default:
13173 printf ("??? (%d)\n", val);
13174 break;
13175 }
13176 return p;
13177
13178 case Tag_ABI_array_object_align_expected:
f6f0e17b 13179 val = read_uleb128 (p, &len, end);
87779176
JM		 13180 p += len;
13181 printf (" Tag_ABI_array_object_align_expected: ");
13182 switch (val)
13183 {
13184 case 0:
13185 printf (_("8-byte\n"));
13186 break;
13187 case 1:
13188 printf (_("4-byte\n"));
13189 break;
13190 case 2:
13191 printf (_("16-byte\n"));
13192 break;
13193 default:
13194 printf ("??? (%d)\n", val);
13195 break;
13196 }
13197 return p;
13198
3cbd1c06 13199 case Tag_ABI_compatibility:
071436c6 13200 {
071436c6
NC		 13201 val = read_uleb128 (p, &len, end);
13202 p += len;
13203 printf (" Tag_ABI_compatibility: ");
071436c6 13204 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13205 if (p < end - 1)
13206 {
13207 size_t maxlen = (end - p) - 1;
13208
13209 print_symbol ((int) maxlen, (const char *) p);
13210 p += strnlen ((char *) p, maxlen) + 1;
13211 }
13212 else
13213 {
13214 printf (_("<corrupt>"));
13215 p = (unsigned char *) end;
13216 }
071436c6 13217 putchar ('\n');
071436c6
NC		 13218 return p;
13219 }
87779176
JM		 13220
13221 case Tag_ABI_conformance:
071436c6 13222 {
4082ef84
NC		 13223 printf (" Tag_ABI_conformance: \"");
13224 if (p < end - 1)
13225 {
13226 size_t maxlen = (end - p) - 1;
071436c6 13227
4082ef84
NC		 13228 print_symbol ((int) maxlen, (const char *) p);
13229 p += strnlen ((char *) p, maxlen) + 1;
13230 }
13231 else
13232 {
13233 printf (_("<corrupt>"));
13234 p = (unsigned char *) end;
13235 }
071436c6 13236 printf ("\"\n");
071436c6
NC		 13237 return p;
13238 }
59e6276b
JM		 13239 }
13240
f6f0e17b
NC		 13241 return display_tag_value (tag, p, end);
13242}
59e6276b 13243
f6f0e17b
NC		 13244static void
13245display_raw_attribute (unsigned char * p, unsigned char * end)
13246{
13247 unsigned long addr = 0;
13248 size_t bytes = end - p;
13249
e0a31db1 13250 assert (end > p);
f6f0e17b 13251 while (bytes)
87779176 13252 {
f6f0e17b
NC		 13253 int j;
13254 int k;
13255 int lbytes = (bytes > 16 ? 16 : bytes);
13256
13257 printf (" 0x%8.8lx ", addr);
13258
13259 for (j = 0; j < 16; j++)
13260 {
13261 if (j < lbytes)
13262 printf ("%2.2x", p[j]);
13263 else
13264 printf (" ");
13265
13266 if ((j & 3) == 3)
13267 printf (" ");
13268 }
13269
13270 for (j = 0; j < lbytes; j++)
13271 {
13272 k = p[j];
13273 if (k >= ' ' && k < 0x7f)
13274 printf ("%c", k);
13275 else
13276 printf (".");
13277 }
13278
13279 putchar ('\n');
13280
13281 p += lbytes;
13282 bytes -= lbytes;
13283 addr += lbytes;
87779176 13284 }
59e6276b 13285
f6f0e17b 13286 putchar ('\n');
59e6276b
JM		 13287}
13288
13761a11
NC		 13289static unsigned char *
13290display_msp430x_attribute (unsigned char * p,
13291 const unsigned char * const end)
13292{
13293 unsigned int len;
13294 int val;
13295 int tag;
13296
13297 tag = read_uleb128 (p, & len, end);
13298 p += len;
0b4362b0 13299
13761a11
NC		 13300 switch (tag)
13301 {
13302 case OFBA_MSPABI_Tag_ISA:
13303 val = read_uleb128 (p, &len, end);
13304 p += len;
13305 printf (" Tag_ISA: ");
13306 switch (val)
13307 {
13308 case 0: printf (_("None\n")); break;
13309 case 1: printf (_("MSP430\n")); break;
13310 case 2: printf (_("MSP430X\n")); break;
13311 default: printf ("??? (%d)\n", val); break;
13312 }
13313 break;
13314
13315 case OFBA_MSPABI_Tag_Code_Model:
13316 val = read_uleb128 (p, &len, end);
13317 p += len;
13318 printf (" Tag_Code_Model: ");
13319 switch (val)
13320 {
13321 case 0: printf (_("None\n")); break;
13322 case 1: printf (_("Small\n")); break;
13323 case 2: printf (_("Large\n")); break;
13324 default: printf ("??? (%d)\n", val); break;
13325 }
13326 break;
13327
13328 case OFBA_MSPABI_Tag_Data_Model:
13329 val = read_uleb128 (p, &len, end);
13330 p += len;
13331 printf (" Tag_Data_Model: ");
13332 switch (val)
13333 {
13334 case 0: printf (_("None\n")); break;
13335 case 1: printf (_("Small\n")); break;
13336 case 2: printf (_("Large\n")); break;
13337 case 3: printf (_("Restricted Large\n")); break;
13338 default: printf ("??? (%d)\n", val); break;
13339 }
13340 break;
13341
13342 default:
13343 printf (_(" <unknown tag %d>: "), tag);
13344
13345 if (tag & 1)
13346 {
071436c6 13347 putchar ('"');
4082ef84
NC		 13348 if (p < end - 1)
13349 {
13350 size_t maxlen = (end - p) - 1;
13351
13352 print_symbol ((int) maxlen, (const char *) p);
13353 p += strnlen ((char *) p, maxlen) + 1;
13354 }
13355 else
13356 {
13357 printf (_("<corrupt>"));
13358 p = (unsigned char *) end;
13359 }
071436c6 13360 printf ("\"\n");
13761a11
NC		 13361 }
13362 else
13363 {
13364 val = read_uleb128 (p, &len, end);
13365 p += len;
13366 printf ("%d (0x%x)\n", val, val);
13367 }
13368 break;
13369 }
13370
4082ef84 13371 assert (p <= end);
13761a11
NC		 13372 return p;
13373}
13374
11c1ff18 13375static int
60bca95a
NC		 13376process_attributes (FILE * file,
13377 const char * public_name,
104d59d1 13378 unsigned int proc_type,
f6f0e17b
NC		 13379 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13380 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13381{
2cf0635d 13382 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13383 unsigned i;
13384
13385 /* Find the section header so that we get the size. */
13386 for (i = 0, sect = section_headers;
13387 i < elf_header.e_shnum;
13388 i++, sect++)
13389 {
071436c6
NC		 13390 unsigned char * contents;
13391 unsigned char * p;
13392
104d59d1 13393 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13394 continue;
13395
3f5e193b
NC		 13396 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13397 sect->sh_size, _("attributes"));
60bca95a 13398 if (contents == NULL)
11c1ff18 13399 continue;
60bca95a 13400
11c1ff18
PB		 13401 p = contents;
13402 if (*p == 'A')
13403 {
071436c6
NC		 13404 bfd_vma section_len;
13405
13406 section_len = sect->sh_size - 1;
11c1ff18 13407 p++;
60bca95a 13408
071436c6 13409 while (section_len > 0)
11c1ff18 13410 {
071436c6 13411 bfd_vma attr_len;
e9847026 13412 unsigned int namelen;
11c1ff18 13413 bfd_boolean public_section;
104d59d1 13414 bfd_boolean gnu_section;
11c1ff18 13415
071436c6 13416 if (section_len <= 4)
e0a31db1
NC		 13417 {
13418 error (_("Tag section ends prematurely\n"));
13419 break;
13420 }
071436c6 13421 attr_len = byte_get (p, 4);
11c1ff18 13422 p += 4;
60bca95a 13423
071436c6 13424 if (attr_len > section_len)
11c1ff18 13425 {
071436c6
NC		 13426 error (_("Bad attribute length (%u > %u)\n"),
13427 (unsigned) attr_len, (unsigned) section_len);
13428 attr_len = section_len;
11c1ff18 13429 }
74e1a04b 13430 /* PR 17531: file: 001-101425-0.004 */
071436c6 13431 else if (attr_len < 5)
74e1a04b 13432 {
071436c6 13433 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13434 break;
13435 }
e9847026 13436
071436c6
NC		 13437 section_len -= attr_len;
13438 attr_len -= 4;
13439
13440 namelen = strnlen ((char *) p, attr_len) + 1;
13441 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13442 {
13443 error (_("Corrupt attribute section name\n"));
13444 break;
13445 }
13446
071436c6
NC		 13447 printf (_("Attribute Section: "));
13448 print_symbol (INT_MAX, (const char *) p);
13449 putchar ('\n');
60bca95a
NC		 13450
13451 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13452 public_section = TRUE;
13453 else
13454 public_section = FALSE;
60bca95a
NC		 13455
13456 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13457 gnu_section = TRUE;
13458 else
13459 gnu_section = FALSE;
60bca95a 13460
11c1ff18 13461 p += namelen;
071436c6 13462 attr_len -= namelen;
e0a31db1 13463
071436c6 13464 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13465 {
e0a31db1 13466 int tag;
11c1ff18
PB		 13467 int val;
13468 bfd_vma size;
071436c6 13469 unsigned char * end;
60bca95a 13470
e0a31db1 13471 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13472 if (attr_len < 6)
e0a31db1
NC		 13473 {
13474 error (_("Unused bytes at end of section\n"));
13475 section_len = 0;
13476 break;
13477 }
13478
13479 tag = *(p++);
11c1ff18 13480 size = byte_get (p, 4);
071436c6 13481 if (size > attr_len)
11c1ff18 13482 {
e9847026 13483 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13484 (unsigned) size, (unsigned) attr_len);
13485 size = attr_len;
11c1ff18 13486 }
e0a31db1
NC		 13487 /* PR binutils/17531: Safe handling of corrupt files. */
13488 if (size < 6)
13489 {
13490 error (_("Bad subsection length (%u < 6)\n"),
13491 (unsigned) size);
13492 section_len = 0;
13493 break;
13494 }
60bca95a 13495
071436c6 13496 attr_len -= size;
11c1ff18 13497 end = p + size - 1;
071436c6 13498 assert (end <= contents + sect->sh_size);
11c1ff18 13499 p += 4;
60bca95a 13500
11c1ff18
PB		 13501 switch (tag)
13502 {
13503 case 1:
2b692964 13504 printf (_("File Attributes\n"));
11c1ff18
PB		 13505 break;
13506 case 2:
2b692964 13507 printf (_("Section Attributes:"));
11c1ff18
PB		 13508 goto do_numlist;
13509 case 3:
2b692964 13510 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13511 do_numlist:
13512 for (;;)
13513 {
91d6fa6a 13514 unsigned int j;
60bca95a 13515
f6f0e17b 13516 val = read_uleb128 (p, &j, end);
91d6fa6a 13517 p += j;
11c1ff18
PB		 13518 if (val == 0)
13519 break;
13520 printf (" %d", val);
13521 }
13522 printf ("\n");
13523 break;
13524 default:
2b692964 13525 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13526 public_section = FALSE;
13527 break;
13528 }
60bca95a 13529
071436c6 13530 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13531 {
13532 while (p < end)
f6f0e17b 13533 p = display_pub_attribute (p, end);
071436c6 13534 assert (p <= end);
104d59d1 13535 }
071436c6 13536 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13537 {
13538 while (p < end)
13539 p = display_gnu_attribute (p,
f6f0e17b
NC		 13540 display_proc_gnu_attribute,
13541 end);
071436c6 13542 assert (p <= end);
11c1ff18 13543 }
071436c6 13544 else if (p < end)
11c1ff18 13545 {
071436c6 13546 printf (_(" Unknown attribute:\n"));
f6f0e17b 13547 display_raw_attribute (p, end);
11c1ff18
PB		 13548 p = end;
13549 }
071436c6
NC		 13550 else
13551 attr_len = 0;
11c1ff18
PB		 13552 }
13553 }
13554 }
13555 else
e9847026 13556 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13557
60bca95a 13558 free (contents);
11c1ff18
PB		 13559 }
13560 return 1;
13561}
13562
104d59d1 13563static int
2cf0635d 13564process_arm_specific (FILE * file)
104d59d1
JM		 13565{
13566 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13567 display_arm_attribute, NULL);
13568}
13569
34c8bcba 13570static int
2cf0635d 13571process_power_specific (FILE * file)
34c8bcba
JM		 13572{
13573 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13574 display_power_gnu_attribute);
13575}
13576
9e8c70f9
DM		 13577static int
13578process_sparc_specific (FILE * file)
13579{
13580 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13581 display_sparc_gnu_attribute);
13582}
13583
59e6276b
JM		 13584static int
13585process_tic6x_specific (FILE * file)
13586{
13587 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13588 display_tic6x_attribute, NULL);
13589}
13590
13761a11
NC		 13591static int
13592process_msp430x_specific (FILE * file)
13593{
13594 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13595 display_msp430x_attribute, NULL);
13596}
13597
ccb4c951
RS		 13598/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13599 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13600 and return the VMA of the next entry, or -1 if there was a problem.
13601 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13602
13603static bfd_vma
82b1b41b
NC		 13604print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13605 unsigned char * data_end)
ccb4c951
RS		 13606{
13607 printf (" ");
13608 print_vma (addr, LONG_HEX);
13609 printf (" ");
13610 if (addr < pltgot + 0xfff0)
13611 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13612 else
13613 printf ("%10s", "");
13614 printf (" ");
13615 if (data == NULL)
2b692964 13616 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13617 else
13618 {
13619 bfd_vma entry;
82b1b41b 13620 unsigned char * from = data + addr - pltgot;
ccb4c951 13621
82b1b41b
NC		 13622 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13623 {
13624 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13625 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13626 return (bfd_vma) -1;
13627 }
13628 else
13629 {
13630 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13631 print_vma (entry, LONG_HEX);
13632 }
ccb4c951
RS		 13633 }
13634 return addr + (is_32bit_elf ? 4 : 8);
13635}
13636
861fb55a
DJ		 13637/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13638 PLTGOT. Print the Address and Initial fields of an entry at VMA
13639 ADDR and return the VMA of the next entry. */
13640
13641static bfd_vma
2cf0635d 13642print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13643{
13644 printf (" ");
13645 print_vma (addr, LONG_HEX);
13646 printf (" ");
13647 if (data == NULL)
2b692964 13648 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13649 else
13650 {
13651 bfd_vma entry;
13652
13653 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13654 print_vma (entry, LONG_HEX);
13655 }
13656 return addr + (is_32bit_elf ? 4 : 8);
13657}
13658
351cdf24
MF		 13659static void
13660print_mips_ases (unsigned int mask)
13661{
13662 if (mask & AFL_ASE_DSP)
13663 fputs ("\n\tDSP ASE", stdout);
13664 if (mask & AFL_ASE_DSPR2)
13665 fputs ("\n\tDSP R2 ASE", stdout);
13666 if (mask & AFL_ASE_EVA)
13667 fputs ("\n\tEnhanced VA Scheme", stdout);
13668 if (mask & AFL_ASE_MCU)
13669 fputs ("\n\tMCU (MicroController) ASE", stdout);
13670 if (mask & AFL_ASE_MDMX)
13671 fputs ("\n\tMDMX ASE", stdout);
13672 if (mask & AFL_ASE_MIPS3D)
13673 fputs ("\n\tMIPS-3D ASE", stdout);
13674 if (mask & AFL_ASE_MT)
13675 fputs ("\n\tMT ASE", stdout);
13676 if (mask & AFL_ASE_SMARTMIPS)
13677 fputs ("\n\tSmartMIPS ASE", stdout);
13678 if (mask & AFL_ASE_VIRT)
13679 fputs ("\n\tVZ ASE", stdout);
13680 if (mask & AFL_ASE_MSA)
13681 fputs ("\n\tMSA ASE", stdout);
13682 if (mask & AFL_ASE_MIPS16)
13683 fputs ("\n\tMIPS16 ASE", stdout);
13684 if (mask & AFL_ASE_MICROMIPS)
13685 fputs ("\n\tMICROMIPS ASE", stdout);
13686 if (mask & AFL_ASE_XPA)
13687 fputs ("\n\tXPA ASE", stdout);
13688 if (mask == 0)
13689 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13690 else if ((mask & ~AFL_ASE_MASK) != 0)
13691 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13692}
13693
13694static void
13695print_mips_isa_ext (unsigned int isa_ext)
13696{
13697 switch (isa_ext)
13698 {
13699 case 0:
13700 fputs (_("None"), stdout);
13701 break;
13702 case AFL_EXT_XLR:
13703 fputs ("RMI XLR", stdout);
13704 break;
2c629856
N		 13705 case AFL_EXT_OCTEON3:
13706 fputs ("Cavium Networks Octeon3", stdout);
13707 break;
351cdf24
MF		 13708 case AFL_EXT_OCTEON2:
13709 fputs ("Cavium Networks Octeon2", stdout);
13710 break;
13711 case AFL_EXT_OCTEONP:
13712 fputs ("Cavium Networks OcteonP", stdout);
13713 break;
13714 case AFL_EXT_LOONGSON_3A:
13715 fputs ("Loongson 3A", stdout);
13716 break;
13717 case AFL_EXT_OCTEON:
13718 fputs ("Cavium Networks Octeon", stdout);
13719 break;
13720 case AFL_EXT_5900:
13721 fputs ("Toshiba R5900", stdout);
13722 break;
13723 case AFL_EXT_4650:
13724 fputs ("MIPS R4650", stdout);
13725 break;
13726 case AFL_EXT_4010:
13727 fputs ("LSI R4010", stdout);
13728 break;
13729 case AFL_EXT_4100:
13730 fputs ("NEC VR4100", stdout);
13731 break;
13732 case AFL_EXT_3900:
13733 fputs ("Toshiba R3900", stdout);
13734 break;
13735 case AFL_EXT_10000:
13736 fputs ("MIPS R10000", stdout);
13737 break;
13738 case AFL_EXT_SB1:
13739 fputs ("Broadcom SB-1", stdout);
13740 break;
13741 case AFL_EXT_4111:
13742 fputs ("NEC VR4111/VR4181", stdout);
13743 break;
13744 case AFL_EXT_4120:
13745 fputs ("NEC VR4120", stdout);
13746 break;
13747 case AFL_EXT_5400:
13748 fputs ("NEC VR5400", stdout);
13749 break;
13750 case AFL_EXT_5500:
13751 fputs ("NEC VR5500", stdout);
13752 break;
13753 case AFL_EXT_LOONGSON_2E:
13754 fputs ("ST Microelectronics Loongson 2E", stdout);
13755 break;
13756 case AFL_EXT_LOONGSON_2F:
13757 fputs ("ST Microelectronics Loongson 2F", stdout);
13758 break;
13759 default:
00ac7aa0 13760 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13761 }
13762}
13763
13764static int
13765get_mips_reg_size (int reg_size)
13766{
13767 return (reg_size == AFL_REG_NONE) ? 0
13768 : (reg_size == AFL_REG_32) ? 32
13769 : (reg_size == AFL_REG_64) ? 64
13770 : (reg_size == AFL_REG_128) ? 128
13771 : -1;
13772}
13773
19e6b90e 13774static int
2cf0635d 13775process_mips_specific (FILE * file)
5b18a4bc 13776{
2cf0635d 13777 Elf_Internal_Dyn * entry;
351cdf24 13778 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13779 size_t liblist_offset = 0;
13780 size_t liblistno = 0;
13781 size_t conflictsno = 0;
13782 size_t options_offset = 0;
13783 size_t conflicts_offset = 0;
861fb55a
DJ		 13784 size_t pltrelsz = 0;
13785 size_t pltrel = 0;
ccb4c951 13786 bfd_vma pltgot = 0;
861fb55a
DJ		 13787 bfd_vma mips_pltgot = 0;
13788 bfd_vma jmprel = 0;
ccb4c951
RS		 13789 bfd_vma local_gotno = 0;
13790 bfd_vma gotsym = 0;
13791 bfd_vma symtabno = 0;
103f02d3 13792
2cf19d5c
JM		 13793 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13794 display_mips_gnu_attribute);
13795
351cdf24
MF		 13796 sect = find_section (".MIPS.abiflags");
13797
13798 if (sect != NULL)
13799 {
13800 Elf_External_ABIFlags_v0 *abiflags_ext;
13801 Elf_Internal_ABIFlags_v0 abiflags_in;
13802
13803 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13804 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13805 else
13806 {
13807 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13808 sect->sh_size, _("MIPS ABI Flags section"));
13809 if (abiflags_ext)
13810 {
13811 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13812 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13813 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13814 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13815 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13816 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13817 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13818 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13819 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13820 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13821 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13822
13823 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13824 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13825 if (abiflags_in.isa_rev > 1)
13826 printf ("r%d", abiflags_in.isa_rev);
13827 printf ("\nGPR size: %d",
13828 get_mips_reg_size (abiflags_in.gpr_size));
13829 printf ("\nCPR1 size: %d",
13830 get_mips_reg_size (abiflags_in.cpr1_size));
13831 printf ("\nCPR2 size: %d",
13832 get_mips_reg_size (abiflags_in.cpr2_size));
13833 fputs ("\nFP ABI: ", stdout);
13834 print_mips_fp_abi_value (abiflags_in.fp_abi);
13835 fputs ("ISA Extension: ", stdout);
13836 print_mips_isa_ext (abiflags_in.isa_ext);
13837 fputs ("\nASEs:", stdout);
13838 print_mips_ases (abiflags_in.ases);
13839 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13840 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13841 fputc ('\n', stdout);
13842 free (abiflags_ext);
13843 }
13844 }
13845 }
13846
19e6b90e
L		 13847 /* We have a lot of special sections. Thanks SGI! */
13848 if (dynamic_section == NULL)
13849 /* No information available. */
13850 return 0;
252b5132 13851
071436c6
NC		 13852 for (entry = dynamic_section;
13853 /* PR 17531 file: 012-50589-0.004. */
13854 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13855 ++entry)
252b5132
RH		 13856 switch (entry->d_tag)
13857 {
13858 case DT_MIPS_LIBLIST:
d93f0186
NC		 13859 liblist_offset
13860 = offset_from_vma (file, entry->d_un.d_val,
13861 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13862 break;
13863 case DT_MIPS_LIBLISTNO:
13864 liblistno = entry->d_un.d_val;
13865 break;
13866 case DT_MIPS_OPTIONS:
d93f0186 13867 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13868 break;
13869 case DT_MIPS_CONFLICT:
d93f0186
NC		 13870 conflicts_offset
13871 = offset_from_vma (file, entry->d_un.d_val,
13872 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13873 break;
13874 case DT_MIPS_CONFLICTNO:
13875 conflictsno = entry->d_un.d_val;
13876 break;
ccb4c951 13877 case DT_PLTGOT:
861fb55a
DJ		 13878 pltgot = entry->d_un.d_ptr;
13879 break;
ccb4c951
RS		 13880 case DT_MIPS_LOCAL_GOTNO:
13881 local_gotno = entry->d_un.d_val;
13882 break;
13883 case DT_MIPS_GOTSYM:
13884 gotsym = entry->d_un.d_val;
13885 break;
13886 case DT_MIPS_SYMTABNO:
13887 symtabno = entry->d_un.d_val;
13888 break;
861fb55a
DJ		 13889 case DT_MIPS_PLTGOT:
13890 mips_pltgot = entry->d_un.d_ptr;
13891 break;
13892 case DT_PLTREL:
13893 pltrel = entry->d_un.d_val;
13894 break;
13895 case DT_PLTRELSZ:
13896 pltrelsz = entry->d_un.d_val;
13897 break;
13898 case DT_JMPREL:
13899 jmprel = entry->d_un.d_ptr;
13900 break;
252b5132
RH		 13901 default:
13902 break;
13903 }
13904
13905 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13906 {
2cf0635d 13907 Elf32_External_Lib * elib;
252b5132
RH		 13908 size_t cnt;
13909
3f5e193b
NC		 13910 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13911 liblistno,
13912 sizeof (Elf32_External_Lib),
9cf03b7e 13913 _("liblist section data"));
a6e9f9df 13914 if (elib)
252b5132 13915 {
2b692964 13916 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13917 (unsigned long) liblistno);
2b692964 13918 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13919 stdout);
13920
13921 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13922 {
a6e9f9df 13923 Elf32_Lib liblist;
91d6fa6a 13924 time_t atime;
a6e9f9df 13925 char timebuf[20];
2cf0635d 13926 struct tm * tmp;
a6e9f9df
AM		 13927
13928 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13929 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13930 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13931 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13932 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13933
91d6fa6a 13934 tmp = gmtime (&atime);
e9e44622
JJ		 13935 snprintf (timebuf, sizeof (timebuf),
13936 "%04u-%02u-%02uT%02u:%02u:%02u",
13937 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13938 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13939
31104126 13940 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13941 if (VALID_DYNAMIC_NAME (liblist.l_name))
13942 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13943 else
2b692964 13944 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13945 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13946 liblist.l_version);
a6e9f9df
AM		 13947
13948 if (liblist.l_flags == 0)
2b692964 13949 puts (_(" NONE"));
a6e9f9df
AM		 13950 else
13951 {
13952 static const struct
252b5132 13953 {
2cf0635d 13954 const char * name;
a6e9f9df 13955 int bit;
252b5132 13956 }
a6e9f9df
AM		 13957 l_flags_vals[] =
13958 {
13959 { " EXACT_MATCH", LL_EXACT_MATCH },
13960 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13961 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13962 { " EXPORTS", LL_EXPORTS },
13963 { " DELAY_LOAD", LL_DELAY_LOAD },
13964 { " DELTA", LL_DELTA }
13965 };
13966 int flags = liblist.l_flags;
13967 size_t fcnt;
13968
60bca95a 13969 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13970 if ((flags & l_flags_vals[fcnt].bit) != 0)
13971 {
13972 fputs (l_flags_vals[fcnt].name, stdout);
13973 flags ^= l_flags_vals[fcnt].bit;
13974 }
13975 if (flags != 0)
13976 printf (" %#x", (unsigned int) flags);
252b5132 13977
a6e9f9df
AM		 13978 puts ("");
13979 }
252b5132 13980 }
252b5132 13981
a6e9f9df
AM		 13982 free (elib);
13983 }
252b5132
RH		 13984 }
13985
13986 if (options_offset != 0)
13987 {
2cf0635d 13988 Elf_External_Options * eopt;
2cf0635d
NC		 13989 Elf_Internal_Options * iopt;
13990 Elf_Internal_Options * option;
252b5132
RH		 13991 size_t offset;
13992 int cnt;
351cdf24 13993 sect = section_headers;
252b5132
RH		 13994
13995 /* Find the section header so that we get the size. */
071436c6 13996 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 13997 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 13998 if (sect == NULL)
13999 {
14000 error (_("No MIPS_OPTIONS header found\n"));
14001 return 0;
14002 }
252b5132 14003
3f5e193b
NC		 14004 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14005 sect->sh_size, _("options"));
a6e9f9df 14006 if (eopt)
252b5132 14007 {
3f5e193b
NC		 14008 iopt = (Elf_Internal_Options *)
14009 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14010 if (iopt == NULL)
14011 {
8b73c356 14012 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14013 return 0;
14014 }
76da6bbe 14015
a6e9f9df
AM		 14016 offset = cnt = 0;
14017 option = iopt;
252b5132 14018
82b1b41b 14019 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14020 {
2cf0635d 14021 Elf_External_Options * eoption;
252b5132 14022
a6e9f9df 14023 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14024
a6e9f9df
AM		 14025 option->kind = BYTE_GET (eoption->kind);
14026 option->size = BYTE_GET (eoption->size);
14027 option->section = BYTE_GET (eoption->section);
14028 option->info = BYTE_GET (eoption->info);
76da6bbe 14029
82b1b41b
NC		 14030 /* PR 17531: file: ffa0fa3b. */
14031 if (option->size < sizeof (* eopt)
14032 || offset + option->size > sect->sh_size)
14033 {
55325047
NC		 14034 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14035 return 0;
82b1b41b 14036 }
a6e9f9df 14037 offset += option->size;
82b1b41b 14038
a6e9f9df
AM		 14039 ++option;
14040 ++cnt;
14041 }
252b5132 14042
a6e9f9df 14043 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14044 printable_section_name (sect), cnt);
76da6bbe 14045
a6e9f9df 14046 option = iopt;
82b1b41b 14047 offset = 0;
252b5132 14048
a6e9f9df 14049 while (cnt-- > 0)
252b5132 14050 {
a6e9f9df
AM		 14051 size_t len;
14052
14053 switch (option->kind)
252b5132 14054 {
a6e9f9df
AM		 14055 case ODK_NULL:
14056 /* This shouldn't happen. */
14057 printf (" NULL %d %lx", option->section, option->info);
14058 break;
14059 case ODK_REGINFO:
14060 printf (" REGINFO ");
14061 if (elf_header.e_machine == EM_MIPS)
14062 {
14063 /* 32bit form. */
2cf0635d 14064 Elf32_External_RegInfo * ereg;
b34976b6 14065 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14066
14067 ereg = (Elf32_External_RegInfo *) (option + 1);
14068 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14069 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14070 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14071 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14072 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14073 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14074
14075 printf ("GPR %08lx GP 0x%lx\n",
14076 reginfo.ri_gprmask,
14077 (unsigned long) reginfo.ri_gp_value);
14078 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14079 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14080 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14081 }
14082 else
14083 {
14084 /* 64 bit form. */
2cf0635d 14085 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14086 Elf64_Internal_RegInfo reginfo;
14087
14088 ereg = (Elf64_External_RegInfo *) (option + 1);
14089 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14090 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14091 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14092 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14093 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14094 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14095
14096 printf ("GPR %08lx GP 0x",
14097 reginfo.ri_gprmask);
14098 printf_vma (reginfo.ri_gp_value);
14099 printf ("\n");
14100
14101 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14102 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14103 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14104 }
14105 ++option;
14106 continue;
14107 case ODK_EXCEPTIONS:
14108 fputs (" EXCEPTIONS fpe_min(", stdout);
14109 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14110 fputs (") fpe_max(", stdout);
14111 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14112 fputs (")", stdout);
14113
14114 if (option->info & OEX_PAGE0)
14115 fputs (" PAGE0", stdout);
14116 if (option->info & OEX_SMM)
14117 fputs (" SMM", stdout);
14118 if (option->info & OEX_FPDBUG)
14119 fputs (" FPDBUG", stdout);
14120 if (option->info & OEX_DISMISS)
14121 fputs (" DISMISS", stdout);
14122 break;
14123 case ODK_PAD:
14124 fputs (" PAD ", stdout);
14125 if (option->info & OPAD_PREFIX)
14126 fputs (" PREFIX", stdout);
14127 if (option->info & OPAD_POSTFIX)
14128 fputs (" POSTFIX", stdout);
14129 if (option->info & OPAD_SYMBOL)
14130 fputs (" SYMBOL", stdout);
14131 break;
14132 case ODK_HWPATCH:
14133 fputs (" HWPATCH ", stdout);
14134 if (option->info & OHW_R4KEOP)
14135 fputs (" R4KEOP", stdout);
14136 if (option->info & OHW_R8KPFETCH)
14137 fputs (" R8KPFETCH", stdout);
14138 if (option->info & OHW_R5KEOP)
14139 fputs (" R5KEOP", stdout);
14140 if (option->info & OHW_R5KCVTL)
14141 fputs (" R5KCVTL", stdout);
14142 break;
14143 case ODK_FILL:
14144 fputs (" FILL ", stdout);
14145 /* XXX Print content of info word? */
14146 break;
14147 case ODK_TAGS:
14148 fputs (" TAGS ", stdout);
14149 /* XXX Print content of info word? */
14150 break;
14151 case ODK_HWAND:
14152 fputs (" HWAND ", stdout);
14153 if (option->info & OHWA0_R4KEOP_CHECKED)
14154 fputs (" R4KEOP_CHECKED", stdout);
14155 if (option->info & OHWA0_R4KEOP_CLEAN)
14156 fputs (" R4KEOP_CLEAN", stdout);
14157 break;
14158 case ODK_HWOR:
14159 fputs (" HWOR ", stdout);
14160 if (option->info & OHWA0_R4KEOP_CHECKED)
14161 fputs (" R4KEOP_CHECKED", stdout);
14162 if (option->info & OHWA0_R4KEOP_CLEAN)
14163 fputs (" R4KEOP_CLEAN", stdout);
14164 break;
14165 case ODK_GP_GROUP:
14166 printf (" GP_GROUP %#06lx self-contained %#06lx",
14167 option->info & OGP_GROUP,
14168 (option->info & OGP_SELF) >> 16);
14169 break;
14170 case ODK_IDENT:
14171 printf (" IDENT %#06lx self-contained %#06lx",
14172 option->info & OGP_GROUP,
14173 (option->info & OGP_SELF) >> 16);
14174 break;
14175 default:
14176 /* This shouldn't happen. */
14177 printf (" %3d ??? %d %lx",
14178 option->kind, option->section, option->info);
14179 break;
252b5132 14180 }
a6e9f9df 14181
2cf0635d 14182 len = sizeof (* eopt);
a6e9f9df 14183 while (len < option->size)
82b1b41b
NC		 14184 {
14185 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14186
82b1b41b
NC		 14187 if (ISPRINT (datum))
14188 printf ("%c", datum);
14189 else
14190 printf ("\\%03o", datum);
14191 len ++;
14192 }
a6e9f9df 14193 fputs ("\n", stdout);
82b1b41b
NC		 14194
14195 offset += option->size;
252b5132 14196 ++option;
252b5132
RH		 14197 }
14198
a6e9f9df 14199 free (eopt);
252b5132 14200 }
252b5132
RH		 14201 }
14202
14203 if (conflicts_offset != 0 && conflictsno != 0)
14204 {
2cf0635d 14205 Elf32_Conflict * iconf;
252b5132
RH		 14206 size_t cnt;
14207
14208 if (dynamic_symbols == NULL)
14209 {
591a748a 14210 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14211 return 0;
14212 }
14213
3f5e193b 14214 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14215 if (iconf == NULL)
14216 {
8b73c356 14217 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14218 return 0;
14219 }
14220
9ea033b2 14221 if (is_32bit_elf)
252b5132 14222 {
2cf0635d 14223 Elf32_External_Conflict * econf32;
a6e9f9df 14224
3f5e193b
NC		 14225 econf32 = (Elf32_External_Conflict *)
14226 get_data (NULL, file, conflicts_offset, conflictsno,
14227 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14228 if (!econf32)
14229 return 0;
252b5132
RH		 14230
14231 for (cnt = 0; cnt < conflictsno; ++cnt)
14232 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14233
14234 free (econf32);
252b5132
RH		 14235 }
14236 else
14237 {
2cf0635d 14238 Elf64_External_Conflict * econf64;
a6e9f9df 14239
3f5e193b
NC		 14240 econf64 = (Elf64_External_Conflict *)
14241 get_data (NULL, file, conflicts_offset, conflictsno,
14242 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14243 if (!econf64)
14244 return 0;
252b5132
RH		 14245
14246 for (cnt = 0; cnt < conflictsno; ++cnt)
14247 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14248
14249 free (econf64);
252b5132
RH		 14250 }
14251
c7e7ca54
NC		 14252 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14253 (unsigned long) conflictsno);
252b5132
RH		 14254 puts (_(" Num: Index Value Name"));
14255
14256 for (cnt = 0; cnt < conflictsno; ++cnt)
14257 {
b34976b6 14258 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14259
14260 if (iconf[cnt] >= num_dynamic_syms)
14261 printf (_("<corrupt symbol index>"));
d79b3d50 14262 else
e0a31db1
NC		 14263 {
14264 Elf_Internal_Sym * psym;
14265
14266 psym = & dynamic_symbols[iconf[cnt]];
14267 print_vma (psym->st_value, FULL_HEX);
14268 putchar (' ');
14269 if (VALID_DYNAMIC_NAME (psym->st_name))
14270 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14271 else
14272 printf (_("<corrupt: %14ld>"), psym->st_name);
14273 }
31104126 14274 putchar ('\n');
252b5132
RH		 14275 }
14276
252b5132
RH		 14277 free (iconf);
14278 }
14279
ccb4c951
RS		 14280 if (pltgot != 0 && local_gotno != 0)
14281 {
91d6fa6a 14282 bfd_vma ent, local_end, global_end;
bbeee7ea 14283 size_t i, offset;
2cf0635d 14284 unsigned char * data;
82b1b41b 14285 unsigned char * data_end;
bbeee7ea 14286 int addr_size;
ccb4c951 14287
91d6fa6a 14288 ent = pltgot;
ccb4c951
RS		 14289 addr_size = (is_32bit_elf ? 4 : 8);
14290 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14291
74e1a04b
NC		 14292 /* PR binutils/17533 file: 012-111227-0.004 */
14293 if (symtabno < gotsym)
14294 {
14295 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14296 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14297 return 0;
14298 }
82b1b41b 14299
74e1a04b 14300 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14301 /* PR 17531: file: 54c91a34. */
14302 if (global_end < local_end)
14303 {
14304 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14305 return 0;
14306 }
948f632f 14307
ccb4c951 14308 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14309 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14310 global_end - pltgot, 1,
14311 _("Global Offset Table data"));
59245841
NC		 14312 if (data == NULL)
14313 return 0;
82b1b41b 14314 data_end = data + (global_end - pltgot);
59245841 14315
ccb4c951
RS		 14316 printf (_("\nPrimary GOT:\n"));
14317 printf (_(" Canonical gp value: "));
14318 print_vma (pltgot + 0x7ff0, LONG_HEX);
14319 printf ("\n\n");
14320
14321 printf (_(" Reserved entries:\n"));
14322 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14323 addr_size * 2, _("Address"), _("Access"),
14324 addr_size * 2, _("Initial"));
82b1b41b 14325 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14326 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14327 if (ent == (bfd_vma) -1)
14328 goto got_print_fail;
ccb4c951 14329 if (data
91d6fa6a 14330 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14331 >> (addr_size * 8 - 1)) != 0)
14332 {
82b1b41b 14333 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14334 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14335 if (ent == (bfd_vma) -1)
14336 goto got_print_fail;
ccb4c951
RS		 14337 }
14338 printf ("\n");
14339
91d6fa6a 14340 if (ent < local_end)
ccb4c951
RS		 14341 {
14342 printf (_(" Local entries:\n"));
cc5914eb 14343 printf (" %*s %10s %*s\n",
2b692964
NC		 14344 addr_size * 2, _("Address"), _("Access"),
14345 addr_size * 2, _("Initial"));
91d6fa6a 14346 while (ent < local_end)
ccb4c951 14347 {
82b1b41b 14348 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14349 printf ("\n");
82b1b41b
NC		 14350 if (ent == (bfd_vma) -1)
14351 goto got_print_fail;
ccb4c951
RS		 14352 }
14353 printf ("\n");
14354 }
14355
14356 if (gotsym < symtabno)
14357 {
14358 int sym_width;
14359
14360 printf (_(" Global entries:\n"));
cc5914eb 14361 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14362 addr_size * 2, _("Address"),
14363 _("Access"),
2b692964 14364 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14365 addr_size * 2, _("Sym.Val."),
14366 _("Type"),
14367 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14368 _("Ndx"), _("Name"));
0b4362b0 14369
ccb4c951 14370 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14371
ccb4c951
RS		 14372 for (i = gotsym; i < symtabno; i++)
14373 {
82b1b41b 14374 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14375 printf (" ");
e0a31db1
NC		 14376
14377 if (dynamic_symbols == NULL)
14378 printf (_("<no dynamic symbols>"));
14379 else if (i < num_dynamic_syms)
14380 {
14381 Elf_Internal_Sym * psym = dynamic_symbols + i;
14382
14383 print_vma (psym->st_value, LONG_HEX);
14384 printf (" %-7s %3s ",
14385 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14386 get_symbol_index_type (psym->st_shndx));
14387
14388 if (VALID_DYNAMIC_NAME (psym->st_name))
14389 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14390 else
14391 printf (_("<corrupt: %14ld>"), psym->st_name);
14392 }
ccb4c951 14393 else
7fc5ac57
JBG		 14394 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14395 (unsigned long) i);
e0a31db1 14396
ccb4c951 14397 printf ("\n");
82b1b41b
NC		 14398 if (ent == (bfd_vma) -1)
14399 break;
ccb4c951
RS		 14400 }
14401 printf ("\n");
14402 }
14403
82b1b41b 14404 got_print_fail:
ccb4c951
RS		 14405 if (data)
14406 free (data);
14407 }
14408
861fb55a
DJ		 14409 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14410 {
91d6fa6a 14411 bfd_vma ent, end;
861fb55a
DJ		 14412 size_t offset, rel_offset;
14413 unsigned long count, i;
2cf0635d 14414 unsigned char * data;
861fb55a 14415 int addr_size, sym_width;
2cf0635d 14416 Elf_Internal_Rela * rels;
861fb55a
DJ		 14417
14418 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14419 if (pltrel == DT_RELA)
14420 {
14421 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14422 return 0;
14423 }
14424 else
14425 {
14426 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14427 return 0;
14428 }
14429
91d6fa6a 14430 ent = mips_pltgot;
861fb55a
DJ		 14431 addr_size = (is_32bit_elf ? 4 : 8);
14432 end = mips_pltgot + (2 + count) * addr_size;
14433
14434 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14435 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14436 1, _("Procedure Linkage Table data"));
59245841
NC		 14437 if (data == NULL)
14438 return 0;
14439
9cf03b7e 14440 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14441 printf (_(" Reserved entries:\n"));
14442 printf (_(" %*s %*s Purpose\n"),
2b692964 14443 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14444 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14445 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14446 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14447 printf (_(" Module pointer\n"));
861fb55a
DJ		 14448 printf ("\n");
14449
14450 printf (_(" Entries:\n"));
cc5914eb 14451 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14452 addr_size * 2, _("Address"),
14453 addr_size * 2, _("Initial"),
14454 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14455 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14456 for (i = 0; i < count; i++)
14457 {
df97ab2a 14458 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14459
91d6fa6a 14460 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14461 printf (" ");
e0a31db1 14462
df97ab2a
MF		 14463 if (idx >= num_dynamic_syms)
14464 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14465 else
e0a31db1 14466 {
df97ab2a 14467 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14468
14469 print_vma (psym->st_value, LONG_HEX);
14470 printf (" %-7s %3s ",
14471 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14472 get_symbol_index_type (psym->st_shndx));
14473 if (VALID_DYNAMIC_NAME (psym->st_name))
14474 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14475 else
14476 printf (_("<corrupt: %14ld>"), psym->st_name);
14477 }
861fb55a
DJ		 14478 printf ("\n");
14479 }
14480 printf ("\n");
14481
14482 if (data)
14483 free (data);
14484 free (rels);
14485 }
14486
252b5132
RH		 14487 return 1;
14488}
14489
35c08157
KLC		 14490static int
14491process_nds32_specific (FILE * file)
14492{
14493 Elf_Internal_Shdr *sect = NULL;
14494
14495 sect = find_section (".nds32_e_flags");
14496 if (sect != NULL)
14497 {
14498 unsigned int *flag;
14499
14500 printf ("\nNDS32 elf flags section:\n");
14501 flag = get_data (NULL, file, sect->sh_offset, 1,
14502 sect->sh_size, _("NDS32 elf flags section"));
14503
14504 switch ((*flag) & 0x3)
14505 {
14506 case 0:
14507 printf ("(VEC_SIZE):\tNo entry.\n");
14508 break;
14509 case 1:
14510 printf ("(VEC_SIZE):\t4 bytes\n");
14511 break;
14512 case 2:
14513 printf ("(VEC_SIZE):\t16 bytes\n");
14514 break;
14515 case 3:
14516 printf ("(VEC_SIZE):\treserved\n");
14517 break;
14518 }
14519 }
14520
14521 return TRUE;
14522}
14523
047b2264 14524static int
2cf0635d 14525process_gnu_liblist (FILE * file)
047b2264 14526{
2cf0635d
NC		 14527 Elf_Internal_Shdr * section;
14528 Elf_Internal_Shdr * string_sec;
14529 Elf32_External_Lib * elib;
14530 char * strtab;
c256ffe7 14531 size_t strtab_size;
047b2264
JJ		 14532 size_t cnt;
14533 unsigned i;
14534
14535 if (! do_arch)
14536 return 0;
14537
14538 for (i = 0, section = section_headers;
14539 i < elf_header.e_shnum;
b34976b6 14540 i++, section++)
047b2264
JJ		 14541 {
14542 switch (section->sh_type)
14543 {
14544 case SHT_GNU_LIBLIST:
4fbb74a6 14545 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14546 break;
14547
3f5e193b
NC		 14548 elib = (Elf32_External_Lib *)
14549 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14550 _("liblist section data"));
047b2264
JJ		 14551
14552 if (elib == NULL)
14553 break;
4fbb74a6 14554 string_sec = section_headers + section->sh_link;
047b2264 14555
3f5e193b
NC		 14556 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14557 string_sec->sh_size,
14558 _("liblist string table"));
047b2264
JJ		 14559 if (strtab == NULL
14560 || section->sh_entsize != sizeof (Elf32_External_Lib))
14561 {
14562 free (elib);
2842702f 14563 free (strtab);
047b2264
JJ		 14564 break;
14565 }
59245841 14566 strtab_size = string_sec->sh_size;
047b2264
JJ		 14567
14568 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14569 printable_section_name (section),
0af1713e 14570 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14571
2b692964 14572 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14573
14574 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14575 ++cnt)
14576 {
14577 Elf32_Lib liblist;
91d6fa6a 14578 time_t atime;
047b2264 14579 char timebuf[20];
2cf0635d 14580 struct tm * tmp;
047b2264
JJ		 14581
14582 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14583 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14584 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14585 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14586 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14587
91d6fa6a 14588 tmp = gmtime (&atime);
e9e44622
JJ		 14589 snprintf (timebuf, sizeof (timebuf),
14590 "%04u-%02u-%02uT%02u:%02u:%02u",
14591 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14592 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14593
14594 printf ("%3lu: ", (unsigned long) cnt);
14595 if (do_wide)
c256ffe7 14596 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14597 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14598 else
c256ffe7 14599 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14600 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14601 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14602 liblist.l_version, liblist.l_flags);
14603 }
14604
14605 free (elib);
2842702f 14606 free (strtab);
047b2264
JJ		 14607 }
14608 }
14609
14610 return 1;
14611}
14612
9437c45b 14613static const char *
d3ba0551 14614get_note_type (unsigned e_type)
779fe533
NC		 14615{
14616 static char buff[64];
103f02d3 14617
1ec5cd37
NC		 14618 if (elf_header.e_type == ET_CORE)
14619 switch (e_type)
14620 {
57346661 14621 case NT_AUXV:
1ec5cd37 14622 return _("NT_AUXV (auxiliary vector)");
57346661 14623 case NT_PRSTATUS:
1ec5cd37 14624 return _("NT_PRSTATUS (prstatus structure)");
57346661 14625 case NT_FPREGSET:
1ec5cd37 14626 return _("NT_FPREGSET (floating point registers)");
57346661 14627 case NT_PRPSINFO:
1ec5cd37 14628 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14629 case NT_TASKSTRUCT:
1ec5cd37 14630 return _("NT_TASKSTRUCT (task structure)");
57346661 14631 case NT_PRXFPREG:
1ec5cd37 14632 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14633 case NT_PPC_VMX:
14634 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14635 case NT_PPC_VSX:
14636 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14637 case NT_386_TLS:
14638 return _("NT_386_TLS (x86 TLS information)");
14639 case NT_386_IOPERM:
14640 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14641 case NT_X86_XSTATE:
14642 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14643 case NT_S390_HIGH_GPRS:
14644 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14645 case NT_S390_TIMER:
14646 return _("NT_S390_TIMER (s390 timer register)");
14647 case NT_S390_TODCMP:
14648 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14649 case NT_S390_TODPREG:
14650 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14651 case NT_S390_CTRS:
14652 return _("NT_S390_CTRS (s390 control registers)");
14653 case NT_S390_PREFIX:
14654 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14655 case NT_S390_LAST_BREAK:
14656 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14657 case NT_S390_SYSTEM_CALL:
14658 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14659 case NT_S390_TDB:
14660 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14661 case NT_S390_VXRS_LOW:
14662 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14663 case NT_S390_VXRS_HIGH:
14664 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14665 case NT_ARM_VFP:
14666 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14667 case NT_ARM_TLS:
14668 return _("NT_ARM_TLS (AArch TLS registers)");
14669 case NT_ARM_HW_BREAK:
14670 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14671 case NT_ARM_HW_WATCH:
14672 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14673 case NT_PSTATUS:
1ec5cd37 14674 return _("NT_PSTATUS (pstatus structure)");
57346661 14675 case NT_FPREGS:
1ec5cd37 14676 return _("NT_FPREGS (floating point registers)");
57346661 14677 case NT_PSINFO:
1ec5cd37 14678 return _("NT_PSINFO (psinfo structure)");
57346661 14679 case NT_LWPSTATUS:
1ec5cd37 14680 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14681 case NT_LWPSINFO:
1ec5cd37 14682 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14683 case NT_WIN32PSTATUS:
1ec5cd37 14684 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14685 case NT_SIGINFO:
14686 return _("NT_SIGINFO (siginfo_t data)");
14687 case NT_FILE:
14688 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14689 default:
14690 break;
14691 }
14692 else
14693 switch (e_type)
14694 {
14695 case NT_VERSION:
14696 return _("NT_VERSION (version)");
14697 case NT_ARCH:
14698 return _("NT_ARCH (architecture)");
14699 default:
14700 break;
14701 }
14702
e9e44622 14703 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14704 return buff;
779fe533
NC		 14705}
14706
9ece1fa9
TT		 14707static int
14708print_core_note (Elf_Internal_Note *pnote)
14709{
14710 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14711 bfd_vma count, page_size;
14712 unsigned char *descdata, *filenames, *descend;
14713
14714 if (pnote->type != NT_FILE)
14715 return 1;
14716
14717#ifndef BFD64
14718 if (!is_32bit_elf)
14719 {
14720 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14721 /* Still "successful". */
14722 return 1;
14723 }
14724#endif
14725
14726 if (pnote->descsz < 2 * addr_size)
14727 {
14728 printf (_(" Malformed note - too short for header\n"));
14729 return 0;
14730 }
14731
14732 descdata = (unsigned char *) pnote->descdata;
14733 descend = descdata + pnote->descsz;
14734
14735 if (descdata[pnote->descsz - 1] != '\0')
14736 {
14737 printf (_(" Malformed note - does not end with \\0\n"));
14738 return 0;
14739 }
14740
14741 count = byte_get (descdata, addr_size);
14742 descdata += addr_size;
14743
14744 page_size = byte_get (descdata, addr_size);
14745 descdata += addr_size;
14746
14747 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14748 {
14749 printf (_(" Malformed note - too short for supplied file count\n"));
14750 return 0;
14751 }
14752
14753 printf (_(" Page size: "));
14754 print_vma (page_size, DEC);
14755 printf ("\n");
14756
14757 printf (_(" %*s%*s%*s\n"),
14758 (int) (2 + 2 * addr_size), _("Start"),
14759 (int) (4 + 2 * addr_size), _("End"),
14760 (int) (4 + 2 * addr_size), _("Page Offset"));
14761 filenames = descdata + count * 3 * addr_size;
14762 while (--count > 0)
14763 {
14764 bfd_vma start, end, file_ofs;
14765
14766 if (filenames == descend)
14767 {
14768 printf (_(" Malformed note - filenames end too early\n"));
14769 return 0;
14770 }
14771
14772 start = byte_get (descdata, addr_size);
14773 descdata += addr_size;
14774 end = byte_get (descdata, addr_size);
14775 descdata += addr_size;
14776 file_ofs = byte_get (descdata, addr_size);
14777 descdata += addr_size;
14778
14779 printf (" ");
14780 print_vma (start, FULL_HEX);
14781 printf (" ");
14782 print_vma (end, FULL_HEX);
14783 printf (" ");
14784 print_vma (file_ofs, FULL_HEX);
14785 printf ("\n %s\n", filenames);
14786
14787 filenames += 1 + strlen ((char *) filenames);
14788 }
14789
14790 return 1;
14791}
14792
1118d252
RM		 14793static const char *
14794get_gnu_elf_note_type (unsigned e_type)
14795{
14796 static char buff[64];
14797
14798 switch (e_type)
14799 {
14800 case NT_GNU_ABI_TAG:
14801 return _("NT_GNU_ABI_TAG (ABI version tag)");
14802 case NT_GNU_HWCAP:
14803 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14804 case NT_GNU_BUILD_ID:
14805 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14806 case NT_GNU_GOLD_VERSION:
14807 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14808 default:
14809 break;
14810 }
14811
14812 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14813 return buff;
14814}
14815
664f90a3
TT		 14816static int
14817print_gnu_note (Elf_Internal_Note *pnote)
14818{
14819 switch (pnote->type)
14820 {
14821 case NT_GNU_BUILD_ID:
14822 {
14823 unsigned long i;
14824
14825 printf (_(" Build ID: "));
14826 for (i = 0; i < pnote->descsz; ++i)
14827 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14828 printf ("\n");
664f90a3
TT		 14829 }
14830 break;
14831
14832 case NT_GNU_ABI_TAG:
14833 {
14834 unsigned long os, major, minor, subminor;
14835 const char *osname;
14836
3102e897
NC		 14837 /* PR 17531: file: 030-599401-0.004. */
14838 if (pnote->descsz < 16)
14839 {
14840 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14841 break;
14842 }
14843
664f90a3
TT		 14844 os = byte_get ((unsigned char *) pnote->descdata, 4);
14845 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14846 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14847 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14848
14849 switch (os)
14850 {
14851 case GNU_ABI_TAG_LINUX:
14852 osname = "Linux";
14853 break;
14854 case GNU_ABI_TAG_HURD:
14855 osname = "Hurd";
14856 break;
14857 case GNU_ABI_TAG_SOLARIS:
14858 osname = "Solaris";
14859 break;
14860 case GNU_ABI_TAG_FREEBSD:
14861 osname = "FreeBSD";
14862 break;
14863 case GNU_ABI_TAG_NETBSD:
14864 osname = "NetBSD";
14865 break;
14866 default:
14867 osname = "Unknown";
14868 break;
14869 }
14870
14871 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14872 major, minor, subminor);
14873 }
14874 break;
926c5385
CC		 14875
14876 case NT_GNU_GOLD_VERSION:
14877 {
14878 unsigned long i;
14879
14880 printf (_(" Version: "));
14881 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14882 printf ("%c", pnote->descdata[i]);
14883 printf ("\n");
14884 }
14885 break;
664f90a3
TT		 14886 }
14887
14888 return 1;
14889}
14890
685080f2
NC		 14891static const char *
14892get_v850_elf_note_type (enum v850_notes n_type)
14893{
14894 static char buff[64];
14895
14896 switch (n_type)
14897 {
14898 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
14899 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
14900 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
14901 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
14902 case V850_NOTE_CACHE_INFO: return _("Use of cache");
14903 case V850_NOTE_MMU_INFO: return _("Use of MMU");
14904 default:
14905 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
14906 return buff;
14907 }
14908}
14909
14910static int
14911print_v850_note (Elf_Internal_Note * pnote)
14912{
14913 unsigned int val;
14914
14915 if (pnote->descsz != 4)
14916 return 0;
14917 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
14918
14919 if (val == 0)
14920 {
14921 printf (_("not set\n"));
14922 return 1;
14923 }
14924
14925 switch (pnote->type)
14926 {
14927 case V850_NOTE_ALIGNMENT:
14928 switch (val)
14929 {
14930 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
14931 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
14932 }
14933 break;
14934
14935 case V850_NOTE_DATA_SIZE:
14936 switch (val)
14937 {
14938 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
14939 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
14940 }
14941 break;
14942
14943 case V850_NOTE_FPU_INFO:
14944 switch (val)
14945 {
14946 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
14947 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
14948 }
14949 break;
14950
14951 case V850_NOTE_MMU_INFO:
14952 case V850_NOTE_CACHE_INFO:
14953 case V850_NOTE_SIMD_INFO:
14954 if (val == EF_RH850_SIMD)
14955 {
14956 printf (_("yes\n"));
14957 return 1;
14958 }
14959 break;
14960
14961 default:
14962 /* An 'unknown note type' message will already have been displayed. */
14963 break;
14964 }
14965
14966 printf (_("unknown value: %x\n"), val);
14967 return 0;
14968}
14969
9437c45b 14970static const char *
d3ba0551 14971get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14972{
14973 static char buff[64];
14974
b4db1224 14975 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14976 {
14977 /* NetBSD core "procinfo" structure. */
14978 return _("NetBSD procinfo structure");
14979 }
14980
14981 /* As of Jan 2002 there are no other machine-independent notes
14982 defined for NetBSD core files. If the note type is less
14983 than the start of the machine-dependent note types, we don't
14984 understand it. */
14985
b4db1224 14986 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14987 {
e9e44622 14988 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14989 return buff;
14990 }
14991
14992 switch (elf_header.e_machine)
14993 {
14994 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14995 and PT_GETFPREGS == mach+2. */
14996
14997 case EM_OLD_ALPHA:
14998 case EM_ALPHA:
14999 case EM_SPARC:
15000 case EM_SPARC32PLUS:
15001 case EM_SPARCV9:
15002 switch (e_type)
15003 {
2b692964 15004 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15005 return _("PT_GETREGS (reg structure)");
2b692964 15006 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15007 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15008 default:
15009 break;
15010 }
15011 break;
15012
15013 /* On all other arch's, PT_GETREGS == mach+1 and
15014 PT_GETFPREGS == mach+3. */
15015 default:
15016 switch (e_type)
15017 {
2b692964 15018 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15019 return _("PT_GETREGS (reg structure)");
2b692964 15020 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15021 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15022 default:
15023 break;
15024 }
15025 }
15026
9cf03b7e 15027 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15028 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15029 return buff;
15030}
15031
70616151
TT		 15032static const char *
15033get_stapsdt_note_type (unsigned e_type)
15034{
15035 static char buff[64];
15036
15037 switch (e_type)
15038 {
15039 case NT_STAPSDT:
15040 return _("NT_STAPSDT (SystemTap probe descriptors)");
15041
15042 default:
15043 break;
15044 }
15045
15046 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15047 return buff;
15048}
15049
c6a9fc58
TT		 15050static int
15051print_stapsdt_note (Elf_Internal_Note *pnote)
15052{
15053 int addr_size = is_32bit_elf ? 4 : 8;
15054 char *data = pnote->descdata;
15055 char *data_end = pnote->descdata + pnote->descsz;
15056 bfd_vma pc, base_addr, semaphore;
15057 char *provider, *probe, *arg_fmt;
15058
15059 pc = byte_get ((unsigned char *) data, addr_size);
15060 data += addr_size;
15061 base_addr = byte_get ((unsigned char *) data, addr_size);
15062 data += addr_size;
15063 semaphore = byte_get ((unsigned char *) data, addr_size);
15064 data += addr_size;
15065
15066 provider = data;
15067 data += strlen (data) + 1;
15068 probe = data;
15069 data += strlen (data) + 1;
15070 arg_fmt = data;
15071 data += strlen (data) + 1;
15072
15073 printf (_(" Provider: %s\n"), provider);
15074 printf (_(" Name: %s\n"), probe);
15075 printf (_(" Location: "));
15076 print_vma (pc, FULL_HEX);
15077 printf (_(", Base: "));
15078 print_vma (base_addr, FULL_HEX);
15079 printf (_(", Semaphore: "));
15080 print_vma (semaphore, FULL_HEX);
9cf03b7e 15081 printf ("\n");
c6a9fc58
TT		 15082 printf (_(" Arguments: %s\n"), arg_fmt);
15083
15084 return data == data_end;
15085}
15086
00e98fc7
TG		 15087static const char *
15088get_ia64_vms_note_type (unsigned e_type)
15089{
15090 static char buff[64];
15091
15092 switch (e_type)
15093 {
15094 case NT_VMS_MHD:
15095 return _("NT_VMS_MHD (module header)");
15096 case NT_VMS_LNM:
15097 return _("NT_VMS_LNM (language name)");
15098 case NT_VMS_SRC:
15099 return _("NT_VMS_SRC (source files)");
15100 case NT_VMS_TITLE:
9cf03b7e 15101 return "NT_VMS_TITLE";
00e98fc7
TG		 15102 case NT_VMS_EIDC:
15103 return _("NT_VMS_EIDC (consistency check)");
15104 case NT_VMS_FPMODE:
15105 return _("NT_VMS_FPMODE (FP mode)");
15106 case NT_VMS_LINKTIME:
9cf03b7e 15107 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15108 case NT_VMS_IMGNAM:
15109 return _("NT_VMS_IMGNAM (image name)");
15110 case NT_VMS_IMGID:
15111 return _("NT_VMS_IMGID (image id)");
15112 case NT_VMS_LINKID:
15113 return _("NT_VMS_LINKID (link id)");
15114 case NT_VMS_IMGBID:
15115 return _("NT_VMS_IMGBID (build id)");
15116 case NT_VMS_GSTNAM:
15117 return _("NT_VMS_GSTNAM (sym table name)");
15118 case NT_VMS_ORIG_DYN:
9cf03b7e 15119 return "NT_VMS_ORIG_DYN";
00e98fc7 15120 case NT_VMS_PATCHTIME:
9cf03b7e 15121 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15122 default:
15123 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15124 return buff;
15125 }
15126}
15127
15128static int
15129print_ia64_vms_note (Elf_Internal_Note * pnote)
15130{
15131 switch (pnote->type)
15132 {
15133 case NT_VMS_MHD:
15134 if (pnote->descsz > 36)
15135 {
15136 size_t l = strlen (pnote->descdata + 34);
15137 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15138 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15139 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15140 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15141 }
15142 else
15143 printf (_(" Invalid size\n"));
15144 break;
15145 case NT_VMS_LNM:
15146 printf (_(" Language: %s\n"), pnote->descdata);
15147 break;
15148#ifdef BFD64
15149 case NT_VMS_FPMODE:
9cf03b7e 15150 printf (_(" Floating Point mode: "));
4a5cb34f 15151 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15152 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15153 break;
15154 case NT_VMS_LINKTIME:
15155 printf (_(" Link time: "));
15156 print_vms_time
15157 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15158 printf ("\n");
15159 break;
15160 case NT_VMS_PATCHTIME:
15161 printf (_(" Patch time: "));
15162 print_vms_time
15163 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15164 printf ("\n");
15165 break;
15166 case NT_VMS_ORIG_DYN:
15167 printf (_(" Major id: %u, minor id: %u\n"),
15168 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15169 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15170 printf (_(" Last modified : "));
00e98fc7
TG		 15171 print_vms_time
15172 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15173 printf (_("\n Link flags : "));
4a5cb34f 15174 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15175 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15176 printf (_(" Header flags: 0x%08x\n"),
948f632f 15177 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15178 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15179 break;
15180#endif
15181 case NT_VMS_IMGNAM:
15182 printf (_(" Image name: %s\n"), pnote->descdata);
15183 break;
15184 case NT_VMS_GSTNAM:
15185 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15186 break;
15187 case NT_VMS_IMGID:
15188 printf (_(" Image id: %s\n"), pnote->descdata);
15189 break;
15190 case NT_VMS_LINKID:
15191 printf (_(" Linker id: %s\n"), pnote->descdata);
15192 break;
15193 default:
15194 break;
15195 }
15196 return 1;
15197}
15198
6d118b09
NC		 15199/* Note that by the ELF standard, the name field is already null byte
15200 terminated, and namesz includes the terminating null byte.
15201 I.E. the value of namesz for the name "FSF" is 4.
15202
e3c8793a 15203 If the value of namesz is zero, there is no name present. */
779fe533 15204static int
2cf0635d 15205process_note (Elf_Internal_Note * pnote)
779fe533 15206{
2cf0635d
NC		 15207 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15208 const char * nt;
9437c45b
JT		 15209
15210 if (pnote->namesz == 0)
1ec5cd37
NC		 15211 /* If there is no note name, then use the default set of
15212 note type strings. */
15213 nt = get_note_type (pnote->type);
15214
1118d252
RM		 15215 else if (const_strneq (pnote->namedata, "GNU"))
15216 /* GNU-specific object file notes. */
15217 nt = get_gnu_elf_note_type (pnote->type);
15218
0112cd26 15219 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15220 /* NetBSD-specific core file notes. */
15221 nt = get_netbsd_elfcore_note_type (pnote->type);
15222
b15fa79e
AM		 15223 else if (strneq (pnote->namedata, "SPU/", 4))
15224 {
15225 /* SPU-specific core file notes. */
15226 nt = pnote->namedata + 4;
15227 name = "SPU";
15228 }
15229
00e98fc7
TG		 15230 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15231 /* VMS/ia64-specific file notes. */
15232 nt = get_ia64_vms_note_type (pnote->type);
15233
70616151
TT		 15234 else if (const_strneq (pnote->namedata, "stapsdt"))
15235 nt = get_stapsdt_note_type (pnote->type);
15236
9437c45b 15237 else
1ec5cd37
NC		 15238 /* Don't recognize this note name; just use the default set of
15239 note type strings. */
00e98fc7 15240 nt = get_note_type (pnote->type);
9437c45b 15241
2aee03ae 15242 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15243
15244 if (const_strneq (pnote->namedata, "IPF/VMS"))
15245 return print_ia64_vms_note (pnote);
664f90a3
TT		 15246 else if (const_strneq (pnote->namedata, "GNU"))
15247 return print_gnu_note (pnote);
c6a9fc58
TT		 15248 else if (const_strneq (pnote->namedata, "stapsdt"))
15249 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15250 else if (const_strneq (pnote->namedata, "CORE"))
15251 return print_core_note (pnote);
00e98fc7
TG		 15252 else
15253 return 1;
779fe533
NC		 15254}
15255
6d118b09 15256
779fe533 15257static int
2cf0635d 15258process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15259{
2cf0635d
NC		 15260 Elf_External_Note * pnotes;
15261 Elf_External_Note * external;
c8071705 15262 char * end;
b34976b6 15263 int res = 1;
103f02d3 15264
779fe533
NC		 15265 if (length <= 0)
15266 return 0;
103f02d3 15267
3f5e193b 15268 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15269 _("notes"));
dd24e3da 15270 if (pnotes == NULL)
a6e9f9df 15271 return 0;
779fe533 15272
103f02d3 15273 external = pnotes;
103f02d3 15274
9dd3a467 15275 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15276 (unsigned long) offset, (unsigned long) length);
2aee03ae 15277 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15278
c8071705
NC		 15279 end = (char *) pnotes + length;
15280 while ((char *) external < end)
779fe533 15281 {
b34976b6 15282 Elf_Internal_Note inote;
15b42fb0
AM		 15283 size_t min_notesz;
15284 char *next;
2cf0635d 15285 char * temp = NULL;
c8071705 15286 size_t data_remaining = end - (char *) external;
6d118b09 15287
00e98fc7 15288 if (!is_ia64_vms ())
15b42fb0 15289 {
9dd3a467
NC		 15290 /* PR binutils/15191
15291 Make sure that there is enough data to read. */
15b42fb0
AM		 15292 min_notesz = offsetof (Elf_External_Note, name);
15293 if (data_remaining < min_notesz)
9dd3a467
NC		 15294 {
15295 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15296 (int) data_remaining);
15297 break;
15298 }
15b42fb0
AM		 15299 inote.type = BYTE_GET (external->type);
15300 inote.namesz = BYTE_GET (external->namesz);
15301 inote.namedata = external->name;
15302 inote.descsz = BYTE_GET (external->descsz);
15303 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15304 /* PR 17531: file: 3443835e. */
c8071705 15305 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15306 {
15307 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15308 inote.descdata = inote.namedata;
15309 inote.namesz = 0;
15310 }
c8071705 15311
15b42fb0
AM		 15312 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15313 next = inote.descdata + align_power (inote.descsz, 2);
15314 }
00e98fc7 15315 else
15b42fb0
AM		 15316 {
15317 Elf64_External_VMS_Note *vms_external;
00e98fc7 15318
9dd3a467
NC		 15319 /* PR binutils/15191
15320 Make sure that there is enough data to read. */
15b42fb0
AM		 15321 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15322 if (data_remaining < min_notesz)
9dd3a467
NC		 15323 {
15324 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15325 (int) data_remaining);
15326 break;
15327 }
3e55a963 15328
15b42fb0
AM		 15329 vms_external = (Elf64_External_VMS_Note *) external;
15330 inote.type = BYTE_GET (vms_external->type);
15331 inote.namesz = BYTE_GET (vms_external->namesz);
15332 inote.namedata = vms_external->name;
15333 inote.descsz = BYTE_GET (vms_external->descsz);
15334 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15335 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15336 next = inote.descdata + align_power (inote.descsz, 3);
15337 }
15338
15339 if (inote.descdata < (char *) external + min_notesz
15340 || next < (char *) external + min_notesz
5d921cbd
NC		 15341 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15342 || inote.namedata + inote.namesz < inote.namedata
15343 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15344 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15345 {
15b42fb0 15346 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15347 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15348 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15349 inote.type, inote.namesz, inote.descsz);
15350 break;
15351 }
15352
15b42fb0 15353 external = (Elf_External_Note *) next;
dd24e3da 15354
6d118b09
NC		 15355 /* Verify that name is null terminated. It appears that at least
15356 one version of Linux (RedHat 6.0) generates corefiles that don't
15357 comply with the ELF spec by failing to include the null byte in
15358 namesz. */
8b971f9f 15359 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15360 {
3f5e193b 15361 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15362 if (temp == NULL)
15363 {
8b73c356 15364 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15365 res = 0;
15366 break;
15367 }
76da6bbe 15368
6d118b09
NC		 15369 strncpy (temp, inote.namedata, inote.namesz);
15370 temp[inote.namesz] = 0;
76da6bbe 15371
6d118b09
NC		 15372 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15373 inote.namedata = temp;
15374 }
15375
15376 res &= process_note (& inote);
103f02d3 15377
6d118b09
NC		 15378 if (temp != NULL)
15379 {
15380 free (temp);
15381 temp = NULL;
15382 }
779fe533
NC		 15383 }
15384
15385 free (pnotes);
103f02d3 15386
779fe533
NC		 15387 return res;
15388}
15389
15390static int
2cf0635d 15391process_corefile_note_segments (FILE * file)
779fe533 15392{
2cf0635d 15393 Elf_Internal_Phdr * segment;
b34976b6
AM		 15394 unsigned int i;
15395 int res = 1;
103f02d3 15396
d93f0186 15397 if (! get_program_headers (file))
779fe533 15398 return 0;
103f02d3 15399
779fe533
NC		 15400 for (i = 0, segment = program_headers;
15401 i < elf_header.e_phnum;
b34976b6 15402 i++, segment++)
779fe533
NC		 15403 {
15404 if (segment->p_type == PT_NOTE)
103f02d3 15405 res &= process_corefile_note_segment (file,
30800947
NC		 15406 (bfd_vma) segment->p_offset,
15407 (bfd_vma) segment->p_filesz);
779fe533 15408 }
103f02d3 15409
779fe533
NC		 15410 return res;
15411}
15412
685080f2
NC		 15413static int
15414process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15415{
15416 Elf_External_Note * pnotes;
15417 Elf_External_Note * external;
c8071705 15418 char * end;
685080f2
NC		 15419 int res = 1;
15420
15421 if (length <= 0)
15422 return 0;
15423
15424 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15425 _("v850 notes"));
15426 if (pnotes == NULL)
15427 return 0;
15428
15429 external = pnotes;
c8071705 15430 end = (char*) pnotes + length;
685080f2
NC		 15431
15432 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15433 (unsigned long) offset, (unsigned long) length);
15434
c8071705 15435 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15436 {
15437 Elf_External_Note * next;
15438 Elf_Internal_Note inote;
15439
15440 inote.type = BYTE_GET (external->type);
15441 inote.namesz = BYTE_GET (external->namesz);
15442 inote.namedata = external->name;
15443 inote.descsz = BYTE_GET (external->descsz);
15444 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15445 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15446
c8071705
NC		 15447 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15448 {
15449 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15450 inote.descdata = inote.namedata;
15451 inote.namesz = 0;
15452 }
15453
685080f2
NC		 15454 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15455
c8071705 15456 if ( ((char *) next > end)
685080f2
NC		 15457 || ((char *) next < (char *) pnotes))
15458 {
15459 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15460 (unsigned long) ((char *) external - (char *) pnotes));
15461 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15462 inote.type, inote.namesz, inote.descsz);
15463 break;
15464 }
15465
15466 external = next;
15467
15468 /* Prevent out-of-bounds indexing. */
c8071705 15469 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15470 || inote.namedata + inote.namesz < inote.namedata)
15471 {
15472 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15473 (unsigned long) ((char *) external - (char *) pnotes));
15474 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15475 inote.type, inote.namesz, inote.descsz);
15476 break;
15477 }
15478
15479 printf (" %s: ", get_v850_elf_note_type (inote.type));
15480
15481 if (! print_v850_note (& inote))
15482 {
15483 res = 0;
15484 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15485 inote.namesz, inote.descsz);
15486 }
15487 }
15488
15489 free (pnotes);
15490
15491 return res;
15492}
15493
779fe533 15494static int
2cf0635d 15495process_note_sections (FILE * file)
1ec5cd37 15496{
2cf0635d 15497 Elf_Internal_Shdr * section;
1ec5cd37 15498 unsigned long i;
df565f32 15499 int n = 0;
1ec5cd37
NC		 15500 int res = 1;
15501
15502 for (i = 0, section = section_headers;
fa1908fd 15503 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15504 i++, section++)
685080f2
NC		 15505 {
15506 if (section->sh_type == SHT_NOTE)
15507 {
15508 res &= process_corefile_note_segment (file,
15509 (bfd_vma) section->sh_offset,
15510 (bfd_vma) section->sh_size);
15511 n++;
15512 }
15513
15514 if (( elf_header.e_machine == EM_V800
15515 || elf_header.e_machine == EM_V850
15516 || elf_header.e_machine == EM_CYGNUS_V850)
15517 && section->sh_type == SHT_RENESAS_INFO)
15518 {
15519 res &= process_v850_notes (file,
15520 (bfd_vma) section->sh_offset,
15521 (bfd_vma) section->sh_size);
15522 n++;
15523 }
15524 }
df565f32
NC		 15525
15526 if (n == 0)
15527 /* Try processing NOTE segments instead. */
15528 return process_corefile_note_segments (file);
1ec5cd37
NC		 15529
15530 return res;
15531}
15532
15533static int
2cf0635d 15534process_notes (FILE * file)
779fe533
NC		 15535{
15536 /* If we have not been asked to display the notes then do nothing. */
15537 if (! do_notes)
15538 return 1;
103f02d3 15539
779fe533 15540 if (elf_header.e_type != ET_CORE)
1ec5cd37 15541 return process_note_sections (file);
103f02d3 15542
779fe533 15543 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15544 if (elf_header.e_phnum > 0)
15545 return process_corefile_note_segments (file);
779fe533 15546
1ec5cd37
NC		 15547 printf (_("No note segments present in the core file.\n"));
15548 return 1;
779fe533
NC		 15549}
15550
252b5132 15551static int
2cf0635d 15552process_arch_specific (FILE * file)
252b5132 15553{
a952a375
NC		 15554 if (! do_arch)
15555 return 1;
15556
252b5132
RH		 15557 switch (elf_header.e_machine)
15558 {
11c1ff18
PB		 15559 case EM_ARM:
15560 return process_arm_specific (file);
252b5132 15561 case EM_MIPS:
4fe85591 15562 case EM_MIPS_RS3_LE:
252b5132
RH		 15563 return process_mips_specific (file);
15564 break;
35c08157
KLC		 15565 case EM_NDS32:
15566 return process_nds32_specific (file);
15567 break;
34c8bcba
JM		 15568 case EM_PPC:
15569 return process_power_specific (file);
15570 break;
9e8c70f9
DM		 15571 case EM_SPARC:
15572 case EM_SPARC32PLUS:
15573 case EM_SPARCV9:
15574 return process_sparc_specific (file);
15575 break;
59e6276b
JM		 15576 case EM_TI_C6000:
15577 return process_tic6x_specific (file);
15578 break;
13761a11
NC		 15579 case EM_MSP430:
15580 return process_msp430x_specific (file);
252b5132
RH		 15581 default:
15582 break;
15583 }
15584 return 1;
15585}
15586
15587static int
2cf0635d 15588get_file_header (FILE * file)
252b5132 15589{
9ea033b2
NC		 15590 /* Read in the identity array. */
15591 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15592 return 0;
15593
9ea033b2 15594 /* Determine how to read the rest of the header. */
b34976b6 15595 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15596 {
15597 default: /* fall through */
15598 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15599 case ELFDATA2LSB:
15600 byte_get = byte_get_little_endian;
15601 byte_put = byte_put_little_endian;
15602 break;
15603 case ELFDATA2MSB:
15604 byte_get = byte_get_big_endian;
15605 byte_put = byte_put_big_endian;
15606 break;
9ea033b2
NC		 15607 }
15608
15609 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15610 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15611
15612 /* Read in the rest of the header. */
15613 if (is_32bit_elf)
15614 {
15615 Elf32_External_Ehdr ehdr32;
252b5132 15616
9ea033b2
NC		 15617 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15618 return 0;
103f02d3 15619
9ea033b2
NC		 15620 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15621 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15622 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15623 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15624 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15625 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15626 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15627 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15628 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15629 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15630 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15631 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15632 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15633 }
252b5132 15634 else
9ea033b2
NC		 15635 {
15636 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15637
15638 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15639 we will not be able to cope with the 64bit data found in
15640 64 ELF files. Detect this now and abort before we start
50c2245b 15641 overwriting things. */
a952a375
NC		 15642 if (sizeof (bfd_vma) < 8)
15643 {
e3c8793a
NC		 15644 error (_("This instance of readelf has been built without support for a\n\
1564564 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15646 return 0;
15647 }
103f02d3 15648
9ea033b2
NC		 15649 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15650 return 0;
103f02d3 15651
9ea033b2
NC		 15652 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15653 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15654 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15655 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15656 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15657 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15658 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15659 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15660 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15661 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15662 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15663 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15664 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15665 }
252b5132 15666
7ece0d85
JJ		 15667 if (elf_header.e_shoff)
15668 {
15669 /* There may be some extensions in the first section header. Don't
15670 bomb if we can't read it. */
15671 if (is_32bit_elf)
049b0c3a 15672 get_32bit_section_headers (file, TRUE);
7ece0d85 15673 else
049b0c3a 15674 get_64bit_section_headers (file, TRUE);
7ece0d85 15675 }
560f3c1c 15676
252b5132
RH		 15677 return 1;
15678}
15679
fb52b2f4
NC		 15680/* Process one ELF object file according to the command line options.
15681 This file may actually be stored in an archive. The file is
15682 positioned at the start of the ELF object. */
15683
ff78d6d6 15684static int
2cf0635d 15685process_object (char * file_name, FILE * file)
252b5132 15686{
252b5132
RH		 15687 unsigned int i;
15688
252b5132
RH		 15689 if (! get_file_header (file))
15690 {
15691 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15692 return 1;
252b5132
RH		 15693 }
15694
15695 /* Initialise per file variables. */
60bca95a 15696 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15697 version_info[i] = 0;
15698
60bca95a 15699 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15700 dynamic_info[i] = 0;
5115b233 15701 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15702
15703 /* Process the file. */
15704 if (show_name)
15705 printf (_("\nFile: %s\n"), file_name);
15706
18bd398b
NC		 15707 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15708 Note we do this even if cmdline_dump_sects is empty because we
15709 must make sure that the dump_sets array is zeroed out before each
15710 object file is processed. */
15711 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15712 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15713
15714 if (num_cmdline_dump_sects > 0)
15715 {
15716 if (num_dump_sects == 0)
15717 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15718 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15719
15720 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15721 memcpy (dump_sects, cmdline_dump_sects,
15722 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15723 }
d70c5fc7 15724
252b5132 15725 if (! process_file_header ())
fb52b2f4 15726 return 1;
252b5132 15727
d1f5c6e3 15728 if (! process_section_headers (file))
2f62977e 15729 {
d1f5c6e3
L		 15730 /* Without loaded section headers we cannot process lots of
15731 things. */
2f62977e 15732 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15733
2f62977e 15734 if (! do_using_dynamic)
2c610e4b 15735 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15736 }
252b5132 15737
d1f5c6e3
L		 15738 if (! process_section_groups (file))
15739 {
15740 /* Without loaded section groups we cannot process unwind. */
15741 do_unwind = 0;
15742 }
15743
2f62977e 15744 if (process_program_headers (file))
b2d38a17 15745 process_dynamic_section (file);
252b5132
RH		 15746
15747 process_relocs (file);
15748
4d6ed7c8
NC		 15749 process_unwind (file);
15750
252b5132
RH		 15751 process_symbol_table (file);
15752
15753 process_syminfo (file);
15754
15755 process_version_sections (file);
15756
15757 process_section_contents (file);
f5842774 15758
1ec5cd37 15759 process_notes (file);
103f02d3 15760
047b2264
JJ		 15761 process_gnu_liblist (file);
15762
252b5132
RH		 15763 process_arch_specific (file);
15764
d93f0186
NC		 15765 if (program_headers)
15766 {
15767 free (program_headers);
15768 program_headers = NULL;
15769 }
15770
252b5132
RH		 15771 if (section_headers)
15772 {
15773 free (section_headers);
15774 section_headers = NULL;
15775 }
15776
15777 if (string_table)
15778 {
15779 free (string_table);
15780 string_table = NULL;
d40ac9bd 15781 string_table_length = 0;
252b5132
RH		 15782 }
15783
15784 if (dynamic_strings)
15785 {
15786 free (dynamic_strings);
15787 dynamic_strings = NULL;
d79b3d50 15788 dynamic_strings_length = 0;
252b5132
RH		 15789 }
15790
15791 if (dynamic_symbols)
15792 {
15793 free (dynamic_symbols);
15794 dynamic_symbols = NULL;
19936277 15795 num_dynamic_syms = 0;
252b5132
RH		 15796 }
15797
15798 if (dynamic_syminfo)
15799 {
15800 free (dynamic_syminfo);
15801 dynamic_syminfo = NULL;
15802 }
ff78d6d6 15803
293c573e
MR		 15804 if (dynamic_section)
15805 {
15806 free (dynamic_section);
15807 dynamic_section = NULL;
15808 }
15809
e4b17d5c
L		 15810 if (section_headers_groups)
15811 {
15812 free (section_headers_groups);
15813 section_headers_groups = NULL;
15814 }
15815
15816 if (section_groups)
15817 {
2cf0635d
NC		 15818 struct group_list * g;
15819 struct group_list * next;
e4b17d5c
L		 15820
15821 for (i = 0; i < group_count; i++)
15822 {
15823 for (g = section_groups [i].root; g != NULL; g = next)
15824 {
15825 next = g->next;
15826 free (g);
15827 }
15828 }
15829
15830 free (section_groups);
15831 section_groups = NULL;
15832 }
15833
19e6b90e 15834 free_debug_memory ();
18bd398b 15835
ff78d6d6 15836 return 0;
252b5132
RH		 15837}
15838
2cf0635d
NC		 15839/* Process an ELF archive.
15840 On entry the file is positioned just after the ARMAG string. */
15841
15842static int
15843process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15844{
15845 struct archive_info arch;
15846 struct archive_info nested_arch;
15847 size_t got;
2cf0635d
NC		 15848 int ret;
15849
15850 show_name = 1;
15851
15852 /* The ARCH structure is used to hold information about this archive. */
15853 arch.file_name = NULL;
15854 arch.file = NULL;
15855 arch.index_array = NULL;
15856 arch.sym_table = NULL;
15857 arch.longnames = NULL;
15858
15859 /* The NESTED_ARCH structure is used as a single-item cache of information
15860 about a nested archive (when members of a thin archive reside within
15861 another regular archive file). */
15862 nested_arch.file_name = NULL;
15863 nested_arch.file = NULL;
15864 nested_arch.index_array = NULL;
15865 nested_arch.sym_table = NULL;
15866 nested_arch.longnames = NULL;
15867
15868 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15869 {
15870 ret = 1;
15871 goto out;
4145f1d5 15872 }
fb52b2f4 15873
4145f1d5
NC		 15874 if (do_archive_index)
15875 {
2cf0635d 15876 if (arch.sym_table == NULL)
4145f1d5
NC		 15877 error (_("%s: unable to dump the index as none was found\n"), file_name);
15878 else
15879 {
591f7597 15880 unsigned long i, l;
4145f1d5
NC		 15881 unsigned long current_pos;
15882
591f7597
NC		 15883 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15884 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 15885 current_pos = ftell (file);
15886
2cf0635d 15887 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 15888 {
2cf0635d
NC		 15889 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15890 {
15891 char * member_name;
4145f1d5 15892
2cf0635d
NC		 15893 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15894
15895 if (member_name != NULL)
15896 {
15897 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15898
15899 if (qualified_name != NULL)
15900 {
c2a7d3f5
NC		 15901 printf (_("Contents of binary %s at offset "), qualified_name);
15902 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15903 putchar ('\n');
2cf0635d
NC		 15904 free (qualified_name);
15905 }
4145f1d5
NC		 15906 }
15907 }
2cf0635d
NC		 15908
15909 if (l >= arch.sym_size)
4145f1d5
NC		 15910 {
15911 error (_("%s: end of the symbol table reached before the end of the index\n"),
15912 file_name);
cb8f3167 15913 break;
4145f1d5 15914 }
591f7597
NC		 15915 /* PR 17531: file: 0b6630b2. */
15916 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15917 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 15918 }
15919
c2a7d3f5
NC		 15920 if (arch.uses_64bit_indicies)
15921 l = (l + 7) & ~ 7;
15922 else
15923 l += l & 1;
15924
2cf0635d 15925 if (l < arch.sym_size)
c2a7d3f5
NC		 15926 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15927 file_name, arch.sym_size - l);
4145f1d5 15928
4145f1d5
NC		 15929 if (fseek (file, current_pos, SEEK_SET) != 0)
15930 {
15931 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 15932 ret = 1;
15933 goto out;
4145f1d5 15934 }
fb52b2f4 15935 }
4145f1d5
NC		 15936
15937 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15938 && !do_segments && !do_header && !do_dump && !do_version
15939 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 15940 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 15941 {
15942 ret = 0; /* Archive index only. */
15943 goto out;
15944 }
fb52b2f4
NC		 15945 }
15946
d989285c 15947 ret = 0;
fb52b2f4
NC		 15948
15949 while (1)
15950 {
2cf0635d
NC		 15951 char * name;
15952 size_t namelen;
15953 char * qualified_name;
15954
15955 /* Read the next archive header. */
15956 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15957 {
15958 error (_("%s: failed to seek to next archive header\n"), file_name);
15959 return 1;
15960 }
15961 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15962 if (got != sizeof arch.arhdr)
15963 {
15964 if (got == 0)
15965 break;
15966 error (_("%s: failed to read archive header\n"), file_name);
15967 ret = 1;
15968 break;
15969 }
15970 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15971 {
15972 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15973 ret = 1;
15974 break;
15975 }
15976
15977 arch.next_arhdr_offset += sizeof arch.arhdr;
15978
15979 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15980 if (archive_file_size & 01)
15981 ++archive_file_size;
15982
15983 name = get_archive_member_name (&arch, &nested_arch);
15984 if (name == NULL)
fb52b2f4 15985 {
0fd3a477 15986 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15987 ret = 1;
15988 break;
fb52b2f4 15989 }
2cf0635d 15990 namelen = strlen (name);
fb52b2f4 15991
2cf0635d
NC		 15992 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15993 if (qualified_name == NULL)
fb52b2f4 15994 {
2cf0635d 15995 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15996 ret = 1;
15997 break;
fb52b2f4
NC		 15998 }
15999
2cf0635d
NC		 16000 if (is_thin_archive && arch.nested_member_origin == 0)
16001 {
16002 /* This is a proxy for an external member of a thin archive. */
16003 FILE * member_file;
16004 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16005 if (member_file_name == NULL)
16006 {
16007 ret = 1;
16008 break;
16009 }
16010
16011 member_file = fopen (member_file_name, "rb");
16012 if (member_file == NULL)
16013 {
16014 error (_("Input file '%s' is not readable.\n"), member_file_name);
16015 free (member_file_name);
16016 ret = 1;
16017 break;
16018 }
16019
16020 archive_file_offset = arch.nested_member_origin;
16021
16022 ret |= process_object (qualified_name, member_file);
16023
16024 fclose (member_file);
16025 free (member_file_name);
16026 }
16027 else if (is_thin_archive)
16028 {
a043396b
NC		 16029 /* PR 15140: Allow for corrupt thin archives. */
16030 if (nested_arch.file == NULL)
16031 {
16032 error (_("%s: contains corrupt thin archive: %s\n"),
16033 file_name, name);
16034 ret = 1;
16035 break;
16036 }
16037
2cf0635d
NC		 16038 /* This is a proxy for a member of a nested archive. */
16039 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16040
16041 /* The nested archive file will have been opened and setup by
16042 get_archive_member_name. */
16043 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16044 {
16045 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16046 ret = 1;
16047 break;
16048 }
16049
16050 ret |= process_object (qualified_name, nested_arch.file);
16051 }
16052 else
16053 {
16054 archive_file_offset = arch.next_arhdr_offset;
16055 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16056
2cf0635d
NC		 16057 ret |= process_object (qualified_name, file);
16058 }
fb52b2f4 16059
2b52916e
L		 16060 if (dump_sects != NULL)
16061 {
16062 free (dump_sects);
16063 dump_sects = NULL;
16064 num_dump_sects = 0;
16065 }
16066
2cf0635d 16067 free (qualified_name);
fb52b2f4
NC		 16068 }
16069
4145f1d5 16070 out:
2cf0635d
NC		 16071 if (nested_arch.file != NULL)
16072 fclose (nested_arch.file);
16073 release_archive (&nested_arch);
16074 release_archive (&arch);
fb52b2f4 16075
d989285c 16076 return ret;
fb52b2f4
NC		 16077}
16078
16079static int
2cf0635d 16080process_file (char * file_name)
fb52b2f4 16081{
2cf0635d 16082 FILE * file;
fb52b2f4
NC		 16083 struct stat statbuf;
16084 char armag[SARMAG];
16085 int ret;
16086
16087 if (stat (file_name, &statbuf) < 0)
16088 {
f24ddbdd
NC		 16089 if (errno == ENOENT)
16090 error (_("'%s': No such file\n"), file_name);
16091 else
16092 error (_("Could not locate '%s'. System error message: %s\n"),
16093 file_name, strerror (errno));
16094 return 1;
16095 }
16096
16097 if (! S_ISREG (statbuf.st_mode))
16098 {
16099 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16100 return 1;
16101 }
16102
16103 file = fopen (file_name, "rb");
16104 if (file == NULL)
16105 {
f24ddbdd 16106 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16107 return 1;
16108 }
16109
16110 if (fread (armag, SARMAG, 1, file) != 1)
16111 {
4145f1d5 16112 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16113 fclose (file);
16114 return 1;
16115 }
16116
f54498b4
NC		 16117 current_file_size = (bfd_size_type) statbuf.st_size;
16118
fb52b2f4 16119 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16120 ret = process_archive (file_name, file, FALSE);
16121 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16122 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16123 else
16124 {
4145f1d5
NC		 16125 if (do_archive_index)
16126 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16127 file_name);
16128
fb52b2f4
NC		 16129 rewind (file);
16130 archive_file_size = archive_file_offset = 0;
16131 ret = process_object (file_name, file);
16132 }
16133
16134 fclose (file);
16135
f54498b4 16136 current_file_size = 0;
fb52b2f4
NC		 16137 return ret;
16138}
16139
252b5132
RH		 16140#ifdef SUPPORT_DISASSEMBLY
16141/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16142 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16143 symbols. */
252b5132
RH		 16144
16145void
2cf0635d 16146print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16147{
16148 fprintf (outfile,"0x%8.8x", addr);
16149}
16150
e3c8793a 16151/* Needed by the i386 disassembler. */
252b5132
RH		 16152void
16153db_task_printsym (unsigned int addr)
16154{
16155 print_address (addr, stderr);
16156}
16157#endif
16158
16159int
2cf0635d 16160main (int argc, char ** argv)
252b5132 16161{
ff78d6d6
L		 16162 int err;
16163
252b5132
RH		 16164#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16165 setlocale (LC_MESSAGES, "");
3882b010
L		 16166#endif
16167#if defined (HAVE_SETLOCALE)
16168 setlocale (LC_CTYPE, "");
252b5132
RH		 16169#endif
16170 bindtextdomain (PACKAGE, LOCALEDIR);
16171 textdomain (PACKAGE);
16172
869b9d07
MM		 16173 expandargv (&argc, &argv);
16174
252b5132
RH		 16175 parse_args (argc, argv);
16176
18bd398b 16177 if (num_dump_sects > 0)
59f14fc0 16178 {
18bd398b 16179 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16180 cmdline_dump_sects = (dump_type *)
16181 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16182 if (cmdline_dump_sects == NULL)
591a748a 16183 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16184 else
16185 {
09c11c86
NC		 16186 memcpy (cmdline_dump_sects, dump_sects,
16187 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16188 num_cmdline_dump_sects = num_dump_sects;
16189 }
16190 }
16191
18bd398b
NC		 16192 if (optind < (argc - 1))
16193 show_name = 1;
5656ba2c
L		 16194 else if (optind >= argc)
16195 {
16196 warn (_("Nothing to do.\n"));
16197 usage (stderr);
16198 }
18bd398b 16199
ff78d6d6 16200 err = 0;
252b5132 16201 while (optind < argc)
18bd398b 16202 err |= process_file (argv[optind++]);
252b5132
RH		 16203
16204 if (dump_sects != NULL)
16205 free (dump_sects);
59f14fc0
AS		 16206 if (cmdline_dump_sects != NULL)
16207 free (cmdline_dump_sects);
252b5132 16208
ff78d6d6 16209 return err;
252b5132 16210}
GDB Binutils - Deliverables
This page took 2.650732 seconds and 4 git commands to generate.