]> Git Repo - binutils.git/blame - binutils/readelf.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Don't enable gdbtk in testsuite
[binutils.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
4b95cf5c 2 Copyright (C) 1998-2014 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <[email protected]>
12ab83a9 5 Modifications by Nick Clifton <[email protected]>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056
CS		 46#ifdef HAVE_ZLIB_H
47#include <zlib.h>
48#endif
3bfcb652 49#ifdef HAVE_WCHAR_H
7bfd842d 50#include <wchar.h>
3bfcb652 51#endif
252b5132 52
a952a375 53#if __GNUC__ >= 2
19936277 54/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 55 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 56 Only do this if we believe that the compiler can support a 64 bit
a952a375 57 data type. For now we only rely on GCC being able to do this. */
19936277 58#define BFD64
a952a375
NC		 59#endif
60
3db64b00
AM		 61#include "bfd.h"
62#include "bucomm.h"
3284fe0c 63#include "elfcomm.h"
19e6b90e 64#include "dwarf.h"
252b5132
RH		 65
66#include "elf/common.h"
67#include "elf/external.h"
68#include "elf/internal.h"
252b5132 69
4b78141a
NC		 70
71/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76#include "elf/h8.h"
77#undef _ELF_H8_H
78
79/* Undo the effects of #including reloc-macros.h. */
80
81#undef START_RELOC_NUMBERS
82#undef RELOC_NUMBER
83#undef FAKE_RELOC
84#undef EMPTY_RELOC
85#undef END_RELOC_NUMBERS
86#undef _RELOC_MACROS_H
87
252b5132
RH		 88/* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92#define RELOC_MACROS_GEN_FUNC
93
a06ea964 94#include "elf/aarch64.h"
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
cfb8c092 106#include "elf/epiphany.h"
252b5132 107#include "elf/fr30.h"
5c70f934 108#include "elf/frv.h"
3b16e843
NC		 109#include "elf/h8.h"
110#include "elf/hppa.h"
111#include "elf/i386.h"
35b1837e 112#include "elf/i370.h"
3b16e843
NC		 113#include "elf/i860.h"
114#include "elf/i960.h"
115#include "elf/ia64.h"
1e4cf259 116#include "elf/ip2k.h"
84e94c90 117#include "elf/lm32.h"
1c0d3aa6 118#include "elf/iq2000.h"
49f58d10 119#include "elf/m32c.h"
3b16e843
NC		 120#include "elf/m32r.h"
121#include "elf/m68k.h"
75751cd9 122#include "elf/m68hc11.h"
252b5132 123#include "elf/mcore.h"
15ab5209 124#include "elf/mep.h"
a3c62988 125#include "elf/metag.h"
7ba29e2a 126#include "elf/microblaze.h"
3b16e843 127#include "elf/mips.h"
3c3bdf30 128#include "elf/mmix.h"
3b16e843
NC		 129#include "elf/mn10200.h"
130#include "elf/mn10300.h"
5506d11a 131#include "elf/moxie.h"
4970f871 132#include "elf/mt.h"
2469cfa2 133#include "elf/msp430.h"
35c08157 134#include "elf/nds32.h"
13761a11 135#include "elf/nios2.h"
73589c9d 136#include "elf/or1k.h"
7d466069 137#include "elf/pj.h"
3b16e843 138#include "elf/ppc.h"
c833c019 139#include "elf/ppc64.h"
99c513f6 140#include "elf/rl78.h"
c7927a3c 141#include "elf/rx.h"
a85d7ed0 142#include "elf/s390.h"
1c0d3aa6 143#include "elf/score.h"
3b16e843
NC		 144#include "elf/sh.h"
145#include "elf/sparc.h"
e9f53129 146#include "elf/spu.h"
40b36596 147#include "elf/tic6x.h"
aa137e4d
NC		 148#include "elf/tilegx.h"
149#include "elf/tilepro.h"
3b16e843 150#include "elf/v850.h"
179d3252 151#include "elf/vax.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 *
c9c1d674 325get_data (void * var, FILE * file, unsigned long offset, size_t size, size_t nmemb,
2cf0635d 326 const char * reason)
a6e9f9df 327{
2cf0635d 328 void * mvar;
c9c1d674 329 size_t amt = size * nmemb;
a6e9f9df 330
c256ffe7 331 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 332 return NULL;
333
c9c1d674
EG		 334 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
335 attempting to allocate memory when the read is bound to fail. */
336 if (amt > current_file_size
337 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 338 {
049b0c3a 339 if (reason)
c9c1d674
EG		 340 error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
341 (unsigned long) amt, reason);
a6e9f9df
AM		 342 return NULL;
343 }
344
c9c1d674 345 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 346 {
347 if (reason)
c9c1d674
EG		 348 error (_("Unable to seek to 0x%lx for %s\n"),
349 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 350 return NULL;
351 }
352
a6e9f9df
AM		 353 mvar = var;
354 if (mvar == NULL)
355 {
c256ffe7
JJ		 356 /* Check for overflow. */
357 if (nmemb < (~(size_t) 0 - 1) / size)
358 /* + 1 so that we can '\0' terminate invalid string table sections. */
359 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 360
361 if (mvar == NULL)
362 {
049b0c3a
NC		 363 if (reason)
364 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
365 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 366 return NULL;
367 }
c256ffe7 368
c9c1d674 369 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 370 }
371
c256ffe7 372 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 373 {
049b0c3a
NC		 374 if (reason)
375 error (_("Unable to read in 0x%lx bytes of %s\n"),
c9c1d674 376 (unsigned long) amt, reason);
a6e9f9df
AM		 377 if (mvar != var)
378 free (mvar);
379 return NULL;
380 }
381
382 return mvar;
383}
384
14a91970 385/* Print a VMA value. */
cb8f3167 386
66543521 387static int
14a91970 388print_vma (bfd_vma vma, print_mode mode)
66543521 389{
66543521
AM		 390 int nc = 0;
391
14a91970 392 switch (mode)
66543521 393 {
14a91970
AM		 394 case FULL_HEX:
395 nc = printf ("0x");
396 /* Drop through. */
66543521 397
14a91970 398 case LONG_HEX:
f7a99963 399#ifdef BFD64
14a91970 400 if (is_32bit_elf)
437c2fb7 401 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 402#endif
14a91970
AM		 403 printf_vma (vma);
404 return nc + 16;
b19aac67 405
14a91970
AM		 406 case DEC_5:
407 if (vma <= 99999)
408 return printf ("%5" BFD_VMA_FMT "d", vma);
409 /* Drop through. */
66543521 410
14a91970
AM		 411 case PREFIX_HEX:
412 nc = printf ("0x");
413 /* Drop through. */
66543521 414
14a91970
AM		 415 case HEX:
416 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 417
14a91970
AM		 418 case DEC:
419 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 420
14a91970
AM		 421 case UNSIGNED:
422 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 423 }
66543521 424 return 0;
f7a99963
NC		 425}
426
7bfd842d 427/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 428 multibye characters (assuming the host environment supports them).
31104126 429
7bfd842d
NC		 430 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
431
432 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
433 padding as necessary.
171191ba
NC		 434
435 Returns the number of emitted characters. */
436
437static unsigned int
7a88bc9c 438print_symbol (int width, const char *symbol)
31104126 439{
171191ba 440 bfd_boolean extra_padding = FALSE;
7bfd842d 441 int num_printed = 0;
3bfcb652 442#ifdef HAVE_MBSTATE_T
7bfd842d 443 mbstate_t state;
3bfcb652 444#endif
7bfd842d 445 int width_remaining;
961c521f 446
7bfd842d 447 if (width < 0)
961c521f 448 {
961c521f
NC		 449 /* Keep the width positive. This also helps. */
450 width = - width;
171191ba 451 extra_padding = TRUE;
0b4362b0 452 }
74e1a04b 453 assert (width != 0);
961c521f 454
7bfd842d
NC		 455 if (do_wide)
456 /* Set the remaining width to a very large value.
457 This simplifies the code below. */
458 width_remaining = INT_MAX;
459 else
460 width_remaining = width;
cb8f3167 461
3bfcb652 462#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 463 /* Initialise the multibyte conversion state. */
464 memset (& state, 0, sizeof (state));
3bfcb652 465#endif
961c521f 466
7bfd842d
NC		 467 while (width_remaining)
468 {
469 size_t n;
7bfd842d 470 const char c = *symbol++;
961c521f 471
7bfd842d 472 if (c == 0)
961c521f
NC		 473 break;
474
7bfd842d
NC		 475 /* Do not print control characters directly as they can affect terminal
476 settings. Such characters usually appear in the names generated
477 by the assembler for local labels. */
478 if (ISCNTRL (c))
961c521f 479 {
7bfd842d 480 if (width_remaining < 2)
961c521f
NC		 481 break;
482
7bfd842d
NC		 483 printf ("^%c", c + 0x40);
484 width_remaining -= 2;
171191ba 485 num_printed += 2;
961c521f 486 }
7bfd842d
NC		 487 else if (ISPRINT (c))
488 {
489 putchar (c);
490 width_remaining --;
491 num_printed ++;
492 }
961c521f
NC		 493 else
494 {
3bfcb652
NC		 495#ifdef HAVE_MBSTATE_T
496 wchar_t w;
497#endif
7bfd842d
NC		 498 /* Let printf do the hard work of displaying multibyte characters. */
499 printf ("%.1s", symbol - 1);
500 width_remaining --;
501 num_printed ++;
502
3bfcb652 503#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 504 /* Try to find out how many bytes made up the character that was
505 just printed. Advance the symbol pointer past the bytes that
506 were displayed. */
507 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 508#else
509 n = 1;
510#endif
7bfd842d
NC		 511 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
512 symbol += (n - 1);
961c521f 513 }
961c521f 514 }
171191ba 515
7bfd842d 516 if (extra_padding && num_printed < width)
171191ba
NC		 517 {
518 /* Fill in the remaining spaces. */
7bfd842d
NC		 519 printf ("%-*s", width - num_printed, " ");
520 num_printed = width;
171191ba
NC		 521 }
522
523 return num_printed;
31104126
NC		 524}
525
74e1a04b
NC		 526/* Returns a pointer to a static buffer containing a printable version of
527 the given section's name. Like print_symbol, except that it does not try
528 to print multibyte characters, it just interprets them as hex values. */
529
530static const char *
531printable_section_name (Elf_Internal_Shdr * sec)
532{
533#define MAX_PRINT_SEC_NAME_LEN 128
534 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
535 const char * name = SECTION_NAME (sec);
536 char * buf = sec_name_buf;
537 char c;
538 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
539
540 while ((c = * name ++) != 0)
541 {
542 if (ISCNTRL (c))
543 {
544 if (remaining < 2)
545 break;
546
547 * buf ++ = '^';
548 * buf ++ = c + 0x40;
549 remaining -= 2;
550 }
551 else if (ISPRINT (c))
552 {
553 * buf ++ = c;
554 remaining -= 1;
555 }
556 else
557 {
558 static char hex[17] = "0123456789ABCDEF";
559
560 if (remaining < 4)
561 break;
562 * buf ++ = '<';
563 * buf ++ = hex[(c & 0xf0) >> 4];
564 * buf ++ = hex[c & 0x0f];
565 * buf ++ = '>';
566 remaining -= 4;
567 }
568
569 if (remaining == 0)
570 break;
571 }
572
573 * buf = 0;
574 return sec_name_buf;
575}
576
577static const char *
578printable_section_name_from_index (unsigned long ndx)
579{
580 if (ndx >= elf_header.e_shnum)
581 return _("<corrupt>");
582
583 return printable_section_name (section_headers + ndx);
584}
585
89fac5e3
RS		 586/* Return a pointer to section NAME, or NULL if no such section exists. */
587
588static Elf_Internal_Shdr *
2cf0635d 589find_section (const char * name)
89fac5e3
RS		 590{
591 unsigned int i;
592
593 for (i = 0; i < elf_header.e_shnum; i++)
594 if (streq (SECTION_NAME (section_headers + i), name))
595 return section_headers + i;
596
597 return NULL;
598}
599
0b6ae522
DJ		 600/* Return a pointer to a section containing ADDR, or NULL if no such
601 section exists. */
602
603static Elf_Internal_Shdr *
604find_section_by_address (bfd_vma addr)
605{
606 unsigned int i;
607
608 for (i = 0; i < elf_header.e_shnum; i++)
609 {
610 Elf_Internal_Shdr *sec = section_headers + i;
611 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
612 return sec;
613 }
614
615 return NULL;
616}
617
071436c6
NC		 618static Elf_Internal_Shdr *
619find_section_by_type (unsigned int type)
620{
621 unsigned int i;
622
623 for (i = 0; i < elf_header.e_shnum; i++)
624 {
625 Elf_Internal_Shdr *sec = section_headers + i;
626 if (sec->sh_type == type)
627 return sec;
628 }
629
630 return NULL;
631}
632
657d0d47
CC		 633/* Return a pointer to section NAME, or NULL if no such section exists,
634 restricted to the list of sections given in SET. */
635
636static Elf_Internal_Shdr *
637find_section_in_set (const char * name, unsigned int * set)
638{
639 unsigned int i;
640
641 if (set != NULL)
642 {
643 while ((i = *set++) > 0)
644 if (streq (SECTION_NAME (section_headers + i), name))
645 return section_headers + i;
646 }
647
648 return find_section (name);
649}
650
0b6ae522
DJ		 651/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
652 bytes read. */
653
f6f0e17b
NC		 654static inline unsigned long
655read_uleb128 (unsigned char *data,
656 unsigned int *length_return,
657 const unsigned char * const end)
0b6ae522 658{
f6f0e17b 659 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 660}
661
28f997cf
TG		 662/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
663 This OS has so many departures from the ELF standard that we test it at
664 many places. */
665
666static inline int
667is_ia64_vms (void)
668{
669 return elf_header.e_machine == EM_IA_64
670 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
671}
672
bcedfee6 673/* Guess the relocation size commonly used by the specific machines. */
252b5132 674
252b5132 675static int
2dc4cec1 676guess_is_rela (unsigned int e_machine)
252b5132 677{
9c19a809 678 switch (e_machine)
252b5132
RH		 679 {
680 /* Targets that use REL relocations. */
252b5132
RH		 681 case EM_386:
682 case EM_486:
63fcb9e9 683 case EM_960:
e9f53129 684 case EM_ARM:
2b0337b0 685 case EM_D10V:
252b5132 686 case EM_CYGNUS_D10V:
e9f53129 687 case EM_DLX:
252b5132 688 case EM_MIPS:
4fe85591 689 case EM_MIPS_RS3_LE:
e9f53129 690 case EM_CYGNUS_M32R:
1c0d3aa6 691 case EM_SCORE:
f6c1a2d5 692 case EM_XGATE:
9c19a809 693 return FALSE;
103f02d3 694
252b5132
RH		 695 /* Targets that use RELA relocations. */
696 case EM_68K:
e9f53129 697 case EM_860:
a06ea964 698 case EM_AARCH64:
cfb8c092 699 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 700 case EM_ALPHA:
701 case EM_ALTERA_NIOS2:
702 case EM_AVR:
703 case EM_AVR_OLD:
704 case EM_BLACKFIN:
60bca95a 705 case EM_CR16:
e9f53129
AM		 706 case EM_CRIS:
707 case EM_CRX:
2b0337b0 708 case EM_D30V:
252b5132 709 case EM_CYGNUS_D30V:
2b0337b0 710 case EM_FR30:
252b5132 711 case EM_CYGNUS_FR30:
5c70f934 712 case EM_CYGNUS_FRV:
e9f53129
AM		 713 case EM_H8S:
714 case EM_H8_300:
715 case EM_H8_300H:
800eeca4 716 case EM_IA_64:
1e4cf259
NC		 717 case EM_IP2K:
718 case EM_IP2K_OLD:
3b36097d 719 case EM_IQ2000:
84e94c90 720 case EM_LATTICEMICO32:
ff7eeb89 721 case EM_M32C_OLD:
49f58d10 722 case EM_M32C:
e9f53129
AM		 723 case EM_M32R:
724 case EM_MCORE:
15ab5209 725 case EM_CYGNUS_MEP:
a3c62988 726 case EM_METAG:
e9f53129
AM		 727 case EM_MMIX:
728 case EM_MN10200:
729 case EM_CYGNUS_MN10200:
730 case EM_MN10300:
731 case EM_CYGNUS_MN10300:
5506d11a 732 case EM_MOXIE:
e9f53129
AM		 733 case EM_MSP430:
734 case EM_MSP430_OLD:
d031aafb 735 case EM_MT:
35c08157 736 case EM_NDS32:
64fd6348 737 case EM_NIOS32:
73589c9d 738 case EM_OR1K:
e9f53129
AM		 739 case EM_PPC64:
740 case EM_PPC:
99c513f6 741 case EM_RL78:
c7927a3c 742 case EM_RX:
e9f53129
AM		 743 case EM_S390:
744 case EM_S390_OLD:
745 case EM_SH:
746 case EM_SPARC:
747 case EM_SPARC32PLUS:
748 case EM_SPARCV9:
749 case EM_SPU:
40b36596 750 case EM_TI_C6000:
aa137e4d
NC		 751 case EM_TILEGX:
752 case EM_TILEPRO:
708e2187 753 case EM_V800:
e9f53129
AM		 754 case EM_V850:
755 case EM_CYGNUS_V850:
756 case EM_VAX:
757 case EM_X86_64:
8a9036a4 758 case EM_L1OM:
7a9068fe 759 case EM_K1OM:
e9f53129
AM		 760 case EM_XSTORMY16:
761 case EM_XTENSA:
762 case EM_XTENSA_OLD:
7ba29e2a
NC		 763 case EM_MICROBLAZE:
764 case EM_MICROBLAZE_OLD:
9c19a809 765 return TRUE;
103f02d3 766
e9f53129
AM		 767 case EM_68HC05:
768 case EM_68HC08:
769 case EM_68HC11:
770 case EM_68HC16:
771 case EM_FX66:
772 case EM_ME16:
d1133906 773 case EM_MMA:
d1133906
NC		 774 case EM_NCPU:
775 case EM_NDR1:
e9f53129 776 case EM_PCP:
d1133906 777 case EM_ST100:
e9f53129 778 case EM_ST19:
d1133906 779 case EM_ST7:
e9f53129
AM		 780 case EM_ST9PLUS:
781 case EM_STARCORE:
d1133906 782 case EM_SVX:
e9f53129 783 case EM_TINYJ:
9c19a809
NC		 784 default:
785 warn (_("Don't know about relocations on this machine architecture\n"));
786 return FALSE;
787 }
788}
252b5132 789
9c19a809 790static int
2cf0635d 791slurp_rela_relocs (FILE * file,
d3ba0551
AM		 792 unsigned long rel_offset,
793 unsigned long rel_size,
2cf0635d
NC		 794 Elf_Internal_Rela ** relasp,
795 unsigned long * nrelasp)
9c19a809 796{
2cf0635d 797 Elf_Internal_Rela * relas;
8b73c356 798 size_t nrelas;
4d6ed7c8 799 unsigned int i;
252b5132 800
4d6ed7c8
NC		 801 if (is_32bit_elf)
802 {
2cf0635d 803 Elf32_External_Rela * erelas;
103f02d3 804
3f5e193b 805 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 806 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 807 if (!erelas)
808 return 0;
252b5132 809
4d6ed7c8 810 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 811
3f5e193b
NC		 812 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
813 sizeof (Elf_Internal_Rela));
103f02d3 814
4d6ed7c8
NC		 815 if (relas == NULL)
816 {
c256ffe7 817 free (erelas);
591a748a 818 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 819 return 0;
820 }
103f02d3 821
4d6ed7c8
NC		 822 for (i = 0; i < nrelas; i++)
823 {
824 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
825 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 826 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 827 }
103f02d3 828
4d6ed7c8
NC		 829 free (erelas);
830 }
831 else
832 {
2cf0635d 833 Elf64_External_Rela * erelas;
103f02d3 834
3f5e193b 835 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 836 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 837 if (!erelas)
838 return 0;
4d6ed7c8
NC		 839
840 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 841
3f5e193b
NC		 842 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
843 sizeof (Elf_Internal_Rela));
103f02d3 844
4d6ed7c8
NC		 845 if (relas == NULL)
846 {
c256ffe7 847 free (erelas);
591a748a 848 error (_("out of memory parsing relocs\n"));
4d6ed7c8 849 return 0;
9c19a809 850 }
4d6ed7c8
NC		 851
852 for (i = 0; i < nrelas; i++)
9c19a809 853 {
66543521
AM		 854 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
855 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 856 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 857
858 /* The #ifdef BFD64 below is to prevent a compile time
859 warning. We know that if we do not have a 64 bit data
860 type that we will never execute this code anyway. */
861#ifdef BFD64
862 if (elf_header.e_machine == EM_MIPS
863 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
864 {
865 /* In little-endian objects, r_info isn't really a
866 64-bit little-endian value: it has a 32-bit
867 little-endian symbol index followed by four
868 individual byte fields. Reorder INFO
869 accordingly. */
91d6fa6a
NC		 870 bfd_vma inf = relas[i].r_info;
871 inf = (((inf & 0xffffffff) << 32)
872 | ((inf >> 56) & 0xff)
873 | ((inf >> 40) & 0xff00)
874 | ((inf >> 24) & 0xff0000)
875 | ((inf >> 8) & 0xff000000));
876 relas[i].r_info = inf;
861fb55a
DJ		 877 }
878#endif /* BFD64 */
4d6ed7c8 879 }
103f02d3 880
4d6ed7c8
NC		 881 free (erelas);
882 }
883 *relasp = relas;
884 *nrelasp = nrelas;
885 return 1;
886}
103f02d3 887
4d6ed7c8 888static int
2cf0635d 889slurp_rel_relocs (FILE * file,
d3ba0551
AM		 890 unsigned long rel_offset,
891 unsigned long rel_size,
2cf0635d
NC		 892 Elf_Internal_Rela ** relsp,
893 unsigned long * nrelsp)
4d6ed7c8 894{
2cf0635d 895 Elf_Internal_Rela * rels;
8b73c356 896 size_t nrels;
4d6ed7c8 897 unsigned int i;
103f02d3 898
4d6ed7c8
NC		 899 if (is_32bit_elf)
900 {
2cf0635d 901 Elf32_External_Rel * erels;
103f02d3 902
3f5e193b 903 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 904 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 905 if (!erels)
906 return 0;
103f02d3 907
4d6ed7c8 908 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 909
3f5e193b 910 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 911
4d6ed7c8
NC		 912 if (rels == NULL)
913 {
c256ffe7 914 free (erels);
591a748a 915 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 916 return 0;
917 }
918
919 for (i = 0; i < nrels; i++)
920 {
921 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
922 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 923 rels[i].r_addend = 0;
9ea033b2 924 }
4d6ed7c8
NC		 925
926 free (erels);
9c19a809
NC		 927 }
928 else
929 {
2cf0635d 930 Elf64_External_Rel * erels;
9ea033b2 931
3f5e193b 932 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 933 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 934 if (!erels)
935 return 0;
103f02d3 936
4d6ed7c8 937 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 938
3f5e193b 939 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 940
4d6ed7c8 941 if (rels == NULL)
9c19a809 942 {
c256ffe7 943 free (erels);
591a748a 944 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 945 return 0;
946 }
103f02d3 947
4d6ed7c8
NC		 948 for (i = 0; i < nrels; i++)
949 {
66543521
AM		 950 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
951 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 952 rels[i].r_addend = 0;
861fb55a
DJ		 953
954 /* The #ifdef BFD64 below is to prevent a compile time
955 warning. We know that if we do not have a 64 bit data
956 type that we will never execute this code anyway. */
957#ifdef BFD64
958 if (elf_header.e_machine == EM_MIPS
959 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
960 {
961 /* In little-endian objects, r_info isn't really a
962 64-bit little-endian value: it has a 32-bit
963 little-endian symbol index followed by four
964 individual byte fields. Reorder INFO
965 accordingly. */
91d6fa6a
NC		 966 bfd_vma inf = rels[i].r_info;
967 inf = (((inf & 0xffffffff) << 32)
968 | ((inf >> 56) & 0xff)
969 | ((inf >> 40) & 0xff00)
970 | ((inf >> 24) & 0xff0000)
971 | ((inf >> 8) & 0xff000000));
972 rels[i].r_info = inf;
861fb55a
DJ		 973 }
974#endif /* BFD64 */
4d6ed7c8 975 }
103f02d3 976
4d6ed7c8
NC		 977 free (erels);
978 }
979 *relsp = rels;
980 *nrelsp = nrels;
981 return 1;
982}
103f02d3 983
aca88567
NC		 984/* Returns the reloc type extracted from the reloc info field. */
985
986static unsigned int
987get_reloc_type (bfd_vma reloc_info)
988{
989 if (is_32bit_elf)
990 return ELF32_R_TYPE (reloc_info);
991
992 switch (elf_header.e_machine)
993 {
994 case EM_MIPS:
995 /* Note: We assume that reloc_info has already been adjusted for us. */
996 return ELF64_MIPS_R_TYPE (reloc_info);
997
998 case EM_SPARCV9:
999 return ELF64_R_TYPE_ID (reloc_info);
1000
1001 default:
1002 return ELF64_R_TYPE (reloc_info);
1003 }
1004}
1005
1006/* Return the symbol index extracted from the reloc info field. */
1007
1008static bfd_vma
1009get_reloc_symindex (bfd_vma reloc_info)
1010{
1011 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1012}
1013
13761a11
NC		 1014static inline bfd_boolean
1015uses_msp430x_relocs (void)
1016{
1017 return
1018 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1019 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1020 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1021 /* TI compiler uses ELFOSABI_NONE. */
1022 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1023}
1024
d3ba0551
AM		 1025/* Display the contents of the relocation data found at the specified
1026 offset. */
ee42cf8c 1027
41e92641 1028static void
2cf0635d 1029dump_relocations (FILE * file,
d3ba0551
AM		 1030 unsigned long rel_offset,
1031 unsigned long rel_size,
2cf0635d 1032 Elf_Internal_Sym * symtab,
d3ba0551 1033 unsigned long nsyms,
2cf0635d 1034 char * strtab,
d79b3d50 1035 unsigned long strtablen,
bb4d2ac2
L		 1036 int is_rela,
1037 int is_dynsym)
4d6ed7c8 1038{
b34976b6 1039 unsigned int i;
2cf0635d 1040 Elf_Internal_Rela * rels;
103f02d3 1041
4d6ed7c8
NC		 1042 if (is_rela == UNKNOWN)
1043 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1044
4d6ed7c8
NC		 1045 if (is_rela)
1046 {
c8286bd1 1047 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1048 return;
4d6ed7c8
NC		 1049 }
1050 else
1051 {
1052 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1053 return;
252b5132
RH		 1054 }
1055
410f7a12
L		 1056 if (is_32bit_elf)
1057 {
1058 if (is_rela)
2c71103e
NC		 1059 {
1060 if (do_wide)
1061 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1062 else
1063 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1064 }
410f7a12 1065 else
2c71103e
NC		 1066 {
1067 if (do_wide)
1068 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1069 else
1070 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1071 }
410f7a12 1072 }
252b5132 1073 else
410f7a12
L		 1074 {
1075 if (is_rela)
2c71103e
NC		 1076 {
1077 if (do_wide)
8beeaeb7 1078 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1079 else
1080 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1081 }
410f7a12 1082 else
2c71103e
NC		 1083 {
1084 if (do_wide)
8beeaeb7 1085 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1086 else
1087 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1088 }
410f7a12 1089 }
252b5132
RH		 1090
1091 for (i = 0; i < rel_size; i++)
1092 {
2cf0635d 1093 const char * rtype;
b34976b6 1094 bfd_vma offset;
91d6fa6a 1095 bfd_vma inf;
b34976b6
AM		 1096 bfd_vma symtab_index;
1097 bfd_vma type;
103f02d3 1098
b34976b6 1099 offset = rels[i].r_offset;
91d6fa6a 1100 inf = rels[i].r_info;
103f02d3 1101
91d6fa6a
NC		 1102 type = get_reloc_type (inf);
1103 symtab_index = get_reloc_symindex (inf);
252b5132 1104
410f7a12
L		 1105 if (is_32bit_elf)
1106 {
39dbeff8
AM		 1107 printf ("%8.8lx %8.8lx ",
1108 (unsigned long) offset & 0xffffffff,
91d6fa6a 1109 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1110 }
1111 else
1112 {
39dbeff8
AM		 1113#if BFD_HOST_64BIT_LONG
1114 printf (do_wide
1115 ? "%16.16lx %16.16lx "
1116 : "%12.12lx %12.12lx ",
91d6fa6a 1117 offset, inf);
39dbeff8 1118#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1119#ifndef __MSVCRT__
39dbeff8
AM		 1120 printf (do_wide
1121 ? "%16.16llx %16.16llx "
1122 : "%12.12llx %12.12llx ",
91d6fa6a 1123 offset, inf);
6e3d6dc1
NC		 1124#else
1125 printf (do_wide
1126 ? "%16.16I64x %16.16I64x "
1127 : "%12.12I64x %12.12I64x ",
91d6fa6a 1128 offset, inf);
6e3d6dc1 1129#endif
39dbeff8 1130#else
2c71103e
NC		 1131 printf (do_wide
1132 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1133 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1134 _bfd_int64_high (offset),
1135 _bfd_int64_low (offset),
91d6fa6a
NC		 1136 _bfd_int64_high (inf),
1137 _bfd_int64_low (inf));
9ea033b2 1138#endif
410f7a12 1139 }
103f02d3 1140
252b5132
RH		 1141 switch (elf_header.e_machine)
1142 {
1143 default:
1144 rtype = NULL;
1145 break;
1146
a06ea964
NC		 1147 case EM_AARCH64:
1148 rtype = elf_aarch64_reloc_type (type);
1149 break;
1150
2b0337b0 1151 case EM_M32R:
252b5132 1152 case EM_CYGNUS_M32R:
9ea033b2 1153 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1154 break;
1155
1156 case EM_386:
1157 case EM_486:
9ea033b2 1158 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1159 break;
1160
ba2685cc
AM		 1161 case EM_68HC11:
1162 case EM_68HC12:
1163 rtype = elf_m68hc11_reloc_type (type);
1164 break;
75751cd9 1165
252b5132 1166 case EM_68K:
9ea033b2 1167 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1168 break;
1169
63fcb9e9 1170 case EM_960:
9ea033b2 1171 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1172 break;
1173
adde6300 1174 case EM_AVR:
2b0337b0 1175 case EM_AVR_OLD:
adde6300
AM		 1176 rtype = elf_avr_reloc_type (type);
1177 break;
1178
9ea033b2
NC		 1179 case EM_OLD_SPARCV9:
1180 case EM_SPARC32PLUS:
1181 case EM_SPARCV9:
252b5132 1182 case EM_SPARC:
9ea033b2 1183 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1184 break;
1185
e9f53129
AM		 1186 case EM_SPU:
1187 rtype = elf_spu_reloc_type (type);
1188 break;
1189
708e2187
NC		 1190 case EM_V800:
1191 rtype = v800_reloc_type (type);
1192 break;
2b0337b0 1193 case EM_V850:
252b5132 1194 case EM_CYGNUS_V850:
9ea033b2 1195 rtype = v850_reloc_type (type);
252b5132
RH		 1196 break;
1197
2b0337b0 1198 case EM_D10V:
252b5132 1199 case EM_CYGNUS_D10V:
9ea033b2 1200 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1201 break;
1202
2b0337b0 1203 case EM_D30V:
252b5132 1204 case EM_CYGNUS_D30V:
9ea033b2 1205 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1206 break;
1207
d172d4ba
NC		 1208 case EM_DLX:
1209 rtype = elf_dlx_reloc_type (type);
1210 break;
1211
252b5132 1212 case EM_SH:
9ea033b2 1213 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1214 break;
1215
2b0337b0 1216 case EM_MN10300:
252b5132 1217 case EM_CYGNUS_MN10300:
9ea033b2 1218 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1219 break;
1220
2b0337b0 1221 case EM_MN10200:
252b5132 1222 case EM_CYGNUS_MN10200:
9ea033b2 1223 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1224 break;
1225
2b0337b0 1226 case EM_FR30:
252b5132 1227 case EM_CYGNUS_FR30:
9ea033b2 1228 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1229 break;
1230
ba2685cc
AM		 1231 case EM_CYGNUS_FRV:
1232 rtype = elf_frv_reloc_type (type);
1233 break;
5c70f934 1234
252b5132 1235 case EM_MCORE:
9ea033b2 1236 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1237 break;
1238
3c3bdf30
NC		 1239 case EM_MMIX:
1240 rtype = elf_mmix_reloc_type (type);
1241 break;
1242
5506d11a
AM		 1243 case EM_MOXIE:
1244 rtype = elf_moxie_reloc_type (type);
1245 break;
1246
2469cfa2 1247 case EM_MSP430:
13761a11
NC		 1248 if (uses_msp430x_relocs ())
1249 {
1250 rtype = elf_msp430x_reloc_type (type);
1251 break;
1252 }
2469cfa2
NC		 1253 case EM_MSP430_OLD:
1254 rtype = elf_msp430_reloc_type (type);
1255 break;
1256
35c08157
KLC		 1257 case EM_NDS32:
1258 rtype = elf_nds32_reloc_type (type);
1259 break;
1260
252b5132 1261 case EM_PPC:
9ea033b2 1262 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1263 break;
1264
c833c019
AM		 1265 case EM_PPC64:
1266 rtype = elf_ppc64_reloc_type (type);
1267 break;
1268
252b5132 1269 case EM_MIPS:
4fe85591 1270 case EM_MIPS_RS3_LE:
9ea033b2 1271 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1272 break;
1273
1274 case EM_ALPHA:
9ea033b2 1275 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1276 break;
1277
1278 case EM_ARM:
9ea033b2 1279 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1280 break;
1281
584da044 1282 case EM_ARC:
9ea033b2 1283 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1284 break;
1285
1286 case EM_PARISC:
69e617ca 1287 rtype = elf_hppa_reloc_type (type);
252b5132 1288 break;
7d466069 1289
b8720f9d
JL		 1290 case EM_H8_300:
1291 case EM_H8_300H:
1292 case EM_H8S:
1293 rtype = elf_h8_reloc_type (type);
1294 break;
1295
73589c9d
CS		 1296 case EM_OR1K:
1297 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1298 break;
1299
7d466069 1300 case EM_PJ:
2b0337b0 1301 case EM_PJ_OLD:
7d466069
ILT		 1302 rtype = elf_pj_reloc_type (type);
1303 break;
800eeca4
JW		 1304 case EM_IA_64:
1305 rtype = elf_ia64_reloc_type (type);
1306 break;
1b61cf92
HPN		 1307
1308 case EM_CRIS:
1309 rtype = elf_cris_reloc_type (type);
1310 break;
535c37ff
JE		 1311
1312 case EM_860:
1313 rtype = elf_i860_reloc_type (type);
1314 break;
bcedfee6
NC		 1315
1316 case EM_X86_64:
8a9036a4 1317 case EM_L1OM:
7a9068fe 1318 case EM_K1OM:
bcedfee6
NC		 1319 rtype = elf_x86_64_reloc_type (type);
1320 break;
a85d7ed0 1321
35b1837e
AM		 1322 case EM_S370:
1323 rtype = i370_reloc_type (type);
1324 break;
1325
53c7db4b
KH		 1326 case EM_S390_OLD:
1327 case EM_S390:
1328 rtype = elf_s390_reloc_type (type);
1329 break;
93fbbb04 1330
1c0d3aa6
NC		 1331 case EM_SCORE:
1332 rtype = elf_score_reloc_type (type);
1333 break;
1334
93fbbb04
GK		 1335 case EM_XSTORMY16:
1336 rtype = elf_xstormy16_reloc_type (type);
1337 break;
179d3252 1338
1fe1f39c
NC		 1339 case EM_CRX:
1340 rtype = elf_crx_reloc_type (type);
1341 break;
1342
179d3252
JT		 1343 case EM_VAX:
1344 rtype = elf_vax_reloc_type (type);
1345 break;
1e4cf259 1346
cfb8c092
NC		 1347 case EM_ADAPTEVA_EPIPHANY:
1348 rtype = elf_epiphany_reloc_type (type);
1349 break;
1350
1e4cf259
NC		 1351 case EM_IP2K:
1352 case EM_IP2K_OLD:
1353 rtype = elf_ip2k_reloc_type (type);
1354 break;
3b36097d
SC		 1355
1356 case EM_IQ2000:
1357 rtype = elf_iq2000_reloc_type (type);
1358 break;
88da6820
NC		 1359
1360 case EM_XTENSA_OLD:
1361 case EM_XTENSA:
1362 rtype = elf_xtensa_reloc_type (type);
1363 break;
a34e3ecb 1364
84e94c90
NC		 1365 case EM_LATTICEMICO32:
1366 rtype = elf_lm32_reloc_type (type);
1367 break;
1368
ff7eeb89 1369 case EM_M32C_OLD:
49f58d10
JB		 1370 case EM_M32C:
1371 rtype = elf_m32c_reloc_type (type);
1372 break;
1373
d031aafb
NS		 1374 case EM_MT:
1375 rtype = elf_mt_reloc_type (type);
a34e3ecb 1376 break;
1d65ded4
CM		 1377
1378 case EM_BLACKFIN:
1379 rtype = elf_bfin_reloc_type (type);
1380 break;
15ab5209
DB		 1381
1382 case EM_CYGNUS_MEP:
1383 rtype = elf_mep_reloc_type (type);
1384 break;
60bca95a
NC		 1385
1386 case EM_CR16:
1387 rtype = elf_cr16_reloc_type (type);
1388 break;
dd24e3da 1389
7ba29e2a
NC		 1390 case EM_MICROBLAZE:
1391 case EM_MICROBLAZE_OLD:
1392 rtype = elf_microblaze_reloc_type (type);
1393 break;
c7927a3c 1394
99c513f6
DD		 1395 case EM_RL78:
1396 rtype = elf_rl78_reloc_type (type);
1397 break;
1398
c7927a3c
NC		 1399 case EM_RX:
1400 rtype = elf_rx_reloc_type (type);
1401 break;
c29aca4a 1402
a3c62988
NC		 1403 case EM_METAG:
1404 rtype = elf_metag_reloc_type (type);
1405 break;
1406
c29aca4a
NC		 1407 case EM_XC16X:
1408 case EM_C166:
1409 rtype = elf_xc16x_reloc_type (type);
1410 break;
40b36596
JM		 1411
1412 case EM_TI_C6000:
1413 rtype = elf_tic6x_reloc_type (type);
1414 break;
aa137e4d
NC		 1415
1416 case EM_TILEGX:
1417 rtype = elf_tilegx_reloc_type (type);
1418 break;
1419
1420 case EM_TILEPRO:
1421 rtype = elf_tilepro_reloc_type (type);
1422 break;
f6c1a2d5
NC		 1423
1424 case EM_XGATE:
1425 rtype = elf_xgate_reloc_type (type);
1426 break;
36591ba1
SL		 1427
1428 case EM_ALTERA_NIOS2:
1429 rtype = elf_nios2_reloc_type (type);
1430 break;
252b5132
RH		 1431 }
1432
1433 if (rtype == NULL)
39dbeff8 1434 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1435 else
8beeaeb7 1436 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1437
7ace3541 1438 if (elf_header.e_machine == EM_ALPHA
157c2599 1439 && rtype != NULL
7ace3541
RH		 1440 && streq (rtype, "R_ALPHA_LITUSE")
1441 && is_rela)
1442 {
1443 switch (rels[i].r_addend)
1444 {
1445 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1446 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1447 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1448 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1449 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1450 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1451 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1452 default: rtype = NULL;
1453 }
1454 if (rtype)
1455 printf (" (%s)", rtype);
1456 else
1457 {
1458 putchar (' ');
1459 printf (_("<unknown addend: %lx>"),
1460 (unsigned long) rels[i].r_addend);
1461 }
1462 }
1463 else if (symtab_index)
252b5132 1464 {
af3fc3bc 1465 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1466 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1467 else
19936277 1468 {
2cf0635d 1469 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1470 const char * version_string;
1471 enum versioned_symbol_info sym_info;
1472 unsigned short vna_other;
19936277 1473
af3fc3bc 1474 psym = symtab + symtab_index;
103f02d3 1475
bb4d2ac2
L		 1476 version_string
1477 = get_symbol_version_string (file, is_dynsym,
1478 strtab, strtablen,
1479 symtab_index,
1480 psym,
1481 &sym_info,
1482 &vna_other);
1483
af3fc3bc 1484 printf (" ");
171191ba 1485
d8045f23
NC		 1486 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1487 {
1488 const char * name;
1489 unsigned int len;
1490 unsigned int width = is_32bit_elf ? 8 : 14;
1491
1492 /* Relocations against GNU_IFUNC symbols do not use the value
1493 of the symbol as the address to relocate against. Instead
1494 they invoke the function named by the symbol and use its
1495 result as the address for relocation.
1496
1497 To indicate this to the user, do not display the value of
1498 the symbol in the "Symbols's Value" field. Instead show
1499 its name followed by () as a hint that the symbol is
1500 invoked. */
1501
1502 if (strtab == NULL
1503 || psym->st_name == 0
1504 || psym->st_name >= strtablen)
1505 name = "??";
1506 else
1507 name = strtab + psym->st_name;
1508
1509 len = print_symbol (width, name);
bb4d2ac2
L		 1510 if (version_string)
1511 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1512 version_string);
d8045f23
NC		 1513 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1514 }
1515 else
1516 {
1517 print_vma (psym->st_value, LONG_HEX);
171191ba 1518
d8045f23
NC		 1519 printf (is_32bit_elf ? " " : " ");
1520 }
103f02d3 1521
af3fc3bc 1522 if (psym->st_name == 0)
f1ef08cb 1523 {
2cf0635d 1524 const char * sec_name = "<null>";
f1ef08cb
AM		 1525 char name_buf[40];
1526
1527 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1528 {
4fbb74a6 1529 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1530 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1531 else if (psym->st_shndx == SHN_ABS)
1532 sec_name = "ABS";
1533 else if (psym->st_shndx == SHN_COMMON)
1534 sec_name = "COMMON";
ac145307
BS		 1535 else if ((elf_header.e_machine == EM_MIPS
1536 && psym->st_shndx == SHN_MIPS_SCOMMON)
1537 || (elf_header.e_machine == EM_TI_C6000
1538 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1539 sec_name = "SCOMMON";
1540 else if (elf_header.e_machine == EM_MIPS
1541 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1542 sec_name = "SUNDEF";
8a9036a4 1543 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1544 || elf_header.e_machine == EM_L1OM
1545 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1546 && psym->st_shndx == SHN_X86_64_LCOMMON)
1547 sec_name = "LARGE_COMMON";
9ce701e2
L		 1548 else if (elf_header.e_machine == EM_IA_64
1549 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1550 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1551 sec_name = "ANSI_COM";
28f997cf 1552 else if (is_ia64_vms ()
148b93f2
NC		 1553 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1554 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1555 else
1556 {
1557 sprintf (name_buf, "<section 0x%x>",
1558 (unsigned int) psym->st_shndx);
1559 sec_name = name_buf;
1560 }
1561 }
1562 print_symbol (22, sec_name);
1563 }
af3fc3bc 1564 else if (strtab == NULL)
d79b3d50 1565 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1566 else if (psym->st_name >= strtablen)
d79b3d50 1567 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1568 else
bb4d2ac2
L		 1569 {
1570 print_symbol (22, strtab + psym->st_name);
1571 if (version_string)
1572 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1573 version_string);
1574 }
103f02d3 1575
af3fc3bc 1576 if (is_rela)
171191ba 1577 {
598aaa76 1578 bfd_signed_vma off = rels[i].r_addend;
171191ba 1579
91d6fa6a 1580 if (off < 0)
598aaa76 1581 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1582 else
598aaa76 1583 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1584 }
19936277 1585 }
252b5132 1586 }
1b228002 1587 else if (is_rela)
f7a99963 1588 {
e04d7088
L		 1589 bfd_signed_vma off = rels[i].r_addend;
1590
1591 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1592 if (off < 0)
1593 printf ("-%" BFD_VMA_FMT "x", - off);
1594 else
1595 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1596 }
252b5132 1597
157c2599
NC		 1598 if (elf_header.e_machine == EM_SPARCV9
1599 && rtype != NULL
1600 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1601 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1602
252b5132 1603 putchar ('\n');
2c71103e 1604
aca88567 1605#ifdef BFD64
53c7db4b 1606 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1607 {
91d6fa6a
NC		 1608 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1609 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1610 const char * rtype2 = elf_mips_reloc_type (type2);
1611 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1612
2c71103e
NC		 1613 printf (" Type2: ");
1614
1615 if (rtype2 == NULL)
39dbeff8
AM		 1616 printf (_("unrecognized: %-7lx"),
1617 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1618 else
1619 printf ("%-17.17s", rtype2);
1620
18bd398b 1621 printf ("\n Type3: ");
2c71103e
NC		 1622
1623 if (rtype3 == NULL)
39dbeff8
AM		 1624 printf (_("unrecognized: %-7lx"),
1625 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1626 else
1627 printf ("%-17.17s", rtype3);
1628
53c7db4b 1629 putchar ('\n');
2c71103e 1630 }
aca88567 1631#endif /* BFD64 */
252b5132
RH		 1632 }
1633
c8286bd1 1634 free (rels);
252b5132
RH		 1635}
1636
1637static const char *
d3ba0551 1638get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1639{
1640 switch (type)
1641 {
1642 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1643 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1644 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1645 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1646 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1647 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1648 case DT_MIPS_MSYM: return "MIPS_MSYM";
1649 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1650 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1651 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1652 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1653 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1654 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1655 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1656 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1657 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1658 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1659 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1660 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1661 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1662 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1663 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1664 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1665 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1666 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1667 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1668 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1669 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1670 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1671 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1672 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1673 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1674 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1675 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1676 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1677 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1678 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1679 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1680 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1681 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1682 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1683 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1684 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1685 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1686 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1687 default:
1688 return NULL;
1689 }
1690}
1691
9a097730 1692static const char *
d3ba0551 1693get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1694{
1695 switch (type)
1696 {
1697 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1698 default:
1699 return NULL;
1700 }
103f02d3
UD		 1701}
1702
7490d522
AM		 1703static const char *
1704get_ppc_dynamic_type (unsigned long type)
1705{
1706 switch (type)
1707 {
a7f2871e 1708 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1709 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1710 default:
1711 return NULL;
1712 }
1713}
1714
f1cb7e17 1715static const char *
d3ba0551 1716get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1717{
1718 switch (type)
1719 {
a7f2871e
AM		 1720 case DT_PPC64_GLINK: return "PPC64_GLINK";
1721 case DT_PPC64_OPD: return "PPC64_OPD";
1722 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1723 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1724 default:
1725 return NULL;
1726 }
1727}
1728
103f02d3 1729static const char *
d3ba0551 1730get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1731{
1732 switch (type)
1733 {
1734 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1735 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1736 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1737 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1738 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1739 case DT_HP_PREINIT: return "HP_PREINIT";
1740 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1741 case DT_HP_NEEDED: return "HP_NEEDED";
1742 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1743 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1744 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1745 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1746 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1747 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1748 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1749 case DT_HP_FILTERED: return "HP_FILTERED";
1750 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1751 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1752 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1753 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1754 case DT_PLT: return "PLT";
1755 case DT_PLT_SIZE: return "PLT_SIZE";
1756 case DT_DLT: return "DLT";
1757 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1758 default:
1759 return NULL;
1760 }
1761}
9a097730 1762
ecc51f48 1763static const char *
d3ba0551 1764get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1765{
1766 switch (type)
1767 {
148b93f2
NC		 1768 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1769 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1770 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1771 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1772 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1773 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1774 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1775 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1776 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1777 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1778 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1779 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1780 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1781 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1782 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1783 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1784 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1785 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1786 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1787 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1788 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1789 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1790 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1791 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1792 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1793 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1794 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1795 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1796 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1797 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1798 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1799 default:
1800 return NULL;
1801 }
1802}
1803
fabcb361
RH		 1804static const char *
1805get_alpha_dynamic_type (unsigned long type)
1806{
1807 switch (type)
1808 {
1809 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1810 default:
1811 return NULL;
1812 }
1813}
1814
1c0d3aa6
NC		 1815static const char *
1816get_score_dynamic_type (unsigned long type)
1817{
1818 switch (type)
1819 {
1820 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1821 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1822 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1823 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1824 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1825 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1826 default:
1827 return NULL;
1828 }
1829}
1830
40b36596
JM		 1831static const char *
1832get_tic6x_dynamic_type (unsigned long type)
1833{
1834 switch (type)
1835 {
1836 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1837 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1838 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1839 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1840 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1841 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1842 default:
1843 return NULL;
1844 }
1845}
1c0d3aa6 1846
36591ba1
SL		 1847static const char *
1848get_nios2_dynamic_type (unsigned long type)
1849{
1850 switch (type)
1851 {
1852 case DT_NIOS2_GP: return "NIOS2_GP";
1853 default:
1854 return NULL;
1855 }
1856}
1857
252b5132 1858static const char *
d3ba0551 1859get_dynamic_type (unsigned long type)
252b5132 1860{
e9e44622 1861 static char buff[64];
252b5132
RH		 1862
1863 switch (type)
1864 {
1865 case DT_NULL: return "NULL";
1866 case DT_NEEDED: return "NEEDED";
1867 case DT_PLTRELSZ: return "PLTRELSZ";
1868 case DT_PLTGOT: return "PLTGOT";
1869 case DT_HASH: return "HASH";
1870 case DT_STRTAB: return "STRTAB";
1871 case DT_SYMTAB: return "SYMTAB";
1872 case DT_RELA: return "RELA";
1873 case DT_RELASZ: return "RELASZ";
1874 case DT_RELAENT: return "RELAENT";
1875 case DT_STRSZ: return "STRSZ";
1876 case DT_SYMENT: return "SYMENT";
1877 case DT_INIT: return "INIT";
1878 case DT_FINI: return "FINI";
1879 case DT_SONAME: return "SONAME";
1880 case DT_RPATH: return "RPATH";
1881 case DT_SYMBOLIC: return "SYMBOLIC";
1882 case DT_REL: return "REL";
1883 case DT_RELSZ: return "RELSZ";
1884 case DT_RELENT: return "RELENT";
1885 case DT_PLTREL: return "PLTREL";
1886 case DT_DEBUG: return "DEBUG";
1887 case DT_TEXTREL: return "TEXTREL";
1888 case DT_JMPREL: return "JMPREL";
1889 case DT_BIND_NOW: return "BIND_NOW";
1890 case DT_INIT_ARRAY: return "INIT_ARRAY";
1891 case DT_FINI_ARRAY: return "FINI_ARRAY";
1892 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1893 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1894 case DT_RUNPATH: return "RUNPATH";
1895 case DT_FLAGS: return "FLAGS";
2d0e6f43 1896
d1133906
NC		 1897 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1898 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1899
05107a46 1900 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1901 case DT_PLTPADSZ: return "PLTPADSZ";
1902 case DT_MOVEENT: return "MOVEENT";
1903 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1904 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1905 case DT_POSFLAG_1: return "POSFLAG_1";
1906 case DT_SYMINSZ: return "SYMINSZ";
1907 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1908
252b5132 1909 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1910 case DT_CONFIG: return "CONFIG";
1911 case DT_DEPAUDIT: return "DEPAUDIT";
1912 case DT_AUDIT: return "AUDIT";
1913 case DT_PLTPAD: return "PLTPAD";
1914 case DT_MOVETAB: return "MOVETAB";
252b5132 1915 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1916
252b5132 1917 case DT_VERSYM: return "VERSYM";
103f02d3 1918
67a4f2b7
AO		 1919 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1920 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1921 case DT_RELACOUNT: return "RELACOUNT";
1922 case DT_RELCOUNT: return "RELCOUNT";
1923 case DT_FLAGS_1: return "FLAGS_1";
1924 case DT_VERDEF: return "VERDEF";
1925 case DT_VERDEFNUM: return "VERDEFNUM";
1926 case DT_VERNEED: return "VERNEED";
1927 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1928
019148e4 1929 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1930 case DT_USED: return "USED";
1931 case DT_FILTER: return "FILTER";
103f02d3 1932
047b2264
JJ		 1933 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1934 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1935 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1936 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1937 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1938 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1939
252b5132
RH		 1940 default:
1941 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1942 {
2cf0635d 1943 const char * result;
103f02d3 1944
252b5132
RH		 1945 switch (elf_header.e_machine)
1946 {
1947 case EM_MIPS:
4fe85591 1948 case EM_MIPS_RS3_LE:
252b5132
RH		 1949 result = get_mips_dynamic_type (type);
1950 break;
9a097730
RH		 1951 case EM_SPARCV9:
1952 result = get_sparc64_dynamic_type (type);
1953 break;
7490d522
AM		 1954 case EM_PPC:
1955 result = get_ppc_dynamic_type (type);
1956 break;
f1cb7e17
AM		 1957 case EM_PPC64:
1958 result = get_ppc64_dynamic_type (type);
1959 break;
ecc51f48
NC		 1960 case EM_IA_64:
1961 result = get_ia64_dynamic_type (type);
1962 break;
fabcb361
RH		 1963 case EM_ALPHA:
1964 result = get_alpha_dynamic_type (type);
1965 break;
1c0d3aa6
NC		 1966 case EM_SCORE:
1967 result = get_score_dynamic_type (type);
1968 break;
40b36596
JM		 1969 case EM_TI_C6000:
1970 result = get_tic6x_dynamic_type (type);
1971 break;
36591ba1
SL		 1972 case EM_ALTERA_NIOS2:
1973 result = get_nios2_dynamic_type (type);
1974 break;
252b5132
RH		 1975 default:
1976 result = NULL;
1977 break;
1978 }
1979
1980 if (result != NULL)
1981 return result;
1982
e9e44622 1983 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1984 }
eec8f817
DA		 1985 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1986 || (elf_header.e_machine == EM_PARISC
1987 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1988 {
2cf0635d 1989 const char * result;
103f02d3
UD		 1990
1991 switch (elf_header.e_machine)
1992 {
1993 case EM_PARISC:
1994 result = get_parisc_dynamic_type (type);
1995 break;
148b93f2
NC		 1996 case EM_IA_64:
1997 result = get_ia64_dynamic_type (type);
1998 break;
103f02d3
UD		 1999 default:
2000 result = NULL;
2001 break;
2002 }
2003
2004 if (result != NULL)
2005 return result;
2006
e9e44622
JJ		 2007 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2008 type);
103f02d3 2009 }
252b5132 2010 else
e9e44622 2011 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2012
252b5132
RH		 2013 return buff;
2014 }
2015}
2016
2017static char *
d3ba0551 2018get_file_type (unsigned e_type)
252b5132 2019{
b34976b6 2020 static char buff[32];
252b5132
RH		 2021
2022 switch (e_type)
2023 {
2024 case ET_NONE: return _("NONE (None)");
2025 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2026 case ET_EXEC: return _("EXEC (Executable file)");
2027 case ET_DYN: return _("DYN (Shared object file)");
2028 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2029
2030 default:
2031 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2032 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2033 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2034 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2035 else
e9e44622 2036 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2037 return buff;
2038 }
2039}
2040
2041static char *
d3ba0551 2042get_machine_name (unsigned e_machine)
252b5132 2043{
b34976b6 2044 static char buff[64]; /* XXX */
252b5132
RH		 2045
2046 switch (e_machine)
2047 {
c45021f2 2048 case EM_NONE: return _("None");
a06ea964 2049 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2050 case EM_M32: return "WE32100";
2051 case EM_SPARC: return "Sparc";
e9f53129 2052 case EM_SPU: return "SPU";
c45021f2
NC		 2053 case EM_386: return "Intel 80386";
2054 case EM_68K: return "MC68000";
2055 case EM_88K: return "MC88000";
2056 case EM_486: return "Intel 80486";
2057 case EM_860: return "Intel 80860";
2058 case EM_MIPS: return "MIPS R3000";
2059 case EM_S370: return "IBM System/370";
7036c0e1 2060 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2061 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2062 case EM_PARISC: return "HPPA";
252b5132 2063 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2064 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2065 case EM_960: return "Intel 90860";
2066 case EM_PPC: return "PowerPC";
285d1771 2067 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 2068 case EM_FR20: return "Fujitsu FR20";
2069 case EM_RH32: return "TRW RH32";
b34976b6 2070 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2071 case EM_ARM: return "ARM";
2072 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2073 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2074 case EM_SPARCV9: return "Sparc v9";
2075 case EM_TRICORE: return "Siemens Tricore";
584da044 2076 case EM_ARC: return "ARC";
c2dcd04e
NC		 2077 case EM_H8_300: return "Renesas H8/300";
2078 case EM_H8_300H: return "Renesas H8/300H";
2079 case EM_H8S: return "Renesas H8S";
2080 case EM_H8_500: return "Renesas H8/500";
30800947 2081 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2082 case EM_MIPS_X: return "Stanford MIPS-X";
2083 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2084 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2085 case EM_CYGNUS_D10V:
2086 case EM_D10V: return "d10v";
2087 case EM_CYGNUS_D30V:
b34976b6 2088 case EM_D30V: return "d30v";
2b0337b0 2089 case EM_CYGNUS_M32R:
26597c86 2090 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2091 case EM_CYGNUS_V850:
708e2187 2092 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2093 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2094 case EM_CYGNUS_MN10300:
2095 case EM_MN10300: return "mn10300";
2096 case EM_CYGNUS_MN10200:
2097 case EM_MN10200: return "mn10200";
5506d11a 2098 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2099 case EM_CYGNUS_FR30:
2100 case EM_FR30: return "Fujitsu FR30";
b34976b6 2101 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2102 case EM_PJ_OLD:
b34976b6 2103 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2104 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2105 case EM_PCP: return "Siemens PCP";
2106 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2107 case EM_NDR1: return "Denso NDR1 microprocesspr";
2108 case EM_STARCORE: return "Motorola Star*Core processor";
2109 case EM_ME16: return "Toyota ME16 processor";
2110 case EM_ST100: return "STMicroelectronics ST100 processor";
2111 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2112 case EM_PDSP: return "Sony DSP processor";
2113 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2114 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2115 case EM_FX66: return "Siemens FX66 microcontroller";
2116 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2117 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2118 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2119 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2120 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2121 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2122 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2123 case EM_SVX: return "Silicon Graphics SVx";
2124 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2125 case EM_VAX: return "Digital VAX";
2b0337b0 2126 case EM_AVR_OLD:
b34976b6 2127 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2128 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2129 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2130 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2131 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2132 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2133 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2134 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2135 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2136 case EM_L1OM: return "Intel L1OM";
7a9068fe 2137 case EM_K1OM: return "Intel K1OM";
b7498e0e 2138 case EM_S390_OLD:
b34976b6 2139 case EM_S390: return "IBM S/390";
1c0d3aa6 2140 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2141 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2142 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2143 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2144 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2145 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2146 case EM_DLX: return "OpenDLX";
1e4cf259 2147 case EM_IP2K_OLD:
b34976b6 2148 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2149 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2150 case EM_XTENSA_OLD:
2151 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2152 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2153 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2154 case EM_NS32K: return "National Semiconductor 32000 series";
2155 case EM_TPC: return "Tenor Network TPC processor";
2156 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2157 case EM_MAX: return "MAX Processor";
2158 case EM_CR: return "National Semiconductor CompactRISC";
2159 case EM_F2MC16: return "Fujitsu F2MC16";
2160 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2161 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2162 case EM_M32C_OLD:
49f58d10 2163 case EM_M32C: return "Renesas M32c";
d031aafb 2164 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2165 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2166 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2167 case EM_SEP: return "Sharp embedded microprocessor";
2168 case EM_ARCA: return "Arca RISC microprocessor";
2169 case EM_UNICORE: return "Unicore";
2170 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2171 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2172 case EM_NIOS32: return "Altera Nios";
2173 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2174 case EM_C166:
d70c5fc7 2175 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2176 case EM_M16C: return "Renesas M16C series microprocessors";
2177 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2178 case EM_CE: return "Freescale Communication Engine RISC core";
2179 case EM_TSK3000: return "Altium TSK3000 core";
2180 case EM_RS08: return "Freescale RS08 embedded processor";
2181 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2182 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2183 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2184 case EM_SE_C17: return "Seiko Epson C17 family";
2185 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2186 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2187 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2188 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2189 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2190 case EM_R32C: return "Renesas R32C series microprocessors";
2191 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2192 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2193 case EM_8051: return "Intel 8051 and variants";
2194 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2195 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2196 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2197 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2198 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2199 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2200 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2201 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2202 case EM_CR16:
f6c1a2d5 2203 case EM_MICROBLAZE:
7ba29e2a 2204 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2205 case EM_RL78: return "Renesas RL78";
c7927a3c 2206 case EM_RX: return "Renesas RX";
a3c62988 2207 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2208 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2209 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2210 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2211 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2212 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2213 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2214 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2215 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2216 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2217 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2218 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2219 default:
35d9dd2f 2220 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2221 return buff;
2222 }
2223}
2224
f3485b74 2225static void
d3ba0551 2226decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2227{
2228 unsigned eabi;
2229 int unknown = 0;
2230
2231 eabi = EF_ARM_EABI_VERSION (e_flags);
2232 e_flags &= ~ EF_ARM_EABIMASK;
2233
2234 /* Handle "generic" ARM flags. */
2235 if (e_flags & EF_ARM_RELEXEC)
2236 {
2237 strcat (buf, ", relocatable executable");
2238 e_flags &= ~ EF_ARM_RELEXEC;
2239 }
76da6bbe 2240
f3485b74
NC		 2241 if (e_flags & EF_ARM_HASENTRY)
2242 {
2243 strcat (buf, ", has entry point");
2244 e_flags &= ~ EF_ARM_HASENTRY;
2245 }
76da6bbe 2246
f3485b74
NC		 2247 /* Now handle EABI specific flags. */
2248 switch (eabi)
2249 {
2250 default:
2c71103e 2251 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2252 if (e_flags)
2253 unknown = 1;
2254 break;
2255
2256 case EF_ARM_EABI_VER1:
a5bcd848 2257 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2258 while (e_flags)
2259 {
2260 unsigned flag;
76da6bbe 2261
f3485b74
NC		 2262 /* Process flags one bit at a time. */
2263 flag = e_flags & - e_flags;
2264 e_flags &= ~ flag;
76da6bbe 2265
f3485b74
NC		 2266 switch (flag)
2267 {
a5bcd848 2268 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2269 strcat (buf, ", sorted symbol tables");
2270 break;
76da6bbe 2271
f3485b74
NC		 2272 default:
2273 unknown = 1;
2274 break;
2275 }
2276 }
2277 break;
76da6bbe 2278
a5bcd848
PB		 2279 case EF_ARM_EABI_VER2:
2280 strcat (buf, ", Version2 EABI");
2281 while (e_flags)
2282 {
2283 unsigned flag;
2284
2285 /* Process flags one bit at a time. */
2286 flag = e_flags & - e_flags;
2287 e_flags &= ~ flag;
2288
2289 switch (flag)
2290 {
2291 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2292 strcat (buf, ", sorted symbol tables");
2293 break;
2294
2295 case EF_ARM_DYNSYMSUSESEGIDX:
2296 strcat (buf, ", dynamic symbols use segment index");
2297 break;
2298
2299 case EF_ARM_MAPSYMSFIRST:
2300 strcat (buf, ", mapping symbols precede others");
2301 break;
2302
2303 default:
2304 unknown = 1;
2305 break;
2306 }
2307 }
2308 break;
2309
d507cf36
PB		 2310 case EF_ARM_EABI_VER3:
2311 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2312 break;
2313
2314 case EF_ARM_EABI_VER4:
2315 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2316 while (e_flags)
2317 {
2318 unsigned flag;
2319
2320 /* Process flags one bit at a time. */
2321 flag = e_flags & - e_flags;
2322 e_flags &= ~ flag;
2323
2324 switch (flag)
2325 {
2326 case EF_ARM_BE8:
2327 strcat (buf, ", BE8");
2328 break;
2329
2330 case EF_ARM_LE8:
2331 strcat (buf, ", LE8");
2332 break;
2333
2334 default:
2335 unknown = 1;
2336 break;
2337 }
2338 break;
2339 }
2340 break;
3a4a14e9
PB		 2341
2342 case EF_ARM_EABI_VER5:
2343 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2344 while (e_flags)
2345 {
2346 unsigned flag;
2347
2348 /* Process flags one bit at a time. */
2349 flag = e_flags & - e_flags;
2350 e_flags &= ~ flag;
2351
2352 switch (flag)
2353 {
2354 case EF_ARM_BE8:
2355 strcat (buf, ", BE8");
2356 break;
2357
2358 case EF_ARM_LE8:
2359 strcat (buf, ", LE8");
2360 break;
2361
3bfcb652
NC		 2362 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2363 strcat (buf, ", soft-float ABI");
2364 break;
2365
2366 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2367 strcat (buf, ", hard-float ABI");
2368 break;
2369
d507cf36
PB		 2370 default:
2371 unknown = 1;
2372 break;
2373 }
2374 }
2375 break;
2376
f3485b74 2377 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2378 strcat (buf, ", GNU EABI");
f3485b74
NC		 2379 while (e_flags)
2380 {
2381 unsigned flag;
76da6bbe 2382
f3485b74
NC		 2383 /* Process flags one bit at a time. */
2384 flag = e_flags & - e_flags;
2385 e_flags &= ~ flag;
76da6bbe 2386
f3485b74
NC		 2387 switch (flag)
2388 {
a5bcd848 2389 case EF_ARM_INTERWORK:
f3485b74
NC		 2390 strcat (buf, ", interworking enabled");
2391 break;
76da6bbe 2392
a5bcd848 2393 case EF_ARM_APCS_26:
f3485b74
NC		 2394 strcat (buf, ", uses APCS/26");
2395 break;
76da6bbe 2396
a5bcd848 2397 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2398 strcat (buf, ", uses APCS/float");
2399 break;
76da6bbe 2400
a5bcd848 2401 case EF_ARM_PIC:
f3485b74
NC		 2402 strcat (buf, ", position independent");
2403 break;
76da6bbe 2404
a5bcd848 2405 case EF_ARM_ALIGN8:
f3485b74
NC		 2406 strcat (buf, ", 8 bit structure alignment");
2407 break;
76da6bbe 2408
a5bcd848 2409 case EF_ARM_NEW_ABI:
f3485b74
NC		 2410 strcat (buf, ", uses new ABI");
2411 break;
76da6bbe 2412
a5bcd848 2413 case EF_ARM_OLD_ABI:
f3485b74
NC		 2414 strcat (buf, ", uses old ABI");
2415 break;
76da6bbe 2416
a5bcd848 2417 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2418 strcat (buf, ", software FP");
2419 break;
76da6bbe 2420
90e01f86
ILT		 2421 case EF_ARM_VFP_FLOAT:
2422 strcat (buf, ", VFP");
2423 break;
2424
fde78edd
NC		 2425 case EF_ARM_MAVERICK_FLOAT:
2426 strcat (buf, ", Maverick FP");
2427 break;
2428
f3485b74
NC		 2429 default:
2430 unknown = 1;
2431 break;
2432 }
2433 }
2434 }
f3485b74
NC		 2435
2436 if (unknown)
2b692964 2437 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2438}
2439
35c08157
KLC		 2440static void
2441decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2442{
2443 unsigned abi;
2444 unsigned arch;
2445 unsigned config;
2446 unsigned version;
2447 int has_fpu = 0;
2448 int r = 0;
2449
2450 static const char *ABI_STRINGS[] =
2451 {
2452 "ABI v0", /* use r5 as return register; only used in N1213HC */
2453 "ABI v1", /* use r0 as return register */
2454 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2455 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2456 "AABI",
2457 "ABI2 FP+"
35c08157
KLC		 2458 };
2459 static const char *VER_STRINGS[] =
2460 {
2461 "Andes ELF V1.3 or older",
2462 "Andes ELF V1.3.1",
2463 "Andes ELF V1.4"
2464 };
2465 static const char *ARCH_STRINGS[] =
2466 {
2467 "",
2468 "Andes Star v1.0",
2469 "Andes Star v2.0",
2470 "Andes Star v3.0",
2471 "Andes Star v3.0m"
2472 };
2473
2474 abi = EF_NDS_ABI & e_flags;
2475 arch = EF_NDS_ARCH & e_flags;
2476 config = EF_NDS_INST & e_flags;
2477 version = EF_NDS32_ELF_VERSION & e_flags;
2478
2479 memset (buf, 0, size);
2480
2481 switch (abi)
2482 {
2483 case E_NDS_ABI_V0:
2484 case E_NDS_ABI_V1:
2485 case E_NDS_ABI_V2:
2486 case E_NDS_ABI_V2FP:
2487 case E_NDS_ABI_AABI:
40c7a7cb 2488 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2489 /* In case there are holes in the array. */
2490 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2491 break;
2492
2493 default:
2494 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2495 break;
2496 }
2497
2498 switch (version)
2499 {
2500 case E_NDS32_ELF_VER_1_2:
2501 case E_NDS32_ELF_VER_1_3:
2502 case E_NDS32_ELF_VER_1_4:
2503 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2504 break;
2505
2506 default:
2507 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2508 break;
2509 }
2510
2511 if (E_NDS_ABI_V0 == abi)
2512 {
2513 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2514 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2515 if (arch == E_NDS_ARCH_STAR_V1_0)
2516 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2517 return;
2518 }
2519
2520 switch (arch)
2521 {
2522 case E_NDS_ARCH_STAR_V1_0:
2523 case E_NDS_ARCH_STAR_V2_0:
2524 case E_NDS_ARCH_STAR_V3_0:
2525 case E_NDS_ARCH_STAR_V3_M:
2526 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2527 break;
2528
2529 default:
2530 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2531 /* ARCH version determines how the e_flags are interpreted.
2532 If it is unknown, we cannot proceed. */
2533 return;
2534 }
2535
2536 /* Newer ABI; Now handle architecture specific flags. */
2537 if (arch == E_NDS_ARCH_STAR_V1_0)
2538 {
2539 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2540 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2541
2542 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2543 r += snprintf (buf + r, size -r, ", MAC");
2544
2545 if (config & E_NDS32_HAS_DIV_INST)
2546 r += snprintf (buf + r, size -r, ", DIV");
2547
2548 if (config & E_NDS32_HAS_16BIT_INST)
2549 r += snprintf (buf + r, size -r, ", 16b");
2550 }
2551 else
2552 {
2553 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2554 {
2555 if (version <= E_NDS32_ELF_VER_1_3)
2556 r += snprintf (buf + r, size -r, ", [B8]");
2557 else
2558 r += snprintf (buf + r, size -r, ", EX9");
2559 }
2560
2561 if (config & E_NDS32_HAS_MAC_DX_INST)
2562 r += snprintf (buf + r, size -r, ", MAC_DX");
2563
2564 if (config & E_NDS32_HAS_DIV_DX_INST)
2565 r += snprintf (buf + r, size -r, ", DIV_DX");
2566
2567 if (config & E_NDS32_HAS_16BIT_INST)
2568 {
2569 if (version <= E_NDS32_ELF_VER_1_3)
2570 r += snprintf (buf + r, size -r, ", 16b");
2571 else
2572 r += snprintf (buf + r, size -r, ", IFC");
2573 }
2574 }
2575
2576 if (config & E_NDS32_HAS_EXT_INST)
2577 r += snprintf (buf + r, size -r, ", PERF1");
2578
2579 if (config & E_NDS32_HAS_EXT2_INST)
2580 r += snprintf (buf + r, size -r, ", PERF2");
2581
2582 if (config & E_NDS32_HAS_FPU_INST)
2583 {
2584 has_fpu = 1;
2585 r += snprintf (buf + r, size -r, ", FPU_SP");
2586 }
2587
2588 if (config & E_NDS32_HAS_FPU_DP_INST)
2589 {
2590 has_fpu = 1;
2591 r += snprintf (buf + r, size -r, ", FPU_DP");
2592 }
2593
2594 if (config & E_NDS32_HAS_FPU_MAC_INST)
2595 {
2596 has_fpu = 1;
2597 r += snprintf (buf + r, size -r, ", FPU_MAC");
2598 }
2599
2600 if (has_fpu)
2601 {
2602 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2603 {
2604 case E_NDS32_FPU_REG_8SP_4DP:
2605 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2606 break;
2607 case E_NDS32_FPU_REG_16SP_8DP:
2608 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2609 break;
2610 case E_NDS32_FPU_REG_32SP_16DP:
2611 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2612 break;
2613 case E_NDS32_FPU_REG_32SP_32DP:
2614 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2615 break;
2616 }
2617 }
2618
2619 if (config & E_NDS32_HAS_AUDIO_INST)
2620 r += snprintf (buf + r, size -r, ", AUDIO");
2621
2622 if (config & E_NDS32_HAS_STRING_INST)
2623 r += snprintf (buf + r, size -r, ", STR");
2624
2625 if (config & E_NDS32_HAS_REDUCED_REGS)
2626 r += snprintf (buf + r, size -r, ", 16REG");
2627
2628 if (config & E_NDS32_HAS_VIDEO_INST)
2629 {
2630 if (version <= E_NDS32_ELF_VER_1_3)
2631 r += snprintf (buf + r, size -r, ", VIDEO");
2632 else
2633 r += snprintf (buf + r, size -r, ", SATURATION");
2634 }
2635
2636 if (config & E_NDS32_HAS_ENCRIPT_INST)
2637 r += snprintf (buf + r, size -r, ", ENCRP");
2638
2639 if (config & E_NDS32_HAS_L2C_INST)
2640 r += snprintf (buf + r, size -r, ", L2C");
2641}
2642
252b5132 2643static char *
d3ba0551 2644get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2645{
b34976b6 2646 static char buf[1024];
252b5132
RH		 2647
2648 buf[0] = '\0';
76da6bbe 2649
252b5132
RH		 2650 if (e_flags)
2651 {
2652 switch (e_machine)
2653 {
2654 default:
2655 break;
2656
f3485b74
NC		 2657 case EM_ARM:
2658 decode_ARM_machine_flags (e_flags, buf);
2659 break;
76da6bbe 2660
781303ce
MF		 2661 case EM_BLACKFIN:
2662 if (e_flags & EF_BFIN_PIC)
2663 strcat (buf, ", PIC");
2664
2665 if (e_flags & EF_BFIN_FDPIC)
2666 strcat (buf, ", FDPIC");
2667
2668 if (e_flags & EF_BFIN_CODE_IN_L1)
2669 strcat (buf, ", code in L1");
2670
2671 if (e_flags & EF_BFIN_DATA_IN_L1)
2672 strcat (buf, ", data in L1");
2673
2674 break;
2675
ec2dfb42
AO		 2676 case EM_CYGNUS_FRV:
2677 switch (e_flags & EF_FRV_CPU_MASK)
2678 {
2679 case EF_FRV_CPU_GENERIC:
2680 break;
2681
2682 default:
2683 strcat (buf, ", fr???");
2684 break;
57346661 2685
ec2dfb42
AO		 2686 case EF_FRV_CPU_FR300:
2687 strcat (buf, ", fr300");
2688 break;
2689
2690 case EF_FRV_CPU_FR400:
2691 strcat (buf, ", fr400");
2692 break;
2693 case EF_FRV_CPU_FR405:
2694 strcat (buf, ", fr405");
2695 break;
2696
2697 case EF_FRV_CPU_FR450:
2698 strcat (buf, ", fr450");
2699 break;
2700
2701 case EF_FRV_CPU_FR500:
2702 strcat (buf, ", fr500");
2703 break;
2704 case EF_FRV_CPU_FR550:
2705 strcat (buf, ", fr550");
2706 break;
2707
2708 case EF_FRV_CPU_SIMPLE:
2709 strcat (buf, ", simple");
2710 break;
2711 case EF_FRV_CPU_TOMCAT:
2712 strcat (buf, ", tomcat");
2713 break;
2714 }
1c877e87 2715 break;
ec2dfb42 2716
53c7db4b 2717 case EM_68K:
425c6cb0 2718 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2719 strcat (buf, ", m68000");
425c6cb0 2720 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2721 strcat (buf, ", cpu32");
2722 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2723 strcat (buf, ", fido_a");
425c6cb0 2724 else
266abb8f 2725 {
2cf0635d
NC		 2726 char const * isa = _("unknown");
2727 char const * mac = _("unknown mac");
2728 char const * additional = NULL;
0112cd26 2729
c694fd50 2730 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2731 {
c694fd50 2732 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2733 isa = "A";
2734 additional = ", nodiv";
2735 break;
c694fd50 2736 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2737 isa = "A";
2738 break;
c694fd50 2739 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2740 isa = "A+";
2741 break;
c694fd50 2742 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2743 isa = "B";
2744 additional = ", nousp";
2745 break;
c694fd50 2746 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2747 isa = "B";
2748 break;
f608cd77
NS		 2749 case EF_M68K_CF_ISA_C:
2750 isa = "C";
2751 break;
2752 case EF_M68K_CF_ISA_C_NODIV:
2753 isa = "C";
2754 additional = ", nodiv";
2755 break;
266abb8f
NS		 2756 }
2757 strcat (buf, ", cf, isa ");
2758 strcat (buf, isa);
0b2e31dc
NS		 2759 if (additional)
2760 strcat (buf, additional);
c694fd50 2761 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2762 strcat (buf, ", float");
c694fd50 2763 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2764 {
2765 case 0:
2766 mac = NULL;
2767 break;
c694fd50 2768 case EF_M68K_CF_MAC:
266abb8f
NS		 2769 mac = "mac";
2770 break;
c694fd50 2771 case EF_M68K_CF_EMAC:
266abb8f
NS		 2772 mac = "emac";
2773 break;
f608cd77
NS		 2774 case EF_M68K_CF_EMAC_B:
2775 mac = "emac_b";
2776 break;
266abb8f
NS		 2777 }
2778 if (mac)
2779 {
2780 strcat (buf, ", ");
2781 strcat (buf, mac);
2782 }
266abb8f 2783 }
53c7db4b 2784 break;
33c63f9d 2785
252b5132
RH		 2786 case EM_PPC:
2787 if (e_flags & EF_PPC_EMB)
2788 strcat (buf, ", emb");
2789
2790 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2791 strcat (buf, _(", relocatable"));
252b5132
RH		 2792
2793 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2794 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2795 break;
2796
ee67d69a
AM		 2797 case EM_PPC64:
2798 if (e_flags & EF_PPC64_ABI)
2799 {
2800 char abi[] = ", abiv0";
2801
2802 abi[6] += e_flags & EF_PPC64_ABI;
2803 strcat (buf, abi);
2804 }
2805 break;
2806
708e2187
NC		 2807 case EM_V800:
2808 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2809 strcat (buf, ", RH850 ABI");
0b4362b0 2810
708e2187
NC		 2811 if (e_flags & EF_V800_850E3)
2812 strcat (buf, ", V3 architecture");
2813
2814 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2815 strcat (buf, ", FPU not used");
2816
2817 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2818 strcat (buf, ", regmode: COMMON");
2819
2820 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2821 strcat (buf, ", r4 not used");
2822
2823 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2824 strcat (buf, ", r30 not used");
2825
2826 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2827 strcat (buf, ", r5 not used");
2828
2829 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2830 strcat (buf, ", r2 not used");
2831
2832 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2833 {
2834 switch (e_flags & - e_flags)
2835 {
2836 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2837 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2838 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2839 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2840 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2841 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2842 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2843 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2844 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2845 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2846 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2847 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2848 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2849 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2850 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2851 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2852 default: break;
2853 }
2854 }
2855 break;
2856
2b0337b0 2857 case EM_V850:
252b5132
RH		 2858 case EM_CYGNUS_V850:
2859 switch (e_flags & EF_V850_ARCH)
2860 {
78c8d46c
NC		 2861 case E_V850E3V5_ARCH:
2862 strcat (buf, ", v850e3v5");
2863 break;
1cd986c5
NC		 2864 case E_V850E2V3_ARCH:
2865 strcat (buf, ", v850e2v3");
2866 break;
2867 case E_V850E2_ARCH:
2868 strcat (buf, ", v850e2");
2869 break;
2870 case E_V850E1_ARCH:
2871 strcat (buf, ", v850e1");
8ad30312 2872 break;
252b5132
RH		 2873 case E_V850E_ARCH:
2874 strcat (buf, ", v850e");
2875 break;
252b5132
RH		 2876 case E_V850_ARCH:
2877 strcat (buf, ", v850");
2878 break;
2879 default:
2b692964 2880 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2881 break;
2882 }
2883 break;
2884
2b0337b0 2885 case EM_M32R:
252b5132
RH		 2886 case EM_CYGNUS_M32R:
2887 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2888 strcat (buf, ", m32r");
252b5132
RH		 2889 break;
2890
2891 case EM_MIPS:
4fe85591 2892 case EM_MIPS_RS3_LE:
252b5132
RH		 2893 if (e_flags & EF_MIPS_NOREORDER)
2894 strcat (buf, ", noreorder");
2895
2896 if (e_flags & EF_MIPS_PIC)
2897 strcat (buf, ", pic");
2898
2899 if (e_flags & EF_MIPS_CPIC)
2900 strcat (buf, ", cpic");
2901
d1bdd336
TS		 2902 if (e_flags & EF_MIPS_UCODE)
2903 strcat (buf, ", ugen_reserved");
2904
252b5132
RH		 2905 if (e_flags & EF_MIPS_ABI2)
2906 strcat (buf, ", abi2");
2907
43521d43
TS		 2908 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2909 strcat (buf, ", odk first");
2910
a5d22d2a
TS		 2911 if (e_flags & EF_MIPS_32BITMODE)
2912 strcat (buf, ", 32bitmode");
2913
ba92f887
MR		 2914 if (e_flags & EF_MIPS_NAN2008)
2915 strcat (buf, ", nan2008");
2916
fef1b0b3
SE		 2917 if (e_flags & EF_MIPS_FP64)
2918 strcat (buf, ", fp64");
2919
156c2f8b
NC		 2920 switch ((e_flags & EF_MIPS_MACH))
2921 {
2922 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2923 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2924 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2925 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2926 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2927 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2928 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2929 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2930 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2931 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2932 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2933 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2934 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2935 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2936 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 2937 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 2938 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2939 case 0:
2940 /* We simply ignore the field in this case to avoid confusion:
2941 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2942 extension. */
2943 break;
2b692964 2944 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2945 }
43521d43
TS		 2946
2947 switch ((e_flags & EF_MIPS_ABI))
2948 {
2949 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2950 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2951 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2952 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2953 case 0:
2954 /* We simply ignore the field in this case to avoid confusion:
2955 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2956 This means it is likely to be an o32 file, but not for
2957 sure. */
2958 break;
2b692964 2959 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2960 }
2961
2962 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2963 strcat (buf, ", mdmx");
2964
2965 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2966 strcat (buf, ", mips16");
2967
df58fc94
RS		 2968 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2969 strcat (buf, ", micromips");
2970
43521d43
TS		 2971 switch ((e_flags & EF_MIPS_ARCH))
2972 {
2973 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2974 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2975 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2976 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2977 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2978 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2979 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 2980 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 2981 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2982 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 2983 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 2984 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2985 }
252b5132 2986 break;
351b4b40 2987
35c08157
KLC		 2988 case EM_NDS32:
2989 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2990 break;
2991
ccde1100
AO		 2992 case EM_SH:
2993 switch ((e_flags & EF_SH_MACH_MASK))
2994 {
2995 case EF_SH1: strcat (buf, ", sh1"); break;
2996 case EF_SH2: strcat (buf, ", sh2"); break;
2997 case EF_SH3: strcat (buf, ", sh3"); break;
2998 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2999 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3000 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3001 case EF_SH3E: strcat (buf, ", sh3e"); break;
3002 case EF_SH4: strcat (buf, ", sh4"); break;
3003 case EF_SH5: strcat (buf, ", sh5"); break;
3004 case EF_SH2E: strcat (buf, ", sh2e"); break;
3005 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3006 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3007 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3008 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3009 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3010 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3011 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3012 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3013 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3014 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3015 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3016 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3017 }
3018
cec6a5b8
MR		 3019 if (e_flags & EF_SH_PIC)
3020 strcat (buf, ", pic");
3021
3022 if (e_flags & EF_SH_FDPIC)
3023 strcat (buf, ", fdpic");
ccde1100 3024 break;
73589c9d
CS		 3025
3026 case EM_OR1K:
3027 if (e_flags & EF_OR1K_NODELAY)
3028 strcat (buf, ", no delay");
3029 break;
57346661 3030
351b4b40
RH		 3031 case EM_SPARCV9:
3032 if (e_flags & EF_SPARC_32PLUS)
3033 strcat (buf, ", v8+");
3034
3035 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3036 strcat (buf, ", ultrasparcI");
3037
3038 if (e_flags & EF_SPARC_SUN_US3)
3039 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3040
3041 if (e_flags & EF_SPARC_HAL_R1)
3042 strcat (buf, ", halr1");
3043
3044 if (e_flags & EF_SPARC_LEDATA)
3045 strcat (buf, ", ledata");
3046
3047 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3048 strcat (buf, ", tso");
3049
3050 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3051 strcat (buf, ", pso");
3052
3053 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3054 strcat (buf, ", rmo");
3055 break;
7d466069 3056
103f02d3
UD		 3057 case EM_PARISC:
3058 switch (e_flags & EF_PARISC_ARCH)
3059 {
3060 case EFA_PARISC_1_0:
3061 strcpy (buf, ", PA-RISC 1.0");
3062 break;
3063 case EFA_PARISC_1_1:
3064 strcpy (buf, ", PA-RISC 1.1");
3065 break;
3066 case EFA_PARISC_2_0:
3067 strcpy (buf, ", PA-RISC 2.0");
3068 break;
3069 default:
3070 break;
3071 }
3072 if (e_flags & EF_PARISC_TRAPNIL)
3073 strcat (buf, ", trapnil");
3074 if (e_flags & EF_PARISC_EXT)
3075 strcat (buf, ", ext");
3076 if (e_flags & EF_PARISC_LSB)
3077 strcat (buf, ", lsb");
3078 if (e_flags & EF_PARISC_WIDE)
3079 strcat (buf, ", wide");
3080 if (e_flags & EF_PARISC_NO_KABP)
3081 strcat (buf, ", no kabp");
3082 if (e_flags & EF_PARISC_LAZYSWAP)
3083 strcat (buf, ", lazyswap");
30800947 3084 break;
76da6bbe 3085
7d466069 3086 case EM_PJ:
2b0337b0 3087 case EM_PJ_OLD:
7d466069
ILT		 3088 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3089 strcat (buf, ", new calling convention");
3090
3091 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3092 strcat (buf, ", gnu calling convention");
3093 break;
4d6ed7c8
NC		 3094
3095 case EM_IA_64:
3096 if ((e_flags & EF_IA_64_ABI64))
3097 strcat (buf, ", 64-bit");
3098 else
3099 strcat (buf, ", 32-bit");
3100 if ((e_flags & EF_IA_64_REDUCEDFP))
3101 strcat (buf, ", reduced fp model");
3102 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3103 strcat (buf, ", no function descriptors, constant gp");
3104 else if ((e_flags & EF_IA_64_CONS_GP))
3105 strcat (buf, ", constant gp");
3106 if ((e_flags & EF_IA_64_ABSOLUTE))
3107 strcat (buf, ", absolute");
28f997cf
TG		 3108 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3109 {
3110 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3111 strcat (buf, ", vms_linkages");
3112 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3113 {
3114 case EF_IA_64_VMS_COMCOD_SUCCESS:
3115 break;
3116 case EF_IA_64_VMS_COMCOD_WARNING:
3117 strcat (buf, ", warning");
3118 break;
3119 case EF_IA_64_VMS_COMCOD_ERROR:
3120 strcat (buf, ", error");
3121 break;
3122 case EF_IA_64_VMS_COMCOD_ABORT:
3123 strcat (buf, ", abort");
3124 break;
3125 default:
3126 abort ();
3127 }
3128 }
4d6ed7c8 3129 break;
179d3252
JT		 3130
3131 case EM_VAX:
3132 if ((e_flags & EF_VAX_NONPIC))
3133 strcat (buf, ", non-PIC");
3134 if ((e_flags & EF_VAX_DFLOAT))
3135 strcat (buf, ", D-Float");
3136 if ((e_flags & EF_VAX_GFLOAT))
3137 strcat (buf, ", G-Float");
3138 break;
c7927a3c 3139
4046d87a
NC		 3140 case EM_RL78:
3141 if (e_flags & E_FLAG_RL78_G10)
3142 strcat (buf, ", G10");
856ea05c
KP		 3143 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3144 strcat (buf, ", 64-bit doubles");
4046d87a 3145 break;
0b4362b0 3146
c7927a3c
NC		 3147 case EM_RX:
3148 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3149 strcat (buf, ", 64-bit doubles");
3150 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3151 strcat (buf, ", dsp");
d4cb0ea0 3152 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3153 strcat (buf, ", pid");
708e2187
NC		 3154 if (e_flags & E_FLAG_RX_ABI)
3155 strcat (buf, ", RX ABI");
d4cb0ea0 3156 break;
55786da2
AK		 3157
3158 case EM_S390:
3159 if (e_flags & EF_S390_HIGH_GPRS)
3160 strcat (buf, ", highgprs");
d4cb0ea0 3161 break;
40b36596
JM		 3162
3163 case EM_TI_C6000:
3164 if ((e_flags & EF_C6000_REL))
3165 strcat (buf, ", relocatable module");
d4cb0ea0 3166 break;
13761a11
NC		 3167
3168 case EM_MSP430:
3169 strcat (buf, _(": architecture variant: "));
3170 switch (e_flags & EF_MSP430_MACH)
3171 {
3172 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3173 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3174 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3175 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3176 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3177 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3178 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3179 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3180 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3181 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3182 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3183 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3184 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3185 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3186 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3187 default:
3188 strcat (buf, _(": unknown")); break;
3189 }
3190
3191 if (e_flags & ~ EF_MSP430_MACH)
3192 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3193 }
3194 }
3195
3196 return buf;
3197}
3198
252b5132 3199static const char *
d3ba0551
AM		 3200get_osabi_name (unsigned int osabi)
3201{
3202 static char buff[32];
3203
3204 switch (osabi)
3205 {
3206 case ELFOSABI_NONE: return "UNIX - System V";
3207 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3208 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3209 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3210 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3211 case ELFOSABI_AIX: return "UNIX - AIX";
3212 case ELFOSABI_IRIX: return "UNIX - IRIX";
3213 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3214 case ELFOSABI_TRU64: return "UNIX - TRU64";
3215 case ELFOSABI_MODESTO: return "Novell - Modesto";
3216 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3217 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3218 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3219 case ELFOSABI_AROS: return "AROS";
11636f9e 3220 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3221 default:
40b36596
JM		 3222 if (osabi >= 64)
3223 switch (elf_header.e_machine)
3224 {
3225 case EM_ARM:
3226 switch (osabi)
3227 {
3228 case ELFOSABI_ARM: return "ARM";
3229 default:
3230 break;
3231 }
3232 break;
3233
3234 case EM_MSP430:
3235 case EM_MSP430_OLD:
3236 switch (osabi)
3237 {
3238 case ELFOSABI_STANDALONE: return _("Standalone App");
3239 default:
3240 break;
3241 }
3242 break;
3243
3244 case EM_TI_C6000:
3245 switch (osabi)
3246 {
3247 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3248 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3249 default:
3250 break;
3251 }
3252 break;
3253
3254 default:
3255 break;
3256 }
e9e44622 3257 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3258 return buff;
3259 }
3260}
3261
a06ea964
NC		 3262static const char *
3263get_aarch64_segment_type (unsigned long type)
3264{
3265 switch (type)
3266 {
3267 case PT_AARCH64_ARCHEXT:
3268 return "AARCH64_ARCHEXT";
3269 default:
3270 break;
3271 }
3272
3273 return NULL;
3274}
3275
b294bdf8
MM		 3276static const char *
3277get_arm_segment_type (unsigned long type)
3278{
3279 switch (type)
3280 {
3281 case PT_ARM_EXIDX:
3282 return "EXIDX";
3283 default:
3284 break;
3285 }
3286
3287 return NULL;
3288}
3289
d3ba0551
AM		 3290static const char *
3291get_mips_segment_type (unsigned long type)
252b5132
RH		 3292{
3293 switch (type)
3294 {
3295 case PT_MIPS_REGINFO:
3296 return "REGINFO";
3297 case PT_MIPS_RTPROC:
3298 return "RTPROC";
3299 case PT_MIPS_OPTIONS:
3300 return "OPTIONS";
351cdf24
MF		 3301 case PT_MIPS_ABIFLAGS:
3302 return "ABIFLAGS";
252b5132
RH		 3303 default:
3304 break;
3305 }
3306
3307 return NULL;
3308}
3309
103f02d3 3310static const char *
d3ba0551 3311get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3312{
3313 switch (type)
3314 {
3315 case PT_HP_TLS: return "HP_TLS";
3316 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3317 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3318 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3319 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3320 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3321 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3322 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3323 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3324 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3325 case PT_HP_PARALLEL: return "HP_PARALLEL";
3326 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3327 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3328 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3329 case PT_HP_STACK: return "HP_STACK";
3330 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3331 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3332 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3333 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3334 default:
3335 break;
3336 }
3337
3338 return NULL;
3339}
3340
4d6ed7c8 3341static const char *
d3ba0551 3342get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3343{
3344 switch (type)
3345 {
3346 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3347 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3348 case PT_HP_TLS: return "HP_TLS";
3349 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3350 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3351 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3352 default:
3353 break;
3354 }
3355
3356 return NULL;
3357}
3358
40b36596
JM		 3359static const char *
3360get_tic6x_segment_type (unsigned long type)
3361{
3362 switch (type)
3363 {
3364 case PT_C6000_PHATTR: return "C6000_PHATTR";
3365 default:
3366 break;
3367 }
3368
3369 return NULL;
3370}
3371
252b5132 3372static const char *
d3ba0551 3373get_segment_type (unsigned long p_type)
252b5132 3374{
b34976b6 3375 static char buff[32];
252b5132
RH		 3376
3377 switch (p_type)
3378 {
b34976b6
AM		 3379 case PT_NULL: return "NULL";
3380 case PT_LOAD: return "LOAD";
252b5132 3381 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3382 case PT_INTERP: return "INTERP";
3383 case PT_NOTE: return "NOTE";
3384 case PT_SHLIB: return "SHLIB";
3385 case PT_PHDR: return "PHDR";
13ae64f3 3386 case PT_TLS: return "TLS";
252b5132 3387
65765700
JJ		 3388 case PT_GNU_EH_FRAME:
3389 return "GNU_EH_FRAME";
2b05f1b7 3390 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3391 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3392
252b5132
RH		 3393 default:
3394 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3395 {
2cf0635d 3396 const char * result;
103f02d3 3397
252b5132
RH		 3398 switch (elf_header.e_machine)
3399 {
a06ea964
NC		 3400 case EM_AARCH64:
3401 result = get_aarch64_segment_type (p_type);
3402 break;
b294bdf8
MM		 3403 case EM_ARM:
3404 result = get_arm_segment_type (p_type);
3405 break;
252b5132 3406 case EM_MIPS:
4fe85591 3407 case EM_MIPS_RS3_LE:
252b5132
RH		 3408 result = get_mips_segment_type (p_type);
3409 break;
103f02d3
UD		 3410 case EM_PARISC:
3411 result = get_parisc_segment_type (p_type);
3412 break;
4d6ed7c8
NC		 3413 case EM_IA_64:
3414 result = get_ia64_segment_type (p_type);
3415 break;
40b36596
JM		 3416 case EM_TI_C6000:
3417 result = get_tic6x_segment_type (p_type);
3418 break;
252b5132
RH		 3419 default:
3420 result = NULL;
3421 break;
3422 }
103f02d3 3423
252b5132
RH		 3424 if (result != NULL)
3425 return result;
103f02d3 3426
252b5132
RH		 3427 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3428 }
3429 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3430 {
2cf0635d 3431 const char * result;
103f02d3
UD		 3432
3433 switch (elf_header.e_machine)
3434 {
3435 case EM_PARISC:
3436 result = get_parisc_segment_type (p_type);
3437 break;
00428cca
AM		 3438 case EM_IA_64:
3439 result = get_ia64_segment_type (p_type);
3440 break;
103f02d3
UD		 3441 default:
3442 result = NULL;
3443 break;
3444 }
3445
3446 if (result != NULL)
3447 return result;
3448
3449 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3450 }
252b5132 3451 else
e9e44622 3452 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3453
3454 return buff;
3455 }
3456}
3457
3458static const char *
d3ba0551 3459get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3460{
3461 switch (sh_type)
3462 {
b34976b6
AM		 3463 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3464 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3465 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3466 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3467 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3468 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3469 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3470 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3471 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3472 case SHT_MIPS_RELD: return "MIPS_RELD";
3473 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3474 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3475 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3476 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3477 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3478 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3479 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3480 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3481 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3482 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3483 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3484 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3485 case SHT_MIPS_LINE: return "MIPS_LINE";
3486 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3487 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3488 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3489 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3490 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3491 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3492 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3493 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3494 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3495 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3496 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3497 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3498 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3499 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3500 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3501 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3502 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3503 default:
3504 break;
3505 }
3506 return NULL;
3507}
3508
103f02d3 3509static const char *
d3ba0551 3510get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3511{
3512 switch (sh_type)
3513 {
3514 case SHT_PARISC_EXT: return "PARISC_EXT";
3515 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3516 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3517 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3518 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3519 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3520 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3521 default:
3522 break;
3523 }
3524 return NULL;
3525}
3526
4d6ed7c8 3527static const char *
d3ba0551 3528get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3529{
18bd398b 3530 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3531 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3532 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3533
4d6ed7c8
NC		 3534 switch (sh_type)
3535 {
148b93f2
NC		 3536 case SHT_IA_64_EXT: return "IA_64_EXT";
3537 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3538 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3539 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3540 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3541 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3542 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3543 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3544 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3545 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3546 default:
3547 break;
3548 }
3549 return NULL;
3550}
3551
d2b2c203
DJ		 3552static const char *
3553get_x86_64_section_type_name (unsigned int sh_type)
3554{
3555 switch (sh_type)
3556 {
3557 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3558 default:
3559 break;
3560 }
3561 return NULL;
3562}
3563
a06ea964
NC		 3564static const char *
3565get_aarch64_section_type_name (unsigned int sh_type)
3566{
3567 switch (sh_type)
3568 {
3569 case SHT_AARCH64_ATTRIBUTES:
3570 return "AARCH64_ATTRIBUTES";
3571 default:
3572 break;
3573 }
3574 return NULL;
3575}
3576
40a18ebd
NC		 3577static const char *
3578get_arm_section_type_name (unsigned int sh_type)
3579{
3580 switch (sh_type)
3581 {
7f6fed87
NC		 3582 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3583 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3584 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3585 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3586 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3587 default:
3588 break;
3589 }
3590 return NULL;
3591}
3592
40b36596
JM		 3593static const char *
3594get_tic6x_section_type_name (unsigned int sh_type)
3595{
3596 switch (sh_type)
3597 {
3598 case SHT_C6000_UNWIND:
3599 return "C6000_UNWIND";
3600 case SHT_C6000_PREEMPTMAP:
3601 return "C6000_PREEMPTMAP";
3602 case SHT_C6000_ATTRIBUTES:
3603 return "C6000_ATTRIBUTES";
3604 case SHT_TI_ICODE:
3605 return "TI_ICODE";
3606 case SHT_TI_XREF:
3607 return "TI_XREF";
3608 case SHT_TI_HANDLER:
3609 return "TI_HANDLER";
3610 case SHT_TI_INITINFO:
3611 return "TI_INITINFO";
3612 case SHT_TI_PHATTRS:
3613 return "TI_PHATTRS";
3614 default:
3615 break;
3616 }
3617 return NULL;
3618}
3619
13761a11
NC		 3620static const char *
3621get_msp430x_section_type_name (unsigned int sh_type)
3622{
3623 switch (sh_type)
3624 {
3625 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3626 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3627 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3628 default: return NULL;
3629 }
3630}
3631
252b5132 3632static const char *
d3ba0551 3633get_section_type_name (unsigned int sh_type)
252b5132 3634{
b34976b6 3635 static char buff[32];
252b5132
RH		 3636
3637 switch (sh_type)
3638 {
3639 case SHT_NULL: return "NULL";
3640 case SHT_PROGBITS: return "PROGBITS";
3641 case SHT_SYMTAB: return "SYMTAB";
3642 case SHT_STRTAB: return "STRTAB";
3643 case SHT_RELA: return "RELA";
3644 case SHT_HASH: return "HASH";
3645 case SHT_DYNAMIC: return "DYNAMIC";
3646 case SHT_NOTE: return "NOTE";
3647 case SHT_NOBITS: return "NOBITS";
3648 case SHT_REL: return "REL";
3649 case SHT_SHLIB: return "SHLIB";
3650 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3651 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3652 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3653 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3654 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3655 case SHT_GROUP: return "GROUP";
3656 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3657 case SHT_GNU_verdef: return "VERDEF";
3658 case SHT_GNU_verneed: return "VERNEED";
3659 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3660 case 0x6ffffff0: return "VERSYM";
3661 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3662 case 0x7ffffffd: return "AUXILIARY";
3663 case 0x7fffffff: return "FILTER";
047b2264 3664 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3665
3666 default:
3667 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3668 {
2cf0635d 3669 const char * result;
252b5132
RH		 3670
3671 switch (elf_header.e_machine)
3672 {
3673 case EM_MIPS:
4fe85591 3674 case EM_MIPS_RS3_LE:
252b5132
RH		 3675 result = get_mips_section_type_name (sh_type);
3676 break;
103f02d3
UD		 3677 case EM_PARISC:
3678 result = get_parisc_section_type_name (sh_type);
3679 break;
4d6ed7c8
NC		 3680 case EM_IA_64:
3681 result = get_ia64_section_type_name (sh_type);
3682 break;
d2b2c203 3683 case EM_X86_64:
8a9036a4 3684 case EM_L1OM:
7a9068fe 3685 case EM_K1OM:
d2b2c203
DJ		 3686 result = get_x86_64_section_type_name (sh_type);
3687 break;
a06ea964
NC		 3688 case EM_AARCH64:
3689 result = get_aarch64_section_type_name (sh_type);
3690 break;
40a18ebd
NC		 3691 case EM_ARM:
3692 result = get_arm_section_type_name (sh_type);
3693 break;
40b36596
JM		 3694 case EM_TI_C6000:
3695 result = get_tic6x_section_type_name (sh_type);
3696 break;
13761a11
NC		 3697 case EM_MSP430:
3698 result = get_msp430x_section_type_name (sh_type);
3699 break;
252b5132
RH		 3700 default:
3701 result = NULL;
3702 break;
3703 }
3704
3705 if (result != NULL)
3706 return result;
3707
c91d0dfb 3708 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3709 }
3710 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3711 {
2cf0635d 3712 const char * result;
148b93f2
NC		 3713
3714 switch (elf_header.e_machine)
3715 {
3716 case EM_IA_64:
3717 result = get_ia64_section_type_name (sh_type);
3718 break;
3719 default:
3720 result = NULL;
3721 break;
3722 }
3723
3724 if (result != NULL)
3725 return result;
3726
3727 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3728 }
252b5132 3729 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3730 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3731 else
a7dbfd1c
NC		 3732 /* This message is probably going to be displayed in a 15
3733 character wide field, so put the hex value first. */
3734 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3735
252b5132
RH		 3736 return buff;
3737 }
3738}
3739
2979dc34 3740#define OPTION_DEBUG_DUMP 512
2c610e4b 3741#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3742#define OPTION_DWARF_DEPTH 514
3743#define OPTION_DWARF_START 515
4723351a 3744#define OPTION_DWARF_CHECK 516
2979dc34 3745
85b1c36d 3746static struct option options[] =
252b5132 3747{
b34976b6 3748 {"all", no_argument, 0, 'a'},
252b5132
RH		 3749 {"file-header", no_argument, 0, 'h'},
3750 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3751 {"headers", no_argument, 0, 'e'},
3752 {"histogram", no_argument, 0, 'I'},
3753 {"segments", no_argument, 0, 'l'},
3754 {"sections", no_argument, 0, 'S'},
252b5132 3755 {"section-headers", no_argument, 0, 'S'},
f5842774 3756 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3757 {"section-details", no_argument, 0, 't'},
595cf52e 3758 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3759 {"symbols", no_argument, 0, 's'},
3760 {"syms", no_argument, 0, 's'},
2c610e4b 3761 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3762 {"relocs", no_argument, 0, 'r'},
3763 {"notes", no_argument, 0, 'n'},
3764 {"dynamic", no_argument, 0, 'd'},
a952a375 3765 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3766 {"version-info", no_argument, 0, 'V'},
3767 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3768 {"unwind", no_argument, 0, 'u'},
4145f1d5 3769 {"archive-index", no_argument, 0, 'c'},
b34976b6 3770 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3771 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3772 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3773#ifdef SUPPORT_DISASSEMBLY
3774 {"instruction-dump", required_argument, 0, 'i'},
3775#endif
cf13d699 3776 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3777
fd2f0033
TT		 3778 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3779 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3780 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3781
b34976b6
AM		 3782 {"version", no_argument, 0, 'v'},
3783 {"wide", no_argument, 0, 'W'},
3784 {"help", no_argument, 0, 'H'},
3785 {0, no_argument, 0, 0}
252b5132
RH		 3786};
3787
3788static void
2cf0635d 3789usage (FILE * stream)
252b5132 3790{
92f01d61
JM		 3791 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3792 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3793 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3794 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3795 -h --file-header Display the ELF file header\n\
3796 -l --program-headers Display the program headers\n\
3797 --segments An alias for --program-headers\n\
3798 -S --section-headers Display the sections' header\n\
3799 --sections An alias for --section-headers\n\
f5842774 3800 -g --section-groups Display the section groups\n\
5477e8a0 3801 -t --section-details Display the section details\n\
8b53311e
NC		 3802 -e --headers Equivalent to: -h -l -S\n\
3803 -s --syms Display the symbol table\n\
3f08eb35 3804 --symbols An alias for --syms\n\
2c610e4b 3805 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3806 -n --notes Display the core notes (if present)\n\
3807 -r --relocs Display the relocations (if present)\n\
3808 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3809 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3810 -V --version-info Display the version sections (if present)\n\
1b31d05e 3811 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3812 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3813 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3814 -x --hex-dump=<number|name>\n\
3815 Dump the contents of section <number|name> as bytes\n\
3816 -p --string-dump=<number|name>\n\
3817 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3818 -R --relocated-dump=<number|name>\n\
3819 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3820 -w[lLiaprmfFsoRt] or\n\
1ed06042 3821 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3822 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3823 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3824 =addr,=cu_index]\n\
8b53311e 3825 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3826 fprintf (stream, _("\
3827 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3828 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3829 or deeper\n"));
252b5132 3830#ifdef SUPPORT_DISASSEMBLY
92f01d61 3831 fprintf (stream, _("\
09c11c86
NC		 3832 -i --instruction-dump=<number|name>\n\
3833 Disassemble the contents of section <number|name>\n"));
252b5132 3834#endif
92f01d61 3835 fprintf (stream, _("\
8b53311e
NC		 3836 -I --histogram Display histogram of bucket list lengths\n\
3837 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3838 @<file> Read options from <file>\n\
8b53311e
NC		 3839 -H --help Display this information\n\
3840 -v --version Display the version number of readelf\n"));
1118d252 3841
92f01d61
JM		 3842 if (REPORT_BUGS_TO[0] && stream == stdout)
3843 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3844
92f01d61 3845 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3846}
3847
18bd398b
NC		 3848/* Record the fact that the user wants the contents of section number
3849 SECTION to be displayed using the method(s) encoded as flags bits
3850 in TYPE. Note, TYPE can be zero if we are creating the array for
3851 the first time. */
3852
252b5132 3853static void
09c11c86 3854request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3855{
3856 if (section >= num_dump_sects)
3857 {
2cf0635d 3858 dump_type * new_dump_sects;
252b5132 3859
3f5e193b
NC		 3860 new_dump_sects = (dump_type *) calloc (section + 1,
3861 sizeof (* dump_sects));
252b5132
RH		 3862
3863 if (new_dump_sects == NULL)
591a748a 3864 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3865 else
3866 {
3867 /* Copy current flag settings. */
09c11c86 3868 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3869
3870 free (dump_sects);
3871
3872 dump_sects = new_dump_sects;
3873 num_dump_sects = section + 1;
3874 }
3875 }
3876
3877 if (dump_sects)
b34976b6 3878 dump_sects[section] |= type;
252b5132
RH		 3879
3880 return;
3881}
3882
aef1f6d0
DJ		 3883/* Request a dump by section name. */
3884
3885static void
2cf0635d 3886request_dump_byname (const char * section, dump_type type)
aef1f6d0 3887{
2cf0635d 3888 struct dump_list_entry * new_request;
aef1f6d0 3889
3f5e193b
NC		 3890 new_request = (struct dump_list_entry *)
3891 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3892 if (!new_request)
591a748a 3893 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3894
3895 new_request->name = strdup (section);
3896 if (!new_request->name)
591a748a 3897 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3898
3899 new_request->type = type;
3900
3901 new_request->next = dump_sects_byname;
3902 dump_sects_byname = new_request;
3903}
3904
cf13d699
NC		 3905static inline void
3906request_dump (dump_type type)
3907{
3908 int section;
3909 char * cp;
3910
3911 do_dump++;
3912 section = strtoul (optarg, & cp, 0);
3913
3914 if (! *cp && section >= 0)
3915 request_dump_bynumber (section, type);
3916 else
3917 request_dump_byname (optarg, type);
3918}
3919
3920
252b5132 3921static void
2cf0635d 3922parse_args (int argc, char ** argv)
252b5132
RH		 3923{
3924 int c;
3925
3926 if (argc < 2)
92f01d61 3927 usage (stderr);
252b5132
RH		 3928
3929 while ((c = getopt_long
cf13d699 3930 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3931 {
252b5132
RH		 3932 switch (c)
3933 {
3934 case 0:
3935 /* Long options. */
3936 break;
3937 case 'H':
92f01d61 3938 usage (stdout);
252b5132
RH		 3939 break;
3940
3941 case 'a':
b34976b6
AM		 3942 do_syms++;
3943 do_reloc++;
3944 do_unwind++;
3945 do_dynamic++;
3946 do_header++;
3947 do_sections++;
f5842774 3948 do_section_groups++;
b34976b6
AM		 3949 do_segments++;
3950 do_version++;
3951 do_histogram++;
3952 do_arch++;
3953 do_notes++;
252b5132 3954 break;
f5842774
L		 3955 case 'g':
3956 do_section_groups++;
3957 break;
5477e8a0 3958 case 't':
595cf52e 3959 case 'N':
5477e8a0
L		 3960 do_sections++;
3961 do_section_details++;
595cf52e 3962 break;
252b5132 3963 case 'e':
b34976b6
AM		 3964 do_header++;
3965 do_sections++;
3966 do_segments++;
252b5132 3967 break;
a952a375 3968 case 'A':
b34976b6 3969 do_arch++;
a952a375 3970 break;
252b5132 3971 case 'D':
b34976b6 3972 do_using_dynamic++;
252b5132
RH		 3973 break;
3974 case 'r':
b34976b6 3975 do_reloc++;
252b5132 3976 break;
4d6ed7c8 3977 case 'u':
b34976b6 3978 do_unwind++;
4d6ed7c8 3979 break;
252b5132 3980 case 'h':
b34976b6 3981 do_header++;
252b5132
RH		 3982 break;
3983 case 'l':
b34976b6 3984 do_segments++;
252b5132
RH		 3985 break;
3986 case 's':
b34976b6 3987 do_syms++;
252b5132
RH		 3988 break;
3989 case 'S':
b34976b6 3990 do_sections++;
252b5132
RH		 3991 break;
3992 case 'd':
b34976b6 3993 do_dynamic++;
252b5132 3994 break;
a952a375 3995 case 'I':
b34976b6 3996 do_histogram++;
a952a375 3997 break;
779fe533 3998 case 'n':
b34976b6 3999 do_notes++;
779fe533 4000 break;
4145f1d5
NC		 4001 case 'c':
4002 do_archive_index++;
4003 break;
252b5132 4004 case 'x':
cf13d699 4005 request_dump (HEX_DUMP);
aef1f6d0 4006 break;
09c11c86 4007 case 'p':
cf13d699
NC		 4008 request_dump (STRING_DUMP);
4009 break;
4010 case 'R':
4011 request_dump (RELOC_DUMP);
09c11c86 4012 break;
252b5132 4013 case 'w':
b34976b6 4014 do_dump++;
252b5132 4015 if (optarg == 0)
613ff48b
CC		 4016 {
4017 do_debugging = 1;
4018 dwarf_select_sections_all ();
4019 }
252b5132
RH		 4020 else
4021 {
4022 do_debugging = 0;
4cb93e3b 4023 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4024 }
4025 break;
2979dc34 4026 case OPTION_DEBUG_DUMP:
b34976b6 4027 do_dump++;
2979dc34
JJ		 4028 if (optarg == 0)
4029 do_debugging = 1;
4030 else
4031 {
2979dc34 4032 do_debugging = 0;
4cb93e3b 4033 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4034 }
4035 break;
fd2f0033
TT		 4036 case OPTION_DWARF_DEPTH:
4037 {
4038 char *cp;
4039
4040 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4041 }
4042 break;
4043 case OPTION_DWARF_START:
4044 {
4045 char *cp;
4046
4047 dwarf_start_die = strtoul (optarg, & cp, 0);
4048 }
4049 break;
4723351a
CC		 4050 case OPTION_DWARF_CHECK:
4051 dwarf_check = 1;
4052 break;
2c610e4b
L		 4053 case OPTION_DYN_SYMS:
4054 do_dyn_syms++;
4055 break;
252b5132
RH		 4056#ifdef SUPPORT_DISASSEMBLY
4057 case 'i':
cf13d699
NC		 4058 request_dump (DISASS_DUMP);
4059 break;
252b5132
RH		 4060#endif
4061 case 'v':
4062 print_version (program_name);
4063 break;
4064 case 'V':
b34976b6 4065 do_version++;
252b5132 4066 break;
d974e256 4067 case 'W':
b34976b6 4068 do_wide++;
d974e256 4069 break;
252b5132 4070 default:
252b5132
RH		 4071 /* xgettext:c-format */
4072 error (_("Invalid option '-%c'\n"), c);
4073 /* Drop through. */
4074 case '?':
92f01d61 4075 usage (stderr);
252b5132
RH		 4076 }
4077 }
4078
4d6ed7c8 4079 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4080 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4081 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4082 && !do_section_groups && !do_archive_index
4083 && !do_dyn_syms)
92f01d61 4084 usage (stderr);
252b5132
RH		 4085 else if (argc < 3)
4086 {
4087 warn (_("Nothing to do.\n"));
92f01d61 4088 usage (stderr);
252b5132
RH		 4089 }
4090}
4091
4092static const char *
d3ba0551 4093get_elf_class (unsigned int elf_class)
252b5132 4094{
b34976b6 4095 static char buff[32];
103f02d3 4096
252b5132
RH		 4097 switch (elf_class)
4098 {
4099 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4100 case ELFCLASS32: return "ELF32";
4101 case ELFCLASS64: return "ELF64";
ab5e7794 4102 default:
e9e44622 4103 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4104 return buff;
252b5132
RH		 4105 }
4106}
4107
4108static const char *
d3ba0551 4109get_data_encoding (unsigned int encoding)
252b5132 4110{
b34976b6 4111 static char buff[32];
103f02d3 4112
252b5132
RH		 4113 switch (encoding)
4114 {
4115 case ELFDATANONE: return _("none");
33c63f9d
CM		 4116 case ELFDATA2LSB: return _("2's complement, little endian");
4117 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4118 default:
e9e44622 4119 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4120 return buff;
252b5132
RH		 4121 }
4122}
4123
252b5132 4124/* Decode the data held in 'elf_header'. */
ee42cf8c 4125
252b5132 4126static int
d3ba0551 4127process_file_header (void)
252b5132 4128{
b34976b6
AM		 4129 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4130 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4131 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4132 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4133 {
4134 error
4135 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4136 return 0;
4137 }
4138
2dc4cec1
L		 4139 init_dwarf_regnames (elf_header.e_machine);
4140
252b5132
RH		 4141 if (do_header)
4142 {
4143 int i;
4144
4145 printf (_("ELF Header:\n"));
4146 printf (_(" Magic: "));
b34976b6
AM		 4147 for (i = 0; i < EI_NIDENT; i++)
4148 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4149 printf ("\n");
4150 printf (_(" Class: %s\n"),
b34976b6 4151 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4152 printf (_(" Data: %s\n"),
b34976b6 4153 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4154 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4155 elf_header.e_ident[EI_VERSION],
4156 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4157 ? "(current)"
b34976b6 4158 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4159 ? _("<unknown: %lx>")
789be9f7 4160 : "")));
252b5132 4161 printf (_(" OS/ABI: %s\n"),
b34976b6 4162 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4163 printf (_(" ABI Version: %d\n"),
b34976b6 4164 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4165 printf (_(" Type: %s\n"),
4166 get_file_type (elf_header.e_type));
4167 printf (_(" Machine: %s\n"),
4168 get_machine_name (elf_header.e_machine));
4169 printf (_(" Version: 0x%lx\n"),
4170 (unsigned long) elf_header.e_version);
76da6bbe 4171
f7a99963
NC		 4172 printf (_(" Entry point address: "));
4173 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4174 printf (_("\n Start of program headers: "));
4175 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4176 printf (_(" (bytes into file)\n Start of section headers: "));
4177 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4178 printf (_(" (bytes into file)\n"));
76da6bbe 4179
252b5132
RH		 4180 printf (_(" Flags: 0x%lx%s\n"),
4181 (unsigned long) elf_header.e_flags,
4182 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4183 printf (_(" Size of this header: %ld (bytes)\n"),
4184 (long) elf_header.e_ehsize);
4185 printf (_(" Size of program headers: %ld (bytes)\n"),
4186 (long) elf_header.e_phentsize);
2046a35d 4187 printf (_(" Number of program headers: %ld"),
252b5132 4188 (long) elf_header.e_phnum);
2046a35d
AM		 4189 if (section_headers != NULL
4190 && elf_header.e_phnum == PN_XNUM
4191 && section_headers[0].sh_info != 0)
cc5914eb 4192 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4193 putc ('\n', stdout);
252b5132
RH		 4194 printf (_(" Size of section headers: %ld (bytes)\n"),
4195 (long) elf_header.e_shentsize);
560f3c1c 4196 printf (_(" Number of section headers: %ld"),
252b5132 4197 (long) elf_header.e_shnum);
4fbb74a6 4198 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4199 printf (" (%ld)", (long) section_headers[0].sh_size);
4200 putc ('\n', stdout);
4201 printf (_(" Section header string table index: %ld"),
252b5132 4202 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4203 if (section_headers != NULL
4204 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4205 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4206 else if (elf_header.e_shstrndx != SHN_UNDEF
4207 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4208 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4209 putc ('\n', stdout);
4210 }
4211
4212 if (section_headers != NULL)
4213 {
2046a35d
AM		 4214 if (elf_header.e_phnum == PN_XNUM
4215 && section_headers[0].sh_info != 0)
4216 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4217 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4218 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4219 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4220 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4221 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4222 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4223 free (section_headers);
4224 section_headers = NULL;
252b5132 4225 }
103f02d3 4226
9ea033b2
NC		 4227 return 1;
4228}
4229
e0a31db1 4230static bfd_boolean
91d6fa6a 4231get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4232{
2cf0635d
NC		 4233 Elf32_External_Phdr * phdrs;
4234 Elf32_External_Phdr * external;
4235 Elf_Internal_Phdr * internal;
b34976b6 4236 unsigned int i;
e0a31db1
NC		 4237 unsigned int size = elf_header.e_phentsize;
4238 unsigned int num = elf_header.e_phnum;
4239
4240 /* PR binutils/17531: Cope with unexpected section header sizes. */
4241 if (size == 0 || num == 0)
4242 return FALSE;
4243 if (size < sizeof * phdrs)
4244 {
4245 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4246 return FALSE;
4247 }
4248 if (size > sizeof * phdrs)
4249 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4250
3f5e193b 4251 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4252 size, num, _("program headers"));
4253 if (phdrs == NULL)
4254 return FALSE;
9ea033b2 4255
91d6fa6a 4256 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4257 i < elf_header.e_phnum;
b34976b6 4258 i++, internal++, external++)
252b5132 4259 {
9ea033b2
NC		 4260 internal->p_type = BYTE_GET (external->p_type);
4261 internal->p_offset = BYTE_GET (external->p_offset);
4262 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4263 internal->p_paddr = BYTE_GET (external->p_paddr);
4264 internal->p_filesz = BYTE_GET (external->p_filesz);
4265 internal->p_memsz = BYTE_GET (external->p_memsz);
4266 internal->p_flags = BYTE_GET (external->p_flags);
4267 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4268 }
4269
9ea033b2 4270 free (phdrs);
e0a31db1 4271 return TRUE;
252b5132
RH		 4272}
4273
e0a31db1 4274static bfd_boolean
91d6fa6a 4275get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4276{
2cf0635d
NC		 4277 Elf64_External_Phdr * phdrs;
4278 Elf64_External_Phdr * external;
4279 Elf_Internal_Phdr * internal;
b34976b6 4280 unsigned int i;
e0a31db1
NC		 4281 unsigned int size = elf_header.e_phentsize;
4282 unsigned int num = elf_header.e_phnum;
4283
4284 /* PR binutils/17531: Cope with unexpected section header sizes. */
4285 if (size == 0 || num == 0)
4286 return FALSE;
4287 if (size < sizeof * phdrs)
4288 {
4289 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4290 return FALSE;
4291 }
4292 if (size > sizeof * phdrs)
4293 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4294
3f5e193b 4295 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4296 size, num, _("program headers"));
a6e9f9df 4297 if (!phdrs)
e0a31db1 4298 return FALSE;
9ea033b2 4299
91d6fa6a 4300 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4301 i < elf_header.e_phnum;
b34976b6 4302 i++, internal++, external++)
9ea033b2
NC		 4303 {
4304 internal->p_type = BYTE_GET (external->p_type);
4305 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4306 internal->p_offset = BYTE_GET (external->p_offset);
4307 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4308 internal->p_paddr = BYTE_GET (external->p_paddr);
4309 internal->p_filesz = BYTE_GET (external->p_filesz);
4310 internal->p_memsz = BYTE_GET (external->p_memsz);
4311 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4312 }
4313
4314 free (phdrs);
e0a31db1 4315 return TRUE;
9ea033b2 4316}
252b5132 4317
d93f0186
NC		 4318/* Returns 1 if the program headers were read into `program_headers'. */
4319
4320static int
2cf0635d 4321get_program_headers (FILE * file)
d93f0186 4322{
2cf0635d 4323 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4324
4325 /* Check cache of prior read. */
4326 if (program_headers != NULL)
4327 return 1;
4328
3f5e193b
NC		 4329 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4330 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4331
4332 if (phdrs == NULL)
4333 {
8b73c356
NC		 4334 error (_("Out of memory reading %u program headers\n"),
4335 elf_header.e_phnum);
d93f0186
NC		 4336 return 0;
4337 }
4338
4339 if (is_32bit_elf
4340 ? get_32bit_program_headers (file, phdrs)
4341 : get_64bit_program_headers (file, phdrs))
4342 {
4343 program_headers = phdrs;
4344 return 1;
4345 }
4346
4347 free (phdrs);
4348 return 0;
4349}
4350
2f62977e
NC		 4351/* Returns 1 if the program headers were loaded. */
4352
252b5132 4353static int
2cf0635d 4354process_program_headers (FILE * file)
252b5132 4355{
2cf0635d 4356 Elf_Internal_Phdr * segment;
b34976b6 4357 unsigned int i;
252b5132
RH		 4358
4359 if (elf_header.e_phnum == 0)
4360 {
82f2dbf7
NC		 4361 /* PR binutils/12467. */
4362 if (elf_header.e_phoff != 0)
4363 warn (_("possibly corrupt ELF header - it has a non-zero program"
4364 " header offset, but no program headers"));
4365 else if (do_segments)
252b5132 4366 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4367 return 0;
252b5132
RH		 4368 }
4369
4370 if (do_segments && !do_header)
4371 {
f7a99963
NC		 4372 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4373 printf (_("Entry point "));
4374 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4375 printf (_("\nThere are %d program headers, starting at offset "),
4376 elf_header.e_phnum);
4377 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4378 printf ("\n");
252b5132
RH		 4379 }
4380
d93f0186 4381 if (! get_program_headers (file))
252b5132 4382 return 0;
103f02d3 4383
252b5132
RH		 4384 if (do_segments)
4385 {
3a1a2036
NC		 4386 if (elf_header.e_phnum > 1)
4387 printf (_("\nProgram Headers:\n"));
4388 else
4389 printf (_("\nProgram Headers:\n"));
76da6bbe 4390
f7a99963
NC		 4391 if (is_32bit_elf)
4392 printf
4393 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4394 else if (do_wide)
4395 printf
4396 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4397 else
4398 {
4399 printf
4400 (_(" Type Offset VirtAddr PhysAddr\n"));
4401 printf
4402 (_(" FileSiz MemSiz Flags Align\n"));
4403 }
252b5132
RH		 4404 }
4405
252b5132 4406 dynamic_addr = 0;
1b228002 4407 dynamic_size = 0;
252b5132
RH		 4408
4409 for (i = 0, segment = program_headers;
4410 i < elf_header.e_phnum;
b34976b6 4411 i++, segment++)
252b5132
RH		 4412 {
4413 if (do_segments)
4414 {
103f02d3 4415 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4416
4417 if (is_32bit_elf)
4418 {
4419 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4420 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4421 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4422 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4423 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4424 printf ("%c%c%c ",
4425 (segment->p_flags & PF_R ? 'R' : ' '),
4426 (segment->p_flags & PF_W ? 'W' : ' '),
4427 (segment->p_flags & PF_X ? 'E' : ' '));
4428 printf ("%#lx", (unsigned long) segment->p_align);
4429 }
d974e256
JJ		 4430 else if (do_wide)
4431 {
4432 if ((unsigned long) segment->p_offset == segment->p_offset)
4433 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4434 else
4435 {
4436 print_vma (segment->p_offset, FULL_HEX);
4437 putchar (' ');
4438 }
4439
4440 print_vma (segment->p_vaddr, FULL_HEX);
4441 putchar (' ');
4442 print_vma (segment->p_paddr, FULL_HEX);
4443 putchar (' ');
4444
4445 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4446 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4447 else
4448 {
4449 print_vma (segment->p_filesz, FULL_HEX);
4450 putchar (' ');
4451 }
4452
4453 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4454 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4455 else
4456 {
f48e6c45 4457 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4458 }
4459
4460 printf (" %c%c%c ",
4461 (segment->p_flags & PF_R ? 'R' : ' '),
4462 (segment->p_flags & PF_W ? 'W' : ' '),
4463 (segment->p_flags & PF_X ? 'E' : ' '));
4464
4465 if ((unsigned long) segment->p_align == segment->p_align)
4466 printf ("%#lx", (unsigned long) segment->p_align);
4467 else
4468 {
4469 print_vma (segment->p_align, PREFIX_HEX);
4470 }
4471 }
f7a99963
NC		 4472 else
4473 {
4474 print_vma (segment->p_offset, FULL_HEX);
4475 putchar (' ');
4476 print_vma (segment->p_vaddr, FULL_HEX);
4477 putchar (' ');
4478 print_vma (segment->p_paddr, FULL_HEX);
4479 printf ("\n ");
4480 print_vma (segment->p_filesz, FULL_HEX);
4481 putchar (' ');
4482 print_vma (segment->p_memsz, FULL_HEX);
4483 printf (" %c%c%c ",
4484 (segment->p_flags & PF_R ? 'R' : ' '),
4485 (segment->p_flags & PF_W ? 'W' : ' '),
4486 (segment->p_flags & PF_X ? 'E' : ' '));
4487 print_vma (segment->p_align, HEX);
4488 }
252b5132
RH		 4489 }
4490
f54498b4
NC		 4491 if (do_segments)
4492 putc ('\n', stdout);
4493
252b5132
RH		 4494 switch (segment->p_type)
4495 {
252b5132
RH		 4496 case PT_DYNAMIC:
4497 if (dynamic_addr)
4498 error (_("more than one dynamic segment\n"));
4499
20737c13
AM		 4500 /* By default, assume that the .dynamic section is the first
4501 section in the DYNAMIC segment. */
4502 dynamic_addr = segment->p_offset;
4503 dynamic_size = segment->p_filesz;
f54498b4
NC		 4504 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4505 if (dynamic_addr + dynamic_size >= current_file_size)
4506 {
4507 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4508 dynamic_addr = dynamic_size = 0;
4509 }
20737c13 4510
b2d38a17
NC		 4511 /* Try to locate the .dynamic section. If there is
4512 a section header table, we can easily locate it. */
4513 if (section_headers != NULL)
4514 {
2cf0635d 4515 Elf_Internal_Shdr * sec;
b2d38a17 4516
89fac5e3
RS		 4517 sec = find_section (".dynamic");
4518 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4519 {
28f997cf
TG		 4520 /* A corresponding .dynamic section is expected, but on
4521 IA-64/OpenVMS it is OK for it to be missing. */
4522 if (!is_ia64_vms ())
4523 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4524 break;
4525 }
4526
42bb2e33 4527 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4528 {
4529 dynamic_size = 0;
4530 break;
4531 }
42bb2e33 4532
b2d38a17
NC		 4533 dynamic_addr = sec->sh_offset;
4534 dynamic_size = sec->sh_size;
4535
4536 if (dynamic_addr < segment->p_offset
4537 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4538 warn (_("the .dynamic section is not contained"
4539 " within the dynamic segment\n"));
b2d38a17 4540 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4541 warn (_("the .dynamic section is not the first section"
4542 " in the dynamic segment.\n"));
b2d38a17 4543 }
252b5132
RH		 4544 break;
4545
4546 case PT_INTERP:
fb52b2f4
NC		 4547 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4548 SEEK_SET))
252b5132
RH		 4549 error (_("Unable to find program interpreter name\n"));
4550 else
4551 {
f8eae8b2 4552 char fmt [32];
9495b2e6 4553 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4554
4555 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4556 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4557
252b5132 4558 program_interpreter[0] = 0;
7bd7b3ef
AM		 4559 if (fscanf (file, fmt, program_interpreter) <= 0)
4560 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4561
4562 if (do_segments)
f54498b4 4563 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4564 program_interpreter);
4565 }
4566 break;
4567 }
252b5132
RH		 4568 }
4569
c256ffe7 4570 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4571 {
4572 printf (_("\n Section to Segment mapping:\n"));
4573 printf (_(" Segment Sections...\n"));
4574
252b5132
RH		 4575 for (i = 0; i < elf_header.e_phnum; i++)
4576 {
9ad5cbcf 4577 unsigned int j;
2cf0635d 4578 Elf_Internal_Shdr * section;
252b5132
RH		 4579
4580 segment = program_headers + i;
b391a3e3 4581 section = section_headers + 1;
252b5132
RH		 4582
4583 printf (" %2.2d ", i);
4584
b34976b6 4585 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4586 {
f4638467
AM		 4587 if (!ELF_TBSS_SPECIAL (section, segment)
4588 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4589 printf ("%s ", printable_section_name (section));
252b5132
RH		 4590 }
4591
4592 putc ('\n',stdout);
4593 }
4594 }
4595
252b5132
RH		 4596 return 1;
4597}
4598
4599
d93f0186
NC		 4600/* Find the file offset corresponding to VMA by using the program headers. */
4601
4602static long
2cf0635d 4603offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4604{
2cf0635d 4605 Elf_Internal_Phdr * seg;
d93f0186
NC		 4606
4607 if (! get_program_headers (file))
4608 {
4609 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4610 return (long) vma;
4611 }
4612
4613 for (seg = program_headers;
4614 seg < program_headers + elf_header.e_phnum;
4615 ++seg)
4616 {
4617 if (seg->p_type != PT_LOAD)
4618 continue;
4619
4620 if (vma >= (seg->p_vaddr & -seg->p_align)
4621 && vma + size <= seg->p_vaddr + seg->p_filesz)
4622 return vma - seg->p_vaddr + seg->p_offset;
4623 }
4624
4625 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4626 (unsigned long) vma);
d93f0186
NC		 4627 return (long) vma;
4628}
4629
4630
049b0c3a
NC		 4631/* Allocate memory and load the sections headers into the global pointer
4632 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4633 generate any error messages if the load fails. */
4634
4635static bfd_boolean
4636get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4637{
2cf0635d
NC		 4638 Elf32_External_Shdr * shdrs;
4639 Elf_Internal_Shdr * internal;
b34976b6 4640 unsigned int i;
049b0c3a
NC		 4641 unsigned int size = elf_header.e_shentsize;
4642 unsigned int num = probe ? 1 : elf_header.e_shnum;
4643
4644 /* PR binutils/17531: Cope with unexpected section header sizes. */
4645 if (size == 0 || num == 0)
4646 return FALSE;
4647 if (size < sizeof * shdrs)
4648 {
4649 if (! probe)
4650 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4651 return FALSE;
4652 }
4653 if (!probe && size > sizeof * shdrs)
4654 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4655
3f5e193b 4656 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4657 size, num,
4658 probe ? NULL : _("section headers"));
4659 if (shdrs == NULL)
4660 return FALSE;
252b5132 4661
049b0c3a
NC		 4662 if (section_headers != NULL)
4663 free (section_headers);
3f5e193b
NC		 4664 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4665 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4666 if (section_headers == NULL)
4667 {
049b0c3a 4668 if (!probe)
8b73c356 4669 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4670 return FALSE;
252b5132
RH		 4671 }
4672
4673 for (i = 0, internal = section_headers;
560f3c1c 4674 i < num;
b34976b6 4675 i++, internal++)
252b5132
RH		 4676 {
4677 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4678 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4679 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4680 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4681 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4682 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4683 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4684 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4685 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4686 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4687 }
4688
4689 free (shdrs);
049b0c3a 4690 return TRUE;
252b5132
RH		 4691}
4692
049b0c3a
NC		 4693static bfd_boolean
4694get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4695{
2cf0635d
NC		 4696 Elf64_External_Shdr * shdrs;
4697 Elf_Internal_Shdr * internal;
b34976b6 4698 unsigned int i;
049b0c3a
NC		 4699 unsigned int size = elf_header.e_shentsize;
4700 unsigned int num = probe ? 1 : elf_header.e_shnum;
4701
4702 /* PR binutils/17531: Cope with unexpected section header sizes. */
4703 if (size == 0 || num == 0)
4704 return FALSE;
4705 if (size < sizeof * shdrs)
4706 {
4707 if (! probe)
4708 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4709 return FALSE;
4710 }
4711 if (! probe && size > sizeof * shdrs)
4712 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4713
3f5e193b 4714 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4715 size, num,
4716 probe ? NULL : _("section headers"));
4717 if (shdrs == NULL)
4718 return FALSE;
9ea033b2 4719
049b0c3a
NC		 4720 if (section_headers != NULL)
4721 free (section_headers);
3f5e193b
NC		 4722 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4723 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4724 if (section_headers == NULL)
4725 {
049b0c3a 4726 if (! probe)
8b73c356 4727 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4728 return FALSE;
9ea033b2
NC		 4729 }
4730
4731 for (i = 0, internal = section_headers;
560f3c1c 4732 i < num;
b34976b6 4733 i++, internal++)
9ea033b2
NC		 4734 {
4735 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4736 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4737 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4738 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4739 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4740 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4741 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4742 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4743 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4744 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4745 }
4746
4747 free (shdrs);
049b0c3a 4748 return TRUE;
9ea033b2
NC		 4749}
4750
252b5132 4751static Elf_Internal_Sym *
ba5cdace
NC		 4752get_32bit_elf_symbols (FILE * file,
4753 Elf_Internal_Shdr * section,
4754 unsigned long * num_syms_return)
252b5132 4755{
ba5cdace 4756 unsigned long number = 0;
dd24e3da 4757 Elf32_External_Sym * esyms = NULL;
ba5cdace 4758 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4759 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4760 Elf_Internal_Sym * psym;
b34976b6 4761 unsigned int j;
252b5132 4762
c9c1d674
EG		 4763 if (section->sh_size == 0)
4764 {
4765 if (num_syms_return != NULL)
4766 * num_syms_return = 0;
4767 return NULL;
4768 }
4769
dd24e3da 4770 /* Run some sanity checks first. */
c9c1d674 4771 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4772 {
c9c1d674
EG		 4773 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4774 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4775 goto exit_point;
dd24e3da
NC		 4776 }
4777
f54498b4
NC		 4778 if (section->sh_size > current_file_size)
4779 {
4780 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4781 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4782 goto exit_point;
4783 }
4784
dd24e3da
NC		 4785 number = section->sh_size / section->sh_entsize;
4786
4787 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4788 {
c9c1d674 4789 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4790 (unsigned long) section->sh_size,
4791 printable_section_name (section),
4792 (unsigned long) section->sh_entsize);
ba5cdace 4793 goto exit_point;
dd24e3da
NC		 4794 }
4795
3f5e193b
NC		 4796 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4797 section->sh_size, _("symbols"));
dd24e3da 4798 if (esyms == NULL)
ba5cdace 4799 goto exit_point;
252b5132 4800
9ad5cbcf
AM		 4801 shndx = NULL;
4802 if (symtab_shndx_hdr != NULL
4803 && (symtab_shndx_hdr->sh_link
4fbb74a6 4804 == (unsigned long) (section - section_headers)))
9ad5cbcf 4805 {
3f5e193b
NC		 4806 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4807 symtab_shndx_hdr->sh_offset,
4808 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4809 _("symbol table section indicies"));
dd24e3da
NC		 4810 if (shndx == NULL)
4811 goto exit_point;
c9c1d674
EG		 4812 /* PR17531: file: heap-buffer-overflow */
4813 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4814 {
4815 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4816 printable_section_name (symtab_shndx_hdr),
4817 (unsigned long) symtab_shndx_hdr->sh_size,
4818 (unsigned long) section->sh_size);
4819 goto exit_point;
4820 }
9ad5cbcf
AM		 4821 }
4822
3f5e193b 4823 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4824
4825 if (isyms == NULL)
4826 {
8b73c356
NC		 4827 error (_("Out of memory reading %lu symbols\n"),
4828 (unsigned long) number);
dd24e3da 4829 goto exit_point;
252b5132
RH		 4830 }
4831
dd24e3da 4832 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4833 {
4834 psym->st_name = BYTE_GET (esyms[j].st_name);
4835 psym->st_value = BYTE_GET (esyms[j].st_value);
4836 psym->st_size = BYTE_GET (esyms[j].st_size);
4837 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4838 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4839 psym->st_shndx
4840 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4841 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4842 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4843 psym->st_info = BYTE_GET (esyms[j].st_info);
4844 psym->st_other = BYTE_GET (esyms[j].st_other);
4845 }
4846
dd24e3da 4847 exit_point:
ba5cdace 4848 if (shndx != NULL)
9ad5cbcf 4849 free (shndx);
ba5cdace 4850 if (esyms != NULL)
dd24e3da 4851 free (esyms);
252b5132 4852
ba5cdace
NC		 4853 if (num_syms_return != NULL)
4854 * num_syms_return = isyms == NULL ? 0 : number;
4855
252b5132
RH		 4856 return isyms;
4857}
4858
9ea033b2 4859static Elf_Internal_Sym *
ba5cdace
NC		 4860get_64bit_elf_symbols (FILE * file,
4861 Elf_Internal_Shdr * section,
4862 unsigned long * num_syms_return)
9ea033b2 4863{
ba5cdace
NC		 4864 unsigned long number = 0;
4865 Elf64_External_Sym * esyms = NULL;
4866 Elf_External_Sym_Shndx * shndx = NULL;
4867 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4868 Elf_Internal_Sym * psym;
b34976b6 4869 unsigned int j;
9ea033b2 4870
c9c1d674
EG		 4871 if (section->sh_size == 0)
4872 {
4873 if (num_syms_return != NULL)
4874 * num_syms_return = 0;
4875 return NULL;
4876 }
4877
dd24e3da 4878 /* Run some sanity checks first. */
c9c1d674 4879 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4880 {
c9c1d674 4881 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 4882 printable_section_name (section),
4883 (unsigned long) section->sh_entsize);
ba5cdace 4884 goto exit_point;
dd24e3da
NC		 4885 }
4886
f54498b4
NC		 4887 if (section->sh_size > current_file_size)
4888 {
4889 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 4890 printable_section_name (section),
4891 (unsigned long) section->sh_size);
f54498b4
NC		 4892 goto exit_point;
4893 }
4894
dd24e3da
NC		 4895 number = section->sh_size / section->sh_entsize;
4896
4897 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4898 {
c9c1d674 4899 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4900 (unsigned long) section->sh_size,
4901 printable_section_name (section),
4902 (unsigned long) section->sh_entsize);
ba5cdace 4903 goto exit_point;
dd24e3da
NC		 4904 }
4905
3f5e193b
NC		 4906 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4907 section->sh_size, _("symbols"));
a6e9f9df 4908 if (!esyms)
ba5cdace 4909 goto exit_point;
9ea033b2 4910
9ad5cbcf
AM		 4911 if (symtab_shndx_hdr != NULL
4912 && (symtab_shndx_hdr->sh_link
4fbb74a6 4913 == (unsigned long) (section - section_headers)))
9ad5cbcf 4914 {
3f5e193b
NC		 4915 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4916 symtab_shndx_hdr->sh_offset,
4917 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4918 _("symbol table section indicies"));
ba5cdace
NC		 4919 if (shndx == NULL)
4920 goto exit_point;
c9c1d674
EG		 4921 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4922 {
4923 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4924 printable_section_name (symtab_shndx_hdr),
4925 (unsigned long) symtab_shndx_hdr->sh_size,
4926 (unsigned long) section->sh_size);
4927 goto exit_point;
4928 }
9ad5cbcf
AM		 4929 }
4930
3f5e193b 4931 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4932
4933 if (isyms == NULL)
4934 {
8b73c356
NC		 4935 error (_("Out of memory reading %lu symbols\n"),
4936 (unsigned long) number);
ba5cdace 4937 goto exit_point;
9ea033b2
NC		 4938 }
4939
ba5cdace 4940 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4941 {
4942 psym->st_name = BYTE_GET (esyms[j].st_name);
4943 psym->st_info = BYTE_GET (esyms[j].st_info);
4944 psym->st_other = BYTE_GET (esyms[j].st_other);
4945 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4946
4fbb74a6 4947 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4948 psym->st_shndx
4949 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4950 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4951 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4952
66543521
AM		 4953 psym->st_value = BYTE_GET (esyms[j].st_value);
4954 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4955 }
4956
ba5cdace
NC		 4957 exit_point:
4958 if (shndx != NULL)
9ad5cbcf 4959 free (shndx);
ba5cdace
NC		 4960 if (esyms != NULL)
4961 free (esyms);
4962
4963 if (num_syms_return != NULL)
4964 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4965
4966 return isyms;
4967}
4968
d1133906 4969static const char *
d3ba0551 4970get_elf_section_flags (bfd_vma sh_flags)
d1133906 4971{
5477e8a0 4972 static char buff[1024];
2cf0635d 4973 char * p = buff;
8d5ff12c 4974 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4975 int sindex;
4976 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4977 bfd_vma os_flags = 0;
4978 bfd_vma proc_flags = 0;
4979 bfd_vma unknown_flags = 0;
148b93f2 4980 static const struct
5477e8a0 4981 {
2cf0635d 4982 const char * str;
5477e8a0
L		 4983 int len;
4984 }
4985 flags [] =
4986 {
cfcac11d
NC		 4987 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4988 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4989 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4990 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4991 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4992 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4993 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4994 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4995 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4996 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4997 /* IA-64 specific. */
4998 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4999 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5000 /* IA-64 OpenVMS specific. */
5001 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5002 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5003 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5004 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5005 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5006 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5007 /* Generic. */
cfcac11d 5008 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5009 /* SPARC specific. */
cfcac11d 5010 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 5011 };
5012
5013 if (do_section_details)
5014 {
8d5ff12c
L		 5015 sprintf (buff, "[%*.*lx]: ",
5016 field_size, field_size, (unsigned long) sh_flags);
5017 p += field_size + 4;
5477e8a0 5018 }
76da6bbe 5019
d1133906
NC		 5020 while (sh_flags)
5021 {
5022 bfd_vma flag;
5023
5024 flag = sh_flags & - sh_flags;
5025 sh_flags &= ~ flag;
76da6bbe 5026
5477e8a0 5027 if (do_section_details)
d1133906 5028 {
5477e8a0
L		 5029 switch (flag)
5030 {
91d6fa6a
NC		 5031 case SHF_WRITE: sindex = 0; break;
5032 case SHF_ALLOC: sindex = 1; break;
5033 case SHF_EXECINSTR: sindex = 2; break;
5034 case SHF_MERGE: sindex = 3; break;
5035 case SHF_STRINGS: sindex = 4; break;
5036 case SHF_INFO_LINK: sindex = 5; break;
5037 case SHF_LINK_ORDER: sindex = 6; break;
5038 case SHF_OS_NONCONFORMING: sindex = 7; break;
5039 case SHF_GROUP: sindex = 8; break;
5040 case SHF_TLS: sindex = 9; break;
18ae9cc1 5041 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 5042
5477e8a0 5043 default:
91d6fa6a 5044 sindex = -1;
cfcac11d 5045 switch (elf_header.e_machine)
148b93f2 5046 {
cfcac11d 5047 case EM_IA_64:
148b93f2 5048 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5049 sindex = 10;
148b93f2 5050 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5051 sindex = 11;
148b93f2
NC		 5052#ifdef BFD64
5053 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5054 switch (flag)
5055 {
91d6fa6a
NC		 5056 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5057 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5058 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5059 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5060 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5061 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5062 default: break;
5063 }
5064#endif
cfcac11d
NC		 5065 break;
5066
caa83f8b
NC		 5067 case EM_386:
5068 case EM_486:
5069 case EM_X86_64:
7f502d6c 5070 case EM_L1OM:
7a9068fe 5071 case EM_K1OM:
cfcac11d
NC		 5072 case EM_OLD_SPARCV9:
5073 case EM_SPARC32PLUS:
5074 case EM_SPARCV9:
5075 case EM_SPARC:
18ae9cc1 5076 if (flag == SHF_ORDERED)
91d6fa6a 5077 sindex = 19;
cfcac11d
NC		 5078 break;
5079 default:
5080 break;
148b93f2 5081 }
5477e8a0
L		 5082 }
5083
91d6fa6a 5084 if (sindex != -1)
5477e8a0 5085 {
8d5ff12c
L		 5086 if (p != buff + field_size + 4)
5087 {
5088 if (size < (10 + 2))
5089 abort ();
5090 size -= 2;
5091 *p++ = ',';
5092 *p++ = ' ';
5093 }
5094
91d6fa6a
NC		 5095 size -= flags [sindex].len;
5096 p = stpcpy (p, flags [sindex].str);
5477e8a0 5097 }
3b22753a 5098 else if (flag & SHF_MASKOS)
8d5ff12c 5099 os_flags |= flag;
d1133906 5100 else if (flag & SHF_MASKPROC)
8d5ff12c 5101 proc_flags |= flag;
d1133906 5102 else
8d5ff12c 5103 unknown_flags |= flag;
5477e8a0
L		 5104 }
5105 else
5106 {
5107 switch (flag)
5108 {
5109 case SHF_WRITE: *p = 'W'; break;
5110 case SHF_ALLOC: *p = 'A'; break;
5111 case SHF_EXECINSTR: *p = 'X'; break;
5112 case SHF_MERGE: *p = 'M'; break;
5113 case SHF_STRINGS: *p = 'S'; break;
5114 case SHF_INFO_LINK: *p = 'I'; break;
5115 case SHF_LINK_ORDER: *p = 'L'; break;
5116 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5117 case SHF_GROUP: *p = 'G'; break;
5118 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5119 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 5120
5121 default:
8a9036a4 5122 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5123 || elf_header.e_machine == EM_L1OM
5124 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5125 && flag == SHF_X86_64_LARGE)
5126 *p = 'l';
5127 else if (flag & SHF_MASKOS)
5128 {
5129 *p = 'o';
5130 sh_flags &= ~ SHF_MASKOS;
5131 }
5132 else if (flag & SHF_MASKPROC)
5133 {
5134 *p = 'p';
5135 sh_flags &= ~ SHF_MASKPROC;
5136 }
5137 else
5138 *p = 'x';
5139 break;
5140 }
5141 p++;
d1133906
NC		 5142 }
5143 }
76da6bbe 5144
8d5ff12c
L		 5145 if (do_section_details)
5146 {
5147 if (os_flags)
5148 {
5149 size -= 5 + field_size;
5150 if (p != buff + field_size + 4)
5151 {
5152 if (size < (2 + 1))
5153 abort ();
5154 size -= 2;
5155 *p++ = ',';
5156 *p++ = ' ';
5157 }
5158 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5159 (unsigned long) os_flags);
5160 p += 5 + field_size;
5161 }
5162 if (proc_flags)
5163 {
5164 size -= 7 + field_size;
5165 if (p != buff + field_size + 4)
5166 {
5167 if (size < (2 + 1))
5168 abort ();
5169 size -= 2;
5170 *p++ = ',';
5171 *p++ = ' ';
5172 }
5173 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5174 (unsigned long) proc_flags);
5175 p += 7 + field_size;
5176 }
5177 if (unknown_flags)
5178 {
5179 size -= 10 + field_size;
5180 if (p != buff + field_size + 4)
5181 {
5182 if (size < (2 + 1))
5183 abort ();
5184 size -= 2;
5185 *p++ = ',';
5186 *p++ = ' ';
5187 }
2b692964 5188 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5189 (unsigned long) unknown_flags);
5190 p += 10 + field_size;
5191 }
5192 }
5193
e9e44622 5194 *p = '\0';
d1133906
NC		 5195 return buff;
5196}
5197
252b5132 5198static int
2cf0635d 5199process_section_headers (FILE * file)
252b5132 5200{
2cf0635d 5201 Elf_Internal_Shdr * section;
b34976b6 5202 unsigned int i;
252b5132
RH		 5203
5204 section_headers = NULL;
5205
5206 if (elf_header.e_shnum == 0)
5207 {
82f2dbf7
NC		 5208 /* PR binutils/12467. */
5209 if (elf_header.e_shoff != 0)
5210 warn (_("possibly corrupt ELF file header - it has a non-zero"
5211 " section header offset, but no section headers\n"));
5212 else if (do_sections)
252b5132
RH		 5213 printf (_("\nThere are no sections in this file.\n"));
5214
5215 return 1;
5216 }
5217
5218 if (do_sections && !do_header)
9ea033b2 5219 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5220 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5221
9ea033b2
NC		 5222 if (is_32bit_elf)
5223 {
049b0c3a 5224 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5225 return 0;
5226 }
049b0c3a 5227 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5228 return 0;
5229
5230 /* Read in the string table, so that we have names to display. */
0b49d371 5231 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5232 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5233 {
4fbb74a6 5234 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5235
c256ffe7
JJ		 5236 if (section->sh_size != 0)
5237 {
3f5e193b
NC		 5238 string_table = (char *) get_data (NULL, file, section->sh_offset,
5239 1, section->sh_size,
5240 _("string table"));
0de14b54 5241
c256ffe7
JJ		 5242 string_table_length = string_table != NULL ? section->sh_size : 0;
5243 }
252b5132
RH		 5244 }
5245
5246 /* Scan the sections for the dynamic symbol table
e3c8793a 5247 and dynamic string table and debug sections. */
252b5132
RH		 5248 dynamic_symbols = NULL;
5249 dynamic_strings = NULL;
5250 dynamic_syminfo = NULL;
f1ef08cb 5251 symtab_shndx_hdr = NULL;
103f02d3 5252
89fac5e3
RS		 5253 eh_addr_size = is_32bit_elf ? 4 : 8;
5254 switch (elf_header.e_machine)
5255 {
5256 case EM_MIPS:
5257 case EM_MIPS_RS3_LE:
5258 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5259 FDE addresses. However, the ABI also has a semi-official ILP32
5260 variant for which the normal FDE address size rules apply.
5261
5262 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5263 section, where XX is the size of longs in bits. Unfortunately,
5264 earlier compilers provided no way of distinguishing ILP32 objects
5265 from LP64 objects, so if there's any doubt, we should assume that
5266 the official LP64 form is being used. */
5267 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5268 && find_section (".gcc_compiled_long32") == NULL)
5269 eh_addr_size = 8;
5270 break;
0f56a26a
DD		 5271
5272 case EM_H8_300:
5273 case EM_H8_300H:
5274 switch (elf_header.e_flags & EF_H8_MACH)
5275 {
5276 case E_H8_MACH_H8300:
5277 case E_H8_MACH_H8300HN:
5278 case E_H8_MACH_H8300SN:
5279 case E_H8_MACH_H8300SXN:
5280 eh_addr_size = 2;
5281 break;
5282 case E_H8_MACH_H8300H:
5283 case E_H8_MACH_H8300S:
5284 case E_H8_MACH_H8300SX:
5285 eh_addr_size = 4;
5286 break;
5287 }
f4236fe4
DD		 5288 break;
5289
ff7eeb89 5290 case EM_M32C_OLD:
f4236fe4
DD		 5291 case EM_M32C:
5292 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5293 {
5294 case EF_M32C_CPU_M16C:
5295 eh_addr_size = 2;
5296 break;
5297 }
5298 break;
89fac5e3
RS		 5299 }
5300
76ca31c0
NC		 5301#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5302 do \
5303 { \
5304 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5305 if (section->sh_entsize != expected_entsize) \
9dd3a467 5306 { \
76ca31c0
NC		 5307 char buf[40]; \
5308 sprintf_vma (buf, section->sh_entsize); \
5309 /* Note: coded this way so that there is a single string for \
5310 translation. */ \
5311 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5312 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5313 (unsigned) expected_entsize); \
9dd3a467 5314 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5315 } \
5316 } \
08d8fa11 5317 while (0)
9dd3a467
NC		 5318
5319#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5320 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5321 sizeof (Elf64_External_##type))
5322
252b5132
RH		 5323 for (i = 0, section = section_headers;
5324 i < elf_header.e_shnum;
b34976b6 5325 i++, section++)
252b5132 5326 {
2cf0635d 5327 char * name = SECTION_NAME (section);
252b5132
RH		 5328
5329 if (section->sh_type == SHT_DYNSYM)
5330 {
5331 if (dynamic_symbols != NULL)
5332 {
5333 error (_("File contains multiple dynamic symbol tables\n"));
5334 continue;
5335 }
5336
08d8fa11 5337 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5338 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5339 }
5340 else if (section->sh_type == SHT_STRTAB
18bd398b 5341 && streq (name, ".dynstr"))
252b5132
RH		 5342 {
5343 if (dynamic_strings != NULL)
5344 {
5345 error (_("File contains multiple dynamic string tables\n"));
5346 continue;
5347 }
5348
3f5e193b
NC		 5349 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5350 1, section->sh_size,
5351 _("dynamic strings"));
59245841 5352 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5353 }
9ad5cbcf
AM		 5354 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5355 {
5356 if (symtab_shndx_hdr != NULL)
5357 {
5358 error (_("File contains multiple symtab shndx tables\n"));
5359 continue;
5360 }
5361 symtab_shndx_hdr = section;
5362 }
08d8fa11
JJ		 5363 else if (section->sh_type == SHT_SYMTAB)
5364 CHECK_ENTSIZE (section, i, Sym);
5365 else if (section->sh_type == SHT_GROUP)
5366 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5367 else if (section->sh_type == SHT_REL)
5368 CHECK_ENTSIZE (section, i, Rel);
5369 else if (section->sh_type == SHT_RELA)
5370 CHECK_ENTSIZE (section, i, Rela);
252b5132 5371 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5372 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5373 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5374 || do_debug_str || do_debug_loc || do_debug_ranges
5375 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5376 && (const_strneq (name, ".debug_")
5377 || const_strneq (name, ".zdebug_")))
252b5132 5378 {
1b315056
CS		 5379 if (name[1] == 'z')
5380 name += sizeof (".zdebug_") - 1;
5381 else
5382 name += sizeof (".debug_") - 1;
252b5132
RH		 5383
5384 if (do_debugging
4723351a
CC		 5385 || (do_debug_info && const_strneq (name, "info"))
5386 || (do_debug_info && const_strneq (name, "types"))
5387 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5388 || (do_debug_lines && strcmp (name, "line") == 0)
5389 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5390 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5391 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5392 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5393 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5394 || (do_debug_aranges && const_strneq (name, "aranges"))
5395 || (do_debug_ranges && const_strneq (name, "ranges"))
5396 || (do_debug_frames && const_strneq (name, "frame"))
5397 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5398 || (do_debug_macinfo && const_strneq (name, "macro"))
5399 || (do_debug_str && const_strneq (name, "str"))
5400 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5401 || (do_debug_addr && const_strneq (name, "addr"))
5402 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5403 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5404 )
09c11c86 5405 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5406 }
a262ae96 5407 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5408 else if ((do_debugging || do_debug_info)
0112cd26 5409 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5410 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5411 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5412 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5413 else if (do_gdb_index && streq (name, ".gdb_index"))
5414 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5415 /* Trace sections for Itanium VMS. */
5416 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5417 || do_trace_aranges)
5418 && const_strneq (name, ".trace_"))
5419 {
5420 name += sizeof (".trace_") - 1;
5421
5422 if (do_debugging
5423 || (do_trace_info && streq (name, "info"))
5424 || (do_trace_abbrevs && streq (name, "abbrev"))
5425 || (do_trace_aranges && streq (name, "aranges"))
5426 )
5427 request_dump_bynumber (i, DEBUG_DUMP);
5428 }
252b5132
RH		 5429 }
5430
5431 if (! do_sections)
5432 return 1;
5433
3a1a2036
NC		 5434 if (elf_header.e_shnum > 1)
5435 printf (_("\nSection Headers:\n"));
5436 else
5437 printf (_("\nSection Header:\n"));
76da6bbe 5438
f7a99963 5439 if (is_32bit_elf)
595cf52e 5440 {
5477e8a0 5441 if (do_section_details)
595cf52e
L		 5442 {
5443 printf (_(" [Nr] Name\n"));
5477e8a0 5444 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5445 }
5446 else
5447 printf
5448 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5449 }
d974e256 5450 else if (do_wide)
595cf52e 5451 {
5477e8a0 5452 if (do_section_details)
595cf52e
L		 5453 {
5454 printf (_(" [Nr] Name\n"));
5477e8a0 5455 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5456 }
5457 else
5458 printf
5459 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5460 }
f7a99963
NC		 5461 else
5462 {
5477e8a0 5463 if (do_section_details)
595cf52e
L		 5464 {
5465 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5466 printf (_(" Type Address Offset Link\n"));
5467 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5468 }
5469 else
5470 {
5471 printf (_(" [Nr] Name Type Address Offset\n"));
5472 printf (_(" Size EntSize Flags Link Info Align\n"));
5473 }
f7a99963 5474 }
252b5132 5475
5477e8a0
L		 5476 if (do_section_details)
5477 printf (_(" Flags\n"));
5478
252b5132
RH		 5479 for (i = 0, section = section_headers;
5480 i < elf_header.e_shnum;
b34976b6 5481 i++, section++)
252b5132 5482 {
7bfd842d 5483 printf (" [%2u] ", i);
5477e8a0 5484 if (do_section_details)
74e1a04b 5485 printf ("%s\n ", printable_section_name (section));
595cf52e 5486 else
74e1a04b 5487 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5488
ea52a088
NC		 5489 printf (do_wide ? " %-15s " : " %-15.15s ",
5490 get_section_type_name (section->sh_type));
0b4362b0 5491
f7a99963
NC		 5492 if (is_32bit_elf)
5493 {
cfcac11d
NC		 5494 const char * link_too_big = NULL;
5495
f7a99963 5496 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5497
f7a99963
NC		 5498 printf ( " %6.6lx %6.6lx %2.2lx",
5499 (unsigned long) section->sh_offset,
5500 (unsigned long) section->sh_size,
5501 (unsigned long) section->sh_entsize);
d1133906 5502
5477e8a0
L		 5503 if (do_section_details)
5504 fputs (" ", stdout);
5505 else
5506 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5507
cfcac11d
NC		 5508 if (section->sh_link >= elf_header.e_shnum)
5509 {
5510 link_too_big = "";
5511 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5512 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5513 switch (elf_header.e_machine)
5514 {
caa83f8b
NC		 5515 case EM_386:
5516 case EM_486:
5517 case EM_X86_64:
7f502d6c 5518 case EM_L1OM:
7a9068fe 5519 case EM_K1OM:
cfcac11d
NC		 5520 case EM_OLD_SPARCV9:
5521 case EM_SPARC32PLUS:
5522 case EM_SPARCV9:
5523 case EM_SPARC:
5524 if (section->sh_link == (SHN_BEFORE & 0xffff))
5525 link_too_big = "BEFORE";
5526 else if (section->sh_link == (SHN_AFTER & 0xffff))
5527 link_too_big = "AFTER";
5528 break;
5529 default:
5530 break;
5531 }
5532 }
5533
5534 if (do_section_details)
5535 {
5536 if (link_too_big != NULL && * link_too_big)
5537 printf ("<%s> ", link_too_big);
5538 else
5539 printf ("%2u ", section->sh_link);
5540 printf ("%3u %2lu\n", section->sh_info,
5541 (unsigned long) section->sh_addralign);
5542 }
5543 else
5544 printf ("%2u %3u %2lu\n",
5545 section->sh_link,
5546 section->sh_info,
5547 (unsigned long) section->sh_addralign);
5548
5549 if (link_too_big && ! * link_too_big)
5550 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5551 i, section->sh_link);
f7a99963 5552 }
d974e256
JJ		 5553 else if (do_wide)
5554 {
5555 print_vma (section->sh_addr, LONG_HEX);
5556
5557 if ((long) section->sh_offset == section->sh_offset)
5558 printf (" %6.6lx", (unsigned long) section->sh_offset);
5559 else
5560 {
5561 putchar (' ');
5562 print_vma (section->sh_offset, LONG_HEX);
5563 }
5564
5565 if ((unsigned long) section->sh_size == section->sh_size)
5566 printf (" %6.6lx", (unsigned long) section->sh_size);
5567 else
5568 {
5569 putchar (' ');
5570 print_vma (section->sh_size, LONG_HEX);
5571 }
5572
5573 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5574 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5575 else
5576 {
5577 putchar (' ');
5578 print_vma (section->sh_entsize, LONG_HEX);
5579 }
5580
5477e8a0
L		 5581 if (do_section_details)
5582 fputs (" ", stdout);
5583 else
5584 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5585
72de5009 5586 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5587
5588 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5589 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5590 else
5591 {
5592 print_vma (section->sh_addralign, DEC);
5593 putchar ('\n');
5594 }
5595 }
5477e8a0 5596 else if (do_section_details)
595cf52e 5597 {
5477e8a0 5598 printf (" %-15.15s ",
595cf52e 5599 get_section_type_name (section->sh_type));
595cf52e
L		 5600 print_vma (section->sh_addr, LONG_HEX);
5601 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5602 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5603 else
5604 {
5605 printf (" ");
5606 print_vma (section->sh_offset, LONG_HEX);
5607 }
72de5009 5608 printf (" %u\n ", section->sh_link);
595cf52e 5609 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5610 putchar (' ');
595cf52e
L		 5611 print_vma (section->sh_entsize, LONG_HEX);
5612
72de5009
AM		 5613 printf (" %-16u %lu\n",
5614 section->sh_info,
595cf52e
L		 5615 (unsigned long) section->sh_addralign);
5616 }
f7a99963
NC		 5617 else
5618 {
5619 putchar (' ');
5620 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5621 if ((long) section->sh_offset == section->sh_offset)
5622 printf (" %8.8lx", (unsigned long) section->sh_offset);
5623 else
5624 {
5625 printf (" ");
5626 print_vma (section->sh_offset, LONG_HEX);
5627 }
f7a99963
NC		 5628 printf ("\n ");
5629 print_vma (section->sh_size, LONG_HEX);
5630 printf (" ");
5631 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5632
d1133906 5633 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5634
72de5009
AM		 5635 printf (" %2u %3u %lu\n",
5636 section->sh_link,
5637 section->sh_info,
f7a99963
NC		 5638 (unsigned long) section->sh_addralign);
5639 }
5477e8a0
L		 5640
5641 if (do_section_details)
5642 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5643 }
5644
5477e8a0 5645 if (!do_section_details)
3dbcc61d
NC		 5646 {
5647 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5648 || elf_header.e_machine == EM_L1OM
5649 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5650 printf (_("Key to Flags:\n\
5651 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5652 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5653 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5654 else
5655 printf (_("Key to Flags:\n\
e3c8793a 5656 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5657 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5658 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5659 }
d1133906 5660
252b5132
RH		 5661 return 1;
5662}
5663
f5842774
L		 5664static const char *
5665get_group_flags (unsigned int flags)
5666{
5667 static char buff[32];
5668 switch (flags)
5669 {
220453ec
AM		 5670 case 0:
5671 return "";
5672
f5842774 5673 case GRP_COMDAT:
220453ec 5674 return "COMDAT ";
f5842774
L		 5675
5676 default:
220453ec 5677 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5678 break;
5679 }
5680 return buff;
5681}
5682
5683static int
2cf0635d 5684process_section_groups (FILE * file)
f5842774 5685{
2cf0635d 5686 Elf_Internal_Shdr * section;
f5842774 5687 unsigned int i;
2cf0635d
NC		 5688 struct group * group;
5689 Elf_Internal_Shdr * symtab_sec;
5690 Elf_Internal_Shdr * strtab_sec;
5691 Elf_Internal_Sym * symtab;
ba5cdace 5692 unsigned long num_syms;
2cf0635d 5693 char * strtab;
c256ffe7 5694 size_t strtab_size;
d1f5c6e3
L		 5695
5696 /* Don't process section groups unless needed. */
5697 if (!do_unwind && !do_section_groups)
5698 return 1;
f5842774
L		 5699
5700 if (elf_header.e_shnum == 0)
5701 {
5702 if (do_section_groups)
82f2dbf7 5703 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5704
5705 return 1;
5706 }
5707
5708 if (section_headers == NULL)
5709 {
5710 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5711 /* PR 13622: This can happen with a corrupt ELF header. */
5712 return 0;
f5842774
L		 5713 }
5714
3f5e193b
NC		 5715 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5716 sizeof (struct group *));
e4b17d5c
L		 5717
5718 if (section_headers_groups == NULL)
5719 {
8b73c356
NC		 5720 error (_("Out of memory reading %u section group headers\n"),
5721 elf_header.e_shnum);
e4b17d5c
L		 5722 return 0;
5723 }
5724
f5842774 5725 /* Scan the sections for the group section. */
d1f5c6e3 5726 group_count = 0;
f5842774
L		 5727 for (i = 0, section = section_headers;
5728 i < elf_header.e_shnum;
5729 i++, section++)
e4b17d5c
L		 5730 if (section->sh_type == SHT_GROUP)
5731 group_count++;
5732
d1f5c6e3
L		 5733 if (group_count == 0)
5734 {
5735 if (do_section_groups)
5736 printf (_("\nThere are no section groups in this file.\n"));
5737
5738 return 1;
5739 }
5740
3f5e193b 5741 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5742
5743 if (section_groups == NULL)
5744 {
8b73c356
NC		 5745 error (_("Out of memory reading %lu groups\n"),
5746 (unsigned long) group_count);
e4b17d5c
L		 5747 return 0;
5748 }
5749
d1f5c6e3
L		 5750 symtab_sec = NULL;
5751 strtab_sec = NULL;
5752 symtab = NULL;
ba5cdace 5753 num_syms = 0;
d1f5c6e3 5754 strtab = NULL;
c256ffe7 5755 strtab_size = 0;
e4b17d5c
L		 5756 for (i = 0, section = section_headers, group = section_groups;
5757 i < elf_header.e_shnum;
5758 i++, section++)
f5842774
L		 5759 {
5760 if (section->sh_type == SHT_GROUP)
5761 {
74e1a04b
NC		 5762 const char * name = printable_section_name (section);
5763 const char * group_name;
2cf0635d
NC		 5764 unsigned char * start;
5765 unsigned char * indices;
f5842774 5766 unsigned int entry, j, size;
2cf0635d
NC		 5767 Elf_Internal_Shdr * sec;
5768 Elf_Internal_Sym * sym;
f5842774
L		 5769
5770 /* Get the symbol table. */
4fbb74a6
AM		 5771 if (section->sh_link >= elf_header.e_shnum
5772 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5773 != SHT_SYMTAB))
f5842774
L		 5774 {
5775 error (_("Bad sh_link in group section `%s'\n"), name);
5776 continue;
5777 }
d1f5c6e3
L		 5778
5779 if (symtab_sec != sec)
5780 {
5781 symtab_sec = sec;
5782 if (symtab)
5783 free (symtab);
ba5cdace 5784 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5785 }
f5842774 5786
dd24e3da
NC		 5787 if (symtab == NULL)
5788 {
5789 error (_("Corrupt header in group section `%s'\n"), name);
5790 continue;
5791 }
5792
ba5cdace
NC		 5793 if (section->sh_info >= num_syms)
5794 {
5795 error (_("Bad sh_info in group section `%s'\n"), name);
5796 continue;
5797 }
5798
f5842774
L		 5799 sym = symtab + section->sh_info;
5800
5801 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5802 {
4fbb74a6
AM		 5803 if (sym->st_shndx == 0
5804 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5805 {
5806 error (_("Bad sh_info in group section `%s'\n"), name);
5807 continue;
5808 }
ba2685cc 5809
4fbb74a6 5810 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5811 strtab_sec = NULL;
5812 if (strtab)
5813 free (strtab);
f5842774 5814 strtab = NULL;
c256ffe7 5815 strtab_size = 0;
f5842774
L		 5816 }
5817 else
5818 {
5819 /* Get the string table. */
4fbb74a6 5820 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5821 {
5822 strtab_sec = NULL;
5823 if (strtab)
5824 free (strtab);
5825 strtab = NULL;
5826 strtab_size = 0;
5827 }
5828 else if (strtab_sec
4fbb74a6 5829 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5830 {
5831 strtab_sec = sec;
5832 if (strtab)
5833 free (strtab);
071436c6 5834
3f5e193b 5835 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 5836 1, strtab_sec->sh_size,
5837 _("string table"));
c256ffe7 5838 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5839 }
c256ffe7 5840 group_name = sym->st_name < strtab_size
2b692964 5841 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5842 }
5843
c9c1d674
EG		 5844 /* PR 17531: file: loop. */
5845 if (section->sh_entsize > section->sh_size)
5846 {
5847 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5848 printable_section_name (section),
8066deb1
AM		 5849 (unsigned long) section->sh_entsize,
5850 (unsigned long) section->sh_size);
c9c1d674
EG		 5851 break;
5852 }
5853
3f5e193b
NC		 5854 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5855 1, section->sh_size,
5856 _("section data"));
59245841
NC		 5857 if (start == NULL)
5858 continue;
f5842774
L		 5859
5860 indices = start;
5861 size = (section->sh_size / section->sh_entsize) - 1;
5862 entry = byte_get (indices, 4);
5863 indices += 4;
e4b17d5c
L		 5864
5865 if (do_section_groups)
5866 {
2b692964 5867 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5868 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5869
e4b17d5c
L		 5870 printf (_(" [Index] Name\n"));
5871 }
5872
5873 group->group_index = i;
5874
f5842774
L		 5875 for (j = 0; j < size; j++)
5876 {
2cf0635d 5877 struct group_list * g;
e4b17d5c 5878
f5842774
L		 5879 entry = byte_get (indices, 4);
5880 indices += 4;
5881
4fbb74a6 5882 if (entry >= elf_header.e_shnum)
391cb864
L		 5883 {
5884 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5885 entry, i, elf_header.e_shnum - 1);
5886 continue;
5887 }
391cb864 5888
4fbb74a6 5889 if (section_headers_groups [entry] != NULL)
e4b17d5c 5890 {
d1f5c6e3
L		 5891 if (entry)
5892 {
391cb864
L		 5893 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5894 entry, i,
4fbb74a6 5895 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5896 continue;
5897 }
5898 else
5899 {
5900 /* Intel C/C++ compiler may put section 0 in a
5901 section group. We just warn it the first time
5902 and ignore it afterwards. */
5903 static int warned = 0;
5904 if (!warned)
5905 {
5906 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5907 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5908 warned++;
5909 }
5910 }
e4b17d5c
L		 5911 }
5912
4fbb74a6 5913 section_headers_groups [entry] = group;
e4b17d5c
L		 5914
5915 if (do_section_groups)
5916 {
4fbb74a6 5917 sec = section_headers + entry;
74e1a04b 5918 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 5919 }
5920
3f5e193b 5921 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5922 g->section_index = entry;
5923 g->next = group->root;
5924 group->root = g;
f5842774
L		 5925 }
5926
f5842774
L		 5927 if (start)
5928 free (start);
e4b17d5c
L		 5929
5930 group++;
f5842774
L		 5931 }
5932 }
5933
d1f5c6e3
L		 5934 if (symtab)
5935 free (symtab);
5936 if (strtab)
5937 free (strtab);
f5842774
L		 5938 return 1;
5939}
5940
28f997cf
TG		 5941/* Data used to display dynamic fixups. */
5942
5943struct ia64_vms_dynfixup
5944{
5945 bfd_vma needed_ident; /* Library ident number. */
5946 bfd_vma needed; /* Index in the dstrtab of the library name. */
5947 bfd_vma fixup_needed; /* Index of the library. */
5948 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5949 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5950};
5951
5952/* Data used to display dynamic relocations. */
5953
5954struct ia64_vms_dynimgrela
5955{
5956 bfd_vma img_rela_cnt; /* Number of relocations. */
5957 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5958};
5959
5960/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5961 library). */
5962
5963static void
5964dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5965 const char *strtab, unsigned int strtab_sz)
5966{
5967 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5968 long i;
5969 const char *lib_name;
5970
5971 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5972 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5973 _("dynamic section image fixups"));
5974 if (!imfs)
5975 return;
5976
5977 if (fixup->needed < strtab_sz)
5978 lib_name = strtab + fixup->needed;
5979 else
5980 {
5981 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5982 (unsigned long) fixup->needed);
28f997cf
TG		 5983 lib_name = "???";
5984 }
5985 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5986 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5987 printf
5988 (_("Seg Offset Type SymVec DataType\n"));
5989
5990 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5991 {
5992 unsigned int type;
5993 const char *rtype;
5994
5995 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5996 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5997 type = BYTE_GET (imfs [i].type);
5998 rtype = elf_ia64_reloc_type (type);
5999 if (rtype == NULL)
6000 printf (" 0x%08x ", type);
6001 else
6002 printf (" %-32s ", rtype);
6003 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6004 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6005 }
6006
6007 free (imfs);
6008}
6009
6010/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6011
6012static void
6013dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6014{
6015 Elf64_External_VMS_IMAGE_RELA *imrs;
6016 long i;
6017
6018 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6019 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6020 _("dynamic section image relocations"));
28f997cf
TG		 6021 if (!imrs)
6022 return;
6023
6024 printf (_("\nImage relocs\n"));
6025 printf
6026 (_("Seg Offset Type Addend Seg Sym Off\n"));
6027
6028 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6029 {
6030 unsigned int type;
6031 const char *rtype;
6032
6033 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6034 printf ("%08" BFD_VMA_FMT "x ",
6035 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6036 type = BYTE_GET (imrs [i].type);
6037 rtype = elf_ia64_reloc_type (type);
6038 if (rtype == NULL)
6039 printf ("0x%08x ", type);
6040 else
6041 printf ("%-31s ", rtype);
6042 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6043 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6044 printf ("%08" BFD_VMA_FMT "x\n",
6045 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6046 }
6047
6048 free (imrs);
6049}
6050
6051/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6052
6053static int
6054process_ia64_vms_dynamic_relocs (FILE *file)
6055{
6056 struct ia64_vms_dynfixup fixup;
6057 struct ia64_vms_dynimgrela imgrela;
6058 Elf_Internal_Dyn *entry;
6059 int res = 0;
6060 bfd_vma strtab_off = 0;
6061 bfd_vma strtab_sz = 0;
6062 char *strtab = NULL;
6063
6064 memset (&fixup, 0, sizeof (fixup));
6065 memset (&imgrela, 0, sizeof (imgrela));
6066
6067 /* Note: the order of the entries is specified by the OpenVMS specs. */
6068 for (entry = dynamic_section;
6069 entry < dynamic_section + dynamic_nent;
6070 entry++)
6071 {
6072 switch (entry->d_tag)
6073 {
6074 case DT_IA_64_VMS_STRTAB_OFFSET:
6075 strtab_off = entry->d_un.d_val;
6076 break;
6077 case DT_STRSZ:
6078 strtab_sz = entry->d_un.d_val;
6079 if (strtab == NULL)
6080 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6081 1, strtab_sz, _("dynamic string section"));
6082 break;
6083
6084 case DT_IA_64_VMS_NEEDED_IDENT:
6085 fixup.needed_ident = entry->d_un.d_val;
6086 break;
6087 case DT_NEEDED:
6088 fixup.needed = entry->d_un.d_val;
6089 break;
6090 case DT_IA_64_VMS_FIXUP_NEEDED:
6091 fixup.fixup_needed = entry->d_un.d_val;
6092 break;
6093 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6094 fixup.fixup_rela_cnt = entry->d_un.d_val;
6095 break;
6096 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6097 fixup.fixup_rela_off = entry->d_un.d_val;
6098 res++;
6099 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6100 break;
6101
6102 case DT_IA_64_VMS_IMG_RELA_CNT:
6103 imgrela.img_rela_cnt = entry->d_un.d_val;
6104 break;
6105 case DT_IA_64_VMS_IMG_RELA_OFF:
6106 imgrela.img_rela_off = entry->d_un.d_val;
6107 res++;
6108 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6109 break;
6110
6111 default:
6112 break;
6113 }
6114 }
6115
6116 if (strtab != NULL)
6117 free (strtab);
6118
6119 return res;
6120}
6121
85b1c36d 6122static struct
566b0d53 6123{
2cf0635d 6124 const char * name;
566b0d53
L		 6125 int reloc;
6126 int size;
6127 int rela;
6128} dynamic_relocations [] =
6129{
6130 { "REL", DT_REL, DT_RELSZ, FALSE },
6131 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6132 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6133};
6134
252b5132 6135/* Process the reloc section. */
18bd398b 6136
252b5132 6137static int
2cf0635d 6138process_relocs (FILE * file)
252b5132 6139{
b34976b6
AM		 6140 unsigned long rel_size;
6141 unsigned long rel_offset;
252b5132
RH		 6142
6143
6144 if (!do_reloc)
6145 return 1;
6146
6147 if (do_using_dynamic)
6148 {
566b0d53 6149 int is_rela;
2cf0635d 6150 const char * name;
566b0d53
L		 6151 int has_dynamic_reloc;
6152 unsigned int i;
0de14b54 6153
566b0d53 6154 has_dynamic_reloc = 0;
252b5132 6155
566b0d53 6156 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6157 {
566b0d53
L		 6158 is_rela = dynamic_relocations [i].rela;
6159 name = dynamic_relocations [i].name;
6160 rel_size = dynamic_info [dynamic_relocations [i].size];
6161 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6162
566b0d53
L		 6163 has_dynamic_reloc |= rel_size;
6164
6165 if (is_rela == UNKNOWN)
aa903cfb 6166 {
566b0d53
L		 6167 if (dynamic_relocations [i].reloc == DT_JMPREL)
6168 switch (dynamic_info[DT_PLTREL])
6169 {
6170 case DT_REL:
6171 is_rela = FALSE;
6172 break;
6173 case DT_RELA:
6174 is_rela = TRUE;
6175 break;
6176 }
aa903cfb 6177 }
252b5132 6178
566b0d53
L		 6179 if (rel_size)
6180 {
6181 printf
6182 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6183 name, rel_offset, rel_size);
252b5132 6184
d93f0186
NC		 6185 dump_relocations (file,
6186 offset_from_vma (file, rel_offset, rel_size),
6187 rel_size,
566b0d53 6188 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6189 dynamic_strings, dynamic_strings_length,
6190 is_rela, 1);
566b0d53 6191 }
252b5132 6192 }
566b0d53 6193
28f997cf
TG		 6194 if (is_ia64_vms ())
6195 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6196
566b0d53 6197 if (! has_dynamic_reloc)
252b5132
RH		 6198 printf (_("\nThere are no dynamic relocations in this file.\n"));
6199 }
6200 else
6201 {
2cf0635d 6202 Elf_Internal_Shdr * section;
b34976b6
AM		 6203 unsigned long i;
6204 int found = 0;
252b5132
RH		 6205
6206 for (i = 0, section = section_headers;
6207 i < elf_header.e_shnum;
b34976b6 6208 i++, section++)
252b5132
RH		 6209 {
6210 if ( section->sh_type != SHT_RELA
6211 && section->sh_type != SHT_REL)
6212 continue;
6213
6214 rel_offset = section->sh_offset;
6215 rel_size = section->sh_size;
6216
6217 if (rel_size)
6218 {
2cf0635d 6219 Elf_Internal_Shdr * strsec;
b34976b6 6220 int is_rela;
103f02d3 6221
252b5132
RH		 6222 printf (_("\nRelocation section "));
6223
6224 if (string_table == NULL)
19936277 6225 printf ("%d", section->sh_name);
252b5132 6226 else
74e1a04b 6227 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6228
6229 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6230 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6231
d79b3d50
NC		 6232 is_rela = section->sh_type == SHT_RELA;
6233
4fbb74a6
AM		 6234 if (section->sh_link != 0
6235 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6236 {
2cf0635d
NC		 6237 Elf_Internal_Shdr * symsec;
6238 Elf_Internal_Sym * symtab;
d79b3d50 6239 unsigned long nsyms;
c256ffe7 6240 unsigned long strtablen = 0;
2cf0635d 6241 char * strtab = NULL;
57346661 6242
4fbb74a6 6243 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6244 if (symsec->sh_type != SHT_SYMTAB
6245 && symsec->sh_type != SHT_DYNSYM)
6246 continue;
6247
ba5cdace 6248 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6249
af3fc3bc
AM		 6250 if (symtab == NULL)
6251 continue;
252b5132 6252
4fbb74a6
AM		 6253 if (symsec->sh_link != 0
6254 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6255 {
4fbb74a6 6256 strsec = section_headers + symsec->sh_link;
103f02d3 6257
3f5e193b 6258 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6259 1, strsec->sh_size,
6260 _("string table"));
c256ffe7
JJ		 6261 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6262 }
252b5132 6263
d79b3d50 6264 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6265 symtab, nsyms, strtab, strtablen,
6266 is_rela,
6267 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6268 if (strtab)
6269 free (strtab);
6270 free (symtab);
6271 }
6272 else
6273 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6274 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6275
6276 found = 1;
6277 }
6278 }
6279
6280 if (! found)
6281 printf (_("\nThere are no relocations in this file.\n"));
6282 }
6283
6284 return 1;
6285}
6286
57346661
AM		 6287/* Process the unwind section. */
6288
4d6ed7c8
NC		 6289#include "unwind-ia64.h"
6290
6291/* An absolute address consists of a section and an offset. If the
6292 section is NULL, the offset itself is the address, otherwise, the
6293 address equals to LOAD_ADDRESS(section) + offset. */
6294
6295struct absaddr
6296 {
6297 unsigned short section;
6298 bfd_vma offset;
6299 };
6300
1949de15
L		 6301#define ABSADDR(a) \
6302 ((a).section \
6303 ? section_headers [(a).section].sh_addr + (a).offset \
6304 : (a).offset)
6305
3f5e193b
NC		 6306struct ia64_unw_table_entry
6307 {
6308 struct absaddr start;
6309 struct absaddr end;
6310 struct absaddr info;
6311 };
6312
57346661 6313struct ia64_unw_aux_info
4d6ed7c8 6314 {
3f5e193b
NC		 6315
6316 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 6317 unsigned long table_len; /* Length of unwind table. */
2cf0635d 6318 unsigned char * info; /* Unwind info. */
b34976b6
AM		 6319 unsigned long info_size; /* Size of unwind info. */
6320 bfd_vma info_addr; /* starting address of unwind info. */
6321 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6322 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 6323 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6324 char * strtab; /* The string table. */
b34976b6 6325 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 6326 };
6327
4d6ed7c8 6328static void
2cf0635d 6329find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 6330 unsigned long nsyms,
2cf0635d 6331 const char * strtab,
57346661 6332 unsigned long strtab_size,
d3ba0551 6333 struct absaddr addr,
2cf0635d
NC		 6334 const char ** symname,
6335 bfd_vma * offset)
4d6ed7c8 6336{
d3ba0551 6337 bfd_vma dist = 0x100000;
2cf0635d
NC		 6338 Elf_Internal_Sym * sym;
6339 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 6340 unsigned long i;
6341
0b6ae522
DJ		 6342 REMOVE_ARCH_BITS (addr.offset);
6343
57346661 6344 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 6345 {
0b6ae522
DJ		 6346 bfd_vma value = sym->st_value;
6347
6348 REMOVE_ARCH_BITS (value);
6349
4d6ed7c8
NC		 6350 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6351 && sym->st_name != 0
6352 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6353 && addr.offset >= value
6354 && addr.offset - value < dist)
4d6ed7c8
NC		 6355 {
6356 best = sym;
0b6ae522 6357 dist = addr.offset - value;
4d6ed7c8
NC		 6358 if (!dist)
6359 break;
6360 }
6361 }
1b31d05e 6362
4d6ed7c8
NC		 6363 if (best)
6364 {
57346661 6365 *symname = (best->st_name >= strtab_size
2b692964 6366 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6367 *offset = dist;
6368 return;
6369 }
1b31d05e 6370
4d6ed7c8
NC		 6371 *symname = NULL;
6372 *offset = addr.offset;
6373}
6374
6375static void
2cf0635d 6376dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6377{
2cf0635d 6378 struct ia64_unw_table_entry * tp;
4d6ed7c8 6379 int in_body;
7036c0e1 6380
4d6ed7c8
NC		 6381 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6382 {
6383 bfd_vma stamp;
6384 bfd_vma offset;
2cf0635d
NC		 6385 const unsigned char * dp;
6386 const unsigned char * head;
6387 const char * procname;
4d6ed7c8 6388
57346661
AM		 6389 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6390 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6391
6392 fputs ("\n<", stdout);
6393
6394 if (procname)
6395 {
6396 fputs (procname, stdout);
6397
6398 if (offset)
6399 printf ("+%lx", (unsigned long) offset);
6400 }
6401
6402 fputs (">: [", stdout);
6403 print_vma (tp->start.offset, PREFIX_HEX);
6404 fputc ('-', stdout);
6405 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6406 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6407 (unsigned long) (tp->info.offset - aux->seg_base));
6408
1949de15 6409 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6410 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6411
86f55779 6412 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6413 (unsigned) UNW_VER (stamp),
6414 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6415 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6416 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6417 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6418
6419 if (UNW_VER (stamp) != 1)
6420 {
2b692964 6421 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6422 continue;
6423 }
6424
6425 in_body = 0;
89fac5e3 6426 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 6427 dp = unw_decode (dp, in_body, & in_body);
6428 }
6429}
6430
6431static int
2cf0635d
NC		 6432slurp_ia64_unwind_table (FILE * file,
6433 struct ia64_unw_aux_info * aux,
6434 Elf_Internal_Shdr * sec)
4d6ed7c8 6435{
89fac5e3 6436 unsigned long size, nrelas, i;
2cf0635d
NC		 6437 Elf_Internal_Phdr * seg;
6438 struct ia64_unw_table_entry * tep;
6439 Elf_Internal_Shdr * relsec;
6440 Elf_Internal_Rela * rela;
6441 Elf_Internal_Rela * rp;
6442 unsigned char * table;
6443 unsigned char * tp;
6444 Elf_Internal_Sym * sym;
6445 const char * relname;
4d6ed7c8 6446
4d6ed7c8
NC		 6447 /* First, find the starting address of the segment that includes
6448 this section: */
6449
6450 if (elf_header.e_phnum)
6451 {
d93f0186 6452 if (! get_program_headers (file))
4d6ed7c8 6453 return 0;
4d6ed7c8 6454
d93f0186
NC		 6455 for (seg = program_headers;
6456 seg < program_headers + elf_header.e_phnum;
6457 ++seg)
4d6ed7c8
NC		 6458 {
6459 if (seg->p_type != PT_LOAD)
6460 continue;
6461
6462 if (sec->sh_addr >= seg->p_vaddr
6463 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6464 {
6465 aux->seg_base = seg->p_vaddr;
6466 break;
6467 }
6468 }
4d6ed7c8
NC		 6469 }
6470
6471 /* Second, build the unwind table from the contents of the unwind section: */
6472 size = sec->sh_size;
3f5e193b
NC		 6473 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6474 _("unwind table"));
a6e9f9df
AM		 6475 if (!table)
6476 return 0;
4d6ed7c8 6477
3f5e193b
NC		 6478 aux->table = (struct ia64_unw_table_entry *)
6479 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 6480 tep = aux->table;
c6a0c689 6481 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 6482 {
6483 tep->start.section = SHN_UNDEF;
6484 tep->end.section = SHN_UNDEF;
6485 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6486 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6487 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6488 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6489 tep->start.offset += aux->seg_base;
6490 tep->end.offset += aux->seg_base;
6491 tep->info.offset += aux->seg_base;
6492 }
6493 free (table);
6494
41e92641 6495 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6496 for (relsec = section_headers;
6497 relsec < section_headers + elf_header.e_shnum;
6498 ++relsec)
6499 {
6500 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6501 || relsec->sh_info >= elf_header.e_shnum
6502 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6503 continue;
6504
6505 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6506 & rela, & nrelas))
6507 return 0;
6508
6509 for (rp = rela; rp < rela + nrelas; ++rp)
6510 {
aca88567
NC		 6511 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6512 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6513
0112cd26 6514 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6515 {
e5fb9629 6516 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 6517 continue;
6518 }
6519
89fac5e3 6520 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6521
89fac5e3 6522 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 6523 {
6524 case 0:
6525 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6526 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6527 break;
6528 case 1:
6529 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6530 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6531 break;
6532 case 2:
6533 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6534 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6535 break;
6536 default:
6537 break;
6538 }
6539 }
6540
6541 free (rela);
6542 }
6543
89fac5e3 6544 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 6545 return 1;
6546}
6547
1b31d05e 6548static void
2cf0635d 6549ia64_process_unwind (FILE * file)
4d6ed7c8 6550{
2cf0635d
NC		 6551 Elf_Internal_Shdr * sec;
6552 Elf_Internal_Shdr * unwsec = NULL;
6553 Elf_Internal_Shdr * strsec;
89fac5e3 6554 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6555 struct ia64_unw_aux_info aux;
f1467e33 6556
4d6ed7c8
NC		 6557 memset (& aux, 0, sizeof (aux));
6558
4d6ed7c8
NC		 6559 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6560 {
c256ffe7 6561 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6562 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6563 {
ba5cdace 6564 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6565
4fbb74a6 6566 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6567 if (aux.strtab != NULL)
6568 {
6569 error (_("Multiple auxillary string tables encountered\n"));
6570 free (aux.strtab);
6571 }
3f5e193b
NC		 6572 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6573 1, strsec->sh_size,
6574 _("string table"));
c256ffe7 6575 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6576 }
6577 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6578 unwcount++;
6579 }
6580
6581 if (!unwcount)
6582 printf (_("\nThere are no unwind sections in this file.\n"));
6583
6584 while (unwcount-- > 0)
6585 {
2cf0635d 6586 char * suffix;
579f31ac
JJ		 6587 size_t len, len2;
6588
4082ef84 6589 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6590 i < elf_header.e_shnum; ++i, ++sec)
6591 if (sec->sh_type == SHT_IA_64_UNWIND)
6592 {
6593 unwsec = sec;
6594 break;
6595 }
4082ef84
NC		 6596 /* We have already counted the number of SHT_IA64_UNWIND
6597 sections so the loop above should never fail. */
6598 assert (unwsec != NULL);
579f31ac
JJ		 6599
6600 unwstart = i + 1;
6601 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6602
e4b17d5c
L		 6603 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6604 {
6605 /* We need to find which section group it is in. */
4082ef84 6606 struct group_list * g;
e4b17d5c 6607
4082ef84
NC		 6608 if (section_headers_groups == NULL
6609 || section_headers_groups [i] == NULL)
6610 i = elf_header.e_shnum;
6611 else
e4b17d5c 6612 {
4082ef84 6613 g = section_headers_groups [i]->root;
18bd398b 6614
4082ef84
NC		 6615 for (; g != NULL; g = g->next)
6616 {
6617 sec = section_headers + g->section_index;
e4b17d5c 6618
4082ef84
NC		 6619 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6620 break;
6621 }
6622
6623 if (g == NULL)
6624 i = elf_header.e_shnum;
6625 }
e4b17d5c 6626 }
18bd398b 6627 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6628 {
18bd398b 6629 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6630 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6631 suffix = SECTION_NAME (unwsec) + len;
6632 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6633 ++i, ++sec)
18bd398b
NC		 6634 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6635 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6636 break;
6637 }
6638 else
6639 {
6640 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6641 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6642 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6643 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6644 suffix = "";
18bd398b 6645 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6646 suffix = SECTION_NAME (unwsec) + len;
6647 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6648 ++i, ++sec)
18bd398b
NC		 6649 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6650 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6651 break;
6652 }
6653
6654 if (i == elf_header.e_shnum)
6655 {
6656 printf (_("\nCould not find unwind info section for "));
6657
6658 if (string_table == NULL)
6659 printf ("%d", unwsec->sh_name);
6660 else
74e1a04b 6661 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6662 }
6663 else
4d6ed7c8 6664 {
4d6ed7c8 6665 aux.info_addr = sec->sh_addr;
3f5e193b 6666 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6667 sec->sh_size,
6668 _("unwind info"));
59245841 6669 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6670
579f31ac 6671 printf (_("\nUnwind section "));
4d6ed7c8 6672
579f31ac
JJ		 6673 if (string_table == NULL)
6674 printf ("%d", unwsec->sh_name);
6675 else
74e1a04b 6676 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 6677
579f31ac 6678 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6679 (unsigned long) unwsec->sh_offset,
89fac5e3 6680 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6681
579f31ac 6682 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6683
579f31ac
JJ		 6684 if (aux.table_len > 0)
6685 dump_ia64_unwind (& aux);
6686
6687 if (aux.table)
6688 free ((char *) aux.table);
6689 if (aux.info)
6690 free ((char *) aux.info);
6691 aux.table = NULL;
6692 aux.info = NULL;
6693 }
4d6ed7c8 6694 }
4d6ed7c8 6695
4d6ed7c8
NC		 6696 if (aux.symtab)
6697 free (aux.symtab);
6698 if (aux.strtab)
6699 free ((char *) aux.strtab);
4d6ed7c8
NC		 6700}
6701
3f5e193b
NC		 6702struct hppa_unw_table_entry
6703 {
6704 struct absaddr start;
6705 struct absaddr end;
6706 unsigned int Cannot_unwind:1; /* 0 */
6707 unsigned int Millicode:1; /* 1 */
6708 unsigned int Millicode_save_sr0:1; /* 2 */
6709 unsigned int Region_description:2; /* 3..4 */
6710 unsigned int reserved1:1; /* 5 */
6711 unsigned int Entry_SR:1; /* 6 */
6712 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6713 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6714 unsigned int Args_stored:1; /* 16 */
6715 unsigned int Variable_Frame:1; /* 17 */
6716 unsigned int Separate_Package_Body:1; /* 18 */
6717 unsigned int Frame_Extension_Millicode:1; /* 19 */
6718 unsigned int Stack_Overflow_Check:1; /* 20 */
6719 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6720 unsigned int Ada_Region:1; /* 22 */
6721 unsigned int cxx_info:1; /* 23 */
6722 unsigned int cxx_try_catch:1; /* 24 */
6723 unsigned int sched_entry_seq:1; /* 25 */
6724 unsigned int reserved2:1; /* 26 */
6725 unsigned int Save_SP:1; /* 27 */
6726 unsigned int Save_RP:1; /* 28 */
6727 unsigned int Save_MRP_in_frame:1; /* 29 */
6728 unsigned int extn_ptr_defined:1; /* 30 */
6729 unsigned int Cleanup_defined:1; /* 31 */
6730
6731 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6732 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6733 unsigned int Large_frame:1; /* 2 */
6734 unsigned int Pseudo_SP_Set:1; /* 3 */
6735 unsigned int reserved4:1; /* 4 */
6736 unsigned int Total_frame_size:27; /* 5..31 */
6737 };
6738
57346661
AM		 6739struct hppa_unw_aux_info
6740 {
3f5e193b 6741 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6742 unsigned long table_len; /* Length of unwind table. */
6743 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6744 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6745 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6746 char * strtab; /* The string table. */
57346661
AM		 6747 unsigned long strtab_size; /* Size of string table. */
6748 };
6749
6750static void
2cf0635d 6751dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6752{
2cf0635d 6753 struct hppa_unw_table_entry * tp;
57346661 6754
57346661
AM		 6755 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6756 {
6757 bfd_vma offset;
2cf0635d 6758 const char * procname;
57346661
AM		 6759
6760 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6761 aux->strtab_size, tp->start, &procname,
6762 &offset);
6763
6764 fputs ("\n<", stdout);
6765
6766 if (procname)
6767 {
6768 fputs (procname, stdout);
6769
6770 if (offset)
6771 printf ("+%lx", (unsigned long) offset);
6772 }
6773
6774 fputs (">: [", stdout);
6775 print_vma (tp->start.offset, PREFIX_HEX);
6776 fputc ('-', stdout);
6777 print_vma (tp->end.offset, PREFIX_HEX);
6778 printf ("]\n\t");
6779
18bd398b
NC		 6780#define PF(_m) if (tp->_m) printf (#_m " ");
6781#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6782 PF(Cannot_unwind);
6783 PF(Millicode);
6784 PF(Millicode_save_sr0);
18bd398b 6785 /* PV(Region_description); */
57346661
AM		 6786 PF(Entry_SR);
6787 PV(Entry_FR);
6788 PV(Entry_GR);
6789 PF(Args_stored);
6790 PF(Variable_Frame);
6791 PF(Separate_Package_Body);
6792 PF(Frame_Extension_Millicode);
6793 PF(Stack_Overflow_Check);
6794 PF(Two_Instruction_SP_Increment);
6795 PF(Ada_Region);
6796 PF(cxx_info);
6797 PF(cxx_try_catch);
6798 PF(sched_entry_seq);
6799 PF(Save_SP);
6800 PF(Save_RP);
6801 PF(Save_MRP_in_frame);
6802 PF(extn_ptr_defined);
6803 PF(Cleanup_defined);
6804 PF(MPE_XL_interrupt_marker);
6805 PF(HP_UX_interrupt_marker);
6806 PF(Large_frame);
6807 PF(Pseudo_SP_Set);
6808 PV(Total_frame_size);
6809#undef PF
6810#undef PV
6811 }
6812
18bd398b 6813 printf ("\n");
57346661
AM		 6814}
6815
6816static int
2cf0635d
NC		 6817slurp_hppa_unwind_table (FILE * file,
6818 struct hppa_unw_aux_info * aux,
6819 Elf_Internal_Shdr * sec)
57346661 6820{
1c0751b2 6821 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6822 Elf_Internal_Phdr * seg;
6823 struct hppa_unw_table_entry * tep;
6824 Elf_Internal_Shdr * relsec;
6825 Elf_Internal_Rela * rela;
6826 Elf_Internal_Rela * rp;
6827 unsigned char * table;
6828 unsigned char * tp;
6829 Elf_Internal_Sym * sym;
6830 const char * relname;
57346661 6831
57346661
AM		 6832 /* First, find the starting address of the segment that includes
6833 this section. */
6834
6835 if (elf_header.e_phnum)
6836 {
6837 if (! get_program_headers (file))
6838 return 0;
6839
6840 for (seg = program_headers;
6841 seg < program_headers + elf_header.e_phnum;
6842 ++seg)
6843 {
6844 if (seg->p_type != PT_LOAD)
6845 continue;
6846
6847 if (sec->sh_addr >= seg->p_vaddr
6848 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6849 {
6850 aux->seg_base = seg->p_vaddr;
6851 break;
6852 }
6853 }
6854 }
6855
6856 /* Second, build the unwind table from the contents of the unwind
6857 section. */
6858 size = sec->sh_size;
3f5e193b
NC		 6859 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6860 _("unwind table"));
57346661
AM		 6861 if (!table)
6862 return 0;
6863
1c0751b2
DA		 6864 unw_ent_size = 16;
6865 nentries = size / unw_ent_size;
6866 size = unw_ent_size * nentries;
57346661 6867
3f5e193b
NC		 6868 tep = aux->table = (struct hppa_unw_table_entry *)
6869 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6870
1c0751b2 6871 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6872 {
6873 unsigned int tmp1, tmp2;
6874
6875 tep->start.section = SHN_UNDEF;
6876 tep->end.section = SHN_UNDEF;
6877
1c0751b2
DA		 6878 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6879 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6880 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6881 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6882
6883 tep->start.offset += aux->seg_base;
6884 tep->end.offset += aux->seg_base;
57346661
AM		 6885
6886 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6887 tep->Millicode = (tmp1 >> 30) & 0x1;
6888 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6889 tep->Region_description = (tmp1 >> 27) & 0x3;
6890 tep->reserved1 = (tmp1 >> 26) & 0x1;
6891 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6892 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6893 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6894 tep->Args_stored = (tmp1 >> 15) & 0x1;
6895 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6896 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6897 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6898 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6899 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6900 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6901 tep->cxx_info = (tmp1 >> 8) & 0x1;
6902 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6903 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6904 tep->reserved2 = (tmp1 >> 5) & 0x1;
6905 tep->Save_SP = (tmp1 >> 4) & 0x1;
6906 tep->Save_RP = (tmp1 >> 3) & 0x1;
6907 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6908 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6909 tep->Cleanup_defined = tmp1 & 0x1;
6910
6911 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6912 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6913 tep->Large_frame = (tmp2 >> 29) & 0x1;
6914 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6915 tep->reserved4 = (tmp2 >> 27) & 0x1;
6916 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6917 }
6918 free (table);
6919
6920 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6921 for (relsec = section_headers;
6922 relsec < section_headers + elf_header.e_shnum;
6923 ++relsec)
6924 {
6925 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6926 || relsec->sh_info >= elf_header.e_shnum
6927 || section_headers + relsec->sh_info != sec)
57346661
AM		 6928 continue;
6929
6930 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6931 & rela, & nrelas))
6932 return 0;
6933
6934 for (rp = rela; rp < rela + nrelas; ++rp)
6935 {
aca88567
NC		 6936 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6937 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6938
6939 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6940 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6941 {
6942 warn (_("Skipping unexpected relocation type %s\n"), relname);
6943 continue;
6944 }
6945
6946 i = rp->r_offset / unw_ent_size;
6947
89fac5e3 6948 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6949 {
6950 case 0:
6951 aux->table[i].start.section = sym->st_shndx;
1e456d54 6952 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6953 break;
6954 case 1:
6955 aux->table[i].end.section = sym->st_shndx;
1e456d54 6956 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6957 break;
6958 default:
6959 break;
6960 }
6961 }
6962
6963 free (rela);
6964 }
6965
1c0751b2 6966 aux->table_len = nentries;
57346661
AM		 6967
6968 return 1;
6969}
6970
1b31d05e 6971static void
2cf0635d 6972hppa_process_unwind (FILE * file)
57346661 6973{
57346661 6974 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6975 Elf_Internal_Shdr * unwsec = NULL;
6976 Elf_Internal_Shdr * strsec;
6977 Elf_Internal_Shdr * sec;
18bd398b 6978 unsigned long i;
57346661 6979
c256ffe7 6980 if (string_table == NULL)
1b31d05e
NC		 6981 return;
6982
6983 memset (& aux, 0, sizeof (aux));
57346661
AM		 6984
6985 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6986 {
c256ffe7 6987 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6988 && sec->sh_link < elf_header.e_shnum)
57346661 6989 {
ba5cdace 6990 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6991
4fbb74a6 6992 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6993 if (aux.strtab != NULL)
6994 {
6995 error (_("Multiple auxillary string tables encountered\n"));
6996 free (aux.strtab);
6997 }
3f5e193b
NC		 6998 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6999 1, strsec->sh_size,
7000 _("string table"));
c256ffe7 7001 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7002 }
18bd398b 7003 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7004 unwsec = sec;
7005 }
7006
7007 if (!unwsec)
7008 printf (_("\nThere are no unwind sections in this file.\n"));
7009
7010 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7011 {
18bd398b 7012 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7013 {
74e1a04b
NC		 7014 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7015 printable_section_name (sec),
57346661 7016 (unsigned long) sec->sh_offset,
89fac5e3 7017 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7018
7019 slurp_hppa_unwind_table (file, &aux, sec);
7020 if (aux.table_len > 0)
7021 dump_hppa_unwind (&aux);
7022
7023 if (aux.table)
7024 free ((char *) aux.table);
7025 aux.table = NULL;
7026 }
7027 }
7028
7029 if (aux.symtab)
7030 free (aux.symtab);
7031 if (aux.strtab)
7032 free ((char *) aux.strtab);
57346661
AM		 7033}
7034
0b6ae522
DJ		 7035struct arm_section
7036{
a734115a
NC		 7037 unsigned char * data; /* The unwind data. */
7038 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7039 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7040 unsigned long nrelas; /* The number of relocations. */
7041 unsigned int rel_type; /* REL or RELA ? */
7042 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7043};
7044
7045struct arm_unw_aux_info
7046{
a734115a
NC		 7047 FILE * file; /* The file containing the unwind sections. */
7048 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7049 unsigned long nsyms; /* Number of symbols. */
7050 char * strtab; /* The file's string table. */
7051 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7052};
7053
7054static const char *
7055arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7056 bfd_vma fn, struct absaddr addr)
7057{
7058 const char *procname;
7059 bfd_vma sym_offset;
7060
7061 if (addr.section == SHN_UNDEF)
7062 addr.offset = fn;
7063
7064 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7065 aux->strtab_size, addr, &procname,
7066 &sym_offset);
7067
7068 print_vma (fn, PREFIX_HEX);
7069
7070 if (procname)
7071 {
7072 fputs (" <", stdout);
7073 fputs (procname, stdout);
7074
7075 if (sym_offset)
7076 printf ("+0x%lx", (unsigned long) sym_offset);
7077 fputc ('>', stdout);
7078 }
7079
7080 return procname;
7081}
7082
7083static void
7084arm_free_section (struct arm_section *arm_sec)
7085{
7086 if (arm_sec->data != NULL)
7087 free (arm_sec->data);
7088
7089 if (arm_sec->rela != NULL)
7090 free (arm_sec->rela);
7091}
7092
a734115a
NC		 7093/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7094 cached section and install SEC instead.
7095 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7096 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7097 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7098 relocation's offset in ADDR.
1b31d05e
NC		 7099 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7100 into the string table of the symbol associated with the reloc. If no
7101 reloc was applied store -1 there.
7102 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7103
7104static bfd_boolean
1b31d05e
NC		 7105get_unwind_section_word (struct arm_unw_aux_info * aux,
7106 struct arm_section * arm_sec,
7107 Elf_Internal_Shdr * sec,
7108 bfd_vma word_offset,
7109 unsigned int * wordp,
7110 struct absaddr * addr,
7111 bfd_vma * sym_name)
0b6ae522
DJ		 7112{
7113 Elf_Internal_Rela *rp;
7114 Elf_Internal_Sym *sym;
7115 const char * relname;
7116 unsigned int word;
7117 bfd_boolean wrapped;
7118
e0a31db1
NC		 7119 if (sec == NULL || arm_sec == NULL)
7120 return FALSE;
7121
0b6ae522
DJ		 7122 addr->section = SHN_UNDEF;
7123 addr->offset = 0;
7124
1b31d05e
NC		 7125 if (sym_name != NULL)
7126 *sym_name = (bfd_vma) -1;
7127
a734115a 7128 /* If necessary, update the section cache. */
0b6ae522
DJ		 7129 if (sec != arm_sec->sec)
7130 {
7131 Elf_Internal_Shdr *relsec;
7132
7133 arm_free_section (arm_sec);
7134
7135 arm_sec->sec = sec;
7136 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7137 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7138 arm_sec->rela = NULL;
7139 arm_sec->nrelas = 0;
7140
7141 for (relsec = section_headers;
7142 relsec < section_headers + elf_header.e_shnum;
7143 ++relsec)
7144 {
7145 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7146 || section_headers + relsec->sh_info != sec
7147 /* PR 15745: Check the section type as well. */
7148 || (relsec->sh_type != SHT_REL
7149 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7150 continue;
7151
a734115a 7152 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7153 if (relsec->sh_type == SHT_REL)
7154 {
7155 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7156 relsec->sh_size,
7157 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7158 return FALSE;
0b6ae522 7159 }
1ae40aa4 7160 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7161 {
7162 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7163 relsec->sh_size,
7164 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7165 return FALSE;
0b6ae522 7166 }
1ae40aa4 7167 break;
0b6ae522
DJ		 7168 }
7169
7170 arm_sec->next_rela = arm_sec->rela;
7171 }
7172
a734115a 7173 /* If there is no unwind data we can do nothing. */
0b6ae522 7174 if (arm_sec->data == NULL)
a734115a 7175 return FALSE;
0b6ae522 7176
e0a31db1
NC		 7177 /* If the offset is invalid then fail. */
7178 if (word_offset > sec->sh_size - 4)
7179 return FALSE;
7180
a734115a 7181 /* Get the word at the required offset. */
0b6ae522
DJ		 7182 word = byte_get (arm_sec->data + word_offset, 4);
7183
0eff7165
NC		 7184 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7185 if (arm_sec->rela == NULL)
7186 {
7187 * wordp = word;
7188 return TRUE;
7189 }
7190
a734115a 7191 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7192 wrapped = FALSE;
7193 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7194 {
7195 bfd_vma prelval, offset;
7196
7197 if (rp->r_offset > word_offset && !wrapped)
7198 {
7199 rp = arm_sec->rela;
7200 wrapped = TRUE;
7201 }
7202 if (rp->r_offset > word_offset)
7203 break;
7204
7205 if (rp->r_offset & 3)
7206 {
7207 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7208 (unsigned long) rp->r_offset);
7209 continue;
7210 }
7211
7212 if (rp->r_offset < word_offset)
7213 continue;
7214
74e1a04b
NC		 7215 /* PR 17531: file: 027-161405-0.004 */
7216 if (aux->symtab == NULL)
7217 continue;
7218
0b6ae522
DJ		 7219 if (arm_sec->rel_type == SHT_REL)
7220 {
7221 offset = word & 0x7fffffff;
7222 if (offset & 0x40000000)
7223 offset |= ~ (bfd_vma) 0x7fffffff;
7224 }
a734115a 7225 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7226 offset = rp->r_addend;
a734115a 7227 else
74e1a04b
NC		 7228 {
7229 error (_("Unknown section relocation type %d encountered\n"),
7230 arm_sec->rel_type);
7231 break;
7232 }
0b6ae522 7233
071436c6
NC		 7234 /* PR 17531 file: 027-1241568-0.004. */
7235 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7236 {
7237 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7238 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7239 break;
7240 }
7241
7242 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7243 offset += sym->st_value;
7244 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7245
a734115a
NC		 7246 /* Check that we are processing the expected reloc type. */
7247 if (elf_header.e_machine == EM_ARM)
7248 {
7249 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7250 if (relname == NULL)
7251 {
7252 warn (_("Skipping unknown ARM relocation type: %d\n"),
7253 (int) ELF32_R_TYPE (rp->r_info));
7254 continue;
7255 }
a734115a
NC		 7256
7257 if (streq (relname, "R_ARM_NONE"))
7258 continue;
0b4362b0 7259
a734115a
NC		 7260 if (! streq (relname, "R_ARM_PREL31"))
7261 {
071436c6 7262 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7263 continue;
7264 }
7265 }
7266 else if (elf_header.e_machine == EM_TI_C6000)
7267 {
7268 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7269 if (relname == NULL)
7270 {
7271 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7272 (int) ELF32_R_TYPE (rp->r_info));
7273 continue;
7274 }
0b4362b0 7275
a734115a
NC		 7276 if (streq (relname, "R_C6000_NONE"))
7277 continue;
7278
7279 if (! streq (relname, "R_C6000_PREL31"))
7280 {
071436c6 7281 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7282 continue;
7283 }
7284
7285 prelval >>= 1;
7286 }
7287 else
74e1a04b
NC		 7288 {
7289 /* This function currently only supports ARM and TI unwinders. */
7290 warn (_("Only TI and ARM unwinders are currently supported\n"));
7291 break;
7292 }
fa197c1c 7293
0b6ae522
DJ		 7294 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7295 addr->section = sym->st_shndx;
7296 addr->offset = offset;
74e1a04b 7297
1b31d05e
NC		 7298 if (sym_name)
7299 * sym_name = sym->st_name;
0b6ae522
DJ		 7300 break;
7301 }
7302
7303 *wordp = word;
7304 arm_sec->next_rela = rp;
7305
a734115a 7306 return TRUE;
0b6ae522
DJ		 7307}
7308
a734115a
NC		 7309static const char *tic6x_unwind_regnames[16] =
7310{
0b4362b0
RM		 7311 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7312 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7313 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7314};
fa197c1c 7315
0b6ae522 7316static void
fa197c1c 7317decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7318{
fa197c1c
PB		 7319 int i;
7320
7321 for (i = 12; mask; mask >>= 1, i--)
7322 {
7323 if (mask & 1)
7324 {
7325 fputs (tic6x_unwind_regnames[i], stdout);
7326 if (mask > 1)
7327 fputs (", ", stdout);
7328 }
7329 }
7330}
0b6ae522
DJ		 7331
7332#define ADVANCE \
7333 if (remaining == 0 && more_words) \
7334 { \
7335 data_offset += 4; \
1b31d05e
NC		 7336 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7337 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7338 return; \
7339 remaining = 4; \
7340 more_words--; \
7341 } \
7342
7343#define GET_OP(OP) \
7344 ADVANCE; \
7345 if (remaining) \
7346 { \
7347 remaining--; \
7348 (OP) = word >> 24; \
7349 word <<= 8; \
7350 } \
7351 else \
7352 { \
2b692964 7353 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7354 return; \
7355 } \
cc5914eb 7356 printf ("0x%02x ", OP)
0b6ae522 7357
fa197c1c
PB		 7358static void
7359decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7360 unsigned int word, unsigned int remaining,
7361 unsigned int more_words,
7362 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7363 struct arm_section *data_arm_sec)
7364{
7365 struct absaddr addr;
0b6ae522
DJ		 7366
7367 /* Decode the unwinding instructions. */
7368 while (1)
7369 {
7370 unsigned int op, op2;
7371
7372 ADVANCE;
7373 if (remaining == 0)
7374 break;
7375 remaining--;
7376 op = word >> 24;
7377 word <<= 8;
7378
cc5914eb 7379 printf (" 0x%02x ", op);
0b6ae522
DJ		 7380
7381 if ((op & 0xc0) == 0x00)
7382 {
7383 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7384
cc5914eb 7385 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7386 }
7387 else if ((op & 0xc0) == 0x40)
7388 {
7389 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7390
cc5914eb 7391 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7392 }
7393 else if ((op & 0xf0) == 0x80)
7394 {
7395 GET_OP (op2);
7396 if (op == 0x80 && op2 == 0)
7397 printf (_("Refuse to unwind"));
7398 else
7399 {
7400 unsigned int mask = ((op & 0x0f) << 8) | op2;
7401 int first = 1;
7402 int i;
2b692964 7403
0b6ae522
DJ		 7404 printf ("pop {");
7405 for (i = 0; i < 12; i++)
7406 if (mask & (1 << i))
7407 {
7408 if (first)
7409 first = 0;
7410 else
7411 printf (", ");
7412 printf ("r%d", 4 + i);
7413 }
7414 printf ("}");
7415 }
7416 }
7417 else if ((op & 0xf0) == 0x90)
7418 {
7419 if (op == 0x9d || op == 0x9f)
7420 printf (_(" [Reserved]"));
7421 else
cc5914eb 7422 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7423 }
7424 else if ((op & 0xf0) == 0xa0)
7425 {
7426 int end = 4 + (op & 0x07);
7427 int first = 1;
7428 int i;
61865e30 7429
0b6ae522
DJ		 7430 printf (" pop {");
7431 for (i = 4; i <= end; i++)
7432 {
7433 if (first)
7434 first = 0;
7435 else
7436 printf (", ");
7437 printf ("r%d", i);
7438 }
7439 if (op & 0x08)
7440 {
1b31d05e 7441 if (!first)
0b6ae522
DJ		 7442 printf (", ");
7443 printf ("r14");
7444 }
7445 printf ("}");
7446 }
7447 else if (op == 0xb0)
7448 printf (_(" finish"));
7449 else if (op == 0xb1)
7450 {
7451 GET_OP (op2);
7452 if (op2 == 0 || (op2 & 0xf0) != 0)
7453 printf (_("[Spare]"));
7454 else
7455 {
7456 unsigned int mask = op2 & 0x0f;
7457 int first = 1;
7458 int i;
61865e30 7459
0b6ae522
DJ		 7460 printf ("pop {");
7461 for (i = 0; i < 12; i++)
7462 if (mask & (1 << i))
7463 {
7464 if (first)
7465 first = 0;
7466 else
7467 printf (", ");
7468 printf ("r%d", i);
7469 }
7470 printf ("}");
7471 }
7472 }
7473 else if (op == 0xb2)
7474 {
b115cf96 7475 unsigned char buf[9];
0b6ae522
DJ		 7476 unsigned int i, len;
7477 unsigned long offset;
61865e30 7478
b115cf96 7479 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7480 {
7481 GET_OP (buf[i]);
7482 if ((buf[i] & 0x80) == 0)
7483 break;
7484 }
4082ef84
NC		 7485 if (i == sizeof (buf))
7486 printf (_("corrupt change to vsp"));
7487 else
7488 {
7489 offset = read_uleb128 (buf, &len, buf + i + 1);
7490 assert (len == i + 1);
7491 offset = offset * 4 + 0x204;
7492 printf ("vsp = vsp + %ld", offset);
7493 }
0b6ae522 7494 }
61865e30 7495 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7496 {
61865e30
NC		 7497 unsigned int first, last;
7498
7499 GET_OP (op2);
7500 first = op2 >> 4;
7501 last = op2 & 0x0f;
7502 if (op == 0xc8)
7503 first = first + 16;
7504 printf ("pop {D%d", first);
7505 if (last)
7506 printf ("-D%d", first + last);
7507 printf ("}");
7508 }
7509 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7510 {
7511 unsigned int count = op & 0x07;
7512
7513 printf ("pop {D8");
7514 if (count)
7515 printf ("-D%d", 8 + count);
7516 printf ("}");
7517 }
7518 else if (op >= 0xc0 && op <= 0xc5)
7519 {
7520 unsigned int count = op & 0x07;
7521
7522 printf (" pop {wR10");
7523 if (count)
7524 printf ("-wR%d", 10 + count);
7525 printf ("}");
7526 }
7527 else if (op == 0xc6)
7528 {
7529 unsigned int first, last;
7530
7531 GET_OP (op2);
7532 first = op2 >> 4;
7533 last = op2 & 0x0f;
7534 printf ("pop {wR%d", first);
7535 if (last)
7536 printf ("-wR%d", first + last);
7537 printf ("}");
7538 }
7539 else if (op == 0xc7)
7540 {
7541 GET_OP (op2);
7542 if (op2 == 0 || (op2 & 0xf0) != 0)
7543 printf (_("[Spare]"));
0b6ae522
DJ		 7544 else
7545 {
61865e30
NC		 7546 unsigned int mask = op2 & 0x0f;
7547 int first = 1;
7548 int i;
7549
7550 printf ("pop {");
7551 for (i = 0; i < 4; i++)
7552 if (mask & (1 << i))
7553 {
7554 if (first)
7555 first = 0;
7556 else
7557 printf (", ");
7558 printf ("wCGR%d", i);
7559 }
7560 printf ("}");
0b6ae522
DJ		 7561 }
7562 }
61865e30
NC		 7563 else
7564 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7565 printf ("\n");
7566 }
fa197c1c
PB		 7567}
7568
7569static void
7570decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7571 unsigned int word, unsigned int remaining,
7572 unsigned int more_words,
7573 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7574 struct arm_section *data_arm_sec)
7575{
7576 struct absaddr addr;
7577
7578 /* Decode the unwinding instructions. */
7579 while (1)
7580 {
7581 unsigned int op, op2;
7582
7583 ADVANCE;
7584 if (remaining == 0)
7585 break;
7586 remaining--;
7587 op = word >> 24;
7588 word <<= 8;
7589
9cf03b7e 7590 printf (" 0x%02x ", op);
fa197c1c
PB		 7591
7592 if ((op & 0xc0) == 0x00)
7593 {
7594 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7595 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7596 }
7597 else if ((op & 0xc0) == 0x80)
7598 {
7599 GET_OP (op2);
7600 if (op == 0x80 && op2 == 0)
7601 printf (_("Refuse to unwind"));
7602 else
7603 {
7604 unsigned int mask = ((op & 0x1f) << 8) | op2;
7605 if (op & 0x20)
7606 printf ("pop compact {");
7607 else
7608 printf ("pop {");
7609
7610 decode_tic6x_unwind_regmask (mask);
7611 printf("}");
7612 }
7613 }
7614 else if ((op & 0xf0) == 0xc0)
7615 {
7616 unsigned int reg;
7617 unsigned int nregs;
7618 unsigned int i;
7619 const char *name;
a734115a
NC		 7620 struct
7621 {
fa197c1c
PB		 7622 unsigned int offset;
7623 unsigned int reg;
7624 } regpos[16];
7625
7626 /* Scan entire instruction first so that GET_OP output is not
7627 interleaved with disassembly. */
7628 nregs = 0;
7629 for (i = 0; nregs < (op & 0xf); i++)
7630 {
7631 GET_OP (op2);
7632 reg = op2 >> 4;
7633 if (reg != 0xf)
7634 {
7635 regpos[nregs].offset = i * 2;
7636 regpos[nregs].reg = reg;
7637 nregs++;
7638 }
7639
7640 reg = op2 & 0xf;
7641 if (reg != 0xf)
7642 {
7643 regpos[nregs].offset = i * 2 + 1;
7644 regpos[nregs].reg = reg;
7645 nregs++;
7646 }
7647 }
7648
7649 printf (_("pop frame {"));
7650 reg = nregs - 1;
7651 for (i = i * 2; i > 0; i--)
7652 {
7653 if (regpos[reg].offset == i - 1)
7654 {
7655 name = tic6x_unwind_regnames[regpos[reg].reg];
7656 if (reg > 0)
7657 reg--;
7658 }
7659 else
7660 name = _("[pad]");
7661
7662 fputs (name, stdout);
7663 if (i > 1)
7664 printf (", ");
7665 }
7666
7667 printf ("}");
7668 }
7669 else if (op == 0xd0)
7670 printf (" MOV FP, SP");
7671 else if (op == 0xd1)
7672 printf (" __c6xabi_pop_rts");
7673 else if (op == 0xd2)
7674 {
7675 unsigned char buf[9];
7676 unsigned int i, len;
7677 unsigned long offset;
a734115a 7678
fa197c1c
PB		 7679 for (i = 0; i < sizeof (buf); i++)
7680 {
7681 GET_OP (buf[i]);
7682 if ((buf[i] & 0x80) == 0)
7683 break;
7684 }
0eff7165
NC		 7685 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7686 if (i == sizeof (buf))
7687 {
7688 printf ("<corrupt sp adjust>\n");
7689 warn (_("Corrupt stack pointer adjustment detected\n"));
7690 return;
7691 }
7692
f6f0e17b 7693 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7694 assert (len == i + 1);
7695 offset = offset * 8 + 0x408;
7696 printf (_("sp = sp + %ld"), offset);
7697 }
7698 else if ((op & 0xf0) == 0xe0)
7699 {
7700 if ((op & 0x0f) == 7)
7701 printf (" RETURN");
7702 else
7703 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7704 }
7705 else
7706 {
7707 printf (_(" [unsupported opcode]"));
7708 }
7709 putchar ('\n');
7710 }
7711}
7712
7713static bfd_vma
a734115a 7714arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7715{
7716 bfd_vma offset;
7717
7718 offset = word & 0x7fffffff;
7719 if (offset & 0x40000000)
7720 offset |= ~ (bfd_vma) 0x7fffffff;
7721
7722 if (elf_header.e_machine == EM_TI_C6000)
7723 offset <<= 1;
7724
7725 return offset + where;
7726}
7727
7728static void
1b31d05e
NC		 7729decode_arm_unwind (struct arm_unw_aux_info * aux,
7730 unsigned int word,
7731 unsigned int remaining,
7732 bfd_vma data_offset,
7733 Elf_Internal_Shdr * data_sec,
7734 struct arm_section * data_arm_sec)
fa197c1c
PB		 7735{
7736 int per_index;
7737 unsigned int more_words = 0;
37e14bc3 7738 struct absaddr addr;
1b31d05e 7739 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7740
7741 if (remaining == 0)
7742 {
1b31d05e
NC		 7743 /* Fetch the first word.
7744 Note - when decoding an object file the address extracted
7745 here will always be 0. So we also pass in the sym_name
7746 parameter so that we can find the symbol associated with
7747 the personality routine. */
7748 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7749 & word, & addr, & sym_name))
fa197c1c 7750 return;
1b31d05e 7751
fa197c1c
PB		 7752 remaining = 4;
7753 }
7754
7755 if ((word & 0x80000000) == 0)
7756 {
7757 /* Expand prel31 for personality routine. */
7758 bfd_vma fn;
7759 const char *procname;
7760
a734115a 7761 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7762 printf (_(" Personality routine: "));
1b31d05e
NC		 7763 if (fn == 0
7764 && addr.section == SHN_UNDEF && addr.offset == 0
7765 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7766 {
7767 procname = aux->strtab + sym_name;
7768 print_vma (fn, PREFIX_HEX);
7769 if (procname)
7770 {
7771 fputs (" <", stdout);
7772 fputs (procname, stdout);
7773 fputc ('>', stdout);
7774 }
7775 }
7776 else
7777 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7778 fputc ('\n', stdout);
7779
7780 /* The GCC personality routines use the standard compact
7781 encoding, starting with one byte giving the number of
7782 words. */
7783 if (procname != NULL
7784 && (const_strneq (procname, "__gcc_personality_v0")
7785 || const_strneq (procname, "__gxx_personality_v0")
7786 || const_strneq (procname, "__gcj_personality_v0")
7787 || const_strneq (procname, "__gnu_objc_personality_v0")))
7788 {
7789 remaining = 0;
7790 more_words = 1;
7791 ADVANCE;
7792 if (!remaining)
7793 {
7794 printf (_(" [Truncated data]\n"));
7795 return;
7796 }
7797 more_words = word >> 24;
7798 word <<= 8;
7799 remaining--;
7800 per_index = -1;
7801 }
7802 else
7803 return;
7804 }
7805 else
7806 {
1b31d05e 7807 /* ARM EHABI Section 6.3:
0b4362b0 7808
1b31d05e 7809 An exception-handling table entry for the compact model looks like:
0b4362b0 7810
1b31d05e
NC		 7811 31 30-28 27-24 23-0
7812 -- ----- ----- ----
7813 1 0 index Data for personalityRoutine[index] */
7814
7815 if (elf_header.e_machine == EM_ARM
7816 && (word & 0x70000000))
83c257ca 7817 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7818
fa197c1c 7819 per_index = (word >> 24) & 0x7f;
1b31d05e 7820 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7821 if (per_index == 0)
7822 {
7823 more_words = 0;
7824 word <<= 8;
7825 remaining--;
7826 }
7827 else if (per_index < 3)
7828 {
7829 more_words = (word >> 16) & 0xff;
7830 word <<= 16;
7831 remaining -= 2;
7832 }
7833 }
7834
7835 switch (elf_header.e_machine)
7836 {
7837 case EM_ARM:
7838 if (per_index < 3)
7839 {
7840 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7841 data_offset, data_sec, data_arm_sec);
7842 }
7843 else
1b31d05e
NC		 7844 {
7845 warn (_("Unknown ARM compact model index encountered\n"));
7846 printf (_(" [reserved]\n"));
7847 }
fa197c1c
PB		 7848 break;
7849
7850 case EM_TI_C6000:
7851 if (per_index < 3)
7852 {
7853 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7854 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7855 }
7856 else if (per_index < 5)
7857 {
7858 if (((word >> 17) & 0x7f) == 0x7f)
7859 printf (_(" Restore stack from frame pointer\n"));
7860 else
7861 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7862 printf (_(" Registers restored: "));
7863 if (per_index == 4)
7864 printf (" (compact) ");
7865 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7866 putchar ('\n');
7867 printf (_(" Return register: %s\n"),
7868 tic6x_unwind_regnames[word & 0xf]);
7869 }
7870 else
1b31d05e 7871 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7872 break;
7873
7874 default:
74e1a04b 7875 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 7876 elf_header.e_machine);
fa197c1c 7877 }
0b6ae522
DJ		 7878
7879 /* Decode the descriptors. Not implemented. */
7880}
7881
7882static void
7883dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7884{
7885 struct arm_section exidx_arm_sec, extab_arm_sec;
7886 unsigned int i, exidx_len;
7887
7888 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7889 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7890 exidx_len = exidx_sec->sh_size / 8;
7891
7892 for (i = 0; i < exidx_len; i++)
7893 {
7894 unsigned int exidx_fn, exidx_entry;
7895 struct absaddr fn_addr, entry_addr;
7896 bfd_vma fn;
7897
7898 fputc ('\n', stdout);
7899
1b31d05e
NC		 7900 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7901 8 * i, & exidx_fn, & fn_addr, NULL)
7902 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7903 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7904 {
1b31d05e
NC		 7905 arm_free_section (& exidx_arm_sec);
7906 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7907 return;
7908 }
7909
83c257ca
NC		 7910 /* ARM EHABI, Section 5:
7911 An index table entry consists of 2 words.
7912 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7913 if (exidx_fn & 0x80000000)
7914 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7915
a734115a 7916 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7917
a734115a 7918 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7919 fputs (": ", stdout);
7920
7921 if (exidx_entry == 1)
7922 {
7923 print_vma (exidx_entry, PREFIX_HEX);
7924 fputs (" [cantunwind]\n", stdout);
7925 }
7926 else if (exidx_entry & 0x80000000)
7927 {
7928 print_vma (exidx_entry, PREFIX_HEX);
7929 fputc ('\n', stdout);
7930 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7931 }
7932 else
7933 {
8f73510c 7934 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7935 Elf_Internal_Shdr *table_sec;
7936
7937 fputs ("@", stdout);
a734115a 7938 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7939 print_vma (table, PREFIX_HEX);
7940 printf ("\n");
7941
7942 /* Locate the matching .ARM.extab. */
7943 if (entry_addr.section != SHN_UNDEF
7944 && entry_addr.section < elf_header.e_shnum)
7945 {
7946 table_sec = section_headers + entry_addr.section;
7947 table_offset = entry_addr.offset;
7948 }
7949 else
7950 {
7951 table_sec = find_section_by_address (table);
7952 if (table_sec != NULL)
7953 table_offset = table - table_sec->sh_addr;
7954 }
7955 if (table_sec == NULL)
7956 {
7957 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7958 (unsigned long) table);
7959 continue;
7960 }
7961 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7962 &extab_arm_sec);
7963 }
7964 }
7965
7966 printf ("\n");
7967
7968 arm_free_section (&exidx_arm_sec);
7969 arm_free_section (&extab_arm_sec);
7970}
7971
fa197c1c 7972/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7973
7974static void
0b6ae522
DJ		 7975arm_process_unwind (FILE *file)
7976{
7977 struct arm_unw_aux_info aux;
7978 Elf_Internal_Shdr *unwsec = NULL;
7979 Elf_Internal_Shdr *strsec;
7980 Elf_Internal_Shdr *sec;
7981 unsigned long i;
fa197c1c 7982 unsigned int sec_type;
0b6ae522 7983
fa197c1c
PB		 7984 switch (elf_header.e_machine)
7985 {
7986 case EM_ARM:
7987 sec_type = SHT_ARM_EXIDX;
7988 break;
7989
7990 case EM_TI_C6000:
7991 sec_type = SHT_C6000_UNWIND;
7992 break;
7993
0b4362b0 7994 default:
74e1a04b 7995 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 7996 elf_header.e_machine);
7997 return;
fa197c1c
PB		 7998 }
7999
0b6ae522 8000 if (string_table == NULL)
1b31d05e
NC		 8001 return;
8002
8003 memset (& aux, 0, sizeof (aux));
8004 aux.file = file;
0b6ae522
DJ		 8005
8006 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8007 {
8008 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8009 {
ba5cdace 8010 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8011
8012 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8013
8014 /* PR binutils/17531 file: 011-12666-0.004. */
8015 if (aux.strtab != NULL)
8016 {
4082ef84 8017 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8018 free (aux.strtab);
8019 }
0b6ae522
DJ		 8020 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8021 1, strsec->sh_size, _("string table"));
8022 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8023 }
fa197c1c 8024 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8025 unwsec = sec;
8026 }
8027
1b31d05e 8028 if (unwsec == NULL)
0b6ae522 8029 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8030 else
8031 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8032 {
8033 if (sec->sh_type == sec_type)
8034 {
8035 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8036 printable_section_name (sec),
1b31d05e
NC		 8037 (unsigned long) sec->sh_offset,
8038 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8039
1b31d05e
NC		 8040 dump_arm_unwind (&aux, sec);
8041 }
8042 }
0b6ae522
DJ		 8043
8044 if (aux.symtab)
8045 free (aux.symtab);
8046 if (aux.strtab)
8047 free ((char *) aux.strtab);
0b6ae522
DJ		 8048}
8049
1b31d05e 8050static void
2cf0635d 8051process_unwind (FILE * file)
57346661 8052{
2cf0635d
NC		 8053 struct unwind_handler
8054 {
57346661 8055 int machtype;
1b31d05e 8056 void (* handler)(FILE *);
2cf0635d
NC		 8057 } handlers[] =
8058 {
0b6ae522 8059 { EM_ARM, arm_process_unwind },
57346661
AM		 8060 { EM_IA_64, ia64_process_unwind },
8061 { EM_PARISC, hppa_process_unwind },
fa197c1c 8062 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8063 { 0, 0 }
8064 };
8065 int i;
8066
8067 if (!do_unwind)
1b31d05e 8068 return;
57346661
AM		 8069
8070 for (i = 0; handlers[i].handler != NULL; i++)
8071 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8072 {
8073 handlers[i].handler (file);
8074 return;
8075 }
57346661 8076
1b31d05e
NC		 8077 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8078 get_machine_name (elf_header.e_machine));
57346661
AM		 8079}
8080
252b5132 8081static void
2cf0635d 8082dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8083{
8084 switch (entry->d_tag)
8085 {
8086 case DT_MIPS_FLAGS:
8087 if (entry->d_un.d_val == 0)
4b68bca3 8088 printf (_("NONE"));
252b5132
RH		 8089 else
8090 {
8091 static const char * opts[] =
8092 {
8093 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8094 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8095 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8096 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8097 "RLD_ORDER_SAFE"
8098 };
8099 unsigned int cnt;
8100 int first = 1;
2b692964 8101
60bca95a 8102 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8103 if (entry->d_un.d_val & (1 << cnt))
8104 {
8105 printf ("%s%s", first ? "" : " ", opts[cnt]);
8106 first = 0;
8107 }
252b5132
RH		 8108 }
8109 break;
103f02d3 8110
252b5132 8111 case DT_MIPS_IVERSION:
d79b3d50 8112 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8113 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8114 else
76ca31c0
NC		 8115 {
8116 char buf[40];
8117 sprintf_vma (buf, entry->d_un.d_ptr);
8118 /* Note: coded this way so that there is a single string for translation. */
8119 printf (_("<corrupt: %s>"), buf);
8120 }
252b5132 8121 break;
103f02d3 8122
252b5132
RH		 8123 case DT_MIPS_TIME_STAMP:
8124 {
8125 char timebuf[20];
2cf0635d 8126 struct tm * tmp;
50da7a9c 8127
91d6fa6a
NC		 8128 time_t atime = entry->d_un.d_val;
8129 tmp = gmtime (&atime);
e9e44622
JJ		 8130 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8131 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8132 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8133 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8134 }
8135 break;
103f02d3 8136
252b5132
RH		 8137 case DT_MIPS_RLD_VERSION:
8138 case DT_MIPS_LOCAL_GOTNO:
8139 case DT_MIPS_CONFLICTNO:
8140 case DT_MIPS_LIBLISTNO:
8141 case DT_MIPS_SYMTABNO:
8142 case DT_MIPS_UNREFEXTNO:
8143 case DT_MIPS_HIPAGENO:
8144 case DT_MIPS_DELTA_CLASS_NO:
8145 case DT_MIPS_DELTA_INSTANCE_NO:
8146 case DT_MIPS_DELTA_RELOC_NO:
8147 case DT_MIPS_DELTA_SYM_NO:
8148 case DT_MIPS_DELTA_CLASSSYM_NO:
8149 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8150 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8151 break;
103f02d3
UD		 8152
8153 default:
4b68bca3 8154 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8155 }
4b68bca3 8156 putchar ('\n');
103f02d3
UD		 8157}
8158
103f02d3 8159static void
2cf0635d 8160dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8161{
8162 switch (entry->d_tag)
8163 {
8164 case DT_HP_DLD_FLAGS:
8165 {
8166 static struct
8167 {
8168 long int bit;
2cf0635d 8169 const char * str;
5e220199
NC		 8170 }
8171 flags[] =
8172 {
8173 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8174 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8175 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8176 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8177 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8178 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8179 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8180 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8181 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8182 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8183 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8184 { DT_HP_GST, "HP_GST" },
8185 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8186 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8187 { DT_HP_NODELETE, "HP_NODELETE" },
8188 { DT_HP_GROUP, "HP_GROUP" },
8189 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8190 };
103f02d3 8191 int first = 1;
5e220199 8192 size_t cnt;
f7a99963 8193 bfd_vma val = entry->d_un.d_val;
103f02d3 8194
60bca95a 8195 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8196 if (val & flags[cnt].bit)
30800947
NC		 8197 {
8198 if (! first)
8199 putchar (' ');
8200 fputs (flags[cnt].str, stdout);
8201 first = 0;
8202 val ^= flags[cnt].bit;
8203 }
76da6bbe 8204
103f02d3 8205 if (val != 0 || first)
f7a99963
NC		 8206 {
8207 if (! first)
8208 putchar (' ');
8209 print_vma (val, HEX);
8210 }
103f02d3
UD		 8211 }
8212 break;
76da6bbe 8213
252b5132 8214 default:
f7a99963
NC		 8215 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8216 break;
252b5132 8217 }
35b1837e 8218 putchar ('\n');
252b5132
RH		 8219}
8220
28f997cf
TG		 8221#ifdef BFD64
8222
8223/* VMS vs Unix time offset and factor. */
8224
8225#define VMS_EPOCH_OFFSET 35067168000000000LL
8226#define VMS_GRANULARITY_FACTOR 10000000
8227
8228/* Display a VMS time in a human readable format. */
8229
8230static void
8231print_vms_time (bfd_int64_t vmstime)
8232{
8233 struct tm *tm;
8234 time_t unxtime;
8235
8236 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8237 tm = gmtime (&unxtime);
8238 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8239 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8240 tm->tm_hour, tm->tm_min, tm->tm_sec);
8241}
8242#endif /* BFD64 */
8243
ecc51f48 8244static void
2cf0635d 8245dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8246{
8247 switch (entry->d_tag)
8248 {
0de14b54 8249 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8250 /* First 3 slots reserved. */
ecc51f48
NC		 8251 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8252 printf (" -- ");
8253 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8254 break;
8255
28f997cf
TG		 8256 case DT_IA_64_VMS_LINKTIME:
8257#ifdef BFD64
8258 print_vms_time (entry->d_un.d_val);
8259#endif
8260 break;
8261
8262 case DT_IA_64_VMS_LNKFLAGS:
8263 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8264 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8265 printf (" CALL_DEBUG");
8266 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8267 printf (" NOP0BUFS");
8268 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8269 printf (" P0IMAGE");
8270 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8271 printf (" MKTHREADS");
8272 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8273 printf (" UPCALLS");
8274 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8275 printf (" IMGSTA");
8276 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8277 printf (" INITIALIZE");
8278 if (entry->d_un.d_val & VMS_LF_MAIN)
8279 printf (" MAIN");
8280 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8281 printf (" EXE_INIT");
8282 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8283 printf (" TBK_IN_IMG");
8284 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8285 printf (" DBG_IN_IMG");
8286 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8287 printf (" TBK_IN_DSF");
8288 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8289 printf (" DBG_IN_DSF");
8290 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8291 printf (" SIGNATURES");
8292 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8293 printf (" REL_SEG_OFF");
8294 break;
8295
bdf4d63a
JJ		 8296 default:
8297 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8298 break;
ecc51f48 8299 }
bdf4d63a 8300 putchar ('\n');
ecc51f48
NC		 8301}
8302
252b5132 8303static int
2cf0635d 8304get_32bit_dynamic_section (FILE * file)
252b5132 8305{
2cf0635d
NC		 8306 Elf32_External_Dyn * edyn;
8307 Elf32_External_Dyn * ext;
8308 Elf_Internal_Dyn * entry;
103f02d3 8309
3f5e193b
NC		 8310 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8311 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8312 if (!edyn)
8313 return 0;
103f02d3 8314
071436c6
NC		 8315 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8316 might not have the luxury of section headers. Look for the DT_NULL
8317 terminator to determine the number of entries. */
ba2685cc 8318 for (ext = edyn, dynamic_nent = 0;
071436c6 8319 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8320 ext++)
8321 {
8322 dynamic_nent++;
8323 if (BYTE_GET (ext->d_tag) == DT_NULL)
8324 break;
8325 }
252b5132 8326
3f5e193b
NC		 8327 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8328 sizeof (* entry));
b2d38a17 8329 if (dynamic_section == NULL)
252b5132 8330 {
8b73c356
NC		 8331 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8332 (unsigned long) dynamic_nent);
9ea033b2
NC		 8333 free (edyn);
8334 return 0;
8335 }
252b5132 8336
fb514b26 8337 for (ext = edyn, entry = dynamic_section;
ba2685cc 8338 entry < dynamic_section + dynamic_nent;
fb514b26 8339 ext++, entry++)
9ea033b2 8340 {
fb514b26
AM		 8341 entry->d_tag = BYTE_GET (ext->d_tag);
8342 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8343 }
8344
9ea033b2
NC		 8345 free (edyn);
8346
8347 return 1;
8348}
8349
8350static int
2cf0635d 8351get_64bit_dynamic_section (FILE * file)
9ea033b2 8352{
2cf0635d
NC		 8353 Elf64_External_Dyn * edyn;
8354 Elf64_External_Dyn * ext;
8355 Elf_Internal_Dyn * entry;
103f02d3 8356
071436c6 8357 /* Read in the data. */
3f5e193b
NC		 8358 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8359 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8360 if (!edyn)
8361 return 0;
103f02d3 8362
071436c6
NC		 8363 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8364 might not have the luxury of section headers. Look for the DT_NULL
8365 terminator to determine the number of entries. */
ba2685cc 8366 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8367 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8368 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8369 ext++)
8370 {
8371 dynamic_nent++;
66543521 8372 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8373 break;
8374 }
252b5132 8375
3f5e193b
NC		 8376 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8377 sizeof (* entry));
b2d38a17 8378 if (dynamic_section == NULL)
252b5132 8379 {
8b73c356
NC		 8380 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8381 (unsigned long) dynamic_nent);
252b5132
RH		 8382 free (edyn);
8383 return 0;
8384 }
8385
071436c6 8386 /* Convert from external to internal formats. */
fb514b26 8387 for (ext = edyn, entry = dynamic_section;
ba2685cc 8388 entry < dynamic_section + dynamic_nent;
fb514b26 8389 ext++, entry++)
252b5132 8390 {
66543521
AM		 8391 entry->d_tag = BYTE_GET (ext->d_tag);
8392 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8393 }
8394
8395 free (edyn);
8396
9ea033b2
NC		 8397 return 1;
8398}
8399
e9e44622
JJ		 8400static void
8401print_dynamic_flags (bfd_vma flags)
d1133906 8402{
e9e44622 8403 int first = 1;
13ae64f3 8404
d1133906
NC		 8405 while (flags)
8406 {
8407 bfd_vma flag;
8408
8409 flag = flags & - flags;
8410 flags &= ~ flag;
8411
e9e44622
JJ		 8412 if (first)
8413 first = 0;
8414 else
8415 putc (' ', stdout);
13ae64f3 8416
d1133906
NC		 8417 switch (flag)
8418 {
e9e44622
JJ		 8419 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8420 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8421 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8422 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8423 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8424 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8425 }
8426 }
e9e44622 8427 puts ("");
d1133906
NC		 8428}
8429
b2d38a17
NC		 8430/* Parse and display the contents of the dynamic section. */
8431
9ea033b2 8432static int
2cf0635d 8433process_dynamic_section (FILE * file)
9ea033b2 8434{
2cf0635d 8435 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8436
8437 if (dynamic_size == 0)
8438 {
8439 if (do_dynamic)
b2d38a17 8440 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8441
8442 return 1;
8443 }
8444
8445 if (is_32bit_elf)
8446 {
b2d38a17 8447 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8448 return 0;
8449 }
b2d38a17 8450 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8451 return 0;
8452
252b5132
RH		 8453 /* Find the appropriate symbol table. */
8454 if (dynamic_symbols == NULL)
8455 {
86dba8ee
AM		 8456 for (entry = dynamic_section;
8457 entry < dynamic_section + dynamic_nent;
8458 ++entry)
252b5132 8459 {
c8286bd1 8460 Elf_Internal_Shdr section;
252b5132
RH		 8461
8462 if (entry->d_tag != DT_SYMTAB)
8463 continue;
8464
8465 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8466
8467 /* Since we do not know how big the symbol table is,
8468 we default to reading in the entire file (!) and
8469 processing that. This is overkill, I know, but it
e3c8793a 8470 should work. */
d93f0186 8471 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8472
fb52b2f4
NC		 8473 if (archive_file_offset != 0)
8474 section.sh_size = archive_file_size - section.sh_offset;
8475 else
8476 {
8477 if (fseek (file, 0, SEEK_END))
591a748a 8478 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8479
8480 section.sh_size = ftell (file) - section.sh_offset;
8481 }
252b5132 8482
9ea033b2 8483 if (is_32bit_elf)
9ad5cbcf 8484 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8485 else
9ad5cbcf 8486 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8487 section.sh_name = string_table_length;
252b5132 8488
ba5cdace 8489 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8490 if (num_dynamic_syms < 1)
252b5132
RH		 8491 {
8492 error (_("Unable to determine the number of symbols to load\n"));
8493 continue;
8494 }
252b5132
RH		 8495 }
8496 }
8497
8498 /* Similarly find a string table. */
8499 if (dynamic_strings == NULL)
8500 {
86dba8ee
AM		 8501 for (entry = dynamic_section;
8502 entry < dynamic_section + dynamic_nent;
8503 ++entry)
252b5132
RH		 8504 {
8505 unsigned long offset;
b34976b6 8506 long str_tab_len;
252b5132
RH		 8507
8508 if (entry->d_tag != DT_STRTAB)
8509 continue;
8510
8511 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8512
8513 /* Since we do not know how big the string table is,
8514 we default to reading in the entire file (!) and
8515 processing that. This is overkill, I know, but it
e3c8793a 8516 should work. */
252b5132 8517
d93f0186 8518 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8519
8520 if (archive_file_offset != 0)
8521 str_tab_len = archive_file_size - offset;
8522 else
8523 {
8524 if (fseek (file, 0, SEEK_END))
8525 error (_("Unable to seek to end of file\n"));
8526 str_tab_len = ftell (file) - offset;
8527 }
252b5132
RH		 8528
8529 if (str_tab_len < 1)
8530 {
8531 error
8532 (_("Unable to determine the length of the dynamic string table\n"));
8533 continue;
8534 }
8535
3f5e193b
NC		 8536 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8537 str_tab_len,
8538 _("dynamic string table"));
59245841 8539 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8540 break;
8541 }
8542 }
8543
8544 /* And find the syminfo section if available. */
8545 if (dynamic_syminfo == NULL)
8546 {
3e8bba36 8547 unsigned long syminsz = 0;
252b5132 8548
86dba8ee
AM		 8549 for (entry = dynamic_section;
8550 entry < dynamic_section + dynamic_nent;
8551 ++entry)
252b5132
RH		 8552 {
8553 if (entry->d_tag == DT_SYMINENT)
8554 {
8555 /* Note: these braces are necessary to avoid a syntax
8556 error from the SunOS4 C compiler. */
049b0c3a
NC		 8557 /* PR binutils/17531: A corrupt file can trigger this test.
8558 So do not use an assert, instead generate an error message. */
8559 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8560 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8561 (int) entry->d_un.d_val);
252b5132
RH		 8562 }
8563 else if (entry->d_tag == DT_SYMINSZ)
8564 syminsz = entry->d_un.d_val;
8565 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8566 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8567 syminsz);
252b5132
RH		 8568 }
8569
8570 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8571 {
2cf0635d
NC		 8572 Elf_External_Syminfo * extsyminfo;
8573 Elf_External_Syminfo * extsym;
8574 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8575
8576 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8577 extsyminfo = (Elf_External_Syminfo *)
8578 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8579 _("symbol information"));
a6e9f9df
AM		 8580 if (!extsyminfo)
8581 return 0;
252b5132 8582
3f5e193b 8583 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8584 if (dynamic_syminfo == NULL)
8585 {
8b73c356
NC		 8586 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8587 (unsigned long) syminsz);
252b5132
RH		 8588 return 0;
8589 }
8590
8591 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8592 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8593 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8594 ++syminfo, ++extsym)
252b5132 8595 {
86dba8ee
AM		 8596 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8597 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8598 }
8599
8600 free (extsyminfo);
8601 }
8602 }
8603
8604 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8605 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8606 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8607 if (do_dynamic)
8608 printf (_(" Tag Type Name/Value\n"));
8609
86dba8ee
AM		 8610 for (entry = dynamic_section;
8611 entry < dynamic_section + dynamic_nent;
8612 entry++)
252b5132
RH		 8613 {
8614 if (do_dynamic)
f7a99963 8615 {
2cf0635d 8616 const char * dtype;
e699b9ff 8617
f7a99963
NC		 8618 putchar (' ');
8619 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8620 dtype = get_dynamic_type (entry->d_tag);
8621 printf (" (%s)%*s", dtype,
8622 ((is_32bit_elf ? 27 : 19)
8623 - (int) strlen (dtype)),
f7a99963
NC		 8624 " ");
8625 }
252b5132
RH		 8626
8627 switch (entry->d_tag)
8628 {
d1133906
NC		 8629 case DT_FLAGS:
8630 if (do_dynamic)
e9e44622 8631 print_dynamic_flags (entry->d_un.d_val);
d1133906 8632 break;
76da6bbe 8633
252b5132
RH		 8634 case DT_AUXILIARY:
8635 case DT_FILTER:
019148e4
L		 8636 case DT_CONFIG:
8637 case DT_DEPAUDIT:
8638 case DT_AUDIT:
252b5132
RH		 8639 if (do_dynamic)
8640 {
019148e4 8641 switch (entry->d_tag)
b34976b6 8642 {
019148e4
L		 8643 case DT_AUXILIARY:
8644 printf (_("Auxiliary library"));
8645 break;
8646
8647 case DT_FILTER:
8648 printf (_("Filter library"));
8649 break;
8650
b34976b6 8651 case DT_CONFIG:
019148e4
L		 8652 printf (_("Configuration file"));
8653 break;
8654
8655 case DT_DEPAUDIT:
8656 printf (_("Dependency audit library"));
8657 break;
8658
8659 case DT_AUDIT:
8660 printf (_("Audit library"));
8661 break;
8662 }
252b5132 8663
d79b3d50
NC		 8664 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8665 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8666 else
f7a99963
NC		 8667 {
8668 printf (": ");
8669 print_vma (entry->d_un.d_val, PREFIX_HEX);
8670 putchar ('\n');
8671 }
252b5132
RH		 8672 }
8673 break;
8674
dcefbbbd 8675 case DT_FEATURE:
252b5132
RH		 8676 if (do_dynamic)
8677 {
8678 printf (_("Flags:"));
86f55779 8679
252b5132
RH		 8680 if (entry->d_un.d_val == 0)
8681 printf (_(" None\n"));
8682 else
8683 {
8684 unsigned long int val = entry->d_un.d_val;
86f55779 8685
252b5132
RH		 8686 if (val & DTF_1_PARINIT)
8687 {
8688 printf (" PARINIT");
8689 val ^= DTF_1_PARINIT;
8690 }
dcefbbbd
L		 8691 if (val & DTF_1_CONFEXP)
8692 {
8693 printf (" CONFEXP");
8694 val ^= DTF_1_CONFEXP;
8695 }
252b5132
RH		 8696 if (val != 0)
8697 printf (" %lx", val);
8698 puts ("");
8699 }
8700 }
8701 break;
8702
8703 case DT_POSFLAG_1:
8704 if (do_dynamic)
8705 {
8706 printf (_("Flags:"));
86f55779 8707
252b5132
RH		 8708 if (entry->d_un.d_val == 0)
8709 printf (_(" None\n"));
8710 else
8711 {
8712 unsigned long int val = entry->d_un.d_val;
86f55779 8713
252b5132
RH		 8714 if (val & DF_P1_LAZYLOAD)
8715 {
8716 printf (" LAZYLOAD");
8717 val ^= DF_P1_LAZYLOAD;
8718 }
8719 if (val & DF_P1_GROUPPERM)
8720 {
8721 printf (" GROUPPERM");
8722 val ^= DF_P1_GROUPPERM;
8723 }
8724 if (val != 0)
8725 printf (" %lx", val);
8726 puts ("");
8727 }
8728 }
8729 break;
8730
8731 case DT_FLAGS_1:
8732 if (do_dynamic)
8733 {
8734 printf (_("Flags:"));
8735 if (entry->d_un.d_val == 0)
8736 printf (_(" None\n"));
8737 else
8738 {
8739 unsigned long int val = entry->d_un.d_val;
86f55779 8740
252b5132
RH		 8741 if (val & DF_1_NOW)
8742 {
8743 printf (" NOW");
8744 val ^= DF_1_NOW;
8745 }
8746 if (val & DF_1_GLOBAL)
8747 {
8748 printf (" GLOBAL");
8749 val ^= DF_1_GLOBAL;
8750 }
8751 if (val & DF_1_GROUP)
8752 {
8753 printf (" GROUP");
8754 val ^= DF_1_GROUP;
8755 }
8756 if (val & DF_1_NODELETE)
8757 {
8758 printf (" NODELETE");
8759 val ^= DF_1_NODELETE;
8760 }
8761 if (val & DF_1_LOADFLTR)
8762 {
8763 printf (" LOADFLTR");
8764 val ^= DF_1_LOADFLTR;
8765 }
8766 if (val & DF_1_INITFIRST)
8767 {
8768 printf (" INITFIRST");
8769 val ^= DF_1_INITFIRST;
8770 }
8771 if (val & DF_1_NOOPEN)
8772 {
8773 printf (" NOOPEN");
8774 val ^= DF_1_NOOPEN;
8775 }
8776 if (val & DF_1_ORIGIN)
8777 {
8778 printf (" ORIGIN");
8779 val ^= DF_1_ORIGIN;
8780 }
8781 if (val & DF_1_DIRECT)
8782 {
8783 printf (" DIRECT");
8784 val ^= DF_1_DIRECT;
8785 }
8786 if (val & DF_1_TRANS)
8787 {
8788 printf (" TRANS");
8789 val ^= DF_1_TRANS;
8790 }
8791 if (val & DF_1_INTERPOSE)
8792 {
8793 printf (" INTERPOSE");
8794 val ^= DF_1_INTERPOSE;
8795 }
f7db6139 8796 if (val & DF_1_NODEFLIB)
dcefbbbd 8797 {
f7db6139
L		 8798 printf (" NODEFLIB");
8799 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8800 }
8801 if (val & DF_1_NODUMP)
8802 {
8803 printf (" NODUMP");
8804 val ^= DF_1_NODUMP;
8805 }
34b60028 8806 if (val & DF_1_CONFALT)
dcefbbbd 8807 {
34b60028
L		 8808 printf (" CONFALT");
8809 val ^= DF_1_CONFALT;
8810 }
8811 if (val & DF_1_ENDFILTEE)
8812 {
8813 printf (" ENDFILTEE");
8814 val ^= DF_1_ENDFILTEE;
8815 }
8816 if (val & DF_1_DISPRELDNE)
8817 {
8818 printf (" DISPRELDNE");
8819 val ^= DF_1_DISPRELDNE;
8820 }
8821 if (val & DF_1_DISPRELPND)
8822 {
8823 printf (" DISPRELPND");
8824 val ^= DF_1_DISPRELPND;
8825 }
8826 if (val & DF_1_NODIRECT)
8827 {
8828 printf (" NODIRECT");
8829 val ^= DF_1_NODIRECT;
8830 }
8831 if (val & DF_1_IGNMULDEF)
8832 {
8833 printf (" IGNMULDEF");
8834 val ^= DF_1_IGNMULDEF;
8835 }
8836 if (val & DF_1_NOKSYMS)
8837 {
8838 printf (" NOKSYMS");
8839 val ^= DF_1_NOKSYMS;
8840 }
8841 if (val & DF_1_NOHDR)
8842 {
8843 printf (" NOHDR");
8844 val ^= DF_1_NOHDR;
8845 }
8846 if (val & DF_1_EDITED)
8847 {
8848 printf (" EDITED");
8849 val ^= DF_1_EDITED;
8850 }
8851 if (val & DF_1_NORELOC)
8852 {
8853 printf (" NORELOC");
8854 val ^= DF_1_NORELOC;
8855 }
8856 if (val & DF_1_SYMINTPOSE)
8857 {
8858 printf (" SYMINTPOSE");
8859 val ^= DF_1_SYMINTPOSE;
8860 }
8861 if (val & DF_1_GLOBAUDIT)
8862 {
8863 printf (" GLOBAUDIT");
8864 val ^= DF_1_GLOBAUDIT;
8865 }
8866 if (val & DF_1_SINGLETON)
8867 {
8868 printf (" SINGLETON");
8869 val ^= DF_1_SINGLETON;
dcefbbbd 8870 }
252b5132
RH		 8871 if (val != 0)
8872 printf (" %lx", val);
8873 puts ("");
8874 }
8875 }
8876 break;
8877
8878 case DT_PLTREL:
566b0d53 8879 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8880 if (do_dynamic)
8881 puts (get_dynamic_type (entry->d_un.d_val));
8882 break;
8883
8884 case DT_NULL :
8885 case DT_NEEDED :
8886 case DT_PLTGOT :
8887 case DT_HASH :
8888 case DT_STRTAB :
8889 case DT_SYMTAB :
8890 case DT_RELA :
8891 case DT_INIT :
8892 case DT_FINI :
8893 case DT_SONAME :
8894 case DT_RPATH :
8895 case DT_SYMBOLIC:
8896 case DT_REL :
8897 case DT_DEBUG :
8898 case DT_TEXTREL :
8899 case DT_JMPREL :
019148e4 8900 case DT_RUNPATH :
252b5132
RH		 8901 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8902
8903 if (do_dynamic)
8904 {
2cf0635d 8905 char * name;
252b5132 8906
d79b3d50
NC		 8907 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8908 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8909 else
d79b3d50 8910 name = NULL;
252b5132
RH		 8911
8912 if (name)
8913 {
8914 switch (entry->d_tag)
8915 {
8916 case DT_NEEDED:
8917 printf (_("Shared library: [%s]"), name);
8918
18bd398b 8919 if (streq (name, program_interpreter))
f7a99963 8920 printf (_(" program interpreter"));
252b5132
RH		 8921 break;
8922
8923 case DT_SONAME:
f7a99963 8924 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8925 break;
8926
8927 case DT_RPATH:
f7a99963 8928 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8929 break;
8930
019148e4
L		 8931 case DT_RUNPATH:
8932 printf (_("Library runpath: [%s]"), name);
8933 break;
8934
252b5132 8935 default:
f7a99963
NC		 8936 print_vma (entry->d_un.d_val, PREFIX_HEX);
8937 break;
252b5132
RH		 8938 }
8939 }
8940 else
f7a99963
NC		 8941 print_vma (entry->d_un.d_val, PREFIX_HEX);
8942
8943 putchar ('\n');
252b5132
RH		 8944 }
8945 break;
8946
8947 case DT_PLTRELSZ:
8948 case DT_RELASZ :
8949 case DT_STRSZ :
8950 case DT_RELSZ :
8951 case DT_RELAENT :
8952 case DT_SYMENT :
8953 case DT_RELENT :
566b0d53 8954 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8955 case DT_PLTPADSZ:
8956 case DT_MOVEENT :
8957 case DT_MOVESZ :
8958 case DT_INIT_ARRAYSZ:
8959 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8960 case DT_GNU_CONFLICTSZ:
8961 case DT_GNU_LIBLISTSZ:
252b5132 8962 if (do_dynamic)
f7a99963
NC		 8963 {
8964 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8965 printf (_(" (bytes)\n"));
f7a99963 8966 }
252b5132
RH		 8967 break;
8968
8969 case DT_VERDEFNUM:
8970 case DT_VERNEEDNUM:
8971 case DT_RELACOUNT:
8972 case DT_RELCOUNT:
8973 if (do_dynamic)
f7a99963
NC		 8974 {
8975 print_vma (entry->d_un.d_val, UNSIGNED);
8976 putchar ('\n');
8977 }
252b5132
RH		 8978 break;
8979
8980 case DT_SYMINSZ:
8981 case DT_SYMINENT:
8982 case DT_SYMINFO:
8983 case DT_USED:
8984 case DT_INIT_ARRAY:
8985 case DT_FINI_ARRAY:
8986 if (do_dynamic)
8987 {
d79b3d50
NC		 8988 if (entry->d_tag == DT_USED
8989 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8990 {
2cf0635d 8991 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8992
b34976b6 8993 if (*name)
252b5132
RH		 8994 {
8995 printf (_("Not needed object: [%s]\n"), name);
8996 break;
8997 }
8998 }
103f02d3 8999
f7a99963
NC		 9000 print_vma (entry->d_un.d_val, PREFIX_HEX);
9001 putchar ('\n');
252b5132
RH		 9002 }
9003 break;
9004
9005 case DT_BIND_NOW:
9006 /* The value of this entry is ignored. */
35b1837e
AM		 9007 if (do_dynamic)
9008 putchar ('\n');
252b5132 9009 break;
103f02d3 9010
047b2264
JJ		 9011 case DT_GNU_PRELINKED:
9012 if (do_dynamic)
9013 {
2cf0635d 9014 struct tm * tmp;
91d6fa6a 9015 time_t atime = entry->d_un.d_val;
047b2264 9016
91d6fa6a 9017 tmp = gmtime (&atime);
071436c6
NC		 9018 /* PR 17533 file: 041-1244816-0.004. */
9019 if (tmp == NULL)
5a2cbcf4
L		 9020 printf (_("<corrupt time val: %lx"),
9021 (unsigned long) atime);
071436c6
NC		 9022 else
9023 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9024 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9025 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9026
9027 }
9028 break;
9029
fdc90cb4
JJ		 9030 case DT_GNU_HASH:
9031 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9032 if (do_dynamic)
9033 {
9034 print_vma (entry->d_un.d_val, PREFIX_HEX);
9035 putchar ('\n');
9036 }
9037 break;
9038
252b5132
RH		 9039 default:
9040 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9041 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9042 entry->d_un.d_val;
9043
9044 if (do_dynamic)
9045 {
9046 switch (elf_header.e_machine)
9047 {
9048 case EM_MIPS:
4fe85591 9049 case EM_MIPS_RS3_LE:
b2d38a17 9050 dynamic_section_mips_val (entry);
252b5132 9051 break;
103f02d3 9052 case EM_PARISC:
b2d38a17 9053 dynamic_section_parisc_val (entry);
103f02d3 9054 break;
ecc51f48 9055 case EM_IA_64:
b2d38a17 9056 dynamic_section_ia64_val (entry);
ecc51f48 9057 break;
252b5132 9058 default:
f7a99963
NC		 9059 print_vma (entry->d_un.d_val, PREFIX_HEX);
9060 putchar ('\n');
252b5132
RH		 9061 }
9062 }
9063 break;
9064 }
9065 }
9066
9067 return 1;
9068}
9069
9070static char *
d3ba0551 9071get_ver_flags (unsigned int flags)
252b5132 9072{
b34976b6 9073 static char buff[32];
252b5132
RH		 9074
9075 buff[0] = 0;
9076
9077 if (flags == 0)
9078 return _("none");
9079
9080 if (flags & VER_FLG_BASE)
9081 strcat (buff, "BASE ");
9082
9083 if (flags & VER_FLG_WEAK)
9084 {
9085 if (flags & VER_FLG_BASE)
9086 strcat (buff, "| ");
9087
9088 strcat (buff, "WEAK ");
9089 }
9090
44ec90b9
RO		 9091 if (flags & VER_FLG_INFO)
9092 {
9093 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9094 strcat (buff, "| ");
9095
9096 strcat (buff, "INFO ");
9097 }
9098
9099 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9100 strcat (buff, _("| <unknown>"));
252b5132
RH		 9101
9102 return buff;
9103}
9104
9105/* Display the contents of the version sections. */
98fb390a 9106
252b5132 9107static int
2cf0635d 9108process_version_sections (FILE * file)
252b5132 9109{
2cf0635d 9110 Elf_Internal_Shdr * section;
b34976b6
AM		 9111 unsigned i;
9112 int found = 0;
252b5132
RH		 9113
9114 if (! do_version)
9115 return 1;
9116
9117 for (i = 0, section = section_headers;
9118 i < elf_header.e_shnum;
b34976b6 9119 i++, section++)
252b5132
RH		 9120 {
9121 switch (section->sh_type)
9122 {
9123 case SHT_GNU_verdef:
9124 {
2cf0635d 9125 Elf_External_Verdef * edefs;
b34976b6
AM		 9126 unsigned int idx;
9127 unsigned int cnt;
2cf0635d 9128 char * endbuf;
252b5132
RH		 9129
9130 found = 1;
9131
74e1a04b
NC		 9132 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9133 printable_section_name (section),
9134 section->sh_info);
252b5132
RH		 9135
9136 printf (_(" Addr: 0x"));
9137 printf_vma (section->sh_addr);
74e1a04b 9138 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9139 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9140 printable_section_name_from_index (section->sh_link));
252b5132 9141
3f5e193b
NC		 9142 edefs = (Elf_External_Verdef *)
9143 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9144 _("version definition section"));
a6e9f9df
AM		 9145 if (!edefs)
9146 break;
59245841 9147 endbuf = (char *) edefs + section->sh_size;
252b5132 9148
b34976b6 9149 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9150 {
2cf0635d
NC		 9151 char * vstart;
9152 Elf_External_Verdef * edef;
b34976b6 9153 Elf_Internal_Verdef ent;
2cf0635d 9154 Elf_External_Verdaux * eaux;
b34976b6
AM		 9155 Elf_Internal_Verdaux aux;
9156 int j;
9157 int isum;
103f02d3 9158
7e26601c
NC		 9159 /* Check for very large indicies. */
9160 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9161 break;
9162
252b5132 9163 vstart = ((char *) edefs) + idx;
54806181
AM		 9164 if (vstart + sizeof (*edef) > endbuf)
9165 break;
252b5132
RH		 9166
9167 edef = (Elf_External_Verdef *) vstart;
9168
9169 ent.vd_version = BYTE_GET (edef->vd_version);
9170 ent.vd_flags = BYTE_GET (edef->vd_flags);
9171 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9172 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9173 ent.vd_hash = BYTE_GET (edef->vd_hash);
9174 ent.vd_aux = BYTE_GET (edef->vd_aux);
9175 ent.vd_next = BYTE_GET (edef->vd_next);
9176
9177 printf (_(" %#06x: Rev: %d Flags: %s"),
9178 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9179
9180 printf (_(" Index: %d Cnt: %d "),
9181 ent.vd_ndx, ent.vd_cnt);
9182
dd24e3da 9183 /* Check for overflow. */
7e26601c 9184 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9185 break;
9186
252b5132
RH		 9187 vstart += ent.vd_aux;
9188
9189 eaux = (Elf_External_Verdaux *) vstart;
9190
9191 aux.vda_name = BYTE_GET (eaux->vda_name);
9192 aux.vda_next = BYTE_GET (eaux->vda_next);
9193
d79b3d50
NC		 9194 if (VALID_DYNAMIC_NAME (aux.vda_name))
9195 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9196 else
9197 printf (_("Name index: %ld\n"), aux.vda_name);
9198
9199 isum = idx + ent.vd_aux;
9200
b34976b6 9201 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9202 {
dd24e3da 9203 /* Check for overflow. */
7e26601c 9204 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9205 break;
9206
252b5132
RH		 9207 isum += aux.vda_next;
9208 vstart += aux.vda_next;
9209
9210 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9211 if (vstart + sizeof (*eaux) > endbuf)
9212 break;
252b5132
RH		 9213
9214 aux.vda_name = BYTE_GET (eaux->vda_name);
9215 aux.vda_next = BYTE_GET (eaux->vda_next);
9216
d79b3d50 9217 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9218 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9219 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9220 else
9221 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9222 isum, j, aux.vda_name);
9223 }
dd24e3da 9224
54806181
AM		 9225 if (j < ent.vd_cnt)
9226 printf (_(" Version def aux past end of section\n"));
252b5132 9227
5d921cbd
NC		 9228 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9229 if (idx + ent.vd_next <= idx)
9230 break;
9231
252b5132
RH		 9232 idx += ent.vd_next;
9233 }
dd24e3da 9234
54806181
AM		 9235 if (cnt < section->sh_info)
9236 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9237
9238 free (edefs);
9239 }
9240 break;
103f02d3 9241
252b5132
RH		 9242 case SHT_GNU_verneed:
9243 {
2cf0635d 9244 Elf_External_Verneed * eneed;
b34976b6
AM		 9245 unsigned int idx;
9246 unsigned int cnt;
2cf0635d 9247 char * endbuf;
252b5132
RH		 9248
9249 found = 1;
9250
72de5009 9251 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9252 printable_section_name (section), section->sh_info);
252b5132
RH		 9253
9254 printf (_(" Addr: 0x"));
9255 printf_vma (section->sh_addr);
72de5009 9256 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9257 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9258 printable_section_name_from_index (section->sh_link));
252b5132 9259
3f5e193b
NC		 9260 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9261 section->sh_offset, 1,
9262 section->sh_size,
9cf03b7e 9263 _("Version Needs section"));
a6e9f9df
AM		 9264 if (!eneed)
9265 break;
59245841 9266 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9267
9268 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9269 {
2cf0635d 9270 Elf_External_Verneed * entry;
b34976b6
AM		 9271 Elf_Internal_Verneed ent;
9272 int j;
9273 int isum;
2cf0635d 9274 char * vstart;
252b5132 9275
7e26601c 9276 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9277 break;
9278
252b5132 9279 vstart = ((char *) eneed) + idx;
54806181
AM		 9280 if (vstart + sizeof (*entry) > endbuf)
9281 break;
252b5132
RH		 9282
9283 entry = (Elf_External_Verneed *) vstart;
9284
9285 ent.vn_version = BYTE_GET (entry->vn_version);
9286 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9287 ent.vn_file = BYTE_GET (entry->vn_file);
9288 ent.vn_aux = BYTE_GET (entry->vn_aux);
9289 ent.vn_next = BYTE_GET (entry->vn_next);
9290
9291 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9292
d79b3d50
NC		 9293 if (VALID_DYNAMIC_NAME (ent.vn_file))
9294 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9295 else
9296 printf (_(" File: %lx"), ent.vn_file);
9297
9298 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9299
dd24e3da 9300 /* Check for overflow. */
7e26601c 9301 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9302 break;
9303
252b5132
RH		 9304 vstart += ent.vn_aux;
9305
9306 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9307 {
2cf0635d 9308 Elf_External_Vernaux * eaux;
b34976b6 9309 Elf_Internal_Vernaux aux;
252b5132 9310
54806181
AM		 9311 if (vstart + sizeof (*eaux) > endbuf)
9312 break;
252b5132
RH		 9313 eaux = (Elf_External_Vernaux *) vstart;
9314
9315 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9316 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9317 aux.vna_other = BYTE_GET (eaux->vna_other);
9318 aux.vna_name = BYTE_GET (eaux->vna_name);
9319 aux.vna_next = BYTE_GET (eaux->vna_next);
9320
d79b3d50 9321 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9322 printf (_(" %#06x: Name: %s"),
d79b3d50 9323 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9324 else
ecc2063b 9325 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9326 isum, aux.vna_name);
9327
9328 printf (_(" Flags: %s Version: %d\n"),
9329 get_ver_flags (aux.vna_flags), aux.vna_other);
9330
dd24e3da 9331 /* Check for overflow. */
7e26601c 9332 if (aux.vna_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9333 break;
9334
252b5132
RH		 9335 isum += aux.vna_next;
9336 vstart += aux.vna_next;
9337 }
9cf03b7e 9338
54806181 9339 if (j < ent.vn_cnt)
9cf03b7e 9340 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9341
bcf83b2a 9342 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9343 {
9344 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9345 cnt = section->sh_info;
9346 break;
9347 }
252b5132
RH		 9348 idx += ent.vn_next;
9349 }
9cf03b7e 9350
54806181 9351 if (cnt < section->sh_info)
9cf03b7e 9352 warn (_("Missing Version Needs information\n"));
103f02d3 9353
252b5132
RH		 9354 free (eneed);
9355 }
9356 break;
9357
9358 case SHT_GNU_versym:
9359 {
2cf0635d 9360 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9361 size_t total;
9362 unsigned int cnt;
2cf0635d
NC		 9363 unsigned char * edata;
9364 unsigned short * data;
9365 char * strtab;
9366 Elf_Internal_Sym * symbols;
9367 Elf_Internal_Shdr * string_sec;
ba5cdace 9368 unsigned long num_syms;
d3ba0551 9369 long off;
252b5132 9370
4fbb74a6 9371 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9372 break;
9373
4fbb74a6 9374 link_section = section_headers + section->sh_link;
08d8fa11 9375 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9376
4fbb74a6 9377 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9378 break;
9379
252b5132
RH		 9380 found = 1;
9381
ba5cdace 9382 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9383 if (symbols == NULL)
9384 break;
252b5132 9385
4fbb74a6 9386 string_sec = section_headers + link_section->sh_link;
252b5132 9387
3f5e193b
NC		 9388 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9389 string_sec->sh_size,
9390 _("version string table"));
a6e9f9df 9391 if (!strtab)
0429c154
MS		 9392 {
9393 free (symbols);
9394 break;
9395 }
252b5132 9396
8b73c356
NC		 9397 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9398 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9399
9400 printf (_(" Addr: "));
9401 printf_vma (section->sh_addr);
72de5009 9402 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9403 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9404 printable_section_name (link_section));
252b5132 9405
d3ba0551
AM		 9406 off = offset_from_vma (file,
9407 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9408 total * sizeof (short));
3f5e193b
NC		 9409 edata = (unsigned char *) get_data (NULL, file, off, total,
9410 sizeof (short),
9411 _("version symbol data"));
a6e9f9df
AM		 9412 if (!edata)
9413 {
9414 free (strtab);
0429c154 9415 free (symbols);
a6e9f9df
AM		 9416 break;
9417 }
252b5132 9418
3f5e193b 9419 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9420
9421 for (cnt = total; cnt --;)
b34976b6
AM		 9422 data[cnt] = byte_get (edata + cnt * sizeof (short),
9423 sizeof (short));
252b5132
RH		 9424
9425 free (edata);
9426
9427 for (cnt = 0; cnt < total; cnt += 4)
9428 {
9429 int j, nn;
00d93f34 9430 int check_def, check_need;
2cf0635d 9431 char * name;
252b5132
RH		 9432
9433 printf (" %03x:", cnt);
9434
9435 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9436 switch (data[cnt + j])
252b5132
RH		 9437 {
9438 case 0:
9439 fputs (_(" 0 (*local*) "), stdout);
9440 break;
9441
9442 case 1:
9443 fputs (_(" 1 (*global*) "), stdout);
9444 break;
9445
9446 default:
c244d050
NC		 9447 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9448 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9449
dd24e3da 9450 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9451 array, break to avoid an out-of-bounds read. */
9452 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9453 {
9454 warn (_("invalid index into symbol array\n"));
9455 break;
9456 }
9457
00d93f34
JJ		 9458 check_def = 1;
9459 check_need = 1;
4fbb74a6
AM		 9460 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9461 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9462 != SHT_NOBITS)
252b5132 9463 {
b34976b6 9464 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9465 check_def = 0;
9466 else
9467 check_need = 0;
252b5132 9468 }
00d93f34
JJ		 9469
9470 if (check_need
b34976b6 9471 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9472 {
b34976b6
AM		 9473 Elf_Internal_Verneed ivn;
9474 unsigned long offset;
252b5132 9475
d93f0186
NC		 9476 offset = offset_from_vma
9477 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9478 sizeof (Elf_External_Verneed));
252b5132 9479
b34976b6 9480 do
252b5132 9481 {
b34976b6
AM		 9482 Elf_Internal_Vernaux ivna;
9483 Elf_External_Verneed evn;
9484 Elf_External_Vernaux evna;
9485 unsigned long a_off;
252b5132 9486
59245841
NC		 9487 if (get_data (&evn, file, offset, sizeof (evn), 1,
9488 _("version need")) == NULL)
9489 break;
0b4362b0 9490
252b5132
RH		 9491 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9492 ivn.vn_next = BYTE_GET (evn.vn_next);
9493
9494 a_off = offset + ivn.vn_aux;
9495
9496 do
9497 {
59245841
NC		 9498 if (get_data (&evna, file, a_off, sizeof (evna),
9499 1, _("version need aux (2)")) == NULL)
9500 {
9501 ivna.vna_next = 0;
9502 ivna.vna_other = 0;
9503 }
9504 else
9505 {
9506 ivna.vna_next = BYTE_GET (evna.vna_next);
9507 ivna.vna_other = BYTE_GET (evna.vna_other);
9508 }
252b5132
RH		 9509
9510 a_off += ivna.vna_next;
9511 }
b34976b6 9512 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9513 && ivna.vna_next != 0);
9514
b34976b6 9515 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9516 {
9517 ivna.vna_name = BYTE_GET (evna.vna_name);
9518
54806181
AM		 9519 if (ivna.vna_name >= string_sec->sh_size)
9520 name = _("*invalid*");
9521 else
9522 name = strtab + ivna.vna_name;
252b5132 9523 nn += printf ("(%s%-*s",
16062207
ILT		 9524 name,
9525 12 - (int) strlen (name),
252b5132 9526 ")");
00d93f34 9527 check_def = 0;
252b5132
RH		 9528 break;
9529 }
9530
9531 offset += ivn.vn_next;
9532 }
9533 while (ivn.vn_next);
9534 }
00d93f34 9535
b34976b6
AM		 9536 if (check_def && data[cnt + j] != 0x8001
9537 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9538 {
b34976b6
AM		 9539 Elf_Internal_Verdef ivd;
9540 Elf_External_Verdef evd;
9541 unsigned long offset;
252b5132 9542
d93f0186
NC		 9543 offset = offset_from_vma
9544 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9545 sizeof evd);
252b5132
RH		 9546
9547 do
9548 {
59245841
NC		 9549 if (get_data (&evd, file, offset, sizeof (evd), 1,
9550 _("version def")) == NULL)
9551 {
9552 ivd.vd_next = 0;
3102e897
NC		 9553 /* PR 17531: file: 046-1082287-0.004. */
9554 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9555 break;
59245841
NC		 9556 }
9557 else
9558 {
9559 ivd.vd_next = BYTE_GET (evd.vd_next);
9560 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9561 }
252b5132
RH		 9562
9563 offset += ivd.vd_next;
9564 }
c244d050 9565 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9566 && ivd.vd_next != 0);
9567
c244d050 9568 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9569 {
b34976b6
AM		 9570 Elf_External_Verdaux evda;
9571 Elf_Internal_Verdaux ivda;
252b5132
RH		 9572
9573 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9574
59245841
NC		 9575 if (get_data (&evda, file,
9576 offset - ivd.vd_next + ivd.vd_aux,
9577 sizeof (evda), 1,
9578 _("version def aux")) == NULL)
9579 break;
252b5132
RH		 9580
9581 ivda.vda_name = BYTE_GET (evda.vda_name);
9582
54806181
AM		 9583 if (ivda.vda_name >= string_sec->sh_size)
9584 name = _("*invalid*");
9585 else
9586 name = strtab + ivda.vda_name;
252b5132 9587 nn += printf ("(%s%-*s",
16062207
ILT		 9588 name,
9589 12 - (int) strlen (name),
252b5132
RH		 9590 ")");
9591 }
9592 }
9593
9594 if (nn < 18)
9595 printf ("%*c", 18 - nn, ' ');
9596 }
9597
9598 putchar ('\n');
9599 }
9600
9601 free (data);
9602 free (strtab);
9603 free (symbols);
9604 }
9605 break;
103f02d3 9606
252b5132
RH		 9607 default:
9608 break;
9609 }
9610 }
9611
9612 if (! found)
9613 printf (_("\nNo version information found in this file.\n"));
9614
9615 return 1;
9616}
9617
d1133906 9618static const char *
d3ba0551 9619get_symbol_binding (unsigned int binding)
252b5132 9620{
b34976b6 9621 static char buff[32];
252b5132
RH		 9622
9623 switch (binding)
9624 {
b34976b6
AM		 9625 case STB_LOCAL: return "LOCAL";
9626 case STB_GLOBAL: return "GLOBAL";
9627 case STB_WEAK: return "WEAK";
252b5132
RH		 9628 default:
9629 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9630 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9631 binding);
252b5132 9632 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9633 {
9634 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9635 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9636 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9637 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9638 return "UNIQUE";
9639 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9640 }
252b5132 9641 else
e9e44622 9642 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9643 return buff;
9644 }
9645}
9646
d1133906 9647static const char *
d3ba0551 9648get_symbol_type (unsigned int type)
252b5132 9649{
b34976b6 9650 static char buff[32];
252b5132
RH		 9651
9652 switch (type)
9653 {
b34976b6
AM		 9654 case STT_NOTYPE: return "NOTYPE";
9655 case STT_OBJECT: return "OBJECT";
9656 case STT_FUNC: return "FUNC";
9657 case STT_SECTION: return "SECTION";
9658 case STT_FILE: return "FILE";
9659 case STT_COMMON: return "COMMON";
9660 case STT_TLS: return "TLS";
15ab5209
DB		 9661 case STT_RELC: return "RELC";
9662 case STT_SRELC: return "SRELC";
252b5132
RH		 9663 default:
9664 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9665 {
3510a7b8
NC		 9666 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9667 return "THUMB_FUNC";
103f02d3 9668
351b4b40 9669 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9670 return "REGISTER";
9671
9672 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9673 return "PARISC_MILLI";
9674
e9e44622 9675 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9676 }
252b5132 9677 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9678 {
9679 if (elf_header.e_machine == EM_PARISC)
9680 {
9681 if (type == STT_HP_OPAQUE)
9682 return "HP_OPAQUE";
9683 if (type == STT_HP_STUB)
9684 return "HP_STUB";
9685 }
9686
d8045f23 9687 if (type == STT_GNU_IFUNC
9c55345c 9688 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9689 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9690 /* GNU is still using the default value 0. */
d8045f23
NC		 9691 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9692 return "IFUNC";
9693
e9e44622 9694 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9695 }
252b5132 9696 else
e9e44622 9697 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9698 return buff;
9699 }
9700}
9701
d1133906 9702static const char *
d3ba0551 9703get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9704{
9705 switch (visibility)
9706 {
b34976b6
AM		 9707 case STV_DEFAULT: return "DEFAULT";
9708 case STV_INTERNAL: return "INTERNAL";
9709 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9710 case STV_PROTECTED: return "PROTECTED";
9711 default: abort ();
9712 }
9713}
9714
5e2b0d47
NC		 9715static const char *
9716get_mips_symbol_other (unsigned int other)
9717{
9718 switch (other)
9719 {
df58fc94
RS		 9720 case STO_OPTIONAL:
9721 return "OPTIONAL";
9722 case STO_MIPS_PLT:
9723 return "MIPS PLT";
9724 case STO_MIPS_PIC:
9725 return "MIPS PIC";
9726 case STO_MICROMIPS:
9727 return "MICROMIPS";
9728 case STO_MICROMIPS | STO_MIPS_PIC:
9729 return "MICROMIPS, MIPS PIC";
9730 case STO_MIPS16:
9731 return "MIPS16";
9732 default:
9733 return NULL;
5e2b0d47
NC		 9734 }
9735}
9736
28f997cf
TG		 9737static const char *
9738get_ia64_symbol_other (unsigned int other)
9739{
9740 if (is_ia64_vms ())
9741 {
9742 static char res[32];
9743
9744 res[0] = 0;
9745
9746 /* Function types is for images and .STB files only. */
9747 switch (elf_header.e_type)
9748 {
9749 case ET_DYN:
9750 case ET_EXEC:
9751 switch (VMS_ST_FUNC_TYPE (other))
9752 {
9753 case VMS_SFT_CODE_ADDR:
9754 strcat (res, " CA");
9755 break;
9756 case VMS_SFT_SYMV_IDX:
9757 strcat (res, " VEC");
9758 break;
9759 case VMS_SFT_FD:
9760 strcat (res, " FD");
9761 break;
9762 case VMS_SFT_RESERVE:
9763 strcat (res, " RSV");
9764 break;
9765 default:
9766 abort ();
9767 }
9768 break;
9769 default:
9770 break;
9771 }
9772 switch (VMS_ST_LINKAGE (other))
9773 {
9774 case VMS_STL_IGNORE:
9775 strcat (res, " IGN");
9776 break;
9777 case VMS_STL_RESERVE:
9778 strcat (res, " RSV");
9779 break;
9780 case VMS_STL_STD:
9781 strcat (res, " STD");
9782 break;
9783 case VMS_STL_LNK:
9784 strcat (res, " LNK");
9785 break;
9786 default:
9787 abort ();
9788 }
9789
9790 if (res[0] != 0)
9791 return res + 1;
9792 else
9793 return res;
9794 }
9795 return NULL;
9796}
9797
6911b7dc
AM		 9798static const char *
9799get_ppc64_symbol_other (unsigned int other)
9800{
9801 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9802 {
9803 static char buf[32];
9804 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9805 PPC64_LOCAL_ENTRY_OFFSET (other));
9806 return buf;
9807 }
9808 return NULL;
9809}
9810
5e2b0d47
NC		 9811static const char *
9812get_symbol_other (unsigned int other)
9813{
9814 const char * result = NULL;
9815 static char buff [32];
9816
9817 if (other == 0)
9818 return "";
9819
9820 switch (elf_header.e_machine)
9821 {
9822 case EM_MIPS:
9823 result = get_mips_symbol_other (other);
28f997cf
TG		 9824 break;
9825 case EM_IA_64:
9826 result = get_ia64_symbol_other (other);
9827 break;
6911b7dc
AM		 9828 case EM_PPC64:
9829 result = get_ppc64_symbol_other (other);
9830 break;
5e2b0d47
NC		 9831 default:
9832 break;
9833 }
9834
9835 if (result)
9836 return result;
9837
9838 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9839 return buff;
9840}
9841
d1133906 9842static const char *
d3ba0551 9843get_symbol_index_type (unsigned int type)
252b5132 9844{
b34976b6 9845 static char buff[32];
5cf1065c 9846
252b5132
RH		 9847 switch (type)
9848 {
b34976b6
AM		 9849 case SHN_UNDEF: return "UND";
9850 case SHN_ABS: return "ABS";
9851 case SHN_COMMON: return "COM";
252b5132 9852 default:
9ce701e2
L		 9853 if (type == SHN_IA_64_ANSI_COMMON
9854 && elf_header.e_machine == EM_IA_64
9855 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9856 return "ANSI_COM";
8a9036a4 9857 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9858 || elf_header.e_machine == EM_L1OM
9859 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9860 && type == SHN_X86_64_LCOMMON)
9861 return "LARGE_COM";
ac145307
BS		 9862 else if ((type == SHN_MIPS_SCOMMON
9863 && elf_header.e_machine == EM_MIPS)
9864 || (type == SHN_TIC6X_SCOMMON
9865 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9866 return "SCOM";
9867 else if (type == SHN_MIPS_SUNDEFINED
9868 && elf_header.e_machine == EM_MIPS)
9869 return "SUND";
9ce701e2 9870 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9871 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9872 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9873 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9874 else if (type >= SHN_LORESERVE)
9875 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 9876 else if (type >= elf_header.e_shnum)
e0a31db1 9877 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 9878 else
232e7cb8 9879 sprintf (buff, "%3d", type);
5cf1065c 9880 break;
252b5132 9881 }
5cf1065c
NC		 9882
9883 return buff;
252b5132
RH		 9884}
9885
66543521 9886static bfd_vma *
8b73c356 9887get_dynamic_data (FILE * file, size_t number, unsigned int ent_size)
252b5132 9888{
2cf0635d
NC		 9889 unsigned char * e_data;
9890 bfd_vma * i_data;
252b5132 9891
3102e897
NC		 9892 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
9893 attempting to allocate memory when the read is bound to fail. */
9894 if (ent_size * number > current_file_size)
9895 {
9896 error (_("Invalid number of dynamic entries: %lu\n"),
9897 (unsigned long) number);
9898 return NULL;
9899 }
9900
3f5e193b 9901 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9902 if (e_data == NULL)
9903 {
8b73c356
NC		 9904 error (_("Out of memory reading %lu dynamic entries\n"),
9905 (unsigned long) number);
252b5132
RH		 9906 return NULL;
9907 }
9908
66543521 9909 if (fread (e_data, ent_size, number, file) != number)
252b5132 9910 {
3102e897
NC		 9911 error (_("Unable to read in %lu bytes of dynamic data\n"),
9912 (unsigned long) (number * ent_size));
9913 free (e_data);
252b5132
RH		 9914 return NULL;
9915 }
9916
3f5e193b 9917 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9918 if (i_data == NULL)
9919 {
8b73c356
NC		 9920 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9921 (unsigned long) number);
252b5132
RH		 9922 free (e_data);
9923 return NULL;
9924 }
9925
9926 while (number--)
66543521 9927 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9928
9929 free (e_data);
9930
9931 return i_data;
9932}
9933
6bd1a22c
L		 9934static void
9935print_dynamic_symbol (bfd_vma si, unsigned long hn)
9936{
2cf0635d 9937 Elf_Internal_Sym * psym;
6bd1a22c
L		 9938 int n;
9939
6bd1a22c
L		 9940 n = print_vma (si, DEC_5);
9941 if (n < 5)
0b4362b0 9942 fputs (&" "[n], stdout);
6bd1a22c 9943 printf (" %3lu: ", hn);
e0a31db1
NC		 9944
9945 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
9946 {
3102e897
NC		 9947 printf (_("<No info available for dynamic symbol number %lu>\n"),
9948 (unsigned long) si);
e0a31db1
NC		 9949 return;
9950 }
9951
9952 psym = dynamic_symbols + si;
6bd1a22c
L		 9953 print_vma (psym->st_value, LONG_HEX);
9954 putchar (' ');
9955 print_vma (psym->st_size, DEC_5);
9956
f4be36b3
AM		 9957 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9958 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9959 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9960 /* Check to see if any other bits in the st_other field are set.
9961 Note - displaying this information disrupts the layout of the
9962 table being generated, but for the moment this case is very
9963 rare. */
9964 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9965 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9966 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9967 if (VALID_DYNAMIC_NAME (psym->st_name))
9968 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9969 else
2b692964 9970 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9971 putchar ('\n');
9972}
9973
bb4d2ac2
L		 9974static const char *
9975get_symbol_version_string (FILE *file, int is_dynsym,
9976 const char *strtab,
9977 unsigned long int strtab_size,
9978 unsigned int si, Elf_Internal_Sym *psym,
9979 enum versioned_symbol_info *sym_info,
9980 unsigned short *vna_other)
9981{
9982 const char *version_string = NULL;
9983
9984 if (is_dynsym
9985 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9986 {
9987 unsigned char data[2];
9988 unsigned short vers_data;
9989 unsigned long offset;
9990 int is_nobits;
9991 int check_def;
9992
9993 offset = offset_from_vma
9994 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9995 sizeof data + si * sizeof (vers_data));
9996
9997 if (get_data (&data, file, offset + si * sizeof (vers_data),
9998 sizeof (data), 1, _("version data")) == NULL)
9999 return NULL;
10000
10001 vers_data = byte_get (data, 2);
10002
10003 is_nobits = (psym->st_shndx < elf_header.e_shnum
10004 && section_headers[psym->st_shndx].sh_type
10005 == SHT_NOBITS);
10006
10007 check_def = (psym->st_shndx != SHN_UNDEF);
10008
10009 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10010 {
10011 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10012 && (is_nobits || ! check_def))
10013 {
10014 Elf_External_Verneed evn;
10015 Elf_Internal_Verneed ivn;
10016 Elf_Internal_Vernaux ivna;
10017
10018 /* We must test both. */
10019 offset = offset_from_vma
10020 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10021 sizeof evn);
10022
10023 do
10024 {
10025 unsigned long vna_off;
10026
10027 if (get_data (&evn, file, offset, sizeof (evn), 1,
10028 _("version need")) == NULL)
10029 {
10030 ivna.vna_next = 0;
10031 ivna.vna_other = 0;
10032 ivna.vna_name = 0;
10033 break;
10034 }
10035
10036 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10037 ivn.vn_next = BYTE_GET (evn.vn_next);
10038
10039 vna_off = offset + ivn.vn_aux;
10040
10041 do
10042 {
10043 Elf_External_Vernaux evna;
10044
10045 if (get_data (&evna, file, vna_off,
10046 sizeof (evna), 1,
10047 _("version need aux (3)")) == NULL)
10048 {
10049 ivna.vna_next = 0;
10050 ivna.vna_other = 0;
10051 ivna.vna_name = 0;
10052 }
10053 else
10054 {
10055 ivna.vna_other = BYTE_GET (evna.vna_other);
10056 ivna.vna_next = BYTE_GET (evna.vna_next);
10057 ivna.vna_name = BYTE_GET (evna.vna_name);
10058 }
10059
10060 vna_off += ivna.vna_next;
10061 }
10062 while (ivna.vna_other != vers_data
10063 && ivna.vna_next != 0);
10064
10065 if (ivna.vna_other == vers_data)
10066 break;
10067
10068 offset += ivn.vn_next;
10069 }
10070 while (ivn.vn_next != 0);
10071
10072 if (ivna.vna_other == vers_data)
10073 {
10074 *sym_info = symbol_undefined;
10075 *vna_other = ivna.vna_other;
10076 version_string = (ivna.vna_name < strtab_size
10077 ? strtab + ivna.vna_name
10078 : _("<corrupt>"));
10079 check_def = 0;
10080 }
10081 else if (! is_nobits)
10082 error (_("bad dynamic symbol\n"));
10083 else
10084 check_def = 1;
10085 }
10086
10087 if (check_def)
10088 {
10089 if (vers_data != 0x8001
10090 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10091 {
10092 Elf_Internal_Verdef ivd;
10093 Elf_Internal_Verdaux ivda;
10094 Elf_External_Verdaux evda;
10095 unsigned long off;
10096
10097 off = offset_from_vma
10098 (file,
10099 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10100 sizeof (Elf_External_Verdef));
10101
10102 do
10103 {
10104 Elf_External_Verdef evd;
10105
10106 if (get_data (&evd, file, off, sizeof (evd),
10107 1, _("version def")) == NULL)
10108 {
10109 ivd.vd_ndx = 0;
10110 ivd.vd_aux = 0;
10111 ivd.vd_next = 0;
10112 }
10113 else
10114 {
10115 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10116 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10117 ivd.vd_next = BYTE_GET (evd.vd_next);
10118 }
10119
10120 off += ivd.vd_next;
10121 }
10122 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10123 && ivd.vd_next != 0);
10124
10125 off -= ivd.vd_next;
10126 off += ivd.vd_aux;
10127
10128 if (get_data (&evda, file, off, sizeof (evda),
10129 1, _("version def aux")) == NULL)
10130 return version_string;
10131
10132 ivda.vda_name = BYTE_GET (evda.vda_name);
10133
10134 if (psym->st_name != ivda.vda_name)
10135 {
10136 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10137 ? symbol_hidden : symbol_public);
10138 version_string = (ivda.vda_name < strtab_size
10139 ? strtab + ivda.vda_name
10140 : _("<corrupt>"));
10141 }
10142 }
10143 }
10144 }
10145 }
10146 return version_string;
10147}
10148
e3c8793a 10149/* Dump the symbol table. */
252b5132 10150static int
2cf0635d 10151process_symbol_table (FILE * file)
252b5132 10152{
2cf0635d 10153 Elf_Internal_Shdr * section;
8b73c356
NC		 10154 bfd_size_type nbuckets = 0;
10155 bfd_size_type nchains = 0;
2cf0635d
NC		 10156 bfd_vma * buckets = NULL;
10157 bfd_vma * chains = NULL;
fdc90cb4 10158 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10159 bfd_vma * gnubuckets = NULL;
10160 bfd_vma * gnuchains = NULL;
6bd1a22c 10161 bfd_vma gnusymidx = 0;
071436c6 10162 bfd_size_type ngnuchains = 0;
252b5132 10163
2c610e4b 10164 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10165 return 1;
10166
6bd1a22c
L		 10167 if (dynamic_info[DT_HASH]
10168 && (do_histogram
2c610e4b
L		 10169 || (do_using_dynamic
10170 && !do_dyn_syms
10171 && dynamic_strings != NULL)))
252b5132 10172 {
66543521
AM		 10173 unsigned char nb[8];
10174 unsigned char nc[8];
8b73c356 10175 unsigned int hash_ent_size = 4;
66543521
AM		 10176
10177 if ((elf_header.e_machine == EM_ALPHA
10178 || elf_header.e_machine == EM_S390
10179 || elf_header.e_machine == EM_S390_OLD)
10180 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10181 hash_ent_size = 8;
10182
fb52b2f4
NC		 10183 if (fseek (file,
10184 (archive_file_offset
10185 + offset_from_vma (file, dynamic_info[DT_HASH],
10186 sizeof nb + sizeof nc)),
d93f0186 10187 SEEK_SET))
252b5132 10188 {
591a748a 10189 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10190 goto no_hash;
252b5132
RH		 10191 }
10192
66543521 10193 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10194 {
10195 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10196 goto no_hash;
252b5132
RH		 10197 }
10198
66543521 10199 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10200 {
10201 error (_("Failed to read in number of chains\n"));
d3a44ec6 10202 goto no_hash;
252b5132
RH		 10203 }
10204
66543521
AM		 10205 nbuckets = byte_get (nb, hash_ent_size);
10206 nchains = byte_get (nc, hash_ent_size);
252b5132 10207
66543521
AM		 10208 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10209 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10210
d3a44ec6 10211 no_hash:
252b5132 10212 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10213 {
10214 if (do_using_dynamic)
10215 return 0;
10216 free (buckets);
10217 free (chains);
10218 buckets = NULL;
10219 chains = NULL;
10220 nbuckets = 0;
10221 nchains = 0;
10222 }
252b5132
RH		 10223 }
10224
6bd1a22c
L		 10225 if (dynamic_info_DT_GNU_HASH
10226 && (do_histogram
2c610e4b
L		 10227 || (do_using_dynamic
10228 && !do_dyn_syms
10229 && dynamic_strings != NULL)))
252b5132 10230 {
6bd1a22c
L		 10231 unsigned char nb[16];
10232 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10233 bfd_vma buckets_vma;
10234
10235 if (fseek (file,
10236 (archive_file_offset
10237 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10238 sizeof nb)),
10239 SEEK_SET))
10240 {
10241 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10242 goto no_gnu_hash;
6bd1a22c 10243 }
252b5132 10244
6bd1a22c
L		 10245 if (fread (nb, 16, 1, file) != 1)
10246 {
10247 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10248 goto no_gnu_hash;
6bd1a22c
L		 10249 }
10250
10251 ngnubuckets = byte_get (nb, 4);
10252 gnusymidx = byte_get (nb + 4, 4);
10253 bitmaskwords = byte_get (nb + 8, 4);
10254 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10255 if (is_32bit_elf)
6bd1a22c 10256 buckets_vma += bitmaskwords * 4;
f7a99963 10257 else
6bd1a22c 10258 buckets_vma += bitmaskwords * 8;
252b5132 10259
6bd1a22c
L		 10260 if (fseek (file,
10261 (archive_file_offset
10262 + offset_from_vma (file, buckets_vma, 4)),
10263 SEEK_SET))
252b5132 10264 {
6bd1a22c 10265 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10266 goto no_gnu_hash;
6bd1a22c
L		 10267 }
10268
10269 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10270
6bd1a22c 10271 if (gnubuckets == NULL)
d3a44ec6 10272 goto no_gnu_hash;
6bd1a22c
L		 10273
10274 for (i = 0; i < ngnubuckets; i++)
10275 if (gnubuckets[i] != 0)
10276 {
10277 if (gnubuckets[i] < gnusymidx)
10278 return 0;
10279
10280 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10281 maxchain = gnubuckets[i];
10282 }
10283
10284 if (maxchain == 0xffffffff)
d3a44ec6 10285 goto no_gnu_hash;
6bd1a22c
L		 10286
10287 maxchain -= gnusymidx;
10288
10289 if (fseek (file,
10290 (archive_file_offset
10291 + offset_from_vma (file, buckets_vma
10292 + 4 * (ngnubuckets + maxchain), 4)),
10293 SEEK_SET))
10294 {
10295 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10296 goto no_gnu_hash;
6bd1a22c
L		 10297 }
10298
10299 do
10300 {
10301 if (fread (nb, 4, 1, file) != 1)
252b5132 10302 {
6bd1a22c 10303 error (_("Failed to determine last chain length\n"));
d3a44ec6 10304 goto no_gnu_hash;
6bd1a22c 10305 }
252b5132 10306
6bd1a22c 10307 if (maxchain + 1 == 0)
d3a44ec6 10308 goto no_gnu_hash;
252b5132 10309
6bd1a22c
L		 10310 ++maxchain;
10311 }
10312 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10313
6bd1a22c
L		 10314 if (fseek (file,
10315 (archive_file_offset
10316 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10317 SEEK_SET))
10318 {
10319 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10320 goto no_gnu_hash;
6bd1a22c
L		 10321 }
10322
10323 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10324 ngnuchains = maxchain;
6bd1a22c 10325
d3a44ec6 10326 no_gnu_hash:
6bd1a22c 10327 if (gnuchains == NULL)
d3a44ec6
JJ		 10328 {
10329 free (gnubuckets);
d3a44ec6
JJ		 10330 gnubuckets = NULL;
10331 ngnubuckets = 0;
f64fddf1
NC		 10332 if (do_using_dynamic)
10333 return 0;
d3a44ec6 10334 }
6bd1a22c
L		 10335 }
10336
10337 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10338 && do_syms
10339 && do_using_dynamic
3102e897
NC		 10340 && dynamic_strings != NULL
10341 && dynamic_symbols != NULL)
6bd1a22c
L		 10342 {
10343 unsigned long hn;
10344
10345 if (dynamic_info[DT_HASH])
10346 {
10347 bfd_vma si;
10348
10349 printf (_("\nSymbol table for image:\n"));
10350 if (is_32bit_elf)
10351 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10352 else
10353 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10354
10355 for (hn = 0; hn < nbuckets; hn++)
10356 {
10357 if (! buckets[hn])
10358 continue;
10359
10360 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10361 print_dynamic_symbol (si, hn);
252b5132
RH		 10362 }
10363 }
6bd1a22c
L		 10364
10365 if (dynamic_info_DT_GNU_HASH)
10366 {
10367 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10368 if (is_32bit_elf)
10369 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10370 else
10371 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10372
10373 for (hn = 0; hn < ngnubuckets; ++hn)
10374 if (gnubuckets[hn] != 0)
10375 {
10376 bfd_vma si = gnubuckets[hn];
10377 bfd_vma off = si - gnusymidx;
10378
10379 do
10380 {
10381 print_dynamic_symbol (si, hn);
10382 si++;
10383 }
071436c6 10384 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10385 }
10386 }
252b5132 10387 }
8b73c356
NC		 10388 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10389 && section_headers != NULL)
252b5132 10390 {
b34976b6 10391 unsigned int i;
252b5132
RH		 10392
10393 for (i = 0, section = section_headers;
10394 i < elf_header.e_shnum;
10395 i++, section++)
10396 {
b34976b6 10397 unsigned int si;
2cf0635d 10398 char * strtab = NULL;
c256ffe7 10399 unsigned long int strtab_size = 0;
2cf0635d
NC		 10400 Elf_Internal_Sym * symtab;
10401 Elf_Internal_Sym * psym;
ba5cdace 10402 unsigned long num_syms;
252b5132 10403
2c610e4b
L		 10404 if ((section->sh_type != SHT_SYMTAB
10405 && section->sh_type != SHT_DYNSYM)
10406 || (!do_syms
10407 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10408 continue;
10409
dd24e3da
NC		 10410 if (section->sh_entsize == 0)
10411 {
10412 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10413 printable_section_name (section));
dd24e3da
NC		 10414 continue;
10415 }
10416
252b5132 10417 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10418 printable_section_name (section),
252b5132 10419 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10420
f7a99963 10421 if (is_32bit_elf)
ca47b30c 10422 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10423 else
ca47b30c 10424 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10425
ba5cdace 10426 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10427 if (symtab == NULL)
10428 continue;
10429
10430 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10431 {
10432 strtab = string_table;
10433 strtab_size = string_table_length;
10434 }
4fbb74a6 10435 else if (section->sh_link < elf_header.e_shnum)
252b5132 10436 {
2cf0635d 10437 Elf_Internal_Shdr * string_sec;
252b5132 10438
4fbb74a6 10439 string_sec = section_headers + section->sh_link;
252b5132 10440
3f5e193b
NC		 10441 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10442 1, string_sec->sh_size,
10443 _("string table"));
c256ffe7 10444 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10445 }
10446
ba5cdace 10447 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10448 {
bb4d2ac2
L		 10449 const char *version_string;
10450 enum versioned_symbol_info sym_info;
10451 unsigned short vna_other;
10452
5e220199 10453 printf ("%6d: ", si);
f7a99963
NC		 10454 print_vma (psym->st_value, LONG_HEX);
10455 putchar (' ');
10456 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10457 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10458 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10459 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10460 /* Check to see if any other bits in the st_other field are set.
10461 Note - displaying this information disrupts the layout of the
10462 table being generated, but for the moment this case is very rare. */
10463 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10464 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10465 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10466 print_symbol (25, psym->st_name < strtab_size
2b692964 10467 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10468
bb4d2ac2
L		 10469 version_string
10470 = get_symbol_version_string (file,
10471 section->sh_type == SHT_DYNSYM,
10472 strtab, strtab_size, si,
10473 psym, &sym_info, &vna_other);
10474 if (version_string)
252b5132 10475 {
bb4d2ac2
L		 10476 if (sym_info == symbol_undefined)
10477 printf ("@%s (%d)", version_string, vna_other);
10478 else
10479 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10480 version_string);
252b5132
RH		 10481 }
10482
10483 putchar ('\n');
10484 }
10485
10486 free (symtab);
10487 if (strtab != string_table)
10488 free (strtab);
10489 }
10490 }
10491 else if (do_syms)
10492 printf
10493 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10494
10495 if (do_histogram && buckets != NULL)
10496 {
2cf0635d
NC		 10497 unsigned long * lengths;
10498 unsigned long * counts;
66543521
AM		 10499 unsigned long hn;
10500 bfd_vma si;
10501 unsigned long maxlength = 0;
10502 unsigned long nzero_counts = 0;
10503 unsigned long nsyms = 0;
252b5132 10504
66543521
AM		 10505 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10506 (unsigned long) nbuckets);
252b5132 10507
3f5e193b 10508 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10509 if (lengths == NULL)
10510 {
8b73c356 10511 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10512 return 0;
10513 }
8b73c356
NC		 10514
10515 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10516 for (hn = 0; hn < nbuckets; ++hn)
10517 {
f7a99963 10518 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 10519 {
b34976b6 10520 ++nsyms;
252b5132 10521 if (maxlength < ++lengths[hn])
b34976b6 10522 ++maxlength;
049b0c3a
NC		 10523
10524 /* PR binutils/17531: A corrupt binary could contain broken
10525 histogram data. Do not go into an infinite loop trying
10526 to process it. */
10527 if (chains[si] == si)
10528 {
10529 error (_("histogram chain links to itself\n"));
10530 break;
10531 }
252b5132
RH		 10532 }
10533 }
10534
3f5e193b 10535 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10536 if (counts == NULL)
10537 {
b2e951ec 10538 free (lengths);
8b73c356 10539 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10540 return 0;
10541 }
10542
10543 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10544 ++counts[lengths[hn]];
252b5132 10545
103f02d3 10546 if (nbuckets > 0)
252b5132 10547 {
66543521
AM		 10548 unsigned long i;
10549 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10550 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10551 for (i = 1; i <= maxlength; ++i)
103f02d3 10552 {
66543521
AM		 10553 nzero_counts += counts[i] * i;
10554 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10555 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10556 (nzero_counts * 100.0) / nsyms);
10557 }
252b5132
RH		 10558 }
10559
10560 free (counts);
10561 free (lengths);
10562 }
10563
10564 if (buckets != NULL)
10565 {
10566 free (buckets);
10567 free (chains);
10568 }
10569
d3a44ec6 10570 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10571 {
2cf0635d
NC		 10572 unsigned long * lengths;
10573 unsigned long * counts;
fdc90cb4
JJ		 10574 unsigned long hn;
10575 unsigned long maxlength = 0;
10576 unsigned long nzero_counts = 0;
10577 unsigned long nsyms = 0;
fdc90cb4 10578
8b73c356
NC		 10579 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10580 (unsigned long) ngnubuckets);
10581
3f5e193b 10582 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10583 if (lengths == NULL)
10584 {
8b73c356 10585 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10586 return 0;
10587 }
10588
fdc90cb4
JJ		 10589 printf (_(" Length Number %% of total Coverage\n"));
10590
10591 for (hn = 0; hn < ngnubuckets; ++hn)
10592 if (gnubuckets[hn] != 0)
10593 {
10594 bfd_vma off, length = 1;
10595
6bd1a22c 10596 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10597 /* PR 17531 file: 010-77222-0.004. */
10598 off < ngnuchains && (gnuchains[off] & 1) == 0;
10599 ++off)
fdc90cb4
JJ		 10600 ++length;
10601 lengths[hn] = length;
10602 if (length > maxlength)
10603 maxlength = length;
10604 nsyms += length;
10605 }
10606
3f5e193b 10607 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10608 if (counts == NULL)
10609 {
b2e951ec 10610 free (lengths);
8b73c356 10611 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 10612 return 0;
10613 }
10614
10615 for (hn = 0; hn < ngnubuckets; ++hn)
10616 ++counts[lengths[hn]];
10617
10618 if (ngnubuckets > 0)
10619 {
10620 unsigned long j;
10621 printf (" 0 %-10lu (%5.1f%%)\n",
10622 counts[0], (counts[0] * 100.0) / ngnubuckets);
10623 for (j = 1; j <= maxlength; ++j)
10624 {
10625 nzero_counts += counts[j] * j;
10626 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10627 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10628 (nzero_counts * 100.0) / nsyms);
10629 }
10630 }
10631
10632 free (counts);
10633 free (lengths);
10634 free (gnubuckets);
10635 free (gnuchains);
10636 }
10637
252b5132
RH		 10638 return 1;
10639}
10640
10641static int
2cf0635d 10642process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10643{
b4c96d0d 10644 unsigned int i;
252b5132
RH		 10645
10646 if (dynamic_syminfo == NULL
10647 || !do_dynamic)
10648 /* No syminfo, this is ok. */
10649 return 1;
10650
10651 /* There better should be a dynamic symbol section. */
10652 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10653 return 0;
10654
10655 if (dynamic_addr)
10656 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10657 dynamic_syminfo_offset, dynamic_syminfo_nent);
10658
10659 printf (_(" Num: Name BoundTo Flags\n"));
10660 for (i = 0; i < dynamic_syminfo_nent; ++i)
10661 {
10662 unsigned short int flags = dynamic_syminfo[i].si_flags;
10663
31104126 10664 printf ("%4d: ", i);
4082ef84
NC		 10665 if (i >= num_dynamic_syms)
10666 printf (_("<corrupt index>"));
10667 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 10668 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10669 else
2b692964 10670 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10671 putchar (' ');
252b5132
RH		 10672
10673 switch (dynamic_syminfo[i].si_boundto)
10674 {
10675 case SYMINFO_BT_SELF:
10676 fputs ("SELF ", stdout);
10677 break;
10678 case SYMINFO_BT_PARENT:
10679 fputs ("PARENT ", stdout);
10680 break;
10681 default:
10682 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10683 && dynamic_syminfo[i].si_boundto < dynamic_nent
10684 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10685 {
d79b3d50 10686 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10687 putchar (' ' );
10688 }
252b5132
RH		 10689 else
10690 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10691 break;
10692 }
10693
10694 if (flags & SYMINFO_FLG_DIRECT)
10695 printf (" DIRECT");
10696 if (flags & SYMINFO_FLG_PASSTHRU)
10697 printf (" PASSTHRU");
10698 if (flags & SYMINFO_FLG_COPY)
10699 printf (" COPY");
10700 if (flags & SYMINFO_FLG_LAZYLOAD)
10701 printf (" LAZYLOAD");
10702
10703 puts ("");
10704 }
10705
10706 return 1;
10707}
10708
cf13d699
NC		 10709/* Check to see if the given reloc needs to be handled in a target specific
10710 manner. If so then process the reloc and return TRUE otherwise return
10711 FALSE. */
09c11c86 10712
cf13d699
NC		 10713static bfd_boolean
10714target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10715 unsigned char * start,
10716 Elf_Internal_Sym * symtab)
252b5132 10717{
cf13d699 10718 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 10719
cf13d699 10720 switch (elf_header.e_machine)
252b5132 10721 {
13761a11
NC		 10722 case EM_MSP430:
10723 case EM_MSP430_OLD:
10724 {
10725 static Elf_Internal_Sym * saved_sym = NULL;
10726
10727 switch (reloc_type)
10728 {
10729 case 10: /* R_MSP430_SYM_DIFF */
10730 if (uses_msp430x_relocs ())
10731 break;
10732 case 21: /* R_MSP430X_SYM_DIFF */
10733 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10734 return TRUE;
10735
10736 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10737 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10738 goto handle_sym_diff;
0b4362b0 10739
13761a11
NC		 10740 case 5: /* R_MSP430_16_BYTE */
10741 case 9: /* R_MSP430_8 */
10742 if (uses_msp430x_relocs ())
10743 break;
10744 goto handle_sym_diff;
10745
10746 case 2: /* R_MSP430_ABS16 */
10747 case 15: /* R_MSP430X_ABS16 */
10748 if (! uses_msp430x_relocs ())
10749 break;
10750 goto handle_sym_diff;
0b4362b0 10751
13761a11
NC		 10752 handle_sym_diff:
10753 if (saved_sym != NULL)
10754 {
10755 bfd_vma value;
10756
10757 value = reloc->r_addend
10758 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10759 - saved_sym->st_value);
10760
10761 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10762
10763 saved_sym = NULL;
10764 return TRUE;
10765 }
10766 break;
10767
10768 default:
10769 if (saved_sym != NULL)
071436c6 10770 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 10771 break;
10772 }
10773 break;
10774 }
10775
cf13d699
NC		 10776 case EM_MN10300:
10777 case EM_CYGNUS_MN10300:
10778 {
10779 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 10780
cf13d699
NC		 10781 switch (reloc_type)
10782 {
10783 case 34: /* R_MN10300_ALIGN */
10784 return TRUE;
10785 case 33: /* R_MN10300_SYM_DIFF */
10786 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10787 return TRUE;
10788 case 1: /* R_MN10300_32 */
10789 case 2: /* R_MN10300_16 */
10790 if (saved_sym != NULL)
10791 {
10792 bfd_vma value;
252b5132 10793
cf13d699
NC		 10794 value = reloc->r_addend
10795 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10796 - saved_sym->st_value);
252b5132 10797
cf13d699 10798 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 10799
cf13d699
NC		 10800 saved_sym = NULL;
10801 return TRUE;
10802 }
10803 break;
10804 default:
10805 if (saved_sym != NULL)
071436c6 10806 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 10807 break;
10808 }
10809 break;
10810 }
252b5132
RH		 10811 }
10812
cf13d699 10813 return FALSE;
252b5132
RH		 10814}
10815
aca88567
NC		 10816/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10817 DWARF debug sections. This is a target specific test. Note - we do not
10818 go through the whole including-target-headers-multiple-times route, (as
10819 we have already done with <elf/h8.h>) because this would become very
10820 messy and even then this function would have to contain target specific
10821 information (the names of the relocs instead of their numeric values).
10822 FIXME: This is not the correct way to solve this problem. The proper way
10823 is to have target specific reloc sizing and typing functions created by
10824 the reloc-macros.h header, in the same way that it already creates the
10825 reloc naming functions. */
10826
10827static bfd_boolean
10828is_32bit_abs_reloc (unsigned int reloc_type)
10829{
10830 switch (elf_header.e_machine)
10831 {
41e92641
NC		 10832 case EM_386:
10833 case EM_486:
10834 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 10835 case EM_68K:
10836 return reloc_type == 1; /* R_68K_32. */
10837 case EM_860:
10838 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10839 case EM_960:
10840 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10841 case EM_AARCH64:
10842 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10843 case EM_ALPHA:
137b6b5f 10844 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10845 case EM_ARC:
10846 return reloc_type == 1; /* R_ARC_32. */
10847 case EM_ARM:
10848 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10849 case EM_AVR_OLD:
aca88567
NC		 10850 case EM_AVR:
10851 return reloc_type == 1;
cfb8c092
NC		 10852 case EM_ADAPTEVA_EPIPHANY:
10853 return reloc_type == 3;
aca88567
NC		 10854 case EM_BLACKFIN:
10855 return reloc_type == 0x12; /* R_byte4_data. */
10856 case EM_CRIS:
10857 return reloc_type == 3; /* R_CRIS_32. */
10858 case EM_CR16:
10859 return reloc_type == 3; /* R_CR16_NUM32. */
10860 case EM_CRX:
10861 return reloc_type == 15; /* R_CRX_NUM32. */
10862 case EM_CYGNUS_FRV:
10863 return reloc_type == 1;
41e92641
NC		 10864 case EM_CYGNUS_D10V:
10865 case EM_D10V:
10866 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10867 case EM_CYGNUS_D30V:
10868 case EM_D30V:
10869 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10870 case EM_DLX:
10871 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10872 case EM_CYGNUS_FR30:
10873 case EM_FR30:
10874 return reloc_type == 3; /* R_FR30_32. */
10875 case EM_H8S:
10876 case EM_H8_300:
10877 case EM_H8_300H:
10878 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10879 case EM_IA_64:
10880 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10881 case EM_IP2K_OLD:
10882 case EM_IP2K:
10883 return reloc_type == 2; /* R_IP2K_32. */
10884 case EM_IQ2000:
10885 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10886 case EM_LATTICEMICO32:
10887 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10888 case EM_M32C_OLD:
aca88567
NC		 10889 case EM_M32C:
10890 return reloc_type == 3; /* R_M32C_32. */
10891 case EM_M32R:
10892 return reloc_type == 34; /* R_M32R_32_RELA. */
10893 case EM_MCORE:
10894 return reloc_type == 1; /* R_MCORE_ADDR32. */
10895 case EM_CYGNUS_MEP:
10896 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10897 case EM_METAG:
10898 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10899 case EM_MICROBLAZE:
10900 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10901 case EM_MIPS:
10902 return reloc_type == 2; /* R_MIPS_32. */
10903 case EM_MMIX:
10904 return reloc_type == 4; /* R_MMIX_32. */
10905 case EM_CYGNUS_MN10200:
10906 case EM_MN10200:
10907 return reloc_type == 1; /* R_MN10200_32. */
10908 case EM_CYGNUS_MN10300:
10909 case EM_MN10300:
10910 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10911 case EM_MOXIE:
10912 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10913 case EM_MSP430_OLD:
10914 case EM_MSP430:
13761a11 10915 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 10916 case EM_MT:
10917 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 10918 case EM_NDS32:
10919 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 10920 case EM_ALTERA_NIOS2:
36591ba1 10921 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 10922 case EM_NIOS32:
10923 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 10924 case EM_OR1K:
10925 return reloc_type == 1; /* R_OR1K_32. */
aca88567 10926 case EM_PARISC:
5fda8eca
NC		 10927 return (reloc_type == 1 /* R_PARISC_DIR32. */
10928 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10929 case EM_PJ:
10930 case EM_PJ_OLD:
10931 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10932 case EM_PPC64:
10933 return reloc_type == 1; /* R_PPC64_ADDR32. */
10934 case EM_PPC:
10935 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10936 case EM_RL78:
10937 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10938 case EM_RX:
10939 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10940 case EM_S370:
10941 return reloc_type == 1; /* R_I370_ADDR31. */
10942 case EM_S390_OLD:
10943 case EM_S390:
10944 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10945 case EM_SCORE:
10946 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10947 case EM_SH:
10948 return reloc_type == 1; /* R_SH_DIR32. */
10949 case EM_SPARC32PLUS:
10950 case EM_SPARCV9:
10951 case EM_SPARC:
10952 return reloc_type == 3 /* R_SPARC_32. */
10953 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10954 case EM_SPU:
10955 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10956 case EM_TI_C6000:
10957 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10958 case EM_TILEGX:
10959 return reloc_type == 2; /* R_TILEGX_32. */
10960 case EM_TILEPRO:
10961 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10962 case EM_CYGNUS_V850:
10963 case EM_V850:
10964 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10965 case EM_V800:
10966 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10967 case EM_VAX:
10968 return reloc_type == 1; /* R_VAX_32. */
10969 case EM_X86_64:
8a9036a4 10970 case EM_L1OM:
7a9068fe 10971 case EM_K1OM:
aca88567 10972 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10973 case EM_XC16X:
10974 case EM_C166:
10975 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10976 case EM_XGATE:
10977 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10978 case EM_XSTORMY16:
10979 return reloc_type == 1; /* R_XSTROMY16_32. */
10980 case EM_XTENSA_OLD:
10981 case EM_XTENSA:
10982 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10983 default:
10984 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10985 elf_header.e_machine);
10986 abort ();
10987 }
10988}
10989
10990/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10991 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10992
10993static bfd_boolean
10994is_32bit_pcrel_reloc (unsigned int reloc_type)
10995{
10996 switch (elf_header.e_machine)
10997 {
41e92641
NC		 10998 case EM_386:
10999 case EM_486:
3e0873ac 11000 return reloc_type == 2; /* R_386_PC32. */
aca88567 11001 case EM_68K:
3e0873ac 11002 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11003 case EM_AARCH64:
11004 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11005 case EM_ADAPTEVA_EPIPHANY:
11006 return reloc_type == 6;
aca88567
NC		 11007 case EM_ALPHA:
11008 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11009 case EM_ARM:
3e0873ac 11010 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11011 case EM_MICROBLAZE:
11012 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11013 case EM_OR1K:
11014 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11015 case EM_PARISC:
85acf597 11016 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11017 case EM_PPC:
11018 return reloc_type == 26; /* R_PPC_REL32. */
11019 case EM_PPC64:
3e0873ac 11020 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11021 case EM_S390_OLD:
11022 case EM_S390:
3e0873ac 11023 return reloc_type == 5; /* R_390_PC32. */
aca88567 11024 case EM_SH:
3e0873ac 11025 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11026 case EM_SPARC32PLUS:
11027 case EM_SPARCV9:
11028 case EM_SPARC:
3e0873ac 11029 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11030 case EM_SPU:
11031 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11032 case EM_TILEGX:
11033 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11034 case EM_TILEPRO:
11035 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 11036 case EM_X86_64:
8a9036a4 11037 case EM_L1OM:
7a9068fe 11038 case EM_K1OM:
3e0873ac 11039 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11040 case EM_XTENSA_OLD:
11041 case EM_XTENSA:
11042 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11043 default:
11044 /* Do not abort or issue an error message here. Not all targets use
11045 pc-relative 32-bit relocs in their DWARF debug information and we
11046 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11047 more helpful warning message will be generated by apply_relocations
11048 anyway, so just return. */
aca88567
NC		 11049 return FALSE;
11050 }
11051}
11052
11053/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11054 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11055
11056static bfd_boolean
11057is_64bit_abs_reloc (unsigned int reloc_type)
11058{
11059 switch (elf_header.e_machine)
11060 {
a06ea964
NC		 11061 case EM_AARCH64:
11062 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11063 case EM_ALPHA:
11064 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11065 case EM_IA_64:
11066 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11067 case EM_PARISC:
11068 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11069 case EM_PPC64:
11070 return reloc_type == 38; /* R_PPC64_ADDR64. */
11071 case EM_SPARC32PLUS:
11072 case EM_SPARCV9:
11073 case EM_SPARC:
11074 return reloc_type == 54; /* R_SPARC_UA64. */
11075 case EM_X86_64:
8a9036a4 11076 case EM_L1OM:
7a9068fe 11077 case EM_K1OM:
aca88567 11078 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11079 case EM_S390_OLD:
11080 case EM_S390:
aa137e4d
NC		 11081 return reloc_type == 22; /* R_S390_64. */
11082 case EM_TILEGX:
11083 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11084 case EM_MIPS:
aa137e4d 11085 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11086 default:
11087 return FALSE;
11088 }
11089}
11090
85acf597
RH		 11091/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11092 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11093
11094static bfd_boolean
11095is_64bit_pcrel_reloc (unsigned int reloc_type)
11096{
11097 switch (elf_header.e_machine)
11098 {
a06ea964
NC		 11099 case EM_AARCH64:
11100 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11101 case EM_ALPHA:
aa137e4d 11102 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11103 case EM_IA_64:
aa137e4d 11104 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11105 case EM_PARISC:
aa137e4d 11106 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11107 case EM_PPC64:
aa137e4d 11108 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11109 case EM_SPARC32PLUS:
11110 case EM_SPARCV9:
11111 case EM_SPARC:
aa137e4d 11112 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11113 case EM_X86_64:
8a9036a4 11114 case EM_L1OM:
7a9068fe 11115 case EM_K1OM:
aa137e4d 11116 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11117 case EM_S390_OLD:
11118 case EM_S390:
aa137e4d
NC		 11119 return reloc_type == 23; /* R_S390_PC64. */
11120 case EM_TILEGX:
11121 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11122 default:
11123 return FALSE;
11124 }
11125}
11126
4dc3c23d
AM		 11127/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11128 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11129
11130static bfd_boolean
11131is_24bit_abs_reloc (unsigned int reloc_type)
11132{
11133 switch (elf_header.e_machine)
11134 {
11135 case EM_CYGNUS_MN10200:
11136 case EM_MN10200:
11137 return reloc_type == 4; /* R_MN10200_24. */
11138 default:
11139 return FALSE;
11140 }
11141}
11142
aca88567
NC		 11143/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11144 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11145
11146static bfd_boolean
11147is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11148{
11149 switch (elf_header.e_machine)
11150 {
aca88567
NC		 11151 case EM_AVR_OLD:
11152 case EM_AVR:
11153 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11154 case EM_ADAPTEVA_EPIPHANY:
11155 return reloc_type == 5;
41e92641
NC		 11156 case EM_CYGNUS_D10V:
11157 case EM_D10V:
11158 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11159 case EM_H8S:
11160 case EM_H8_300:
11161 case EM_H8_300H:
aca88567
NC		 11162 return reloc_type == R_H8_DIR16;
11163 case EM_IP2K_OLD:
11164 case EM_IP2K:
11165 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11166 case EM_M32C_OLD:
f4236fe4
DD		 11167 case EM_M32C:
11168 return reloc_type == 1; /* R_M32C_16 */
aca88567 11169 case EM_MSP430:
13761a11
NC		 11170 if (uses_msp430x_relocs ())
11171 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11172 case EM_MSP430_OLD:
aca88567 11173 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11174 case EM_NDS32:
11175 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11176 case EM_ALTERA_NIOS2:
36591ba1 11177 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11178 case EM_NIOS32:
11179 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11180 case EM_OR1K:
11181 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11182 case EM_TI_C6000:
11183 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11184 case EM_XC16X:
11185 case EM_C166:
11186 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11187 case EM_CYGNUS_MN10200:
11188 case EM_MN10200:
11189 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11190 case EM_CYGNUS_MN10300:
11191 case EM_MN10300:
11192 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 11193 case EM_XGATE:
11194 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11195 default:
aca88567 11196 return FALSE;
4b78141a
NC		 11197 }
11198}
11199
2a7b2e88
JK		 11200/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11201 relocation entries (possibly formerly used for SHT_GROUP sections). */
11202
11203static bfd_boolean
11204is_none_reloc (unsigned int reloc_type)
11205{
11206 switch (elf_header.e_machine)
11207 {
cb8f3167
NC		 11208 case EM_68K: /* R_68K_NONE. */
11209 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11210 case EM_SPARC32PLUS:
11211 case EM_SPARCV9:
cb8f3167
NC		 11212 case EM_SPARC: /* R_SPARC_NONE. */
11213 case EM_MIPS: /* R_MIPS_NONE. */
11214 case EM_PARISC: /* R_PARISC_NONE. */
11215 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11216 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11217 case EM_PPC: /* R_PPC_NONE. */
11218 case EM_PPC64: /* R_PPC64_NONE. */
11219 case EM_ARM: /* R_ARM_NONE. */
11220 case EM_IA_64: /* R_IA64_NONE. */
11221 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11222 case EM_S390_OLD:
cb8f3167
NC		 11223 case EM_S390: /* R_390_NONE. */
11224 case EM_CRIS: /* R_CRIS_NONE. */
11225 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11226 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11227 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11228 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 11229 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11230 case EM_M32R: /* R_M32R_NONE. */
40b36596 11231 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11232 case EM_TILEGX: /* R_TILEGX_NONE. */
11233 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11234 case EM_XC16X:
11235 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11236 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11237 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11238 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11239 return reloc_type == 0;
a06ea964
NC		 11240 case EM_AARCH64:
11241 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11242 case EM_NDS32:
11243 return (reloc_type == 0 /* R_XTENSA_NONE. */
11244 || reloc_type == 204 /* R_NDS32_DIFF8. */
11245 || reloc_type == 205 /* R_NDS32_DIFF16. */
11246 || reloc_type == 206 /* R_NDS32_DIFF32. */
11247 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11248 case EM_XTENSA_OLD:
11249 case EM_XTENSA:
4dc3c23d
AM		 11250 return (reloc_type == 0 /* R_XTENSA_NONE. */
11251 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11252 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11253 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11254 case EM_METAG:
11255 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11256 }
11257 return FALSE;
11258}
11259
cf13d699
NC		 11260/* Apply relocations to a section.
11261 Note: So far support has been added only for those relocations
11262 which can be found in debug sections.
11263 FIXME: Add support for more relocations ? */
1b315056 11264
cf13d699
NC		 11265static void
11266apply_relocations (void * file,
11267 Elf_Internal_Shdr * section,
11268 unsigned char * start)
1b315056 11269{
cf13d699
NC		 11270 Elf_Internal_Shdr * relsec;
11271 unsigned char * end = start + section->sh_size;
cb8f3167 11272
cf13d699
NC		 11273 if (elf_header.e_type != ET_REL)
11274 return;
1b315056 11275
cf13d699 11276 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11277 for (relsec = section_headers;
11278 relsec < section_headers + elf_header.e_shnum;
11279 ++relsec)
252b5132 11280 {
41e92641
NC		 11281 bfd_boolean is_rela;
11282 unsigned long num_relocs;
2cf0635d
NC		 11283 Elf_Internal_Rela * relocs;
11284 Elf_Internal_Rela * rp;
11285 Elf_Internal_Shdr * symsec;
11286 Elf_Internal_Sym * symtab;
ba5cdace 11287 unsigned long num_syms;
2cf0635d 11288 Elf_Internal_Sym * sym;
252b5132 11289
41e92641 11290 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11291 || relsec->sh_info >= elf_header.e_shnum
11292 || section_headers + relsec->sh_info != section
c256ffe7 11293 || relsec->sh_size == 0
4fbb74a6 11294 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11295 continue;
428409d5 11296
41e92641
NC		 11297 is_rela = relsec->sh_type == SHT_RELA;
11298
11299 if (is_rela)
11300 {
3f5e193b
NC		 11301 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11302 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11303 return;
11304 }
11305 else
11306 {
3f5e193b
NC		 11307 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11308 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11309 return;
11310 }
11311
11312 /* SH uses RELA but uses in place value instead of the addend field. */
11313 if (elf_header.e_machine == EM_SH)
11314 is_rela = FALSE;
428409d5 11315
4fbb74a6 11316 symsec = section_headers + relsec->sh_link;
ba5cdace 11317 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11318
41e92641 11319 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11320 {
41e92641
NC		 11321 bfd_vma addend;
11322 unsigned int reloc_type;
11323 unsigned int reloc_size;
91d6fa6a 11324 unsigned char * rloc;
ba5cdace 11325 unsigned long sym_index;
4b78141a 11326
aca88567 11327 reloc_type = get_reloc_type (rp->r_info);
41e92641 11328
98fb390a 11329 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11330 continue;
98fb390a
NC		 11331 else if (is_none_reloc (reloc_type))
11332 continue;
11333 else if (is_32bit_abs_reloc (reloc_type)
11334 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11335 reloc_size = 4;
85acf597
RH		 11336 else if (is_64bit_abs_reloc (reloc_type)
11337 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11338 reloc_size = 8;
4dc3c23d
AM		 11339 else if (is_24bit_abs_reloc (reloc_type))
11340 reloc_size = 3;
aca88567
NC		 11341 else if (is_16bit_abs_reloc (reloc_type))
11342 reloc_size = 2;
11343 else
4b78141a 11344 {
41e92641 11345 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
74e1a04b 11346 reloc_type, printable_section_name (section));
4b78141a
NC		 11347 continue;
11348 }
103f02d3 11349
91d6fa6a 11350 rloc = start + rp->r_offset;
c8da6823 11351 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11352 {
11353 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11354 (unsigned long) rp->r_offset,
74e1a04b 11355 printable_section_name (section));
700dd8b7
L		 11356 continue;
11357 }
103f02d3 11358
ba5cdace
NC		 11359 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11360 if (sym_index >= num_syms)
11361 {
11362 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11363 sym_index, printable_section_name (section));
ba5cdace
NC		 11364 continue;
11365 }
11366 sym = symtab + sym_index;
41e92641
NC		 11367
11368 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11369 make sure that it is of an appropriate type.
11370
11371 Relocations against symbols without type can happen.
11372 Gcc -feliminate-dwarf2-dups may generate symbols
11373 without type for debug info.
11374
11375 Icc generates relocations against function symbols
11376 instead of local labels.
11377
11378 Relocations against object symbols can happen, eg when
11379 referencing a global array. For an example of this see
11380 the _clz.o binary in libgcc.a. */
aca88567 11381 if (sym != symtab
55f25fc3 11382 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11383 {
41e92641 11384 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11385 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11386 (long int)(rp - relocs),
74e1a04b 11387 printable_section_name (relsec));
aca88567 11388 continue;
5b18a4bc 11389 }
252b5132 11390
4dc3c23d
AM		 11391 addend = 0;
11392 if (is_rela)
11393 addend += rp->r_addend;
c47320c3
AM		 11394 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11395 partial_inplace. */
4dc3c23d
AM		 11396 if (!is_rela
11397 || (elf_header.e_machine == EM_XTENSA
11398 && reloc_type == 1)
11399 || ((elf_header.e_machine == EM_PJ
11400 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11401 && reloc_type == 1)
11402 || ((elf_header.e_machine == EM_D30V
11403 || elf_header.e_machine == EM_CYGNUS_D30V)
11404 && reloc_type == 12))
91d6fa6a 11405 addend += byte_get (rloc, reloc_size);
cb8f3167 11406
85acf597
RH		 11407 if (is_32bit_pcrel_reloc (reloc_type)
11408 || is_64bit_pcrel_reloc (reloc_type))
11409 {
11410 /* On HPPA, all pc-relative relocations are biased by 8. */
11411 if (elf_header.e_machine == EM_PARISC)
11412 addend -= 8;
91d6fa6a 11413 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11414 reloc_size);
11415 }
41e92641 11416 else
91d6fa6a 11417 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11418 }
252b5132 11419
5b18a4bc 11420 free (symtab);
41e92641 11421 free (relocs);
5b18a4bc
NC		 11422 break;
11423 }
5b18a4bc 11424}
103f02d3 11425
cf13d699
NC		 11426#ifdef SUPPORT_DISASSEMBLY
11427static int
11428disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11429{
74e1a04b 11430 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11431
74e1a04b 11432 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11433
11434 return 1;
11435}
11436#endif
11437
11438/* Reads in the contents of SECTION from FILE, returning a pointer
11439 to a malloc'ed buffer or NULL if something went wrong. */
11440
11441static char *
11442get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11443{
11444 bfd_size_type num_bytes;
11445
11446 num_bytes = section->sh_size;
11447
11448 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11449 {
11450 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11451 printable_section_name (section));
cf13d699
NC		 11452 return NULL;
11453 }
11454
3f5e193b
NC		 11455 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11456 _("section contents"));
cf13d699
NC		 11457}
11458
dd24e3da 11459
cf13d699
NC		 11460static void
11461dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11462{
11463 Elf_Internal_Shdr * relsec;
11464 bfd_size_type num_bytes;
cf13d699
NC		 11465 char * data;
11466 char * end;
11467 char * start;
cf13d699
NC		 11468 bfd_boolean some_strings_shown;
11469
11470 start = get_section_contents (section, file);
11471 if (start == NULL)
11472 return;
11473
74e1a04b 11474 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11475
11476 /* If the section being dumped has relocations against it the user might
11477 be expecting these relocations to have been applied. Check for this
11478 case and issue a warning message in order to avoid confusion.
11479 FIXME: Maybe we ought to have an option that dumps a section with
11480 relocs applied ? */
11481 for (relsec = section_headers;
11482 relsec < section_headers + elf_header.e_shnum;
11483 ++relsec)
11484 {
11485 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11486 || relsec->sh_info >= elf_header.e_shnum
11487 || section_headers + relsec->sh_info != section
11488 || relsec->sh_size == 0
11489 || relsec->sh_link >= elf_header.e_shnum)
11490 continue;
11491
11492 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11493 break;
11494 }
11495
11496 num_bytes = section->sh_size;
cf13d699
NC		 11497 data = start;
11498 end = start + num_bytes;
11499 some_strings_shown = FALSE;
11500
11501 while (data < end)
11502 {
11503 while (!ISPRINT (* data))
11504 if (++ data >= end)
11505 break;
11506
11507 if (data < end)
11508 {
071436c6
NC		 11509 size_t maxlen = end - data;
11510
cf13d699 11511#ifndef __MSVCRT__
c975cc98
NC		 11512 /* PR 11128: Use two separate invocations in order to work
11513 around bugs in the Solaris 8 implementation of printf. */
11514 printf (" [%6tx] ", data - start);
cf13d699 11515#else
071436c6 11516 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 11517#endif
4082ef84
NC		 11518 if (maxlen > 0)
11519 {
11520 print_symbol ((int) maxlen, data);
11521 putchar ('\n');
11522 data += strnlen (data, maxlen);
11523 }
11524 else
11525 {
11526 printf (_("<corrupt>\n"));
11527 data = end;
11528 }
cf13d699
NC		 11529 some_strings_shown = TRUE;
11530 }
11531 }
11532
11533 if (! some_strings_shown)
11534 printf (_(" No strings found in this section."));
11535
11536 free (start);
11537
11538 putchar ('\n');
11539}
11540
11541static void
11542dump_section_as_bytes (Elf_Internal_Shdr * section,
11543 FILE * file,
11544 bfd_boolean relocate)
11545{
11546 Elf_Internal_Shdr * relsec;
11547 bfd_size_type bytes;
11548 bfd_vma addr;
11549 unsigned char * data;
11550 unsigned char * start;
11551
11552 start = (unsigned char *) get_section_contents (section, file);
11553 if (start == NULL)
11554 return;
11555
74e1a04b 11556 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11557
11558 if (relocate)
11559 {
11560 apply_relocations (file, section, start);
11561 }
11562 else
11563 {
11564 /* If the section being dumped has relocations against it the user might
11565 be expecting these relocations to have been applied. Check for this
11566 case and issue a warning message in order to avoid confusion.
11567 FIXME: Maybe we ought to have an option that dumps a section with
11568 relocs applied ? */
11569 for (relsec = section_headers;
11570 relsec < section_headers + elf_header.e_shnum;
11571 ++relsec)
11572 {
11573 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11574 || relsec->sh_info >= elf_header.e_shnum
11575 || section_headers + relsec->sh_info != section
11576 || relsec->sh_size == 0
11577 || relsec->sh_link >= elf_header.e_shnum)
11578 continue;
11579
11580 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11581 break;
11582 }
11583 }
11584
11585 addr = section->sh_addr;
11586 bytes = section->sh_size;
11587 data = start;
11588
11589 while (bytes)
11590 {
11591 int j;
11592 int k;
11593 int lbytes;
11594
11595 lbytes = (bytes > 16 ? 16 : bytes);
11596
11597 printf (" 0x%8.8lx ", (unsigned long) addr);
11598
11599 for (j = 0; j < 16; j++)
11600 {
11601 if (j < lbytes)
11602 printf ("%2.2x", data[j]);
11603 else
11604 printf (" ");
11605
11606 if ((j & 3) == 3)
11607 printf (" ");
11608 }
11609
11610 for (j = 0; j < lbytes; j++)
11611 {
11612 k = data[j];
11613 if (k >= ' ' && k < 0x7f)
11614 printf ("%c", k);
11615 else
11616 printf (".");
11617 }
11618
11619 putchar ('\n');
11620
11621 data += lbytes;
11622 addr += lbytes;
11623 bytes -= lbytes;
11624 }
11625
11626 free (start);
11627
11628 putchar ('\n');
11629}
11630
4a114e3e 11631/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11632
11633static int
d3dbc530
AM		 11634uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11635 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 11636{
11637#ifndef HAVE_ZLIB_H
cf13d699
NC		 11638 return FALSE;
11639#else
11640 dwarf_size_type compressed_size = *size;
11641 unsigned char * compressed_buffer = *buffer;
11642 dwarf_size_type uncompressed_size;
11643 unsigned char * uncompressed_buffer;
11644 z_stream strm;
11645 int rc;
11646 dwarf_size_type header_size = 12;
11647
11648 /* Read the zlib header. In this case, it should be "ZLIB" followed
11649 by the uncompressed section size, 8 bytes in big-endian order. */
11650 if (compressed_size < header_size
11651 || ! streq ((char *) compressed_buffer, "ZLIB"))
11652 return 0;
11653
11654 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11655 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11656 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11657 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11658 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11659 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11660 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11661 uncompressed_size += compressed_buffer[11];
11662
11663 /* It is possible the section consists of several compressed
11664 buffers concatenated together, so we uncompress in a loop. */
11665 strm.zalloc = NULL;
11666 strm.zfree = NULL;
11667 strm.opaque = NULL;
11668 strm.avail_in = compressed_size - header_size;
11669 strm.next_in = (Bytef *) compressed_buffer + header_size;
11670 strm.avail_out = uncompressed_size;
3f5e193b 11671 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 11672
11673 rc = inflateInit (& strm);
11674 while (strm.avail_in > 0)
11675 {
11676 if (rc != Z_OK)
11677 goto fail;
11678 strm.next_out = ((Bytef *) uncompressed_buffer
11679 + (uncompressed_size - strm.avail_out));
11680 rc = inflate (&strm, Z_FINISH);
11681 if (rc != Z_STREAM_END)
11682 goto fail;
11683 rc = inflateReset (& strm);
11684 }
11685 rc = inflateEnd (& strm);
11686 if (rc != Z_OK
11687 || strm.avail_out != 0)
11688 goto fail;
11689
11690 free (compressed_buffer);
11691 *buffer = uncompressed_buffer;
11692 *size = uncompressed_size;
11693 return 1;
11694
11695 fail:
11696 free (uncompressed_buffer);
4a114e3e
L		 11697 /* Indicate decompression failure. */
11698 *buffer = NULL;
cf13d699
NC		 11699 return 0;
11700#endif /* HAVE_ZLIB_H */
11701}
11702
d966045b
DJ		 11703static int
11704load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 11705 Elf_Internal_Shdr * sec, void * file)
1007acb3 11706{
2cf0635d 11707 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 11708 char buf [64];
1007acb3 11709
19e6b90e
L		 11710 /* If it is already loaded, do nothing. */
11711 if (section->start != NULL)
11712 return 1;
1007acb3 11713
19e6b90e
L		 11714 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11715 section->address = sec->sh_addr;
3f5e193b
NC		 11716 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11717 sec->sh_offset, 1,
11718 sec->sh_size, buf);
59245841
NC		 11719 if (section->start == NULL)
11720 section->size = 0;
11721 else
11722 {
11723 section->size = sec->sh_size;
11724 if (uncompress_section_contents (&section->start, &section->size))
11725 sec->sh_size = section->size;
11726 }
4a114e3e 11727
1b315056
CS		 11728 if (section->start == NULL)
11729 return 0;
11730
19e6b90e 11731 if (debug_displays [debug].relocate)
3f5e193b 11732 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11733
1b315056 11734 return 1;
1007acb3
L		 11735}
11736
657d0d47
CC		 11737/* If this is not NULL, load_debug_section will only look for sections
11738 within the list of sections given here. */
11739unsigned int *section_subset = NULL;
11740
d966045b 11741int
2cf0635d 11742load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11743{
2cf0635d
NC		 11744 struct dwarf_section * section = &debug_displays [debug].section;
11745 Elf_Internal_Shdr * sec;
d966045b
DJ		 11746
11747 /* Locate the debug section. */
657d0d47 11748 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 11749 if (sec != NULL)
11750 section->name = section->uncompressed_name;
11751 else
11752 {
657d0d47 11753 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 11754 if (sec != NULL)
11755 section->name = section->compressed_name;
11756 }
11757 if (sec == NULL)
11758 return 0;
11759
657d0d47
CC		 11760 /* If we're loading from a subset of sections, and we've loaded
11761 a section matching this name before, it's likely that it's a
11762 different one. */
11763 if (section_subset != NULL)
11764 free_debug_section (debug);
11765
3f5e193b 11766 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 11767}
11768
19e6b90e
L		 11769void
11770free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 11771{
2cf0635d 11772 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 11773
19e6b90e
L		 11774 if (section->start == NULL)
11775 return;
1007acb3 11776
19e6b90e
L		 11777 free ((char *) section->start);
11778 section->start = NULL;
11779 section->address = 0;
11780 section->size = 0;
1007acb3
L		 11781}
11782
1007acb3 11783static int
657d0d47 11784display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 11785{
2cf0635d 11786 char * name = SECTION_NAME (section);
74e1a04b 11787 const char * print_name = printable_section_name (section);
19e6b90e
L		 11788 bfd_size_type length;
11789 int result = 1;
3f5e193b 11790 int i;
1007acb3 11791
19e6b90e
L		 11792 length = section->sh_size;
11793 if (length == 0)
1007acb3 11794 {
74e1a04b 11795 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 11796 return 0;
1007acb3 11797 }
5dff79d8
NC		 11798 if (section->sh_type == SHT_NOBITS)
11799 {
11800 /* There is no point in dumping the contents of a debugging section
11801 which has the NOBITS type - the bits in the file will be random.
11802 This can happen when a file containing a .eh_frame section is
11803 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 11804 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11805 print_name);
5dff79d8
NC		 11806 return 0;
11807 }
1007acb3 11808
0112cd26 11809 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 11810 name = ".debug_info";
1007acb3 11811
19e6b90e
L		 11812 /* See if we know how to display the contents of this section. */
11813 for (i = 0; i < max; i++)
1b315056 11814 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 11815 || (i == line && const_strneq (name, ".debug_line."))
1b315056 11816 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 11817 {
2cf0635d 11818 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 11819 int secondary = (section != find_section (name));
11820
11821 if (secondary)
3f5e193b 11822 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 11823
b40bf0a2
NC		 11824 if (i == line && const_strneq (name, ".debug_line."))
11825 sec->name = name;
11826 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 11827 sec->name = sec->uncompressed_name;
11828 else
11829 sec->name = sec->compressed_name;
3f5e193b
NC		 11830 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11831 section, file))
19e6b90e 11832 {
657d0d47
CC		 11833 /* If this debug section is part of a CU/TU set in a .dwp file,
11834 restrict load_debug_section to the sections in that set. */
11835 section_subset = find_cu_tu_set (file, shndx);
11836
19e6b90e 11837 result &= debug_displays[i].display (sec, file);
1007acb3 11838
657d0d47
CC		 11839 section_subset = NULL;
11840
d966045b 11841 if (secondary || (i != info && i != abbrev))
3f5e193b 11842 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 11843 }
1007acb3 11844
19e6b90e
L		 11845 break;
11846 }
1007acb3 11847
19e6b90e 11848 if (i == max)
1007acb3 11849 {
74e1a04b 11850 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 11851 result = 0;
1007acb3
L		 11852 }
11853
19e6b90e 11854 return result;
5b18a4bc 11855}
103f02d3 11856
aef1f6d0
DJ		 11857/* Set DUMP_SECTS for all sections where dumps were requested
11858 based on section name. */
11859
11860static void
11861initialise_dumps_byname (void)
11862{
2cf0635d 11863 struct dump_list_entry * cur;
aef1f6d0
DJ		 11864
11865 for (cur = dump_sects_byname; cur; cur = cur->next)
11866 {
11867 unsigned int i;
11868 int any;
11869
11870 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11871 if (streq (SECTION_NAME (section_headers + i), cur->name))
11872 {
09c11c86 11873 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11874 any = 1;
11875 }
11876
11877 if (!any)
11878 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11879 cur->name);
11880 }
11881}
11882
5b18a4bc 11883static void
2cf0635d 11884process_section_contents (FILE * file)
5b18a4bc 11885{
2cf0635d 11886 Elf_Internal_Shdr * section;
19e6b90e 11887 unsigned int i;
103f02d3 11888
19e6b90e
L		 11889 if (! do_dump)
11890 return;
103f02d3 11891
aef1f6d0
DJ		 11892 initialise_dumps_byname ();
11893
19e6b90e
L		 11894 for (i = 0, section = section_headers;
11895 i < elf_header.e_shnum && i < num_dump_sects;
11896 i++, section++)
11897 {
11898#ifdef SUPPORT_DISASSEMBLY
11899 if (dump_sects[i] & DISASS_DUMP)
11900 disassemble_section (section, file);
11901#endif
11902 if (dump_sects[i] & HEX_DUMP)
cf13d699 11903 dump_section_as_bytes (section, file, FALSE);
103f02d3 11904
cf13d699
NC		 11905 if (dump_sects[i] & RELOC_DUMP)
11906 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11907
11908 if (dump_sects[i] & STRING_DUMP)
11909 dump_section_as_strings (section, file);
cf13d699
NC		 11910
11911 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11912 display_debug_section (i, section, file);
5b18a4bc 11913 }
103f02d3 11914
19e6b90e
L		 11915 /* Check to see if the user requested a
11916 dump of a section that does not exist. */
11917 while (i++ < num_dump_sects)
11918 if (dump_sects[i])
11919 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11920}
103f02d3 11921
5b18a4bc 11922static void
19e6b90e 11923process_mips_fpe_exception (int mask)
5b18a4bc 11924{
19e6b90e
L		 11925 if (mask)
11926 {
11927 int first = 1;
11928 if (mask & OEX_FPU_INEX)
11929 fputs ("INEX", stdout), first = 0;
11930 if (mask & OEX_FPU_UFLO)
11931 printf ("%sUFLO", first ? "" : "|"), first = 0;
11932 if (mask & OEX_FPU_OFLO)
11933 printf ("%sOFLO", first ? "" : "|"), first = 0;
11934 if (mask & OEX_FPU_DIV0)
11935 printf ("%sDIV0", first ? "" : "|"), first = 0;
11936 if (mask & OEX_FPU_INVAL)
11937 printf ("%sINVAL", first ? "" : "|");
11938 }
5b18a4bc 11939 else
19e6b90e 11940 fputs ("0", stdout);
5b18a4bc 11941}
103f02d3 11942
f6f0e17b
NC		 11943/* Display's the value of TAG at location P. If TAG is
11944 greater than 0 it is assumed to be an unknown tag, and
11945 a message is printed to this effect. Otherwise it is
11946 assumed that a message has already been printed.
11947
11948 If the bottom bit of TAG is set it assumed to have a
11949 string value, otherwise it is assumed to have an integer
11950 value.
11951
11952 Returns an updated P pointing to the first unread byte
11953 beyond the end of TAG's value.
11954
11955 Reads at or beyond END will not be made. */
11956
11957static unsigned char *
11958display_tag_value (int tag,
11959 unsigned char * p,
11960 const unsigned char * const end)
11961{
11962 unsigned long val;
11963
11964 if (tag > 0)
11965 printf (" Tag_unknown_%d: ", tag);
11966
11967 if (p >= end)
11968 {
4082ef84 11969 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 11970 }
11971 else if (tag & 1)
11972 {
071436c6
NC		 11973 /* PR 17531 file: 027-19978-0.004. */
11974 size_t maxlen = (end - p) - 1;
11975
11976 putchar ('"');
4082ef84
NC		 11977 if (maxlen > 0)
11978 {
11979 print_symbol ((int) maxlen, (const char *) p);
11980 p += strnlen ((char *) p, maxlen) + 1;
11981 }
11982 else
11983 {
11984 printf (_("<corrupt string tag>"));
11985 p = (unsigned char *) end;
11986 }
071436c6 11987 printf ("\"\n");
f6f0e17b
NC		 11988 }
11989 else
11990 {
11991 unsigned int len;
11992
11993 val = read_uleb128 (p, &len, end);
11994 p += len;
11995 printf ("%ld (0x%lx)\n", val, val);
11996 }
11997
4082ef84 11998 assert (p <= end);
f6f0e17b
NC		 11999 return p;
12000}
12001
11c1ff18
PB		 12002/* ARM EABI attributes section. */
12003typedef struct
12004{
70e99720 12005 unsigned int tag;
2cf0635d 12006 const char * name;
11c1ff18 12007 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12008 unsigned int type;
2cf0635d 12009 const char ** table;
11c1ff18
PB		 12010} arm_attr_public_tag;
12011
2cf0635d 12012static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12013 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12014 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12015static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12016static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12017 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12018static const char * arm_attr_tag_FP_arch[] =
bca38921 12019 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12020 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12021static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12022static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12023 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12024static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12025 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12026 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12027static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12028 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12029static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12030 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12031static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12032 {"Absolute", "PC-relative", "None"};
2cf0635d 12033static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12034 {"None", "direct", "GOT-indirect"};
2cf0635d 12035static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12036 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12037static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12038static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12039 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12040static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12041static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12042static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12043 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12044static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12045 {"Unused", "small", "int", "forced to int"};
2cf0635d 12046static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 12047 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 12048static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 12049 {"AAPCS", "VFP registers", "custom"};
2cf0635d 12050static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12051 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12052static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12053 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12054 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12055static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12056 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12057 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12058static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12059static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12060 {"Not Allowed", "Allowed"};
2cf0635d 12061static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12062 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12063static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12064 {"Not Allowed", "Allowed"};
12065static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12066 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12067 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12068static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12069static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12070 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12071 "TrustZone and Virtualization Extensions"};
dd24e3da 12072static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12073 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12074
12075#define LOOKUP(id, name) \
12076 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12077static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12078{
12079 {4, "CPU_raw_name", 1, NULL},
12080 {5, "CPU_name", 1, NULL},
12081 LOOKUP(6, CPU_arch),
12082 {7, "CPU_arch_profile", 0, NULL},
12083 LOOKUP(8, ARM_ISA_use),
12084 LOOKUP(9, THUMB_ISA_use),
75375b3e 12085 LOOKUP(10, FP_arch),
11c1ff18 12086 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12087 LOOKUP(12, Advanced_SIMD_arch),
12088 LOOKUP(13, PCS_config),
11c1ff18
PB		 12089 LOOKUP(14, ABI_PCS_R9_use),
12090 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12091 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12092 LOOKUP(17, ABI_PCS_GOT_use),
12093 LOOKUP(18, ABI_PCS_wchar_t),
12094 LOOKUP(19, ABI_FP_rounding),
12095 LOOKUP(20, ABI_FP_denormal),
12096 LOOKUP(21, ABI_FP_exceptions),
12097 LOOKUP(22, ABI_FP_user_exceptions),
12098 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12099 {24, "ABI_align_needed", 0, NULL},
12100 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12101 LOOKUP(26, ABI_enum_size),
12102 LOOKUP(27, ABI_HardFP_use),
12103 LOOKUP(28, ABI_VFP_args),
12104 LOOKUP(29, ABI_WMMX_args),
12105 LOOKUP(30, ABI_optimization_goals),
12106 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12107 {32, "compatibility", 0, NULL},
f5f53991 12108 LOOKUP(34, CPU_unaligned_access),
75375b3e 12109 LOOKUP(36, FP_HP_extension),
8e79c3df 12110 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12111 LOOKUP(42, MPextension_use),
12112 LOOKUP(44, DIV_use),
f5f53991
AS		 12113 {64, "nodefaults", 0, NULL},
12114 {65, "also_compatible_with", 0, NULL},
12115 LOOKUP(66, T2EE_use),
12116 {67, "conformance", 1, NULL},
12117 LOOKUP(68, Virtualization_use),
cd21e546 12118 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12119};
12120#undef LOOKUP
12121
11c1ff18 12122static unsigned char *
f6f0e17b
NC		 12123display_arm_attribute (unsigned char * p,
12124 const unsigned char * const end)
11c1ff18 12125{
70e99720 12126 unsigned int tag;
11c1ff18 12127 unsigned int len;
70e99720 12128 unsigned int val;
2cf0635d 12129 arm_attr_public_tag * attr;
11c1ff18 12130 unsigned i;
70e99720 12131 unsigned int type;
11c1ff18 12132
f6f0e17b 12133 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12134 p += len;
12135 attr = NULL;
2cf0635d 12136 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12137 {
12138 if (arm_attr_public_tags[i].tag == tag)
12139 {
12140 attr = &arm_attr_public_tags[i];
12141 break;
12142 }
12143 }
12144
12145 if (attr)
12146 {
12147 printf (" Tag_%s: ", attr->name);
12148 switch (attr->type)
12149 {
12150 case 0:
12151 switch (tag)
12152 {
12153 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12154 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12155 p += len;
12156 switch (val)
12157 {
2b692964
NC		 12158 case 0: printf (_("None\n")); break;
12159 case 'A': printf (_("Application\n")); break;
12160 case 'R': printf (_("Realtime\n")); break;
12161 case 'M': printf (_("Microcontroller\n")); break;
12162 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12163 default: printf ("??? (%d)\n", val); break;
12164 }
12165 break;
12166
75375b3e 12167 case 24: /* Tag_align_needed. */
f6f0e17b 12168 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12169 p += len;
12170 switch (val)
12171 {
2b692964
NC		 12172 case 0: printf (_("None\n")); break;
12173 case 1: printf (_("8-byte\n")); break;
12174 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12175 case 3: printf ("??? 3\n"); break;
12176 default:
12177 if (val <= 12)
dd24e3da 12178 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12179 1 << val);
12180 else
12181 printf ("??? (%d)\n", val);
12182 break;
12183 }
12184 break;
12185
12186 case 25: /* Tag_align_preserved. */
f6f0e17b 12187 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12188 p += len;
12189 switch (val)
12190 {
2b692964
NC		 12191 case 0: printf (_("None\n")); break;
12192 case 1: printf (_("8-byte, except leaf SP\n")); break;
12193 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12194 case 3: printf ("??? 3\n"); break;
12195 default:
12196 if (val <= 12)
dd24e3da 12197 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12198 1 << val);
12199 else
12200 printf ("??? (%d)\n", val);
12201 break;
12202 }
12203 break;
12204
11c1ff18 12205 case 32: /* Tag_compatibility. */
071436c6 12206 {
071436c6
NC		 12207 val = read_uleb128 (p, &len, end);
12208 p += len;
071436c6 12209 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12210 if (p < end - 1)
12211 {
12212 size_t maxlen = (end - p) - 1;
12213
12214 print_symbol ((int) maxlen, (const char *) p);
12215 p += strnlen ((char *) p, maxlen) + 1;
12216 }
12217 else
12218 {
12219 printf (_("<corrupt>"));
12220 p = (unsigned char *) end;
12221 }
071436c6 12222 putchar ('\n');
071436c6 12223 }
11c1ff18
PB		 12224 break;
12225
f5f53991 12226 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12227 /* PR 17531: file: 001-505008-0.01. */
12228 if (p < end)
12229 p++;
2b692964 12230 printf (_("True\n"));
f5f53991
AS		 12231 break;
12232
12233 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12234 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12235 p += len;
12236 if (val == 6 /* Tag_CPU_arch. */)
12237 {
f6f0e17b 12238 val = read_uleb128 (p, &len, end);
f5f53991 12239 p += len;
071436c6 12240 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12241 printf ("??? (%d)\n", val);
12242 else
12243 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12244 }
12245 else
12246 printf ("???\n");
071436c6
NC		 12247 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12248 ;
f5f53991
AS		 12249 break;
12250
11c1ff18 12251 default:
2cf0635d 12252 abort ();
11c1ff18
PB		 12253 }
12254 return p;
12255
12256 case 1:
f6f0e17b 12257 return display_tag_value (-1, p, end);
11c1ff18 12258 case 2:
f6f0e17b 12259 return display_tag_value (0, p, end);
11c1ff18
PB		 12260
12261 default:
12262 assert (attr->type & 0x80);
f6f0e17b 12263 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12264 p += len;
12265 type = attr->type & 0x7f;
12266 if (val >= type)
12267 printf ("??? (%d)\n", val);
12268 else
12269 printf ("%s\n", attr->table[val]);
12270 return p;
12271 }
12272 }
11c1ff18 12273
f6f0e17b 12274 return display_tag_value (tag, p, end);
11c1ff18
PB		 12275}
12276
104d59d1 12277static unsigned char *
60bca95a 12278display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12279 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12280 const unsigned char * const end)
104d59d1
JM		 12281{
12282 int tag;
12283 unsigned int len;
12284 int val;
104d59d1 12285
f6f0e17b 12286 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12287 p += len;
12288
12289 /* Tag_compatibility is the only generic GNU attribute defined at
12290 present. */
12291 if (tag == 32)
12292 {
f6f0e17b 12293 val = read_uleb128 (p, &len, end);
104d59d1 12294 p += len;
071436c6
NC		 12295
12296 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12297 if (p == end)
12298 {
071436c6 12299 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12300 warn (_("corrupt vendor attribute\n"));
12301 }
12302 else
12303 {
4082ef84
NC		 12304 if (p < end - 1)
12305 {
12306 size_t maxlen = (end - p) - 1;
071436c6 12307
4082ef84
NC		 12308 print_symbol ((int) maxlen, (const char *) p);
12309 p += strnlen ((char *) p, maxlen) + 1;
12310 }
12311 else
12312 {
12313 printf (_("<corrupt>"));
12314 p = (unsigned char *) end;
12315 }
071436c6 12316 putchar ('\n');
f6f0e17b 12317 }
104d59d1
JM		 12318 return p;
12319 }
12320
12321 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12322 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12323
f6f0e17b 12324 return display_tag_value (tag, p, end);
104d59d1
JM		 12325}
12326
34c8bcba 12327static unsigned char *
f6f0e17b
NC		 12328display_power_gnu_attribute (unsigned char * p,
12329 int tag,
12330 const unsigned char * const end)
34c8bcba 12331{
34c8bcba
JM		 12332 unsigned int len;
12333 int val;
12334
12335 if (tag == Tag_GNU_Power_ABI_FP)
12336 {
f6f0e17b 12337 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12338 p += len;
12339 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12340
34c8bcba
JM		 12341 switch (val)
12342 {
12343 case 0:
2b692964 12344 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12345 break;
12346 case 1:
2b692964 12347 printf (_("Hard float\n"));
34c8bcba
JM		 12348 break;
12349 case 2:
2b692964 12350 printf (_("Soft float\n"));
34c8bcba 12351 break;
3c7b9897 12352 case 3:
2b692964 12353 printf (_("Single-precision hard float\n"));
3c7b9897 12354 break;
34c8bcba
JM		 12355 default:
12356 printf ("??? (%d)\n", val);
12357 break;
12358 }
12359 return p;
12360 }
12361
c6e65352
DJ		 12362 if (tag == Tag_GNU_Power_ABI_Vector)
12363 {
f6f0e17b 12364 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12365 p += len;
12366 printf (" Tag_GNU_Power_ABI_Vector: ");
12367 switch (val)
12368 {
12369 case 0:
2b692964 12370 printf (_("Any\n"));
c6e65352
DJ		 12371 break;
12372 case 1:
2b692964 12373 printf (_("Generic\n"));
c6e65352
DJ		 12374 break;
12375 case 2:
12376 printf ("AltiVec\n");
12377 break;
12378 case 3:
12379 printf ("SPE\n");
12380 break;
12381 default:
12382 printf ("??? (%d)\n", val);
12383 break;
12384 }
12385 return p;
12386 }
12387
f82e0623
NF		 12388 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12389 {
f6f0e17b
NC		 12390 if (p == end)
12391 {
071436c6 12392 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12393 return p;
12394 }
0b4362b0 12395
f6f0e17b 12396 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12397 p += len;
12398 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12399 switch (val)
12400 {
12401 case 0:
2b692964 12402 printf (_("Any\n"));
f82e0623
NF		 12403 break;
12404 case 1:
12405 printf ("r3/r4\n");
12406 break;
12407 case 2:
2b692964 12408 printf (_("Memory\n"));
f82e0623
NF		 12409 break;
12410 default:
12411 printf ("??? (%d)\n", val);
12412 break;
12413 }
12414 return p;
12415 }
12416
f6f0e17b 12417 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12418}
12419
9e8c70f9
DM		 12420static void
12421display_sparc_hwcaps (int mask)
12422{
12423 if (mask)
12424 {
12425 int first = 1;
071436c6 12426
9e8c70f9
DM		 12427 if (mask & ELF_SPARC_HWCAP_MUL32)
12428 fputs ("mul32", stdout), first = 0;
12429 if (mask & ELF_SPARC_HWCAP_DIV32)
12430 printf ("%sdiv32", first ? "" : "|"), first = 0;
12431 if (mask & ELF_SPARC_HWCAP_FSMULD)
12432 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12433 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12434 printf ("%sv8plus", first ? "" : "|"), first = 0;
12435 if (mask & ELF_SPARC_HWCAP_POPC)
12436 printf ("%spopc", first ? "" : "|"), first = 0;
12437 if (mask & ELF_SPARC_HWCAP_VIS)
12438 printf ("%svis", first ? "" : "|"), first = 0;
12439 if (mask & ELF_SPARC_HWCAP_VIS2)
12440 printf ("%svis2", first ? "" : "|"), first = 0;
12441 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12442 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12443 if (mask & ELF_SPARC_HWCAP_FMAF)
12444 printf ("%sfmaf", first ? "" : "|"), first = 0;
12445 if (mask & ELF_SPARC_HWCAP_VIS3)
12446 printf ("%svis3", first ? "" : "|"), first = 0;
12447 if (mask & ELF_SPARC_HWCAP_HPC)
12448 printf ("%shpc", first ? "" : "|"), first = 0;
12449 if (mask & ELF_SPARC_HWCAP_RANDOM)
12450 printf ("%srandom", first ? "" : "|"), first = 0;
12451 if (mask & ELF_SPARC_HWCAP_TRANS)
12452 printf ("%strans", first ? "" : "|"), first = 0;
12453 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12454 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12455 if (mask & ELF_SPARC_HWCAP_IMA)
12456 printf ("%sima", first ? "" : "|"), first = 0;
12457 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12458 printf ("%scspare", first ? "" : "|"), first = 0;
12459 }
12460 else
071436c6
NC		 12461 fputc ('0', stdout);
12462 fputc ('\n', stdout);
9e8c70f9
DM		 12463}
12464
3d68f91c
JM		 12465static void
12466display_sparc_hwcaps2 (int mask)
12467{
12468 if (mask)
12469 {
12470 int first = 1;
071436c6 12471
3d68f91c
JM		 12472 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12473 fputs ("fjathplus", stdout), first = 0;
12474 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12475 printf ("%svis3b", first ? "" : "|"), first = 0;
12476 if (mask & ELF_SPARC_HWCAP2_ADP)
12477 printf ("%sadp", first ? "" : "|"), first = 0;
12478 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12479 printf ("%ssparc5", first ? "" : "|"), first = 0;
12480 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12481 printf ("%smwait", first ? "" : "|"), first = 0;
12482 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12483 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12484 if (mask & ELF_SPARC_HWCAP2_XMONT)
12485 printf ("%sxmont2", first ? "" : "|"), first = 0;
12486 if (mask & ELF_SPARC_HWCAP2_NSEC)
12487 printf ("%snsec", first ? "" : "|"), first = 0;
12488 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12489 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12490 if (mask & ELF_SPARC_HWCAP2_FJDES)
12491 printf ("%sfjdes", first ? "" : "|"), first = 0;
12492 if (mask & ELF_SPARC_HWCAP2_FJAES)
12493 printf ("%sfjaes", first ? "" : "|"), first = 0;
12494 }
12495 else
071436c6
NC		 12496 fputc ('0', stdout);
12497 fputc ('\n', stdout);
3d68f91c
JM		 12498}
12499
9e8c70f9 12500static unsigned char *
f6f0e17b
NC		 12501display_sparc_gnu_attribute (unsigned char * p,
12502 int tag,
12503 const unsigned char * const end)
9e8c70f9 12504{
3d68f91c
JM		 12505 unsigned int len;
12506 int val;
12507
9e8c70f9
DM		 12508 if (tag == Tag_GNU_Sparc_HWCAPS)
12509 {
f6f0e17b 12510 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12511 p += len;
12512 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12513 display_sparc_hwcaps (val);
12514 return p;
3d68f91c
JM		 12515 }
12516 if (tag == Tag_GNU_Sparc_HWCAPS2)
12517 {
12518 val = read_uleb128 (p, &len, end);
12519 p += len;
12520 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12521 display_sparc_hwcaps2 (val);
12522 return p;
12523 }
9e8c70f9 12524
f6f0e17b 12525 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12526}
12527
351cdf24
MF		 12528static void
12529print_mips_fp_abi_value (int val)
12530{
12531 switch (val)
12532 {
12533 case Val_GNU_MIPS_ABI_FP_ANY:
12534 printf (_("Hard or soft float\n"));
12535 break;
12536 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12537 printf (_("Hard float (double precision)\n"));
12538 break;
12539 case Val_GNU_MIPS_ABI_FP_SINGLE:
12540 printf (_("Hard float (single precision)\n"));
12541 break;
12542 case Val_GNU_MIPS_ABI_FP_SOFT:
12543 printf (_("Soft float\n"));
12544 break;
12545 case Val_GNU_MIPS_ABI_FP_OLD_64:
12546 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12547 break;
12548 case Val_GNU_MIPS_ABI_FP_XX:
12549 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12550 break;
12551 case Val_GNU_MIPS_ABI_FP_64:
12552 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12553 break;
12554 case Val_GNU_MIPS_ABI_FP_64A:
12555 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12556 break;
12557 default:
12558 printf ("??? (%d)\n", val);
12559 break;
12560 }
12561}
12562
2cf19d5c 12563static unsigned char *
f6f0e17b
NC		 12564display_mips_gnu_attribute (unsigned char * p,
12565 int tag,
12566 const unsigned char * const end)
2cf19d5c 12567{
2cf19d5c
JM		 12568 if (tag == Tag_GNU_MIPS_ABI_FP)
12569 {
f6f0e17b
NC		 12570 unsigned int len;
12571 int val;
12572
12573 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12574 p += len;
12575 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12576
351cdf24
MF		 12577 print_mips_fp_abi_value (val);
12578
2cf19d5c
JM		 12579 return p;
12580 }
12581
a9f58168
CF		 12582 if (tag == Tag_GNU_MIPS_ABI_MSA)
12583 {
12584 unsigned int len;
12585 int val;
12586
12587 val = read_uleb128 (p, &len, end);
12588 p += len;
12589 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12590
12591 switch (val)
12592 {
12593 case Val_GNU_MIPS_ABI_MSA_ANY:
12594 printf (_("Any MSA or not\n"));
12595 break;
12596 case Val_GNU_MIPS_ABI_MSA_128:
12597 printf (_("128-bit MSA\n"));
12598 break;
12599 default:
12600 printf ("??? (%d)\n", val);
12601 break;
12602 }
12603 return p;
12604 }
12605
f6f0e17b 12606 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12607}
12608
59e6276b 12609static unsigned char *
f6f0e17b
NC		 12610display_tic6x_attribute (unsigned char * p,
12611 const unsigned char * const end)
59e6276b
JM		 12612{
12613 int tag;
12614 unsigned int len;
12615 int val;
12616
f6f0e17b 12617 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12618 p += len;
12619
12620 switch (tag)
12621 {
75fa6dc1 12622 case Tag_ISA:
f6f0e17b 12623 val = read_uleb128 (p, &len, end);
59e6276b 12624 p += len;
75fa6dc1 12625 printf (" Tag_ISA: ");
59e6276b
JM		 12626
12627 switch (val)
12628 {
75fa6dc1 12629 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12630 printf (_("None\n"));
12631 break;
75fa6dc1 12632 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12633 printf ("C62x\n");
12634 break;
75fa6dc1 12635 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12636 printf ("C67x\n");
12637 break;
75fa6dc1 12638 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12639 printf ("C67x+\n");
12640 break;
75fa6dc1 12641 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12642 printf ("C64x\n");
12643 break;
75fa6dc1 12644 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12645 printf ("C64x+\n");
12646 break;
75fa6dc1 12647 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12648 printf ("C674x\n");
12649 break;
12650 default:
12651 printf ("??? (%d)\n", val);
12652 break;
12653 }
12654 return p;
12655
87779176 12656 case Tag_ABI_wchar_t:
f6f0e17b 12657 val = read_uleb128 (p, &len, end);
87779176
JM		 12658 p += len;
12659 printf (" Tag_ABI_wchar_t: ");
12660 switch (val)
12661 {
12662 case 0:
12663 printf (_("Not used\n"));
12664 break;
12665 case 1:
12666 printf (_("2 bytes\n"));
12667 break;
12668 case 2:
12669 printf (_("4 bytes\n"));
12670 break;
12671 default:
12672 printf ("??? (%d)\n", val);
12673 break;
12674 }
12675 return p;
12676
12677 case Tag_ABI_stack_align_needed:
f6f0e17b 12678 val = read_uleb128 (p, &len, end);
87779176
JM		 12679 p += len;
12680 printf (" Tag_ABI_stack_align_needed: ");
12681 switch (val)
12682 {
12683 case 0:
12684 printf (_("8-byte\n"));
12685 break;
12686 case 1:
12687 printf (_("16-byte\n"));
12688 break;
12689 default:
12690 printf ("??? (%d)\n", val);
12691 break;
12692 }
12693 return p;
12694
12695 case Tag_ABI_stack_align_preserved:
f6f0e17b 12696 val = read_uleb128 (p, &len, end);
87779176
JM		 12697 p += len;
12698 printf (" Tag_ABI_stack_align_preserved: ");
12699 switch (val)
12700 {
12701 case 0:
12702 printf (_("8-byte\n"));
12703 break;
12704 case 1:
12705 printf (_("16-byte\n"));
12706 break;
12707 default:
12708 printf ("??? (%d)\n", val);
12709 break;
12710 }
12711 return p;
12712
b5593623 12713 case Tag_ABI_DSBT:
f6f0e17b 12714 val = read_uleb128 (p, &len, end);
b5593623
JM		 12715 p += len;
12716 printf (" Tag_ABI_DSBT: ");
12717 switch (val)
12718 {
12719 case 0:
12720 printf (_("DSBT addressing not used\n"));
12721 break;
12722 case 1:
12723 printf (_("DSBT addressing used\n"));
12724 break;
12725 default:
12726 printf ("??? (%d)\n", val);
12727 break;
12728 }
12729 return p;
12730
87779176 12731 case Tag_ABI_PID:
f6f0e17b 12732 val = read_uleb128 (p, &len, end);
87779176
JM		 12733 p += len;
12734 printf (" Tag_ABI_PID: ");
12735 switch (val)
12736 {
12737 case 0:
12738 printf (_("Data addressing position-dependent\n"));
12739 break;
12740 case 1:
12741 printf (_("Data addressing position-independent, GOT near DP\n"));
12742 break;
12743 case 2:
12744 printf (_("Data addressing position-independent, GOT far from DP\n"));
12745 break;
12746 default:
12747 printf ("??? (%d)\n", val);
12748 break;
12749 }
12750 return p;
12751
12752 case Tag_ABI_PIC:
f6f0e17b 12753 val = read_uleb128 (p, &len, end);
87779176
JM		 12754 p += len;
12755 printf (" Tag_ABI_PIC: ");
12756 switch (val)
12757 {
12758 case 0:
12759 printf (_("Code addressing position-dependent\n"));
12760 break;
12761 case 1:
12762 printf (_("Code addressing position-independent\n"));
12763 break;
12764 default:
12765 printf ("??? (%d)\n", val);
12766 break;
12767 }
12768 return p;
12769
12770 case Tag_ABI_array_object_alignment:
f6f0e17b 12771 val = read_uleb128 (p, &len, end);
87779176
JM		 12772 p += len;
12773 printf (" Tag_ABI_array_object_alignment: ");
12774 switch (val)
12775 {
12776 case 0:
12777 printf (_("8-byte\n"));
12778 break;
12779 case 1:
12780 printf (_("4-byte\n"));
12781 break;
12782 case 2:
12783 printf (_("16-byte\n"));
12784 break;
12785 default:
12786 printf ("??? (%d)\n", val);
12787 break;
12788 }
12789 return p;
12790
12791 case Tag_ABI_array_object_align_expected:
f6f0e17b 12792 val = read_uleb128 (p, &len, end);
87779176
JM		 12793 p += len;
12794 printf (" Tag_ABI_array_object_align_expected: ");
12795 switch (val)
12796 {
12797 case 0:
12798 printf (_("8-byte\n"));
12799 break;
12800 case 1:
12801 printf (_("4-byte\n"));
12802 break;
12803 case 2:
12804 printf (_("16-byte\n"));
12805 break;
12806 default:
12807 printf ("??? (%d)\n", val);
12808 break;
12809 }
12810 return p;
12811
3cbd1c06 12812 case Tag_ABI_compatibility:
071436c6 12813 {
071436c6
NC		 12814 val = read_uleb128 (p, &len, end);
12815 p += len;
12816 printf (" Tag_ABI_compatibility: ");
071436c6 12817 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12818 if (p < end - 1)
12819 {
12820 size_t maxlen = (end - p) - 1;
12821
12822 print_symbol ((int) maxlen, (const char *) p);
12823 p += strnlen ((char *) p, maxlen) + 1;
12824 }
12825 else
12826 {
12827 printf (_("<corrupt>"));
12828 p = (unsigned char *) end;
12829 }
071436c6 12830 putchar ('\n');
071436c6
NC		 12831 return p;
12832 }
87779176
JM		 12833
12834 case Tag_ABI_conformance:
071436c6 12835 {
4082ef84
NC		 12836 printf (" Tag_ABI_conformance: \"");
12837 if (p < end - 1)
12838 {
12839 size_t maxlen = (end - p) - 1;
071436c6 12840
4082ef84
NC		 12841 print_symbol ((int) maxlen, (const char *) p);
12842 p += strnlen ((char *) p, maxlen) + 1;
12843 }
12844 else
12845 {
12846 printf (_("<corrupt>"));
12847 p = (unsigned char *) end;
12848 }
071436c6 12849 printf ("\"\n");
071436c6
NC		 12850 return p;
12851 }
59e6276b
JM		 12852 }
12853
f6f0e17b
NC		 12854 return display_tag_value (tag, p, end);
12855}
59e6276b 12856
f6f0e17b
NC		 12857static void
12858display_raw_attribute (unsigned char * p, unsigned char * end)
12859{
12860 unsigned long addr = 0;
12861 size_t bytes = end - p;
12862
e0a31db1 12863 assert (end > p);
f6f0e17b 12864 while (bytes)
87779176 12865 {
f6f0e17b
NC		 12866 int j;
12867 int k;
12868 int lbytes = (bytes > 16 ? 16 : bytes);
12869
12870 printf (" 0x%8.8lx ", addr);
12871
12872 for (j = 0; j < 16; j++)
12873 {
12874 if (j < lbytes)
12875 printf ("%2.2x", p[j]);
12876 else
12877 printf (" ");
12878
12879 if ((j & 3) == 3)
12880 printf (" ");
12881 }
12882
12883 for (j = 0; j < lbytes; j++)
12884 {
12885 k = p[j];
12886 if (k >= ' ' && k < 0x7f)
12887 printf ("%c", k);
12888 else
12889 printf (".");
12890 }
12891
12892 putchar ('\n');
12893
12894 p += lbytes;
12895 bytes -= lbytes;
12896 addr += lbytes;
87779176 12897 }
59e6276b 12898
f6f0e17b 12899 putchar ('\n');
59e6276b
JM		 12900}
12901
13761a11
NC		 12902static unsigned char *
12903display_msp430x_attribute (unsigned char * p,
12904 const unsigned char * const end)
12905{
12906 unsigned int len;
12907 int val;
12908 int tag;
12909
12910 tag = read_uleb128 (p, & len, end);
12911 p += len;
0b4362b0 12912
13761a11
NC		 12913 switch (tag)
12914 {
12915 case OFBA_MSPABI_Tag_ISA:
12916 val = read_uleb128 (p, &len, end);
12917 p += len;
12918 printf (" Tag_ISA: ");
12919 switch (val)
12920 {
12921 case 0: printf (_("None\n")); break;
12922 case 1: printf (_("MSP430\n")); break;
12923 case 2: printf (_("MSP430X\n")); break;
12924 default: printf ("??? (%d)\n", val); break;
12925 }
12926 break;
12927
12928 case OFBA_MSPABI_Tag_Code_Model:
12929 val = read_uleb128 (p, &len, end);
12930 p += len;
12931 printf (" Tag_Code_Model: ");
12932 switch (val)
12933 {
12934 case 0: printf (_("None\n")); break;
12935 case 1: printf (_("Small\n")); break;
12936 case 2: printf (_("Large\n")); break;
12937 default: printf ("??? (%d)\n", val); break;
12938 }
12939 break;
12940
12941 case OFBA_MSPABI_Tag_Data_Model:
12942 val = read_uleb128 (p, &len, end);
12943 p += len;
12944 printf (" Tag_Data_Model: ");
12945 switch (val)
12946 {
12947 case 0: printf (_("None\n")); break;
12948 case 1: printf (_("Small\n")); break;
12949 case 2: printf (_("Large\n")); break;
12950 case 3: printf (_("Restricted Large\n")); break;
12951 default: printf ("??? (%d)\n", val); break;
12952 }
12953 break;
12954
12955 default:
12956 printf (_(" <unknown tag %d>: "), tag);
12957
12958 if (tag & 1)
12959 {
071436c6 12960 putchar ('"');
4082ef84
NC		 12961 if (p < end - 1)
12962 {
12963 size_t maxlen = (end - p) - 1;
12964
12965 print_symbol ((int) maxlen, (const char *) p);
12966 p += strnlen ((char *) p, maxlen) + 1;
12967 }
12968 else
12969 {
12970 printf (_("<corrupt>"));
12971 p = (unsigned char *) end;
12972 }
071436c6 12973 printf ("\"\n");
13761a11
NC		 12974 }
12975 else
12976 {
12977 val = read_uleb128 (p, &len, end);
12978 p += len;
12979 printf ("%d (0x%x)\n", val, val);
12980 }
12981 break;
12982 }
12983
4082ef84 12984 assert (p <= end);
13761a11
NC		 12985 return p;
12986}
12987
11c1ff18 12988static int
60bca95a
NC		 12989process_attributes (FILE * file,
12990 const char * public_name,
104d59d1 12991 unsigned int proc_type,
f6f0e17b
NC		 12992 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12993 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 12994{
2cf0635d 12995 Elf_Internal_Shdr * sect;
11c1ff18
PB		 12996 unsigned i;
12997
12998 /* Find the section header so that we get the size. */
12999 for (i = 0, sect = section_headers;
13000 i < elf_header.e_shnum;
13001 i++, sect++)
13002 {
071436c6
NC		 13003 unsigned char * contents;
13004 unsigned char * p;
13005
104d59d1 13006 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13007 continue;
13008
3f5e193b
NC		 13009 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13010 sect->sh_size, _("attributes"));
60bca95a 13011 if (contents == NULL)
11c1ff18 13012 continue;
60bca95a 13013
11c1ff18
PB		 13014 p = contents;
13015 if (*p == 'A')
13016 {
071436c6
NC		 13017 bfd_vma section_len;
13018
13019 section_len = sect->sh_size - 1;
11c1ff18 13020 p++;
60bca95a 13021
071436c6 13022 while (section_len > 0)
11c1ff18 13023 {
071436c6 13024 bfd_vma attr_len;
e9847026 13025 unsigned int namelen;
11c1ff18 13026 bfd_boolean public_section;
104d59d1 13027 bfd_boolean gnu_section;
11c1ff18 13028
071436c6 13029 if (section_len <= 4)
e0a31db1
NC		 13030 {
13031 error (_("Tag section ends prematurely\n"));
13032 break;
13033 }
071436c6 13034 attr_len = byte_get (p, 4);
11c1ff18 13035 p += 4;
60bca95a 13036
071436c6 13037 if (attr_len > section_len)
11c1ff18 13038 {
071436c6
NC		 13039 error (_("Bad attribute length (%u > %u)\n"),
13040 (unsigned) attr_len, (unsigned) section_len);
13041 attr_len = section_len;
11c1ff18 13042 }
74e1a04b 13043 /* PR 17531: file: 001-101425-0.004 */
071436c6 13044 else if (attr_len < 5)
74e1a04b 13045 {
071436c6 13046 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13047 break;
13048 }
e9847026 13049
071436c6
NC		 13050 section_len -= attr_len;
13051 attr_len -= 4;
13052
13053 namelen = strnlen ((char *) p, attr_len) + 1;
13054 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13055 {
13056 error (_("Corrupt attribute section name\n"));
13057 break;
13058 }
13059
071436c6
NC		 13060 printf (_("Attribute Section: "));
13061 print_symbol (INT_MAX, (const char *) p);
13062 putchar ('\n');
60bca95a
NC		 13063
13064 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13065 public_section = TRUE;
13066 else
13067 public_section = FALSE;
60bca95a
NC		 13068
13069 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13070 gnu_section = TRUE;
13071 else
13072 gnu_section = FALSE;
60bca95a 13073
11c1ff18 13074 p += namelen;
071436c6 13075 attr_len -= namelen;
e0a31db1 13076
071436c6 13077 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13078 {
e0a31db1 13079 int tag;
11c1ff18
PB		 13080 int val;
13081 bfd_vma size;
071436c6 13082 unsigned char * end;
60bca95a 13083
e0a31db1 13084 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13085 if (attr_len < 6)
e0a31db1
NC		 13086 {
13087 error (_("Unused bytes at end of section\n"));
13088 section_len = 0;
13089 break;
13090 }
13091
13092 tag = *(p++);
11c1ff18 13093 size = byte_get (p, 4);
071436c6 13094 if (size > attr_len)
11c1ff18 13095 {
e9847026 13096 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13097 (unsigned) size, (unsigned) attr_len);
13098 size = attr_len;
11c1ff18 13099 }
e0a31db1
NC		 13100 /* PR binutils/17531: Safe handling of corrupt files. */
13101 if (size < 6)
13102 {
13103 error (_("Bad subsection length (%u < 6)\n"),
13104 (unsigned) size);
13105 section_len = 0;
13106 break;
13107 }
60bca95a 13108
071436c6 13109 attr_len -= size;
11c1ff18 13110 end = p + size - 1;
071436c6 13111 assert (end <= contents + sect->sh_size);
11c1ff18 13112 p += 4;
60bca95a 13113
11c1ff18
PB		 13114 switch (tag)
13115 {
13116 case 1:
2b692964 13117 printf (_("File Attributes\n"));
11c1ff18
PB		 13118 break;
13119 case 2:
2b692964 13120 printf (_("Section Attributes:"));
11c1ff18
PB		 13121 goto do_numlist;
13122 case 3:
2b692964 13123 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13124 do_numlist:
13125 for (;;)
13126 {
91d6fa6a 13127 unsigned int j;
60bca95a 13128
f6f0e17b 13129 val = read_uleb128 (p, &j, end);
91d6fa6a 13130 p += j;
11c1ff18
PB		 13131 if (val == 0)
13132 break;
13133 printf (" %d", val);
13134 }
13135 printf ("\n");
13136 break;
13137 default:
2b692964 13138 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13139 public_section = FALSE;
13140 break;
13141 }
60bca95a 13142
071436c6 13143 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13144 {
13145 while (p < end)
f6f0e17b 13146 p = display_pub_attribute (p, end);
071436c6 13147 assert (p <= end);
104d59d1 13148 }
071436c6 13149 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13150 {
13151 while (p < end)
13152 p = display_gnu_attribute (p,
f6f0e17b
NC		 13153 display_proc_gnu_attribute,
13154 end);
071436c6 13155 assert (p <= end);
11c1ff18 13156 }
071436c6 13157 else if (p < end)
11c1ff18 13158 {
071436c6 13159 printf (_(" Unknown attribute:\n"));
f6f0e17b 13160 display_raw_attribute (p, end);
11c1ff18
PB		 13161 p = end;
13162 }
071436c6
NC		 13163 else
13164 attr_len = 0;
11c1ff18
PB		 13165 }
13166 }
13167 }
13168 else
e9847026 13169 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13170
60bca95a 13171 free (contents);
11c1ff18
PB		 13172 }
13173 return 1;
13174}
13175
104d59d1 13176static int
2cf0635d 13177process_arm_specific (FILE * file)
104d59d1
JM		 13178{
13179 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13180 display_arm_attribute, NULL);
13181}
13182
34c8bcba 13183static int
2cf0635d 13184process_power_specific (FILE * file)
34c8bcba
JM		 13185{
13186 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13187 display_power_gnu_attribute);
13188}
13189
9e8c70f9
DM		 13190static int
13191process_sparc_specific (FILE * file)
13192{
13193 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13194 display_sparc_gnu_attribute);
13195}
13196
59e6276b
JM		 13197static int
13198process_tic6x_specific (FILE * file)
13199{
13200 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13201 display_tic6x_attribute, NULL);
13202}
13203
13761a11
NC		 13204static int
13205process_msp430x_specific (FILE * file)
13206{
13207 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13208 display_msp430x_attribute, NULL);
13209}
13210
ccb4c951
RS		 13211/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13212 Print the Address, Access and Initial fields of an entry at VMA ADDR
13213 and return the VMA of the next entry. */
13214
13215static bfd_vma
2cf0635d 13216print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 13217{
13218 printf (" ");
13219 print_vma (addr, LONG_HEX);
13220 printf (" ");
13221 if (addr < pltgot + 0xfff0)
13222 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13223 else
13224 printf ("%10s", "");
13225 printf (" ");
13226 if (data == NULL)
2b692964 13227 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13228 else
13229 {
13230 bfd_vma entry;
13231
13232 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13233 print_vma (entry, LONG_HEX);
13234 }
13235 return addr + (is_32bit_elf ? 4 : 8);
13236}
13237
861fb55a
DJ		 13238/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13239 PLTGOT. Print the Address and Initial fields of an entry at VMA
13240 ADDR and return the VMA of the next entry. */
13241
13242static bfd_vma
2cf0635d 13243print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13244{
13245 printf (" ");
13246 print_vma (addr, LONG_HEX);
13247 printf (" ");
13248 if (data == NULL)
2b692964 13249 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13250 else
13251 {
13252 bfd_vma entry;
13253
13254 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13255 print_vma (entry, LONG_HEX);
13256 }
13257 return addr + (is_32bit_elf ? 4 : 8);
13258}
13259
351cdf24
MF		 13260static void
13261print_mips_ases (unsigned int mask)
13262{
13263 if (mask & AFL_ASE_DSP)
13264 fputs ("\n\tDSP ASE", stdout);
13265 if (mask & AFL_ASE_DSPR2)
13266 fputs ("\n\tDSP R2 ASE", stdout);
13267 if (mask & AFL_ASE_EVA)
13268 fputs ("\n\tEnhanced VA Scheme", stdout);
13269 if (mask & AFL_ASE_MCU)
13270 fputs ("\n\tMCU (MicroController) ASE", stdout);
13271 if (mask & AFL_ASE_MDMX)
13272 fputs ("\n\tMDMX ASE", stdout);
13273 if (mask & AFL_ASE_MIPS3D)
13274 fputs ("\n\tMIPS-3D ASE", stdout);
13275 if (mask & AFL_ASE_MT)
13276 fputs ("\n\tMT ASE", stdout);
13277 if (mask & AFL_ASE_SMARTMIPS)
13278 fputs ("\n\tSmartMIPS ASE", stdout);
13279 if (mask & AFL_ASE_VIRT)
13280 fputs ("\n\tVZ ASE", stdout);
13281 if (mask & AFL_ASE_MSA)
13282 fputs ("\n\tMSA ASE", stdout);
13283 if (mask & AFL_ASE_MIPS16)
13284 fputs ("\n\tMIPS16 ASE", stdout);
13285 if (mask & AFL_ASE_MICROMIPS)
13286 fputs ("\n\tMICROMIPS ASE", stdout);
13287 if (mask & AFL_ASE_XPA)
13288 fputs ("\n\tXPA ASE", stdout);
13289 if (mask == 0)
13290 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13291 else if ((mask & ~AFL_ASE_MASK) != 0)
13292 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13293}
13294
13295static void
13296print_mips_isa_ext (unsigned int isa_ext)
13297{
13298 switch (isa_ext)
13299 {
13300 case 0:
13301 fputs (_("None"), stdout);
13302 break;
13303 case AFL_EXT_XLR:
13304 fputs ("RMI XLR", stdout);
13305 break;
2c629856
N		 13306 case AFL_EXT_OCTEON3:
13307 fputs ("Cavium Networks Octeon3", stdout);
13308 break;
351cdf24
MF		 13309 case AFL_EXT_OCTEON2:
13310 fputs ("Cavium Networks Octeon2", stdout);
13311 break;
13312 case AFL_EXT_OCTEONP:
13313 fputs ("Cavium Networks OcteonP", stdout);
13314 break;
13315 case AFL_EXT_LOONGSON_3A:
13316 fputs ("Loongson 3A", stdout);
13317 break;
13318 case AFL_EXT_OCTEON:
13319 fputs ("Cavium Networks Octeon", stdout);
13320 break;
13321 case AFL_EXT_5900:
13322 fputs ("Toshiba R5900", stdout);
13323 break;
13324 case AFL_EXT_4650:
13325 fputs ("MIPS R4650", stdout);
13326 break;
13327 case AFL_EXT_4010:
13328 fputs ("LSI R4010", stdout);
13329 break;
13330 case AFL_EXT_4100:
13331 fputs ("NEC VR4100", stdout);
13332 break;
13333 case AFL_EXT_3900:
13334 fputs ("Toshiba R3900", stdout);
13335 break;
13336 case AFL_EXT_10000:
13337 fputs ("MIPS R10000", stdout);
13338 break;
13339 case AFL_EXT_SB1:
13340 fputs ("Broadcom SB-1", stdout);
13341 break;
13342 case AFL_EXT_4111:
13343 fputs ("NEC VR4111/VR4181", stdout);
13344 break;
13345 case AFL_EXT_4120:
13346 fputs ("NEC VR4120", stdout);
13347 break;
13348 case AFL_EXT_5400:
13349 fputs ("NEC VR5400", stdout);
13350 break;
13351 case AFL_EXT_5500:
13352 fputs ("NEC VR5500", stdout);
13353 break;
13354 case AFL_EXT_LOONGSON_2E:
13355 fputs ("ST Microelectronics Loongson 2E", stdout);
13356 break;
13357 case AFL_EXT_LOONGSON_2F:
13358 fputs ("ST Microelectronics Loongson 2F", stdout);
13359 break;
13360 default:
00ac7aa0 13361 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13362 }
13363}
13364
13365static int
13366get_mips_reg_size (int reg_size)
13367{
13368 return (reg_size == AFL_REG_NONE) ? 0
13369 : (reg_size == AFL_REG_32) ? 32
13370 : (reg_size == AFL_REG_64) ? 64
13371 : (reg_size == AFL_REG_128) ? 128
13372 : -1;
13373}
13374
19e6b90e 13375static int
2cf0635d 13376process_mips_specific (FILE * file)
5b18a4bc 13377{
2cf0635d 13378 Elf_Internal_Dyn * entry;
351cdf24 13379 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13380 size_t liblist_offset = 0;
13381 size_t liblistno = 0;
13382 size_t conflictsno = 0;
13383 size_t options_offset = 0;
13384 size_t conflicts_offset = 0;
861fb55a
DJ		 13385 size_t pltrelsz = 0;
13386 size_t pltrel = 0;
ccb4c951 13387 bfd_vma pltgot = 0;
861fb55a
DJ		 13388 bfd_vma mips_pltgot = 0;
13389 bfd_vma jmprel = 0;
ccb4c951
RS		 13390 bfd_vma local_gotno = 0;
13391 bfd_vma gotsym = 0;
13392 bfd_vma symtabno = 0;
103f02d3 13393
2cf19d5c
JM		 13394 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13395 display_mips_gnu_attribute);
13396
351cdf24
MF		 13397 sect = find_section (".MIPS.abiflags");
13398
13399 if (sect != NULL)
13400 {
13401 Elf_External_ABIFlags_v0 *abiflags_ext;
13402 Elf_Internal_ABIFlags_v0 abiflags_in;
13403
13404 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13405 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13406 else
13407 {
13408 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13409 sect->sh_size, _("MIPS ABI Flags section"));
13410 if (abiflags_ext)
13411 {
13412 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13413 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13414 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13415 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13416 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13417 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13418 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13419 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13420 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13421 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13422 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13423
13424 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13425 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13426 if (abiflags_in.isa_rev > 1)
13427 printf ("r%d", abiflags_in.isa_rev);
13428 printf ("\nGPR size: %d",
13429 get_mips_reg_size (abiflags_in.gpr_size));
13430 printf ("\nCPR1 size: %d",
13431 get_mips_reg_size (abiflags_in.cpr1_size));
13432 printf ("\nCPR2 size: %d",
13433 get_mips_reg_size (abiflags_in.cpr2_size));
13434 fputs ("\nFP ABI: ", stdout);
13435 print_mips_fp_abi_value (abiflags_in.fp_abi);
13436 fputs ("ISA Extension: ", stdout);
13437 print_mips_isa_ext (abiflags_in.isa_ext);
13438 fputs ("\nASEs:", stdout);
13439 print_mips_ases (abiflags_in.ases);
13440 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13441 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13442 fputc ('\n', stdout);
13443 free (abiflags_ext);
13444 }
13445 }
13446 }
13447
19e6b90e
L		 13448 /* We have a lot of special sections. Thanks SGI! */
13449 if (dynamic_section == NULL)
13450 /* No information available. */
13451 return 0;
252b5132 13452
071436c6
NC		 13453 for (entry = dynamic_section;
13454 /* PR 17531 file: 012-50589-0.004. */
13455 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13456 ++entry)
252b5132
RH		 13457 switch (entry->d_tag)
13458 {
13459 case DT_MIPS_LIBLIST:
d93f0186
NC		 13460 liblist_offset
13461 = offset_from_vma (file, entry->d_un.d_val,
13462 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13463 break;
13464 case DT_MIPS_LIBLISTNO:
13465 liblistno = entry->d_un.d_val;
13466 break;
13467 case DT_MIPS_OPTIONS:
d93f0186 13468 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13469 break;
13470 case DT_MIPS_CONFLICT:
d93f0186
NC		 13471 conflicts_offset
13472 = offset_from_vma (file, entry->d_un.d_val,
13473 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13474 break;
13475 case DT_MIPS_CONFLICTNO:
13476 conflictsno = entry->d_un.d_val;
13477 break;
ccb4c951 13478 case DT_PLTGOT:
861fb55a
DJ		 13479 pltgot = entry->d_un.d_ptr;
13480 break;
ccb4c951
RS		 13481 case DT_MIPS_LOCAL_GOTNO:
13482 local_gotno = entry->d_un.d_val;
13483 break;
13484 case DT_MIPS_GOTSYM:
13485 gotsym = entry->d_un.d_val;
13486 break;
13487 case DT_MIPS_SYMTABNO:
13488 symtabno = entry->d_un.d_val;
13489 break;
861fb55a
DJ		 13490 case DT_MIPS_PLTGOT:
13491 mips_pltgot = entry->d_un.d_ptr;
13492 break;
13493 case DT_PLTREL:
13494 pltrel = entry->d_un.d_val;
13495 break;
13496 case DT_PLTRELSZ:
13497 pltrelsz = entry->d_un.d_val;
13498 break;
13499 case DT_JMPREL:
13500 jmprel = entry->d_un.d_ptr;
13501 break;
252b5132
RH		 13502 default:
13503 break;
13504 }
13505
13506 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13507 {
2cf0635d 13508 Elf32_External_Lib * elib;
252b5132
RH		 13509 size_t cnt;
13510
3f5e193b
NC		 13511 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13512 liblistno,
13513 sizeof (Elf32_External_Lib),
9cf03b7e 13514 _("liblist section data"));
a6e9f9df 13515 if (elib)
252b5132 13516 {
2b692964 13517 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13518 (unsigned long) liblistno);
2b692964 13519 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13520 stdout);
13521
13522 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13523 {
a6e9f9df 13524 Elf32_Lib liblist;
91d6fa6a 13525 time_t atime;
a6e9f9df 13526 char timebuf[20];
2cf0635d 13527 struct tm * tmp;
a6e9f9df
AM		 13528
13529 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13530 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13531 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13532 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13533 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13534
91d6fa6a 13535 tmp = gmtime (&atime);
e9e44622
JJ		 13536 snprintf (timebuf, sizeof (timebuf),
13537 "%04u-%02u-%02uT%02u:%02u:%02u",
13538 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13539 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13540
31104126 13541 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13542 if (VALID_DYNAMIC_NAME (liblist.l_name))
13543 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13544 else
2b692964 13545 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13546 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13547 liblist.l_version);
a6e9f9df
AM		 13548
13549 if (liblist.l_flags == 0)
2b692964 13550 puts (_(" NONE"));
a6e9f9df
AM		 13551 else
13552 {
13553 static const struct
252b5132 13554 {
2cf0635d 13555 const char * name;
a6e9f9df 13556 int bit;
252b5132 13557 }
a6e9f9df
AM		 13558 l_flags_vals[] =
13559 {
13560 { " EXACT_MATCH", LL_EXACT_MATCH },
13561 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13562 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13563 { " EXPORTS", LL_EXPORTS },
13564 { " DELAY_LOAD", LL_DELAY_LOAD },
13565 { " DELTA", LL_DELTA }
13566 };
13567 int flags = liblist.l_flags;
13568 size_t fcnt;
13569
60bca95a 13570 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13571 if ((flags & l_flags_vals[fcnt].bit) != 0)
13572 {
13573 fputs (l_flags_vals[fcnt].name, stdout);
13574 flags ^= l_flags_vals[fcnt].bit;
13575 }
13576 if (flags != 0)
13577 printf (" %#x", (unsigned int) flags);
252b5132 13578
a6e9f9df
AM		 13579 puts ("");
13580 }
252b5132 13581 }
252b5132 13582
a6e9f9df
AM		 13583 free (elib);
13584 }
252b5132
RH		 13585 }
13586
13587 if (options_offset != 0)
13588 {
2cf0635d 13589 Elf_External_Options * eopt;
2cf0635d
NC		 13590 Elf_Internal_Options * iopt;
13591 Elf_Internal_Options * option;
252b5132
RH		 13592 size_t offset;
13593 int cnt;
351cdf24 13594 sect = section_headers;
252b5132
RH		 13595
13596 /* Find the section header so that we get the size. */
071436c6
NC		 13597 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13598 /* PR 17533 file: 012-277276-0.004. */
13599 if (sect == NULL)
13600 {
13601 error (_("No MIPS_OPTIONS header found\n"));
13602 return 0;
13603 }
252b5132 13604
3f5e193b
NC		 13605 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13606 sect->sh_size, _("options"));
a6e9f9df 13607 if (eopt)
252b5132 13608 {
3f5e193b
NC		 13609 iopt = (Elf_Internal_Options *)
13610 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13611 if (iopt == NULL)
13612 {
8b73c356 13613 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 13614 return 0;
13615 }
76da6bbe 13616
a6e9f9df
AM		 13617 offset = cnt = 0;
13618 option = iopt;
252b5132 13619
a6e9f9df
AM		 13620 while (offset < sect->sh_size)
13621 {
2cf0635d 13622 Elf_External_Options * eoption;
252b5132 13623
a6e9f9df 13624 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13625
a6e9f9df
AM		 13626 option->kind = BYTE_GET (eoption->kind);
13627 option->size = BYTE_GET (eoption->size);
13628 option->section = BYTE_GET (eoption->section);
13629 option->info = BYTE_GET (eoption->info);
76da6bbe 13630
a6e9f9df 13631 offset += option->size;
252b5132 13632
a6e9f9df
AM		 13633 ++option;
13634 ++cnt;
13635 }
252b5132 13636
a6e9f9df 13637 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 13638 printable_section_name (sect), cnt);
76da6bbe 13639
a6e9f9df 13640 option = iopt;
252b5132 13641
a6e9f9df 13642 while (cnt-- > 0)
252b5132 13643 {
a6e9f9df
AM		 13644 size_t len;
13645
13646 switch (option->kind)
252b5132 13647 {
a6e9f9df
AM		 13648 case ODK_NULL:
13649 /* This shouldn't happen. */
13650 printf (" NULL %d %lx", option->section, option->info);
13651 break;
13652 case ODK_REGINFO:
13653 printf (" REGINFO ");
13654 if (elf_header.e_machine == EM_MIPS)
13655 {
13656 /* 32bit form. */
2cf0635d 13657 Elf32_External_RegInfo * ereg;
b34976b6 13658 Elf32_RegInfo reginfo;
a6e9f9df
AM		 13659
13660 ereg = (Elf32_External_RegInfo *) (option + 1);
13661 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13662 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13663 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13664 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13665 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13666 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13667
13668 printf ("GPR %08lx GP 0x%lx\n",
13669 reginfo.ri_gprmask,
13670 (unsigned long) reginfo.ri_gp_value);
13671 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13672 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13673 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13674 }
13675 else
13676 {
13677 /* 64 bit form. */
2cf0635d 13678 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 13679 Elf64_Internal_RegInfo reginfo;
13680
13681 ereg = (Elf64_External_RegInfo *) (option + 1);
13682 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13683 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13684 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13685 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13686 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 13687 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 13688
13689 printf ("GPR %08lx GP 0x",
13690 reginfo.ri_gprmask);
13691 printf_vma (reginfo.ri_gp_value);
13692 printf ("\n");
13693
13694 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13695 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13696 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13697 }
13698 ++option;
13699 continue;
13700 case ODK_EXCEPTIONS:
13701 fputs (" EXCEPTIONS fpe_min(", stdout);
13702 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13703 fputs (") fpe_max(", stdout);
13704 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13705 fputs (")", stdout);
13706
13707 if (option->info & OEX_PAGE0)
13708 fputs (" PAGE0", stdout);
13709 if (option->info & OEX_SMM)
13710 fputs (" SMM", stdout);
13711 if (option->info & OEX_FPDBUG)
13712 fputs (" FPDBUG", stdout);
13713 if (option->info & OEX_DISMISS)
13714 fputs (" DISMISS", stdout);
13715 break;
13716 case ODK_PAD:
13717 fputs (" PAD ", stdout);
13718 if (option->info & OPAD_PREFIX)
13719 fputs (" PREFIX", stdout);
13720 if (option->info & OPAD_POSTFIX)
13721 fputs (" POSTFIX", stdout);
13722 if (option->info & OPAD_SYMBOL)
13723 fputs (" SYMBOL", stdout);
13724 break;
13725 case ODK_HWPATCH:
13726 fputs (" HWPATCH ", stdout);
13727 if (option->info & OHW_R4KEOP)
13728 fputs (" R4KEOP", stdout);
13729 if (option->info & OHW_R8KPFETCH)
13730 fputs (" R8KPFETCH", stdout);
13731 if (option->info & OHW_R5KEOP)
13732 fputs (" R5KEOP", stdout);
13733 if (option->info & OHW_R5KCVTL)
13734 fputs (" R5KCVTL", stdout);
13735 break;
13736 case ODK_FILL:
13737 fputs (" FILL ", stdout);
13738 /* XXX Print content of info word? */
13739 break;
13740 case ODK_TAGS:
13741 fputs (" TAGS ", stdout);
13742 /* XXX Print content of info word? */
13743 break;
13744 case ODK_HWAND:
13745 fputs (" HWAND ", stdout);
13746 if (option->info & OHWA0_R4KEOP_CHECKED)
13747 fputs (" R4KEOP_CHECKED", stdout);
13748 if (option->info & OHWA0_R4KEOP_CLEAN)
13749 fputs (" R4KEOP_CLEAN", stdout);
13750 break;
13751 case ODK_HWOR:
13752 fputs (" HWOR ", stdout);
13753 if (option->info & OHWA0_R4KEOP_CHECKED)
13754 fputs (" R4KEOP_CHECKED", stdout);
13755 if (option->info & OHWA0_R4KEOP_CLEAN)
13756 fputs (" R4KEOP_CLEAN", stdout);
13757 break;
13758 case ODK_GP_GROUP:
13759 printf (" GP_GROUP %#06lx self-contained %#06lx",
13760 option->info & OGP_GROUP,
13761 (option->info & OGP_SELF) >> 16);
13762 break;
13763 case ODK_IDENT:
13764 printf (" IDENT %#06lx self-contained %#06lx",
13765 option->info & OGP_GROUP,
13766 (option->info & OGP_SELF) >> 16);
13767 break;
13768 default:
13769 /* This shouldn't happen. */
13770 printf (" %3d ??? %d %lx",
13771 option->kind, option->section, option->info);
13772 break;
252b5132 13773 }
a6e9f9df 13774
2cf0635d 13775 len = sizeof (* eopt);
a6e9f9df
AM		 13776 while (len < option->size)
13777 if (((char *) option)[len] >= ' '
13778 && ((char *) option)[len] < 0x7f)
13779 printf ("%c", ((char *) option)[len++]);
13780 else
13781 printf ("\\%03o", ((char *) option)[len++]);
13782
13783 fputs ("\n", stdout);
252b5132 13784 ++option;
252b5132
RH		 13785 }
13786
a6e9f9df 13787 free (eopt);
252b5132 13788 }
252b5132
RH		 13789 }
13790
13791 if (conflicts_offset != 0 && conflictsno != 0)
13792 {
2cf0635d 13793 Elf32_Conflict * iconf;
252b5132
RH		 13794 size_t cnt;
13795
13796 if (dynamic_symbols == NULL)
13797 {
591a748a 13798 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 13799 return 0;
13800 }
13801
3f5e193b 13802 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 13803 if (iconf == NULL)
13804 {
8b73c356 13805 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 13806 return 0;
13807 }
13808
9ea033b2 13809 if (is_32bit_elf)
252b5132 13810 {
2cf0635d 13811 Elf32_External_Conflict * econf32;
a6e9f9df 13812
3f5e193b
NC		 13813 econf32 = (Elf32_External_Conflict *)
13814 get_data (NULL, file, conflicts_offset, conflictsno,
13815 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 13816 if (!econf32)
13817 return 0;
252b5132
RH		 13818
13819 for (cnt = 0; cnt < conflictsno; ++cnt)
13820 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 13821
13822 free (econf32);
252b5132
RH		 13823 }
13824 else
13825 {
2cf0635d 13826 Elf64_External_Conflict * econf64;
a6e9f9df 13827
3f5e193b
NC		 13828 econf64 = (Elf64_External_Conflict *)
13829 get_data (NULL, file, conflicts_offset, conflictsno,
13830 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 13831 if (!econf64)
13832 return 0;
252b5132
RH		 13833
13834 for (cnt = 0; cnt < conflictsno; ++cnt)
13835 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 13836
13837 free (econf64);
252b5132
RH		 13838 }
13839
c7e7ca54
NC		 13840 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13841 (unsigned long) conflictsno);
252b5132
RH		 13842 puts (_(" Num: Index Value Name"));
13843
13844 for (cnt = 0; cnt < conflictsno; ++cnt)
13845 {
b34976b6 13846 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 13847
13848 if (iconf[cnt] >= num_dynamic_syms)
13849 printf (_("<corrupt symbol index>"));
d79b3d50 13850 else
e0a31db1
NC		 13851 {
13852 Elf_Internal_Sym * psym;
13853
13854 psym = & dynamic_symbols[iconf[cnt]];
13855 print_vma (psym->st_value, FULL_HEX);
13856 putchar (' ');
13857 if (VALID_DYNAMIC_NAME (psym->st_name))
13858 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13859 else
13860 printf (_("<corrupt: %14ld>"), psym->st_name);
13861 }
31104126 13862 putchar ('\n');
252b5132
RH		 13863 }
13864
252b5132
RH		 13865 free (iconf);
13866 }
13867
ccb4c951
RS		 13868 if (pltgot != 0 && local_gotno != 0)
13869 {
91d6fa6a 13870 bfd_vma ent, local_end, global_end;
bbeee7ea 13871 size_t i, offset;
2cf0635d 13872 unsigned char * data;
bbeee7ea 13873 int addr_size;
ccb4c951 13874
91d6fa6a 13875 ent = pltgot;
ccb4c951
RS		 13876 addr_size = (is_32bit_elf ? 4 : 8);
13877 local_end = pltgot + local_gotno * addr_size;
ccb4c951 13878
74e1a04b
NC		 13879 /* PR binutils/17533 file: 012-111227-0.004 */
13880 if (symtabno < gotsym)
13881 {
13882 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13883 (long) gotsym, (long) symtabno);
13884 return 0;
13885 }
13886
13887 global_end = local_end + (symtabno - gotsym) * addr_size;
13888 assert (global_end >= local_end);
ccb4c951 13889 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 13890 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 13891 global_end - pltgot, 1,
13892 _("Global Offset Table data"));
59245841
NC		 13893 if (data == NULL)
13894 return 0;
13895
ccb4c951
RS		 13896 printf (_("\nPrimary GOT:\n"));
13897 printf (_(" Canonical gp value: "));
13898 print_vma (pltgot + 0x7ff0, LONG_HEX);
13899 printf ("\n\n");
13900
13901 printf (_(" Reserved entries:\n"));
13902 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 13903 addr_size * 2, _("Address"), _("Access"),
13904 addr_size * 2, _("Initial"));
91d6fa6a 13905 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13906 printf (_(" Lazy resolver\n"));
ccb4c951 13907 if (data
91d6fa6a 13908 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 13909 >> (addr_size * 8 - 1)) != 0)
13910 {
91d6fa6a 13911 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13912 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 13913 }
13914 printf ("\n");
13915
91d6fa6a 13916 if (ent < local_end)
ccb4c951
RS		 13917 {
13918 printf (_(" Local entries:\n"));
cc5914eb 13919 printf (" %*s %10s %*s\n",
2b692964
NC		 13920 addr_size * 2, _("Address"), _("Access"),
13921 addr_size * 2, _("Initial"));
91d6fa6a 13922 while (ent < local_end)
ccb4c951 13923 {
91d6fa6a 13924 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 13925 printf ("\n");
13926 }
13927 printf ("\n");
13928 }
13929
13930 if (gotsym < symtabno)
13931 {
13932 int sym_width;
13933
13934 printf (_(" Global entries:\n"));
cc5914eb 13935 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 13936 addr_size * 2, _("Address"),
13937 _("Access"),
2b692964 13938 addr_size * 2, _("Initial"),
9cf03b7e
NC		 13939 addr_size * 2, _("Sym.Val."),
13940 _("Type"),
13941 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13942 _("Ndx"), _("Name"));
0b4362b0 13943
ccb4c951 13944 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 13945
ccb4c951
RS		 13946 for (i = gotsym; i < symtabno; i++)
13947 {
91d6fa6a 13948 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951 13949 printf (" ");
e0a31db1
NC		 13950
13951 if (dynamic_symbols == NULL)
13952 printf (_("<no dynamic symbols>"));
13953 else if (i < num_dynamic_syms)
13954 {
13955 Elf_Internal_Sym * psym = dynamic_symbols + i;
13956
13957 print_vma (psym->st_value, LONG_HEX);
13958 printf (" %-7s %3s ",
13959 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13960 get_symbol_index_type (psym->st_shndx));
13961
13962 if (VALID_DYNAMIC_NAME (psym->st_name))
13963 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13964 else
13965 printf (_("<corrupt: %14ld>"), psym->st_name);
13966 }
ccb4c951 13967 else
7fc5ac57
JBG		 13968 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
13969 (unsigned long) i);
e0a31db1 13970
ccb4c951
RS		 13971 printf ("\n");
13972 }
13973 printf ("\n");
13974 }
13975
13976 if (data)
13977 free (data);
13978 }
13979
861fb55a
DJ		 13980 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13981 {
91d6fa6a 13982 bfd_vma ent, end;
861fb55a
DJ		 13983 size_t offset, rel_offset;
13984 unsigned long count, i;
2cf0635d 13985 unsigned char * data;
861fb55a 13986 int addr_size, sym_width;
2cf0635d 13987 Elf_Internal_Rela * rels;
861fb55a
DJ		 13988
13989 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13990 if (pltrel == DT_RELA)
13991 {
13992 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13993 return 0;
13994 }
13995 else
13996 {
13997 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13998 return 0;
13999 }
14000
91d6fa6a 14001 ent = mips_pltgot;
861fb55a
DJ		 14002 addr_size = (is_32bit_elf ? 4 : 8);
14003 end = mips_pltgot + (2 + count) * addr_size;
14004
14005 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14006 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14007 1, _("Procedure Linkage Table data"));
59245841
NC		 14008 if (data == NULL)
14009 return 0;
14010
9cf03b7e 14011 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14012 printf (_(" Reserved entries:\n"));
14013 printf (_(" %*s %*s Purpose\n"),
2b692964 14014 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14015 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14016 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14017 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14018 printf (_(" Module pointer\n"));
861fb55a
DJ		 14019 printf ("\n");
14020
14021 printf (_(" Entries:\n"));
cc5914eb 14022 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14023 addr_size * 2, _("Address"),
14024 addr_size * 2, _("Initial"),
14025 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14026 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14027 for (i = 0; i < count; i++)
14028 {
df97ab2a 14029 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14030
91d6fa6a 14031 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14032 printf (" ");
e0a31db1 14033
df97ab2a
MF		 14034 if (idx >= num_dynamic_syms)
14035 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14036 else
e0a31db1 14037 {
df97ab2a 14038 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14039
14040 print_vma (psym->st_value, LONG_HEX);
14041 printf (" %-7s %3s ",
14042 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14043 get_symbol_index_type (psym->st_shndx));
14044 if (VALID_DYNAMIC_NAME (psym->st_name))
14045 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14046 else
14047 printf (_("<corrupt: %14ld>"), psym->st_name);
14048 }
861fb55a
DJ		 14049 printf ("\n");
14050 }
14051 printf ("\n");
14052
14053 if (data)
14054 free (data);
14055 free (rels);
14056 }
14057
252b5132
RH		 14058 return 1;
14059}
14060
35c08157
KLC		 14061static int
14062process_nds32_specific (FILE * file)
14063{
14064 Elf_Internal_Shdr *sect = NULL;
14065
14066 sect = find_section (".nds32_e_flags");
14067 if (sect != NULL)
14068 {
14069 unsigned int *flag;
14070
14071 printf ("\nNDS32 elf flags section:\n");
14072 flag = get_data (NULL, file, sect->sh_offset, 1,
14073 sect->sh_size, _("NDS32 elf flags section"));
14074
14075 switch ((*flag) & 0x3)
14076 {
14077 case 0:
14078 printf ("(VEC_SIZE):\tNo entry.\n");
14079 break;
14080 case 1:
14081 printf ("(VEC_SIZE):\t4 bytes\n");
14082 break;
14083 case 2:
14084 printf ("(VEC_SIZE):\t16 bytes\n");
14085 break;
14086 case 3:
14087 printf ("(VEC_SIZE):\treserved\n");
14088 break;
14089 }
14090 }
14091
14092 return TRUE;
14093}
14094
047b2264 14095static int
2cf0635d 14096process_gnu_liblist (FILE * file)
047b2264 14097{
2cf0635d
NC		 14098 Elf_Internal_Shdr * section;
14099 Elf_Internal_Shdr * string_sec;
14100 Elf32_External_Lib * elib;
14101 char * strtab;
c256ffe7 14102 size_t strtab_size;
047b2264
JJ		 14103 size_t cnt;
14104 unsigned i;
14105
14106 if (! do_arch)
14107 return 0;
14108
14109 for (i = 0, section = section_headers;
14110 i < elf_header.e_shnum;
b34976b6 14111 i++, section++)
047b2264
JJ		 14112 {
14113 switch (section->sh_type)
14114 {
14115 case SHT_GNU_LIBLIST:
4fbb74a6 14116 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14117 break;
14118
3f5e193b
NC		 14119 elib = (Elf32_External_Lib *)
14120 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14121 _("liblist section data"));
047b2264
JJ		 14122
14123 if (elib == NULL)
14124 break;
4fbb74a6 14125 string_sec = section_headers + section->sh_link;
047b2264 14126
3f5e193b
NC		 14127 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14128 string_sec->sh_size,
14129 _("liblist string table"));
047b2264
JJ		 14130 if (strtab == NULL
14131 || section->sh_entsize != sizeof (Elf32_External_Lib))
14132 {
14133 free (elib);
2842702f 14134 free (strtab);
047b2264
JJ		 14135 break;
14136 }
59245841 14137 strtab_size = string_sec->sh_size;
047b2264
JJ		 14138
14139 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14140 printable_section_name (section),
0af1713e 14141 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14142
2b692964 14143 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14144
14145 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14146 ++cnt)
14147 {
14148 Elf32_Lib liblist;
91d6fa6a 14149 time_t atime;
047b2264 14150 char timebuf[20];
2cf0635d 14151 struct tm * tmp;
047b2264
JJ		 14152
14153 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14154 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14155 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14156 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14157 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14158
91d6fa6a 14159 tmp = gmtime (&atime);
e9e44622
JJ		 14160 snprintf (timebuf, sizeof (timebuf),
14161 "%04u-%02u-%02uT%02u:%02u:%02u",
14162 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14163 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14164
14165 printf ("%3lu: ", (unsigned long) cnt);
14166 if (do_wide)
c256ffe7 14167 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14168 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14169 else
c256ffe7 14170 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14171 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14172 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14173 liblist.l_version, liblist.l_flags);
14174 }
14175
14176 free (elib);
2842702f 14177 free (strtab);
047b2264
JJ		 14178 }
14179 }
14180
14181 return 1;
14182}
14183
9437c45b 14184static const char *
d3ba0551 14185get_note_type (unsigned e_type)
779fe533
NC		 14186{
14187 static char buff[64];
103f02d3 14188
1ec5cd37
NC		 14189 if (elf_header.e_type == ET_CORE)
14190 switch (e_type)
14191 {
57346661 14192 case NT_AUXV:
1ec5cd37 14193 return _("NT_AUXV (auxiliary vector)");
57346661 14194 case NT_PRSTATUS:
1ec5cd37 14195 return _("NT_PRSTATUS (prstatus structure)");
57346661 14196 case NT_FPREGSET:
1ec5cd37 14197 return _("NT_FPREGSET (floating point registers)");
57346661 14198 case NT_PRPSINFO:
1ec5cd37 14199 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14200 case NT_TASKSTRUCT:
1ec5cd37 14201 return _("NT_TASKSTRUCT (task structure)");
57346661 14202 case NT_PRXFPREG:
1ec5cd37 14203 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14204 case NT_PPC_VMX:
14205 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14206 case NT_PPC_VSX:
14207 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14208 case NT_386_TLS:
14209 return _("NT_386_TLS (x86 TLS information)");
14210 case NT_386_IOPERM:
14211 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14212 case NT_X86_XSTATE:
14213 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14214 case NT_S390_HIGH_GPRS:
14215 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14216 case NT_S390_TIMER:
14217 return _("NT_S390_TIMER (s390 timer register)");
14218 case NT_S390_TODCMP:
14219 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14220 case NT_S390_TODPREG:
14221 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14222 case NT_S390_CTRS:
14223 return _("NT_S390_CTRS (s390 control registers)");
14224 case NT_S390_PREFIX:
14225 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14226 case NT_S390_LAST_BREAK:
14227 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14228 case NT_S390_SYSTEM_CALL:
14229 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14230 case NT_S390_TDB:
14231 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW		 14232 case NT_ARM_VFP:
14233 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14234 case NT_ARM_TLS:
14235 return _("NT_ARM_TLS (AArch TLS registers)");
14236 case NT_ARM_HW_BREAK:
14237 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14238 case NT_ARM_HW_WATCH:
14239 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14240 case NT_PSTATUS:
1ec5cd37 14241 return _("NT_PSTATUS (pstatus structure)");
57346661 14242 case NT_FPREGS:
1ec5cd37 14243 return _("NT_FPREGS (floating point registers)");
57346661 14244 case NT_PSINFO:
1ec5cd37 14245 return _("NT_PSINFO (psinfo structure)");
57346661 14246 case NT_LWPSTATUS:
1ec5cd37 14247 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14248 case NT_LWPSINFO:
1ec5cd37 14249 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14250 case NT_WIN32PSTATUS:
1ec5cd37 14251 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14252 case NT_SIGINFO:
14253 return _("NT_SIGINFO (siginfo_t data)");
14254 case NT_FILE:
14255 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14256 default:
14257 break;
14258 }
14259 else
14260 switch (e_type)
14261 {
14262 case NT_VERSION:
14263 return _("NT_VERSION (version)");
14264 case NT_ARCH:
14265 return _("NT_ARCH (architecture)");
14266 default:
14267 break;
14268 }
14269
e9e44622 14270 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14271 return buff;
779fe533
NC		 14272}
14273
9ece1fa9
TT		 14274static int
14275print_core_note (Elf_Internal_Note *pnote)
14276{
14277 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14278 bfd_vma count, page_size;
14279 unsigned char *descdata, *filenames, *descend;
14280
14281 if (pnote->type != NT_FILE)
14282 return 1;
14283
14284#ifndef BFD64
14285 if (!is_32bit_elf)
14286 {
14287 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14288 /* Still "successful". */
14289 return 1;
14290 }
14291#endif
14292
14293 if (pnote->descsz < 2 * addr_size)
14294 {
14295 printf (_(" Malformed note - too short for header\n"));
14296 return 0;
14297 }
14298
14299 descdata = (unsigned char *) pnote->descdata;
14300 descend = descdata + pnote->descsz;
14301
14302 if (descdata[pnote->descsz - 1] != '\0')
14303 {
14304 printf (_(" Malformed note - does not end with \\0\n"));
14305 return 0;
14306 }
14307
14308 count = byte_get (descdata, addr_size);
14309 descdata += addr_size;
14310
14311 page_size = byte_get (descdata, addr_size);
14312 descdata += addr_size;
14313
14314 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14315 {
14316 printf (_(" Malformed note - too short for supplied file count\n"));
14317 return 0;
14318 }
14319
14320 printf (_(" Page size: "));
14321 print_vma (page_size, DEC);
14322 printf ("\n");
14323
14324 printf (_(" %*s%*s%*s\n"),
14325 (int) (2 + 2 * addr_size), _("Start"),
14326 (int) (4 + 2 * addr_size), _("End"),
14327 (int) (4 + 2 * addr_size), _("Page Offset"));
14328 filenames = descdata + count * 3 * addr_size;
14329 while (--count > 0)
14330 {
14331 bfd_vma start, end, file_ofs;
14332
14333 if (filenames == descend)
14334 {
14335 printf (_(" Malformed note - filenames end too early\n"));
14336 return 0;
14337 }
14338
14339 start = byte_get (descdata, addr_size);
14340 descdata += addr_size;
14341 end = byte_get (descdata, addr_size);
14342 descdata += addr_size;
14343 file_ofs = byte_get (descdata, addr_size);
14344 descdata += addr_size;
14345
14346 printf (" ");
14347 print_vma (start, FULL_HEX);
14348 printf (" ");
14349 print_vma (end, FULL_HEX);
14350 printf (" ");
14351 print_vma (file_ofs, FULL_HEX);
14352 printf ("\n %s\n", filenames);
14353
14354 filenames += 1 + strlen ((char *) filenames);
14355 }
14356
14357 return 1;
14358}
14359
1118d252
RM		 14360static const char *
14361get_gnu_elf_note_type (unsigned e_type)
14362{
14363 static char buff[64];
14364
14365 switch (e_type)
14366 {
14367 case NT_GNU_ABI_TAG:
14368 return _("NT_GNU_ABI_TAG (ABI version tag)");
14369 case NT_GNU_HWCAP:
14370 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14371 case NT_GNU_BUILD_ID:
14372 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14373 case NT_GNU_GOLD_VERSION:
14374 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14375 default:
14376 break;
14377 }
14378
14379 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14380 return buff;
14381}
14382
664f90a3
TT		 14383static int
14384print_gnu_note (Elf_Internal_Note *pnote)
14385{
14386 switch (pnote->type)
14387 {
14388 case NT_GNU_BUILD_ID:
14389 {
14390 unsigned long i;
14391
14392 printf (_(" Build ID: "));
14393 for (i = 0; i < pnote->descsz; ++i)
14394 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14395 printf ("\n");
664f90a3
TT		 14396 }
14397 break;
14398
14399 case NT_GNU_ABI_TAG:
14400 {
14401 unsigned long os, major, minor, subminor;
14402 const char *osname;
14403
3102e897
NC		 14404 /* PR 17531: file: 030-599401-0.004. */
14405 if (pnote->descsz < 16)
14406 {
14407 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14408 break;
14409 }
14410
664f90a3
TT		 14411 os = byte_get ((unsigned char *) pnote->descdata, 4);
14412 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14413 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14414 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14415
14416 switch (os)
14417 {
14418 case GNU_ABI_TAG_LINUX:
14419 osname = "Linux";
14420 break;
14421 case GNU_ABI_TAG_HURD:
14422 osname = "Hurd";
14423 break;
14424 case GNU_ABI_TAG_SOLARIS:
14425 osname = "Solaris";
14426 break;
14427 case GNU_ABI_TAG_FREEBSD:
14428 osname = "FreeBSD";
14429 break;
14430 case GNU_ABI_TAG_NETBSD:
14431 osname = "NetBSD";
14432 break;
14433 default:
14434 osname = "Unknown";
14435 break;
14436 }
14437
14438 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14439 major, minor, subminor);
14440 }
14441 break;
926c5385
CC		 14442
14443 case NT_GNU_GOLD_VERSION:
14444 {
14445 unsigned long i;
14446
14447 printf (_(" Version: "));
14448 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14449 printf ("%c", pnote->descdata[i]);
14450 printf ("\n");
14451 }
14452 break;
664f90a3
TT		 14453 }
14454
14455 return 1;
14456}
14457
9437c45b 14458static const char *
d3ba0551 14459get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14460{
14461 static char buff[64];
14462
b4db1224 14463 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14464 {
14465 /* NetBSD core "procinfo" structure. */
14466 return _("NetBSD procinfo structure");
14467 }
14468
14469 /* As of Jan 2002 there are no other machine-independent notes
14470 defined for NetBSD core files. If the note type is less
14471 than the start of the machine-dependent note types, we don't
14472 understand it. */
14473
b4db1224 14474 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14475 {
e9e44622 14476 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14477 return buff;
14478 }
14479
14480 switch (elf_header.e_machine)
14481 {
14482 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14483 and PT_GETFPREGS == mach+2. */
14484
14485 case EM_OLD_ALPHA:
14486 case EM_ALPHA:
14487 case EM_SPARC:
14488 case EM_SPARC32PLUS:
14489 case EM_SPARCV9:
14490 switch (e_type)
14491 {
2b692964 14492 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 14493 return _("PT_GETREGS (reg structure)");
2b692964 14494 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 14495 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14496 default:
14497 break;
14498 }
14499 break;
14500
14501 /* On all other arch's, PT_GETREGS == mach+1 and
14502 PT_GETFPREGS == mach+3. */
14503 default:
14504 switch (e_type)
14505 {
2b692964 14506 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 14507 return _("PT_GETREGS (reg structure)");
2b692964 14508 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 14509 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14510 default:
14511 break;
14512 }
14513 }
14514
9cf03b7e 14515 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 14516 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 14517 return buff;
14518}
14519
70616151
TT		 14520static const char *
14521get_stapsdt_note_type (unsigned e_type)
14522{
14523 static char buff[64];
14524
14525 switch (e_type)
14526 {
14527 case NT_STAPSDT:
14528 return _("NT_STAPSDT (SystemTap probe descriptors)");
14529
14530 default:
14531 break;
14532 }
14533
14534 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14535 return buff;
14536}
14537
c6a9fc58
TT		 14538static int
14539print_stapsdt_note (Elf_Internal_Note *pnote)
14540{
14541 int addr_size = is_32bit_elf ? 4 : 8;
14542 char *data = pnote->descdata;
14543 char *data_end = pnote->descdata + pnote->descsz;
14544 bfd_vma pc, base_addr, semaphore;
14545 char *provider, *probe, *arg_fmt;
14546
14547 pc = byte_get ((unsigned char *) data, addr_size);
14548 data += addr_size;
14549 base_addr = byte_get ((unsigned char *) data, addr_size);
14550 data += addr_size;
14551 semaphore = byte_get ((unsigned char *) data, addr_size);
14552 data += addr_size;
14553
14554 provider = data;
14555 data += strlen (data) + 1;
14556 probe = data;
14557 data += strlen (data) + 1;
14558 arg_fmt = data;
14559 data += strlen (data) + 1;
14560
14561 printf (_(" Provider: %s\n"), provider);
14562 printf (_(" Name: %s\n"), probe);
14563 printf (_(" Location: "));
14564 print_vma (pc, FULL_HEX);
14565 printf (_(", Base: "));
14566 print_vma (base_addr, FULL_HEX);
14567 printf (_(", Semaphore: "));
14568 print_vma (semaphore, FULL_HEX);
9cf03b7e 14569 printf ("\n");
c6a9fc58
TT		 14570 printf (_(" Arguments: %s\n"), arg_fmt);
14571
14572 return data == data_end;
14573}
14574
00e98fc7
TG		 14575static const char *
14576get_ia64_vms_note_type (unsigned e_type)
14577{
14578 static char buff[64];
14579
14580 switch (e_type)
14581 {
14582 case NT_VMS_MHD:
14583 return _("NT_VMS_MHD (module header)");
14584 case NT_VMS_LNM:
14585 return _("NT_VMS_LNM (language name)");
14586 case NT_VMS_SRC:
14587 return _("NT_VMS_SRC (source files)");
14588 case NT_VMS_TITLE:
9cf03b7e 14589 return "NT_VMS_TITLE";
00e98fc7
TG		 14590 case NT_VMS_EIDC:
14591 return _("NT_VMS_EIDC (consistency check)");
14592 case NT_VMS_FPMODE:
14593 return _("NT_VMS_FPMODE (FP mode)");
14594 case NT_VMS_LINKTIME:
9cf03b7e 14595 return "NT_VMS_LINKTIME";
00e98fc7
TG		 14596 case NT_VMS_IMGNAM:
14597 return _("NT_VMS_IMGNAM (image name)");
14598 case NT_VMS_IMGID:
14599 return _("NT_VMS_IMGID (image id)");
14600 case NT_VMS_LINKID:
14601 return _("NT_VMS_LINKID (link id)");
14602 case NT_VMS_IMGBID:
14603 return _("NT_VMS_IMGBID (build id)");
14604 case NT_VMS_GSTNAM:
14605 return _("NT_VMS_GSTNAM (sym table name)");
14606 case NT_VMS_ORIG_DYN:
9cf03b7e 14607 return "NT_VMS_ORIG_DYN";
00e98fc7 14608 case NT_VMS_PATCHTIME:
9cf03b7e 14609 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 14610 default:
14611 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14612 return buff;
14613 }
14614}
14615
14616static int
14617print_ia64_vms_note (Elf_Internal_Note * pnote)
14618{
14619 switch (pnote->type)
14620 {
14621 case NT_VMS_MHD:
14622 if (pnote->descsz > 36)
14623 {
14624 size_t l = strlen (pnote->descdata + 34);
14625 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14626 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14627 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14628 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14629 }
14630 else
14631 printf (_(" Invalid size\n"));
14632 break;
14633 case NT_VMS_LNM:
14634 printf (_(" Language: %s\n"), pnote->descdata);
14635 break;
14636#ifdef BFD64
14637 case NT_VMS_FPMODE:
9cf03b7e 14638 printf (_(" Floating Point mode: "));
4a5cb34f 14639 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14640 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14641 break;
14642 case NT_VMS_LINKTIME:
14643 printf (_(" Link time: "));
14644 print_vms_time
14645 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14646 printf ("\n");
14647 break;
14648 case NT_VMS_PATCHTIME:
14649 printf (_(" Patch time: "));
14650 print_vms_time
14651 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14652 printf ("\n");
14653 break;
14654 case NT_VMS_ORIG_DYN:
14655 printf (_(" Major id: %u, minor id: %u\n"),
14656 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14657 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 14658 printf (_(" Last modified : "));
00e98fc7
TG		 14659 print_vms_time
14660 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 14661 printf (_("\n Link flags : "));
4a5cb34f 14662 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14663 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14664 printf (_(" Header flags: 0x%08x\n"),
14665 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14666 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14667 break;
14668#endif
14669 case NT_VMS_IMGNAM:
14670 printf (_(" Image name: %s\n"), pnote->descdata);
14671 break;
14672 case NT_VMS_GSTNAM:
14673 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14674 break;
14675 case NT_VMS_IMGID:
14676 printf (_(" Image id: %s\n"), pnote->descdata);
14677 break;
14678 case NT_VMS_LINKID:
14679 printf (_(" Linker id: %s\n"), pnote->descdata);
14680 break;
14681 default:
14682 break;
14683 }
14684 return 1;
14685}
14686
6d118b09
NC		 14687/* Note that by the ELF standard, the name field is already null byte
14688 terminated, and namesz includes the terminating null byte.
14689 I.E. the value of namesz for the name "FSF" is 4.
14690
e3c8793a 14691 If the value of namesz is zero, there is no name present. */
779fe533 14692static int
2cf0635d 14693process_note (Elf_Internal_Note * pnote)
779fe533 14694{
2cf0635d
NC		 14695 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14696 const char * nt;
9437c45b
JT		 14697
14698 if (pnote->namesz == 0)
1ec5cd37
NC		 14699 /* If there is no note name, then use the default set of
14700 note type strings. */
14701 nt = get_note_type (pnote->type);
14702
1118d252
RM		 14703 else if (const_strneq (pnote->namedata, "GNU"))
14704 /* GNU-specific object file notes. */
14705 nt = get_gnu_elf_note_type (pnote->type);
14706
0112cd26 14707 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 14708 /* NetBSD-specific core file notes. */
14709 nt = get_netbsd_elfcore_note_type (pnote->type);
14710
b15fa79e
AM		 14711 else if (strneq (pnote->namedata, "SPU/", 4))
14712 {
14713 /* SPU-specific core file notes. */
14714 nt = pnote->namedata + 4;
14715 name = "SPU";
14716 }
14717
00e98fc7
TG		 14718 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14719 /* VMS/ia64-specific file notes. */
14720 nt = get_ia64_vms_note_type (pnote->type);
14721
70616151
TT		 14722 else if (const_strneq (pnote->namedata, "stapsdt"))
14723 nt = get_stapsdt_note_type (pnote->type);
14724
9437c45b 14725 else
1ec5cd37
NC		 14726 /* Don't recognize this note name; just use the default set of
14727 note type strings. */
00e98fc7 14728 nt = get_note_type (pnote->type);
9437c45b 14729
2aee03ae 14730 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 14731
14732 if (const_strneq (pnote->namedata, "IPF/VMS"))
14733 return print_ia64_vms_note (pnote);
664f90a3
TT		 14734 else if (const_strneq (pnote->namedata, "GNU"))
14735 return print_gnu_note (pnote);
c6a9fc58
TT		 14736 else if (const_strneq (pnote->namedata, "stapsdt"))
14737 return print_stapsdt_note (pnote);
9ece1fa9
TT		 14738 else if (const_strneq (pnote->namedata, "CORE"))
14739 return print_core_note (pnote);
00e98fc7
TG		 14740 else
14741 return 1;
779fe533
NC		 14742}
14743
6d118b09 14744
779fe533 14745static int
2cf0635d 14746process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 14747{
2cf0635d
NC		 14748 Elf_External_Note * pnotes;
14749 Elf_External_Note * external;
b34976b6 14750 int res = 1;
103f02d3 14751
779fe533
NC		 14752 if (length <= 0)
14753 return 0;
103f02d3 14754
3f5e193b 14755 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 14756 _("notes"));
dd24e3da 14757 if (pnotes == NULL)
a6e9f9df 14758 return 0;
779fe533 14759
103f02d3 14760 external = pnotes;
103f02d3 14761
9dd3a467 14762 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 14763 (unsigned long) offset, (unsigned long) length);
2aee03ae 14764 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 14765
15b42fb0 14766 while ((char *) external < (char *) pnotes + length)
779fe533 14767 {
b34976b6 14768 Elf_Internal_Note inote;
15b42fb0
AM		 14769 size_t min_notesz;
14770 char *next;
2cf0635d 14771 char * temp = NULL;
15b42fb0 14772 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 14773
00e98fc7 14774 if (!is_ia64_vms ())
15b42fb0 14775 {
9dd3a467
NC		 14776 /* PR binutils/15191
14777 Make sure that there is enough data to read. */
15b42fb0
AM		 14778 min_notesz = offsetof (Elf_External_Note, name);
14779 if (data_remaining < min_notesz)
9dd3a467
NC		 14780 {
14781 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14782 (int) data_remaining);
14783 break;
14784 }
15b42fb0
AM		 14785 inote.type = BYTE_GET (external->type);
14786 inote.namesz = BYTE_GET (external->namesz);
14787 inote.namedata = external->name;
14788 inote.descsz = BYTE_GET (external->descsz);
14789 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14790 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14791 next = inote.descdata + align_power (inote.descsz, 2);
14792 }
00e98fc7 14793 else
15b42fb0
AM		 14794 {
14795 Elf64_External_VMS_Note *vms_external;
00e98fc7 14796
9dd3a467
NC		 14797 /* PR binutils/15191
14798 Make sure that there is enough data to read. */
15b42fb0
AM		 14799 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14800 if (data_remaining < min_notesz)
9dd3a467
NC		 14801 {
14802 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14803 (int) data_remaining);
14804 break;
14805 }
3e55a963 14806
15b42fb0
AM		 14807 vms_external = (Elf64_External_VMS_Note *) external;
14808 inote.type = BYTE_GET (vms_external->type);
14809 inote.namesz = BYTE_GET (vms_external->namesz);
14810 inote.namedata = vms_external->name;
14811 inote.descsz = BYTE_GET (vms_external->descsz);
14812 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14813 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14814 next = inote.descdata + align_power (inote.descsz, 3);
14815 }
14816
14817 if (inote.descdata < (char *) external + min_notesz
14818 || next < (char *) external + min_notesz
5d921cbd
NC		 14819 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14820 || inote.namedata + inote.namesz < inote.namedata
14821 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 14822 || data_remaining < (size_t)(next - (char *) external))
3e55a963 14823 {
15b42fb0 14824 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 14825 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 14826 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 14827 inote.type, inote.namesz, inote.descsz);
14828 break;
14829 }
14830
15b42fb0 14831 external = (Elf_External_Note *) next;
dd24e3da 14832
6d118b09
NC		 14833 /* Verify that name is null terminated. It appears that at least
14834 one version of Linux (RedHat 6.0) generates corefiles that don't
14835 comply with the ELF spec by failing to include the null byte in
14836 namesz. */
8b971f9f 14837 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 14838 {
3f5e193b 14839 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 14840 if (temp == NULL)
14841 {
8b73c356 14842 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 14843 res = 0;
14844 break;
14845 }
76da6bbe 14846
6d118b09
NC		 14847 strncpy (temp, inote.namedata, inote.namesz);
14848 temp[inote.namesz] = 0;
76da6bbe 14849
6d118b09
NC		 14850 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14851 inote.namedata = temp;
14852 }
14853
14854 res &= process_note (& inote);
103f02d3 14855
6d118b09
NC		 14856 if (temp != NULL)
14857 {
14858 free (temp);
14859 temp = NULL;
14860 }
779fe533
NC		 14861 }
14862
14863 free (pnotes);
103f02d3 14864
779fe533
NC		 14865 return res;
14866}
14867
14868static int
2cf0635d 14869process_corefile_note_segments (FILE * file)
779fe533 14870{
2cf0635d 14871 Elf_Internal_Phdr * segment;
b34976b6
AM		 14872 unsigned int i;
14873 int res = 1;
103f02d3 14874
d93f0186 14875 if (! get_program_headers (file))
779fe533 14876 return 0;
103f02d3 14877
779fe533
NC		 14878 for (i = 0, segment = program_headers;
14879 i < elf_header.e_phnum;
b34976b6 14880 i++, segment++)
779fe533
NC		 14881 {
14882 if (segment->p_type == PT_NOTE)
103f02d3 14883 res &= process_corefile_note_segment (file,
30800947
NC		 14884 (bfd_vma) segment->p_offset,
14885 (bfd_vma) segment->p_filesz);
779fe533 14886 }
103f02d3 14887
779fe533
NC		 14888 return res;
14889}
14890
14891static int
2cf0635d 14892process_note_sections (FILE * file)
1ec5cd37 14893{
2cf0635d 14894 Elf_Internal_Shdr * section;
1ec5cd37 14895 unsigned long i;
df565f32 14896 int n = 0;
1ec5cd37
NC		 14897 int res = 1;
14898
14899 for (i = 0, section = section_headers;
fa1908fd 14900 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 14901 i++, section++)
14902 if (section->sh_type == SHT_NOTE)
df565f32
NC		 14903 {
14904 res &= process_corefile_note_segment (file,
14905 (bfd_vma) section->sh_offset,
14906 (bfd_vma) section->sh_size);
14907 n++;
14908 }
14909
14910 if (n == 0)
14911 /* Try processing NOTE segments instead. */
14912 return process_corefile_note_segments (file);
1ec5cd37
NC		 14913
14914 return res;
14915}
14916
14917static int
2cf0635d 14918process_notes (FILE * file)
779fe533
NC		 14919{
14920 /* If we have not been asked to display the notes then do nothing. */
14921 if (! do_notes)
14922 return 1;
103f02d3 14923
779fe533 14924 if (elf_header.e_type != ET_CORE)
1ec5cd37 14925 return process_note_sections (file);
103f02d3 14926
779fe533 14927 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 14928 if (elf_header.e_phnum > 0)
14929 return process_corefile_note_segments (file);
779fe533 14930
1ec5cd37
NC		 14931 printf (_("No note segments present in the core file.\n"));
14932 return 1;
779fe533
NC		 14933}
14934
252b5132 14935static int
2cf0635d 14936process_arch_specific (FILE * file)
252b5132 14937{
a952a375
NC		 14938 if (! do_arch)
14939 return 1;
14940
252b5132
RH		 14941 switch (elf_header.e_machine)
14942 {
11c1ff18
PB		 14943 case EM_ARM:
14944 return process_arm_specific (file);
252b5132 14945 case EM_MIPS:
4fe85591 14946 case EM_MIPS_RS3_LE:
252b5132
RH		 14947 return process_mips_specific (file);
14948 break;
35c08157
KLC		 14949 case EM_NDS32:
14950 return process_nds32_specific (file);
14951 break;
34c8bcba
JM		 14952 case EM_PPC:
14953 return process_power_specific (file);
14954 break;
9e8c70f9
DM		 14955 case EM_SPARC:
14956 case EM_SPARC32PLUS:
14957 case EM_SPARCV9:
14958 return process_sparc_specific (file);
14959 break;
59e6276b
JM		 14960 case EM_TI_C6000:
14961 return process_tic6x_specific (file);
14962 break;
13761a11
NC		 14963 case EM_MSP430:
14964 return process_msp430x_specific (file);
252b5132
RH		 14965 default:
14966 break;
14967 }
14968 return 1;
14969}
14970
14971static int
2cf0635d 14972get_file_header (FILE * file)
252b5132 14973{
9ea033b2
NC		 14974 /* Read in the identity array. */
14975 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 14976 return 0;
14977
9ea033b2 14978 /* Determine how to read the rest of the header. */
b34976b6 14979 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 14980 {
14981 default: /* fall through */
14982 case ELFDATANONE: /* fall through */
adab8cdc
AO		 14983 case ELFDATA2LSB:
14984 byte_get = byte_get_little_endian;
14985 byte_put = byte_put_little_endian;
14986 break;
14987 case ELFDATA2MSB:
14988 byte_get = byte_get_big_endian;
14989 byte_put = byte_put_big_endian;
14990 break;
9ea033b2
NC		 14991 }
14992
14993 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 14994 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 14995
14996 /* Read in the rest of the header. */
14997 if (is_32bit_elf)
14998 {
14999 Elf32_External_Ehdr ehdr32;
252b5132 15000
9ea033b2
NC		 15001 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15002 return 0;
103f02d3 15003
9ea033b2
NC		 15004 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15005 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15006 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15007 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15008 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15009 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15010 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15011 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15012 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15013 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15014 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15015 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15016 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15017 }
252b5132 15018 else
9ea033b2
NC		 15019 {
15020 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15021
15022 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15023 we will not be able to cope with the 64bit data found in
15024 64 ELF files. Detect this now and abort before we start
50c2245b 15025 overwriting things. */
a952a375
NC		 15026 if (sizeof (bfd_vma) < 8)
15027 {
e3c8793a
NC		 15028 error (_("This instance of readelf has been built without support for a\n\
1502964 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15030 return 0;
15031 }
103f02d3 15032
9ea033b2
NC		 15033 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15034 return 0;
103f02d3 15035
9ea033b2
NC		 15036 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15037 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15038 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15039 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15040 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15041 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15042 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15043 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15044 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15045 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15046 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15047 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15048 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15049 }
252b5132 15050
7ece0d85
JJ		 15051 if (elf_header.e_shoff)
15052 {
15053 /* There may be some extensions in the first section header. Don't
15054 bomb if we can't read it. */
15055 if (is_32bit_elf)
049b0c3a 15056 get_32bit_section_headers (file, TRUE);
7ece0d85 15057 else
049b0c3a 15058 get_64bit_section_headers (file, TRUE);
7ece0d85 15059 }
560f3c1c 15060
252b5132
RH		 15061 return 1;
15062}
15063
fb52b2f4
NC		 15064/* Process one ELF object file according to the command line options.
15065 This file may actually be stored in an archive. The file is
15066 positioned at the start of the ELF object. */
15067
ff78d6d6 15068static int
2cf0635d 15069process_object (char * file_name, FILE * file)
252b5132 15070{
252b5132
RH		 15071 unsigned int i;
15072
252b5132
RH		 15073 if (! get_file_header (file))
15074 {
15075 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15076 return 1;
252b5132
RH		 15077 }
15078
15079 /* Initialise per file variables. */
60bca95a 15080 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15081 version_info[i] = 0;
15082
60bca95a 15083 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15084 dynamic_info[i] = 0;
5115b233 15085 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15086
15087 /* Process the file. */
15088 if (show_name)
15089 printf (_("\nFile: %s\n"), file_name);
15090
18bd398b
NC		 15091 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15092 Note we do this even if cmdline_dump_sects is empty because we
15093 must make sure that the dump_sets array is zeroed out before each
15094 object file is processed. */
15095 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15096 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15097
15098 if (num_cmdline_dump_sects > 0)
15099 {
15100 if (num_dump_sects == 0)
15101 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15102 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15103
15104 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15105 memcpy (dump_sects, cmdline_dump_sects,
15106 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15107 }
d70c5fc7 15108
252b5132 15109 if (! process_file_header ())
fb52b2f4 15110 return 1;
252b5132 15111
d1f5c6e3 15112 if (! process_section_headers (file))
2f62977e 15113 {
d1f5c6e3
L		 15114 /* Without loaded section headers we cannot process lots of
15115 things. */
2f62977e 15116 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15117
2f62977e 15118 if (! do_using_dynamic)
2c610e4b 15119 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15120 }
252b5132 15121
d1f5c6e3
L		 15122 if (! process_section_groups (file))
15123 {
15124 /* Without loaded section groups we cannot process unwind. */
15125 do_unwind = 0;
15126 }
15127
2f62977e 15128 if (process_program_headers (file))
b2d38a17 15129 process_dynamic_section (file);
252b5132
RH		 15130
15131 process_relocs (file);
15132
4d6ed7c8
NC		 15133 process_unwind (file);
15134
252b5132
RH		 15135 process_symbol_table (file);
15136
15137 process_syminfo (file);
15138
15139 process_version_sections (file);
15140
15141 process_section_contents (file);
f5842774 15142
1ec5cd37 15143 process_notes (file);
103f02d3 15144
047b2264
JJ		 15145 process_gnu_liblist (file);
15146
252b5132
RH		 15147 process_arch_specific (file);
15148
d93f0186
NC		 15149 if (program_headers)
15150 {
15151 free (program_headers);
15152 program_headers = NULL;
15153 }
15154
252b5132
RH		 15155 if (section_headers)
15156 {
15157 free (section_headers);
15158 section_headers = NULL;
15159 }
15160
15161 if (string_table)
15162 {
15163 free (string_table);
15164 string_table = NULL;
d40ac9bd 15165 string_table_length = 0;
252b5132
RH		 15166 }
15167
15168 if (dynamic_strings)
15169 {
15170 free (dynamic_strings);
15171 dynamic_strings = NULL;
d79b3d50 15172 dynamic_strings_length = 0;
252b5132
RH		 15173 }
15174
15175 if (dynamic_symbols)
15176 {
15177 free (dynamic_symbols);
15178 dynamic_symbols = NULL;
19936277 15179 num_dynamic_syms = 0;
252b5132
RH		 15180 }
15181
15182 if (dynamic_syminfo)
15183 {
15184 free (dynamic_syminfo);
15185 dynamic_syminfo = NULL;
15186 }
ff78d6d6 15187
293c573e
MR		 15188 if (dynamic_section)
15189 {
15190 free (dynamic_section);
15191 dynamic_section = NULL;
15192 }
15193
e4b17d5c
L		 15194 if (section_headers_groups)
15195 {
15196 free (section_headers_groups);
15197 section_headers_groups = NULL;
15198 }
15199
15200 if (section_groups)
15201 {
2cf0635d
NC		 15202 struct group_list * g;
15203 struct group_list * next;
e4b17d5c
L		 15204
15205 for (i = 0; i < group_count; i++)
15206 {
15207 for (g = section_groups [i].root; g != NULL; g = next)
15208 {
15209 next = g->next;
15210 free (g);
15211 }
15212 }
15213
15214 free (section_groups);
15215 section_groups = NULL;
15216 }
15217
19e6b90e 15218 free_debug_memory ();
18bd398b 15219
ff78d6d6 15220 return 0;
252b5132
RH		 15221}
15222
2cf0635d
NC		 15223/* Process an ELF archive.
15224 On entry the file is positioned just after the ARMAG string. */
15225
15226static int
15227process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15228{
15229 struct archive_info arch;
15230 struct archive_info nested_arch;
15231 size_t got;
2cf0635d
NC		 15232 int ret;
15233
15234 show_name = 1;
15235
15236 /* The ARCH structure is used to hold information about this archive. */
15237 arch.file_name = NULL;
15238 arch.file = NULL;
15239 arch.index_array = NULL;
15240 arch.sym_table = NULL;
15241 arch.longnames = NULL;
15242
15243 /* The NESTED_ARCH structure is used as a single-item cache of information
15244 about a nested archive (when members of a thin archive reside within
15245 another regular archive file). */
15246 nested_arch.file_name = NULL;
15247 nested_arch.file = NULL;
15248 nested_arch.index_array = NULL;
15249 nested_arch.sym_table = NULL;
15250 nested_arch.longnames = NULL;
15251
15252 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15253 {
15254 ret = 1;
15255 goto out;
4145f1d5 15256 }
fb52b2f4 15257
4145f1d5
NC		 15258 if (do_archive_index)
15259 {
2cf0635d 15260 if (arch.sym_table == NULL)
4145f1d5
NC		 15261 error (_("%s: unable to dump the index as none was found\n"), file_name);
15262 else
15263 {
2cf0635d 15264 unsigned int i, l;
4145f1d5
NC		 15265 unsigned long current_pos;
15266
15267 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 15268 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 15269 current_pos = ftell (file);
15270
2cf0635d 15271 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 15272 {
2cf0635d
NC		 15273 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15274 {
15275 char * member_name;
4145f1d5 15276
2cf0635d
NC		 15277 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15278
15279 if (member_name != NULL)
15280 {
15281 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15282
15283 if (qualified_name != NULL)
15284 {
c2a7d3f5
NC		 15285 printf (_("Contents of binary %s at offset "), qualified_name);
15286 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15287 putchar ('\n');
2cf0635d
NC		 15288 free (qualified_name);
15289 }
4145f1d5
NC		 15290 }
15291 }
2cf0635d
NC		 15292
15293 if (l >= arch.sym_size)
4145f1d5
NC		 15294 {
15295 error (_("%s: end of the symbol table reached before the end of the index\n"),
15296 file_name);
cb8f3167 15297 break;
4145f1d5 15298 }
2cf0635d
NC		 15299 printf ("\t%s\n", arch.sym_table + l);
15300 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 15301 }
15302
c2a7d3f5
NC		 15303 if (arch.uses_64bit_indicies)
15304 l = (l + 7) & ~ 7;
15305 else
15306 l += l & 1;
15307
2cf0635d 15308 if (l < arch.sym_size)
c2a7d3f5
NC		 15309 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15310 file_name, arch.sym_size - l);
4145f1d5 15311
4145f1d5
NC		 15312 if (fseek (file, current_pos, SEEK_SET) != 0)
15313 {
15314 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 15315 ret = 1;
15316 goto out;
4145f1d5 15317 }
fb52b2f4 15318 }
4145f1d5
NC		 15319
15320 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15321 && !do_segments && !do_header && !do_dump && !do_version
15322 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 15323 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 15324 {
15325 ret = 0; /* Archive index only. */
15326 goto out;
15327 }
fb52b2f4
NC		 15328 }
15329
d989285c 15330 ret = 0;
fb52b2f4
NC		 15331
15332 while (1)
15333 {
2cf0635d
NC		 15334 char * name;
15335 size_t namelen;
15336 char * qualified_name;
15337
15338 /* Read the next archive header. */
15339 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15340 {
15341 error (_("%s: failed to seek to next archive header\n"), file_name);
15342 return 1;
15343 }
15344 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15345 if (got != sizeof arch.arhdr)
15346 {
15347 if (got == 0)
15348 break;
15349 error (_("%s: failed to read archive header\n"), file_name);
15350 ret = 1;
15351 break;
15352 }
15353 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15354 {
15355 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15356 ret = 1;
15357 break;
15358 }
15359
15360 arch.next_arhdr_offset += sizeof arch.arhdr;
15361
15362 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15363 if (archive_file_size & 01)
15364 ++archive_file_size;
15365
15366 name = get_archive_member_name (&arch, &nested_arch);
15367 if (name == NULL)
fb52b2f4 15368 {
0fd3a477 15369 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15370 ret = 1;
15371 break;
fb52b2f4 15372 }
2cf0635d 15373 namelen = strlen (name);
fb52b2f4 15374
2cf0635d
NC		 15375 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15376 if (qualified_name == NULL)
fb52b2f4 15377 {
2cf0635d 15378 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15379 ret = 1;
15380 break;
fb52b2f4
NC		 15381 }
15382
2cf0635d
NC		 15383 if (is_thin_archive && arch.nested_member_origin == 0)
15384 {
15385 /* This is a proxy for an external member of a thin archive. */
15386 FILE * member_file;
15387 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15388 if (member_file_name == NULL)
15389 {
15390 ret = 1;
15391 break;
15392 }
15393
15394 member_file = fopen (member_file_name, "rb");
15395 if (member_file == NULL)
15396 {
15397 error (_("Input file '%s' is not readable.\n"), member_file_name);
15398 free (member_file_name);
15399 ret = 1;
15400 break;
15401 }
15402
15403 archive_file_offset = arch.nested_member_origin;
15404
15405 ret |= process_object (qualified_name, member_file);
15406
15407 fclose (member_file);
15408 free (member_file_name);
15409 }
15410 else if (is_thin_archive)
15411 {
a043396b
NC		 15412 /* PR 15140: Allow for corrupt thin archives. */
15413 if (nested_arch.file == NULL)
15414 {
15415 error (_("%s: contains corrupt thin archive: %s\n"),
15416 file_name, name);
15417 ret = 1;
15418 break;
15419 }
15420
2cf0635d
NC		 15421 /* This is a proxy for a member of a nested archive. */
15422 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15423
15424 /* The nested archive file will have been opened and setup by
15425 get_archive_member_name. */
15426 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15427 {
15428 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15429 ret = 1;
15430 break;
15431 }
15432
15433 ret |= process_object (qualified_name, nested_arch.file);
15434 }
15435 else
15436 {
15437 archive_file_offset = arch.next_arhdr_offset;
15438 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 15439
2cf0635d
NC		 15440 ret |= process_object (qualified_name, file);
15441 }
fb52b2f4 15442
2b52916e
L		 15443 if (dump_sects != NULL)
15444 {
15445 free (dump_sects);
15446 dump_sects = NULL;
15447 num_dump_sects = 0;
15448 }
15449
2cf0635d 15450 free (qualified_name);
fb52b2f4
NC		 15451 }
15452
4145f1d5 15453 out:
2cf0635d
NC		 15454 if (nested_arch.file != NULL)
15455 fclose (nested_arch.file);
15456 release_archive (&nested_arch);
15457 release_archive (&arch);
fb52b2f4 15458
d989285c 15459 return ret;
fb52b2f4
NC		 15460}
15461
15462static int
2cf0635d 15463process_file (char * file_name)
fb52b2f4 15464{
2cf0635d 15465 FILE * file;
fb52b2f4
NC		 15466 struct stat statbuf;
15467 char armag[SARMAG];
15468 int ret;
15469
15470 if (stat (file_name, &statbuf) < 0)
15471 {
f24ddbdd
NC		 15472 if (errno == ENOENT)
15473 error (_("'%s': No such file\n"), file_name);
15474 else
15475 error (_("Could not locate '%s'. System error message: %s\n"),
15476 file_name, strerror (errno));
15477 return 1;
15478 }
15479
15480 if (! S_ISREG (statbuf.st_mode))
15481 {
15482 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 15483 return 1;
15484 }
15485
15486 file = fopen (file_name, "rb");
15487 if (file == NULL)
15488 {
f24ddbdd 15489 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 15490 return 1;
15491 }
15492
15493 if (fread (armag, SARMAG, 1, file) != 1)
15494 {
4145f1d5 15495 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 15496 fclose (file);
15497 return 1;
15498 }
15499
f54498b4
NC		 15500 current_file_size = (bfd_size_type) statbuf.st_size;
15501
fb52b2f4 15502 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 15503 ret = process_archive (file_name, file, FALSE);
15504 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15505 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 15506 else
15507 {
4145f1d5
NC		 15508 if (do_archive_index)
15509 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15510 file_name);
15511
fb52b2f4
NC		 15512 rewind (file);
15513 archive_file_size = archive_file_offset = 0;
15514 ret = process_object (file_name, file);
15515 }
15516
15517 fclose (file);
15518
f54498b4 15519 current_file_size = 0;
fb52b2f4
NC		 15520 return ret;
15521}
15522
252b5132
RH		 15523#ifdef SUPPORT_DISASSEMBLY
15524/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 15525 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 15526 symbols. */
252b5132
RH		 15527
15528void
2cf0635d 15529print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 15530{
15531 fprintf (outfile,"0x%8.8x", addr);
15532}
15533
e3c8793a 15534/* Needed by the i386 disassembler. */
252b5132
RH		 15535void
15536db_task_printsym (unsigned int addr)
15537{
15538 print_address (addr, stderr);
15539}
15540#endif
15541
15542int
2cf0635d 15543main (int argc, char ** argv)
252b5132 15544{
ff78d6d6
L		 15545 int err;
15546
252b5132
RH		 15547#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15548 setlocale (LC_MESSAGES, "");
3882b010
L		 15549#endif
15550#if defined (HAVE_SETLOCALE)
15551 setlocale (LC_CTYPE, "");
252b5132
RH		 15552#endif
15553 bindtextdomain (PACKAGE, LOCALEDIR);
15554 textdomain (PACKAGE);
15555
869b9d07
MM		 15556 expandargv (&argc, &argv);
15557
252b5132
RH		 15558 parse_args (argc, argv);
15559
18bd398b 15560 if (num_dump_sects > 0)
59f14fc0 15561 {
18bd398b 15562 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 15563 cmdline_dump_sects = (dump_type *)
15564 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 15565 if (cmdline_dump_sects == NULL)
591a748a 15566 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 15567 else
15568 {
09c11c86
NC		 15569 memcpy (cmdline_dump_sects, dump_sects,
15570 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 15571 num_cmdline_dump_sects = num_dump_sects;
15572 }
15573 }
15574
18bd398b
NC		 15575 if (optind < (argc - 1))
15576 show_name = 1;
15577
ff78d6d6 15578 err = 0;
252b5132 15579 while (optind < argc)
18bd398b 15580 err |= process_file (argv[optind++]);
252b5132
RH		 15581
15582 if (dump_sects != NULL)
15583 free (dump_sects);
59f14fc0
AS		 15584 if (cmdline_dump_sects != NULL)
15585 free (cmdline_dump_sects);
252b5132 15586
ff78d6d6 15587 return err;
252b5132 15588}
Empty description
This page took 4.450669 seconds and 4 git commands to generate.