projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Reformat elf_x86_64_create_dynamic_sections
[deliverable/binutils-gdb.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 <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056
CS		 46#ifdef HAVE_ZLIB_H
47#include <zlib.h>
48#endif
3bfcb652 49#ifdef HAVE_WCHAR_H
7bfd842d 50#include <wchar.h>
3bfcb652 51#endif
252b5132 52
a952a375 53#if __GNUC__ >= 2
19936277 54/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 55 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 56 Only do this if we believe that the compiler can support a 64 bit
a952a375 57 data type. For now we only rely on GCC being able to do this. */
19936277 58#define BFD64
a952a375
NC		 59#endif
60
3db64b00
AM		 61#include "bfd.h"
62#include "bucomm.h"
3284fe0c 63#include "elfcomm.h"
19e6b90e 64#include "dwarf.h"
252b5132
RH		 65
66#include "elf/common.h"
67#include "elf/external.h"
68#include "elf/internal.h"
252b5132 69
4b78141a
NC		 70
71/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76#include "elf/h8.h"
77#undef _ELF_H8_H
78
79/* Undo the effects of #including reloc-macros.h. */
80
81#undef START_RELOC_NUMBERS
82#undef RELOC_NUMBER
83#undef FAKE_RELOC
84#undef EMPTY_RELOC
85#undef END_RELOC_NUMBERS
86#undef _RELOC_MACROS_H
87
252b5132
RH		 88/* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92#define RELOC_MACROS_GEN_FUNC
93
a06ea964 94#include "elf/aarch64.h"
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
cfb8c092 106#include "elf/epiphany.h"
252b5132 107#include "elf/fr30.h"
5c70f934 108#include "elf/frv.h"
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;
06614111 11716 section->user_data = NULL;
3f5e193b
NC		 11717 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11718 sec->sh_offset, 1,
11719 sec->sh_size, buf);
59245841
NC		 11720 if (section->start == NULL)
11721 section->size = 0;
11722 else
11723 {
11724 section->size = sec->sh_size;
11725 if (uncompress_section_contents (&section->start, &section->size))
11726 sec->sh_size = section->size;
11727 }
4a114e3e 11728
1b315056
CS		 11729 if (section->start == NULL)
11730 return 0;
11731
19e6b90e 11732 if (debug_displays [debug].relocate)
3f5e193b 11733 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11734
1b315056 11735 return 1;
1007acb3
L		 11736}
11737
657d0d47
CC		 11738/* If this is not NULL, load_debug_section will only look for sections
11739 within the list of sections given here. */
11740unsigned int *section_subset = NULL;
11741
d966045b 11742int
2cf0635d 11743load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11744{
2cf0635d
NC		 11745 struct dwarf_section * section = &debug_displays [debug].section;
11746 Elf_Internal_Shdr * sec;
d966045b
DJ		 11747
11748 /* Locate the debug section. */
657d0d47 11749 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 11750 if (sec != NULL)
11751 section->name = section->uncompressed_name;
11752 else
11753 {
657d0d47 11754 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 11755 if (sec != NULL)
11756 section->name = section->compressed_name;
11757 }
11758 if (sec == NULL)
11759 return 0;
11760
657d0d47
CC		 11761 /* If we're loading from a subset of sections, and we've loaded
11762 a section matching this name before, it's likely that it's a
11763 different one. */
11764 if (section_subset != NULL)
11765 free_debug_section (debug);
11766
3f5e193b 11767 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 11768}
11769
19e6b90e
L		 11770void
11771free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 11772{
2cf0635d 11773 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 11774
19e6b90e
L		 11775 if (section->start == NULL)
11776 return;
1007acb3 11777
19e6b90e
L		 11778 free ((char *) section->start);
11779 section->start = NULL;
11780 section->address = 0;
11781 section->size = 0;
1007acb3
L		 11782}
11783
1007acb3 11784static int
657d0d47 11785display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 11786{
2cf0635d 11787 char * name = SECTION_NAME (section);
74e1a04b 11788 const char * print_name = printable_section_name (section);
19e6b90e
L		 11789 bfd_size_type length;
11790 int result = 1;
3f5e193b 11791 int i;
1007acb3 11792
19e6b90e
L		 11793 length = section->sh_size;
11794 if (length == 0)
1007acb3 11795 {
74e1a04b 11796 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 11797 return 0;
1007acb3 11798 }
5dff79d8
NC		 11799 if (section->sh_type == SHT_NOBITS)
11800 {
11801 /* There is no point in dumping the contents of a debugging section
11802 which has the NOBITS type - the bits in the file will be random.
11803 This can happen when a file containing a .eh_frame section is
11804 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 11805 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11806 print_name);
5dff79d8
NC		 11807 return 0;
11808 }
1007acb3 11809
0112cd26 11810 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 11811 name = ".debug_info";
1007acb3 11812
19e6b90e
L		 11813 /* See if we know how to display the contents of this section. */
11814 for (i = 0; i < max; i++)
1b315056 11815 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 11816 || (i == line && const_strneq (name, ".debug_line."))
1b315056 11817 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 11818 {
2cf0635d 11819 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 11820 int secondary = (section != find_section (name));
11821
11822 if (secondary)
3f5e193b 11823 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 11824
b40bf0a2
NC		 11825 if (i == line && const_strneq (name, ".debug_line."))
11826 sec->name = name;
11827 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 11828 sec->name = sec->uncompressed_name;
11829 else
11830 sec->name = sec->compressed_name;
3f5e193b
NC		 11831 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11832 section, file))
19e6b90e 11833 {
657d0d47
CC		 11834 /* If this debug section is part of a CU/TU set in a .dwp file,
11835 restrict load_debug_section to the sections in that set. */
11836 section_subset = find_cu_tu_set (file, shndx);
11837
19e6b90e 11838 result &= debug_displays[i].display (sec, file);
1007acb3 11839
657d0d47
CC		 11840 section_subset = NULL;
11841
d966045b 11842 if (secondary || (i != info && i != abbrev))
3f5e193b 11843 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 11844 }
1007acb3 11845
19e6b90e
L		 11846 break;
11847 }
1007acb3 11848
19e6b90e 11849 if (i == max)
1007acb3 11850 {
74e1a04b 11851 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 11852 result = 0;
1007acb3
L		 11853 }
11854
19e6b90e 11855 return result;
5b18a4bc 11856}
103f02d3 11857
aef1f6d0
DJ		 11858/* Set DUMP_SECTS for all sections where dumps were requested
11859 based on section name. */
11860
11861static void
11862initialise_dumps_byname (void)
11863{
2cf0635d 11864 struct dump_list_entry * cur;
aef1f6d0
DJ		 11865
11866 for (cur = dump_sects_byname; cur; cur = cur->next)
11867 {
11868 unsigned int i;
11869 int any;
11870
11871 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11872 if (streq (SECTION_NAME (section_headers + i), cur->name))
11873 {
09c11c86 11874 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11875 any = 1;
11876 }
11877
11878 if (!any)
11879 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11880 cur->name);
11881 }
11882}
11883
5b18a4bc 11884static void
2cf0635d 11885process_section_contents (FILE * file)
5b18a4bc 11886{
2cf0635d 11887 Elf_Internal_Shdr * section;
19e6b90e 11888 unsigned int i;
103f02d3 11889
19e6b90e
L		 11890 if (! do_dump)
11891 return;
103f02d3 11892
aef1f6d0
DJ		 11893 initialise_dumps_byname ();
11894
19e6b90e
L		 11895 for (i = 0, section = section_headers;
11896 i < elf_header.e_shnum && i < num_dump_sects;
11897 i++, section++)
11898 {
11899#ifdef SUPPORT_DISASSEMBLY
11900 if (dump_sects[i] & DISASS_DUMP)
11901 disassemble_section (section, file);
11902#endif
11903 if (dump_sects[i] & HEX_DUMP)
cf13d699 11904 dump_section_as_bytes (section, file, FALSE);
103f02d3 11905
cf13d699
NC		 11906 if (dump_sects[i] & RELOC_DUMP)
11907 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11908
11909 if (dump_sects[i] & STRING_DUMP)
11910 dump_section_as_strings (section, file);
cf13d699
NC		 11911
11912 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11913 display_debug_section (i, section, file);
5b18a4bc 11914 }
103f02d3 11915
19e6b90e
L		 11916 /* Check to see if the user requested a
11917 dump of a section that does not exist. */
11918 while (i++ < num_dump_sects)
11919 if (dump_sects[i])
11920 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11921}
103f02d3 11922
5b18a4bc 11923static void
19e6b90e 11924process_mips_fpe_exception (int mask)
5b18a4bc 11925{
19e6b90e
L		 11926 if (mask)
11927 {
11928 int first = 1;
11929 if (mask & OEX_FPU_INEX)
11930 fputs ("INEX", stdout), first = 0;
11931 if (mask & OEX_FPU_UFLO)
11932 printf ("%sUFLO", first ? "" : "|"), first = 0;
11933 if (mask & OEX_FPU_OFLO)
11934 printf ("%sOFLO", first ? "" : "|"), first = 0;
11935 if (mask & OEX_FPU_DIV0)
11936 printf ("%sDIV0", first ? "" : "|"), first = 0;
11937 if (mask & OEX_FPU_INVAL)
11938 printf ("%sINVAL", first ? "" : "|");
11939 }
5b18a4bc 11940 else
19e6b90e 11941 fputs ("0", stdout);
5b18a4bc 11942}
103f02d3 11943
f6f0e17b
NC		 11944/* Display's the value of TAG at location P. If TAG is
11945 greater than 0 it is assumed to be an unknown tag, and
11946 a message is printed to this effect. Otherwise it is
11947 assumed that a message has already been printed.
11948
11949 If the bottom bit of TAG is set it assumed to have a
11950 string value, otherwise it is assumed to have an integer
11951 value.
11952
11953 Returns an updated P pointing to the first unread byte
11954 beyond the end of TAG's value.
11955
11956 Reads at or beyond END will not be made. */
11957
11958static unsigned char *
11959display_tag_value (int tag,
11960 unsigned char * p,
11961 const unsigned char * const end)
11962{
11963 unsigned long val;
11964
11965 if (tag > 0)
11966 printf (" Tag_unknown_%d: ", tag);
11967
11968 if (p >= end)
11969 {
4082ef84 11970 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 11971 }
11972 else if (tag & 1)
11973 {
071436c6
NC		 11974 /* PR 17531 file: 027-19978-0.004. */
11975 size_t maxlen = (end - p) - 1;
11976
11977 putchar ('"');
4082ef84
NC		 11978 if (maxlen > 0)
11979 {
11980 print_symbol ((int) maxlen, (const char *) p);
11981 p += strnlen ((char *) p, maxlen) + 1;
11982 }
11983 else
11984 {
11985 printf (_("<corrupt string tag>"));
11986 p = (unsigned char *) end;
11987 }
071436c6 11988 printf ("\"\n");
f6f0e17b
NC		 11989 }
11990 else
11991 {
11992 unsigned int len;
11993
11994 val = read_uleb128 (p, &len, end);
11995 p += len;
11996 printf ("%ld (0x%lx)\n", val, val);
11997 }
11998
4082ef84 11999 assert (p <= end);
f6f0e17b
NC		 12000 return p;
12001}
12002
11c1ff18
PB		 12003/* ARM EABI attributes section. */
12004typedef struct
12005{
70e99720 12006 unsigned int tag;
2cf0635d 12007 const char * name;
11c1ff18 12008 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12009 unsigned int type;
2cf0635d 12010 const char ** table;
11c1ff18
PB		 12011} arm_attr_public_tag;
12012
2cf0635d 12013static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12014 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12015 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12016static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12017static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12018 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12019static const char * arm_attr_tag_FP_arch[] =
bca38921 12020 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12021 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12022static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12023static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12024 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12025static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12026 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12027 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12028static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12029 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12030static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12031 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12032static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12033 {"Absolute", "PC-relative", "None"};
2cf0635d 12034static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12035 {"None", "direct", "GOT-indirect"};
2cf0635d 12036static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12037 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12038static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12039static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12040 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12041static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12042static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12043static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12044 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12045static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12046 {"Unused", "small", "int", "forced to int"};
2cf0635d 12047static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 12048 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 12049static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 12050 {"AAPCS", "VFP registers", "custom"};
2cf0635d 12051static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12052 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12053static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12054 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12055 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12056static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12057 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12058 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12059static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12060static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12061 {"Not Allowed", "Allowed"};
2cf0635d 12062static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12063 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12064static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12065 {"Not Allowed", "Allowed"};
12066static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12067 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12068 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12069static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12070static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12071 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12072 "TrustZone and Virtualization Extensions"};
dd24e3da 12073static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12074 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12075
12076#define LOOKUP(id, name) \
12077 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12078static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12079{
12080 {4, "CPU_raw_name", 1, NULL},
12081 {5, "CPU_name", 1, NULL},
12082 LOOKUP(6, CPU_arch),
12083 {7, "CPU_arch_profile", 0, NULL},
12084 LOOKUP(8, ARM_ISA_use),
12085 LOOKUP(9, THUMB_ISA_use),
75375b3e 12086 LOOKUP(10, FP_arch),
11c1ff18 12087 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12088 LOOKUP(12, Advanced_SIMD_arch),
12089 LOOKUP(13, PCS_config),
11c1ff18
PB		 12090 LOOKUP(14, ABI_PCS_R9_use),
12091 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12092 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12093 LOOKUP(17, ABI_PCS_GOT_use),
12094 LOOKUP(18, ABI_PCS_wchar_t),
12095 LOOKUP(19, ABI_FP_rounding),
12096 LOOKUP(20, ABI_FP_denormal),
12097 LOOKUP(21, ABI_FP_exceptions),
12098 LOOKUP(22, ABI_FP_user_exceptions),
12099 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12100 {24, "ABI_align_needed", 0, NULL},
12101 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12102 LOOKUP(26, ABI_enum_size),
12103 LOOKUP(27, ABI_HardFP_use),
12104 LOOKUP(28, ABI_VFP_args),
12105 LOOKUP(29, ABI_WMMX_args),
12106 LOOKUP(30, ABI_optimization_goals),
12107 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12108 {32, "compatibility", 0, NULL},
f5f53991 12109 LOOKUP(34, CPU_unaligned_access),
75375b3e 12110 LOOKUP(36, FP_HP_extension),
8e79c3df 12111 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12112 LOOKUP(42, MPextension_use),
12113 LOOKUP(44, DIV_use),
f5f53991
AS		 12114 {64, "nodefaults", 0, NULL},
12115 {65, "also_compatible_with", 0, NULL},
12116 LOOKUP(66, T2EE_use),
12117 {67, "conformance", 1, NULL},
12118 LOOKUP(68, Virtualization_use),
cd21e546 12119 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12120};
12121#undef LOOKUP
12122
11c1ff18 12123static unsigned char *
f6f0e17b
NC		 12124display_arm_attribute (unsigned char * p,
12125 const unsigned char * const end)
11c1ff18 12126{
70e99720 12127 unsigned int tag;
11c1ff18 12128 unsigned int len;
70e99720 12129 unsigned int val;
2cf0635d 12130 arm_attr_public_tag * attr;
11c1ff18 12131 unsigned i;
70e99720 12132 unsigned int type;
11c1ff18 12133
f6f0e17b 12134 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12135 p += len;
12136 attr = NULL;
2cf0635d 12137 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12138 {
12139 if (arm_attr_public_tags[i].tag == tag)
12140 {
12141 attr = &arm_attr_public_tags[i];
12142 break;
12143 }
12144 }
12145
12146 if (attr)
12147 {
12148 printf (" Tag_%s: ", attr->name);
12149 switch (attr->type)
12150 {
12151 case 0:
12152 switch (tag)
12153 {
12154 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12155 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12156 p += len;
12157 switch (val)
12158 {
2b692964
NC		 12159 case 0: printf (_("None\n")); break;
12160 case 'A': printf (_("Application\n")); break;
12161 case 'R': printf (_("Realtime\n")); break;
12162 case 'M': printf (_("Microcontroller\n")); break;
12163 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12164 default: printf ("??? (%d)\n", val); break;
12165 }
12166 break;
12167
75375b3e 12168 case 24: /* Tag_align_needed. */
f6f0e17b 12169 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12170 p += len;
12171 switch (val)
12172 {
2b692964
NC		 12173 case 0: printf (_("None\n")); break;
12174 case 1: printf (_("8-byte\n")); break;
12175 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12176 case 3: printf ("??? 3\n"); break;
12177 default:
12178 if (val <= 12)
dd24e3da 12179 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12180 1 << val);
12181 else
12182 printf ("??? (%d)\n", val);
12183 break;
12184 }
12185 break;
12186
12187 case 25: /* Tag_align_preserved. */
f6f0e17b 12188 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12189 p += len;
12190 switch (val)
12191 {
2b692964
NC		 12192 case 0: printf (_("None\n")); break;
12193 case 1: printf (_("8-byte, except leaf SP\n")); break;
12194 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12195 case 3: printf ("??? 3\n"); break;
12196 default:
12197 if (val <= 12)
dd24e3da 12198 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12199 1 << val);
12200 else
12201 printf ("??? (%d)\n", val);
12202 break;
12203 }
12204 break;
12205
11c1ff18 12206 case 32: /* Tag_compatibility. */
071436c6 12207 {
071436c6
NC		 12208 val = read_uleb128 (p, &len, end);
12209 p += len;
071436c6 12210 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12211 if (p < end - 1)
12212 {
12213 size_t maxlen = (end - p) - 1;
12214
12215 print_symbol ((int) maxlen, (const char *) p);
12216 p += strnlen ((char *) p, maxlen) + 1;
12217 }
12218 else
12219 {
12220 printf (_("<corrupt>"));
12221 p = (unsigned char *) end;
12222 }
071436c6 12223 putchar ('\n');
071436c6 12224 }
11c1ff18
PB		 12225 break;
12226
f5f53991 12227 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12228 /* PR 17531: file: 001-505008-0.01. */
12229 if (p < end)
12230 p++;
2b692964 12231 printf (_("True\n"));
f5f53991
AS		 12232 break;
12233
12234 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12235 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12236 p += len;
12237 if (val == 6 /* Tag_CPU_arch. */)
12238 {
f6f0e17b 12239 val = read_uleb128 (p, &len, end);
f5f53991 12240 p += len;
071436c6 12241 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12242 printf ("??? (%d)\n", val);
12243 else
12244 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12245 }
12246 else
12247 printf ("???\n");
071436c6
NC		 12248 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12249 ;
f5f53991
AS		 12250 break;
12251
11c1ff18 12252 default:
2cf0635d 12253 abort ();
11c1ff18
PB		 12254 }
12255 return p;
12256
12257 case 1:
f6f0e17b 12258 return display_tag_value (-1, p, end);
11c1ff18 12259 case 2:
f6f0e17b 12260 return display_tag_value (0, p, end);
11c1ff18
PB		 12261
12262 default:
12263 assert (attr->type & 0x80);
f6f0e17b 12264 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12265 p += len;
12266 type = attr->type & 0x7f;
12267 if (val >= type)
12268 printf ("??? (%d)\n", val);
12269 else
12270 printf ("%s\n", attr->table[val]);
12271 return p;
12272 }
12273 }
11c1ff18 12274
f6f0e17b 12275 return display_tag_value (tag, p, end);
11c1ff18
PB		 12276}
12277
104d59d1 12278static unsigned char *
60bca95a 12279display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12280 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12281 const unsigned char * const end)
104d59d1
JM		 12282{
12283 int tag;
12284 unsigned int len;
12285 int val;
104d59d1 12286
f6f0e17b 12287 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12288 p += len;
12289
12290 /* Tag_compatibility is the only generic GNU attribute defined at
12291 present. */
12292 if (tag == 32)
12293 {
f6f0e17b 12294 val = read_uleb128 (p, &len, end);
104d59d1 12295 p += len;
071436c6
NC		 12296
12297 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12298 if (p == end)
12299 {
071436c6 12300 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12301 warn (_("corrupt vendor attribute\n"));
12302 }
12303 else
12304 {
4082ef84
NC		 12305 if (p < end - 1)
12306 {
12307 size_t maxlen = (end - p) - 1;
071436c6 12308
4082ef84
NC		 12309 print_symbol ((int) maxlen, (const char *) p);
12310 p += strnlen ((char *) p, maxlen) + 1;
12311 }
12312 else
12313 {
12314 printf (_("<corrupt>"));
12315 p = (unsigned char *) end;
12316 }
071436c6 12317 putchar ('\n');
f6f0e17b 12318 }
104d59d1
JM		 12319 return p;
12320 }
12321
12322 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12323 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12324
f6f0e17b 12325 return display_tag_value (tag, p, end);
104d59d1
JM		 12326}
12327
34c8bcba 12328static unsigned char *
f6f0e17b
NC		 12329display_power_gnu_attribute (unsigned char * p,
12330 int tag,
12331 const unsigned char * const end)
34c8bcba 12332{
34c8bcba
JM		 12333 unsigned int len;
12334 int val;
12335
12336 if (tag == Tag_GNU_Power_ABI_FP)
12337 {
f6f0e17b 12338 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12339 p += len;
12340 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12341
34c8bcba
JM		 12342 switch (val)
12343 {
12344 case 0:
2b692964 12345 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12346 break;
12347 case 1:
2b692964 12348 printf (_("Hard float\n"));
34c8bcba
JM		 12349 break;
12350 case 2:
2b692964 12351 printf (_("Soft float\n"));
34c8bcba 12352 break;
3c7b9897 12353 case 3:
2b692964 12354 printf (_("Single-precision hard float\n"));
3c7b9897 12355 break;
34c8bcba
JM		 12356 default:
12357 printf ("??? (%d)\n", val);
12358 break;
12359 }
12360 return p;
12361 }
12362
c6e65352
DJ		 12363 if (tag == Tag_GNU_Power_ABI_Vector)
12364 {
f6f0e17b 12365 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12366 p += len;
12367 printf (" Tag_GNU_Power_ABI_Vector: ");
12368 switch (val)
12369 {
12370 case 0:
2b692964 12371 printf (_("Any\n"));
c6e65352
DJ		 12372 break;
12373 case 1:
2b692964 12374 printf (_("Generic\n"));
c6e65352
DJ		 12375 break;
12376 case 2:
12377 printf ("AltiVec\n");
12378 break;
12379 case 3:
12380 printf ("SPE\n");
12381 break;
12382 default:
12383 printf ("??? (%d)\n", val);
12384 break;
12385 }
12386 return p;
12387 }
12388
f82e0623
NF		 12389 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12390 {
f6f0e17b
NC		 12391 if (p == end)
12392 {
071436c6 12393 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12394 return p;
12395 }
0b4362b0 12396
f6f0e17b 12397 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12398 p += len;
12399 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12400 switch (val)
12401 {
12402 case 0:
2b692964 12403 printf (_("Any\n"));
f82e0623
NF		 12404 break;
12405 case 1:
12406 printf ("r3/r4\n");
12407 break;
12408 case 2:
2b692964 12409 printf (_("Memory\n"));
f82e0623
NF		 12410 break;
12411 default:
12412 printf ("??? (%d)\n", val);
12413 break;
12414 }
12415 return p;
12416 }
12417
f6f0e17b 12418 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12419}
12420
9e8c70f9
DM		 12421static void
12422display_sparc_hwcaps (int mask)
12423{
12424 if (mask)
12425 {
12426 int first = 1;
071436c6 12427
9e8c70f9
DM		 12428 if (mask & ELF_SPARC_HWCAP_MUL32)
12429 fputs ("mul32", stdout), first = 0;
12430 if (mask & ELF_SPARC_HWCAP_DIV32)
12431 printf ("%sdiv32", first ? "" : "|"), first = 0;
12432 if (mask & ELF_SPARC_HWCAP_FSMULD)
12433 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12434 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12435 printf ("%sv8plus", first ? "" : "|"), first = 0;
12436 if (mask & ELF_SPARC_HWCAP_POPC)
12437 printf ("%spopc", first ? "" : "|"), first = 0;
12438 if (mask & ELF_SPARC_HWCAP_VIS)
12439 printf ("%svis", first ? "" : "|"), first = 0;
12440 if (mask & ELF_SPARC_HWCAP_VIS2)
12441 printf ("%svis2", first ? "" : "|"), first = 0;
12442 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12443 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12444 if (mask & ELF_SPARC_HWCAP_FMAF)
12445 printf ("%sfmaf", first ? "" : "|"), first = 0;
12446 if (mask & ELF_SPARC_HWCAP_VIS3)
12447 printf ("%svis3", first ? "" : "|"), first = 0;
12448 if (mask & ELF_SPARC_HWCAP_HPC)
12449 printf ("%shpc", first ? "" : "|"), first = 0;
12450 if (mask & ELF_SPARC_HWCAP_RANDOM)
12451 printf ("%srandom", first ? "" : "|"), first = 0;
12452 if (mask & ELF_SPARC_HWCAP_TRANS)
12453 printf ("%strans", first ? "" : "|"), first = 0;
12454 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12455 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12456 if (mask & ELF_SPARC_HWCAP_IMA)
12457 printf ("%sima", first ? "" : "|"), first = 0;
12458 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12459 printf ("%scspare", first ? "" : "|"), first = 0;
12460 }
12461 else
071436c6
NC		 12462 fputc ('0', stdout);
12463 fputc ('\n', stdout);
9e8c70f9
DM		 12464}
12465
3d68f91c
JM		 12466static void
12467display_sparc_hwcaps2 (int mask)
12468{
12469 if (mask)
12470 {
12471 int first = 1;
071436c6 12472
3d68f91c
JM		 12473 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12474 fputs ("fjathplus", stdout), first = 0;
12475 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12476 printf ("%svis3b", first ? "" : "|"), first = 0;
12477 if (mask & ELF_SPARC_HWCAP2_ADP)
12478 printf ("%sadp", first ? "" : "|"), first = 0;
12479 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12480 printf ("%ssparc5", first ? "" : "|"), first = 0;
12481 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12482 printf ("%smwait", first ? "" : "|"), first = 0;
12483 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12484 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12485 if (mask & ELF_SPARC_HWCAP2_XMONT)
12486 printf ("%sxmont2", first ? "" : "|"), first = 0;
12487 if (mask & ELF_SPARC_HWCAP2_NSEC)
12488 printf ("%snsec", first ? "" : "|"), first = 0;
12489 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12490 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12491 if (mask & ELF_SPARC_HWCAP2_FJDES)
12492 printf ("%sfjdes", first ? "" : "|"), first = 0;
12493 if (mask & ELF_SPARC_HWCAP2_FJAES)
12494 printf ("%sfjaes", first ? "" : "|"), first = 0;
12495 }
12496 else
071436c6
NC		 12497 fputc ('0', stdout);
12498 fputc ('\n', stdout);
3d68f91c
JM		 12499}
12500
9e8c70f9 12501static unsigned char *
f6f0e17b
NC		 12502display_sparc_gnu_attribute (unsigned char * p,
12503 int tag,
12504 const unsigned char * const end)
9e8c70f9 12505{
3d68f91c
JM		 12506 unsigned int len;
12507 int val;
12508
9e8c70f9
DM		 12509 if (tag == Tag_GNU_Sparc_HWCAPS)
12510 {
f6f0e17b 12511 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12512 p += len;
12513 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12514 display_sparc_hwcaps (val);
12515 return p;
3d68f91c
JM		 12516 }
12517 if (tag == Tag_GNU_Sparc_HWCAPS2)
12518 {
12519 val = read_uleb128 (p, &len, end);
12520 p += len;
12521 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12522 display_sparc_hwcaps2 (val);
12523 return p;
12524 }
9e8c70f9 12525
f6f0e17b 12526 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12527}
12528
351cdf24
MF		 12529static void
12530print_mips_fp_abi_value (int val)
12531{
12532 switch (val)
12533 {
12534 case Val_GNU_MIPS_ABI_FP_ANY:
12535 printf (_("Hard or soft float\n"));
12536 break;
12537 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12538 printf (_("Hard float (double precision)\n"));
12539 break;
12540 case Val_GNU_MIPS_ABI_FP_SINGLE:
12541 printf (_("Hard float (single precision)\n"));
12542 break;
12543 case Val_GNU_MIPS_ABI_FP_SOFT:
12544 printf (_("Soft float\n"));
12545 break;
12546 case Val_GNU_MIPS_ABI_FP_OLD_64:
12547 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12548 break;
12549 case Val_GNU_MIPS_ABI_FP_XX:
12550 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12551 break;
12552 case Val_GNU_MIPS_ABI_FP_64:
12553 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12554 break;
12555 case Val_GNU_MIPS_ABI_FP_64A:
12556 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12557 break;
12558 default:
12559 printf ("??? (%d)\n", val);
12560 break;
12561 }
12562}
12563
2cf19d5c 12564static unsigned char *
f6f0e17b
NC		 12565display_mips_gnu_attribute (unsigned char * p,
12566 int tag,
12567 const unsigned char * const end)
2cf19d5c 12568{
2cf19d5c
JM		 12569 if (tag == Tag_GNU_MIPS_ABI_FP)
12570 {
f6f0e17b
NC		 12571 unsigned int len;
12572 int val;
12573
12574 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12575 p += len;
12576 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12577
351cdf24
MF		 12578 print_mips_fp_abi_value (val);
12579
2cf19d5c
JM		 12580 return p;
12581 }
12582
a9f58168
CF		 12583 if (tag == Tag_GNU_MIPS_ABI_MSA)
12584 {
12585 unsigned int len;
12586 int val;
12587
12588 val = read_uleb128 (p, &len, end);
12589 p += len;
12590 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12591
12592 switch (val)
12593 {
12594 case Val_GNU_MIPS_ABI_MSA_ANY:
12595 printf (_("Any MSA or not\n"));
12596 break;
12597 case Val_GNU_MIPS_ABI_MSA_128:
12598 printf (_("128-bit MSA\n"));
12599 break;
12600 default:
12601 printf ("??? (%d)\n", val);
12602 break;
12603 }
12604 return p;
12605 }
12606
f6f0e17b 12607 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12608}
12609
59e6276b 12610static unsigned char *
f6f0e17b
NC		 12611display_tic6x_attribute (unsigned char * p,
12612 const unsigned char * const end)
59e6276b
JM		 12613{
12614 int tag;
12615 unsigned int len;
12616 int val;
12617
f6f0e17b 12618 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12619 p += len;
12620
12621 switch (tag)
12622 {
75fa6dc1 12623 case Tag_ISA:
f6f0e17b 12624 val = read_uleb128 (p, &len, end);
59e6276b 12625 p += len;
75fa6dc1 12626 printf (" Tag_ISA: ");
59e6276b
JM		 12627
12628 switch (val)
12629 {
75fa6dc1 12630 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12631 printf (_("None\n"));
12632 break;
75fa6dc1 12633 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12634 printf ("C62x\n");
12635 break;
75fa6dc1 12636 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12637 printf ("C67x\n");
12638 break;
75fa6dc1 12639 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12640 printf ("C67x+\n");
12641 break;
75fa6dc1 12642 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12643 printf ("C64x\n");
12644 break;
75fa6dc1 12645 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12646 printf ("C64x+\n");
12647 break;
75fa6dc1 12648 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12649 printf ("C674x\n");
12650 break;
12651 default:
12652 printf ("??? (%d)\n", val);
12653 break;
12654 }
12655 return p;
12656
87779176 12657 case Tag_ABI_wchar_t:
f6f0e17b 12658 val = read_uleb128 (p, &len, end);
87779176
JM		 12659 p += len;
12660 printf (" Tag_ABI_wchar_t: ");
12661 switch (val)
12662 {
12663 case 0:
12664 printf (_("Not used\n"));
12665 break;
12666 case 1:
12667 printf (_("2 bytes\n"));
12668 break;
12669 case 2:
12670 printf (_("4 bytes\n"));
12671 break;
12672 default:
12673 printf ("??? (%d)\n", val);
12674 break;
12675 }
12676 return p;
12677
12678 case Tag_ABI_stack_align_needed:
f6f0e17b 12679 val = read_uleb128 (p, &len, end);
87779176
JM		 12680 p += len;
12681 printf (" Tag_ABI_stack_align_needed: ");
12682 switch (val)
12683 {
12684 case 0:
12685 printf (_("8-byte\n"));
12686 break;
12687 case 1:
12688 printf (_("16-byte\n"));
12689 break;
12690 default:
12691 printf ("??? (%d)\n", val);
12692 break;
12693 }
12694 return p;
12695
12696 case Tag_ABI_stack_align_preserved:
f6f0e17b 12697 val = read_uleb128 (p, &len, end);
87779176
JM		 12698 p += len;
12699 printf (" Tag_ABI_stack_align_preserved: ");
12700 switch (val)
12701 {
12702 case 0:
12703 printf (_("8-byte\n"));
12704 break;
12705 case 1:
12706 printf (_("16-byte\n"));
12707 break;
12708 default:
12709 printf ("??? (%d)\n", val);
12710 break;
12711 }
12712 return p;
12713
b5593623 12714 case Tag_ABI_DSBT:
f6f0e17b 12715 val = read_uleb128 (p, &len, end);
b5593623
JM		 12716 p += len;
12717 printf (" Tag_ABI_DSBT: ");
12718 switch (val)
12719 {
12720 case 0:
12721 printf (_("DSBT addressing not used\n"));
12722 break;
12723 case 1:
12724 printf (_("DSBT addressing used\n"));
12725 break;
12726 default:
12727 printf ("??? (%d)\n", val);
12728 break;
12729 }
12730 return p;
12731
87779176 12732 case Tag_ABI_PID:
f6f0e17b 12733 val = read_uleb128 (p, &len, end);
87779176
JM		 12734 p += len;
12735 printf (" Tag_ABI_PID: ");
12736 switch (val)
12737 {
12738 case 0:
12739 printf (_("Data addressing position-dependent\n"));
12740 break;
12741 case 1:
12742 printf (_("Data addressing position-independent, GOT near DP\n"));
12743 break;
12744 case 2:
12745 printf (_("Data addressing position-independent, GOT far from DP\n"));
12746 break;
12747 default:
12748 printf ("??? (%d)\n", val);
12749 break;
12750 }
12751 return p;
12752
12753 case Tag_ABI_PIC:
f6f0e17b 12754 val = read_uleb128 (p, &len, end);
87779176
JM		 12755 p += len;
12756 printf (" Tag_ABI_PIC: ");
12757 switch (val)
12758 {
12759 case 0:
12760 printf (_("Code addressing position-dependent\n"));
12761 break;
12762 case 1:
12763 printf (_("Code addressing position-independent\n"));
12764 break;
12765 default:
12766 printf ("??? (%d)\n", val);
12767 break;
12768 }
12769 return p;
12770
12771 case Tag_ABI_array_object_alignment:
f6f0e17b 12772 val = read_uleb128 (p, &len, end);
87779176
JM		 12773 p += len;
12774 printf (" Tag_ABI_array_object_alignment: ");
12775 switch (val)
12776 {
12777 case 0:
12778 printf (_("8-byte\n"));
12779 break;
12780 case 1:
12781 printf (_("4-byte\n"));
12782 break;
12783 case 2:
12784 printf (_("16-byte\n"));
12785 break;
12786 default:
12787 printf ("??? (%d)\n", val);
12788 break;
12789 }
12790 return p;
12791
12792 case Tag_ABI_array_object_align_expected:
f6f0e17b 12793 val = read_uleb128 (p, &len, end);
87779176
JM		 12794 p += len;
12795 printf (" Tag_ABI_array_object_align_expected: ");
12796 switch (val)
12797 {
12798 case 0:
12799 printf (_("8-byte\n"));
12800 break;
12801 case 1:
12802 printf (_("4-byte\n"));
12803 break;
12804 case 2:
12805 printf (_("16-byte\n"));
12806 break;
12807 default:
12808 printf ("??? (%d)\n", val);
12809 break;
12810 }
12811 return p;
12812
3cbd1c06 12813 case Tag_ABI_compatibility:
071436c6 12814 {
071436c6
NC		 12815 val = read_uleb128 (p, &len, end);
12816 p += len;
12817 printf (" Tag_ABI_compatibility: ");
071436c6 12818 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12819 if (p < end - 1)
12820 {
12821 size_t maxlen = (end - p) - 1;
12822
12823 print_symbol ((int) maxlen, (const char *) p);
12824 p += strnlen ((char *) p, maxlen) + 1;
12825 }
12826 else
12827 {
12828 printf (_("<corrupt>"));
12829 p = (unsigned char *) end;
12830 }
071436c6 12831 putchar ('\n');
071436c6
NC		 12832 return p;
12833 }
87779176
JM		 12834
12835 case Tag_ABI_conformance:
071436c6 12836 {
4082ef84
NC		 12837 printf (" Tag_ABI_conformance: \"");
12838 if (p < end - 1)
12839 {
12840 size_t maxlen = (end - p) - 1;
071436c6 12841
4082ef84
NC		 12842 print_symbol ((int) maxlen, (const char *) p);
12843 p += strnlen ((char *) p, maxlen) + 1;
12844 }
12845 else
12846 {
12847 printf (_("<corrupt>"));
12848 p = (unsigned char *) end;
12849 }
071436c6 12850 printf ("\"\n");
071436c6
NC		 12851 return p;
12852 }
59e6276b
JM		 12853 }
12854
f6f0e17b
NC		 12855 return display_tag_value (tag, p, end);
12856}
59e6276b 12857
f6f0e17b
NC		 12858static void
12859display_raw_attribute (unsigned char * p, unsigned char * end)
12860{
12861 unsigned long addr = 0;
12862 size_t bytes = end - p;
12863
e0a31db1 12864 assert (end > p);
f6f0e17b 12865 while (bytes)
87779176 12866 {
f6f0e17b
NC		 12867 int j;
12868 int k;
12869 int lbytes = (bytes > 16 ? 16 : bytes);
12870
12871 printf (" 0x%8.8lx ", addr);
12872
12873 for (j = 0; j < 16; j++)
12874 {
12875 if (j < lbytes)
12876 printf ("%2.2x", p[j]);
12877 else
12878 printf (" ");
12879
12880 if ((j & 3) == 3)
12881 printf (" ");
12882 }
12883
12884 for (j = 0; j < lbytes; j++)
12885 {
12886 k = p[j];
12887 if (k >= ' ' && k < 0x7f)
12888 printf ("%c", k);
12889 else
12890 printf (".");
12891 }
12892
12893 putchar ('\n');
12894
12895 p += lbytes;
12896 bytes -= lbytes;
12897 addr += lbytes;
87779176 12898 }
59e6276b 12899
f6f0e17b 12900 putchar ('\n');
59e6276b
JM		 12901}
12902
13761a11
NC		 12903static unsigned char *
12904display_msp430x_attribute (unsigned char * p,
12905 const unsigned char * const end)
12906{
12907 unsigned int len;
12908 int val;
12909 int tag;
12910
12911 tag = read_uleb128 (p, & len, end);
12912 p += len;
0b4362b0 12913
13761a11
NC		 12914 switch (tag)
12915 {
12916 case OFBA_MSPABI_Tag_ISA:
12917 val = read_uleb128 (p, &len, end);
12918 p += len;
12919 printf (" Tag_ISA: ");
12920 switch (val)
12921 {
12922 case 0: printf (_("None\n")); break;
12923 case 1: printf (_("MSP430\n")); break;
12924 case 2: printf (_("MSP430X\n")); break;
12925 default: printf ("??? (%d)\n", val); break;
12926 }
12927 break;
12928
12929 case OFBA_MSPABI_Tag_Code_Model:
12930 val = read_uleb128 (p, &len, end);
12931 p += len;
12932 printf (" Tag_Code_Model: ");
12933 switch (val)
12934 {
12935 case 0: printf (_("None\n")); break;
12936 case 1: printf (_("Small\n")); break;
12937 case 2: printf (_("Large\n")); break;
12938 default: printf ("??? (%d)\n", val); break;
12939 }
12940 break;
12941
12942 case OFBA_MSPABI_Tag_Data_Model:
12943 val = read_uleb128 (p, &len, end);
12944 p += len;
12945 printf (" Tag_Data_Model: ");
12946 switch (val)
12947 {
12948 case 0: printf (_("None\n")); break;
12949 case 1: printf (_("Small\n")); break;
12950 case 2: printf (_("Large\n")); break;
12951 case 3: printf (_("Restricted Large\n")); break;
12952 default: printf ("??? (%d)\n", val); break;
12953 }
12954 break;
12955
12956 default:
12957 printf (_(" <unknown tag %d>: "), tag);
12958
12959 if (tag & 1)
12960 {
071436c6 12961 putchar ('"');
4082ef84
NC		 12962 if (p < end - 1)
12963 {
12964 size_t maxlen = (end - p) - 1;
12965
12966 print_symbol ((int) maxlen, (const char *) p);
12967 p += strnlen ((char *) p, maxlen) + 1;
12968 }
12969 else
12970 {
12971 printf (_("<corrupt>"));
12972 p = (unsigned char *) end;
12973 }
071436c6 12974 printf ("\"\n");
13761a11
NC		 12975 }
12976 else
12977 {
12978 val = read_uleb128 (p, &len, end);
12979 p += len;
12980 printf ("%d (0x%x)\n", val, val);
12981 }
12982 break;
12983 }
12984
4082ef84 12985 assert (p <= end);
13761a11
NC		 12986 return p;
12987}
12988
11c1ff18 12989static int
60bca95a
NC		 12990process_attributes (FILE * file,
12991 const char * public_name,
104d59d1 12992 unsigned int proc_type,
f6f0e17b
NC		 12993 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12994 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 12995{
2cf0635d 12996 Elf_Internal_Shdr * sect;
11c1ff18
PB		 12997 unsigned i;
12998
12999 /* Find the section header so that we get the size. */
13000 for (i = 0, sect = section_headers;
13001 i < elf_header.e_shnum;
13002 i++, sect++)
13003 {
071436c6
NC		 13004 unsigned char * contents;
13005 unsigned char * p;
13006
104d59d1 13007 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13008 continue;
13009
3f5e193b
NC		 13010 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13011 sect->sh_size, _("attributes"));
60bca95a 13012 if (contents == NULL)
11c1ff18 13013 continue;
60bca95a 13014
11c1ff18
PB		 13015 p = contents;
13016 if (*p == 'A')
13017 {
071436c6
NC		 13018 bfd_vma section_len;
13019
13020 section_len = sect->sh_size - 1;
11c1ff18 13021 p++;
60bca95a 13022
071436c6 13023 while (section_len > 0)
11c1ff18 13024 {
071436c6 13025 bfd_vma attr_len;
e9847026 13026 unsigned int namelen;
11c1ff18 13027 bfd_boolean public_section;
104d59d1 13028 bfd_boolean gnu_section;
11c1ff18 13029
071436c6 13030 if (section_len <= 4)
e0a31db1
NC		 13031 {
13032 error (_("Tag section ends prematurely\n"));
13033 break;
13034 }
071436c6 13035 attr_len = byte_get (p, 4);
11c1ff18 13036 p += 4;
60bca95a 13037
071436c6 13038 if (attr_len > section_len)
11c1ff18 13039 {
071436c6
NC		 13040 error (_("Bad attribute length (%u > %u)\n"),
13041 (unsigned) attr_len, (unsigned) section_len);
13042 attr_len = section_len;
11c1ff18 13043 }
74e1a04b 13044 /* PR 17531: file: 001-101425-0.004 */
071436c6 13045 else if (attr_len < 5)
74e1a04b 13046 {
071436c6 13047 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13048 break;
13049 }
e9847026 13050
071436c6
NC		 13051 section_len -= attr_len;
13052 attr_len -= 4;
13053
13054 namelen = strnlen ((char *) p, attr_len) + 1;
13055 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13056 {
13057 error (_("Corrupt attribute section name\n"));
13058 break;
13059 }
13060
071436c6
NC		 13061 printf (_("Attribute Section: "));
13062 print_symbol (INT_MAX, (const char *) p);
13063 putchar ('\n');
60bca95a
NC		 13064
13065 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13066 public_section = TRUE;
13067 else
13068 public_section = FALSE;
60bca95a
NC		 13069
13070 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13071 gnu_section = TRUE;
13072 else
13073 gnu_section = FALSE;
60bca95a 13074
11c1ff18 13075 p += namelen;
071436c6 13076 attr_len -= namelen;
e0a31db1 13077
071436c6 13078 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13079 {
e0a31db1 13080 int tag;
11c1ff18
PB		 13081 int val;
13082 bfd_vma size;
071436c6 13083 unsigned char * end;
60bca95a 13084
e0a31db1 13085 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13086 if (attr_len < 6)
e0a31db1
NC		 13087 {
13088 error (_("Unused bytes at end of section\n"));
13089 section_len = 0;
13090 break;
13091 }
13092
13093 tag = *(p++);
11c1ff18 13094 size = byte_get (p, 4);
071436c6 13095 if (size > attr_len)
11c1ff18 13096 {
e9847026 13097 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13098 (unsigned) size, (unsigned) attr_len);
13099 size = attr_len;
11c1ff18 13100 }
e0a31db1
NC		 13101 /* PR binutils/17531: Safe handling of corrupt files. */
13102 if (size < 6)
13103 {
13104 error (_("Bad subsection length (%u < 6)\n"),
13105 (unsigned) size);
13106 section_len = 0;
13107 break;
13108 }
60bca95a 13109
071436c6 13110 attr_len -= size;
11c1ff18 13111 end = p + size - 1;
071436c6 13112 assert (end <= contents + sect->sh_size);
11c1ff18 13113 p += 4;
60bca95a 13114
11c1ff18
PB		 13115 switch (tag)
13116 {
13117 case 1:
2b692964 13118 printf (_("File Attributes\n"));
11c1ff18
PB		 13119 break;
13120 case 2:
2b692964 13121 printf (_("Section Attributes:"));
11c1ff18
PB		 13122 goto do_numlist;
13123 case 3:
2b692964 13124 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13125 do_numlist:
13126 for (;;)
13127 {
91d6fa6a 13128 unsigned int j;
60bca95a 13129
f6f0e17b 13130 val = read_uleb128 (p, &j, end);
91d6fa6a 13131 p += j;
11c1ff18
PB		 13132 if (val == 0)
13133 break;
13134 printf (" %d", val);
13135 }
13136 printf ("\n");
13137 break;
13138 default:
2b692964 13139 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13140 public_section = FALSE;
13141 break;
13142 }
60bca95a 13143
071436c6 13144 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13145 {
13146 while (p < end)
f6f0e17b 13147 p = display_pub_attribute (p, end);
071436c6 13148 assert (p <= end);
104d59d1 13149 }
071436c6 13150 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13151 {
13152 while (p < end)
13153 p = display_gnu_attribute (p,
f6f0e17b
NC		 13154 display_proc_gnu_attribute,
13155 end);
071436c6 13156 assert (p <= end);
11c1ff18 13157 }
071436c6 13158 else if (p < end)
11c1ff18 13159 {
071436c6 13160 printf (_(" Unknown attribute:\n"));
f6f0e17b 13161 display_raw_attribute (p, end);
11c1ff18
PB		 13162 p = end;
13163 }
071436c6
NC		 13164 else
13165 attr_len = 0;
11c1ff18
PB		 13166 }
13167 }
13168 }
13169 else
e9847026 13170 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13171
60bca95a 13172 free (contents);
11c1ff18
PB		 13173 }
13174 return 1;
13175}
13176
104d59d1 13177static int
2cf0635d 13178process_arm_specific (FILE * file)
104d59d1
JM		 13179{
13180 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13181 display_arm_attribute, NULL);
13182}
13183
34c8bcba 13184static int
2cf0635d 13185process_power_specific (FILE * file)
34c8bcba
JM		 13186{
13187 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13188 display_power_gnu_attribute);
13189}
13190
9e8c70f9
DM		 13191static int
13192process_sparc_specific (FILE * file)
13193{
13194 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13195 display_sparc_gnu_attribute);
13196}
13197
59e6276b
JM		 13198static int
13199process_tic6x_specific (FILE * file)
13200{
13201 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13202 display_tic6x_attribute, NULL);
13203}
13204
13761a11
NC		 13205static int
13206process_msp430x_specific (FILE * file)
13207{
13208 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13209 display_msp430x_attribute, NULL);
13210}
13211
ccb4c951
RS		 13212/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13213 Print the Address, Access and Initial fields of an entry at VMA ADDR
13214 and return the VMA of the next entry. */
13215
13216static bfd_vma
2cf0635d 13217print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 13218{
13219 printf (" ");
13220 print_vma (addr, LONG_HEX);
13221 printf (" ");
13222 if (addr < pltgot + 0xfff0)
13223 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13224 else
13225 printf ("%10s", "");
13226 printf (" ");
13227 if (data == NULL)
2b692964 13228 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13229 else
13230 {
13231 bfd_vma entry;
13232
13233 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13234 print_vma (entry, LONG_HEX);
13235 }
13236 return addr + (is_32bit_elf ? 4 : 8);
13237}
13238
861fb55a
DJ		 13239/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13240 PLTGOT. Print the Address and Initial fields of an entry at VMA
13241 ADDR and return the VMA of the next entry. */
13242
13243static bfd_vma
2cf0635d 13244print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13245{
13246 printf (" ");
13247 print_vma (addr, LONG_HEX);
13248 printf (" ");
13249 if (data == NULL)
2b692964 13250 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13251 else
13252 {
13253 bfd_vma entry;
13254
13255 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13256 print_vma (entry, LONG_HEX);
13257 }
13258 return addr + (is_32bit_elf ? 4 : 8);
13259}
13260
351cdf24
MF		 13261static void
13262print_mips_ases (unsigned int mask)
13263{
13264 if (mask & AFL_ASE_DSP)
13265 fputs ("\n\tDSP ASE", stdout);
13266 if (mask & AFL_ASE_DSPR2)
13267 fputs ("\n\tDSP R2 ASE", stdout);
13268 if (mask & AFL_ASE_EVA)
13269 fputs ("\n\tEnhanced VA Scheme", stdout);
13270 if (mask & AFL_ASE_MCU)
13271 fputs ("\n\tMCU (MicroController) ASE", stdout);
13272 if (mask & AFL_ASE_MDMX)
13273 fputs ("\n\tMDMX ASE", stdout);
13274 if (mask & AFL_ASE_MIPS3D)
13275 fputs ("\n\tMIPS-3D ASE", stdout);
13276 if (mask & AFL_ASE_MT)
13277 fputs ("\n\tMT ASE", stdout);
13278 if (mask & AFL_ASE_SMARTMIPS)
13279 fputs ("\n\tSmartMIPS ASE", stdout);
13280 if (mask & AFL_ASE_VIRT)
13281 fputs ("\n\tVZ ASE", stdout);
13282 if (mask & AFL_ASE_MSA)
13283 fputs ("\n\tMSA ASE", stdout);
13284 if (mask & AFL_ASE_MIPS16)
13285 fputs ("\n\tMIPS16 ASE", stdout);
13286 if (mask & AFL_ASE_MICROMIPS)
13287 fputs ("\n\tMICROMIPS ASE", stdout);
13288 if (mask & AFL_ASE_XPA)
13289 fputs ("\n\tXPA ASE", stdout);
13290 if (mask == 0)
13291 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13292 else if ((mask & ~AFL_ASE_MASK) != 0)
13293 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13294}
13295
13296static void
13297print_mips_isa_ext (unsigned int isa_ext)
13298{
13299 switch (isa_ext)
13300 {
13301 case 0:
13302 fputs (_("None"), stdout);
13303 break;
13304 case AFL_EXT_XLR:
13305 fputs ("RMI XLR", stdout);
13306 break;
2c629856
N		 13307 case AFL_EXT_OCTEON3:
13308 fputs ("Cavium Networks Octeon3", stdout);
13309 break;
351cdf24
MF		 13310 case AFL_EXT_OCTEON2:
13311 fputs ("Cavium Networks Octeon2", stdout);
13312 break;
13313 case AFL_EXT_OCTEONP:
13314 fputs ("Cavium Networks OcteonP", stdout);
13315 break;
13316 case AFL_EXT_LOONGSON_3A:
13317 fputs ("Loongson 3A", stdout);
13318 break;
13319 case AFL_EXT_OCTEON:
13320 fputs ("Cavium Networks Octeon", stdout);
13321 break;
13322 case AFL_EXT_5900:
13323 fputs ("Toshiba R5900", stdout);
13324 break;
13325 case AFL_EXT_4650:
13326 fputs ("MIPS R4650", stdout);
13327 break;
13328 case AFL_EXT_4010:
13329 fputs ("LSI R4010", stdout);
13330 break;
13331 case AFL_EXT_4100:
13332 fputs ("NEC VR4100", stdout);
13333 break;
13334 case AFL_EXT_3900:
13335 fputs ("Toshiba R3900", stdout);
13336 break;
13337 case AFL_EXT_10000:
13338 fputs ("MIPS R10000", stdout);
13339 break;
13340 case AFL_EXT_SB1:
13341 fputs ("Broadcom SB-1", stdout);
13342 break;
13343 case AFL_EXT_4111:
13344 fputs ("NEC VR4111/VR4181", stdout);
13345 break;
13346 case AFL_EXT_4120:
13347 fputs ("NEC VR4120", stdout);
13348 break;
13349 case AFL_EXT_5400:
13350 fputs ("NEC VR5400", stdout);
13351 break;
13352 case AFL_EXT_5500:
13353 fputs ("NEC VR5500", stdout);
13354 break;
13355 case AFL_EXT_LOONGSON_2E:
13356 fputs ("ST Microelectronics Loongson 2E", stdout);
13357 break;
13358 case AFL_EXT_LOONGSON_2F:
13359 fputs ("ST Microelectronics Loongson 2F", stdout);
13360 break;
13361 default:
00ac7aa0 13362 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13363 }
13364}
13365
13366static int
13367get_mips_reg_size (int reg_size)
13368{
13369 return (reg_size == AFL_REG_NONE) ? 0
13370 : (reg_size == AFL_REG_32) ? 32
13371 : (reg_size == AFL_REG_64) ? 64
13372 : (reg_size == AFL_REG_128) ? 128
13373 : -1;
13374}
13375
19e6b90e 13376static int
2cf0635d 13377process_mips_specific (FILE * file)
5b18a4bc 13378{
2cf0635d 13379 Elf_Internal_Dyn * entry;
351cdf24 13380 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13381 size_t liblist_offset = 0;
13382 size_t liblistno = 0;
13383 size_t conflictsno = 0;
13384 size_t options_offset = 0;
13385 size_t conflicts_offset = 0;
861fb55a
DJ		 13386 size_t pltrelsz = 0;
13387 size_t pltrel = 0;
ccb4c951 13388 bfd_vma pltgot = 0;
861fb55a
DJ		 13389 bfd_vma mips_pltgot = 0;
13390 bfd_vma jmprel = 0;
ccb4c951
RS		 13391 bfd_vma local_gotno = 0;
13392 bfd_vma gotsym = 0;
13393 bfd_vma symtabno = 0;
103f02d3 13394
2cf19d5c
JM		 13395 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13396 display_mips_gnu_attribute);
13397
351cdf24
MF		 13398 sect = find_section (".MIPS.abiflags");
13399
13400 if (sect != NULL)
13401 {
13402 Elf_External_ABIFlags_v0 *abiflags_ext;
13403 Elf_Internal_ABIFlags_v0 abiflags_in;
13404
13405 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13406 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13407 else
13408 {
13409 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13410 sect->sh_size, _("MIPS ABI Flags section"));
13411 if (abiflags_ext)
13412 {
13413 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13414 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13415 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13416 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13417 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13418 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13419 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13420 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13421 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13422 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13423 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13424
13425 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13426 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13427 if (abiflags_in.isa_rev > 1)
13428 printf ("r%d", abiflags_in.isa_rev);
13429 printf ("\nGPR size: %d",
13430 get_mips_reg_size (abiflags_in.gpr_size));
13431 printf ("\nCPR1 size: %d",
13432 get_mips_reg_size (abiflags_in.cpr1_size));
13433 printf ("\nCPR2 size: %d",
13434 get_mips_reg_size (abiflags_in.cpr2_size));
13435 fputs ("\nFP ABI: ", stdout);
13436 print_mips_fp_abi_value (abiflags_in.fp_abi);
13437 fputs ("ISA Extension: ", stdout);
13438 print_mips_isa_ext (abiflags_in.isa_ext);
13439 fputs ("\nASEs:", stdout);
13440 print_mips_ases (abiflags_in.ases);
13441 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13442 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13443 fputc ('\n', stdout);
13444 free (abiflags_ext);
13445 }
13446 }
13447 }
13448
19e6b90e
L		 13449 /* We have a lot of special sections. Thanks SGI! */
13450 if (dynamic_section == NULL)
13451 /* No information available. */
13452 return 0;
252b5132 13453
071436c6
NC		 13454 for (entry = dynamic_section;
13455 /* PR 17531 file: 012-50589-0.004. */
13456 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13457 ++entry)
252b5132
RH		 13458 switch (entry->d_tag)
13459 {
13460 case DT_MIPS_LIBLIST:
d93f0186
NC		 13461 liblist_offset
13462 = offset_from_vma (file, entry->d_un.d_val,
13463 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13464 break;
13465 case DT_MIPS_LIBLISTNO:
13466 liblistno = entry->d_un.d_val;
13467 break;
13468 case DT_MIPS_OPTIONS:
d93f0186 13469 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13470 break;
13471 case DT_MIPS_CONFLICT:
d93f0186
NC		 13472 conflicts_offset
13473 = offset_from_vma (file, entry->d_un.d_val,
13474 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13475 break;
13476 case DT_MIPS_CONFLICTNO:
13477 conflictsno = entry->d_un.d_val;
13478 break;
ccb4c951 13479 case DT_PLTGOT:
861fb55a
DJ		 13480 pltgot = entry->d_un.d_ptr;
13481 break;
ccb4c951
RS		 13482 case DT_MIPS_LOCAL_GOTNO:
13483 local_gotno = entry->d_un.d_val;
13484 break;
13485 case DT_MIPS_GOTSYM:
13486 gotsym = entry->d_un.d_val;
13487 break;
13488 case DT_MIPS_SYMTABNO:
13489 symtabno = entry->d_un.d_val;
13490 break;
861fb55a
DJ		 13491 case DT_MIPS_PLTGOT:
13492 mips_pltgot = entry->d_un.d_ptr;
13493 break;
13494 case DT_PLTREL:
13495 pltrel = entry->d_un.d_val;
13496 break;
13497 case DT_PLTRELSZ:
13498 pltrelsz = entry->d_un.d_val;
13499 break;
13500 case DT_JMPREL:
13501 jmprel = entry->d_un.d_ptr;
13502 break;
252b5132
RH		 13503 default:
13504 break;
13505 }
13506
13507 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13508 {
2cf0635d 13509 Elf32_External_Lib * elib;
252b5132
RH		 13510 size_t cnt;
13511
3f5e193b
NC		 13512 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13513 liblistno,
13514 sizeof (Elf32_External_Lib),
9cf03b7e 13515 _("liblist section data"));
a6e9f9df 13516 if (elib)
252b5132 13517 {
2b692964 13518 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13519 (unsigned long) liblistno);
2b692964 13520 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13521 stdout);
13522
13523 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13524 {
a6e9f9df 13525 Elf32_Lib liblist;
91d6fa6a 13526 time_t atime;
a6e9f9df 13527 char timebuf[20];
2cf0635d 13528 struct tm * tmp;
a6e9f9df
AM		 13529
13530 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13531 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13532 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13533 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13534 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13535
91d6fa6a 13536 tmp = gmtime (&atime);
e9e44622
JJ		 13537 snprintf (timebuf, sizeof (timebuf),
13538 "%04u-%02u-%02uT%02u:%02u:%02u",
13539 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13540 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13541
31104126 13542 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13543 if (VALID_DYNAMIC_NAME (liblist.l_name))
13544 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13545 else
2b692964 13546 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13547 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13548 liblist.l_version);
a6e9f9df
AM		 13549
13550 if (liblist.l_flags == 0)
2b692964 13551 puts (_(" NONE"));
a6e9f9df
AM		 13552 else
13553 {
13554 static const struct
252b5132 13555 {
2cf0635d 13556 const char * name;
a6e9f9df 13557 int bit;
252b5132 13558 }
a6e9f9df
AM		 13559 l_flags_vals[] =
13560 {
13561 { " EXACT_MATCH", LL_EXACT_MATCH },
13562 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13563 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13564 { " EXPORTS", LL_EXPORTS },
13565 { " DELAY_LOAD", LL_DELAY_LOAD },
13566 { " DELTA", LL_DELTA }
13567 };
13568 int flags = liblist.l_flags;
13569 size_t fcnt;
13570
60bca95a 13571 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13572 if ((flags & l_flags_vals[fcnt].bit) != 0)
13573 {
13574 fputs (l_flags_vals[fcnt].name, stdout);
13575 flags ^= l_flags_vals[fcnt].bit;
13576 }
13577 if (flags != 0)
13578 printf (" %#x", (unsigned int) flags);
252b5132 13579
a6e9f9df
AM		 13580 puts ("");
13581 }
252b5132 13582 }
252b5132 13583
a6e9f9df
AM		 13584 free (elib);
13585 }
252b5132
RH		 13586 }
13587
13588 if (options_offset != 0)
13589 {
2cf0635d 13590 Elf_External_Options * eopt;
2cf0635d
NC		 13591 Elf_Internal_Options * iopt;
13592 Elf_Internal_Options * option;
252b5132
RH		 13593 size_t offset;
13594 int cnt;
351cdf24 13595 sect = section_headers;
252b5132
RH		 13596
13597 /* Find the section header so that we get the size. */
071436c6
NC		 13598 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13599 /* PR 17533 file: 012-277276-0.004. */
13600 if (sect == NULL)
13601 {
13602 error (_("No MIPS_OPTIONS header found\n"));
13603 return 0;
13604 }
252b5132 13605
3f5e193b
NC		 13606 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13607 sect->sh_size, _("options"));
a6e9f9df 13608 if (eopt)
252b5132 13609 {
3f5e193b
NC		 13610 iopt = (Elf_Internal_Options *)
13611 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13612 if (iopt == NULL)
13613 {
8b73c356 13614 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 13615 return 0;
13616 }
76da6bbe 13617
a6e9f9df
AM		 13618 offset = cnt = 0;
13619 option = iopt;
252b5132 13620
a6e9f9df
AM		 13621 while (offset < sect->sh_size)
13622 {
2cf0635d 13623 Elf_External_Options * eoption;
252b5132 13624
a6e9f9df 13625 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13626
a6e9f9df
AM		 13627 option->kind = BYTE_GET (eoption->kind);
13628 option->size = BYTE_GET (eoption->size);
13629 option->section = BYTE_GET (eoption->section);
13630 option->info = BYTE_GET (eoption->info);
76da6bbe 13631
a6e9f9df 13632 offset += option->size;
252b5132 13633
a6e9f9df
AM		 13634 ++option;
13635 ++cnt;
13636 }
252b5132 13637
a6e9f9df 13638 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 13639 printable_section_name (sect), cnt);
76da6bbe 13640
a6e9f9df 13641 option = iopt;
252b5132 13642
a6e9f9df 13643 while (cnt-- > 0)
252b5132 13644 {
a6e9f9df
AM		 13645 size_t len;
13646
13647 switch (option->kind)
252b5132 13648 {
a6e9f9df
AM		 13649 case ODK_NULL:
13650 /* This shouldn't happen. */
13651 printf (" NULL %d %lx", option->section, option->info);
13652 break;
13653 case ODK_REGINFO:
13654 printf (" REGINFO ");
13655 if (elf_header.e_machine == EM_MIPS)
13656 {
13657 /* 32bit form. */
2cf0635d 13658 Elf32_External_RegInfo * ereg;
b34976b6 13659 Elf32_RegInfo reginfo;
a6e9f9df
AM		 13660
13661 ereg = (Elf32_External_RegInfo *) (option + 1);
13662 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13663 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13664 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13665 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13666 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13667 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13668
13669 printf ("GPR %08lx GP 0x%lx\n",
13670 reginfo.ri_gprmask,
13671 (unsigned long) reginfo.ri_gp_value);
13672 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13673 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13674 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13675 }
13676 else
13677 {
13678 /* 64 bit form. */
2cf0635d 13679 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 13680 Elf64_Internal_RegInfo reginfo;
13681
13682 ereg = (Elf64_External_RegInfo *) (option + 1);
13683 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13684 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13685 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13686 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13687 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 13688 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 13689
13690 printf ("GPR %08lx GP 0x",
13691 reginfo.ri_gprmask);
13692 printf_vma (reginfo.ri_gp_value);
13693 printf ("\n");
13694
13695 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13696 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13697 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13698 }
13699 ++option;
13700 continue;
13701 case ODK_EXCEPTIONS:
13702 fputs (" EXCEPTIONS fpe_min(", stdout);
13703 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13704 fputs (") fpe_max(", stdout);
13705 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13706 fputs (")", stdout);
13707
13708 if (option->info & OEX_PAGE0)
13709 fputs (" PAGE0", stdout);
13710 if (option->info & OEX_SMM)
13711 fputs (" SMM", stdout);
13712 if (option->info & OEX_FPDBUG)
13713 fputs (" FPDBUG", stdout);
13714 if (option->info & OEX_DISMISS)
13715 fputs (" DISMISS", stdout);
13716 break;
13717 case ODK_PAD:
13718 fputs (" PAD ", stdout);
13719 if (option->info & OPAD_PREFIX)
13720 fputs (" PREFIX", stdout);
13721 if (option->info & OPAD_POSTFIX)
13722 fputs (" POSTFIX", stdout);
13723 if (option->info & OPAD_SYMBOL)
13724 fputs (" SYMBOL", stdout);
13725 break;
13726 case ODK_HWPATCH:
13727 fputs (" HWPATCH ", stdout);
13728 if (option->info & OHW_R4KEOP)
13729 fputs (" R4KEOP", stdout);
13730 if (option->info & OHW_R8KPFETCH)
13731 fputs (" R8KPFETCH", stdout);
13732 if (option->info & OHW_R5KEOP)
13733 fputs (" R5KEOP", stdout);
13734 if (option->info & OHW_R5KCVTL)
13735 fputs (" R5KCVTL", stdout);
13736 break;
13737 case ODK_FILL:
13738 fputs (" FILL ", stdout);
13739 /* XXX Print content of info word? */
13740 break;
13741 case ODK_TAGS:
13742 fputs (" TAGS ", stdout);
13743 /* XXX Print content of info word? */
13744 break;
13745 case ODK_HWAND:
13746 fputs (" HWAND ", stdout);
13747 if (option->info & OHWA0_R4KEOP_CHECKED)
13748 fputs (" R4KEOP_CHECKED", stdout);
13749 if (option->info & OHWA0_R4KEOP_CLEAN)
13750 fputs (" R4KEOP_CLEAN", stdout);
13751 break;
13752 case ODK_HWOR:
13753 fputs (" HWOR ", stdout);
13754 if (option->info & OHWA0_R4KEOP_CHECKED)
13755 fputs (" R4KEOP_CHECKED", stdout);
13756 if (option->info & OHWA0_R4KEOP_CLEAN)
13757 fputs (" R4KEOP_CLEAN", stdout);
13758 break;
13759 case ODK_GP_GROUP:
13760 printf (" GP_GROUP %#06lx self-contained %#06lx",
13761 option->info & OGP_GROUP,
13762 (option->info & OGP_SELF) >> 16);
13763 break;
13764 case ODK_IDENT:
13765 printf (" IDENT %#06lx self-contained %#06lx",
13766 option->info & OGP_GROUP,
13767 (option->info & OGP_SELF) >> 16);
13768 break;
13769 default:
13770 /* This shouldn't happen. */
13771 printf (" %3d ??? %d %lx",
13772 option->kind, option->section, option->info);
13773 break;
252b5132 13774 }
a6e9f9df 13775
2cf0635d 13776 len = sizeof (* eopt);
a6e9f9df
AM		 13777 while (len < option->size)
13778 if (((char *) option)[len] >= ' '
13779 && ((char *) option)[len] < 0x7f)
13780 printf ("%c", ((char *) option)[len++]);
13781 else
13782 printf ("\\%03o", ((char *) option)[len++]);
13783
13784 fputs ("\n", stdout);
252b5132 13785 ++option;
252b5132
RH		 13786 }
13787
a6e9f9df 13788 free (eopt);
252b5132 13789 }
252b5132
RH		 13790 }
13791
13792 if (conflicts_offset != 0 && conflictsno != 0)
13793 {
2cf0635d 13794 Elf32_Conflict * iconf;
252b5132
RH		 13795 size_t cnt;
13796
13797 if (dynamic_symbols == NULL)
13798 {
591a748a 13799 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 13800 return 0;
13801 }
13802
3f5e193b 13803 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 13804 if (iconf == NULL)
13805 {
8b73c356 13806 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 13807 return 0;
13808 }
13809
9ea033b2 13810 if (is_32bit_elf)
252b5132 13811 {
2cf0635d 13812 Elf32_External_Conflict * econf32;
a6e9f9df 13813
3f5e193b
NC		 13814 econf32 = (Elf32_External_Conflict *)
13815 get_data (NULL, file, conflicts_offset, conflictsno,
13816 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 13817 if (!econf32)
13818 return 0;
252b5132
RH		 13819
13820 for (cnt = 0; cnt < conflictsno; ++cnt)
13821 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 13822
13823 free (econf32);
252b5132
RH		 13824 }
13825 else
13826 {
2cf0635d 13827 Elf64_External_Conflict * econf64;
a6e9f9df 13828
3f5e193b
NC		 13829 econf64 = (Elf64_External_Conflict *)
13830 get_data (NULL, file, conflicts_offset, conflictsno,
13831 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 13832 if (!econf64)
13833 return 0;
252b5132
RH		 13834
13835 for (cnt = 0; cnt < conflictsno; ++cnt)
13836 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 13837
13838 free (econf64);
252b5132
RH		 13839 }
13840
c7e7ca54
NC		 13841 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13842 (unsigned long) conflictsno);
252b5132
RH		 13843 puts (_(" Num: Index Value Name"));
13844
13845 for (cnt = 0; cnt < conflictsno; ++cnt)
13846 {
b34976b6 13847 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 13848
13849 if (iconf[cnt] >= num_dynamic_syms)
13850 printf (_("<corrupt symbol index>"));
d79b3d50 13851 else
e0a31db1
NC		 13852 {
13853 Elf_Internal_Sym * psym;
13854
13855 psym = & dynamic_symbols[iconf[cnt]];
13856 print_vma (psym->st_value, FULL_HEX);
13857 putchar (' ');
13858 if (VALID_DYNAMIC_NAME (psym->st_name))
13859 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13860 else
13861 printf (_("<corrupt: %14ld>"), psym->st_name);
13862 }
31104126 13863 putchar ('\n');
252b5132
RH		 13864 }
13865
252b5132
RH		 13866 free (iconf);
13867 }
13868
ccb4c951
RS		 13869 if (pltgot != 0 && local_gotno != 0)
13870 {
91d6fa6a 13871 bfd_vma ent, local_end, global_end;
bbeee7ea 13872 size_t i, offset;
2cf0635d 13873 unsigned char * data;
bbeee7ea 13874 int addr_size;
ccb4c951 13875
91d6fa6a 13876 ent = pltgot;
ccb4c951
RS		 13877 addr_size = (is_32bit_elf ? 4 : 8);
13878 local_end = pltgot + local_gotno * addr_size;
ccb4c951 13879
74e1a04b
NC		 13880 /* PR binutils/17533 file: 012-111227-0.004 */
13881 if (symtabno < gotsym)
13882 {
13883 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13884 (long) gotsym, (long) symtabno);
13885 return 0;
13886 }
13887
13888 global_end = local_end + (symtabno - gotsym) * addr_size;
13889 assert (global_end >= local_end);
ccb4c951 13890 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 13891 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 13892 global_end - pltgot, 1,
13893 _("Global Offset Table data"));
59245841
NC		 13894 if (data == NULL)
13895 return 0;
13896
ccb4c951
RS		 13897 printf (_("\nPrimary GOT:\n"));
13898 printf (_(" Canonical gp value: "));
13899 print_vma (pltgot + 0x7ff0, LONG_HEX);
13900 printf ("\n\n");
13901
13902 printf (_(" Reserved entries:\n"));
13903 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 13904 addr_size * 2, _("Address"), _("Access"),
13905 addr_size * 2, _("Initial"));
91d6fa6a 13906 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13907 printf (_(" Lazy resolver\n"));
ccb4c951 13908 if (data
91d6fa6a 13909 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 13910 >> (addr_size * 8 - 1)) != 0)
13911 {
91d6fa6a 13912 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13913 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 13914 }
13915 printf ("\n");
13916
91d6fa6a 13917 if (ent < local_end)
ccb4c951
RS		 13918 {
13919 printf (_(" Local entries:\n"));
cc5914eb 13920 printf (" %*s %10s %*s\n",
2b692964
NC		 13921 addr_size * 2, _("Address"), _("Access"),
13922 addr_size * 2, _("Initial"));
91d6fa6a 13923 while (ent < local_end)
ccb4c951 13924 {
91d6fa6a 13925 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 13926 printf ("\n");
13927 }
13928 printf ("\n");
13929 }
13930
13931 if (gotsym < symtabno)
13932 {
13933 int sym_width;
13934
13935 printf (_(" Global entries:\n"));
cc5914eb 13936 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 13937 addr_size * 2, _("Address"),
13938 _("Access"),
2b692964 13939 addr_size * 2, _("Initial"),
9cf03b7e
NC		 13940 addr_size * 2, _("Sym.Val."),
13941 _("Type"),
13942 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13943 _("Ndx"), _("Name"));
0b4362b0 13944
ccb4c951 13945 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 13946
ccb4c951
RS		 13947 for (i = gotsym; i < symtabno; i++)
13948 {
91d6fa6a 13949 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951 13950 printf (" ");
e0a31db1
NC		 13951
13952 if (dynamic_symbols == NULL)
13953 printf (_("<no dynamic symbols>"));
13954 else if (i < num_dynamic_syms)
13955 {
13956 Elf_Internal_Sym * psym = dynamic_symbols + i;
13957
13958 print_vma (psym->st_value, LONG_HEX);
13959 printf (" %-7s %3s ",
13960 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13961 get_symbol_index_type (psym->st_shndx));
13962
13963 if (VALID_DYNAMIC_NAME (psym->st_name))
13964 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13965 else
13966 printf (_("<corrupt: %14ld>"), psym->st_name);
13967 }
ccb4c951 13968 else
7fc5ac57
JBG		 13969 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
13970 (unsigned long) i);
e0a31db1 13971
ccb4c951
RS		 13972 printf ("\n");
13973 }
13974 printf ("\n");
13975 }
13976
13977 if (data)
13978 free (data);
13979 }
13980
861fb55a
DJ		 13981 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13982 {
91d6fa6a 13983 bfd_vma ent, end;
861fb55a
DJ		 13984 size_t offset, rel_offset;
13985 unsigned long count, i;
2cf0635d 13986 unsigned char * data;
861fb55a 13987 int addr_size, sym_width;
2cf0635d 13988 Elf_Internal_Rela * rels;
861fb55a
DJ		 13989
13990 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13991 if (pltrel == DT_RELA)
13992 {
13993 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13994 return 0;
13995 }
13996 else
13997 {
13998 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13999 return 0;
14000 }
14001
91d6fa6a 14002 ent = mips_pltgot;
861fb55a
DJ		 14003 addr_size = (is_32bit_elf ? 4 : 8);
14004 end = mips_pltgot + (2 + count) * addr_size;
14005
14006 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14007 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14008 1, _("Procedure Linkage Table data"));
59245841
NC		 14009 if (data == NULL)
14010 return 0;
14011
9cf03b7e 14012 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14013 printf (_(" Reserved entries:\n"));
14014 printf (_(" %*s %*s Purpose\n"),
2b692964 14015 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14016 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14017 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14018 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14019 printf (_(" Module pointer\n"));
861fb55a
DJ		 14020 printf ("\n");
14021
14022 printf (_(" Entries:\n"));
cc5914eb 14023 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14024 addr_size * 2, _("Address"),
14025 addr_size * 2, _("Initial"),
14026 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14027 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14028 for (i = 0; i < count; i++)
14029 {
df97ab2a 14030 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14031
91d6fa6a 14032 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14033 printf (" ");
e0a31db1 14034
df97ab2a
MF		 14035 if (idx >= num_dynamic_syms)
14036 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14037 else
e0a31db1 14038 {
df97ab2a 14039 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14040
14041 print_vma (psym->st_value, LONG_HEX);
14042 printf (" %-7s %3s ",
14043 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14044 get_symbol_index_type (psym->st_shndx));
14045 if (VALID_DYNAMIC_NAME (psym->st_name))
14046 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14047 else
14048 printf (_("<corrupt: %14ld>"), psym->st_name);
14049 }
861fb55a
DJ		 14050 printf ("\n");
14051 }
14052 printf ("\n");
14053
14054 if (data)
14055 free (data);
14056 free (rels);
14057 }
14058
252b5132
RH		 14059 return 1;
14060}
14061
35c08157
KLC		 14062static int
14063process_nds32_specific (FILE * file)
14064{
14065 Elf_Internal_Shdr *sect = NULL;
14066
14067 sect = find_section (".nds32_e_flags");
14068 if (sect != NULL)
14069 {
14070 unsigned int *flag;
14071
14072 printf ("\nNDS32 elf flags section:\n");
14073 flag = get_data (NULL, file, sect->sh_offset, 1,
14074 sect->sh_size, _("NDS32 elf flags section"));
14075
14076 switch ((*flag) & 0x3)
14077 {
14078 case 0:
14079 printf ("(VEC_SIZE):\tNo entry.\n");
14080 break;
14081 case 1:
14082 printf ("(VEC_SIZE):\t4 bytes\n");
14083 break;
14084 case 2:
14085 printf ("(VEC_SIZE):\t16 bytes\n");
14086 break;
14087 case 3:
14088 printf ("(VEC_SIZE):\treserved\n");
14089 break;
14090 }
14091 }
14092
14093 return TRUE;
14094}
14095
047b2264 14096static int
2cf0635d 14097process_gnu_liblist (FILE * file)
047b2264 14098{
2cf0635d
NC		 14099 Elf_Internal_Shdr * section;
14100 Elf_Internal_Shdr * string_sec;
14101 Elf32_External_Lib * elib;
14102 char * strtab;
c256ffe7 14103 size_t strtab_size;
047b2264
JJ		 14104 size_t cnt;
14105 unsigned i;
14106
14107 if (! do_arch)
14108 return 0;
14109
14110 for (i = 0, section = section_headers;
14111 i < elf_header.e_shnum;
b34976b6 14112 i++, section++)
047b2264
JJ		 14113 {
14114 switch (section->sh_type)
14115 {
14116 case SHT_GNU_LIBLIST:
4fbb74a6 14117 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14118 break;
14119
3f5e193b
NC		 14120 elib = (Elf32_External_Lib *)
14121 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14122 _("liblist section data"));
047b2264
JJ		 14123
14124 if (elib == NULL)
14125 break;
4fbb74a6 14126 string_sec = section_headers + section->sh_link;
047b2264 14127
3f5e193b
NC		 14128 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14129 string_sec->sh_size,
14130 _("liblist string table"));
047b2264
JJ		 14131 if (strtab == NULL
14132 || section->sh_entsize != sizeof (Elf32_External_Lib))
14133 {
14134 free (elib);
2842702f 14135 free (strtab);
047b2264
JJ		 14136 break;
14137 }
59245841 14138 strtab_size = string_sec->sh_size;
047b2264
JJ		 14139
14140 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14141 printable_section_name (section),
0af1713e 14142 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14143
2b692964 14144 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14145
14146 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14147 ++cnt)
14148 {
14149 Elf32_Lib liblist;
91d6fa6a 14150 time_t atime;
047b2264 14151 char timebuf[20];
2cf0635d 14152 struct tm * tmp;
047b2264
JJ		 14153
14154 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14155 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14156 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14157 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14158 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14159
91d6fa6a 14160 tmp = gmtime (&atime);
e9e44622
JJ		 14161 snprintf (timebuf, sizeof (timebuf),
14162 "%04u-%02u-%02uT%02u:%02u:%02u",
14163 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14164 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14165
14166 printf ("%3lu: ", (unsigned long) cnt);
14167 if (do_wide)
c256ffe7 14168 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14169 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14170 else
c256ffe7 14171 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14172 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14173 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14174 liblist.l_version, liblist.l_flags);
14175 }
14176
14177 free (elib);
2842702f 14178 free (strtab);
047b2264
JJ		 14179 }
14180 }
14181
14182 return 1;
14183}
14184
9437c45b 14185static const char *
d3ba0551 14186get_note_type (unsigned e_type)
779fe533
NC		 14187{
14188 static char buff[64];
103f02d3 14189
1ec5cd37
NC		 14190 if (elf_header.e_type == ET_CORE)
14191 switch (e_type)
14192 {
57346661 14193 case NT_AUXV:
1ec5cd37 14194 return _("NT_AUXV (auxiliary vector)");
57346661 14195 case NT_PRSTATUS:
1ec5cd37 14196 return _("NT_PRSTATUS (prstatus structure)");
57346661 14197 case NT_FPREGSET:
1ec5cd37 14198 return _("NT_FPREGSET (floating point registers)");
57346661 14199 case NT_PRPSINFO:
1ec5cd37 14200 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14201 case NT_TASKSTRUCT:
1ec5cd37 14202 return _("NT_TASKSTRUCT (task structure)");
57346661 14203 case NT_PRXFPREG:
1ec5cd37 14204 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14205 case NT_PPC_VMX:
14206 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14207 case NT_PPC_VSX:
14208 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14209 case NT_386_TLS:
14210 return _("NT_386_TLS (x86 TLS information)");
14211 case NT_386_IOPERM:
14212 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14213 case NT_X86_XSTATE:
14214 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14215 case NT_S390_HIGH_GPRS:
14216 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14217 case NT_S390_TIMER:
14218 return _("NT_S390_TIMER (s390 timer register)");
14219 case NT_S390_TODCMP:
14220 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14221 case NT_S390_TODPREG:
14222 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14223 case NT_S390_CTRS:
14224 return _("NT_S390_CTRS (s390 control registers)");
14225 case NT_S390_PREFIX:
14226 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14227 case NT_S390_LAST_BREAK:
14228 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14229 case NT_S390_SYSTEM_CALL:
14230 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14231 case NT_S390_TDB:
14232 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW		 14233 case NT_ARM_VFP:
14234 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14235 case NT_ARM_TLS:
14236 return _("NT_ARM_TLS (AArch TLS registers)");
14237 case NT_ARM_HW_BREAK:
14238 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14239 case NT_ARM_HW_WATCH:
14240 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14241 case NT_PSTATUS:
1ec5cd37 14242 return _("NT_PSTATUS (pstatus structure)");
57346661 14243 case NT_FPREGS:
1ec5cd37 14244 return _("NT_FPREGS (floating point registers)");
57346661 14245 case NT_PSINFO:
1ec5cd37 14246 return _("NT_PSINFO (psinfo structure)");
57346661 14247 case NT_LWPSTATUS:
1ec5cd37 14248 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14249 case NT_LWPSINFO:
1ec5cd37 14250 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14251 case NT_WIN32PSTATUS:
1ec5cd37 14252 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14253 case NT_SIGINFO:
14254 return _("NT_SIGINFO (siginfo_t data)");
14255 case NT_FILE:
14256 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14257 default:
14258 break;
14259 }
14260 else
14261 switch (e_type)
14262 {
14263 case NT_VERSION:
14264 return _("NT_VERSION (version)");
14265 case NT_ARCH:
14266 return _("NT_ARCH (architecture)");
14267 default:
14268 break;
14269 }
14270
e9e44622 14271 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14272 return buff;
779fe533
NC		 14273}
14274
9ece1fa9
TT		 14275static int
14276print_core_note (Elf_Internal_Note *pnote)
14277{
14278 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14279 bfd_vma count, page_size;
14280 unsigned char *descdata, *filenames, *descend;
14281
14282 if (pnote->type != NT_FILE)
14283 return 1;
14284
14285#ifndef BFD64
14286 if (!is_32bit_elf)
14287 {
14288 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14289 /* Still "successful". */
14290 return 1;
14291 }
14292#endif
14293
14294 if (pnote->descsz < 2 * addr_size)
14295 {
14296 printf (_(" Malformed note - too short for header\n"));
14297 return 0;
14298 }
14299
14300 descdata = (unsigned char *) pnote->descdata;
14301 descend = descdata + pnote->descsz;
14302
14303 if (descdata[pnote->descsz - 1] != '\0')
14304 {
14305 printf (_(" Malformed note - does not end with \\0\n"));
14306 return 0;
14307 }
14308
14309 count = byte_get (descdata, addr_size);
14310 descdata += addr_size;
14311
14312 page_size = byte_get (descdata, addr_size);
14313 descdata += addr_size;
14314
14315 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14316 {
14317 printf (_(" Malformed note - too short for supplied file count\n"));
14318 return 0;
14319 }
14320
14321 printf (_(" Page size: "));
14322 print_vma (page_size, DEC);
14323 printf ("\n");
14324
14325 printf (_(" %*s%*s%*s\n"),
14326 (int) (2 + 2 * addr_size), _("Start"),
14327 (int) (4 + 2 * addr_size), _("End"),
14328 (int) (4 + 2 * addr_size), _("Page Offset"));
14329 filenames = descdata + count * 3 * addr_size;
14330 while (--count > 0)
14331 {
14332 bfd_vma start, end, file_ofs;
14333
14334 if (filenames == descend)
14335 {
14336 printf (_(" Malformed note - filenames end too early\n"));
14337 return 0;
14338 }
14339
14340 start = byte_get (descdata, addr_size);
14341 descdata += addr_size;
14342 end = byte_get (descdata, addr_size);
14343 descdata += addr_size;
14344 file_ofs = byte_get (descdata, addr_size);
14345 descdata += addr_size;
14346
14347 printf (" ");
14348 print_vma (start, FULL_HEX);
14349 printf (" ");
14350 print_vma (end, FULL_HEX);
14351 printf (" ");
14352 print_vma (file_ofs, FULL_HEX);
14353 printf ("\n %s\n", filenames);
14354
14355 filenames += 1 + strlen ((char *) filenames);
14356 }
14357
14358 return 1;
14359}
14360
1118d252
RM		 14361static const char *
14362get_gnu_elf_note_type (unsigned e_type)
14363{
14364 static char buff[64];
14365
14366 switch (e_type)
14367 {
14368 case NT_GNU_ABI_TAG:
14369 return _("NT_GNU_ABI_TAG (ABI version tag)");
14370 case NT_GNU_HWCAP:
14371 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14372 case NT_GNU_BUILD_ID:
14373 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14374 case NT_GNU_GOLD_VERSION:
14375 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14376 default:
14377 break;
14378 }
14379
14380 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14381 return buff;
14382}
14383
664f90a3
TT		 14384static int
14385print_gnu_note (Elf_Internal_Note *pnote)
14386{
14387 switch (pnote->type)
14388 {
14389 case NT_GNU_BUILD_ID:
14390 {
14391 unsigned long i;
14392
14393 printf (_(" Build ID: "));
14394 for (i = 0; i < pnote->descsz; ++i)
14395 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14396 printf ("\n");
664f90a3
TT		 14397 }
14398 break;
14399
14400 case NT_GNU_ABI_TAG:
14401 {
14402 unsigned long os, major, minor, subminor;
14403 const char *osname;
14404
3102e897
NC		 14405 /* PR 17531: file: 030-599401-0.004. */
14406 if (pnote->descsz < 16)
14407 {
14408 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14409 break;
14410 }
14411
664f90a3
TT		 14412 os = byte_get ((unsigned char *) pnote->descdata, 4);
14413 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14414 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14415 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14416
14417 switch (os)
14418 {
14419 case GNU_ABI_TAG_LINUX:
14420 osname = "Linux";
14421 break;
14422 case GNU_ABI_TAG_HURD:
14423 osname = "Hurd";
14424 break;
14425 case GNU_ABI_TAG_SOLARIS:
14426 osname = "Solaris";
14427 break;
14428 case GNU_ABI_TAG_FREEBSD:
14429 osname = "FreeBSD";
14430 break;
14431 case GNU_ABI_TAG_NETBSD:
14432 osname = "NetBSD";
14433 break;
14434 default:
14435 osname = "Unknown";
14436 break;
14437 }
14438
14439 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14440 major, minor, subminor);
14441 }
14442 break;
926c5385
CC		 14443
14444 case NT_GNU_GOLD_VERSION:
14445 {
14446 unsigned long i;
14447
14448 printf (_(" Version: "));
14449 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14450 printf ("%c", pnote->descdata[i]);
14451 printf ("\n");
14452 }
14453 break;
664f90a3
TT		 14454 }
14455
14456 return 1;
14457}
14458
9437c45b 14459static const char *
d3ba0551 14460get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14461{
14462 static char buff[64];
14463
b4db1224 14464 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14465 {
14466 /* NetBSD core "procinfo" structure. */
14467 return _("NetBSD procinfo structure");
14468 }
14469
14470 /* As of Jan 2002 there are no other machine-independent notes
14471 defined for NetBSD core files. If the note type is less
14472 than the start of the machine-dependent note types, we don't
14473 understand it. */
14474
b4db1224 14475 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14476 {
e9e44622 14477 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14478 return buff;
14479 }
14480
14481 switch (elf_header.e_machine)
14482 {
14483 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14484 and PT_GETFPREGS == mach+2. */
14485
14486 case EM_OLD_ALPHA:
14487 case EM_ALPHA:
14488 case EM_SPARC:
14489 case EM_SPARC32PLUS:
14490 case EM_SPARCV9:
14491 switch (e_type)
14492 {
2b692964 14493 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 14494 return _("PT_GETREGS (reg structure)");
2b692964 14495 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 14496 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14497 default:
14498 break;
14499 }
14500 break;
14501
14502 /* On all other arch's, PT_GETREGS == mach+1 and
14503 PT_GETFPREGS == mach+3. */
14504 default:
14505 switch (e_type)
14506 {
2b692964 14507 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 14508 return _("PT_GETREGS (reg structure)");
2b692964 14509 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 14510 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14511 default:
14512 break;
14513 }
14514 }
14515
9cf03b7e 14516 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 14517 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 14518 return buff;
14519}
14520
70616151
TT		 14521static const char *
14522get_stapsdt_note_type (unsigned e_type)
14523{
14524 static char buff[64];
14525
14526 switch (e_type)
14527 {
14528 case NT_STAPSDT:
14529 return _("NT_STAPSDT (SystemTap probe descriptors)");
14530
14531 default:
14532 break;
14533 }
14534
14535 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14536 return buff;
14537}
14538
c6a9fc58
TT		 14539static int
14540print_stapsdt_note (Elf_Internal_Note *pnote)
14541{
14542 int addr_size = is_32bit_elf ? 4 : 8;
14543 char *data = pnote->descdata;
14544 char *data_end = pnote->descdata + pnote->descsz;
14545 bfd_vma pc, base_addr, semaphore;
14546 char *provider, *probe, *arg_fmt;
14547
14548 pc = byte_get ((unsigned char *) data, addr_size);
14549 data += addr_size;
14550 base_addr = byte_get ((unsigned char *) data, addr_size);
14551 data += addr_size;
14552 semaphore = byte_get ((unsigned char *) data, addr_size);
14553 data += addr_size;
14554
14555 provider = data;
14556 data += strlen (data) + 1;
14557 probe = data;
14558 data += strlen (data) + 1;
14559 arg_fmt = data;
14560 data += strlen (data) + 1;
14561
14562 printf (_(" Provider: %s\n"), provider);
14563 printf (_(" Name: %s\n"), probe);
14564 printf (_(" Location: "));
14565 print_vma (pc, FULL_HEX);
14566 printf (_(", Base: "));
14567 print_vma (base_addr, FULL_HEX);
14568 printf (_(", Semaphore: "));
14569 print_vma (semaphore, FULL_HEX);
9cf03b7e 14570 printf ("\n");
c6a9fc58
TT		 14571 printf (_(" Arguments: %s\n"), arg_fmt);
14572
14573 return data == data_end;
14574}
14575
00e98fc7
TG		 14576static const char *
14577get_ia64_vms_note_type (unsigned e_type)
14578{
14579 static char buff[64];
14580
14581 switch (e_type)
14582 {
14583 case NT_VMS_MHD:
14584 return _("NT_VMS_MHD (module header)");
14585 case NT_VMS_LNM:
14586 return _("NT_VMS_LNM (language name)");
14587 case NT_VMS_SRC:
14588 return _("NT_VMS_SRC (source files)");
14589 case NT_VMS_TITLE:
9cf03b7e 14590 return "NT_VMS_TITLE";
00e98fc7
TG		 14591 case NT_VMS_EIDC:
14592 return _("NT_VMS_EIDC (consistency check)");
14593 case NT_VMS_FPMODE:
14594 return _("NT_VMS_FPMODE (FP mode)");
14595 case NT_VMS_LINKTIME:
9cf03b7e 14596 return "NT_VMS_LINKTIME";
00e98fc7
TG		 14597 case NT_VMS_IMGNAM:
14598 return _("NT_VMS_IMGNAM (image name)");
14599 case NT_VMS_IMGID:
14600 return _("NT_VMS_IMGID (image id)");
14601 case NT_VMS_LINKID:
14602 return _("NT_VMS_LINKID (link id)");
14603 case NT_VMS_IMGBID:
14604 return _("NT_VMS_IMGBID (build id)");
14605 case NT_VMS_GSTNAM:
14606 return _("NT_VMS_GSTNAM (sym table name)");
14607 case NT_VMS_ORIG_DYN:
9cf03b7e 14608 return "NT_VMS_ORIG_DYN";
00e98fc7 14609 case NT_VMS_PATCHTIME:
9cf03b7e 14610 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 14611 default:
14612 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14613 return buff;
14614 }
14615}
14616
14617static int
14618print_ia64_vms_note (Elf_Internal_Note * pnote)
14619{
14620 switch (pnote->type)
14621 {
14622 case NT_VMS_MHD:
14623 if (pnote->descsz > 36)
14624 {
14625 size_t l = strlen (pnote->descdata + 34);
14626 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14627 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14628 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14629 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14630 }
14631 else
14632 printf (_(" Invalid size\n"));
14633 break;
14634 case NT_VMS_LNM:
14635 printf (_(" Language: %s\n"), pnote->descdata);
14636 break;
14637#ifdef BFD64
14638 case NT_VMS_FPMODE:
9cf03b7e 14639 printf (_(" Floating Point mode: "));
4a5cb34f 14640 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14641 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14642 break;
14643 case NT_VMS_LINKTIME:
14644 printf (_(" Link time: "));
14645 print_vms_time
14646 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14647 printf ("\n");
14648 break;
14649 case NT_VMS_PATCHTIME:
14650 printf (_(" Patch time: "));
14651 print_vms_time
14652 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14653 printf ("\n");
14654 break;
14655 case NT_VMS_ORIG_DYN:
14656 printf (_(" Major id: %u, minor id: %u\n"),
14657 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14658 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 14659 printf (_(" Last modified : "));
00e98fc7
TG		 14660 print_vms_time
14661 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 14662 printf (_("\n Link flags : "));
4a5cb34f 14663 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14664 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14665 printf (_(" Header flags: 0x%08x\n"),
14666 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14667 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14668 break;
14669#endif
14670 case NT_VMS_IMGNAM:
14671 printf (_(" Image name: %s\n"), pnote->descdata);
14672 break;
14673 case NT_VMS_GSTNAM:
14674 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14675 break;
14676 case NT_VMS_IMGID:
14677 printf (_(" Image id: %s\n"), pnote->descdata);
14678 break;
14679 case NT_VMS_LINKID:
14680 printf (_(" Linker id: %s\n"), pnote->descdata);
14681 break;
14682 default:
14683 break;
14684 }
14685 return 1;
14686}
14687
6d118b09
NC		 14688/* Note that by the ELF standard, the name field is already null byte
14689 terminated, and namesz includes the terminating null byte.
14690 I.E. the value of namesz for the name "FSF" is 4.
14691
e3c8793a 14692 If the value of namesz is zero, there is no name present. */
779fe533 14693static int
2cf0635d 14694process_note (Elf_Internal_Note * pnote)
779fe533 14695{
2cf0635d
NC		 14696 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14697 const char * nt;
9437c45b
JT		 14698
14699 if (pnote->namesz == 0)
1ec5cd37
NC		 14700 /* If there is no note name, then use the default set of
14701 note type strings. */
14702 nt = get_note_type (pnote->type);
14703
1118d252
RM		 14704 else if (const_strneq (pnote->namedata, "GNU"))
14705 /* GNU-specific object file notes. */
14706 nt = get_gnu_elf_note_type (pnote->type);
14707
0112cd26 14708 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 14709 /* NetBSD-specific core file notes. */
14710 nt = get_netbsd_elfcore_note_type (pnote->type);
14711
b15fa79e
AM		 14712 else if (strneq (pnote->namedata, "SPU/", 4))
14713 {
14714 /* SPU-specific core file notes. */
14715 nt = pnote->namedata + 4;
14716 name = "SPU";
14717 }
14718
00e98fc7
TG		 14719 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14720 /* VMS/ia64-specific file notes. */
14721 nt = get_ia64_vms_note_type (pnote->type);
14722
70616151
TT		 14723 else if (const_strneq (pnote->namedata, "stapsdt"))
14724 nt = get_stapsdt_note_type (pnote->type);
14725
9437c45b 14726 else
1ec5cd37
NC		 14727 /* Don't recognize this note name; just use the default set of
14728 note type strings. */
00e98fc7 14729 nt = get_note_type (pnote->type);
9437c45b 14730
2aee03ae 14731 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 14732
14733 if (const_strneq (pnote->namedata, "IPF/VMS"))
14734 return print_ia64_vms_note (pnote);
664f90a3
TT		 14735 else if (const_strneq (pnote->namedata, "GNU"))
14736 return print_gnu_note (pnote);
c6a9fc58
TT		 14737 else if (const_strneq (pnote->namedata, "stapsdt"))
14738 return print_stapsdt_note (pnote);
9ece1fa9
TT		 14739 else if (const_strneq (pnote->namedata, "CORE"))
14740 return print_core_note (pnote);
00e98fc7
TG		 14741 else
14742 return 1;
779fe533
NC		 14743}
14744
6d118b09 14745
779fe533 14746static int
2cf0635d 14747process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 14748{
2cf0635d
NC		 14749 Elf_External_Note * pnotes;
14750 Elf_External_Note * external;
b34976b6 14751 int res = 1;
103f02d3 14752
779fe533
NC		 14753 if (length <= 0)
14754 return 0;
103f02d3 14755
3f5e193b 14756 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 14757 _("notes"));
dd24e3da 14758 if (pnotes == NULL)
a6e9f9df 14759 return 0;
779fe533 14760
103f02d3 14761 external = pnotes;
103f02d3 14762
9dd3a467 14763 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 14764 (unsigned long) offset, (unsigned long) length);
2aee03ae 14765 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 14766
15b42fb0 14767 while ((char *) external < (char *) pnotes + length)
779fe533 14768 {
b34976b6 14769 Elf_Internal_Note inote;
15b42fb0
AM		 14770 size_t min_notesz;
14771 char *next;
2cf0635d 14772 char * temp = NULL;
15b42fb0 14773 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 14774
00e98fc7 14775 if (!is_ia64_vms ())
15b42fb0 14776 {
9dd3a467
NC		 14777 /* PR binutils/15191
14778 Make sure that there is enough data to read. */
15b42fb0
AM		 14779 min_notesz = offsetof (Elf_External_Note, name);
14780 if (data_remaining < min_notesz)
9dd3a467
NC		 14781 {
14782 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14783 (int) data_remaining);
14784 break;
14785 }
15b42fb0
AM		 14786 inote.type = BYTE_GET (external->type);
14787 inote.namesz = BYTE_GET (external->namesz);
14788 inote.namedata = external->name;
14789 inote.descsz = BYTE_GET (external->descsz);
14790 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14791 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14792 next = inote.descdata + align_power (inote.descsz, 2);
14793 }
00e98fc7 14794 else
15b42fb0
AM		 14795 {
14796 Elf64_External_VMS_Note *vms_external;
00e98fc7 14797
9dd3a467
NC		 14798 /* PR binutils/15191
14799 Make sure that there is enough data to read. */
15b42fb0
AM		 14800 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14801 if (data_remaining < min_notesz)
9dd3a467
NC		 14802 {
14803 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14804 (int) data_remaining);
14805 break;
14806 }
3e55a963 14807
15b42fb0
AM		 14808 vms_external = (Elf64_External_VMS_Note *) external;
14809 inote.type = BYTE_GET (vms_external->type);
14810 inote.namesz = BYTE_GET (vms_external->namesz);
14811 inote.namedata = vms_external->name;
14812 inote.descsz = BYTE_GET (vms_external->descsz);
14813 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14814 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14815 next = inote.descdata + align_power (inote.descsz, 3);
14816 }
14817
14818 if (inote.descdata < (char *) external + min_notesz
14819 || next < (char *) external + min_notesz
5d921cbd
NC		 14820 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14821 || inote.namedata + inote.namesz < inote.namedata
14822 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 14823 || data_remaining < (size_t)(next - (char *) external))
3e55a963 14824 {
15b42fb0 14825 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 14826 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 14827 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 14828 inote.type, inote.namesz, inote.descsz);
14829 break;
14830 }
14831
15b42fb0 14832 external = (Elf_External_Note *) next;
dd24e3da 14833
6d118b09
NC		 14834 /* Verify that name is null terminated. It appears that at least
14835 one version of Linux (RedHat 6.0) generates corefiles that don't
14836 comply with the ELF spec by failing to include the null byte in
14837 namesz. */
8b971f9f 14838 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 14839 {
3f5e193b 14840 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 14841 if (temp == NULL)
14842 {
8b73c356 14843 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 14844 res = 0;
14845 break;
14846 }
76da6bbe 14847
6d118b09
NC		 14848 strncpy (temp, inote.namedata, inote.namesz);
14849 temp[inote.namesz] = 0;
76da6bbe 14850
6d118b09
NC		 14851 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14852 inote.namedata = temp;
14853 }
14854
14855 res &= process_note (& inote);
103f02d3 14856
6d118b09
NC		 14857 if (temp != NULL)
14858 {
14859 free (temp);
14860 temp = NULL;
14861 }
779fe533
NC		 14862 }
14863
14864 free (pnotes);
103f02d3 14865
779fe533
NC		 14866 return res;
14867}
14868
14869static int
2cf0635d 14870process_corefile_note_segments (FILE * file)
779fe533 14871{
2cf0635d 14872 Elf_Internal_Phdr * segment;
b34976b6
AM		 14873 unsigned int i;
14874 int res = 1;
103f02d3 14875
d93f0186 14876 if (! get_program_headers (file))
779fe533 14877 return 0;
103f02d3 14878
779fe533
NC		 14879 for (i = 0, segment = program_headers;
14880 i < elf_header.e_phnum;
b34976b6 14881 i++, segment++)
779fe533
NC		 14882 {
14883 if (segment->p_type == PT_NOTE)
103f02d3 14884 res &= process_corefile_note_segment (file,
30800947
NC		 14885 (bfd_vma) segment->p_offset,
14886 (bfd_vma) segment->p_filesz);
779fe533 14887 }
103f02d3 14888
779fe533
NC		 14889 return res;
14890}
14891
14892static int
2cf0635d 14893process_note_sections (FILE * file)
1ec5cd37 14894{
2cf0635d 14895 Elf_Internal_Shdr * section;
1ec5cd37 14896 unsigned long i;
df565f32 14897 int n = 0;
1ec5cd37
NC		 14898 int res = 1;
14899
14900 for (i = 0, section = section_headers;
fa1908fd 14901 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 14902 i++, section++)
14903 if (section->sh_type == SHT_NOTE)
df565f32
NC		 14904 {
14905 res &= process_corefile_note_segment (file,
14906 (bfd_vma) section->sh_offset,
14907 (bfd_vma) section->sh_size);
14908 n++;
14909 }
14910
14911 if (n == 0)
14912 /* Try processing NOTE segments instead. */
14913 return process_corefile_note_segments (file);
1ec5cd37
NC		 14914
14915 return res;
14916}
14917
14918static int
2cf0635d 14919process_notes (FILE * file)
779fe533
NC		 14920{
14921 /* If we have not been asked to display the notes then do nothing. */
14922 if (! do_notes)
14923 return 1;
103f02d3 14924
779fe533 14925 if (elf_header.e_type != ET_CORE)
1ec5cd37 14926 return process_note_sections (file);
103f02d3 14927
779fe533 14928 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 14929 if (elf_header.e_phnum > 0)
14930 return process_corefile_note_segments (file);
779fe533 14931
1ec5cd37
NC		 14932 printf (_("No note segments present in the core file.\n"));
14933 return 1;
779fe533
NC		 14934}
14935
252b5132 14936static int
2cf0635d 14937process_arch_specific (FILE * file)
252b5132 14938{
a952a375
NC		 14939 if (! do_arch)
14940 return 1;
14941
252b5132
RH		 14942 switch (elf_header.e_machine)
14943 {
11c1ff18
PB		 14944 case EM_ARM:
14945 return process_arm_specific (file);
252b5132 14946 case EM_MIPS:
4fe85591 14947 case EM_MIPS_RS3_LE:
252b5132
RH		 14948 return process_mips_specific (file);
14949 break;
35c08157
KLC		 14950 case EM_NDS32:
14951 return process_nds32_specific (file);
14952 break;
34c8bcba
JM		 14953 case EM_PPC:
14954 return process_power_specific (file);
14955 break;
9e8c70f9
DM		 14956 case EM_SPARC:
14957 case EM_SPARC32PLUS:
14958 case EM_SPARCV9:
14959 return process_sparc_specific (file);
14960 break;
59e6276b
JM		 14961 case EM_TI_C6000:
14962 return process_tic6x_specific (file);
14963 break;
13761a11
NC		 14964 case EM_MSP430:
14965 return process_msp430x_specific (file);
252b5132
RH		 14966 default:
14967 break;
14968 }
14969 return 1;
14970}
14971
14972static int
2cf0635d 14973get_file_header (FILE * file)
252b5132 14974{
9ea033b2
NC		 14975 /* Read in the identity array. */
14976 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 14977 return 0;
14978
9ea033b2 14979 /* Determine how to read the rest of the header. */
b34976b6 14980 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 14981 {
14982 default: /* fall through */
14983 case ELFDATANONE: /* fall through */
adab8cdc
AO		 14984 case ELFDATA2LSB:
14985 byte_get = byte_get_little_endian;
14986 byte_put = byte_put_little_endian;
14987 break;
14988 case ELFDATA2MSB:
14989 byte_get = byte_get_big_endian;
14990 byte_put = byte_put_big_endian;
14991 break;
9ea033b2
NC		 14992 }
14993
14994 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 14995 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 14996
14997 /* Read in the rest of the header. */
14998 if (is_32bit_elf)
14999 {
15000 Elf32_External_Ehdr ehdr32;
252b5132 15001
9ea033b2
NC		 15002 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15003 return 0;
103f02d3 15004
9ea033b2
NC		 15005 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15006 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15007 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15008 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15009 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15010 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15011 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15012 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15013 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15014 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15015 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15016 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15017 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15018 }
252b5132 15019 else
9ea033b2
NC		 15020 {
15021 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15022
15023 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15024 we will not be able to cope with the 64bit data found in
15025 64 ELF files. Detect this now and abort before we start
50c2245b 15026 overwriting things. */
a952a375
NC		 15027 if (sizeof (bfd_vma) < 8)
15028 {
e3c8793a
NC		 15029 error (_("This instance of readelf has been built without support for a\n\
1503064 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15031 return 0;
15032 }
103f02d3 15033
9ea033b2
NC		 15034 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15035 return 0;
103f02d3 15036
9ea033b2
NC		 15037 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15038 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15039 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15040 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15041 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15042 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15043 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15044 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15045 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15046 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15047 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15048 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15049 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15050 }
252b5132 15051
7ece0d85
JJ		 15052 if (elf_header.e_shoff)
15053 {
15054 /* There may be some extensions in the first section header. Don't
15055 bomb if we can't read it. */
15056 if (is_32bit_elf)
049b0c3a 15057 get_32bit_section_headers (file, TRUE);
7ece0d85 15058 else
049b0c3a 15059 get_64bit_section_headers (file, TRUE);
7ece0d85 15060 }
560f3c1c 15061
252b5132
RH		 15062 return 1;
15063}
15064
fb52b2f4
NC		 15065/* Process one ELF object file according to the command line options.
15066 This file may actually be stored in an archive. The file is
15067 positioned at the start of the ELF object. */
15068
ff78d6d6 15069static int
2cf0635d 15070process_object (char * file_name, FILE * file)
252b5132 15071{
252b5132
RH		 15072 unsigned int i;
15073
252b5132
RH		 15074 if (! get_file_header (file))
15075 {
15076 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15077 return 1;
252b5132
RH		 15078 }
15079
15080 /* Initialise per file variables. */
60bca95a 15081 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15082 version_info[i] = 0;
15083
60bca95a 15084 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15085 dynamic_info[i] = 0;
5115b233 15086 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15087
15088 /* Process the file. */
15089 if (show_name)
15090 printf (_("\nFile: %s\n"), file_name);
15091
18bd398b
NC		 15092 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15093 Note we do this even if cmdline_dump_sects is empty because we
15094 must make sure that the dump_sets array is zeroed out before each
15095 object file is processed. */
15096 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15097 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15098
15099 if (num_cmdline_dump_sects > 0)
15100 {
15101 if (num_dump_sects == 0)
15102 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15103 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15104
15105 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15106 memcpy (dump_sects, cmdline_dump_sects,
15107 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15108 }
d70c5fc7 15109
252b5132 15110 if (! process_file_header ())
fb52b2f4 15111 return 1;
252b5132 15112
d1f5c6e3 15113 if (! process_section_headers (file))
2f62977e 15114 {
d1f5c6e3
L		 15115 /* Without loaded section headers we cannot process lots of
15116 things. */
2f62977e 15117 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15118
2f62977e 15119 if (! do_using_dynamic)
2c610e4b 15120 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15121 }
252b5132 15122
d1f5c6e3
L		 15123 if (! process_section_groups (file))
15124 {
15125 /* Without loaded section groups we cannot process unwind. */
15126 do_unwind = 0;
15127 }
15128
2f62977e 15129 if (process_program_headers (file))
b2d38a17 15130 process_dynamic_section (file);
252b5132
RH		 15131
15132 process_relocs (file);
15133
4d6ed7c8
NC		 15134 process_unwind (file);
15135
252b5132
RH		 15136 process_symbol_table (file);
15137
15138 process_syminfo (file);
15139
15140 process_version_sections (file);
15141
15142 process_section_contents (file);
f5842774 15143
1ec5cd37 15144 process_notes (file);
103f02d3 15145
047b2264
JJ		 15146 process_gnu_liblist (file);
15147
252b5132
RH		 15148 process_arch_specific (file);
15149
d93f0186
NC		 15150 if (program_headers)
15151 {
15152 free (program_headers);
15153 program_headers = NULL;
15154 }
15155
252b5132
RH		 15156 if (section_headers)
15157 {
15158 free (section_headers);
15159 section_headers = NULL;
15160 }
15161
15162 if (string_table)
15163 {
15164 free (string_table);
15165 string_table = NULL;
d40ac9bd 15166 string_table_length = 0;
252b5132
RH		 15167 }
15168
15169 if (dynamic_strings)
15170 {
15171 free (dynamic_strings);
15172 dynamic_strings = NULL;
d79b3d50 15173 dynamic_strings_length = 0;
252b5132
RH		 15174 }
15175
15176 if (dynamic_symbols)
15177 {
15178 free (dynamic_symbols);
15179 dynamic_symbols = NULL;
19936277 15180 num_dynamic_syms = 0;
252b5132
RH		 15181 }
15182
15183 if (dynamic_syminfo)
15184 {
15185 free (dynamic_syminfo);
15186 dynamic_syminfo = NULL;
15187 }
ff78d6d6 15188
293c573e
MR		 15189 if (dynamic_section)
15190 {
15191 free (dynamic_section);
15192 dynamic_section = NULL;
15193 }
15194
e4b17d5c
L		 15195 if (section_headers_groups)
15196 {
15197 free (section_headers_groups);
15198 section_headers_groups = NULL;
15199 }
15200
15201 if (section_groups)
15202 {
2cf0635d
NC		 15203 struct group_list * g;
15204 struct group_list * next;
e4b17d5c
L		 15205
15206 for (i = 0; i < group_count; i++)
15207 {
15208 for (g = section_groups [i].root; g != NULL; g = next)
15209 {
15210 next = g->next;
15211 free (g);
15212 }
15213 }
15214
15215 free (section_groups);
15216 section_groups = NULL;
15217 }
15218
19e6b90e 15219 free_debug_memory ();
18bd398b 15220
ff78d6d6 15221 return 0;
252b5132
RH		 15222}
15223
2cf0635d
NC		 15224/* Process an ELF archive.
15225 On entry the file is positioned just after the ARMAG string. */
15226
15227static int
15228process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15229{
15230 struct archive_info arch;
15231 struct archive_info nested_arch;
15232 size_t got;
2cf0635d
NC		 15233 int ret;
15234
15235 show_name = 1;
15236
15237 /* The ARCH structure is used to hold information about this archive. */
15238 arch.file_name = NULL;
15239 arch.file = NULL;
15240 arch.index_array = NULL;
15241 arch.sym_table = NULL;
15242 arch.longnames = NULL;
15243
15244 /* The NESTED_ARCH structure is used as a single-item cache of information
15245 about a nested archive (when members of a thin archive reside within
15246 another regular archive file). */
15247 nested_arch.file_name = NULL;
15248 nested_arch.file = NULL;
15249 nested_arch.index_array = NULL;
15250 nested_arch.sym_table = NULL;
15251 nested_arch.longnames = NULL;
15252
15253 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15254 {
15255 ret = 1;
15256 goto out;
4145f1d5 15257 }
fb52b2f4 15258
4145f1d5
NC		 15259 if (do_archive_index)
15260 {
2cf0635d 15261 if (arch.sym_table == NULL)
4145f1d5
NC		 15262 error (_("%s: unable to dump the index as none was found\n"), file_name);
15263 else
15264 {
591f7597 15265 unsigned long i, l;
4145f1d5
NC		 15266 unsigned long current_pos;
15267
591f7597
NC		 15268 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15269 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 15270 current_pos = ftell (file);
15271
2cf0635d 15272 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 15273 {
2cf0635d
NC		 15274 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15275 {
15276 char * member_name;
4145f1d5 15277
2cf0635d
NC		 15278 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15279
15280 if (member_name != NULL)
15281 {
15282 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15283
15284 if (qualified_name != NULL)
15285 {
c2a7d3f5
NC		 15286 printf (_("Contents of binary %s at offset "), qualified_name);
15287 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15288 putchar ('\n');
2cf0635d
NC		 15289 free (qualified_name);
15290 }
4145f1d5
NC		 15291 }
15292 }
2cf0635d
NC		 15293
15294 if (l >= arch.sym_size)
4145f1d5
NC		 15295 {
15296 error (_("%s: end of the symbol table reached before the end of the index\n"),
15297 file_name);
cb8f3167 15298 break;
4145f1d5 15299 }
591f7597
NC		 15300 /* PR 17531: file: 0b6630b2. */
15301 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15302 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 15303 }
15304
c2a7d3f5
NC		 15305 if (arch.uses_64bit_indicies)
15306 l = (l + 7) & ~ 7;
15307 else
15308 l += l & 1;
15309
2cf0635d 15310 if (l < arch.sym_size)
c2a7d3f5
NC		 15311 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15312 file_name, arch.sym_size - l);
4145f1d5 15313
4145f1d5
NC		 15314 if (fseek (file, current_pos, SEEK_SET) != 0)
15315 {
15316 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 15317 ret = 1;
15318 goto out;
4145f1d5 15319 }
fb52b2f4 15320 }
4145f1d5
NC		 15321
15322 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15323 && !do_segments && !do_header && !do_dump && !do_version
15324 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 15325 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 15326 {
15327 ret = 0; /* Archive index only. */
15328 goto out;
15329 }
fb52b2f4
NC		 15330 }
15331
d989285c 15332 ret = 0;
fb52b2f4
NC		 15333
15334 while (1)
15335 {
2cf0635d
NC		 15336 char * name;
15337 size_t namelen;
15338 char * qualified_name;
15339
15340 /* Read the next archive header. */
15341 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15342 {
15343 error (_("%s: failed to seek to next archive header\n"), file_name);
15344 return 1;
15345 }
15346 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15347 if (got != sizeof arch.arhdr)
15348 {
15349 if (got == 0)
15350 break;
15351 error (_("%s: failed to read archive header\n"), file_name);
15352 ret = 1;
15353 break;
15354 }
15355 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15356 {
15357 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15358 ret = 1;
15359 break;
15360 }
15361
15362 arch.next_arhdr_offset += sizeof arch.arhdr;
15363
15364 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15365 if (archive_file_size & 01)
15366 ++archive_file_size;
15367
15368 name = get_archive_member_name (&arch, &nested_arch);
15369 if (name == NULL)
fb52b2f4 15370 {
0fd3a477 15371 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15372 ret = 1;
15373 break;
fb52b2f4 15374 }
2cf0635d 15375 namelen = strlen (name);
fb52b2f4 15376
2cf0635d
NC		 15377 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15378 if (qualified_name == NULL)
fb52b2f4 15379 {
2cf0635d 15380 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15381 ret = 1;
15382 break;
fb52b2f4
NC		 15383 }
15384
2cf0635d
NC		 15385 if (is_thin_archive && arch.nested_member_origin == 0)
15386 {
15387 /* This is a proxy for an external member of a thin archive. */
15388 FILE * member_file;
15389 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15390 if (member_file_name == NULL)
15391 {
15392 ret = 1;
15393 break;
15394 }
15395
15396 member_file = fopen (member_file_name, "rb");
15397 if (member_file == NULL)
15398 {
15399 error (_("Input file '%s' is not readable.\n"), member_file_name);
15400 free (member_file_name);
15401 ret = 1;
15402 break;
15403 }
15404
15405 archive_file_offset = arch.nested_member_origin;
15406
15407 ret |= process_object (qualified_name, member_file);
15408
15409 fclose (member_file);
15410 free (member_file_name);
15411 }
15412 else if (is_thin_archive)
15413 {
a043396b
NC		 15414 /* PR 15140: Allow for corrupt thin archives. */
15415 if (nested_arch.file == NULL)
15416 {
15417 error (_("%s: contains corrupt thin archive: %s\n"),
15418 file_name, name);
15419 ret = 1;
15420 break;
15421 }
15422
2cf0635d
NC		 15423 /* This is a proxy for a member of a nested archive. */
15424 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15425
15426 /* The nested archive file will have been opened and setup by
15427 get_archive_member_name. */
15428 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15429 {
15430 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15431 ret = 1;
15432 break;
15433 }
15434
15435 ret |= process_object (qualified_name, nested_arch.file);
15436 }
15437 else
15438 {
15439 archive_file_offset = arch.next_arhdr_offset;
15440 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 15441
2cf0635d
NC		 15442 ret |= process_object (qualified_name, file);
15443 }
fb52b2f4 15444
2b52916e
L		 15445 if (dump_sects != NULL)
15446 {
15447 free (dump_sects);
15448 dump_sects = NULL;
15449 num_dump_sects = 0;
15450 }
15451
2cf0635d 15452 free (qualified_name);
fb52b2f4
NC		 15453 }
15454
4145f1d5 15455 out:
2cf0635d
NC		 15456 if (nested_arch.file != NULL)
15457 fclose (nested_arch.file);
15458 release_archive (&nested_arch);
15459 release_archive (&arch);
fb52b2f4 15460
d989285c 15461 return ret;
fb52b2f4
NC		 15462}
15463
15464static int
2cf0635d 15465process_file (char * file_name)
fb52b2f4 15466{
2cf0635d 15467 FILE * file;
fb52b2f4
NC		 15468 struct stat statbuf;
15469 char armag[SARMAG];
15470 int ret;
15471
15472 if (stat (file_name, &statbuf) < 0)
15473 {
f24ddbdd
NC		 15474 if (errno == ENOENT)
15475 error (_("'%s': No such file\n"), file_name);
15476 else
15477 error (_("Could not locate '%s'. System error message: %s\n"),
15478 file_name, strerror (errno));
15479 return 1;
15480 }
15481
15482 if (! S_ISREG (statbuf.st_mode))
15483 {
15484 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 15485 return 1;
15486 }
15487
15488 file = fopen (file_name, "rb");
15489 if (file == NULL)
15490 {
f24ddbdd 15491 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 15492 return 1;
15493 }
15494
15495 if (fread (armag, SARMAG, 1, file) != 1)
15496 {
4145f1d5 15497 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 15498 fclose (file);
15499 return 1;
15500 }
15501
f54498b4
NC		 15502 current_file_size = (bfd_size_type) statbuf.st_size;
15503
fb52b2f4 15504 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 15505 ret = process_archive (file_name, file, FALSE);
15506 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15507 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 15508 else
15509 {
4145f1d5
NC		 15510 if (do_archive_index)
15511 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15512 file_name);
15513
fb52b2f4
NC		 15514 rewind (file);
15515 archive_file_size = archive_file_offset = 0;
15516 ret = process_object (file_name, file);
15517 }
15518
15519 fclose (file);
15520
f54498b4 15521 current_file_size = 0;
fb52b2f4
NC		 15522 return ret;
15523}
15524
252b5132
RH		 15525#ifdef SUPPORT_DISASSEMBLY
15526/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 15527 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 15528 symbols. */
252b5132
RH		 15529
15530void
2cf0635d 15531print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 15532{
15533 fprintf (outfile,"0x%8.8x", addr);
15534}
15535
e3c8793a 15536/* Needed by the i386 disassembler. */
252b5132
RH		 15537void
15538db_task_printsym (unsigned int addr)
15539{
15540 print_address (addr, stderr);
15541}
15542#endif
15543
15544int
2cf0635d 15545main (int argc, char ** argv)
252b5132 15546{
ff78d6d6
L		 15547 int err;
15548
252b5132
RH		 15549#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15550 setlocale (LC_MESSAGES, "");
3882b010
L		 15551#endif
15552#if defined (HAVE_SETLOCALE)
15553 setlocale (LC_CTYPE, "");
252b5132
RH		 15554#endif
15555 bindtextdomain (PACKAGE, LOCALEDIR);
15556 textdomain (PACKAGE);
15557
869b9d07
MM		 15558 expandargv (&argc, &argv);
15559
252b5132
RH		 15560 parse_args (argc, argv);
15561
18bd398b 15562 if (num_dump_sects > 0)
59f14fc0 15563 {
18bd398b 15564 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 15565 cmdline_dump_sects = (dump_type *)
15566 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 15567 if (cmdline_dump_sects == NULL)
591a748a 15568 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 15569 else
15570 {
09c11c86
NC		 15571 memcpy (cmdline_dump_sects, dump_sects,
15572 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 15573 num_cmdline_dump_sects = num_dump_sects;
15574 }
15575 }
15576
18bd398b
NC		 15577 if (optind < (argc - 1))
15578 show_name = 1;
15579
ff78d6d6 15580 err = 0;
252b5132 15581 while (optind < argc)
18bd398b 15582 err |= process_file (argv[optind++]);
252b5132
RH		 15583
15584 if (dump_sects != NULL)
15585 free (dump_sects);
59f14fc0
AS		 15586 if (cmdline_dump_sects != NULL)
15587 free (cmdline_dump_sects);
252b5132 15588
ff78d6d6 15589 return err;
252b5132 15590}
GDB Binutils - Deliverables
This page took 2.747219 seconds and 4 git commands to generate.