]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update mips tests with symbol version string
[thirdparty/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";
85b1c36d
BE		 168static long archive_file_offset;
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
59245841
NC		 316/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
317 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
318 using malloc and fill that. In either case return the pointer to the start of
319 the retrieved data or NULL if something went wrong. If something does go wrong
320 emit an error message using REASON as part of the context. */
321
c256ffe7 322static void *
2cf0635d
NC		 323get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
324 const char * reason)
a6e9f9df 325{
2cf0635d 326 void * mvar;
a6e9f9df 327
c256ffe7 328 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 329 return NULL;
330
fb52b2f4 331 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 332 {
049b0c3a
NC		 333 if (reason)
334 error (_("Unable to seek to 0x%lx for %s\n"),
335 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 336 return NULL;
337 }
338
071436c6
NC		 339 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
340 attempting to allocate memory when the read is bound to fail. */
341 if (offset + archive_file_offset + size * nmemb > current_file_size)
342 {
343 if (reason)
344 error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
345 (unsigned long) (size * nmemb), reason);
346 return NULL;
347 }
348
a6e9f9df
AM		 349 mvar = var;
350 if (mvar == NULL)
351 {
c256ffe7
JJ		 352 /* Check for overflow. */
353 if (nmemb < (~(size_t) 0 - 1) / size)
354 /* + 1 so that we can '\0' terminate invalid string table sections. */
355 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 356
357 if (mvar == NULL)
358 {
049b0c3a
NC		 359 if (reason)
360 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
361 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 362 return NULL;
363 }
c256ffe7
JJ		 364
365 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 366 }
367
c256ffe7 368 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 369 {
049b0c3a
NC		 370 if (reason)
371 error (_("Unable to read in 0x%lx bytes of %s\n"),
372 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 373 if (mvar != var)
374 free (mvar);
375 return NULL;
376 }
377
378 return mvar;
379}
380
14a91970 381/* Print a VMA value. */
cb8f3167 382
66543521 383static int
14a91970 384print_vma (bfd_vma vma, print_mode mode)
66543521 385{
66543521
AM		 386 int nc = 0;
387
14a91970 388 switch (mode)
66543521 389 {
14a91970
AM		 390 case FULL_HEX:
391 nc = printf ("0x");
392 /* Drop through. */
66543521 393
14a91970 394 case LONG_HEX:
f7a99963 395#ifdef BFD64
14a91970 396 if (is_32bit_elf)
437c2fb7 397 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 398#endif
14a91970
AM		 399 printf_vma (vma);
400 return nc + 16;
b19aac67 401
14a91970
AM		 402 case DEC_5:
403 if (vma <= 99999)
404 return printf ("%5" BFD_VMA_FMT "d", vma);
405 /* Drop through. */
66543521 406
14a91970
AM		 407 case PREFIX_HEX:
408 nc = printf ("0x");
409 /* Drop through. */
66543521 410
14a91970
AM		 411 case HEX:
412 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 413
14a91970
AM		 414 case DEC:
415 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 416
14a91970
AM		 417 case UNSIGNED:
418 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 419 }
66543521 420 return 0;
f7a99963
NC		 421}
422
7bfd842d 423/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 424 multibye characters (assuming the host environment supports them).
31104126 425
7bfd842d
NC		 426 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
427
428 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
429 padding as necessary.
171191ba
NC		 430
431 Returns the number of emitted characters. */
432
433static unsigned int
7a88bc9c 434print_symbol (int width, const char *symbol)
31104126 435{
171191ba 436 bfd_boolean extra_padding = FALSE;
7bfd842d 437 int num_printed = 0;
3bfcb652 438#ifdef HAVE_MBSTATE_T
7bfd842d 439 mbstate_t state;
3bfcb652 440#endif
7bfd842d 441 int width_remaining;
961c521f 442
7bfd842d 443 if (width < 0)
961c521f 444 {
961c521f
NC		 445 /* Keep the width positive. This also helps. */
446 width = - width;
171191ba 447 extra_padding = TRUE;
0b4362b0 448 }
74e1a04b 449 assert (width != 0);
961c521f 450
7bfd842d
NC		 451 if (do_wide)
452 /* Set the remaining width to a very large value.
453 This simplifies the code below. */
454 width_remaining = INT_MAX;
455 else
456 width_remaining = width;
cb8f3167 457
3bfcb652 458#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 459 /* Initialise the multibyte conversion state. */
460 memset (& state, 0, sizeof (state));
3bfcb652 461#endif
961c521f 462
7bfd842d
NC		 463 while (width_remaining)
464 {
465 size_t n;
7bfd842d 466 const char c = *symbol++;
961c521f 467
7bfd842d 468 if (c == 0)
961c521f
NC		 469 break;
470
7bfd842d
NC		 471 /* Do not print control characters directly as they can affect terminal
472 settings. Such characters usually appear in the names generated
473 by the assembler for local labels. */
474 if (ISCNTRL (c))
961c521f 475 {
7bfd842d 476 if (width_remaining < 2)
961c521f
NC		 477 break;
478
7bfd842d
NC		 479 printf ("^%c", c + 0x40);
480 width_remaining -= 2;
171191ba 481 num_printed += 2;
961c521f 482 }
7bfd842d
NC		 483 else if (ISPRINT (c))
484 {
485 putchar (c);
486 width_remaining --;
487 num_printed ++;
488 }
961c521f
NC		 489 else
490 {
3bfcb652
NC		 491#ifdef HAVE_MBSTATE_T
492 wchar_t w;
493#endif
7bfd842d
NC		 494 /* Let printf do the hard work of displaying multibyte characters. */
495 printf ("%.1s", symbol - 1);
496 width_remaining --;
497 num_printed ++;
498
3bfcb652 499#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 500 /* Try to find out how many bytes made up the character that was
501 just printed. Advance the symbol pointer past the bytes that
502 were displayed. */
503 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 504#else
505 n = 1;
506#endif
7bfd842d
NC		 507 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
508 symbol += (n - 1);
961c521f 509 }
961c521f 510 }
171191ba 511
7bfd842d 512 if (extra_padding && num_printed < width)
171191ba
NC		 513 {
514 /* Fill in the remaining spaces. */
7bfd842d
NC		 515 printf ("%-*s", width - num_printed, " ");
516 num_printed = width;
171191ba
NC		 517 }
518
519 return num_printed;
31104126
NC		 520}
521
74e1a04b
NC		 522/* Returns a pointer to a static buffer containing a printable version of
523 the given section's name. Like print_symbol, except that it does not try
524 to print multibyte characters, it just interprets them as hex values. */
525
526static const char *
527printable_section_name (Elf_Internal_Shdr * sec)
528{
529#define MAX_PRINT_SEC_NAME_LEN 128
530 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
531 const char * name = SECTION_NAME (sec);
532 char * buf = sec_name_buf;
533 char c;
534 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
535
536 while ((c = * name ++) != 0)
537 {
538 if (ISCNTRL (c))
539 {
540 if (remaining < 2)
541 break;
542
543 * buf ++ = '^';
544 * buf ++ = c + 0x40;
545 remaining -= 2;
546 }
547 else if (ISPRINT (c))
548 {
549 * buf ++ = c;
550 remaining -= 1;
551 }
552 else
553 {
554 static char hex[17] = "0123456789ABCDEF";
555
556 if (remaining < 4)
557 break;
558 * buf ++ = '<';
559 * buf ++ = hex[(c & 0xf0) >> 4];
560 * buf ++ = hex[c & 0x0f];
561 * buf ++ = '>';
562 remaining -= 4;
563 }
564
565 if (remaining == 0)
566 break;
567 }
568
569 * buf = 0;
570 return sec_name_buf;
571}
572
573static const char *
574printable_section_name_from_index (unsigned long ndx)
575{
576 if (ndx >= elf_header.e_shnum)
577 return _("<corrupt>");
578
579 return printable_section_name (section_headers + ndx);
580}
581
89fac5e3
RS		 582/* Return a pointer to section NAME, or NULL if no such section exists. */
583
584static Elf_Internal_Shdr *
2cf0635d 585find_section (const char * name)
89fac5e3
RS		 586{
587 unsigned int i;
588
589 for (i = 0; i < elf_header.e_shnum; i++)
590 if (streq (SECTION_NAME (section_headers + i), name))
591 return section_headers + i;
592
593 return NULL;
594}
595
0b6ae522
DJ		 596/* Return a pointer to a section containing ADDR, or NULL if no such
597 section exists. */
598
599static Elf_Internal_Shdr *
600find_section_by_address (bfd_vma addr)
601{
602 unsigned int i;
603
604 for (i = 0; i < elf_header.e_shnum; i++)
605 {
606 Elf_Internal_Shdr *sec = section_headers + i;
607 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
608 return sec;
609 }
610
611 return NULL;
612}
613
071436c6
NC		 614static Elf_Internal_Shdr *
615find_section_by_type (unsigned int type)
616{
617 unsigned int i;
618
619 for (i = 0; i < elf_header.e_shnum; i++)
620 {
621 Elf_Internal_Shdr *sec = section_headers + i;
622 if (sec->sh_type == type)
623 return sec;
624 }
625
626 return NULL;
627}
628
657d0d47
CC		 629/* Return a pointer to section NAME, or NULL if no such section exists,
630 restricted to the list of sections given in SET. */
631
632static Elf_Internal_Shdr *
633find_section_in_set (const char * name, unsigned int * set)
634{
635 unsigned int i;
636
637 if (set != NULL)
638 {
639 while ((i = *set++) > 0)
640 if (streq (SECTION_NAME (section_headers + i), name))
641 return section_headers + i;
642 }
643
644 return find_section (name);
645}
646
0b6ae522
DJ		 647/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
648 bytes read. */
649
f6f0e17b
NC		 650static inline unsigned long
651read_uleb128 (unsigned char *data,
652 unsigned int *length_return,
653 const unsigned char * const end)
0b6ae522 654{
f6f0e17b 655 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 656}
657
28f997cf
TG		 658/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
659 This OS has so many departures from the ELF standard that we test it at
660 many places. */
661
662static inline int
663is_ia64_vms (void)
664{
665 return elf_header.e_machine == EM_IA_64
666 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
667}
668
bcedfee6 669/* Guess the relocation size commonly used by the specific machines. */
252b5132 670
252b5132 671static int
2dc4cec1 672guess_is_rela (unsigned int e_machine)
252b5132 673{
9c19a809 674 switch (e_machine)
252b5132
RH		 675 {
676 /* Targets that use REL relocations. */
252b5132
RH		 677 case EM_386:
678 case EM_486:
63fcb9e9 679 case EM_960:
e9f53129 680 case EM_ARM:
2b0337b0 681 case EM_D10V:
252b5132 682 case EM_CYGNUS_D10V:
e9f53129 683 case EM_DLX:
252b5132 684 case EM_MIPS:
4fe85591 685 case EM_MIPS_RS3_LE:
e9f53129 686 case EM_CYGNUS_M32R:
1c0d3aa6 687 case EM_SCORE:
f6c1a2d5 688 case EM_XGATE:
9c19a809 689 return FALSE;
103f02d3 690
252b5132
RH		 691 /* Targets that use RELA relocations. */
692 case EM_68K:
e9f53129 693 case EM_860:
a06ea964 694 case EM_AARCH64:
cfb8c092 695 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 696 case EM_ALPHA:
697 case EM_ALTERA_NIOS2:
698 case EM_AVR:
699 case EM_AVR_OLD:
700 case EM_BLACKFIN:
60bca95a 701 case EM_CR16:
e9f53129
AM		 702 case EM_CRIS:
703 case EM_CRX:
2b0337b0 704 case EM_D30V:
252b5132 705 case EM_CYGNUS_D30V:
2b0337b0 706 case EM_FR30:
252b5132 707 case EM_CYGNUS_FR30:
5c70f934 708 case EM_CYGNUS_FRV:
e9f53129
AM		 709 case EM_H8S:
710 case EM_H8_300:
711 case EM_H8_300H:
800eeca4 712 case EM_IA_64:
1e4cf259
NC		 713 case EM_IP2K:
714 case EM_IP2K_OLD:
3b36097d 715 case EM_IQ2000:
84e94c90 716 case EM_LATTICEMICO32:
ff7eeb89 717 case EM_M32C_OLD:
49f58d10 718 case EM_M32C:
e9f53129
AM		 719 case EM_M32R:
720 case EM_MCORE:
15ab5209 721 case EM_CYGNUS_MEP:
a3c62988 722 case EM_METAG:
e9f53129
AM		 723 case EM_MMIX:
724 case EM_MN10200:
725 case EM_CYGNUS_MN10200:
726 case EM_MN10300:
727 case EM_CYGNUS_MN10300:
5506d11a 728 case EM_MOXIE:
e9f53129
AM		 729 case EM_MSP430:
730 case EM_MSP430_OLD:
d031aafb 731 case EM_MT:
35c08157 732 case EM_NDS32:
64fd6348 733 case EM_NIOS32:
73589c9d 734 case EM_OR1K:
e9f53129
AM		 735 case EM_PPC64:
736 case EM_PPC:
99c513f6 737 case EM_RL78:
c7927a3c 738 case EM_RX:
e9f53129
AM		 739 case EM_S390:
740 case EM_S390_OLD:
741 case EM_SH:
742 case EM_SPARC:
743 case EM_SPARC32PLUS:
744 case EM_SPARCV9:
745 case EM_SPU:
40b36596 746 case EM_TI_C6000:
aa137e4d
NC		 747 case EM_TILEGX:
748 case EM_TILEPRO:
708e2187 749 case EM_V800:
e9f53129
AM		 750 case EM_V850:
751 case EM_CYGNUS_V850:
752 case EM_VAX:
753 case EM_X86_64:
8a9036a4 754 case EM_L1OM:
7a9068fe 755 case EM_K1OM:
e9f53129
AM		 756 case EM_XSTORMY16:
757 case EM_XTENSA:
758 case EM_XTENSA_OLD:
7ba29e2a
NC		 759 case EM_MICROBLAZE:
760 case EM_MICROBLAZE_OLD:
9c19a809 761 return TRUE;
103f02d3 762
e9f53129
AM		 763 case EM_68HC05:
764 case EM_68HC08:
765 case EM_68HC11:
766 case EM_68HC16:
767 case EM_FX66:
768 case EM_ME16:
d1133906 769 case EM_MMA:
d1133906
NC		 770 case EM_NCPU:
771 case EM_NDR1:
e9f53129 772 case EM_PCP:
d1133906 773 case EM_ST100:
e9f53129 774 case EM_ST19:
d1133906 775 case EM_ST7:
e9f53129
AM		 776 case EM_ST9PLUS:
777 case EM_STARCORE:
d1133906 778 case EM_SVX:
e9f53129 779 case EM_TINYJ:
9c19a809
NC		 780 default:
781 warn (_("Don't know about relocations on this machine architecture\n"));
782 return FALSE;
783 }
784}
252b5132 785
9c19a809 786static int
2cf0635d 787slurp_rela_relocs (FILE * file,
d3ba0551
AM		 788 unsigned long rel_offset,
789 unsigned long rel_size,
2cf0635d
NC		 790 Elf_Internal_Rela ** relasp,
791 unsigned long * nrelasp)
9c19a809 792{
2cf0635d 793 Elf_Internal_Rela * relas;
8b73c356 794 size_t nrelas;
4d6ed7c8 795 unsigned int i;
252b5132 796
4d6ed7c8
NC		 797 if (is_32bit_elf)
798 {
2cf0635d 799 Elf32_External_Rela * erelas;
103f02d3 800
3f5e193b 801 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 802 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 803 if (!erelas)
804 return 0;
252b5132 805
4d6ed7c8 806 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 807
3f5e193b
NC		 808 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
809 sizeof (Elf_Internal_Rela));
103f02d3 810
4d6ed7c8
NC		 811 if (relas == NULL)
812 {
c256ffe7 813 free (erelas);
591a748a 814 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 815 return 0;
816 }
103f02d3 817
4d6ed7c8
NC		 818 for (i = 0; i < nrelas; i++)
819 {
820 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
821 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 822 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 823 }
103f02d3 824
4d6ed7c8
NC		 825 free (erelas);
826 }
827 else
828 {
2cf0635d 829 Elf64_External_Rela * erelas;
103f02d3 830
3f5e193b 831 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 832 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 833 if (!erelas)
834 return 0;
4d6ed7c8
NC		 835
836 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 837
3f5e193b
NC		 838 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
839 sizeof (Elf_Internal_Rela));
103f02d3 840
4d6ed7c8
NC		 841 if (relas == NULL)
842 {
c256ffe7 843 free (erelas);
591a748a 844 error (_("out of memory parsing relocs\n"));
4d6ed7c8 845 return 0;
9c19a809 846 }
4d6ed7c8
NC		 847
848 for (i = 0; i < nrelas; i++)
9c19a809 849 {
66543521
AM		 850 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
851 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 852 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 853
854 /* The #ifdef BFD64 below is to prevent a compile time
855 warning. We know that if we do not have a 64 bit data
856 type that we will never execute this code anyway. */
857#ifdef BFD64
858 if (elf_header.e_machine == EM_MIPS
859 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
860 {
861 /* In little-endian objects, r_info isn't really a
862 64-bit little-endian value: it has a 32-bit
863 little-endian symbol index followed by four
864 individual byte fields. Reorder INFO
865 accordingly. */
91d6fa6a
NC		 866 bfd_vma inf = relas[i].r_info;
867 inf = (((inf & 0xffffffff) << 32)
868 | ((inf >> 56) & 0xff)
869 | ((inf >> 40) & 0xff00)
870 | ((inf >> 24) & 0xff0000)
871 | ((inf >> 8) & 0xff000000));
872 relas[i].r_info = inf;
861fb55a
DJ		 873 }
874#endif /* BFD64 */
4d6ed7c8 875 }
103f02d3 876
4d6ed7c8
NC		 877 free (erelas);
878 }
879 *relasp = relas;
880 *nrelasp = nrelas;
881 return 1;
882}
103f02d3 883
4d6ed7c8 884static int
2cf0635d 885slurp_rel_relocs (FILE * file,
d3ba0551
AM		 886 unsigned long rel_offset,
887 unsigned long rel_size,
2cf0635d
NC		 888 Elf_Internal_Rela ** relsp,
889 unsigned long * nrelsp)
4d6ed7c8 890{
2cf0635d 891 Elf_Internal_Rela * rels;
8b73c356 892 size_t nrels;
4d6ed7c8 893 unsigned int i;
103f02d3 894
4d6ed7c8
NC		 895 if (is_32bit_elf)
896 {
2cf0635d 897 Elf32_External_Rel * erels;
103f02d3 898
3f5e193b 899 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 900 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 901 if (!erels)
902 return 0;
103f02d3 903
4d6ed7c8 904 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 905
3f5e193b 906 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 907
4d6ed7c8
NC		 908 if (rels == NULL)
909 {
c256ffe7 910 free (erels);
591a748a 911 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 912 return 0;
913 }
914
915 for (i = 0; i < nrels; i++)
916 {
917 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
918 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 919 rels[i].r_addend = 0;
9ea033b2 920 }
4d6ed7c8
NC		 921
922 free (erels);
9c19a809
NC		 923 }
924 else
925 {
2cf0635d 926 Elf64_External_Rel * erels;
9ea033b2 927
3f5e193b 928 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 929 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 930 if (!erels)
931 return 0;
103f02d3 932
4d6ed7c8 933 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 934
3f5e193b 935 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 936
4d6ed7c8 937 if (rels == NULL)
9c19a809 938 {
c256ffe7 939 free (erels);
591a748a 940 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 941 return 0;
942 }
103f02d3 943
4d6ed7c8
NC		 944 for (i = 0; i < nrels; i++)
945 {
66543521
AM		 946 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
947 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 948 rels[i].r_addend = 0;
861fb55a
DJ		 949
950 /* The #ifdef BFD64 below is to prevent a compile time
951 warning. We know that if we do not have a 64 bit data
952 type that we will never execute this code anyway. */
953#ifdef BFD64
954 if (elf_header.e_machine == EM_MIPS
955 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
956 {
957 /* In little-endian objects, r_info isn't really a
958 64-bit little-endian value: it has a 32-bit
959 little-endian symbol index followed by four
960 individual byte fields. Reorder INFO
961 accordingly. */
91d6fa6a
NC		 962 bfd_vma inf = rels[i].r_info;
963 inf = (((inf & 0xffffffff) << 32)
964 | ((inf >> 56) & 0xff)
965 | ((inf >> 40) & 0xff00)
966 | ((inf >> 24) & 0xff0000)
967 | ((inf >> 8) & 0xff000000));
968 rels[i].r_info = inf;
861fb55a
DJ		 969 }
970#endif /* BFD64 */
4d6ed7c8 971 }
103f02d3 972
4d6ed7c8
NC		 973 free (erels);
974 }
975 *relsp = rels;
976 *nrelsp = nrels;
977 return 1;
978}
103f02d3 979
aca88567
NC		 980/* Returns the reloc type extracted from the reloc info field. */
981
982static unsigned int
983get_reloc_type (bfd_vma reloc_info)
984{
985 if (is_32bit_elf)
986 return ELF32_R_TYPE (reloc_info);
987
988 switch (elf_header.e_machine)
989 {
990 case EM_MIPS:
991 /* Note: We assume that reloc_info has already been adjusted for us. */
992 return ELF64_MIPS_R_TYPE (reloc_info);
993
994 case EM_SPARCV9:
995 return ELF64_R_TYPE_ID (reloc_info);
996
997 default:
998 return ELF64_R_TYPE (reloc_info);
999 }
1000}
1001
1002/* Return the symbol index extracted from the reloc info field. */
1003
1004static bfd_vma
1005get_reloc_symindex (bfd_vma reloc_info)
1006{
1007 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1008}
1009
13761a11
NC		 1010static inline bfd_boolean
1011uses_msp430x_relocs (void)
1012{
1013 return
1014 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1015 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1016 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1017 /* TI compiler uses ELFOSABI_NONE. */
1018 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1019}
1020
d3ba0551
AM		 1021/* Display the contents of the relocation data found at the specified
1022 offset. */
ee42cf8c 1023
41e92641 1024static void
2cf0635d 1025dump_relocations (FILE * file,
d3ba0551
AM		 1026 unsigned long rel_offset,
1027 unsigned long rel_size,
2cf0635d 1028 Elf_Internal_Sym * symtab,
d3ba0551 1029 unsigned long nsyms,
2cf0635d 1030 char * strtab,
d79b3d50 1031 unsigned long strtablen,
bb4d2ac2
L		 1032 int is_rela,
1033 int is_dynsym)
4d6ed7c8 1034{
b34976b6 1035 unsigned int i;
2cf0635d 1036 Elf_Internal_Rela * rels;
103f02d3 1037
4d6ed7c8
NC		 1038 if (is_rela == UNKNOWN)
1039 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1040
4d6ed7c8
NC		 1041 if (is_rela)
1042 {
c8286bd1 1043 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1044 return;
4d6ed7c8
NC		 1045 }
1046 else
1047 {
1048 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1049 return;
252b5132
RH		 1050 }
1051
410f7a12
L		 1052 if (is_32bit_elf)
1053 {
1054 if (is_rela)
2c71103e
NC		 1055 {
1056 if (do_wide)
1057 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1058 else
1059 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1060 }
410f7a12 1061 else
2c71103e
NC		 1062 {
1063 if (do_wide)
1064 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1065 else
1066 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1067 }
410f7a12 1068 }
252b5132 1069 else
410f7a12
L		 1070 {
1071 if (is_rela)
2c71103e
NC		 1072 {
1073 if (do_wide)
8beeaeb7 1074 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1075 else
1076 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1077 }
410f7a12 1078 else
2c71103e
NC		 1079 {
1080 if (do_wide)
8beeaeb7 1081 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1082 else
1083 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1084 }
410f7a12 1085 }
252b5132
RH		 1086
1087 for (i = 0; i < rel_size; i++)
1088 {
2cf0635d 1089 const char * rtype;
b34976b6 1090 bfd_vma offset;
91d6fa6a 1091 bfd_vma inf;
b34976b6
AM		 1092 bfd_vma symtab_index;
1093 bfd_vma type;
103f02d3 1094
b34976b6 1095 offset = rels[i].r_offset;
91d6fa6a 1096 inf = rels[i].r_info;
103f02d3 1097
91d6fa6a
NC		 1098 type = get_reloc_type (inf);
1099 symtab_index = get_reloc_symindex (inf);
252b5132 1100
410f7a12
L		 1101 if (is_32bit_elf)
1102 {
39dbeff8
AM		 1103 printf ("%8.8lx %8.8lx ",
1104 (unsigned long) offset & 0xffffffff,
91d6fa6a 1105 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1106 }
1107 else
1108 {
39dbeff8
AM		 1109#if BFD_HOST_64BIT_LONG
1110 printf (do_wide
1111 ? "%16.16lx %16.16lx "
1112 : "%12.12lx %12.12lx ",
91d6fa6a 1113 offset, inf);
39dbeff8 1114#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1115#ifndef __MSVCRT__
39dbeff8
AM		 1116 printf (do_wide
1117 ? "%16.16llx %16.16llx "
1118 : "%12.12llx %12.12llx ",
91d6fa6a 1119 offset, inf);
6e3d6dc1
NC		 1120#else
1121 printf (do_wide
1122 ? "%16.16I64x %16.16I64x "
1123 : "%12.12I64x %12.12I64x ",
91d6fa6a 1124 offset, inf);
6e3d6dc1 1125#endif
39dbeff8 1126#else
2c71103e
NC		 1127 printf (do_wide
1128 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1129 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1130 _bfd_int64_high (offset),
1131 _bfd_int64_low (offset),
91d6fa6a
NC		 1132 _bfd_int64_high (inf),
1133 _bfd_int64_low (inf));
9ea033b2 1134#endif
410f7a12 1135 }
103f02d3 1136
252b5132
RH		 1137 switch (elf_header.e_machine)
1138 {
1139 default:
1140 rtype = NULL;
1141 break;
1142
a06ea964
NC		 1143 case EM_AARCH64:
1144 rtype = elf_aarch64_reloc_type (type);
1145 break;
1146
2b0337b0 1147 case EM_M32R:
252b5132 1148 case EM_CYGNUS_M32R:
9ea033b2 1149 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1150 break;
1151
1152 case EM_386:
1153 case EM_486:
9ea033b2 1154 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1155 break;
1156
ba2685cc
AM		 1157 case EM_68HC11:
1158 case EM_68HC12:
1159 rtype = elf_m68hc11_reloc_type (type);
1160 break;
75751cd9 1161
252b5132 1162 case EM_68K:
9ea033b2 1163 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1164 break;
1165
63fcb9e9 1166 case EM_960:
9ea033b2 1167 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1168 break;
1169
adde6300 1170 case EM_AVR:
2b0337b0 1171 case EM_AVR_OLD:
adde6300
AM		 1172 rtype = elf_avr_reloc_type (type);
1173 break;
1174
9ea033b2
NC		 1175 case EM_OLD_SPARCV9:
1176 case EM_SPARC32PLUS:
1177 case EM_SPARCV9:
252b5132 1178 case EM_SPARC:
9ea033b2 1179 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1180 break;
1181
e9f53129
AM		 1182 case EM_SPU:
1183 rtype = elf_spu_reloc_type (type);
1184 break;
1185
708e2187
NC		 1186 case EM_V800:
1187 rtype = v800_reloc_type (type);
1188 break;
2b0337b0 1189 case EM_V850:
252b5132 1190 case EM_CYGNUS_V850:
9ea033b2 1191 rtype = v850_reloc_type (type);
252b5132
RH		 1192 break;
1193
2b0337b0 1194 case EM_D10V:
252b5132 1195 case EM_CYGNUS_D10V:
9ea033b2 1196 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1197 break;
1198
2b0337b0 1199 case EM_D30V:
252b5132 1200 case EM_CYGNUS_D30V:
9ea033b2 1201 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1202 break;
1203
d172d4ba
NC		 1204 case EM_DLX:
1205 rtype = elf_dlx_reloc_type (type);
1206 break;
1207
252b5132 1208 case EM_SH:
9ea033b2 1209 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1210 break;
1211
2b0337b0 1212 case EM_MN10300:
252b5132 1213 case EM_CYGNUS_MN10300:
9ea033b2 1214 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1215 break;
1216
2b0337b0 1217 case EM_MN10200:
252b5132 1218 case EM_CYGNUS_MN10200:
9ea033b2 1219 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1220 break;
1221
2b0337b0 1222 case EM_FR30:
252b5132 1223 case EM_CYGNUS_FR30:
9ea033b2 1224 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1225 break;
1226
ba2685cc
AM		 1227 case EM_CYGNUS_FRV:
1228 rtype = elf_frv_reloc_type (type);
1229 break;
5c70f934 1230
252b5132 1231 case EM_MCORE:
9ea033b2 1232 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1233 break;
1234
3c3bdf30
NC		 1235 case EM_MMIX:
1236 rtype = elf_mmix_reloc_type (type);
1237 break;
1238
5506d11a
AM		 1239 case EM_MOXIE:
1240 rtype = elf_moxie_reloc_type (type);
1241 break;
1242
2469cfa2 1243 case EM_MSP430:
13761a11
NC		 1244 if (uses_msp430x_relocs ())
1245 {
1246 rtype = elf_msp430x_reloc_type (type);
1247 break;
1248 }
2469cfa2
NC		 1249 case EM_MSP430_OLD:
1250 rtype = elf_msp430_reloc_type (type);
1251 break;
1252
35c08157
KLC		 1253 case EM_NDS32:
1254 rtype = elf_nds32_reloc_type (type);
1255 break;
1256
252b5132 1257 case EM_PPC:
9ea033b2 1258 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1259 break;
1260
c833c019
AM		 1261 case EM_PPC64:
1262 rtype = elf_ppc64_reloc_type (type);
1263 break;
1264
252b5132 1265 case EM_MIPS:
4fe85591 1266 case EM_MIPS_RS3_LE:
9ea033b2 1267 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1268 break;
1269
1270 case EM_ALPHA:
9ea033b2 1271 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1272 break;
1273
1274 case EM_ARM:
9ea033b2 1275 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1276 break;
1277
584da044 1278 case EM_ARC:
9ea033b2 1279 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1280 break;
1281
1282 case EM_PARISC:
69e617ca 1283 rtype = elf_hppa_reloc_type (type);
252b5132 1284 break;
7d466069 1285
b8720f9d
JL		 1286 case EM_H8_300:
1287 case EM_H8_300H:
1288 case EM_H8S:
1289 rtype = elf_h8_reloc_type (type);
1290 break;
1291
73589c9d
CS		 1292 case EM_OR1K:
1293 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1294 break;
1295
7d466069 1296 case EM_PJ:
2b0337b0 1297 case EM_PJ_OLD:
7d466069
ILT		 1298 rtype = elf_pj_reloc_type (type);
1299 break;
800eeca4
JW		 1300 case EM_IA_64:
1301 rtype = elf_ia64_reloc_type (type);
1302 break;
1b61cf92
HPN		 1303
1304 case EM_CRIS:
1305 rtype = elf_cris_reloc_type (type);
1306 break;
535c37ff
JE		 1307
1308 case EM_860:
1309 rtype = elf_i860_reloc_type (type);
1310 break;
bcedfee6
NC		 1311
1312 case EM_X86_64:
8a9036a4 1313 case EM_L1OM:
7a9068fe 1314 case EM_K1OM:
bcedfee6
NC		 1315 rtype = elf_x86_64_reloc_type (type);
1316 break;
a85d7ed0 1317
35b1837e
AM		 1318 case EM_S370:
1319 rtype = i370_reloc_type (type);
1320 break;
1321
53c7db4b
KH		 1322 case EM_S390_OLD:
1323 case EM_S390:
1324 rtype = elf_s390_reloc_type (type);
1325 break;
93fbbb04 1326
1c0d3aa6
NC		 1327 case EM_SCORE:
1328 rtype = elf_score_reloc_type (type);
1329 break;
1330
93fbbb04
GK		 1331 case EM_XSTORMY16:
1332 rtype = elf_xstormy16_reloc_type (type);
1333 break;
179d3252 1334
1fe1f39c
NC		 1335 case EM_CRX:
1336 rtype = elf_crx_reloc_type (type);
1337 break;
1338
179d3252
JT		 1339 case EM_VAX:
1340 rtype = elf_vax_reloc_type (type);
1341 break;
1e4cf259 1342
cfb8c092
NC		 1343 case EM_ADAPTEVA_EPIPHANY:
1344 rtype = elf_epiphany_reloc_type (type);
1345 break;
1346
1e4cf259
NC		 1347 case EM_IP2K:
1348 case EM_IP2K_OLD:
1349 rtype = elf_ip2k_reloc_type (type);
1350 break;
3b36097d
SC		 1351
1352 case EM_IQ2000:
1353 rtype = elf_iq2000_reloc_type (type);
1354 break;
88da6820
NC		 1355
1356 case EM_XTENSA_OLD:
1357 case EM_XTENSA:
1358 rtype = elf_xtensa_reloc_type (type);
1359 break;
a34e3ecb 1360
84e94c90
NC		 1361 case EM_LATTICEMICO32:
1362 rtype = elf_lm32_reloc_type (type);
1363 break;
1364
ff7eeb89 1365 case EM_M32C_OLD:
49f58d10
JB		 1366 case EM_M32C:
1367 rtype = elf_m32c_reloc_type (type);
1368 break;
1369
d031aafb
NS		 1370 case EM_MT:
1371 rtype = elf_mt_reloc_type (type);
a34e3ecb 1372 break;
1d65ded4
CM		 1373
1374 case EM_BLACKFIN:
1375 rtype = elf_bfin_reloc_type (type);
1376 break;
15ab5209
DB		 1377
1378 case EM_CYGNUS_MEP:
1379 rtype = elf_mep_reloc_type (type);
1380 break;
60bca95a
NC		 1381
1382 case EM_CR16:
1383 rtype = elf_cr16_reloc_type (type);
1384 break;
dd24e3da 1385
7ba29e2a
NC		 1386 case EM_MICROBLAZE:
1387 case EM_MICROBLAZE_OLD:
1388 rtype = elf_microblaze_reloc_type (type);
1389 break;
c7927a3c 1390
99c513f6
DD		 1391 case EM_RL78:
1392 rtype = elf_rl78_reloc_type (type);
1393 break;
1394
c7927a3c
NC		 1395 case EM_RX:
1396 rtype = elf_rx_reloc_type (type);
1397 break;
c29aca4a 1398
a3c62988
NC		 1399 case EM_METAG:
1400 rtype = elf_metag_reloc_type (type);
1401 break;
1402
c29aca4a
NC		 1403 case EM_XC16X:
1404 case EM_C166:
1405 rtype = elf_xc16x_reloc_type (type);
1406 break;
40b36596
JM		 1407
1408 case EM_TI_C6000:
1409 rtype = elf_tic6x_reloc_type (type);
1410 break;
aa137e4d
NC		 1411
1412 case EM_TILEGX:
1413 rtype = elf_tilegx_reloc_type (type);
1414 break;
1415
1416 case EM_TILEPRO:
1417 rtype = elf_tilepro_reloc_type (type);
1418 break;
f6c1a2d5
NC		 1419
1420 case EM_XGATE:
1421 rtype = elf_xgate_reloc_type (type);
1422 break;
36591ba1
SL		 1423
1424 case EM_ALTERA_NIOS2:
1425 rtype = elf_nios2_reloc_type (type);
1426 break;
252b5132
RH		 1427 }
1428
1429 if (rtype == NULL)
39dbeff8 1430 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1431 else
8beeaeb7 1432 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1433
7ace3541 1434 if (elf_header.e_machine == EM_ALPHA
157c2599 1435 && rtype != NULL
7ace3541
RH		 1436 && streq (rtype, "R_ALPHA_LITUSE")
1437 && is_rela)
1438 {
1439 switch (rels[i].r_addend)
1440 {
1441 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1442 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1443 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1444 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1445 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1446 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1447 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1448 default: rtype = NULL;
1449 }
1450 if (rtype)
1451 printf (" (%s)", rtype);
1452 else
1453 {
1454 putchar (' ');
1455 printf (_("<unknown addend: %lx>"),
1456 (unsigned long) rels[i].r_addend);
1457 }
1458 }
1459 else if (symtab_index)
252b5132 1460 {
af3fc3bc 1461 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1462 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1463 else
19936277 1464 {
2cf0635d 1465 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1466 const char * version_string;
1467 enum versioned_symbol_info sym_info;
1468 unsigned short vna_other;
19936277 1469
af3fc3bc 1470 psym = symtab + symtab_index;
103f02d3 1471
bb4d2ac2
L		 1472 version_string
1473 = get_symbol_version_string (file, is_dynsym,
1474 strtab, strtablen,
1475 symtab_index,
1476 psym,
1477 &sym_info,
1478 &vna_other);
1479
af3fc3bc 1480 printf (" ");
171191ba 1481
d8045f23
NC		 1482 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1483 {
1484 const char * name;
1485 unsigned int len;
1486 unsigned int width = is_32bit_elf ? 8 : 14;
1487
1488 /* Relocations against GNU_IFUNC symbols do not use the value
1489 of the symbol as the address to relocate against. Instead
1490 they invoke the function named by the symbol and use its
1491 result as the address for relocation.
1492
1493 To indicate this to the user, do not display the value of
1494 the symbol in the "Symbols's Value" field. Instead show
1495 its name followed by () as a hint that the symbol is
1496 invoked. */
1497
1498 if (strtab == NULL
1499 || psym->st_name == 0
1500 || psym->st_name >= strtablen)
1501 name = "??";
1502 else
1503 name = strtab + psym->st_name;
1504
1505 len = print_symbol (width, name);
bb4d2ac2
L		 1506 if (version_string)
1507 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1508 version_string);
d8045f23
NC		 1509 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1510 }
1511 else
1512 {
1513 print_vma (psym->st_value, LONG_HEX);
171191ba 1514
d8045f23
NC		 1515 printf (is_32bit_elf ? " " : " ");
1516 }
103f02d3 1517
af3fc3bc 1518 if (psym->st_name == 0)
f1ef08cb 1519 {
2cf0635d 1520 const char * sec_name = "<null>";
f1ef08cb
AM		 1521 char name_buf[40];
1522
1523 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1524 {
4fbb74a6 1525 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1526 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1527 else if (psym->st_shndx == SHN_ABS)
1528 sec_name = "ABS";
1529 else if (psym->st_shndx == SHN_COMMON)
1530 sec_name = "COMMON";
ac145307
BS		 1531 else if ((elf_header.e_machine == EM_MIPS
1532 && psym->st_shndx == SHN_MIPS_SCOMMON)
1533 || (elf_header.e_machine == EM_TI_C6000
1534 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1535 sec_name = "SCOMMON";
1536 else if (elf_header.e_machine == EM_MIPS
1537 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1538 sec_name = "SUNDEF";
8a9036a4 1539 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1540 || elf_header.e_machine == EM_L1OM
1541 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1542 && psym->st_shndx == SHN_X86_64_LCOMMON)
1543 sec_name = "LARGE_COMMON";
9ce701e2
L		 1544 else if (elf_header.e_machine == EM_IA_64
1545 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1546 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1547 sec_name = "ANSI_COM";
28f997cf 1548 else if (is_ia64_vms ()
148b93f2
NC		 1549 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1550 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1551 else
1552 {
1553 sprintf (name_buf, "<section 0x%x>",
1554 (unsigned int) psym->st_shndx);
1555 sec_name = name_buf;
1556 }
1557 }
1558 print_symbol (22, sec_name);
1559 }
af3fc3bc 1560 else if (strtab == NULL)
d79b3d50 1561 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1562 else if (psym->st_name >= strtablen)
d79b3d50 1563 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1564 else
bb4d2ac2
L		 1565 {
1566 print_symbol (22, strtab + psym->st_name);
1567 if (version_string)
1568 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1569 version_string);
1570 }
103f02d3 1571
af3fc3bc 1572 if (is_rela)
171191ba 1573 {
598aaa76 1574 bfd_signed_vma off = rels[i].r_addend;
171191ba 1575
91d6fa6a 1576 if (off < 0)
598aaa76 1577 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1578 else
598aaa76 1579 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1580 }
19936277 1581 }
252b5132 1582 }
1b228002 1583 else if (is_rela)
f7a99963 1584 {
e04d7088
L		 1585 bfd_signed_vma off = rels[i].r_addend;
1586
1587 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1588 if (off < 0)
1589 printf ("-%" BFD_VMA_FMT "x", - off);
1590 else
1591 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1592 }
252b5132 1593
157c2599
NC		 1594 if (elf_header.e_machine == EM_SPARCV9
1595 && rtype != NULL
1596 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1597 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1598
252b5132 1599 putchar ('\n');
2c71103e 1600
aca88567 1601#ifdef BFD64
53c7db4b 1602 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1603 {
91d6fa6a
NC		 1604 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1605 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1606 const char * rtype2 = elf_mips_reloc_type (type2);
1607 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1608
2c71103e
NC		 1609 printf (" Type2: ");
1610
1611 if (rtype2 == NULL)
39dbeff8
AM		 1612 printf (_("unrecognized: %-7lx"),
1613 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1614 else
1615 printf ("%-17.17s", rtype2);
1616
18bd398b 1617 printf ("\n Type3: ");
2c71103e
NC		 1618
1619 if (rtype3 == NULL)
39dbeff8
AM		 1620 printf (_("unrecognized: %-7lx"),
1621 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1622 else
1623 printf ("%-17.17s", rtype3);
1624
53c7db4b 1625 putchar ('\n');
2c71103e 1626 }
aca88567 1627#endif /* BFD64 */
252b5132
RH		 1628 }
1629
c8286bd1 1630 free (rels);
252b5132
RH		 1631}
1632
1633static const char *
d3ba0551 1634get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1635{
1636 switch (type)
1637 {
1638 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1639 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1640 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1641 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1642 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1643 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1644 case DT_MIPS_MSYM: return "MIPS_MSYM";
1645 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1646 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1647 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1648 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1649 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1650 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1651 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1652 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1653 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1654 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1655 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1656 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1657 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1658 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1659 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1660 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1661 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1662 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1663 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1664 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1665 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1666 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1667 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1668 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1669 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1670 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1671 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1672 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1673 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1674 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1675 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1676 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1677 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1678 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1679 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1680 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1681 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1682 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1683 default:
1684 return NULL;
1685 }
1686}
1687
9a097730 1688static const char *
d3ba0551 1689get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1690{
1691 switch (type)
1692 {
1693 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1694 default:
1695 return NULL;
1696 }
103f02d3
UD		 1697}
1698
7490d522
AM		 1699static const char *
1700get_ppc_dynamic_type (unsigned long type)
1701{
1702 switch (type)
1703 {
a7f2871e 1704 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1705 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1706 default:
1707 return NULL;
1708 }
1709}
1710
f1cb7e17 1711static const char *
d3ba0551 1712get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1713{
1714 switch (type)
1715 {
a7f2871e
AM		 1716 case DT_PPC64_GLINK: return "PPC64_GLINK";
1717 case DT_PPC64_OPD: return "PPC64_OPD";
1718 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1719 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1720 default:
1721 return NULL;
1722 }
1723}
1724
103f02d3 1725static const char *
d3ba0551 1726get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1727{
1728 switch (type)
1729 {
1730 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1731 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1732 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1733 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1734 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1735 case DT_HP_PREINIT: return "HP_PREINIT";
1736 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1737 case DT_HP_NEEDED: return "HP_NEEDED";
1738 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1739 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1740 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1741 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1742 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1743 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1744 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1745 case DT_HP_FILTERED: return "HP_FILTERED";
1746 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1747 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1748 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1749 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1750 case DT_PLT: return "PLT";
1751 case DT_PLT_SIZE: return "PLT_SIZE";
1752 case DT_DLT: return "DLT";
1753 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1754 default:
1755 return NULL;
1756 }
1757}
9a097730 1758
ecc51f48 1759static const char *
d3ba0551 1760get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1761{
1762 switch (type)
1763 {
148b93f2
NC		 1764 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1765 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1766 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1767 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1768 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1769 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1770 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1771 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1772 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1773 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1774 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1775 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1776 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1777 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1778 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1779 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1780 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1781 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1782 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1783 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1784 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1785 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1786 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1787 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1788 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1789 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1790 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1791 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1792 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1793 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1794 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1795 default:
1796 return NULL;
1797 }
1798}
1799
fabcb361
RH		 1800static const char *
1801get_alpha_dynamic_type (unsigned long type)
1802{
1803 switch (type)
1804 {
1805 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1806 default:
1807 return NULL;
1808 }
1809}
1810
1c0d3aa6
NC		 1811static const char *
1812get_score_dynamic_type (unsigned long type)
1813{
1814 switch (type)
1815 {
1816 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1817 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1818 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1819 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1820 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1821 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1822 default:
1823 return NULL;
1824 }
1825}
1826
40b36596
JM		 1827static const char *
1828get_tic6x_dynamic_type (unsigned long type)
1829{
1830 switch (type)
1831 {
1832 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1833 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1834 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1835 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1836 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1837 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1838 default:
1839 return NULL;
1840 }
1841}
1c0d3aa6 1842
36591ba1
SL		 1843static const char *
1844get_nios2_dynamic_type (unsigned long type)
1845{
1846 switch (type)
1847 {
1848 case DT_NIOS2_GP: return "NIOS2_GP";
1849 default:
1850 return NULL;
1851 }
1852}
1853
252b5132 1854static const char *
d3ba0551 1855get_dynamic_type (unsigned long type)
252b5132 1856{
e9e44622 1857 static char buff[64];
252b5132
RH		 1858
1859 switch (type)
1860 {
1861 case DT_NULL: return "NULL";
1862 case DT_NEEDED: return "NEEDED";
1863 case DT_PLTRELSZ: return "PLTRELSZ";
1864 case DT_PLTGOT: return "PLTGOT";
1865 case DT_HASH: return "HASH";
1866 case DT_STRTAB: return "STRTAB";
1867 case DT_SYMTAB: return "SYMTAB";
1868 case DT_RELA: return "RELA";
1869 case DT_RELASZ: return "RELASZ";
1870 case DT_RELAENT: return "RELAENT";
1871 case DT_STRSZ: return "STRSZ";
1872 case DT_SYMENT: return "SYMENT";
1873 case DT_INIT: return "INIT";
1874 case DT_FINI: return "FINI";
1875 case DT_SONAME: return "SONAME";
1876 case DT_RPATH: return "RPATH";
1877 case DT_SYMBOLIC: return "SYMBOLIC";
1878 case DT_REL: return "REL";
1879 case DT_RELSZ: return "RELSZ";
1880 case DT_RELENT: return "RELENT";
1881 case DT_PLTREL: return "PLTREL";
1882 case DT_DEBUG: return "DEBUG";
1883 case DT_TEXTREL: return "TEXTREL";
1884 case DT_JMPREL: return "JMPREL";
1885 case DT_BIND_NOW: return "BIND_NOW";
1886 case DT_INIT_ARRAY: return "INIT_ARRAY";
1887 case DT_FINI_ARRAY: return "FINI_ARRAY";
1888 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1889 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1890 case DT_RUNPATH: return "RUNPATH";
1891 case DT_FLAGS: return "FLAGS";
2d0e6f43 1892
d1133906
NC		 1893 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1894 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1895
05107a46 1896 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1897 case DT_PLTPADSZ: return "PLTPADSZ";
1898 case DT_MOVEENT: return "MOVEENT";
1899 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1900 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1901 case DT_POSFLAG_1: return "POSFLAG_1";
1902 case DT_SYMINSZ: return "SYMINSZ";
1903 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1904
252b5132 1905 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1906 case DT_CONFIG: return "CONFIG";
1907 case DT_DEPAUDIT: return "DEPAUDIT";
1908 case DT_AUDIT: return "AUDIT";
1909 case DT_PLTPAD: return "PLTPAD";
1910 case DT_MOVETAB: return "MOVETAB";
252b5132 1911 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1912
252b5132 1913 case DT_VERSYM: return "VERSYM";
103f02d3 1914
67a4f2b7
AO		 1915 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1916 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1917 case DT_RELACOUNT: return "RELACOUNT";
1918 case DT_RELCOUNT: return "RELCOUNT";
1919 case DT_FLAGS_1: return "FLAGS_1";
1920 case DT_VERDEF: return "VERDEF";
1921 case DT_VERDEFNUM: return "VERDEFNUM";
1922 case DT_VERNEED: return "VERNEED";
1923 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1924
019148e4 1925 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1926 case DT_USED: return "USED";
1927 case DT_FILTER: return "FILTER";
103f02d3 1928
047b2264
JJ		 1929 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1930 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1931 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1932 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1933 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1934 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1935
252b5132
RH		 1936 default:
1937 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1938 {
2cf0635d 1939 const char * result;
103f02d3 1940
252b5132
RH		 1941 switch (elf_header.e_machine)
1942 {
1943 case EM_MIPS:
4fe85591 1944 case EM_MIPS_RS3_LE:
252b5132
RH		 1945 result = get_mips_dynamic_type (type);
1946 break;
9a097730
RH		 1947 case EM_SPARCV9:
1948 result = get_sparc64_dynamic_type (type);
1949 break;
7490d522
AM		 1950 case EM_PPC:
1951 result = get_ppc_dynamic_type (type);
1952 break;
f1cb7e17
AM		 1953 case EM_PPC64:
1954 result = get_ppc64_dynamic_type (type);
1955 break;
ecc51f48
NC		 1956 case EM_IA_64:
1957 result = get_ia64_dynamic_type (type);
1958 break;
fabcb361
RH		 1959 case EM_ALPHA:
1960 result = get_alpha_dynamic_type (type);
1961 break;
1c0d3aa6
NC		 1962 case EM_SCORE:
1963 result = get_score_dynamic_type (type);
1964 break;
40b36596
JM		 1965 case EM_TI_C6000:
1966 result = get_tic6x_dynamic_type (type);
1967 break;
36591ba1
SL		 1968 case EM_ALTERA_NIOS2:
1969 result = get_nios2_dynamic_type (type);
1970 break;
252b5132
RH		 1971 default:
1972 result = NULL;
1973 break;
1974 }
1975
1976 if (result != NULL)
1977 return result;
1978
e9e44622 1979 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1980 }
eec8f817
DA		 1981 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1982 || (elf_header.e_machine == EM_PARISC
1983 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1984 {
2cf0635d 1985 const char * result;
103f02d3
UD		 1986
1987 switch (elf_header.e_machine)
1988 {
1989 case EM_PARISC:
1990 result = get_parisc_dynamic_type (type);
1991 break;
148b93f2
NC		 1992 case EM_IA_64:
1993 result = get_ia64_dynamic_type (type);
1994 break;
103f02d3
UD		 1995 default:
1996 result = NULL;
1997 break;
1998 }
1999
2000 if (result != NULL)
2001 return result;
2002
e9e44622
JJ		 2003 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2004 type);
103f02d3 2005 }
252b5132 2006 else
e9e44622 2007 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2008
252b5132
RH		 2009 return buff;
2010 }
2011}
2012
2013static char *
d3ba0551 2014get_file_type (unsigned e_type)
252b5132 2015{
b34976b6 2016 static char buff[32];
252b5132
RH		 2017
2018 switch (e_type)
2019 {
2020 case ET_NONE: return _("NONE (None)");
2021 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2022 case ET_EXEC: return _("EXEC (Executable file)");
2023 case ET_DYN: return _("DYN (Shared object file)");
2024 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2025
2026 default:
2027 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2028 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2029 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2030 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2031 else
e9e44622 2032 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2033 return buff;
2034 }
2035}
2036
2037static char *
d3ba0551 2038get_machine_name (unsigned e_machine)
252b5132 2039{
b34976b6 2040 static char buff[64]; /* XXX */
252b5132
RH		 2041
2042 switch (e_machine)
2043 {
c45021f2 2044 case EM_NONE: return _("None");
a06ea964 2045 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2046 case EM_M32: return "WE32100";
2047 case EM_SPARC: return "Sparc";
e9f53129 2048 case EM_SPU: return "SPU";
c45021f2
NC		 2049 case EM_386: return "Intel 80386";
2050 case EM_68K: return "MC68000";
2051 case EM_88K: return "MC88000";
2052 case EM_486: return "Intel 80486";
2053 case EM_860: return "Intel 80860";
2054 case EM_MIPS: return "MIPS R3000";
2055 case EM_S370: return "IBM System/370";
7036c0e1 2056 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2057 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2058 case EM_PARISC: return "HPPA";
252b5132 2059 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2060 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2061 case EM_960: return "Intel 90860";
2062 case EM_PPC: return "PowerPC";
285d1771 2063 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 2064 case EM_FR20: return "Fujitsu FR20";
2065 case EM_RH32: return "TRW RH32";
b34976b6 2066 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2067 case EM_ARM: return "ARM";
2068 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2069 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2070 case EM_SPARCV9: return "Sparc v9";
2071 case EM_TRICORE: return "Siemens Tricore";
584da044 2072 case EM_ARC: return "ARC";
c2dcd04e
NC		 2073 case EM_H8_300: return "Renesas H8/300";
2074 case EM_H8_300H: return "Renesas H8/300H";
2075 case EM_H8S: return "Renesas H8S";
2076 case EM_H8_500: return "Renesas H8/500";
30800947 2077 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2078 case EM_MIPS_X: return "Stanford MIPS-X";
2079 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2080 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2081 case EM_CYGNUS_D10V:
2082 case EM_D10V: return "d10v";
2083 case EM_CYGNUS_D30V:
b34976b6 2084 case EM_D30V: return "d30v";
2b0337b0 2085 case EM_CYGNUS_M32R:
26597c86 2086 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2087 case EM_CYGNUS_V850:
708e2187 2088 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2089 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2090 case EM_CYGNUS_MN10300:
2091 case EM_MN10300: return "mn10300";
2092 case EM_CYGNUS_MN10200:
2093 case EM_MN10200: return "mn10200";
5506d11a 2094 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2095 case EM_CYGNUS_FR30:
2096 case EM_FR30: return "Fujitsu FR30";
b34976b6 2097 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2098 case EM_PJ_OLD:
b34976b6 2099 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2100 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2101 case EM_PCP: return "Siemens PCP";
2102 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2103 case EM_NDR1: return "Denso NDR1 microprocesspr";
2104 case EM_STARCORE: return "Motorola Star*Core processor";
2105 case EM_ME16: return "Toyota ME16 processor";
2106 case EM_ST100: return "STMicroelectronics ST100 processor";
2107 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2108 case EM_PDSP: return "Sony DSP processor";
2109 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2110 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2111 case EM_FX66: return "Siemens FX66 microcontroller";
2112 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2113 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2114 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2115 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2116 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2117 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2118 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2119 case EM_SVX: return "Silicon Graphics SVx";
2120 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2121 case EM_VAX: return "Digital VAX";
2b0337b0 2122 case EM_AVR_OLD:
b34976b6 2123 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2124 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2125 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2126 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2127 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2128 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2129 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2130 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2131 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2132 case EM_L1OM: return "Intel L1OM";
7a9068fe 2133 case EM_K1OM: return "Intel K1OM";
b7498e0e 2134 case EM_S390_OLD:
b34976b6 2135 case EM_S390: return "IBM S/390";
1c0d3aa6 2136 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2137 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2138 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2139 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2140 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2141 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2142 case EM_DLX: return "OpenDLX";
1e4cf259 2143 case EM_IP2K_OLD:
b34976b6 2144 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2145 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2146 case EM_XTENSA_OLD:
2147 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2148 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2149 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2150 case EM_NS32K: return "National Semiconductor 32000 series";
2151 case EM_TPC: return "Tenor Network TPC processor";
2152 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2153 case EM_MAX: return "MAX Processor";
2154 case EM_CR: return "National Semiconductor CompactRISC";
2155 case EM_F2MC16: return "Fujitsu F2MC16";
2156 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2157 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2158 case EM_M32C_OLD:
49f58d10 2159 case EM_M32C: return "Renesas M32c";
d031aafb 2160 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2161 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2162 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2163 case EM_SEP: return "Sharp embedded microprocessor";
2164 case EM_ARCA: return "Arca RISC microprocessor";
2165 case EM_UNICORE: return "Unicore";
2166 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2167 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2168 case EM_NIOS32: return "Altera Nios";
2169 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2170 case EM_C166:
d70c5fc7 2171 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2172 case EM_M16C: return "Renesas M16C series microprocessors";
2173 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2174 case EM_CE: return "Freescale Communication Engine RISC core";
2175 case EM_TSK3000: return "Altium TSK3000 core";
2176 case EM_RS08: return "Freescale RS08 embedded processor";
2177 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2178 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2179 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2180 case EM_SE_C17: return "Seiko Epson C17 family";
2181 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2182 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2183 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2184 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2185 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2186 case EM_R32C: return "Renesas R32C series microprocessors";
2187 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2188 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2189 case EM_8051: return "Intel 8051 and variants";
2190 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2191 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2192 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2193 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2194 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2195 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2196 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2197 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2198 case EM_CR16:
f6c1a2d5 2199 case EM_MICROBLAZE:
7ba29e2a 2200 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2201 case EM_RL78: return "Renesas RL78";
c7927a3c 2202 case EM_RX: return "Renesas RX";
a3c62988 2203 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2204 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2205 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2206 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2207 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2208 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2209 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2210 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2211 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2212 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2213 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2214 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2215 default:
35d9dd2f 2216 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2217 return buff;
2218 }
2219}
2220
f3485b74 2221static void
d3ba0551 2222decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2223{
2224 unsigned eabi;
2225 int unknown = 0;
2226
2227 eabi = EF_ARM_EABI_VERSION (e_flags);
2228 e_flags &= ~ EF_ARM_EABIMASK;
2229
2230 /* Handle "generic" ARM flags. */
2231 if (e_flags & EF_ARM_RELEXEC)
2232 {
2233 strcat (buf, ", relocatable executable");
2234 e_flags &= ~ EF_ARM_RELEXEC;
2235 }
76da6bbe 2236
f3485b74
NC		 2237 if (e_flags & EF_ARM_HASENTRY)
2238 {
2239 strcat (buf, ", has entry point");
2240 e_flags &= ~ EF_ARM_HASENTRY;
2241 }
76da6bbe 2242
f3485b74
NC		 2243 /* Now handle EABI specific flags. */
2244 switch (eabi)
2245 {
2246 default:
2c71103e 2247 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2248 if (e_flags)
2249 unknown = 1;
2250 break;
2251
2252 case EF_ARM_EABI_VER1:
a5bcd848 2253 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2254 while (e_flags)
2255 {
2256 unsigned flag;
76da6bbe 2257
f3485b74
NC		 2258 /* Process flags one bit at a time. */
2259 flag = e_flags & - e_flags;
2260 e_flags &= ~ flag;
76da6bbe 2261
f3485b74
NC		 2262 switch (flag)
2263 {
a5bcd848 2264 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2265 strcat (buf, ", sorted symbol tables");
2266 break;
76da6bbe 2267
f3485b74
NC		 2268 default:
2269 unknown = 1;
2270 break;
2271 }
2272 }
2273 break;
76da6bbe 2274
a5bcd848
PB		 2275 case EF_ARM_EABI_VER2:
2276 strcat (buf, ", Version2 EABI");
2277 while (e_flags)
2278 {
2279 unsigned flag;
2280
2281 /* Process flags one bit at a time. */
2282 flag = e_flags & - e_flags;
2283 e_flags &= ~ flag;
2284
2285 switch (flag)
2286 {
2287 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2288 strcat (buf, ", sorted symbol tables");
2289 break;
2290
2291 case EF_ARM_DYNSYMSUSESEGIDX:
2292 strcat (buf, ", dynamic symbols use segment index");
2293 break;
2294
2295 case EF_ARM_MAPSYMSFIRST:
2296 strcat (buf, ", mapping symbols precede others");
2297 break;
2298
2299 default:
2300 unknown = 1;
2301 break;
2302 }
2303 }
2304 break;
2305
d507cf36
PB		 2306 case EF_ARM_EABI_VER3:
2307 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2308 break;
2309
2310 case EF_ARM_EABI_VER4:
2311 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2312 while (e_flags)
2313 {
2314 unsigned flag;
2315
2316 /* Process flags one bit at a time. */
2317 flag = e_flags & - e_flags;
2318 e_flags &= ~ flag;
2319
2320 switch (flag)
2321 {
2322 case EF_ARM_BE8:
2323 strcat (buf, ", BE8");
2324 break;
2325
2326 case EF_ARM_LE8:
2327 strcat (buf, ", LE8");
2328 break;
2329
2330 default:
2331 unknown = 1;
2332 break;
2333 }
2334 break;
2335 }
2336 break;
3a4a14e9
PB		 2337
2338 case EF_ARM_EABI_VER5:
2339 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2340 while (e_flags)
2341 {
2342 unsigned flag;
2343
2344 /* Process flags one bit at a time. */
2345 flag = e_flags & - e_flags;
2346 e_flags &= ~ flag;
2347
2348 switch (flag)
2349 {
2350 case EF_ARM_BE8:
2351 strcat (buf, ", BE8");
2352 break;
2353
2354 case EF_ARM_LE8:
2355 strcat (buf, ", LE8");
2356 break;
2357
3bfcb652
NC		 2358 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2359 strcat (buf, ", soft-float ABI");
2360 break;
2361
2362 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2363 strcat (buf, ", hard-float ABI");
2364 break;
2365
d507cf36
PB		 2366 default:
2367 unknown = 1;
2368 break;
2369 }
2370 }
2371 break;
2372
f3485b74 2373 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2374 strcat (buf, ", GNU EABI");
f3485b74
NC		 2375 while (e_flags)
2376 {
2377 unsigned flag;
76da6bbe 2378
f3485b74
NC		 2379 /* Process flags one bit at a time. */
2380 flag = e_flags & - e_flags;
2381 e_flags &= ~ flag;
76da6bbe 2382
f3485b74
NC		 2383 switch (flag)
2384 {
a5bcd848 2385 case EF_ARM_INTERWORK:
f3485b74
NC		 2386 strcat (buf, ", interworking enabled");
2387 break;
76da6bbe 2388
a5bcd848 2389 case EF_ARM_APCS_26:
f3485b74
NC		 2390 strcat (buf, ", uses APCS/26");
2391 break;
76da6bbe 2392
a5bcd848 2393 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2394 strcat (buf, ", uses APCS/float");
2395 break;
76da6bbe 2396
a5bcd848 2397 case EF_ARM_PIC:
f3485b74
NC		 2398 strcat (buf, ", position independent");
2399 break;
76da6bbe 2400
a5bcd848 2401 case EF_ARM_ALIGN8:
f3485b74
NC		 2402 strcat (buf, ", 8 bit structure alignment");
2403 break;
76da6bbe 2404
a5bcd848 2405 case EF_ARM_NEW_ABI:
f3485b74
NC		 2406 strcat (buf, ", uses new ABI");
2407 break;
76da6bbe 2408
a5bcd848 2409 case EF_ARM_OLD_ABI:
f3485b74
NC		 2410 strcat (buf, ", uses old ABI");
2411 break;
76da6bbe 2412
a5bcd848 2413 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2414 strcat (buf, ", software FP");
2415 break;
76da6bbe 2416
90e01f86
ILT		 2417 case EF_ARM_VFP_FLOAT:
2418 strcat (buf, ", VFP");
2419 break;
2420
fde78edd
NC		 2421 case EF_ARM_MAVERICK_FLOAT:
2422 strcat (buf, ", Maverick FP");
2423 break;
2424
f3485b74
NC		 2425 default:
2426 unknown = 1;
2427 break;
2428 }
2429 }
2430 }
f3485b74
NC		 2431
2432 if (unknown)
2b692964 2433 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2434}
2435
35c08157
KLC		 2436static void
2437decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2438{
2439 unsigned abi;
2440 unsigned arch;
2441 unsigned config;
2442 unsigned version;
2443 int has_fpu = 0;
2444 int r = 0;
2445
2446 static const char *ABI_STRINGS[] =
2447 {
2448 "ABI v0", /* use r5 as return register; only used in N1213HC */
2449 "ABI v1", /* use r0 as return register */
2450 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2451 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2452 "AABI",
2453 "ABI2 FP+"
35c08157
KLC		 2454 };
2455 static const char *VER_STRINGS[] =
2456 {
2457 "Andes ELF V1.3 or older",
2458 "Andes ELF V1.3.1",
2459 "Andes ELF V1.4"
2460 };
2461 static const char *ARCH_STRINGS[] =
2462 {
2463 "",
2464 "Andes Star v1.0",
2465 "Andes Star v2.0",
2466 "Andes Star v3.0",
2467 "Andes Star v3.0m"
2468 };
2469
2470 abi = EF_NDS_ABI & e_flags;
2471 arch = EF_NDS_ARCH & e_flags;
2472 config = EF_NDS_INST & e_flags;
2473 version = EF_NDS32_ELF_VERSION & e_flags;
2474
2475 memset (buf, 0, size);
2476
2477 switch (abi)
2478 {
2479 case E_NDS_ABI_V0:
2480 case E_NDS_ABI_V1:
2481 case E_NDS_ABI_V2:
2482 case E_NDS_ABI_V2FP:
2483 case E_NDS_ABI_AABI:
40c7a7cb 2484 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2485 /* In case there are holes in the array. */
2486 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2487 break;
2488
2489 default:
2490 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2491 break;
2492 }
2493
2494 switch (version)
2495 {
2496 case E_NDS32_ELF_VER_1_2:
2497 case E_NDS32_ELF_VER_1_3:
2498 case E_NDS32_ELF_VER_1_4:
2499 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2500 break;
2501
2502 default:
2503 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2504 break;
2505 }
2506
2507 if (E_NDS_ABI_V0 == abi)
2508 {
2509 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2510 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2511 if (arch == E_NDS_ARCH_STAR_V1_0)
2512 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2513 return;
2514 }
2515
2516 switch (arch)
2517 {
2518 case E_NDS_ARCH_STAR_V1_0:
2519 case E_NDS_ARCH_STAR_V2_0:
2520 case E_NDS_ARCH_STAR_V3_0:
2521 case E_NDS_ARCH_STAR_V3_M:
2522 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2523 break;
2524
2525 default:
2526 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2527 /* ARCH version determines how the e_flags are interpreted.
2528 If it is unknown, we cannot proceed. */
2529 return;
2530 }
2531
2532 /* Newer ABI; Now handle architecture specific flags. */
2533 if (arch == E_NDS_ARCH_STAR_V1_0)
2534 {
2535 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2536 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2537
2538 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2539 r += snprintf (buf + r, size -r, ", MAC");
2540
2541 if (config & E_NDS32_HAS_DIV_INST)
2542 r += snprintf (buf + r, size -r, ", DIV");
2543
2544 if (config & E_NDS32_HAS_16BIT_INST)
2545 r += snprintf (buf + r, size -r, ", 16b");
2546 }
2547 else
2548 {
2549 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2550 {
2551 if (version <= E_NDS32_ELF_VER_1_3)
2552 r += snprintf (buf + r, size -r, ", [B8]");
2553 else
2554 r += snprintf (buf + r, size -r, ", EX9");
2555 }
2556
2557 if (config & E_NDS32_HAS_MAC_DX_INST)
2558 r += snprintf (buf + r, size -r, ", MAC_DX");
2559
2560 if (config & E_NDS32_HAS_DIV_DX_INST)
2561 r += snprintf (buf + r, size -r, ", DIV_DX");
2562
2563 if (config & E_NDS32_HAS_16BIT_INST)
2564 {
2565 if (version <= E_NDS32_ELF_VER_1_3)
2566 r += snprintf (buf + r, size -r, ", 16b");
2567 else
2568 r += snprintf (buf + r, size -r, ", IFC");
2569 }
2570 }
2571
2572 if (config & E_NDS32_HAS_EXT_INST)
2573 r += snprintf (buf + r, size -r, ", PERF1");
2574
2575 if (config & E_NDS32_HAS_EXT2_INST)
2576 r += snprintf (buf + r, size -r, ", PERF2");
2577
2578 if (config & E_NDS32_HAS_FPU_INST)
2579 {
2580 has_fpu = 1;
2581 r += snprintf (buf + r, size -r, ", FPU_SP");
2582 }
2583
2584 if (config & E_NDS32_HAS_FPU_DP_INST)
2585 {
2586 has_fpu = 1;
2587 r += snprintf (buf + r, size -r, ", FPU_DP");
2588 }
2589
2590 if (config & E_NDS32_HAS_FPU_MAC_INST)
2591 {
2592 has_fpu = 1;
2593 r += snprintf (buf + r, size -r, ", FPU_MAC");
2594 }
2595
2596 if (has_fpu)
2597 {
2598 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2599 {
2600 case E_NDS32_FPU_REG_8SP_4DP:
2601 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2602 break;
2603 case E_NDS32_FPU_REG_16SP_8DP:
2604 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2605 break;
2606 case E_NDS32_FPU_REG_32SP_16DP:
2607 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2608 break;
2609 case E_NDS32_FPU_REG_32SP_32DP:
2610 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2611 break;
2612 }
2613 }
2614
2615 if (config & E_NDS32_HAS_AUDIO_INST)
2616 r += snprintf (buf + r, size -r, ", AUDIO");
2617
2618 if (config & E_NDS32_HAS_STRING_INST)
2619 r += snprintf (buf + r, size -r, ", STR");
2620
2621 if (config & E_NDS32_HAS_REDUCED_REGS)
2622 r += snprintf (buf + r, size -r, ", 16REG");
2623
2624 if (config & E_NDS32_HAS_VIDEO_INST)
2625 {
2626 if (version <= E_NDS32_ELF_VER_1_3)
2627 r += snprintf (buf + r, size -r, ", VIDEO");
2628 else
2629 r += snprintf (buf + r, size -r, ", SATURATION");
2630 }
2631
2632 if (config & E_NDS32_HAS_ENCRIPT_INST)
2633 r += snprintf (buf + r, size -r, ", ENCRP");
2634
2635 if (config & E_NDS32_HAS_L2C_INST)
2636 r += snprintf (buf + r, size -r, ", L2C");
2637}
2638
252b5132 2639static char *
d3ba0551 2640get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2641{
b34976b6 2642 static char buf[1024];
252b5132
RH		 2643
2644 buf[0] = '\0';
76da6bbe 2645
252b5132
RH		 2646 if (e_flags)
2647 {
2648 switch (e_machine)
2649 {
2650 default:
2651 break;
2652
f3485b74
NC		 2653 case EM_ARM:
2654 decode_ARM_machine_flags (e_flags, buf);
2655 break;
76da6bbe 2656
781303ce
MF		 2657 case EM_BLACKFIN:
2658 if (e_flags & EF_BFIN_PIC)
2659 strcat (buf, ", PIC");
2660
2661 if (e_flags & EF_BFIN_FDPIC)
2662 strcat (buf, ", FDPIC");
2663
2664 if (e_flags & EF_BFIN_CODE_IN_L1)
2665 strcat (buf, ", code in L1");
2666
2667 if (e_flags & EF_BFIN_DATA_IN_L1)
2668 strcat (buf, ", data in L1");
2669
2670 break;
2671
ec2dfb42
AO		 2672 case EM_CYGNUS_FRV:
2673 switch (e_flags & EF_FRV_CPU_MASK)
2674 {
2675 case EF_FRV_CPU_GENERIC:
2676 break;
2677
2678 default:
2679 strcat (buf, ", fr???");
2680 break;
57346661 2681
ec2dfb42
AO		 2682 case EF_FRV_CPU_FR300:
2683 strcat (buf, ", fr300");
2684 break;
2685
2686 case EF_FRV_CPU_FR400:
2687 strcat (buf, ", fr400");
2688 break;
2689 case EF_FRV_CPU_FR405:
2690 strcat (buf, ", fr405");
2691 break;
2692
2693 case EF_FRV_CPU_FR450:
2694 strcat (buf, ", fr450");
2695 break;
2696
2697 case EF_FRV_CPU_FR500:
2698 strcat (buf, ", fr500");
2699 break;
2700 case EF_FRV_CPU_FR550:
2701 strcat (buf, ", fr550");
2702 break;
2703
2704 case EF_FRV_CPU_SIMPLE:
2705 strcat (buf, ", simple");
2706 break;
2707 case EF_FRV_CPU_TOMCAT:
2708 strcat (buf, ", tomcat");
2709 break;
2710 }
1c877e87 2711 break;
ec2dfb42 2712
53c7db4b 2713 case EM_68K:
425c6cb0 2714 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2715 strcat (buf, ", m68000");
425c6cb0 2716 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2717 strcat (buf, ", cpu32");
2718 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2719 strcat (buf, ", fido_a");
425c6cb0 2720 else
266abb8f 2721 {
2cf0635d
NC		 2722 char const * isa = _("unknown");
2723 char const * mac = _("unknown mac");
2724 char const * additional = NULL;
0112cd26 2725
c694fd50 2726 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2727 {
c694fd50 2728 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2729 isa = "A";
2730 additional = ", nodiv";
2731 break;
c694fd50 2732 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2733 isa = "A";
2734 break;
c694fd50 2735 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2736 isa = "A+";
2737 break;
c694fd50 2738 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2739 isa = "B";
2740 additional = ", nousp";
2741 break;
c694fd50 2742 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2743 isa = "B";
2744 break;
f608cd77
NS		 2745 case EF_M68K_CF_ISA_C:
2746 isa = "C";
2747 break;
2748 case EF_M68K_CF_ISA_C_NODIV:
2749 isa = "C";
2750 additional = ", nodiv";
2751 break;
266abb8f
NS		 2752 }
2753 strcat (buf, ", cf, isa ");
2754 strcat (buf, isa);
0b2e31dc
NS		 2755 if (additional)
2756 strcat (buf, additional);
c694fd50 2757 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2758 strcat (buf, ", float");
c694fd50 2759 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2760 {
2761 case 0:
2762 mac = NULL;
2763 break;
c694fd50 2764 case EF_M68K_CF_MAC:
266abb8f
NS		 2765 mac = "mac";
2766 break;
c694fd50 2767 case EF_M68K_CF_EMAC:
266abb8f
NS		 2768 mac = "emac";
2769 break;
f608cd77
NS		 2770 case EF_M68K_CF_EMAC_B:
2771 mac = "emac_b";
2772 break;
266abb8f
NS		 2773 }
2774 if (mac)
2775 {
2776 strcat (buf, ", ");
2777 strcat (buf, mac);
2778 }
266abb8f 2779 }
53c7db4b 2780 break;
33c63f9d 2781
252b5132
RH		 2782 case EM_PPC:
2783 if (e_flags & EF_PPC_EMB)
2784 strcat (buf, ", emb");
2785
2786 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2787 strcat (buf, _(", relocatable"));
252b5132
RH		 2788
2789 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2790 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2791 break;
2792
ee67d69a
AM		 2793 case EM_PPC64:
2794 if (e_flags & EF_PPC64_ABI)
2795 {
2796 char abi[] = ", abiv0";
2797
2798 abi[6] += e_flags & EF_PPC64_ABI;
2799 strcat (buf, abi);
2800 }
2801 break;
2802
708e2187
NC		 2803 case EM_V800:
2804 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2805 strcat (buf, ", RH850 ABI");
0b4362b0 2806
708e2187
NC		 2807 if (e_flags & EF_V800_850E3)
2808 strcat (buf, ", V3 architecture");
2809
2810 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2811 strcat (buf, ", FPU not used");
2812
2813 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2814 strcat (buf, ", regmode: COMMON");
2815
2816 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2817 strcat (buf, ", r4 not used");
2818
2819 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2820 strcat (buf, ", r30 not used");
2821
2822 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2823 strcat (buf, ", r5 not used");
2824
2825 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2826 strcat (buf, ", r2 not used");
2827
2828 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2829 {
2830 switch (e_flags & - e_flags)
2831 {
2832 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2833 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2834 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2835 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2836 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2837 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2838 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2839 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2840 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2841 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2842 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2843 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2844 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2845 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2846 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2847 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2848 default: break;
2849 }
2850 }
2851 break;
2852
2b0337b0 2853 case EM_V850:
252b5132
RH		 2854 case EM_CYGNUS_V850:
2855 switch (e_flags & EF_V850_ARCH)
2856 {
78c8d46c
NC		 2857 case E_V850E3V5_ARCH:
2858 strcat (buf, ", v850e3v5");
2859 break;
1cd986c5
NC		 2860 case E_V850E2V3_ARCH:
2861 strcat (buf, ", v850e2v3");
2862 break;
2863 case E_V850E2_ARCH:
2864 strcat (buf, ", v850e2");
2865 break;
2866 case E_V850E1_ARCH:
2867 strcat (buf, ", v850e1");
8ad30312 2868 break;
252b5132
RH		 2869 case E_V850E_ARCH:
2870 strcat (buf, ", v850e");
2871 break;
252b5132
RH		 2872 case E_V850_ARCH:
2873 strcat (buf, ", v850");
2874 break;
2875 default:
2b692964 2876 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2877 break;
2878 }
2879 break;
2880
2b0337b0 2881 case EM_M32R:
252b5132
RH		 2882 case EM_CYGNUS_M32R:
2883 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2884 strcat (buf, ", m32r");
252b5132
RH		 2885 break;
2886
2887 case EM_MIPS:
4fe85591 2888 case EM_MIPS_RS3_LE:
252b5132
RH		 2889 if (e_flags & EF_MIPS_NOREORDER)
2890 strcat (buf, ", noreorder");
2891
2892 if (e_flags & EF_MIPS_PIC)
2893 strcat (buf, ", pic");
2894
2895 if (e_flags & EF_MIPS_CPIC)
2896 strcat (buf, ", cpic");
2897
d1bdd336
TS		 2898 if (e_flags & EF_MIPS_UCODE)
2899 strcat (buf, ", ugen_reserved");
2900
252b5132
RH		 2901 if (e_flags & EF_MIPS_ABI2)
2902 strcat (buf, ", abi2");
2903
43521d43
TS		 2904 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2905 strcat (buf, ", odk first");
2906
a5d22d2a
TS		 2907 if (e_flags & EF_MIPS_32BITMODE)
2908 strcat (buf, ", 32bitmode");
2909
ba92f887
MR		 2910 if (e_flags & EF_MIPS_NAN2008)
2911 strcat (buf, ", nan2008");
2912
fef1b0b3
SE		 2913 if (e_flags & EF_MIPS_FP64)
2914 strcat (buf, ", fp64");
2915
156c2f8b
NC		 2916 switch ((e_flags & EF_MIPS_MACH))
2917 {
2918 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2919 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2920 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2921 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2922 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2923 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2924 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2925 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2926 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2927 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2928 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2929 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2930 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2931 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2932 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 2933 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 2934 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2935 case 0:
2936 /* We simply ignore the field in this case to avoid confusion:
2937 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2938 extension. */
2939 break;
2b692964 2940 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2941 }
43521d43
TS		 2942
2943 switch ((e_flags & EF_MIPS_ABI))
2944 {
2945 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2946 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2947 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2948 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2949 case 0:
2950 /* We simply ignore the field in this case to avoid confusion:
2951 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2952 This means it is likely to be an o32 file, but not for
2953 sure. */
2954 break;
2b692964 2955 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2956 }
2957
2958 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2959 strcat (buf, ", mdmx");
2960
2961 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2962 strcat (buf, ", mips16");
2963
df58fc94
RS		 2964 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2965 strcat (buf, ", micromips");
2966
43521d43
TS		 2967 switch ((e_flags & EF_MIPS_ARCH))
2968 {
2969 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2970 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2971 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2972 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2973 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2974 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2975 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 2976 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 2977 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2978 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 2979 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 2980 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2981 }
252b5132 2982 break;
351b4b40 2983
35c08157
KLC		 2984 case EM_NDS32:
2985 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2986 break;
2987
ccde1100
AO		 2988 case EM_SH:
2989 switch ((e_flags & EF_SH_MACH_MASK))
2990 {
2991 case EF_SH1: strcat (buf, ", sh1"); break;
2992 case EF_SH2: strcat (buf, ", sh2"); break;
2993 case EF_SH3: strcat (buf, ", sh3"); break;
2994 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2995 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2996 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2997 case EF_SH3E: strcat (buf, ", sh3e"); break;
2998 case EF_SH4: strcat (buf, ", sh4"); break;
2999 case EF_SH5: strcat (buf, ", sh5"); break;
3000 case EF_SH2E: strcat (buf, ", sh2e"); break;
3001 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3002 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3003 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3004 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3005 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3006 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3007 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3008 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3009 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3010 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3011 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3012 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3013 }
3014
cec6a5b8
MR		 3015 if (e_flags & EF_SH_PIC)
3016 strcat (buf, ", pic");
3017
3018 if (e_flags & EF_SH_FDPIC)
3019 strcat (buf, ", fdpic");
ccde1100 3020 break;
73589c9d
CS		 3021
3022 case EM_OR1K:
3023 if (e_flags & EF_OR1K_NODELAY)
3024 strcat (buf, ", no delay");
3025 break;
57346661 3026
351b4b40
RH		 3027 case EM_SPARCV9:
3028 if (e_flags & EF_SPARC_32PLUS)
3029 strcat (buf, ", v8+");
3030
3031 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3032 strcat (buf, ", ultrasparcI");
3033
3034 if (e_flags & EF_SPARC_SUN_US3)
3035 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3036
3037 if (e_flags & EF_SPARC_HAL_R1)
3038 strcat (buf, ", halr1");
3039
3040 if (e_flags & EF_SPARC_LEDATA)
3041 strcat (buf, ", ledata");
3042
3043 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3044 strcat (buf, ", tso");
3045
3046 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3047 strcat (buf, ", pso");
3048
3049 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3050 strcat (buf, ", rmo");
3051 break;
7d466069 3052
103f02d3
UD		 3053 case EM_PARISC:
3054 switch (e_flags & EF_PARISC_ARCH)
3055 {
3056 case EFA_PARISC_1_0:
3057 strcpy (buf, ", PA-RISC 1.0");
3058 break;
3059 case EFA_PARISC_1_1:
3060 strcpy (buf, ", PA-RISC 1.1");
3061 break;
3062 case EFA_PARISC_2_0:
3063 strcpy (buf, ", PA-RISC 2.0");
3064 break;
3065 default:
3066 break;
3067 }
3068 if (e_flags & EF_PARISC_TRAPNIL)
3069 strcat (buf, ", trapnil");
3070 if (e_flags & EF_PARISC_EXT)
3071 strcat (buf, ", ext");
3072 if (e_flags & EF_PARISC_LSB)
3073 strcat (buf, ", lsb");
3074 if (e_flags & EF_PARISC_WIDE)
3075 strcat (buf, ", wide");
3076 if (e_flags & EF_PARISC_NO_KABP)
3077 strcat (buf, ", no kabp");
3078 if (e_flags & EF_PARISC_LAZYSWAP)
3079 strcat (buf, ", lazyswap");
30800947 3080 break;
76da6bbe 3081
7d466069 3082 case EM_PJ:
2b0337b0 3083 case EM_PJ_OLD:
7d466069
ILT		 3084 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3085 strcat (buf, ", new calling convention");
3086
3087 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3088 strcat (buf, ", gnu calling convention");
3089 break;
4d6ed7c8
NC		 3090
3091 case EM_IA_64:
3092 if ((e_flags & EF_IA_64_ABI64))
3093 strcat (buf, ", 64-bit");
3094 else
3095 strcat (buf, ", 32-bit");
3096 if ((e_flags & EF_IA_64_REDUCEDFP))
3097 strcat (buf, ", reduced fp model");
3098 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3099 strcat (buf, ", no function descriptors, constant gp");
3100 else if ((e_flags & EF_IA_64_CONS_GP))
3101 strcat (buf, ", constant gp");
3102 if ((e_flags & EF_IA_64_ABSOLUTE))
3103 strcat (buf, ", absolute");
28f997cf
TG		 3104 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3105 {
3106 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3107 strcat (buf, ", vms_linkages");
3108 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3109 {
3110 case EF_IA_64_VMS_COMCOD_SUCCESS:
3111 break;
3112 case EF_IA_64_VMS_COMCOD_WARNING:
3113 strcat (buf, ", warning");
3114 break;
3115 case EF_IA_64_VMS_COMCOD_ERROR:
3116 strcat (buf, ", error");
3117 break;
3118 case EF_IA_64_VMS_COMCOD_ABORT:
3119 strcat (buf, ", abort");
3120 break;
3121 default:
3122 abort ();
3123 }
3124 }
4d6ed7c8 3125 break;
179d3252
JT		 3126
3127 case EM_VAX:
3128 if ((e_flags & EF_VAX_NONPIC))
3129 strcat (buf, ", non-PIC");
3130 if ((e_flags & EF_VAX_DFLOAT))
3131 strcat (buf, ", D-Float");
3132 if ((e_flags & EF_VAX_GFLOAT))
3133 strcat (buf, ", G-Float");
3134 break;
c7927a3c 3135
4046d87a
NC		 3136 case EM_RL78:
3137 if (e_flags & E_FLAG_RL78_G10)
3138 strcat (buf, ", G10");
856ea05c
KP		 3139 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3140 strcat (buf, ", 64-bit doubles");
4046d87a 3141 break;
0b4362b0 3142
c7927a3c
NC		 3143 case EM_RX:
3144 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3145 strcat (buf, ", 64-bit doubles");
3146 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3147 strcat (buf, ", dsp");
d4cb0ea0 3148 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3149 strcat (buf, ", pid");
708e2187
NC		 3150 if (e_flags & E_FLAG_RX_ABI)
3151 strcat (buf, ", RX ABI");
d4cb0ea0 3152 break;
55786da2
AK		 3153
3154 case EM_S390:
3155 if (e_flags & EF_S390_HIGH_GPRS)
3156 strcat (buf, ", highgprs");
d4cb0ea0 3157 break;
40b36596
JM		 3158
3159 case EM_TI_C6000:
3160 if ((e_flags & EF_C6000_REL))
3161 strcat (buf, ", relocatable module");
d4cb0ea0 3162 break;
13761a11
NC		 3163
3164 case EM_MSP430:
3165 strcat (buf, _(": architecture variant: "));
3166 switch (e_flags & EF_MSP430_MACH)
3167 {
3168 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3169 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3170 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3171 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3172 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3173 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3174 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3175 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3176 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3177 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3178 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3179 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3180 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3181 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3182 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3183 default:
3184 strcat (buf, _(": unknown")); break;
3185 }
3186
3187 if (e_flags & ~ EF_MSP430_MACH)
3188 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3189 }
3190 }
3191
3192 return buf;
3193}
3194
252b5132 3195static const char *
d3ba0551
AM		 3196get_osabi_name (unsigned int osabi)
3197{
3198 static char buff[32];
3199
3200 switch (osabi)
3201 {
3202 case ELFOSABI_NONE: return "UNIX - System V";
3203 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3204 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3205 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3206 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3207 case ELFOSABI_AIX: return "UNIX - AIX";
3208 case ELFOSABI_IRIX: return "UNIX - IRIX";
3209 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3210 case ELFOSABI_TRU64: return "UNIX - TRU64";
3211 case ELFOSABI_MODESTO: return "Novell - Modesto";
3212 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3213 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3214 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3215 case ELFOSABI_AROS: return "AROS";
11636f9e 3216 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3217 default:
40b36596
JM		 3218 if (osabi >= 64)
3219 switch (elf_header.e_machine)
3220 {
3221 case EM_ARM:
3222 switch (osabi)
3223 {
3224 case ELFOSABI_ARM: return "ARM";
3225 default:
3226 break;
3227 }
3228 break;
3229
3230 case EM_MSP430:
3231 case EM_MSP430_OLD:
3232 switch (osabi)
3233 {
3234 case ELFOSABI_STANDALONE: return _("Standalone App");
3235 default:
3236 break;
3237 }
3238 break;
3239
3240 case EM_TI_C6000:
3241 switch (osabi)
3242 {
3243 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3244 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3245 default:
3246 break;
3247 }
3248 break;
3249
3250 default:
3251 break;
3252 }
e9e44622 3253 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3254 return buff;
3255 }
3256}
3257
a06ea964
NC		 3258static const char *
3259get_aarch64_segment_type (unsigned long type)
3260{
3261 switch (type)
3262 {
3263 case PT_AARCH64_ARCHEXT:
3264 return "AARCH64_ARCHEXT";
3265 default:
3266 break;
3267 }
3268
3269 return NULL;
3270}
3271
b294bdf8
MM		 3272static const char *
3273get_arm_segment_type (unsigned long type)
3274{
3275 switch (type)
3276 {
3277 case PT_ARM_EXIDX:
3278 return "EXIDX";
3279 default:
3280 break;
3281 }
3282
3283 return NULL;
3284}
3285
d3ba0551
AM		 3286static const char *
3287get_mips_segment_type (unsigned long type)
252b5132
RH		 3288{
3289 switch (type)
3290 {
3291 case PT_MIPS_REGINFO:
3292 return "REGINFO";
3293 case PT_MIPS_RTPROC:
3294 return "RTPROC";
3295 case PT_MIPS_OPTIONS:
3296 return "OPTIONS";
351cdf24
MF		 3297 case PT_MIPS_ABIFLAGS:
3298 return "ABIFLAGS";
252b5132
RH		 3299 default:
3300 break;
3301 }
3302
3303 return NULL;
3304}
3305
103f02d3 3306static const char *
d3ba0551 3307get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3308{
3309 switch (type)
3310 {
3311 case PT_HP_TLS: return "HP_TLS";
3312 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3313 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3314 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3315 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3316 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3317 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3318 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3319 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3320 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3321 case PT_HP_PARALLEL: return "HP_PARALLEL";
3322 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3323 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3324 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3325 case PT_HP_STACK: return "HP_STACK";
3326 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3327 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3328 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3329 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3330 default:
3331 break;
3332 }
3333
3334 return NULL;
3335}
3336
4d6ed7c8 3337static const char *
d3ba0551 3338get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3339{
3340 switch (type)
3341 {
3342 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3343 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3344 case PT_HP_TLS: return "HP_TLS";
3345 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3346 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3347 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3348 default:
3349 break;
3350 }
3351
3352 return NULL;
3353}
3354
40b36596
JM		 3355static const char *
3356get_tic6x_segment_type (unsigned long type)
3357{
3358 switch (type)
3359 {
3360 case PT_C6000_PHATTR: return "C6000_PHATTR";
3361 default:
3362 break;
3363 }
3364
3365 return NULL;
3366}
3367
252b5132 3368static const char *
d3ba0551 3369get_segment_type (unsigned long p_type)
252b5132 3370{
b34976b6 3371 static char buff[32];
252b5132
RH		 3372
3373 switch (p_type)
3374 {
b34976b6
AM		 3375 case PT_NULL: return "NULL";
3376 case PT_LOAD: return "LOAD";
252b5132 3377 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3378 case PT_INTERP: return "INTERP";
3379 case PT_NOTE: return "NOTE";
3380 case PT_SHLIB: return "SHLIB";
3381 case PT_PHDR: return "PHDR";
13ae64f3 3382 case PT_TLS: return "TLS";
252b5132 3383
65765700
JJ		 3384 case PT_GNU_EH_FRAME:
3385 return "GNU_EH_FRAME";
2b05f1b7 3386 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3387 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3388
252b5132
RH		 3389 default:
3390 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3391 {
2cf0635d 3392 const char * result;
103f02d3 3393
252b5132
RH		 3394 switch (elf_header.e_machine)
3395 {
a06ea964
NC		 3396 case EM_AARCH64:
3397 result = get_aarch64_segment_type (p_type);
3398 break;
b294bdf8
MM		 3399 case EM_ARM:
3400 result = get_arm_segment_type (p_type);
3401 break;
252b5132 3402 case EM_MIPS:
4fe85591 3403 case EM_MIPS_RS3_LE:
252b5132
RH		 3404 result = get_mips_segment_type (p_type);
3405 break;
103f02d3
UD		 3406 case EM_PARISC:
3407 result = get_parisc_segment_type (p_type);
3408 break;
4d6ed7c8
NC		 3409 case EM_IA_64:
3410 result = get_ia64_segment_type (p_type);
3411 break;
40b36596
JM		 3412 case EM_TI_C6000:
3413 result = get_tic6x_segment_type (p_type);
3414 break;
252b5132
RH		 3415 default:
3416 result = NULL;
3417 break;
3418 }
103f02d3 3419
252b5132
RH		 3420 if (result != NULL)
3421 return result;
103f02d3 3422
252b5132
RH		 3423 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3424 }
3425 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3426 {
2cf0635d 3427 const char * result;
103f02d3
UD		 3428
3429 switch (elf_header.e_machine)
3430 {
3431 case EM_PARISC:
3432 result = get_parisc_segment_type (p_type);
3433 break;
00428cca
AM		 3434 case EM_IA_64:
3435 result = get_ia64_segment_type (p_type);
3436 break;
103f02d3
UD		 3437 default:
3438 result = NULL;
3439 break;
3440 }
3441
3442 if (result != NULL)
3443 return result;
3444
3445 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3446 }
252b5132 3447 else
e9e44622 3448 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3449
3450 return buff;
3451 }
3452}
3453
3454static const char *
d3ba0551 3455get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3456{
3457 switch (sh_type)
3458 {
b34976b6
AM		 3459 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3460 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3461 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3462 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3463 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3464 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3465 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3466 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3467 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3468 case SHT_MIPS_RELD: return "MIPS_RELD";
3469 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3470 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3471 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3472 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3473 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3474 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3475 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3476 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3477 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3478 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3479 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3480 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3481 case SHT_MIPS_LINE: return "MIPS_LINE";
3482 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3483 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3484 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3485 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3486 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3487 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3488 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3489 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3490 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3491 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3492 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3493 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3494 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3495 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3496 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3497 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3498 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3499 default:
3500 break;
3501 }
3502 return NULL;
3503}
3504
103f02d3 3505static const char *
d3ba0551 3506get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3507{
3508 switch (sh_type)
3509 {
3510 case SHT_PARISC_EXT: return "PARISC_EXT";
3511 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3512 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3513 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3514 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3515 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3516 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3517 default:
3518 break;
3519 }
3520 return NULL;
3521}
3522
4d6ed7c8 3523static const char *
d3ba0551 3524get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3525{
18bd398b 3526 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3527 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3528 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3529
4d6ed7c8
NC		 3530 switch (sh_type)
3531 {
148b93f2
NC		 3532 case SHT_IA_64_EXT: return "IA_64_EXT";
3533 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3534 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3535 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3536 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3537 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3538 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3539 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3540 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3541 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3542 default:
3543 break;
3544 }
3545 return NULL;
3546}
3547
d2b2c203
DJ		 3548static const char *
3549get_x86_64_section_type_name (unsigned int sh_type)
3550{
3551 switch (sh_type)
3552 {
3553 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3554 default:
3555 break;
3556 }
3557 return NULL;
3558}
3559
a06ea964
NC		 3560static const char *
3561get_aarch64_section_type_name (unsigned int sh_type)
3562{
3563 switch (sh_type)
3564 {
3565 case SHT_AARCH64_ATTRIBUTES:
3566 return "AARCH64_ATTRIBUTES";
3567 default:
3568 break;
3569 }
3570 return NULL;
3571}
3572
40a18ebd
NC		 3573static const char *
3574get_arm_section_type_name (unsigned int sh_type)
3575{
3576 switch (sh_type)
3577 {
7f6fed87
NC		 3578 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3579 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3580 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3581 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3582 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3583 default:
3584 break;
3585 }
3586 return NULL;
3587}
3588
40b36596
JM		 3589static const char *
3590get_tic6x_section_type_name (unsigned int sh_type)
3591{
3592 switch (sh_type)
3593 {
3594 case SHT_C6000_UNWIND:
3595 return "C6000_UNWIND";
3596 case SHT_C6000_PREEMPTMAP:
3597 return "C6000_PREEMPTMAP";
3598 case SHT_C6000_ATTRIBUTES:
3599 return "C6000_ATTRIBUTES";
3600 case SHT_TI_ICODE:
3601 return "TI_ICODE";
3602 case SHT_TI_XREF:
3603 return "TI_XREF";
3604 case SHT_TI_HANDLER:
3605 return "TI_HANDLER";
3606 case SHT_TI_INITINFO:
3607 return "TI_INITINFO";
3608 case SHT_TI_PHATTRS:
3609 return "TI_PHATTRS";
3610 default:
3611 break;
3612 }
3613 return NULL;
3614}
3615
13761a11
NC		 3616static const char *
3617get_msp430x_section_type_name (unsigned int sh_type)
3618{
3619 switch (sh_type)
3620 {
3621 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3622 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3623 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3624 default: return NULL;
3625 }
3626}
3627
252b5132 3628static const char *
d3ba0551 3629get_section_type_name (unsigned int sh_type)
252b5132 3630{
b34976b6 3631 static char buff[32];
252b5132
RH		 3632
3633 switch (sh_type)
3634 {
3635 case SHT_NULL: return "NULL";
3636 case SHT_PROGBITS: return "PROGBITS";
3637 case SHT_SYMTAB: return "SYMTAB";
3638 case SHT_STRTAB: return "STRTAB";
3639 case SHT_RELA: return "RELA";
3640 case SHT_HASH: return "HASH";
3641 case SHT_DYNAMIC: return "DYNAMIC";
3642 case SHT_NOTE: return "NOTE";
3643 case SHT_NOBITS: return "NOBITS";
3644 case SHT_REL: return "REL";
3645 case SHT_SHLIB: return "SHLIB";
3646 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3647 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3648 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3649 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3650 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3651 case SHT_GROUP: return "GROUP";
3652 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3653 case SHT_GNU_verdef: return "VERDEF";
3654 case SHT_GNU_verneed: return "VERNEED";
3655 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3656 case 0x6ffffff0: return "VERSYM";
3657 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3658 case 0x7ffffffd: return "AUXILIARY";
3659 case 0x7fffffff: return "FILTER";
047b2264 3660 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3661
3662 default:
3663 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3664 {
2cf0635d 3665 const char * result;
252b5132
RH		 3666
3667 switch (elf_header.e_machine)
3668 {
3669 case EM_MIPS:
4fe85591 3670 case EM_MIPS_RS3_LE:
252b5132
RH		 3671 result = get_mips_section_type_name (sh_type);
3672 break;
103f02d3
UD		 3673 case EM_PARISC:
3674 result = get_parisc_section_type_name (sh_type);
3675 break;
4d6ed7c8
NC		 3676 case EM_IA_64:
3677 result = get_ia64_section_type_name (sh_type);
3678 break;
d2b2c203 3679 case EM_X86_64:
8a9036a4 3680 case EM_L1OM:
7a9068fe 3681 case EM_K1OM:
d2b2c203
DJ		 3682 result = get_x86_64_section_type_name (sh_type);
3683 break;
a06ea964
NC		 3684 case EM_AARCH64:
3685 result = get_aarch64_section_type_name (sh_type);
3686 break;
40a18ebd
NC		 3687 case EM_ARM:
3688 result = get_arm_section_type_name (sh_type);
3689 break;
40b36596
JM		 3690 case EM_TI_C6000:
3691 result = get_tic6x_section_type_name (sh_type);
3692 break;
13761a11
NC		 3693 case EM_MSP430:
3694 result = get_msp430x_section_type_name (sh_type);
3695 break;
252b5132
RH		 3696 default:
3697 result = NULL;
3698 break;
3699 }
3700
3701 if (result != NULL)
3702 return result;
3703
c91d0dfb 3704 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3705 }
3706 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3707 {
2cf0635d 3708 const char * result;
148b93f2
NC		 3709
3710 switch (elf_header.e_machine)
3711 {
3712 case EM_IA_64:
3713 result = get_ia64_section_type_name (sh_type);
3714 break;
3715 default:
3716 result = NULL;
3717 break;
3718 }
3719
3720 if (result != NULL)
3721 return result;
3722
3723 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3724 }
252b5132 3725 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3726 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3727 else
a7dbfd1c
NC		 3728 /* This message is probably going to be displayed in a 15
3729 character wide field, so put the hex value first. */
3730 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3731
252b5132
RH		 3732 return buff;
3733 }
3734}
3735
2979dc34 3736#define OPTION_DEBUG_DUMP 512
2c610e4b 3737#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3738#define OPTION_DWARF_DEPTH 514
3739#define OPTION_DWARF_START 515
4723351a 3740#define OPTION_DWARF_CHECK 516
2979dc34 3741
85b1c36d 3742static struct option options[] =
252b5132 3743{
b34976b6 3744 {"all", no_argument, 0, 'a'},
252b5132
RH		 3745 {"file-header", no_argument, 0, 'h'},
3746 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3747 {"headers", no_argument, 0, 'e'},
3748 {"histogram", no_argument, 0, 'I'},
3749 {"segments", no_argument, 0, 'l'},
3750 {"sections", no_argument, 0, 'S'},
252b5132 3751 {"section-headers", no_argument, 0, 'S'},
f5842774 3752 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3753 {"section-details", no_argument, 0, 't'},
595cf52e 3754 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3755 {"symbols", no_argument, 0, 's'},
3756 {"syms", no_argument, 0, 's'},
2c610e4b 3757 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3758 {"relocs", no_argument, 0, 'r'},
3759 {"notes", no_argument, 0, 'n'},
3760 {"dynamic", no_argument, 0, 'd'},
a952a375 3761 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3762 {"version-info", no_argument, 0, 'V'},
3763 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3764 {"unwind", no_argument, 0, 'u'},
4145f1d5 3765 {"archive-index", no_argument, 0, 'c'},
b34976b6 3766 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3767 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3768 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3769#ifdef SUPPORT_DISASSEMBLY
3770 {"instruction-dump", required_argument, 0, 'i'},
3771#endif
cf13d699 3772 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3773
fd2f0033
TT		 3774 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3775 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3776 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3777
b34976b6
AM		 3778 {"version", no_argument, 0, 'v'},
3779 {"wide", no_argument, 0, 'W'},
3780 {"help", no_argument, 0, 'H'},
3781 {0, no_argument, 0, 0}
252b5132
RH		 3782};
3783
3784static void
2cf0635d 3785usage (FILE * stream)
252b5132 3786{
92f01d61
JM		 3787 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3788 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3789 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3790 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3791 -h --file-header Display the ELF file header\n\
3792 -l --program-headers Display the program headers\n\
3793 --segments An alias for --program-headers\n\
3794 -S --section-headers Display the sections' header\n\
3795 --sections An alias for --section-headers\n\
f5842774 3796 -g --section-groups Display the section groups\n\
5477e8a0 3797 -t --section-details Display the section details\n\
8b53311e
NC		 3798 -e --headers Equivalent to: -h -l -S\n\
3799 -s --syms Display the symbol table\n\
3f08eb35 3800 --symbols An alias for --syms\n\
2c610e4b 3801 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3802 -n --notes Display the core notes (if present)\n\
3803 -r --relocs Display the relocations (if present)\n\
3804 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3805 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3806 -V --version-info Display the version sections (if present)\n\
1b31d05e 3807 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3808 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3809 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3810 -x --hex-dump=<number|name>\n\
3811 Dump the contents of section <number|name> as bytes\n\
3812 -p --string-dump=<number|name>\n\
3813 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3814 -R --relocated-dump=<number|name>\n\
3815 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3816 -w[lLiaprmfFsoRt] or\n\
1ed06042 3817 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3818 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3819 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3820 =addr,=cu_index]\n\
8b53311e 3821 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3822 fprintf (stream, _("\
3823 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3824 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3825 or deeper\n"));
252b5132 3826#ifdef SUPPORT_DISASSEMBLY
92f01d61 3827 fprintf (stream, _("\
09c11c86
NC		 3828 -i --instruction-dump=<number|name>\n\
3829 Disassemble the contents of section <number|name>\n"));
252b5132 3830#endif
92f01d61 3831 fprintf (stream, _("\
8b53311e
NC		 3832 -I --histogram Display histogram of bucket list lengths\n\
3833 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3834 @<file> Read options from <file>\n\
8b53311e
NC		 3835 -H --help Display this information\n\
3836 -v --version Display the version number of readelf\n"));
1118d252 3837
92f01d61
JM		 3838 if (REPORT_BUGS_TO[0] && stream == stdout)
3839 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3840
92f01d61 3841 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3842}
3843
18bd398b
NC		 3844/* Record the fact that the user wants the contents of section number
3845 SECTION to be displayed using the method(s) encoded as flags bits
3846 in TYPE. Note, TYPE can be zero if we are creating the array for
3847 the first time. */
3848
252b5132 3849static void
09c11c86 3850request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3851{
3852 if (section >= num_dump_sects)
3853 {
2cf0635d 3854 dump_type * new_dump_sects;
252b5132 3855
3f5e193b
NC		 3856 new_dump_sects = (dump_type *) calloc (section + 1,
3857 sizeof (* dump_sects));
252b5132
RH		 3858
3859 if (new_dump_sects == NULL)
591a748a 3860 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3861 else
3862 {
3863 /* Copy current flag settings. */
09c11c86 3864 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3865
3866 free (dump_sects);
3867
3868 dump_sects = new_dump_sects;
3869 num_dump_sects = section + 1;
3870 }
3871 }
3872
3873 if (dump_sects)
b34976b6 3874 dump_sects[section] |= type;
252b5132
RH		 3875
3876 return;
3877}
3878
aef1f6d0
DJ		 3879/* Request a dump by section name. */
3880
3881static void
2cf0635d 3882request_dump_byname (const char * section, dump_type type)
aef1f6d0 3883{
2cf0635d 3884 struct dump_list_entry * new_request;
aef1f6d0 3885
3f5e193b
NC		 3886 new_request = (struct dump_list_entry *)
3887 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3888 if (!new_request)
591a748a 3889 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3890
3891 new_request->name = strdup (section);
3892 if (!new_request->name)
591a748a 3893 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3894
3895 new_request->type = type;
3896
3897 new_request->next = dump_sects_byname;
3898 dump_sects_byname = new_request;
3899}
3900
cf13d699
NC		 3901static inline void
3902request_dump (dump_type type)
3903{
3904 int section;
3905 char * cp;
3906
3907 do_dump++;
3908 section = strtoul (optarg, & cp, 0);
3909
3910 if (! *cp && section >= 0)
3911 request_dump_bynumber (section, type);
3912 else
3913 request_dump_byname (optarg, type);
3914}
3915
3916
252b5132 3917static void
2cf0635d 3918parse_args (int argc, char ** argv)
252b5132
RH		 3919{
3920 int c;
3921
3922 if (argc < 2)
92f01d61 3923 usage (stderr);
252b5132
RH		 3924
3925 while ((c = getopt_long
cf13d699 3926 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3927 {
252b5132
RH		 3928 switch (c)
3929 {
3930 case 0:
3931 /* Long options. */
3932 break;
3933 case 'H':
92f01d61 3934 usage (stdout);
252b5132
RH		 3935 break;
3936
3937 case 'a':
b34976b6
AM		 3938 do_syms++;
3939 do_reloc++;
3940 do_unwind++;
3941 do_dynamic++;
3942 do_header++;
3943 do_sections++;
f5842774 3944 do_section_groups++;
b34976b6
AM		 3945 do_segments++;
3946 do_version++;
3947 do_histogram++;
3948 do_arch++;
3949 do_notes++;
252b5132 3950 break;
f5842774
L		 3951 case 'g':
3952 do_section_groups++;
3953 break;
5477e8a0 3954 case 't':
595cf52e 3955 case 'N':
5477e8a0
L		 3956 do_sections++;
3957 do_section_details++;
595cf52e 3958 break;
252b5132 3959 case 'e':
b34976b6
AM		 3960 do_header++;
3961 do_sections++;
3962 do_segments++;
252b5132 3963 break;
a952a375 3964 case 'A':
b34976b6 3965 do_arch++;
a952a375 3966 break;
252b5132 3967 case 'D':
b34976b6 3968 do_using_dynamic++;
252b5132
RH		 3969 break;
3970 case 'r':
b34976b6 3971 do_reloc++;
252b5132 3972 break;
4d6ed7c8 3973 case 'u':
b34976b6 3974 do_unwind++;
4d6ed7c8 3975 break;
252b5132 3976 case 'h':
b34976b6 3977 do_header++;
252b5132
RH		 3978 break;
3979 case 'l':
b34976b6 3980 do_segments++;
252b5132
RH		 3981 break;
3982 case 's':
b34976b6 3983 do_syms++;
252b5132
RH		 3984 break;
3985 case 'S':
b34976b6 3986 do_sections++;
252b5132
RH		 3987 break;
3988 case 'd':
b34976b6 3989 do_dynamic++;
252b5132 3990 break;
a952a375 3991 case 'I':
b34976b6 3992 do_histogram++;
a952a375 3993 break;
779fe533 3994 case 'n':
b34976b6 3995 do_notes++;
779fe533 3996 break;
4145f1d5
NC		 3997 case 'c':
3998 do_archive_index++;
3999 break;
252b5132 4000 case 'x':
cf13d699 4001 request_dump (HEX_DUMP);
aef1f6d0 4002 break;
09c11c86 4003 case 'p':
cf13d699
NC		 4004 request_dump (STRING_DUMP);
4005 break;
4006 case 'R':
4007 request_dump (RELOC_DUMP);
09c11c86 4008 break;
252b5132 4009 case 'w':
b34976b6 4010 do_dump++;
252b5132 4011 if (optarg == 0)
613ff48b
CC		 4012 {
4013 do_debugging = 1;
4014 dwarf_select_sections_all ();
4015 }
252b5132
RH		 4016 else
4017 {
4018 do_debugging = 0;
4cb93e3b 4019 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4020 }
4021 break;
2979dc34 4022 case OPTION_DEBUG_DUMP:
b34976b6 4023 do_dump++;
2979dc34
JJ		 4024 if (optarg == 0)
4025 do_debugging = 1;
4026 else
4027 {
2979dc34 4028 do_debugging = 0;
4cb93e3b 4029 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4030 }
4031 break;
fd2f0033
TT		 4032 case OPTION_DWARF_DEPTH:
4033 {
4034 char *cp;
4035
4036 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4037 }
4038 break;
4039 case OPTION_DWARF_START:
4040 {
4041 char *cp;
4042
4043 dwarf_start_die = strtoul (optarg, & cp, 0);
4044 }
4045 break;
4723351a
CC		 4046 case OPTION_DWARF_CHECK:
4047 dwarf_check = 1;
4048 break;
2c610e4b
L		 4049 case OPTION_DYN_SYMS:
4050 do_dyn_syms++;
4051 break;
252b5132
RH		 4052#ifdef SUPPORT_DISASSEMBLY
4053 case 'i':
cf13d699
NC		 4054 request_dump (DISASS_DUMP);
4055 break;
252b5132
RH		 4056#endif
4057 case 'v':
4058 print_version (program_name);
4059 break;
4060 case 'V':
b34976b6 4061 do_version++;
252b5132 4062 break;
d974e256 4063 case 'W':
b34976b6 4064 do_wide++;
d974e256 4065 break;
252b5132 4066 default:
252b5132
RH		 4067 /* xgettext:c-format */
4068 error (_("Invalid option '-%c'\n"), c);
4069 /* Drop through. */
4070 case '?':
92f01d61 4071 usage (stderr);
252b5132
RH		 4072 }
4073 }
4074
4d6ed7c8 4075 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4076 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4077 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4078 && !do_section_groups && !do_archive_index
4079 && !do_dyn_syms)
92f01d61 4080 usage (stderr);
252b5132
RH		 4081 else if (argc < 3)
4082 {
4083 warn (_("Nothing to do.\n"));
92f01d61 4084 usage (stderr);
252b5132
RH		 4085 }
4086}
4087
4088static const char *
d3ba0551 4089get_elf_class (unsigned int elf_class)
252b5132 4090{
b34976b6 4091 static char buff[32];
103f02d3 4092
252b5132
RH		 4093 switch (elf_class)
4094 {
4095 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4096 case ELFCLASS32: return "ELF32";
4097 case ELFCLASS64: return "ELF64";
ab5e7794 4098 default:
e9e44622 4099 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4100 return buff;
252b5132
RH		 4101 }
4102}
4103
4104static const char *
d3ba0551 4105get_data_encoding (unsigned int encoding)
252b5132 4106{
b34976b6 4107 static char buff[32];
103f02d3 4108
252b5132
RH		 4109 switch (encoding)
4110 {
4111 case ELFDATANONE: return _("none");
33c63f9d
CM		 4112 case ELFDATA2LSB: return _("2's complement, little endian");
4113 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4114 default:
e9e44622 4115 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4116 return buff;
252b5132
RH		 4117 }
4118}
4119
252b5132 4120/* Decode the data held in 'elf_header'. */
ee42cf8c 4121
252b5132 4122static int
d3ba0551 4123process_file_header (void)
252b5132 4124{
b34976b6
AM		 4125 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4126 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4127 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4128 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4129 {
4130 error
4131 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4132 return 0;
4133 }
4134
2dc4cec1
L		 4135 init_dwarf_regnames (elf_header.e_machine);
4136
252b5132
RH		 4137 if (do_header)
4138 {
4139 int i;
4140
4141 printf (_("ELF Header:\n"));
4142 printf (_(" Magic: "));
b34976b6
AM		 4143 for (i = 0; i < EI_NIDENT; i++)
4144 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4145 printf ("\n");
4146 printf (_(" Class: %s\n"),
b34976b6 4147 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4148 printf (_(" Data: %s\n"),
b34976b6 4149 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4150 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4151 elf_header.e_ident[EI_VERSION],
4152 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4153 ? "(current)"
b34976b6 4154 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4155 ? _("<unknown: %lx>")
789be9f7 4156 : "")));
252b5132 4157 printf (_(" OS/ABI: %s\n"),
b34976b6 4158 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4159 printf (_(" ABI Version: %d\n"),
b34976b6 4160 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4161 printf (_(" Type: %s\n"),
4162 get_file_type (elf_header.e_type));
4163 printf (_(" Machine: %s\n"),
4164 get_machine_name (elf_header.e_machine));
4165 printf (_(" Version: 0x%lx\n"),
4166 (unsigned long) elf_header.e_version);
76da6bbe 4167
f7a99963
NC		 4168 printf (_(" Entry point address: "));
4169 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4170 printf (_("\n Start of program headers: "));
4171 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4172 printf (_(" (bytes into file)\n Start of section headers: "));
4173 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4174 printf (_(" (bytes into file)\n"));
76da6bbe 4175
252b5132
RH		 4176 printf (_(" Flags: 0x%lx%s\n"),
4177 (unsigned long) elf_header.e_flags,
4178 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4179 printf (_(" Size of this header: %ld (bytes)\n"),
4180 (long) elf_header.e_ehsize);
4181 printf (_(" Size of program headers: %ld (bytes)\n"),
4182 (long) elf_header.e_phentsize);
2046a35d 4183 printf (_(" Number of program headers: %ld"),
252b5132 4184 (long) elf_header.e_phnum);
2046a35d
AM		 4185 if (section_headers != NULL
4186 && elf_header.e_phnum == PN_XNUM
4187 && section_headers[0].sh_info != 0)
cc5914eb 4188 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4189 putc ('\n', stdout);
252b5132
RH		 4190 printf (_(" Size of section headers: %ld (bytes)\n"),
4191 (long) elf_header.e_shentsize);
560f3c1c 4192 printf (_(" Number of section headers: %ld"),
252b5132 4193 (long) elf_header.e_shnum);
4fbb74a6 4194 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4195 printf (" (%ld)", (long) section_headers[0].sh_size);
4196 putc ('\n', stdout);
4197 printf (_(" Section header string table index: %ld"),
252b5132 4198 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4199 if (section_headers != NULL
4200 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4201 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4202 else if (elf_header.e_shstrndx != SHN_UNDEF
4203 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4204 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4205 putc ('\n', stdout);
4206 }
4207
4208 if (section_headers != NULL)
4209 {
2046a35d
AM		 4210 if (elf_header.e_phnum == PN_XNUM
4211 && section_headers[0].sh_info != 0)
4212 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4213 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4214 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4215 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4216 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4217 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4218 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4219 free (section_headers);
4220 section_headers = NULL;
252b5132 4221 }
103f02d3 4222
9ea033b2
NC		 4223 return 1;
4224}
4225
e0a31db1 4226static bfd_boolean
91d6fa6a 4227get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4228{
2cf0635d
NC		 4229 Elf32_External_Phdr * phdrs;
4230 Elf32_External_Phdr * external;
4231 Elf_Internal_Phdr * internal;
b34976b6 4232 unsigned int i;
e0a31db1
NC		 4233 unsigned int size = elf_header.e_phentsize;
4234 unsigned int num = elf_header.e_phnum;
4235
4236 /* PR binutils/17531: Cope with unexpected section header sizes. */
4237 if (size == 0 || num == 0)
4238 return FALSE;
4239 if (size < sizeof * phdrs)
4240 {
4241 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4242 return FALSE;
4243 }
4244 if (size > sizeof * phdrs)
4245 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4246
3f5e193b 4247 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4248 size, num, _("program headers"));
4249 if (phdrs == NULL)
4250 return FALSE;
9ea033b2 4251
91d6fa6a 4252 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4253 i < elf_header.e_phnum;
b34976b6 4254 i++, internal++, external++)
252b5132 4255 {
9ea033b2
NC		 4256 internal->p_type = BYTE_GET (external->p_type);
4257 internal->p_offset = BYTE_GET (external->p_offset);
4258 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4259 internal->p_paddr = BYTE_GET (external->p_paddr);
4260 internal->p_filesz = BYTE_GET (external->p_filesz);
4261 internal->p_memsz = BYTE_GET (external->p_memsz);
4262 internal->p_flags = BYTE_GET (external->p_flags);
4263 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4264 }
4265
9ea033b2 4266 free (phdrs);
e0a31db1 4267 return TRUE;
252b5132
RH		 4268}
4269
e0a31db1 4270static bfd_boolean
91d6fa6a 4271get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4272{
2cf0635d
NC		 4273 Elf64_External_Phdr * phdrs;
4274 Elf64_External_Phdr * external;
4275 Elf_Internal_Phdr * internal;
b34976b6 4276 unsigned int i;
e0a31db1
NC		 4277 unsigned int size = elf_header.e_phentsize;
4278 unsigned int num = elf_header.e_phnum;
4279
4280 /* PR binutils/17531: Cope with unexpected section header sizes. */
4281 if (size == 0 || num == 0)
4282 return FALSE;
4283 if (size < sizeof * phdrs)
4284 {
4285 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4286 return FALSE;
4287 }
4288 if (size > sizeof * phdrs)
4289 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4290
3f5e193b 4291 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4292 size, num, _("program headers"));
a6e9f9df 4293 if (!phdrs)
e0a31db1 4294 return FALSE;
9ea033b2 4295
91d6fa6a 4296 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4297 i < elf_header.e_phnum;
b34976b6 4298 i++, internal++, external++)
9ea033b2
NC		 4299 {
4300 internal->p_type = BYTE_GET (external->p_type);
4301 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4302 internal->p_offset = BYTE_GET (external->p_offset);
4303 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4304 internal->p_paddr = BYTE_GET (external->p_paddr);
4305 internal->p_filesz = BYTE_GET (external->p_filesz);
4306 internal->p_memsz = BYTE_GET (external->p_memsz);
4307 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4308 }
4309
4310 free (phdrs);
e0a31db1 4311 return TRUE;
9ea033b2 4312}
252b5132 4313
d93f0186
NC		 4314/* Returns 1 if the program headers were read into `program_headers'. */
4315
4316static int
2cf0635d 4317get_program_headers (FILE * file)
d93f0186 4318{
2cf0635d 4319 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4320
4321 /* Check cache of prior read. */
4322 if (program_headers != NULL)
4323 return 1;
4324
3f5e193b
NC		 4325 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4326 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4327
4328 if (phdrs == NULL)
4329 {
8b73c356
NC		 4330 error (_("Out of memory reading %u program headers\n"),
4331 elf_header.e_phnum);
d93f0186
NC		 4332 return 0;
4333 }
4334
4335 if (is_32bit_elf
4336 ? get_32bit_program_headers (file, phdrs)
4337 : get_64bit_program_headers (file, phdrs))
4338 {
4339 program_headers = phdrs;
4340 return 1;
4341 }
4342
4343 free (phdrs);
4344 return 0;
4345}
4346
2f62977e
NC		 4347/* Returns 1 if the program headers were loaded. */
4348
252b5132 4349static int
2cf0635d 4350process_program_headers (FILE * file)
252b5132 4351{
2cf0635d 4352 Elf_Internal_Phdr * segment;
b34976b6 4353 unsigned int i;
252b5132
RH		 4354
4355 if (elf_header.e_phnum == 0)
4356 {
82f2dbf7
NC		 4357 /* PR binutils/12467. */
4358 if (elf_header.e_phoff != 0)
4359 warn (_("possibly corrupt ELF header - it has a non-zero program"
4360 " header offset, but no program headers"));
4361 else if (do_segments)
252b5132 4362 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4363 return 0;
252b5132
RH		 4364 }
4365
4366 if (do_segments && !do_header)
4367 {
f7a99963
NC		 4368 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4369 printf (_("Entry point "));
4370 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4371 printf (_("\nThere are %d program headers, starting at offset "),
4372 elf_header.e_phnum);
4373 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4374 printf ("\n");
252b5132
RH		 4375 }
4376
d93f0186 4377 if (! get_program_headers (file))
252b5132 4378 return 0;
103f02d3 4379
252b5132
RH		 4380 if (do_segments)
4381 {
3a1a2036
NC		 4382 if (elf_header.e_phnum > 1)
4383 printf (_("\nProgram Headers:\n"));
4384 else
4385 printf (_("\nProgram Headers:\n"));
76da6bbe 4386
f7a99963
NC		 4387 if (is_32bit_elf)
4388 printf
4389 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4390 else if (do_wide)
4391 printf
4392 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4393 else
4394 {
4395 printf
4396 (_(" Type Offset VirtAddr PhysAddr\n"));
4397 printf
4398 (_(" FileSiz MemSiz Flags Align\n"));
4399 }
252b5132
RH		 4400 }
4401
252b5132 4402 dynamic_addr = 0;
1b228002 4403 dynamic_size = 0;
252b5132
RH		 4404
4405 for (i = 0, segment = program_headers;
4406 i < elf_header.e_phnum;
b34976b6 4407 i++, segment++)
252b5132
RH		 4408 {
4409 if (do_segments)
4410 {
103f02d3 4411 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4412
4413 if (is_32bit_elf)
4414 {
4415 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4416 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4417 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4418 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4419 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4420 printf ("%c%c%c ",
4421 (segment->p_flags & PF_R ? 'R' : ' '),
4422 (segment->p_flags & PF_W ? 'W' : ' '),
4423 (segment->p_flags & PF_X ? 'E' : ' '));
4424 printf ("%#lx", (unsigned long) segment->p_align);
4425 }
d974e256
JJ		 4426 else if (do_wide)
4427 {
4428 if ((unsigned long) segment->p_offset == segment->p_offset)
4429 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4430 else
4431 {
4432 print_vma (segment->p_offset, FULL_HEX);
4433 putchar (' ');
4434 }
4435
4436 print_vma (segment->p_vaddr, FULL_HEX);
4437 putchar (' ');
4438 print_vma (segment->p_paddr, FULL_HEX);
4439 putchar (' ');
4440
4441 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4442 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4443 else
4444 {
4445 print_vma (segment->p_filesz, FULL_HEX);
4446 putchar (' ');
4447 }
4448
4449 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4450 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4451 else
4452 {
f48e6c45 4453 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4454 }
4455
4456 printf (" %c%c%c ",
4457 (segment->p_flags & PF_R ? 'R' : ' '),
4458 (segment->p_flags & PF_W ? 'W' : ' '),
4459 (segment->p_flags & PF_X ? 'E' : ' '));
4460
4461 if ((unsigned long) segment->p_align == segment->p_align)
4462 printf ("%#lx", (unsigned long) segment->p_align);
4463 else
4464 {
4465 print_vma (segment->p_align, PREFIX_HEX);
4466 }
4467 }
f7a99963
NC		 4468 else
4469 {
4470 print_vma (segment->p_offset, FULL_HEX);
4471 putchar (' ');
4472 print_vma (segment->p_vaddr, FULL_HEX);
4473 putchar (' ');
4474 print_vma (segment->p_paddr, FULL_HEX);
4475 printf ("\n ");
4476 print_vma (segment->p_filesz, FULL_HEX);
4477 putchar (' ');
4478 print_vma (segment->p_memsz, FULL_HEX);
4479 printf (" %c%c%c ",
4480 (segment->p_flags & PF_R ? 'R' : ' '),
4481 (segment->p_flags & PF_W ? 'W' : ' '),
4482 (segment->p_flags & PF_X ? 'E' : ' '));
4483 print_vma (segment->p_align, HEX);
4484 }
252b5132
RH		 4485 }
4486
f54498b4
NC		 4487 if (do_segments)
4488 putc ('\n', stdout);
4489
252b5132
RH		 4490 switch (segment->p_type)
4491 {
252b5132
RH		 4492 case PT_DYNAMIC:
4493 if (dynamic_addr)
4494 error (_("more than one dynamic segment\n"));
4495
20737c13
AM		 4496 /* By default, assume that the .dynamic section is the first
4497 section in the DYNAMIC segment. */
4498 dynamic_addr = segment->p_offset;
4499 dynamic_size = segment->p_filesz;
f54498b4
NC		 4500 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4501 if (dynamic_addr + dynamic_size >= current_file_size)
4502 {
4503 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4504 dynamic_addr = dynamic_size = 0;
4505 }
20737c13 4506
b2d38a17
NC		 4507 /* Try to locate the .dynamic section. If there is
4508 a section header table, we can easily locate it. */
4509 if (section_headers != NULL)
4510 {
2cf0635d 4511 Elf_Internal_Shdr * sec;
b2d38a17 4512
89fac5e3
RS		 4513 sec = find_section (".dynamic");
4514 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4515 {
28f997cf
TG		 4516 /* A corresponding .dynamic section is expected, but on
4517 IA-64/OpenVMS it is OK for it to be missing. */
4518 if (!is_ia64_vms ())
4519 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4520 break;
4521 }
4522
42bb2e33 4523 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4524 {
4525 dynamic_size = 0;
4526 break;
4527 }
42bb2e33 4528
b2d38a17
NC		 4529 dynamic_addr = sec->sh_offset;
4530 dynamic_size = sec->sh_size;
4531
4532 if (dynamic_addr < segment->p_offset
4533 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4534 warn (_("the .dynamic section is not contained"
4535 " within the dynamic segment\n"));
b2d38a17 4536 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4537 warn (_("the .dynamic section is not the first section"
4538 " in the dynamic segment.\n"));
b2d38a17 4539 }
252b5132
RH		 4540 break;
4541
4542 case PT_INTERP:
fb52b2f4
NC		 4543 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4544 SEEK_SET))
252b5132
RH		 4545 error (_("Unable to find program interpreter name\n"));
4546 else
4547 {
f8eae8b2 4548 char fmt [32];
9495b2e6 4549 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4550
4551 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4552 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4553
252b5132 4554 program_interpreter[0] = 0;
7bd7b3ef
AM		 4555 if (fscanf (file, fmt, program_interpreter) <= 0)
4556 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4557
4558 if (do_segments)
f54498b4 4559 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4560 program_interpreter);
4561 }
4562 break;
4563 }
252b5132
RH		 4564 }
4565
c256ffe7 4566 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4567 {
4568 printf (_("\n Section to Segment mapping:\n"));
4569 printf (_(" Segment Sections...\n"));
4570
252b5132
RH		 4571 for (i = 0; i < elf_header.e_phnum; i++)
4572 {
9ad5cbcf 4573 unsigned int j;
2cf0635d 4574 Elf_Internal_Shdr * section;
252b5132
RH		 4575
4576 segment = program_headers + i;
b391a3e3 4577 section = section_headers + 1;
252b5132
RH		 4578
4579 printf (" %2.2d ", i);
4580
b34976b6 4581 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4582 {
f4638467
AM		 4583 if (!ELF_TBSS_SPECIAL (section, segment)
4584 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4585 printf ("%s ", printable_section_name (section));
252b5132
RH		 4586 }
4587
4588 putc ('\n',stdout);
4589 }
4590 }
4591
252b5132
RH		 4592 return 1;
4593}
4594
4595
d93f0186
NC		 4596/* Find the file offset corresponding to VMA by using the program headers. */
4597
4598static long
2cf0635d 4599offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4600{
2cf0635d 4601 Elf_Internal_Phdr * seg;
d93f0186
NC		 4602
4603 if (! get_program_headers (file))
4604 {
4605 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4606 return (long) vma;
4607 }
4608
4609 for (seg = program_headers;
4610 seg < program_headers + elf_header.e_phnum;
4611 ++seg)
4612 {
4613 if (seg->p_type != PT_LOAD)
4614 continue;
4615
4616 if (vma >= (seg->p_vaddr & -seg->p_align)
4617 && vma + size <= seg->p_vaddr + seg->p_filesz)
4618 return vma - seg->p_vaddr + seg->p_offset;
4619 }
4620
4621 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4622 (unsigned long) vma);
d93f0186
NC		 4623 return (long) vma;
4624}
4625
4626
049b0c3a
NC		 4627/* Allocate memory and load the sections headers into the global pointer
4628 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4629 generate any error messages if the load fails. */
4630
4631static bfd_boolean
4632get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4633{
2cf0635d
NC		 4634 Elf32_External_Shdr * shdrs;
4635 Elf_Internal_Shdr * internal;
b34976b6 4636 unsigned int i;
049b0c3a
NC		 4637 unsigned int size = elf_header.e_shentsize;
4638 unsigned int num = probe ? 1 : elf_header.e_shnum;
4639
4640 /* PR binutils/17531: Cope with unexpected section header sizes. */
4641 if (size == 0 || num == 0)
4642 return FALSE;
4643 if (size < sizeof * shdrs)
4644 {
4645 if (! probe)
4646 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4647 return FALSE;
4648 }
4649 if (!probe && size > sizeof * shdrs)
4650 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4651
3f5e193b 4652 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4653 size, num,
4654 probe ? NULL : _("section headers"));
4655 if (shdrs == NULL)
4656 return FALSE;
252b5132 4657
049b0c3a
NC		 4658 if (section_headers != NULL)
4659 free (section_headers);
3f5e193b
NC		 4660 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4661 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4662 if (section_headers == NULL)
4663 {
049b0c3a 4664 if (!probe)
8b73c356 4665 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4666 return FALSE;
252b5132
RH		 4667 }
4668
4669 for (i = 0, internal = section_headers;
560f3c1c 4670 i < num;
b34976b6 4671 i++, internal++)
252b5132
RH		 4672 {
4673 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4674 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4675 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4676 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4677 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4678 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4679 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4680 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4681 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4682 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4683 }
4684
4685 free (shdrs);
049b0c3a 4686 return TRUE;
252b5132
RH		 4687}
4688
049b0c3a
NC		 4689static bfd_boolean
4690get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4691{
2cf0635d
NC		 4692 Elf64_External_Shdr * shdrs;
4693 Elf_Internal_Shdr * internal;
b34976b6 4694 unsigned int i;
049b0c3a
NC		 4695 unsigned int size = elf_header.e_shentsize;
4696 unsigned int num = probe ? 1 : elf_header.e_shnum;
4697
4698 /* PR binutils/17531: Cope with unexpected section header sizes. */
4699 if (size == 0 || num == 0)
4700 return FALSE;
4701 if (size < sizeof * shdrs)
4702 {
4703 if (! probe)
4704 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4705 return FALSE;
4706 }
4707 if (! probe && size > sizeof * shdrs)
4708 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4709
3f5e193b 4710 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4711 size, num,
4712 probe ? NULL : _("section headers"));
4713 if (shdrs == NULL)
4714 return FALSE;
9ea033b2 4715
049b0c3a
NC		 4716 if (section_headers != NULL)
4717 free (section_headers);
3f5e193b
NC		 4718 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4719 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4720 if (section_headers == NULL)
4721 {
049b0c3a 4722 if (! probe)
8b73c356 4723 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4724 return FALSE;
9ea033b2
NC		 4725 }
4726
4727 for (i = 0, internal = section_headers;
560f3c1c 4728 i < num;
b34976b6 4729 i++, internal++)
9ea033b2
NC		 4730 {
4731 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4732 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4733 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4734 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4735 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4736 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4737 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4738 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4739 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4740 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4741 }
4742
4743 free (shdrs);
049b0c3a 4744 return TRUE;
9ea033b2
NC		 4745}
4746
252b5132 4747static Elf_Internal_Sym *
ba5cdace
NC		 4748get_32bit_elf_symbols (FILE * file,
4749 Elf_Internal_Shdr * section,
4750 unsigned long * num_syms_return)
252b5132 4751{
ba5cdace 4752 unsigned long number = 0;
dd24e3da 4753 Elf32_External_Sym * esyms = NULL;
ba5cdace 4754 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4755 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4756 Elf_Internal_Sym * psym;
b34976b6 4757 unsigned int j;
252b5132 4758
dd24e3da
NC		 4759 /* Run some sanity checks first. */
4760 if (section->sh_entsize == 0)
4761 {
4762 error (_("sh_entsize is zero\n"));
ba5cdace 4763 goto exit_point;
dd24e3da
NC		 4764 }
4765
f54498b4
NC		 4766 if (section->sh_size > current_file_size)
4767 {
4768 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4769 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4770 goto exit_point;
4771 }
4772
dd24e3da
NC		 4773 number = section->sh_size / section->sh_entsize;
4774
4775 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4776 {
4777 error (_("Invalid sh_entsize\n"));
ba5cdace 4778 goto exit_point;
dd24e3da
NC		 4779 }
4780
3f5e193b
NC		 4781 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4782 section->sh_size, _("symbols"));
dd24e3da 4783 if (esyms == NULL)
ba5cdace 4784 goto exit_point;
252b5132 4785
9ad5cbcf
AM		 4786 shndx = NULL;
4787 if (symtab_shndx_hdr != NULL
4788 && (symtab_shndx_hdr->sh_link
4fbb74a6 4789 == (unsigned long) (section - section_headers)))
9ad5cbcf 4790 {
3f5e193b
NC		 4791 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4792 symtab_shndx_hdr->sh_offset,
4793 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4794 _("symbol table section indicies"));
dd24e3da
NC		 4795 if (shndx == NULL)
4796 goto exit_point;
9ad5cbcf
AM		 4797 }
4798
3f5e193b 4799 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4800
4801 if (isyms == NULL)
4802 {
8b73c356
NC		 4803 error (_("Out of memory reading %lu symbols\n"),
4804 (unsigned long) number);
dd24e3da 4805 goto exit_point;
252b5132
RH		 4806 }
4807
dd24e3da 4808 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4809 {
4810 psym->st_name = BYTE_GET (esyms[j].st_name);
4811 psym->st_value = BYTE_GET (esyms[j].st_value);
4812 psym->st_size = BYTE_GET (esyms[j].st_size);
4813 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4814 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4815 psym->st_shndx
4816 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4817 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4818 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4819 psym->st_info = BYTE_GET (esyms[j].st_info);
4820 psym->st_other = BYTE_GET (esyms[j].st_other);
4821 }
4822
dd24e3da 4823 exit_point:
ba5cdace 4824 if (shndx != NULL)
9ad5cbcf 4825 free (shndx);
ba5cdace 4826 if (esyms != NULL)
dd24e3da 4827 free (esyms);
252b5132 4828
ba5cdace
NC		 4829 if (num_syms_return != NULL)
4830 * num_syms_return = isyms == NULL ? 0 : number;
4831
252b5132
RH		 4832 return isyms;
4833}
4834
9ea033b2 4835static Elf_Internal_Sym *
ba5cdace
NC		 4836get_64bit_elf_symbols (FILE * file,
4837 Elf_Internal_Shdr * section,
4838 unsigned long * num_syms_return)
9ea033b2 4839{
ba5cdace
NC		 4840 unsigned long number = 0;
4841 Elf64_External_Sym * esyms = NULL;
4842 Elf_External_Sym_Shndx * shndx = NULL;
4843 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4844 Elf_Internal_Sym * psym;
b34976b6 4845 unsigned int j;
9ea033b2 4846
dd24e3da
NC		 4847 /* Run some sanity checks first. */
4848 if (section->sh_entsize == 0)
4849 {
4850 error (_("sh_entsize is zero\n"));
ba5cdace 4851 goto exit_point;
dd24e3da
NC		 4852 }
4853
f54498b4
NC		 4854 if (section->sh_size > current_file_size)
4855 {
4856 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4857 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4858 goto exit_point;
4859 }
4860
dd24e3da
NC		 4861 number = section->sh_size / section->sh_entsize;
4862
4863 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4864 {
4865 error (_("Invalid sh_entsize\n"));
ba5cdace 4866 goto exit_point;
dd24e3da
NC		 4867 }
4868
3f5e193b
NC		 4869 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4870 section->sh_size, _("symbols"));
a6e9f9df 4871 if (!esyms)
ba5cdace 4872 goto exit_point;
9ea033b2 4873
9ad5cbcf
AM		 4874 if (symtab_shndx_hdr != NULL
4875 && (symtab_shndx_hdr->sh_link
4fbb74a6 4876 == (unsigned long) (section - section_headers)))
9ad5cbcf 4877 {
3f5e193b
NC		 4878 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4879 symtab_shndx_hdr->sh_offset,
4880 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4881 _("symbol table section indicies"));
ba5cdace
NC		 4882 if (shndx == NULL)
4883 goto exit_point;
9ad5cbcf
AM		 4884 }
4885
3f5e193b 4886 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4887
4888 if (isyms == NULL)
4889 {
8b73c356
NC		 4890 error (_("Out of memory reading %lu symbols\n"),
4891 (unsigned long) number);
ba5cdace 4892 goto exit_point;
9ea033b2
NC		 4893 }
4894
ba5cdace 4895 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4896 {
4897 psym->st_name = BYTE_GET (esyms[j].st_name);
4898 psym->st_info = BYTE_GET (esyms[j].st_info);
4899 psym->st_other = BYTE_GET (esyms[j].st_other);
4900 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4901
4fbb74a6 4902 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4903 psym->st_shndx
4904 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4905 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4906 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4907
66543521
AM		 4908 psym->st_value = BYTE_GET (esyms[j].st_value);
4909 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4910 }
4911
ba5cdace
NC		 4912 exit_point:
4913 if (shndx != NULL)
9ad5cbcf 4914 free (shndx);
ba5cdace
NC		 4915 if (esyms != NULL)
4916 free (esyms);
4917
4918 if (num_syms_return != NULL)
4919 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4920
4921 return isyms;
4922}
4923
d1133906 4924static const char *
d3ba0551 4925get_elf_section_flags (bfd_vma sh_flags)
d1133906 4926{
5477e8a0 4927 static char buff[1024];
2cf0635d 4928 char * p = buff;
8d5ff12c 4929 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4930 int sindex;
4931 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4932 bfd_vma os_flags = 0;
4933 bfd_vma proc_flags = 0;
4934 bfd_vma unknown_flags = 0;
148b93f2 4935 static const struct
5477e8a0 4936 {
2cf0635d 4937 const char * str;
5477e8a0
L		 4938 int len;
4939 }
4940 flags [] =
4941 {
cfcac11d
NC		 4942 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4943 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4944 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4945 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4946 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4947 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4948 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4949 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4950 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4951 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4952 /* IA-64 specific. */
4953 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4954 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4955 /* IA-64 OpenVMS specific. */
4956 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4957 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4958 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4959 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4960 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4961 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4962 /* Generic. */
cfcac11d 4963 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4964 /* SPARC specific. */
cfcac11d 4965 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4966 };
4967
4968 if (do_section_details)
4969 {
8d5ff12c
L		 4970 sprintf (buff, "[%*.*lx]: ",
4971 field_size, field_size, (unsigned long) sh_flags);
4972 p += field_size + 4;
5477e8a0 4973 }
76da6bbe 4974
d1133906
NC		 4975 while (sh_flags)
4976 {
4977 bfd_vma flag;
4978
4979 flag = sh_flags & - sh_flags;
4980 sh_flags &= ~ flag;
76da6bbe 4981
5477e8a0 4982 if (do_section_details)
d1133906 4983 {
5477e8a0
L		 4984 switch (flag)
4985 {
91d6fa6a
NC		 4986 case SHF_WRITE: sindex = 0; break;
4987 case SHF_ALLOC: sindex = 1; break;
4988 case SHF_EXECINSTR: sindex = 2; break;
4989 case SHF_MERGE: sindex = 3; break;
4990 case SHF_STRINGS: sindex = 4; break;
4991 case SHF_INFO_LINK: sindex = 5; break;
4992 case SHF_LINK_ORDER: sindex = 6; break;
4993 case SHF_OS_NONCONFORMING: sindex = 7; break;
4994 case SHF_GROUP: sindex = 8; break;
4995 case SHF_TLS: sindex = 9; break;
18ae9cc1 4996 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4997
5477e8a0 4998 default:
91d6fa6a 4999 sindex = -1;
cfcac11d 5000 switch (elf_header.e_machine)
148b93f2 5001 {
cfcac11d 5002 case EM_IA_64:
148b93f2 5003 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5004 sindex = 10;
148b93f2 5005 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5006 sindex = 11;
148b93f2
NC		 5007#ifdef BFD64
5008 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5009 switch (flag)
5010 {
91d6fa6a
NC		 5011 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5012 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5013 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5014 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5015 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5016 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5017 default: break;
5018 }
5019#endif
cfcac11d
NC		 5020 break;
5021
caa83f8b
NC		 5022 case EM_386:
5023 case EM_486:
5024 case EM_X86_64:
7f502d6c 5025 case EM_L1OM:
7a9068fe 5026 case EM_K1OM:
cfcac11d
NC		 5027 case EM_OLD_SPARCV9:
5028 case EM_SPARC32PLUS:
5029 case EM_SPARCV9:
5030 case EM_SPARC:
18ae9cc1 5031 if (flag == SHF_ORDERED)
91d6fa6a 5032 sindex = 19;
cfcac11d
NC		 5033 break;
5034 default:
5035 break;
148b93f2 5036 }
5477e8a0
L		 5037 }
5038
91d6fa6a 5039 if (sindex != -1)
5477e8a0 5040 {
8d5ff12c
L		 5041 if (p != buff + field_size + 4)
5042 {
5043 if (size < (10 + 2))
5044 abort ();
5045 size -= 2;
5046 *p++ = ',';
5047 *p++ = ' ';
5048 }
5049
91d6fa6a
NC		 5050 size -= flags [sindex].len;
5051 p = stpcpy (p, flags [sindex].str);
5477e8a0 5052 }
3b22753a 5053 else if (flag & SHF_MASKOS)
8d5ff12c 5054 os_flags |= flag;
d1133906 5055 else if (flag & SHF_MASKPROC)
8d5ff12c 5056 proc_flags |= flag;
d1133906 5057 else
8d5ff12c 5058 unknown_flags |= flag;
5477e8a0
L		 5059 }
5060 else
5061 {
5062 switch (flag)
5063 {
5064 case SHF_WRITE: *p = 'W'; break;
5065 case SHF_ALLOC: *p = 'A'; break;
5066 case SHF_EXECINSTR: *p = 'X'; break;
5067 case SHF_MERGE: *p = 'M'; break;
5068 case SHF_STRINGS: *p = 'S'; break;
5069 case SHF_INFO_LINK: *p = 'I'; break;
5070 case SHF_LINK_ORDER: *p = 'L'; break;
5071 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5072 case SHF_GROUP: *p = 'G'; break;
5073 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5074 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 5075
5076 default:
8a9036a4 5077 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5078 || elf_header.e_machine == EM_L1OM
5079 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5080 && flag == SHF_X86_64_LARGE)
5081 *p = 'l';
5082 else if (flag & SHF_MASKOS)
5083 {
5084 *p = 'o';
5085 sh_flags &= ~ SHF_MASKOS;
5086 }
5087 else if (flag & SHF_MASKPROC)
5088 {
5089 *p = 'p';
5090 sh_flags &= ~ SHF_MASKPROC;
5091 }
5092 else
5093 *p = 'x';
5094 break;
5095 }
5096 p++;
d1133906
NC		 5097 }
5098 }
76da6bbe 5099
8d5ff12c
L		 5100 if (do_section_details)
5101 {
5102 if (os_flags)
5103 {
5104 size -= 5 + field_size;
5105 if (p != buff + field_size + 4)
5106 {
5107 if (size < (2 + 1))
5108 abort ();
5109 size -= 2;
5110 *p++ = ',';
5111 *p++ = ' ';
5112 }
5113 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5114 (unsigned long) os_flags);
5115 p += 5 + field_size;
5116 }
5117 if (proc_flags)
5118 {
5119 size -= 7 + field_size;
5120 if (p != buff + field_size + 4)
5121 {
5122 if (size < (2 + 1))
5123 abort ();
5124 size -= 2;
5125 *p++ = ',';
5126 *p++ = ' ';
5127 }
5128 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5129 (unsigned long) proc_flags);
5130 p += 7 + field_size;
5131 }
5132 if (unknown_flags)
5133 {
5134 size -= 10 + field_size;
5135 if (p != buff + field_size + 4)
5136 {
5137 if (size < (2 + 1))
5138 abort ();
5139 size -= 2;
5140 *p++ = ',';
5141 *p++ = ' ';
5142 }
2b692964 5143 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5144 (unsigned long) unknown_flags);
5145 p += 10 + field_size;
5146 }
5147 }
5148
e9e44622 5149 *p = '\0';
d1133906
NC		 5150 return buff;
5151}
5152
252b5132 5153static int
2cf0635d 5154process_section_headers (FILE * file)
252b5132 5155{
2cf0635d 5156 Elf_Internal_Shdr * section;
b34976b6 5157 unsigned int i;
252b5132
RH		 5158
5159 section_headers = NULL;
5160
5161 if (elf_header.e_shnum == 0)
5162 {
82f2dbf7
NC		 5163 /* PR binutils/12467. */
5164 if (elf_header.e_shoff != 0)
5165 warn (_("possibly corrupt ELF file header - it has a non-zero"
5166 " section header offset, but no section headers\n"));
5167 else if (do_sections)
252b5132
RH		 5168 printf (_("\nThere are no sections in this file.\n"));
5169
5170 return 1;
5171 }
5172
5173 if (do_sections && !do_header)
9ea033b2 5174 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5175 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5176
9ea033b2
NC		 5177 if (is_32bit_elf)
5178 {
049b0c3a 5179 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5180 return 0;
5181 }
049b0c3a 5182 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5183 return 0;
5184
5185 /* Read in the string table, so that we have names to display. */
0b49d371 5186 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5187 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5188 {
4fbb74a6 5189 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5190
c256ffe7
JJ		 5191 if (section->sh_size != 0)
5192 {
3f5e193b
NC		 5193 string_table = (char *) get_data (NULL, file, section->sh_offset,
5194 1, section->sh_size,
5195 _("string table"));
0de14b54 5196
c256ffe7
JJ		 5197 string_table_length = string_table != NULL ? section->sh_size : 0;
5198 }
252b5132
RH		 5199 }
5200
5201 /* Scan the sections for the dynamic symbol table
e3c8793a 5202 and dynamic string table and debug sections. */
252b5132
RH		 5203 dynamic_symbols = NULL;
5204 dynamic_strings = NULL;
5205 dynamic_syminfo = NULL;
f1ef08cb 5206 symtab_shndx_hdr = NULL;
103f02d3 5207
89fac5e3
RS		 5208 eh_addr_size = is_32bit_elf ? 4 : 8;
5209 switch (elf_header.e_machine)
5210 {
5211 case EM_MIPS:
5212 case EM_MIPS_RS3_LE:
5213 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5214 FDE addresses. However, the ABI also has a semi-official ILP32
5215 variant for which the normal FDE address size rules apply.
5216
5217 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5218 section, where XX is the size of longs in bits. Unfortunately,
5219 earlier compilers provided no way of distinguishing ILP32 objects
5220 from LP64 objects, so if there's any doubt, we should assume that
5221 the official LP64 form is being used. */
5222 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5223 && find_section (".gcc_compiled_long32") == NULL)
5224 eh_addr_size = 8;
5225 break;
0f56a26a
DD		 5226
5227 case EM_H8_300:
5228 case EM_H8_300H:
5229 switch (elf_header.e_flags & EF_H8_MACH)
5230 {
5231 case E_H8_MACH_H8300:
5232 case E_H8_MACH_H8300HN:
5233 case E_H8_MACH_H8300SN:
5234 case E_H8_MACH_H8300SXN:
5235 eh_addr_size = 2;
5236 break;
5237 case E_H8_MACH_H8300H:
5238 case E_H8_MACH_H8300S:
5239 case E_H8_MACH_H8300SX:
5240 eh_addr_size = 4;
5241 break;
5242 }
f4236fe4
DD		 5243 break;
5244
ff7eeb89 5245 case EM_M32C_OLD:
f4236fe4
DD		 5246 case EM_M32C:
5247 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5248 {
5249 case EF_M32C_CPU_M16C:
5250 eh_addr_size = 2;
5251 break;
5252 }
5253 break;
89fac5e3
RS		 5254 }
5255
76ca31c0
NC		 5256#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5257 do \
5258 { \
5259 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5260 if (section->sh_entsize != expected_entsize) \
9dd3a467 5261 { \
76ca31c0
NC		 5262 char buf[40]; \
5263 sprintf_vma (buf, section->sh_entsize); \
5264 /* Note: coded this way so that there is a single string for \
5265 translation. */ \
5266 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5267 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5268 (unsigned) expected_entsize); \
9dd3a467 5269 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5270 } \
5271 } \
08d8fa11 5272 while (0)
9dd3a467
NC		 5273
5274#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5275 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5276 sizeof (Elf64_External_##type))
5277
252b5132
RH		 5278 for (i = 0, section = section_headers;
5279 i < elf_header.e_shnum;
b34976b6 5280 i++, section++)
252b5132 5281 {
2cf0635d 5282 char * name = SECTION_NAME (section);
252b5132
RH		 5283
5284 if (section->sh_type == SHT_DYNSYM)
5285 {
5286 if (dynamic_symbols != NULL)
5287 {
5288 error (_("File contains multiple dynamic symbol tables\n"));
5289 continue;
5290 }
5291
08d8fa11 5292 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5293 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5294 }
5295 else if (section->sh_type == SHT_STRTAB
18bd398b 5296 && streq (name, ".dynstr"))
252b5132
RH		 5297 {
5298 if (dynamic_strings != NULL)
5299 {
5300 error (_("File contains multiple dynamic string tables\n"));
5301 continue;
5302 }
5303
3f5e193b
NC		 5304 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5305 1, section->sh_size,
5306 _("dynamic strings"));
59245841 5307 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5308 }
9ad5cbcf
AM		 5309 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5310 {
5311 if (symtab_shndx_hdr != NULL)
5312 {
5313 error (_("File contains multiple symtab shndx tables\n"));
5314 continue;
5315 }
5316 symtab_shndx_hdr = section;
5317 }
08d8fa11
JJ		 5318 else if (section->sh_type == SHT_SYMTAB)
5319 CHECK_ENTSIZE (section, i, Sym);
5320 else if (section->sh_type == SHT_GROUP)
5321 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5322 else if (section->sh_type == SHT_REL)
5323 CHECK_ENTSIZE (section, i, Rel);
5324 else if (section->sh_type == SHT_RELA)
5325 CHECK_ENTSIZE (section, i, Rela);
252b5132 5326 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5327 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5328 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5329 || do_debug_str || do_debug_loc || do_debug_ranges
5330 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5331 && (const_strneq (name, ".debug_")
5332 || const_strneq (name, ".zdebug_")))
252b5132 5333 {
1b315056
CS		 5334 if (name[1] == 'z')
5335 name += sizeof (".zdebug_") - 1;
5336 else
5337 name += sizeof (".debug_") - 1;
252b5132
RH		 5338
5339 if (do_debugging
4723351a
CC		 5340 || (do_debug_info && const_strneq (name, "info"))
5341 || (do_debug_info && const_strneq (name, "types"))
5342 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5343 || (do_debug_lines && strcmp (name, "line") == 0)
5344 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5345 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5346 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5347 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5348 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5349 || (do_debug_aranges && const_strneq (name, "aranges"))
5350 || (do_debug_ranges && const_strneq (name, "ranges"))
5351 || (do_debug_frames && const_strneq (name, "frame"))
5352 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5353 || (do_debug_macinfo && const_strneq (name, "macro"))
5354 || (do_debug_str && const_strneq (name, "str"))
5355 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5356 || (do_debug_addr && const_strneq (name, "addr"))
5357 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5358 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5359 )
09c11c86 5360 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5361 }
a262ae96 5362 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5363 else if ((do_debugging || do_debug_info)
0112cd26 5364 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5365 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5366 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5367 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5368 else if (do_gdb_index && streq (name, ".gdb_index"))
5369 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5370 /* Trace sections for Itanium VMS. */
5371 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5372 || do_trace_aranges)
5373 && const_strneq (name, ".trace_"))
5374 {
5375 name += sizeof (".trace_") - 1;
5376
5377 if (do_debugging
5378 || (do_trace_info && streq (name, "info"))
5379 || (do_trace_abbrevs && streq (name, "abbrev"))
5380 || (do_trace_aranges && streq (name, "aranges"))
5381 )
5382 request_dump_bynumber (i, DEBUG_DUMP);
5383 }
252b5132
RH		 5384 }
5385
5386 if (! do_sections)
5387 return 1;
5388
3a1a2036
NC		 5389 if (elf_header.e_shnum > 1)
5390 printf (_("\nSection Headers:\n"));
5391 else
5392 printf (_("\nSection Header:\n"));
76da6bbe 5393
f7a99963 5394 if (is_32bit_elf)
595cf52e 5395 {
5477e8a0 5396 if (do_section_details)
595cf52e
L		 5397 {
5398 printf (_(" [Nr] Name\n"));
5477e8a0 5399 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5400 }
5401 else
5402 printf
5403 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5404 }
d974e256 5405 else if (do_wide)
595cf52e 5406 {
5477e8a0 5407 if (do_section_details)
595cf52e
L		 5408 {
5409 printf (_(" [Nr] Name\n"));
5477e8a0 5410 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5411 }
5412 else
5413 printf
5414 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5415 }
f7a99963
NC		 5416 else
5417 {
5477e8a0 5418 if (do_section_details)
595cf52e
L		 5419 {
5420 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5421 printf (_(" Type Address Offset Link\n"));
5422 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5423 }
5424 else
5425 {
5426 printf (_(" [Nr] Name Type Address Offset\n"));
5427 printf (_(" Size EntSize Flags Link Info Align\n"));
5428 }
f7a99963 5429 }
252b5132 5430
5477e8a0
L		 5431 if (do_section_details)
5432 printf (_(" Flags\n"));
5433
252b5132
RH		 5434 for (i = 0, section = section_headers;
5435 i < elf_header.e_shnum;
b34976b6 5436 i++, section++)
252b5132 5437 {
7bfd842d 5438 printf (" [%2u] ", i);
5477e8a0 5439 if (do_section_details)
74e1a04b 5440 printf ("%s\n ", printable_section_name (section));
595cf52e 5441 else
74e1a04b 5442 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5443
ea52a088
NC		 5444 printf (do_wide ? " %-15s " : " %-15.15s ",
5445 get_section_type_name (section->sh_type));
0b4362b0 5446
f7a99963
NC		 5447 if (is_32bit_elf)
5448 {
cfcac11d
NC		 5449 const char * link_too_big = NULL;
5450
f7a99963 5451 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5452
f7a99963
NC		 5453 printf ( " %6.6lx %6.6lx %2.2lx",
5454 (unsigned long) section->sh_offset,
5455 (unsigned long) section->sh_size,
5456 (unsigned long) section->sh_entsize);
d1133906 5457
5477e8a0
L		 5458 if (do_section_details)
5459 fputs (" ", stdout);
5460 else
5461 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5462
cfcac11d
NC		 5463 if (section->sh_link >= elf_header.e_shnum)
5464 {
5465 link_too_big = "";
5466 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5467 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5468 switch (elf_header.e_machine)
5469 {
caa83f8b
NC		 5470 case EM_386:
5471 case EM_486:
5472 case EM_X86_64:
7f502d6c 5473 case EM_L1OM:
7a9068fe 5474 case EM_K1OM:
cfcac11d
NC		 5475 case EM_OLD_SPARCV9:
5476 case EM_SPARC32PLUS:
5477 case EM_SPARCV9:
5478 case EM_SPARC:
5479 if (section->sh_link == (SHN_BEFORE & 0xffff))
5480 link_too_big = "BEFORE";
5481 else if (section->sh_link == (SHN_AFTER & 0xffff))
5482 link_too_big = "AFTER";
5483 break;
5484 default:
5485 break;
5486 }
5487 }
5488
5489 if (do_section_details)
5490 {
5491 if (link_too_big != NULL && * link_too_big)
5492 printf ("<%s> ", link_too_big);
5493 else
5494 printf ("%2u ", section->sh_link);
5495 printf ("%3u %2lu\n", section->sh_info,
5496 (unsigned long) section->sh_addralign);
5497 }
5498 else
5499 printf ("%2u %3u %2lu\n",
5500 section->sh_link,
5501 section->sh_info,
5502 (unsigned long) section->sh_addralign);
5503
5504 if (link_too_big && ! * link_too_big)
5505 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5506 i, section->sh_link);
f7a99963 5507 }
d974e256
JJ		 5508 else if (do_wide)
5509 {
5510 print_vma (section->sh_addr, LONG_HEX);
5511
5512 if ((long) section->sh_offset == section->sh_offset)
5513 printf (" %6.6lx", (unsigned long) section->sh_offset);
5514 else
5515 {
5516 putchar (' ');
5517 print_vma (section->sh_offset, LONG_HEX);
5518 }
5519
5520 if ((unsigned long) section->sh_size == section->sh_size)
5521 printf (" %6.6lx", (unsigned long) section->sh_size);
5522 else
5523 {
5524 putchar (' ');
5525 print_vma (section->sh_size, LONG_HEX);
5526 }
5527
5528 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5529 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5530 else
5531 {
5532 putchar (' ');
5533 print_vma (section->sh_entsize, LONG_HEX);
5534 }
5535
5477e8a0
L		 5536 if (do_section_details)
5537 fputs (" ", stdout);
5538 else
5539 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5540
72de5009 5541 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5542
5543 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5544 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5545 else
5546 {
5547 print_vma (section->sh_addralign, DEC);
5548 putchar ('\n');
5549 }
5550 }
5477e8a0 5551 else if (do_section_details)
595cf52e 5552 {
5477e8a0 5553 printf (" %-15.15s ",
595cf52e 5554 get_section_type_name (section->sh_type));
595cf52e
L		 5555 print_vma (section->sh_addr, LONG_HEX);
5556 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5557 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5558 else
5559 {
5560 printf (" ");
5561 print_vma (section->sh_offset, LONG_HEX);
5562 }
72de5009 5563 printf (" %u\n ", section->sh_link);
595cf52e 5564 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5565 putchar (' ');
595cf52e
L		 5566 print_vma (section->sh_entsize, LONG_HEX);
5567
72de5009
AM		 5568 printf (" %-16u %lu\n",
5569 section->sh_info,
595cf52e
L		 5570 (unsigned long) section->sh_addralign);
5571 }
f7a99963
NC		 5572 else
5573 {
5574 putchar (' ');
5575 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5576 if ((long) section->sh_offset == section->sh_offset)
5577 printf (" %8.8lx", (unsigned long) section->sh_offset);
5578 else
5579 {
5580 printf (" ");
5581 print_vma (section->sh_offset, LONG_HEX);
5582 }
f7a99963
NC		 5583 printf ("\n ");
5584 print_vma (section->sh_size, LONG_HEX);
5585 printf (" ");
5586 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5587
d1133906 5588 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5589
72de5009
AM		 5590 printf (" %2u %3u %lu\n",
5591 section->sh_link,
5592 section->sh_info,
f7a99963
NC		 5593 (unsigned long) section->sh_addralign);
5594 }
5477e8a0
L		 5595
5596 if (do_section_details)
5597 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5598 }
5599
5477e8a0 5600 if (!do_section_details)
3dbcc61d
NC		 5601 {
5602 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5603 || elf_header.e_machine == EM_L1OM
5604 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5605 printf (_("Key to Flags:\n\
5606 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5607 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5608 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5609 else
5610 printf (_("Key to Flags:\n\
e3c8793a 5611 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5612 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5613 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5614 }
d1133906 5615
252b5132
RH		 5616 return 1;
5617}
5618
f5842774
L		 5619static const char *
5620get_group_flags (unsigned int flags)
5621{
5622 static char buff[32];
5623 switch (flags)
5624 {
220453ec
AM		 5625 case 0:
5626 return "";
5627
f5842774 5628 case GRP_COMDAT:
220453ec 5629 return "COMDAT ";
f5842774
L		 5630
5631 default:
220453ec 5632 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5633 break;
5634 }
5635 return buff;
5636}
5637
5638static int
2cf0635d 5639process_section_groups (FILE * file)
f5842774 5640{
2cf0635d 5641 Elf_Internal_Shdr * section;
f5842774 5642 unsigned int i;
2cf0635d
NC		 5643 struct group * group;
5644 Elf_Internal_Shdr * symtab_sec;
5645 Elf_Internal_Shdr * strtab_sec;
5646 Elf_Internal_Sym * symtab;
ba5cdace 5647 unsigned long num_syms;
2cf0635d 5648 char * strtab;
c256ffe7 5649 size_t strtab_size;
d1f5c6e3
L		 5650
5651 /* Don't process section groups unless needed. */
5652 if (!do_unwind && !do_section_groups)
5653 return 1;
f5842774
L		 5654
5655 if (elf_header.e_shnum == 0)
5656 {
5657 if (do_section_groups)
82f2dbf7 5658 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5659
5660 return 1;
5661 }
5662
5663 if (section_headers == NULL)
5664 {
5665 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5666 /* PR 13622: This can happen with a corrupt ELF header. */
5667 return 0;
f5842774
L		 5668 }
5669
3f5e193b
NC		 5670 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5671 sizeof (struct group *));
e4b17d5c
L		 5672
5673 if (section_headers_groups == NULL)
5674 {
8b73c356
NC		 5675 error (_("Out of memory reading %u section group headers\n"),
5676 elf_header.e_shnum);
e4b17d5c
L		 5677 return 0;
5678 }
5679
f5842774 5680 /* Scan the sections for the group section. */
d1f5c6e3 5681 group_count = 0;
f5842774
L		 5682 for (i = 0, section = section_headers;
5683 i < elf_header.e_shnum;
5684 i++, section++)
e4b17d5c
L		 5685 if (section->sh_type == SHT_GROUP)
5686 group_count++;
5687
d1f5c6e3
L		 5688 if (group_count == 0)
5689 {
5690 if (do_section_groups)
5691 printf (_("\nThere are no section groups in this file.\n"));
5692
5693 return 1;
5694 }
5695
3f5e193b 5696 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5697
5698 if (section_groups == NULL)
5699 {
8b73c356
NC		 5700 error (_("Out of memory reading %lu groups\n"),
5701 (unsigned long) group_count);
e4b17d5c
L		 5702 return 0;
5703 }
5704
d1f5c6e3
L		 5705 symtab_sec = NULL;
5706 strtab_sec = NULL;
5707 symtab = NULL;
ba5cdace 5708 num_syms = 0;
d1f5c6e3 5709 strtab = NULL;
c256ffe7 5710 strtab_size = 0;
e4b17d5c
L		 5711 for (i = 0, section = section_headers, group = section_groups;
5712 i < elf_header.e_shnum;
5713 i++, section++)
f5842774
L		 5714 {
5715 if (section->sh_type == SHT_GROUP)
5716 {
74e1a04b
NC		 5717 const char * name = printable_section_name (section);
5718 const char * group_name;
2cf0635d
NC		 5719 unsigned char * start;
5720 unsigned char * indices;
f5842774 5721 unsigned int entry, j, size;
2cf0635d
NC		 5722 Elf_Internal_Shdr * sec;
5723 Elf_Internal_Sym * sym;
f5842774
L		 5724
5725 /* Get the symbol table. */
4fbb74a6
AM		 5726 if (section->sh_link >= elf_header.e_shnum
5727 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5728 != SHT_SYMTAB))
f5842774
L		 5729 {
5730 error (_("Bad sh_link in group section `%s'\n"), name);
5731 continue;
5732 }
d1f5c6e3
L		 5733
5734 if (symtab_sec != sec)
5735 {
5736 symtab_sec = sec;
5737 if (symtab)
5738 free (symtab);
ba5cdace 5739 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5740 }
f5842774 5741
dd24e3da
NC		 5742 if (symtab == NULL)
5743 {
5744 error (_("Corrupt header in group section `%s'\n"), name);
5745 continue;
5746 }
5747
ba5cdace
NC		 5748 if (section->sh_info >= num_syms)
5749 {
5750 error (_("Bad sh_info in group section `%s'\n"), name);
5751 continue;
5752 }
5753
f5842774
L		 5754 sym = symtab + section->sh_info;
5755
5756 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5757 {
4fbb74a6
AM		 5758 if (sym->st_shndx == 0
5759 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5760 {
5761 error (_("Bad sh_info in group section `%s'\n"), name);
5762 continue;
5763 }
ba2685cc 5764
4fbb74a6 5765 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5766 strtab_sec = NULL;
5767 if (strtab)
5768 free (strtab);
f5842774 5769 strtab = NULL;
c256ffe7 5770 strtab_size = 0;
f5842774
L		 5771 }
5772 else
5773 {
5774 /* Get the string table. */
4fbb74a6 5775 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5776 {
5777 strtab_sec = NULL;
5778 if (strtab)
5779 free (strtab);
5780 strtab = NULL;
5781 strtab_size = 0;
5782 }
5783 else if (strtab_sec
4fbb74a6 5784 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5785 {
5786 strtab_sec = sec;
5787 if (strtab)
5788 free (strtab);
071436c6 5789
3f5e193b 5790 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 5791 1, strtab_sec->sh_size,
5792 _("string table"));
c256ffe7 5793 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5794 }
c256ffe7 5795 group_name = sym->st_name < strtab_size
2b692964 5796 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5797 }
5798
3f5e193b
NC		 5799 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5800 1, section->sh_size,
5801 _("section data"));
59245841
NC		 5802 if (start == NULL)
5803 continue;
f5842774
L		 5804
5805 indices = start;
5806 size = (section->sh_size / section->sh_entsize) - 1;
5807 entry = byte_get (indices, 4);
5808 indices += 4;
e4b17d5c
L		 5809
5810 if (do_section_groups)
5811 {
2b692964 5812 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5813 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5814
e4b17d5c
L		 5815 printf (_(" [Index] Name\n"));
5816 }
5817
5818 group->group_index = i;
5819
f5842774
L		 5820 for (j = 0; j < size; j++)
5821 {
2cf0635d 5822 struct group_list * g;
e4b17d5c 5823
f5842774
L		 5824 entry = byte_get (indices, 4);
5825 indices += 4;
5826
4fbb74a6 5827 if (entry >= elf_header.e_shnum)
391cb864
L		 5828 {
5829 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5830 entry, i, elf_header.e_shnum - 1);
5831 continue;
5832 }
391cb864 5833
4fbb74a6 5834 if (section_headers_groups [entry] != NULL)
e4b17d5c 5835 {
d1f5c6e3
L		 5836 if (entry)
5837 {
391cb864
L		 5838 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5839 entry, i,
4fbb74a6 5840 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5841 continue;
5842 }
5843 else
5844 {
5845 /* Intel C/C++ compiler may put section 0 in a
5846 section group. We just warn it the first time
5847 and ignore it afterwards. */
5848 static int warned = 0;
5849 if (!warned)
5850 {
5851 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5852 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5853 warned++;
5854 }
5855 }
e4b17d5c
L		 5856 }
5857
4fbb74a6 5858 section_headers_groups [entry] = group;
e4b17d5c
L		 5859
5860 if (do_section_groups)
5861 {
4fbb74a6 5862 sec = section_headers + entry;
74e1a04b 5863 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 5864 }
5865
3f5e193b 5866 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5867 g->section_index = entry;
5868 g->next = group->root;
5869 group->root = g;
f5842774
L		 5870 }
5871
f5842774
L		 5872 if (start)
5873 free (start);
e4b17d5c
L		 5874
5875 group++;
f5842774
L		 5876 }
5877 }
5878
d1f5c6e3
L		 5879 if (symtab)
5880 free (symtab);
5881 if (strtab)
5882 free (strtab);
f5842774
L		 5883 return 1;
5884}
5885
28f997cf
TG		 5886/* Data used to display dynamic fixups. */
5887
5888struct ia64_vms_dynfixup
5889{
5890 bfd_vma needed_ident; /* Library ident number. */
5891 bfd_vma needed; /* Index in the dstrtab of the library name. */
5892 bfd_vma fixup_needed; /* Index of the library. */
5893 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5894 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5895};
5896
5897/* Data used to display dynamic relocations. */
5898
5899struct ia64_vms_dynimgrela
5900{
5901 bfd_vma img_rela_cnt; /* Number of relocations. */
5902 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5903};
5904
5905/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5906 library). */
5907
5908static void
5909dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5910 const char *strtab, unsigned int strtab_sz)
5911{
5912 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5913 long i;
5914 const char *lib_name;
5915
5916 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5917 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5918 _("dynamic section image fixups"));
5919 if (!imfs)
5920 return;
5921
5922 if (fixup->needed < strtab_sz)
5923 lib_name = strtab + fixup->needed;
5924 else
5925 {
5926 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5927 (unsigned long) fixup->needed);
28f997cf
TG		 5928 lib_name = "???";
5929 }
5930 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5931 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5932 printf
5933 (_("Seg Offset Type SymVec DataType\n"));
5934
5935 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5936 {
5937 unsigned int type;
5938 const char *rtype;
5939
5940 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5941 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5942 type = BYTE_GET (imfs [i].type);
5943 rtype = elf_ia64_reloc_type (type);
5944 if (rtype == NULL)
5945 printf (" 0x%08x ", type);
5946 else
5947 printf (" %-32s ", rtype);
5948 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5949 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5950 }
5951
5952 free (imfs);
5953}
5954
5955/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5956
5957static void
5958dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5959{
5960 Elf64_External_VMS_IMAGE_RELA *imrs;
5961 long i;
5962
5963 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5964 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5965 _("dynamic section image relocations"));
28f997cf
TG		 5966 if (!imrs)
5967 return;
5968
5969 printf (_("\nImage relocs\n"));
5970 printf
5971 (_("Seg Offset Type Addend Seg Sym Off\n"));
5972
5973 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5974 {
5975 unsigned int type;
5976 const char *rtype;
5977
5978 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5979 printf ("%08" BFD_VMA_FMT "x ",
5980 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5981 type = BYTE_GET (imrs [i].type);
5982 rtype = elf_ia64_reloc_type (type);
5983 if (rtype == NULL)
5984 printf ("0x%08x ", type);
5985 else
5986 printf ("%-31s ", rtype);
5987 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5988 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5989 printf ("%08" BFD_VMA_FMT "x\n",
5990 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5991 }
5992
5993 free (imrs);
5994}
5995
5996/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5997
5998static int
5999process_ia64_vms_dynamic_relocs (FILE *file)
6000{
6001 struct ia64_vms_dynfixup fixup;
6002 struct ia64_vms_dynimgrela imgrela;
6003 Elf_Internal_Dyn *entry;
6004 int res = 0;
6005 bfd_vma strtab_off = 0;
6006 bfd_vma strtab_sz = 0;
6007 char *strtab = NULL;
6008
6009 memset (&fixup, 0, sizeof (fixup));
6010 memset (&imgrela, 0, sizeof (imgrela));
6011
6012 /* Note: the order of the entries is specified by the OpenVMS specs. */
6013 for (entry = dynamic_section;
6014 entry < dynamic_section + dynamic_nent;
6015 entry++)
6016 {
6017 switch (entry->d_tag)
6018 {
6019 case DT_IA_64_VMS_STRTAB_OFFSET:
6020 strtab_off = entry->d_un.d_val;
6021 break;
6022 case DT_STRSZ:
6023 strtab_sz = entry->d_un.d_val;
6024 if (strtab == NULL)
6025 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6026 1, strtab_sz, _("dynamic string section"));
6027 break;
6028
6029 case DT_IA_64_VMS_NEEDED_IDENT:
6030 fixup.needed_ident = entry->d_un.d_val;
6031 break;
6032 case DT_NEEDED:
6033 fixup.needed = entry->d_un.d_val;
6034 break;
6035 case DT_IA_64_VMS_FIXUP_NEEDED:
6036 fixup.fixup_needed = entry->d_un.d_val;
6037 break;
6038 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6039 fixup.fixup_rela_cnt = entry->d_un.d_val;
6040 break;
6041 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6042 fixup.fixup_rela_off = entry->d_un.d_val;
6043 res++;
6044 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6045 break;
6046
6047 case DT_IA_64_VMS_IMG_RELA_CNT:
6048 imgrela.img_rela_cnt = entry->d_un.d_val;
6049 break;
6050 case DT_IA_64_VMS_IMG_RELA_OFF:
6051 imgrela.img_rela_off = entry->d_un.d_val;
6052 res++;
6053 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6054 break;
6055
6056 default:
6057 break;
6058 }
6059 }
6060
6061 if (strtab != NULL)
6062 free (strtab);
6063
6064 return res;
6065}
6066
85b1c36d 6067static struct
566b0d53 6068{
2cf0635d 6069 const char * name;
566b0d53
L		 6070 int reloc;
6071 int size;
6072 int rela;
6073} dynamic_relocations [] =
6074{
6075 { "REL", DT_REL, DT_RELSZ, FALSE },
6076 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6077 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6078};
6079
252b5132 6080/* Process the reloc section. */
18bd398b 6081
252b5132 6082static int
2cf0635d 6083process_relocs (FILE * file)
252b5132 6084{
b34976b6
AM		 6085 unsigned long rel_size;
6086 unsigned long rel_offset;
252b5132
RH		 6087
6088
6089 if (!do_reloc)
6090 return 1;
6091
6092 if (do_using_dynamic)
6093 {
566b0d53 6094 int is_rela;
2cf0635d 6095 const char * name;
566b0d53
L		 6096 int has_dynamic_reloc;
6097 unsigned int i;
0de14b54 6098
566b0d53 6099 has_dynamic_reloc = 0;
252b5132 6100
566b0d53 6101 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6102 {
566b0d53
L		 6103 is_rela = dynamic_relocations [i].rela;
6104 name = dynamic_relocations [i].name;
6105 rel_size = dynamic_info [dynamic_relocations [i].size];
6106 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6107
566b0d53
L		 6108 has_dynamic_reloc |= rel_size;
6109
6110 if (is_rela == UNKNOWN)
aa903cfb 6111 {
566b0d53
L		 6112 if (dynamic_relocations [i].reloc == DT_JMPREL)
6113 switch (dynamic_info[DT_PLTREL])
6114 {
6115 case DT_REL:
6116 is_rela = FALSE;
6117 break;
6118 case DT_RELA:
6119 is_rela = TRUE;
6120 break;
6121 }
aa903cfb 6122 }
252b5132 6123
566b0d53
L		 6124 if (rel_size)
6125 {
6126 printf
6127 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6128 name, rel_offset, rel_size);
252b5132 6129
d93f0186
NC		 6130 dump_relocations (file,
6131 offset_from_vma (file, rel_offset, rel_size),
6132 rel_size,
566b0d53 6133 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6134 dynamic_strings, dynamic_strings_length,
6135 is_rela, 1);
566b0d53 6136 }
252b5132 6137 }
566b0d53 6138
28f997cf
TG		 6139 if (is_ia64_vms ())
6140 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6141
566b0d53 6142 if (! has_dynamic_reloc)
252b5132
RH		 6143 printf (_("\nThere are no dynamic relocations in this file.\n"));
6144 }
6145 else
6146 {
2cf0635d 6147 Elf_Internal_Shdr * section;
b34976b6
AM		 6148 unsigned long i;
6149 int found = 0;
252b5132
RH		 6150
6151 for (i = 0, section = section_headers;
6152 i < elf_header.e_shnum;
b34976b6 6153 i++, section++)
252b5132
RH		 6154 {
6155 if ( section->sh_type != SHT_RELA
6156 && section->sh_type != SHT_REL)
6157 continue;
6158
6159 rel_offset = section->sh_offset;
6160 rel_size = section->sh_size;
6161
6162 if (rel_size)
6163 {
2cf0635d 6164 Elf_Internal_Shdr * strsec;
b34976b6 6165 int is_rela;
103f02d3 6166
252b5132
RH		 6167 printf (_("\nRelocation section "));
6168
6169 if (string_table == NULL)
19936277 6170 printf ("%d", section->sh_name);
252b5132 6171 else
74e1a04b 6172 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6173
6174 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6175 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6176
d79b3d50
NC		 6177 is_rela = section->sh_type == SHT_RELA;
6178
4fbb74a6
AM		 6179 if (section->sh_link != 0
6180 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6181 {
2cf0635d
NC		 6182 Elf_Internal_Shdr * symsec;
6183 Elf_Internal_Sym * symtab;
d79b3d50 6184 unsigned long nsyms;
c256ffe7 6185 unsigned long strtablen = 0;
2cf0635d 6186 char * strtab = NULL;
57346661 6187
4fbb74a6 6188 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6189 if (symsec->sh_type != SHT_SYMTAB
6190 && symsec->sh_type != SHT_DYNSYM)
6191 continue;
6192
ba5cdace 6193 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6194
af3fc3bc
AM		 6195 if (symtab == NULL)
6196 continue;
252b5132 6197
4fbb74a6
AM		 6198 if (symsec->sh_link != 0
6199 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6200 {
4fbb74a6 6201 strsec = section_headers + symsec->sh_link;
103f02d3 6202
3f5e193b 6203 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6204 1, strsec->sh_size,
6205 _("string table"));
c256ffe7
JJ		 6206 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6207 }
252b5132 6208
d79b3d50 6209 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6210 symtab, nsyms, strtab, strtablen,
6211 is_rela,
6212 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6213 if (strtab)
6214 free (strtab);
6215 free (symtab);
6216 }
6217 else
6218 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6219 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6220
6221 found = 1;
6222 }
6223 }
6224
6225 if (! found)
6226 printf (_("\nThere are no relocations in this file.\n"));
6227 }
6228
6229 return 1;
6230}
6231
57346661
AM		 6232/* Process the unwind section. */
6233
4d6ed7c8
NC		 6234#include "unwind-ia64.h"
6235
6236/* An absolute address consists of a section and an offset. If the
6237 section is NULL, the offset itself is the address, otherwise, the
6238 address equals to LOAD_ADDRESS(section) + offset. */
6239
6240struct absaddr
6241 {
6242 unsigned short section;
6243 bfd_vma offset;
6244 };
6245
1949de15
L		 6246#define ABSADDR(a) \
6247 ((a).section \
6248 ? section_headers [(a).section].sh_addr + (a).offset \
6249 : (a).offset)
6250
3f5e193b
NC		 6251struct ia64_unw_table_entry
6252 {
6253 struct absaddr start;
6254 struct absaddr end;
6255 struct absaddr info;
6256 };
6257
57346661 6258struct ia64_unw_aux_info
4d6ed7c8 6259 {
3f5e193b
NC		 6260
6261 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 6262 unsigned long table_len; /* Length of unwind table. */
2cf0635d 6263 unsigned char * info; /* Unwind info. */
b34976b6
AM		 6264 unsigned long info_size; /* Size of unwind info. */
6265 bfd_vma info_addr; /* starting address of unwind info. */
6266 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6267 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 6268 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6269 char * strtab; /* The string table. */
b34976b6 6270 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 6271 };
6272
4d6ed7c8 6273static void
2cf0635d 6274find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 6275 unsigned long nsyms,
2cf0635d 6276 const char * strtab,
57346661 6277 unsigned long strtab_size,
d3ba0551 6278 struct absaddr addr,
2cf0635d
NC		 6279 const char ** symname,
6280 bfd_vma * offset)
4d6ed7c8 6281{
d3ba0551 6282 bfd_vma dist = 0x100000;
2cf0635d
NC		 6283 Elf_Internal_Sym * sym;
6284 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 6285 unsigned long i;
6286
0b6ae522
DJ		 6287 REMOVE_ARCH_BITS (addr.offset);
6288
57346661 6289 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 6290 {
0b6ae522
DJ		 6291 bfd_vma value = sym->st_value;
6292
6293 REMOVE_ARCH_BITS (value);
6294
4d6ed7c8
NC		 6295 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6296 && sym->st_name != 0
6297 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6298 && addr.offset >= value
6299 && addr.offset - value < dist)
4d6ed7c8
NC		 6300 {
6301 best = sym;
0b6ae522 6302 dist = addr.offset - value;
4d6ed7c8
NC		 6303 if (!dist)
6304 break;
6305 }
6306 }
1b31d05e 6307
4d6ed7c8
NC		 6308 if (best)
6309 {
57346661 6310 *symname = (best->st_name >= strtab_size
2b692964 6311 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6312 *offset = dist;
6313 return;
6314 }
1b31d05e 6315
4d6ed7c8
NC		 6316 *symname = NULL;
6317 *offset = addr.offset;
6318}
6319
6320static void
2cf0635d 6321dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6322{
2cf0635d 6323 struct ia64_unw_table_entry * tp;
4d6ed7c8 6324 int in_body;
7036c0e1 6325
4d6ed7c8
NC		 6326 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6327 {
6328 bfd_vma stamp;
6329 bfd_vma offset;
2cf0635d
NC		 6330 const unsigned char * dp;
6331 const unsigned char * head;
6332 const char * procname;
4d6ed7c8 6333
57346661
AM		 6334 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6335 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6336
6337 fputs ("\n<", stdout);
6338
6339 if (procname)
6340 {
6341 fputs (procname, stdout);
6342
6343 if (offset)
6344 printf ("+%lx", (unsigned long) offset);
6345 }
6346
6347 fputs (">: [", stdout);
6348 print_vma (tp->start.offset, PREFIX_HEX);
6349 fputc ('-', stdout);
6350 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6351 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6352 (unsigned long) (tp->info.offset - aux->seg_base));
6353
1949de15 6354 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6355 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6356
86f55779 6357 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6358 (unsigned) UNW_VER (stamp),
6359 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6360 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6361 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6362 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6363
6364 if (UNW_VER (stamp) != 1)
6365 {
2b692964 6366 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6367 continue;
6368 }
6369
6370 in_body = 0;
89fac5e3 6371 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 6372 dp = unw_decode (dp, in_body, & in_body);
6373 }
6374}
6375
6376static int
2cf0635d
NC		 6377slurp_ia64_unwind_table (FILE * file,
6378 struct ia64_unw_aux_info * aux,
6379 Elf_Internal_Shdr * sec)
4d6ed7c8 6380{
89fac5e3 6381 unsigned long size, nrelas, i;
2cf0635d
NC		 6382 Elf_Internal_Phdr * seg;
6383 struct ia64_unw_table_entry * tep;
6384 Elf_Internal_Shdr * relsec;
6385 Elf_Internal_Rela * rela;
6386 Elf_Internal_Rela * rp;
6387 unsigned char * table;
6388 unsigned char * tp;
6389 Elf_Internal_Sym * sym;
6390 const char * relname;
4d6ed7c8 6391
4d6ed7c8
NC		 6392 /* First, find the starting address of the segment that includes
6393 this section: */
6394
6395 if (elf_header.e_phnum)
6396 {
d93f0186 6397 if (! get_program_headers (file))
4d6ed7c8 6398 return 0;
4d6ed7c8 6399
d93f0186
NC		 6400 for (seg = program_headers;
6401 seg < program_headers + elf_header.e_phnum;
6402 ++seg)
4d6ed7c8
NC		 6403 {
6404 if (seg->p_type != PT_LOAD)
6405 continue;
6406
6407 if (sec->sh_addr >= seg->p_vaddr
6408 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6409 {
6410 aux->seg_base = seg->p_vaddr;
6411 break;
6412 }
6413 }
4d6ed7c8
NC		 6414 }
6415
6416 /* Second, build the unwind table from the contents of the unwind section: */
6417 size = sec->sh_size;
3f5e193b
NC		 6418 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6419 _("unwind table"));
a6e9f9df
AM		 6420 if (!table)
6421 return 0;
4d6ed7c8 6422
3f5e193b
NC		 6423 aux->table = (struct ia64_unw_table_entry *)
6424 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 6425 tep = aux->table;
c6a0c689 6426 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 6427 {
6428 tep->start.section = SHN_UNDEF;
6429 tep->end.section = SHN_UNDEF;
6430 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6431 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6432 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6433 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6434 tep->start.offset += aux->seg_base;
6435 tep->end.offset += aux->seg_base;
6436 tep->info.offset += aux->seg_base;
6437 }
6438 free (table);
6439
41e92641 6440 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6441 for (relsec = section_headers;
6442 relsec < section_headers + elf_header.e_shnum;
6443 ++relsec)
6444 {
6445 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6446 || relsec->sh_info >= elf_header.e_shnum
6447 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6448 continue;
6449
6450 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6451 & rela, & nrelas))
6452 return 0;
6453
6454 for (rp = rela; rp < rela + nrelas; ++rp)
6455 {
aca88567
NC		 6456 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6457 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6458
0112cd26 6459 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6460 {
e5fb9629 6461 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 6462 continue;
6463 }
6464
89fac5e3 6465 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6466
89fac5e3 6467 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 6468 {
6469 case 0:
6470 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6471 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6472 break;
6473 case 1:
6474 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6475 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6476 break;
6477 case 2:
6478 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6479 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6480 break;
6481 default:
6482 break;
6483 }
6484 }
6485
6486 free (rela);
6487 }
6488
89fac5e3 6489 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 6490 return 1;
6491}
6492
1b31d05e 6493static void
2cf0635d 6494ia64_process_unwind (FILE * file)
4d6ed7c8 6495{
2cf0635d
NC		 6496 Elf_Internal_Shdr * sec;
6497 Elf_Internal_Shdr * unwsec = NULL;
6498 Elf_Internal_Shdr * strsec;
89fac5e3 6499 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6500 struct ia64_unw_aux_info aux;
f1467e33 6501
4d6ed7c8
NC		 6502 memset (& aux, 0, sizeof (aux));
6503
4d6ed7c8
NC		 6504 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6505 {
c256ffe7 6506 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6507 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6508 {
ba5cdace 6509 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6510
4fbb74a6 6511 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6512 if (aux.strtab != NULL)
6513 {
6514 error (_("Multiple auxillary string tables encountered\n"));
6515 free (aux.strtab);
6516 }
3f5e193b
NC		 6517 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6518 1, strsec->sh_size,
6519 _("string table"));
c256ffe7 6520 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6521 }
6522 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6523 unwcount++;
6524 }
6525
6526 if (!unwcount)
6527 printf (_("\nThere are no unwind sections in this file.\n"));
6528
6529 while (unwcount-- > 0)
6530 {
2cf0635d 6531 char * suffix;
579f31ac
JJ		 6532 size_t len, len2;
6533
4082ef84 6534 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6535 i < elf_header.e_shnum; ++i, ++sec)
6536 if (sec->sh_type == SHT_IA_64_UNWIND)
6537 {
6538 unwsec = sec;
6539 break;
6540 }
4082ef84
NC		 6541 /* We have already counted the number of SHT_IA64_UNWIND
6542 sections so the loop above should never fail. */
6543 assert (unwsec != NULL);
579f31ac
JJ		 6544
6545 unwstart = i + 1;
6546 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6547
e4b17d5c
L		 6548 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6549 {
6550 /* We need to find which section group it is in. */
4082ef84 6551 struct group_list * g;
e4b17d5c 6552
4082ef84
NC		 6553 if (section_headers_groups == NULL
6554 || section_headers_groups [i] == NULL)
6555 i = elf_header.e_shnum;
6556 else
e4b17d5c 6557 {
4082ef84 6558 g = section_headers_groups [i]->root;
18bd398b 6559
4082ef84
NC		 6560 for (; g != NULL; g = g->next)
6561 {
6562 sec = section_headers + g->section_index;
e4b17d5c 6563
4082ef84
NC		 6564 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6565 break;
6566 }
6567
6568 if (g == NULL)
6569 i = elf_header.e_shnum;
6570 }
e4b17d5c 6571 }
18bd398b 6572 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6573 {
18bd398b 6574 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6575 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6576 suffix = SECTION_NAME (unwsec) + len;
6577 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6578 ++i, ++sec)
18bd398b
NC		 6579 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6580 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6581 break;
6582 }
6583 else
6584 {
6585 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6586 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6587 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6588 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6589 suffix = "";
18bd398b 6590 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6591 suffix = SECTION_NAME (unwsec) + len;
6592 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6593 ++i, ++sec)
18bd398b
NC		 6594 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6595 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6596 break;
6597 }
6598
6599 if (i == elf_header.e_shnum)
6600 {
6601 printf (_("\nCould not find unwind info section for "));
6602
6603 if (string_table == NULL)
6604 printf ("%d", unwsec->sh_name);
6605 else
74e1a04b 6606 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6607 }
6608 else
4d6ed7c8 6609 {
4d6ed7c8 6610 aux.info_addr = sec->sh_addr;
3f5e193b 6611 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6612 sec->sh_size,
6613 _("unwind info"));
59245841 6614 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6615
579f31ac 6616 printf (_("\nUnwind section "));
4d6ed7c8 6617
579f31ac
JJ		 6618 if (string_table == NULL)
6619 printf ("%d", unwsec->sh_name);
6620 else
74e1a04b 6621 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 6622
579f31ac 6623 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6624 (unsigned long) unwsec->sh_offset,
89fac5e3 6625 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6626
579f31ac 6627 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6628
579f31ac
JJ		 6629 if (aux.table_len > 0)
6630 dump_ia64_unwind (& aux);
6631
6632 if (aux.table)
6633 free ((char *) aux.table);
6634 if (aux.info)
6635 free ((char *) aux.info);
6636 aux.table = NULL;
6637 aux.info = NULL;
6638 }
4d6ed7c8 6639 }
4d6ed7c8 6640
4d6ed7c8
NC		 6641 if (aux.symtab)
6642 free (aux.symtab);
6643 if (aux.strtab)
6644 free ((char *) aux.strtab);
4d6ed7c8
NC		 6645}
6646
3f5e193b
NC		 6647struct hppa_unw_table_entry
6648 {
6649 struct absaddr start;
6650 struct absaddr end;
6651 unsigned int Cannot_unwind:1; /* 0 */
6652 unsigned int Millicode:1; /* 1 */
6653 unsigned int Millicode_save_sr0:1; /* 2 */
6654 unsigned int Region_description:2; /* 3..4 */
6655 unsigned int reserved1:1; /* 5 */
6656 unsigned int Entry_SR:1; /* 6 */
6657 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6658 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6659 unsigned int Args_stored:1; /* 16 */
6660 unsigned int Variable_Frame:1; /* 17 */
6661 unsigned int Separate_Package_Body:1; /* 18 */
6662 unsigned int Frame_Extension_Millicode:1; /* 19 */
6663 unsigned int Stack_Overflow_Check:1; /* 20 */
6664 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6665 unsigned int Ada_Region:1; /* 22 */
6666 unsigned int cxx_info:1; /* 23 */
6667 unsigned int cxx_try_catch:1; /* 24 */
6668 unsigned int sched_entry_seq:1; /* 25 */
6669 unsigned int reserved2:1; /* 26 */
6670 unsigned int Save_SP:1; /* 27 */
6671 unsigned int Save_RP:1; /* 28 */
6672 unsigned int Save_MRP_in_frame:1; /* 29 */
6673 unsigned int extn_ptr_defined:1; /* 30 */
6674 unsigned int Cleanup_defined:1; /* 31 */
6675
6676 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6677 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6678 unsigned int Large_frame:1; /* 2 */
6679 unsigned int Pseudo_SP_Set:1; /* 3 */
6680 unsigned int reserved4:1; /* 4 */
6681 unsigned int Total_frame_size:27; /* 5..31 */
6682 };
6683
57346661
AM		 6684struct hppa_unw_aux_info
6685 {
3f5e193b 6686 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6687 unsigned long table_len; /* Length of unwind table. */
6688 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6689 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6690 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6691 char * strtab; /* The string table. */
57346661
AM		 6692 unsigned long strtab_size; /* Size of string table. */
6693 };
6694
6695static void
2cf0635d 6696dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6697{
2cf0635d 6698 struct hppa_unw_table_entry * tp;
57346661 6699
57346661
AM		 6700 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6701 {
6702 bfd_vma offset;
2cf0635d 6703 const char * procname;
57346661
AM		 6704
6705 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6706 aux->strtab_size, tp->start, &procname,
6707 &offset);
6708
6709 fputs ("\n<", stdout);
6710
6711 if (procname)
6712 {
6713 fputs (procname, stdout);
6714
6715 if (offset)
6716 printf ("+%lx", (unsigned long) offset);
6717 }
6718
6719 fputs (">: [", stdout);
6720 print_vma (tp->start.offset, PREFIX_HEX);
6721 fputc ('-', stdout);
6722 print_vma (tp->end.offset, PREFIX_HEX);
6723 printf ("]\n\t");
6724
18bd398b
NC		 6725#define PF(_m) if (tp->_m) printf (#_m " ");
6726#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6727 PF(Cannot_unwind);
6728 PF(Millicode);
6729 PF(Millicode_save_sr0);
18bd398b 6730 /* PV(Region_description); */
57346661
AM		 6731 PF(Entry_SR);
6732 PV(Entry_FR);
6733 PV(Entry_GR);
6734 PF(Args_stored);
6735 PF(Variable_Frame);
6736 PF(Separate_Package_Body);
6737 PF(Frame_Extension_Millicode);
6738 PF(Stack_Overflow_Check);
6739 PF(Two_Instruction_SP_Increment);
6740 PF(Ada_Region);
6741 PF(cxx_info);
6742 PF(cxx_try_catch);
6743 PF(sched_entry_seq);
6744 PF(Save_SP);
6745 PF(Save_RP);
6746 PF(Save_MRP_in_frame);
6747 PF(extn_ptr_defined);
6748 PF(Cleanup_defined);
6749 PF(MPE_XL_interrupt_marker);
6750 PF(HP_UX_interrupt_marker);
6751 PF(Large_frame);
6752 PF(Pseudo_SP_Set);
6753 PV(Total_frame_size);
6754#undef PF
6755#undef PV
6756 }
6757
18bd398b 6758 printf ("\n");
57346661
AM		 6759}
6760
6761static int
2cf0635d
NC		 6762slurp_hppa_unwind_table (FILE * file,
6763 struct hppa_unw_aux_info * aux,
6764 Elf_Internal_Shdr * sec)
57346661 6765{
1c0751b2 6766 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6767 Elf_Internal_Phdr * seg;
6768 struct hppa_unw_table_entry * tep;
6769 Elf_Internal_Shdr * relsec;
6770 Elf_Internal_Rela * rela;
6771 Elf_Internal_Rela * rp;
6772 unsigned char * table;
6773 unsigned char * tp;
6774 Elf_Internal_Sym * sym;
6775 const char * relname;
57346661 6776
57346661
AM		 6777 /* First, find the starting address of the segment that includes
6778 this section. */
6779
6780 if (elf_header.e_phnum)
6781 {
6782 if (! get_program_headers (file))
6783 return 0;
6784
6785 for (seg = program_headers;
6786 seg < program_headers + elf_header.e_phnum;
6787 ++seg)
6788 {
6789 if (seg->p_type != PT_LOAD)
6790 continue;
6791
6792 if (sec->sh_addr >= seg->p_vaddr
6793 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6794 {
6795 aux->seg_base = seg->p_vaddr;
6796 break;
6797 }
6798 }
6799 }
6800
6801 /* Second, build the unwind table from the contents of the unwind
6802 section. */
6803 size = sec->sh_size;
3f5e193b
NC		 6804 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6805 _("unwind table"));
57346661
AM		 6806 if (!table)
6807 return 0;
6808
1c0751b2
DA		 6809 unw_ent_size = 16;
6810 nentries = size / unw_ent_size;
6811 size = unw_ent_size * nentries;
57346661 6812
3f5e193b
NC		 6813 tep = aux->table = (struct hppa_unw_table_entry *)
6814 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6815
1c0751b2 6816 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6817 {
6818 unsigned int tmp1, tmp2;
6819
6820 tep->start.section = SHN_UNDEF;
6821 tep->end.section = SHN_UNDEF;
6822
1c0751b2
DA		 6823 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6824 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6825 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6826 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6827
6828 tep->start.offset += aux->seg_base;
6829 tep->end.offset += aux->seg_base;
57346661
AM		 6830
6831 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6832 tep->Millicode = (tmp1 >> 30) & 0x1;
6833 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6834 tep->Region_description = (tmp1 >> 27) & 0x3;
6835 tep->reserved1 = (tmp1 >> 26) & 0x1;
6836 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6837 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6838 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6839 tep->Args_stored = (tmp1 >> 15) & 0x1;
6840 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6841 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6842 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6843 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6844 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6845 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6846 tep->cxx_info = (tmp1 >> 8) & 0x1;
6847 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6848 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6849 tep->reserved2 = (tmp1 >> 5) & 0x1;
6850 tep->Save_SP = (tmp1 >> 4) & 0x1;
6851 tep->Save_RP = (tmp1 >> 3) & 0x1;
6852 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6853 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6854 tep->Cleanup_defined = tmp1 & 0x1;
6855
6856 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6857 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6858 tep->Large_frame = (tmp2 >> 29) & 0x1;
6859 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6860 tep->reserved4 = (tmp2 >> 27) & 0x1;
6861 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6862 }
6863 free (table);
6864
6865 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6866 for (relsec = section_headers;
6867 relsec < section_headers + elf_header.e_shnum;
6868 ++relsec)
6869 {
6870 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6871 || relsec->sh_info >= elf_header.e_shnum
6872 || section_headers + relsec->sh_info != sec)
57346661
AM		 6873 continue;
6874
6875 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6876 & rela, & nrelas))
6877 return 0;
6878
6879 for (rp = rela; rp < rela + nrelas; ++rp)
6880 {
aca88567
NC		 6881 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6882 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6883
6884 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6885 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6886 {
6887 warn (_("Skipping unexpected relocation type %s\n"), relname);
6888 continue;
6889 }
6890
6891 i = rp->r_offset / unw_ent_size;
6892
89fac5e3 6893 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6894 {
6895 case 0:
6896 aux->table[i].start.section = sym->st_shndx;
1e456d54 6897 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6898 break;
6899 case 1:
6900 aux->table[i].end.section = sym->st_shndx;
1e456d54 6901 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6902 break;
6903 default:
6904 break;
6905 }
6906 }
6907
6908 free (rela);
6909 }
6910
1c0751b2 6911 aux->table_len = nentries;
57346661
AM		 6912
6913 return 1;
6914}
6915
1b31d05e 6916static void
2cf0635d 6917hppa_process_unwind (FILE * file)
57346661 6918{
57346661 6919 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6920 Elf_Internal_Shdr * unwsec = NULL;
6921 Elf_Internal_Shdr * strsec;
6922 Elf_Internal_Shdr * sec;
18bd398b 6923 unsigned long i;
57346661 6924
c256ffe7 6925 if (string_table == NULL)
1b31d05e
NC		 6926 return;
6927
6928 memset (& aux, 0, sizeof (aux));
57346661
AM		 6929
6930 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6931 {
c256ffe7 6932 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6933 && sec->sh_link < elf_header.e_shnum)
57346661 6934 {
ba5cdace 6935 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6936
4fbb74a6 6937 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6938 if (aux.strtab != NULL)
6939 {
6940 error (_("Multiple auxillary string tables encountered\n"));
6941 free (aux.strtab);
6942 }
3f5e193b
NC		 6943 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6944 1, strsec->sh_size,
6945 _("string table"));
c256ffe7 6946 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6947 }
18bd398b 6948 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6949 unwsec = sec;
6950 }
6951
6952 if (!unwsec)
6953 printf (_("\nThere are no unwind sections in this file.\n"));
6954
6955 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6956 {
18bd398b 6957 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6958 {
74e1a04b
NC		 6959 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
6960 printable_section_name (sec),
57346661 6961 (unsigned long) sec->sh_offset,
89fac5e3 6962 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6963
6964 slurp_hppa_unwind_table (file, &aux, sec);
6965 if (aux.table_len > 0)
6966 dump_hppa_unwind (&aux);
6967
6968 if (aux.table)
6969 free ((char *) aux.table);
6970 aux.table = NULL;
6971 }
6972 }
6973
6974 if (aux.symtab)
6975 free (aux.symtab);
6976 if (aux.strtab)
6977 free ((char *) aux.strtab);
57346661
AM		 6978}
6979
0b6ae522
DJ		 6980struct arm_section
6981{
a734115a
NC		 6982 unsigned char * data; /* The unwind data. */
6983 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6984 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6985 unsigned long nrelas; /* The number of relocations. */
6986 unsigned int rel_type; /* REL or RELA ? */
6987 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6988};
6989
6990struct arm_unw_aux_info
6991{
a734115a
NC		 6992 FILE * file; /* The file containing the unwind sections. */
6993 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6994 unsigned long nsyms; /* Number of symbols. */
6995 char * strtab; /* The file's string table. */
6996 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6997};
6998
6999static const char *
7000arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7001 bfd_vma fn, struct absaddr addr)
7002{
7003 const char *procname;
7004 bfd_vma sym_offset;
7005
7006 if (addr.section == SHN_UNDEF)
7007 addr.offset = fn;
7008
7009 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7010 aux->strtab_size, addr, &procname,
7011 &sym_offset);
7012
7013 print_vma (fn, PREFIX_HEX);
7014
7015 if (procname)
7016 {
7017 fputs (" <", stdout);
7018 fputs (procname, stdout);
7019
7020 if (sym_offset)
7021 printf ("+0x%lx", (unsigned long) sym_offset);
7022 fputc ('>', stdout);
7023 }
7024
7025 return procname;
7026}
7027
7028static void
7029arm_free_section (struct arm_section *arm_sec)
7030{
7031 if (arm_sec->data != NULL)
7032 free (arm_sec->data);
7033
7034 if (arm_sec->rela != NULL)
7035 free (arm_sec->rela);
7036}
7037
a734115a
NC		 7038/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7039 cached section and install SEC instead.
7040 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7041 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7042 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7043 relocation's offset in ADDR.
1b31d05e
NC		 7044 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7045 into the string table of the symbol associated with the reloc. If no
7046 reloc was applied store -1 there.
7047 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7048
7049static bfd_boolean
1b31d05e
NC		 7050get_unwind_section_word (struct arm_unw_aux_info * aux,
7051 struct arm_section * arm_sec,
7052 Elf_Internal_Shdr * sec,
7053 bfd_vma word_offset,
7054 unsigned int * wordp,
7055 struct absaddr * addr,
7056 bfd_vma * sym_name)
0b6ae522
DJ		 7057{
7058 Elf_Internal_Rela *rp;
7059 Elf_Internal_Sym *sym;
7060 const char * relname;
7061 unsigned int word;
7062 bfd_boolean wrapped;
7063
e0a31db1
NC		 7064 if (sec == NULL || arm_sec == NULL)
7065 return FALSE;
7066
0b6ae522
DJ		 7067 addr->section = SHN_UNDEF;
7068 addr->offset = 0;
7069
1b31d05e
NC		 7070 if (sym_name != NULL)
7071 *sym_name = (bfd_vma) -1;
7072
a734115a 7073 /* If necessary, update the section cache. */
0b6ae522
DJ		 7074 if (sec != arm_sec->sec)
7075 {
7076 Elf_Internal_Shdr *relsec;
7077
7078 arm_free_section (arm_sec);
7079
7080 arm_sec->sec = sec;
7081 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7082 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7083 arm_sec->rela = NULL;
7084 arm_sec->nrelas = 0;
7085
7086 for (relsec = section_headers;
7087 relsec < section_headers + elf_header.e_shnum;
7088 ++relsec)
7089 {
7090 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7091 || section_headers + relsec->sh_info != sec
7092 /* PR 15745: Check the section type as well. */
7093 || (relsec->sh_type != SHT_REL
7094 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7095 continue;
7096
a734115a 7097 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7098 if (relsec->sh_type == SHT_REL)
7099 {
7100 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7101 relsec->sh_size,
7102 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7103 return FALSE;
0b6ae522 7104 }
1ae40aa4 7105 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7106 {
7107 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7108 relsec->sh_size,
7109 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7110 return FALSE;
0b6ae522 7111 }
1ae40aa4 7112 break;
0b6ae522
DJ		 7113 }
7114
7115 arm_sec->next_rela = arm_sec->rela;
7116 }
7117
a734115a 7118 /* If there is no unwind data we can do nothing. */
0b6ae522 7119 if (arm_sec->data == NULL)
a734115a 7120 return FALSE;
0b6ae522 7121
e0a31db1
NC		 7122 /* If the offset is invalid then fail. */
7123 if (word_offset > sec->sh_size - 4)
7124 return FALSE;
7125
a734115a 7126 /* Get the word at the required offset. */
0b6ae522
DJ		 7127 word = byte_get (arm_sec->data + word_offset, 4);
7128
0eff7165
NC		 7129 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7130 if (arm_sec->rela == NULL)
7131 {
7132 * wordp = word;
7133 return TRUE;
7134 }
7135
a734115a 7136 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7137 wrapped = FALSE;
7138 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7139 {
7140 bfd_vma prelval, offset;
7141
7142 if (rp->r_offset > word_offset && !wrapped)
7143 {
7144 rp = arm_sec->rela;
7145 wrapped = TRUE;
7146 }
7147 if (rp->r_offset > word_offset)
7148 break;
7149
7150 if (rp->r_offset & 3)
7151 {
7152 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7153 (unsigned long) rp->r_offset);
7154 continue;
7155 }
7156
7157 if (rp->r_offset < word_offset)
7158 continue;
7159
74e1a04b
NC		 7160 /* PR 17531: file: 027-161405-0.004 */
7161 if (aux->symtab == NULL)
7162 continue;
7163
0b6ae522
DJ		 7164 if (arm_sec->rel_type == SHT_REL)
7165 {
7166 offset = word & 0x7fffffff;
7167 if (offset & 0x40000000)
7168 offset |= ~ (bfd_vma) 0x7fffffff;
7169 }
a734115a 7170 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7171 offset = rp->r_addend;
a734115a 7172 else
74e1a04b
NC		 7173 {
7174 error (_("Unknown section relocation type %d encountered\n"),
7175 arm_sec->rel_type);
7176 break;
7177 }
0b6ae522 7178
071436c6
NC		 7179 /* PR 17531 file: 027-1241568-0.004. */
7180 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7181 {
7182 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7183 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7184 break;
7185 }
7186
7187 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7188 offset += sym->st_value;
7189 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7190
a734115a
NC		 7191 /* Check that we are processing the expected reloc type. */
7192 if (elf_header.e_machine == EM_ARM)
7193 {
7194 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7195 if (relname == NULL)
7196 {
7197 warn (_("Skipping unknown ARM relocation type: %d\n"),
7198 (int) ELF32_R_TYPE (rp->r_info));
7199 continue;
7200 }
a734115a
NC		 7201
7202 if (streq (relname, "R_ARM_NONE"))
7203 continue;
0b4362b0 7204
a734115a
NC		 7205 if (! streq (relname, "R_ARM_PREL31"))
7206 {
071436c6 7207 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7208 continue;
7209 }
7210 }
7211 else if (elf_header.e_machine == EM_TI_C6000)
7212 {
7213 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7214 if (relname == NULL)
7215 {
7216 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7217 (int) ELF32_R_TYPE (rp->r_info));
7218 continue;
7219 }
0b4362b0 7220
a734115a
NC		 7221 if (streq (relname, "R_C6000_NONE"))
7222 continue;
7223
7224 if (! streq (relname, "R_C6000_PREL31"))
7225 {
071436c6 7226 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7227 continue;
7228 }
7229
7230 prelval >>= 1;
7231 }
7232 else
74e1a04b
NC		 7233 {
7234 /* This function currently only supports ARM and TI unwinders. */
7235 warn (_("Only TI and ARM unwinders are currently supported\n"));
7236 break;
7237 }
fa197c1c 7238
0b6ae522
DJ		 7239 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7240 addr->section = sym->st_shndx;
7241 addr->offset = offset;
74e1a04b 7242
1b31d05e
NC		 7243 if (sym_name)
7244 * sym_name = sym->st_name;
0b6ae522
DJ		 7245 break;
7246 }
7247
7248 *wordp = word;
7249 arm_sec->next_rela = rp;
7250
a734115a 7251 return TRUE;
0b6ae522
DJ		 7252}
7253
a734115a
NC		 7254static const char *tic6x_unwind_regnames[16] =
7255{
0b4362b0
RM		 7256 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7257 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7258 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7259};
fa197c1c 7260
0b6ae522 7261static void
fa197c1c 7262decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7263{
fa197c1c
PB		 7264 int i;
7265
7266 for (i = 12; mask; mask >>= 1, i--)
7267 {
7268 if (mask & 1)
7269 {
7270 fputs (tic6x_unwind_regnames[i], stdout);
7271 if (mask > 1)
7272 fputs (", ", stdout);
7273 }
7274 }
7275}
0b6ae522
DJ		 7276
7277#define ADVANCE \
7278 if (remaining == 0 && more_words) \
7279 { \
7280 data_offset += 4; \
1b31d05e
NC		 7281 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7282 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7283 return; \
7284 remaining = 4; \
7285 more_words--; \
7286 } \
7287
7288#define GET_OP(OP) \
7289 ADVANCE; \
7290 if (remaining) \
7291 { \
7292 remaining--; \
7293 (OP) = word >> 24; \
7294 word <<= 8; \
7295 } \
7296 else \
7297 { \
2b692964 7298 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7299 return; \
7300 } \
cc5914eb 7301 printf ("0x%02x ", OP)
0b6ae522 7302
fa197c1c
PB		 7303static void
7304decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7305 unsigned int word, unsigned int remaining,
7306 unsigned int more_words,
7307 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7308 struct arm_section *data_arm_sec)
7309{
7310 struct absaddr addr;
0b6ae522
DJ		 7311
7312 /* Decode the unwinding instructions. */
7313 while (1)
7314 {
7315 unsigned int op, op2;
7316
7317 ADVANCE;
7318 if (remaining == 0)
7319 break;
7320 remaining--;
7321 op = word >> 24;
7322 word <<= 8;
7323
cc5914eb 7324 printf (" 0x%02x ", op);
0b6ae522
DJ		 7325
7326 if ((op & 0xc0) == 0x00)
7327 {
7328 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7329
cc5914eb 7330 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7331 }
7332 else if ((op & 0xc0) == 0x40)
7333 {
7334 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7335
cc5914eb 7336 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7337 }
7338 else if ((op & 0xf0) == 0x80)
7339 {
7340 GET_OP (op2);
7341 if (op == 0x80 && op2 == 0)
7342 printf (_("Refuse to unwind"));
7343 else
7344 {
7345 unsigned int mask = ((op & 0x0f) << 8) | op2;
7346 int first = 1;
7347 int i;
2b692964 7348
0b6ae522
DJ		 7349 printf ("pop {");
7350 for (i = 0; i < 12; i++)
7351 if (mask & (1 << i))
7352 {
7353 if (first)
7354 first = 0;
7355 else
7356 printf (", ");
7357 printf ("r%d", 4 + i);
7358 }
7359 printf ("}");
7360 }
7361 }
7362 else if ((op & 0xf0) == 0x90)
7363 {
7364 if (op == 0x9d || op == 0x9f)
7365 printf (_(" [Reserved]"));
7366 else
cc5914eb 7367 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7368 }
7369 else if ((op & 0xf0) == 0xa0)
7370 {
7371 int end = 4 + (op & 0x07);
7372 int first = 1;
7373 int i;
61865e30 7374
0b6ae522
DJ		 7375 printf (" pop {");
7376 for (i = 4; i <= end; i++)
7377 {
7378 if (first)
7379 first = 0;
7380 else
7381 printf (", ");
7382 printf ("r%d", i);
7383 }
7384 if (op & 0x08)
7385 {
1b31d05e 7386 if (!first)
0b6ae522
DJ		 7387 printf (", ");
7388 printf ("r14");
7389 }
7390 printf ("}");
7391 }
7392 else if (op == 0xb0)
7393 printf (_(" finish"));
7394 else if (op == 0xb1)
7395 {
7396 GET_OP (op2);
7397 if (op2 == 0 || (op2 & 0xf0) != 0)
7398 printf (_("[Spare]"));
7399 else
7400 {
7401 unsigned int mask = op2 & 0x0f;
7402 int first = 1;
7403 int i;
61865e30 7404
0b6ae522
DJ		 7405 printf ("pop {");
7406 for (i = 0; i < 12; i++)
7407 if (mask & (1 << i))
7408 {
7409 if (first)
7410 first = 0;
7411 else
7412 printf (", ");
7413 printf ("r%d", i);
7414 }
7415 printf ("}");
7416 }
7417 }
7418 else if (op == 0xb2)
7419 {
b115cf96 7420 unsigned char buf[9];
0b6ae522
DJ		 7421 unsigned int i, len;
7422 unsigned long offset;
61865e30 7423
b115cf96 7424 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7425 {
7426 GET_OP (buf[i]);
7427 if ((buf[i] & 0x80) == 0)
7428 break;
7429 }
4082ef84
NC		 7430 if (i == sizeof (buf))
7431 printf (_("corrupt change to vsp"));
7432 else
7433 {
7434 offset = read_uleb128 (buf, &len, buf + i + 1);
7435 assert (len == i + 1);
7436 offset = offset * 4 + 0x204;
7437 printf ("vsp = vsp + %ld", offset);
7438 }
0b6ae522 7439 }
61865e30 7440 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7441 {
61865e30
NC		 7442 unsigned int first, last;
7443
7444 GET_OP (op2);
7445 first = op2 >> 4;
7446 last = op2 & 0x0f;
7447 if (op == 0xc8)
7448 first = first + 16;
7449 printf ("pop {D%d", first);
7450 if (last)
7451 printf ("-D%d", first + last);
7452 printf ("}");
7453 }
7454 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7455 {
7456 unsigned int count = op & 0x07;
7457
7458 printf ("pop {D8");
7459 if (count)
7460 printf ("-D%d", 8 + count);
7461 printf ("}");
7462 }
7463 else if (op >= 0xc0 && op <= 0xc5)
7464 {
7465 unsigned int count = op & 0x07;
7466
7467 printf (" pop {wR10");
7468 if (count)
7469 printf ("-wR%d", 10 + count);
7470 printf ("}");
7471 }
7472 else if (op == 0xc6)
7473 {
7474 unsigned int first, last;
7475
7476 GET_OP (op2);
7477 first = op2 >> 4;
7478 last = op2 & 0x0f;
7479 printf ("pop {wR%d", first);
7480 if (last)
7481 printf ("-wR%d", first + last);
7482 printf ("}");
7483 }
7484 else if (op == 0xc7)
7485 {
7486 GET_OP (op2);
7487 if (op2 == 0 || (op2 & 0xf0) != 0)
7488 printf (_("[Spare]"));
0b6ae522
DJ		 7489 else
7490 {
61865e30
NC		 7491 unsigned int mask = op2 & 0x0f;
7492 int first = 1;
7493 int i;
7494
7495 printf ("pop {");
7496 for (i = 0; i < 4; i++)
7497 if (mask & (1 << i))
7498 {
7499 if (first)
7500 first = 0;
7501 else
7502 printf (", ");
7503 printf ("wCGR%d", i);
7504 }
7505 printf ("}");
0b6ae522
DJ		 7506 }
7507 }
61865e30
NC		 7508 else
7509 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7510 printf ("\n");
7511 }
fa197c1c
PB		 7512}
7513
7514static void
7515decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7516 unsigned int word, unsigned int remaining,
7517 unsigned int more_words,
7518 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7519 struct arm_section *data_arm_sec)
7520{
7521 struct absaddr addr;
7522
7523 /* Decode the unwinding instructions. */
7524 while (1)
7525 {
7526 unsigned int op, op2;
7527
7528 ADVANCE;
7529 if (remaining == 0)
7530 break;
7531 remaining--;
7532 op = word >> 24;
7533 word <<= 8;
7534
9cf03b7e 7535 printf (" 0x%02x ", op);
fa197c1c
PB		 7536
7537 if ((op & 0xc0) == 0x00)
7538 {
7539 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7540 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7541 }
7542 else if ((op & 0xc0) == 0x80)
7543 {
7544 GET_OP (op2);
7545 if (op == 0x80 && op2 == 0)
7546 printf (_("Refuse to unwind"));
7547 else
7548 {
7549 unsigned int mask = ((op & 0x1f) << 8) | op2;
7550 if (op & 0x20)
7551 printf ("pop compact {");
7552 else
7553 printf ("pop {");
7554
7555 decode_tic6x_unwind_regmask (mask);
7556 printf("}");
7557 }
7558 }
7559 else if ((op & 0xf0) == 0xc0)
7560 {
7561 unsigned int reg;
7562 unsigned int nregs;
7563 unsigned int i;
7564 const char *name;
a734115a
NC		 7565 struct
7566 {
fa197c1c
PB		 7567 unsigned int offset;
7568 unsigned int reg;
7569 } regpos[16];
7570
7571 /* Scan entire instruction first so that GET_OP output is not
7572 interleaved with disassembly. */
7573 nregs = 0;
7574 for (i = 0; nregs < (op & 0xf); i++)
7575 {
7576 GET_OP (op2);
7577 reg = op2 >> 4;
7578 if (reg != 0xf)
7579 {
7580 regpos[nregs].offset = i * 2;
7581 regpos[nregs].reg = reg;
7582 nregs++;
7583 }
7584
7585 reg = op2 & 0xf;
7586 if (reg != 0xf)
7587 {
7588 regpos[nregs].offset = i * 2 + 1;
7589 regpos[nregs].reg = reg;
7590 nregs++;
7591 }
7592 }
7593
7594 printf (_("pop frame {"));
7595 reg = nregs - 1;
7596 for (i = i * 2; i > 0; i--)
7597 {
7598 if (regpos[reg].offset == i - 1)
7599 {
7600 name = tic6x_unwind_regnames[regpos[reg].reg];
7601 if (reg > 0)
7602 reg--;
7603 }
7604 else
7605 name = _("[pad]");
7606
7607 fputs (name, stdout);
7608 if (i > 1)
7609 printf (", ");
7610 }
7611
7612 printf ("}");
7613 }
7614 else if (op == 0xd0)
7615 printf (" MOV FP, SP");
7616 else if (op == 0xd1)
7617 printf (" __c6xabi_pop_rts");
7618 else if (op == 0xd2)
7619 {
7620 unsigned char buf[9];
7621 unsigned int i, len;
7622 unsigned long offset;
a734115a 7623
fa197c1c
PB		 7624 for (i = 0; i < sizeof (buf); i++)
7625 {
7626 GET_OP (buf[i]);
7627 if ((buf[i] & 0x80) == 0)
7628 break;
7629 }
0eff7165
NC		 7630 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7631 if (i == sizeof (buf))
7632 {
7633 printf ("<corrupt sp adjust>\n");
7634 warn (_("Corrupt stack pointer adjustment detected\n"));
7635 return;
7636 }
7637
f6f0e17b 7638 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7639 assert (len == i + 1);
7640 offset = offset * 8 + 0x408;
7641 printf (_("sp = sp + %ld"), offset);
7642 }
7643 else if ((op & 0xf0) == 0xe0)
7644 {
7645 if ((op & 0x0f) == 7)
7646 printf (" RETURN");
7647 else
7648 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7649 }
7650 else
7651 {
7652 printf (_(" [unsupported opcode]"));
7653 }
7654 putchar ('\n');
7655 }
7656}
7657
7658static bfd_vma
a734115a 7659arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7660{
7661 bfd_vma offset;
7662
7663 offset = word & 0x7fffffff;
7664 if (offset & 0x40000000)
7665 offset |= ~ (bfd_vma) 0x7fffffff;
7666
7667 if (elf_header.e_machine == EM_TI_C6000)
7668 offset <<= 1;
7669
7670 return offset + where;
7671}
7672
7673static void
1b31d05e
NC		 7674decode_arm_unwind (struct arm_unw_aux_info * aux,
7675 unsigned int word,
7676 unsigned int remaining,
7677 bfd_vma data_offset,
7678 Elf_Internal_Shdr * data_sec,
7679 struct arm_section * data_arm_sec)
fa197c1c
PB		 7680{
7681 int per_index;
7682 unsigned int more_words = 0;
37e14bc3 7683 struct absaddr addr;
1b31d05e 7684 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7685
7686 if (remaining == 0)
7687 {
1b31d05e
NC		 7688 /* Fetch the first word.
7689 Note - when decoding an object file the address extracted
7690 here will always be 0. So we also pass in the sym_name
7691 parameter so that we can find the symbol associated with
7692 the personality routine. */
7693 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7694 & word, & addr, & sym_name))
fa197c1c 7695 return;
1b31d05e 7696
fa197c1c
PB		 7697 remaining = 4;
7698 }
7699
7700 if ((word & 0x80000000) == 0)
7701 {
7702 /* Expand prel31 for personality routine. */
7703 bfd_vma fn;
7704 const char *procname;
7705
a734115a 7706 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7707 printf (_(" Personality routine: "));
1b31d05e
NC		 7708 if (fn == 0
7709 && addr.section == SHN_UNDEF && addr.offset == 0
7710 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7711 {
7712 procname = aux->strtab + sym_name;
7713 print_vma (fn, PREFIX_HEX);
7714 if (procname)
7715 {
7716 fputs (" <", stdout);
7717 fputs (procname, stdout);
7718 fputc ('>', stdout);
7719 }
7720 }
7721 else
7722 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7723 fputc ('\n', stdout);
7724
7725 /* The GCC personality routines use the standard compact
7726 encoding, starting with one byte giving the number of
7727 words. */
7728 if (procname != NULL
7729 && (const_strneq (procname, "__gcc_personality_v0")
7730 || const_strneq (procname, "__gxx_personality_v0")
7731 || const_strneq (procname, "__gcj_personality_v0")
7732 || const_strneq (procname, "__gnu_objc_personality_v0")))
7733 {
7734 remaining = 0;
7735 more_words = 1;
7736 ADVANCE;
7737 if (!remaining)
7738 {
7739 printf (_(" [Truncated data]\n"));
7740 return;
7741 }
7742 more_words = word >> 24;
7743 word <<= 8;
7744 remaining--;
7745 per_index = -1;
7746 }
7747 else
7748 return;
7749 }
7750 else
7751 {
1b31d05e 7752 /* ARM EHABI Section 6.3:
0b4362b0 7753
1b31d05e 7754 An exception-handling table entry for the compact model looks like:
0b4362b0 7755
1b31d05e
NC		 7756 31 30-28 27-24 23-0
7757 -- ----- ----- ----
7758 1 0 index Data for personalityRoutine[index] */
7759
7760 if (elf_header.e_machine == EM_ARM
7761 && (word & 0x70000000))
83c257ca 7762 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7763
fa197c1c 7764 per_index = (word >> 24) & 0x7f;
1b31d05e 7765 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7766 if (per_index == 0)
7767 {
7768 more_words = 0;
7769 word <<= 8;
7770 remaining--;
7771 }
7772 else if (per_index < 3)
7773 {
7774 more_words = (word >> 16) & 0xff;
7775 word <<= 16;
7776 remaining -= 2;
7777 }
7778 }
7779
7780 switch (elf_header.e_machine)
7781 {
7782 case EM_ARM:
7783 if (per_index < 3)
7784 {
7785 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7786 data_offset, data_sec, data_arm_sec);
7787 }
7788 else
1b31d05e
NC		 7789 {
7790 warn (_("Unknown ARM compact model index encountered\n"));
7791 printf (_(" [reserved]\n"));
7792 }
fa197c1c
PB		 7793 break;
7794
7795 case EM_TI_C6000:
7796 if (per_index < 3)
7797 {
7798 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7799 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7800 }
7801 else if (per_index < 5)
7802 {
7803 if (((word >> 17) & 0x7f) == 0x7f)
7804 printf (_(" Restore stack from frame pointer\n"));
7805 else
7806 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7807 printf (_(" Registers restored: "));
7808 if (per_index == 4)
7809 printf (" (compact) ");
7810 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7811 putchar ('\n');
7812 printf (_(" Return register: %s\n"),
7813 tic6x_unwind_regnames[word & 0xf]);
7814 }
7815 else
1b31d05e 7816 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7817 break;
7818
7819 default:
74e1a04b 7820 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 7821 elf_header.e_machine);
fa197c1c 7822 }
0b6ae522
DJ		 7823
7824 /* Decode the descriptors. Not implemented. */
7825}
7826
7827static void
7828dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7829{
7830 struct arm_section exidx_arm_sec, extab_arm_sec;
7831 unsigned int i, exidx_len;
7832
7833 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7834 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7835 exidx_len = exidx_sec->sh_size / 8;
7836
7837 for (i = 0; i < exidx_len; i++)
7838 {
7839 unsigned int exidx_fn, exidx_entry;
7840 struct absaddr fn_addr, entry_addr;
7841 bfd_vma fn;
7842
7843 fputc ('\n', stdout);
7844
1b31d05e
NC		 7845 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7846 8 * i, & exidx_fn, & fn_addr, NULL)
7847 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7848 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7849 {
1b31d05e
NC		 7850 arm_free_section (& exidx_arm_sec);
7851 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7852 return;
7853 }
7854
83c257ca
NC		 7855 /* ARM EHABI, Section 5:
7856 An index table entry consists of 2 words.
7857 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7858 if (exidx_fn & 0x80000000)
7859 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7860
a734115a 7861 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7862
a734115a 7863 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7864 fputs (": ", stdout);
7865
7866 if (exidx_entry == 1)
7867 {
7868 print_vma (exidx_entry, PREFIX_HEX);
7869 fputs (" [cantunwind]\n", stdout);
7870 }
7871 else if (exidx_entry & 0x80000000)
7872 {
7873 print_vma (exidx_entry, PREFIX_HEX);
7874 fputc ('\n', stdout);
7875 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7876 }
7877 else
7878 {
8f73510c 7879 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7880 Elf_Internal_Shdr *table_sec;
7881
7882 fputs ("@", stdout);
a734115a 7883 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7884 print_vma (table, PREFIX_HEX);
7885 printf ("\n");
7886
7887 /* Locate the matching .ARM.extab. */
7888 if (entry_addr.section != SHN_UNDEF
7889 && entry_addr.section < elf_header.e_shnum)
7890 {
7891 table_sec = section_headers + entry_addr.section;
7892 table_offset = entry_addr.offset;
7893 }
7894 else
7895 {
7896 table_sec = find_section_by_address (table);
7897 if (table_sec != NULL)
7898 table_offset = table - table_sec->sh_addr;
7899 }
7900 if (table_sec == NULL)
7901 {
7902 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7903 (unsigned long) table);
7904 continue;
7905 }
7906 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7907 &extab_arm_sec);
7908 }
7909 }
7910
7911 printf ("\n");
7912
7913 arm_free_section (&exidx_arm_sec);
7914 arm_free_section (&extab_arm_sec);
7915}
7916
fa197c1c 7917/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7918
7919static void
0b6ae522
DJ		 7920arm_process_unwind (FILE *file)
7921{
7922 struct arm_unw_aux_info aux;
7923 Elf_Internal_Shdr *unwsec = NULL;
7924 Elf_Internal_Shdr *strsec;
7925 Elf_Internal_Shdr *sec;
7926 unsigned long i;
fa197c1c 7927 unsigned int sec_type;
0b6ae522 7928
fa197c1c
PB		 7929 switch (elf_header.e_machine)
7930 {
7931 case EM_ARM:
7932 sec_type = SHT_ARM_EXIDX;
7933 break;
7934
7935 case EM_TI_C6000:
7936 sec_type = SHT_C6000_UNWIND;
7937 break;
7938
0b4362b0 7939 default:
74e1a04b 7940 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 7941 elf_header.e_machine);
7942 return;
fa197c1c
PB		 7943 }
7944
0b6ae522 7945 if (string_table == NULL)
1b31d05e
NC		 7946 return;
7947
7948 memset (& aux, 0, sizeof (aux));
7949 aux.file = file;
0b6ae522
DJ		 7950
7951 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7952 {
7953 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7954 {
ba5cdace 7955 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7956
7957 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 7958
7959 /* PR binutils/17531 file: 011-12666-0.004. */
7960 if (aux.strtab != NULL)
7961 {
4082ef84 7962 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 7963 free (aux.strtab);
7964 }
0b6ae522
DJ		 7965 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7966 1, strsec->sh_size, _("string table"));
7967 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7968 }
fa197c1c 7969 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7970 unwsec = sec;
7971 }
7972
1b31d05e 7973 if (unwsec == NULL)
0b6ae522 7974 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7975 else
7976 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7977 {
7978 if (sec->sh_type == sec_type)
7979 {
7980 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 7981 printable_section_name (sec),
1b31d05e
NC		 7982 (unsigned long) sec->sh_offset,
7983 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7984
1b31d05e
NC		 7985 dump_arm_unwind (&aux, sec);
7986 }
7987 }
0b6ae522
DJ		 7988
7989 if (aux.symtab)
7990 free (aux.symtab);
7991 if (aux.strtab)
7992 free ((char *) aux.strtab);
0b6ae522
DJ		 7993}
7994
1b31d05e 7995static void
2cf0635d 7996process_unwind (FILE * file)
57346661 7997{
2cf0635d
NC		 7998 struct unwind_handler
7999 {
57346661 8000 int machtype;
1b31d05e 8001 void (* handler)(FILE *);
2cf0635d
NC		 8002 } handlers[] =
8003 {
0b6ae522 8004 { EM_ARM, arm_process_unwind },
57346661
AM		 8005 { EM_IA_64, ia64_process_unwind },
8006 { EM_PARISC, hppa_process_unwind },
fa197c1c 8007 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8008 { 0, 0 }
8009 };
8010 int i;
8011
8012 if (!do_unwind)
1b31d05e 8013 return;
57346661
AM		 8014
8015 for (i = 0; handlers[i].handler != NULL; i++)
8016 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8017 {
8018 handlers[i].handler (file);
8019 return;
8020 }
57346661 8021
1b31d05e
NC		 8022 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8023 get_machine_name (elf_header.e_machine));
57346661
AM		 8024}
8025
252b5132 8026static void
2cf0635d 8027dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8028{
8029 switch (entry->d_tag)
8030 {
8031 case DT_MIPS_FLAGS:
8032 if (entry->d_un.d_val == 0)
4b68bca3 8033 printf (_("NONE"));
252b5132
RH		 8034 else
8035 {
8036 static const char * opts[] =
8037 {
8038 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8039 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8040 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8041 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8042 "RLD_ORDER_SAFE"
8043 };
8044 unsigned int cnt;
8045 int first = 1;
2b692964 8046
60bca95a 8047 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8048 if (entry->d_un.d_val & (1 << cnt))
8049 {
8050 printf ("%s%s", first ? "" : " ", opts[cnt]);
8051 first = 0;
8052 }
252b5132
RH		 8053 }
8054 break;
103f02d3 8055
252b5132 8056 case DT_MIPS_IVERSION:
d79b3d50 8057 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8058 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8059 else
76ca31c0
NC		 8060 {
8061 char buf[40];
8062 sprintf_vma (buf, entry->d_un.d_ptr);
8063 /* Note: coded this way so that there is a single string for translation. */
8064 printf (_("<corrupt: %s>"), buf);
8065 }
252b5132 8066 break;
103f02d3 8067
252b5132
RH		 8068 case DT_MIPS_TIME_STAMP:
8069 {
8070 char timebuf[20];
2cf0635d 8071 struct tm * tmp;
50da7a9c 8072
91d6fa6a
NC		 8073 time_t atime = entry->d_un.d_val;
8074 tmp = gmtime (&atime);
e9e44622
JJ		 8075 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8076 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8077 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8078 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8079 }
8080 break;
103f02d3 8081
252b5132
RH		 8082 case DT_MIPS_RLD_VERSION:
8083 case DT_MIPS_LOCAL_GOTNO:
8084 case DT_MIPS_CONFLICTNO:
8085 case DT_MIPS_LIBLISTNO:
8086 case DT_MIPS_SYMTABNO:
8087 case DT_MIPS_UNREFEXTNO:
8088 case DT_MIPS_HIPAGENO:
8089 case DT_MIPS_DELTA_CLASS_NO:
8090 case DT_MIPS_DELTA_INSTANCE_NO:
8091 case DT_MIPS_DELTA_RELOC_NO:
8092 case DT_MIPS_DELTA_SYM_NO:
8093 case DT_MIPS_DELTA_CLASSSYM_NO:
8094 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8095 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8096 break;
103f02d3
UD		 8097
8098 default:
4b68bca3 8099 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8100 }
4b68bca3 8101 putchar ('\n');
103f02d3
UD		 8102}
8103
103f02d3 8104static void
2cf0635d 8105dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8106{
8107 switch (entry->d_tag)
8108 {
8109 case DT_HP_DLD_FLAGS:
8110 {
8111 static struct
8112 {
8113 long int bit;
2cf0635d 8114 const char * str;
5e220199
NC		 8115 }
8116 flags[] =
8117 {
8118 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8119 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8120 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8121 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8122 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8123 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8124 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8125 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8126 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8127 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8128 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8129 { DT_HP_GST, "HP_GST" },
8130 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8131 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8132 { DT_HP_NODELETE, "HP_NODELETE" },
8133 { DT_HP_GROUP, "HP_GROUP" },
8134 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8135 };
103f02d3 8136 int first = 1;
5e220199 8137 size_t cnt;
f7a99963 8138 bfd_vma val = entry->d_un.d_val;
103f02d3 8139
60bca95a 8140 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8141 if (val & flags[cnt].bit)
30800947
NC		 8142 {
8143 if (! first)
8144 putchar (' ');
8145 fputs (flags[cnt].str, stdout);
8146 first = 0;
8147 val ^= flags[cnt].bit;
8148 }
76da6bbe 8149
103f02d3 8150 if (val != 0 || first)
f7a99963
NC		 8151 {
8152 if (! first)
8153 putchar (' ');
8154 print_vma (val, HEX);
8155 }
103f02d3
UD		 8156 }
8157 break;
76da6bbe 8158
252b5132 8159 default:
f7a99963
NC		 8160 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8161 break;
252b5132 8162 }
35b1837e 8163 putchar ('\n');
252b5132
RH		 8164}
8165
28f997cf
TG		 8166#ifdef BFD64
8167
8168/* VMS vs Unix time offset and factor. */
8169
8170#define VMS_EPOCH_OFFSET 35067168000000000LL
8171#define VMS_GRANULARITY_FACTOR 10000000
8172
8173/* Display a VMS time in a human readable format. */
8174
8175static void
8176print_vms_time (bfd_int64_t vmstime)
8177{
8178 struct tm *tm;
8179 time_t unxtime;
8180
8181 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8182 tm = gmtime (&unxtime);
8183 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8184 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8185 tm->tm_hour, tm->tm_min, tm->tm_sec);
8186}
8187#endif /* BFD64 */
8188
ecc51f48 8189static void
2cf0635d 8190dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8191{
8192 switch (entry->d_tag)
8193 {
0de14b54 8194 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8195 /* First 3 slots reserved. */
ecc51f48
NC		 8196 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8197 printf (" -- ");
8198 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8199 break;
8200
28f997cf
TG		 8201 case DT_IA_64_VMS_LINKTIME:
8202#ifdef BFD64
8203 print_vms_time (entry->d_un.d_val);
8204#endif
8205 break;
8206
8207 case DT_IA_64_VMS_LNKFLAGS:
8208 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8209 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8210 printf (" CALL_DEBUG");
8211 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8212 printf (" NOP0BUFS");
8213 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8214 printf (" P0IMAGE");
8215 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8216 printf (" MKTHREADS");
8217 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8218 printf (" UPCALLS");
8219 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8220 printf (" IMGSTA");
8221 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8222 printf (" INITIALIZE");
8223 if (entry->d_un.d_val & VMS_LF_MAIN)
8224 printf (" MAIN");
8225 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8226 printf (" EXE_INIT");
8227 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8228 printf (" TBK_IN_IMG");
8229 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8230 printf (" DBG_IN_IMG");
8231 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8232 printf (" TBK_IN_DSF");
8233 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8234 printf (" DBG_IN_DSF");
8235 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8236 printf (" SIGNATURES");
8237 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8238 printf (" REL_SEG_OFF");
8239 break;
8240
bdf4d63a
JJ		 8241 default:
8242 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8243 break;
ecc51f48 8244 }
bdf4d63a 8245 putchar ('\n');
ecc51f48
NC		 8246}
8247
252b5132 8248static int
2cf0635d 8249get_32bit_dynamic_section (FILE * file)
252b5132 8250{
2cf0635d
NC		 8251 Elf32_External_Dyn * edyn;
8252 Elf32_External_Dyn * ext;
8253 Elf_Internal_Dyn * entry;
103f02d3 8254
3f5e193b
NC		 8255 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8256 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8257 if (!edyn)
8258 return 0;
103f02d3 8259
071436c6
NC		 8260 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8261 might not have the luxury of section headers. Look for the DT_NULL
8262 terminator to determine the number of entries. */
ba2685cc 8263 for (ext = edyn, dynamic_nent = 0;
071436c6 8264 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8265 ext++)
8266 {
8267 dynamic_nent++;
8268 if (BYTE_GET (ext->d_tag) == DT_NULL)
8269 break;
8270 }
252b5132 8271
3f5e193b
NC		 8272 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8273 sizeof (* entry));
b2d38a17 8274 if (dynamic_section == NULL)
252b5132 8275 {
8b73c356
NC		 8276 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8277 (unsigned long) dynamic_nent);
9ea033b2
NC		 8278 free (edyn);
8279 return 0;
8280 }
252b5132 8281
fb514b26 8282 for (ext = edyn, entry = dynamic_section;
ba2685cc 8283 entry < dynamic_section + dynamic_nent;
fb514b26 8284 ext++, entry++)
9ea033b2 8285 {
fb514b26
AM		 8286 entry->d_tag = BYTE_GET (ext->d_tag);
8287 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8288 }
8289
9ea033b2
NC		 8290 free (edyn);
8291
8292 return 1;
8293}
8294
8295static int
2cf0635d 8296get_64bit_dynamic_section (FILE * file)
9ea033b2 8297{
2cf0635d
NC		 8298 Elf64_External_Dyn * edyn;
8299 Elf64_External_Dyn * ext;
8300 Elf_Internal_Dyn * entry;
103f02d3 8301
071436c6 8302 /* Read in the data. */
3f5e193b
NC		 8303 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8304 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8305 if (!edyn)
8306 return 0;
103f02d3 8307
071436c6
NC		 8308 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8309 might not have the luxury of section headers. Look for the DT_NULL
8310 terminator to determine the number of entries. */
ba2685cc 8311 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8312 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8313 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8314 ext++)
8315 {
8316 dynamic_nent++;
66543521 8317 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8318 break;
8319 }
252b5132 8320
3f5e193b
NC		 8321 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8322 sizeof (* entry));
b2d38a17 8323 if (dynamic_section == NULL)
252b5132 8324 {
8b73c356
NC		 8325 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8326 (unsigned long) dynamic_nent);
252b5132
RH		 8327 free (edyn);
8328 return 0;
8329 }
8330
071436c6 8331 /* Convert from external to internal formats. */
fb514b26 8332 for (ext = edyn, entry = dynamic_section;
ba2685cc 8333 entry < dynamic_section + dynamic_nent;
fb514b26 8334 ext++, entry++)
252b5132 8335 {
66543521
AM		 8336 entry->d_tag = BYTE_GET (ext->d_tag);
8337 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8338 }
8339
8340 free (edyn);
8341
9ea033b2
NC		 8342 return 1;
8343}
8344
e9e44622
JJ		 8345static void
8346print_dynamic_flags (bfd_vma flags)
d1133906 8347{
e9e44622 8348 int first = 1;
13ae64f3 8349
d1133906
NC		 8350 while (flags)
8351 {
8352 bfd_vma flag;
8353
8354 flag = flags & - flags;
8355 flags &= ~ flag;
8356
e9e44622
JJ		 8357 if (first)
8358 first = 0;
8359 else
8360 putc (' ', stdout);
13ae64f3 8361
d1133906
NC		 8362 switch (flag)
8363 {
e9e44622
JJ		 8364 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8365 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8366 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8367 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8368 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8369 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8370 }
8371 }
e9e44622 8372 puts ("");
d1133906
NC		 8373}
8374
b2d38a17
NC		 8375/* Parse and display the contents of the dynamic section. */
8376
9ea033b2 8377static int
2cf0635d 8378process_dynamic_section (FILE * file)
9ea033b2 8379{
2cf0635d 8380 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8381
8382 if (dynamic_size == 0)
8383 {
8384 if (do_dynamic)
b2d38a17 8385 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8386
8387 return 1;
8388 }
8389
8390 if (is_32bit_elf)
8391 {
b2d38a17 8392 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8393 return 0;
8394 }
b2d38a17 8395 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8396 return 0;
8397
252b5132
RH		 8398 /* Find the appropriate symbol table. */
8399 if (dynamic_symbols == NULL)
8400 {
86dba8ee
AM		 8401 for (entry = dynamic_section;
8402 entry < dynamic_section + dynamic_nent;
8403 ++entry)
252b5132 8404 {
c8286bd1 8405 Elf_Internal_Shdr section;
252b5132
RH		 8406
8407 if (entry->d_tag != DT_SYMTAB)
8408 continue;
8409
8410 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8411
8412 /* Since we do not know how big the symbol table is,
8413 we default to reading in the entire file (!) and
8414 processing that. This is overkill, I know, but it
e3c8793a 8415 should work. */
d93f0186 8416 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8417
fb52b2f4
NC		 8418 if (archive_file_offset != 0)
8419 section.sh_size = archive_file_size - section.sh_offset;
8420 else
8421 {
8422 if (fseek (file, 0, SEEK_END))
591a748a 8423 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8424
8425 section.sh_size = ftell (file) - section.sh_offset;
8426 }
252b5132 8427
9ea033b2 8428 if (is_32bit_elf)
9ad5cbcf 8429 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8430 else
9ad5cbcf 8431 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8432 section.sh_name = string_table_length;
252b5132 8433
ba5cdace 8434 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8435 if (num_dynamic_syms < 1)
252b5132
RH		 8436 {
8437 error (_("Unable to determine the number of symbols to load\n"));
8438 continue;
8439 }
252b5132
RH		 8440 }
8441 }
8442
8443 /* Similarly find a string table. */
8444 if (dynamic_strings == NULL)
8445 {
86dba8ee
AM		 8446 for (entry = dynamic_section;
8447 entry < dynamic_section + dynamic_nent;
8448 ++entry)
252b5132
RH		 8449 {
8450 unsigned long offset;
b34976b6 8451 long str_tab_len;
252b5132
RH		 8452
8453 if (entry->d_tag != DT_STRTAB)
8454 continue;
8455
8456 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8457
8458 /* Since we do not know how big the string table is,
8459 we default to reading in the entire file (!) and
8460 processing that. This is overkill, I know, but it
e3c8793a 8461 should work. */
252b5132 8462
d93f0186 8463 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8464
8465 if (archive_file_offset != 0)
8466 str_tab_len = archive_file_size - offset;
8467 else
8468 {
8469 if (fseek (file, 0, SEEK_END))
8470 error (_("Unable to seek to end of file\n"));
8471 str_tab_len = ftell (file) - offset;
8472 }
252b5132
RH		 8473
8474 if (str_tab_len < 1)
8475 {
8476 error
8477 (_("Unable to determine the length of the dynamic string table\n"));
8478 continue;
8479 }
8480
3f5e193b
NC		 8481 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8482 str_tab_len,
8483 _("dynamic string table"));
59245841 8484 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8485 break;
8486 }
8487 }
8488
8489 /* And find the syminfo section if available. */
8490 if (dynamic_syminfo == NULL)
8491 {
3e8bba36 8492 unsigned long syminsz = 0;
252b5132 8493
86dba8ee
AM		 8494 for (entry = dynamic_section;
8495 entry < dynamic_section + dynamic_nent;
8496 ++entry)
252b5132
RH		 8497 {
8498 if (entry->d_tag == DT_SYMINENT)
8499 {
8500 /* Note: these braces are necessary to avoid a syntax
8501 error from the SunOS4 C compiler. */
049b0c3a
NC		 8502 /* PR binutils/17531: A corrupt file can trigger this test.
8503 So do not use an assert, instead generate an error message. */
8504 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8505 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8506 (int) entry->d_un.d_val);
252b5132
RH		 8507 }
8508 else if (entry->d_tag == DT_SYMINSZ)
8509 syminsz = entry->d_un.d_val;
8510 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8511 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8512 syminsz);
252b5132
RH		 8513 }
8514
8515 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8516 {
2cf0635d
NC		 8517 Elf_External_Syminfo * extsyminfo;
8518 Elf_External_Syminfo * extsym;
8519 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8520
8521 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8522 extsyminfo = (Elf_External_Syminfo *)
8523 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8524 _("symbol information"));
a6e9f9df
AM		 8525 if (!extsyminfo)
8526 return 0;
252b5132 8527
3f5e193b 8528 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8529 if (dynamic_syminfo == NULL)
8530 {
8b73c356
NC		 8531 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8532 (unsigned long) syminsz);
252b5132
RH		 8533 return 0;
8534 }
8535
8536 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8537 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8538 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8539 ++syminfo, ++extsym)
252b5132 8540 {
86dba8ee
AM		 8541 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8542 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8543 }
8544
8545 free (extsyminfo);
8546 }
8547 }
8548
8549 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8550 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8551 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8552 if (do_dynamic)
8553 printf (_(" Tag Type Name/Value\n"));
8554
86dba8ee
AM		 8555 for (entry = dynamic_section;
8556 entry < dynamic_section + dynamic_nent;
8557 entry++)
252b5132
RH		 8558 {
8559 if (do_dynamic)
f7a99963 8560 {
2cf0635d 8561 const char * dtype;
e699b9ff 8562
f7a99963
NC		 8563 putchar (' ');
8564 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8565 dtype = get_dynamic_type (entry->d_tag);
8566 printf (" (%s)%*s", dtype,
8567 ((is_32bit_elf ? 27 : 19)
8568 - (int) strlen (dtype)),
f7a99963
NC		 8569 " ");
8570 }
252b5132
RH		 8571
8572 switch (entry->d_tag)
8573 {
d1133906
NC		 8574 case DT_FLAGS:
8575 if (do_dynamic)
e9e44622 8576 print_dynamic_flags (entry->d_un.d_val);
d1133906 8577 break;
76da6bbe 8578
252b5132
RH		 8579 case DT_AUXILIARY:
8580 case DT_FILTER:
019148e4
L		 8581 case DT_CONFIG:
8582 case DT_DEPAUDIT:
8583 case DT_AUDIT:
252b5132
RH		 8584 if (do_dynamic)
8585 {
019148e4 8586 switch (entry->d_tag)
b34976b6 8587 {
019148e4
L		 8588 case DT_AUXILIARY:
8589 printf (_("Auxiliary library"));
8590 break;
8591
8592 case DT_FILTER:
8593 printf (_("Filter library"));
8594 break;
8595
b34976b6 8596 case DT_CONFIG:
019148e4
L		 8597 printf (_("Configuration file"));
8598 break;
8599
8600 case DT_DEPAUDIT:
8601 printf (_("Dependency audit library"));
8602 break;
8603
8604 case DT_AUDIT:
8605 printf (_("Audit library"));
8606 break;
8607 }
252b5132 8608
d79b3d50
NC		 8609 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8610 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8611 else
f7a99963
NC		 8612 {
8613 printf (": ");
8614 print_vma (entry->d_un.d_val, PREFIX_HEX);
8615 putchar ('\n');
8616 }
252b5132
RH		 8617 }
8618 break;
8619
dcefbbbd 8620 case DT_FEATURE:
252b5132
RH		 8621 if (do_dynamic)
8622 {
8623 printf (_("Flags:"));
86f55779 8624
252b5132
RH		 8625 if (entry->d_un.d_val == 0)
8626 printf (_(" None\n"));
8627 else
8628 {
8629 unsigned long int val = entry->d_un.d_val;
86f55779 8630
252b5132
RH		 8631 if (val & DTF_1_PARINIT)
8632 {
8633 printf (" PARINIT");
8634 val ^= DTF_1_PARINIT;
8635 }
dcefbbbd
L		 8636 if (val & DTF_1_CONFEXP)
8637 {
8638 printf (" CONFEXP");
8639 val ^= DTF_1_CONFEXP;
8640 }
252b5132
RH		 8641 if (val != 0)
8642 printf (" %lx", val);
8643 puts ("");
8644 }
8645 }
8646 break;
8647
8648 case DT_POSFLAG_1:
8649 if (do_dynamic)
8650 {
8651 printf (_("Flags:"));
86f55779 8652
252b5132
RH		 8653 if (entry->d_un.d_val == 0)
8654 printf (_(" None\n"));
8655 else
8656 {
8657 unsigned long int val = entry->d_un.d_val;
86f55779 8658
252b5132
RH		 8659 if (val & DF_P1_LAZYLOAD)
8660 {
8661 printf (" LAZYLOAD");
8662 val ^= DF_P1_LAZYLOAD;
8663 }
8664 if (val & DF_P1_GROUPPERM)
8665 {
8666 printf (" GROUPPERM");
8667 val ^= DF_P1_GROUPPERM;
8668 }
8669 if (val != 0)
8670 printf (" %lx", val);
8671 puts ("");
8672 }
8673 }
8674 break;
8675
8676 case DT_FLAGS_1:
8677 if (do_dynamic)
8678 {
8679 printf (_("Flags:"));
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 & DF_1_NOW)
8687 {
8688 printf (" NOW");
8689 val ^= DF_1_NOW;
8690 }
8691 if (val & DF_1_GLOBAL)
8692 {
8693 printf (" GLOBAL");
8694 val ^= DF_1_GLOBAL;
8695 }
8696 if (val & DF_1_GROUP)
8697 {
8698 printf (" GROUP");
8699 val ^= DF_1_GROUP;
8700 }
8701 if (val & DF_1_NODELETE)
8702 {
8703 printf (" NODELETE");
8704 val ^= DF_1_NODELETE;
8705 }
8706 if (val & DF_1_LOADFLTR)
8707 {
8708 printf (" LOADFLTR");
8709 val ^= DF_1_LOADFLTR;
8710 }
8711 if (val & DF_1_INITFIRST)
8712 {
8713 printf (" INITFIRST");
8714 val ^= DF_1_INITFIRST;
8715 }
8716 if (val & DF_1_NOOPEN)
8717 {
8718 printf (" NOOPEN");
8719 val ^= DF_1_NOOPEN;
8720 }
8721 if (val & DF_1_ORIGIN)
8722 {
8723 printf (" ORIGIN");
8724 val ^= DF_1_ORIGIN;
8725 }
8726 if (val & DF_1_DIRECT)
8727 {
8728 printf (" DIRECT");
8729 val ^= DF_1_DIRECT;
8730 }
8731 if (val & DF_1_TRANS)
8732 {
8733 printf (" TRANS");
8734 val ^= DF_1_TRANS;
8735 }
8736 if (val & DF_1_INTERPOSE)
8737 {
8738 printf (" INTERPOSE");
8739 val ^= DF_1_INTERPOSE;
8740 }
f7db6139 8741 if (val & DF_1_NODEFLIB)
dcefbbbd 8742 {
f7db6139
L		 8743 printf (" NODEFLIB");
8744 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8745 }
8746 if (val & DF_1_NODUMP)
8747 {
8748 printf (" NODUMP");
8749 val ^= DF_1_NODUMP;
8750 }
34b60028 8751 if (val & DF_1_CONFALT)
dcefbbbd 8752 {
34b60028
L		 8753 printf (" CONFALT");
8754 val ^= DF_1_CONFALT;
8755 }
8756 if (val & DF_1_ENDFILTEE)
8757 {
8758 printf (" ENDFILTEE");
8759 val ^= DF_1_ENDFILTEE;
8760 }
8761 if (val & DF_1_DISPRELDNE)
8762 {
8763 printf (" DISPRELDNE");
8764 val ^= DF_1_DISPRELDNE;
8765 }
8766 if (val & DF_1_DISPRELPND)
8767 {
8768 printf (" DISPRELPND");
8769 val ^= DF_1_DISPRELPND;
8770 }
8771 if (val & DF_1_NODIRECT)
8772 {
8773 printf (" NODIRECT");
8774 val ^= DF_1_NODIRECT;
8775 }
8776 if (val & DF_1_IGNMULDEF)
8777 {
8778 printf (" IGNMULDEF");
8779 val ^= DF_1_IGNMULDEF;
8780 }
8781 if (val & DF_1_NOKSYMS)
8782 {
8783 printf (" NOKSYMS");
8784 val ^= DF_1_NOKSYMS;
8785 }
8786 if (val & DF_1_NOHDR)
8787 {
8788 printf (" NOHDR");
8789 val ^= DF_1_NOHDR;
8790 }
8791 if (val & DF_1_EDITED)
8792 {
8793 printf (" EDITED");
8794 val ^= DF_1_EDITED;
8795 }
8796 if (val & DF_1_NORELOC)
8797 {
8798 printf (" NORELOC");
8799 val ^= DF_1_NORELOC;
8800 }
8801 if (val & DF_1_SYMINTPOSE)
8802 {
8803 printf (" SYMINTPOSE");
8804 val ^= DF_1_SYMINTPOSE;
8805 }
8806 if (val & DF_1_GLOBAUDIT)
8807 {
8808 printf (" GLOBAUDIT");
8809 val ^= DF_1_GLOBAUDIT;
8810 }
8811 if (val & DF_1_SINGLETON)
8812 {
8813 printf (" SINGLETON");
8814 val ^= DF_1_SINGLETON;
dcefbbbd 8815 }
252b5132
RH		 8816 if (val != 0)
8817 printf (" %lx", val);
8818 puts ("");
8819 }
8820 }
8821 break;
8822
8823 case DT_PLTREL:
566b0d53 8824 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8825 if (do_dynamic)
8826 puts (get_dynamic_type (entry->d_un.d_val));
8827 break;
8828
8829 case DT_NULL :
8830 case DT_NEEDED :
8831 case DT_PLTGOT :
8832 case DT_HASH :
8833 case DT_STRTAB :
8834 case DT_SYMTAB :
8835 case DT_RELA :
8836 case DT_INIT :
8837 case DT_FINI :
8838 case DT_SONAME :
8839 case DT_RPATH :
8840 case DT_SYMBOLIC:
8841 case DT_REL :
8842 case DT_DEBUG :
8843 case DT_TEXTREL :
8844 case DT_JMPREL :
019148e4 8845 case DT_RUNPATH :
252b5132
RH		 8846 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8847
8848 if (do_dynamic)
8849 {
2cf0635d 8850 char * name;
252b5132 8851
d79b3d50
NC		 8852 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8853 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8854 else
d79b3d50 8855 name = NULL;
252b5132
RH		 8856
8857 if (name)
8858 {
8859 switch (entry->d_tag)
8860 {
8861 case DT_NEEDED:
8862 printf (_("Shared library: [%s]"), name);
8863
18bd398b 8864 if (streq (name, program_interpreter))
f7a99963 8865 printf (_(" program interpreter"));
252b5132
RH		 8866 break;
8867
8868 case DT_SONAME:
f7a99963 8869 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8870 break;
8871
8872 case DT_RPATH:
f7a99963 8873 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8874 break;
8875
019148e4
L		 8876 case DT_RUNPATH:
8877 printf (_("Library runpath: [%s]"), name);
8878 break;
8879
252b5132 8880 default:
f7a99963
NC		 8881 print_vma (entry->d_un.d_val, PREFIX_HEX);
8882 break;
252b5132
RH		 8883 }
8884 }
8885 else
f7a99963
NC		 8886 print_vma (entry->d_un.d_val, PREFIX_HEX);
8887
8888 putchar ('\n');
252b5132
RH		 8889 }
8890 break;
8891
8892 case DT_PLTRELSZ:
8893 case DT_RELASZ :
8894 case DT_STRSZ :
8895 case DT_RELSZ :
8896 case DT_RELAENT :
8897 case DT_SYMENT :
8898 case DT_RELENT :
566b0d53 8899 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8900 case DT_PLTPADSZ:
8901 case DT_MOVEENT :
8902 case DT_MOVESZ :
8903 case DT_INIT_ARRAYSZ:
8904 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8905 case DT_GNU_CONFLICTSZ:
8906 case DT_GNU_LIBLISTSZ:
252b5132 8907 if (do_dynamic)
f7a99963
NC		 8908 {
8909 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8910 printf (_(" (bytes)\n"));
f7a99963 8911 }
252b5132
RH		 8912 break;
8913
8914 case DT_VERDEFNUM:
8915 case DT_VERNEEDNUM:
8916 case DT_RELACOUNT:
8917 case DT_RELCOUNT:
8918 if (do_dynamic)
f7a99963
NC		 8919 {
8920 print_vma (entry->d_un.d_val, UNSIGNED);
8921 putchar ('\n');
8922 }
252b5132
RH		 8923 break;
8924
8925 case DT_SYMINSZ:
8926 case DT_SYMINENT:
8927 case DT_SYMINFO:
8928 case DT_USED:
8929 case DT_INIT_ARRAY:
8930 case DT_FINI_ARRAY:
8931 if (do_dynamic)
8932 {
d79b3d50
NC		 8933 if (entry->d_tag == DT_USED
8934 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8935 {
2cf0635d 8936 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8937
b34976b6 8938 if (*name)
252b5132
RH		 8939 {
8940 printf (_("Not needed object: [%s]\n"), name);
8941 break;
8942 }
8943 }
103f02d3 8944
f7a99963
NC		 8945 print_vma (entry->d_un.d_val, PREFIX_HEX);
8946 putchar ('\n');
252b5132
RH		 8947 }
8948 break;
8949
8950 case DT_BIND_NOW:
8951 /* The value of this entry is ignored. */
35b1837e
AM		 8952 if (do_dynamic)
8953 putchar ('\n');
252b5132 8954 break;
103f02d3 8955
047b2264
JJ		 8956 case DT_GNU_PRELINKED:
8957 if (do_dynamic)
8958 {
2cf0635d 8959 struct tm * tmp;
91d6fa6a 8960 time_t atime = entry->d_un.d_val;
047b2264 8961
91d6fa6a 8962 tmp = gmtime (&atime);
071436c6
NC		 8963 /* PR 17533 file: 041-1244816-0.004. */
8964 if (tmp == NULL)
5a2cbcf4
L		 8965 printf (_("<corrupt time val: %lx"),
8966 (unsigned long) atime);
071436c6
NC		 8967 else
8968 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8969 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8970 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 8971
8972 }
8973 break;
8974
fdc90cb4
JJ		 8975 case DT_GNU_HASH:
8976 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8977 if (do_dynamic)
8978 {
8979 print_vma (entry->d_un.d_val, PREFIX_HEX);
8980 putchar ('\n');
8981 }
8982 break;
8983
252b5132
RH		 8984 default:
8985 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8986 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8987 entry->d_un.d_val;
8988
8989 if (do_dynamic)
8990 {
8991 switch (elf_header.e_machine)
8992 {
8993 case EM_MIPS:
4fe85591 8994 case EM_MIPS_RS3_LE:
b2d38a17 8995 dynamic_section_mips_val (entry);
252b5132 8996 break;
103f02d3 8997 case EM_PARISC:
b2d38a17 8998 dynamic_section_parisc_val (entry);
103f02d3 8999 break;
ecc51f48 9000 case EM_IA_64:
b2d38a17 9001 dynamic_section_ia64_val (entry);
ecc51f48 9002 break;
252b5132 9003 default:
f7a99963
NC		 9004 print_vma (entry->d_un.d_val, PREFIX_HEX);
9005 putchar ('\n');
252b5132
RH		 9006 }
9007 }
9008 break;
9009 }
9010 }
9011
9012 return 1;
9013}
9014
9015static char *
d3ba0551 9016get_ver_flags (unsigned int flags)
252b5132 9017{
b34976b6 9018 static char buff[32];
252b5132
RH		 9019
9020 buff[0] = 0;
9021
9022 if (flags == 0)
9023 return _("none");
9024
9025 if (flags & VER_FLG_BASE)
9026 strcat (buff, "BASE ");
9027
9028 if (flags & VER_FLG_WEAK)
9029 {
9030 if (flags & VER_FLG_BASE)
9031 strcat (buff, "| ");
9032
9033 strcat (buff, "WEAK ");
9034 }
9035
44ec90b9
RO		 9036 if (flags & VER_FLG_INFO)
9037 {
9038 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9039 strcat (buff, "| ");
9040
9041 strcat (buff, "INFO ");
9042 }
9043
9044 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9045 strcat (buff, _("| <unknown>"));
252b5132
RH		 9046
9047 return buff;
9048}
9049
9050/* Display the contents of the version sections. */
98fb390a 9051
252b5132 9052static int
2cf0635d 9053process_version_sections (FILE * file)
252b5132 9054{
2cf0635d 9055 Elf_Internal_Shdr * section;
b34976b6
AM		 9056 unsigned i;
9057 int found = 0;
252b5132
RH		 9058
9059 if (! do_version)
9060 return 1;
9061
9062 for (i = 0, section = section_headers;
9063 i < elf_header.e_shnum;
b34976b6 9064 i++, section++)
252b5132
RH		 9065 {
9066 switch (section->sh_type)
9067 {
9068 case SHT_GNU_verdef:
9069 {
2cf0635d 9070 Elf_External_Verdef * edefs;
b34976b6
AM		 9071 unsigned int idx;
9072 unsigned int cnt;
2cf0635d 9073 char * endbuf;
252b5132
RH		 9074
9075 found = 1;
9076
74e1a04b
NC		 9077 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9078 printable_section_name (section),
9079 section->sh_info);
252b5132
RH		 9080
9081 printf (_(" Addr: 0x"));
9082 printf_vma (section->sh_addr);
74e1a04b 9083 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9084 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9085 printable_section_name_from_index (section->sh_link));
252b5132 9086
3f5e193b
NC		 9087 edefs = (Elf_External_Verdef *)
9088 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9089 _("version definition section"));
a6e9f9df
AM		 9090 if (!edefs)
9091 break;
59245841 9092 endbuf = (char *) edefs + section->sh_size;
252b5132 9093
b34976b6 9094 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9095 {
2cf0635d
NC		 9096 char * vstart;
9097 Elf_External_Verdef * edef;
b34976b6 9098 Elf_Internal_Verdef ent;
2cf0635d 9099 Elf_External_Verdaux * eaux;
b34976b6
AM		 9100 Elf_Internal_Verdaux aux;
9101 int j;
9102 int isum;
103f02d3 9103
7e26601c
NC		 9104 /* Check for very large indicies. */
9105 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9106 break;
9107
252b5132 9108 vstart = ((char *) edefs) + idx;
54806181
AM		 9109 if (vstart + sizeof (*edef) > endbuf)
9110 break;
252b5132
RH		 9111
9112 edef = (Elf_External_Verdef *) vstart;
9113
9114 ent.vd_version = BYTE_GET (edef->vd_version);
9115 ent.vd_flags = BYTE_GET (edef->vd_flags);
9116 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9117 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9118 ent.vd_hash = BYTE_GET (edef->vd_hash);
9119 ent.vd_aux = BYTE_GET (edef->vd_aux);
9120 ent.vd_next = BYTE_GET (edef->vd_next);
9121
9122 printf (_(" %#06x: Rev: %d Flags: %s"),
9123 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9124
9125 printf (_(" Index: %d Cnt: %d "),
9126 ent.vd_ndx, ent.vd_cnt);
9127
dd24e3da 9128 /* Check for overflow. */
7e26601c 9129 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9130 break;
9131
252b5132
RH		 9132 vstart += ent.vd_aux;
9133
9134 eaux = (Elf_External_Verdaux *) vstart;
9135
9136 aux.vda_name = BYTE_GET (eaux->vda_name);
9137 aux.vda_next = BYTE_GET (eaux->vda_next);
9138
d79b3d50
NC		 9139 if (VALID_DYNAMIC_NAME (aux.vda_name))
9140 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9141 else
9142 printf (_("Name index: %ld\n"), aux.vda_name);
9143
9144 isum = idx + ent.vd_aux;
9145
b34976b6 9146 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9147 {
dd24e3da 9148 /* Check for overflow. */
7e26601c 9149 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9150 break;
9151
252b5132
RH		 9152 isum += aux.vda_next;
9153 vstart += aux.vda_next;
9154
9155 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9156 if (vstart + sizeof (*eaux) > endbuf)
9157 break;
252b5132
RH		 9158
9159 aux.vda_name = BYTE_GET (eaux->vda_name);
9160 aux.vda_next = BYTE_GET (eaux->vda_next);
9161
d79b3d50 9162 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9163 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9164 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9165 else
9166 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9167 isum, j, aux.vda_name);
9168 }
dd24e3da 9169
54806181
AM		 9170 if (j < ent.vd_cnt)
9171 printf (_(" Version def aux past end of section\n"));
252b5132 9172
5d921cbd
NC		 9173 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9174 if (idx + ent.vd_next <= idx)
9175 break;
9176
252b5132
RH		 9177 idx += ent.vd_next;
9178 }
dd24e3da 9179
54806181
AM		 9180 if (cnt < section->sh_info)
9181 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9182
9183 free (edefs);
9184 }
9185 break;
103f02d3 9186
252b5132
RH		 9187 case SHT_GNU_verneed:
9188 {
2cf0635d 9189 Elf_External_Verneed * eneed;
b34976b6
AM		 9190 unsigned int idx;
9191 unsigned int cnt;
2cf0635d 9192 char * endbuf;
252b5132
RH		 9193
9194 found = 1;
9195
72de5009 9196 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9197 printable_section_name (section), section->sh_info);
252b5132
RH		 9198
9199 printf (_(" Addr: 0x"));
9200 printf_vma (section->sh_addr);
72de5009 9201 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9202 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9203 printable_section_name_from_index (section->sh_link));
252b5132 9204
3f5e193b
NC		 9205 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9206 section->sh_offset, 1,
9207 section->sh_size,
9cf03b7e 9208 _("Version Needs section"));
a6e9f9df
AM		 9209 if (!eneed)
9210 break;
59245841 9211 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9212
9213 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9214 {
2cf0635d 9215 Elf_External_Verneed * entry;
b34976b6
AM		 9216 Elf_Internal_Verneed ent;
9217 int j;
9218 int isum;
2cf0635d 9219 char * vstart;
252b5132 9220
7e26601c 9221 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9222 break;
9223
252b5132 9224 vstart = ((char *) eneed) + idx;
54806181
AM		 9225 if (vstart + sizeof (*entry) > endbuf)
9226 break;
252b5132
RH		 9227
9228 entry = (Elf_External_Verneed *) vstart;
9229
9230 ent.vn_version = BYTE_GET (entry->vn_version);
9231 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9232 ent.vn_file = BYTE_GET (entry->vn_file);
9233 ent.vn_aux = BYTE_GET (entry->vn_aux);
9234 ent.vn_next = BYTE_GET (entry->vn_next);
9235
9236 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9237
d79b3d50
NC		 9238 if (VALID_DYNAMIC_NAME (ent.vn_file))
9239 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9240 else
9241 printf (_(" File: %lx"), ent.vn_file);
9242
9243 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9244
dd24e3da 9245 /* Check for overflow. */
7e26601c 9246 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9247 break;
9248
252b5132
RH		 9249 vstart += ent.vn_aux;
9250
9251 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9252 {
2cf0635d 9253 Elf_External_Vernaux * eaux;
b34976b6 9254 Elf_Internal_Vernaux aux;
252b5132 9255
54806181
AM		 9256 if (vstart + sizeof (*eaux) > endbuf)
9257 break;
252b5132
RH		 9258 eaux = (Elf_External_Vernaux *) vstart;
9259
9260 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9261 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9262 aux.vna_other = BYTE_GET (eaux->vna_other);
9263 aux.vna_name = BYTE_GET (eaux->vna_name);
9264 aux.vna_next = BYTE_GET (eaux->vna_next);
9265
d79b3d50 9266 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9267 printf (_(" %#06x: Name: %s"),
d79b3d50 9268 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9269 else
ecc2063b 9270 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9271 isum, aux.vna_name);
9272
9273 printf (_(" Flags: %s Version: %d\n"),
9274 get_ver_flags (aux.vna_flags), aux.vna_other);
9275
dd24e3da 9276 /* Check for overflow. */
7e26601c 9277 if (aux.vna_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9278 break;
9279
252b5132
RH		 9280 isum += aux.vna_next;
9281 vstart += aux.vna_next;
9282 }
9cf03b7e 9283
54806181 9284 if (j < ent.vn_cnt)
9cf03b7e 9285 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9286
bcf83b2a 9287 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9288 {
9289 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9290 cnt = section->sh_info;
9291 break;
9292 }
252b5132
RH		 9293 idx += ent.vn_next;
9294 }
9cf03b7e 9295
54806181 9296 if (cnt < section->sh_info)
9cf03b7e 9297 warn (_("Missing Version Needs information\n"));
103f02d3 9298
252b5132
RH		 9299 free (eneed);
9300 }
9301 break;
9302
9303 case SHT_GNU_versym:
9304 {
2cf0635d 9305 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9306 size_t total;
9307 unsigned int cnt;
2cf0635d
NC		 9308 unsigned char * edata;
9309 unsigned short * data;
9310 char * strtab;
9311 Elf_Internal_Sym * symbols;
9312 Elf_Internal_Shdr * string_sec;
ba5cdace 9313 unsigned long num_syms;
d3ba0551 9314 long off;
252b5132 9315
4fbb74a6 9316 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9317 break;
9318
4fbb74a6 9319 link_section = section_headers + section->sh_link;
08d8fa11 9320 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9321
4fbb74a6 9322 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9323 break;
9324
252b5132
RH		 9325 found = 1;
9326
ba5cdace 9327 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9328 if (symbols == NULL)
9329 break;
252b5132 9330
4fbb74a6 9331 string_sec = section_headers + link_section->sh_link;
252b5132 9332
3f5e193b
NC		 9333 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9334 string_sec->sh_size,
9335 _("version string table"));
a6e9f9df 9336 if (!strtab)
0429c154
MS		 9337 {
9338 free (symbols);
9339 break;
9340 }
252b5132 9341
8b73c356
NC		 9342 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9343 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9344
9345 printf (_(" Addr: "));
9346 printf_vma (section->sh_addr);
72de5009 9347 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9348 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9349 printable_section_name (link_section));
252b5132 9350
d3ba0551
AM		 9351 off = offset_from_vma (file,
9352 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9353 total * sizeof (short));
3f5e193b
NC		 9354 edata = (unsigned char *) get_data (NULL, file, off, total,
9355 sizeof (short),
9356 _("version symbol data"));
a6e9f9df
AM		 9357 if (!edata)
9358 {
9359 free (strtab);
0429c154 9360 free (symbols);
a6e9f9df
AM		 9361 break;
9362 }
252b5132 9363
3f5e193b 9364 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9365
9366 for (cnt = total; cnt --;)
b34976b6
AM		 9367 data[cnt] = byte_get (edata + cnt * sizeof (short),
9368 sizeof (short));
252b5132
RH		 9369
9370 free (edata);
9371
9372 for (cnt = 0; cnt < total; cnt += 4)
9373 {
9374 int j, nn;
00d93f34 9375 int check_def, check_need;
2cf0635d 9376 char * name;
252b5132
RH		 9377
9378 printf (" %03x:", cnt);
9379
9380 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9381 switch (data[cnt + j])
252b5132
RH		 9382 {
9383 case 0:
9384 fputs (_(" 0 (*local*) "), stdout);
9385 break;
9386
9387 case 1:
9388 fputs (_(" 1 (*global*) "), stdout);
9389 break;
9390
9391 default:
c244d050
NC		 9392 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9393 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9394
dd24e3da 9395 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9396 array, break to avoid an out-of-bounds read. */
9397 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9398 {
9399 warn (_("invalid index into symbol array\n"));
9400 break;
9401 }
9402
00d93f34
JJ		 9403 check_def = 1;
9404 check_need = 1;
4fbb74a6
AM		 9405 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9406 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9407 != SHT_NOBITS)
252b5132 9408 {
b34976b6 9409 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9410 check_def = 0;
9411 else
9412 check_need = 0;
252b5132 9413 }
00d93f34
JJ		 9414
9415 if (check_need
b34976b6 9416 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9417 {
b34976b6
AM		 9418 Elf_Internal_Verneed ivn;
9419 unsigned long offset;
252b5132 9420
d93f0186
NC		 9421 offset = offset_from_vma
9422 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9423 sizeof (Elf_External_Verneed));
252b5132 9424
b34976b6 9425 do
252b5132 9426 {
b34976b6
AM		 9427 Elf_Internal_Vernaux ivna;
9428 Elf_External_Verneed evn;
9429 Elf_External_Vernaux evna;
9430 unsigned long a_off;
252b5132 9431
59245841
NC		 9432 if (get_data (&evn, file, offset, sizeof (evn), 1,
9433 _("version need")) == NULL)
9434 break;
0b4362b0 9435
252b5132
RH		 9436 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9437 ivn.vn_next = BYTE_GET (evn.vn_next);
9438
9439 a_off = offset + ivn.vn_aux;
9440
9441 do
9442 {
59245841
NC		 9443 if (get_data (&evna, file, a_off, sizeof (evna),
9444 1, _("version need aux (2)")) == NULL)
9445 {
9446 ivna.vna_next = 0;
9447 ivna.vna_other = 0;
9448 }
9449 else
9450 {
9451 ivna.vna_next = BYTE_GET (evna.vna_next);
9452 ivna.vna_other = BYTE_GET (evna.vna_other);
9453 }
252b5132
RH		 9454
9455 a_off += ivna.vna_next;
9456 }
b34976b6 9457 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9458 && ivna.vna_next != 0);
9459
b34976b6 9460 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9461 {
9462 ivna.vna_name = BYTE_GET (evna.vna_name);
9463
54806181
AM		 9464 if (ivna.vna_name >= string_sec->sh_size)
9465 name = _("*invalid*");
9466 else
9467 name = strtab + ivna.vna_name;
252b5132 9468 nn += printf ("(%s%-*s",
16062207
ILT		 9469 name,
9470 12 - (int) strlen (name),
252b5132 9471 ")");
00d93f34 9472 check_def = 0;
252b5132
RH		 9473 break;
9474 }
9475
9476 offset += ivn.vn_next;
9477 }
9478 while (ivn.vn_next);
9479 }
00d93f34 9480
b34976b6
AM		 9481 if (check_def && data[cnt + j] != 0x8001
9482 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9483 {
b34976b6
AM		 9484 Elf_Internal_Verdef ivd;
9485 Elf_External_Verdef evd;
9486 unsigned long offset;
252b5132 9487
d93f0186
NC		 9488 offset = offset_from_vma
9489 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9490 sizeof evd);
252b5132
RH		 9491
9492 do
9493 {
59245841
NC		 9494 if (get_data (&evd, file, offset, sizeof (evd), 1,
9495 _("version def")) == NULL)
9496 {
9497 ivd.vd_next = 0;
3102e897
NC		 9498 /* PR 17531: file: 046-1082287-0.004. */
9499 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9500 break;
59245841
NC		 9501 }
9502 else
9503 {
9504 ivd.vd_next = BYTE_GET (evd.vd_next);
9505 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9506 }
252b5132
RH		 9507
9508 offset += ivd.vd_next;
9509 }
c244d050 9510 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9511 && ivd.vd_next != 0);
9512
c244d050 9513 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9514 {
b34976b6
AM		 9515 Elf_External_Verdaux evda;
9516 Elf_Internal_Verdaux ivda;
252b5132
RH		 9517
9518 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9519
59245841
NC		 9520 if (get_data (&evda, file,
9521 offset - ivd.vd_next + ivd.vd_aux,
9522 sizeof (evda), 1,
9523 _("version def aux")) == NULL)
9524 break;
252b5132
RH		 9525
9526 ivda.vda_name = BYTE_GET (evda.vda_name);
9527
54806181
AM		 9528 if (ivda.vda_name >= string_sec->sh_size)
9529 name = _("*invalid*");
9530 else
9531 name = strtab + ivda.vda_name;
252b5132 9532 nn += printf ("(%s%-*s",
16062207
ILT		 9533 name,
9534 12 - (int) strlen (name),
252b5132
RH		 9535 ")");
9536 }
9537 }
9538
9539 if (nn < 18)
9540 printf ("%*c", 18 - nn, ' ');
9541 }
9542
9543 putchar ('\n');
9544 }
9545
9546 free (data);
9547 free (strtab);
9548 free (symbols);
9549 }
9550 break;
103f02d3 9551
252b5132
RH		 9552 default:
9553 break;
9554 }
9555 }
9556
9557 if (! found)
9558 printf (_("\nNo version information found in this file.\n"));
9559
9560 return 1;
9561}
9562
d1133906 9563static const char *
d3ba0551 9564get_symbol_binding (unsigned int binding)
252b5132 9565{
b34976b6 9566 static char buff[32];
252b5132
RH		 9567
9568 switch (binding)
9569 {
b34976b6
AM		 9570 case STB_LOCAL: return "LOCAL";
9571 case STB_GLOBAL: return "GLOBAL";
9572 case STB_WEAK: return "WEAK";
252b5132
RH		 9573 default:
9574 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9575 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9576 binding);
252b5132 9577 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9578 {
9579 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9580 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9581 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9582 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9583 return "UNIQUE";
9584 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9585 }
252b5132 9586 else
e9e44622 9587 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9588 return buff;
9589 }
9590}
9591
d1133906 9592static const char *
d3ba0551 9593get_symbol_type (unsigned int type)
252b5132 9594{
b34976b6 9595 static char buff[32];
252b5132
RH		 9596
9597 switch (type)
9598 {
b34976b6
AM		 9599 case STT_NOTYPE: return "NOTYPE";
9600 case STT_OBJECT: return "OBJECT";
9601 case STT_FUNC: return "FUNC";
9602 case STT_SECTION: return "SECTION";
9603 case STT_FILE: return "FILE";
9604 case STT_COMMON: return "COMMON";
9605 case STT_TLS: return "TLS";
15ab5209
DB		 9606 case STT_RELC: return "RELC";
9607 case STT_SRELC: return "SRELC";
252b5132
RH		 9608 default:
9609 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9610 {
3510a7b8
NC		 9611 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9612 return "THUMB_FUNC";
103f02d3 9613
351b4b40 9614 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9615 return "REGISTER";
9616
9617 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9618 return "PARISC_MILLI";
9619
e9e44622 9620 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9621 }
252b5132 9622 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9623 {
9624 if (elf_header.e_machine == EM_PARISC)
9625 {
9626 if (type == STT_HP_OPAQUE)
9627 return "HP_OPAQUE";
9628 if (type == STT_HP_STUB)
9629 return "HP_STUB";
9630 }
9631
d8045f23 9632 if (type == STT_GNU_IFUNC
9c55345c 9633 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9634 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9635 /* GNU is still using the default value 0. */
d8045f23
NC		 9636 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9637 return "IFUNC";
9638
e9e44622 9639 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9640 }
252b5132 9641 else
e9e44622 9642 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9643 return buff;
9644 }
9645}
9646
d1133906 9647static const char *
d3ba0551 9648get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9649{
9650 switch (visibility)
9651 {
b34976b6
AM		 9652 case STV_DEFAULT: return "DEFAULT";
9653 case STV_INTERNAL: return "INTERNAL";
9654 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9655 case STV_PROTECTED: return "PROTECTED";
9656 default: abort ();
9657 }
9658}
9659
5e2b0d47
NC		 9660static const char *
9661get_mips_symbol_other (unsigned int other)
9662{
9663 switch (other)
9664 {
df58fc94
RS		 9665 case STO_OPTIONAL:
9666 return "OPTIONAL";
9667 case STO_MIPS_PLT:
9668 return "MIPS PLT";
9669 case STO_MIPS_PIC:
9670 return "MIPS PIC";
9671 case STO_MICROMIPS:
9672 return "MICROMIPS";
9673 case STO_MICROMIPS | STO_MIPS_PIC:
9674 return "MICROMIPS, MIPS PIC";
9675 case STO_MIPS16:
9676 return "MIPS16";
9677 default:
9678 return NULL;
5e2b0d47
NC		 9679 }
9680}
9681
28f997cf
TG		 9682static const char *
9683get_ia64_symbol_other (unsigned int other)
9684{
9685 if (is_ia64_vms ())
9686 {
9687 static char res[32];
9688
9689 res[0] = 0;
9690
9691 /* Function types is for images and .STB files only. */
9692 switch (elf_header.e_type)
9693 {
9694 case ET_DYN:
9695 case ET_EXEC:
9696 switch (VMS_ST_FUNC_TYPE (other))
9697 {
9698 case VMS_SFT_CODE_ADDR:
9699 strcat (res, " CA");
9700 break;
9701 case VMS_SFT_SYMV_IDX:
9702 strcat (res, " VEC");
9703 break;
9704 case VMS_SFT_FD:
9705 strcat (res, " FD");
9706 break;
9707 case VMS_SFT_RESERVE:
9708 strcat (res, " RSV");
9709 break;
9710 default:
9711 abort ();
9712 }
9713 break;
9714 default:
9715 break;
9716 }
9717 switch (VMS_ST_LINKAGE (other))
9718 {
9719 case VMS_STL_IGNORE:
9720 strcat (res, " IGN");
9721 break;
9722 case VMS_STL_RESERVE:
9723 strcat (res, " RSV");
9724 break;
9725 case VMS_STL_STD:
9726 strcat (res, " STD");
9727 break;
9728 case VMS_STL_LNK:
9729 strcat (res, " LNK");
9730 break;
9731 default:
9732 abort ();
9733 }
9734
9735 if (res[0] != 0)
9736 return res + 1;
9737 else
9738 return res;
9739 }
9740 return NULL;
9741}
9742
6911b7dc
AM		 9743static const char *
9744get_ppc64_symbol_other (unsigned int other)
9745{
9746 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9747 {
9748 static char buf[32];
9749 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9750 PPC64_LOCAL_ENTRY_OFFSET (other));
9751 return buf;
9752 }
9753 return NULL;
9754}
9755
5e2b0d47
NC		 9756static const char *
9757get_symbol_other (unsigned int other)
9758{
9759 const char * result = NULL;
9760 static char buff [32];
9761
9762 if (other == 0)
9763 return "";
9764
9765 switch (elf_header.e_machine)
9766 {
9767 case EM_MIPS:
9768 result = get_mips_symbol_other (other);
28f997cf
TG		 9769 break;
9770 case EM_IA_64:
9771 result = get_ia64_symbol_other (other);
9772 break;
6911b7dc
AM		 9773 case EM_PPC64:
9774 result = get_ppc64_symbol_other (other);
9775 break;
5e2b0d47
NC		 9776 default:
9777 break;
9778 }
9779
9780 if (result)
9781 return result;
9782
9783 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9784 return buff;
9785}
9786
d1133906 9787static const char *
d3ba0551 9788get_symbol_index_type (unsigned int type)
252b5132 9789{
b34976b6 9790 static char buff[32];
5cf1065c 9791
252b5132
RH		 9792 switch (type)
9793 {
b34976b6
AM		 9794 case SHN_UNDEF: return "UND";
9795 case SHN_ABS: return "ABS";
9796 case SHN_COMMON: return "COM";
252b5132 9797 default:
9ce701e2
L		 9798 if (type == SHN_IA_64_ANSI_COMMON
9799 && elf_header.e_machine == EM_IA_64
9800 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9801 return "ANSI_COM";
8a9036a4 9802 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9803 || elf_header.e_machine == EM_L1OM
9804 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9805 && type == SHN_X86_64_LCOMMON)
9806 return "LARGE_COM";
ac145307
BS		 9807 else if ((type == SHN_MIPS_SCOMMON
9808 && elf_header.e_machine == EM_MIPS)
9809 || (type == SHN_TIC6X_SCOMMON
9810 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9811 return "SCOM";
9812 else if (type == SHN_MIPS_SUNDEFINED
9813 && elf_header.e_machine == EM_MIPS)
9814 return "SUND";
9ce701e2 9815 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9816 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9817 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9818 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9819 else if (type >= SHN_LORESERVE)
9820 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 9821 else if (type >= elf_header.e_shnum)
e0a31db1 9822 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 9823 else
232e7cb8 9824 sprintf (buff, "%3d", type);
5cf1065c 9825 break;
252b5132 9826 }
5cf1065c
NC		 9827
9828 return buff;
252b5132
RH		 9829}
9830
66543521 9831static bfd_vma *
8b73c356 9832get_dynamic_data (FILE * file, size_t number, unsigned int ent_size)
252b5132 9833{
2cf0635d
NC		 9834 unsigned char * e_data;
9835 bfd_vma * i_data;
252b5132 9836
3102e897
NC		 9837 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
9838 attempting to allocate memory when the read is bound to fail. */
9839 if (ent_size * number > current_file_size)
9840 {
9841 error (_("Invalid number of dynamic entries: %lu\n"),
9842 (unsigned long) number);
9843 return NULL;
9844 }
9845
3f5e193b 9846 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9847 if (e_data == NULL)
9848 {
8b73c356
NC		 9849 error (_("Out of memory reading %lu dynamic entries\n"),
9850 (unsigned long) number);
252b5132
RH		 9851 return NULL;
9852 }
9853
66543521 9854 if (fread (e_data, ent_size, number, file) != number)
252b5132 9855 {
3102e897
NC		 9856 error (_("Unable to read in %lu bytes of dynamic data\n"),
9857 (unsigned long) (number * ent_size));
9858 free (e_data);
252b5132
RH		 9859 return NULL;
9860 }
9861
3f5e193b 9862 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9863 if (i_data == NULL)
9864 {
8b73c356
NC		 9865 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9866 (unsigned long) number);
252b5132
RH		 9867 free (e_data);
9868 return NULL;
9869 }
9870
9871 while (number--)
66543521 9872 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9873
9874 free (e_data);
9875
9876 return i_data;
9877}
9878
6bd1a22c
L		 9879static void
9880print_dynamic_symbol (bfd_vma si, unsigned long hn)
9881{
2cf0635d 9882 Elf_Internal_Sym * psym;
6bd1a22c
L		 9883 int n;
9884
6bd1a22c
L		 9885 n = print_vma (si, DEC_5);
9886 if (n < 5)
0b4362b0 9887 fputs (&" "[n], stdout);
6bd1a22c 9888 printf (" %3lu: ", hn);
e0a31db1
NC		 9889
9890 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
9891 {
3102e897
NC		 9892 printf (_("<No info available for dynamic symbol number %lu>\n"),
9893 (unsigned long) si);
e0a31db1
NC		 9894 return;
9895 }
9896
9897 psym = dynamic_symbols + si;
6bd1a22c
L		 9898 print_vma (psym->st_value, LONG_HEX);
9899 putchar (' ');
9900 print_vma (psym->st_size, DEC_5);
9901
f4be36b3
AM		 9902 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9903 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9904 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9905 /* Check to see if any other bits in the st_other field are set.
9906 Note - displaying this information disrupts the layout of the
9907 table being generated, but for the moment this case is very
9908 rare. */
9909 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9910 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9911 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9912 if (VALID_DYNAMIC_NAME (psym->st_name))
9913 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9914 else
2b692964 9915 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9916 putchar ('\n');
9917}
9918
bb4d2ac2
L		 9919static const char *
9920get_symbol_version_string (FILE *file, int is_dynsym,
9921 const char *strtab,
9922 unsigned long int strtab_size,
9923 unsigned int si, Elf_Internal_Sym *psym,
9924 enum versioned_symbol_info *sym_info,
9925 unsigned short *vna_other)
9926{
9927 const char *version_string = NULL;
9928
9929 if (is_dynsym
9930 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9931 {
9932 unsigned char data[2];
9933 unsigned short vers_data;
9934 unsigned long offset;
9935 int is_nobits;
9936 int check_def;
9937
9938 offset = offset_from_vma
9939 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9940 sizeof data + si * sizeof (vers_data));
9941
9942 if (get_data (&data, file, offset + si * sizeof (vers_data),
9943 sizeof (data), 1, _("version data")) == NULL)
9944 return NULL;
9945
9946 vers_data = byte_get (data, 2);
9947
9948 is_nobits = (psym->st_shndx < elf_header.e_shnum
9949 && section_headers[psym->st_shndx].sh_type
9950 == SHT_NOBITS);
9951
9952 check_def = (psym->st_shndx != SHN_UNDEF);
9953
9954 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9955 {
9956 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9957 && (is_nobits || ! check_def))
9958 {
9959 Elf_External_Verneed evn;
9960 Elf_Internal_Verneed ivn;
9961 Elf_Internal_Vernaux ivna;
9962
9963 /* We must test both. */
9964 offset = offset_from_vma
9965 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9966 sizeof evn);
9967
9968 do
9969 {
9970 unsigned long vna_off;
9971
9972 if (get_data (&evn, file, offset, sizeof (evn), 1,
9973 _("version need")) == NULL)
9974 {
9975 ivna.vna_next = 0;
9976 ivna.vna_other = 0;
9977 ivna.vna_name = 0;
9978 break;
9979 }
9980
9981 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9982 ivn.vn_next = BYTE_GET (evn.vn_next);
9983
9984 vna_off = offset + ivn.vn_aux;
9985
9986 do
9987 {
9988 Elf_External_Vernaux evna;
9989
9990 if (get_data (&evna, file, vna_off,
9991 sizeof (evna), 1,
9992 _("version need aux (3)")) == NULL)
9993 {
9994 ivna.vna_next = 0;
9995 ivna.vna_other = 0;
9996 ivna.vna_name = 0;
9997 }
9998 else
9999 {
10000 ivna.vna_other = BYTE_GET (evna.vna_other);
10001 ivna.vna_next = BYTE_GET (evna.vna_next);
10002 ivna.vna_name = BYTE_GET (evna.vna_name);
10003 }
10004
10005 vna_off += ivna.vna_next;
10006 }
10007 while (ivna.vna_other != vers_data
10008 && ivna.vna_next != 0);
10009
10010 if (ivna.vna_other == vers_data)
10011 break;
10012
10013 offset += ivn.vn_next;
10014 }
10015 while (ivn.vn_next != 0);
10016
10017 if (ivna.vna_other == vers_data)
10018 {
10019 *sym_info = symbol_undefined;
10020 *vna_other = ivna.vna_other;
10021 version_string = (ivna.vna_name < strtab_size
10022 ? strtab + ivna.vna_name
10023 : _("<corrupt>"));
10024 check_def = 0;
10025 }
10026 else if (! is_nobits)
10027 error (_("bad dynamic symbol\n"));
10028 else
10029 check_def = 1;
10030 }
10031
10032 if (check_def)
10033 {
10034 if (vers_data != 0x8001
10035 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10036 {
10037 Elf_Internal_Verdef ivd;
10038 Elf_Internal_Verdaux ivda;
10039 Elf_External_Verdaux evda;
10040 unsigned long off;
10041
10042 off = offset_from_vma
10043 (file,
10044 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10045 sizeof (Elf_External_Verdef));
10046
10047 do
10048 {
10049 Elf_External_Verdef evd;
10050
10051 if (get_data (&evd, file, off, sizeof (evd),
10052 1, _("version def")) == NULL)
10053 {
10054 ivd.vd_ndx = 0;
10055 ivd.vd_aux = 0;
10056 ivd.vd_next = 0;
10057 }
10058 else
10059 {
10060 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10061 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10062 ivd.vd_next = BYTE_GET (evd.vd_next);
10063 }
10064
10065 off += ivd.vd_next;
10066 }
10067 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10068 && ivd.vd_next != 0);
10069
10070 off -= ivd.vd_next;
10071 off += ivd.vd_aux;
10072
10073 if (get_data (&evda, file, off, sizeof (evda),
10074 1, _("version def aux")) == NULL)
10075 return version_string;
10076
10077 ivda.vda_name = BYTE_GET (evda.vda_name);
10078
10079 if (psym->st_name != ivda.vda_name)
10080 {
10081 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10082 ? symbol_hidden : symbol_public);
10083 version_string = (ivda.vda_name < strtab_size
10084 ? strtab + ivda.vda_name
10085 : _("<corrupt>"));
10086 }
10087 }
10088 }
10089 }
10090 }
10091 return version_string;
10092}
10093
e3c8793a 10094/* Dump the symbol table. */
252b5132 10095static int
2cf0635d 10096process_symbol_table (FILE * file)
252b5132 10097{
2cf0635d 10098 Elf_Internal_Shdr * section;
8b73c356
NC		 10099 bfd_size_type nbuckets = 0;
10100 bfd_size_type nchains = 0;
2cf0635d
NC		 10101 bfd_vma * buckets = NULL;
10102 bfd_vma * chains = NULL;
fdc90cb4 10103 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10104 bfd_vma * gnubuckets = NULL;
10105 bfd_vma * gnuchains = NULL;
6bd1a22c 10106 bfd_vma gnusymidx = 0;
071436c6 10107 bfd_size_type ngnuchains = 0;
252b5132 10108
2c610e4b 10109 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10110 return 1;
10111
6bd1a22c
L		 10112 if (dynamic_info[DT_HASH]
10113 && (do_histogram
2c610e4b
L		 10114 || (do_using_dynamic
10115 && !do_dyn_syms
10116 && dynamic_strings != NULL)))
252b5132 10117 {
66543521
AM		 10118 unsigned char nb[8];
10119 unsigned char nc[8];
8b73c356 10120 unsigned int hash_ent_size = 4;
66543521
AM		 10121
10122 if ((elf_header.e_machine == EM_ALPHA
10123 || elf_header.e_machine == EM_S390
10124 || elf_header.e_machine == EM_S390_OLD)
10125 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10126 hash_ent_size = 8;
10127
fb52b2f4
NC		 10128 if (fseek (file,
10129 (archive_file_offset
10130 + offset_from_vma (file, dynamic_info[DT_HASH],
10131 sizeof nb + sizeof nc)),
d93f0186 10132 SEEK_SET))
252b5132 10133 {
591a748a 10134 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10135 goto no_hash;
252b5132
RH		 10136 }
10137
66543521 10138 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10139 {
10140 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10141 goto no_hash;
252b5132
RH		 10142 }
10143
66543521 10144 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10145 {
10146 error (_("Failed to read in number of chains\n"));
d3a44ec6 10147 goto no_hash;
252b5132
RH		 10148 }
10149
66543521
AM		 10150 nbuckets = byte_get (nb, hash_ent_size);
10151 nchains = byte_get (nc, hash_ent_size);
252b5132 10152
66543521
AM		 10153 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10154 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10155
d3a44ec6 10156 no_hash:
252b5132 10157 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10158 {
10159 if (do_using_dynamic)
10160 return 0;
10161 free (buckets);
10162 free (chains);
10163 buckets = NULL;
10164 chains = NULL;
10165 nbuckets = 0;
10166 nchains = 0;
10167 }
252b5132
RH		 10168 }
10169
6bd1a22c
L		 10170 if (dynamic_info_DT_GNU_HASH
10171 && (do_histogram
2c610e4b
L		 10172 || (do_using_dynamic
10173 && !do_dyn_syms
10174 && dynamic_strings != NULL)))
252b5132 10175 {
6bd1a22c
L		 10176 unsigned char nb[16];
10177 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10178 bfd_vma buckets_vma;
10179
10180 if (fseek (file,
10181 (archive_file_offset
10182 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10183 sizeof nb)),
10184 SEEK_SET))
10185 {
10186 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10187 goto no_gnu_hash;
6bd1a22c 10188 }
252b5132 10189
6bd1a22c
L		 10190 if (fread (nb, 16, 1, file) != 1)
10191 {
10192 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10193 goto no_gnu_hash;
6bd1a22c
L		 10194 }
10195
10196 ngnubuckets = byte_get (nb, 4);
10197 gnusymidx = byte_get (nb + 4, 4);
10198 bitmaskwords = byte_get (nb + 8, 4);
10199 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10200 if (is_32bit_elf)
6bd1a22c 10201 buckets_vma += bitmaskwords * 4;
f7a99963 10202 else
6bd1a22c 10203 buckets_vma += bitmaskwords * 8;
252b5132 10204
6bd1a22c
L		 10205 if (fseek (file,
10206 (archive_file_offset
10207 + offset_from_vma (file, buckets_vma, 4)),
10208 SEEK_SET))
252b5132 10209 {
6bd1a22c 10210 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10211 goto no_gnu_hash;
6bd1a22c
L		 10212 }
10213
10214 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10215
6bd1a22c 10216 if (gnubuckets == NULL)
d3a44ec6 10217 goto no_gnu_hash;
6bd1a22c
L		 10218
10219 for (i = 0; i < ngnubuckets; i++)
10220 if (gnubuckets[i] != 0)
10221 {
10222 if (gnubuckets[i] < gnusymidx)
10223 return 0;
10224
10225 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10226 maxchain = gnubuckets[i];
10227 }
10228
10229 if (maxchain == 0xffffffff)
d3a44ec6 10230 goto no_gnu_hash;
6bd1a22c
L		 10231
10232 maxchain -= gnusymidx;
10233
10234 if (fseek (file,
10235 (archive_file_offset
10236 + offset_from_vma (file, buckets_vma
10237 + 4 * (ngnubuckets + maxchain), 4)),
10238 SEEK_SET))
10239 {
10240 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10241 goto no_gnu_hash;
6bd1a22c
L		 10242 }
10243
10244 do
10245 {
10246 if (fread (nb, 4, 1, file) != 1)
252b5132 10247 {
6bd1a22c 10248 error (_("Failed to determine last chain length\n"));
d3a44ec6 10249 goto no_gnu_hash;
6bd1a22c 10250 }
252b5132 10251
6bd1a22c 10252 if (maxchain + 1 == 0)
d3a44ec6 10253 goto no_gnu_hash;
252b5132 10254
6bd1a22c
L		 10255 ++maxchain;
10256 }
10257 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10258
6bd1a22c
L		 10259 if (fseek (file,
10260 (archive_file_offset
10261 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10262 SEEK_SET))
10263 {
10264 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10265 goto no_gnu_hash;
6bd1a22c
L		 10266 }
10267
10268 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10269 ngnuchains = maxchain;
6bd1a22c 10270
d3a44ec6 10271 no_gnu_hash:
6bd1a22c 10272 if (gnuchains == NULL)
d3a44ec6
JJ		 10273 {
10274 free (gnubuckets);
d3a44ec6
JJ		 10275 gnubuckets = NULL;
10276 ngnubuckets = 0;
f64fddf1
NC		 10277 if (do_using_dynamic)
10278 return 0;
d3a44ec6 10279 }
6bd1a22c
L		 10280 }
10281
10282 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10283 && do_syms
10284 && do_using_dynamic
3102e897
NC		 10285 && dynamic_strings != NULL
10286 && dynamic_symbols != NULL)
6bd1a22c
L		 10287 {
10288 unsigned long hn;
10289
10290 if (dynamic_info[DT_HASH])
10291 {
10292 bfd_vma si;
10293
10294 printf (_("\nSymbol table for image:\n"));
10295 if (is_32bit_elf)
10296 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10297 else
10298 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10299
10300 for (hn = 0; hn < nbuckets; hn++)
10301 {
10302 if (! buckets[hn])
10303 continue;
10304
10305 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10306 print_dynamic_symbol (si, hn);
252b5132
RH		 10307 }
10308 }
6bd1a22c
L		 10309
10310 if (dynamic_info_DT_GNU_HASH)
10311 {
10312 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10313 if (is_32bit_elf)
10314 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10315 else
10316 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10317
10318 for (hn = 0; hn < ngnubuckets; ++hn)
10319 if (gnubuckets[hn] != 0)
10320 {
10321 bfd_vma si = gnubuckets[hn];
10322 bfd_vma off = si - gnusymidx;
10323
10324 do
10325 {
10326 print_dynamic_symbol (si, hn);
10327 si++;
10328 }
071436c6 10329 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10330 }
10331 }
252b5132 10332 }
8b73c356
NC		 10333 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10334 && section_headers != NULL)
252b5132 10335 {
b34976b6 10336 unsigned int i;
252b5132
RH		 10337
10338 for (i = 0, section = section_headers;
10339 i < elf_header.e_shnum;
10340 i++, section++)
10341 {
b34976b6 10342 unsigned int si;
2cf0635d 10343 char * strtab = NULL;
c256ffe7 10344 unsigned long int strtab_size = 0;
2cf0635d
NC		 10345 Elf_Internal_Sym * symtab;
10346 Elf_Internal_Sym * psym;
ba5cdace 10347 unsigned long num_syms;
252b5132 10348
2c610e4b
L		 10349 if ((section->sh_type != SHT_SYMTAB
10350 && section->sh_type != SHT_DYNSYM)
10351 || (!do_syms
10352 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10353 continue;
10354
dd24e3da
NC		 10355 if (section->sh_entsize == 0)
10356 {
10357 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10358 printable_section_name (section));
dd24e3da
NC		 10359 continue;
10360 }
10361
252b5132 10362 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10363 printable_section_name (section),
252b5132 10364 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10365
f7a99963 10366 if (is_32bit_elf)
ca47b30c 10367 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10368 else
ca47b30c 10369 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10370
ba5cdace 10371 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10372 if (symtab == NULL)
10373 continue;
10374
10375 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10376 {
10377 strtab = string_table;
10378 strtab_size = string_table_length;
10379 }
4fbb74a6 10380 else if (section->sh_link < elf_header.e_shnum)
252b5132 10381 {
2cf0635d 10382 Elf_Internal_Shdr * string_sec;
252b5132 10383
4fbb74a6 10384 string_sec = section_headers + section->sh_link;
252b5132 10385
3f5e193b
NC		 10386 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10387 1, string_sec->sh_size,
10388 _("string table"));
c256ffe7 10389 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10390 }
10391
ba5cdace 10392 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10393 {
bb4d2ac2
L		 10394 const char *version_string;
10395 enum versioned_symbol_info sym_info;
10396 unsigned short vna_other;
10397
5e220199 10398 printf ("%6d: ", si);
f7a99963
NC		 10399 print_vma (psym->st_value, LONG_HEX);
10400 putchar (' ');
10401 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10402 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10403 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10404 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10405 /* Check to see if any other bits in the st_other field are set.
10406 Note - displaying this information disrupts the layout of the
10407 table being generated, but for the moment this case is very rare. */
10408 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10409 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10410 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10411 print_symbol (25, psym->st_name < strtab_size
2b692964 10412 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10413
bb4d2ac2
L		 10414 version_string
10415 = get_symbol_version_string (file,
10416 section->sh_type == SHT_DYNSYM,
10417 strtab, strtab_size, si,
10418 psym, &sym_info, &vna_other);
10419 if (version_string)
252b5132 10420 {
bb4d2ac2
L		 10421 if (sym_info == symbol_undefined)
10422 printf ("@%s (%d)", version_string, vna_other);
10423 else
10424 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10425 version_string);
252b5132
RH		 10426 }
10427
10428 putchar ('\n');
10429 }
10430
10431 free (symtab);
10432 if (strtab != string_table)
10433 free (strtab);
10434 }
10435 }
10436 else if (do_syms)
10437 printf
10438 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10439
10440 if (do_histogram && buckets != NULL)
10441 {
2cf0635d
NC		 10442 unsigned long * lengths;
10443 unsigned long * counts;
66543521
AM		 10444 unsigned long hn;
10445 bfd_vma si;
10446 unsigned long maxlength = 0;
10447 unsigned long nzero_counts = 0;
10448 unsigned long nsyms = 0;
252b5132 10449
66543521
AM		 10450 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10451 (unsigned long) nbuckets);
252b5132 10452
3f5e193b 10453 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10454 if (lengths == NULL)
10455 {
8b73c356 10456 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10457 return 0;
10458 }
8b73c356
NC		 10459
10460 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10461 for (hn = 0; hn < nbuckets; ++hn)
10462 {
f7a99963 10463 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 10464 {
b34976b6 10465 ++nsyms;
252b5132 10466 if (maxlength < ++lengths[hn])
b34976b6 10467 ++maxlength;
049b0c3a
NC		 10468
10469 /* PR binutils/17531: A corrupt binary could contain broken
10470 histogram data. Do not go into an infinite loop trying
10471 to process it. */
10472 if (chains[si] == si)
10473 {
10474 error (_("histogram chain links to itself\n"));
10475 break;
10476 }
252b5132
RH		 10477 }
10478 }
10479
3f5e193b 10480 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10481 if (counts == NULL)
10482 {
b2e951ec 10483 free (lengths);
8b73c356 10484 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10485 return 0;
10486 }
10487
10488 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10489 ++counts[lengths[hn]];
252b5132 10490
103f02d3 10491 if (nbuckets > 0)
252b5132 10492 {
66543521
AM		 10493 unsigned long i;
10494 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10495 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10496 for (i = 1; i <= maxlength; ++i)
103f02d3 10497 {
66543521
AM		 10498 nzero_counts += counts[i] * i;
10499 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10500 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10501 (nzero_counts * 100.0) / nsyms);
10502 }
252b5132
RH		 10503 }
10504
10505 free (counts);
10506 free (lengths);
10507 }
10508
10509 if (buckets != NULL)
10510 {
10511 free (buckets);
10512 free (chains);
10513 }
10514
d3a44ec6 10515 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10516 {
2cf0635d
NC		 10517 unsigned long * lengths;
10518 unsigned long * counts;
fdc90cb4
JJ		 10519 unsigned long hn;
10520 unsigned long maxlength = 0;
10521 unsigned long nzero_counts = 0;
10522 unsigned long nsyms = 0;
fdc90cb4 10523
8b73c356
NC		 10524 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10525 (unsigned long) ngnubuckets);
10526
3f5e193b 10527 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10528 if (lengths == NULL)
10529 {
8b73c356 10530 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10531 return 0;
10532 }
10533
fdc90cb4
JJ		 10534 printf (_(" Length Number %% of total Coverage\n"));
10535
10536 for (hn = 0; hn < ngnubuckets; ++hn)
10537 if (gnubuckets[hn] != 0)
10538 {
10539 bfd_vma off, length = 1;
10540
6bd1a22c 10541 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10542 /* PR 17531 file: 010-77222-0.004. */
10543 off < ngnuchains && (gnuchains[off] & 1) == 0;
10544 ++off)
fdc90cb4
JJ		 10545 ++length;
10546 lengths[hn] = length;
10547 if (length > maxlength)
10548 maxlength = length;
10549 nsyms += length;
10550 }
10551
3f5e193b 10552 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10553 if (counts == NULL)
10554 {
b2e951ec 10555 free (lengths);
8b73c356 10556 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 10557 return 0;
10558 }
10559
10560 for (hn = 0; hn < ngnubuckets; ++hn)
10561 ++counts[lengths[hn]];
10562
10563 if (ngnubuckets > 0)
10564 {
10565 unsigned long j;
10566 printf (" 0 %-10lu (%5.1f%%)\n",
10567 counts[0], (counts[0] * 100.0) / ngnubuckets);
10568 for (j = 1; j <= maxlength; ++j)
10569 {
10570 nzero_counts += counts[j] * j;
10571 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10572 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10573 (nzero_counts * 100.0) / nsyms);
10574 }
10575 }
10576
10577 free (counts);
10578 free (lengths);
10579 free (gnubuckets);
10580 free (gnuchains);
10581 }
10582
252b5132
RH		 10583 return 1;
10584}
10585
10586static int
2cf0635d 10587process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10588{
b4c96d0d 10589 unsigned int i;
252b5132
RH		 10590
10591 if (dynamic_syminfo == NULL
10592 || !do_dynamic)
10593 /* No syminfo, this is ok. */
10594 return 1;
10595
10596 /* There better should be a dynamic symbol section. */
10597 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10598 return 0;
10599
10600 if (dynamic_addr)
10601 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10602 dynamic_syminfo_offset, dynamic_syminfo_nent);
10603
10604 printf (_(" Num: Name BoundTo Flags\n"));
10605 for (i = 0; i < dynamic_syminfo_nent; ++i)
10606 {
10607 unsigned short int flags = dynamic_syminfo[i].si_flags;
10608
31104126 10609 printf ("%4d: ", i);
4082ef84
NC		 10610 if (i >= num_dynamic_syms)
10611 printf (_("<corrupt index>"));
10612 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 10613 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10614 else
2b692964 10615 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10616 putchar (' ');
252b5132
RH		 10617
10618 switch (dynamic_syminfo[i].si_boundto)
10619 {
10620 case SYMINFO_BT_SELF:
10621 fputs ("SELF ", stdout);
10622 break;
10623 case SYMINFO_BT_PARENT:
10624 fputs ("PARENT ", stdout);
10625 break;
10626 default:
10627 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10628 && dynamic_syminfo[i].si_boundto < dynamic_nent
10629 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10630 {
d79b3d50 10631 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10632 putchar (' ' );
10633 }
252b5132
RH		 10634 else
10635 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10636 break;
10637 }
10638
10639 if (flags & SYMINFO_FLG_DIRECT)
10640 printf (" DIRECT");
10641 if (flags & SYMINFO_FLG_PASSTHRU)
10642 printf (" PASSTHRU");
10643 if (flags & SYMINFO_FLG_COPY)
10644 printf (" COPY");
10645 if (flags & SYMINFO_FLG_LAZYLOAD)
10646 printf (" LAZYLOAD");
10647
10648 puts ("");
10649 }
10650
10651 return 1;
10652}
10653
cf13d699
NC		 10654/* Check to see if the given reloc needs to be handled in a target specific
10655 manner. If so then process the reloc and return TRUE otherwise return
10656 FALSE. */
09c11c86 10657
cf13d699
NC		 10658static bfd_boolean
10659target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10660 unsigned char * start,
10661 Elf_Internal_Sym * symtab)
252b5132 10662{
cf13d699 10663 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 10664
cf13d699 10665 switch (elf_header.e_machine)
252b5132 10666 {
13761a11
NC		 10667 case EM_MSP430:
10668 case EM_MSP430_OLD:
10669 {
10670 static Elf_Internal_Sym * saved_sym = NULL;
10671
10672 switch (reloc_type)
10673 {
10674 case 10: /* R_MSP430_SYM_DIFF */
10675 if (uses_msp430x_relocs ())
10676 break;
10677 case 21: /* R_MSP430X_SYM_DIFF */
10678 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10679 return TRUE;
10680
10681 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10682 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10683 goto handle_sym_diff;
0b4362b0 10684
13761a11
NC		 10685 case 5: /* R_MSP430_16_BYTE */
10686 case 9: /* R_MSP430_8 */
10687 if (uses_msp430x_relocs ())
10688 break;
10689 goto handle_sym_diff;
10690
10691 case 2: /* R_MSP430_ABS16 */
10692 case 15: /* R_MSP430X_ABS16 */
10693 if (! uses_msp430x_relocs ())
10694 break;
10695 goto handle_sym_diff;
0b4362b0 10696
13761a11
NC		 10697 handle_sym_diff:
10698 if (saved_sym != NULL)
10699 {
10700 bfd_vma value;
10701
10702 value = reloc->r_addend
10703 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10704 - saved_sym->st_value);
10705
10706 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10707
10708 saved_sym = NULL;
10709 return TRUE;
10710 }
10711 break;
10712
10713 default:
10714 if (saved_sym != NULL)
071436c6 10715 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 10716 break;
10717 }
10718 break;
10719 }
10720
cf13d699
NC		 10721 case EM_MN10300:
10722 case EM_CYGNUS_MN10300:
10723 {
10724 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 10725
cf13d699
NC		 10726 switch (reloc_type)
10727 {
10728 case 34: /* R_MN10300_ALIGN */
10729 return TRUE;
10730 case 33: /* R_MN10300_SYM_DIFF */
10731 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10732 return TRUE;
10733 case 1: /* R_MN10300_32 */
10734 case 2: /* R_MN10300_16 */
10735 if (saved_sym != NULL)
10736 {
10737 bfd_vma value;
252b5132 10738
cf13d699
NC		 10739 value = reloc->r_addend
10740 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10741 - saved_sym->st_value);
252b5132 10742
cf13d699 10743 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 10744
cf13d699
NC		 10745 saved_sym = NULL;
10746 return TRUE;
10747 }
10748 break;
10749 default:
10750 if (saved_sym != NULL)
071436c6 10751 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 10752 break;
10753 }
10754 break;
10755 }
252b5132
RH		 10756 }
10757
cf13d699 10758 return FALSE;
252b5132
RH		 10759}
10760
aca88567
NC		 10761/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10762 DWARF debug sections. This is a target specific test. Note - we do not
10763 go through the whole including-target-headers-multiple-times route, (as
10764 we have already done with <elf/h8.h>) because this would become very
10765 messy and even then this function would have to contain target specific
10766 information (the names of the relocs instead of their numeric values).
10767 FIXME: This is not the correct way to solve this problem. The proper way
10768 is to have target specific reloc sizing and typing functions created by
10769 the reloc-macros.h header, in the same way that it already creates the
10770 reloc naming functions. */
10771
10772static bfd_boolean
10773is_32bit_abs_reloc (unsigned int reloc_type)
10774{
10775 switch (elf_header.e_machine)
10776 {
41e92641
NC		 10777 case EM_386:
10778 case EM_486:
10779 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 10780 case EM_68K:
10781 return reloc_type == 1; /* R_68K_32. */
10782 case EM_860:
10783 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10784 case EM_960:
10785 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10786 case EM_AARCH64:
10787 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10788 case EM_ALPHA:
137b6b5f 10789 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10790 case EM_ARC:
10791 return reloc_type == 1; /* R_ARC_32. */
10792 case EM_ARM:
10793 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10794 case EM_AVR_OLD:
aca88567
NC		 10795 case EM_AVR:
10796 return reloc_type == 1;
cfb8c092
NC		 10797 case EM_ADAPTEVA_EPIPHANY:
10798 return reloc_type == 3;
aca88567
NC		 10799 case EM_BLACKFIN:
10800 return reloc_type == 0x12; /* R_byte4_data. */
10801 case EM_CRIS:
10802 return reloc_type == 3; /* R_CRIS_32. */
10803 case EM_CR16:
10804 return reloc_type == 3; /* R_CR16_NUM32. */
10805 case EM_CRX:
10806 return reloc_type == 15; /* R_CRX_NUM32. */
10807 case EM_CYGNUS_FRV:
10808 return reloc_type == 1;
41e92641
NC		 10809 case EM_CYGNUS_D10V:
10810 case EM_D10V:
10811 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10812 case EM_CYGNUS_D30V:
10813 case EM_D30V:
10814 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10815 case EM_DLX:
10816 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10817 case EM_CYGNUS_FR30:
10818 case EM_FR30:
10819 return reloc_type == 3; /* R_FR30_32. */
10820 case EM_H8S:
10821 case EM_H8_300:
10822 case EM_H8_300H:
10823 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10824 case EM_IA_64:
10825 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10826 case EM_IP2K_OLD:
10827 case EM_IP2K:
10828 return reloc_type == 2; /* R_IP2K_32. */
10829 case EM_IQ2000:
10830 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10831 case EM_LATTICEMICO32:
10832 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10833 case EM_M32C_OLD:
aca88567
NC		 10834 case EM_M32C:
10835 return reloc_type == 3; /* R_M32C_32. */
10836 case EM_M32R:
10837 return reloc_type == 34; /* R_M32R_32_RELA. */
10838 case EM_MCORE:
10839 return reloc_type == 1; /* R_MCORE_ADDR32. */
10840 case EM_CYGNUS_MEP:
10841 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10842 case EM_METAG:
10843 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10844 case EM_MICROBLAZE:
10845 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10846 case EM_MIPS:
10847 return reloc_type == 2; /* R_MIPS_32. */
10848 case EM_MMIX:
10849 return reloc_type == 4; /* R_MMIX_32. */
10850 case EM_CYGNUS_MN10200:
10851 case EM_MN10200:
10852 return reloc_type == 1; /* R_MN10200_32. */
10853 case EM_CYGNUS_MN10300:
10854 case EM_MN10300:
10855 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10856 case EM_MOXIE:
10857 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10858 case EM_MSP430_OLD:
10859 case EM_MSP430:
13761a11 10860 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 10861 case EM_MT:
10862 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 10863 case EM_NDS32:
10864 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 10865 case EM_ALTERA_NIOS2:
36591ba1 10866 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 10867 case EM_NIOS32:
10868 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 10869 case EM_OR1K:
10870 return reloc_type == 1; /* R_OR1K_32. */
aca88567 10871 case EM_PARISC:
5fda8eca
NC		 10872 return (reloc_type == 1 /* R_PARISC_DIR32. */
10873 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10874 case EM_PJ:
10875 case EM_PJ_OLD:
10876 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10877 case EM_PPC64:
10878 return reloc_type == 1; /* R_PPC64_ADDR32. */
10879 case EM_PPC:
10880 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10881 case EM_RL78:
10882 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10883 case EM_RX:
10884 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10885 case EM_S370:
10886 return reloc_type == 1; /* R_I370_ADDR31. */
10887 case EM_S390_OLD:
10888 case EM_S390:
10889 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10890 case EM_SCORE:
10891 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10892 case EM_SH:
10893 return reloc_type == 1; /* R_SH_DIR32. */
10894 case EM_SPARC32PLUS:
10895 case EM_SPARCV9:
10896 case EM_SPARC:
10897 return reloc_type == 3 /* R_SPARC_32. */
10898 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10899 case EM_SPU:
10900 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10901 case EM_TI_C6000:
10902 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10903 case EM_TILEGX:
10904 return reloc_type == 2; /* R_TILEGX_32. */
10905 case EM_TILEPRO:
10906 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10907 case EM_CYGNUS_V850:
10908 case EM_V850:
10909 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10910 case EM_V800:
10911 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10912 case EM_VAX:
10913 return reloc_type == 1; /* R_VAX_32. */
10914 case EM_X86_64:
8a9036a4 10915 case EM_L1OM:
7a9068fe 10916 case EM_K1OM:
aca88567 10917 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10918 case EM_XC16X:
10919 case EM_C166:
10920 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10921 case EM_XGATE:
10922 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10923 case EM_XSTORMY16:
10924 return reloc_type == 1; /* R_XSTROMY16_32. */
10925 case EM_XTENSA_OLD:
10926 case EM_XTENSA:
10927 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10928 default:
10929 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10930 elf_header.e_machine);
10931 abort ();
10932 }
10933}
10934
10935/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10936 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10937
10938static bfd_boolean
10939is_32bit_pcrel_reloc (unsigned int reloc_type)
10940{
10941 switch (elf_header.e_machine)
10942 {
41e92641
NC		 10943 case EM_386:
10944 case EM_486:
3e0873ac 10945 return reloc_type == 2; /* R_386_PC32. */
aca88567 10946 case EM_68K:
3e0873ac 10947 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10948 case EM_AARCH64:
10949 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10950 case EM_ADAPTEVA_EPIPHANY:
10951 return reloc_type == 6;
aca88567
NC		 10952 case EM_ALPHA:
10953 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10954 case EM_ARM:
3e0873ac 10955 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10956 case EM_MICROBLAZE:
10957 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 10958 case EM_OR1K:
10959 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 10960 case EM_PARISC:
85acf597 10961 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10962 case EM_PPC:
10963 return reloc_type == 26; /* R_PPC_REL32. */
10964 case EM_PPC64:
3e0873ac 10965 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10966 case EM_S390_OLD:
10967 case EM_S390:
3e0873ac 10968 return reloc_type == 5; /* R_390_PC32. */
aca88567 10969 case EM_SH:
3e0873ac 10970 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10971 case EM_SPARC32PLUS:
10972 case EM_SPARCV9:
10973 case EM_SPARC:
3e0873ac 10974 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10975 case EM_SPU:
10976 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10977 case EM_TILEGX:
10978 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10979 case EM_TILEPRO:
10980 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10981 case EM_X86_64:
8a9036a4 10982 case EM_L1OM:
7a9068fe 10983 case EM_K1OM:
3e0873ac 10984 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10985 case EM_XTENSA_OLD:
10986 case EM_XTENSA:
10987 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10988 default:
10989 /* Do not abort or issue an error message here. Not all targets use
10990 pc-relative 32-bit relocs in their DWARF debug information and we
10991 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10992 more helpful warning message will be generated by apply_relocations
10993 anyway, so just return. */
aca88567
NC		 10994 return FALSE;
10995 }
10996}
10997
10998/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10999 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11000
11001static bfd_boolean
11002is_64bit_abs_reloc (unsigned int reloc_type)
11003{
11004 switch (elf_header.e_machine)
11005 {
a06ea964
NC		 11006 case EM_AARCH64:
11007 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11008 case EM_ALPHA:
11009 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11010 case EM_IA_64:
11011 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11012 case EM_PARISC:
11013 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11014 case EM_PPC64:
11015 return reloc_type == 38; /* R_PPC64_ADDR64. */
11016 case EM_SPARC32PLUS:
11017 case EM_SPARCV9:
11018 case EM_SPARC:
11019 return reloc_type == 54; /* R_SPARC_UA64. */
11020 case EM_X86_64:
8a9036a4 11021 case EM_L1OM:
7a9068fe 11022 case EM_K1OM:
aca88567 11023 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11024 case EM_S390_OLD:
11025 case EM_S390:
aa137e4d
NC		 11026 return reloc_type == 22; /* R_S390_64. */
11027 case EM_TILEGX:
11028 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11029 case EM_MIPS:
aa137e4d 11030 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11031 default:
11032 return FALSE;
11033 }
11034}
11035
85acf597
RH		 11036/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11037 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11038
11039static bfd_boolean
11040is_64bit_pcrel_reloc (unsigned int reloc_type)
11041{
11042 switch (elf_header.e_machine)
11043 {
a06ea964
NC		 11044 case EM_AARCH64:
11045 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11046 case EM_ALPHA:
aa137e4d 11047 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11048 case EM_IA_64:
aa137e4d 11049 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11050 case EM_PARISC:
aa137e4d 11051 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11052 case EM_PPC64:
aa137e4d 11053 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11054 case EM_SPARC32PLUS:
11055 case EM_SPARCV9:
11056 case EM_SPARC:
aa137e4d 11057 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11058 case EM_X86_64:
8a9036a4 11059 case EM_L1OM:
7a9068fe 11060 case EM_K1OM:
aa137e4d 11061 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11062 case EM_S390_OLD:
11063 case EM_S390:
aa137e4d
NC		 11064 return reloc_type == 23; /* R_S390_PC64. */
11065 case EM_TILEGX:
11066 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11067 default:
11068 return FALSE;
11069 }
11070}
11071
4dc3c23d
AM		 11072/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11073 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11074
11075static bfd_boolean
11076is_24bit_abs_reloc (unsigned int reloc_type)
11077{
11078 switch (elf_header.e_machine)
11079 {
11080 case EM_CYGNUS_MN10200:
11081 case EM_MN10200:
11082 return reloc_type == 4; /* R_MN10200_24. */
11083 default:
11084 return FALSE;
11085 }
11086}
11087
aca88567
NC		 11088/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11089 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11090
11091static bfd_boolean
11092is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11093{
11094 switch (elf_header.e_machine)
11095 {
aca88567
NC		 11096 case EM_AVR_OLD:
11097 case EM_AVR:
11098 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11099 case EM_ADAPTEVA_EPIPHANY:
11100 return reloc_type == 5;
41e92641
NC		 11101 case EM_CYGNUS_D10V:
11102 case EM_D10V:
11103 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11104 case EM_H8S:
11105 case EM_H8_300:
11106 case EM_H8_300H:
aca88567
NC		 11107 return reloc_type == R_H8_DIR16;
11108 case EM_IP2K_OLD:
11109 case EM_IP2K:
11110 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11111 case EM_M32C_OLD:
f4236fe4
DD		 11112 case EM_M32C:
11113 return reloc_type == 1; /* R_M32C_16 */
aca88567 11114 case EM_MSP430:
13761a11
NC		 11115 if (uses_msp430x_relocs ())
11116 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11117 case EM_MSP430_OLD:
aca88567 11118 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11119 case EM_NDS32:
11120 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11121 case EM_ALTERA_NIOS2:
36591ba1 11122 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11123 case EM_NIOS32:
11124 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11125 case EM_OR1K:
11126 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11127 case EM_TI_C6000:
11128 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11129 case EM_XC16X:
11130 case EM_C166:
11131 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11132 case EM_CYGNUS_MN10200:
11133 case EM_MN10200:
11134 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11135 case EM_CYGNUS_MN10300:
11136 case EM_MN10300:
11137 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 11138 case EM_XGATE:
11139 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11140 default:
aca88567 11141 return FALSE;
4b78141a
NC		 11142 }
11143}
11144
2a7b2e88
JK		 11145/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11146 relocation entries (possibly formerly used for SHT_GROUP sections). */
11147
11148static bfd_boolean
11149is_none_reloc (unsigned int reloc_type)
11150{
11151 switch (elf_header.e_machine)
11152 {
cb8f3167
NC		 11153 case EM_68K: /* R_68K_NONE. */
11154 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11155 case EM_SPARC32PLUS:
11156 case EM_SPARCV9:
cb8f3167
NC		 11157 case EM_SPARC: /* R_SPARC_NONE. */
11158 case EM_MIPS: /* R_MIPS_NONE. */
11159 case EM_PARISC: /* R_PARISC_NONE. */
11160 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11161 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11162 case EM_PPC: /* R_PPC_NONE. */
11163 case EM_PPC64: /* R_PPC64_NONE. */
11164 case EM_ARM: /* R_ARM_NONE. */
11165 case EM_IA_64: /* R_IA64_NONE. */
11166 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11167 case EM_S390_OLD:
cb8f3167
NC		 11168 case EM_S390: /* R_390_NONE. */
11169 case EM_CRIS: /* R_CRIS_NONE. */
11170 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11171 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11172 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11173 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 11174 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11175 case EM_M32R: /* R_M32R_NONE. */
40b36596 11176 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11177 case EM_TILEGX: /* R_TILEGX_NONE. */
11178 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11179 case EM_XC16X:
11180 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11181 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11182 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11183 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11184 return reloc_type == 0;
a06ea964
NC		 11185 case EM_AARCH64:
11186 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11187 case EM_NDS32:
11188 return (reloc_type == 0 /* R_XTENSA_NONE. */
11189 || reloc_type == 204 /* R_NDS32_DIFF8. */
11190 || reloc_type == 205 /* R_NDS32_DIFF16. */
11191 || reloc_type == 206 /* R_NDS32_DIFF32. */
11192 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11193 case EM_XTENSA_OLD:
11194 case EM_XTENSA:
4dc3c23d
AM		 11195 return (reloc_type == 0 /* R_XTENSA_NONE. */
11196 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11197 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11198 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11199 case EM_METAG:
11200 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11201 }
11202 return FALSE;
11203}
11204
cf13d699
NC		 11205/* Apply relocations to a section.
11206 Note: So far support has been added only for those relocations
11207 which can be found in debug sections.
11208 FIXME: Add support for more relocations ? */
1b315056 11209
cf13d699
NC		 11210static void
11211apply_relocations (void * file,
11212 Elf_Internal_Shdr * section,
11213 unsigned char * start)
1b315056 11214{
cf13d699
NC		 11215 Elf_Internal_Shdr * relsec;
11216 unsigned char * end = start + section->sh_size;
cb8f3167 11217
cf13d699
NC		 11218 if (elf_header.e_type != ET_REL)
11219 return;
1b315056 11220
cf13d699 11221 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11222 for (relsec = section_headers;
11223 relsec < section_headers + elf_header.e_shnum;
11224 ++relsec)
252b5132 11225 {
41e92641
NC		 11226 bfd_boolean is_rela;
11227 unsigned long num_relocs;
2cf0635d
NC		 11228 Elf_Internal_Rela * relocs;
11229 Elf_Internal_Rela * rp;
11230 Elf_Internal_Shdr * symsec;
11231 Elf_Internal_Sym * symtab;
ba5cdace 11232 unsigned long num_syms;
2cf0635d 11233 Elf_Internal_Sym * sym;
252b5132 11234
41e92641 11235 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11236 || relsec->sh_info >= elf_header.e_shnum
11237 || section_headers + relsec->sh_info != section
c256ffe7 11238 || relsec->sh_size == 0
4fbb74a6 11239 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11240 continue;
428409d5 11241
41e92641
NC		 11242 is_rela = relsec->sh_type == SHT_RELA;
11243
11244 if (is_rela)
11245 {
3f5e193b
NC		 11246 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11247 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11248 return;
11249 }
11250 else
11251 {
3f5e193b
NC		 11252 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11253 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11254 return;
11255 }
11256
11257 /* SH uses RELA but uses in place value instead of the addend field. */
11258 if (elf_header.e_machine == EM_SH)
11259 is_rela = FALSE;
428409d5 11260
4fbb74a6 11261 symsec = section_headers + relsec->sh_link;
ba5cdace 11262 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11263
41e92641 11264 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11265 {
41e92641
NC		 11266 bfd_vma addend;
11267 unsigned int reloc_type;
11268 unsigned int reloc_size;
91d6fa6a 11269 unsigned char * rloc;
ba5cdace 11270 unsigned long sym_index;
4b78141a 11271
aca88567 11272 reloc_type = get_reloc_type (rp->r_info);
41e92641 11273
98fb390a 11274 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11275 continue;
98fb390a
NC		 11276 else if (is_none_reloc (reloc_type))
11277 continue;
11278 else if (is_32bit_abs_reloc (reloc_type)
11279 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11280 reloc_size = 4;
85acf597
RH		 11281 else if (is_64bit_abs_reloc (reloc_type)
11282 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11283 reloc_size = 8;
4dc3c23d
AM		 11284 else if (is_24bit_abs_reloc (reloc_type))
11285 reloc_size = 3;
aca88567
NC		 11286 else if (is_16bit_abs_reloc (reloc_type))
11287 reloc_size = 2;
11288 else
4b78141a 11289 {
41e92641 11290 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
74e1a04b 11291 reloc_type, printable_section_name (section));
4b78141a
NC		 11292 continue;
11293 }
103f02d3 11294
91d6fa6a 11295 rloc = start + rp->r_offset;
c8da6823 11296 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11297 {
11298 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11299 (unsigned long) rp->r_offset,
74e1a04b 11300 printable_section_name (section));
700dd8b7
L		 11301 continue;
11302 }
103f02d3 11303
ba5cdace
NC		 11304 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11305 if (sym_index >= num_syms)
11306 {
11307 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11308 sym_index, printable_section_name (section));
ba5cdace
NC		 11309 continue;
11310 }
11311 sym = symtab + sym_index;
41e92641
NC		 11312
11313 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11314 make sure that it is of an appropriate type.
11315
11316 Relocations against symbols without type can happen.
11317 Gcc -feliminate-dwarf2-dups may generate symbols
11318 without type for debug info.
11319
11320 Icc generates relocations against function symbols
11321 instead of local labels.
11322
11323 Relocations against object symbols can happen, eg when
11324 referencing a global array. For an example of this see
11325 the _clz.o binary in libgcc.a. */
aca88567 11326 if (sym != symtab
55f25fc3 11327 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11328 {
41e92641 11329 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11330 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11331 (long int)(rp - relocs),
74e1a04b 11332 printable_section_name (relsec));
aca88567 11333 continue;
5b18a4bc 11334 }
252b5132 11335
4dc3c23d
AM		 11336 addend = 0;
11337 if (is_rela)
11338 addend += rp->r_addend;
c47320c3
AM		 11339 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11340 partial_inplace. */
4dc3c23d
AM		 11341 if (!is_rela
11342 || (elf_header.e_machine == EM_XTENSA
11343 && reloc_type == 1)
11344 || ((elf_header.e_machine == EM_PJ
11345 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11346 && reloc_type == 1)
11347 || ((elf_header.e_machine == EM_D30V
11348 || elf_header.e_machine == EM_CYGNUS_D30V)
11349 && reloc_type == 12))
91d6fa6a 11350 addend += byte_get (rloc, reloc_size);
cb8f3167 11351
85acf597
RH		 11352 if (is_32bit_pcrel_reloc (reloc_type)
11353 || is_64bit_pcrel_reloc (reloc_type))
11354 {
11355 /* On HPPA, all pc-relative relocations are biased by 8. */
11356 if (elf_header.e_machine == EM_PARISC)
11357 addend -= 8;
91d6fa6a 11358 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11359 reloc_size);
11360 }
41e92641 11361 else
91d6fa6a 11362 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11363 }
252b5132 11364
5b18a4bc 11365 free (symtab);
41e92641 11366 free (relocs);
5b18a4bc
NC		 11367 break;
11368 }
5b18a4bc 11369}
103f02d3 11370
cf13d699
NC		 11371#ifdef SUPPORT_DISASSEMBLY
11372static int
11373disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11374{
74e1a04b 11375 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11376
74e1a04b 11377 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11378
11379 return 1;
11380}
11381#endif
11382
11383/* Reads in the contents of SECTION from FILE, returning a pointer
11384 to a malloc'ed buffer or NULL if something went wrong. */
11385
11386static char *
11387get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11388{
11389 bfd_size_type num_bytes;
11390
11391 num_bytes = section->sh_size;
11392
11393 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11394 {
11395 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11396 printable_section_name (section));
cf13d699
NC		 11397 return NULL;
11398 }
11399
3f5e193b
NC		 11400 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11401 _("section contents"));
cf13d699
NC		 11402}
11403
dd24e3da 11404
cf13d699
NC		 11405static void
11406dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11407{
11408 Elf_Internal_Shdr * relsec;
11409 bfd_size_type num_bytes;
cf13d699
NC		 11410 char * data;
11411 char * end;
11412 char * start;
cf13d699
NC		 11413 bfd_boolean some_strings_shown;
11414
11415 start = get_section_contents (section, file);
11416 if (start == NULL)
11417 return;
11418
74e1a04b 11419 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11420
11421 /* If the section being dumped has relocations against it the user might
11422 be expecting these relocations to have been applied. Check for this
11423 case and issue a warning message in order to avoid confusion.
11424 FIXME: Maybe we ought to have an option that dumps a section with
11425 relocs applied ? */
11426 for (relsec = section_headers;
11427 relsec < section_headers + elf_header.e_shnum;
11428 ++relsec)
11429 {
11430 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11431 || relsec->sh_info >= elf_header.e_shnum
11432 || section_headers + relsec->sh_info != section
11433 || relsec->sh_size == 0
11434 || relsec->sh_link >= elf_header.e_shnum)
11435 continue;
11436
11437 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11438 break;
11439 }
11440
11441 num_bytes = section->sh_size;
cf13d699
NC		 11442 data = start;
11443 end = start + num_bytes;
11444 some_strings_shown = FALSE;
11445
11446 while (data < end)
11447 {
11448 while (!ISPRINT (* data))
11449 if (++ data >= end)
11450 break;
11451
11452 if (data < end)
11453 {
071436c6
NC		 11454 size_t maxlen = end - data;
11455
cf13d699 11456#ifndef __MSVCRT__
c975cc98
NC		 11457 /* PR 11128: Use two separate invocations in order to work
11458 around bugs in the Solaris 8 implementation of printf. */
11459 printf (" [%6tx] ", data - start);
cf13d699 11460#else
071436c6 11461 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 11462#endif
4082ef84
NC		 11463 if (maxlen > 0)
11464 {
11465 print_symbol ((int) maxlen, data);
11466 putchar ('\n');
11467 data += strnlen (data, maxlen);
11468 }
11469 else
11470 {
11471 printf (_("<corrupt>\n"));
11472 data = end;
11473 }
cf13d699
NC		 11474 some_strings_shown = TRUE;
11475 }
11476 }
11477
11478 if (! some_strings_shown)
11479 printf (_(" No strings found in this section."));
11480
11481 free (start);
11482
11483 putchar ('\n');
11484}
11485
11486static void
11487dump_section_as_bytes (Elf_Internal_Shdr * section,
11488 FILE * file,
11489 bfd_boolean relocate)
11490{
11491 Elf_Internal_Shdr * relsec;
11492 bfd_size_type bytes;
11493 bfd_vma addr;
11494 unsigned char * data;
11495 unsigned char * start;
11496
11497 start = (unsigned char *) get_section_contents (section, file);
11498 if (start == NULL)
11499 return;
11500
74e1a04b 11501 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11502
11503 if (relocate)
11504 {
11505 apply_relocations (file, section, start);
11506 }
11507 else
11508 {
11509 /* If the section being dumped has relocations against it the user might
11510 be expecting these relocations to have been applied. Check for this
11511 case and issue a warning message in order to avoid confusion.
11512 FIXME: Maybe we ought to have an option that dumps a section with
11513 relocs applied ? */
11514 for (relsec = section_headers;
11515 relsec < section_headers + elf_header.e_shnum;
11516 ++relsec)
11517 {
11518 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11519 || relsec->sh_info >= elf_header.e_shnum
11520 || section_headers + relsec->sh_info != section
11521 || relsec->sh_size == 0
11522 || relsec->sh_link >= elf_header.e_shnum)
11523 continue;
11524
11525 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11526 break;
11527 }
11528 }
11529
11530 addr = section->sh_addr;
11531 bytes = section->sh_size;
11532 data = start;
11533
11534 while (bytes)
11535 {
11536 int j;
11537 int k;
11538 int lbytes;
11539
11540 lbytes = (bytes > 16 ? 16 : bytes);
11541
11542 printf (" 0x%8.8lx ", (unsigned long) addr);
11543
11544 for (j = 0; j < 16; j++)
11545 {
11546 if (j < lbytes)
11547 printf ("%2.2x", data[j]);
11548 else
11549 printf (" ");
11550
11551 if ((j & 3) == 3)
11552 printf (" ");
11553 }
11554
11555 for (j = 0; j < lbytes; j++)
11556 {
11557 k = data[j];
11558 if (k >= ' ' && k < 0x7f)
11559 printf ("%c", k);
11560 else
11561 printf (".");
11562 }
11563
11564 putchar ('\n');
11565
11566 data += lbytes;
11567 addr += lbytes;
11568 bytes -= lbytes;
11569 }
11570
11571 free (start);
11572
11573 putchar ('\n');
11574}
11575
4a114e3e 11576/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11577
11578static int
d3dbc530
AM		 11579uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11580 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 11581{
11582#ifndef HAVE_ZLIB_H
cf13d699
NC		 11583 return FALSE;
11584#else
11585 dwarf_size_type compressed_size = *size;
11586 unsigned char * compressed_buffer = *buffer;
11587 dwarf_size_type uncompressed_size;
11588 unsigned char * uncompressed_buffer;
11589 z_stream strm;
11590 int rc;
11591 dwarf_size_type header_size = 12;
11592
11593 /* Read the zlib header. In this case, it should be "ZLIB" followed
11594 by the uncompressed section size, 8 bytes in big-endian order. */
11595 if (compressed_size < header_size
11596 || ! streq ((char *) compressed_buffer, "ZLIB"))
11597 return 0;
11598
11599 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11600 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11601 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11602 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11603 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11604 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11605 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11606 uncompressed_size += compressed_buffer[11];
11607
11608 /* It is possible the section consists of several compressed
11609 buffers concatenated together, so we uncompress in a loop. */
11610 strm.zalloc = NULL;
11611 strm.zfree = NULL;
11612 strm.opaque = NULL;
11613 strm.avail_in = compressed_size - header_size;
11614 strm.next_in = (Bytef *) compressed_buffer + header_size;
11615 strm.avail_out = uncompressed_size;
3f5e193b 11616 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 11617
11618 rc = inflateInit (& strm);
11619 while (strm.avail_in > 0)
11620 {
11621 if (rc != Z_OK)
11622 goto fail;
11623 strm.next_out = ((Bytef *) uncompressed_buffer
11624 + (uncompressed_size - strm.avail_out));
11625 rc = inflate (&strm, Z_FINISH);
11626 if (rc != Z_STREAM_END)
11627 goto fail;
11628 rc = inflateReset (& strm);
11629 }
11630 rc = inflateEnd (& strm);
11631 if (rc != Z_OK
11632 || strm.avail_out != 0)
11633 goto fail;
11634
11635 free (compressed_buffer);
11636 *buffer = uncompressed_buffer;
11637 *size = uncompressed_size;
11638 return 1;
11639
11640 fail:
11641 free (uncompressed_buffer);
4a114e3e
L		 11642 /* Indicate decompression failure. */
11643 *buffer = NULL;
cf13d699
NC		 11644 return 0;
11645#endif /* HAVE_ZLIB_H */
11646}
11647
d966045b
DJ		 11648static int
11649load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 11650 Elf_Internal_Shdr * sec, void * file)
1007acb3 11651{
2cf0635d 11652 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 11653 char buf [64];
1007acb3 11654
19e6b90e
L		 11655 /* If it is already loaded, do nothing. */
11656 if (section->start != NULL)
11657 return 1;
1007acb3 11658
19e6b90e
L		 11659 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11660 section->address = sec->sh_addr;
3f5e193b
NC		 11661 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11662 sec->sh_offset, 1,
11663 sec->sh_size, buf);
59245841
NC		 11664 if (section->start == NULL)
11665 section->size = 0;
11666 else
11667 {
11668 section->size = sec->sh_size;
11669 if (uncompress_section_contents (&section->start, &section->size))
11670 sec->sh_size = section->size;
11671 }
4a114e3e 11672
1b315056
CS		 11673 if (section->start == NULL)
11674 return 0;
11675
19e6b90e 11676 if (debug_displays [debug].relocate)
3f5e193b 11677 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11678
1b315056 11679 return 1;
1007acb3
L		 11680}
11681
657d0d47
CC		 11682/* If this is not NULL, load_debug_section will only look for sections
11683 within the list of sections given here. */
11684unsigned int *section_subset = NULL;
11685
d966045b 11686int
2cf0635d 11687load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11688{
2cf0635d
NC		 11689 struct dwarf_section * section = &debug_displays [debug].section;
11690 Elf_Internal_Shdr * sec;
d966045b
DJ		 11691
11692 /* Locate the debug section. */
657d0d47 11693 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 11694 if (sec != NULL)
11695 section->name = section->uncompressed_name;
11696 else
11697 {
657d0d47 11698 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 11699 if (sec != NULL)
11700 section->name = section->compressed_name;
11701 }
11702 if (sec == NULL)
11703 return 0;
11704
657d0d47
CC		 11705 /* If we're loading from a subset of sections, and we've loaded
11706 a section matching this name before, it's likely that it's a
11707 different one. */
11708 if (section_subset != NULL)
11709 free_debug_section (debug);
11710
3f5e193b 11711 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 11712}
11713
19e6b90e
L		 11714void
11715free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 11716{
2cf0635d 11717 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 11718
19e6b90e
L		 11719 if (section->start == NULL)
11720 return;
1007acb3 11721
19e6b90e
L		 11722 free ((char *) section->start);
11723 section->start = NULL;
11724 section->address = 0;
11725 section->size = 0;
1007acb3
L		 11726}
11727
1007acb3 11728static int
657d0d47 11729display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 11730{
2cf0635d 11731 char * name = SECTION_NAME (section);
74e1a04b 11732 const char * print_name = printable_section_name (section);
19e6b90e
L		 11733 bfd_size_type length;
11734 int result = 1;
3f5e193b 11735 int i;
1007acb3 11736
19e6b90e
L		 11737 length = section->sh_size;
11738 if (length == 0)
1007acb3 11739 {
74e1a04b 11740 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 11741 return 0;
1007acb3 11742 }
5dff79d8
NC		 11743 if (section->sh_type == SHT_NOBITS)
11744 {
11745 /* There is no point in dumping the contents of a debugging section
11746 which has the NOBITS type - the bits in the file will be random.
11747 This can happen when a file containing a .eh_frame section is
11748 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 11749 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11750 print_name);
5dff79d8
NC		 11751 return 0;
11752 }
1007acb3 11753
0112cd26 11754 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 11755 name = ".debug_info";
1007acb3 11756
19e6b90e
L		 11757 /* See if we know how to display the contents of this section. */
11758 for (i = 0; i < max; i++)
1b315056 11759 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 11760 || (i == line && const_strneq (name, ".debug_line."))
1b315056 11761 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 11762 {
2cf0635d 11763 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 11764 int secondary = (section != find_section (name));
11765
11766 if (secondary)
3f5e193b 11767 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 11768
b40bf0a2
NC		 11769 if (i == line && const_strneq (name, ".debug_line."))
11770 sec->name = name;
11771 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 11772 sec->name = sec->uncompressed_name;
11773 else
11774 sec->name = sec->compressed_name;
3f5e193b
NC		 11775 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11776 section, file))
19e6b90e 11777 {
657d0d47
CC		 11778 /* If this debug section is part of a CU/TU set in a .dwp file,
11779 restrict load_debug_section to the sections in that set. */
11780 section_subset = find_cu_tu_set (file, shndx);
11781
19e6b90e 11782 result &= debug_displays[i].display (sec, file);
1007acb3 11783
657d0d47
CC		 11784 section_subset = NULL;
11785
d966045b 11786 if (secondary || (i != info && i != abbrev))
3f5e193b 11787 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 11788 }
1007acb3 11789
19e6b90e
L		 11790 break;
11791 }
1007acb3 11792
19e6b90e 11793 if (i == max)
1007acb3 11794 {
74e1a04b 11795 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 11796 result = 0;
1007acb3
L		 11797 }
11798
19e6b90e 11799 return result;
5b18a4bc 11800}
103f02d3 11801
aef1f6d0
DJ		 11802/* Set DUMP_SECTS for all sections where dumps were requested
11803 based on section name. */
11804
11805static void
11806initialise_dumps_byname (void)
11807{
2cf0635d 11808 struct dump_list_entry * cur;
aef1f6d0
DJ		 11809
11810 for (cur = dump_sects_byname; cur; cur = cur->next)
11811 {
11812 unsigned int i;
11813 int any;
11814
11815 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11816 if (streq (SECTION_NAME (section_headers + i), cur->name))
11817 {
09c11c86 11818 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11819 any = 1;
11820 }
11821
11822 if (!any)
11823 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11824 cur->name);
11825 }
11826}
11827
5b18a4bc 11828static void
2cf0635d 11829process_section_contents (FILE * file)
5b18a4bc 11830{
2cf0635d 11831 Elf_Internal_Shdr * section;
19e6b90e 11832 unsigned int i;
103f02d3 11833
19e6b90e
L		 11834 if (! do_dump)
11835 return;
103f02d3 11836
aef1f6d0
DJ		 11837 initialise_dumps_byname ();
11838
19e6b90e
L		 11839 for (i = 0, section = section_headers;
11840 i < elf_header.e_shnum && i < num_dump_sects;
11841 i++, section++)
11842 {
11843#ifdef SUPPORT_DISASSEMBLY
11844 if (dump_sects[i] & DISASS_DUMP)
11845 disassemble_section (section, file);
11846#endif
11847 if (dump_sects[i] & HEX_DUMP)
cf13d699 11848 dump_section_as_bytes (section, file, FALSE);
103f02d3 11849
cf13d699
NC		 11850 if (dump_sects[i] & RELOC_DUMP)
11851 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11852
11853 if (dump_sects[i] & STRING_DUMP)
11854 dump_section_as_strings (section, file);
cf13d699
NC		 11855
11856 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11857 display_debug_section (i, section, file);
5b18a4bc 11858 }
103f02d3 11859
19e6b90e
L		 11860 /* Check to see if the user requested a
11861 dump of a section that does not exist. */
11862 while (i++ < num_dump_sects)
11863 if (dump_sects[i])
11864 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11865}
103f02d3 11866
5b18a4bc 11867static void
19e6b90e 11868process_mips_fpe_exception (int mask)
5b18a4bc 11869{
19e6b90e
L		 11870 if (mask)
11871 {
11872 int first = 1;
11873 if (mask & OEX_FPU_INEX)
11874 fputs ("INEX", stdout), first = 0;
11875 if (mask & OEX_FPU_UFLO)
11876 printf ("%sUFLO", first ? "" : "|"), first = 0;
11877 if (mask & OEX_FPU_OFLO)
11878 printf ("%sOFLO", first ? "" : "|"), first = 0;
11879 if (mask & OEX_FPU_DIV0)
11880 printf ("%sDIV0", first ? "" : "|"), first = 0;
11881 if (mask & OEX_FPU_INVAL)
11882 printf ("%sINVAL", first ? "" : "|");
11883 }
5b18a4bc 11884 else
19e6b90e 11885 fputs ("0", stdout);
5b18a4bc 11886}
103f02d3 11887
f6f0e17b
NC		 11888/* Display's the value of TAG at location P. If TAG is
11889 greater than 0 it is assumed to be an unknown tag, and
11890 a message is printed to this effect. Otherwise it is
11891 assumed that a message has already been printed.
11892
11893 If the bottom bit of TAG is set it assumed to have a
11894 string value, otherwise it is assumed to have an integer
11895 value.
11896
11897 Returns an updated P pointing to the first unread byte
11898 beyond the end of TAG's value.
11899
11900 Reads at or beyond END will not be made. */
11901
11902static unsigned char *
11903display_tag_value (int tag,
11904 unsigned char * p,
11905 const unsigned char * const end)
11906{
11907 unsigned long val;
11908
11909 if (tag > 0)
11910 printf (" Tag_unknown_%d: ", tag);
11911
11912 if (p >= end)
11913 {
4082ef84 11914 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 11915 }
11916 else if (tag & 1)
11917 {
071436c6
NC		 11918 /* PR 17531 file: 027-19978-0.004. */
11919 size_t maxlen = (end - p) - 1;
11920
11921 putchar ('"');
4082ef84
NC		 11922 if (maxlen > 0)
11923 {
11924 print_symbol ((int) maxlen, (const char *) p);
11925 p += strnlen ((char *) p, maxlen) + 1;
11926 }
11927 else
11928 {
11929 printf (_("<corrupt string tag>"));
11930 p = (unsigned char *) end;
11931 }
071436c6 11932 printf ("\"\n");
f6f0e17b
NC		 11933 }
11934 else
11935 {
11936 unsigned int len;
11937
11938 val = read_uleb128 (p, &len, end);
11939 p += len;
11940 printf ("%ld (0x%lx)\n", val, val);
11941 }
11942
4082ef84 11943 assert (p <= end);
f6f0e17b
NC		 11944 return p;
11945}
11946
11c1ff18
PB		 11947/* ARM EABI attributes section. */
11948typedef struct
11949{
70e99720 11950 unsigned int tag;
2cf0635d 11951 const char * name;
11c1ff18 11952 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 11953 unsigned int type;
2cf0635d 11954 const char ** table;
11c1ff18
PB		 11955} arm_attr_public_tag;
11956
2cf0635d 11957static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11958 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11959 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11960static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11961static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11962 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11963static const char * arm_attr_tag_FP_arch[] =
bca38921 11964 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 11965 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 11966static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11967static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11968 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11969static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11970 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11971 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11972static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11973 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11974static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11975 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11976static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11977 {"Absolute", "PC-relative", "None"};
2cf0635d 11978static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11979 {"None", "direct", "GOT-indirect"};
2cf0635d 11980static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11981 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11982static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11983static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11984 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11985static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11986static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11987static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11988 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11989static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11990 {"Unused", "small", "int", "forced to int"};
2cf0635d 11991static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11992 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11993static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11994 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11995static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11996 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11997static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11998 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11999 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12000static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12001 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12002 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12003static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12004static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12005 {"Not Allowed", "Allowed"};
2cf0635d 12006static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12007 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12008static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12009 {"Not Allowed", "Allowed"};
12010static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12011 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12012 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12013static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12014static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12015 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12016 "TrustZone and Virtualization Extensions"};
dd24e3da 12017static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12018 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12019
12020#define LOOKUP(id, name) \
12021 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12022static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12023{
12024 {4, "CPU_raw_name", 1, NULL},
12025 {5, "CPU_name", 1, NULL},
12026 LOOKUP(6, CPU_arch),
12027 {7, "CPU_arch_profile", 0, NULL},
12028 LOOKUP(8, ARM_ISA_use),
12029 LOOKUP(9, THUMB_ISA_use),
75375b3e 12030 LOOKUP(10, FP_arch),
11c1ff18 12031 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12032 LOOKUP(12, Advanced_SIMD_arch),
12033 LOOKUP(13, PCS_config),
11c1ff18
PB		 12034 LOOKUP(14, ABI_PCS_R9_use),
12035 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12036 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12037 LOOKUP(17, ABI_PCS_GOT_use),
12038 LOOKUP(18, ABI_PCS_wchar_t),
12039 LOOKUP(19, ABI_FP_rounding),
12040 LOOKUP(20, ABI_FP_denormal),
12041 LOOKUP(21, ABI_FP_exceptions),
12042 LOOKUP(22, ABI_FP_user_exceptions),
12043 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12044 {24, "ABI_align_needed", 0, NULL},
12045 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12046 LOOKUP(26, ABI_enum_size),
12047 LOOKUP(27, ABI_HardFP_use),
12048 LOOKUP(28, ABI_VFP_args),
12049 LOOKUP(29, ABI_WMMX_args),
12050 LOOKUP(30, ABI_optimization_goals),
12051 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12052 {32, "compatibility", 0, NULL},
f5f53991 12053 LOOKUP(34, CPU_unaligned_access),
75375b3e 12054 LOOKUP(36, FP_HP_extension),
8e79c3df 12055 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12056 LOOKUP(42, MPextension_use),
12057 LOOKUP(44, DIV_use),
f5f53991
AS		 12058 {64, "nodefaults", 0, NULL},
12059 {65, "also_compatible_with", 0, NULL},
12060 LOOKUP(66, T2EE_use),
12061 {67, "conformance", 1, NULL},
12062 LOOKUP(68, Virtualization_use),
cd21e546 12063 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12064};
12065#undef LOOKUP
12066
11c1ff18 12067static unsigned char *
f6f0e17b
NC		 12068display_arm_attribute (unsigned char * p,
12069 const unsigned char * const end)
11c1ff18 12070{
70e99720 12071 unsigned int tag;
11c1ff18 12072 unsigned int len;
70e99720 12073 unsigned int val;
2cf0635d 12074 arm_attr_public_tag * attr;
11c1ff18 12075 unsigned i;
70e99720 12076 unsigned int type;
11c1ff18 12077
f6f0e17b 12078 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12079 p += len;
12080 attr = NULL;
2cf0635d 12081 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12082 {
12083 if (arm_attr_public_tags[i].tag == tag)
12084 {
12085 attr = &arm_attr_public_tags[i];
12086 break;
12087 }
12088 }
12089
12090 if (attr)
12091 {
12092 printf (" Tag_%s: ", attr->name);
12093 switch (attr->type)
12094 {
12095 case 0:
12096 switch (tag)
12097 {
12098 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12099 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12100 p += len;
12101 switch (val)
12102 {
2b692964
NC		 12103 case 0: printf (_("None\n")); break;
12104 case 'A': printf (_("Application\n")); break;
12105 case 'R': printf (_("Realtime\n")); break;
12106 case 'M': printf (_("Microcontroller\n")); break;
12107 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12108 default: printf ("??? (%d)\n", val); break;
12109 }
12110 break;
12111
75375b3e 12112 case 24: /* Tag_align_needed. */
f6f0e17b 12113 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12114 p += len;
12115 switch (val)
12116 {
2b692964
NC		 12117 case 0: printf (_("None\n")); break;
12118 case 1: printf (_("8-byte\n")); break;
12119 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12120 case 3: printf ("??? 3\n"); break;
12121 default:
12122 if (val <= 12)
dd24e3da 12123 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12124 1 << val);
12125 else
12126 printf ("??? (%d)\n", val);
12127 break;
12128 }
12129 break;
12130
12131 case 25: /* Tag_align_preserved. */
f6f0e17b 12132 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12133 p += len;
12134 switch (val)
12135 {
2b692964
NC		 12136 case 0: printf (_("None\n")); break;
12137 case 1: printf (_("8-byte, except leaf SP\n")); break;
12138 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12139 case 3: printf ("??? 3\n"); break;
12140 default:
12141 if (val <= 12)
dd24e3da 12142 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12143 1 << val);
12144 else
12145 printf ("??? (%d)\n", val);
12146 break;
12147 }
12148 break;
12149
11c1ff18 12150 case 32: /* Tag_compatibility. */
071436c6 12151 {
071436c6
NC		 12152 val = read_uleb128 (p, &len, end);
12153 p += len;
071436c6 12154 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12155 if (p < end - 1)
12156 {
12157 size_t maxlen = (end - p) - 1;
12158
12159 print_symbol ((int) maxlen, (const char *) p);
12160 p += strnlen ((char *) p, maxlen) + 1;
12161 }
12162 else
12163 {
12164 printf (_("<corrupt>"));
12165 p = (unsigned char *) end;
12166 }
071436c6 12167 putchar ('\n');
071436c6 12168 }
11c1ff18
PB		 12169 break;
12170
f5f53991 12171 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12172 /* PR 17531: file: 001-505008-0.01. */
12173 if (p < end)
12174 p++;
2b692964 12175 printf (_("True\n"));
f5f53991
AS		 12176 break;
12177
12178 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12179 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12180 p += len;
12181 if (val == 6 /* Tag_CPU_arch. */)
12182 {
f6f0e17b 12183 val = read_uleb128 (p, &len, end);
f5f53991 12184 p += len;
071436c6 12185 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12186 printf ("??? (%d)\n", val);
12187 else
12188 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12189 }
12190 else
12191 printf ("???\n");
071436c6
NC		 12192 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12193 ;
f5f53991
AS		 12194 break;
12195
11c1ff18 12196 default:
2cf0635d 12197 abort ();
11c1ff18
PB		 12198 }
12199 return p;
12200
12201 case 1:
f6f0e17b 12202 return display_tag_value (-1, p, end);
11c1ff18 12203 case 2:
f6f0e17b 12204 return display_tag_value (0, p, end);
11c1ff18
PB		 12205
12206 default:
12207 assert (attr->type & 0x80);
f6f0e17b 12208 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12209 p += len;
12210 type = attr->type & 0x7f;
12211 if (val >= type)
12212 printf ("??? (%d)\n", val);
12213 else
12214 printf ("%s\n", attr->table[val]);
12215 return p;
12216 }
12217 }
11c1ff18 12218
f6f0e17b 12219 return display_tag_value (tag, p, end);
11c1ff18
PB		 12220}
12221
104d59d1 12222static unsigned char *
60bca95a 12223display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12224 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12225 const unsigned char * const end)
104d59d1
JM		 12226{
12227 int tag;
12228 unsigned int len;
12229 int val;
104d59d1 12230
f6f0e17b 12231 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12232 p += len;
12233
12234 /* Tag_compatibility is the only generic GNU attribute defined at
12235 present. */
12236 if (tag == 32)
12237 {
f6f0e17b 12238 val = read_uleb128 (p, &len, end);
104d59d1 12239 p += len;
071436c6
NC		 12240
12241 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12242 if (p == end)
12243 {
071436c6 12244 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12245 warn (_("corrupt vendor attribute\n"));
12246 }
12247 else
12248 {
4082ef84
NC		 12249 if (p < end - 1)
12250 {
12251 size_t maxlen = (end - p) - 1;
071436c6 12252
4082ef84
NC		 12253 print_symbol ((int) maxlen, (const char *) p);
12254 p += strnlen ((char *) p, maxlen) + 1;
12255 }
12256 else
12257 {
12258 printf (_("<corrupt>"));
12259 p = (unsigned char *) end;
12260 }
071436c6 12261 putchar ('\n');
f6f0e17b 12262 }
104d59d1
JM		 12263 return p;
12264 }
12265
12266 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12267 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12268
f6f0e17b 12269 return display_tag_value (tag, p, end);
104d59d1
JM		 12270}
12271
34c8bcba 12272static unsigned char *
f6f0e17b
NC		 12273display_power_gnu_attribute (unsigned char * p,
12274 int tag,
12275 const unsigned char * const end)
34c8bcba 12276{
34c8bcba
JM		 12277 unsigned int len;
12278 int val;
12279
12280 if (tag == Tag_GNU_Power_ABI_FP)
12281 {
f6f0e17b 12282 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12283 p += len;
12284 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12285
34c8bcba
JM		 12286 switch (val)
12287 {
12288 case 0:
2b692964 12289 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12290 break;
12291 case 1:
2b692964 12292 printf (_("Hard float\n"));
34c8bcba
JM		 12293 break;
12294 case 2:
2b692964 12295 printf (_("Soft float\n"));
34c8bcba 12296 break;
3c7b9897 12297 case 3:
2b692964 12298 printf (_("Single-precision hard float\n"));
3c7b9897 12299 break;
34c8bcba
JM		 12300 default:
12301 printf ("??? (%d)\n", val);
12302 break;
12303 }
12304 return p;
12305 }
12306
c6e65352
DJ		 12307 if (tag == Tag_GNU_Power_ABI_Vector)
12308 {
f6f0e17b 12309 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12310 p += len;
12311 printf (" Tag_GNU_Power_ABI_Vector: ");
12312 switch (val)
12313 {
12314 case 0:
2b692964 12315 printf (_("Any\n"));
c6e65352
DJ		 12316 break;
12317 case 1:
2b692964 12318 printf (_("Generic\n"));
c6e65352
DJ		 12319 break;
12320 case 2:
12321 printf ("AltiVec\n");
12322 break;
12323 case 3:
12324 printf ("SPE\n");
12325 break;
12326 default:
12327 printf ("??? (%d)\n", val);
12328 break;
12329 }
12330 return p;
12331 }
12332
f82e0623
NF		 12333 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12334 {
f6f0e17b
NC		 12335 if (p == end)
12336 {
071436c6 12337 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12338 return p;
12339 }
0b4362b0 12340
f6f0e17b 12341 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12342 p += len;
12343 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12344 switch (val)
12345 {
12346 case 0:
2b692964 12347 printf (_("Any\n"));
f82e0623
NF		 12348 break;
12349 case 1:
12350 printf ("r3/r4\n");
12351 break;
12352 case 2:
2b692964 12353 printf (_("Memory\n"));
f82e0623
NF		 12354 break;
12355 default:
12356 printf ("??? (%d)\n", val);
12357 break;
12358 }
12359 return p;
12360 }
12361
f6f0e17b 12362 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12363}
12364
9e8c70f9
DM		 12365static void
12366display_sparc_hwcaps (int mask)
12367{
12368 if (mask)
12369 {
12370 int first = 1;
071436c6 12371
9e8c70f9
DM		 12372 if (mask & ELF_SPARC_HWCAP_MUL32)
12373 fputs ("mul32", stdout), first = 0;
12374 if (mask & ELF_SPARC_HWCAP_DIV32)
12375 printf ("%sdiv32", first ? "" : "|"), first = 0;
12376 if (mask & ELF_SPARC_HWCAP_FSMULD)
12377 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12378 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12379 printf ("%sv8plus", first ? "" : "|"), first = 0;
12380 if (mask & ELF_SPARC_HWCAP_POPC)
12381 printf ("%spopc", first ? "" : "|"), first = 0;
12382 if (mask & ELF_SPARC_HWCAP_VIS)
12383 printf ("%svis", first ? "" : "|"), first = 0;
12384 if (mask & ELF_SPARC_HWCAP_VIS2)
12385 printf ("%svis2", first ? "" : "|"), first = 0;
12386 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12387 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12388 if (mask & ELF_SPARC_HWCAP_FMAF)
12389 printf ("%sfmaf", first ? "" : "|"), first = 0;
12390 if (mask & ELF_SPARC_HWCAP_VIS3)
12391 printf ("%svis3", first ? "" : "|"), first = 0;
12392 if (mask & ELF_SPARC_HWCAP_HPC)
12393 printf ("%shpc", first ? "" : "|"), first = 0;
12394 if (mask & ELF_SPARC_HWCAP_RANDOM)
12395 printf ("%srandom", first ? "" : "|"), first = 0;
12396 if (mask & ELF_SPARC_HWCAP_TRANS)
12397 printf ("%strans", first ? "" : "|"), first = 0;
12398 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12399 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12400 if (mask & ELF_SPARC_HWCAP_IMA)
12401 printf ("%sima", first ? "" : "|"), first = 0;
12402 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12403 printf ("%scspare", first ? "" : "|"), first = 0;
12404 }
12405 else
071436c6
NC		 12406 fputc ('0', stdout);
12407 fputc ('\n', stdout);
9e8c70f9
DM		 12408}
12409
3d68f91c
JM		 12410static void
12411display_sparc_hwcaps2 (int mask)
12412{
12413 if (mask)
12414 {
12415 int first = 1;
071436c6 12416
3d68f91c
JM		 12417 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12418 fputs ("fjathplus", stdout), first = 0;
12419 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12420 printf ("%svis3b", first ? "" : "|"), first = 0;
12421 if (mask & ELF_SPARC_HWCAP2_ADP)
12422 printf ("%sadp", first ? "" : "|"), first = 0;
12423 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12424 printf ("%ssparc5", first ? "" : "|"), first = 0;
12425 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12426 printf ("%smwait", first ? "" : "|"), first = 0;
12427 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12428 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12429 if (mask & ELF_SPARC_HWCAP2_XMONT)
12430 printf ("%sxmont2", first ? "" : "|"), first = 0;
12431 if (mask & ELF_SPARC_HWCAP2_NSEC)
12432 printf ("%snsec", first ? "" : "|"), first = 0;
12433 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12434 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12435 if (mask & ELF_SPARC_HWCAP2_FJDES)
12436 printf ("%sfjdes", first ? "" : "|"), first = 0;
12437 if (mask & ELF_SPARC_HWCAP2_FJAES)
12438 printf ("%sfjaes", first ? "" : "|"), first = 0;
12439 }
12440 else
071436c6
NC		 12441 fputc ('0', stdout);
12442 fputc ('\n', stdout);
3d68f91c
JM		 12443}
12444
9e8c70f9 12445static unsigned char *
f6f0e17b
NC		 12446display_sparc_gnu_attribute (unsigned char * p,
12447 int tag,
12448 const unsigned char * const end)
9e8c70f9 12449{
3d68f91c
JM		 12450 unsigned int len;
12451 int val;
12452
9e8c70f9
DM		 12453 if (tag == Tag_GNU_Sparc_HWCAPS)
12454 {
f6f0e17b 12455 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12456 p += len;
12457 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12458 display_sparc_hwcaps (val);
12459 return p;
3d68f91c
JM		 12460 }
12461 if (tag == Tag_GNU_Sparc_HWCAPS2)
12462 {
12463 val = read_uleb128 (p, &len, end);
12464 p += len;
12465 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12466 display_sparc_hwcaps2 (val);
12467 return p;
12468 }
9e8c70f9 12469
f6f0e17b 12470 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12471}
12472
351cdf24
MF		 12473static void
12474print_mips_fp_abi_value (int val)
12475{
12476 switch (val)
12477 {
12478 case Val_GNU_MIPS_ABI_FP_ANY:
12479 printf (_("Hard or soft float\n"));
12480 break;
12481 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12482 printf (_("Hard float (double precision)\n"));
12483 break;
12484 case Val_GNU_MIPS_ABI_FP_SINGLE:
12485 printf (_("Hard float (single precision)\n"));
12486 break;
12487 case Val_GNU_MIPS_ABI_FP_SOFT:
12488 printf (_("Soft float\n"));
12489 break;
12490 case Val_GNU_MIPS_ABI_FP_OLD_64:
12491 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12492 break;
12493 case Val_GNU_MIPS_ABI_FP_XX:
12494 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12495 break;
12496 case Val_GNU_MIPS_ABI_FP_64:
12497 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12498 break;
12499 case Val_GNU_MIPS_ABI_FP_64A:
12500 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12501 break;
12502 default:
12503 printf ("??? (%d)\n", val);
12504 break;
12505 }
12506}
12507
2cf19d5c 12508static unsigned char *
f6f0e17b
NC		 12509display_mips_gnu_attribute (unsigned char * p,
12510 int tag,
12511 const unsigned char * const end)
2cf19d5c 12512{
2cf19d5c
JM		 12513 if (tag == Tag_GNU_MIPS_ABI_FP)
12514 {
f6f0e17b
NC		 12515 unsigned int len;
12516 int val;
12517
12518 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12519 p += len;
12520 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12521
351cdf24
MF		 12522 print_mips_fp_abi_value (val);
12523
2cf19d5c
JM		 12524 return p;
12525 }
12526
a9f58168
CF		 12527 if (tag == Tag_GNU_MIPS_ABI_MSA)
12528 {
12529 unsigned int len;
12530 int val;
12531
12532 val = read_uleb128 (p, &len, end);
12533 p += len;
12534 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12535
12536 switch (val)
12537 {
12538 case Val_GNU_MIPS_ABI_MSA_ANY:
12539 printf (_("Any MSA or not\n"));
12540 break;
12541 case Val_GNU_MIPS_ABI_MSA_128:
12542 printf (_("128-bit MSA\n"));
12543 break;
12544 default:
12545 printf ("??? (%d)\n", val);
12546 break;
12547 }
12548 return p;
12549 }
12550
f6f0e17b 12551 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12552}
12553
59e6276b 12554static unsigned char *
f6f0e17b
NC		 12555display_tic6x_attribute (unsigned char * p,
12556 const unsigned char * const end)
59e6276b
JM		 12557{
12558 int tag;
12559 unsigned int len;
12560 int val;
12561
f6f0e17b 12562 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12563 p += len;
12564
12565 switch (tag)
12566 {
75fa6dc1 12567 case Tag_ISA:
f6f0e17b 12568 val = read_uleb128 (p, &len, end);
59e6276b 12569 p += len;
75fa6dc1 12570 printf (" Tag_ISA: ");
59e6276b
JM		 12571
12572 switch (val)
12573 {
75fa6dc1 12574 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12575 printf (_("None\n"));
12576 break;
75fa6dc1 12577 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12578 printf ("C62x\n");
12579 break;
75fa6dc1 12580 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12581 printf ("C67x\n");
12582 break;
75fa6dc1 12583 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12584 printf ("C67x+\n");
12585 break;
75fa6dc1 12586 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12587 printf ("C64x\n");
12588 break;
75fa6dc1 12589 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12590 printf ("C64x+\n");
12591 break;
75fa6dc1 12592 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12593 printf ("C674x\n");
12594 break;
12595 default:
12596 printf ("??? (%d)\n", val);
12597 break;
12598 }
12599 return p;
12600
87779176 12601 case Tag_ABI_wchar_t:
f6f0e17b 12602 val = read_uleb128 (p, &len, end);
87779176
JM		 12603 p += len;
12604 printf (" Tag_ABI_wchar_t: ");
12605 switch (val)
12606 {
12607 case 0:
12608 printf (_("Not used\n"));
12609 break;
12610 case 1:
12611 printf (_("2 bytes\n"));
12612 break;
12613 case 2:
12614 printf (_("4 bytes\n"));
12615 break;
12616 default:
12617 printf ("??? (%d)\n", val);
12618 break;
12619 }
12620 return p;
12621
12622 case Tag_ABI_stack_align_needed:
f6f0e17b 12623 val = read_uleb128 (p, &len, end);
87779176
JM		 12624 p += len;
12625 printf (" Tag_ABI_stack_align_needed: ");
12626 switch (val)
12627 {
12628 case 0:
12629 printf (_("8-byte\n"));
12630 break;
12631 case 1:
12632 printf (_("16-byte\n"));
12633 break;
12634 default:
12635 printf ("??? (%d)\n", val);
12636 break;
12637 }
12638 return p;
12639
12640 case Tag_ABI_stack_align_preserved:
f6f0e17b 12641 val = read_uleb128 (p, &len, end);
87779176
JM		 12642 p += len;
12643 printf (" Tag_ABI_stack_align_preserved: ");
12644 switch (val)
12645 {
12646 case 0:
12647 printf (_("8-byte\n"));
12648 break;
12649 case 1:
12650 printf (_("16-byte\n"));
12651 break;
12652 default:
12653 printf ("??? (%d)\n", val);
12654 break;
12655 }
12656 return p;
12657
b5593623 12658 case Tag_ABI_DSBT:
f6f0e17b 12659 val = read_uleb128 (p, &len, end);
b5593623
JM		 12660 p += len;
12661 printf (" Tag_ABI_DSBT: ");
12662 switch (val)
12663 {
12664 case 0:
12665 printf (_("DSBT addressing not used\n"));
12666 break;
12667 case 1:
12668 printf (_("DSBT addressing used\n"));
12669 break;
12670 default:
12671 printf ("??? (%d)\n", val);
12672 break;
12673 }
12674 return p;
12675
87779176 12676 case Tag_ABI_PID:
f6f0e17b 12677 val = read_uleb128 (p, &len, end);
87779176
JM		 12678 p += len;
12679 printf (" Tag_ABI_PID: ");
12680 switch (val)
12681 {
12682 case 0:
12683 printf (_("Data addressing position-dependent\n"));
12684 break;
12685 case 1:
12686 printf (_("Data addressing position-independent, GOT near DP\n"));
12687 break;
12688 case 2:
12689 printf (_("Data addressing position-independent, GOT far from DP\n"));
12690 break;
12691 default:
12692 printf ("??? (%d)\n", val);
12693 break;
12694 }
12695 return p;
12696
12697 case Tag_ABI_PIC:
f6f0e17b 12698 val = read_uleb128 (p, &len, end);
87779176
JM		 12699 p += len;
12700 printf (" Tag_ABI_PIC: ");
12701 switch (val)
12702 {
12703 case 0:
12704 printf (_("Code addressing position-dependent\n"));
12705 break;
12706 case 1:
12707 printf (_("Code addressing position-independent\n"));
12708 break;
12709 default:
12710 printf ("??? (%d)\n", val);
12711 break;
12712 }
12713 return p;
12714
12715 case Tag_ABI_array_object_alignment:
f6f0e17b 12716 val = read_uleb128 (p, &len, end);
87779176
JM		 12717 p += len;
12718 printf (" Tag_ABI_array_object_alignment: ");
12719 switch (val)
12720 {
12721 case 0:
12722 printf (_("8-byte\n"));
12723 break;
12724 case 1:
12725 printf (_("4-byte\n"));
12726 break;
12727 case 2:
12728 printf (_("16-byte\n"));
12729 break;
12730 default:
12731 printf ("??? (%d)\n", val);
12732 break;
12733 }
12734 return p;
12735
12736 case Tag_ABI_array_object_align_expected:
f6f0e17b 12737 val = read_uleb128 (p, &len, end);
87779176
JM		 12738 p += len;
12739 printf (" Tag_ABI_array_object_align_expected: ");
12740 switch (val)
12741 {
12742 case 0:
12743 printf (_("8-byte\n"));
12744 break;
12745 case 1:
12746 printf (_("4-byte\n"));
12747 break;
12748 case 2:
12749 printf (_("16-byte\n"));
12750 break;
12751 default:
12752 printf ("??? (%d)\n", val);
12753 break;
12754 }
12755 return p;
12756
3cbd1c06 12757 case Tag_ABI_compatibility:
071436c6 12758 {
071436c6
NC		 12759 val = read_uleb128 (p, &len, end);
12760 p += len;
12761 printf (" Tag_ABI_compatibility: ");
071436c6 12762 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12763 if (p < end - 1)
12764 {
12765 size_t maxlen = (end - p) - 1;
12766
12767 print_symbol ((int) maxlen, (const char *) p);
12768 p += strnlen ((char *) p, maxlen) + 1;
12769 }
12770 else
12771 {
12772 printf (_("<corrupt>"));
12773 p = (unsigned char *) end;
12774 }
071436c6 12775 putchar ('\n');
071436c6
NC		 12776 return p;
12777 }
87779176
JM		 12778
12779 case Tag_ABI_conformance:
071436c6 12780 {
4082ef84
NC		 12781 printf (" Tag_ABI_conformance: \"");
12782 if (p < end - 1)
12783 {
12784 size_t maxlen = (end - p) - 1;
071436c6 12785
4082ef84
NC		 12786 print_symbol ((int) maxlen, (const char *) p);
12787 p += strnlen ((char *) p, maxlen) + 1;
12788 }
12789 else
12790 {
12791 printf (_("<corrupt>"));
12792 p = (unsigned char *) end;
12793 }
071436c6 12794 printf ("\"\n");
071436c6
NC		 12795 return p;
12796 }
59e6276b
JM		 12797 }
12798
f6f0e17b
NC		 12799 return display_tag_value (tag, p, end);
12800}
59e6276b 12801
f6f0e17b
NC		 12802static void
12803display_raw_attribute (unsigned char * p, unsigned char * end)
12804{
12805 unsigned long addr = 0;
12806 size_t bytes = end - p;
12807
e0a31db1 12808 assert (end > p);
f6f0e17b 12809 while (bytes)
87779176 12810 {
f6f0e17b
NC		 12811 int j;
12812 int k;
12813 int lbytes = (bytes > 16 ? 16 : bytes);
12814
12815 printf (" 0x%8.8lx ", addr);
12816
12817 for (j = 0; j < 16; j++)
12818 {
12819 if (j < lbytes)
12820 printf ("%2.2x", p[j]);
12821 else
12822 printf (" ");
12823
12824 if ((j & 3) == 3)
12825 printf (" ");
12826 }
12827
12828 for (j = 0; j < lbytes; j++)
12829 {
12830 k = p[j];
12831 if (k >= ' ' && k < 0x7f)
12832 printf ("%c", k);
12833 else
12834 printf (".");
12835 }
12836
12837 putchar ('\n');
12838
12839 p += lbytes;
12840 bytes -= lbytes;
12841 addr += lbytes;
87779176 12842 }
59e6276b 12843
f6f0e17b 12844 putchar ('\n');
59e6276b
JM		 12845}
12846
13761a11
NC		 12847static unsigned char *
12848display_msp430x_attribute (unsigned char * p,
12849 const unsigned char * const end)
12850{
12851 unsigned int len;
12852 int val;
12853 int tag;
12854
12855 tag = read_uleb128 (p, & len, end);
12856 p += len;
0b4362b0 12857
13761a11
NC		 12858 switch (tag)
12859 {
12860 case OFBA_MSPABI_Tag_ISA:
12861 val = read_uleb128 (p, &len, end);
12862 p += len;
12863 printf (" Tag_ISA: ");
12864 switch (val)
12865 {
12866 case 0: printf (_("None\n")); break;
12867 case 1: printf (_("MSP430\n")); break;
12868 case 2: printf (_("MSP430X\n")); break;
12869 default: printf ("??? (%d)\n", val); break;
12870 }
12871 break;
12872
12873 case OFBA_MSPABI_Tag_Code_Model:
12874 val = read_uleb128 (p, &len, end);
12875 p += len;
12876 printf (" Tag_Code_Model: ");
12877 switch (val)
12878 {
12879 case 0: printf (_("None\n")); break;
12880 case 1: printf (_("Small\n")); break;
12881 case 2: printf (_("Large\n")); break;
12882 default: printf ("??? (%d)\n", val); break;
12883 }
12884 break;
12885
12886 case OFBA_MSPABI_Tag_Data_Model:
12887 val = read_uleb128 (p, &len, end);
12888 p += len;
12889 printf (" Tag_Data_Model: ");
12890 switch (val)
12891 {
12892 case 0: printf (_("None\n")); break;
12893 case 1: printf (_("Small\n")); break;
12894 case 2: printf (_("Large\n")); break;
12895 case 3: printf (_("Restricted Large\n")); break;
12896 default: printf ("??? (%d)\n", val); break;
12897 }
12898 break;
12899
12900 default:
12901 printf (_(" <unknown tag %d>: "), tag);
12902
12903 if (tag & 1)
12904 {
071436c6 12905 putchar ('"');
4082ef84
NC		 12906 if (p < end - 1)
12907 {
12908 size_t maxlen = (end - p) - 1;
12909
12910 print_symbol ((int) maxlen, (const char *) p);
12911 p += strnlen ((char *) p, maxlen) + 1;
12912 }
12913 else
12914 {
12915 printf (_("<corrupt>"));
12916 p = (unsigned char *) end;
12917 }
071436c6 12918 printf ("\"\n");
13761a11
NC		 12919 }
12920 else
12921 {
12922 val = read_uleb128 (p, &len, end);
12923 p += len;
12924 printf ("%d (0x%x)\n", val, val);
12925 }
12926 break;
12927 }
12928
4082ef84 12929 assert (p <= end);
13761a11
NC		 12930 return p;
12931}
12932
11c1ff18 12933static int
60bca95a
NC		 12934process_attributes (FILE * file,
12935 const char * public_name,
104d59d1 12936 unsigned int proc_type,
f6f0e17b
NC		 12937 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12938 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 12939{
2cf0635d 12940 Elf_Internal_Shdr * sect;
11c1ff18
PB		 12941 unsigned i;
12942
12943 /* Find the section header so that we get the size. */
12944 for (i = 0, sect = section_headers;
12945 i < elf_header.e_shnum;
12946 i++, sect++)
12947 {
071436c6
NC		 12948 unsigned char * contents;
12949 unsigned char * p;
12950
104d59d1 12951 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 12952 continue;
12953
3f5e193b
NC		 12954 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12955 sect->sh_size, _("attributes"));
60bca95a 12956 if (contents == NULL)
11c1ff18 12957 continue;
60bca95a 12958
11c1ff18
PB		 12959 p = contents;
12960 if (*p == 'A')
12961 {
071436c6
NC		 12962 bfd_vma section_len;
12963
12964 section_len = sect->sh_size - 1;
11c1ff18 12965 p++;
60bca95a 12966
071436c6 12967 while (section_len > 0)
11c1ff18 12968 {
071436c6 12969 bfd_vma attr_len;
e9847026 12970 unsigned int namelen;
11c1ff18 12971 bfd_boolean public_section;
104d59d1 12972 bfd_boolean gnu_section;
11c1ff18 12973
071436c6 12974 if (section_len <= 4)
e0a31db1
NC		 12975 {
12976 error (_("Tag section ends prematurely\n"));
12977 break;
12978 }
071436c6 12979 attr_len = byte_get (p, 4);
11c1ff18 12980 p += 4;
60bca95a 12981
071436c6 12982 if (attr_len > section_len)
11c1ff18 12983 {
071436c6
NC		 12984 error (_("Bad attribute length (%u > %u)\n"),
12985 (unsigned) attr_len, (unsigned) section_len);
12986 attr_len = section_len;
11c1ff18 12987 }
74e1a04b 12988 /* PR 17531: file: 001-101425-0.004 */
071436c6 12989 else if (attr_len < 5)
74e1a04b 12990 {
071436c6 12991 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 12992 break;
12993 }
e9847026 12994
071436c6
NC		 12995 section_len -= attr_len;
12996 attr_len -= 4;
12997
12998 namelen = strnlen ((char *) p, attr_len) + 1;
12999 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13000 {
13001 error (_("Corrupt attribute section name\n"));
13002 break;
13003 }
13004
071436c6
NC		 13005 printf (_("Attribute Section: "));
13006 print_symbol (INT_MAX, (const char *) p);
13007 putchar ('\n');
60bca95a
NC		 13008
13009 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13010 public_section = TRUE;
13011 else
13012 public_section = FALSE;
60bca95a
NC		 13013
13014 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13015 gnu_section = TRUE;
13016 else
13017 gnu_section = FALSE;
60bca95a 13018
11c1ff18 13019 p += namelen;
071436c6 13020 attr_len -= namelen;
e0a31db1 13021
071436c6 13022 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13023 {
e0a31db1 13024 int tag;
11c1ff18
PB		 13025 int val;
13026 bfd_vma size;
071436c6 13027 unsigned char * end;
60bca95a 13028
e0a31db1 13029 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13030 if (attr_len < 6)
e0a31db1
NC		 13031 {
13032 error (_("Unused bytes at end of section\n"));
13033 section_len = 0;
13034 break;
13035 }
13036
13037 tag = *(p++);
11c1ff18 13038 size = byte_get (p, 4);
071436c6 13039 if (size > attr_len)
11c1ff18 13040 {
e9847026 13041 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13042 (unsigned) size, (unsigned) attr_len);
13043 size = attr_len;
11c1ff18 13044 }
e0a31db1
NC		 13045 /* PR binutils/17531: Safe handling of corrupt files. */
13046 if (size < 6)
13047 {
13048 error (_("Bad subsection length (%u < 6)\n"),
13049 (unsigned) size);
13050 section_len = 0;
13051 break;
13052 }
60bca95a 13053
071436c6 13054 attr_len -= size;
11c1ff18 13055 end = p + size - 1;
071436c6 13056 assert (end <= contents + sect->sh_size);
11c1ff18 13057 p += 4;
60bca95a 13058
11c1ff18
PB		 13059 switch (tag)
13060 {
13061 case 1:
2b692964 13062 printf (_("File Attributes\n"));
11c1ff18
PB		 13063 break;
13064 case 2:
2b692964 13065 printf (_("Section Attributes:"));
11c1ff18
PB		 13066 goto do_numlist;
13067 case 3:
2b692964 13068 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13069 do_numlist:
13070 for (;;)
13071 {
91d6fa6a 13072 unsigned int j;
60bca95a 13073
f6f0e17b 13074 val = read_uleb128 (p, &j, end);
91d6fa6a 13075 p += j;
11c1ff18
PB		 13076 if (val == 0)
13077 break;
13078 printf (" %d", val);
13079 }
13080 printf ("\n");
13081 break;
13082 default:
2b692964 13083 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13084 public_section = FALSE;
13085 break;
13086 }
60bca95a 13087
071436c6 13088 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13089 {
13090 while (p < end)
f6f0e17b 13091 p = display_pub_attribute (p, end);
071436c6 13092 assert (p <= end);
104d59d1 13093 }
071436c6 13094 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13095 {
13096 while (p < end)
13097 p = display_gnu_attribute (p,
f6f0e17b
NC		 13098 display_proc_gnu_attribute,
13099 end);
071436c6 13100 assert (p <= end);
11c1ff18 13101 }
071436c6 13102 else if (p < end)
11c1ff18 13103 {
071436c6 13104 printf (_(" Unknown attribute:\n"));
f6f0e17b 13105 display_raw_attribute (p, end);
11c1ff18
PB		 13106 p = end;
13107 }
071436c6
NC		 13108 else
13109 attr_len = 0;
11c1ff18
PB		 13110 }
13111 }
13112 }
13113 else
e9847026 13114 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13115
60bca95a 13116 free (contents);
11c1ff18
PB		 13117 }
13118 return 1;
13119}
13120
104d59d1 13121static int
2cf0635d 13122process_arm_specific (FILE * file)
104d59d1
JM		 13123{
13124 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13125 display_arm_attribute, NULL);
13126}
13127
34c8bcba 13128static int
2cf0635d 13129process_power_specific (FILE * file)
34c8bcba
JM		 13130{
13131 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13132 display_power_gnu_attribute);
13133}
13134
9e8c70f9
DM		 13135static int
13136process_sparc_specific (FILE * file)
13137{
13138 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13139 display_sparc_gnu_attribute);
13140}
13141
59e6276b
JM		 13142static int
13143process_tic6x_specific (FILE * file)
13144{
13145 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13146 display_tic6x_attribute, NULL);
13147}
13148
13761a11
NC		 13149static int
13150process_msp430x_specific (FILE * file)
13151{
13152 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13153 display_msp430x_attribute, NULL);
13154}
13155
ccb4c951
RS		 13156/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13157 Print the Address, Access and Initial fields of an entry at VMA ADDR
13158 and return the VMA of the next entry. */
13159
13160static bfd_vma
2cf0635d 13161print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 13162{
13163 printf (" ");
13164 print_vma (addr, LONG_HEX);
13165 printf (" ");
13166 if (addr < pltgot + 0xfff0)
13167 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13168 else
13169 printf ("%10s", "");
13170 printf (" ");
13171 if (data == NULL)
2b692964 13172 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13173 else
13174 {
13175 bfd_vma entry;
13176
13177 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13178 print_vma (entry, LONG_HEX);
13179 }
13180 return addr + (is_32bit_elf ? 4 : 8);
13181}
13182
861fb55a
DJ		 13183/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13184 PLTGOT. Print the Address and Initial fields of an entry at VMA
13185 ADDR and return the VMA of the next entry. */
13186
13187static bfd_vma
2cf0635d 13188print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13189{
13190 printf (" ");
13191 print_vma (addr, LONG_HEX);
13192 printf (" ");
13193 if (data == NULL)
2b692964 13194 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13195 else
13196 {
13197 bfd_vma entry;
13198
13199 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13200 print_vma (entry, LONG_HEX);
13201 }
13202 return addr + (is_32bit_elf ? 4 : 8);
13203}
13204
351cdf24
MF		 13205static void
13206print_mips_ases (unsigned int mask)
13207{
13208 if (mask & AFL_ASE_DSP)
13209 fputs ("\n\tDSP ASE", stdout);
13210 if (mask & AFL_ASE_DSPR2)
13211 fputs ("\n\tDSP R2 ASE", stdout);
13212 if (mask & AFL_ASE_EVA)
13213 fputs ("\n\tEnhanced VA Scheme", stdout);
13214 if (mask & AFL_ASE_MCU)
13215 fputs ("\n\tMCU (MicroController) ASE", stdout);
13216 if (mask & AFL_ASE_MDMX)
13217 fputs ("\n\tMDMX ASE", stdout);
13218 if (mask & AFL_ASE_MIPS3D)
13219 fputs ("\n\tMIPS-3D ASE", stdout);
13220 if (mask & AFL_ASE_MT)
13221 fputs ("\n\tMT ASE", stdout);
13222 if (mask & AFL_ASE_SMARTMIPS)
13223 fputs ("\n\tSmartMIPS ASE", stdout);
13224 if (mask & AFL_ASE_VIRT)
13225 fputs ("\n\tVZ ASE", stdout);
13226 if (mask & AFL_ASE_MSA)
13227 fputs ("\n\tMSA ASE", stdout);
13228 if (mask & AFL_ASE_MIPS16)
13229 fputs ("\n\tMIPS16 ASE", stdout);
13230 if (mask & AFL_ASE_MICROMIPS)
13231 fputs ("\n\tMICROMIPS ASE", stdout);
13232 if (mask & AFL_ASE_XPA)
13233 fputs ("\n\tXPA ASE", stdout);
13234 if (mask == 0)
13235 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13236 else if ((mask & ~AFL_ASE_MASK) != 0)
13237 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13238}
13239
13240static void
13241print_mips_isa_ext (unsigned int isa_ext)
13242{
13243 switch (isa_ext)
13244 {
13245 case 0:
13246 fputs (_("None"), stdout);
13247 break;
13248 case AFL_EXT_XLR:
13249 fputs ("RMI XLR", stdout);
13250 break;
2c629856
N		 13251 case AFL_EXT_OCTEON3:
13252 fputs ("Cavium Networks Octeon3", stdout);
13253 break;
351cdf24
MF		 13254 case AFL_EXT_OCTEON2:
13255 fputs ("Cavium Networks Octeon2", stdout);
13256 break;
13257 case AFL_EXT_OCTEONP:
13258 fputs ("Cavium Networks OcteonP", stdout);
13259 break;
13260 case AFL_EXT_LOONGSON_3A:
13261 fputs ("Loongson 3A", stdout);
13262 break;
13263 case AFL_EXT_OCTEON:
13264 fputs ("Cavium Networks Octeon", stdout);
13265 break;
13266 case AFL_EXT_5900:
13267 fputs ("Toshiba R5900", stdout);
13268 break;
13269 case AFL_EXT_4650:
13270 fputs ("MIPS R4650", stdout);
13271 break;
13272 case AFL_EXT_4010:
13273 fputs ("LSI R4010", stdout);
13274 break;
13275 case AFL_EXT_4100:
13276 fputs ("NEC VR4100", stdout);
13277 break;
13278 case AFL_EXT_3900:
13279 fputs ("Toshiba R3900", stdout);
13280 break;
13281 case AFL_EXT_10000:
13282 fputs ("MIPS R10000", stdout);
13283 break;
13284 case AFL_EXT_SB1:
13285 fputs ("Broadcom SB-1", stdout);
13286 break;
13287 case AFL_EXT_4111:
13288 fputs ("NEC VR4111/VR4181", stdout);
13289 break;
13290 case AFL_EXT_4120:
13291 fputs ("NEC VR4120", stdout);
13292 break;
13293 case AFL_EXT_5400:
13294 fputs ("NEC VR5400", stdout);
13295 break;
13296 case AFL_EXT_5500:
13297 fputs ("NEC VR5500", stdout);
13298 break;
13299 case AFL_EXT_LOONGSON_2E:
13300 fputs ("ST Microelectronics Loongson 2E", stdout);
13301 break;
13302 case AFL_EXT_LOONGSON_2F:
13303 fputs ("ST Microelectronics Loongson 2F", stdout);
13304 break;
13305 default:
00ac7aa0 13306 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13307 }
13308}
13309
13310static int
13311get_mips_reg_size (int reg_size)
13312{
13313 return (reg_size == AFL_REG_NONE) ? 0
13314 : (reg_size == AFL_REG_32) ? 32
13315 : (reg_size == AFL_REG_64) ? 64
13316 : (reg_size == AFL_REG_128) ? 128
13317 : -1;
13318}
13319
19e6b90e 13320static int
2cf0635d 13321process_mips_specific (FILE * file)
5b18a4bc 13322{
2cf0635d 13323 Elf_Internal_Dyn * entry;
351cdf24 13324 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13325 size_t liblist_offset = 0;
13326 size_t liblistno = 0;
13327 size_t conflictsno = 0;
13328 size_t options_offset = 0;
13329 size_t conflicts_offset = 0;
861fb55a
DJ		 13330 size_t pltrelsz = 0;
13331 size_t pltrel = 0;
ccb4c951 13332 bfd_vma pltgot = 0;
861fb55a
DJ		 13333 bfd_vma mips_pltgot = 0;
13334 bfd_vma jmprel = 0;
ccb4c951
RS		 13335 bfd_vma local_gotno = 0;
13336 bfd_vma gotsym = 0;
13337 bfd_vma symtabno = 0;
103f02d3 13338
2cf19d5c
JM		 13339 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13340 display_mips_gnu_attribute);
13341
351cdf24
MF		 13342 sect = find_section (".MIPS.abiflags");
13343
13344 if (sect != NULL)
13345 {
13346 Elf_External_ABIFlags_v0 *abiflags_ext;
13347 Elf_Internal_ABIFlags_v0 abiflags_in;
13348
13349 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13350 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13351 else
13352 {
13353 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13354 sect->sh_size, _("MIPS ABI Flags section"));
13355 if (abiflags_ext)
13356 {
13357 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13358 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13359 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13360 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13361 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13362 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13363 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13364 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13365 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13366 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13367 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13368
13369 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13370 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13371 if (abiflags_in.isa_rev > 1)
13372 printf ("r%d", abiflags_in.isa_rev);
13373 printf ("\nGPR size: %d",
13374 get_mips_reg_size (abiflags_in.gpr_size));
13375 printf ("\nCPR1 size: %d",
13376 get_mips_reg_size (abiflags_in.cpr1_size));
13377 printf ("\nCPR2 size: %d",
13378 get_mips_reg_size (abiflags_in.cpr2_size));
13379 fputs ("\nFP ABI: ", stdout);
13380 print_mips_fp_abi_value (abiflags_in.fp_abi);
13381 fputs ("ISA Extension: ", stdout);
13382 print_mips_isa_ext (abiflags_in.isa_ext);
13383 fputs ("\nASEs:", stdout);
13384 print_mips_ases (abiflags_in.ases);
13385 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13386 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13387 fputc ('\n', stdout);
13388 free (abiflags_ext);
13389 }
13390 }
13391 }
13392
19e6b90e
L		 13393 /* We have a lot of special sections. Thanks SGI! */
13394 if (dynamic_section == NULL)
13395 /* No information available. */
13396 return 0;
252b5132 13397
071436c6
NC		 13398 for (entry = dynamic_section;
13399 /* PR 17531 file: 012-50589-0.004. */
13400 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13401 ++entry)
252b5132
RH		 13402 switch (entry->d_tag)
13403 {
13404 case DT_MIPS_LIBLIST:
d93f0186
NC		 13405 liblist_offset
13406 = offset_from_vma (file, entry->d_un.d_val,
13407 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13408 break;
13409 case DT_MIPS_LIBLISTNO:
13410 liblistno = entry->d_un.d_val;
13411 break;
13412 case DT_MIPS_OPTIONS:
d93f0186 13413 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13414 break;
13415 case DT_MIPS_CONFLICT:
d93f0186
NC		 13416 conflicts_offset
13417 = offset_from_vma (file, entry->d_un.d_val,
13418 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13419 break;
13420 case DT_MIPS_CONFLICTNO:
13421 conflictsno = entry->d_un.d_val;
13422 break;
ccb4c951 13423 case DT_PLTGOT:
861fb55a
DJ		 13424 pltgot = entry->d_un.d_ptr;
13425 break;
ccb4c951
RS		 13426 case DT_MIPS_LOCAL_GOTNO:
13427 local_gotno = entry->d_un.d_val;
13428 break;
13429 case DT_MIPS_GOTSYM:
13430 gotsym = entry->d_un.d_val;
13431 break;
13432 case DT_MIPS_SYMTABNO:
13433 symtabno = entry->d_un.d_val;
13434 break;
861fb55a
DJ		 13435 case DT_MIPS_PLTGOT:
13436 mips_pltgot = entry->d_un.d_ptr;
13437 break;
13438 case DT_PLTREL:
13439 pltrel = entry->d_un.d_val;
13440 break;
13441 case DT_PLTRELSZ:
13442 pltrelsz = entry->d_un.d_val;
13443 break;
13444 case DT_JMPREL:
13445 jmprel = entry->d_un.d_ptr;
13446 break;
252b5132
RH		 13447 default:
13448 break;
13449 }
13450
13451 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13452 {
2cf0635d 13453 Elf32_External_Lib * elib;
252b5132
RH		 13454 size_t cnt;
13455
3f5e193b
NC		 13456 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13457 liblistno,
13458 sizeof (Elf32_External_Lib),
9cf03b7e 13459 _("liblist section data"));
a6e9f9df 13460 if (elib)
252b5132 13461 {
2b692964 13462 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13463 (unsigned long) liblistno);
2b692964 13464 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13465 stdout);
13466
13467 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13468 {
a6e9f9df 13469 Elf32_Lib liblist;
91d6fa6a 13470 time_t atime;
a6e9f9df 13471 char timebuf[20];
2cf0635d 13472 struct tm * tmp;
a6e9f9df
AM		 13473
13474 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13475 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13476 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13477 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13478 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13479
91d6fa6a 13480 tmp = gmtime (&atime);
e9e44622
JJ		 13481 snprintf (timebuf, sizeof (timebuf),
13482 "%04u-%02u-%02uT%02u:%02u:%02u",
13483 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13484 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13485
31104126 13486 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13487 if (VALID_DYNAMIC_NAME (liblist.l_name))
13488 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13489 else
2b692964 13490 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13491 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13492 liblist.l_version);
a6e9f9df
AM		 13493
13494 if (liblist.l_flags == 0)
2b692964 13495 puts (_(" NONE"));
a6e9f9df
AM		 13496 else
13497 {
13498 static const struct
252b5132 13499 {
2cf0635d 13500 const char * name;
a6e9f9df 13501 int bit;
252b5132 13502 }
a6e9f9df
AM		 13503 l_flags_vals[] =
13504 {
13505 { " EXACT_MATCH", LL_EXACT_MATCH },
13506 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13507 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13508 { " EXPORTS", LL_EXPORTS },
13509 { " DELAY_LOAD", LL_DELAY_LOAD },
13510 { " DELTA", LL_DELTA }
13511 };
13512 int flags = liblist.l_flags;
13513 size_t fcnt;
13514
60bca95a 13515 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13516 if ((flags & l_flags_vals[fcnt].bit) != 0)
13517 {
13518 fputs (l_flags_vals[fcnt].name, stdout);
13519 flags ^= l_flags_vals[fcnt].bit;
13520 }
13521 if (flags != 0)
13522 printf (" %#x", (unsigned int) flags);
252b5132 13523
a6e9f9df
AM		 13524 puts ("");
13525 }
252b5132 13526 }
252b5132 13527
a6e9f9df
AM		 13528 free (elib);
13529 }
252b5132
RH		 13530 }
13531
13532 if (options_offset != 0)
13533 {
2cf0635d 13534 Elf_External_Options * eopt;
2cf0635d
NC		 13535 Elf_Internal_Options * iopt;
13536 Elf_Internal_Options * option;
252b5132
RH		 13537 size_t offset;
13538 int cnt;
351cdf24 13539 sect = section_headers;
252b5132
RH		 13540
13541 /* Find the section header so that we get the size. */
071436c6
NC		 13542 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13543 /* PR 17533 file: 012-277276-0.004. */
13544 if (sect == NULL)
13545 {
13546 error (_("No MIPS_OPTIONS header found\n"));
13547 return 0;
13548 }
252b5132 13549
3f5e193b
NC		 13550 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13551 sect->sh_size, _("options"));
a6e9f9df 13552 if (eopt)
252b5132 13553 {
3f5e193b
NC		 13554 iopt = (Elf_Internal_Options *)
13555 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13556 if (iopt == NULL)
13557 {
8b73c356 13558 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 13559 return 0;
13560 }
76da6bbe 13561
a6e9f9df
AM		 13562 offset = cnt = 0;
13563 option = iopt;
252b5132 13564
a6e9f9df
AM		 13565 while (offset < sect->sh_size)
13566 {
2cf0635d 13567 Elf_External_Options * eoption;
252b5132 13568
a6e9f9df 13569 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13570
a6e9f9df
AM		 13571 option->kind = BYTE_GET (eoption->kind);
13572 option->size = BYTE_GET (eoption->size);
13573 option->section = BYTE_GET (eoption->section);
13574 option->info = BYTE_GET (eoption->info);
76da6bbe 13575
a6e9f9df 13576 offset += option->size;
252b5132 13577
a6e9f9df
AM		 13578 ++option;
13579 ++cnt;
13580 }
252b5132 13581
a6e9f9df 13582 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 13583 printable_section_name (sect), cnt);
76da6bbe 13584
a6e9f9df 13585 option = iopt;
252b5132 13586
a6e9f9df 13587 while (cnt-- > 0)
252b5132 13588 {
a6e9f9df
AM		 13589 size_t len;
13590
13591 switch (option->kind)
252b5132 13592 {
a6e9f9df
AM		 13593 case ODK_NULL:
13594 /* This shouldn't happen. */
13595 printf (" NULL %d %lx", option->section, option->info);
13596 break;
13597 case ODK_REGINFO:
13598 printf (" REGINFO ");
13599 if (elf_header.e_machine == EM_MIPS)
13600 {
13601 /* 32bit form. */
2cf0635d 13602 Elf32_External_RegInfo * ereg;
b34976b6 13603 Elf32_RegInfo reginfo;
a6e9f9df
AM		 13604
13605 ereg = (Elf32_External_RegInfo *) (option + 1);
13606 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13607 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13608 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13609 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13610 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13611 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13612
13613 printf ("GPR %08lx GP 0x%lx\n",
13614 reginfo.ri_gprmask,
13615 (unsigned long) reginfo.ri_gp_value);
13616 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13617 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13618 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13619 }
13620 else
13621 {
13622 /* 64 bit form. */
2cf0635d 13623 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 13624 Elf64_Internal_RegInfo reginfo;
13625
13626 ereg = (Elf64_External_RegInfo *) (option + 1);
13627 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13628 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13629 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13630 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13631 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 13632 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 13633
13634 printf ("GPR %08lx GP 0x",
13635 reginfo.ri_gprmask);
13636 printf_vma (reginfo.ri_gp_value);
13637 printf ("\n");
13638
13639 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13640 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13641 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13642 }
13643 ++option;
13644 continue;
13645 case ODK_EXCEPTIONS:
13646 fputs (" EXCEPTIONS fpe_min(", stdout);
13647 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13648 fputs (") fpe_max(", stdout);
13649 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13650 fputs (")", stdout);
13651
13652 if (option->info & OEX_PAGE0)
13653 fputs (" PAGE0", stdout);
13654 if (option->info & OEX_SMM)
13655 fputs (" SMM", stdout);
13656 if (option->info & OEX_FPDBUG)
13657 fputs (" FPDBUG", stdout);
13658 if (option->info & OEX_DISMISS)
13659 fputs (" DISMISS", stdout);
13660 break;
13661 case ODK_PAD:
13662 fputs (" PAD ", stdout);
13663 if (option->info & OPAD_PREFIX)
13664 fputs (" PREFIX", stdout);
13665 if (option->info & OPAD_POSTFIX)
13666 fputs (" POSTFIX", stdout);
13667 if (option->info & OPAD_SYMBOL)
13668 fputs (" SYMBOL", stdout);
13669 break;
13670 case ODK_HWPATCH:
13671 fputs (" HWPATCH ", stdout);
13672 if (option->info & OHW_R4KEOP)
13673 fputs (" R4KEOP", stdout);
13674 if (option->info & OHW_R8KPFETCH)
13675 fputs (" R8KPFETCH", stdout);
13676 if (option->info & OHW_R5KEOP)
13677 fputs (" R5KEOP", stdout);
13678 if (option->info & OHW_R5KCVTL)
13679 fputs (" R5KCVTL", stdout);
13680 break;
13681 case ODK_FILL:
13682 fputs (" FILL ", stdout);
13683 /* XXX Print content of info word? */
13684 break;
13685 case ODK_TAGS:
13686 fputs (" TAGS ", stdout);
13687 /* XXX Print content of info word? */
13688 break;
13689 case ODK_HWAND:
13690 fputs (" HWAND ", stdout);
13691 if (option->info & OHWA0_R4KEOP_CHECKED)
13692 fputs (" R4KEOP_CHECKED", stdout);
13693 if (option->info & OHWA0_R4KEOP_CLEAN)
13694 fputs (" R4KEOP_CLEAN", stdout);
13695 break;
13696 case ODK_HWOR:
13697 fputs (" HWOR ", stdout);
13698 if (option->info & OHWA0_R4KEOP_CHECKED)
13699 fputs (" R4KEOP_CHECKED", stdout);
13700 if (option->info & OHWA0_R4KEOP_CLEAN)
13701 fputs (" R4KEOP_CLEAN", stdout);
13702 break;
13703 case ODK_GP_GROUP:
13704 printf (" GP_GROUP %#06lx self-contained %#06lx",
13705 option->info & OGP_GROUP,
13706 (option->info & OGP_SELF) >> 16);
13707 break;
13708 case ODK_IDENT:
13709 printf (" IDENT %#06lx self-contained %#06lx",
13710 option->info & OGP_GROUP,
13711 (option->info & OGP_SELF) >> 16);
13712 break;
13713 default:
13714 /* This shouldn't happen. */
13715 printf (" %3d ??? %d %lx",
13716 option->kind, option->section, option->info);
13717 break;
252b5132 13718 }
a6e9f9df 13719
2cf0635d 13720 len = sizeof (* eopt);
a6e9f9df
AM		 13721 while (len < option->size)
13722 if (((char *) option)[len] >= ' '
13723 && ((char *) option)[len] < 0x7f)
13724 printf ("%c", ((char *) option)[len++]);
13725 else
13726 printf ("\\%03o", ((char *) option)[len++]);
13727
13728 fputs ("\n", stdout);
252b5132 13729 ++option;
252b5132
RH		 13730 }
13731
a6e9f9df 13732 free (eopt);
252b5132 13733 }
252b5132
RH		 13734 }
13735
13736 if (conflicts_offset != 0 && conflictsno != 0)
13737 {
2cf0635d 13738 Elf32_Conflict * iconf;
252b5132
RH		 13739 size_t cnt;
13740
13741 if (dynamic_symbols == NULL)
13742 {
591a748a 13743 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 13744 return 0;
13745 }
13746
3f5e193b 13747 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 13748 if (iconf == NULL)
13749 {
8b73c356 13750 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 13751 return 0;
13752 }
13753
9ea033b2 13754 if (is_32bit_elf)
252b5132 13755 {
2cf0635d 13756 Elf32_External_Conflict * econf32;
a6e9f9df 13757
3f5e193b
NC		 13758 econf32 = (Elf32_External_Conflict *)
13759 get_data (NULL, file, conflicts_offset, conflictsno,
13760 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 13761 if (!econf32)
13762 return 0;
252b5132
RH		 13763
13764 for (cnt = 0; cnt < conflictsno; ++cnt)
13765 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 13766
13767 free (econf32);
252b5132
RH		 13768 }
13769 else
13770 {
2cf0635d 13771 Elf64_External_Conflict * econf64;
a6e9f9df 13772
3f5e193b
NC		 13773 econf64 = (Elf64_External_Conflict *)
13774 get_data (NULL, file, conflicts_offset, conflictsno,
13775 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 13776 if (!econf64)
13777 return 0;
252b5132
RH		 13778
13779 for (cnt = 0; cnt < conflictsno; ++cnt)
13780 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 13781
13782 free (econf64);
252b5132
RH		 13783 }
13784
c7e7ca54
NC		 13785 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13786 (unsigned long) conflictsno);
252b5132
RH		 13787 puts (_(" Num: Index Value Name"));
13788
13789 for (cnt = 0; cnt < conflictsno; ++cnt)
13790 {
b34976b6 13791 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 13792
13793 if (iconf[cnt] >= num_dynamic_syms)
13794 printf (_("<corrupt symbol index>"));
d79b3d50 13795 else
e0a31db1
NC		 13796 {
13797 Elf_Internal_Sym * psym;
13798
13799 psym = & dynamic_symbols[iconf[cnt]];
13800 print_vma (psym->st_value, FULL_HEX);
13801 putchar (' ');
13802 if (VALID_DYNAMIC_NAME (psym->st_name))
13803 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13804 else
13805 printf (_("<corrupt: %14ld>"), psym->st_name);
13806 }
31104126 13807 putchar ('\n');
252b5132
RH		 13808 }
13809
252b5132
RH		 13810 free (iconf);
13811 }
13812
ccb4c951
RS		 13813 if (pltgot != 0 && local_gotno != 0)
13814 {
91d6fa6a 13815 bfd_vma ent, local_end, global_end;
bbeee7ea 13816 size_t i, offset;
2cf0635d 13817 unsigned char * data;
bbeee7ea 13818 int addr_size;
ccb4c951 13819
91d6fa6a 13820 ent = pltgot;
ccb4c951
RS		 13821 addr_size = (is_32bit_elf ? 4 : 8);
13822 local_end = pltgot + local_gotno * addr_size;
ccb4c951 13823
74e1a04b
NC		 13824 /* PR binutils/17533 file: 012-111227-0.004 */
13825 if (symtabno < gotsym)
13826 {
13827 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13828 (long) gotsym, (long) symtabno);
13829 return 0;
13830 }
13831
13832 global_end = local_end + (symtabno - gotsym) * addr_size;
13833 assert (global_end >= local_end);
ccb4c951 13834 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 13835 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 13836 global_end - pltgot, 1,
13837 _("Global Offset Table data"));
59245841
NC		 13838 if (data == NULL)
13839 return 0;
13840
ccb4c951
RS		 13841 printf (_("\nPrimary GOT:\n"));
13842 printf (_(" Canonical gp value: "));
13843 print_vma (pltgot + 0x7ff0, LONG_HEX);
13844 printf ("\n\n");
13845
13846 printf (_(" Reserved entries:\n"));
13847 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 13848 addr_size * 2, _("Address"), _("Access"),
13849 addr_size * 2, _("Initial"));
91d6fa6a 13850 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13851 printf (_(" Lazy resolver\n"));
ccb4c951 13852 if (data
91d6fa6a 13853 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 13854 >> (addr_size * 8 - 1)) != 0)
13855 {
91d6fa6a 13856 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13857 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 13858 }
13859 printf ("\n");
13860
91d6fa6a 13861 if (ent < local_end)
ccb4c951
RS		 13862 {
13863 printf (_(" Local entries:\n"));
cc5914eb 13864 printf (" %*s %10s %*s\n",
2b692964
NC		 13865 addr_size * 2, _("Address"), _("Access"),
13866 addr_size * 2, _("Initial"));
91d6fa6a 13867 while (ent < local_end)
ccb4c951 13868 {
91d6fa6a 13869 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 13870 printf ("\n");
13871 }
13872 printf ("\n");
13873 }
13874
13875 if (gotsym < symtabno)
13876 {
13877 int sym_width;
13878
13879 printf (_(" Global entries:\n"));
cc5914eb 13880 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 13881 addr_size * 2, _("Address"),
13882 _("Access"),
2b692964 13883 addr_size * 2, _("Initial"),
9cf03b7e
NC		 13884 addr_size * 2, _("Sym.Val."),
13885 _("Type"),
13886 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13887 _("Ndx"), _("Name"));
0b4362b0 13888
ccb4c951 13889 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 13890
ccb4c951
RS		 13891 for (i = gotsym; i < symtabno; i++)
13892 {
91d6fa6a 13893 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951 13894 printf (" ");
e0a31db1
NC		 13895
13896 if (dynamic_symbols == NULL)
13897 printf (_("<no dynamic symbols>"));
13898 else if (i < num_dynamic_syms)
13899 {
13900 Elf_Internal_Sym * psym = dynamic_symbols + i;
13901
13902 print_vma (psym->st_value, LONG_HEX);
13903 printf (" %-7s %3s ",
13904 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13905 get_symbol_index_type (psym->st_shndx));
13906
13907 if (VALID_DYNAMIC_NAME (psym->st_name))
13908 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13909 else
13910 printf (_("<corrupt: %14ld>"), psym->st_name);
13911 }
ccb4c951 13912 else
7fc5ac57
JBG		 13913 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
13914 (unsigned long) i);
e0a31db1 13915
ccb4c951
RS		 13916 printf ("\n");
13917 }
13918 printf ("\n");
13919 }
13920
13921 if (data)
13922 free (data);
13923 }
13924
861fb55a
DJ		 13925 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13926 {
91d6fa6a 13927 bfd_vma ent, end;
861fb55a
DJ		 13928 size_t offset, rel_offset;
13929 unsigned long count, i;
2cf0635d 13930 unsigned char * data;
861fb55a 13931 int addr_size, sym_width;
2cf0635d 13932 Elf_Internal_Rela * rels;
861fb55a
DJ		 13933
13934 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13935 if (pltrel == DT_RELA)
13936 {
13937 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13938 return 0;
13939 }
13940 else
13941 {
13942 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13943 return 0;
13944 }
13945
91d6fa6a 13946 ent = mips_pltgot;
861fb55a
DJ		 13947 addr_size = (is_32bit_elf ? 4 : 8);
13948 end = mips_pltgot + (2 + count) * addr_size;
13949
13950 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 13951 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 13952 1, _("Procedure Linkage Table data"));
59245841
NC		 13953 if (data == NULL)
13954 return 0;
13955
9cf03b7e 13956 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 13957 printf (_(" Reserved entries:\n"));
13958 printf (_(" %*s %*s Purpose\n"),
2b692964 13959 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 13960 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 13961 printf (_(" PLT lazy resolver\n"));
91d6fa6a 13962 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 13963 printf (_(" Module pointer\n"));
861fb55a
DJ		 13964 printf ("\n");
13965
13966 printf (_(" Entries:\n"));
cc5914eb 13967 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 13968 addr_size * 2, _("Address"),
13969 addr_size * 2, _("Initial"),
13970 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 13971 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13972 for (i = 0; i < count; i++)
13973 {
df97ab2a 13974 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 13975
91d6fa6a 13976 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 13977 printf (" ");
e0a31db1 13978
df97ab2a
MF		 13979 if (idx >= num_dynamic_syms)
13980 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 13981 else
e0a31db1 13982 {
df97ab2a 13983 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 13984
13985 print_vma (psym->st_value, LONG_HEX);
13986 printf (" %-7s %3s ",
13987 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13988 get_symbol_index_type (psym->st_shndx));
13989 if (VALID_DYNAMIC_NAME (psym->st_name))
13990 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13991 else
13992 printf (_("<corrupt: %14ld>"), psym->st_name);
13993 }
861fb55a
DJ		 13994 printf ("\n");
13995 }
13996 printf ("\n");
13997
13998 if (data)
13999 free (data);
14000 free (rels);
14001 }
14002
252b5132
RH		 14003 return 1;
14004}
14005
35c08157
KLC		 14006static int
14007process_nds32_specific (FILE * file)
14008{
14009 Elf_Internal_Shdr *sect = NULL;
14010
14011 sect = find_section (".nds32_e_flags");
14012 if (sect != NULL)
14013 {
14014 unsigned int *flag;
14015
14016 printf ("\nNDS32 elf flags section:\n");
14017 flag = get_data (NULL, file, sect->sh_offset, 1,
14018 sect->sh_size, _("NDS32 elf flags section"));
14019
14020 switch ((*flag) & 0x3)
14021 {
14022 case 0:
14023 printf ("(VEC_SIZE):\tNo entry.\n");
14024 break;
14025 case 1:
14026 printf ("(VEC_SIZE):\t4 bytes\n");
14027 break;
14028 case 2:
14029 printf ("(VEC_SIZE):\t16 bytes\n");
14030 break;
14031 case 3:
14032 printf ("(VEC_SIZE):\treserved\n");
14033 break;
14034 }
14035 }
14036
14037 return TRUE;
14038}
14039
047b2264 14040static int
2cf0635d 14041process_gnu_liblist (FILE * file)
047b2264 14042{
2cf0635d
NC		 14043 Elf_Internal_Shdr * section;
14044 Elf_Internal_Shdr * string_sec;
14045 Elf32_External_Lib * elib;
14046 char * strtab;
c256ffe7 14047 size_t strtab_size;
047b2264
JJ		 14048 size_t cnt;
14049 unsigned i;
14050
14051 if (! do_arch)
14052 return 0;
14053
14054 for (i = 0, section = section_headers;
14055 i < elf_header.e_shnum;
b34976b6 14056 i++, section++)
047b2264
JJ		 14057 {
14058 switch (section->sh_type)
14059 {
14060 case SHT_GNU_LIBLIST:
4fbb74a6 14061 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14062 break;
14063
3f5e193b
NC		 14064 elib = (Elf32_External_Lib *)
14065 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14066 _("liblist section data"));
047b2264
JJ		 14067
14068 if (elib == NULL)
14069 break;
4fbb74a6 14070 string_sec = section_headers + section->sh_link;
047b2264 14071
3f5e193b
NC		 14072 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14073 string_sec->sh_size,
14074 _("liblist string table"));
047b2264
JJ		 14075 if (strtab == NULL
14076 || section->sh_entsize != sizeof (Elf32_External_Lib))
14077 {
14078 free (elib);
2842702f 14079 free (strtab);
047b2264
JJ		 14080 break;
14081 }
59245841 14082 strtab_size = string_sec->sh_size;
047b2264
JJ		 14083
14084 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14085 printable_section_name (section),
0af1713e 14086 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14087
2b692964 14088 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14089
14090 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14091 ++cnt)
14092 {
14093 Elf32_Lib liblist;
91d6fa6a 14094 time_t atime;
047b2264 14095 char timebuf[20];
2cf0635d 14096 struct tm * tmp;
047b2264
JJ		 14097
14098 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14099 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14100 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14101 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14102 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14103
91d6fa6a 14104 tmp = gmtime (&atime);
e9e44622
JJ		 14105 snprintf (timebuf, sizeof (timebuf),
14106 "%04u-%02u-%02uT%02u:%02u:%02u",
14107 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14108 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14109
14110 printf ("%3lu: ", (unsigned long) cnt);
14111 if (do_wide)
c256ffe7 14112 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14113 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14114 else
c256ffe7 14115 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14116 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14117 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14118 liblist.l_version, liblist.l_flags);
14119 }
14120
14121 free (elib);
2842702f 14122 free (strtab);
047b2264
JJ		 14123 }
14124 }
14125
14126 return 1;
14127}
14128
9437c45b 14129static const char *
d3ba0551 14130get_note_type (unsigned e_type)
779fe533
NC		 14131{
14132 static char buff[64];
103f02d3 14133
1ec5cd37
NC		 14134 if (elf_header.e_type == ET_CORE)
14135 switch (e_type)
14136 {
57346661 14137 case NT_AUXV:
1ec5cd37 14138 return _("NT_AUXV (auxiliary vector)");
57346661 14139 case NT_PRSTATUS:
1ec5cd37 14140 return _("NT_PRSTATUS (prstatus structure)");
57346661 14141 case NT_FPREGSET:
1ec5cd37 14142 return _("NT_FPREGSET (floating point registers)");
57346661 14143 case NT_PRPSINFO:
1ec5cd37 14144 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14145 case NT_TASKSTRUCT:
1ec5cd37 14146 return _("NT_TASKSTRUCT (task structure)");
57346661 14147 case NT_PRXFPREG:
1ec5cd37 14148 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14149 case NT_PPC_VMX:
14150 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14151 case NT_PPC_VSX:
14152 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14153 case NT_386_TLS:
14154 return _("NT_386_TLS (x86 TLS information)");
14155 case NT_386_IOPERM:
14156 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14157 case NT_X86_XSTATE:
14158 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14159 case NT_S390_HIGH_GPRS:
14160 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14161 case NT_S390_TIMER:
14162 return _("NT_S390_TIMER (s390 timer register)");
14163 case NT_S390_TODCMP:
14164 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14165 case NT_S390_TODPREG:
14166 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14167 case NT_S390_CTRS:
14168 return _("NT_S390_CTRS (s390 control registers)");
14169 case NT_S390_PREFIX:
14170 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14171 case NT_S390_LAST_BREAK:
14172 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14173 case NT_S390_SYSTEM_CALL:
14174 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14175 case NT_S390_TDB:
14176 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW		 14177 case NT_ARM_VFP:
14178 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14179 case NT_ARM_TLS:
14180 return _("NT_ARM_TLS (AArch TLS registers)");
14181 case NT_ARM_HW_BREAK:
14182 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14183 case NT_ARM_HW_WATCH:
14184 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14185 case NT_PSTATUS:
1ec5cd37 14186 return _("NT_PSTATUS (pstatus structure)");
57346661 14187 case NT_FPREGS:
1ec5cd37 14188 return _("NT_FPREGS (floating point registers)");
57346661 14189 case NT_PSINFO:
1ec5cd37 14190 return _("NT_PSINFO (psinfo structure)");
57346661 14191 case NT_LWPSTATUS:
1ec5cd37 14192 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14193 case NT_LWPSINFO:
1ec5cd37 14194 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14195 case NT_WIN32PSTATUS:
1ec5cd37 14196 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14197 case NT_SIGINFO:
14198 return _("NT_SIGINFO (siginfo_t data)");
14199 case NT_FILE:
14200 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14201 default:
14202 break;
14203 }
14204 else
14205 switch (e_type)
14206 {
14207 case NT_VERSION:
14208 return _("NT_VERSION (version)");
14209 case NT_ARCH:
14210 return _("NT_ARCH (architecture)");
14211 default:
14212 break;
14213 }
14214
e9e44622 14215 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14216 return buff;
779fe533
NC		 14217}
14218
9ece1fa9
TT		 14219static int
14220print_core_note (Elf_Internal_Note *pnote)
14221{
14222 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14223 bfd_vma count, page_size;
14224 unsigned char *descdata, *filenames, *descend;
14225
14226 if (pnote->type != NT_FILE)
14227 return 1;
14228
14229#ifndef BFD64
14230 if (!is_32bit_elf)
14231 {
14232 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14233 /* Still "successful". */
14234 return 1;
14235 }
14236#endif
14237
14238 if (pnote->descsz < 2 * addr_size)
14239 {
14240 printf (_(" Malformed note - too short for header\n"));
14241 return 0;
14242 }
14243
14244 descdata = (unsigned char *) pnote->descdata;
14245 descend = descdata + pnote->descsz;
14246
14247 if (descdata[pnote->descsz - 1] != '\0')
14248 {
14249 printf (_(" Malformed note - does not end with \\0\n"));
14250 return 0;
14251 }
14252
14253 count = byte_get (descdata, addr_size);
14254 descdata += addr_size;
14255
14256 page_size = byte_get (descdata, addr_size);
14257 descdata += addr_size;
14258
14259 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14260 {
14261 printf (_(" Malformed note - too short for supplied file count\n"));
14262 return 0;
14263 }
14264
14265 printf (_(" Page size: "));
14266 print_vma (page_size, DEC);
14267 printf ("\n");
14268
14269 printf (_(" %*s%*s%*s\n"),
14270 (int) (2 + 2 * addr_size), _("Start"),
14271 (int) (4 + 2 * addr_size), _("End"),
14272 (int) (4 + 2 * addr_size), _("Page Offset"));
14273 filenames = descdata + count * 3 * addr_size;
14274 while (--count > 0)
14275 {
14276 bfd_vma start, end, file_ofs;
14277
14278 if (filenames == descend)
14279 {
14280 printf (_(" Malformed note - filenames end too early\n"));
14281 return 0;
14282 }
14283
14284 start = byte_get (descdata, addr_size);
14285 descdata += addr_size;
14286 end = byte_get (descdata, addr_size);
14287 descdata += addr_size;
14288 file_ofs = byte_get (descdata, addr_size);
14289 descdata += addr_size;
14290
14291 printf (" ");
14292 print_vma (start, FULL_HEX);
14293 printf (" ");
14294 print_vma (end, FULL_HEX);
14295 printf (" ");
14296 print_vma (file_ofs, FULL_HEX);
14297 printf ("\n %s\n", filenames);
14298
14299 filenames += 1 + strlen ((char *) filenames);
14300 }
14301
14302 return 1;
14303}
14304
1118d252
RM		 14305static const char *
14306get_gnu_elf_note_type (unsigned e_type)
14307{
14308 static char buff[64];
14309
14310 switch (e_type)
14311 {
14312 case NT_GNU_ABI_TAG:
14313 return _("NT_GNU_ABI_TAG (ABI version tag)");
14314 case NT_GNU_HWCAP:
14315 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14316 case NT_GNU_BUILD_ID:
14317 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14318 case NT_GNU_GOLD_VERSION:
14319 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14320 default:
14321 break;
14322 }
14323
14324 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14325 return buff;
14326}
14327
664f90a3
TT		 14328static int
14329print_gnu_note (Elf_Internal_Note *pnote)
14330{
14331 switch (pnote->type)
14332 {
14333 case NT_GNU_BUILD_ID:
14334 {
14335 unsigned long i;
14336
14337 printf (_(" Build ID: "));
14338 for (i = 0; i < pnote->descsz; ++i)
14339 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14340 printf ("\n");
664f90a3
TT		 14341 }
14342 break;
14343
14344 case NT_GNU_ABI_TAG:
14345 {
14346 unsigned long os, major, minor, subminor;
14347 const char *osname;
14348
3102e897
NC		 14349 /* PR 17531: file: 030-599401-0.004. */
14350 if (pnote->descsz < 16)
14351 {
14352 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14353 break;
14354 }
14355
664f90a3
TT		 14356 os = byte_get ((unsigned char *) pnote->descdata, 4);
14357 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14358 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14359 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14360
14361 switch (os)
14362 {
14363 case GNU_ABI_TAG_LINUX:
14364 osname = "Linux";
14365 break;
14366 case GNU_ABI_TAG_HURD:
14367 osname = "Hurd";
14368 break;
14369 case GNU_ABI_TAG_SOLARIS:
14370 osname = "Solaris";
14371 break;
14372 case GNU_ABI_TAG_FREEBSD:
14373 osname = "FreeBSD";
14374 break;
14375 case GNU_ABI_TAG_NETBSD:
14376 osname = "NetBSD";
14377 break;
14378 default:
14379 osname = "Unknown";
14380 break;
14381 }
14382
14383 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14384 major, minor, subminor);
14385 }
14386 break;
926c5385
CC		 14387
14388 case NT_GNU_GOLD_VERSION:
14389 {
14390 unsigned long i;
14391
14392 printf (_(" Version: "));
14393 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14394 printf ("%c", pnote->descdata[i]);
14395 printf ("\n");
14396 }
14397 break;
664f90a3
TT		 14398 }
14399
14400 return 1;
14401}
14402
9437c45b 14403static const char *
d3ba0551 14404get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14405{
14406 static char buff[64];
14407
b4db1224 14408 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14409 {
14410 /* NetBSD core "procinfo" structure. */
14411 return _("NetBSD procinfo structure");
14412 }
14413
14414 /* As of Jan 2002 there are no other machine-independent notes
14415 defined for NetBSD core files. If the note type is less
14416 than the start of the machine-dependent note types, we don't
14417 understand it. */
14418
b4db1224 14419 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14420 {
e9e44622 14421 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14422 return buff;
14423 }
14424
14425 switch (elf_header.e_machine)
14426 {
14427 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14428 and PT_GETFPREGS == mach+2. */
14429
14430 case EM_OLD_ALPHA:
14431 case EM_ALPHA:
14432 case EM_SPARC:
14433 case EM_SPARC32PLUS:
14434 case EM_SPARCV9:
14435 switch (e_type)
14436 {
2b692964 14437 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 14438 return _("PT_GETREGS (reg structure)");
2b692964 14439 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 14440 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14441 default:
14442 break;
14443 }
14444 break;
14445
14446 /* On all other arch's, PT_GETREGS == mach+1 and
14447 PT_GETFPREGS == mach+3. */
14448 default:
14449 switch (e_type)
14450 {
2b692964 14451 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 14452 return _("PT_GETREGS (reg structure)");
2b692964 14453 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 14454 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14455 default:
14456 break;
14457 }
14458 }
14459
9cf03b7e 14460 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 14461 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 14462 return buff;
14463}
14464
70616151
TT		 14465static const char *
14466get_stapsdt_note_type (unsigned e_type)
14467{
14468 static char buff[64];
14469
14470 switch (e_type)
14471 {
14472 case NT_STAPSDT:
14473 return _("NT_STAPSDT (SystemTap probe descriptors)");
14474
14475 default:
14476 break;
14477 }
14478
14479 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14480 return buff;
14481}
14482
c6a9fc58
TT		 14483static int
14484print_stapsdt_note (Elf_Internal_Note *pnote)
14485{
14486 int addr_size = is_32bit_elf ? 4 : 8;
14487 char *data = pnote->descdata;
14488 char *data_end = pnote->descdata + pnote->descsz;
14489 bfd_vma pc, base_addr, semaphore;
14490 char *provider, *probe, *arg_fmt;
14491
14492 pc = byte_get ((unsigned char *) data, addr_size);
14493 data += addr_size;
14494 base_addr = byte_get ((unsigned char *) data, addr_size);
14495 data += addr_size;
14496 semaphore = byte_get ((unsigned char *) data, addr_size);
14497 data += addr_size;
14498
14499 provider = data;
14500 data += strlen (data) + 1;
14501 probe = data;
14502 data += strlen (data) + 1;
14503 arg_fmt = data;
14504 data += strlen (data) + 1;
14505
14506 printf (_(" Provider: %s\n"), provider);
14507 printf (_(" Name: %s\n"), probe);
14508 printf (_(" Location: "));
14509 print_vma (pc, FULL_HEX);
14510 printf (_(", Base: "));
14511 print_vma (base_addr, FULL_HEX);
14512 printf (_(", Semaphore: "));
14513 print_vma (semaphore, FULL_HEX);
9cf03b7e 14514 printf ("\n");
c6a9fc58
TT		 14515 printf (_(" Arguments: %s\n"), arg_fmt);
14516
14517 return data == data_end;
14518}
14519
00e98fc7
TG		 14520static const char *
14521get_ia64_vms_note_type (unsigned e_type)
14522{
14523 static char buff[64];
14524
14525 switch (e_type)
14526 {
14527 case NT_VMS_MHD:
14528 return _("NT_VMS_MHD (module header)");
14529 case NT_VMS_LNM:
14530 return _("NT_VMS_LNM (language name)");
14531 case NT_VMS_SRC:
14532 return _("NT_VMS_SRC (source files)");
14533 case NT_VMS_TITLE:
9cf03b7e 14534 return "NT_VMS_TITLE";
00e98fc7
TG		 14535 case NT_VMS_EIDC:
14536 return _("NT_VMS_EIDC (consistency check)");
14537 case NT_VMS_FPMODE:
14538 return _("NT_VMS_FPMODE (FP mode)");
14539 case NT_VMS_LINKTIME:
9cf03b7e 14540 return "NT_VMS_LINKTIME";
00e98fc7
TG		 14541 case NT_VMS_IMGNAM:
14542 return _("NT_VMS_IMGNAM (image name)");
14543 case NT_VMS_IMGID:
14544 return _("NT_VMS_IMGID (image id)");
14545 case NT_VMS_LINKID:
14546 return _("NT_VMS_LINKID (link id)");
14547 case NT_VMS_IMGBID:
14548 return _("NT_VMS_IMGBID (build id)");
14549 case NT_VMS_GSTNAM:
14550 return _("NT_VMS_GSTNAM (sym table name)");
14551 case NT_VMS_ORIG_DYN:
9cf03b7e 14552 return "NT_VMS_ORIG_DYN";
00e98fc7 14553 case NT_VMS_PATCHTIME:
9cf03b7e 14554 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 14555 default:
14556 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14557 return buff;
14558 }
14559}
14560
14561static int
14562print_ia64_vms_note (Elf_Internal_Note * pnote)
14563{
14564 switch (pnote->type)
14565 {
14566 case NT_VMS_MHD:
14567 if (pnote->descsz > 36)
14568 {
14569 size_t l = strlen (pnote->descdata + 34);
14570 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14571 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14572 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14573 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14574 }
14575 else
14576 printf (_(" Invalid size\n"));
14577 break;
14578 case NT_VMS_LNM:
14579 printf (_(" Language: %s\n"), pnote->descdata);
14580 break;
14581#ifdef BFD64
14582 case NT_VMS_FPMODE:
9cf03b7e 14583 printf (_(" Floating Point mode: "));
4a5cb34f 14584 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14585 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14586 break;
14587 case NT_VMS_LINKTIME:
14588 printf (_(" Link time: "));
14589 print_vms_time
14590 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14591 printf ("\n");
14592 break;
14593 case NT_VMS_PATCHTIME:
14594 printf (_(" Patch time: "));
14595 print_vms_time
14596 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14597 printf ("\n");
14598 break;
14599 case NT_VMS_ORIG_DYN:
14600 printf (_(" Major id: %u, minor id: %u\n"),
14601 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14602 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 14603 printf (_(" Last modified : "));
00e98fc7
TG		 14604 print_vms_time
14605 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 14606 printf (_("\n Link flags : "));
4a5cb34f 14607 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14608 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14609 printf (_(" Header flags: 0x%08x\n"),
14610 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14611 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14612 break;
14613#endif
14614 case NT_VMS_IMGNAM:
14615 printf (_(" Image name: %s\n"), pnote->descdata);
14616 break;
14617 case NT_VMS_GSTNAM:
14618 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14619 break;
14620 case NT_VMS_IMGID:
14621 printf (_(" Image id: %s\n"), pnote->descdata);
14622 break;
14623 case NT_VMS_LINKID:
14624 printf (_(" Linker id: %s\n"), pnote->descdata);
14625 break;
14626 default:
14627 break;
14628 }
14629 return 1;
14630}
14631
6d118b09
NC		 14632/* Note that by the ELF standard, the name field is already null byte
14633 terminated, and namesz includes the terminating null byte.
14634 I.E. the value of namesz for the name "FSF" is 4.
14635
e3c8793a 14636 If the value of namesz is zero, there is no name present. */
779fe533 14637static int
2cf0635d 14638process_note (Elf_Internal_Note * pnote)
779fe533 14639{
2cf0635d
NC		 14640 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14641 const char * nt;
9437c45b
JT		 14642
14643 if (pnote->namesz == 0)
1ec5cd37
NC		 14644 /* If there is no note name, then use the default set of
14645 note type strings. */
14646 nt = get_note_type (pnote->type);
14647
1118d252
RM		 14648 else if (const_strneq (pnote->namedata, "GNU"))
14649 /* GNU-specific object file notes. */
14650 nt = get_gnu_elf_note_type (pnote->type);
14651
0112cd26 14652 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 14653 /* NetBSD-specific core file notes. */
14654 nt = get_netbsd_elfcore_note_type (pnote->type);
14655
b15fa79e
AM		 14656 else if (strneq (pnote->namedata, "SPU/", 4))
14657 {
14658 /* SPU-specific core file notes. */
14659 nt = pnote->namedata + 4;
14660 name = "SPU";
14661 }
14662
00e98fc7
TG		 14663 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14664 /* VMS/ia64-specific file notes. */
14665 nt = get_ia64_vms_note_type (pnote->type);
14666
70616151
TT		 14667 else if (const_strneq (pnote->namedata, "stapsdt"))
14668 nt = get_stapsdt_note_type (pnote->type);
14669
9437c45b 14670 else
1ec5cd37
NC		 14671 /* Don't recognize this note name; just use the default set of
14672 note type strings. */
00e98fc7 14673 nt = get_note_type (pnote->type);
9437c45b 14674
2aee03ae 14675 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 14676
14677 if (const_strneq (pnote->namedata, "IPF/VMS"))
14678 return print_ia64_vms_note (pnote);
664f90a3
TT		 14679 else if (const_strneq (pnote->namedata, "GNU"))
14680 return print_gnu_note (pnote);
c6a9fc58
TT		 14681 else if (const_strneq (pnote->namedata, "stapsdt"))
14682 return print_stapsdt_note (pnote);
9ece1fa9
TT		 14683 else if (const_strneq (pnote->namedata, "CORE"))
14684 return print_core_note (pnote);
00e98fc7
TG		 14685 else
14686 return 1;
779fe533
NC		 14687}
14688
6d118b09 14689
779fe533 14690static int
2cf0635d 14691process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 14692{
2cf0635d
NC		 14693 Elf_External_Note * pnotes;
14694 Elf_External_Note * external;
b34976b6 14695 int res = 1;
103f02d3 14696
779fe533
NC		 14697 if (length <= 0)
14698 return 0;
103f02d3 14699
3f5e193b 14700 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 14701 _("notes"));
dd24e3da 14702 if (pnotes == NULL)
a6e9f9df 14703 return 0;
779fe533 14704
103f02d3 14705 external = pnotes;
103f02d3 14706
9dd3a467 14707 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 14708 (unsigned long) offset, (unsigned long) length);
2aee03ae 14709 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 14710
15b42fb0 14711 while ((char *) external < (char *) pnotes + length)
779fe533 14712 {
b34976b6 14713 Elf_Internal_Note inote;
15b42fb0
AM		 14714 size_t min_notesz;
14715 char *next;
2cf0635d 14716 char * temp = NULL;
15b42fb0 14717 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 14718
00e98fc7 14719 if (!is_ia64_vms ())
15b42fb0 14720 {
9dd3a467
NC		 14721 /* PR binutils/15191
14722 Make sure that there is enough data to read. */
15b42fb0
AM		 14723 min_notesz = offsetof (Elf_External_Note, name);
14724 if (data_remaining < min_notesz)
9dd3a467
NC		 14725 {
14726 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14727 (int) data_remaining);
14728 break;
14729 }
15b42fb0
AM		 14730 inote.type = BYTE_GET (external->type);
14731 inote.namesz = BYTE_GET (external->namesz);
14732 inote.namedata = external->name;
14733 inote.descsz = BYTE_GET (external->descsz);
14734 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14735 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14736 next = inote.descdata + align_power (inote.descsz, 2);
14737 }
00e98fc7 14738 else
15b42fb0
AM		 14739 {
14740 Elf64_External_VMS_Note *vms_external;
00e98fc7 14741
9dd3a467
NC		 14742 /* PR binutils/15191
14743 Make sure that there is enough data to read. */
15b42fb0
AM		 14744 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14745 if (data_remaining < min_notesz)
9dd3a467
NC		 14746 {
14747 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14748 (int) data_remaining);
14749 break;
14750 }
3e55a963 14751
15b42fb0
AM		 14752 vms_external = (Elf64_External_VMS_Note *) external;
14753 inote.type = BYTE_GET (vms_external->type);
14754 inote.namesz = BYTE_GET (vms_external->namesz);
14755 inote.namedata = vms_external->name;
14756 inote.descsz = BYTE_GET (vms_external->descsz);
14757 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14758 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14759 next = inote.descdata + align_power (inote.descsz, 3);
14760 }
14761
14762 if (inote.descdata < (char *) external + min_notesz
14763 || next < (char *) external + min_notesz
5d921cbd
NC		 14764 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14765 || inote.namedata + inote.namesz < inote.namedata
14766 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 14767 || data_remaining < (size_t)(next - (char *) external))
3e55a963 14768 {
15b42fb0 14769 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 14770 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 14771 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 14772 inote.type, inote.namesz, inote.descsz);
14773 break;
14774 }
14775
15b42fb0 14776 external = (Elf_External_Note *) next;
dd24e3da 14777
6d118b09
NC		 14778 /* Verify that name is null terminated. It appears that at least
14779 one version of Linux (RedHat 6.0) generates corefiles that don't
14780 comply with the ELF spec by failing to include the null byte in
14781 namesz. */
8b971f9f 14782 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 14783 {
3f5e193b 14784 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 14785 if (temp == NULL)
14786 {
8b73c356 14787 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 14788 res = 0;
14789 break;
14790 }
76da6bbe 14791
6d118b09
NC		 14792 strncpy (temp, inote.namedata, inote.namesz);
14793 temp[inote.namesz] = 0;
76da6bbe 14794
6d118b09
NC		 14795 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14796 inote.namedata = temp;
14797 }
14798
14799 res &= process_note (& inote);
103f02d3 14800
6d118b09
NC		 14801 if (temp != NULL)
14802 {
14803 free (temp);
14804 temp = NULL;
14805 }
779fe533
NC		 14806 }
14807
14808 free (pnotes);
103f02d3 14809
779fe533
NC		 14810 return res;
14811}
14812
14813static int
2cf0635d 14814process_corefile_note_segments (FILE * file)
779fe533 14815{
2cf0635d 14816 Elf_Internal_Phdr * segment;
b34976b6
AM		 14817 unsigned int i;
14818 int res = 1;
103f02d3 14819
d93f0186 14820 if (! get_program_headers (file))
779fe533 14821 return 0;
103f02d3 14822
779fe533
NC		 14823 for (i = 0, segment = program_headers;
14824 i < elf_header.e_phnum;
b34976b6 14825 i++, segment++)
779fe533
NC		 14826 {
14827 if (segment->p_type == PT_NOTE)
103f02d3 14828 res &= process_corefile_note_segment (file,
30800947
NC		 14829 (bfd_vma) segment->p_offset,
14830 (bfd_vma) segment->p_filesz);
779fe533 14831 }
103f02d3 14832
779fe533
NC		 14833 return res;
14834}
14835
14836static int
2cf0635d 14837process_note_sections (FILE * file)
1ec5cd37 14838{
2cf0635d 14839 Elf_Internal_Shdr * section;
1ec5cd37 14840 unsigned long i;
df565f32 14841 int n = 0;
1ec5cd37
NC		 14842 int res = 1;
14843
14844 for (i = 0, section = section_headers;
fa1908fd 14845 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 14846 i++, section++)
14847 if (section->sh_type == SHT_NOTE)
df565f32
NC		 14848 {
14849 res &= process_corefile_note_segment (file,
14850 (bfd_vma) section->sh_offset,
14851 (bfd_vma) section->sh_size);
14852 n++;
14853 }
14854
14855 if (n == 0)
14856 /* Try processing NOTE segments instead. */
14857 return process_corefile_note_segments (file);
1ec5cd37
NC		 14858
14859 return res;
14860}
14861
14862static int
2cf0635d 14863process_notes (FILE * file)
779fe533
NC		 14864{
14865 /* If we have not been asked to display the notes then do nothing. */
14866 if (! do_notes)
14867 return 1;
103f02d3 14868
779fe533 14869 if (elf_header.e_type != ET_CORE)
1ec5cd37 14870 return process_note_sections (file);
103f02d3 14871
779fe533 14872 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 14873 if (elf_header.e_phnum > 0)
14874 return process_corefile_note_segments (file);
779fe533 14875
1ec5cd37
NC		 14876 printf (_("No note segments present in the core file.\n"));
14877 return 1;
779fe533
NC		 14878}
14879
252b5132 14880static int
2cf0635d 14881process_arch_specific (FILE * file)
252b5132 14882{
a952a375
NC		 14883 if (! do_arch)
14884 return 1;
14885
252b5132
RH		 14886 switch (elf_header.e_machine)
14887 {
11c1ff18
PB		 14888 case EM_ARM:
14889 return process_arm_specific (file);
252b5132 14890 case EM_MIPS:
4fe85591 14891 case EM_MIPS_RS3_LE:
252b5132
RH		 14892 return process_mips_specific (file);
14893 break;
35c08157
KLC		 14894 case EM_NDS32:
14895 return process_nds32_specific (file);
14896 break;
34c8bcba
JM		 14897 case EM_PPC:
14898 return process_power_specific (file);
14899 break;
9e8c70f9
DM		 14900 case EM_SPARC:
14901 case EM_SPARC32PLUS:
14902 case EM_SPARCV9:
14903 return process_sparc_specific (file);
14904 break;
59e6276b
JM		 14905 case EM_TI_C6000:
14906 return process_tic6x_specific (file);
14907 break;
13761a11
NC		 14908 case EM_MSP430:
14909 return process_msp430x_specific (file);
252b5132
RH		 14910 default:
14911 break;
14912 }
14913 return 1;
14914}
14915
14916static int
2cf0635d 14917get_file_header (FILE * file)
252b5132 14918{
9ea033b2
NC		 14919 /* Read in the identity array. */
14920 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 14921 return 0;
14922
9ea033b2 14923 /* Determine how to read the rest of the header. */
b34976b6 14924 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 14925 {
14926 default: /* fall through */
14927 case ELFDATANONE: /* fall through */
adab8cdc
AO		 14928 case ELFDATA2LSB:
14929 byte_get = byte_get_little_endian;
14930 byte_put = byte_put_little_endian;
14931 break;
14932 case ELFDATA2MSB:
14933 byte_get = byte_get_big_endian;
14934 byte_put = byte_put_big_endian;
14935 break;
9ea033b2
NC		 14936 }
14937
14938 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 14939 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 14940
14941 /* Read in the rest of the header. */
14942 if (is_32bit_elf)
14943 {
14944 Elf32_External_Ehdr ehdr32;
252b5132 14945
9ea033b2
NC		 14946 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14947 return 0;
103f02d3 14948
9ea033b2
NC		 14949 elf_header.e_type = BYTE_GET (ehdr32.e_type);
14950 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
14951 elf_header.e_version = BYTE_GET (ehdr32.e_version);
14952 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
14953 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
14954 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
14955 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
14956 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
14957 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14958 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
14959 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14960 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
14961 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
14962 }
252b5132 14963 else
9ea033b2
NC		 14964 {
14965 Elf64_External_Ehdr ehdr64;
a952a375
NC		 14966
14967 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14968 we will not be able to cope with the 64bit data found in
14969 64 ELF files. Detect this now and abort before we start
50c2245b 14970 overwriting things. */
a952a375
NC		 14971 if (sizeof (bfd_vma) < 8)
14972 {
e3c8793a
NC		 14973 error (_("This instance of readelf has been built without support for a\n\
1497464 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 14975 return 0;
14976 }
103f02d3 14977
9ea033b2
NC		 14978 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14979 return 0;
103f02d3 14980
9ea033b2
NC		 14981 elf_header.e_type = BYTE_GET (ehdr64.e_type);
14982 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
14983 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 14984 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
14985 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
14986 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 14987 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
14988 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
14989 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14990 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
14991 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14992 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
14993 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
14994 }
252b5132 14995
7ece0d85
JJ		 14996 if (elf_header.e_shoff)
14997 {
14998 /* There may be some extensions in the first section header. Don't
14999 bomb if we can't read it. */
15000 if (is_32bit_elf)
049b0c3a 15001 get_32bit_section_headers (file, TRUE);
7ece0d85 15002 else
049b0c3a 15003 get_64bit_section_headers (file, TRUE);
7ece0d85 15004 }
560f3c1c 15005
252b5132
RH		 15006 return 1;
15007}
15008
fb52b2f4
NC		 15009/* Process one ELF object file according to the command line options.
15010 This file may actually be stored in an archive. The file is
15011 positioned at the start of the ELF object. */
15012
ff78d6d6 15013static int
2cf0635d 15014process_object (char * file_name, FILE * file)
252b5132 15015{
252b5132
RH		 15016 unsigned int i;
15017
252b5132
RH		 15018 if (! get_file_header (file))
15019 {
15020 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15021 return 1;
252b5132
RH		 15022 }
15023
15024 /* Initialise per file variables. */
60bca95a 15025 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15026 version_info[i] = 0;
15027
60bca95a 15028 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15029 dynamic_info[i] = 0;
5115b233 15030 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15031
15032 /* Process the file. */
15033 if (show_name)
15034 printf (_("\nFile: %s\n"), file_name);
15035
18bd398b
NC		 15036 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15037 Note we do this even if cmdline_dump_sects is empty because we
15038 must make sure that the dump_sets array is zeroed out before each
15039 object file is processed. */
15040 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15041 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15042
15043 if (num_cmdline_dump_sects > 0)
15044 {
15045 if (num_dump_sects == 0)
15046 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15047 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15048
15049 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15050 memcpy (dump_sects, cmdline_dump_sects,
15051 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15052 }
d70c5fc7 15053
252b5132 15054 if (! process_file_header ())
fb52b2f4 15055 return 1;
252b5132 15056
d1f5c6e3 15057 if (! process_section_headers (file))
2f62977e 15058 {
d1f5c6e3
L		 15059 /* Without loaded section headers we cannot process lots of
15060 things. */
2f62977e 15061 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15062
2f62977e 15063 if (! do_using_dynamic)
2c610e4b 15064 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15065 }
252b5132 15066
d1f5c6e3
L		 15067 if (! process_section_groups (file))
15068 {
15069 /* Without loaded section groups we cannot process unwind. */
15070 do_unwind = 0;
15071 }
15072
2f62977e 15073 if (process_program_headers (file))
b2d38a17 15074 process_dynamic_section (file);
252b5132
RH		 15075
15076 process_relocs (file);
15077
4d6ed7c8
NC		 15078 process_unwind (file);
15079
252b5132
RH		 15080 process_symbol_table (file);
15081
15082 process_syminfo (file);
15083
15084 process_version_sections (file);
15085
15086 process_section_contents (file);
f5842774 15087
1ec5cd37 15088 process_notes (file);
103f02d3 15089
047b2264
JJ		 15090 process_gnu_liblist (file);
15091
252b5132
RH		 15092 process_arch_specific (file);
15093
d93f0186
NC		 15094 if (program_headers)
15095 {
15096 free (program_headers);
15097 program_headers = NULL;
15098 }
15099
252b5132
RH		 15100 if (section_headers)
15101 {
15102 free (section_headers);
15103 section_headers = NULL;
15104 }
15105
15106 if (string_table)
15107 {
15108 free (string_table);
15109 string_table = NULL;
d40ac9bd 15110 string_table_length = 0;
252b5132
RH		 15111 }
15112
15113 if (dynamic_strings)
15114 {
15115 free (dynamic_strings);
15116 dynamic_strings = NULL;
d79b3d50 15117 dynamic_strings_length = 0;
252b5132
RH		 15118 }
15119
15120 if (dynamic_symbols)
15121 {
15122 free (dynamic_symbols);
15123 dynamic_symbols = NULL;
19936277 15124 num_dynamic_syms = 0;
252b5132
RH		 15125 }
15126
15127 if (dynamic_syminfo)
15128 {
15129 free (dynamic_syminfo);
15130 dynamic_syminfo = NULL;
15131 }
ff78d6d6 15132
293c573e
MR		 15133 if (dynamic_section)
15134 {
15135 free (dynamic_section);
15136 dynamic_section = NULL;
15137 }
15138
e4b17d5c
L		 15139 if (section_headers_groups)
15140 {
15141 free (section_headers_groups);
15142 section_headers_groups = NULL;
15143 }
15144
15145 if (section_groups)
15146 {
2cf0635d
NC		 15147 struct group_list * g;
15148 struct group_list * next;
e4b17d5c
L		 15149
15150 for (i = 0; i < group_count; i++)
15151 {
15152 for (g = section_groups [i].root; g != NULL; g = next)
15153 {
15154 next = g->next;
15155 free (g);
15156 }
15157 }
15158
15159 free (section_groups);
15160 section_groups = NULL;
15161 }
15162
19e6b90e 15163 free_debug_memory ();
18bd398b 15164
ff78d6d6 15165 return 0;
252b5132
RH		 15166}
15167
2cf0635d
NC		 15168/* Process an ELF archive.
15169 On entry the file is positioned just after the ARMAG string. */
15170
15171static int
15172process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15173{
15174 struct archive_info arch;
15175 struct archive_info nested_arch;
15176 size_t got;
2cf0635d
NC		 15177 int ret;
15178
15179 show_name = 1;
15180
15181 /* The ARCH structure is used to hold information about this archive. */
15182 arch.file_name = NULL;
15183 arch.file = NULL;
15184 arch.index_array = NULL;
15185 arch.sym_table = NULL;
15186 arch.longnames = NULL;
15187
15188 /* The NESTED_ARCH structure is used as a single-item cache of information
15189 about a nested archive (when members of a thin archive reside within
15190 another regular archive file). */
15191 nested_arch.file_name = NULL;
15192 nested_arch.file = NULL;
15193 nested_arch.index_array = NULL;
15194 nested_arch.sym_table = NULL;
15195 nested_arch.longnames = NULL;
15196
15197 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15198 {
15199 ret = 1;
15200 goto out;
4145f1d5 15201 }
fb52b2f4 15202
4145f1d5
NC		 15203 if (do_archive_index)
15204 {
2cf0635d 15205 if (arch.sym_table == NULL)
4145f1d5
NC		 15206 error (_("%s: unable to dump the index as none was found\n"), file_name);
15207 else
15208 {
2cf0635d 15209 unsigned int i, l;
4145f1d5
NC		 15210 unsigned long current_pos;
15211
15212 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 15213 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 15214 current_pos = ftell (file);
15215
2cf0635d 15216 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 15217 {
2cf0635d
NC		 15218 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15219 {
15220 char * member_name;
4145f1d5 15221
2cf0635d
NC		 15222 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15223
15224 if (member_name != NULL)
15225 {
15226 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15227
15228 if (qualified_name != NULL)
15229 {
c2a7d3f5
NC		 15230 printf (_("Contents of binary %s at offset "), qualified_name);
15231 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15232 putchar ('\n');
2cf0635d
NC		 15233 free (qualified_name);
15234 }
4145f1d5
NC		 15235 }
15236 }
2cf0635d
NC		 15237
15238 if (l >= arch.sym_size)
4145f1d5
NC		 15239 {
15240 error (_("%s: end of the symbol table reached before the end of the index\n"),
15241 file_name);
cb8f3167 15242 break;
4145f1d5 15243 }
2cf0635d
NC		 15244 printf ("\t%s\n", arch.sym_table + l);
15245 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 15246 }
15247
c2a7d3f5
NC		 15248 if (arch.uses_64bit_indicies)
15249 l = (l + 7) & ~ 7;
15250 else
15251 l += l & 1;
15252
2cf0635d 15253 if (l < arch.sym_size)
c2a7d3f5
NC		 15254 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15255 file_name, arch.sym_size - l);
4145f1d5 15256
4145f1d5
NC		 15257 if (fseek (file, current_pos, SEEK_SET) != 0)
15258 {
15259 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 15260 ret = 1;
15261 goto out;
4145f1d5 15262 }
fb52b2f4 15263 }
4145f1d5
NC		 15264
15265 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15266 && !do_segments && !do_header && !do_dump && !do_version
15267 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 15268 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 15269 {
15270 ret = 0; /* Archive index only. */
15271 goto out;
15272 }
fb52b2f4
NC		 15273 }
15274
d989285c 15275 ret = 0;
fb52b2f4
NC		 15276
15277 while (1)
15278 {
2cf0635d
NC		 15279 char * name;
15280 size_t namelen;
15281 char * qualified_name;
15282
15283 /* Read the next archive header. */
15284 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15285 {
15286 error (_("%s: failed to seek to next archive header\n"), file_name);
15287 return 1;
15288 }
15289 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15290 if (got != sizeof arch.arhdr)
15291 {
15292 if (got == 0)
15293 break;
15294 error (_("%s: failed to read archive header\n"), file_name);
15295 ret = 1;
15296 break;
15297 }
15298 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15299 {
15300 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15301 ret = 1;
15302 break;
15303 }
15304
15305 arch.next_arhdr_offset += sizeof arch.arhdr;
15306
15307 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15308 if (archive_file_size & 01)
15309 ++archive_file_size;
15310
15311 name = get_archive_member_name (&arch, &nested_arch);
15312 if (name == NULL)
fb52b2f4 15313 {
0fd3a477 15314 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15315 ret = 1;
15316 break;
fb52b2f4 15317 }
2cf0635d 15318 namelen = strlen (name);
fb52b2f4 15319
2cf0635d
NC		 15320 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15321 if (qualified_name == NULL)
fb52b2f4 15322 {
2cf0635d 15323 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15324 ret = 1;
15325 break;
fb52b2f4
NC		 15326 }
15327
2cf0635d
NC		 15328 if (is_thin_archive && arch.nested_member_origin == 0)
15329 {
15330 /* This is a proxy for an external member of a thin archive. */
15331 FILE * member_file;
15332 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15333 if (member_file_name == NULL)
15334 {
15335 ret = 1;
15336 break;
15337 }
15338
15339 member_file = fopen (member_file_name, "rb");
15340 if (member_file == NULL)
15341 {
15342 error (_("Input file '%s' is not readable.\n"), member_file_name);
15343 free (member_file_name);
15344 ret = 1;
15345 break;
15346 }
15347
15348 archive_file_offset = arch.nested_member_origin;
15349
15350 ret |= process_object (qualified_name, member_file);
15351
15352 fclose (member_file);
15353 free (member_file_name);
15354 }
15355 else if (is_thin_archive)
15356 {
a043396b
NC		 15357 /* PR 15140: Allow for corrupt thin archives. */
15358 if (nested_arch.file == NULL)
15359 {
15360 error (_("%s: contains corrupt thin archive: %s\n"),
15361 file_name, name);
15362 ret = 1;
15363 break;
15364 }
15365
2cf0635d
NC		 15366 /* This is a proxy for a member of a nested archive. */
15367 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15368
15369 /* The nested archive file will have been opened and setup by
15370 get_archive_member_name. */
15371 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15372 {
15373 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15374 ret = 1;
15375 break;
15376 }
15377
15378 ret |= process_object (qualified_name, nested_arch.file);
15379 }
15380 else
15381 {
15382 archive_file_offset = arch.next_arhdr_offset;
15383 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 15384
2cf0635d
NC		 15385 ret |= process_object (qualified_name, file);
15386 }
fb52b2f4 15387
2b52916e
L		 15388 if (dump_sects != NULL)
15389 {
15390 free (dump_sects);
15391 dump_sects = NULL;
15392 num_dump_sects = 0;
15393 }
15394
2cf0635d 15395 free (qualified_name);
fb52b2f4
NC		 15396 }
15397
4145f1d5 15398 out:
2cf0635d
NC		 15399 if (nested_arch.file != NULL)
15400 fclose (nested_arch.file);
15401 release_archive (&nested_arch);
15402 release_archive (&arch);
fb52b2f4 15403
d989285c 15404 return ret;
fb52b2f4
NC		 15405}
15406
15407static int
2cf0635d 15408process_file (char * file_name)
fb52b2f4 15409{
2cf0635d 15410 FILE * file;
fb52b2f4
NC		 15411 struct stat statbuf;
15412 char armag[SARMAG];
15413 int ret;
15414
15415 if (stat (file_name, &statbuf) < 0)
15416 {
f24ddbdd
NC		 15417 if (errno == ENOENT)
15418 error (_("'%s': No such file\n"), file_name);
15419 else
15420 error (_("Could not locate '%s'. System error message: %s\n"),
15421 file_name, strerror (errno));
15422 return 1;
15423 }
15424
15425 if (! S_ISREG (statbuf.st_mode))
15426 {
15427 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 15428 return 1;
15429 }
15430
15431 file = fopen (file_name, "rb");
15432 if (file == NULL)
15433 {
f24ddbdd 15434 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 15435 return 1;
15436 }
15437
15438 if (fread (armag, SARMAG, 1, file) != 1)
15439 {
4145f1d5 15440 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 15441 fclose (file);
15442 return 1;
15443 }
15444
f54498b4
NC		 15445 current_file_size = (bfd_size_type) statbuf.st_size;
15446
fb52b2f4 15447 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 15448 ret = process_archive (file_name, file, FALSE);
15449 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15450 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 15451 else
15452 {
4145f1d5
NC		 15453 if (do_archive_index)
15454 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15455 file_name);
15456
fb52b2f4
NC		 15457 rewind (file);
15458 archive_file_size = archive_file_offset = 0;
15459 ret = process_object (file_name, file);
15460 }
15461
15462 fclose (file);
15463
f54498b4 15464 current_file_size = 0;
fb52b2f4
NC		 15465 return ret;
15466}
15467
252b5132
RH		 15468#ifdef SUPPORT_DISASSEMBLY
15469/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 15470 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 15471 symbols. */
252b5132
RH		 15472
15473void
2cf0635d 15474print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 15475{
15476 fprintf (outfile,"0x%8.8x", addr);
15477}
15478
e3c8793a 15479/* Needed by the i386 disassembler. */
252b5132
RH		 15480void
15481db_task_printsym (unsigned int addr)
15482{
15483 print_address (addr, stderr);
15484}
15485#endif
15486
15487int
2cf0635d 15488main (int argc, char ** argv)
252b5132 15489{
ff78d6d6
L		 15490 int err;
15491
252b5132
RH		 15492#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15493 setlocale (LC_MESSAGES, "");
3882b010
L		 15494#endif
15495#if defined (HAVE_SETLOCALE)
15496 setlocale (LC_CTYPE, "");
252b5132
RH		 15497#endif
15498 bindtextdomain (PACKAGE, LOCALEDIR);
15499 textdomain (PACKAGE);
15500
869b9d07
MM		 15501 expandargv (&argc, &argv);
15502
252b5132
RH		 15503 parse_args (argc, argv);
15504
18bd398b 15505 if (num_dump_sects > 0)
59f14fc0 15506 {
18bd398b 15507 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 15508 cmdline_dump_sects = (dump_type *)
15509 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 15510 if (cmdline_dump_sects == NULL)
591a748a 15511 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 15512 else
15513 {
09c11c86
NC		 15514 memcpy (cmdline_dump_sects, dump_sects,
15515 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 15516 num_cmdline_dump_sects = num_dump_sects;
15517 }
15518 }
15519
18bd398b
NC		 15520 if (optind < (argc - 1))
15521 show_name = 1;
15522
ff78d6d6 15523 err = 0;
252b5132 15524 while (optind < argc)
18bd398b 15525 err |= process_file (argv[optind++]);
252b5132
RH		 15526
15527 if (dump_sects != NULL)
15528 free (dump_sects);
59f14fc0
AS		 15529 if (cmdline_dump_sects != NULL)
15530 free (cmdline_dump_sects);
252b5132 15531
ff78d6d6 15532 return err;
252b5132 15533}
A mirror of the official binutils-gdb repository