projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Xfail the compressed debug sections
[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. */
cfcac11d 5158 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 5159 };
5160
5161 if (do_section_details)
5162 {
8d5ff12c
L		 5163 sprintf (buff, "[%*.*lx]: ",
5164 field_size, field_size, (unsigned long) sh_flags);
5165 p += field_size + 4;
5477e8a0 5166 }
76da6bbe 5167
d1133906
NC		 5168 while (sh_flags)
5169 {
5170 bfd_vma flag;
5171
5172 flag = sh_flags & - sh_flags;
5173 sh_flags &= ~ flag;
76da6bbe 5174
5477e8a0 5175 if (do_section_details)
d1133906 5176 {
5477e8a0
L		 5177 switch (flag)
5178 {
91d6fa6a
NC		 5179 case SHF_WRITE: sindex = 0; break;
5180 case SHF_ALLOC: sindex = 1; break;
5181 case SHF_EXECINSTR: sindex = 2; break;
5182 case SHF_MERGE: sindex = 3; break;
5183 case SHF_STRINGS: sindex = 4; break;
5184 case SHF_INFO_LINK: sindex = 5; break;
5185 case SHF_LINK_ORDER: sindex = 6; break;
5186 case SHF_OS_NONCONFORMING: sindex = 7; break;
5187 case SHF_GROUP: sindex = 8; break;
5188 case SHF_TLS: sindex = 9; break;
18ae9cc1 5189 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 5190
5477e8a0 5191 default:
91d6fa6a 5192 sindex = -1;
cfcac11d 5193 switch (elf_header.e_machine)
148b93f2 5194 {
cfcac11d 5195 case EM_IA_64:
148b93f2 5196 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5197 sindex = 10;
148b93f2 5198 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5199 sindex = 11;
148b93f2
NC		 5200#ifdef BFD64
5201 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5202 switch (flag)
5203 {
91d6fa6a
NC		 5204 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5205 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5206 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5207 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5208 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5209 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5210 default: break;
5211 }
5212#endif
cfcac11d
NC		 5213 break;
5214
caa83f8b
NC		 5215 case EM_386:
5216 case EM_486:
5217 case EM_X86_64:
7f502d6c 5218 case EM_L1OM:
7a9068fe 5219 case EM_K1OM:
cfcac11d
NC		 5220 case EM_OLD_SPARCV9:
5221 case EM_SPARC32PLUS:
5222 case EM_SPARCV9:
5223 case EM_SPARC:
18ae9cc1 5224 if (flag == SHF_ORDERED)
91d6fa6a 5225 sindex = 19;
cfcac11d
NC		 5226 break;
5227 default:
5228 break;
148b93f2 5229 }
5477e8a0
L		 5230 }
5231
91d6fa6a 5232 if (sindex != -1)
5477e8a0 5233 {
8d5ff12c
L		 5234 if (p != buff + field_size + 4)
5235 {
5236 if (size < (10 + 2))
bee0ee85
NC		 5237 {
5238 warn (_("Internal error: not enough buffer room for section flag info"));
5239 return _("<unknown>");
5240 }
8d5ff12c
L		 5241 size -= 2;
5242 *p++ = ',';
5243 *p++ = ' ';
5244 }
5245
91d6fa6a
NC		 5246 size -= flags [sindex].len;
5247 p = stpcpy (p, flags [sindex].str);
5477e8a0 5248 }
3b22753a 5249 else if (flag & SHF_MASKOS)
8d5ff12c 5250 os_flags |= flag;
d1133906 5251 else if (flag & SHF_MASKPROC)
8d5ff12c 5252 proc_flags |= flag;
d1133906 5253 else
8d5ff12c 5254 unknown_flags |= flag;
5477e8a0
L		 5255 }
5256 else
5257 {
5258 switch (flag)
5259 {
5260 case SHF_WRITE: *p = 'W'; break;
5261 case SHF_ALLOC: *p = 'A'; break;
5262 case SHF_EXECINSTR: *p = 'X'; break;
5263 case SHF_MERGE: *p = 'M'; break;
5264 case SHF_STRINGS: *p = 'S'; break;
5265 case SHF_INFO_LINK: *p = 'I'; break;
5266 case SHF_LINK_ORDER: *p = 'L'; break;
5267 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5268 case SHF_GROUP: *p = 'G'; break;
5269 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5270 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 5271
5272 default:
8a9036a4 5273 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5274 || elf_header.e_machine == EM_L1OM
5275 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5276 && flag == SHF_X86_64_LARGE)
5277 *p = 'l';
5278 else if (flag & SHF_MASKOS)
5279 {
5280 *p = 'o';
5281 sh_flags &= ~ SHF_MASKOS;
5282 }
5283 else if (flag & SHF_MASKPROC)
5284 {
5285 *p = 'p';
5286 sh_flags &= ~ SHF_MASKPROC;
5287 }
5288 else
5289 *p = 'x';
5290 break;
5291 }
5292 p++;
d1133906
NC		 5293 }
5294 }
76da6bbe 5295
8d5ff12c
L		 5296 if (do_section_details)
5297 {
5298 if (os_flags)
5299 {
5300 size -= 5 + field_size;
5301 if (p != buff + field_size + 4)
5302 {
5303 if (size < (2 + 1))
bee0ee85
NC		 5304 {
5305 warn (_("Internal error: not enough buffer room for section flag info"));
5306 return _("<unknown>");
5307 }
8d5ff12c
L		 5308 size -= 2;
5309 *p++ = ',';
5310 *p++ = ' ';
5311 }
5312 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5313 (unsigned long) os_flags);
5314 p += 5 + field_size;
5315 }
5316 if (proc_flags)
5317 {
5318 size -= 7 + field_size;
5319 if (p != buff + field_size + 4)
5320 {
5321 if (size < (2 + 1))
bee0ee85
NC		 5322 {
5323 warn (_("Internal error: not enough buffer room for section flag info"));
5324 return _("<unknown>");
5325 }
8d5ff12c
L		 5326 size -= 2;
5327 *p++ = ',';
5328 *p++ = ' ';
5329 }
5330 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5331 (unsigned long) proc_flags);
5332 p += 7 + field_size;
5333 }
5334 if (unknown_flags)
5335 {
5336 size -= 10 + field_size;
5337 if (p != buff + field_size + 4)
5338 {
5339 if (size < (2 + 1))
bee0ee85
NC		 5340 {
5341 warn (_("Internal error: not enough buffer room for section flag info"));
5342 return _("<unknown>");
5343 }
8d5ff12c
L		 5344 size -= 2;
5345 *p++ = ',';
5346 *p++ = ' ';
5347 }
2b692964 5348 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5349 (unsigned long) unknown_flags);
5350 p += 10 + field_size;
5351 }
5352 }
5353
e9e44622 5354 *p = '\0';
d1133906
NC		 5355 return buff;
5356}
5357
252b5132 5358static int
2cf0635d 5359process_section_headers (FILE * file)
252b5132 5360{
2cf0635d 5361 Elf_Internal_Shdr * section;
b34976b6 5362 unsigned int i;
252b5132
RH		 5363
5364 section_headers = NULL;
5365
5366 if (elf_header.e_shnum == 0)
5367 {
82f2dbf7
NC		 5368 /* PR binutils/12467. */
5369 if (elf_header.e_shoff != 0)
5370 warn (_("possibly corrupt ELF file header - it has a non-zero"
5371 " section header offset, but no section headers\n"));
5372 else if (do_sections)
252b5132
RH		 5373 printf (_("\nThere are no sections in this file.\n"));
5374
5375 return 1;
5376 }
5377
5378 if (do_sections && !do_header)
9ea033b2 5379 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5380 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5381
9ea033b2
NC		 5382 if (is_32bit_elf)
5383 {
049b0c3a 5384 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5385 return 0;
5386 }
049b0c3a 5387 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5388 return 0;
5389
5390 /* Read in the string table, so that we have names to display. */
0b49d371 5391 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5392 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5393 {
4fbb74a6 5394 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5395
c256ffe7
JJ		 5396 if (section->sh_size != 0)
5397 {
3f5e193b
NC		 5398 string_table = (char *) get_data (NULL, file, section->sh_offset,
5399 1, section->sh_size,
5400 _("string table"));
0de14b54 5401
c256ffe7
JJ		 5402 string_table_length = string_table != NULL ? section->sh_size : 0;
5403 }
252b5132
RH		 5404 }
5405
5406 /* Scan the sections for the dynamic symbol table
e3c8793a 5407 and dynamic string table and debug sections. */
252b5132
RH		 5408 dynamic_symbols = NULL;
5409 dynamic_strings = NULL;
5410 dynamic_syminfo = NULL;
f1ef08cb 5411 symtab_shndx_hdr = NULL;
103f02d3 5412
89fac5e3
RS		 5413 eh_addr_size = is_32bit_elf ? 4 : 8;
5414 switch (elf_header.e_machine)
5415 {
5416 case EM_MIPS:
5417 case EM_MIPS_RS3_LE:
5418 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5419 FDE addresses. However, the ABI also has a semi-official ILP32
5420 variant for which the normal FDE address size rules apply.
5421
5422 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5423 section, where XX is the size of longs in bits. Unfortunately,
5424 earlier compilers provided no way of distinguishing ILP32 objects
5425 from LP64 objects, so if there's any doubt, we should assume that
5426 the official LP64 form is being used. */
5427 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5428 && find_section (".gcc_compiled_long32") == NULL)
5429 eh_addr_size = 8;
5430 break;
0f56a26a
DD		 5431
5432 case EM_H8_300:
5433 case EM_H8_300H:
5434 switch (elf_header.e_flags & EF_H8_MACH)
5435 {
5436 case E_H8_MACH_H8300:
5437 case E_H8_MACH_H8300HN:
5438 case E_H8_MACH_H8300SN:
5439 case E_H8_MACH_H8300SXN:
5440 eh_addr_size = 2;
5441 break;
5442 case E_H8_MACH_H8300H:
5443 case E_H8_MACH_H8300S:
5444 case E_H8_MACH_H8300SX:
5445 eh_addr_size = 4;
5446 break;
5447 }
f4236fe4
DD		 5448 break;
5449
ff7eeb89 5450 case EM_M32C_OLD:
f4236fe4
DD		 5451 case EM_M32C:
5452 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5453 {
5454 case EF_M32C_CPU_M16C:
5455 eh_addr_size = 2;
5456 break;
5457 }
5458 break;
89fac5e3
RS		 5459 }
5460
76ca31c0
NC		 5461#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5462 do \
5463 { \
5464 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5465 if (section->sh_entsize != expected_entsize) \
9dd3a467 5466 { \
76ca31c0
NC		 5467 char buf[40]; \
5468 sprintf_vma (buf, section->sh_entsize); \
5469 /* Note: coded this way so that there is a single string for \
5470 translation. */ \
5471 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5472 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5473 (unsigned) expected_entsize); \
9dd3a467 5474 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5475 } \
5476 } \
08d8fa11 5477 while (0)
9dd3a467
NC		 5478
5479#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5480 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5481 sizeof (Elf64_External_##type))
5482
252b5132
RH		 5483 for (i = 0, section = section_headers;
5484 i < elf_header.e_shnum;
b34976b6 5485 i++, section++)
252b5132 5486 {
2cf0635d 5487 char * name = SECTION_NAME (section);
252b5132
RH		 5488
5489 if (section->sh_type == SHT_DYNSYM)
5490 {
5491 if (dynamic_symbols != NULL)
5492 {
5493 error (_("File contains multiple dynamic symbol tables\n"));
5494 continue;
5495 }
5496
08d8fa11 5497 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5498 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5499 }
5500 else if (section->sh_type == SHT_STRTAB
18bd398b 5501 && streq (name, ".dynstr"))
252b5132
RH		 5502 {
5503 if (dynamic_strings != NULL)
5504 {
5505 error (_("File contains multiple dynamic string tables\n"));
5506 continue;
5507 }
5508
3f5e193b
NC		 5509 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5510 1, section->sh_size,
5511 _("dynamic strings"));
59245841 5512 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5513 }
9ad5cbcf
AM		 5514 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5515 {
5516 if (symtab_shndx_hdr != NULL)
5517 {
5518 error (_("File contains multiple symtab shndx tables\n"));
5519 continue;
5520 }
5521 symtab_shndx_hdr = section;
5522 }
08d8fa11
JJ		 5523 else if (section->sh_type == SHT_SYMTAB)
5524 CHECK_ENTSIZE (section, i, Sym);
5525 else if (section->sh_type == SHT_GROUP)
5526 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5527 else if (section->sh_type == SHT_REL)
5528 CHECK_ENTSIZE (section, i, Rel);
5529 else if (section->sh_type == SHT_RELA)
5530 CHECK_ENTSIZE (section, i, Rela);
252b5132 5531 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5532 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5533 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5534 || do_debug_str || do_debug_loc || do_debug_ranges
5535 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5536 && (const_strneq (name, ".debug_")
5537 || const_strneq (name, ".zdebug_")))
252b5132 5538 {
1b315056
CS		 5539 if (name[1] == 'z')
5540 name += sizeof (".zdebug_") - 1;
5541 else
5542 name += sizeof (".debug_") - 1;
252b5132
RH		 5543
5544 if (do_debugging
4723351a
CC		 5545 || (do_debug_info && const_strneq (name, "info"))
5546 || (do_debug_info && const_strneq (name, "types"))
5547 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5548 || (do_debug_lines && strcmp (name, "line") == 0)
5549 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5550 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5551 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5552 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5553 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5554 || (do_debug_aranges && const_strneq (name, "aranges"))
5555 || (do_debug_ranges && const_strneq (name, "ranges"))
5556 || (do_debug_frames && const_strneq (name, "frame"))
5557 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5558 || (do_debug_macinfo && const_strneq (name, "macro"))
5559 || (do_debug_str && const_strneq (name, "str"))
5560 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5561 || (do_debug_addr && const_strneq (name, "addr"))
5562 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5563 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5564 )
09c11c86 5565 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5566 }
a262ae96 5567 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5568 else if ((do_debugging || do_debug_info)
0112cd26 5569 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5570 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5571 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5572 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5573 else if (do_gdb_index && streq (name, ".gdb_index"))
5574 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5575 /* Trace sections for Itanium VMS. */
5576 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5577 || do_trace_aranges)
5578 && const_strneq (name, ".trace_"))
5579 {
5580 name += sizeof (".trace_") - 1;
5581
5582 if (do_debugging
5583 || (do_trace_info && streq (name, "info"))
5584 || (do_trace_abbrevs && streq (name, "abbrev"))
5585 || (do_trace_aranges && streq (name, "aranges"))
5586 )
5587 request_dump_bynumber (i, DEBUG_DUMP);
5588 }
252b5132
RH		 5589 }
5590
5591 if (! do_sections)
5592 return 1;
5593
3a1a2036
NC		 5594 if (elf_header.e_shnum > 1)
5595 printf (_("\nSection Headers:\n"));
5596 else
5597 printf (_("\nSection Header:\n"));
76da6bbe 5598
f7a99963 5599 if (is_32bit_elf)
595cf52e 5600 {
5477e8a0 5601 if (do_section_details)
595cf52e
L		 5602 {
5603 printf (_(" [Nr] Name\n"));
5477e8a0 5604 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5605 }
5606 else
5607 printf
5608 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5609 }
d974e256 5610 else if (do_wide)
595cf52e 5611 {
5477e8a0 5612 if (do_section_details)
595cf52e
L		 5613 {
5614 printf (_(" [Nr] Name\n"));
5477e8a0 5615 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5616 }
5617 else
5618 printf
5619 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5620 }
f7a99963
NC		 5621 else
5622 {
5477e8a0 5623 if (do_section_details)
595cf52e
L		 5624 {
5625 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5626 printf (_(" Type Address Offset Link\n"));
5627 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5628 }
5629 else
5630 {
5631 printf (_(" [Nr] Name Type Address Offset\n"));
5632 printf (_(" Size EntSize Flags Link Info Align\n"));
5633 }
f7a99963 5634 }
252b5132 5635
5477e8a0
L		 5636 if (do_section_details)
5637 printf (_(" Flags\n"));
5638
252b5132
RH		 5639 for (i = 0, section = section_headers;
5640 i < elf_header.e_shnum;
b34976b6 5641 i++, section++)
252b5132 5642 {
7bfd842d 5643 printf (" [%2u] ", i);
5477e8a0 5644 if (do_section_details)
74e1a04b 5645 printf ("%s\n ", printable_section_name (section));
595cf52e 5646 else
74e1a04b 5647 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5648
ea52a088
NC		 5649 printf (do_wide ? " %-15s " : " %-15.15s ",
5650 get_section_type_name (section->sh_type));
0b4362b0 5651
f7a99963
NC		 5652 if (is_32bit_elf)
5653 {
cfcac11d
NC		 5654 const char * link_too_big = NULL;
5655
f7a99963 5656 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5657
f7a99963
NC		 5658 printf ( " %6.6lx %6.6lx %2.2lx",
5659 (unsigned long) section->sh_offset,
5660 (unsigned long) section->sh_size,
5661 (unsigned long) section->sh_entsize);
d1133906 5662
5477e8a0
L		 5663 if (do_section_details)
5664 fputs (" ", stdout);
5665 else
5666 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5667
cfcac11d
NC		 5668 if (section->sh_link >= elf_header.e_shnum)
5669 {
5670 link_too_big = "";
5671 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5672 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5673 switch (elf_header.e_machine)
5674 {
caa83f8b
NC		 5675 case EM_386:
5676 case EM_486:
5677 case EM_X86_64:
7f502d6c 5678 case EM_L1OM:
7a9068fe 5679 case EM_K1OM:
cfcac11d
NC		 5680 case EM_OLD_SPARCV9:
5681 case EM_SPARC32PLUS:
5682 case EM_SPARCV9:
5683 case EM_SPARC:
5684 if (section->sh_link == (SHN_BEFORE & 0xffff))
5685 link_too_big = "BEFORE";
5686 else if (section->sh_link == (SHN_AFTER & 0xffff))
5687 link_too_big = "AFTER";
5688 break;
5689 default:
5690 break;
5691 }
5692 }
5693
5694 if (do_section_details)
5695 {
5696 if (link_too_big != NULL && * link_too_big)
5697 printf ("<%s> ", link_too_big);
5698 else
5699 printf ("%2u ", section->sh_link);
5700 printf ("%3u %2lu\n", section->sh_info,
5701 (unsigned long) section->sh_addralign);
5702 }
5703 else
5704 printf ("%2u %3u %2lu\n",
5705 section->sh_link,
5706 section->sh_info,
5707 (unsigned long) section->sh_addralign);
5708
5709 if (link_too_big && ! * link_too_big)
5710 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5711 i, section->sh_link);
f7a99963 5712 }
d974e256
JJ		 5713 else if (do_wide)
5714 {
5715 print_vma (section->sh_addr, LONG_HEX);
5716
5717 if ((long) section->sh_offset == section->sh_offset)
5718 printf (" %6.6lx", (unsigned long) section->sh_offset);
5719 else
5720 {
5721 putchar (' ');
5722 print_vma (section->sh_offset, LONG_HEX);
5723 }
5724
5725 if ((unsigned long) section->sh_size == section->sh_size)
5726 printf (" %6.6lx", (unsigned long) section->sh_size);
5727 else
5728 {
5729 putchar (' ');
5730 print_vma (section->sh_size, LONG_HEX);
5731 }
5732
5733 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5734 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5735 else
5736 {
5737 putchar (' ');
5738 print_vma (section->sh_entsize, LONG_HEX);
5739 }
5740
5477e8a0
L		 5741 if (do_section_details)
5742 fputs (" ", stdout);
5743 else
5744 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5745
72de5009 5746 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5747
5748 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5749 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5750 else
5751 {
5752 print_vma (section->sh_addralign, DEC);
5753 putchar ('\n');
5754 }
5755 }
5477e8a0 5756 else if (do_section_details)
595cf52e 5757 {
5477e8a0 5758 printf (" %-15.15s ",
595cf52e 5759 get_section_type_name (section->sh_type));
595cf52e
L		 5760 print_vma (section->sh_addr, LONG_HEX);
5761 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5762 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5763 else
5764 {
5765 printf (" ");
5766 print_vma (section->sh_offset, LONG_HEX);
5767 }
72de5009 5768 printf (" %u\n ", section->sh_link);
595cf52e 5769 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5770 putchar (' ');
595cf52e
L		 5771 print_vma (section->sh_entsize, LONG_HEX);
5772
72de5009
AM		 5773 printf (" %-16u %lu\n",
5774 section->sh_info,
595cf52e
L		 5775 (unsigned long) section->sh_addralign);
5776 }
f7a99963
NC		 5777 else
5778 {
5779 putchar (' ');
5780 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5781 if ((long) section->sh_offset == section->sh_offset)
5782 printf (" %8.8lx", (unsigned long) section->sh_offset);
5783 else
5784 {
5785 printf (" ");
5786 print_vma (section->sh_offset, LONG_HEX);
5787 }
f7a99963
NC		 5788 printf ("\n ");
5789 print_vma (section->sh_size, LONG_HEX);
5790 printf (" ");
5791 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5792
d1133906 5793 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5794
72de5009
AM		 5795 printf (" %2u %3u %lu\n",
5796 section->sh_link,
5797 section->sh_info,
f7a99963
NC		 5798 (unsigned long) section->sh_addralign);
5799 }
5477e8a0
L		 5800
5801 if (do_section_details)
5802 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5803 }
5804
5477e8a0 5805 if (!do_section_details)
3dbcc61d
NC		 5806 {
5807 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5808 || elf_header.e_machine == EM_L1OM
5809 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5810 printf (_("Key to Flags:\n\
5811 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5812 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5813 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5814 else
5815 printf (_("Key to Flags:\n\
e3c8793a 5816 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5817 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5818 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5819 }
d1133906 5820
252b5132
RH		 5821 return 1;
5822}
5823
f5842774
L		 5824static const char *
5825get_group_flags (unsigned int flags)
5826{
5827 static char buff[32];
5828 switch (flags)
5829 {
220453ec
AM		 5830 case 0:
5831 return "";
5832
f5842774 5833 case GRP_COMDAT:
220453ec 5834 return "COMDAT ";
f5842774
L		 5835
5836 default:
220453ec 5837 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5838 break;
5839 }
5840 return buff;
5841}
5842
5843static int
2cf0635d 5844process_section_groups (FILE * file)
f5842774 5845{
2cf0635d 5846 Elf_Internal_Shdr * section;
f5842774 5847 unsigned int i;
2cf0635d
NC		 5848 struct group * group;
5849 Elf_Internal_Shdr * symtab_sec;
5850 Elf_Internal_Shdr * strtab_sec;
5851 Elf_Internal_Sym * symtab;
ba5cdace 5852 unsigned long num_syms;
2cf0635d 5853 char * strtab;
c256ffe7 5854 size_t strtab_size;
d1f5c6e3
L		 5855
5856 /* Don't process section groups unless needed. */
5857 if (!do_unwind && !do_section_groups)
5858 return 1;
f5842774
L		 5859
5860 if (elf_header.e_shnum == 0)
5861 {
5862 if (do_section_groups)
82f2dbf7 5863 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5864
5865 return 1;
5866 }
5867
5868 if (section_headers == NULL)
5869 {
5870 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5871 /* PR 13622: This can happen with a corrupt ELF header. */
5872 return 0;
f5842774
L		 5873 }
5874
3f5e193b
NC		 5875 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5876 sizeof (struct group *));
e4b17d5c
L		 5877
5878 if (section_headers_groups == NULL)
5879 {
8b73c356
NC		 5880 error (_("Out of memory reading %u section group headers\n"),
5881 elf_header.e_shnum);
e4b17d5c
L		 5882 return 0;
5883 }
5884
f5842774 5885 /* Scan the sections for the group section. */
d1f5c6e3 5886 group_count = 0;
f5842774
L		 5887 for (i = 0, section = section_headers;
5888 i < elf_header.e_shnum;
5889 i++, section++)
e4b17d5c
L		 5890 if (section->sh_type == SHT_GROUP)
5891 group_count++;
5892
d1f5c6e3
L		 5893 if (group_count == 0)
5894 {
5895 if (do_section_groups)
5896 printf (_("\nThere are no section groups in this file.\n"));
5897
5898 return 1;
5899 }
5900
3f5e193b 5901 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5902
5903 if (section_groups == NULL)
5904 {
8b73c356
NC		 5905 error (_("Out of memory reading %lu groups\n"),
5906 (unsigned long) group_count);
e4b17d5c
L		 5907 return 0;
5908 }
5909
d1f5c6e3
L		 5910 symtab_sec = NULL;
5911 strtab_sec = NULL;
5912 symtab = NULL;
ba5cdace 5913 num_syms = 0;
d1f5c6e3 5914 strtab = NULL;
c256ffe7 5915 strtab_size = 0;
e4b17d5c
L		 5916 for (i = 0, section = section_headers, group = section_groups;
5917 i < elf_header.e_shnum;
5918 i++, section++)
f5842774
L		 5919 {
5920 if (section->sh_type == SHT_GROUP)
5921 {
74e1a04b
NC		 5922 const char * name = printable_section_name (section);
5923 const char * group_name;
2cf0635d
NC		 5924 unsigned char * start;
5925 unsigned char * indices;
f5842774 5926 unsigned int entry, j, size;
2cf0635d
NC		 5927 Elf_Internal_Shdr * sec;
5928 Elf_Internal_Sym * sym;
f5842774
L		 5929
5930 /* Get the symbol table. */
4fbb74a6
AM		 5931 if (section->sh_link >= elf_header.e_shnum
5932 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5933 != SHT_SYMTAB))
f5842774
L		 5934 {
5935 error (_("Bad sh_link in group section `%s'\n"), name);
5936 continue;
5937 }
d1f5c6e3
L		 5938
5939 if (symtab_sec != sec)
5940 {
5941 symtab_sec = sec;
5942 if (symtab)
5943 free (symtab);
ba5cdace 5944 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5945 }
f5842774 5946
dd24e3da
NC		 5947 if (symtab == NULL)
5948 {
5949 error (_("Corrupt header in group section `%s'\n"), name);
5950 continue;
5951 }
5952
ba5cdace
NC		 5953 if (section->sh_info >= num_syms)
5954 {
5955 error (_("Bad sh_info in group section `%s'\n"), name);
5956 continue;
5957 }
5958
f5842774
L		 5959 sym = symtab + section->sh_info;
5960
5961 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5962 {
4fbb74a6
AM		 5963 if (sym->st_shndx == 0
5964 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5965 {
5966 error (_("Bad sh_info in group section `%s'\n"), name);
5967 continue;
5968 }
ba2685cc 5969
4fbb74a6 5970 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5971 strtab_sec = NULL;
5972 if (strtab)
5973 free (strtab);
f5842774 5974 strtab = NULL;
c256ffe7 5975 strtab_size = 0;
f5842774
L		 5976 }
5977 else
5978 {
5979 /* Get the string table. */
4fbb74a6 5980 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5981 {
5982 strtab_sec = NULL;
5983 if (strtab)
5984 free (strtab);
5985 strtab = NULL;
5986 strtab_size = 0;
5987 }
5988 else if (strtab_sec
4fbb74a6 5989 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5990 {
5991 strtab_sec = sec;
5992 if (strtab)
5993 free (strtab);
071436c6 5994
3f5e193b 5995 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 5996 1, strtab_sec->sh_size,
5997 _("string table"));
c256ffe7 5998 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5999 }
c256ffe7 6000 group_name = sym->st_name < strtab_size
2b692964 6001 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6002 }
6003
c9c1d674
EG		 6004 /* PR 17531: file: loop. */
6005 if (section->sh_entsize > section->sh_size)
6006 {
6007 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6008 printable_section_name (section),
8066deb1
AM		 6009 (unsigned long) section->sh_entsize,
6010 (unsigned long) section->sh_size);
c9c1d674
EG		 6011 break;
6012 }
6013
3f5e193b
NC		 6014 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6015 1, section->sh_size,
6016 _("section data"));
59245841
NC		 6017 if (start == NULL)
6018 continue;
f5842774
L		 6019
6020 indices = start;
6021 size = (section->sh_size / section->sh_entsize) - 1;
6022 entry = byte_get (indices, 4);
6023 indices += 4;
e4b17d5c
L		 6024
6025 if (do_section_groups)
6026 {
2b692964 6027 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6028 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6029
e4b17d5c
L		 6030 printf (_(" [Index] Name\n"));
6031 }
6032
6033 group->group_index = i;
6034
f5842774
L		 6035 for (j = 0; j < size; j++)
6036 {
2cf0635d 6037 struct group_list * g;
e4b17d5c 6038
f5842774
L		 6039 entry = byte_get (indices, 4);
6040 indices += 4;
6041
4fbb74a6 6042 if (entry >= elf_header.e_shnum)
391cb864 6043 {
57028622
NC		 6044 static unsigned num_group_errors = 0;
6045
6046 if (num_group_errors ++ < 10)
6047 {
6048 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6049 entry, i, elf_header.e_shnum - 1);
6050 if (num_group_errors == 10)
6051 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6052 }
391cb864
L		 6053 continue;
6054 }
391cb864 6055
4fbb74a6 6056 if (section_headers_groups [entry] != NULL)
e4b17d5c 6057 {
d1f5c6e3
L		 6058 if (entry)
6059 {
57028622
NC		 6060 static unsigned num_errs = 0;
6061
6062 if (num_errs ++ < 10)
6063 {
6064 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6065 entry, i,
6066 section_headers_groups [entry]->group_index);
6067 if (num_errs == 10)
6068 warn (_("Further error messages about already contained group sections suppressed\n"));
6069 }
d1f5c6e3
L		 6070 continue;
6071 }
6072 else
6073 {
6074 /* Intel C/C++ compiler may put section 0 in a
6075 section group. We just warn it the first time
6076 and ignore it afterwards. */
6077 static int warned = 0;
6078 if (!warned)
6079 {
6080 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6081 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6082 warned++;
6083 }
6084 }
e4b17d5c
L		 6085 }
6086
4fbb74a6 6087 section_headers_groups [entry] = group;
e4b17d5c
L		 6088
6089 if (do_section_groups)
6090 {
4fbb74a6 6091 sec = section_headers + entry;
74e1a04b 6092 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6093 }
6094
3f5e193b 6095 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6096 g->section_index = entry;
6097 g->next = group->root;
6098 group->root = g;
f5842774
L		 6099 }
6100
f5842774
L		 6101 if (start)
6102 free (start);
e4b17d5c
L		 6103
6104 group++;
f5842774
L		 6105 }
6106 }
6107
d1f5c6e3
L		 6108 if (symtab)
6109 free (symtab);
6110 if (strtab)
6111 free (strtab);
f5842774
L		 6112 return 1;
6113}
6114
28f997cf
TG		 6115/* Data used to display dynamic fixups. */
6116
6117struct ia64_vms_dynfixup
6118{
6119 bfd_vma needed_ident; /* Library ident number. */
6120 bfd_vma needed; /* Index in the dstrtab of the library name. */
6121 bfd_vma fixup_needed; /* Index of the library. */
6122 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6123 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6124};
6125
6126/* Data used to display dynamic relocations. */
6127
6128struct ia64_vms_dynimgrela
6129{
6130 bfd_vma img_rela_cnt; /* Number of relocations. */
6131 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6132};
6133
6134/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6135 library). */
6136
6137static void
6138dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6139 const char *strtab, unsigned int strtab_sz)
6140{
6141 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6142 long i;
6143 const char *lib_name;
6144
6145 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6146 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6147 _("dynamic section image fixups"));
6148 if (!imfs)
6149 return;
6150
6151 if (fixup->needed < strtab_sz)
6152 lib_name = strtab + fixup->needed;
6153 else
6154 {
6155 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6156 (unsigned long) fixup->needed);
28f997cf
TG		 6157 lib_name = "???";
6158 }
6159 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6160 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6161 printf
6162 (_("Seg Offset Type SymVec DataType\n"));
6163
6164 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6165 {
6166 unsigned int type;
6167 const char *rtype;
6168
6169 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6170 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6171 type = BYTE_GET (imfs [i].type);
6172 rtype = elf_ia64_reloc_type (type);
6173 if (rtype == NULL)
6174 printf (" 0x%08x ", type);
6175 else
6176 printf (" %-32s ", rtype);
6177 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6178 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6179 }
6180
6181 free (imfs);
6182}
6183
6184/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6185
6186static void
6187dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6188{
6189 Elf64_External_VMS_IMAGE_RELA *imrs;
6190 long i;
6191
6192 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6193 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6194 _("dynamic section image relocations"));
28f997cf
TG		 6195 if (!imrs)
6196 return;
6197
6198 printf (_("\nImage relocs\n"));
6199 printf
6200 (_("Seg Offset Type Addend Seg Sym Off\n"));
6201
6202 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6203 {
6204 unsigned int type;
6205 const char *rtype;
6206
6207 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6208 printf ("%08" BFD_VMA_FMT "x ",
6209 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6210 type = BYTE_GET (imrs [i].type);
6211 rtype = elf_ia64_reloc_type (type);
6212 if (rtype == NULL)
6213 printf ("0x%08x ", type);
6214 else
6215 printf ("%-31s ", rtype);
6216 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6217 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6218 printf ("%08" BFD_VMA_FMT "x\n",
6219 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6220 }
6221
6222 free (imrs);
6223}
6224
6225/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6226
6227static int
6228process_ia64_vms_dynamic_relocs (FILE *file)
6229{
6230 struct ia64_vms_dynfixup fixup;
6231 struct ia64_vms_dynimgrela imgrela;
6232 Elf_Internal_Dyn *entry;
6233 int res = 0;
6234 bfd_vma strtab_off = 0;
6235 bfd_vma strtab_sz = 0;
6236 char *strtab = NULL;
6237
6238 memset (&fixup, 0, sizeof (fixup));
6239 memset (&imgrela, 0, sizeof (imgrela));
6240
6241 /* Note: the order of the entries is specified by the OpenVMS specs. */
6242 for (entry = dynamic_section;
6243 entry < dynamic_section + dynamic_nent;
6244 entry++)
6245 {
6246 switch (entry->d_tag)
6247 {
6248 case DT_IA_64_VMS_STRTAB_OFFSET:
6249 strtab_off = entry->d_un.d_val;
6250 break;
6251 case DT_STRSZ:
6252 strtab_sz = entry->d_un.d_val;
6253 if (strtab == NULL)
6254 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6255 1, strtab_sz, _("dynamic string section"));
6256 break;
6257
6258 case DT_IA_64_VMS_NEEDED_IDENT:
6259 fixup.needed_ident = entry->d_un.d_val;
6260 break;
6261 case DT_NEEDED:
6262 fixup.needed = entry->d_un.d_val;
6263 break;
6264 case DT_IA_64_VMS_FIXUP_NEEDED:
6265 fixup.fixup_needed = entry->d_un.d_val;
6266 break;
6267 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6268 fixup.fixup_rela_cnt = entry->d_un.d_val;
6269 break;
6270 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6271 fixup.fixup_rela_off = entry->d_un.d_val;
6272 res++;
6273 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6274 break;
6275
6276 case DT_IA_64_VMS_IMG_RELA_CNT:
6277 imgrela.img_rela_cnt = entry->d_un.d_val;
6278 break;
6279 case DT_IA_64_VMS_IMG_RELA_OFF:
6280 imgrela.img_rela_off = entry->d_un.d_val;
6281 res++;
6282 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6283 break;
6284
6285 default:
6286 break;
6287 }
6288 }
6289
6290 if (strtab != NULL)
6291 free (strtab);
6292
6293 return res;
6294}
6295
85b1c36d 6296static struct
566b0d53 6297{
2cf0635d 6298 const char * name;
566b0d53
L		 6299 int reloc;
6300 int size;
6301 int rela;
6302} dynamic_relocations [] =
6303{
6304 { "REL", DT_REL, DT_RELSZ, FALSE },
6305 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6306 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6307};
6308
252b5132 6309/* Process the reloc section. */
18bd398b 6310
252b5132 6311static int
2cf0635d 6312process_relocs (FILE * file)
252b5132 6313{
b34976b6
AM		 6314 unsigned long rel_size;
6315 unsigned long rel_offset;
252b5132
RH		 6316
6317
6318 if (!do_reloc)
6319 return 1;
6320
6321 if (do_using_dynamic)
6322 {
566b0d53 6323 int is_rela;
2cf0635d 6324 const char * name;
566b0d53
L		 6325 int has_dynamic_reloc;
6326 unsigned int i;
0de14b54 6327
566b0d53 6328 has_dynamic_reloc = 0;
252b5132 6329
566b0d53 6330 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6331 {
566b0d53
L		 6332 is_rela = dynamic_relocations [i].rela;
6333 name = dynamic_relocations [i].name;
6334 rel_size = dynamic_info [dynamic_relocations [i].size];
6335 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6336
566b0d53
L		 6337 has_dynamic_reloc |= rel_size;
6338
6339 if (is_rela == UNKNOWN)
aa903cfb 6340 {
566b0d53
L		 6341 if (dynamic_relocations [i].reloc == DT_JMPREL)
6342 switch (dynamic_info[DT_PLTREL])
6343 {
6344 case DT_REL:
6345 is_rela = FALSE;
6346 break;
6347 case DT_RELA:
6348 is_rela = TRUE;
6349 break;
6350 }
aa903cfb 6351 }
252b5132 6352
566b0d53
L		 6353 if (rel_size)
6354 {
6355 printf
6356 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6357 name, rel_offset, rel_size);
252b5132 6358
d93f0186
NC		 6359 dump_relocations (file,
6360 offset_from_vma (file, rel_offset, rel_size),
6361 rel_size,
566b0d53 6362 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6363 dynamic_strings, dynamic_strings_length,
6364 is_rela, 1);
566b0d53 6365 }
252b5132 6366 }
566b0d53 6367
28f997cf
TG		 6368 if (is_ia64_vms ())
6369 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6370
566b0d53 6371 if (! has_dynamic_reloc)
252b5132
RH		 6372 printf (_("\nThere are no dynamic relocations in this file.\n"));
6373 }
6374 else
6375 {
2cf0635d 6376 Elf_Internal_Shdr * section;
b34976b6
AM		 6377 unsigned long i;
6378 int found = 0;
252b5132
RH		 6379
6380 for (i = 0, section = section_headers;
6381 i < elf_header.e_shnum;
b34976b6 6382 i++, section++)
252b5132
RH		 6383 {
6384 if ( section->sh_type != SHT_RELA
6385 && section->sh_type != SHT_REL)
6386 continue;
6387
6388 rel_offset = section->sh_offset;
6389 rel_size = section->sh_size;
6390
6391 if (rel_size)
6392 {
2cf0635d 6393 Elf_Internal_Shdr * strsec;
b34976b6 6394 int is_rela;
103f02d3 6395
252b5132
RH		 6396 printf (_("\nRelocation section "));
6397
6398 if (string_table == NULL)
19936277 6399 printf ("%d", section->sh_name);
252b5132 6400 else
74e1a04b 6401 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6402
6403 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6404 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6405
d79b3d50
NC		 6406 is_rela = section->sh_type == SHT_RELA;
6407
4fbb74a6
AM		 6408 if (section->sh_link != 0
6409 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6410 {
2cf0635d
NC		 6411 Elf_Internal_Shdr * symsec;
6412 Elf_Internal_Sym * symtab;
d79b3d50 6413 unsigned long nsyms;
c256ffe7 6414 unsigned long strtablen = 0;
2cf0635d 6415 char * strtab = NULL;
57346661 6416
4fbb74a6 6417 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6418 if (symsec->sh_type != SHT_SYMTAB
6419 && symsec->sh_type != SHT_DYNSYM)
6420 continue;
6421
ba5cdace 6422 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6423
af3fc3bc
AM		 6424 if (symtab == NULL)
6425 continue;
252b5132 6426
4fbb74a6
AM		 6427 if (symsec->sh_link != 0
6428 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6429 {
4fbb74a6 6430 strsec = section_headers + symsec->sh_link;
103f02d3 6431
3f5e193b 6432 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6433 1, strsec->sh_size,
6434 _("string table"));
c256ffe7
JJ		 6435 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6436 }
252b5132 6437
d79b3d50 6438 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6439 symtab, nsyms, strtab, strtablen,
6440 is_rela,
6441 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6442 if (strtab)
6443 free (strtab);
6444 free (symtab);
6445 }
6446 else
6447 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6448 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6449
6450 found = 1;
6451 }
6452 }
6453
6454 if (! found)
6455 printf (_("\nThere are no relocations in this file.\n"));
6456 }
6457
6458 return 1;
6459}
6460
4d6ed7c8
NC		 6461/* An absolute address consists of a section and an offset. If the
6462 section is NULL, the offset itself is the address, otherwise, the
6463 address equals to LOAD_ADDRESS(section) + offset. */
6464
6465struct absaddr
948f632f
DA		 6466{
6467 unsigned short section;
6468 bfd_vma offset;
6469};
4d6ed7c8 6470
1949de15
L		 6471#define ABSADDR(a) \
6472 ((a).section \
6473 ? section_headers [(a).section].sh_addr + (a).offset \
6474 : (a).offset)
6475
948f632f
DA		 6476/* Find the nearest symbol at or below ADDR. Returns the symbol
6477 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6478
4d6ed7c8 6479static void
2cf0635d 6480find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6481 unsigned long nsyms,
6482 const char * strtab,
6483 unsigned long strtab_size,
6484 struct absaddr addr,
6485 const char ** symname,
6486 bfd_vma * offset)
4d6ed7c8 6487{
d3ba0551 6488 bfd_vma dist = 0x100000;
2cf0635d 6489 Elf_Internal_Sym * sym;
948f632f
DA		 6490 Elf_Internal_Sym * beg;
6491 Elf_Internal_Sym * end;
2cf0635d 6492 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6493
0b6ae522 6494 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6495 beg = symtab;
6496 end = symtab + nsyms;
0b6ae522 6497
948f632f 6498 while (beg < end)
4d6ed7c8 6499 {
948f632f
DA		 6500 bfd_vma value;
6501
6502 sym = beg + (end - beg) / 2;
0b6ae522 6503
948f632f 6504 value = sym->st_value;
0b6ae522
DJ		 6505 REMOVE_ARCH_BITS (value);
6506
948f632f 6507 if (sym->st_name != 0
4d6ed7c8 6508 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6509 && addr.offset >= value
6510 && addr.offset - value < dist)
4d6ed7c8
NC		 6511 {
6512 best = sym;
0b6ae522 6513 dist = addr.offset - value;
4d6ed7c8
NC		 6514 if (!dist)
6515 break;
6516 }
948f632f
DA		 6517
6518 if (addr.offset < value)
6519 end = sym;
6520 else
6521 beg = sym + 1;
4d6ed7c8 6522 }
1b31d05e 6523
4d6ed7c8
NC		 6524 if (best)
6525 {
57346661 6526 *symname = (best->st_name >= strtab_size
2b692964 6527 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6528 *offset = dist;
6529 return;
6530 }
1b31d05e 6531
4d6ed7c8
NC		 6532 *symname = NULL;
6533 *offset = addr.offset;
6534}
6535
948f632f
DA		 6536static int
6537symcmp (const void *p, const void *q)
6538{
6539 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6540 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6541
6542 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6543}
6544
6545/* Process the unwind section. */
6546
6547#include "unwind-ia64.h"
6548
6549struct ia64_unw_table_entry
6550{
6551 struct absaddr start;
6552 struct absaddr end;
6553 struct absaddr info;
6554};
6555
6556struct ia64_unw_aux_info
6557{
6558 struct ia64_unw_table_entry *table; /* Unwind table. */
6559 unsigned long table_len; /* Length of unwind table. */
6560 unsigned char * info; /* Unwind info. */
6561 unsigned long info_size; /* Size of unwind info. */
6562 bfd_vma info_addr; /* Starting address of unwind info. */
6563 bfd_vma seg_base; /* Starting address of segment. */
6564 Elf_Internal_Sym * symtab; /* The symbol table. */
6565 unsigned long nsyms; /* Number of symbols. */
6566 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6567 unsigned long nfuns; /* Number of entries in funtab. */
6568 char * strtab; /* The string table. */
6569 unsigned long strtab_size; /* Size of string table. */
6570};
6571
4d6ed7c8 6572static void
2cf0635d 6573dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6574{
2cf0635d 6575 struct ia64_unw_table_entry * tp;
948f632f 6576 unsigned long j, nfuns;
4d6ed7c8 6577 int in_body;
7036c0e1 6578
948f632f
DA		 6579 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6580 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6581 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6582 aux->funtab[nfuns++] = aux->symtab[j];
6583 aux->nfuns = nfuns;
6584 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6585
4d6ed7c8
NC		 6586 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6587 {
6588 bfd_vma stamp;
6589 bfd_vma offset;
2cf0635d
NC		 6590 const unsigned char * dp;
6591 const unsigned char * head;
53774b7e 6592 const unsigned char * end;
2cf0635d 6593 const char * procname;
4d6ed7c8 6594
948f632f 6595 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6596 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6597
6598 fputs ("\n<", stdout);
6599
6600 if (procname)
6601 {
6602 fputs (procname, stdout);
6603
6604 if (offset)
6605 printf ("+%lx", (unsigned long) offset);
6606 }
6607
6608 fputs (">: [", stdout);
6609 print_vma (tp->start.offset, PREFIX_HEX);
6610 fputc ('-', stdout);
6611 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6612 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6613 (unsigned long) (tp->info.offset - aux->seg_base));
6614
53774b7e
NC		 6615 /* PR 17531: file: 86232b32. */
6616 if (aux->info == NULL)
6617 continue;
6618
6619 /* PR 17531: file: 0997b4d1. */
6620 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6621 {
6622 warn (_("Invalid offset %lx in table entry %ld\n"),
6623 (long) tp->info.offset, (long) (tp - aux->table));
6624 continue;
6625 }
6626
1949de15 6627 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6628 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6629
86f55779 6630 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6631 (unsigned) UNW_VER (stamp),
6632 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6633 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6634 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6635 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6636
6637 if (UNW_VER (stamp) != 1)
6638 {
2b692964 6639 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6640 continue;
6641 }
6642
6643 in_body = 0;
53774b7e
NC		 6644 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6645 /* PR 17531: file: 16ceda89. */
6646 if (end > aux->info + aux->info_size)
6647 end = aux->info + aux->info_size;
6648 for (dp = head + 8; dp < end;)
4d6ed7c8
NC		 6649 dp = unw_decode (dp, in_body, & in_body);
6650 }
948f632f
DA		 6651
6652 free (aux->funtab);
4d6ed7c8
NC		 6653}
6654
53774b7e 6655static bfd_boolean
2cf0635d
NC		 6656slurp_ia64_unwind_table (FILE * file,
6657 struct ia64_unw_aux_info * aux,
6658 Elf_Internal_Shdr * sec)
4d6ed7c8 6659{
89fac5e3 6660 unsigned long size, nrelas, i;
2cf0635d
NC		 6661 Elf_Internal_Phdr * seg;
6662 struct ia64_unw_table_entry * tep;
6663 Elf_Internal_Shdr * relsec;
6664 Elf_Internal_Rela * rela;
6665 Elf_Internal_Rela * rp;
6666 unsigned char * table;
6667 unsigned char * tp;
6668 Elf_Internal_Sym * sym;
6669 const char * relname;
4d6ed7c8 6670
53774b7e
NC		 6671 aux->table_len = 0;
6672
4d6ed7c8
NC		 6673 /* First, find the starting address of the segment that includes
6674 this section: */
6675
6676 if (elf_header.e_phnum)
6677 {
d93f0186 6678 if (! get_program_headers (file))
53774b7e 6679 return FALSE;
4d6ed7c8 6680
d93f0186
NC		 6681 for (seg = program_headers;
6682 seg < program_headers + elf_header.e_phnum;
6683 ++seg)
4d6ed7c8
NC		 6684 {
6685 if (seg->p_type != PT_LOAD)
6686 continue;
6687
6688 if (sec->sh_addr >= seg->p_vaddr
6689 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6690 {
6691 aux->seg_base = seg->p_vaddr;
6692 break;
6693 }
6694 }
4d6ed7c8
NC		 6695 }
6696
6697 /* Second, build the unwind table from the contents of the unwind section: */
6698 size = sec->sh_size;
3f5e193b
NC		 6699 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6700 _("unwind table"));
a6e9f9df 6701 if (!table)
53774b7e 6702 return FALSE;
4d6ed7c8 6703
53774b7e 6704 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6705 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6706 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6707 tep = aux->table;
53774b7e
NC		 6708
6709 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6710 {
6711 tep->start.section = SHN_UNDEF;
6712 tep->end.section = SHN_UNDEF;
6713 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6714 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6715 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6716 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6717 tep->start.offset += aux->seg_base;
6718 tep->end.offset += aux->seg_base;
6719 tep->info.offset += aux->seg_base;
6720 }
6721 free (table);
6722
41e92641 6723 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6724 for (relsec = section_headers;
6725 relsec < section_headers + elf_header.e_shnum;
6726 ++relsec)
6727 {
6728 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6729 || relsec->sh_info >= elf_header.e_shnum
6730 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6731 continue;
6732
6733 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6734 & rela, & nrelas))
53774b7e
NC		 6735 {
6736 free (aux->table);
6737 aux->table = NULL;
6738 aux->table_len = 0;
6739 return FALSE;
6740 }
4d6ed7c8
NC		 6741
6742 for (rp = rela; rp < rela + nrelas; ++rp)
6743 {
aca88567
NC		 6744 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6745 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6746
82b1b41b
NC		 6747 /* PR 17531: file: 9fa67536. */
6748 if (relname == NULL)
6749 {
6750 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6751 continue;
6752 }
948f632f 6753
0112cd26 6754 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6755 {
82b1b41b 6756 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6757 continue;
6758 }
6759
89fac5e3 6760 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6761
53774b7e
NC		 6762 /* PR 17531: file: 5bc8d9bf. */
6763 if (i >= aux->table_len)
6764 {
6765 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6766 continue;
6767 }
6768
6769 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6770 {
6771 case 0:
6772 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6773 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6774 break;
6775 case 1:
6776 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6777 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6778 break;
6779 case 2:
6780 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6781 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6782 break;
6783 default:
6784 break;
6785 }
6786 }
6787
6788 free (rela);
6789 }
6790
53774b7e 6791 return TRUE;
4d6ed7c8
NC		 6792}
6793
1b31d05e 6794static void
2cf0635d 6795ia64_process_unwind (FILE * file)
4d6ed7c8 6796{
2cf0635d
NC		 6797 Elf_Internal_Shdr * sec;
6798 Elf_Internal_Shdr * unwsec = NULL;
6799 Elf_Internal_Shdr * strsec;
89fac5e3 6800 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6801 struct ia64_unw_aux_info aux;
f1467e33 6802
4d6ed7c8
NC		 6803 memset (& aux, 0, sizeof (aux));
6804
4d6ed7c8
NC		 6805 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6806 {
c256ffe7 6807 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6808 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6809 {
ba5cdace 6810 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6811
4fbb74a6 6812 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6813 if (aux.strtab != NULL)
6814 {
6815 error (_("Multiple auxillary string tables encountered\n"));
6816 free (aux.strtab);
6817 }
3f5e193b
NC		 6818 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6819 1, strsec->sh_size,
6820 _("string table"));
c256ffe7 6821 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6822 }
6823 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6824 unwcount++;
6825 }
6826
6827 if (!unwcount)
6828 printf (_("\nThere are no unwind sections in this file.\n"));
6829
6830 while (unwcount-- > 0)
6831 {
2cf0635d 6832 char * suffix;
579f31ac
JJ		 6833 size_t len, len2;
6834
4082ef84 6835 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6836 i < elf_header.e_shnum; ++i, ++sec)
6837 if (sec->sh_type == SHT_IA_64_UNWIND)
6838 {
6839 unwsec = sec;
6840 break;
6841 }
4082ef84
NC		 6842 /* We have already counted the number of SHT_IA64_UNWIND
6843 sections so the loop above should never fail. */
6844 assert (unwsec != NULL);
579f31ac
JJ		 6845
6846 unwstart = i + 1;
6847 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6848
e4b17d5c
L		 6849 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6850 {
6851 /* We need to find which section group it is in. */
4082ef84 6852 struct group_list * g;
e4b17d5c 6853
4082ef84
NC		 6854 if (section_headers_groups == NULL
6855 || section_headers_groups [i] == NULL)
6856 i = elf_header.e_shnum;
6857 else
e4b17d5c 6858 {
4082ef84 6859 g = section_headers_groups [i]->root;
18bd398b 6860
4082ef84
NC		 6861 for (; g != NULL; g = g->next)
6862 {
6863 sec = section_headers + g->section_index;
e4b17d5c 6864
4082ef84
NC		 6865 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6866 break;
6867 }
6868
6869 if (g == NULL)
6870 i = elf_header.e_shnum;
6871 }
e4b17d5c 6872 }
18bd398b 6873 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6874 {
18bd398b 6875 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6876 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6877 suffix = SECTION_NAME (unwsec) + len;
6878 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6879 ++i, ++sec)
18bd398b
NC		 6880 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6881 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6882 break;
6883 }
6884 else
6885 {
6886 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6887 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6888 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6889 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6890 suffix = "";
18bd398b 6891 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6892 suffix = SECTION_NAME (unwsec) + len;
6893 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6894 ++i, ++sec)
18bd398b
NC		 6895 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6896 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6897 break;
6898 }
6899
6900 if (i == elf_header.e_shnum)
6901 {
6902 printf (_("\nCould not find unwind info section for "));
6903
6904 if (string_table == NULL)
6905 printf ("%d", unwsec->sh_name);
6906 else
74e1a04b 6907 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6908 }
6909 else
4d6ed7c8 6910 {
4d6ed7c8 6911 aux.info_addr = sec->sh_addr;
3f5e193b 6912 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6913 sec->sh_size,
6914 _("unwind info"));
59245841 6915 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6916
579f31ac 6917 printf (_("\nUnwind section "));
4d6ed7c8 6918
579f31ac
JJ		 6919 if (string_table == NULL)
6920 printf ("%d", unwsec->sh_name);
6921 else
74e1a04b 6922 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 6923
579f31ac 6924 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6925 (unsigned long) unwsec->sh_offset,
89fac5e3 6926 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6927
53774b7e
NC		 6928 if (slurp_ia64_unwind_table (file, & aux, unwsec)
6929 && aux.table_len > 0)
579f31ac
JJ		 6930 dump_ia64_unwind (& aux);
6931
6932 if (aux.table)
6933 free ((char *) aux.table);
6934 if (aux.info)
6935 free ((char *) aux.info);
6936 aux.table = NULL;
6937 aux.info = NULL;
6938 }
4d6ed7c8 6939 }
4d6ed7c8 6940
4d6ed7c8
NC		 6941 if (aux.symtab)
6942 free (aux.symtab);
6943 if (aux.strtab)
6944 free ((char *) aux.strtab);
4d6ed7c8
NC		 6945}
6946
3f5e193b
NC		 6947struct hppa_unw_table_entry
6948 {
6949 struct absaddr start;
6950 struct absaddr end;
948f632f 6951 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 6952 unsigned int Millicode:1; /* 1 */
6953 unsigned int Millicode_save_sr0:1; /* 2 */
6954 unsigned int Region_description:2; /* 3..4 */
6955 unsigned int reserved1:1; /* 5 */
6956 unsigned int Entry_SR:1; /* 6 */
6957 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6958 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6959 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 6960 unsigned int Variable_Frame:1; /* 17 */
6961 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 6962 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 6963 unsigned int Stack_Overflow_Check:1; /* 20 */
6964 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 6965 unsigned int Ada_Region:1; /* 22 */
6966 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 6967 unsigned int cxx_try_catch:1; /* 24 */
6968 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 6969 unsigned int reserved2:1; /* 26 */
948f632f
DA		 6970 unsigned int Save_SP:1; /* 27 */
6971 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 6972 unsigned int Save_MRP_in_frame:1; /* 29 */
6973 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 6974 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 6975
948f632f
DA		 6976 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6977 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 6978 unsigned int Large_frame:1; /* 2 */
948f632f 6979 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 6980 unsigned int reserved4:1; /* 4 */
6981 unsigned int Total_frame_size:27; /* 5..31 */
6982 };
6983
57346661 6984struct hppa_unw_aux_info
948f632f
DA		 6985{
6986 struct hppa_unw_table_entry * table; /* Unwind table. */
6987 unsigned long table_len; /* Length of unwind table. */
6988 bfd_vma seg_base; /* Starting address of segment. */
6989 Elf_Internal_Sym * symtab; /* The symbol table. */
6990 unsigned long nsyms; /* Number of symbols. */
6991 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6992 unsigned long nfuns; /* Number of entries in funtab. */
6993 char * strtab; /* The string table. */
6994 unsigned long strtab_size; /* Size of string table. */
6995};
57346661
AM		 6996
6997static void
2cf0635d 6998dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6999{
2cf0635d 7000 struct hppa_unw_table_entry * tp;
948f632f
DA		 7001 unsigned long j, nfuns;
7002
7003 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7004 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7005 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7006 aux->funtab[nfuns++] = aux->symtab[j];
7007 aux->nfuns = nfuns;
7008 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7009
57346661
AM		 7010 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7011 {
7012 bfd_vma offset;
2cf0635d 7013 const char * procname;
57346661 7014
948f632f 7015 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7016 aux->strtab_size, tp->start, &procname,
7017 &offset);
7018
7019 fputs ("\n<", stdout);
7020
7021 if (procname)
7022 {
7023 fputs (procname, stdout);
7024
7025 if (offset)
7026 printf ("+%lx", (unsigned long) offset);
7027 }
7028
7029 fputs (">: [", stdout);
7030 print_vma (tp->start.offset, PREFIX_HEX);
7031 fputc ('-', stdout);
7032 print_vma (tp->end.offset, PREFIX_HEX);
7033 printf ("]\n\t");
7034
18bd398b
NC		 7035#define PF(_m) if (tp->_m) printf (#_m " ");
7036#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7037 PF(Cannot_unwind);
7038 PF(Millicode);
7039 PF(Millicode_save_sr0);
18bd398b 7040 /* PV(Region_description); */
57346661
AM		 7041 PF(Entry_SR);
7042 PV(Entry_FR);
7043 PV(Entry_GR);
7044 PF(Args_stored);
7045 PF(Variable_Frame);
7046 PF(Separate_Package_Body);
7047 PF(Frame_Extension_Millicode);
7048 PF(Stack_Overflow_Check);
7049 PF(Two_Instruction_SP_Increment);
7050 PF(Ada_Region);
7051 PF(cxx_info);
7052 PF(cxx_try_catch);
7053 PF(sched_entry_seq);
7054 PF(Save_SP);
7055 PF(Save_RP);
7056 PF(Save_MRP_in_frame);
7057 PF(extn_ptr_defined);
7058 PF(Cleanup_defined);
7059 PF(MPE_XL_interrupt_marker);
7060 PF(HP_UX_interrupt_marker);
7061 PF(Large_frame);
7062 PF(Pseudo_SP_Set);
7063 PV(Total_frame_size);
7064#undef PF
7065#undef PV
7066 }
7067
18bd398b 7068 printf ("\n");
948f632f
DA		 7069
7070 free (aux->funtab);
57346661
AM		 7071}
7072
7073static int
2cf0635d
NC		 7074slurp_hppa_unwind_table (FILE * file,
7075 struct hppa_unw_aux_info * aux,
7076 Elf_Internal_Shdr * sec)
57346661 7077{
1c0751b2 7078 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7079 Elf_Internal_Phdr * seg;
7080 struct hppa_unw_table_entry * tep;
7081 Elf_Internal_Shdr * relsec;
7082 Elf_Internal_Rela * rela;
7083 Elf_Internal_Rela * rp;
7084 unsigned char * table;
7085 unsigned char * tp;
7086 Elf_Internal_Sym * sym;
7087 const char * relname;
57346661 7088
57346661
AM		 7089 /* First, find the starting address of the segment that includes
7090 this section. */
7091
7092 if (elf_header.e_phnum)
7093 {
7094 if (! get_program_headers (file))
7095 return 0;
7096
7097 for (seg = program_headers;
7098 seg < program_headers + elf_header.e_phnum;
7099 ++seg)
7100 {
7101 if (seg->p_type != PT_LOAD)
7102 continue;
7103
7104 if (sec->sh_addr >= seg->p_vaddr
7105 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7106 {
7107 aux->seg_base = seg->p_vaddr;
7108 break;
7109 }
7110 }
7111 }
7112
7113 /* Second, build the unwind table from the contents of the unwind
7114 section. */
7115 size = sec->sh_size;
3f5e193b
NC		 7116 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7117 _("unwind table"));
57346661
AM		 7118 if (!table)
7119 return 0;
7120
1c0751b2
DA		 7121 unw_ent_size = 16;
7122 nentries = size / unw_ent_size;
7123 size = unw_ent_size * nentries;
57346661 7124
3f5e193b
NC		 7125 tep = aux->table = (struct hppa_unw_table_entry *)
7126 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7127
1c0751b2 7128 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7129 {
7130 unsigned int tmp1, tmp2;
7131
7132 tep->start.section = SHN_UNDEF;
7133 tep->end.section = SHN_UNDEF;
7134
1c0751b2
DA		 7135 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7136 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7137 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7138 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7139
7140 tep->start.offset += aux->seg_base;
7141 tep->end.offset += aux->seg_base;
57346661
AM		 7142
7143 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7144 tep->Millicode = (tmp1 >> 30) & 0x1;
7145 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7146 tep->Region_description = (tmp1 >> 27) & 0x3;
7147 tep->reserved1 = (tmp1 >> 26) & 0x1;
7148 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7149 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7150 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7151 tep->Args_stored = (tmp1 >> 15) & 0x1;
7152 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7153 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7154 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7155 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7156 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7157 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7158 tep->cxx_info = (tmp1 >> 8) & 0x1;
7159 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7160 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7161 tep->reserved2 = (tmp1 >> 5) & 0x1;
7162 tep->Save_SP = (tmp1 >> 4) & 0x1;
7163 tep->Save_RP = (tmp1 >> 3) & 0x1;
7164 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7165 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7166 tep->Cleanup_defined = tmp1 & 0x1;
7167
7168 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7169 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7170 tep->Large_frame = (tmp2 >> 29) & 0x1;
7171 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7172 tep->reserved4 = (tmp2 >> 27) & 0x1;
7173 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7174 }
7175 free (table);
7176
7177 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7178 for (relsec = section_headers;
7179 relsec < section_headers + elf_header.e_shnum;
7180 ++relsec)
7181 {
7182 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7183 || relsec->sh_info >= elf_header.e_shnum
7184 || section_headers + relsec->sh_info != sec)
57346661
AM		 7185 continue;
7186
7187 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7188 & rela, & nrelas))
7189 return 0;
7190
7191 for (rp = rela; rp < rela + nrelas; ++rp)
7192 {
aca88567
NC		 7193 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7194 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7195
7196 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7197 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7198 {
7199 warn (_("Skipping unexpected relocation type %s\n"), relname);
7200 continue;
7201 }
7202
7203 i = rp->r_offset / unw_ent_size;
7204
89fac5e3 7205 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7206 {
7207 case 0:
7208 aux->table[i].start.section = sym->st_shndx;
1e456d54 7209 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7210 break;
7211 case 1:
7212 aux->table[i].end.section = sym->st_shndx;
1e456d54 7213 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7214 break;
7215 default:
7216 break;
7217 }
7218 }
7219
7220 free (rela);
7221 }
7222
1c0751b2 7223 aux->table_len = nentries;
57346661
AM		 7224
7225 return 1;
7226}
7227
1b31d05e 7228static void
2cf0635d 7229hppa_process_unwind (FILE * file)
57346661 7230{
57346661 7231 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7232 Elf_Internal_Shdr * unwsec = NULL;
7233 Elf_Internal_Shdr * strsec;
7234 Elf_Internal_Shdr * sec;
18bd398b 7235 unsigned long i;
57346661 7236
c256ffe7 7237 if (string_table == NULL)
1b31d05e
NC		 7238 return;
7239
7240 memset (& aux, 0, sizeof (aux));
57346661
AM		 7241
7242 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7243 {
c256ffe7 7244 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7245 && sec->sh_link < elf_header.e_shnum)
57346661 7246 {
ba5cdace 7247 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7248
4fbb74a6 7249 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7250 if (aux.strtab != NULL)
7251 {
7252 error (_("Multiple auxillary string tables encountered\n"));
7253 free (aux.strtab);
7254 }
3f5e193b
NC		 7255 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7256 1, strsec->sh_size,
7257 _("string table"));
c256ffe7 7258 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7259 }
18bd398b 7260 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7261 unwsec = sec;
7262 }
7263
7264 if (!unwsec)
7265 printf (_("\nThere are no unwind sections in this file.\n"));
7266
7267 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7268 {
18bd398b 7269 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7270 {
74e1a04b
NC		 7271 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7272 printable_section_name (sec),
57346661 7273 (unsigned long) sec->sh_offset,
89fac5e3 7274 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7275
7276 slurp_hppa_unwind_table (file, &aux, sec);
7277 if (aux.table_len > 0)
7278 dump_hppa_unwind (&aux);
7279
7280 if (aux.table)
7281 free ((char *) aux.table);
7282 aux.table = NULL;
7283 }
7284 }
7285
7286 if (aux.symtab)
7287 free (aux.symtab);
7288 if (aux.strtab)
7289 free ((char *) aux.strtab);
57346661
AM		 7290}
7291
0b6ae522
DJ		 7292struct arm_section
7293{
a734115a
NC		 7294 unsigned char * data; /* The unwind data. */
7295 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7296 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7297 unsigned long nrelas; /* The number of relocations. */
7298 unsigned int rel_type; /* REL or RELA ? */
7299 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7300};
7301
7302struct arm_unw_aux_info
7303{
a734115a
NC		 7304 FILE * file; /* The file containing the unwind sections. */
7305 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7306 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7307 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7308 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7309 char * strtab; /* The file's string table. */
7310 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7311};
7312
7313static const char *
7314arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7315 bfd_vma fn, struct absaddr addr)
7316{
7317 const char *procname;
7318 bfd_vma sym_offset;
7319
7320 if (addr.section == SHN_UNDEF)
7321 addr.offset = fn;
7322
948f632f 7323 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7324 aux->strtab_size, addr, &procname,
7325 &sym_offset);
7326
7327 print_vma (fn, PREFIX_HEX);
7328
7329 if (procname)
7330 {
7331 fputs (" <", stdout);
7332 fputs (procname, stdout);
7333
7334 if (sym_offset)
7335 printf ("+0x%lx", (unsigned long) sym_offset);
7336 fputc ('>', stdout);
7337 }
7338
7339 return procname;
7340}
7341
7342static void
7343arm_free_section (struct arm_section *arm_sec)
7344{
7345 if (arm_sec->data != NULL)
7346 free (arm_sec->data);
7347
7348 if (arm_sec->rela != NULL)
7349 free (arm_sec->rela);
7350}
7351
a734115a
NC		 7352/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7353 cached section and install SEC instead.
7354 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7355 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7356 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7357 relocation's offset in ADDR.
1b31d05e
NC		 7358 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7359 into the string table of the symbol associated with the reloc. If no
7360 reloc was applied store -1 there.
7361 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7362
7363static bfd_boolean
1b31d05e
NC		 7364get_unwind_section_word (struct arm_unw_aux_info * aux,
7365 struct arm_section * arm_sec,
7366 Elf_Internal_Shdr * sec,
7367 bfd_vma word_offset,
7368 unsigned int * wordp,
7369 struct absaddr * addr,
7370 bfd_vma * sym_name)
0b6ae522
DJ		 7371{
7372 Elf_Internal_Rela *rp;
7373 Elf_Internal_Sym *sym;
7374 const char * relname;
7375 unsigned int word;
7376 bfd_boolean wrapped;
7377
e0a31db1
NC		 7378 if (sec == NULL || arm_sec == NULL)
7379 return FALSE;
7380
0b6ae522
DJ		 7381 addr->section = SHN_UNDEF;
7382 addr->offset = 0;
7383
1b31d05e
NC		 7384 if (sym_name != NULL)
7385 *sym_name = (bfd_vma) -1;
7386
a734115a 7387 /* If necessary, update the section cache. */
0b6ae522
DJ		 7388 if (sec != arm_sec->sec)
7389 {
7390 Elf_Internal_Shdr *relsec;
7391
7392 arm_free_section (arm_sec);
7393
7394 arm_sec->sec = sec;
7395 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7396 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7397 arm_sec->rela = NULL;
7398 arm_sec->nrelas = 0;
7399
7400 for (relsec = section_headers;
7401 relsec < section_headers + elf_header.e_shnum;
7402 ++relsec)
7403 {
7404 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7405 || section_headers + relsec->sh_info != sec
7406 /* PR 15745: Check the section type as well. */
7407 || (relsec->sh_type != SHT_REL
7408 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7409 continue;
7410
a734115a 7411 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7412 if (relsec->sh_type == SHT_REL)
7413 {
7414 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7415 relsec->sh_size,
7416 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7417 return FALSE;
0b6ae522 7418 }
1ae40aa4 7419 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7420 {
7421 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7422 relsec->sh_size,
7423 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7424 return FALSE;
0b6ae522 7425 }
1ae40aa4 7426 break;
0b6ae522
DJ		 7427 }
7428
7429 arm_sec->next_rela = arm_sec->rela;
7430 }
7431
a734115a 7432 /* If there is no unwind data we can do nothing. */
0b6ae522 7433 if (arm_sec->data == NULL)
a734115a 7434 return FALSE;
0b6ae522 7435
e0a31db1
NC		 7436 /* If the offset is invalid then fail. */
7437 if (word_offset > sec->sh_size - 4)
7438 return FALSE;
7439
a734115a 7440 /* Get the word at the required offset. */
0b6ae522
DJ		 7441 word = byte_get (arm_sec->data + word_offset, 4);
7442
0eff7165
NC		 7443 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7444 if (arm_sec->rela == NULL)
7445 {
7446 * wordp = word;
7447 return TRUE;
7448 }
7449
a734115a 7450 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7451 wrapped = FALSE;
7452 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7453 {
7454 bfd_vma prelval, offset;
7455
7456 if (rp->r_offset > word_offset && !wrapped)
7457 {
7458 rp = arm_sec->rela;
7459 wrapped = TRUE;
7460 }
7461 if (rp->r_offset > word_offset)
7462 break;
7463
7464 if (rp->r_offset & 3)
7465 {
7466 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7467 (unsigned long) rp->r_offset);
7468 continue;
7469 }
7470
7471 if (rp->r_offset < word_offset)
7472 continue;
7473
74e1a04b
NC		 7474 /* PR 17531: file: 027-161405-0.004 */
7475 if (aux->symtab == NULL)
7476 continue;
7477
0b6ae522
DJ		 7478 if (arm_sec->rel_type == SHT_REL)
7479 {
7480 offset = word & 0x7fffffff;
7481 if (offset & 0x40000000)
7482 offset |= ~ (bfd_vma) 0x7fffffff;
7483 }
a734115a 7484 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7485 offset = rp->r_addend;
a734115a 7486 else
74e1a04b
NC		 7487 {
7488 error (_("Unknown section relocation type %d encountered\n"),
7489 arm_sec->rel_type);
7490 break;
7491 }
0b6ae522 7492
071436c6
NC		 7493 /* PR 17531 file: 027-1241568-0.004. */
7494 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7495 {
7496 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7497 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7498 break;
7499 }
7500
7501 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7502 offset += sym->st_value;
7503 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7504
a734115a
NC		 7505 /* Check that we are processing the expected reloc type. */
7506 if (elf_header.e_machine == EM_ARM)
7507 {
7508 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7509 if (relname == NULL)
7510 {
7511 warn (_("Skipping unknown ARM relocation type: %d\n"),
7512 (int) ELF32_R_TYPE (rp->r_info));
7513 continue;
7514 }
a734115a
NC		 7515
7516 if (streq (relname, "R_ARM_NONE"))
7517 continue;
0b4362b0 7518
a734115a
NC		 7519 if (! streq (relname, "R_ARM_PREL31"))
7520 {
071436c6 7521 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7522 continue;
7523 }
7524 }
7525 else if (elf_header.e_machine == EM_TI_C6000)
7526 {
7527 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7528 if (relname == NULL)
7529 {
7530 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7531 (int) ELF32_R_TYPE (rp->r_info));
7532 continue;
7533 }
0b4362b0 7534
a734115a
NC		 7535 if (streq (relname, "R_C6000_NONE"))
7536 continue;
7537
7538 if (! streq (relname, "R_C6000_PREL31"))
7539 {
071436c6 7540 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7541 continue;
7542 }
7543
7544 prelval >>= 1;
7545 }
7546 else
74e1a04b
NC		 7547 {
7548 /* This function currently only supports ARM and TI unwinders. */
7549 warn (_("Only TI and ARM unwinders are currently supported\n"));
7550 break;
7551 }
fa197c1c 7552
0b6ae522
DJ		 7553 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7554 addr->section = sym->st_shndx;
7555 addr->offset = offset;
74e1a04b 7556
1b31d05e
NC		 7557 if (sym_name)
7558 * sym_name = sym->st_name;
0b6ae522
DJ		 7559 break;
7560 }
7561
7562 *wordp = word;
7563 arm_sec->next_rela = rp;
7564
a734115a 7565 return TRUE;
0b6ae522
DJ		 7566}
7567
a734115a
NC		 7568static const char *tic6x_unwind_regnames[16] =
7569{
0b4362b0
RM		 7570 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7571 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7572 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7573};
fa197c1c 7574
0b6ae522 7575static void
fa197c1c 7576decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7577{
fa197c1c
PB		 7578 int i;
7579
7580 for (i = 12; mask; mask >>= 1, i--)
7581 {
7582 if (mask & 1)
7583 {
7584 fputs (tic6x_unwind_regnames[i], stdout);
7585 if (mask > 1)
7586 fputs (", ", stdout);
7587 }
7588 }
7589}
0b6ae522
DJ		 7590
7591#define ADVANCE \
7592 if (remaining == 0 && more_words) \
7593 { \
7594 data_offset += 4; \
1b31d05e
NC		 7595 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7596 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7597 return; \
7598 remaining = 4; \
7599 more_words--; \
7600 } \
7601
7602#define GET_OP(OP) \
7603 ADVANCE; \
7604 if (remaining) \
7605 { \
7606 remaining--; \
7607 (OP) = word >> 24; \
7608 word <<= 8; \
7609 } \
7610 else \
7611 { \
2b692964 7612 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7613 return; \
7614 } \
cc5914eb 7615 printf ("0x%02x ", OP)
0b6ae522 7616
fa197c1c 7617static void
948f632f
DA		 7618decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7619 unsigned int word,
7620 unsigned int remaining,
7621 unsigned int more_words,
7622 bfd_vma data_offset,
7623 Elf_Internal_Shdr * data_sec,
7624 struct arm_section * data_arm_sec)
fa197c1c
PB		 7625{
7626 struct absaddr addr;
0b6ae522
DJ		 7627
7628 /* Decode the unwinding instructions. */
7629 while (1)
7630 {
7631 unsigned int op, op2;
7632
7633 ADVANCE;
7634 if (remaining == 0)
7635 break;
7636 remaining--;
7637 op = word >> 24;
7638 word <<= 8;
7639
cc5914eb 7640 printf (" 0x%02x ", op);
0b6ae522
DJ		 7641
7642 if ((op & 0xc0) == 0x00)
7643 {
7644 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7645
cc5914eb 7646 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7647 }
7648 else if ((op & 0xc0) == 0x40)
7649 {
7650 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7651
cc5914eb 7652 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7653 }
7654 else if ((op & 0xf0) == 0x80)
7655 {
7656 GET_OP (op2);
7657 if (op == 0x80 && op2 == 0)
7658 printf (_("Refuse to unwind"));
7659 else
7660 {
7661 unsigned int mask = ((op & 0x0f) << 8) | op2;
7662 int first = 1;
7663 int i;
2b692964 7664
0b6ae522
DJ		 7665 printf ("pop {");
7666 for (i = 0; i < 12; i++)
7667 if (mask & (1 << i))
7668 {
7669 if (first)
7670 first = 0;
7671 else
7672 printf (", ");
7673 printf ("r%d", 4 + i);
7674 }
7675 printf ("}");
7676 }
7677 }
7678 else if ((op & 0xf0) == 0x90)
7679 {
7680 if (op == 0x9d || op == 0x9f)
7681 printf (_(" [Reserved]"));
7682 else
cc5914eb 7683 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7684 }
7685 else if ((op & 0xf0) == 0xa0)
7686 {
7687 int end = 4 + (op & 0x07);
7688 int first = 1;
7689 int i;
61865e30 7690
0b6ae522
DJ		 7691 printf (" pop {");
7692 for (i = 4; i <= end; i++)
7693 {
7694 if (first)
7695 first = 0;
7696 else
7697 printf (", ");
7698 printf ("r%d", i);
7699 }
7700 if (op & 0x08)
7701 {
1b31d05e 7702 if (!first)
0b6ae522
DJ		 7703 printf (", ");
7704 printf ("r14");
7705 }
7706 printf ("}");
7707 }
7708 else if (op == 0xb0)
7709 printf (_(" finish"));
7710 else if (op == 0xb1)
7711 {
7712 GET_OP (op2);
7713 if (op2 == 0 || (op2 & 0xf0) != 0)
7714 printf (_("[Spare]"));
7715 else
7716 {
7717 unsigned int mask = op2 & 0x0f;
7718 int first = 1;
7719 int i;
61865e30 7720
0b6ae522
DJ		 7721 printf ("pop {");
7722 for (i = 0; i < 12; i++)
7723 if (mask & (1 << i))
7724 {
7725 if (first)
7726 first = 0;
7727 else
7728 printf (", ");
7729 printf ("r%d", i);
7730 }
7731 printf ("}");
7732 }
7733 }
7734 else if (op == 0xb2)
7735 {
b115cf96 7736 unsigned char buf[9];
0b6ae522
DJ		 7737 unsigned int i, len;
7738 unsigned long offset;
61865e30 7739
b115cf96 7740 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7741 {
7742 GET_OP (buf[i]);
7743 if ((buf[i] & 0x80) == 0)
7744 break;
7745 }
4082ef84
NC		 7746 if (i == sizeof (buf))
7747 printf (_("corrupt change to vsp"));
7748 else
7749 {
7750 offset = read_uleb128 (buf, &len, buf + i + 1);
7751 assert (len == i + 1);
7752 offset = offset * 4 + 0x204;
7753 printf ("vsp = vsp + %ld", offset);
7754 }
0b6ae522 7755 }
61865e30 7756 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7757 {
61865e30
NC		 7758 unsigned int first, last;
7759
7760 GET_OP (op2);
7761 first = op2 >> 4;
7762 last = op2 & 0x0f;
7763 if (op == 0xc8)
7764 first = first + 16;
7765 printf ("pop {D%d", first);
7766 if (last)
7767 printf ("-D%d", first + last);
7768 printf ("}");
7769 }
7770 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7771 {
7772 unsigned int count = op & 0x07;
7773
7774 printf ("pop {D8");
7775 if (count)
7776 printf ("-D%d", 8 + count);
7777 printf ("}");
7778 }
7779 else if (op >= 0xc0 && op <= 0xc5)
7780 {
7781 unsigned int count = op & 0x07;
7782
7783 printf (" pop {wR10");
7784 if (count)
7785 printf ("-wR%d", 10 + count);
7786 printf ("}");
7787 }
7788 else if (op == 0xc6)
7789 {
7790 unsigned int first, last;
7791
7792 GET_OP (op2);
7793 first = op2 >> 4;
7794 last = op2 & 0x0f;
7795 printf ("pop {wR%d", first);
7796 if (last)
7797 printf ("-wR%d", first + last);
7798 printf ("}");
7799 }
7800 else if (op == 0xc7)
7801 {
7802 GET_OP (op2);
7803 if (op2 == 0 || (op2 & 0xf0) != 0)
7804 printf (_("[Spare]"));
0b6ae522
DJ		 7805 else
7806 {
61865e30
NC		 7807 unsigned int mask = op2 & 0x0f;
7808 int first = 1;
7809 int i;
7810
7811 printf ("pop {");
7812 for (i = 0; i < 4; i++)
7813 if (mask & (1 << i))
7814 {
7815 if (first)
7816 first = 0;
7817 else
7818 printf (", ");
7819 printf ("wCGR%d", i);
7820 }
7821 printf ("}");
0b6ae522
DJ		 7822 }
7823 }
61865e30
NC		 7824 else
7825 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7826 printf ("\n");
7827 }
fa197c1c
PB		 7828}
7829
7830static void
948f632f
DA		 7831decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7832 unsigned int word,
7833 unsigned int remaining,
7834 unsigned int more_words,
7835 bfd_vma data_offset,
7836 Elf_Internal_Shdr * data_sec,
7837 struct arm_section * data_arm_sec)
fa197c1c
PB		 7838{
7839 struct absaddr addr;
7840
7841 /* Decode the unwinding instructions. */
7842 while (1)
7843 {
7844 unsigned int op, op2;
7845
7846 ADVANCE;
7847 if (remaining == 0)
7848 break;
7849 remaining--;
7850 op = word >> 24;
7851 word <<= 8;
7852
9cf03b7e 7853 printf (" 0x%02x ", op);
fa197c1c
PB		 7854
7855 if ((op & 0xc0) == 0x00)
7856 {
7857 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7858 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7859 }
7860 else if ((op & 0xc0) == 0x80)
7861 {
7862 GET_OP (op2);
7863 if (op == 0x80 && op2 == 0)
7864 printf (_("Refuse to unwind"));
7865 else
7866 {
7867 unsigned int mask = ((op & 0x1f) << 8) | op2;
7868 if (op & 0x20)
7869 printf ("pop compact {");
7870 else
7871 printf ("pop {");
7872
7873 decode_tic6x_unwind_regmask (mask);
7874 printf("}");
7875 }
7876 }
7877 else if ((op & 0xf0) == 0xc0)
7878 {
7879 unsigned int reg;
7880 unsigned int nregs;
7881 unsigned int i;
7882 const char *name;
a734115a
NC		 7883 struct
7884 {
fa197c1c
PB		 7885 unsigned int offset;
7886 unsigned int reg;
7887 } regpos[16];
7888
7889 /* Scan entire instruction first so that GET_OP output is not
7890 interleaved with disassembly. */
7891 nregs = 0;
7892 for (i = 0; nregs < (op & 0xf); i++)
7893 {
7894 GET_OP (op2);
7895 reg = op2 >> 4;
7896 if (reg != 0xf)
7897 {
7898 regpos[nregs].offset = i * 2;
7899 regpos[nregs].reg = reg;
7900 nregs++;
7901 }
7902
7903 reg = op2 & 0xf;
7904 if (reg != 0xf)
7905 {
7906 regpos[nregs].offset = i * 2 + 1;
7907 regpos[nregs].reg = reg;
7908 nregs++;
7909 }
7910 }
7911
7912 printf (_("pop frame {"));
7913 reg = nregs - 1;
7914 for (i = i * 2; i > 0; i--)
7915 {
7916 if (regpos[reg].offset == i - 1)
7917 {
7918 name = tic6x_unwind_regnames[regpos[reg].reg];
7919 if (reg > 0)
7920 reg--;
7921 }
7922 else
7923 name = _("[pad]");
7924
7925 fputs (name, stdout);
7926 if (i > 1)
7927 printf (", ");
7928 }
7929
7930 printf ("}");
7931 }
7932 else if (op == 0xd0)
7933 printf (" MOV FP, SP");
7934 else if (op == 0xd1)
7935 printf (" __c6xabi_pop_rts");
7936 else if (op == 0xd2)
7937 {
7938 unsigned char buf[9];
7939 unsigned int i, len;
7940 unsigned long offset;
a734115a 7941
fa197c1c
PB		 7942 for (i = 0; i < sizeof (buf); i++)
7943 {
7944 GET_OP (buf[i]);
7945 if ((buf[i] & 0x80) == 0)
7946 break;
7947 }
0eff7165
NC		 7948 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7949 if (i == sizeof (buf))
7950 {
7951 printf ("<corrupt sp adjust>\n");
7952 warn (_("Corrupt stack pointer adjustment detected\n"));
7953 return;
7954 }
948f632f 7955
f6f0e17b 7956 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7957 assert (len == i + 1);
7958 offset = offset * 8 + 0x408;
7959 printf (_("sp = sp + %ld"), offset);
7960 }
7961 else if ((op & 0xf0) == 0xe0)
7962 {
7963 if ((op & 0x0f) == 7)
7964 printf (" RETURN");
7965 else
7966 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7967 }
7968 else
7969 {
7970 printf (_(" [unsupported opcode]"));
7971 }
7972 putchar ('\n');
7973 }
7974}
7975
7976static bfd_vma
a734115a 7977arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7978{
7979 bfd_vma offset;
7980
7981 offset = word & 0x7fffffff;
7982 if (offset & 0x40000000)
7983 offset |= ~ (bfd_vma) 0x7fffffff;
7984
7985 if (elf_header.e_machine == EM_TI_C6000)
7986 offset <<= 1;
7987
7988 return offset + where;
7989}
7990
7991static void
1b31d05e
NC		 7992decode_arm_unwind (struct arm_unw_aux_info * aux,
7993 unsigned int word,
7994 unsigned int remaining,
7995 bfd_vma data_offset,
7996 Elf_Internal_Shdr * data_sec,
7997 struct arm_section * data_arm_sec)
fa197c1c
PB		 7998{
7999 int per_index;
8000 unsigned int more_words = 0;
37e14bc3 8001 struct absaddr addr;
1b31d05e 8002 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8003
8004 if (remaining == 0)
8005 {
1b31d05e
NC		 8006 /* Fetch the first word.
8007 Note - when decoding an object file the address extracted
8008 here will always be 0. So we also pass in the sym_name
8009 parameter so that we can find the symbol associated with
8010 the personality routine. */
8011 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8012 & word, & addr, & sym_name))
fa197c1c 8013 return;
1b31d05e 8014
fa197c1c
PB		 8015 remaining = 4;
8016 }
8017
8018 if ((word & 0x80000000) == 0)
8019 {
8020 /* Expand prel31 for personality routine. */
8021 bfd_vma fn;
8022 const char *procname;
8023
a734115a 8024 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8025 printf (_(" Personality routine: "));
1b31d05e
NC		 8026 if (fn == 0
8027 && addr.section == SHN_UNDEF && addr.offset == 0
8028 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8029 {
8030 procname = aux->strtab + sym_name;
8031 print_vma (fn, PREFIX_HEX);
8032 if (procname)
8033 {
8034 fputs (" <", stdout);
8035 fputs (procname, stdout);
8036 fputc ('>', stdout);
8037 }
8038 }
8039 else
8040 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8041 fputc ('\n', stdout);
8042
8043 /* The GCC personality routines use the standard compact
8044 encoding, starting with one byte giving the number of
8045 words. */
8046 if (procname != NULL
8047 && (const_strneq (procname, "__gcc_personality_v0")
8048 || const_strneq (procname, "__gxx_personality_v0")
8049 || const_strneq (procname, "__gcj_personality_v0")
8050 || const_strneq (procname, "__gnu_objc_personality_v0")))
8051 {
8052 remaining = 0;
8053 more_words = 1;
8054 ADVANCE;
8055 if (!remaining)
8056 {
8057 printf (_(" [Truncated data]\n"));
8058 return;
8059 }
8060 more_words = word >> 24;
8061 word <<= 8;
8062 remaining--;
8063 per_index = -1;
8064 }
8065 else
8066 return;
8067 }
8068 else
8069 {
1b31d05e 8070 /* ARM EHABI Section 6.3:
0b4362b0 8071
1b31d05e 8072 An exception-handling table entry for the compact model looks like:
0b4362b0 8073
1b31d05e
NC		 8074 31 30-28 27-24 23-0
8075 -- ----- ----- ----
8076 1 0 index Data for personalityRoutine[index] */
8077
8078 if (elf_header.e_machine == EM_ARM
8079 && (word & 0x70000000))
83c257ca 8080 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8081
fa197c1c 8082 per_index = (word >> 24) & 0x7f;
1b31d05e 8083 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8084 if (per_index == 0)
8085 {
8086 more_words = 0;
8087 word <<= 8;
8088 remaining--;
8089 }
8090 else if (per_index < 3)
8091 {
8092 more_words = (word >> 16) & 0xff;
8093 word <<= 16;
8094 remaining -= 2;
8095 }
8096 }
8097
8098 switch (elf_header.e_machine)
8099 {
8100 case EM_ARM:
8101 if (per_index < 3)
8102 {
8103 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8104 data_offset, data_sec, data_arm_sec);
8105 }
8106 else
1b31d05e
NC		 8107 {
8108 warn (_("Unknown ARM compact model index encountered\n"));
8109 printf (_(" [reserved]\n"));
8110 }
fa197c1c
PB		 8111 break;
8112
8113 case EM_TI_C6000:
8114 if (per_index < 3)
8115 {
8116 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8117 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8118 }
8119 else if (per_index < 5)
8120 {
8121 if (((word >> 17) & 0x7f) == 0x7f)
8122 printf (_(" Restore stack from frame pointer\n"));
8123 else
8124 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8125 printf (_(" Registers restored: "));
8126 if (per_index == 4)
8127 printf (" (compact) ");
8128 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8129 putchar ('\n');
8130 printf (_(" Return register: %s\n"),
8131 tic6x_unwind_regnames[word & 0xf]);
8132 }
8133 else
1b31d05e 8134 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8135 break;
8136
8137 default:
74e1a04b 8138 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8139 elf_header.e_machine);
fa197c1c 8140 }
0b6ae522
DJ		 8141
8142 /* Decode the descriptors. Not implemented. */
8143}
8144
8145static void
8146dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8147{
8148 struct arm_section exidx_arm_sec, extab_arm_sec;
8149 unsigned int i, exidx_len;
948f632f 8150 unsigned long j, nfuns;
0b6ae522
DJ		 8151
8152 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8153 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8154 exidx_len = exidx_sec->sh_size / 8;
8155
948f632f
DA		 8156 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8157 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8158 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8159 aux->funtab[nfuns++] = aux->symtab[j];
8160 aux->nfuns = nfuns;
8161 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8162
0b6ae522
DJ		 8163 for (i = 0; i < exidx_len; i++)
8164 {
8165 unsigned int exidx_fn, exidx_entry;
8166 struct absaddr fn_addr, entry_addr;
8167 bfd_vma fn;
8168
8169 fputc ('\n', stdout);
8170
1b31d05e
NC		 8171 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8172 8 * i, & exidx_fn, & fn_addr, NULL)
8173 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8174 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8175 {
948f632f 8176 free (aux->funtab);
1b31d05e
NC		 8177 arm_free_section (& exidx_arm_sec);
8178 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8179 return;
8180 }
8181
83c257ca
NC		 8182 /* ARM EHABI, Section 5:
8183 An index table entry consists of 2 words.
8184 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8185 if (exidx_fn & 0x80000000)
8186 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8187
a734115a 8188 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8189
a734115a 8190 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8191 fputs (": ", stdout);
8192
8193 if (exidx_entry == 1)
8194 {
8195 print_vma (exidx_entry, PREFIX_HEX);
8196 fputs (" [cantunwind]\n", stdout);
8197 }
8198 else if (exidx_entry & 0x80000000)
8199 {
8200 print_vma (exidx_entry, PREFIX_HEX);
8201 fputc ('\n', stdout);
8202 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8203 }
8204 else
8205 {
8f73510c 8206 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8207 Elf_Internal_Shdr *table_sec;
8208
8209 fputs ("@", stdout);
a734115a 8210 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8211 print_vma (table, PREFIX_HEX);
8212 printf ("\n");
8213
8214 /* Locate the matching .ARM.extab. */
8215 if (entry_addr.section != SHN_UNDEF
8216 && entry_addr.section < elf_header.e_shnum)
8217 {
8218 table_sec = section_headers + entry_addr.section;
8219 table_offset = entry_addr.offset;
8220 }
8221 else
8222 {
8223 table_sec = find_section_by_address (table);
8224 if (table_sec != NULL)
8225 table_offset = table - table_sec->sh_addr;
8226 }
8227 if (table_sec == NULL)
8228 {
8229 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8230 (unsigned long) table);
8231 continue;
8232 }
8233 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8234 &extab_arm_sec);
8235 }
8236 }
8237
8238 printf ("\n");
8239
948f632f 8240 free (aux->funtab);
0b6ae522
DJ		 8241 arm_free_section (&exidx_arm_sec);
8242 arm_free_section (&extab_arm_sec);
8243}
8244
fa197c1c 8245/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8246
8247static void
0b6ae522
DJ		 8248arm_process_unwind (FILE *file)
8249{
8250 struct arm_unw_aux_info aux;
8251 Elf_Internal_Shdr *unwsec = NULL;
8252 Elf_Internal_Shdr *strsec;
8253 Elf_Internal_Shdr *sec;
8254 unsigned long i;
fa197c1c 8255 unsigned int sec_type;
0b6ae522 8256
fa197c1c
PB		 8257 switch (elf_header.e_machine)
8258 {
8259 case EM_ARM:
8260 sec_type = SHT_ARM_EXIDX;
8261 break;
8262
8263 case EM_TI_C6000:
8264 sec_type = SHT_C6000_UNWIND;
8265 break;
8266
0b4362b0 8267 default:
74e1a04b 8268 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8269 elf_header.e_machine);
8270 return;
fa197c1c
PB		 8271 }
8272
0b6ae522 8273 if (string_table == NULL)
1b31d05e
NC		 8274 return;
8275
8276 memset (& aux, 0, sizeof (aux));
8277 aux.file = file;
0b6ae522
DJ		 8278
8279 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8280 {
8281 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8282 {
ba5cdace 8283 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8284
8285 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8286
8287 /* PR binutils/17531 file: 011-12666-0.004. */
8288 if (aux.strtab != NULL)
8289 {
4082ef84 8290 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8291 free (aux.strtab);
8292 }
0b6ae522
DJ		 8293 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8294 1, strsec->sh_size, _("string table"));
8295 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8296 }
fa197c1c 8297 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8298 unwsec = sec;
8299 }
8300
1b31d05e 8301 if (unwsec == NULL)
0b6ae522 8302 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8303 else
8304 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8305 {
8306 if (sec->sh_type == sec_type)
8307 {
8308 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8309 printable_section_name (sec),
1b31d05e
NC		 8310 (unsigned long) sec->sh_offset,
8311 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8312
1b31d05e
NC		 8313 dump_arm_unwind (&aux, sec);
8314 }
8315 }
0b6ae522
DJ		 8316
8317 if (aux.symtab)
8318 free (aux.symtab);
8319 if (aux.strtab)
8320 free ((char *) aux.strtab);
0b6ae522
DJ		 8321}
8322
1b31d05e 8323static void
2cf0635d 8324process_unwind (FILE * file)
57346661 8325{
2cf0635d
NC		 8326 struct unwind_handler
8327 {
57346661 8328 int machtype;
1b31d05e 8329 void (* handler)(FILE *);
2cf0635d
NC		 8330 } handlers[] =
8331 {
0b6ae522 8332 { EM_ARM, arm_process_unwind },
57346661
AM		 8333 { EM_IA_64, ia64_process_unwind },
8334 { EM_PARISC, hppa_process_unwind },
fa197c1c 8335 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8336 { 0, 0 }
8337 };
8338 int i;
8339
8340 if (!do_unwind)
1b31d05e 8341 return;
57346661
AM		 8342
8343 for (i = 0; handlers[i].handler != NULL; i++)
8344 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8345 {
8346 handlers[i].handler (file);
8347 return;
8348 }
57346661 8349
1b31d05e
NC		 8350 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8351 get_machine_name (elf_header.e_machine));
57346661
AM		 8352}
8353
252b5132 8354static void
2cf0635d 8355dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8356{
8357 switch (entry->d_tag)
8358 {
8359 case DT_MIPS_FLAGS:
8360 if (entry->d_un.d_val == 0)
4b68bca3 8361 printf (_("NONE"));
252b5132
RH		 8362 else
8363 {
8364 static const char * opts[] =
8365 {
8366 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8367 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8368 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8369 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8370 "RLD_ORDER_SAFE"
8371 };
8372 unsigned int cnt;
8373 int first = 1;
2b692964 8374
60bca95a 8375 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8376 if (entry->d_un.d_val & (1 << cnt))
8377 {
8378 printf ("%s%s", first ? "" : " ", opts[cnt]);
8379 first = 0;
8380 }
252b5132
RH		 8381 }
8382 break;
103f02d3 8383
252b5132 8384 case DT_MIPS_IVERSION:
d79b3d50 8385 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8386 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8387 else
76ca31c0
NC		 8388 {
8389 char buf[40];
8390 sprintf_vma (buf, entry->d_un.d_ptr);
8391 /* Note: coded this way so that there is a single string for translation. */
8392 printf (_("<corrupt: %s>"), buf);
8393 }
252b5132 8394 break;
103f02d3 8395
252b5132
RH		 8396 case DT_MIPS_TIME_STAMP:
8397 {
8398 char timebuf[20];
2cf0635d 8399 struct tm * tmp;
91d6fa6a 8400 time_t atime = entry->d_un.d_val;
82b1b41b 8401
91d6fa6a 8402 tmp = gmtime (&atime);
82b1b41b
NC		 8403 /* PR 17531: file: 6accc532. */
8404 if (tmp == NULL)
8405 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8406 else
8407 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8408 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8409 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8410 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8411 }
8412 break;
103f02d3 8413
252b5132
RH		 8414 case DT_MIPS_RLD_VERSION:
8415 case DT_MIPS_LOCAL_GOTNO:
8416 case DT_MIPS_CONFLICTNO:
8417 case DT_MIPS_LIBLISTNO:
8418 case DT_MIPS_SYMTABNO:
8419 case DT_MIPS_UNREFEXTNO:
8420 case DT_MIPS_HIPAGENO:
8421 case DT_MIPS_DELTA_CLASS_NO:
8422 case DT_MIPS_DELTA_INSTANCE_NO:
8423 case DT_MIPS_DELTA_RELOC_NO:
8424 case DT_MIPS_DELTA_SYM_NO:
8425 case DT_MIPS_DELTA_CLASSSYM_NO:
8426 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8427 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8428 break;
103f02d3
UD		 8429
8430 default:
4b68bca3 8431 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8432 }
4b68bca3 8433 putchar ('\n');
103f02d3
UD		 8434}
8435
103f02d3 8436static void
2cf0635d 8437dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8438{
8439 switch (entry->d_tag)
8440 {
8441 case DT_HP_DLD_FLAGS:
8442 {
8443 static struct
8444 {
8445 long int bit;
2cf0635d 8446 const char * str;
5e220199
NC		 8447 }
8448 flags[] =
8449 {
8450 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8451 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8452 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8453 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8454 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8455 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8456 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8457 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8458 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8459 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8460 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8461 { DT_HP_GST, "HP_GST" },
8462 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8463 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8464 { DT_HP_NODELETE, "HP_NODELETE" },
8465 { DT_HP_GROUP, "HP_GROUP" },
8466 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8467 };
103f02d3 8468 int first = 1;
5e220199 8469 size_t cnt;
f7a99963 8470 bfd_vma val = entry->d_un.d_val;
103f02d3 8471
60bca95a 8472 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8473 if (val & flags[cnt].bit)
30800947
NC		 8474 {
8475 if (! first)
8476 putchar (' ');
8477 fputs (flags[cnt].str, stdout);
8478 first = 0;
8479 val ^= flags[cnt].bit;
8480 }
76da6bbe 8481
103f02d3 8482 if (val != 0 || first)
f7a99963
NC		 8483 {
8484 if (! first)
8485 putchar (' ');
8486 print_vma (val, HEX);
8487 }
103f02d3
UD		 8488 }
8489 break;
76da6bbe 8490
252b5132 8491 default:
f7a99963
NC		 8492 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8493 break;
252b5132 8494 }
35b1837e 8495 putchar ('\n');
252b5132
RH		 8496}
8497
28f997cf
TG		 8498#ifdef BFD64
8499
8500/* VMS vs Unix time offset and factor. */
8501
8502#define VMS_EPOCH_OFFSET 35067168000000000LL
8503#define VMS_GRANULARITY_FACTOR 10000000
8504
8505/* Display a VMS time in a human readable format. */
8506
8507static void
8508print_vms_time (bfd_int64_t vmstime)
8509{
8510 struct tm *tm;
8511 time_t unxtime;
8512
8513 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8514 tm = gmtime (&unxtime);
8515 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8516 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8517 tm->tm_hour, tm->tm_min, tm->tm_sec);
8518}
8519#endif /* BFD64 */
8520
ecc51f48 8521static void
2cf0635d 8522dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8523{
8524 switch (entry->d_tag)
8525 {
0de14b54 8526 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8527 /* First 3 slots reserved. */
ecc51f48
NC		 8528 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8529 printf (" -- ");
8530 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8531 break;
8532
28f997cf
TG		 8533 case DT_IA_64_VMS_LINKTIME:
8534#ifdef BFD64
8535 print_vms_time (entry->d_un.d_val);
8536#endif
8537 break;
8538
8539 case DT_IA_64_VMS_LNKFLAGS:
8540 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8541 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8542 printf (" CALL_DEBUG");
8543 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8544 printf (" NOP0BUFS");
8545 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8546 printf (" P0IMAGE");
8547 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8548 printf (" MKTHREADS");
8549 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8550 printf (" UPCALLS");
8551 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8552 printf (" IMGSTA");
8553 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8554 printf (" INITIALIZE");
8555 if (entry->d_un.d_val & VMS_LF_MAIN)
8556 printf (" MAIN");
8557 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8558 printf (" EXE_INIT");
8559 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8560 printf (" TBK_IN_IMG");
8561 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8562 printf (" DBG_IN_IMG");
8563 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8564 printf (" TBK_IN_DSF");
8565 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8566 printf (" DBG_IN_DSF");
8567 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8568 printf (" SIGNATURES");
8569 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8570 printf (" REL_SEG_OFF");
8571 break;
8572
bdf4d63a
JJ		 8573 default:
8574 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8575 break;
ecc51f48 8576 }
bdf4d63a 8577 putchar ('\n');
ecc51f48
NC		 8578}
8579
252b5132 8580static int
2cf0635d 8581get_32bit_dynamic_section (FILE * file)
252b5132 8582{
2cf0635d
NC		 8583 Elf32_External_Dyn * edyn;
8584 Elf32_External_Dyn * ext;
8585 Elf_Internal_Dyn * entry;
103f02d3 8586
3f5e193b
NC		 8587 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8588 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8589 if (!edyn)
8590 return 0;
103f02d3 8591
071436c6
NC		 8592 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8593 might not have the luxury of section headers. Look for the DT_NULL
8594 terminator to determine the number of entries. */
ba2685cc 8595 for (ext = edyn, dynamic_nent = 0;
071436c6 8596 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8597 ext++)
8598 {
8599 dynamic_nent++;
8600 if (BYTE_GET (ext->d_tag) == DT_NULL)
8601 break;
8602 }
252b5132 8603
3f5e193b
NC		 8604 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8605 sizeof (* entry));
b2d38a17 8606 if (dynamic_section == NULL)
252b5132 8607 {
8b73c356
NC		 8608 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8609 (unsigned long) dynamic_nent);
9ea033b2
NC		 8610 free (edyn);
8611 return 0;
8612 }
252b5132 8613
fb514b26 8614 for (ext = edyn, entry = dynamic_section;
ba2685cc 8615 entry < dynamic_section + dynamic_nent;
fb514b26 8616 ext++, entry++)
9ea033b2 8617 {
fb514b26
AM		 8618 entry->d_tag = BYTE_GET (ext->d_tag);
8619 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8620 }
8621
9ea033b2
NC		 8622 free (edyn);
8623
8624 return 1;
8625}
8626
8627static int
2cf0635d 8628get_64bit_dynamic_section (FILE * file)
9ea033b2 8629{
2cf0635d
NC		 8630 Elf64_External_Dyn * edyn;
8631 Elf64_External_Dyn * ext;
8632 Elf_Internal_Dyn * entry;
103f02d3 8633
071436c6 8634 /* Read in the data. */
3f5e193b
NC		 8635 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8636 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8637 if (!edyn)
8638 return 0;
103f02d3 8639
071436c6
NC		 8640 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8641 might not have the luxury of section headers. Look for the DT_NULL
8642 terminator to determine the number of entries. */
ba2685cc 8643 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8644 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8645 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8646 ext++)
8647 {
8648 dynamic_nent++;
66543521 8649 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8650 break;
8651 }
252b5132 8652
3f5e193b
NC		 8653 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8654 sizeof (* entry));
b2d38a17 8655 if (dynamic_section == NULL)
252b5132 8656 {
8b73c356
NC		 8657 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8658 (unsigned long) dynamic_nent);
252b5132
RH		 8659 free (edyn);
8660 return 0;
8661 }
8662
071436c6 8663 /* Convert from external to internal formats. */
fb514b26 8664 for (ext = edyn, entry = dynamic_section;
ba2685cc 8665 entry < dynamic_section + dynamic_nent;
fb514b26 8666 ext++, entry++)
252b5132 8667 {
66543521
AM		 8668 entry->d_tag = BYTE_GET (ext->d_tag);
8669 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8670 }
8671
8672 free (edyn);
8673
9ea033b2
NC		 8674 return 1;
8675}
8676
e9e44622
JJ		 8677static void
8678print_dynamic_flags (bfd_vma flags)
d1133906 8679{
e9e44622 8680 int first = 1;
13ae64f3 8681
d1133906
NC		 8682 while (flags)
8683 {
8684 bfd_vma flag;
8685
8686 flag = flags & - flags;
8687 flags &= ~ flag;
8688
e9e44622
JJ		 8689 if (first)
8690 first = 0;
8691 else
8692 putc (' ', stdout);
13ae64f3 8693
d1133906
NC		 8694 switch (flag)
8695 {
e9e44622
JJ		 8696 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8697 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8698 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8699 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8700 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8701 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8702 }
8703 }
e9e44622 8704 puts ("");
d1133906
NC		 8705}
8706
b2d38a17
NC		 8707/* Parse and display the contents of the dynamic section. */
8708
9ea033b2 8709static int
2cf0635d 8710process_dynamic_section (FILE * file)
9ea033b2 8711{
2cf0635d 8712 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8713
8714 if (dynamic_size == 0)
8715 {
8716 if (do_dynamic)
b2d38a17 8717 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8718
8719 return 1;
8720 }
8721
8722 if (is_32bit_elf)
8723 {
b2d38a17 8724 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8725 return 0;
8726 }
b2d38a17 8727 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8728 return 0;
8729
252b5132
RH		 8730 /* Find the appropriate symbol table. */
8731 if (dynamic_symbols == NULL)
8732 {
86dba8ee
AM		 8733 for (entry = dynamic_section;
8734 entry < dynamic_section + dynamic_nent;
8735 ++entry)
252b5132 8736 {
c8286bd1 8737 Elf_Internal_Shdr section;
252b5132
RH		 8738
8739 if (entry->d_tag != DT_SYMTAB)
8740 continue;
8741
8742 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8743
8744 /* Since we do not know how big the symbol table is,
8745 we default to reading in the entire file (!) and
8746 processing that. This is overkill, I know, but it
e3c8793a 8747 should work. */
d93f0186 8748 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8749
fb52b2f4
NC		 8750 if (archive_file_offset != 0)
8751 section.sh_size = archive_file_size - section.sh_offset;
8752 else
8753 {
8754 if (fseek (file, 0, SEEK_END))
591a748a 8755 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8756
8757 section.sh_size = ftell (file) - section.sh_offset;
8758 }
252b5132 8759
9ea033b2 8760 if (is_32bit_elf)
9ad5cbcf 8761 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8762 else
9ad5cbcf 8763 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8764 section.sh_name = string_table_length;
252b5132 8765
ba5cdace 8766 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8767 if (num_dynamic_syms < 1)
252b5132
RH		 8768 {
8769 error (_("Unable to determine the number of symbols to load\n"));
8770 continue;
8771 }
252b5132
RH		 8772 }
8773 }
8774
8775 /* Similarly find a string table. */
8776 if (dynamic_strings == NULL)
8777 {
86dba8ee
AM		 8778 for (entry = dynamic_section;
8779 entry < dynamic_section + dynamic_nent;
8780 ++entry)
252b5132
RH		 8781 {
8782 unsigned long offset;
b34976b6 8783 long str_tab_len;
252b5132
RH		 8784
8785 if (entry->d_tag != DT_STRTAB)
8786 continue;
8787
8788 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8789
8790 /* Since we do not know how big the string 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. */
252b5132 8794
d93f0186 8795 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8796
8797 if (archive_file_offset != 0)
8798 str_tab_len = archive_file_size - offset;
8799 else
8800 {
8801 if (fseek (file, 0, SEEK_END))
8802 error (_("Unable to seek to end of file\n"));
8803 str_tab_len = ftell (file) - offset;
8804 }
252b5132
RH		 8805
8806 if (str_tab_len < 1)
8807 {
8808 error
8809 (_("Unable to determine the length of the dynamic string table\n"));
8810 continue;
8811 }
8812
3f5e193b
NC		 8813 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8814 str_tab_len,
8815 _("dynamic string table"));
59245841 8816 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8817 break;
8818 }
8819 }
8820
8821 /* And find the syminfo section if available. */
8822 if (dynamic_syminfo == NULL)
8823 {
3e8bba36 8824 unsigned long syminsz = 0;
252b5132 8825
86dba8ee
AM		 8826 for (entry = dynamic_section;
8827 entry < dynamic_section + dynamic_nent;
8828 ++entry)
252b5132
RH		 8829 {
8830 if (entry->d_tag == DT_SYMINENT)
8831 {
8832 /* Note: these braces are necessary to avoid a syntax
8833 error from the SunOS4 C compiler. */
049b0c3a
NC		 8834 /* PR binutils/17531: A corrupt file can trigger this test.
8835 So do not use an assert, instead generate an error message. */
8836 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8837 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8838 (int) entry->d_un.d_val);
252b5132
RH		 8839 }
8840 else if (entry->d_tag == DT_SYMINSZ)
8841 syminsz = entry->d_un.d_val;
8842 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8843 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8844 syminsz);
252b5132
RH		 8845 }
8846
8847 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8848 {
2cf0635d
NC		 8849 Elf_External_Syminfo * extsyminfo;
8850 Elf_External_Syminfo * extsym;
8851 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8852
8853 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8854 extsyminfo = (Elf_External_Syminfo *)
8855 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8856 _("symbol information"));
a6e9f9df
AM		 8857 if (!extsyminfo)
8858 return 0;
252b5132 8859
3f5e193b 8860 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8861 if (dynamic_syminfo == NULL)
8862 {
8b73c356
NC		 8863 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8864 (unsigned long) syminsz);
252b5132
RH		 8865 return 0;
8866 }
8867
8868 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8869 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8870 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8871 ++syminfo, ++extsym)
252b5132 8872 {
86dba8ee
AM		 8873 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8874 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8875 }
8876
8877 free (extsyminfo);
8878 }
8879 }
8880
8881 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8882 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8883 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8884 if (do_dynamic)
8885 printf (_(" Tag Type Name/Value\n"));
8886
86dba8ee
AM		 8887 for (entry = dynamic_section;
8888 entry < dynamic_section + dynamic_nent;
8889 entry++)
252b5132
RH		 8890 {
8891 if (do_dynamic)
f7a99963 8892 {
2cf0635d 8893 const char * dtype;
e699b9ff 8894
f7a99963
NC		 8895 putchar (' ');
8896 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8897 dtype = get_dynamic_type (entry->d_tag);
8898 printf (" (%s)%*s", dtype,
8899 ((is_32bit_elf ? 27 : 19)
8900 - (int) strlen (dtype)),
f7a99963
NC		 8901 " ");
8902 }
252b5132
RH		 8903
8904 switch (entry->d_tag)
8905 {
d1133906
NC		 8906 case DT_FLAGS:
8907 if (do_dynamic)
e9e44622 8908 print_dynamic_flags (entry->d_un.d_val);
d1133906 8909 break;
76da6bbe 8910
252b5132
RH		 8911 case DT_AUXILIARY:
8912 case DT_FILTER:
019148e4
L		 8913 case DT_CONFIG:
8914 case DT_DEPAUDIT:
8915 case DT_AUDIT:
252b5132
RH		 8916 if (do_dynamic)
8917 {
019148e4 8918 switch (entry->d_tag)
b34976b6 8919 {
019148e4
L		 8920 case DT_AUXILIARY:
8921 printf (_("Auxiliary library"));
8922 break;
8923
8924 case DT_FILTER:
8925 printf (_("Filter library"));
8926 break;
8927
b34976b6 8928 case DT_CONFIG:
019148e4
L		 8929 printf (_("Configuration file"));
8930 break;
8931
8932 case DT_DEPAUDIT:
8933 printf (_("Dependency audit library"));
8934 break;
8935
8936 case DT_AUDIT:
8937 printf (_("Audit library"));
8938 break;
8939 }
252b5132 8940
d79b3d50
NC		 8941 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8942 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8943 else
f7a99963
NC		 8944 {
8945 printf (": ");
8946 print_vma (entry->d_un.d_val, PREFIX_HEX);
8947 putchar ('\n');
8948 }
252b5132
RH		 8949 }
8950 break;
8951
dcefbbbd 8952 case DT_FEATURE:
252b5132
RH		 8953 if (do_dynamic)
8954 {
8955 printf (_("Flags:"));
86f55779 8956
252b5132
RH		 8957 if (entry->d_un.d_val == 0)
8958 printf (_(" None\n"));
8959 else
8960 {
8961 unsigned long int val = entry->d_un.d_val;
86f55779 8962
252b5132
RH		 8963 if (val & DTF_1_PARINIT)
8964 {
8965 printf (" PARINIT");
8966 val ^= DTF_1_PARINIT;
8967 }
dcefbbbd
L		 8968 if (val & DTF_1_CONFEXP)
8969 {
8970 printf (" CONFEXP");
8971 val ^= DTF_1_CONFEXP;
8972 }
252b5132
RH		 8973 if (val != 0)
8974 printf (" %lx", val);
8975 puts ("");
8976 }
8977 }
8978 break;
8979
8980 case DT_POSFLAG_1:
8981 if (do_dynamic)
8982 {
8983 printf (_("Flags:"));
86f55779 8984
252b5132
RH		 8985 if (entry->d_un.d_val == 0)
8986 printf (_(" None\n"));
8987 else
8988 {
8989 unsigned long int val = entry->d_un.d_val;
86f55779 8990
252b5132
RH		 8991 if (val & DF_P1_LAZYLOAD)
8992 {
8993 printf (" LAZYLOAD");
8994 val ^= DF_P1_LAZYLOAD;
8995 }
8996 if (val & DF_P1_GROUPPERM)
8997 {
8998 printf (" GROUPPERM");
8999 val ^= DF_P1_GROUPPERM;
9000 }
9001 if (val != 0)
9002 printf (" %lx", val);
9003 puts ("");
9004 }
9005 }
9006 break;
9007
9008 case DT_FLAGS_1:
9009 if (do_dynamic)
9010 {
9011 printf (_("Flags:"));
9012 if (entry->d_un.d_val == 0)
9013 printf (_(" None\n"));
9014 else
9015 {
9016 unsigned long int val = entry->d_un.d_val;
86f55779 9017
252b5132
RH		 9018 if (val & DF_1_NOW)
9019 {
9020 printf (" NOW");
9021 val ^= DF_1_NOW;
9022 }
9023 if (val & DF_1_GLOBAL)
9024 {
9025 printf (" GLOBAL");
9026 val ^= DF_1_GLOBAL;
9027 }
9028 if (val & DF_1_GROUP)
9029 {
9030 printf (" GROUP");
9031 val ^= DF_1_GROUP;
9032 }
9033 if (val & DF_1_NODELETE)
9034 {
9035 printf (" NODELETE");
9036 val ^= DF_1_NODELETE;
9037 }
9038 if (val & DF_1_LOADFLTR)
9039 {
9040 printf (" LOADFLTR");
9041 val ^= DF_1_LOADFLTR;
9042 }
9043 if (val & DF_1_INITFIRST)
9044 {
9045 printf (" INITFIRST");
9046 val ^= DF_1_INITFIRST;
9047 }
9048 if (val & DF_1_NOOPEN)
9049 {
9050 printf (" NOOPEN");
9051 val ^= DF_1_NOOPEN;
9052 }
9053 if (val & DF_1_ORIGIN)
9054 {
9055 printf (" ORIGIN");
9056 val ^= DF_1_ORIGIN;
9057 }
9058 if (val & DF_1_DIRECT)
9059 {
9060 printf (" DIRECT");
9061 val ^= DF_1_DIRECT;
9062 }
9063 if (val & DF_1_TRANS)
9064 {
9065 printf (" TRANS");
9066 val ^= DF_1_TRANS;
9067 }
9068 if (val & DF_1_INTERPOSE)
9069 {
9070 printf (" INTERPOSE");
9071 val ^= DF_1_INTERPOSE;
9072 }
f7db6139 9073 if (val & DF_1_NODEFLIB)
dcefbbbd 9074 {
f7db6139
L		 9075 printf (" NODEFLIB");
9076 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9077 }
9078 if (val & DF_1_NODUMP)
9079 {
9080 printf (" NODUMP");
9081 val ^= DF_1_NODUMP;
9082 }
34b60028 9083 if (val & DF_1_CONFALT)
dcefbbbd 9084 {
34b60028
L		 9085 printf (" CONFALT");
9086 val ^= DF_1_CONFALT;
9087 }
9088 if (val & DF_1_ENDFILTEE)
9089 {
9090 printf (" ENDFILTEE");
9091 val ^= DF_1_ENDFILTEE;
9092 }
9093 if (val & DF_1_DISPRELDNE)
9094 {
9095 printf (" DISPRELDNE");
9096 val ^= DF_1_DISPRELDNE;
9097 }
9098 if (val & DF_1_DISPRELPND)
9099 {
9100 printf (" DISPRELPND");
9101 val ^= DF_1_DISPRELPND;
9102 }
9103 if (val & DF_1_NODIRECT)
9104 {
9105 printf (" NODIRECT");
9106 val ^= DF_1_NODIRECT;
9107 }
9108 if (val & DF_1_IGNMULDEF)
9109 {
9110 printf (" IGNMULDEF");
9111 val ^= DF_1_IGNMULDEF;
9112 }
9113 if (val & DF_1_NOKSYMS)
9114 {
9115 printf (" NOKSYMS");
9116 val ^= DF_1_NOKSYMS;
9117 }
9118 if (val & DF_1_NOHDR)
9119 {
9120 printf (" NOHDR");
9121 val ^= DF_1_NOHDR;
9122 }
9123 if (val & DF_1_EDITED)
9124 {
9125 printf (" EDITED");
9126 val ^= DF_1_EDITED;
9127 }
9128 if (val & DF_1_NORELOC)
9129 {
9130 printf (" NORELOC");
9131 val ^= DF_1_NORELOC;
9132 }
9133 if (val & DF_1_SYMINTPOSE)
9134 {
9135 printf (" SYMINTPOSE");
9136 val ^= DF_1_SYMINTPOSE;
9137 }
9138 if (val & DF_1_GLOBAUDIT)
9139 {
9140 printf (" GLOBAUDIT");
9141 val ^= DF_1_GLOBAUDIT;
9142 }
9143 if (val & DF_1_SINGLETON)
9144 {
9145 printf (" SINGLETON");
9146 val ^= DF_1_SINGLETON;
dcefbbbd 9147 }
252b5132
RH		 9148 if (val != 0)
9149 printf (" %lx", val);
9150 puts ("");
9151 }
9152 }
9153 break;
9154
9155 case DT_PLTREL:
566b0d53 9156 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9157 if (do_dynamic)
9158 puts (get_dynamic_type (entry->d_un.d_val));
9159 break;
9160
9161 case DT_NULL :
9162 case DT_NEEDED :
9163 case DT_PLTGOT :
9164 case DT_HASH :
9165 case DT_STRTAB :
9166 case DT_SYMTAB :
9167 case DT_RELA :
9168 case DT_INIT :
9169 case DT_FINI :
9170 case DT_SONAME :
9171 case DT_RPATH :
9172 case DT_SYMBOLIC:
9173 case DT_REL :
9174 case DT_DEBUG :
9175 case DT_TEXTREL :
9176 case DT_JMPREL :
019148e4 9177 case DT_RUNPATH :
252b5132
RH		 9178 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9179
9180 if (do_dynamic)
9181 {
2cf0635d 9182 char * name;
252b5132 9183
d79b3d50
NC		 9184 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9185 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9186 else
d79b3d50 9187 name = NULL;
252b5132
RH		 9188
9189 if (name)
9190 {
9191 switch (entry->d_tag)
9192 {
9193 case DT_NEEDED:
9194 printf (_("Shared library: [%s]"), name);
9195
18bd398b 9196 if (streq (name, program_interpreter))
f7a99963 9197 printf (_(" program interpreter"));
252b5132
RH		 9198 break;
9199
9200 case DT_SONAME:
f7a99963 9201 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9202 break;
9203
9204 case DT_RPATH:
f7a99963 9205 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9206 break;
9207
019148e4
L		 9208 case DT_RUNPATH:
9209 printf (_("Library runpath: [%s]"), name);
9210 break;
9211
252b5132 9212 default:
f7a99963
NC		 9213 print_vma (entry->d_un.d_val, PREFIX_HEX);
9214 break;
252b5132
RH		 9215 }
9216 }
9217 else
f7a99963
NC		 9218 print_vma (entry->d_un.d_val, PREFIX_HEX);
9219
9220 putchar ('\n');
252b5132
RH		 9221 }
9222 break;
9223
9224 case DT_PLTRELSZ:
9225 case DT_RELASZ :
9226 case DT_STRSZ :
9227 case DT_RELSZ :
9228 case DT_RELAENT :
9229 case DT_SYMENT :
9230 case DT_RELENT :
566b0d53 9231 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9232 case DT_PLTPADSZ:
9233 case DT_MOVEENT :
9234 case DT_MOVESZ :
9235 case DT_INIT_ARRAYSZ:
9236 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9237 case DT_GNU_CONFLICTSZ:
9238 case DT_GNU_LIBLISTSZ:
252b5132 9239 if (do_dynamic)
f7a99963
NC		 9240 {
9241 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9242 printf (_(" (bytes)\n"));
f7a99963 9243 }
252b5132
RH		 9244 break;
9245
9246 case DT_VERDEFNUM:
9247 case DT_VERNEEDNUM:
9248 case DT_RELACOUNT:
9249 case DT_RELCOUNT:
9250 if (do_dynamic)
f7a99963
NC		 9251 {
9252 print_vma (entry->d_un.d_val, UNSIGNED);
9253 putchar ('\n');
9254 }
252b5132
RH		 9255 break;
9256
9257 case DT_SYMINSZ:
9258 case DT_SYMINENT:
9259 case DT_SYMINFO:
9260 case DT_USED:
9261 case DT_INIT_ARRAY:
9262 case DT_FINI_ARRAY:
9263 if (do_dynamic)
9264 {
d79b3d50
NC		 9265 if (entry->d_tag == DT_USED
9266 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9267 {
2cf0635d 9268 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9269
b34976b6 9270 if (*name)
252b5132
RH		 9271 {
9272 printf (_("Not needed object: [%s]\n"), name);
9273 break;
9274 }
9275 }
103f02d3 9276
f7a99963
NC		 9277 print_vma (entry->d_un.d_val, PREFIX_HEX);
9278 putchar ('\n');
252b5132
RH		 9279 }
9280 break;
9281
9282 case DT_BIND_NOW:
9283 /* The value of this entry is ignored. */
35b1837e
AM		 9284 if (do_dynamic)
9285 putchar ('\n');
252b5132 9286 break;
103f02d3 9287
047b2264
JJ		 9288 case DT_GNU_PRELINKED:
9289 if (do_dynamic)
9290 {
2cf0635d 9291 struct tm * tmp;
91d6fa6a 9292 time_t atime = entry->d_un.d_val;
047b2264 9293
91d6fa6a 9294 tmp = gmtime (&atime);
071436c6
NC		 9295 /* PR 17533 file: 041-1244816-0.004. */
9296 if (tmp == NULL)
5a2cbcf4
L		 9297 printf (_("<corrupt time val: %lx"),
9298 (unsigned long) atime);
071436c6
NC		 9299 else
9300 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9301 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9302 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9303
9304 }
9305 break;
9306
fdc90cb4
JJ		 9307 case DT_GNU_HASH:
9308 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9309 if (do_dynamic)
9310 {
9311 print_vma (entry->d_un.d_val, PREFIX_HEX);
9312 putchar ('\n');
9313 }
9314 break;
9315
252b5132
RH		 9316 default:
9317 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9318 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9319 entry->d_un.d_val;
9320
9321 if (do_dynamic)
9322 {
9323 switch (elf_header.e_machine)
9324 {
9325 case EM_MIPS:
4fe85591 9326 case EM_MIPS_RS3_LE:
b2d38a17 9327 dynamic_section_mips_val (entry);
252b5132 9328 break;
103f02d3 9329 case EM_PARISC:
b2d38a17 9330 dynamic_section_parisc_val (entry);
103f02d3 9331 break;
ecc51f48 9332 case EM_IA_64:
b2d38a17 9333 dynamic_section_ia64_val (entry);
ecc51f48 9334 break;
252b5132 9335 default:
f7a99963
NC		 9336 print_vma (entry->d_un.d_val, PREFIX_HEX);
9337 putchar ('\n');
252b5132
RH		 9338 }
9339 }
9340 break;
9341 }
9342 }
9343
9344 return 1;
9345}
9346
9347static char *
d3ba0551 9348get_ver_flags (unsigned int flags)
252b5132 9349{
b34976b6 9350 static char buff[32];
252b5132
RH		 9351
9352 buff[0] = 0;
9353
9354 if (flags == 0)
9355 return _("none");
9356
9357 if (flags & VER_FLG_BASE)
9358 strcat (buff, "BASE ");
9359
9360 if (flags & VER_FLG_WEAK)
9361 {
9362 if (flags & VER_FLG_BASE)
9363 strcat (buff, "| ");
9364
9365 strcat (buff, "WEAK ");
9366 }
9367
44ec90b9
RO		 9368 if (flags & VER_FLG_INFO)
9369 {
9370 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9371 strcat (buff, "| ");
9372
9373 strcat (buff, "INFO ");
9374 }
9375
9376 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9377 strcat (buff, _("| <unknown>"));
252b5132
RH		 9378
9379 return buff;
9380}
9381
9382/* Display the contents of the version sections. */
98fb390a 9383
252b5132 9384static int
2cf0635d 9385process_version_sections (FILE * file)
252b5132 9386{
2cf0635d 9387 Elf_Internal_Shdr * section;
b34976b6
AM		 9388 unsigned i;
9389 int found = 0;
252b5132
RH		 9390
9391 if (! do_version)
9392 return 1;
9393
9394 for (i = 0, section = section_headers;
9395 i < elf_header.e_shnum;
b34976b6 9396 i++, section++)
252b5132
RH		 9397 {
9398 switch (section->sh_type)
9399 {
9400 case SHT_GNU_verdef:
9401 {
2cf0635d 9402 Elf_External_Verdef * edefs;
b34976b6
AM		 9403 unsigned int idx;
9404 unsigned int cnt;
2cf0635d 9405 char * endbuf;
252b5132
RH		 9406
9407 found = 1;
9408
74e1a04b
NC		 9409 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9410 printable_section_name (section),
9411 section->sh_info);
252b5132
RH		 9412
9413 printf (_(" Addr: 0x"));
9414 printf_vma (section->sh_addr);
74e1a04b 9415 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9416 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9417 printable_section_name_from_index (section->sh_link));
252b5132 9418
3f5e193b
NC		 9419 edefs = (Elf_External_Verdef *)
9420 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9421 _("version definition section"));
a6e9f9df
AM		 9422 if (!edefs)
9423 break;
59245841 9424 endbuf = (char *) edefs + section->sh_size;
252b5132 9425
b34976b6 9426 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9427 {
2cf0635d
NC		 9428 char * vstart;
9429 Elf_External_Verdef * edef;
b34976b6 9430 Elf_Internal_Verdef ent;
2cf0635d 9431 Elf_External_Verdaux * eaux;
b34976b6
AM		 9432 Elf_Internal_Verdaux aux;
9433 int j;
9434 int isum;
103f02d3 9435
7e26601c
NC		 9436 /* Check for very large indicies. */
9437 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9438 break;
9439
252b5132 9440 vstart = ((char *) edefs) + idx;
54806181
AM		 9441 if (vstart + sizeof (*edef) > endbuf)
9442 break;
252b5132
RH		 9443
9444 edef = (Elf_External_Verdef *) vstart;
9445
9446 ent.vd_version = BYTE_GET (edef->vd_version);
9447 ent.vd_flags = BYTE_GET (edef->vd_flags);
9448 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9449 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9450 ent.vd_hash = BYTE_GET (edef->vd_hash);
9451 ent.vd_aux = BYTE_GET (edef->vd_aux);
9452 ent.vd_next = BYTE_GET (edef->vd_next);
9453
9454 printf (_(" %#06x: Rev: %d Flags: %s"),
9455 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9456
9457 printf (_(" Index: %d Cnt: %d "),
9458 ent.vd_ndx, ent.vd_cnt);
9459
dd24e3da 9460 /* Check for overflow. */
7e26601c 9461 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9462 break;
9463
252b5132
RH		 9464 vstart += ent.vd_aux;
9465
9466 eaux = (Elf_External_Verdaux *) vstart;
9467
9468 aux.vda_name = BYTE_GET (eaux->vda_name);
9469 aux.vda_next = BYTE_GET (eaux->vda_next);
9470
d79b3d50
NC		 9471 if (VALID_DYNAMIC_NAME (aux.vda_name))
9472 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9473 else
9474 printf (_("Name index: %ld\n"), aux.vda_name);
9475
9476 isum = idx + ent.vd_aux;
9477
b34976b6 9478 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9479 {
dd24e3da 9480 /* Check for overflow. */
7e26601c 9481 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9482 break;
9483
252b5132
RH		 9484 isum += aux.vda_next;
9485 vstart += aux.vda_next;
9486
9487 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9488 if (vstart + sizeof (*eaux) > endbuf)
9489 break;
252b5132
RH		 9490
9491 aux.vda_name = BYTE_GET (eaux->vda_name);
9492 aux.vda_next = BYTE_GET (eaux->vda_next);
9493
d79b3d50 9494 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9495 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9496 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9497 else
9498 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9499 isum, j, aux.vda_name);
9500 }
dd24e3da 9501
54806181
AM		 9502 if (j < ent.vd_cnt)
9503 printf (_(" Version def aux past end of section\n"));
252b5132 9504
5d921cbd
NC		 9505 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9506 if (idx + ent.vd_next <= idx)
9507 break;
9508
252b5132
RH		 9509 idx += ent.vd_next;
9510 }
dd24e3da 9511
54806181
AM		 9512 if (cnt < section->sh_info)
9513 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9514
9515 free (edefs);
9516 }
9517 break;
103f02d3 9518
252b5132
RH		 9519 case SHT_GNU_verneed:
9520 {
2cf0635d 9521 Elf_External_Verneed * eneed;
b34976b6
AM		 9522 unsigned int idx;
9523 unsigned int cnt;
2cf0635d 9524 char * endbuf;
252b5132
RH		 9525
9526 found = 1;
9527
72de5009 9528 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9529 printable_section_name (section), section->sh_info);
252b5132
RH		 9530
9531 printf (_(" Addr: 0x"));
9532 printf_vma (section->sh_addr);
72de5009 9533 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9534 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9535 printable_section_name_from_index (section->sh_link));
252b5132 9536
3f5e193b
NC		 9537 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9538 section->sh_offset, 1,
9539 section->sh_size,
9cf03b7e 9540 _("Version Needs section"));
a6e9f9df
AM		 9541 if (!eneed)
9542 break;
59245841 9543 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9544
9545 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9546 {
2cf0635d 9547 Elf_External_Verneed * entry;
b34976b6
AM		 9548 Elf_Internal_Verneed ent;
9549 int j;
9550 int isum;
2cf0635d 9551 char * vstart;
252b5132 9552
7e26601c 9553 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9554 break;
9555
252b5132 9556 vstart = ((char *) eneed) + idx;
54806181
AM		 9557 if (vstart + sizeof (*entry) > endbuf)
9558 break;
252b5132
RH		 9559
9560 entry = (Elf_External_Verneed *) vstart;
9561
9562 ent.vn_version = BYTE_GET (entry->vn_version);
9563 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9564 ent.vn_file = BYTE_GET (entry->vn_file);
9565 ent.vn_aux = BYTE_GET (entry->vn_aux);
9566 ent.vn_next = BYTE_GET (entry->vn_next);
9567
9568 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9569
d79b3d50
NC		 9570 if (VALID_DYNAMIC_NAME (ent.vn_file))
9571 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9572 else
9573 printf (_(" File: %lx"), ent.vn_file);
9574
9575 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9576
dd24e3da 9577 /* Check for overflow. */
7e26601c 9578 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9579 break;
252b5132
RH		 9580 vstart += ent.vn_aux;
9581
9582 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9583 {
2cf0635d 9584 Elf_External_Vernaux * eaux;
b34976b6 9585 Elf_Internal_Vernaux aux;
252b5132 9586
54806181
AM		 9587 if (vstart + sizeof (*eaux) > endbuf)
9588 break;
252b5132
RH		 9589 eaux = (Elf_External_Vernaux *) vstart;
9590
9591 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9592 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9593 aux.vna_other = BYTE_GET (eaux->vna_other);
9594 aux.vna_name = BYTE_GET (eaux->vna_name);
9595 aux.vna_next = BYTE_GET (eaux->vna_next);
9596
d79b3d50 9597 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9598 printf (_(" %#06x: Name: %s"),
d79b3d50 9599 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9600 else
ecc2063b 9601 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9602 isum, aux.vna_name);
9603
9604 printf (_(" Flags: %s Version: %d\n"),
9605 get_ver_flags (aux.vna_flags), aux.vna_other);
9606
dd24e3da 9607 /* Check for overflow. */
53774b7e
NC		 9608 if (aux.vna_next > (size_t) (endbuf - vstart)
9609 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9610 {
9611 warn (_("Invalid vna_next field of %lx\n"),
9612 aux.vna_next);
9613 j = ent.vn_cnt;
9614 break;
9615 }
252b5132
RH		 9616 isum += aux.vna_next;
9617 vstart += aux.vna_next;
9618 }
9cf03b7e 9619
54806181 9620 if (j < ent.vn_cnt)
9cf03b7e 9621 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9622
bcf83b2a 9623 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9624 {
9625 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9626 cnt = section->sh_info;
9627 break;
9628 }
252b5132
RH		 9629 idx += ent.vn_next;
9630 }
9cf03b7e 9631
54806181 9632 if (cnt < section->sh_info)
9cf03b7e 9633 warn (_("Missing Version Needs information\n"));
103f02d3 9634
252b5132
RH		 9635 free (eneed);
9636 }
9637 break;
9638
9639 case SHT_GNU_versym:
9640 {
2cf0635d 9641 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9642 size_t total;
9643 unsigned int cnt;
2cf0635d
NC		 9644 unsigned char * edata;
9645 unsigned short * data;
9646 char * strtab;
9647 Elf_Internal_Sym * symbols;
9648 Elf_Internal_Shdr * string_sec;
ba5cdace 9649 unsigned long num_syms;
d3ba0551 9650 long off;
252b5132 9651
4fbb74a6 9652 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9653 break;
9654
4fbb74a6 9655 link_section = section_headers + section->sh_link;
08d8fa11 9656 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9657
4fbb74a6 9658 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9659 break;
9660
252b5132
RH		 9661 found = 1;
9662
ba5cdace 9663 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9664 if (symbols == NULL)
9665 break;
252b5132 9666
4fbb74a6 9667 string_sec = section_headers + link_section->sh_link;
252b5132 9668
3f5e193b
NC		 9669 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9670 string_sec->sh_size,
9671 _("version string table"));
a6e9f9df 9672 if (!strtab)
0429c154
MS		 9673 {
9674 free (symbols);
9675 break;
9676 }
252b5132 9677
8b73c356
NC		 9678 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9679 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9680
9681 printf (_(" Addr: "));
9682 printf_vma (section->sh_addr);
72de5009 9683 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9684 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9685 printable_section_name (link_section));
252b5132 9686
d3ba0551
AM		 9687 off = offset_from_vma (file,
9688 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9689 total * sizeof (short));
3f5e193b
NC		 9690 edata = (unsigned char *) get_data (NULL, file, off, total,
9691 sizeof (short),
9692 _("version symbol data"));
a6e9f9df
AM		 9693 if (!edata)
9694 {
9695 free (strtab);
0429c154 9696 free (symbols);
a6e9f9df
AM		 9697 break;
9698 }
252b5132 9699
3f5e193b 9700 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9701
9702 for (cnt = total; cnt --;)
b34976b6
AM		 9703 data[cnt] = byte_get (edata + cnt * sizeof (short),
9704 sizeof (short));
252b5132
RH		 9705
9706 free (edata);
9707
9708 for (cnt = 0; cnt < total; cnt += 4)
9709 {
9710 int j, nn;
00d93f34 9711 int check_def, check_need;
2cf0635d 9712 char * name;
252b5132
RH		 9713
9714 printf (" %03x:", cnt);
9715
9716 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9717 switch (data[cnt + j])
252b5132
RH		 9718 {
9719 case 0:
9720 fputs (_(" 0 (*local*) "), stdout);
9721 break;
9722
9723 case 1:
9724 fputs (_(" 1 (*global*) "), stdout);
9725 break;
9726
9727 default:
c244d050
NC		 9728 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9729 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9730
dd24e3da 9731 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9732 array, break to avoid an out-of-bounds read. */
9733 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9734 {
9735 warn (_("invalid index into symbol array\n"));
9736 break;
9737 }
9738
00d93f34
JJ		 9739 check_def = 1;
9740 check_need = 1;
4fbb74a6
AM		 9741 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9742 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9743 != SHT_NOBITS)
252b5132 9744 {
b34976b6 9745 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9746 check_def = 0;
9747 else
9748 check_need = 0;
252b5132 9749 }
00d93f34
JJ		 9750
9751 if (check_need
b34976b6 9752 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9753 {
b34976b6
AM		 9754 Elf_Internal_Verneed ivn;
9755 unsigned long offset;
252b5132 9756
d93f0186
NC		 9757 offset = offset_from_vma
9758 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9759 sizeof (Elf_External_Verneed));
252b5132 9760
b34976b6 9761 do
252b5132 9762 {
b34976b6
AM		 9763 Elf_Internal_Vernaux ivna;
9764 Elf_External_Verneed evn;
9765 Elf_External_Vernaux evna;
9766 unsigned long a_off;
252b5132 9767
59245841
NC		 9768 if (get_data (&evn, file, offset, sizeof (evn), 1,
9769 _("version need")) == NULL)
9770 break;
0b4362b0 9771
252b5132
RH		 9772 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9773 ivn.vn_next = BYTE_GET (evn.vn_next);
9774
9775 a_off = offset + ivn.vn_aux;
9776
9777 do
9778 {
59245841
NC		 9779 if (get_data (&evna, file, a_off, sizeof (evna),
9780 1, _("version need aux (2)")) == NULL)
9781 {
9782 ivna.vna_next = 0;
9783 ivna.vna_other = 0;
9784 }
9785 else
9786 {
9787 ivna.vna_next = BYTE_GET (evna.vna_next);
9788 ivna.vna_other = BYTE_GET (evna.vna_other);
9789 }
252b5132
RH		 9790
9791 a_off += ivna.vna_next;
9792 }
b34976b6 9793 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9794 && ivna.vna_next != 0);
9795
b34976b6 9796 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9797 {
9798 ivna.vna_name = BYTE_GET (evna.vna_name);
9799
54806181
AM		 9800 if (ivna.vna_name >= string_sec->sh_size)
9801 name = _("*invalid*");
9802 else
9803 name = strtab + ivna.vna_name;
252b5132 9804 nn += printf ("(%s%-*s",
16062207
ILT		 9805 name,
9806 12 - (int) strlen (name),
252b5132 9807 ")");
00d93f34 9808 check_def = 0;
252b5132
RH		 9809 break;
9810 }
9811
9812 offset += ivn.vn_next;
9813 }
9814 while (ivn.vn_next);
9815 }
00d93f34 9816
b34976b6
AM		 9817 if (check_def && data[cnt + j] != 0x8001
9818 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9819 {
b34976b6
AM		 9820 Elf_Internal_Verdef ivd;
9821 Elf_External_Verdef evd;
9822 unsigned long offset;
252b5132 9823
d93f0186
NC		 9824 offset = offset_from_vma
9825 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9826 sizeof evd);
252b5132
RH		 9827
9828 do
9829 {
59245841
NC		 9830 if (get_data (&evd, file, offset, sizeof (evd), 1,
9831 _("version def")) == NULL)
9832 {
9833 ivd.vd_next = 0;
948f632f 9834 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9835 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9836 break;
59245841
NC		 9837 }
9838 else
9839 {
9840 ivd.vd_next = BYTE_GET (evd.vd_next);
9841 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9842 }
252b5132
RH		 9843
9844 offset += ivd.vd_next;
9845 }
c244d050 9846 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9847 && ivd.vd_next != 0);
9848
c244d050 9849 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9850 {
b34976b6
AM		 9851 Elf_External_Verdaux evda;
9852 Elf_Internal_Verdaux ivda;
252b5132
RH		 9853
9854 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9855
59245841
NC		 9856 if (get_data (&evda, file,
9857 offset - ivd.vd_next + ivd.vd_aux,
9858 sizeof (evda), 1,
9859 _("version def aux")) == NULL)
9860 break;
252b5132
RH		 9861
9862 ivda.vda_name = BYTE_GET (evda.vda_name);
9863
54806181
AM		 9864 if (ivda.vda_name >= string_sec->sh_size)
9865 name = _("*invalid*");
9866 else
9867 name = strtab + ivda.vda_name;
252b5132 9868 nn += printf ("(%s%-*s",
16062207
ILT		 9869 name,
9870 12 - (int) strlen (name),
252b5132
RH		 9871 ")");
9872 }
9873 }
9874
9875 if (nn < 18)
9876 printf ("%*c", 18 - nn, ' ');
9877 }
9878
9879 putchar ('\n');
9880 }
9881
9882 free (data);
9883 free (strtab);
9884 free (symbols);
9885 }
9886 break;
103f02d3 9887
252b5132
RH		 9888 default:
9889 break;
9890 }
9891 }
9892
9893 if (! found)
9894 printf (_("\nNo version information found in this file.\n"));
9895
9896 return 1;
9897}
9898
d1133906 9899static const char *
d3ba0551 9900get_symbol_binding (unsigned int binding)
252b5132 9901{
b34976b6 9902 static char buff[32];
252b5132
RH		 9903
9904 switch (binding)
9905 {
b34976b6
AM		 9906 case STB_LOCAL: return "LOCAL";
9907 case STB_GLOBAL: return "GLOBAL";
9908 case STB_WEAK: return "WEAK";
252b5132
RH		 9909 default:
9910 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9911 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9912 binding);
252b5132 9913 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9914 {
9915 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9916 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9917 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9918 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9919 return "UNIQUE";
9920 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9921 }
252b5132 9922 else
e9e44622 9923 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9924 return buff;
9925 }
9926}
9927
d1133906 9928static const char *
d3ba0551 9929get_symbol_type (unsigned int type)
252b5132 9930{
b34976b6 9931 static char buff[32];
252b5132
RH		 9932
9933 switch (type)
9934 {
b34976b6
AM		 9935 case STT_NOTYPE: return "NOTYPE";
9936 case STT_OBJECT: return "OBJECT";
9937 case STT_FUNC: return "FUNC";
9938 case STT_SECTION: return "SECTION";
9939 case STT_FILE: return "FILE";
9940 case STT_COMMON: return "COMMON";
9941 case STT_TLS: return "TLS";
15ab5209
DB		 9942 case STT_RELC: return "RELC";
9943 case STT_SRELC: return "SRELC";
252b5132
RH		 9944 default:
9945 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9946 {
3510a7b8
NC		 9947 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9948 return "THUMB_FUNC";
103f02d3 9949
351b4b40 9950 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9951 return "REGISTER";
9952
9953 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9954 return "PARISC_MILLI";
9955
e9e44622 9956 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9957 }
252b5132 9958 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9959 {
9960 if (elf_header.e_machine == EM_PARISC)
9961 {
9962 if (type == STT_HP_OPAQUE)
9963 return "HP_OPAQUE";
9964 if (type == STT_HP_STUB)
9965 return "HP_STUB";
9966 }
9967
d8045f23 9968 if (type == STT_GNU_IFUNC
9c55345c 9969 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9970 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9971 /* GNU is still using the default value 0. */
d8045f23
NC		 9972 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9973 return "IFUNC";
9974
e9e44622 9975 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9976 }
252b5132 9977 else
e9e44622 9978 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9979 return buff;
9980 }
9981}
9982
d1133906 9983static const char *
d3ba0551 9984get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9985{
9986 switch (visibility)
9987 {
b34976b6
AM		 9988 case STV_DEFAULT: return "DEFAULT";
9989 case STV_INTERNAL: return "INTERNAL";
9990 case STV_HIDDEN: return "HIDDEN";
d1133906 9991 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 9992 default:
9993 error (_("Unrecognized visibility value: %u"), visibility);
9994 return _("<unknown>");
d1133906
NC		 9995 }
9996}
9997
5e2b0d47
NC		 9998static const char *
9999get_mips_symbol_other (unsigned int other)
10000{
10001 switch (other)
10002 {
df58fc94
RS		 10003 case STO_OPTIONAL:
10004 return "OPTIONAL";
10005 case STO_MIPS_PLT:
10006 return "MIPS PLT";
10007 case STO_MIPS_PIC:
10008 return "MIPS PIC";
10009 case STO_MICROMIPS:
10010 return "MICROMIPS";
10011 case STO_MICROMIPS | STO_MIPS_PIC:
10012 return "MICROMIPS, MIPS PIC";
10013 case STO_MIPS16:
10014 return "MIPS16";
10015 default:
10016 return NULL;
5e2b0d47
NC		 10017 }
10018}
10019
28f997cf
TG		 10020static const char *
10021get_ia64_symbol_other (unsigned int other)
10022{
10023 if (is_ia64_vms ())
10024 {
10025 static char res[32];
10026
10027 res[0] = 0;
10028
10029 /* Function types is for images and .STB files only. */
10030 switch (elf_header.e_type)
10031 {
10032 case ET_DYN:
10033 case ET_EXEC:
10034 switch (VMS_ST_FUNC_TYPE (other))
10035 {
10036 case VMS_SFT_CODE_ADDR:
10037 strcat (res, " CA");
10038 break;
10039 case VMS_SFT_SYMV_IDX:
10040 strcat (res, " VEC");
10041 break;
10042 case VMS_SFT_FD:
10043 strcat (res, " FD");
10044 break;
10045 case VMS_SFT_RESERVE:
10046 strcat (res, " RSV");
10047 break;
10048 default:
bee0ee85
NC		 10049 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10050 VMS_ST_FUNC_TYPE (other));
10051 strcat (res, " <unknown>");
10052 break;
28f997cf
TG		 10053 }
10054 break;
10055 default:
10056 break;
10057 }
10058 switch (VMS_ST_LINKAGE (other))
10059 {
10060 case VMS_STL_IGNORE:
10061 strcat (res, " IGN");
10062 break;
10063 case VMS_STL_RESERVE:
10064 strcat (res, " RSV");
10065 break;
10066 case VMS_STL_STD:
10067 strcat (res, " STD");
10068 break;
10069 case VMS_STL_LNK:
10070 strcat (res, " LNK");
10071 break;
10072 default:
bee0ee85
NC		 10073 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10074 VMS_ST_LINKAGE (other));
10075 strcat (res, " <unknown>");
10076 break;
28f997cf
TG		 10077 }
10078
10079 if (res[0] != 0)
10080 return res + 1;
10081 else
10082 return res;
10083 }
10084 return NULL;
10085}
10086
6911b7dc
AM		 10087static const char *
10088get_ppc64_symbol_other (unsigned int other)
10089{
10090 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10091 {
10092 static char buf[32];
10093 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10094 PPC64_LOCAL_ENTRY_OFFSET (other));
10095 return buf;
10096 }
10097 return NULL;
10098}
10099
5e2b0d47
NC		 10100static const char *
10101get_symbol_other (unsigned int other)
10102{
10103 const char * result = NULL;
10104 static char buff [32];
10105
10106 if (other == 0)
10107 return "";
10108
10109 switch (elf_header.e_machine)
10110 {
10111 case EM_MIPS:
10112 result = get_mips_symbol_other (other);
28f997cf
TG		 10113 break;
10114 case EM_IA_64:
10115 result = get_ia64_symbol_other (other);
10116 break;
6911b7dc
AM		 10117 case EM_PPC64:
10118 result = get_ppc64_symbol_other (other);
10119 break;
5e2b0d47
NC		 10120 default:
10121 break;
10122 }
10123
10124 if (result)
10125 return result;
10126
10127 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10128 return buff;
10129}
10130
d1133906 10131static const char *
d3ba0551 10132get_symbol_index_type (unsigned int type)
252b5132 10133{
b34976b6 10134 static char buff[32];
5cf1065c 10135
252b5132
RH		 10136 switch (type)
10137 {
b34976b6
AM		 10138 case SHN_UNDEF: return "UND";
10139 case SHN_ABS: return "ABS";
10140 case SHN_COMMON: return "COM";
252b5132 10141 default:
9ce701e2
L		 10142 if (type == SHN_IA_64_ANSI_COMMON
10143 && elf_header.e_machine == EM_IA_64
10144 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10145 return "ANSI_COM";
8a9036a4 10146 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10147 || elf_header.e_machine == EM_L1OM
10148 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10149 && type == SHN_X86_64_LCOMMON)
10150 return "LARGE_COM";
ac145307
BS		 10151 else if ((type == SHN_MIPS_SCOMMON
10152 && elf_header.e_machine == EM_MIPS)
10153 || (type == SHN_TIC6X_SCOMMON
10154 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10155 return "SCOM";
10156 else if (type == SHN_MIPS_SUNDEFINED
10157 && elf_header.e_machine == EM_MIPS)
10158 return "SUND";
9ce701e2 10159 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10160 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10161 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10162 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10163 else if (type >= SHN_LORESERVE)
10164 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10165 else if (type >= elf_header.e_shnum)
e0a31db1 10166 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10167 else
232e7cb8 10168 sprintf (buff, "%3d", type);
5cf1065c 10169 break;
252b5132 10170 }
5cf1065c
NC		 10171
10172 return buff;
252b5132
RH		 10173}
10174
66543521 10175static bfd_vma *
57028622 10176get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10177{
2cf0635d
NC		 10178 unsigned char * e_data;
10179 bfd_vma * i_data;
252b5132 10180
57028622
NC		 10181 /* If the size_t type is smaller than the bfd_size_type, eg because
10182 you are building a 32-bit tool on a 64-bit host, then make sure
10183 that when (number) is cast to (size_t) no information is lost. */
10184 if (sizeof (size_t) < sizeof (bfd_size_type)
10185 && (bfd_size_type) ((size_t) number) != number)
10186 {
10187 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10188 (unsigned long long) number, ent_size);
10189 return NULL;
10190 }
948f632f 10191
3102e897
NC		 10192 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10193 attempting to allocate memory when the read is bound to fail. */
10194 if (ent_size * number > current_file_size)
10195 {
57028622
NC		 10196 error (_("Invalid number of dynamic entries: %llu\n"),
10197 (unsigned long long) number);
3102e897
NC		 10198 return NULL;
10199 }
10200
57028622 10201 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10202 if (e_data == NULL)
10203 {
57028622
NC		 10204 error (_("Out of memory reading %llu dynamic entries\n"),
10205 (unsigned long long) number);
252b5132
RH		 10206 return NULL;
10207 }
10208
57028622 10209 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10210 {
57028622
NC		 10211 error (_("Unable to read in %llu bytes of dynamic data\n"),
10212 (unsigned long long) (number * ent_size));
3102e897 10213 free (e_data);
252b5132
RH		 10214 return NULL;
10215 }
10216
57028622 10217 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10218 if (i_data == NULL)
10219 {
57028622
NC		 10220 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10221 (unsigned long long) number);
252b5132
RH		 10222 free (e_data);
10223 return NULL;
10224 }
10225
10226 while (number--)
66543521 10227 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10228
10229 free (e_data);
10230
10231 return i_data;
10232}
10233
6bd1a22c
L		 10234static void
10235print_dynamic_symbol (bfd_vma si, unsigned long hn)
10236{
2cf0635d 10237 Elf_Internal_Sym * psym;
6bd1a22c
L		 10238 int n;
10239
6bd1a22c
L		 10240 n = print_vma (si, DEC_5);
10241 if (n < 5)
0b4362b0 10242 fputs (&" "[n], stdout);
6bd1a22c 10243 printf (" %3lu: ", hn);
e0a31db1
NC		 10244
10245 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10246 {
3102e897
NC		 10247 printf (_("<No info available for dynamic symbol number %lu>\n"),
10248 (unsigned long) si);
e0a31db1
NC		 10249 return;
10250 }
10251
10252 psym = dynamic_symbols + si;
6bd1a22c
L		 10253 print_vma (psym->st_value, LONG_HEX);
10254 putchar (' ');
10255 print_vma (psym->st_size, DEC_5);
10256
f4be36b3
AM		 10257 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10258 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10259 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10260 /* Check to see if any other bits in the st_other field are set.
10261 Note - displaying this information disrupts the layout of the
10262 table being generated, but for the moment this case is very
10263 rare. */
10264 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10265 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10266 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10267 if (VALID_DYNAMIC_NAME (psym->st_name))
10268 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10269 else
2b692964 10270 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10271 putchar ('\n');
10272}
10273
bb4d2ac2
L		 10274static const char *
10275get_symbol_version_string (FILE *file, int is_dynsym,
10276 const char *strtab,
10277 unsigned long int strtab_size,
10278 unsigned int si, Elf_Internal_Sym *psym,
10279 enum versioned_symbol_info *sym_info,
10280 unsigned short *vna_other)
10281{
10282 const char *version_string = NULL;
10283
10284 if (is_dynsym
10285 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10286 {
10287 unsigned char data[2];
10288 unsigned short vers_data;
10289 unsigned long offset;
10290 int is_nobits;
10291 int check_def;
10292
10293 offset = offset_from_vma
10294 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10295 sizeof data + si * sizeof (vers_data));
10296
10297 if (get_data (&data, file, offset + si * sizeof (vers_data),
10298 sizeof (data), 1, _("version data")) == NULL)
10299 return NULL;
10300
10301 vers_data = byte_get (data, 2);
10302
53774b7e
NC		 10303 is_nobits = (section_headers != NULL
10304 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10305 && section_headers[psym->st_shndx].sh_type
10306 == SHT_NOBITS);
10307
10308 check_def = (psym->st_shndx != SHN_UNDEF);
10309
10310 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10311 {
10312 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10313 && (is_nobits || ! check_def))
10314 {
10315 Elf_External_Verneed evn;
10316 Elf_Internal_Verneed ivn;
10317 Elf_Internal_Vernaux ivna;
10318
10319 /* We must test both. */
10320 offset = offset_from_vma
10321 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10322 sizeof evn);
10323
10324 do
10325 {
10326 unsigned long vna_off;
10327
10328 if (get_data (&evn, file, offset, sizeof (evn), 1,
10329 _("version need")) == NULL)
10330 {
10331 ivna.vna_next = 0;
10332 ivna.vna_other = 0;
10333 ivna.vna_name = 0;
10334 break;
10335 }
10336
10337 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10338 ivn.vn_next = BYTE_GET (evn.vn_next);
10339
10340 vna_off = offset + ivn.vn_aux;
10341
10342 do
10343 {
10344 Elf_External_Vernaux evna;
10345
10346 if (get_data (&evna, file, vna_off,
10347 sizeof (evna), 1,
10348 _("version need aux (3)")) == NULL)
10349 {
10350 ivna.vna_next = 0;
10351 ivna.vna_other = 0;
10352 ivna.vna_name = 0;
10353 }
10354 else
10355 {
10356 ivna.vna_other = BYTE_GET (evna.vna_other);
10357 ivna.vna_next = BYTE_GET (evna.vna_next);
10358 ivna.vna_name = BYTE_GET (evna.vna_name);
10359 }
10360
10361 vna_off += ivna.vna_next;
10362 }
10363 while (ivna.vna_other != vers_data
10364 && ivna.vna_next != 0);
10365
10366 if (ivna.vna_other == vers_data)
10367 break;
10368
10369 offset += ivn.vn_next;
10370 }
10371 while (ivn.vn_next != 0);
10372
10373 if (ivna.vna_other == vers_data)
10374 {
10375 *sym_info = symbol_undefined;
10376 *vna_other = ivna.vna_other;
10377 version_string = (ivna.vna_name < strtab_size
10378 ? strtab + ivna.vna_name
10379 : _("<corrupt>"));
10380 check_def = 0;
10381 }
10382 else if (! is_nobits)
10383 error (_("bad dynamic symbol\n"));
10384 else
10385 check_def = 1;
10386 }
10387
10388 if (check_def)
10389 {
10390 if (vers_data != 0x8001
10391 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10392 {
10393 Elf_Internal_Verdef ivd;
10394 Elf_Internal_Verdaux ivda;
10395 Elf_External_Verdaux evda;
10396 unsigned long off;
10397
10398 off = offset_from_vma
10399 (file,
10400 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10401 sizeof (Elf_External_Verdef));
10402
10403 do
10404 {
10405 Elf_External_Verdef evd;
10406
10407 if (get_data (&evd, file, off, sizeof (evd),
10408 1, _("version def")) == NULL)
10409 {
10410 ivd.vd_ndx = 0;
10411 ivd.vd_aux = 0;
10412 ivd.vd_next = 0;
10413 }
10414 else
10415 {
10416 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10417 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10418 ivd.vd_next = BYTE_GET (evd.vd_next);
10419 }
10420
10421 off += ivd.vd_next;
10422 }
10423 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10424 && ivd.vd_next != 0);
10425
10426 off -= ivd.vd_next;
10427 off += ivd.vd_aux;
10428
10429 if (get_data (&evda, file, off, sizeof (evda),
10430 1, _("version def aux")) == NULL)
10431 return version_string;
10432
10433 ivda.vda_name = BYTE_GET (evda.vda_name);
10434
10435 if (psym->st_name != ivda.vda_name)
10436 {
10437 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10438 ? symbol_hidden : symbol_public);
10439 version_string = (ivda.vda_name < strtab_size
10440 ? strtab + ivda.vda_name
10441 : _("<corrupt>"));
10442 }
10443 }
10444 }
10445 }
10446 }
10447 return version_string;
10448}
10449
e3c8793a 10450/* Dump the symbol table. */
252b5132 10451static int
2cf0635d 10452process_symbol_table (FILE * file)
252b5132 10453{
2cf0635d 10454 Elf_Internal_Shdr * section;
8b73c356
NC		 10455 bfd_size_type nbuckets = 0;
10456 bfd_size_type nchains = 0;
2cf0635d
NC		 10457 bfd_vma * buckets = NULL;
10458 bfd_vma * chains = NULL;
fdc90cb4 10459 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10460 bfd_vma * gnubuckets = NULL;
10461 bfd_vma * gnuchains = NULL;
6bd1a22c 10462 bfd_vma gnusymidx = 0;
071436c6 10463 bfd_size_type ngnuchains = 0;
252b5132 10464
2c610e4b 10465 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10466 return 1;
10467
6bd1a22c
L		 10468 if (dynamic_info[DT_HASH]
10469 && (do_histogram
2c610e4b
L		 10470 || (do_using_dynamic
10471 && !do_dyn_syms
10472 && dynamic_strings != NULL)))
252b5132 10473 {
66543521
AM		 10474 unsigned char nb[8];
10475 unsigned char nc[8];
8b73c356 10476 unsigned int hash_ent_size = 4;
66543521
AM		 10477
10478 if ((elf_header.e_machine == EM_ALPHA
10479 || elf_header.e_machine == EM_S390
10480 || elf_header.e_machine == EM_S390_OLD)
10481 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10482 hash_ent_size = 8;
10483
fb52b2f4
NC		 10484 if (fseek (file,
10485 (archive_file_offset
10486 + offset_from_vma (file, dynamic_info[DT_HASH],
10487 sizeof nb + sizeof nc)),
d93f0186 10488 SEEK_SET))
252b5132 10489 {
591a748a 10490 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10491 goto no_hash;
252b5132
RH		 10492 }
10493
66543521 10494 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10495 {
10496 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10497 goto no_hash;
252b5132
RH		 10498 }
10499
66543521 10500 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10501 {
10502 error (_("Failed to read in number of chains\n"));
d3a44ec6 10503 goto no_hash;
252b5132
RH		 10504 }
10505
66543521
AM		 10506 nbuckets = byte_get (nb, hash_ent_size);
10507 nchains = byte_get (nc, hash_ent_size);
252b5132 10508
66543521
AM		 10509 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10510 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10511
d3a44ec6 10512 no_hash:
252b5132 10513 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10514 {
10515 if (do_using_dynamic)
10516 return 0;
10517 free (buckets);
10518 free (chains);
10519 buckets = NULL;
10520 chains = NULL;
10521 nbuckets = 0;
10522 nchains = 0;
10523 }
252b5132
RH		 10524 }
10525
6bd1a22c
L		 10526 if (dynamic_info_DT_GNU_HASH
10527 && (do_histogram
2c610e4b
L		 10528 || (do_using_dynamic
10529 && !do_dyn_syms
10530 && dynamic_strings != NULL)))
252b5132 10531 {
6bd1a22c
L		 10532 unsigned char nb[16];
10533 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10534 bfd_vma buckets_vma;
10535
10536 if (fseek (file,
10537 (archive_file_offset
10538 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10539 sizeof nb)),
10540 SEEK_SET))
10541 {
10542 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10543 goto no_gnu_hash;
6bd1a22c 10544 }
252b5132 10545
6bd1a22c
L		 10546 if (fread (nb, 16, 1, file) != 1)
10547 {
10548 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10549 goto no_gnu_hash;
6bd1a22c
L		 10550 }
10551
10552 ngnubuckets = byte_get (nb, 4);
10553 gnusymidx = byte_get (nb + 4, 4);
10554 bitmaskwords = byte_get (nb + 8, 4);
10555 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10556 if (is_32bit_elf)
6bd1a22c 10557 buckets_vma += bitmaskwords * 4;
f7a99963 10558 else
6bd1a22c 10559 buckets_vma += bitmaskwords * 8;
252b5132 10560
6bd1a22c
L		 10561 if (fseek (file,
10562 (archive_file_offset
10563 + offset_from_vma (file, buckets_vma, 4)),
10564 SEEK_SET))
252b5132 10565 {
6bd1a22c 10566 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10567 goto no_gnu_hash;
6bd1a22c
L		 10568 }
10569
10570 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10571
6bd1a22c 10572 if (gnubuckets == NULL)
d3a44ec6 10573 goto no_gnu_hash;
6bd1a22c
L		 10574
10575 for (i = 0; i < ngnubuckets; i++)
10576 if (gnubuckets[i] != 0)
10577 {
10578 if (gnubuckets[i] < gnusymidx)
10579 return 0;
10580
10581 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10582 maxchain = gnubuckets[i];
10583 }
10584
10585 if (maxchain == 0xffffffff)
d3a44ec6 10586 goto no_gnu_hash;
6bd1a22c
L		 10587
10588 maxchain -= gnusymidx;
10589
10590 if (fseek (file,
10591 (archive_file_offset
10592 + offset_from_vma (file, buckets_vma
10593 + 4 * (ngnubuckets + maxchain), 4)),
10594 SEEK_SET))
10595 {
10596 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10597 goto no_gnu_hash;
6bd1a22c
L		 10598 }
10599
10600 do
10601 {
10602 if (fread (nb, 4, 1, file) != 1)
252b5132 10603 {
6bd1a22c 10604 error (_("Failed to determine last chain length\n"));
d3a44ec6 10605 goto no_gnu_hash;
6bd1a22c 10606 }
252b5132 10607
6bd1a22c 10608 if (maxchain + 1 == 0)
d3a44ec6 10609 goto no_gnu_hash;
252b5132 10610
6bd1a22c
L		 10611 ++maxchain;
10612 }
10613 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10614
6bd1a22c
L		 10615 if (fseek (file,
10616 (archive_file_offset
10617 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10618 SEEK_SET))
10619 {
10620 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10621 goto no_gnu_hash;
6bd1a22c
L		 10622 }
10623
10624 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10625 ngnuchains = maxchain;
6bd1a22c 10626
d3a44ec6 10627 no_gnu_hash:
6bd1a22c 10628 if (gnuchains == NULL)
d3a44ec6
JJ		 10629 {
10630 free (gnubuckets);
d3a44ec6
JJ		 10631 gnubuckets = NULL;
10632 ngnubuckets = 0;
f64fddf1
NC		 10633 if (do_using_dynamic)
10634 return 0;
d3a44ec6 10635 }
6bd1a22c
L		 10636 }
10637
10638 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10639 && do_syms
10640 && do_using_dynamic
3102e897
NC		 10641 && dynamic_strings != NULL
10642 && dynamic_symbols != NULL)
6bd1a22c
L		 10643 {
10644 unsigned long hn;
10645
10646 if (dynamic_info[DT_HASH])
10647 {
10648 bfd_vma si;
10649
10650 printf (_("\nSymbol table for image:\n"));
10651 if (is_32bit_elf)
10652 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10653 else
10654 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10655
10656 for (hn = 0; hn < nbuckets; hn++)
10657 {
10658 if (! buckets[hn])
10659 continue;
10660
10661 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10662 print_dynamic_symbol (si, hn);
252b5132
RH		 10663 }
10664 }
6bd1a22c
L		 10665
10666 if (dynamic_info_DT_GNU_HASH)
10667 {
10668 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10669 if (is_32bit_elf)
10670 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10671 else
10672 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10673
10674 for (hn = 0; hn < ngnubuckets; ++hn)
10675 if (gnubuckets[hn] != 0)
10676 {
10677 bfd_vma si = gnubuckets[hn];
10678 bfd_vma off = si - gnusymidx;
10679
10680 do
10681 {
10682 print_dynamic_symbol (si, hn);
10683 si++;
10684 }
071436c6 10685 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10686 }
10687 }
252b5132 10688 }
8b73c356
NC		 10689 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10690 && section_headers != NULL)
252b5132 10691 {
b34976b6 10692 unsigned int i;
252b5132
RH		 10693
10694 for (i = 0, section = section_headers;
10695 i < elf_header.e_shnum;
10696 i++, section++)
10697 {
b34976b6 10698 unsigned int si;
2cf0635d 10699 char * strtab = NULL;
c256ffe7 10700 unsigned long int strtab_size = 0;
2cf0635d
NC		 10701 Elf_Internal_Sym * symtab;
10702 Elf_Internal_Sym * psym;
ba5cdace 10703 unsigned long num_syms;
252b5132 10704
2c610e4b
L		 10705 if ((section->sh_type != SHT_SYMTAB
10706 && section->sh_type != SHT_DYNSYM)
10707 || (!do_syms
10708 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10709 continue;
10710
dd24e3da
NC		 10711 if (section->sh_entsize == 0)
10712 {
10713 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10714 printable_section_name (section));
dd24e3da
NC		 10715 continue;
10716 }
10717
252b5132 10718 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10719 printable_section_name (section),
252b5132 10720 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10721
f7a99963 10722 if (is_32bit_elf)
ca47b30c 10723 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10724 else
ca47b30c 10725 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10726
ba5cdace 10727 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10728 if (symtab == NULL)
10729 continue;
10730
10731 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10732 {
10733 strtab = string_table;
10734 strtab_size = string_table_length;
10735 }
4fbb74a6 10736 else if (section->sh_link < elf_header.e_shnum)
252b5132 10737 {
2cf0635d 10738 Elf_Internal_Shdr * string_sec;
252b5132 10739
4fbb74a6 10740 string_sec = section_headers + section->sh_link;
252b5132 10741
3f5e193b
NC		 10742 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10743 1, string_sec->sh_size,
10744 _("string table"));
c256ffe7 10745 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10746 }
10747
ba5cdace 10748 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10749 {
bb4d2ac2
L		 10750 const char *version_string;
10751 enum versioned_symbol_info sym_info;
10752 unsigned short vna_other;
10753
5e220199 10754 printf ("%6d: ", si);
f7a99963
NC		 10755 print_vma (psym->st_value, LONG_HEX);
10756 putchar (' ');
10757 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10758 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10759 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10760 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10761 /* Check to see if any other bits in the st_other field are set.
10762 Note - displaying this information disrupts the layout of the
10763 table being generated, but for the moment this case is very rare. */
10764 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10765 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10766 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10767 print_symbol (25, psym->st_name < strtab_size
2b692964 10768 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10769
bb4d2ac2
L		 10770 version_string
10771 = get_symbol_version_string (file,
10772 section->sh_type == SHT_DYNSYM,
10773 strtab, strtab_size, si,
10774 psym, &sym_info, &vna_other);
10775 if (version_string)
252b5132 10776 {
bb4d2ac2
L		 10777 if (sym_info == symbol_undefined)
10778 printf ("@%s (%d)", version_string, vna_other);
10779 else
10780 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10781 version_string);
252b5132
RH		 10782 }
10783
10784 putchar ('\n');
10785 }
10786
10787 free (symtab);
10788 if (strtab != string_table)
10789 free (strtab);
10790 }
10791 }
10792 else if (do_syms)
10793 printf
10794 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10795
10796 if (do_histogram && buckets != NULL)
10797 {
2cf0635d
NC		 10798 unsigned long * lengths;
10799 unsigned long * counts;
66543521
AM		 10800 unsigned long hn;
10801 bfd_vma si;
10802 unsigned long maxlength = 0;
10803 unsigned long nzero_counts = 0;
10804 unsigned long nsyms = 0;
94d15024 10805 unsigned long chained;
252b5132 10806
66543521
AM		 10807 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10808 (unsigned long) nbuckets);
252b5132 10809
3f5e193b 10810 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10811 if (lengths == NULL)
10812 {
8b73c356 10813 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10814 return 0;
10815 }
8b73c356
NC		 10816
10817 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10818 for (hn = 0; hn < nbuckets; ++hn)
10819 {
94d15024
MF		 10820 for (si = buckets[hn], chained = 0;
10821 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10822 si = chains[si], ++chained)
252b5132 10823 {
b34976b6 10824 ++nsyms;
252b5132 10825 if (maxlength < ++lengths[hn])
b34976b6 10826 ++maxlength;
252b5132 10827 }
94d15024
MF		 10828
10829 /* PR binutils/17531: A corrupt binary could contain broken
10830 histogram data. Do not go into an infinite loop trying
10831 to process it. */
10832 if (chained > nchains)
10833 {
10834 error (_("histogram chain is corrupt\n"));
10835 break;
10836 }
252b5132
RH		 10837 }
10838
3f5e193b 10839 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10840 if (counts == NULL)
10841 {
b2e951ec 10842 free (lengths);
8b73c356 10843 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10844 return 0;
10845 }
10846
10847 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10848 ++counts[lengths[hn]];
252b5132 10849
103f02d3 10850 if (nbuckets > 0)
252b5132 10851 {
66543521
AM		 10852 unsigned long i;
10853 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10854 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10855 for (i = 1; i <= maxlength; ++i)
103f02d3 10856 {
66543521
AM		 10857 nzero_counts += counts[i] * i;
10858 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10859 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10860 (nzero_counts * 100.0) / nsyms);
10861 }
252b5132
RH		 10862 }
10863
10864 free (counts);
10865 free (lengths);
10866 }
10867
10868 if (buckets != NULL)
10869 {
10870 free (buckets);
10871 free (chains);
10872 }
10873
d3a44ec6 10874 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10875 {
2cf0635d
NC		 10876 unsigned long * lengths;
10877 unsigned long * counts;
fdc90cb4
JJ		 10878 unsigned long hn;
10879 unsigned long maxlength = 0;
10880 unsigned long nzero_counts = 0;
10881 unsigned long nsyms = 0;
fdc90cb4 10882
8b73c356
NC		 10883 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10884 (unsigned long) ngnubuckets);
10885
3f5e193b 10886 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10887 if (lengths == NULL)
10888 {
8b73c356 10889 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10890 return 0;
10891 }
10892
fdc90cb4
JJ		 10893 printf (_(" Length Number %% of total Coverage\n"));
10894
10895 for (hn = 0; hn < ngnubuckets; ++hn)
10896 if (gnubuckets[hn] != 0)
10897 {
10898 bfd_vma off, length = 1;
10899
6bd1a22c 10900 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10901 /* PR 17531 file: 010-77222-0.004. */
10902 off < ngnuchains && (gnuchains[off] & 1) == 0;
10903 ++off)
fdc90cb4
JJ		 10904 ++length;
10905 lengths[hn] = length;
10906 if (length > maxlength)
10907 maxlength = length;
10908 nsyms += length;
10909 }
10910
3f5e193b 10911 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10912 if (counts == NULL)
10913 {
b2e951ec 10914 free (lengths);
8b73c356 10915 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 10916 return 0;
10917 }
10918
10919 for (hn = 0; hn < ngnubuckets; ++hn)
10920 ++counts[lengths[hn]];
10921
10922 if (ngnubuckets > 0)
10923 {
10924 unsigned long j;
10925 printf (" 0 %-10lu (%5.1f%%)\n",
10926 counts[0], (counts[0] * 100.0) / ngnubuckets);
10927 for (j = 1; j <= maxlength; ++j)
10928 {
10929 nzero_counts += counts[j] * j;
10930 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10931 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10932 (nzero_counts * 100.0) / nsyms);
10933 }
10934 }
10935
10936 free (counts);
10937 free (lengths);
10938 free (gnubuckets);
10939 free (gnuchains);
10940 }
10941
252b5132
RH		 10942 return 1;
10943}
10944
10945static int
2cf0635d 10946process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10947{
b4c96d0d 10948 unsigned int i;
252b5132
RH		 10949
10950 if (dynamic_syminfo == NULL
10951 || !do_dynamic)
10952 /* No syminfo, this is ok. */
10953 return 1;
10954
10955 /* There better should be a dynamic symbol section. */
10956 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10957 return 0;
10958
10959 if (dynamic_addr)
10960 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10961 dynamic_syminfo_offset, dynamic_syminfo_nent);
10962
10963 printf (_(" Num: Name BoundTo Flags\n"));
10964 for (i = 0; i < dynamic_syminfo_nent; ++i)
10965 {
10966 unsigned short int flags = dynamic_syminfo[i].si_flags;
10967
31104126 10968 printf ("%4d: ", i);
4082ef84
NC		 10969 if (i >= num_dynamic_syms)
10970 printf (_("<corrupt index>"));
10971 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 10972 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10973 else
2b692964 10974 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10975 putchar (' ');
252b5132
RH		 10976
10977 switch (dynamic_syminfo[i].si_boundto)
10978 {
10979 case SYMINFO_BT_SELF:
10980 fputs ("SELF ", stdout);
10981 break;
10982 case SYMINFO_BT_PARENT:
10983 fputs ("PARENT ", stdout);
10984 break;
10985 default:
10986 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10987 && dynamic_syminfo[i].si_boundto < dynamic_nent
10988 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10989 {
d79b3d50 10990 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10991 putchar (' ' );
10992 }
252b5132
RH		 10993 else
10994 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10995 break;
10996 }
10997
10998 if (flags & SYMINFO_FLG_DIRECT)
10999 printf (" DIRECT");
11000 if (flags & SYMINFO_FLG_PASSTHRU)
11001 printf (" PASSTHRU");
11002 if (flags & SYMINFO_FLG_COPY)
11003 printf (" COPY");
11004 if (flags & SYMINFO_FLG_LAZYLOAD)
11005 printf (" LAZYLOAD");
11006
11007 puts ("");
11008 }
11009
11010 return 1;
11011}
11012
cf13d699
NC		 11013/* Check to see if the given reloc needs to be handled in a target specific
11014 manner. If so then process the reloc and return TRUE otherwise return
11015 FALSE. */
09c11c86 11016
cf13d699
NC		 11017static bfd_boolean
11018target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11019 unsigned char * start,
11020 Elf_Internal_Sym * symtab)
252b5132 11021{
cf13d699 11022 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11023
cf13d699 11024 switch (elf_header.e_machine)
252b5132 11025 {
13761a11
NC		 11026 case EM_MSP430:
11027 case EM_MSP430_OLD:
11028 {
11029 static Elf_Internal_Sym * saved_sym = NULL;
11030
11031 switch (reloc_type)
11032 {
11033 case 10: /* R_MSP430_SYM_DIFF */
11034 if (uses_msp430x_relocs ())
11035 break;
11036 case 21: /* R_MSP430X_SYM_DIFF */
11037 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11038 return TRUE;
11039
11040 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11041 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11042 goto handle_sym_diff;
0b4362b0 11043
13761a11
NC		 11044 case 5: /* R_MSP430_16_BYTE */
11045 case 9: /* R_MSP430_8 */
11046 if (uses_msp430x_relocs ())
11047 break;
11048 goto handle_sym_diff;
11049
11050 case 2: /* R_MSP430_ABS16 */
11051 case 15: /* R_MSP430X_ABS16 */
11052 if (! uses_msp430x_relocs ())
11053 break;
11054 goto handle_sym_diff;
0b4362b0 11055
13761a11
NC		 11056 handle_sym_diff:
11057 if (saved_sym != NULL)
11058 {
11059 bfd_vma value;
11060
11061 value = reloc->r_addend
11062 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11063 - saved_sym->st_value);
11064
11065 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11066
11067 saved_sym = NULL;
11068 return TRUE;
11069 }
11070 break;
11071
11072 default:
11073 if (saved_sym != NULL)
071436c6 11074 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11075 break;
11076 }
11077 break;
11078 }
11079
cf13d699
NC		 11080 case EM_MN10300:
11081 case EM_CYGNUS_MN10300:
11082 {
11083 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11084
cf13d699
NC		 11085 switch (reloc_type)
11086 {
11087 case 34: /* R_MN10300_ALIGN */
11088 return TRUE;
11089 case 33: /* R_MN10300_SYM_DIFF */
11090 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11091 return TRUE;
11092 case 1: /* R_MN10300_32 */
11093 case 2: /* R_MN10300_16 */
11094 if (saved_sym != NULL)
11095 {
11096 bfd_vma value;
252b5132 11097
cf13d699
NC		 11098 value = reloc->r_addend
11099 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11100 - saved_sym->st_value);
252b5132 11101
cf13d699 11102 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11103
cf13d699
NC		 11104 saved_sym = NULL;
11105 return TRUE;
11106 }
11107 break;
11108 default:
11109 if (saved_sym != NULL)
071436c6 11110 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11111 break;
11112 }
11113 break;
11114 }
252b5132
RH		 11115 }
11116
cf13d699 11117 return FALSE;
252b5132
RH		 11118}
11119
aca88567
NC		 11120/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11121 DWARF debug sections. This is a target specific test. Note - we do not
11122 go through the whole including-target-headers-multiple-times route, (as
11123 we have already done with <elf/h8.h>) because this would become very
11124 messy and even then this function would have to contain target specific
11125 information (the names of the relocs instead of their numeric values).
11126 FIXME: This is not the correct way to solve this problem. The proper way
11127 is to have target specific reloc sizing and typing functions created by
11128 the reloc-macros.h header, in the same way that it already creates the
11129 reloc naming functions. */
11130
11131static bfd_boolean
11132is_32bit_abs_reloc (unsigned int reloc_type)
11133{
11134 switch (elf_header.e_machine)
11135 {
41e92641
NC		 11136 case EM_386:
11137 case EM_486:
11138 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11139 case EM_68K:
11140 return reloc_type == 1; /* R_68K_32. */
11141 case EM_860:
11142 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11143 case EM_960:
11144 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11145 case EM_AARCH64:
11146 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11147 case EM_ALPHA:
137b6b5f 11148 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11149 case EM_ARC:
11150 return reloc_type == 1; /* R_ARC_32. */
11151 case EM_ARM:
11152 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11153 case EM_AVR_OLD:
aca88567
NC		 11154 case EM_AVR:
11155 return reloc_type == 1;
cfb8c092
NC		 11156 case EM_ADAPTEVA_EPIPHANY:
11157 return reloc_type == 3;
aca88567
NC		 11158 case EM_BLACKFIN:
11159 return reloc_type == 0x12; /* R_byte4_data. */
11160 case EM_CRIS:
11161 return reloc_type == 3; /* R_CRIS_32. */
11162 case EM_CR16:
11163 return reloc_type == 3; /* R_CR16_NUM32. */
11164 case EM_CRX:
11165 return reloc_type == 15; /* R_CRX_NUM32. */
11166 case EM_CYGNUS_FRV:
11167 return reloc_type == 1;
41e92641
NC		 11168 case EM_CYGNUS_D10V:
11169 case EM_D10V:
11170 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11171 case EM_CYGNUS_D30V:
11172 case EM_D30V:
11173 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11174 case EM_DLX:
11175 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11176 case EM_CYGNUS_FR30:
11177 case EM_FR30:
11178 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11179 case EM_FT32:
11180 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11181 case EM_H8S:
11182 case EM_H8_300:
11183 case EM_H8_300H:
11184 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 11185 case EM_IA_64:
11186 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 11187 case EM_IP2K_OLD:
11188 case EM_IP2K:
11189 return reloc_type == 2; /* R_IP2K_32. */
11190 case EM_IQ2000:
11191 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11192 case EM_LATTICEMICO32:
11193 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11194 case EM_M32C_OLD:
aca88567
NC		 11195 case EM_M32C:
11196 return reloc_type == 3; /* R_M32C_32. */
11197 case EM_M32R:
11198 return reloc_type == 34; /* R_M32R_32_RELA. */
11199 case EM_MCORE:
11200 return reloc_type == 1; /* R_MCORE_ADDR32. */
11201 case EM_CYGNUS_MEP:
11202 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11203 case EM_METAG:
11204 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11205 case EM_MICROBLAZE:
11206 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11207 case EM_MIPS:
11208 return reloc_type == 2; /* R_MIPS_32. */
11209 case EM_MMIX:
11210 return reloc_type == 4; /* R_MMIX_32. */
11211 case EM_CYGNUS_MN10200:
11212 case EM_MN10200:
11213 return reloc_type == 1; /* R_MN10200_32. */
11214 case EM_CYGNUS_MN10300:
11215 case EM_MN10300:
11216 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11217 case EM_MOXIE:
11218 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11219 case EM_MSP430_OLD:
11220 case EM_MSP430:
13761a11 11221 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11222 case EM_MT:
11223 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11224 case EM_NDS32:
11225 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11226 case EM_ALTERA_NIOS2:
36591ba1 11227 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11228 case EM_NIOS32:
11229 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11230 case EM_OR1K:
11231 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11232 case EM_PARISC:
5fda8eca
NC		 11233 return (reloc_type == 1 /* R_PARISC_DIR32. */
11234 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11235 case EM_PJ:
11236 case EM_PJ_OLD:
11237 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11238 case EM_PPC64:
11239 return reloc_type == 1; /* R_PPC64_ADDR32. */
11240 case EM_PPC:
11241 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11242 case EM_RL78:
11243 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11244 case EM_RX:
11245 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11246 case EM_S370:
11247 return reloc_type == 1; /* R_I370_ADDR31. */
11248 case EM_S390_OLD:
11249 case EM_S390:
11250 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11251 case EM_SCORE:
11252 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11253 case EM_SH:
11254 return reloc_type == 1; /* R_SH_DIR32. */
11255 case EM_SPARC32PLUS:
11256 case EM_SPARCV9:
11257 case EM_SPARC:
11258 return reloc_type == 3 /* R_SPARC_32. */
11259 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11260 case EM_SPU:
11261 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11262 case EM_TI_C6000:
11263 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11264 case EM_TILEGX:
11265 return reloc_type == 2; /* R_TILEGX_32. */
11266 case EM_TILEPRO:
11267 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11268 case EM_CYGNUS_V850:
11269 case EM_V850:
11270 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11271 case EM_V800:
11272 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11273 case EM_VAX:
11274 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11275 case EM_VISIUM:
11276 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11277 case EM_X86_64:
8a9036a4 11278 case EM_L1OM:
7a9068fe 11279 case EM_K1OM:
aca88567 11280 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11281 case EM_XC16X:
11282 case EM_C166:
11283 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11284 case EM_XGATE:
11285 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11286 case EM_XSTORMY16:
11287 return reloc_type == 1; /* R_XSTROMY16_32. */
11288 case EM_XTENSA_OLD:
11289 case EM_XTENSA:
11290 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11291 default:
bee0ee85
NC		 11292 {
11293 static unsigned int prev_warn = 0;
11294
11295 /* Avoid repeating the same warning multiple times. */
11296 if (prev_warn != elf_header.e_machine)
11297 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11298 elf_header.e_machine);
11299 prev_warn = elf_header.e_machine;
11300 return FALSE;
11301 }
aca88567
NC		 11302 }
11303}
11304
11305/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11306 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11307
11308static bfd_boolean
11309is_32bit_pcrel_reloc (unsigned int reloc_type)
11310{
11311 switch (elf_header.e_machine)
11312 {
41e92641
NC		 11313 case EM_386:
11314 case EM_486:
3e0873ac 11315 return reloc_type == 2; /* R_386_PC32. */
aca88567 11316 case EM_68K:
3e0873ac 11317 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11318 case EM_AARCH64:
11319 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11320 case EM_ADAPTEVA_EPIPHANY:
11321 return reloc_type == 6;
aca88567
NC		 11322 case EM_ALPHA:
11323 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11324 case EM_ARM:
3e0873ac 11325 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11326 case EM_MICROBLAZE:
11327 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11328 case EM_OR1K:
11329 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11330 case EM_PARISC:
85acf597 11331 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11332 case EM_PPC:
11333 return reloc_type == 26; /* R_PPC_REL32. */
11334 case EM_PPC64:
3e0873ac 11335 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11336 case EM_S390_OLD:
11337 case EM_S390:
3e0873ac 11338 return reloc_type == 5; /* R_390_PC32. */
aca88567 11339 case EM_SH:
3e0873ac 11340 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11341 case EM_SPARC32PLUS:
11342 case EM_SPARCV9:
11343 case EM_SPARC:
3e0873ac 11344 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11345 case EM_SPU:
11346 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11347 case EM_TILEGX:
11348 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11349 case EM_TILEPRO:
11350 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11351 case EM_VISIUM:
11352 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11353 case EM_X86_64:
8a9036a4 11354 case EM_L1OM:
7a9068fe 11355 case EM_K1OM:
3e0873ac 11356 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11357 case EM_XTENSA_OLD:
11358 case EM_XTENSA:
11359 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11360 default:
11361 /* Do not abort or issue an error message here. Not all targets use
11362 pc-relative 32-bit relocs in their DWARF debug information and we
11363 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11364 more helpful warning message will be generated by apply_relocations
11365 anyway, so just return. */
aca88567
NC		 11366 return FALSE;
11367 }
11368}
11369
11370/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11371 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11372
11373static bfd_boolean
11374is_64bit_abs_reloc (unsigned int reloc_type)
11375{
11376 switch (elf_header.e_machine)
11377 {
a06ea964
NC		 11378 case EM_AARCH64:
11379 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11380 case EM_ALPHA:
11381 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11382 case EM_IA_64:
11383 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11384 case EM_PARISC:
11385 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11386 case EM_PPC64:
11387 return reloc_type == 38; /* R_PPC64_ADDR64. */
11388 case EM_SPARC32PLUS:
11389 case EM_SPARCV9:
11390 case EM_SPARC:
11391 return reloc_type == 54; /* R_SPARC_UA64. */
11392 case EM_X86_64:
8a9036a4 11393 case EM_L1OM:
7a9068fe 11394 case EM_K1OM:
aca88567 11395 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11396 case EM_S390_OLD:
11397 case EM_S390:
aa137e4d
NC		 11398 return reloc_type == 22; /* R_S390_64. */
11399 case EM_TILEGX:
11400 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11401 case EM_MIPS:
aa137e4d 11402 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11403 default:
11404 return FALSE;
11405 }
11406}
11407
85acf597
RH		 11408/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11409 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11410
11411static bfd_boolean
11412is_64bit_pcrel_reloc (unsigned int reloc_type)
11413{
11414 switch (elf_header.e_machine)
11415 {
a06ea964
NC		 11416 case EM_AARCH64:
11417 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11418 case EM_ALPHA:
aa137e4d 11419 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11420 case EM_IA_64:
aa137e4d 11421 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11422 case EM_PARISC:
aa137e4d 11423 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11424 case EM_PPC64:
aa137e4d 11425 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11426 case EM_SPARC32PLUS:
11427 case EM_SPARCV9:
11428 case EM_SPARC:
aa137e4d 11429 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11430 case EM_X86_64:
8a9036a4 11431 case EM_L1OM:
7a9068fe 11432 case EM_K1OM:
aa137e4d 11433 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11434 case EM_S390_OLD:
11435 case EM_S390:
aa137e4d
NC		 11436 return reloc_type == 23; /* R_S390_PC64. */
11437 case EM_TILEGX:
11438 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11439 default:
11440 return FALSE;
11441 }
11442}
11443
4dc3c23d
AM		 11444/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11445 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11446
11447static bfd_boolean
11448is_24bit_abs_reloc (unsigned int reloc_type)
11449{
11450 switch (elf_header.e_machine)
11451 {
11452 case EM_CYGNUS_MN10200:
11453 case EM_MN10200:
11454 return reloc_type == 4; /* R_MN10200_24. */
11455 default:
11456 return FALSE;
11457 }
11458}
11459
aca88567
NC		 11460/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11461 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11462
11463static bfd_boolean
11464is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11465{
11466 switch (elf_header.e_machine)
11467 {
aca88567
NC		 11468 case EM_AVR_OLD:
11469 case EM_AVR:
11470 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11471 case EM_ADAPTEVA_EPIPHANY:
11472 return reloc_type == 5;
41e92641
NC		 11473 case EM_CYGNUS_D10V:
11474 case EM_D10V:
11475 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11476 case EM_H8S:
11477 case EM_H8_300:
11478 case EM_H8_300H:
aca88567
NC		 11479 return reloc_type == R_H8_DIR16;
11480 case EM_IP2K_OLD:
11481 case EM_IP2K:
11482 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11483 case EM_M32C_OLD:
f4236fe4
DD		 11484 case EM_M32C:
11485 return reloc_type == 1; /* R_M32C_16 */
aca88567 11486 case EM_MSP430:
13761a11
NC		 11487 if (uses_msp430x_relocs ())
11488 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11489 case EM_MSP430_OLD:
aca88567 11490 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11491 case EM_NDS32:
11492 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11493 case EM_ALTERA_NIOS2:
36591ba1 11494 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11495 case EM_NIOS32:
11496 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11497 case EM_OR1K:
11498 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11499 case EM_TI_C6000:
11500 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11501 case EM_XC16X:
11502 case EM_C166:
11503 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11504 case EM_CYGNUS_MN10200:
11505 case EM_MN10200:
11506 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11507 case EM_CYGNUS_MN10300:
11508 case EM_MN10300:
11509 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11510 case EM_VISIUM:
11511 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11512 case EM_XGATE:
11513 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11514 default:
aca88567 11515 return FALSE;
4b78141a
NC		 11516 }
11517}
11518
2a7b2e88
JK		 11519/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11520 relocation entries (possibly formerly used for SHT_GROUP sections). */
11521
11522static bfd_boolean
11523is_none_reloc (unsigned int reloc_type)
11524{
11525 switch (elf_header.e_machine)
11526 {
cb8f3167
NC		 11527 case EM_68K: /* R_68K_NONE. */
11528 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11529 case EM_SPARC32PLUS:
11530 case EM_SPARCV9:
cb8f3167
NC		 11531 case EM_SPARC: /* R_SPARC_NONE. */
11532 case EM_MIPS: /* R_MIPS_NONE. */
11533 case EM_PARISC: /* R_PARISC_NONE. */
11534 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11535 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11536 case EM_PPC: /* R_PPC_NONE. */
11537 case EM_PPC64: /* R_PPC64_NONE. */
11538 case EM_ARM: /* R_ARM_NONE. */
11539 case EM_IA_64: /* R_IA64_NONE. */
11540 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11541 case EM_S390_OLD:
cb8f3167
NC		 11542 case EM_S390: /* R_390_NONE. */
11543 case EM_CRIS: /* R_CRIS_NONE. */
11544 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11545 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11546 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11547 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11548 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11549 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11550 case EM_M32R: /* R_M32R_NONE. */
40b36596 11551 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11552 case EM_TILEGX: /* R_TILEGX_NONE. */
11553 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11554 case EM_XC16X:
11555 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11556 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11557 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11558 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11559 return reloc_type == 0;
a06ea964
NC		 11560 case EM_AARCH64:
11561 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11562 case EM_NDS32:
11563 return (reloc_type == 0 /* R_XTENSA_NONE. */
11564 || reloc_type == 204 /* R_NDS32_DIFF8. */
11565 || reloc_type == 205 /* R_NDS32_DIFF16. */
11566 || reloc_type == 206 /* R_NDS32_DIFF32. */
11567 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11568 case EM_XTENSA_OLD:
11569 case EM_XTENSA:
4dc3c23d
AM		 11570 return (reloc_type == 0 /* R_XTENSA_NONE. */
11571 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11572 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11573 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11574 case EM_METAG:
11575 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11576 }
11577 return FALSE;
11578}
11579
cf13d699
NC		 11580/* Apply relocations to a section.
11581 Note: So far support has been added only for those relocations
11582 which can be found in debug sections.
11583 FIXME: Add support for more relocations ? */
1b315056 11584
cf13d699
NC		 11585static void
11586apply_relocations (void * file,
11587 Elf_Internal_Shdr * section,
11588 unsigned char * start)
1b315056 11589{
cf13d699
NC		 11590 Elf_Internal_Shdr * relsec;
11591 unsigned char * end = start + section->sh_size;
cb8f3167 11592
cf13d699
NC		 11593 if (elf_header.e_type != ET_REL)
11594 return;
1b315056 11595
cf13d699 11596 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11597 for (relsec = section_headers;
11598 relsec < section_headers + elf_header.e_shnum;
11599 ++relsec)
252b5132 11600 {
41e92641
NC		 11601 bfd_boolean is_rela;
11602 unsigned long num_relocs;
2cf0635d
NC		 11603 Elf_Internal_Rela * relocs;
11604 Elf_Internal_Rela * rp;
11605 Elf_Internal_Shdr * symsec;
11606 Elf_Internal_Sym * symtab;
ba5cdace 11607 unsigned long num_syms;
2cf0635d 11608 Elf_Internal_Sym * sym;
252b5132 11609
41e92641 11610 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11611 || relsec->sh_info >= elf_header.e_shnum
11612 || section_headers + relsec->sh_info != section
c256ffe7 11613 || relsec->sh_size == 0
4fbb74a6 11614 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11615 continue;
428409d5 11616
41e92641
NC		 11617 is_rela = relsec->sh_type == SHT_RELA;
11618
11619 if (is_rela)
11620 {
3f5e193b
NC		 11621 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11622 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11623 return;
11624 }
11625 else
11626 {
3f5e193b
NC		 11627 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11628 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11629 return;
11630 }
11631
11632 /* SH uses RELA but uses in place value instead of the addend field. */
11633 if (elf_header.e_machine == EM_SH)
11634 is_rela = FALSE;
428409d5 11635
4fbb74a6 11636 symsec = section_headers + relsec->sh_link;
ba5cdace 11637 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11638
41e92641 11639 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11640 {
41e92641
NC		 11641 bfd_vma addend;
11642 unsigned int reloc_type;
11643 unsigned int reloc_size;
91d6fa6a 11644 unsigned char * rloc;
ba5cdace 11645 unsigned long sym_index;
4b78141a 11646
aca88567 11647 reloc_type = get_reloc_type (rp->r_info);
41e92641 11648
98fb390a 11649 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11650 continue;
98fb390a
NC		 11651 else if (is_none_reloc (reloc_type))
11652 continue;
11653 else if (is_32bit_abs_reloc (reloc_type)
11654 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11655 reloc_size = 4;
85acf597
RH		 11656 else if (is_64bit_abs_reloc (reloc_type)
11657 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11658 reloc_size = 8;
4dc3c23d
AM		 11659 else if (is_24bit_abs_reloc (reloc_type))
11660 reloc_size = 3;
aca88567
NC		 11661 else if (is_16bit_abs_reloc (reloc_type))
11662 reloc_size = 2;
11663 else
4b78141a 11664 {
bee0ee85
NC		 11665 static unsigned int prev_reloc = 0;
11666 if (reloc_type != prev_reloc)
11667 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11668 reloc_type, printable_section_name (section));
11669 prev_reloc = reloc_type;
4b78141a
NC		 11670 continue;
11671 }
103f02d3 11672
91d6fa6a 11673 rloc = start + rp->r_offset;
c8da6823 11674 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11675 {
11676 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11677 (unsigned long) rp->r_offset,
74e1a04b 11678 printable_section_name (section));
700dd8b7
L		 11679 continue;
11680 }
103f02d3 11681
ba5cdace
NC		 11682 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11683 if (sym_index >= num_syms)
11684 {
11685 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11686 sym_index, printable_section_name (section));
ba5cdace
NC		 11687 continue;
11688 }
11689 sym = symtab + sym_index;
41e92641
NC		 11690
11691 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11692 make sure that it is of an appropriate type.
11693
11694 Relocations against symbols without type can happen.
11695 Gcc -feliminate-dwarf2-dups may generate symbols
11696 without type for debug info.
11697
11698 Icc generates relocations against function symbols
11699 instead of local labels.
11700
11701 Relocations against object symbols can happen, eg when
11702 referencing a global array. For an example of this see
11703 the _clz.o binary in libgcc.a. */
aca88567 11704 if (sym != symtab
55f25fc3 11705 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11706 {
41e92641 11707 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11708 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11709 (long int)(rp - relocs),
74e1a04b 11710 printable_section_name (relsec));
aca88567 11711 continue;
5b18a4bc 11712 }
252b5132 11713
4dc3c23d
AM		 11714 addend = 0;
11715 if (is_rela)
11716 addend += rp->r_addend;
c47320c3
AM		 11717 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11718 partial_inplace. */
4dc3c23d
AM		 11719 if (!is_rela
11720 || (elf_header.e_machine == EM_XTENSA
11721 && reloc_type == 1)
11722 || ((elf_header.e_machine == EM_PJ
11723 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11724 && reloc_type == 1)
11725 || ((elf_header.e_machine == EM_D30V
11726 || elf_header.e_machine == EM_CYGNUS_D30V)
11727 && reloc_type == 12))
91d6fa6a 11728 addend += byte_get (rloc, reloc_size);
cb8f3167 11729
85acf597
RH		 11730 if (is_32bit_pcrel_reloc (reloc_type)
11731 || is_64bit_pcrel_reloc (reloc_type))
11732 {
11733 /* On HPPA, all pc-relative relocations are biased by 8. */
11734 if (elf_header.e_machine == EM_PARISC)
11735 addend -= 8;
91d6fa6a 11736 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11737 reloc_size);
11738 }
41e92641 11739 else
91d6fa6a 11740 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11741 }
252b5132 11742
5b18a4bc 11743 free (symtab);
41e92641 11744 free (relocs);
5b18a4bc
NC		 11745 break;
11746 }
5b18a4bc 11747}
103f02d3 11748
cf13d699
NC		 11749#ifdef SUPPORT_DISASSEMBLY
11750static int
11751disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11752{
74e1a04b 11753 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11754
74e1a04b 11755 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11756
11757 return 1;
11758}
11759#endif
11760
11761/* Reads in the contents of SECTION from FILE, returning a pointer
11762 to a malloc'ed buffer or NULL if something went wrong. */
11763
11764static char *
11765get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11766{
11767 bfd_size_type num_bytes;
11768
11769 num_bytes = section->sh_size;
11770
11771 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11772 {
11773 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11774 printable_section_name (section));
cf13d699
NC		 11775 return NULL;
11776 }
11777
3f5e193b
NC		 11778 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11779 _("section contents"));
cf13d699
NC		 11780}
11781
dd24e3da 11782
cf13d699
NC		 11783static void
11784dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11785{
11786 Elf_Internal_Shdr * relsec;
11787 bfd_size_type num_bytes;
cf13d699
NC		 11788 char * data;
11789 char * end;
11790 char * start;
cf13d699
NC		 11791 bfd_boolean some_strings_shown;
11792
11793 start = get_section_contents (section, file);
11794 if (start == NULL)
11795 return;
11796
74e1a04b 11797 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11798
11799 /* If the section being dumped has relocations against it the user might
11800 be expecting these relocations to have been applied. Check for this
11801 case and issue a warning message in order to avoid confusion.
11802 FIXME: Maybe we ought to have an option that dumps a section with
11803 relocs applied ? */
11804 for (relsec = section_headers;
11805 relsec < section_headers + elf_header.e_shnum;
11806 ++relsec)
11807 {
11808 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11809 || relsec->sh_info >= elf_header.e_shnum
11810 || section_headers + relsec->sh_info != section
11811 || relsec->sh_size == 0
11812 || relsec->sh_link >= elf_header.e_shnum)
11813 continue;
11814
11815 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11816 break;
11817 }
11818
11819 num_bytes = section->sh_size;
cf13d699
NC		 11820 data = start;
11821 end = start + num_bytes;
11822 some_strings_shown = FALSE;
11823
11824 while (data < end)
11825 {
11826 while (!ISPRINT (* data))
11827 if (++ data >= end)
11828 break;
11829
11830 if (data < end)
11831 {
071436c6
NC		 11832 size_t maxlen = end - data;
11833
cf13d699 11834#ifndef __MSVCRT__
c975cc98
NC		 11835 /* PR 11128: Use two separate invocations in order to work
11836 around bugs in the Solaris 8 implementation of printf. */
11837 printf (" [%6tx] ", data - start);
cf13d699 11838#else
071436c6 11839 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 11840#endif
4082ef84
NC		 11841 if (maxlen > 0)
11842 {
11843 print_symbol ((int) maxlen, data);
11844 putchar ('\n');
11845 data += strnlen (data, maxlen);
11846 }
11847 else
11848 {
11849 printf (_("<corrupt>\n"));
11850 data = end;
11851 }
cf13d699
NC		 11852 some_strings_shown = TRUE;
11853 }
11854 }
11855
11856 if (! some_strings_shown)
11857 printf (_(" No strings found in this section."));
11858
11859 free (start);
11860
11861 putchar ('\n');
11862}
11863
11864static void
11865dump_section_as_bytes (Elf_Internal_Shdr * section,
11866 FILE * file,
11867 bfd_boolean relocate)
11868{
11869 Elf_Internal_Shdr * relsec;
11870 bfd_size_type bytes;
11871 bfd_vma addr;
11872 unsigned char * data;
11873 unsigned char * start;
11874
11875 start = (unsigned char *) get_section_contents (section, file);
11876 if (start == NULL)
11877 return;
11878
74e1a04b 11879 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11880
11881 if (relocate)
11882 {
11883 apply_relocations (file, section, start);
11884 }
11885 else
11886 {
11887 /* If the section being dumped has relocations against it the user might
11888 be expecting these relocations to have been applied. Check for this
11889 case and issue a warning message in order to avoid confusion.
11890 FIXME: Maybe we ought to have an option that dumps a section with
11891 relocs applied ? */
11892 for (relsec = section_headers;
11893 relsec < section_headers + elf_header.e_shnum;
11894 ++relsec)
11895 {
11896 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11897 || relsec->sh_info >= elf_header.e_shnum
11898 || section_headers + relsec->sh_info != section
11899 || relsec->sh_size == 0
11900 || relsec->sh_link >= elf_header.e_shnum)
11901 continue;
11902
11903 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11904 break;
11905 }
11906 }
11907
11908 addr = section->sh_addr;
11909 bytes = section->sh_size;
11910 data = start;
11911
11912 while (bytes)
11913 {
11914 int j;
11915 int k;
11916 int lbytes;
11917
11918 lbytes = (bytes > 16 ? 16 : bytes);
11919
11920 printf (" 0x%8.8lx ", (unsigned long) addr);
11921
11922 for (j = 0; j < 16; j++)
11923 {
11924 if (j < lbytes)
11925 printf ("%2.2x", data[j]);
11926 else
11927 printf (" ");
11928
11929 if ((j & 3) == 3)
11930 printf (" ");
11931 }
11932
11933 for (j = 0; j < lbytes; j++)
11934 {
11935 k = data[j];
11936 if (k >= ' ' && k < 0x7f)
11937 printf ("%c", k);
11938 else
11939 printf (".");
11940 }
11941
11942 putchar ('\n');
11943
11944 data += lbytes;
11945 addr += lbytes;
11946 bytes -= lbytes;
11947 }
11948
11949 free (start);
11950
11951 putchar ('\n');
11952}
11953
4a114e3e 11954/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11955
11956static int
0ee42ecd
L		 11957uncompress_section_contents (unsigned char **buffer,
11958 dwarf_size_type *size)
cf13d699 11959{
cf13d699
NC		 11960 dwarf_size_type compressed_size = *size;
11961 unsigned char * compressed_buffer = *buffer;
11962 dwarf_size_type uncompressed_size;
11963 unsigned char * uncompressed_buffer;
11964 z_stream strm;
11965 int rc;
11966 dwarf_size_type header_size = 12;
11967
11968 /* Read the zlib header. In this case, it should be "ZLIB" followed
11969 by the uncompressed section size, 8 bytes in big-endian order. */
11970 if (compressed_size < header_size
11971 || ! streq ((char *) compressed_buffer, "ZLIB"))
11972 return 0;
11973
11974 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11975 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11976 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11977 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11978 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11979 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11980 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11981 uncompressed_size += compressed_buffer[11];
11982
11983 /* It is possible the section consists of several compressed
11984 buffers concatenated together, so we uncompress in a loop. */
11985 strm.zalloc = NULL;
11986 strm.zfree = NULL;
11987 strm.opaque = NULL;
11988 strm.avail_in = compressed_size - header_size;
11989 strm.next_in = (Bytef *) compressed_buffer + header_size;
11990 strm.avail_out = uncompressed_size;
3f5e193b 11991 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 11992
11993 rc = inflateInit (& strm);
11994 while (strm.avail_in > 0)
11995 {
11996 if (rc != Z_OK)
11997 goto fail;
11998 strm.next_out = ((Bytef *) uncompressed_buffer
11999 + (uncompressed_size - strm.avail_out));
12000 rc = inflate (&strm, Z_FINISH);
12001 if (rc != Z_STREAM_END)
12002 goto fail;
12003 rc = inflateReset (& strm);
12004 }
12005 rc = inflateEnd (& strm);
12006 if (rc != Z_OK
12007 || strm.avail_out != 0)
12008 goto fail;
12009
12010 free (compressed_buffer);
12011 *buffer = uncompressed_buffer;
12012 *size = uncompressed_size;
12013 return 1;
12014
12015 fail:
12016 free (uncompressed_buffer);
4a114e3e
L		 12017 /* Indicate decompression failure. */
12018 *buffer = NULL;
cf13d699 12019 return 0;
cf13d699
NC		 12020}
12021
d966045b
DJ		 12022static int
12023load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 12024 Elf_Internal_Shdr * sec, void * file)
1007acb3 12025{
2cf0635d 12026 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12027 char buf [64];
1007acb3 12028
19e6b90e
L		 12029 /* If it is already loaded, do nothing. */
12030 if (section->start != NULL)
12031 return 1;
1007acb3 12032
19e6b90e
L		 12033 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12034 section->address = sec->sh_addr;
06614111 12035 section->user_data = NULL;
3f5e193b
NC		 12036 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12037 sec->sh_offset, 1,
12038 sec->sh_size, buf);
59245841
NC		 12039 if (section->start == NULL)
12040 section->size = 0;
12041 else
12042 {
12043 section->size = sec->sh_size;
12044 if (uncompress_section_contents (&section->start, &section->size))
12045 sec->sh_size = section->size;
12046 }
4a114e3e 12047
1b315056
CS		 12048 if (section->start == NULL)
12049 return 0;
12050
19e6b90e 12051 if (debug_displays [debug].relocate)
3f5e193b 12052 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 12053
1b315056 12054 return 1;
1007acb3
L		 12055}
12056
657d0d47
CC		 12057/* If this is not NULL, load_debug_section will only look for sections
12058 within the list of sections given here. */
12059unsigned int *section_subset = NULL;
12060
d966045b 12061int
2cf0635d 12062load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12063{
2cf0635d
NC		 12064 struct dwarf_section * section = &debug_displays [debug].section;
12065 Elf_Internal_Shdr * sec;
d966045b
DJ		 12066
12067 /* Locate the debug section. */
657d0d47 12068 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12069 if (sec != NULL)
12070 section->name = section->uncompressed_name;
12071 else
12072 {
657d0d47 12073 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12074 if (sec != NULL)
12075 section->name = section->compressed_name;
12076 }
12077 if (sec == NULL)
12078 return 0;
12079
657d0d47
CC		 12080 /* If we're loading from a subset of sections, and we've loaded
12081 a section matching this name before, it's likely that it's a
12082 different one. */
12083 if (section_subset != NULL)
12084 free_debug_section (debug);
12085
3f5e193b 12086 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12087}
12088
19e6b90e
L		 12089void
12090free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12091{
2cf0635d 12092 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12093
19e6b90e
L		 12094 if (section->start == NULL)
12095 return;
1007acb3 12096
19e6b90e
L		 12097 free ((char *) section->start);
12098 section->start = NULL;
12099 section->address = 0;
12100 section->size = 0;
1007acb3
L		 12101}
12102
1007acb3 12103static int
657d0d47 12104display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12105{
2cf0635d 12106 char * name = SECTION_NAME (section);
74e1a04b 12107 const char * print_name = printable_section_name (section);
19e6b90e
L		 12108 bfd_size_type length;
12109 int result = 1;
3f5e193b 12110 int i;
1007acb3 12111
19e6b90e
L		 12112 length = section->sh_size;
12113 if (length == 0)
1007acb3 12114 {
74e1a04b 12115 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12116 return 0;
1007acb3 12117 }
5dff79d8
NC		 12118 if (section->sh_type == SHT_NOBITS)
12119 {
12120 /* There is no point in dumping the contents of a debugging section
12121 which has the NOBITS type - the bits in the file will be random.
12122 This can happen when a file containing a .eh_frame section is
12123 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12124 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12125 print_name);
5dff79d8
NC		 12126 return 0;
12127 }
1007acb3 12128
0112cd26 12129 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12130 name = ".debug_info";
1007acb3 12131
19e6b90e
L		 12132 /* See if we know how to display the contents of this section. */
12133 for (i = 0; i < max; i++)
1b315056 12134 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12135 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12136 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12137 {
2cf0635d 12138 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12139 int secondary = (section != find_section (name));
12140
12141 if (secondary)
3f5e193b 12142 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12143
b40bf0a2
NC		 12144 if (i == line && const_strneq (name, ".debug_line."))
12145 sec->name = name;
12146 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12147 sec->name = sec->uncompressed_name;
12148 else
12149 sec->name = sec->compressed_name;
3f5e193b
NC		 12150 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12151 section, file))
19e6b90e 12152 {
657d0d47
CC		 12153 /* If this debug section is part of a CU/TU set in a .dwp file,
12154 restrict load_debug_section to the sections in that set. */
12155 section_subset = find_cu_tu_set (file, shndx);
12156
19e6b90e 12157 result &= debug_displays[i].display (sec, file);
1007acb3 12158
657d0d47
CC		 12159 section_subset = NULL;
12160
d966045b 12161 if (secondary || (i != info && i != abbrev))
3f5e193b 12162 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12163 }
1007acb3 12164
19e6b90e
L		 12165 break;
12166 }
1007acb3 12167
19e6b90e 12168 if (i == max)
1007acb3 12169 {
74e1a04b 12170 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12171 result = 0;
1007acb3
L		 12172 }
12173
19e6b90e 12174 return result;
5b18a4bc 12175}
103f02d3 12176
aef1f6d0
DJ		 12177/* Set DUMP_SECTS for all sections where dumps were requested
12178 based on section name. */
12179
12180static void
12181initialise_dumps_byname (void)
12182{
2cf0635d 12183 struct dump_list_entry * cur;
aef1f6d0
DJ		 12184
12185 for (cur = dump_sects_byname; cur; cur = cur->next)
12186 {
12187 unsigned int i;
12188 int any;
12189
12190 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12191 if (streq (SECTION_NAME (section_headers + i), cur->name))
12192 {
09c11c86 12193 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12194 any = 1;
12195 }
12196
12197 if (!any)
12198 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12199 cur->name);
12200 }
12201}
12202
5b18a4bc 12203static void
2cf0635d 12204process_section_contents (FILE * file)
5b18a4bc 12205{
2cf0635d 12206 Elf_Internal_Shdr * section;
19e6b90e 12207 unsigned int i;
103f02d3 12208
19e6b90e
L		 12209 if (! do_dump)
12210 return;
103f02d3 12211
aef1f6d0
DJ		 12212 initialise_dumps_byname ();
12213
19e6b90e
L		 12214 for (i = 0, section = section_headers;
12215 i < elf_header.e_shnum && i < num_dump_sects;
12216 i++, section++)
12217 {
12218#ifdef SUPPORT_DISASSEMBLY
12219 if (dump_sects[i] & DISASS_DUMP)
12220 disassemble_section (section, file);
12221#endif
12222 if (dump_sects[i] & HEX_DUMP)
cf13d699 12223 dump_section_as_bytes (section, file, FALSE);
103f02d3 12224
cf13d699
NC		 12225 if (dump_sects[i] & RELOC_DUMP)
12226 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12227
12228 if (dump_sects[i] & STRING_DUMP)
12229 dump_section_as_strings (section, file);
cf13d699
NC		 12230
12231 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12232 display_debug_section (i, section, file);
5b18a4bc 12233 }
103f02d3 12234
19e6b90e
L		 12235 /* Check to see if the user requested a
12236 dump of a section that does not exist. */
12237 while (i++ < num_dump_sects)
12238 if (dump_sects[i])
12239 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12240}
103f02d3 12241
5b18a4bc 12242static void
19e6b90e 12243process_mips_fpe_exception (int mask)
5b18a4bc 12244{
19e6b90e
L		 12245 if (mask)
12246 {
12247 int first = 1;
12248 if (mask & OEX_FPU_INEX)
12249 fputs ("INEX", stdout), first = 0;
12250 if (mask & OEX_FPU_UFLO)
12251 printf ("%sUFLO", first ? "" : "|"), first = 0;
12252 if (mask & OEX_FPU_OFLO)
12253 printf ("%sOFLO", first ? "" : "|"), first = 0;
12254 if (mask & OEX_FPU_DIV0)
12255 printf ("%sDIV0", first ? "" : "|"), first = 0;
12256 if (mask & OEX_FPU_INVAL)
12257 printf ("%sINVAL", first ? "" : "|");
12258 }
5b18a4bc 12259 else
19e6b90e 12260 fputs ("0", stdout);
5b18a4bc 12261}
103f02d3 12262
f6f0e17b
NC		 12263/* Display's the value of TAG at location P. If TAG is
12264 greater than 0 it is assumed to be an unknown tag, and
12265 a message is printed to this effect. Otherwise it is
12266 assumed that a message has already been printed.
12267
12268 If the bottom bit of TAG is set it assumed to have a
12269 string value, otherwise it is assumed to have an integer
12270 value.
12271
12272 Returns an updated P pointing to the first unread byte
12273 beyond the end of TAG's value.
12274
12275 Reads at or beyond END will not be made. */
12276
12277static unsigned char *
12278display_tag_value (int tag,
12279 unsigned char * p,
12280 const unsigned char * const end)
12281{
12282 unsigned long val;
12283
12284 if (tag > 0)
12285 printf (" Tag_unknown_%d: ", tag);
12286
12287 if (p >= end)
12288 {
4082ef84 12289 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12290 }
12291 else if (tag & 1)
12292 {
071436c6
NC		 12293 /* PR 17531 file: 027-19978-0.004. */
12294 size_t maxlen = (end - p) - 1;
12295
12296 putchar ('"');
4082ef84
NC		 12297 if (maxlen > 0)
12298 {
12299 print_symbol ((int) maxlen, (const char *) p);
12300 p += strnlen ((char *) p, maxlen) + 1;
12301 }
12302 else
12303 {
12304 printf (_("<corrupt string tag>"));
12305 p = (unsigned char *) end;
12306 }
071436c6 12307 printf ("\"\n");
f6f0e17b
NC		 12308 }
12309 else
12310 {
12311 unsigned int len;
12312
12313 val = read_uleb128 (p, &len, end);
12314 p += len;
12315 printf ("%ld (0x%lx)\n", val, val);
12316 }
12317
4082ef84 12318 assert (p <= end);
f6f0e17b
NC		 12319 return p;
12320}
12321
11c1ff18
PB		 12322/* ARM EABI attributes section. */
12323typedef struct
12324{
70e99720 12325 unsigned int tag;
2cf0635d 12326 const char * name;
11c1ff18 12327 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12328 unsigned int type;
2cf0635d 12329 const char ** table;
11c1ff18
PB		 12330} arm_attr_public_tag;
12331
2cf0635d 12332static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12333 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12334 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12335static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12336static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12337 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12338static const char * arm_attr_tag_FP_arch[] =
bca38921 12339 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12340 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12341static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12342static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12343 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12344static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12345 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12346 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12347static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12348 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12349static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12350 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12351static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12352 {"Absolute", "PC-relative", "None"};
2cf0635d 12353static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12354 {"None", "direct", "GOT-indirect"};
2cf0635d 12355static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12356 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12357static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12358static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12359 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12360static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12361static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12362static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12363 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12364static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12365 {"Unused", "small", "int", "forced to int"};
2cf0635d 12366static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12367 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12368static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12369 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12370static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12371 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12372static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12373 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12374 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12375static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12376 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12377 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12378static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12379static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12380 {"Not Allowed", "Allowed"};
2cf0635d 12381static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12382 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12383static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12384 {"Not Allowed", "Allowed"};
12385static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12386 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12387 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12388static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12389static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12390 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12391 "TrustZone and Virtualization Extensions"};
dd24e3da 12392static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12393 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12394
12395#define LOOKUP(id, name) \
12396 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12397static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12398{
12399 {4, "CPU_raw_name", 1, NULL},
12400 {5, "CPU_name", 1, NULL},
12401 LOOKUP(6, CPU_arch),
12402 {7, "CPU_arch_profile", 0, NULL},
12403 LOOKUP(8, ARM_ISA_use),
12404 LOOKUP(9, THUMB_ISA_use),
75375b3e 12405 LOOKUP(10, FP_arch),
11c1ff18 12406 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12407 LOOKUP(12, Advanced_SIMD_arch),
12408 LOOKUP(13, PCS_config),
11c1ff18
PB		 12409 LOOKUP(14, ABI_PCS_R9_use),
12410 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12411 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12412 LOOKUP(17, ABI_PCS_GOT_use),
12413 LOOKUP(18, ABI_PCS_wchar_t),
12414 LOOKUP(19, ABI_FP_rounding),
12415 LOOKUP(20, ABI_FP_denormal),
12416 LOOKUP(21, ABI_FP_exceptions),
12417 LOOKUP(22, ABI_FP_user_exceptions),
12418 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12419 {24, "ABI_align_needed", 0, NULL},
12420 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12421 LOOKUP(26, ABI_enum_size),
12422 LOOKUP(27, ABI_HardFP_use),
12423 LOOKUP(28, ABI_VFP_args),
12424 LOOKUP(29, ABI_WMMX_args),
12425 LOOKUP(30, ABI_optimization_goals),
12426 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12427 {32, "compatibility", 0, NULL},
f5f53991 12428 LOOKUP(34, CPU_unaligned_access),
75375b3e 12429 LOOKUP(36, FP_HP_extension),
8e79c3df 12430 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12431 LOOKUP(42, MPextension_use),
12432 LOOKUP(44, DIV_use),
f5f53991
AS		 12433 {64, "nodefaults", 0, NULL},
12434 {65, "also_compatible_with", 0, NULL},
12435 LOOKUP(66, T2EE_use),
12436 {67, "conformance", 1, NULL},
12437 LOOKUP(68, Virtualization_use),
cd21e546 12438 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12439};
12440#undef LOOKUP
12441
11c1ff18 12442static unsigned char *
f6f0e17b
NC		 12443display_arm_attribute (unsigned char * p,
12444 const unsigned char * const end)
11c1ff18 12445{
70e99720 12446 unsigned int tag;
11c1ff18 12447 unsigned int len;
70e99720 12448 unsigned int val;
2cf0635d 12449 arm_attr_public_tag * attr;
11c1ff18 12450 unsigned i;
70e99720 12451 unsigned int type;
11c1ff18 12452
f6f0e17b 12453 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12454 p += len;
12455 attr = NULL;
2cf0635d 12456 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12457 {
12458 if (arm_attr_public_tags[i].tag == tag)
12459 {
12460 attr = &arm_attr_public_tags[i];
12461 break;
12462 }
12463 }
12464
12465 if (attr)
12466 {
12467 printf (" Tag_%s: ", attr->name);
12468 switch (attr->type)
12469 {
12470 case 0:
12471 switch (tag)
12472 {
12473 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12474 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12475 p += len;
12476 switch (val)
12477 {
2b692964
NC		 12478 case 0: printf (_("None\n")); break;
12479 case 'A': printf (_("Application\n")); break;
12480 case 'R': printf (_("Realtime\n")); break;
12481 case 'M': printf (_("Microcontroller\n")); break;
12482 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12483 default: printf ("??? (%d)\n", val); break;
12484 }
12485 break;
12486
75375b3e 12487 case 24: /* Tag_align_needed. */
f6f0e17b 12488 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12489 p += len;
12490 switch (val)
12491 {
2b692964
NC		 12492 case 0: printf (_("None\n")); break;
12493 case 1: printf (_("8-byte\n")); break;
12494 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12495 case 3: printf ("??? 3\n"); break;
12496 default:
12497 if (val <= 12)
dd24e3da 12498 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12499 1 << val);
12500 else
12501 printf ("??? (%d)\n", val);
12502 break;
12503 }
12504 break;
12505
12506 case 25: /* Tag_align_preserved. */
f6f0e17b 12507 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12508 p += len;
12509 switch (val)
12510 {
2b692964
NC		 12511 case 0: printf (_("None\n")); break;
12512 case 1: printf (_("8-byte, except leaf SP\n")); break;
12513 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12514 case 3: printf ("??? 3\n"); break;
12515 default:
12516 if (val <= 12)
dd24e3da 12517 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12518 1 << val);
12519 else
12520 printf ("??? (%d)\n", val);
12521 break;
12522 }
12523 break;
12524
11c1ff18 12525 case 32: /* Tag_compatibility. */
071436c6 12526 {
071436c6
NC		 12527 val = read_uleb128 (p, &len, end);
12528 p += len;
071436c6 12529 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12530 if (p < end - 1)
12531 {
12532 size_t maxlen = (end - p) - 1;
12533
12534 print_symbol ((int) maxlen, (const char *) p);
12535 p += strnlen ((char *) p, maxlen) + 1;
12536 }
12537 else
12538 {
12539 printf (_("<corrupt>"));
12540 p = (unsigned char *) end;
12541 }
071436c6 12542 putchar ('\n');
071436c6 12543 }
11c1ff18
PB		 12544 break;
12545
f5f53991 12546 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12547 /* PR 17531: file: 001-505008-0.01. */
12548 if (p < end)
12549 p++;
2b692964 12550 printf (_("True\n"));
f5f53991
AS		 12551 break;
12552
12553 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12554 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12555 p += len;
12556 if (val == 6 /* Tag_CPU_arch. */)
12557 {
f6f0e17b 12558 val = read_uleb128 (p, &len, end);
f5f53991 12559 p += len;
071436c6 12560 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12561 printf ("??? (%d)\n", val);
12562 else
12563 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12564 }
12565 else
12566 printf ("???\n");
071436c6
NC		 12567 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12568 ;
f5f53991
AS		 12569 break;
12570
11c1ff18 12571 default:
bee0ee85
NC		 12572 printf (_("<unknown: %d>\n"), tag);
12573 break;
11c1ff18
PB		 12574 }
12575 return p;
12576
12577 case 1:
f6f0e17b 12578 return display_tag_value (-1, p, end);
11c1ff18 12579 case 2:
f6f0e17b 12580 return display_tag_value (0, p, end);
11c1ff18
PB		 12581
12582 default:
12583 assert (attr->type & 0x80);
f6f0e17b 12584 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12585 p += len;
12586 type = attr->type & 0x7f;
12587 if (val >= type)
12588 printf ("??? (%d)\n", val);
12589 else
12590 printf ("%s\n", attr->table[val]);
12591 return p;
12592 }
12593 }
11c1ff18 12594
f6f0e17b 12595 return display_tag_value (tag, p, end);
11c1ff18
PB		 12596}
12597
104d59d1 12598static unsigned char *
60bca95a 12599display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12600 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12601 const unsigned char * const end)
104d59d1
JM		 12602{
12603 int tag;
12604 unsigned int len;
12605 int val;
104d59d1 12606
f6f0e17b 12607 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12608 p += len;
12609
12610 /* Tag_compatibility is the only generic GNU attribute defined at
12611 present. */
12612 if (tag == 32)
12613 {
f6f0e17b 12614 val = read_uleb128 (p, &len, end);
104d59d1 12615 p += len;
071436c6
NC		 12616
12617 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12618 if (p == end)
12619 {
071436c6 12620 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12621 warn (_("corrupt vendor attribute\n"));
12622 }
12623 else
12624 {
4082ef84
NC		 12625 if (p < end - 1)
12626 {
12627 size_t maxlen = (end - p) - 1;
071436c6 12628
4082ef84
NC		 12629 print_symbol ((int) maxlen, (const char *) p);
12630 p += strnlen ((char *) p, maxlen) + 1;
12631 }
12632 else
12633 {
12634 printf (_("<corrupt>"));
12635 p = (unsigned char *) end;
12636 }
071436c6 12637 putchar ('\n');
f6f0e17b 12638 }
104d59d1
JM		 12639 return p;
12640 }
12641
12642 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12643 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12644
f6f0e17b 12645 return display_tag_value (tag, p, end);
104d59d1
JM		 12646}
12647
34c8bcba 12648static unsigned char *
f6f0e17b
NC		 12649display_power_gnu_attribute (unsigned char * p,
12650 int tag,
12651 const unsigned char * const end)
34c8bcba 12652{
34c8bcba
JM		 12653 unsigned int len;
12654 int val;
12655
12656 if (tag == Tag_GNU_Power_ABI_FP)
12657 {
f6f0e17b 12658 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12659 p += len;
12660 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12661
34c8bcba
JM		 12662 switch (val)
12663 {
12664 case 0:
2b692964 12665 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12666 break;
12667 case 1:
2b692964 12668 printf (_("Hard float\n"));
34c8bcba
JM		 12669 break;
12670 case 2:
2b692964 12671 printf (_("Soft float\n"));
34c8bcba 12672 break;
3c7b9897 12673 case 3:
2b692964 12674 printf (_("Single-precision hard float\n"));
3c7b9897 12675 break;
34c8bcba
JM		 12676 default:
12677 printf ("??? (%d)\n", val);
12678 break;
12679 }
12680 return p;
12681 }
12682
c6e65352
DJ		 12683 if (tag == Tag_GNU_Power_ABI_Vector)
12684 {
f6f0e17b 12685 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12686 p += len;
12687 printf (" Tag_GNU_Power_ABI_Vector: ");
12688 switch (val)
12689 {
12690 case 0:
2b692964 12691 printf (_("Any\n"));
c6e65352
DJ		 12692 break;
12693 case 1:
2b692964 12694 printf (_("Generic\n"));
c6e65352
DJ		 12695 break;
12696 case 2:
12697 printf ("AltiVec\n");
12698 break;
12699 case 3:
12700 printf ("SPE\n");
12701 break;
12702 default:
12703 printf ("??? (%d)\n", val);
12704 break;
12705 }
12706 return p;
12707 }
12708
f82e0623
NF		 12709 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12710 {
f6f0e17b
NC		 12711 if (p == end)
12712 {
071436c6 12713 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12714 return p;
12715 }
0b4362b0 12716
f6f0e17b 12717 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12718 p += len;
12719 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12720 switch (val)
12721 {
12722 case 0:
2b692964 12723 printf (_("Any\n"));
f82e0623
NF		 12724 break;
12725 case 1:
12726 printf ("r3/r4\n");
12727 break;
12728 case 2:
2b692964 12729 printf (_("Memory\n"));
f82e0623
NF		 12730 break;
12731 default:
12732 printf ("??? (%d)\n", val);
12733 break;
12734 }
12735 return p;
12736 }
12737
f6f0e17b 12738 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12739}
12740
9e8c70f9
DM		 12741static void
12742display_sparc_hwcaps (int mask)
12743{
12744 if (mask)
12745 {
12746 int first = 1;
071436c6 12747
9e8c70f9
DM		 12748 if (mask & ELF_SPARC_HWCAP_MUL32)
12749 fputs ("mul32", stdout), first = 0;
12750 if (mask & ELF_SPARC_HWCAP_DIV32)
12751 printf ("%sdiv32", first ? "" : "|"), first = 0;
12752 if (mask & ELF_SPARC_HWCAP_FSMULD)
12753 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12754 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12755 printf ("%sv8plus", first ? "" : "|"), first = 0;
12756 if (mask & ELF_SPARC_HWCAP_POPC)
12757 printf ("%spopc", first ? "" : "|"), first = 0;
12758 if (mask & ELF_SPARC_HWCAP_VIS)
12759 printf ("%svis", first ? "" : "|"), first = 0;
12760 if (mask & ELF_SPARC_HWCAP_VIS2)
12761 printf ("%svis2", first ? "" : "|"), first = 0;
12762 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12763 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12764 if (mask & ELF_SPARC_HWCAP_FMAF)
12765 printf ("%sfmaf", first ? "" : "|"), first = 0;
12766 if (mask & ELF_SPARC_HWCAP_VIS3)
12767 printf ("%svis3", first ? "" : "|"), first = 0;
12768 if (mask & ELF_SPARC_HWCAP_HPC)
12769 printf ("%shpc", first ? "" : "|"), first = 0;
12770 if (mask & ELF_SPARC_HWCAP_RANDOM)
12771 printf ("%srandom", first ? "" : "|"), first = 0;
12772 if (mask & ELF_SPARC_HWCAP_TRANS)
12773 printf ("%strans", first ? "" : "|"), first = 0;
12774 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12775 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12776 if (mask & ELF_SPARC_HWCAP_IMA)
12777 printf ("%sima", first ? "" : "|"), first = 0;
12778 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12779 printf ("%scspare", first ? "" : "|"), first = 0;
12780 }
12781 else
071436c6
NC		 12782 fputc ('0', stdout);
12783 fputc ('\n', stdout);
9e8c70f9
DM		 12784}
12785
3d68f91c
JM		 12786static void
12787display_sparc_hwcaps2 (int mask)
12788{
12789 if (mask)
12790 {
12791 int first = 1;
071436c6 12792
3d68f91c
JM		 12793 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12794 fputs ("fjathplus", stdout), first = 0;
12795 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12796 printf ("%svis3b", first ? "" : "|"), first = 0;
12797 if (mask & ELF_SPARC_HWCAP2_ADP)
12798 printf ("%sadp", first ? "" : "|"), first = 0;
12799 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12800 printf ("%ssparc5", first ? "" : "|"), first = 0;
12801 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12802 printf ("%smwait", first ? "" : "|"), first = 0;
12803 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12804 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12805 if (mask & ELF_SPARC_HWCAP2_XMONT)
12806 printf ("%sxmont2", first ? "" : "|"), first = 0;
12807 if (mask & ELF_SPARC_HWCAP2_NSEC)
12808 printf ("%snsec", first ? "" : "|"), first = 0;
12809 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12810 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12811 if (mask & ELF_SPARC_HWCAP2_FJDES)
12812 printf ("%sfjdes", first ? "" : "|"), first = 0;
12813 if (mask & ELF_SPARC_HWCAP2_FJAES)
12814 printf ("%sfjaes", first ? "" : "|"), first = 0;
12815 }
12816 else
071436c6
NC		 12817 fputc ('0', stdout);
12818 fputc ('\n', stdout);
3d68f91c
JM		 12819}
12820
9e8c70f9 12821static unsigned char *
f6f0e17b
NC		 12822display_sparc_gnu_attribute (unsigned char * p,
12823 int tag,
12824 const unsigned char * const end)
9e8c70f9 12825{
3d68f91c
JM		 12826 unsigned int len;
12827 int val;
12828
9e8c70f9
DM		 12829 if (tag == Tag_GNU_Sparc_HWCAPS)
12830 {
f6f0e17b 12831 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12832 p += len;
12833 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12834 display_sparc_hwcaps (val);
12835 return p;
3d68f91c
JM		 12836 }
12837 if (tag == Tag_GNU_Sparc_HWCAPS2)
12838 {
12839 val = read_uleb128 (p, &len, end);
12840 p += len;
12841 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12842 display_sparc_hwcaps2 (val);
12843 return p;
12844 }
9e8c70f9 12845
f6f0e17b 12846 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12847}
12848
351cdf24
MF		 12849static void
12850print_mips_fp_abi_value (int val)
12851{
12852 switch (val)
12853 {
12854 case Val_GNU_MIPS_ABI_FP_ANY:
12855 printf (_("Hard or soft float\n"));
12856 break;
12857 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12858 printf (_("Hard float (double precision)\n"));
12859 break;
12860 case Val_GNU_MIPS_ABI_FP_SINGLE:
12861 printf (_("Hard float (single precision)\n"));
12862 break;
12863 case Val_GNU_MIPS_ABI_FP_SOFT:
12864 printf (_("Soft float\n"));
12865 break;
12866 case Val_GNU_MIPS_ABI_FP_OLD_64:
12867 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12868 break;
12869 case Val_GNU_MIPS_ABI_FP_XX:
12870 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12871 break;
12872 case Val_GNU_MIPS_ABI_FP_64:
12873 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12874 break;
12875 case Val_GNU_MIPS_ABI_FP_64A:
12876 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12877 break;
12878 default:
12879 printf ("??? (%d)\n", val);
12880 break;
12881 }
12882}
12883
2cf19d5c 12884static unsigned char *
f6f0e17b
NC		 12885display_mips_gnu_attribute (unsigned char * p,
12886 int tag,
12887 const unsigned char * const end)
2cf19d5c 12888{
2cf19d5c
JM		 12889 if (tag == Tag_GNU_MIPS_ABI_FP)
12890 {
f6f0e17b
NC		 12891 unsigned int len;
12892 int val;
12893
12894 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12895 p += len;
12896 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12897
351cdf24
MF		 12898 print_mips_fp_abi_value (val);
12899
2cf19d5c
JM		 12900 return p;
12901 }
12902
a9f58168
CF		 12903 if (tag == Tag_GNU_MIPS_ABI_MSA)
12904 {
12905 unsigned int len;
12906 int val;
12907
12908 val = read_uleb128 (p, &len, end);
12909 p += len;
12910 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12911
12912 switch (val)
12913 {
12914 case Val_GNU_MIPS_ABI_MSA_ANY:
12915 printf (_("Any MSA or not\n"));
12916 break;
12917 case Val_GNU_MIPS_ABI_MSA_128:
12918 printf (_("128-bit MSA\n"));
12919 break;
12920 default:
12921 printf ("??? (%d)\n", val);
12922 break;
12923 }
12924 return p;
12925 }
12926
f6f0e17b 12927 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12928}
12929
59e6276b 12930static unsigned char *
f6f0e17b
NC		 12931display_tic6x_attribute (unsigned char * p,
12932 const unsigned char * const end)
59e6276b
JM		 12933{
12934 int tag;
12935 unsigned int len;
12936 int val;
12937
f6f0e17b 12938 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12939 p += len;
12940
12941 switch (tag)
12942 {
75fa6dc1 12943 case Tag_ISA:
f6f0e17b 12944 val = read_uleb128 (p, &len, end);
59e6276b 12945 p += len;
75fa6dc1 12946 printf (" Tag_ISA: ");
59e6276b
JM		 12947
12948 switch (val)
12949 {
75fa6dc1 12950 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12951 printf (_("None\n"));
12952 break;
75fa6dc1 12953 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12954 printf ("C62x\n");
12955 break;
75fa6dc1 12956 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12957 printf ("C67x\n");
12958 break;
75fa6dc1 12959 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12960 printf ("C67x+\n");
12961 break;
75fa6dc1 12962 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12963 printf ("C64x\n");
12964 break;
75fa6dc1 12965 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12966 printf ("C64x+\n");
12967 break;
75fa6dc1 12968 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12969 printf ("C674x\n");
12970 break;
12971 default:
12972 printf ("??? (%d)\n", val);
12973 break;
12974 }
12975 return p;
12976
87779176 12977 case Tag_ABI_wchar_t:
f6f0e17b 12978 val = read_uleb128 (p, &len, end);
87779176
JM		 12979 p += len;
12980 printf (" Tag_ABI_wchar_t: ");
12981 switch (val)
12982 {
12983 case 0:
12984 printf (_("Not used\n"));
12985 break;
12986 case 1:
12987 printf (_("2 bytes\n"));
12988 break;
12989 case 2:
12990 printf (_("4 bytes\n"));
12991 break;
12992 default:
12993 printf ("??? (%d)\n", val);
12994 break;
12995 }
12996 return p;
12997
12998 case Tag_ABI_stack_align_needed:
f6f0e17b 12999 val = read_uleb128 (p, &len, end);
87779176
JM		 13000 p += len;
13001 printf (" Tag_ABI_stack_align_needed: ");
13002 switch (val)
13003 {
13004 case 0:
13005 printf (_("8-byte\n"));
13006 break;
13007 case 1:
13008 printf (_("16-byte\n"));
13009 break;
13010 default:
13011 printf ("??? (%d)\n", val);
13012 break;
13013 }
13014 return p;
13015
13016 case Tag_ABI_stack_align_preserved:
f6f0e17b 13017 val = read_uleb128 (p, &len, end);
87779176
JM		 13018 p += len;
13019 printf (" Tag_ABI_stack_align_preserved: ");
13020 switch (val)
13021 {
13022 case 0:
13023 printf (_("8-byte\n"));
13024 break;
13025 case 1:
13026 printf (_("16-byte\n"));
13027 break;
13028 default:
13029 printf ("??? (%d)\n", val);
13030 break;
13031 }
13032 return p;
13033
b5593623 13034 case Tag_ABI_DSBT:
f6f0e17b 13035 val = read_uleb128 (p, &len, end);
b5593623
JM		 13036 p += len;
13037 printf (" Tag_ABI_DSBT: ");
13038 switch (val)
13039 {
13040 case 0:
13041 printf (_("DSBT addressing not used\n"));
13042 break;
13043 case 1:
13044 printf (_("DSBT addressing used\n"));
13045 break;
13046 default:
13047 printf ("??? (%d)\n", val);
13048 break;
13049 }
13050 return p;
13051
87779176 13052 case Tag_ABI_PID:
f6f0e17b 13053 val = read_uleb128 (p, &len, end);
87779176
JM		 13054 p += len;
13055 printf (" Tag_ABI_PID: ");
13056 switch (val)
13057 {
13058 case 0:
13059 printf (_("Data addressing position-dependent\n"));
13060 break;
13061 case 1:
13062 printf (_("Data addressing position-independent, GOT near DP\n"));
13063 break;
13064 case 2:
13065 printf (_("Data addressing position-independent, GOT far from DP\n"));
13066 break;
13067 default:
13068 printf ("??? (%d)\n", val);
13069 break;
13070 }
13071 return p;
13072
13073 case Tag_ABI_PIC:
f6f0e17b 13074 val = read_uleb128 (p, &len, end);
87779176
JM		 13075 p += len;
13076 printf (" Tag_ABI_PIC: ");
13077 switch (val)
13078 {
13079 case 0:
13080 printf (_("Code addressing position-dependent\n"));
13081 break;
13082 case 1:
13083 printf (_("Code addressing position-independent\n"));
13084 break;
13085 default:
13086 printf ("??? (%d)\n", val);
13087 break;
13088 }
13089 return p;
13090
13091 case Tag_ABI_array_object_alignment:
f6f0e17b 13092 val = read_uleb128 (p, &len, end);
87779176
JM		 13093 p += len;
13094 printf (" Tag_ABI_array_object_alignment: ");
13095 switch (val)
13096 {
13097 case 0:
13098 printf (_("8-byte\n"));
13099 break;
13100 case 1:
13101 printf (_("4-byte\n"));
13102 break;
13103 case 2:
13104 printf (_("16-byte\n"));
13105 break;
13106 default:
13107 printf ("??? (%d)\n", val);
13108 break;
13109 }
13110 return p;
13111
13112 case Tag_ABI_array_object_align_expected:
f6f0e17b 13113 val = read_uleb128 (p, &len, end);
87779176
JM		 13114 p += len;
13115 printf (" Tag_ABI_array_object_align_expected: ");
13116 switch (val)
13117 {
13118 case 0:
13119 printf (_("8-byte\n"));
13120 break;
13121 case 1:
13122 printf (_("4-byte\n"));
13123 break;
13124 case 2:
13125 printf (_("16-byte\n"));
13126 break;
13127 default:
13128 printf ("??? (%d)\n", val);
13129 break;
13130 }
13131 return p;
13132
3cbd1c06 13133 case Tag_ABI_compatibility:
071436c6 13134 {
071436c6
NC		 13135 val = read_uleb128 (p, &len, end);
13136 p += len;
13137 printf (" Tag_ABI_compatibility: ");
071436c6 13138 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13139 if (p < end - 1)
13140 {
13141 size_t maxlen = (end - p) - 1;
13142
13143 print_symbol ((int) maxlen, (const char *) p);
13144 p += strnlen ((char *) p, maxlen) + 1;
13145 }
13146 else
13147 {
13148 printf (_("<corrupt>"));
13149 p = (unsigned char *) end;
13150 }
071436c6 13151 putchar ('\n');
071436c6
NC		 13152 return p;
13153 }
87779176
JM		 13154
13155 case Tag_ABI_conformance:
071436c6 13156 {
4082ef84
NC		 13157 printf (" Tag_ABI_conformance: \"");
13158 if (p < end - 1)
13159 {
13160 size_t maxlen = (end - p) - 1;
071436c6 13161
4082ef84
NC		 13162 print_symbol ((int) maxlen, (const char *) p);
13163 p += strnlen ((char *) p, maxlen) + 1;
13164 }
13165 else
13166 {
13167 printf (_("<corrupt>"));
13168 p = (unsigned char *) end;
13169 }
071436c6 13170 printf ("\"\n");
071436c6
NC		 13171 return p;
13172 }
59e6276b
JM		 13173 }
13174
f6f0e17b
NC		 13175 return display_tag_value (tag, p, end);
13176}
59e6276b 13177
f6f0e17b
NC		 13178static void
13179display_raw_attribute (unsigned char * p, unsigned char * end)
13180{
13181 unsigned long addr = 0;
13182 size_t bytes = end - p;
13183
e0a31db1 13184 assert (end > p);
f6f0e17b 13185 while (bytes)
87779176 13186 {
f6f0e17b
NC		 13187 int j;
13188 int k;
13189 int lbytes = (bytes > 16 ? 16 : bytes);
13190
13191 printf (" 0x%8.8lx ", addr);
13192
13193 for (j = 0; j < 16; j++)
13194 {
13195 if (j < lbytes)
13196 printf ("%2.2x", p[j]);
13197 else
13198 printf (" ");
13199
13200 if ((j & 3) == 3)
13201 printf (" ");
13202 }
13203
13204 for (j = 0; j < lbytes; j++)
13205 {
13206 k = p[j];
13207 if (k >= ' ' && k < 0x7f)
13208 printf ("%c", k);
13209 else
13210 printf (".");
13211 }
13212
13213 putchar ('\n');
13214
13215 p += lbytes;
13216 bytes -= lbytes;
13217 addr += lbytes;
87779176 13218 }
59e6276b 13219
f6f0e17b 13220 putchar ('\n');
59e6276b
JM		 13221}
13222
13761a11
NC		 13223static unsigned char *
13224display_msp430x_attribute (unsigned char * p,
13225 const unsigned char * const end)
13226{
13227 unsigned int len;
13228 int val;
13229 int tag;
13230
13231 tag = read_uleb128 (p, & len, end);
13232 p += len;
0b4362b0 13233
13761a11
NC		 13234 switch (tag)
13235 {
13236 case OFBA_MSPABI_Tag_ISA:
13237 val = read_uleb128 (p, &len, end);
13238 p += len;
13239 printf (" Tag_ISA: ");
13240 switch (val)
13241 {
13242 case 0: printf (_("None\n")); break;
13243 case 1: printf (_("MSP430\n")); break;
13244 case 2: printf (_("MSP430X\n")); break;
13245 default: printf ("??? (%d)\n", val); break;
13246 }
13247 break;
13248
13249 case OFBA_MSPABI_Tag_Code_Model:
13250 val = read_uleb128 (p, &len, end);
13251 p += len;
13252 printf (" Tag_Code_Model: ");
13253 switch (val)
13254 {
13255 case 0: printf (_("None\n")); break;
13256 case 1: printf (_("Small\n")); break;
13257 case 2: printf (_("Large\n")); break;
13258 default: printf ("??? (%d)\n", val); break;
13259 }
13260 break;
13261
13262 case OFBA_MSPABI_Tag_Data_Model:
13263 val = read_uleb128 (p, &len, end);
13264 p += len;
13265 printf (" Tag_Data_Model: ");
13266 switch (val)
13267 {
13268 case 0: printf (_("None\n")); break;
13269 case 1: printf (_("Small\n")); break;
13270 case 2: printf (_("Large\n")); break;
13271 case 3: printf (_("Restricted Large\n")); break;
13272 default: printf ("??? (%d)\n", val); break;
13273 }
13274 break;
13275
13276 default:
13277 printf (_(" <unknown tag %d>: "), tag);
13278
13279 if (tag & 1)
13280 {
071436c6 13281 putchar ('"');
4082ef84
NC		 13282 if (p < end - 1)
13283 {
13284 size_t maxlen = (end - p) - 1;
13285
13286 print_symbol ((int) maxlen, (const char *) p);
13287 p += strnlen ((char *) p, maxlen) + 1;
13288 }
13289 else
13290 {
13291 printf (_("<corrupt>"));
13292 p = (unsigned char *) end;
13293 }
071436c6 13294 printf ("\"\n");
13761a11
NC		 13295 }
13296 else
13297 {
13298 val = read_uleb128 (p, &len, end);
13299 p += len;
13300 printf ("%d (0x%x)\n", val, val);
13301 }
13302 break;
13303 }
13304
4082ef84 13305 assert (p <= end);
13761a11
NC		 13306 return p;
13307}
13308
11c1ff18 13309static int
60bca95a
NC		 13310process_attributes (FILE * file,
13311 const char * public_name,
104d59d1 13312 unsigned int proc_type,
f6f0e17b
NC		 13313 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13314 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13315{
2cf0635d 13316 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13317 unsigned i;
13318
13319 /* Find the section header so that we get the size. */
13320 for (i = 0, sect = section_headers;
13321 i < elf_header.e_shnum;
13322 i++, sect++)
13323 {
071436c6
NC		 13324 unsigned char * contents;
13325 unsigned char * p;
13326
104d59d1 13327 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13328 continue;
13329
3f5e193b
NC		 13330 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13331 sect->sh_size, _("attributes"));
60bca95a 13332 if (contents == NULL)
11c1ff18 13333 continue;
60bca95a 13334
11c1ff18
PB		 13335 p = contents;
13336 if (*p == 'A')
13337 {
071436c6
NC		 13338 bfd_vma section_len;
13339
13340 section_len = sect->sh_size - 1;
11c1ff18 13341 p++;
60bca95a 13342
071436c6 13343 while (section_len > 0)
11c1ff18 13344 {
071436c6 13345 bfd_vma attr_len;
e9847026 13346 unsigned int namelen;
11c1ff18 13347 bfd_boolean public_section;
104d59d1 13348 bfd_boolean gnu_section;
11c1ff18 13349
071436c6 13350 if (section_len <= 4)
e0a31db1
NC		 13351 {
13352 error (_("Tag section ends prematurely\n"));
13353 break;
13354 }
071436c6 13355 attr_len = byte_get (p, 4);
11c1ff18 13356 p += 4;
60bca95a 13357
071436c6 13358 if (attr_len > section_len)
11c1ff18 13359 {
071436c6
NC		 13360 error (_("Bad attribute length (%u > %u)\n"),
13361 (unsigned) attr_len, (unsigned) section_len);
13362 attr_len = section_len;
11c1ff18 13363 }
74e1a04b 13364 /* PR 17531: file: 001-101425-0.004 */
071436c6 13365 else if (attr_len < 5)
74e1a04b 13366 {
071436c6 13367 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13368 break;
13369 }
e9847026 13370
071436c6
NC		 13371 section_len -= attr_len;
13372 attr_len -= 4;
13373
13374 namelen = strnlen ((char *) p, attr_len) + 1;
13375 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13376 {
13377 error (_("Corrupt attribute section name\n"));
13378 break;
13379 }
13380
071436c6
NC		 13381 printf (_("Attribute Section: "));
13382 print_symbol (INT_MAX, (const char *) p);
13383 putchar ('\n');
60bca95a
NC		 13384
13385 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13386 public_section = TRUE;
13387 else
13388 public_section = FALSE;
60bca95a
NC		 13389
13390 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13391 gnu_section = TRUE;
13392 else
13393 gnu_section = FALSE;
60bca95a 13394
11c1ff18 13395 p += namelen;
071436c6 13396 attr_len -= namelen;
e0a31db1 13397
071436c6 13398 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13399 {
e0a31db1 13400 int tag;
11c1ff18
PB		 13401 int val;
13402 bfd_vma size;
071436c6 13403 unsigned char * end;
60bca95a 13404
e0a31db1 13405 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13406 if (attr_len < 6)
e0a31db1
NC		 13407 {
13408 error (_("Unused bytes at end of section\n"));
13409 section_len = 0;
13410 break;
13411 }
13412
13413 tag = *(p++);
11c1ff18 13414 size = byte_get (p, 4);
071436c6 13415 if (size > attr_len)
11c1ff18 13416 {
e9847026 13417 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13418 (unsigned) size, (unsigned) attr_len);
13419 size = attr_len;
11c1ff18 13420 }
e0a31db1
NC		 13421 /* PR binutils/17531: Safe handling of corrupt files. */
13422 if (size < 6)
13423 {
13424 error (_("Bad subsection length (%u < 6)\n"),
13425 (unsigned) size);
13426 section_len = 0;
13427 break;
13428 }
60bca95a 13429
071436c6 13430 attr_len -= size;
11c1ff18 13431 end = p + size - 1;
071436c6 13432 assert (end <= contents + sect->sh_size);
11c1ff18 13433 p += 4;
60bca95a 13434
11c1ff18
PB		 13435 switch (tag)
13436 {
13437 case 1:
2b692964 13438 printf (_("File Attributes\n"));
11c1ff18
PB		 13439 break;
13440 case 2:
2b692964 13441 printf (_("Section Attributes:"));
11c1ff18
PB		 13442 goto do_numlist;
13443 case 3:
2b692964 13444 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13445 do_numlist:
13446 for (;;)
13447 {
91d6fa6a 13448 unsigned int j;
60bca95a 13449
f6f0e17b 13450 val = read_uleb128 (p, &j, end);
91d6fa6a 13451 p += j;
11c1ff18
PB		 13452 if (val == 0)
13453 break;
13454 printf (" %d", val);
13455 }
13456 printf ("\n");
13457 break;
13458 default:
2b692964 13459 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13460 public_section = FALSE;
13461 break;
13462 }
60bca95a 13463
071436c6 13464 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13465 {
13466 while (p < end)
f6f0e17b 13467 p = display_pub_attribute (p, end);
071436c6 13468 assert (p <= end);
104d59d1 13469 }
071436c6 13470 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13471 {
13472 while (p < end)
13473 p = display_gnu_attribute (p,
f6f0e17b
NC		 13474 display_proc_gnu_attribute,
13475 end);
071436c6 13476 assert (p <= end);
11c1ff18 13477 }
071436c6 13478 else if (p < end)
11c1ff18 13479 {
071436c6 13480 printf (_(" Unknown attribute:\n"));
f6f0e17b 13481 display_raw_attribute (p, end);
11c1ff18
PB		 13482 p = end;
13483 }
071436c6
NC		 13484 else
13485 attr_len = 0;
11c1ff18
PB		 13486 }
13487 }
13488 }
13489 else
e9847026 13490 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13491
60bca95a 13492 free (contents);
11c1ff18
PB		 13493 }
13494 return 1;
13495}
13496
104d59d1 13497static int
2cf0635d 13498process_arm_specific (FILE * file)
104d59d1
JM		 13499{
13500 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13501 display_arm_attribute, NULL);
13502}
13503
34c8bcba 13504static int
2cf0635d 13505process_power_specific (FILE * file)
34c8bcba
JM		 13506{
13507 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13508 display_power_gnu_attribute);
13509}
13510
9e8c70f9
DM		 13511static int
13512process_sparc_specific (FILE * file)
13513{
13514 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13515 display_sparc_gnu_attribute);
13516}
13517
59e6276b
JM		 13518static int
13519process_tic6x_specific (FILE * file)
13520{
13521 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13522 display_tic6x_attribute, NULL);
13523}
13524
13761a11
NC		 13525static int
13526process_msp430x_specific (FILE * file)
13527{
13528 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13529 display_msp430x_attribute, NULL);
13530}
13531
ccb4c951
RS		 13532/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13533 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13534 and return the VMA of the next entry, or -1 if there was a problem.
13535 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13536
13537static bfd_vma
82b1b41b
NC		 13538print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13539 unsigned char * data_end)
ccb4c951
RS		 13540{
13541 printf (" ");
13542 print_vma (addr, LONG_HEX);
13543 printf (" ");
13544 if (addr < pltgot + 0xfff0)
13545 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13546 else
13547 printf ("%10s", "");
13548 printf (" ");
13549 if (data == NULL)
2b692964 13550 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13551 else
13552 {
13553 bfd_vma entry;
82b1b41b 13554 unsigned char * from = data + addr - pltgot;
ccb4c951 13555
82b1b41b
NC		 13556 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13557 {
13558 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13559 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13560 return (bfd_vma) -1;
13561 }
13562 else
13563 {
13564 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13565 print_vma (entry, LONG_HEX);
13566 }
ccb4c951
RS		 13567 }
13568 return addr + (is_32bit_elf ? 4 : 8);
13569}
13570
861fb55a
DJ		 13571/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13572 PLTGOT. Print the Address and Initial fields of an entry at VMA
13573 ADDR and return the VMA of the next entry. */
13574
13575static bfd_vma
2cf0635d 13576print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13577{
13578 printf (" ");
13579 print_vma (addr, LONG_HEX);
13580 printf (" ");
13581 if (data == NULL)
2b692964 13582 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13583 else
13584 {
13585 bfd_vma entry;
13586
13587 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13588 print_vma (entry, LONG_HEX);
13589 }
13590 return addr + (is_32bit_elf ? 4 : 8);
13591}
13592
351cdf24
MF		 13593static void
13594print_mips_ases (unsigned int mask)
13595{
13596 if (mask & AFL_ASE_DSP)
13597 fputs ("\n\tDSP ASE", stdout);
13598 if (mask & AFL_ASE_DSPR2)
13599 fputs ("\n\tDSP R2 ASE", stdout);
13600 if (mask & AFL_ASE_EVA)
13601 fputs ("\n\tEnhanced VA Scheme", stdout);
13602 if (mask & AFL_ASE_MCU)
13603 fputs ("\n\tMCU (MicroController) ASE", stdout);
13604 if (mask & AFL_ASE_MDMX)
13605 fputs ("\n\tMDMX ASE", stdout);
13606 if (mask & AFL_ASE_MIPS3D)
13607 fputs ("\n\tMIPS-3D ASE", stdout);
13608 if (mask & AFL_ASE_MT)
13609 fputs ("\n\tMT ASE", stdout);
13610 if (mask & AFL_ASE_SMARTMIPS)
13611 fputs ("\n\tSmartMIPS ASE", stdout);
13612 if (mask & AFL_ASE_VIRT)
13613 fputs ("\n\tVZ ASE", stdout);
13614 if (mask & AFL_ASE_MSA)
13615 fputs ("\n\tMSA ASE", stdout);
13616 if (mask & AFL_ASE_MIPS16)
13617 fputs ("\n\tMIPS16 ASE", stdout);
13618 if (mask & AFL_ASE_MICROMIPS)
13619 fputs ("\n\tMICROMIPS ASE", stdout);
13620 if (mask & AFL_ASE_XPA)
13621 fputs ("\n\tXPA ASE", stdout);
13622 if (mask == 0)
13623 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13624 else if ((mask & ~AFL_ASE_MASK) != 0)
13625 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13626}
13627
13628static void
13629print_mips_isa_ext (unsigned int isa_ext)
13630{
13631 switch (isa_ext)
13632 {
13633 case 0:
13634 fputs (_("None"), stdout);
13635 break;
13636 case AFL_EXT_XLR:
13637 fputs ("RMI XLR", stdout);
13638 break;
2c629856
N		 13639 case AFL_EXT_OCTEON3:
13640 fputs ("Cavium Networks Octeon3", stdout);
13641 break;
351cdf24
MF		 13642 case AFL_EXT_OCTEON2:
13643 fputs ("Cavium Networks Octeon2", stdout);
13644 break;
13645 case AFL_EXT_OCTEONP:
13646 fputs ("Cavium Networks OcteonP", stdout);
13647 break;
13648 case AFL_EXT_LOONGSON_3A:
13649 fputs ("Loongson 3A", stdout);
13650 break;
13651 case AFL_EXT_OCTEON:
13652 fputs ("Cavium Networks Octeon", stdout);
13653 break;
13654 case AFL_EXT_5900:
13655 fputs ("Toshiba R5900", stdout);
13656 break;
13657 case AFL_EXT_4650:
13658 fputs ("MIPS R4650", stdout);
13659 break;
13660 case AFL_EXT_4010:
13661 fputs ("LSI R4010", stdout);
13662 break;
13663 case AFL_EXT_4100:
13664 fputs ("NEC VR4100", stdout);
13665 break;
13666 case AFL_EXT_3900:
13667 fputs ("Toshiba R3900", stdout);
13668 break;
13669 case AFL_EXT_10000:
13670 fputs ("MIPS R10000", stdout);
13671 break;
13672 case AFL_EXT_SB1:
13673 fputs ("Broadcom SB-1", stdout);
13674 break;
13675 case AFL_EXT_4111:
13676 fputs ("NEC VR4111/VR4181", stdout);
13677 break;
13678 case AFL_EXT_4120:
13679 fputs ("NEC VR4120", stdout);
13680 break;
13681 case AFL_EXT_5400:
13682 fputs ("NEC VR5400", stdout);
13683 break;
13684 case AFL_EXT_5500:
13685 fputs ("NEC VR5500", stdout);
13686 break;
13687 case AFL_EXT_LOONGSON_2E:
13688 fputs ("ST Microelectronics Loongson 2E", stdout);
13689 break;
13690 case AFL_EXT_LOONGSON_2F:
13691 fputs ("ST Microelectronics Loongson 2F", stdout);
13692 break;
13693 default:
00ac7aa0 13694 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13695 }
13696}
13697
13698static int
13699get_mips_reg_size (int reg_size)
13700{
13701 return (reg_size == AFL_REG_NONE) ? 0
13702 : (reg_size == AFL_REG_32) ? 32
13703 : (reg_size == AFL_REG_64) ? 64
13704 : (reg_size == AFL_REG_128) ? 128
13705 : -1;
13706}
13707
19e6b90e 13708static int
2cf0635d 13709process_mips_specific (FILE * file)
5b18a4bc 13710{
2cf0635d 13711 Elf_Internal_Dyn * entry;
351cdf24 13712 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13713 size_t liblist_offset = 0;
13714 size_t liblistno = 0;
13715 size_t conflictsno = 0;
13716 size_t options_offset = 0;
13717 size_t conflicts_offset = 0;
861fb55a
DJ		 13718 size_t pltrelsz = 0;
13719 size_t pltrel = 0;
ccb4c951 13720 bfd_vma pltgot = 0;
861fb55a
DJ		 13721 bfd_vma mips_pltgot = 0;
13722 bfd_vma jmprel = 0;
ccb4c951
RS		 13723 bfd_vma local_gotno = 0;
13724 bfd_vma gotsym = 0;
13725 bfd_vma symtabno = 0;
103f02d3 13726
2cf19d5c
JM		 13727 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13728 display_mips_gnu_attribute);
13729
351cdf24
MF		 13730 sect = find_section (".MIPS.abiflags");
13731
13732 if (sect != NULL)
13733 {
13734 Elf_External_ABIFlags_v0 *abiflags_ext;
13735 Elf_Internal_ABIFlags_v0 abiflags_in;
13736
13737 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13738 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13739 else
13740 {
13741 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13742 sect->sh_size, _("MIPS ABI Flags section"));
13743 if (abiflags_ext)
13744 {
13745 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13746 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13747 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13748 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13749 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13750 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13751 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13752 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13753 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13754 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13755 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13756
13757 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13758 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13759 if (abiflags_in.isa_rev > 1)
13760 printf ("r%d", abiflags_in.isa_rev);
13761 printf ("\nGPR size: %d",
13762 get_mips_reg_size (abiflags_in.gpr_size));
13763 printf ("\nCPR1 size: %d",
13764 get_mips_reg_size (abiflags_in.cpr1_size));
13765 printf ("\nCPR2 size: %d",
13766 get_mips_reg_size (abiflags_in.cpr2_size));
13767 fputs ("\nFP ABI: ", stdout);
13768 print_mips_fp_abi_value (abiflags_in.fp_abi);
13769 fputs ("ISA Extension: ", stdout);
13770 print_mips_isa_ext (abiflags_in.isa_ext);
13771 fputs ("\nASEs:", stdout);
13772 print_mips_ases (abiflags_in.ases);
13773 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13774 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13775 fputc ('\n', stdout);
13776 free (abiflags_ext);
13777 }
13778 }
13779 }
13780
19e6b90e
L		 13781 /* We have a lot of special sections. Thanks SGI! */
13782 if (dynamic_section == NULL)
13783 /* No information available. */
13784 return 0;
252b5132 13785
071436c6
NC		 13786 for (entry = dynamic_section;
13787 /* PR 17531 file: 012-50589-0.004. */
13788 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13789 ++entry)
252b5132
RH		 13790 switch (entry->d_tag)
13791 {
13792 case DT_MIPS_LIBLIST:
d93f0186
NC		 13793 liblist_offset
13794 = offset_from_vma (file, entry->d_un.d_val,
13795 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13796 break;
13797 case DT_MIPS_LIBLISTNO:
13798 liblistno = entry->d_un.d_val;
13799 break;
13800 case DT_MIPS_OPTIONS:
d93f0186 13801 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13802 break;
13803 case DT_MIPS_CONFLICT:
d93f0186
NC		 13804 conflicts_offset
13805 = offset_from_vma (file, entry->d_un.d_val,
13806 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13807 break;
13808 case DT_MIPS_CONFLICTNO:
13809 conflictsno = entry->d_un.d_val;
13810 break;
ccb4c951 13811 case DT_PLTGOT:
861fb55a
DJ		 13812 pltgot = entry->d_un.d_ptr;
13813 break;
ccb4c951
RS		 13814 case DT_MIPS_LOCAL_GOTNO:
13815 local_gotno = entry->d_un.d_val;
13816 break;
13817 case DT_MIPS_GOTSYM:
13818 gotsym = entry->d_un.d_val;
13819 break;
13820 case DT_MIPS_SYMTABNO:
13821 symtabno = entry->d_un.d_val;
13822 break;
861fb55a
DJ		 13823 case DT_MIPS_PLTGOT:
13824 mips_pltgot = entry->d_un.d_ptr;
13825 break;
13826 case DT_PLTREL:
13827 pltrel = entry->d_un.d_val;
13828 break;
13829 case DT_PLTRELSZ:
13830 pltrelsz = entry->d_un.d_val;
13831 break;
13832 case DT_JMPREL:
13833 jmprel = entry->d_un.d_ptr;
13834 break;
252b5132
RH		 13835 default:
13836 break;
13837 }
13838
13839 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13840 {
2cf0635d 13841 Elf32_External_Lib * elib;
252b5132
RH		 13842 size_t cnt;
13843
3f5e193b
NC		 13844 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13845 liblistno,
13846 sizeof (Elf32_External_Lib),
9cf03b7e 13847 _("liblist section data"));
a6e9f9df 13848 if (elib)
252b5132 13849 {
2b692964 13850 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13851 (unsigned long) liblistno);
2b692964 13852 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13853 stdout);
13854
13855 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13856 {
a6e9f9df 13857 Elf32_Lib liblist;
91d6fa6a 13858 time_t atime;
a6e9f9df 13859 char timebuf[20];
2cf0635d 13860 struct tm * tmp;
a6e9f9df
AM		 13861
13862 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13863 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13864 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13865 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13866 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13867
91d6fa6a 13868 tmp = gmtime (&atime);
e9e44622
JJ		 13869 snprintf (timebuf, sizeof (timebuf),
13870 "%04u-%02u-%02uT%02u:%02u:%02u",
13871 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13872 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13873
31104126 13874 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13875 if (VALID_DYNAMIC_NAME (liblist.l_name))
13876 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13877 else
2b692964 13878 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13879 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13880 liblist.l_version);
a6e9f9df
AM		 13881
13882 if (liblist.l_flags == 0)
2b692964 13883 puts (_(" NONE"));
a6e9f9df
AM		 13884 else
13885 {
13886 static const struct
252b5132 13887 {
2cf0635d 13888 const char * name;
a6e9f9df 13889 int bit;
252b5132 13890 }
a6e9f9df
AM		 13891 l_flags_vals[] =
13892 {
13893 { " EXACT_MATCH", LL_EXACT_MATCH },
13894 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13895 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13896 { " EXPORTS", LL_EXPORTS },
13897 { " DELAY_LOAD", LL_DELAY_LOAD },
13898 { " DELTA", LL_DELTA }
13899 };
13900 int flags = liblist.l_flags;
13901 size_t fcnt;
13902
60bca95a 13903 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13904 if ((flags & l_flags_vals[fcnt].bit) != 0)
13905 {
13906 fputs (l_flags_vals[fcnt].name, stdout);
13907 flags ^= l_flags_vals[fcnt].bit;
13908 }
13909 if (flags != 0)
13910 printf (" %#x", (unsigned int) flags);
252b5132 13911
a6e9f9df
AM		 13912 puts ("");
13913 }
252b5132 13914 }
252b5132 13915
a6e9f9df
AM		 13916 free (elib);
13917 }
252b5132
RH		 13918 }
13919
13920 if (options_offset != 0)
13921 {
2cf0635d 13922 Elf_External_Options * eopt;
2cf0635d
NC		 13923 Elf_Internal_Options * iopt;
13924 Elf_Internal_Options * option;
252b5132
RH		 13925 size_t offset;
13926 int cnt;
351cdf24 13927 sect = section_headers;
252b5132
RH		 13928
13929 /* Find the section header so that we get the size. */
071436c6 13930 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 13931 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 13932 if (sect == NULL)
13933 {
13934 error (_("No MIPS_OPTIONS header found\n"));
13935 return 0;
13936 }
252b5132 13937
3f5e193b
NC		 13938 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13939 sect->sh_size, _("options"));
a6e9f9df 13940 if (eopt)
252b5132 13941 {
3f5e193b
NC		 13942 iopt = (Elf_Internal_Options *)
13943 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13944 if (iopt == NULL)
13945 {
8b73c356 13946 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 13947 return 0;
13948 }
76da6bbe 13949
a6e9f9df
AM		 13950 offset = cnt = 0;
13951 option = iopt;
252b5132 13952
82b1b41b 13953 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 13954 {
2cf0635d 13955 Elf_External_Options * eoption;
252b5132 13956
a6e9f9df 13957 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13958
a6e9f9df
AM		 13959 option->kind = BYTE_GET (eoption->kind);
13960 option->size = BYTE_GET (eoption->size);
13961 option->section = BYTE_GET (eoption->section);
13962 option->info = BYTE_GET (eoption->info);
76da6bbe 13963
82b1b41b
NC		 13964 /* PR 17531: file: ffa0fa3b. */
13965 if (option->size < sizeof (* eopt)
13966 || offset + option->size > sect->sh_size)
13967 {
55325047
NC		 13968 error (_("Invalid size (%u) for MIPS option\n"), option->size);
13969 return 0;
82b1b41b 13970 }
a6e9f9df 13971 offset += option->size;
82b1b41b 13972
a6e9f9df
AM		 13973 ++option;
13974 ++cnt;
13975 }
252b5132 13976
a6e9f9df 13977 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 13978 printable_section_name (sect), cnt);
76da6bbe 13979
a6e9f9df 13980 option = iopt;
82b1b41b 13981 offset = 0;
252b5132 13982
a6e9f9df 13983 while (cnt-- > 0)
252b5132 13984 {
a6e9f9df
AM		 13985 size_t len;
13986
13987 switch (option->kind)
252b5132 13988 {
a6e9f9df
AM		 13989 case ODK_NULL:
13990 /* This shouldn't happen. */
13991 printf (" NULL %d %lx", option->section, option->info);
13992 break;
13993 case ODK_REGINFO:
13994 printf (" REGINFO ");
13995 if (elf_header.e_machine == EM_MIPS)
13996 {
13997 /* 32bit form. */
2cf0635d 13998 Elf32_External_RegInfo * ereg;
b34976b6 13999 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14000
14001 ereg = (Elf32_External_RegInfo *) (option + 1);
14002 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14003 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14004 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14005 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14006 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14007 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14008
14009 printf ("GPR %08lx GP 0x%lx\n",
14010 reginfo.ri_gprmask,
14011 (unsigned long) reginfo.ri_gp_value);
14012 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14013 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14014 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14015 }
14016 else
14017 {
14018 /* 64 bit form. */
2cf0635d 14019 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14020 Elf64_Internal_RegInfo reginfo;
14021
14022 ereg = (Elf64_External_RegInfo *) (option + 1);
14023 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14024 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14025 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14026 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14027 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14028 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14029
14030 printf ("GPR %08lx GP 0x",
14031 reginfo.ri_gprmask);
14032 printf_vma (reginfo.ri_gp_value);
14033 printf ("\n");
14034
14035 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14036 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14037 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14038 }
14039 ++option;
14040 continue;
14041 case ODK_EXCEPTIONS:
14042 fputs (" EXCEPTIONS fpe_min(", stdout);
14043 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14044 fputs (") fpe_max(", stdout);
14045 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14046 fputs (")", stdout);
14047
14048 if (option->info & OEX_PAGE0)
14049 fputs (" PAGE0", stdout);
14050 if (option->info & OEX_SMM)
14051 fputs (" SMM", stdout);
14052 if (option->info & OEX_FPDBUG)
14053 fputs (" FPDBUG", stdout);
14054 if (option->info & OEX_DISMISS)
14055 fputs (" DISMISS", stdout);
14056 break;
14057 case ODK_PAD:
14058 fputs (" PAD ", stdout);
14059 if (option->info & OPAD_PREFIX)
14060 fputs (" PREFIX", stdout);
14061 if (option->info & OPAD_POSTFIX)
14062 fputs (" POSTFIX", stdout);
14063 if (option->info & OPAD_SYMBOL)
14064 fputs (" SYMBOL", stdout);
14065 break;
14066 case ODK_HWPATCH:
14067 fputs (" HWPATCH ", stdout);
14068 if (option->info & OHW_R4KEOP)
14069 fputs (" R4KEOP", stdout);
14070 if (option->info & OHW_R8KPFETCH)
14071 fputs (" R8KPFETCH", stdout);
14072 if (option->info & OHW_R5KEOP)
14073 fputs (" R5KEOP", stdout);
14074 if (option->info & OHW_R5KCVTL)
14075 fputs (" R5KCVTL", stdout);
14076 break;
14077 case ODK_FILL:
14078 fputs (" FILL ", stdout);
14079 /* XXX Print content of info word? */
14080 break;
14081 case ODK_TAGS:
14082 fputs (" TAGS ", stdout);
14083 /* XXX Print content of info word? */
14084 break;
14085 case ODK_HWAND:
14086 fputs (" HWAND ", stdout);
14087 if (option->info & OHWA0_R4KEOP_CHECKED)
14088 fputs (" R4KEOP_CHECKED", stdout);
14089 if (option->info & OHWA0_R4KEOP_CLEAN)
14090 fputs (" R4KEOP_CLEAN", stdout);
14091 break;
14092 case ODK_HWOR:
14093 fputs (" HWOR ", stdout);
14094 if (option->info & OHWA0_R4KEOP_CHECKED)
14095 fputs (" R4KEOP_CHECKED", stdout);
14096 if (option->info & OHWA0_R4KEOP_CLEAN)
14097 fputs (" R4KEOP_CLEAN", stdout);
14098 break;
14099 case ODK_GP_GROUP:
14100 printf (" GP_GROUP %#06lx self-contained %#06lx",
14101 option->info & OGP_GROUP,
14102 (option->info & OGP_SELF) >> 16);
14103 break;
14104 case ODK_IDENT:
14105 printf (" IDENT %#06lx self-contained %#06lx",
14106 option->info & OGP_GROUP,
14107 (option->info & OGP_SELF) >> 16);
14108 break;
14109 default:
14110 /* This shouldn't happen. */
14111 printf (" %3d ??? %d %lx",
14112 option->kind, option->section, option->info);
14113 break;
252b5132 14114 }
a6e9f9df 14115
2cf0635d 14116 len = sizeof (* eopt);
a6e9f9df 14117 while (len < option->size)
82b1b41b
NC		 14118 {
14119 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14120
82b1b41b
NC		 14121 if (ISPRINT (datum))
14122 printf ("%c", datum);
14123 else
14124 printf ("\\%03o", datum);
14125 len ++;
14126 }
a6e9f9df 14127 fputs ("\n", stdout);
82b1b41b
NC		 14128
14129 offset += option->size;
252b5132 14130 ++option;
252b5132
RH		 14131 }
14132
a6e9f9df 14133 free (eopt);
252b5132 14134 }
252b5132
RH		 14135 }
14136
14137 if (conflicts_offset != 0 && conflictsno != 0)
14138 {
2cf0635d 14139 Elf32_Conflict * iconf;
252b5132
RH		 14140 size_t cnt;
14141
14142 if (dynamic_symbols == NULL)
14143 {
591a748a 14144 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14145 return 0;
14146 }
14147
3f5e193b 14148 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14149 if (iconf == NULL)
14150 {
8b73c356 14151 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14152 return 0;
14153 }
14154
9ea033b2 14155 if (is_32bit_elf)
252b5132 14156 {
2cf0635d 14157 Elf32_External_Conflict * econf32;
a6e9f9df 14158
3f5e193b
NC		 14159 econf32 = (Elf32_External_Conflict *)
14160 get_data (NULL, file, conflicts_offset, conflictsno,
14161 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14162 if (!econf32)
14163 return 0;
252b5132
RH		 14164
14165 for (cnt = 0; cnt < conflictsno; ++cnt)
14166 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14167
14168 free (econf32);
252b5132
RH		 14169 }
14170 else
14171 {
2cf0635d 14172 Elf64_External_Conflict * econf64;
a6e9f9df 14173
3f5e193b
NC		 14174 econf64 = (Elf64_External_Conflict *)
14175 get_data (NULL, file, conflicts_offset, conflictsno,
14176 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14177 if (!econf64)
14178 return 0;
252b5132
RH		 14179
14180 for (cnt = 0; cnt < conflictsno; ++cnt)
14181 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14182
14183 free (econf64);
252b5132
RH		 14184 }
14185
c7e7ca54
NC		 14186 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14187 (unsigned long) conflictsno);
252b5132
RH		 14188 puts (_(" Num: Index Value Name"));
14189
14190 for (cnt = 0; cnt < conflictsno; ++cnt)
14191 {
b34976b6 14192 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14193
14194 if (iconf[cnt] >= num_dynamic_syms)
14195 printf (_("<corrupt symbol index>"));
d79b3d50 14196 else
e0a31db1
NC		 14197 {
14198 Elf_Internal_Sym * psym;
14199
14200 psym = & dynamic_symbols[iconf[cnt]];
14201 print_vma (psym->st_value, FULL_HEX);
14202 putchar (' ');
14203 if (VALID_DYNAMIC_NAME (psym->st_name))
14204 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14205 else
14206 printf (_("<corrupt: %14ld>"), psym->st_name);
14207 }
31104126 14208 putchar ('\n');
252b5132
RH		 14209 }
14210
252b5132
RH		 14211 free (iconf);
14212 }
14213
ccb4c951
RS		 14214 if (pltgot != 0 && local_gotno != 0)
14215 {
91d6fa6a 14216 bfd_vma ent, local_end, global_end;
bbeee7ea 14217 size_t i, offset;
2cf0635d 14218 unsigned char * data;
82b1b41b 14219 unsigned char * data_end;
bbeee7ea 14220 int addr_size;
ccb4c951 14221
91d6fa6a 14222 ent = pltgot;
ccb4c951
RS		 14223 addr_size = (is_32bit_elf ? 4 : 8);
14224 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14225
74e1a04b
NC		 14226 /* PR binutils/17533 file: 012-111227-0.004 */
14227 if (symtabno < gotsym)
14228 {
14229 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14230 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14231 return 0;
14232 }
82b1b41b 14233
74e1a04b 14234 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14235 /* PR 17531: file: 54c91a34. */
14236 if (global_end < local_end)
14237 {
14238 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14239 return 0;
14240 }
948f632f 14241
ccb4c951 14242 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14243 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14244 global_end - pltgot, 1,
14245 _("Global Offset Table data"));
59245841
NC		 14246 if (data == NULL)
14247 return 0;
82b1b41b 14248 data_end = data + (global_end - pltgot);
59245841 14249
ccb4c951
RS		 14250 printf (_("\nPrimary GOT:\n"));
14251 printf (_(" Canonical gp value: "));
14252 print_vma (pltgot + 0x7ff0, LONG_HEX);
14253 printf ("\n\n");
14254
14255 printf (_(" Reserved entries:\n"));
14256 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14257 addr_size * 2, _("Address"), _("Access"),
14258 addr_size * 2, _("Initial"));
82b1b41b 14259 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14260 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14261 if (ent == (bfd_vma) -1)
14262 goto got_print_fail;
ccb4c951 14263 if (data
91d6fa6a 14264 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14265 >> (addr_size * 8 - 1)) != 0)
14266 {
82b1b41b 14267 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14268 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14269 if (ent == (bfd_vma) -1)
14270 goto got_print_fail;
ccb4c951
RS		 14271 }
14272 printf ("\n");
14273
91d6fa6a 14274 if (ent < local_end)
ccb4c951
RS		 14275 {
14276 printf (_(" Local entries:\n"));
cc5914eb 14277 printf (" %*s %10s %*s\n",
2b692964
NC		 14278 addr_size * 2, _("Address"), _("Access"),
14279 addr_size * 2, _("Initial"));
91d6fa6a 14280 while (ent < local_end)
ccb4c951 14281 {
82b1b41b 14282 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14283 printf ("\n");
82b1b41b
NC		 14284 if (ent == (bfd_vma) -1)
14285 goto got_print_fail;
ccb4c951
RS		 14286 }
14287 printf ("\n");
14288 }
14289
14290 if (gotsym < symtabno)
14291 {
14292 int sym_width;
14293
14294 printf (_(" Global entries:\n"));
cc5914eb 14295 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14296 addr_size * 2, _("Address"),
14297 _("Access"),
2b692964 14298 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14299 addr_size * 2, _("Sym.Val."),
14300 _("Type"),
14301 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14302 _("Ndx"), _("Name"));
0b4362b0 14303
ccb4c951 14304 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14305
ccb4c951
RS		 14306 for (i = gotsym; i < symtabno; i++)
14307 {
82b1b41b 14308 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14309 printf (" ");
e0a31db1
NC		 14310
14311 if (dynamic_symbols == NULL)
14312 printf (_("<no dynamic symbols>"));
14313 else if (i < num_dynamic_syms)
14314 {
14315 Elf_Internal_Sym * psym = dynamic_symbols + i;
14316
14317 print_vma (psym->st_value, LONG_HEX);
14318 printf (" %-7s %3s ",
14319 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14320 get_symbol_index_type (psym->st_shndx));
14321
14322 if (VALID_DYNAMIC_NAME (psym->st_name))
14323 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14324 else
14325 printf (_("<corrupt: %14ld>"), psym->st_name);
14326 }
ccb4c951 14327 else
7fc5ac57
JBG		 14328 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14329 (unsigned long) i);
e0a31db1 14330
ccb4c951 14331 printf ("\n");
82b1b41b
NC		 14332 if (ent == (bfd_vma) -1)
14333 break;
ccb4c951
RS		 14334 }
14335 printf ("\n");
14336 }
14337
82b1b41b 14338 got_print_fail:
ccb4c951
RS		 14339 if (data)
14340 free (data);
14341 }
14342
861fb55a
DJ		 14343 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14344 {
91d6fa6a 14345 bfd_vma ent, end;
861fb55a
DJ		 14346 size_t offset, rel_offset;
14347 unsigned long count, i;
2cf0635d 14348 unsigned char * data;
861fb55a 14349 int addr_size, sym_width;
2cf0635d 14350 Elf_Internal_Rela * rels;
861fb55a
DJ		 14351
14352 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14353 if (pltrel == DT_RELA)
14354 {
14355 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14356 return 0;
14357 }
14358 else
14359 {
14360 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14361 return 0;
14362 }
14363
91d6fa6a 14364 ent = mips_pltgot;
861fb55a
DJ		 14365 addr_size = (is_32bit_elf ? 4 : 8);
14366 end = mips_pltgot + (2 + count) * addr_size;
14367
14368 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14369 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14370 1, _("Procedure Linkage Table data"));
59245841
NC		 14371 if (data == NULL)
14372 return 0;
14373
9cf03b7e 14374 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14375 printf (_(" Reserved entries:\n"));
14376 printf (_(" %*s %*s Purpose\n"),
2b692964 14377 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14378 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14379 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14380 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14381 printf (_(" Module pointer\n"));
861fb55a
DJ		 14382 printf ("\n");
14383
14384 printf (_(" Entries:\n"));
cc5914eb 14385 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14386 addr_size * 2, _("Address"),
14387 addr_size * 2, _("Initial"),
14388 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14389 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14390 for (i = 0; i < count; i++)
14391 {
df97ab2a 14392 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14393
91d6fa6a 14394 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14395 printf (" ");
e0a31db1 14396
df97ab2a
MF		 14397 if (idx >= num_dynamic_syms)
14398 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14399 else
e0a31db1 14400 {
df97ab2a 14401 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14402
14403 print_vma (psym->st_value, LONG_HEX);
14404 printf (" %-7s %3s ",
14405 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14406 get_symbol_index_type (psym->st_shndx));
14407 if (VALID_DYNAMIC_NAME (psym->st_name))
14408 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14409 else
14410 printf (_("<corrupt: %14ld>"), psym->st_name);
14411 }
861fb55a
DJ		 14412 printf ("\n");
14413 }
14414 printf ("\n");
14415
14416 if (data)
14417 free (data);
14418 free (rels);
14419 }
14420
252b5132
RH		 14421 return 1;
14422}
14423
35c08157
KLC		 14424static int
14425process_nds32_specific (FILE * file)
14426{
14427 Elf_Internal_Shdr *sect = NULL;
14428
14429 sect = find_section (".nds32_e_flags");
14430 if (sect != NULL)
14431 {
14432 unsigned int *flag;
14433
14434 printf ("\nNDS32 elf flags section:\n");
14435 flag = get_data (NULL, file, sect->sh_offset, 1,
14436 sect->sh_size, _("NDS32 elf flags section"));
14437
14438 switch ((*flag) & 0x3)
14439 {
14440 case 0:
14441 printf ("(VEC_SIZE):\tNo entry.\n");
14442 break;
14443 case 1:
14444 printf ("(VEC_SIZE):\t4 bytes\n");
14445 break;
14446 case 2:
14447 printf ("(VEC_SIZE):\t16 bytes\n");
14448 break;
14449 case 3:
14450 printf ("(VEC_SIZE):\treserved\n");
14451 break;
14452 }
14453 }
14454
14455 return TRUE;
14456}
14457
047b2264 14458static int
2cf0635d 14459process_gnu_liblist (FILE * file)
047b2264 14460{
2cf0635d
NC		 14461 Elf_Internal_Shdr * section;
14462 Elf_Internal_Shdr * string_sec;
14463 Elf32_External_Lib * elib;
14464 char * strtab;
c256ffe7 14465 size_t strtab_size;
047b2264
JJ		 14466 size_t cnt;
14467 unsigned i;
14468
14469 if (! do_arch)
14470 return 0;
14471
14472 for (i = 0, section = section_headers;
14473 i < elf_header.e_shnum;
b34976b6 14474 i++, section++)
047b2264
JJ		 14475 {
14476 switch (section->sh_type)
14477 {
14478 case SHT_GNU_LIBLIST:
4fbb74a6 14479 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14480 break;
14481
3f5e193b
NC		 14482 elib = (Elf32_External_Lib *)
14483 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14484 _("liblist section data"));
047b2264
JJ		 14485
14486 if (elib == NULL)
14487 break;
4fbb74a6 14488 string_sec = section_headers + section->sh_link;
047b2264 14489
3f5e193b
NC		 14490 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14491 string_sec->sh_size,
14492 _("liblist string table"));
047b2264
JJ		 14493 if (strtab == NULL
14494 || section->sh_entsize != sizeof (Elf32_External_Lib))
14495 {
14496 free (elib);
2842702f 14497 free (strtab);
047b2264
JJ		 14498 break;
14499 }
59245841 14500 strtab_size = string_sec->sh_size;
047b2264
JJ		 14501
14502 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14503 printable_section_name (section),
0af1713e 14504 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14505
2b692964 14506 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14507
14508 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14509 ++cnt)
14510 {
14511 Elf32_Lib liblist;
91d6fa6a 14512 time_t atime;
047b2264 14513 char timebuf[20];
2cf0635d 14514 struct tm * tmp;
047b2264
JJ		 14515
14516 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14517 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14518 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14519 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14520 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14521
91d6fa6a 14522 tmp = gmtime (&atime);
e9e44622
JJ		 14523 snprintf (timebuf, sizeof (timebuf),
14524 "%04u-%02u-%02uT%02u:%02u:%02u",
14525 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14526 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14527
14528 printf ("%3lu: ", (unsigned long) cnt);
14529 if (do_wide)
c256ffe7 14530 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14531 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14532 else
c256ffe7 14533 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14534 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14535 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14536 liblist.l_version, liblist.l_flags);
14537 }
14538
14539 free (elib);
2842702f 14540 free (strtab);
047b2264
JJ		 14541 }
14542 }
14543
14544 return 1;
14545}
14546
9437c45b 14547static const char *
d3ba0551 14548get_note_type (unsigned e_type)
779fe533
NC		 14549{
14550 static char buff[64];
103f02d3 14551
1ec5cd37
NC		 14552 if (elf_header.e_type == ET_CORE)
14553 switch (e_type)
14554 {
57346661 14555 case NT_AUXV:
1ec5cd37 14556 return _("NT_AUXV (auxiliary vector)");
57346661 14557 case NT_PRSTATUS:
1ec5cd37 14558 return _("NT_PRSTATUS (prstatus structure)");
57346661 14559 case NT_FPREGSET:
1ec5cd37 14560 return _("NT_FPREGSET (floating point registers)");
57346661 14561 case NT_PRPSINFO:
1ec5cd37 14562 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14563 case NT_TASKSTRUCT:
1ec5cd37 14564 return _("NT_TASKSTRUCT (task structure)");
57346661 14565 case NT_PRXFPREG:
1ec5cd37 14566 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14567 case NT_PPC_VMX:
14568 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14569 case NT_PPC_VSX:
14570 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14571 case NT_386_TLS:
14572 return _("NT_386_TLS (x86 TLS information)");
14573 case NT_386_IOPERM:
14574 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14575 case NT_X86_XSTATE:
14576 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14577 case NT_S390_HIGH_GPRS:
14578 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14579 case NT_S390_TIMER:
14580 return _("NT_S390_TIMER (s390 timer register)");
14581 case NT_S390_TODCMP:
14582 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14583 case NT_S390_TODPREG:
14584 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14585 case NT_S390_CTRS:
14586 return _("NT_S390_CTRS (s390 control registers)");
14587 case NT_S390_PREFIX:
14588 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14589 case NT_S390_LAST_BREAK:
14590 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14591 case NT_S390_SYSTEM_CALL:
14592 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14593 case NT_S390_TDB:
14594 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14595 case NT_S390_VXRS_LOW:
14596 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14597 case NT_S390_VXRS_HIGH:
14598 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14599 case NT_ARM_VFP:
14600 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14601 case NT_ARM_TLS:
14602 return _("NT_ARM_TLS (AArch TLS registers)");
14603 case NT_ARM_HW_BREAK:
14604 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14605 case NT_ARM_HW_WATCH:
14606 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14607 case NT_PSTATUS:
1ec5cd37 14608 return _("NT_PSTATUS (pstatus structure)");
57346661 14609 case NT_FPREGS:
1ec5cd37 14610 return _("NT_FPREGS (floating point registers)");
57346661 14611 case NT_PSINFO:
1ec5cd37 14612 return _("NT_PSINFO (psinfo structure)");
57346661 14613 case NT_LWPSTATUS:
1ec5cd37 14614 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14615 case NT_LWPSINFO:
1ec5cd37 14616 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14617 case NT_WIN32PSTATUS:
1ec5cd37 14618 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14619 case NT_SIGINFO:
14620 return _("NT_SIGINFO (siginfo_t data)");
14621 case NT_FILE:
14622 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14623 default:
14624 break;
14625 }
14626 else
14627 switch (e_type)
14628 {
14629 case NT_VERSION:
14630 return _("NT_VERSION (version)");
14631 case NT_ARCH:
14632 return _("NT_ARCH (architecture)");
14633 default:
14634 break;
14635 }
14636
e9e44622 14637 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14638 return buff;
779fe533
NC		 14639}
14640
9ece1fa9
TT		 14641static int
14642print_core_note (Elf_Internal_Note *pnote)
14643{
14644 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14645 bfd_vma count, page_size;
14646 unsigned char *descdata, *filenames, *descend;
14647
14648 if (pnote->type != NT_FILE)
14649 return 1;
14650
14651#ifndef BFD64
14652 if (!is_32bit_elf)
14653 {
14654 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14655 /* Still "successful". */
14656 return 1;
14657 }
14658#endif
14659
14660 if (pnote->descsz < 2 * addr_size)
14661 {
14662 printf (_(" Malformed note - too short for header\n"));
14663 return 0;
14664 }
14665
14666 descdata = (unsigned char *) pnote->descdata;
14667 descend = descdata + pnote->descsz;
14668
14669 if (descdata[pnote->descsz - 1] != '\0')
14670 {
14671 printf (_(" Malformed note - does not end with \\0\n"));
14672 return 0;
14673 }
14674
14675 count = byte_get (descdata, addr_size);
14676 descdata += addr_size;
14677
14678 page_size = byte_get (descdata, addr_size);
14679 descdata += addr_size;
14680
14681 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14682 {
14683 printf (_(" Malformed note - too short for supplied file count\n"));
14684 return 0;
14685 }
14686
14687 printf (_(" Page size: "));
14688 print_vma (page_size, DEC);
14689 printf ("\n");
14690
14691 printf (_(" %*s%*s%*s\n"),
14692 (int) (2 + 2 * addr_size), _("Start"),
14693 (int) (4 + 2 * addr_size), _("End"),
14694 (int) (4 + 2 * addr_size), _("Page Offset"));
14695 filenames = descdata + count * 3 * addr_size;
14696 while (--count > 0)
14697 {
14698 bfd_vma start, end, file_ofs;
14699
14700 if (filenames == descend)
14701 {
14702 printf (_(" Malformed note - filenames end too early\n"));
14703 return 0;
14704 }
14705
14706 start = byte_get (descdata, addr_size);
14707 descdata += addr_size;
14708 end = byte_get (descdata, addr_size);
14709 descdata += addr_size;
14710 file_ofs = byte_get (descdata, addr_size);
14711 descdata += addr_size;
14712
14713 printf (" ");
14714 print_vma (start, FULL_HEX);
14715 printf (" ");
14716 print_vma (end, FULL_HEX);
14717 printf (" ");
14718 print_vma (file_ofs, FULL_HEX);
14719 printf ("\n %s\n", filenames);
14720
14721 filenames += 1 + strlen ((char *) filenames);
14722 }
14723
14724 return 1;
14725}
14726
1118d252
RM		 14727static const char *
14728get_gnu_elf_note_type (unsigned e_type)
14729{
14730 static char buff[64];
14731
14732 switch (e_type)
14733 {
14734 case NT_GNU_ABI_TAG:
14735 return _("NT_GNU_ABI_TAG (ABI version tag)");
14736 case NT_GNU_HWCAP:
14737 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14738 case NT_GNU_BUILD_ID:
14739 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14740 case NT_GNU_GOLD_VERSION:
14741 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14742 default:
14743 break;
14744 }
14745
14746 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14747 return buff;
14748}
14749
664f90a3
TT		 14750static int
14751print_gnu_note (Elf_Internal_Note *pnote)
14752{
14753 switch (pnote->type)
14754 {
14755 case NT_GNU_BUILD_ID:
14756 {
14757 unsigned long i;
14758
14759 printf (_(" Build ID: "));
14760 for (i = 0; i < pnote->descsz; ++i)
14761 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14762 printf ("\n");
664f90a3
TT		 14763 }
14764 break;
14765
14766 case NT_GNU_ABI_TAG:
14767 {
14768 unsigned long os, major, minor, subminor;
14769 const char *osname;
14770
3102e897
NC		 14771 /* PR 17531: file: 030-599401-0.004. */
14772 if (pnote->descsz < 16)
14773 {
14774 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14775 break;
14776 }
14777
664f90a3
TT		 14778 os = byte_get ((unsigned char *) pnote->descdata, 4);
14779 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14780 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14781 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14782
14783 switch (os)
14784 {
14785 case GNU_ABI_TAG_LINUX:
14786 osname = "Linux";
14787 break;
14788 case GNU_ABI_TAG_HURD:
14789 osname = "Hurd";
14790 break;
14791 case GNU_ABI_TAG_SOLARIS:
14792 osname = "Solaris";
14793 break;
14794 case GNU_ABI_TAG_FREEBSD:
14795 osname = "FreeBSD";
14796 break;
14797 case GNU_ABI_TAG_NETBSD:
14798 osname = "NetBSD";
14799 break;
14800 default:
14801 osname = "Unknown";
14802 break;
14803 }
14804
14805 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14806 major, minor, subminor);
14807 }
14808 break;
926c5385
CC		 14809
14810 case NT_GNU_GOLD_VERSION:
14811 {
14812 unsigned long i;
14813
14814 printf (_(" Version: "));
14815 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14816 printf ("%c", pnote->descdata[i]);
14817 printf ("\n");
14818 }
14819 break;
664f90a3
TT		 14820 }
14821
14822 return 1;
14823}
14824
685080f2
NC		 14825static const char *
14826get_v850_elf_note_type (enum v850_notes n_type)
14827{
14828 static char buff[64];
14829
14830 switch (n_type)
14831 {
14832 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
14833 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
14834 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
14835 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
14836 case V850_NOTE_CACHE_INFO: return _("Use of cache");
14837 case V850_NOTE_MMU_INFO: return _("Use of MMU");
14838 default:
14839 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
14840 return buff;
14841 }
14842}
14843
14844static int
14845print_v850_note (Elf_Internal_Note * pnote)
14846{
14847 unsigned int val;
14848
14849 if (pnote->descsz != 4)
14850 return 0;
14851 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
14852
14853 if (val == 0)
14854 {
14855 printf (_("not set\n"));
14856 return 1;
14857 }
14858
14859 switch (pnote->type)
14860 {
14861 case V850_NOTE_ALIGNMENT:
14862 switch (val)
14863 {
14864 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
14865 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
14866 }
14867 break;
14868
14869 case V850_NOTE_DATA_SIZE:
14870 switch (val)
14871 {
14872 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
14873 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
14874 }
14875 break;
14876
14877 case V850_NOTE_FPU_INFO:
14878 switch (val)
14879 {
14880 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
14881 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
14882 }
14883 break;
14884
14885 case V850_NOTE_MMU_INFO:
14886 case V850_NOTE_CACHE_INFO:
14887 case V850_NOTE_SIMD_INFO:
14888 if (val == EF_RH850_SIMD)
14889 {
14890 printf (_("yes\n"));
14891 return 1;
14892 }
14893 break;
14894
14895 default:
14896 /* An 'unknown note type' message will already have been displayed. */
14897 break;
14898 }
14899
14900 printf (_("unknown value: %x\n"), val);
14901 return 0;
14902}
14903
9437c45b 14904static const char *
d3ba0551 14905get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14906{
14907 static char buff[64];
14908
b4db1224 14909 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14910 {
14911 /* NetBSD core "procinfo" structure. */
14912 return _("NetBSD procinfo structure");
14913 }
14914
14915 /* As of Jan 2002 there are no other machine-independent notes
14916 defined for NetBSD core files. If the note type is less
14917 than the start of the machine-dependent note types, we don't
14918 understand it. */
14919
b4db1224 14920 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14921 {
e9e44622 14922 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14923 return buff;
14924 }
14925
14926 switch (elf_header.e_machine)
14927 {
14928 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14929 and PT_GETFPREGS == mach+2. */
14930
14931 case EM_OLD_ALPHA:
14932 case EM_ALPHA:
14933 case EM_SPARC:
14934 case EM_SPARC32PLUS:
14935 case EM_SPARCV9:
14936 switch (e_type)
14937 {
2b692964 14938 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 14939 return _("PT_GETREGS (reg structure)");
2b692964 14940 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 14941 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14942 default:
14943 break;
14944 }
14945 break;
14946
14947 /* On all other arch's, PT_GETREGS == mach+1 and
14948 PT_GETFPREGS == mach+3. */
14949 default:
14950 switch (e_type)
14951 {
2b692964 14952 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 14953 return _("PT_GETREGS (reg structure)");
2b692964 14954 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 14955 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14956 default:
14957 break;
14958 }
14959 }
14960
9cf03b7e 14961 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 14962 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 14963 return buff;
14964}
14965
70616151
TT		 14966static const char *
14967get_stapsdt_note_type (unsigned e_type)
14968{
14969 static char buff[64];
14970
14971 switch (e_type)
14972 {
14973 case NT_STAPSDT:
14974 return _("NT_STAPSDT (SystemTap probe descriptors)");
14975
14976 default:
14977 break;
14978 }
14979
14980 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14981 return buff;
14982}
14983
c6a9fc58
TT		 14984static int
14985print_stapsdt_note (Elf_Internal_Note *pnote)
14986{
14987 int addr_size = is_32bit_elf ? 4 : 8;
14988 char *data = pnote->descdata;
14989 char *data_end = pnote->descdata + pnote->descsz;
14990 bfd_vma pc, base_addr, semaphore;
14991 char *provider, *probe, *arg_fmt;
14992
14993 pc = byte_get ((unsigned char *) data, addr_size);
14994 data += addr_size;
14995 base_addr = byte_get ((unsigned char *) data, addr_size);
14996 data += addr_size;
14997 semaphore = byte_get ((unsigned char *) data, addr_size);
14998 data += addr_size;
14999
15000 provider = data;
15001 data += strlen (data) + 1;
15002 probe = data;
15003 data += strlen (data) + 1;
15004 arg_fmt = data;
15005 data += strlen (data) + 1;
15006
15007 printf (_(" Provider: %s\n"), provider);
15008 printf (_(" Name: %s\n"), probe);
15009 printf (_(" Location: "));
15010 print_vma (pc, FULL_HEX);
15011 printf (_(", Base: "));
15012 print_vma (base_addr, FULL_HEX);
15013 printf (_(", Semaphore: "));
15014 print_vma (semaphore, FULL_HEX);
9cf03b7e 15015 printf ("\n");
c6a9fc58
TT		 15016 printf (_(" Arguments: %s\n"), arg_fmt);
15017
15018 return data == data_end;
15019}
15020
00e98fc7
TG		 15021static const char *
15022get_ia64_vms_note_type (unsigned e_type)
15023{
15024 static char buff[64];
15025
15026 switch (e_type)
15027 {
15028 case NT_VMS_MHD:
15029 return _("NT_VMS_MHD (module header)");
15030 case NT_VMS_LNM:
15031 return _("NT_VMS_LNM (language name)");
15032 case NT_VMS_SRC:
15033 return _("NT_VMS_SRC (source files)");
15034 case NT_VMS_TITLE:
9cf03b7e 15035 return "NT_VMS_TITLE";
00e98fc7
TG		 15036 case NT_VMS_EIDC:
15037 return _("NT_VMS_EIDC (consistency check)");
15038 case NT_VMS_FPMODE:
15039 return _("NT_VMS_FPMODE (FP mode)");
15040 case NT_VMS_LINKTIME:
9cf03b7e 15041 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15042 case NT_VMS_IMGNAM:
15043 return _("NT_VMS_IMGNAM (image name)");
15044 case NT_VMS_IMGID:
15045 return _("NT_VMS_IMGID (image id)");
15046 case NT_VMS_LINKID:
15047 return _("NT_VMS_LINKID (link id)");
15048 case NT_VMS_IMGBID:
15049 return _("NT_VMS_IMGBID (build id)");
15050 case NT_VMS_GSTNAM:
15051 return _("NT_VMS_GSTNAM (sym table name)");
15052 case NT_VMS_ORIG_DYN:
9cf03b7e 15053 return "NT_VMS_ORIG_DYN";
00e98fc7 15054 case NT_VMS_PATCHTIME:
9cf03b7e 15055 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15056 default:
15057 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15058 return buff;
15059 }
15060}
15061
15062static int
15063print_ia64_vms_note (Elf_Internal_Note * pnote)
15064{
15065 switch (pnote->type)
15066 {
15067 case NT_VMS_MHD:
15068 if (pnote->descsz > 36)
15069 {
15070 size_t l = strlen (pnote->descdata + 34);
15071 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15072 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15073 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15074 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15075 }
15076 else
15077 printf (_(" Invalid size\n"));
15078 break;
15079 case NT_VMS_LNM:
15080 printf (_(" Language: %s\n"), pnote->descdata);
15081 break;
15082#ifdef BFD64
15083 case NT_VMS_FPMODE:
9cf03b7e 15084 printf (_(" Floating Point mode: "));
4a5cb34f 15085 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15086 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15087 break;
15088 case NT_VMS_LINKTIME:
15089 printf (_(" Link time: "));
15090 print_vms_time
15091 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15092 printf ("\n");
15093 break;
15094 case NT_VMS_PATCHTIME:
15095 printf (_(" Patch time: "));
15096 print_vms_time
15097 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15098 printf ("\n");
15099 break;
15100 case NT_VMS_ORIG_DYN:
15101 printf (_(" Major id: %u, minor id: %u\n"),
15102 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15103 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15104 printf (_(" Last modified : "));
00e98fc7
TG		 15105 print_vms_time
15106 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15107 printf (_("\n Link flags : "));
4a5cb34f 15108 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15109 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15110 printf (_(" Header flags: 0x%08x\n"),
948f632f 15111 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15112 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15113 break;
15114#endif
15115 case NT_VMS_IMGNAM:
15116 printf (_(" Image name: %s\n"), pnote->descdata);
15117 break;
15118 case NT_VMS_GSTNAM:
15119 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15120 break;
15121 case NT_VMS_IMGID:
15122 printf (_(" Image id: %s\n"), pnote->descdata);
15123 break;
15124 case NT_VMS_LINKID:
15125 printf (_(" Linker id: %s\n"), pnote->descdata);
15126 break;
15127 default:
15128 break;
15129 }
15130 return 1;
15131}
15132
6d118b09
NC		 15133/* Note that by the ELF standard, the name field is already null byte
15134 terminated, and namesz includes the terminating null byte.
15135 I.E. the value of namesz for the name "FSF" is 4.
15136
e3c8793a 15137 If the value of namesz is zero, there is no name present. */
779fe533 15138static int
2cf0635d 15139process_note (Elf_Internal_Note * pnote)
779fe533 15140{
2cf0635d
NC		 15141 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15142 const char * nt;
9437c45b
JT		 15143
15144 if (pnote->namesz == 0)
1ec5cd37
NC		 15145 /* If there is no note name, then use the default set of
15146 note type strings. */
15147 nt = get_note_type (pnote->type);
15148
1118d252
RM		 15149 else if (const_strneq (pnote->namedata, "GNU"))
15150 /* GNU-specific object file notes. */
15151 nt = get_gnu_elf_note_type (pnote->type);
15152
0112cd26 15153 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15154 /* NetBSD-specific core file notes. */
15155 nt = get_netbsd_elfcore_note_type (pnote->type);
15156
b15fa79e
AM		 15157 else if (strneq (pnote->namedata, "SPU/", 4))
15158 {
15159 /* SPU-specific core file notes. */
15160 nt = pnote->namedata + 4;
15161 name = "SPU";
15162 }
15163
00e98fc7
TG		 15164 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15165 /* VMS/ia64-specific file notes. */
15166 nt = get_ia64_vms_note_type (pnote->type);
15167
70616151
TT		 15168 else if (const_strneq (pnote->namedata, "stapsdt"))
15169 nt = get_stapsdt_note_type (pnote->type);
15170
9437c45b 15171 else
1ec5cd37
NC		 15172 /* Don't recognize this note name; just use the default set of
15173 note type strings. */
00e98fc7 15174 nt = get_note_type (pnote->type);
9437c45b 15175
2aee03ae 15176 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15177
15178 if (const_strneq (pnote->namedata, "IPF/VMS"))
15179 return print_ia64_vms_note (pnote);
664f90a3
TT		 15180 else if (const_strneq (pnote->namedata, "GNU"))
15181 return print_gnu_note (pnote);
c6a9fc58
TT		 15182 else if (const_strneq (pnote->namedata, "stapsdt"))
15183 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15184 else if (const_strneq (pnote->namedata, "CORE"))
15185 return print_core_note (pnote);
00e98fc7
TG		 15186 else
15187 return 1;
779fe533
NC		 15188}
15189
6d118b09 15190
779fe533 15191static int
2cf0635d 15192process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15193{
2cf0635d
NC		 15194 Elf_External_Note * pnotes;
15195 Elf_External_Note * external;
c8071705 15196 char * end;
b34976b6 15197 int res = 1;
103f02d3 15198
779fe533
NC		 15199 if (length <= 0)
15200 return 0;
103f02d3 15201
3f5e193b 15202 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15203 _("notes"));
dd24e3da 15204 if (pnotes == NULL)
a6e9f9df 15205 return 0;
779fe533 15206
103f02d3 15207 external = pnotes;
103f02d3 15208
9dd3a467 15209 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15210 (unsigned long) offset, (unsigned long) length);
2aee03ae 15211 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15212
c8071705
NC		 15213 end = (char *) pnotes + length;
15214 while ((char *) external < end)
779fe533 15215 {
b34976b6 15216 Elf_Internal_Note inote;
15b42fb0
AM		 15217 size_t min_notesz;
15218 char *next;
2cf0635d 15219 char * temp = NULL;
c8071705 15220 size_t data_remaining = end - (char *) external;
6d118b09 15221
00e98fc7 15222 if (!is_ia64_vms ())
15b42fb0 15223 {
9dd3a467
NC		 15224 /* PR binutils/15191
15225 Make sure that there is enough data to read. */
15b42fb0
AM		 15226 min_notesz = offsetof (Elf_External_Note, name);
15227 if (data_remaining < min_notesz)
9dd3a467
NC		 15228 {
15229 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15230 (int) data_remaining);
15231 break;
15232 }
15b42fb0
AM		 15233 inote.type = BYTE_GET (external->type);
15234 inote.namesz = BYTE_GET (external->namesz);
15235 inote.namedata = external->name;
15236 inote.descsz = BYTE_GET (external->descsz);
15237 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15238 /* PR 17531: file: 3443835e. */
c8071705 15239 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15240 {
15241 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15242 inote.descdata = inote.namedata;
15243 inote.namesz = 0;
15244 }
c8071705 15245
15b42fb0
AM		 15246 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15247 next = inote.descdata + align_power (inote.descsz, 2);
15248 }
00e98fc7 15249 else
15b42fb0
AM		 15250 {
15251 Elf64_External_VMS_Note *vms_external;
00e98fc7 15252
9dd3a467
NC		 15253 /* PR binutils/15191
15254 Make sure that there is enough data to read. */
15b42fb0
AM		 15255 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15256 if (data_remaining < min_notesz)
9dd3a467
NC		 15257 {
15258 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15259 (int) data_remaining);
15260 break;
15261 }
3e55a963 15262
15b42fb0
AM		 15263 vms_external = (Elf64_External_VMS_Note *) external;
15264 inote.type = BYTE_GET (vms_external->type);
15265 inote.namesz = BYTE_GET (vms_external->namesz);
15266 inote.namedata = vms_external->name;
15267 inote.descsz = BYTE_GET (vms_external->descsz);
15268 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15269 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15270 next = inote.descdata + align_power (inote.descsz, 3);
15271 }
15272
15273 if (inote.descdata < (char *) external + min_notesz
15274 || next < (char *) external + min_notesz
5d921cbd
NC		 15275 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15276 || inote.namedata + inote.namesz < inote.namedata
15277 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15278 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15279 {
15b42fb0 15280 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15281 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15282 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15283 inote.type, inote.namesz, inote.descsz);
15284 break;
15285 }
15286
15b42fb0 15287 external = (Elf_External_Note *) next;
dd24e3da 15288
6d118b09
NC		 15289 /* Verify that name is null terminated. It appears that at least
15290 one version of Linux (RedHat 6.0) generates corefiles that don't
15291 comply with the ELF spec by failing to include the null byte in
15292 namesz. */
8b971f9f 15293 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15294 {
3f5e193b 15295 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15296 if (temp == NULL)
15297 {
8b73c356 15298 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15299 res = 0;
15300 break;
15301 }
76da6bbe 15302
6d118b09
NC		 15303 strncpy (temp, inote.namedata, inote.namesz);
15304 temp[inote.namesz] = 0;
76da6bbe 15305
6d118b09
NC		 15306 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15307 inote.namedata = temp;
15308 }
15309
15310 res &= process_note (& inote);
103f02d3 15311
6d118b09
NC		 15312 if (temp != NULL)
15313 {
15314 free (temp);
15315 temp = NULL;
15316 }
779fe533
NC		 15317 }
15318
15319 free (pnotes);
103f02d3 15320
779fe533
NC		 15321 return res;
15322}
15323
15324static int
2cf0635d 15325process_corefile_note_segments (FILE * file)
779fe533 15326{
2cf0635d 15327 Elf_Internal_Phdr * segment;
b34976b6
AM		 15328 unsigned int i;
15329 int res = 1;
103f02d3 15330
d93f0186 15331 if (! get_program_headers (file))
779fe533 15332 return 0;
103f02d3 15333
779fe533
NC		 15334 for (i = 0, segment = program_headers;
15335 i < elf_header.e_phnum;
b34976b6 15336 i++, segment++)
779fe533
NC		 15337 {
15338 if (segment->p_type == PT_NOTE)
103f02d3 15339 res &= process_corefile_note_segment (file,
30800947
NC		 15340 (bfd_vma) segment->p_offset,
15341 (bfd_vma) segment->p_filesz);
779fe533 15342 }
103f02d3 15343
779fe533
NC		 15344 return res;
15345}
15346
685080f2
NC		 15347static int
15348process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15349{
15350 Elf_External_Note * pnotes;
15351 Elf_External_Note * external;
c8071705 15352 char * end;
685080f2
NC		 15353 int res = 1;
15354
15355 if (length <= 0)
15356 return 0;
15357
15358 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15359 _("v850 notes"));
15360 if (pnotes == NULL)
15361 return 0;
15362
15363 external = pnotes;
c8071705 15364 end = (char*) pnotes + length;
685080f2
NC		 15365
15366 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15367 (unsigned long) offset, (unsigned long) length);
15368
c8071705 15369 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15370 {
15371 Elf_External_Note * next;
15372 Elf_Internal_Note inote;
15373
15374 inote.type = BYTE_GET (external->type);
15375 inote.namesz = BYTE_GET (external->namesz);
15376 inote.namedata = external->name;
15377 inote.descsz = BYTE_GET (external->descsz);
15378 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15379 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15380
c8071705
NC		 15381 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15382 {
15383 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15384 inote.descdata = inote.namedata;
15385 inote.namesz = 0;
15386 }
15387
685080f2
NC		 15388 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15389
c8071705 15390 if ( ((char *) next > end)
685080f2
NC		 15391 || ((char *) next < (char *) pnotes))
15392 {
15393 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15394 (unsigned long) ((char *) external - (char *) pnotes));
15395 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15396 inote.type, inote.namesz, inote.descsz);
15397 break;
15398 }
15399
15400 external = next;
15401
15402 /* Prevent out-of-bounds indexing. */
c8071705 15403 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15404 || inote.namedata + inote.namesz < inote.namedata)
15405 {
15406 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15407 (unsigned long) ((char *) external - (char *) pnotes));
15408 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15409 inote.type, inote.namesz, inote.descsz);
15410 break;
15411 }
15412
15413 printf (" %s: ", get_v850_elf_note_type (inote.type));
15414
15415 if (! print_v850_note (& inote))
15416 {
15417 res = 0;
15418 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15419 inote.namesz, inote.descsz);
15420 }
15421 }
15422
15423 free (pnotes);
15424
15425 return res;
15426}
15427
779fe533 15428static int
2cf0635d 15429process_note_sections (FILE * file)
1ec5cd37 15430{
2cf0635d 15431 Elf_Internal_Shdr * section;
1ec5cd37 15432 unsigned long i;
df565f32 15433 int n = 0;
1ec5cd37
NC		 15434 int res = 1;
15435
15436 for (i = 0, section = section_headers;
fa1908fd 15437 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15438 i++, section++)
685080f2
NC		 15439 {
15440 if (section->sh_type == SHT_NOTE)
15441 {
15442 res &= process_corefile_note_segment (file,
15443 (bfd_vma) section->sh_offset,
15444 (bfd_vma) section->sh_size);
15445 n++;
15446 }
15447
15448 if (( elf_header.e_machine == EM_V800
15449 || elf_header.e_machine == EM_V850
15450 || elf_header.e_machine == EM_CYGNUS_V850)
15451 && section->sh_type == SHT_RENESAS_INFO)
15452 {
15453 res &= process_v850_notes (file,
15454 (bfd_vma) section->sh_offset,
15455 (bfd_vma) section->sh_size);
15456 n++;
15457 }
15458 }
df565f32
NC		 15459
15460 if (n == 0)
15461 /* Try processing NOTE segments instead. */
15462 return process_corefile_note_segments (file);
1ec5cd37
NC		 15463
15464 return res;
15465}
15466
15467static int
2cf0635d 15468process_notes (FILE * file)
779fe533
NC		 15469{
15470 /* If we have not been asked to display the notes then do nothing. */
15471 if (! do_notes)
15472 return 1;
103f02d3 15473
779fe533 15474 if (elf_header.e_type != ET_CORE)
1ec5cd37 15475 return process_note_sections (file);
103f02d3 15476
779fe533 15477 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15478 if (elf_header.e_phnum > 0)
15479 return process_corefile_note_segments (file);
779fe533 15480
1ec5cd37
NC		 15481 printf (_("No note segments present in the core file.\n"));
15482 return 1;
779fe533
NC		 15483}
15484
252b5132 15485static int
2cf0635d 15486process_arch_specific (FILE * file)
252b5132 15487{
a952a375
NC		 15488 if (! do_arch)
15489 return 1;
15490
252b5132
RH		 15491 switch (elf_header.e_machine)
15492 {
11c1ff18
PB		 15493 case EM_ARM:
15494 return process_arm_specific (file);
252b5132 15495 case EM_MIPS:
4fe85591 15496 case EM_MIPS_RS3_LE:
252b5132
RH		 15497 return process_mips_specific (file);
15498 break;
35c08157
KLC		 15499 case EM_NDS32:
15500 return process_nds32_specific (file);
15501 break;
34c8bcba
JM		 15502 case EM_PPC:
15503 return process_power_specific (file);
15504 break;
9e8c70f9
DM		 15505 case EM_SPARC:
15506 case EM_SPARC32PLUS:
15507 case EM_SPARCV9:
15508 return process_sparc_specific (file);
15509 break;
59e6276b
JM		 15510 case EM_TI_C6000:
15511 return process_tic6x_specific (file);
15512 break;
13761a11
NC		 15513 case EM_MSP430:
15514 return process_msp430x_specific (file);
252b5132
RH		 15515 default:
15516 break;
15517 }
15518 return 1;
15519}
15520
15521static int
2cf0635d 15522get_file_header (FILE * file)
252b5132 15523{
9ea033b2
NC		 15524 /* Read in the identity array. */
15525 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15526 return 0;
15527
9ea033b2 15528 /* Determine how to read the rest of the header. */
b34976b6 15529 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15530 {
15531 default: /* fall through */
15532 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15533 case ELFDATA2LSB:
15534 byte_get = byte_get_little_endian;
15535 byte_put = byte_put_little_endian;
15536 break;
15537 case ELFDATA2MSB:
15538 byte_get = byte_get_big_endian;
15539 byte_put = byte_put_big_endian;
15540 break;
9ea033b2
NC		 15541 }
15542
15543 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15544 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15545
15546 /* Read in the rest of the header. */
15547 if (is_32bit_elf)
15548 {
15549 Elf32_External_Ehdr ehdr32;
252b5132 15550
9ea033b2
NC		 15551 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15552 return 0;
103f02d3 15553
9ea033b2
NC		 15554 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15555 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15556 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15557 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15558 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15559 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15560 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15561 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15562 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15563 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15564 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15565 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15566 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15567 }
252b5132 15568 else
9ea033b2
NC		 15569 {
15570 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15571
15572 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15573 we will not be able to cope with the 64bit data found in
15574 64 ELF files. Detect this now and abort before we start
50c2245b 15575 overwriting things. */
a952a375
NC		 15576 if (sizeof (bfd_vma) < 8)
15577 {
e3c8793a
NC		 15578 error (_("This instance of readelf has been built without support for a\n\
1557964 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15580 return 0;
15581 }
103f02d3 15582
9ea033b2
NC		 15583 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15584 return 0;
103f02d3 15585
9ea033b2
NC		 15586 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15587 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15588 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15589 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15590 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15591 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15592 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15593 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15594 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15595 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15596 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15597 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15598 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15599 }
252b5132 15600
7ece0d85
JJ		 15601 if (elf_header.e_shoff)
15602 {
15603 /* There may be some extensions in the first section header. Don't
15604 bomb if we can't read it. */
15605 if (is_32bit_elf)
049b0c3a 15606 get_32bit_section_headers (file, TRUE);
7ece0d85 15607 else
049b0c3a 15608 get_64bit_section_headers (file, TRUE);
7ece0d85 15609 }
560f3c1c 15610
252b5132
RH		 15611 return 1;
15612}
15613
fb52b2f4
NC		 15614/* Process one ELF object file according to the command line options.
15615 This file may actually be stored in an archive. The file is
15616 positioned at the start of the ELF object. */
15617
ff78d6d6 15618static int
2cf0635d 15619process_object (char * file_name, FILE * file)
252b5132 15620{
252b5132
RH		 15621 unsigned int i;
15622
252b5132
RH		 15623 if (! get_file_header (file))
15624 {
15625 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15626 return 1;
252b5132
RH		 15627 }
15628
15629 /* Initialise per file variables. */
60bca95a 15630 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15631 version_info[i] = 0;
15632
60bca95a 15633 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15634 dynamic_info[i] = 0;
5115b233 15635 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15636
15637 /* Process the file. */
15638 if (show_name)
15639 printf (_("\nFile: %s\n"), file_name);
15640
18bd398b
NC		 15641 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15642 Note we do this even if cmdline_dump_sects is empty because we
15643 must make sure that the dump_sets array is zeroed out before each
15644 object file is processed. */
15645 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15646 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15647
15648 if (num_cmdline_dump_sects > 0)
15649 {
15650 if (num_dump_sects == 0)
15651 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15652 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15653
15654 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15655 memcpy (dump_sects, cmdline_dump_sects,
15656 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15657 }
d70c5fc7 15658
252b5132 15659 if (! process_file_header ())
fb52b2f4 15660 return 1;
252b5132 15661
d1f5c6e3 15662 if (! process_section_headers (file))
2f62977e 15663 {
d1f5c6e3
L		 15664 /* Without loaded section headers we cannot process lots of
15665 things. */
2f62977e 15666 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15667
2f62977e 15668 if (! do_using_dynamic)
2c610e4b 15669 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15670 }
252b5132 15671
d1f5c6e3
L		 15672 if (! process_section_groups (file))
15673 {
15674 /* Without loaded section groups we cannot process unwind. */
15675 do_unwind = 0;
15676 }
15677
2f62977e 15678 if (process_program_headers (file))
b2d38a17 15679 process_dynamic_section (file);
252b5132
RH		 15680
15681 process_relocs (file);
15682
4d6ed7c8
NC		 15683 process_unwind (file);
15684
252b5132
RH		 15685 process_symbol_table (file);
15686
15687 process_syminfo (file);
15688
15689 process_version_sections (file);
15690
15691 process_section_contents (file);
f5842774 15692
1ec5cd37 15693 process_notes (file);
103f02d3 15694
047b2264
JJ		 15695 process_gnu_liblist (file);
15696
252b5132
RH		 15697 process_arch_specific (file);
15698
d93f0186
NC		 15699 if (program_headers)
15700 {
15701 free (program_headers);
15702 program_headers = NULL;
15703 }
15704
252b5132
RH		 15705 if (section_headers)
15706 {
15707 free (section_headers);
15708 section_headers = NULL;
15709 }
15710
15711 if (string_table)
15712 {
15713 free (string_table);
15714 string_table = NULL;
d40ac9bd 15715 string_table_length = 0;
252b5132
RH		 15716 }
15717
15718 if (dynamic_strings)
15719 {
15720 free (dynamic_strings);
15721 dynamic_strings = NULL;
d79b3d50 15722 dynamic_strings_length = 0;
252b5132
RH		 15723 }
15724
15725 if (dynamic_symbols)
15726 {
15727 free (dynamic_symbols);
15728 dynamic_symbols = NULL;
19936277 15729 num_dynamic_syms = 0;
252b5132
RH		 15730 }
15731
15732 if (dynamic_syminfo)
15733 {
15734 free (dynamic_syminfo);
15735 dynamic_syminfo = NULL;
15736 }
ff78d6d6 15737
293c573e
MR		 15738 if (dynamic_section)
15739 {
15740 free (dynamic_section);
15741 dynamic_section = NULL;
15742 }
15743
e4b17d5c
L		 15744 if (section_headers_groups)
15745 {
15746 free (section_headers_groups);
15747 section_headers_groups = NULL;
15748 }
15749
15750 if (section_groups)
15751 {
2cf0635d
NC		 15752 struct group_list * g;
15753 struct group_list * next;
e4b17d5c
L		 15754
15755 for (i = 0; i < group_count; i++)
15756 {
15757 for (g = section_groups [i].root; g != NULL; g = next)
15758 {
15759 next = g->next;
15760 free (g);
15761 }
15762 }
15763
15764 free (section_groups);
15765 section_groups = NULL;
15766 }
15767
19e6b90e 15768 free_debug_memory ();
18bd398b 15769
ff78d6d6 15770 return 0;
252b5132
RH		 15771}
15772
2cf0635d
NC		 15773/* Process an ELF archive.
15774 On entry the file is positioned just after the ARMAG string. */
15775
15776static int
15777process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15778{
15779 struct archive_info arch;
15780 struct archive_info nested_arch;
15781 size_t got;
2cf0635d
NC		 15782 int ret;
15783
15784 show_name = 1;
15785
15786 /* The ARCH structure is used to hold information about this archive. */
15787 arch.file_name = NULL;
15788 arch.file = NULL;
15789 arch.index_array = NULL;
15790 arch.sym_table = NULL;
15791 arch.longnames = NULL;
15792
15793 /* The NESTED_ARCH structure is used as a single-item cache of information
15794 about a nested archive (when members of a thin archive reside within
15795 another regular archive file). */
15796 nested_arch.file_name = NULL;
15797 nested_arch.file = NULL;
15798 nested_arch.index_array = NULL;
15799 nested_arch.sym_table = NULL;
15800 nested_arch.longnames = NULL;
15801
15802 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15803 {
15804 ret = 1;
15805 goto out;
4145f1d5 15806 }
fb52b2f4 15807
4145f1d5
NC		 15808 if (do_archive_index)
15809 {
2cf0635d 15810 if (arch.sym_table == NULL)
4145f1d5
NC		 15811 error (_("%s: unable to dump the index as none was found\n"), file_name);
15812 else
15813 {
591f7597 15814 unsigned long i, l;
4145f1d5
NC		 15815 unsigned long current_pos;
15816
591f7597
NC		 15817 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15818 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 15819 current_pos = ftell (file);
15820
2cf0635d 15821 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 15822 {
2cf0635d
NC		 15823 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15824 {
15825 char * member_name;
4145f1d5 15826
2cf0635d
NC		 15827 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15828
15829 if (member_name != NULL)
15830 {
15831 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15832
15833 if (qualified_name != NULL)
15834 {
c2a7d3f5
NC		 15835 printf (_("Contents of binary %s at offset "), qualified_name);
15836 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15837 putchar ('\n');
2cf0635d
NC		 15838 free (qualified_name);
15839 }
4145f1d5
NC		 15840 }
15841 }
2cf0635d
NC		 15842
15843 if (l >= arch.sym_size)
4145f1d5
NC		 15844 {
15845 error (_("%s: end of the symbol table reached before the end of the index\n"),
15846 file_name);
cb8f3167 15847 break;
4145f1d5 15848 }
591f7597
NC		 15849 /* PR 17531: file: 0b6630b2. */
15850 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15851 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 15852 }
15853
c2a7d3f5
NC		 15854 if (arch.uses_64bit_indicies)
15855 l = (l + 7) & ~ 7;
15856 else
15857 l += l & 1;
15858
2cf0635d 15859 if (l < arch.sym_size)
c2a7d3f5
NC		 15860 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15861 file_name, arch.sym_size - l);
4145f1d5 15862
4145f1d5
NC		 15863 if (fseek (file, current_pos, SEEK_SET) != 0)
15864 {
15865 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 15866 ret = 1;
15867 goto out;
4145f1d5 15868 }
fb52b2f4 15869 }
4145f1d5
NC		 15870
15871 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15872 && !do_segments && !do_header && !do_dump && !do_version
15873 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 15874 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 15875 {
15876 ret = 0; /* Archive index only. */
15877 goto out;
15878 }
fb52b2f4
NC		 15879 }
15880
d989285c 15881 ret = 0;
fb52b2f4
NC		 15882
15883 while (1)
15884 {
2cf0635d
NC		 15885 char * name;
15886 size_t namelen;
15887 char * qualified_name;
15888
15889 /* Read the next archive header. */
15890 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15891 {
15892 error (_("%s: failed to seek to next archive header\n"), file_name);
15893 return 1;
15894 }
15895 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15896 if (got != sizeof arch.arhdr)
15897 {
15898 if (got == 0)
15899 break;
15900 error (_("%s: failed to read archive header\n"), file_name);
15901 ret = 1;
15902 break;
15903 }
15904 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15905 {
15906 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15907 ret = 1;
15908 break;
15909 }
15910
15911 arch.next_arhdr_offset += sizeof arch.arhdr;
15912
15913 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15914 if (archive_file_size & 01)
15915 ++archive_file_size;
15916
15917 name = get_archive_member_name (&arch, &nested_arch);
15918 if (name == NULL)
fb52b2f4 15919 {
0fd3a477 15920 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15921 ret = 1;
15922 break;
fb52b2f4 15923 }
2cf0635d 15924 namelen = strlen (name);
fb52b2f4 15925
2cf0635d
NC		 15926 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15927 if (qualified_name == NULL)
fb52b2f4 15928 {
2cf0635d 15929 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15930 ret = 1;
15931 break;
fb52b2f4
NC		 15932 }
15933
2cf0635d
NC		 15934 if (is_thin_archive && arch.nested_member_origin == 0)
15935 {
15936 /* This is a proxy for an external member of a thin archive. */
15937 FILE * member_file;
15938 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15939 if (member_file_name == NULL)
15940 {
15941 ret = 1;
15942 break;
15943 }
15944
15945 member_file = fopen (member_file_name, "rb");
15946 if (member_file == NULL)
15947 {
15948 error (_("Input file '%s' is not readable.\n"), member_file_name);
15949 free (member_file_name);
15950 ret = 1;
15951 break;
15952 }
15953
15954 archive_file_offset = arch.nested_member_origin;
15955
15956 ret |= process_object (qualified_name, member_file);
15957
15958 fclose (member_file);
15959 free (member_file_name);
15960 }
15961 else if (is_thin_archive)
15962 {
a043396b
NC		 15963 /* PR 15140: Allow for corrupt thin archives. */
15964 if (nested_arch.file == NULL)
15965 {
15966 error (_("%s: contains corrupt thin archive: %s\n"),
15967 file_name, name);
15968 ret = 1;
15969 break;
15970 }
15971
2cf0635d
NC		 15972 /* This is a proxy for a member of a nested archive. */
15973 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15974
15975 /* The nested archive file will have been opened and setup by
15976 get_archive_member_name. */
15977 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15978 {
15979 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15980 ret = 1;
15981 break;
15982 }
15983
15984 ret |= process_object (qualified_name, nested_arch.file);
15985 }
15986 else
15987 {
15988 archive_file_offset = arch.next_arhdr_offset;
15989 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 15990
2cf0635d
NC		 15991 ret |= process_object (qualified_name, file);
15992 }
fb52b2f4 15993
2b52916e
L		 15994 if (dump_sects != NULL)
15995 {
15996 free (dump_sects);
15997 dump_sects = NULL;
15998 num_dump_sects = 0;
15999 }
16000
2cf0635d 16001 free (qualified_name);
fb52b2f4
NC		 16002 }
16003
4145f1d5 16004 out:
2cf0635d
NC		 16005 if (nested_arch.file != NULL)
16006 fclose (nested_arch.file);
16007 release_archive (&nested_arch);
16008 release_archive (&arch);
fb52b2f4 16009
d989285c 16010 return ret;
fb52b2f4
NC		 16011}
16012
16013static int
2cf0635d 16014process_file (char * file_name)
fb52b2f4 16015{
2cf0635d 16016 FILE * file;
fb52b2f4
NC		 16017 struct stat statbuf;
16018 char armag[SARMAG];
16019 int ret;
16020
16021 if (stat (file_name, &statbuf) < 0)
16022 {
f24ddbdd
NC		 16023 if (errno == ENOENT)
16024 error (_("'%s': No such file\n"), file_name);
16025 else
16026 error (_("Could not locate '%s'. System error message: %s\n"),
16027 file_name, strerror (errno));
16028 return 1;
16029 }
16030
16031 if (! S_ISREG (statbuf.st_mode))
16032 {
16033 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16034 return 1;
16035 }
16036
16037 file = fopen (file_name, "rb");
16038 if (file == NULL)
16039 {
f24ddbdd 16040 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16041 return 1;
16042 }
16043
16044 if (fread (armag, SARMAG, 1, file) != 1)
16045 {
4145f1d5 16046 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16047 fclose (file);
16048 return 1;
16049 }
16050
f54498b4
NC		 16051 current_file_size = (bfd_size_type) statbuf.st_size;
16052
fb52b2f4 16053 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16054 ret = process_archive (file_name, file, FALSE);
16055 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16056 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16057 else
16058 {
4145f1d5
NC		 16059 if (do_archive_index)
16060 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16061 file_name);
16062
fb52b2f4
NC		 16063 rewind (file);
16064 archive_file_size = archive_file_offset = 0;
16065 ret = process_object (file_name, file);
16066 }
16067
16068 fclose (file);
16069
f54498b4 16070 current_file_size = 0;
fb52b2f4
NC		 16071 return ret;
16072}
16073
252b5132
RH		 16074#ifdef SUPPORT_DISASSEMBLY
16075/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16076 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16077 symbols. */
252b5132
RH		 16078
16079void
2cf0635d 16080print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16081{
16082 fprintf (outfile,"0x%8.8x", addr);
16083}
16084
e3c8793a 16085/* Needed by the i386 disassembler. */
252b5132
RH		 16086void
16087db_task_printsym (unsigned int addr)
16088{
16089 print_address (addr, stderr);
16090}
16091#endif
16092
16093int
2cf0635d 16094main (int argc, char ** argv)
252b5132 16095{
ff78d6d6
L		 16096 int err;
16097
252b5132
RH		 16098#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16099 setlocale (LC_MESSAGES, "");
3882b010
L		 16100#endif
16101#if defined (HAVE_SETLOCALE)
16102 setlocale (LC_CTYPE, "");
252b5132
RH		 16103#endif
16104 bindtextdomain (PACKAGE, LOCALEDIR);
16105 textdomain (PACKAGE);
16106
869b9d07
MM		 16107 expandargv (&argc, &argv);
16108
252b5132
RH		 16109 parse_args (argc, argv);
16110
18bd398b 16111 if (num_dump_sects > 0)
59f14fc0 16112 {
18bd398b 16113 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16114 cmdline_dump_sects = (dump_type *)
16115 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16116 if (cmdline_dump_sects == NULL)
591a748a 16117 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16118 else
16119 {
09c11c86
NC		 16120 memcpy (cmdline_dump_sects, dump_sects,
16121 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16122 num_cmdline_dump_sects = num_dump_sects;
16123 }
16124 }
16125
18bd398b
NC		 16126 if (optind < (argc - 1))
16127 show_name = 1;
5656ba2c
L		 16128 else if (optind >= argc)
16129 {
16130 warn (_("Nothing to do.\n"));
16131 usage (stderr);
16132 }
18bd398b 16133
ff78d6d6 16134 err = 0;
252b5132 16135 while (optind < argc)
18bd398b 16136 err |= process_file (argv[optind++]);
252b5132
RH		 16137
16138 if (dump_sects != NULL)
16139 free (dump_sects);
59f14fc0
AS		 16140 if (cmdline_dump_sects != NULL)
16141 free (cmdline_dump_sects);
252b5132 16142
ff78d6d6 16143 return err;
252b5132 16144}
GDB Binutils - Deliverables
This page took 2.180424 seconds and 4 git commands to generate.