]> 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
gold: fix ABI pagesize for aarch64
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
b90efa5b 2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
6a40cf0c
NC		 167typedef struct elf_section_list
168{
169 Elf_Internal_Shdr * hdr;
170 struct elf_section_list * next;
171} elf_section_list;
172
2cf0635d 173char * program_name = "readelf";
c9c1d674 174static unsigned long archive_file_offset;
85b1c36d 175static unsigned long archive_file_size;
f54498b4 176static bfd_size_type current_file_size;
85b1c36d
BE		 177static unsigned long dynamic_addr;
178static bfd_size_type dynamic_size;
8b73c356 179static size_t dynamic_nent;
2cf0635d 180static char * dynamic_strings;
85b1c36d 181static unsigned long dynamic_strings_length;
2cf0635d 182static char * string_table;
85b1c36d
BE		 183static unsigned long string_table_length;
184static unsigned long num_dynamic_syms;
2cf0635d
NC		 185static Elf_Internal_Sym * dynamic_symbols;
186static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 187static unsigned long dynamic_syminfo_offset;
188static unsigned int dynamic_syminfo_nent;
f8eae8b2 189static char program_interpreter[PATH_MAX];
bb8a0291 190static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 191static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 192static bfd_vma version_info[16];
193static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 194static Elf_Internal_Shdr * section_headers;
195static Elf_Internal_Phdr * program_headers;
196static Elf_Internal_Dyn * dynamic_section;
6a40cf0c 197static elf_section_list * symtab_shndx_list;
85b1c36d
BE		 198static int show_name;
199static int do_dynamic;
200static int do_syms;
2c610e4b 201static int do_dyn_syms;
85b1c36d
BE		 202static int do_reloc;
203static int do_sections;
204static int do_section_groups;
5477e8a0 205static int do_section_details;
85b1c36d
BE		 206static int do_segments;
207static int do_unwind;
208static int do_using_dynamic;
209static int do_header;
210static int do_dump;
211static int do_version;
85b1c36d
BE		 212static int do_histogram;
213static int do_debugging;
85b1c36d
BE		 214static int do_arch;
215static int do_notes;
4145f1d5 216static int do_archive_index;
85b1c36d 217static int is_32bit_elf;
0e602686 218static int decompress_dumps;
252b5132 219
e4b17d5c
L		 220struct group_list
221{
2cf0635d 222 struct group_list * next;
e4b17d5c
L		 223 unsigned int section_index;
224};
225
226struct group
227{
2cf0635d 228 struct group_list * root;
e4b17d5c
L		 229 unsigned int group_index;
230};
231
85b1c36d 232static size_t group_count;
2cf0635d
NC		 233static struct group * section_groups;
234static struct group ** section_headers_groups;
e4b17d5c 235
09c11c86
NC		 236
237/* Flag bits indicating particular types of dump. */
238#define HEX_DUMP (1 << 0) /* The -x command line switch. */
239#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
240#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
241#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 242#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 243
244typedef unsigned char dump_type;
245
246/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 247struct dump_list_entry
248{
2cf0635d 249 char * name;
09c11c86 250 dump_type type;
2cf0635d 251 struct dump_list_entry * next;
aef1f6d0 252};
2cf0635d 253static struct dump_list_entry * dump_sects_byname;
aef1f6d0 254
09c11c86
NC		 255/* A dynamic array of flags indicating for which sections a dump
256 has been requested via command line switches. */
257static dump_type * cmdline_dump_sects = NULL;
258static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 259
260/* A dynamic array of flags indicating for which sections a dump of
261 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 262 basis and then initialised from the cmdline_dump_sects array,
263 the results of interpreting the -w switch, and the
264 dump_sects_byname list. */
09c11c86
NC		 265static dump_type * dump_sects = NULL;
266static unsigned int num_dump_sects = 0;
252b5132 267
252b5132 268
c256ffe7 269/* How to print a vma value. */
843dd992
NC		 270typedef enum print_mode
271{
272 HEX,
273 DEC,
274 DEC_5,
275 UNSIGNED,
276 PREFIX_HEX,
277 FULL_HEX,
278 LONG_HEX
279}
280print_mode;
281
bb4d2ac2
L		 282/* Versioned symbol info. */
283enum versioned_symbol_info
284{
285 symbol_undefined,
286 symbol_hidden,
287 symbol_public
288};
289
290static const char *get_symbol_version_string
291 (FILE *file, int is_dynsym, const char *strtab,
292 unsigned long int strtab_size, unsigned int si,
293 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
294 unsigned short *vna_other);
295
9c19a809
NC		 296#define UNKNOWN -1
297
2b692964
NC		 298#define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 302 : string_table + (X)->sh_name))
252b5132 303
ee42cf8c 304#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 305
ba5cdace
NC		 306#define GET_ELF_SYMBOLS(file, section, sym_count) \
307 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
308 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 309
d79b3d50
NC		 310#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
311/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
312 already been called and verified that the string exists. */
313#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 314
61865e30
NC		 315#define REMOVE_ARCH_BITS(ADDR) \
316 do \
317 { \
318 if (elf_header.e_machine == EM_ARM) \
319 (ADDR) &= ~1; \
320 } \
321 while (0)
d79b3d50 322\f
c9c1d674
EG		 323/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
324 the offset of the current archive member, if we are examining an archive.
59245841
NC		 325 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
326 using malloc and fill that. In either case return the pointer to the start of
327 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 328 and REASON is not NULL then emit an error message using REASON as part of the
329 context. */
59245841 330
c256ffe7 331static void *
57028622
NC		 332get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
333 bfd_size_type nmemb, const char * reason)
a6e9f9df 334{
2cf0635d 335 void * mvar;
57028622 336 bfd_size_type amt = size * nmemb;
a6e9f9df 337
c256ffe7 338 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 339 return NULL;
340
57028622
NC		 341 /* If the size_t type is smaller than the bfd_size_type, eg because
342 you are building a 32-bit tool on a 64-bit host, then make sure
343 that when the sizes are cast to (size_t) no information is lost. */
344 if (sizeof (size_t) < sizeof (bfd_size_type)
345 && ( (bfd_size_type) ((size_t) size) != size
346 || (bfd_size_type) ((size_t) nmemb) != nmemb))
347 {
348 if (reason)
349 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
350 (unsigned long long) nmemb, (unsigned long long) size, reason);
351 return NULL;
352 }
353
354 /* Check for size overflow. */
355 if (amt < nmemb)
356 {
357 if (reason)
358 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
359 (unsigned long long) nmemb, (unsigned long long) size, reason);
360 return NULL;
361 }
362
c9c1d674
EG		 363 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
364 attempting to allocate memory when the read is bound to fail. */
365 if (amt > current_file_size
366 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 367 {
049b0c3a 368 if (reason)
57028622
NC		 369 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
370 (unsigned long long) amt, reason);
a6e9f9df
AM		 371 return NULL;
372 }
373
c9c1d674 374 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 375 {
376 if (reason)
c9c1d674
EG		 377 error (_("Unable to seek to 0x%lx for %s\n"),
378 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 379 return NULL;
380 }
381
a6e9f9df
AM		 382 mvar = var;
383 if (mvar == NULL)
384 {
c256ffe7 385 /* Check for overflow. */
57028622 386 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 387 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 388 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 389
390 if (mvar == NULL)
391 {
049b0c3a 392 if (reason)
57028622
NC		 393 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
394 (unsigned long long) amt, reason);
a6e9f9df
AM		 395 return NULL;
396 }
c256ffe7 397
c9c1d674 398 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 399 }
400
57028622 401 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 402 {
049b0c3a 403 if (reason)
57028622
NC		 404 error (_("Unable to read in 0x%llx bytes of %s\n"),
405 (unsigned long long) amt, reason);
a6e9f9df
AM		 406 if (mvar != var)
407 free (mvar);
408 return NULL;
409 }
410
411 return mvar;
412}
413
14a91970 414/* Print a VMA value. */
cb8f3167 415
66543521 416static int
14a91970 417print_vma (bfd_vma vma, print_mode mode)
66543521 418{
66543521
AM		 419 int nc = 0;
420
14a91970 421 switch (mode)
66543521 422 {
14a91970
AM		 423 case FULL_HEX:
424 nc = printf ("0x");
425 /* Drop through. */
66543521 426
14a91970 427 case LONG_HEX:
f7a99963 428#ifdef BFD64
14a91970 429 if (is_32bit_elf)
437c2fb7 430 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 431#endif
14a91970
AM		 432 printf_vma (vma);
433 return nc + 16;
b19aac67 434
14a91970
AM		 435 case DEC_5:
436 if (vma <= 99999)
437 return printf ("%5" BFD_VMA_FMT "d", vma);
438 /* Drop through. */
66543521 439
14a91970
AM		 440 case PREFIX_HEX:
441 nc = printf ("0x");
442 /* Drop through. */
66543521 443
14a91970
AM		 444 case HEX:
445 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 446
14a91970
AM		 447 case DEC:
448 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 449
14a91970
AM		 450 case UNSIGNED:
451 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 452 }
66543521 453 return 0;
f7a99963
NC		 454}
455
7bfd842d 456/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 457 multibye characters (assuming the host environment supports them).
31104126 458
7bfd842d
NC		 459 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
460
461 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
462 padding as necessary.
171191ba
NC		 463
464 Returns the number of emitted characters. */
465
466static unsigned int
7a88bc9c 467print_symbol (int width, const char *symbol)
31104126 468{
171191ba 469 bfd_boolean extra_padding = FALSE;
7bfd842d 470 int num_printed = 0;
3bfcb652 471#ifdef HAVE_MBSTATE_T
7bfd842d 472 mbstate_t state;
3bfcb652 473#endif
7bfd842d 474 int width_remaining;
961c521f 475
7bfd842d 476 if (width < 0)
961c521f 477 {
961c521f
NC		 478 /* Keep the width positive. This also helps. */
479 width = - width;
171191ba 480 extra_padding = TRUE;
0b4362b0 481 }
74e1a04b 482 assert (width != 0);
961c521f 483
7bfd842d
NC		 484 if (do_wide)
485 /* Set the remaining width to a very large value.
486 This simplifies the code below. */
487 width_remaining = INT_MAX;
488 else
489 width_remaining = width;
cb8f3167 490
3bfcb652 491#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 492 /* Initialise the multibyte conversion state. */
493 memset (& state, 0, sizeof (state));
3bfcb652 494#endif
961c521f 495
7bfd842d
NC		 496 while (width_remaining)
497 {
498 size_t n;
7bfd842d 499 const char c = *symbol++;
961c521f 500
7bfd842d 501 if (c == 0)
961c521f
NC		 502 break;
503
7bfd842d
NC		 504 /* Do not print control characters directly as they can affect terminal
505 settings. Such characters usually appear in the names generated
506 by the assembler for local labels. */
507 if (ISCNTRL (c))
961c521f 508 {
7bfd842d 509 if (width_remaining < 2)
961c521f
NC		 510 break;
511
7bfd842d
NC		 512 printf ("^%c", c + 0x40);
513 width_remaining -= 2;
171191ba 514 num_printed += 2;
961c521f 515 }
7bfd842d
NC		 516 else if (ISPRINT (c))
517 {
518 putchar (c);
519 width_remaining --;
520 num_printed ++;
521 }
961c521f
NC		 522 else
523 {
3bfcb652
NC		 524#ifdef HAVE_MBSTATE_T
525 wchar_t w;
526#endif
7bfd842d
NC		 527 /* Let printf do the hard work of displaying multibyte characters. */
528 printf ("%.1s", symbol - 1);
529 width_remaining --;
530 num_printed ++;
531
3bfcb652 532#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 533 /* Try to find out how many bytes made up the character that was
534 just printed. Advance the symbol pointer past the bytes that
535 were displayed. */
536 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 537#else
538 n = 1;
539#endif
7bfd842d
NC		 540 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
541 symbol += (n - 1);
961c521f 542 }
961c521f 543 }
171191ba 544
7bfd842d 545 if (extra_padding && num_printed < width)
171191ba
NC		 546 {
547 /* Fill in the remaining spaces. */
7bfd842d
NC		 548 printf ("%-*s", width - num_printed, " ");
549 num_printed = width;
171191ba
NC		 550 }
551
552 return num_printed;
31104126
NC		 553}
554
74e1a04b
NC		 555/* Returns a pointer to a static buffer containing a printable version of
556 the given section's name. Like print_symbol, except that it does not try
557 to print multibyte characters, it just interprets them as hex values. */
558
559static const char *
0d2a7a93 560printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 561{
562#define MAX_PRINT_SEC_NAME_LEN 128
563 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
564 const char * name = SECTION_NAME (sec);
565 char * buf = sec_name_buf;
566 char c;
567 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
568
569 while ((c = * name ++) != 0)
570 {
571 if (ISCNTRL (c))
572 {
573 if (remaining < 2)
574 break;
948f632f 575
74e1a04b
NC		 576 * buf ++ = '^';
577 * buf ++ = c + 0x40;
578 remaining -= 2;
579 }
580 else if (ISPRINT (c))
581 {
582 * buf ++ = c;
583 remaining -= 1;
584 }
585 else
586 {
587 static char hex[17] = "0123456789ABCDEF";
588
589 if (remaining < 4)
590 break;
591 * buf ++ = '<';
592 * buf ++ = hex[(c & 0xf0) >> 4];
593 * buf ++ = hex[c & 0x0f];
594 * buf ++ = '>';
595 remaining -= 4;
596 }
597
598 if (remaining == 0)
599 break;
600 }
601
602 * buf = 0;
603 return sec_name_buf;
604}
605
606static const char *
607printable_section_name_from_index (unsigned long ndx)
608{
609 if (ndx >= elf_header.e_shnum)
610 return _("<corrupt>");
611
612 return printable_section_name (section_headers + ndx);
613}
614
89fac5e3
RS		 615/* Return a pointer to section NAME, or NULL if no such section exists. */
616
617static Elf_Internal_Shdr *
2cf0635d 618find_section (const char * name)
89fac5e3
RS		 619{
620 unsigned int i;
621
622 for (i = 0; i < elf_header.e_shnum; i++)
623 if (streq (SECTION_NAME (section_headers + i), name))
624 return section_headers + i;
625
626 return NULL;
627}
628
0b6ae522
DJ		 629/* Return a pointer to a section containing ADDR, or NULL if no such
630 section exists. */
631
632static Elf_Internal_Shdr *
633find_section_by_address (bfd_vma addr)
634{
635 unsigned int i;
636
637 for (i = 0; i < elf_header.e_shnum; i++)
638 {
639 Elf_Internal_Shdr *sec = section_headers + i;
640 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
641 return sec;
642 }
643
644 return NULL;
645}
646
071436c6
NC		 647static Elf_Internal_Shdr *
648find_section_by_type (unsigned int type)
649{
650 unsigned int i;
651
652 for (i = 0; i < elf_header.e_shnum; i++)
653 {
654 Elf_Internal_Shdr *sec = section_headers + i;
655 if (sec->sh_type == type)
656 return sec;
657 }
658
659 return NULL;
660}
661
657d0d47
CC		 662/* Return a pointer to section NAME, or NULL if no such section exists,
663 restricted to the list of sections given in SET. */
664
665static Elf_Internal_Shdr *
666find_section_in_set (const char * name, unsigned int * set)
667{
668 unsigned int i;
669
670 if (set != NULL)
671 {
672 while ((i = *set++) > 0)
673 if (streq (SECTION_NAME (section_headers + i), name))
674 return section_headers + i;
675 }
676
677 return find_section (name);
678}
679
0b6ae522
DJ		 680/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
681 bytes read. */
682
f6f0e17b
NC		 683static inline unsigned long
684read_uleb128 (unsigned char *data,
685 unsigned int *length_return,
686 const unsigned char * const end)
0b6ae522 687{
f6f0e17b 688 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 689}
690
28f997cf
TG		 691/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
692 This OS has so many departures from the ELF standard that we test it at
693 many places. */
694
695static inline int
696is_ia64_vms (void)
697{
698 return elf_header.e_machine == EM_IA_64
699 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
700}
701
bcedfee6 702/* Guess the relocation size commonly used by the specific machines. */
252b5132 703
252b5132 704static int
2dc4cec1 705guess_is_rela (unsigned int e_machine)
252b5132 706{
9c19a809 707 switch (e_machine)
252b5132
RH		 708 {
709 /* Targets that use REL relocations. */
252b5132 710 case EM_386:
22abe556 711 case EM_IAMCU:
63fcb9e9 712 case EM_960:
e9f53129 713 case EM_ARM:
2b0337b0 714 case EM_D10V:
252b5132 715 case EM_CYGNUS_D10V:
e9f53129 716 case EM_DLX:
252b5132 717 case EM_MIPS:
4fe85591 718 case EM_MIPS_RS3_LE:
e9f53129 719 case EM_CYGNUS_M32R:
1c0d3aa6 720 case EM_SCORE:
f6c1a2d5 721 case EM_XGATE:
9c19a809 722 return FALSE;
103f02d3 723
252b5132
RH		 724 /* Targets that use RELA relocations. */
725 case EM_68K:
e9f53129 726 case EM_860:
a06ea964 727 case EM_AARCH64:
cfb8c092 728 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 729 case EM_ALPHA:
730 case EM_ALTERA_NIOS2:
731 case EM_AVR:
732 case EM_AVR_OLD:
733 case EM_BLACKFIN:
60bca95a 734 case EM_CR16:
e9f53129
AM		 735 case EM_CRIS:
736 case EM_CRX:
2b0337b0 737 case EM_D30V:
252b5132 738 case EM_CYGNUS_D30V:
2b0337b0 739 case EM_FR30:
3f8107ab 740 case EM_FT32:
252b5132 741 case EM_CYGNUS_FR30:
5c70f934 742 case EM_CYGNUS_FRV:
e9f53129
AM		 743 case EM_H8S:
744 case EM_H8_300:
745 case EM_H8_300H:
800eeca4 746 case EM_IA_64:
1e4cf259
NC		 747 case EM_IP2K:
748 case EM_IP2K_OLD:
3b36097d 749 case EM_IQ2000:
84e94c90 750 case EM_LATTICEMICO32:
ff7eeb89 751 case EM_M32C_OLD:
49f58d10 752 case EM_M32C:
e9f53129
AM		 753 case EM_M32R:
754 case EM_MCORE:
15ab5209 755 case EM_CYGNUS_MEP:
a3c62988 756 case EM_METAG:
e9f53129
AM		 757 case EM_MMIX:
758 case EM_MN10200:
759 case EM_CYGNUS_MN10200:
760 case EM_MN10300:
761 case EM_CYGNUS_MN10300:
5506d11a 762 case EM_MOXIE:
e9f53129
AM		 763 case EM_MSP430:
764 case EM_MSP430_OLD:
d031aafb 765 case EM_MT:
35c08157 766 case EM_NDS32:
64fd6348 767 case EM_NIOS32:
73589c9d 768 case EM_OR1K:
e9f53129
AM		 769 case EM_PPC64:
770 case EM_PPC:
99c513f6 771 case EM_RL78:
c7927a3c 772 case EM_RX:
e9f53129
AM		 773 case EM_S390:
774 case EM_S390_OLD:
775 case EM_SH:
776 case EM_SPARC:
777 case EM_SPARC32PLUS:
778 case EM_SPARCV9:
779 case EM_SPU:
40b36596 780 case EM_TI_C6000:
aa137e4d
NC		 781 case EM_TILEGX:
782 case EM_TILEPRO:
708e2187 783 case EM_V800:
e9f53129
AM		 784 case EM_V850:
785 case EM_CYGNUS_V850:
786 case EM_VAX:
619ed720 787 case EM_VISIUM:
e9f53129 788 case EM_X86_64:
8a9036a4 789 case EM_L1OM:
7a9068fe 790 case EM_K1OM:
e9f53129
AM		 791 case EM_XSTORMY16:
792 case EM_XTENSA:
793 case EM_XTENSA_OLD:
7ba29e2a
NC		 794 case EM_MICROBLAZE:
795 case EM_MICROBLAZE_OLD:
9c19a809 796 return TRUE;
103f02d3 797
e9f53129
AM		 798 case EM_68HC05:
799 case EM_68HC08:
800 case EM_68HC11:
801 case EM_68HC16:
802 case EM_FX66:
803 case EM_ME16:
d1133906 804 case EM_MMA:
d1133906
NC		 805 case EM_NCPU:
806 case EM_NDR1:
e9f53129 807 case EM_PCP:
d1133906 808 case EM_ST100:
e9f53129 809 case EM_ST19:
d1133906 810 case EM_ST7:
e9f53129
AM		 811 case EM_ST9PLUS:
812 case EM_STARCORE:
d1133906 813 case EM_SVX:
e9f53129 814 case EM_TINYJ:
9c19a809
NC		 815 default:
816 warn (_("Don't know about relocations on this machine architecture\n"));
817 return FALSE;
818 }
819}
252b5132 820
9c19a809 821static int
2cf0635d 822slurp_rela_relocs (FILE * file,
d3ba0551
AM		 823 unsigned long rel_offset,
824 unsigned long rel_size,
2cf0635d
NC		 825 Elf_Internal_Rela ** relasp,
826 unsigned long * nrelasp)
9c19a809 827{
2cf0635d 828 Elf_Internal_Rela * relas;
8b73c356 829 size_t nrelas;
4d6ed7c8 830 unsigned int i;
252b5132 831
4d6ed7c8
NC		 832 if (is_32bit_elf)
833 {
2cf0635d 834 Elf32_External_Rela * erelas;
103f02d3 835
3f5e193b 836 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 837 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 838 if (!erelas)
839 return 0;
252b5132 840
4d6ed7c8 841 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 842
3f5e193b
NC		 843 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
844 sizeof (Elf_Internal_Rela));
103f02d3 845
4d6ed7c8
NC		 846 if (relas == NULL)
847 {
c256ffe7 848 free (erelas);
591a748a 849 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 850 return 0;
851 }
103f02d3 852
4d6ed7c8
NC		 853 for (i = 0; i < nrelas; i++)
854 {
855 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
856 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 857 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 858 }
103f02d3 859
4d6ed7c8
NC		 860 free (erelas);
861 }
862 else
863 {
2cf0635d 864 Elf64_External_Rela * erelas;
103f02d3 865
3f5e193b 866 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 867 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 868 if (!erelas)
869 return 0;
4d6ed7c8
NC		 870
871 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 872
3f5e193b
NC		 873 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
874 sizeof (Elf_Internal_Rela));
103f02d3 875
4d6ed7c8
NC		 876 if (relas == NULL)
877 {
c256ffe7 878 free (erelas);
591a748a 879 error (_("out of memory parsing relocs\n"));
4d6ed7c8 880 return 0;
9c19a809 881 }
4d6ed7c8
NC		 882
883 for (i = 0; i < nrelas; i++)
9c19a809 884 {
66543521
AM		 885 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
886 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 887 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 888
889 /* The #ifdef BFD64 below is to prevent a compile time
890 warning. We know that if we do not have a 64 bit data
891 type that we will never execute this code anyway. */
892#ifdef BFD64
893 if (elf_header.e_machine == EM_MIPS
894 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
895 {
896 /* In little-endian objects, r_info isn't really a
897 64-bit little-endian value: it has a 32-bit
898 little-endian symbol index followed by four
899 individual byte fields. Reorder INFO
900 accordingly. */
91d6fa6a
NC		 901 bfd_vma inf = relas[i].r_info;
902 inf = (((inf & 0xffffffff) << 32)
903 | ((inf >> 56) & 0xff)
904 | ((inf >> 40) & 0xff00)
905 | ((inf >> 24) & 0xff0000)
906 | ((inf >> 8) & 0xff000000));
907 relas[i].r_info = inf;
861fb55a
DJ		 908 }
909#endif /* BFD64 */
4d6ed7c8 910 }
103f02d3 911
4d6ed7c8
NC		 912 free (erelas);
913 }
914 *relasp = relas;
915 *nrelasp = nrelas;
916 return 1;
917}
103f02d3 918
4d6ed7c8 919static int
2cf0635d 920slurp_rel_relocs (FILE * file,
d3ba0551
AM		 921 unsigned long rel_offset,
922 unsigned long rel_size,
2cf0635d
NC		 923 Elf_Internal_Rela ** relsp,
924 unsigned long * nrelsp)
4d6ed7c8 925{
2cf0635d 926 Elf_Internal_Rela * rels;
8b73c356 927 size_t nrels;
4d6ed7c8 928 unsigned int i;
103f02d3 929
4d6ed7c8
NC		 930 if (is_32bit_elf)
931 {
2cf0635d 932 Elf32_External_Rel * erels;
103f02d3 933
3f5e193b 934 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 935 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 936 if (!erels)
937 return 0;
103f02d3 938
4d6ed7c8 939 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 940
3f5e193b 941 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 942
4d6ed7c8
NC		 943 if (rels == NULL)
944 {
c256ffe7 945 free (erels);
591a748a 946 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 947 return 0;
948 }
949
950 for (i = 0; i < nrels; i++)
951 {
952 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
953 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 954 rels[i].r_addend = 0;
9ea033b2 955 }
4d6ed7c8
NC		 956
957 free (erels);
9c19a809
NC		 958 }
959 else
960 {
2cf0635d 961 Elf64_External_Rel * erels;
9ea033b2 962
3f5e193b 963 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 964 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 965 if (!erels)
966 return 0;
103f02d3 967
4d6ed7c8 968 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 969
3f5e193b 970 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 971
4d6ed7c8 972 if (rels == NULL)
9c19a809 973 {
c256ffe7 974 free (erels);
591a748a 975 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 976 return 0;
977 }
103f02d3 978
4d6ed7c8
NC		 979 for (i = 0; i < nrels; i++)
980 {
66543521
AM		 981 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
982 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 983 rels[i].r_addend = 0;
861fb55a
DJ		 984
985 /* The #ifdef BFD64 below is to prevent a compile time
986 warning. We know that if we do not have a 64 bit data
987 type that we will never execute this code anyway. */
988#ifdef BFD64
989 if (elf_header.e_machine == EM_MIPS
990 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
991 {
992 /* In little-endian objects, r_info isn't really a
993 64-bit little-endian value: it has a 32-bit
994 little-endian symbol index followed by four
995 individual byte fields. Reorder INFO
996 accordingly. */
91d6fa6a
NC		 997 bfd_vma inf = rels[i].r_info;
998 inf = (((inf & 0xffffffff) << 32)
999 | ((inf >> 56) & 0xff)
1000 | ((inf >> 40) & 0xff00)
1001 | ((inf >> 24) & 0xff0000)
1002 | ((inf >> 8) & 0xff000000));
1003 rels[i].r_info = inf;
861fb55a
DJ		 1004 }
1005#endif /* BFD64 */
4d6ed7c8 1006 }
103f02d3 1007
4d6ed7c8
NC		 1008 free (erels);
1009 }
1010 *relsp = rels;
1011 *nrelsp = nrels;
1012 return 1;
1013}
103f02d3 1014
aca88567
NC		 1015/* Returns the reloc type extracted from the reloc info field. */
1016
1017static unsigned int
1018get_reloc_type (bfd_vma reloc_info)
1019{
1020 if (is_32bit_elf)
1021 return ELF32_R_TYPE (reloc_info);
1022
1023 switch (elf_header.e_machine)
1024 {
1025 case EM_MIPS:
1026 /* Note: We assume that reloc_info has already been adjusted for us. */
1027 return ELF64_MIPS_R_TYPE (reloc_info);
1028
1029 case EM_SPARCV9:
1030 return ELF64_R_TYPE_ID (reloc_info);
1031
1032 default:
1033 return ELF64_R_TYPE (reloc_info);
1034 }
1035}
1036
1037/* Return the symbol index extracted from the reloc info field. */
1038
1039static bfd_vma
1040get_reloc_symindex (bfd_vma reloc_info)
1041{
1042 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1043}
1044
13761a11
NC		 1045static inline bfd_boolean
1046uses_msp430x_relocs (void)
1047{
1048 return
1049 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1050 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1051 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1052 /* TI compiler uses ELFOSABI_NONE. */
1053 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1054}
1055
d3ba0551
AM		 1056/* Display the contents of the relocation data found at the specified
1057 offset. */
ee42cf8c 1058
41e92641 1059static void
2cf0635d 1060dump_relocations (FILE * file,
d3ba0551
AM		 1061 unsigned long rel_offset,
1062 unsigned long rel_size,
2cf0635d 1063 Elf_Internal_Sym * symtab,
d3ba0551 1064 unsigned long nsyms,
2cf0635d 1065 char * strtab,
d79b3d50 1066 unsigned long strtablen,
bb4d2ac2
L		 1067 int is_rela,
1068 int is_dynsym)
4d6ed7c8 1069{
b34976b6 1070 unsigned int i;
2cf0635d 1071 Elf_Internal_Rela * rels;
103f02d3 1072
4d6ed7c8
NC		 1073 if (is_rela == UNKNOWN)
1074 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1075
4d6ed7c8
NC		 1076 if (is_rela)
1077 {
c8286bd1 1078 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1079 return;
4d6ed7c8
NC		 1080 }
1081 else
1082 {
1083 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1084 return;
252b5132
RH		 1085 }
1086
410f7a12
L		 1087 if (is_32bit_elf)
1088 {
1089 if (is_rela)
2c71103e
NC		 1090 {
1091 if (do_wide)
1092 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1093 else
1094 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1095 }
410f7a12 1096 else
2c71103e
NC		 1097 {
1098 if (do_wide)
1099 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1100 else
1101 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1102 }
410f7a12 1103 }
252b5132 1104 else
410f7a12
L		 1105 {
1106 if (is_rela)
2c71103e
NC		 1107 {
1108 if (do_wide)
8beeaeb7 1109 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1110 else
1111 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1112 }
410f7a12 1113 else
2c71103e
NC		 1114 {
1115 if (do_wide)
8beeaeb7 1116 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1117 else
1118 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1119 }
410f7a12 1120 }
252b5132
RH		 1121
1122 for (i = 0; i < rel_size; i++)
1123 {
2cf0635d 1124 const char * rtype;
b34976b6 1125 bfd_vma offset;
91d6fa6a 1126 bfd_vma inf;
b34976b6
AM		 1127 bfd_vma symtab_index;
1128 bfd_vma type;
103f02d3 1129
b34976b6 1130 offset = rels[i].r_offset;
91d6fa6a 1131 inf = rels[i].r_info;
103f02d3 1132
91d6fa6a
NC		 1133 type = get_reloc_type (inf);
1134 symtab_index = get_reloc_symindex (inf);
252b5132 1135
410f7a12
L		 1136 if (is_32bit_elf)
1137 {
39dbeff8
AM		 1138 printf ("%8.8lx %8.8lx ",
1139 (unsigned long) offset & 0xffffffff,
91d6fa6a 1140 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1141 }
1142 else
1143 {
39dbeff8
AM		 1144#if BFD_HOST_64BIT_LONG
1145 printf (do_wide
1146 ? "%16.16lx %16.16lx "
1147 : "%12.12lx %12.12lx ",
91d6fa6a 1148 offset, inf);
39dbeff8 1149#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1150#ifndef __MSVCRT__
39dbeff8
AM		 1151 printf (do_wide
1152 ? "%16.16llx %16.16llx "
1153 : "%12.12llx %12.12llx ",
91d6fa6a 1154 offset, inf);
6e3d6dc1
NC		 1155#else
1156 printf (do_wide
1157 ? "%16.16I64x %16.16I64x "
1158 : "%12.12I64x %12.12I64x ",
91d6fa6a 1159 offset, inf);
6e3d6dc1 1160#endif
39dbeff8 1161#else
2c71103e
NC		 1162 printf (do_wide
1163 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1164 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1165 _bfd_int64_high (offset),
1166 _bfd_int64_low (offset),
91d6fa6a
NC		 1167 _bfd_int64_high (inf),
1168 _bfd_int64_low (inf));
9ea033b2 1169#endif
410f7a12 1170 }
103f02d3 1171
252b5132
RH		 1172 switch (elf_header.e_machine)
1173 {
1174 default:
1175 rtype = NULL;
1176 break;
1177
a06ea964
NC		 1178 case EM_AARCH64:
1179 rtype = elf_aarch64_reloc_type (type);
1180 break;
1181
2b0337b0 1182 case EM_M32R:
252b5132 1183 case EM_CYGNUS_M32R:
9ea033b2 1184 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1185 break;
1186
1187 case EM_386:
22abe556 1188 case EM_IAMCU:
9ea033b2 1189 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1190 break;
1191
ba2685cc
AM		 1192 case EM_68HC11:
1193 case EM_68HC12:
1194 rtype = elf_m68hc11_reloc_type (type);
1195 break;
75751cd9 1196
252b5132 1197 case EM_68K:
9ea033b2 1198 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1199 break;
1200
63fcb9e9 1201 case EM_960:
9ea033b2 1202 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1203 break;
1204
adde6300 1205 case EM_AVR:
2b0337b0 1206 case EM_AVR_OLD:
adde6300
AM		 1207 rtype = elf_avr_reloc_type (type);
1208 break;
1209
9ea033b2
NC		 1210 case EM_OLD_SPARCV9:
1211 case EM_SPARC32PLUS:
1212 case EM_SPARCV9:
252b5132 1213 case EM_SPARC:
9ea033b2 1214 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1215 break;
1216
e9f53129
AM		 1217 case EM_SPU:
1218 rtype = elf_spu_reloc_type (type);
1219 break;
1220
708e2187
NC		 1221 case EM_V800:
1222 rtype = v800_reloc_type (type);
1223 break;
2b0337b0 1224 case EM_V850:
252b5132 1225 case EM_CYGNUS_V850:
9ea033b2 1226 rtype = v850_reloc_type (type);
252b5132
RH		 1227 break;
1228
2b0337b0 1229 case EM_D10V:
252b5132 1230 case EM_CYGNUS_D10V:
9ea033b2 1231 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1232 break;
1233
2b0337b0 1234 case EM_D30V:
252b5132 1235 case EM_CYGNUS_D30V:
9ea033b2 1236 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1237 break;
1238
d172d4ba
NC		 1239 case EM_DLX:
1240 rtype = elf_dlx_reloc_type (type);
1241 break;
1242
252b5132 1243 case EM_SH:
9ea033b2 1244 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1245 break;
1246
2b0337b0 1247 case EM_MN10300:
252b5132 1248 case EM_CYGNUS_MN10300:
9ea033b2 1249 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1250 break;
1251
2b0337b0 1252 case EM_MN10200:
252b5132 1253 case EM_CYGNUS_MN10200:
9ea033b2 1254 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1255 break;
1256
2b0337b0 1257 case EM_FR30:
252b5132 1258 case EM_CYGNUS_FR30:
9ea033b2 1259 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1260 break;
1261
ba2685cc
AM		 1262 case EM_CYGNUS_FRV:
1263 rtype = elf_frv_reloc_type (type);
1264 break;
5c70f934 1265
3f8107ab
AM		 1266 case EM_FT32:
1267 rtype = elf_ft32_reloc_type (type);
1268 break;
1269
252b5132 1270 case EM_MCORE:
9ea033b2 1271 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1272 break;
1273
3c3bdf30
NC		 1274 case EM_MMIX:
1275 rtype = elf_mmix_reloc_type (type);
1276 break;
1277
5506d11a
AM		 1278 case EM_MOXIE:
1279 rtype = elf_moxie_reloc_type (type);
1280 break;
1281
2469cfa2 1282 case EM_MSP430:
13761a11
NC		 1283 if (uses_msp430x_relocs ())
1284 {
1285 rtype = elf_msp430x_reloc_type (type);
1286 break;
1287 }
2469cfa2
NC		 1288 case EM_MSP430_OLD:
1289 rtype = elf_msp430_reloc_type (type);
1290 break;
1291
35c08157
KLC		 1292 case EM_NDS32:
1293 rtype = elf_nds32_reloc_type (type);
1294 break;
1295
252b5132 1296 case EM_PPC:
9ea033b2 1297 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1298 break;
1299
c833c019
AM		 1300 case EM_PPC64:
1301 rtype = elf_ppc64_reloc_type (type);
1302 break;
1303
252b5132 1304 case EM_MIPS:
4fe85591 1305 case EM_MIPS_RS3_LE:
9ea033b2 1306 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1307 break;
1308
1309 case EM_ALPHA:
9ea033b2 1310 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1311 break;
1312
1313 case EM_ARM:
9ea033b2 1314 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1315 break;
1316
584da044 1317 case EM_ARC:
9ea033b2 1318 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1319 break;
1320
1321 case EM_PARISC:
69e617ca 1322 rtype = elf_hppa_reloc_type (type);
252b5132 1323 break;
7d466069 1324
b8720f9d
JL		 1325 case EM_H8_300:
1326 case EM_H8_300H:
1327 case EM_H8S:
1328 rtype = elf_h8_reloc_type (type);
1329 break;
1330
73589c9d
CS		 1331 case EM_OR1K:
1332 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1333 break;
1334
7d466069 1335 case EM_PJ:
2b0337b0 1336 case EM_PJ_OLD:
7d466069
ILT		 1337 rtype = elf_pj_reloc_type (type);
1338 break;
800eeca4
JW		 1339 case EM_IA_64:
1340 rtype = elf_ia64_reloc_type (type);
1341 break;
1b61cf92
HPN		 1342
1343 case EM_CRIS:
1344 rtype = elf_cris_reloc_type (type);
1345 break;
535c37ff
JE		 1346
1347 case EM_860:
1348 rtype = elf_i860_reloc_type (type);
1349 break;
bcedfee6
NC		 1350
1351 case EM_X86_64:
8a9036a4 1352 case EM_L1OM:
7a9068fe 1353 case EM_K1OM:
bcedfee6
NC		 1354 rtype = elf_x86_64_reloc_type (type);
1355 break;
a85d7ed0 1356
35b1837e
AM		 1357 case EM_S370:
1358 rtype = i370_reloc_type (type);
1359 break;
1360
53c7db4b
KH		 1361 case EM_S390_OLD:
1362 case EM_S390:
1363 rtype = elf_s390_reloc_type (type);
1364 break;
93fbbb04 1365
1c0d3aa6
NC		 1366 case EM_SCORE:
1367 rtype = elf_score_reloc_type (type);
1368 break;
1369
93fbbb04
GK		 1370 case EM_XSTORMY16:
1371 rtype = elf_xstormy16_reloc_type (type);
1372 break;
179d3252 1373
1fe1f39c
NC		 1374 case EM_CRX:
1375 rtype = elf_crx_reloc_type (type);
1376 break;
1377
179d3252
JT		 1378 case EM_VAX:
1379 rtype = elf_vax_reloc_type (type);
1380 break;
1e4cf259 1381
619ed720
EB		 1382 case EM_VISIUM:
1383 rtype = elf_visium_reloc_type (type);
1384 break;
1385
cfb8c092
NC		 1386 case EM_ADAPTEVA_EPIPHANY:
1387 rtype = elf_epiphany_reloc_type (type);
1388 break;
1389
1e4cf259
NC		 1390 case EM_IP2K:
1391 case EM_IP2K_OLD:
1392 rtype = elf_ip2k_reloc_type (type);
1393 break;
3b36097d
SC		 1394
1395 case EM_IQ2000:
1396 rtype = elf_iq2000_reloc_type (type);
1397 break;
88da6820
NC		 1398
1399 case EM_XTENSA_OLD:
1400 case EM_XTENSA:
1401 rtype = elf_xtensa_reloc_type (type);
1402 break;
a34e3ecb 1403
84e94c90
NC		 1404 case EM_LATTICEMICO32:
1405 rtype = elf_lm32_reloc_type (type);
1406 break;
1407
ff7eeb89 1408 case EM_M32C_OLD:
49f58d10
JB		 1409 case EM_M32C:
1410 rtype = elf_m32c_reloc_type (type);
1411 break;
1412
d031aafb
NS		 1413 case EM_MT:
1414 rtype = elf_mt_reloc_type (type);
a34e3ecb 1415 break;
1d65ded4
CM		 1416
1417 case EM_BLACKFIN:
1418 rtype = elf_bfin_reloc_type (type);
1419 break;
15ab5209
DB		 1420
1421 case EM_CYGNUS_MEP:
1422 rtype = elf_mep_reloc_type (type);
1423 break;
60bca95a
NC		 1424
1425 case EM_CR16:
1426 rtype = elf_cr16_reloc_type (type);
1427 break;
dd24e3da 1428
7ba29e2a
NC		 1429 case EM_MICROBLAZE:
1430 case EM_MICROBLAZE_OLD:
1431 rtype = elf_microblaze_reloc_type (type);
1432 break;
c7927a3c 1433
99c513f6
DD		 1434 case EM_RL78:
1435 rtype = elf_rl78_reloc_type (type);
1436 break;
1437
c7927a3c
NC		 1438 case EM_RX:
1439 rtype = elf_rx_reloc_type (type);
1440 break;
c29aca4a 1441
a3c62988
NC		 1442 case EM_METAG:
1443 rtype = elf_metag_reloc_type (type);
1444 break;
1445
c29aca4a
NC		 1446 case EM_XC16X:
1447 case EM_C166:
1448 rtype = elf_xc16x_reloc_type (type);
1449 break;
40b36596
JM		 1450
1451 case EM_TI_C6000:
1452 rtype = elf_tic6x_reloc_type (type);
1453 break;
aa137e4d
NC		 1454
1455 case EM_TILEGX:
1456 rtype = elf_tilegx_reloc_type (type);
1457 break;
1458
1459 case EM_TILEPRO:
1460 rtype = elf_tilepro_reloc_type (type);
1461 break;
f6c1a2d5
NC		 1462
1463 case EM_XGATE:
1464 rtype = elf_xgate_reloc_type (type);
1465 break;
36591ba1
SL		 1466
1467 case EM_ALTERA_NIOS2:
1468 rtype = elf_nios2_reloc_type (type);
1469 break;
252b5132
RH		 1470 }
1471
1472 if (rtype == NULL)
39dbeff8 1473 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1474 else
8beeaeb7 1475 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1476
7ace3541 1477 if (elf_header.e_machine == EM_ALPHA
157c2599 1478 && rtype != NULL
7ace3541
RH		 1479 && streq (rtype, "R_ALPHA_LITUSE")
1480 && is_rela)
1481 {
1482 switch (rels[i].r_addend)
1483 {
1484 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1485 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1486 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1487 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1488 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1489 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1490 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1491 default: rtype = NULL;
1492 }
1493 if (rtype)
1494 printf (" (%s)", rtype);
1495 else
1496 {
1497 putchar (' ');
1498 printf (_("<unknown addend: %lx>"),
1499 (unsigned long) rels[i].r_addend);
1500 }
1501 }
1502 else if (symtab_index)
252b5132 1503 {
af3fc3bc 1504 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1505 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1506 else
19936277 1507 {
2cf0635d 1508 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1509 const char * version_string;
1510 enum versioned_symbol_info sym_info;
1511 unsigned short vna_other;
19936277 1512
af3fc3bc 1513 psym = symtab + symtab_index;
103f02d3 1514
bb4d2ac2
L		 1515 version_string
1516 = get_symbol_version_string (file, is_dynsym,
1517 strtab, strtablen,
1518 symtab_index,
1519 psym,
1520 &sym_info,
1521 &vna_other);
1522
af3fc3bc 1523 printf (" ");
171191ba 1524
d8045f23
NC		 1525 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1526 {
1527 const char * name;
1528 unsigned int len;
1529 unsigned int width = is_32bit_elf ? 8 : 14;
1530
1531 /* Relocations against GNU_IFUNC symbols do not use the value
1532 of the symbol as the address to relocate against. Instead
1533 they invoke the function named by the symbol and use its
1534 result as the address for relocation.
1535
1536 To indicate this to the user, do not display the value of
1537 the symbol in the "Symbols's Value" field. Instead show
1538 its name followed by () as a hint that the symbol is
1539 invoked. */
1540
1541 if (strtab == NULL
1542 || psym->st_name == 0
1543 || psym->st_name >= strtablen)
1544 name = "??";
1545 else
1546 name = strtab + psym->st_name;
1547
1548 len = print_symbol (width, name);
bb4d2ac2
L		 1549 if (version_string)
1550 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1551 version_string);
d8045f23
NC		 1552 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1553 }
1554 else
1555 {
1556 print_vma (psym->st_value, LONG_HEX);
171191ba 1557
d8045f23
NC		 1558 printf (is_32bit_elf ? " " : " ");
1559 }
103f02d3 1560
af3fc3bc 1561 if (psym->st_name == 0)
f1ef08cb 1562 {
2cf0635d 1563 const char * sec_name = "<null>";
f1ef08cb
AM		 1564 char name_buf[40];
1565
1566 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1567 {
4fbb74a6 1568 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1569 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1570 else if (psym->st_shndx == SHN_ABS)
1571 sec_name = "ABS";
1572 else if (psym->st_shndx == SHN_COMMON)
1573 sec_name = "COMMON";
ac145307
BS		 1574 else if ((elf_header.e_machine == EM_MIPS
1575 && psym->st_shndx == SHN_MIPS_SCOMMON)
1576 || (elf_header.e_machine == EM_TI_C6000
1577 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1578 sec_name = "SCOMMON";
1579 else if (elf_header.e_machine == EM_MIPS
1580 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1581 sec_name = "SUNDEF";
8a9036a4 1582 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1583 || elf_header.e_machine == EM_L1OM
1584 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1585 && psym->st_shndx == SHN_X86_64_LCOMMON)
1586 sec_name = "LARGE_COMMON";
9ce701e2
L		 1587 else if (elf_header.e_machine == EM_IA_64
1588 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1589 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1590 sec_name = "ANSI_COM";
28f997cf 1591 else if (is_ia64_vms ()
148b93f2
NC		 1592 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1593 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1594 else
1595 {
1596 sprintf (name_buf, "<section 0x%x>",
1597 (unsigned int) psym->st_shndx);
1598 sec_name = name_buf;
1599 }
1600 }
1601 print_symbol (22, sec_name);
1602 }
af3fc3bc 1603 else if (strtab == NULL)
d79b3d50 1604 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1605 else if (psym->st_name >= strtablen)
d79b3d50 1606 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1607 else
bb4d2ac2
L		 1608 {
1609 print_symbol (22, strtab + psym->st_name);
1610 if (version_string)
1611 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1612 version_string);
1613 }
103f02d3 1614
af3fc3bc 1615 if (is_rela)
171191ba 1616 {
7360e63f 1617 bfd_vma off = rels[i].r_addend;
171191ba 1618
7360e63f 1619 if ((bfd_signed_vma) off < 0)
598aaa76 1620 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1621 else
598aaa76 1622 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1623 }
19936277 1624 }
252b5132 1625 }
1b228002 1626 else if (is_rela)
f7a99963 1627 {
7360e63f 1628 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1629
1630 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1631 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1632 printf ("-%" BFD_VMA_FMT "x", - off);
1633 else
1634 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1635 }
252b5132 1636
157c2599
NC		 1637 if (elf_header.e_machine == EM_SPARCV9
1638 && rtype != NULL
1639 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1640 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1641
252b5132 1642 putchar ('\n');
2c71103e 1643
aca88567 1644#ifdef BFD64
53c7db4b 1645 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1646 {
91d6fa6a
NC		 1647 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1648 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1649 const char * rtype2 = elf_mips_reloc_type (type2);
1650 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1651
2c71103e
NC		 1652 printf (" Type2: ");
1653
1654 if (rtype2 == NULL)
39dbeff8
AM		 1655 printf (_("unrecognized: %-7lx"),
1656 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1657 else
1658 printf ("%-17.17s", rtype2);
1659
18bd398b 1660 printf ("\n Type3: ");
2c71103e
NC		 1661
1662 if (rtype3 == NULL)
39dbeff8
AM		 1663 printf (_("unrecognized: %-7lx"),
1664 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1665 else
1666 printf ("%-17.17s", rtype3);
1667
53c7db4b 1668 putchar ('\n');
2c71103e 1669 }
aca88567 1670#endif /* BFD64 */
252b5132
RH		 1671 }
1672
c8286bd1 1673 free (rels);
252b5132
RH		 1674}
1675
1676static const char *
d3ba0551 1677get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1678{
1679 switch (type)
1680 {
1681 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1682 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1683 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1684 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1685 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1686 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1687 case DT_MIPS_MSYM: return "MIPS_MSYM";
1688 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1689 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1690 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1691 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1692 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1693 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1694 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1695 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1696 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1697 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1698 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1699 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1700 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1701 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1702 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1703 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1704 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1705 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1706 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1707 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1708 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1709 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1710 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1711 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1712 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1713 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1714 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1715 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1716 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1717 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1718 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1719 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1720 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1722 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1723 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1724 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1725 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1726 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1727 default:
1728 return NULL;
1729 }
1730}
1731
9a097730 1732static const char *
d3ba0551 1733get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1734{
1735 switch (type)
1736 {
1737 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1738 default:
1739 return NULL;
1740 }
103f02d3
UD		 1741}
1742
7490d522
AM		 1743static const char *
1744get_ppc_dynamic_type (unsigned long type)
1745{
1746 switch (type)
1747 {
a7f2871e 1748 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1749 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1750 default:
1751 return NULL;
1752 }
1753}
1754
f1cb7e17 1755static const char *
d3ba0551 1756get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1757{
1758 switch (type)
1759 {
a7f2871e
AM		 1760 case DT_PPC64_GLINK: return "PPC64_GLINK";
1761 case DT_PPC64_OPD: return "PPC64_OPD";
1762 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1763 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1764 default:
1765 return NULL;
1766 }
1767}
1768
103f02d3 1769static const char *
d3ba0551 1770get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1771{
1772 switch (type)
1773 {
1774 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1775 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1776 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1777 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1778 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1779 case DT_HP_PREINIT: return "HP_PREINIT";
1780 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1781 case DT_HP_NEEDED: return "HP_NEEDED";
1782 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1783 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1784 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1785 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1786 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1787 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1788 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1789 case DT_HP_FILTERED: return "HP_FILTERED";
1790 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1791 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1792 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1793 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1794 case DT_PLT: return "PLT";
1795 case DT_PLT_SIZE: return "PLT_SIZE";
1796 case DT_DLT: return "DLT";
1797 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1798 default:
1799 return NULL;
1800 }
1801}
9a097730 1802
ecc51f48 1803static const char *
d3ba0551 1804get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1805{
1806 switch (type)
1807 {
148b93f2
NC		 1808 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1809 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1810 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1811 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1812 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1813 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1814 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1815 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1816 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1818 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1819 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1820 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1821 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1822 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1823 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1824 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1825 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1826 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1827 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1828 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1829 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1830 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1831 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1832 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1833 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1834 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1835 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1836 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1837 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1838 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1839 default:
1840 return NULL;
1841 }
1842}
1843
fabcb361
RH		 1844static const char *
1845get_alpha_dynamic_type (unsigned long type)
1846{
1847 switch (type)
1848 {
1849 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1850 default:
1851 return NULL;
1852 }
1853}
1854
1c0d3aa6
NC		 1855static const char *
1856get_score_dynamic_type (unsigned long type)
1857{
1858 switch (type)
1859 {
1860 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1861 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1862 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1863 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1864 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1865 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1866 default:
1867 return NULL;
1868 }
1869}
1870
40b36596
JM		 1871static const char *
1872get_tic6x_dynamic_type (unsigned long type)
1873{
1874 switch (type)
1875 {
1876 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1877 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1878 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1879 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1880 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1881 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1882 default:
1883 return NULL;
1884 }
1885}
1c0d3aa6 1886
36591ba1
SL		 1887static const char *
1888get_nios2_dynamic_type (unsigned long type)
1889{
1890 switch (type)
1891 {
1892 case DT_NIOS2_GP: return "NIOS2_GP";
1893 default:
1894 return NULL;
1895 }
1896}
1897
252b5132 1898static const char *
d3ba0551 1899get_dynamic_type (unsigned long type)
252b5132 1900{
e9e44622 1901 static char buff[64];
252b5132
RH		 1902
1903 switch (type)
1904 {
1905 case DT_NULL: return "NULL";
1906 case DT_NEEDED: return "NEEDED";
1907 case DT_PLTRELSZ: return "PLTRELSZ";
1908 case DT_PLTGOT: return "PLTGOT";
1909 case DT_HASH: return "HASH";
1910 case DT_STRTAB: return "STRTAB";
1911 case DT_SYMTAB: return "SYMTAB";
1912 case DT_RELA: return "RELA";
1913 case DT_RELASZ: return "RELASZ";
1914 case DT_RELAENT: return "RELAENT";
1915 case DT_STRSZ: return "STRSZ";
1916 case DT_SYMENT: return "SYMENT";
1917 case DT_INIT: return "INIT";
1918 case DT_FINI: return "FINI";
1919 case DT_SONAME: return "SONAME";
1920 case DT_RPATH: return "RPATH";
1921 case DT_SYMBOLIC: return "SYMBOLIC";
1922 case DT_REL: return "REL";
1923 case DT_RELSZ: return "RELSZ";
1924 case DT_RELENT: return "RELENT";
1925 case DT_PLTREL: return "PLTREL";
1926 case DT_DEBUG: return "DEBUG";
1927 case DT_TEXTREL: return "TEXTREL";
1928 case DT_JMPREL: return "JMPREL";
1929 case DT_BIND_NOW: return "BIND_NOW";
1930 case DT_INIT_ARRAY: return "INIT_ARRAY";
1931 case DT_FINI_ARRAY: return "FINI_ARRAY";
1932 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1933 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1934 case DT_RUNPATH: return "RUNPATH";
1935 case DT_FLAGS: return "FLAGS";
2d0e6f43 1936
d1133906
NC		 1937 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1938 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1939
05107a46 1940 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1941 case DT_PLTPADSZ: return "PLTPADSZ";
1942 case DT_MOVEENT: return "MOVEENT";
1943 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1944 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1945 case DT_POSFLAG_1: return "POSFLAG_1";
1946 case DT_SYMINSZ: return "SYMINSZ";
1947 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1948
252b5132 1949 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1950 case DT_CONFIG: return "CONFIG";
1951 case DT_DEPAUDIT: return "DEPAUDIT";
1952 case DT_AUDIT: return "AUDIT";
1953 case DT_PLTPAD: return "PLTPAD";
1954 case DT_MOVETAB: return "MOVETAB";
252b5132 1955 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1956
252b5132 1957 case DT_VERSYM: return "VERSYM";
103f02d3 1958
67a4f2b7
AO		 1959 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1960 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1961 case DT_RELACOUNT: return "RELACOUNT";
1962 case DT_RELCOUNT: return "RELCOUNT";
1963 case DT_FLAGS_1: return "FLAGS_1";
1964 case DT_VERDEF: return "VERDEF";
1965 case DT_VERDEFNUM: return "VERDEFNUM";
1966 case DT_VERNEED: return "VERNEED";
1967 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1968
019148e4 1969 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1970 case DT_USED: return "USED";
1971 case DT_FILTER: return "FILTER";
103f02d3 1972
047b2264
JJ		 1973 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1974 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1975 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1976 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1977 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1978 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1979
252b5132
RH		 1980 default:
1981 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1982 {
2cf0635d 1983 const char * result;
103f02d3 1984
252b5132
RH		 1985 switch (elf_header.e_machine)
1986 {
1987 case EM_MIPS:
4fe85591 1988 case EM_MIPS_RS3_LE:
252b5132
RH		 1989 result = get_mips_dynamic_type (type);
1990 break;
9a097730
RH		 1991 case EM_SPARCV9:
1992 result = get_sparc64_dynamic_type (type);
1993 break;
7490d522
AM		 1994 case EM_PPC:
1995 result = get_ppc_dynamic_type (type);
1996 break;
f1cb7e17
AM		 1997 case EM_PPC64:
1998 result = get_ppc64_dynamic_type (type);
1999 break;
ecc51f48
NC		 2000 case EM_IA_64:
2001 result = get_ia64_dynamic_type (type);
2002 break;
fabcb361
RH		 2003 case EM_ALPHA:
2004 result = get_alpha_dynamic_type (type);
2005 break;
1c0d3aa6
NC		 2006 case EM_SCORE:
2007 result = get_score_dynamic_type (type);
2008 break;
40b36596
JM		 2009 case EM_TI_C6000:
2010 result = get_tic6x_dynamic_type (type);
2011 break;
36591ba1
SL		 2012 case EM_ALTERA_NIOS2:
2013 result = get_nios2_dynamic_type (type);
2014 break;
252b5132
RH		 2015 default:
2016 result = NULL;
2017 break;
2018 }
2019
2020 if (result != NULL)
2021 return result;
2022
e9e44622 2023 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2024 }
eec8f817
DA		 2025 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2026 || (elf_header.e_machine == EM_PARISC
2027 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2028 {
2cf0635d 2029 const char * result;
103f02d3
UD		 2030
2031 switch (elf_header.e_machine)
2032 {
2033 case EM_PARISC:
2034 result = get_parisc_dynamic_type (type);
2035 break;
148b93f2
NC		 2036 case EM_IA_64:
2037 result = get_ia64_dynamic_type (type);
2038 break;
103f02d3
UD		 2039 default:
2040 result = NULL;
2041 break;
2042 }
2043
2044 if (result != NULL)
2045 return result;
2046
e9e44622
JJ		 2047 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2048 type);
103f02d3 2049 }
252b5132 2050 else
e9e44622 2051 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2052
252b5132
RH		 2053 return buff;
2054 }
2055}
2056
2057static char *
d3ba0551 2058get_file_type (unsigned e_type)
252b5132 2059{
b34976b6 2060 static char buff[32];
252b5132
RH		 2061
2062 switch (e_type)
2063 {
2064 case ET_NONE: return _("NONE (None)");
2065 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2066 case ET_EXEC: return _("EXEC (Executable file)");
2067 case ET_DYN: return _("DYN (Shared object file)");
2068 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2069
2070 default:
2071 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2072 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2073 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2074 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2075 else
e9e44622 2076 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2077 return buff;
2078 }
2079}
2080
2081static char *
d3ba0551 2082get_machine_name (unsigned e_machine)
252b5132 2083{
b34976b6 2084 static char buff[64]; /* XXX */
252b5132
RH		 2085
2086 switch (e_machine)
2087 {
c45021f2 2088 case EM_NONE: return _("None");
a06ea964 2089 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2090 case EM_M32: return "WE32100";
2091 case EM_SPARC: return "Sparc";
e9f53129 2092 case EM_SPU: return "SPU";
c45021f2
NC		 2093 case EM_386: return "Intel 80386";
2094 case EM_68K: return "MC68000";
2095 case EM_88K: return "MC88000";
22abe556 2096 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2097 case EM_860: return "Intel 80860";
2098 case EM_MIPS: return "MIPS R3000";
2099 case EM_S370: return "IBM System/370";
7036c0e1 2100 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2101 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2102 case EM_PARISC: return "HPPA";
252b5132 2103 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2104 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2105 case EM_960: return "Intel 90860";
2106 case EM_PPC: return "PowerPC";
285d1771 2107 case EM_PPC64: return "PowerPC64";
c45021f2 2108 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2109 case EM_FT32: return "FTDI FT32";
c45021f2 2110 case EM_RH32: return "TRW RH32";
b34976b6 2111 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2112 case EM_ARM: return "ARM";
2113 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2114 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2115 case EM_SPARCV9: return "Sparc v9";
2116 case EM_TRICORE: return "Siemens Tricore";
584da044 2117 case EM_ARC: return "ARC";
c2dcd04e
NC		 2118 case EM_H8_300: return "Renesas H8/300";
2119 case EM_H8_300H: return "Renesas H8/300H";
2120 case EM_H8S: return "Renesas H8S";
2121 case EM_H8_500: return "Renesas H8/500";
30800947 2122 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2123 case EM_MIPS_X: return "Stanford MIPS-X";
2124 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2125 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2126 case EM_CYGNUS_D10V:
2127 case EM_D10V: return "d10v";
2128 case EM_CYGNUS_D30V:
b34976b6 2129 case EM_D30V: return "d30v";
2b0337b0 2130 case EM_CYGNUS_M32R:
26597c86 2131 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2132 case EM_CYGNUS_V850:
708e2187 2133 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2134 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2135 case EM_CYGNUS_MN10300:
2136 case EM_MN10300: return "mn10300";
2137 case EM_CYGNUS_MN10200:
2138 case EM_MN10200: return "mn10200";
5506d11a 2139 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2140 case EM_CYGNUS_FR30:
2141 case EM_FR30: return "Fujitsu FR30";
b34976b6 2142 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2143 case EM_PJ_OLD:
b34976b6 2144 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2145 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2146 case EM_PCP: return "Siemens PCP";
2147 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2148 case EM_NDR1: return "Denso NDR1 microprocesspr";
2149 case EM_STARCORE: return "Motorola Star*Core processor";
2150 case EM_ME16: return "Toyota ME16 processor";
2151 case EM_ST100: return "STMicroelectronics ST100 processor";
2152 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2153 case EM_PDSP: return "Sony DSP processor";
2154 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2155 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2156 case EM_FX66: return "Siemens FX66 microcontroller";
2157 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2159 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2160 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2161 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2162 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2163 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2164 case EM_SVX: return "Silicon Graphics SVx";
2165 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2166 case EM_VAX: return "Digital VAX";
619ed720 2167 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2168 case EM_AVR_OLD:
b34976b6 2169 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2170 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2171 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2172 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2173 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2174 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2175 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2176 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2177 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2178 case EM_L1OM: return "Intel L1OM";
7a9068fe 2179 case EM_K1OM: return "Intel K1OM";
b7498e0e 2180 case EM_S390_OLD:
b34976b6 2181 case EM_S390: return "IBM S/390";
1c0d3aa6 2182 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2183 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2184 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2185 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2186 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2187 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2188 case EM_DLX: return "OpenDLX";
1e4cf259 2189 case EM_IP2K_OLD:
b34976b6 2190 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2191 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2192 case EM_XTENSA_OLD:
2193 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2194 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2195 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2196 case EM_NS32K: return "National Semiconductor 32000 series";
2197 case EM_TPC: return "Tenor Network TPC processor";
2198 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2199 case EM_MAX: return "MAX Processor";
2200 case EM_CR: return "National Semiconductor CompactRISC";
2201 case EM_F2MC16: return "Fujitsu F2MC16";
2202 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2203 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2204 case EM_M32C_OLD:
49f58d10 2205 case EM_M32C: return "Renesas M32c";
d031aafb 2206 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2207 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2208 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2209 case EM_SEP: return "Sharp embedded microprocessor";
2210 case EM_ARCA: return "Arca RISC microprocessor";
2211 case EM_UNICORE: return "Unicore";
2212 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2213 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2214 case EM_NIOS32: return "Altera Nios";
2215 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2216 case EM_C166:
d70c5fc7 2217 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2218 case EM_M16C: return "Renesas M16C series microprocessors";
2219 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2220 case EM_CE: return "Freescale Communication Engine RISC core";
2221 case EM_TSK3000: return "Altium TSK3000 core";
2222 case EM_RS08: return "Freescale RS08 embedded processor";
2223 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2224 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2225 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2226 case EM_SE_C17: return "Seiko Epson C17 family";
2227 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2228 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2229 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2230 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2232 case EM_R32C: return "Renesas R32C series microprocessors";
2233 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2234 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2235 case EM_8051: return "Intel 8051 and variants";
2236 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2237 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2238 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2239 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2241 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2242 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2243 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2244 case EM_CR16:
f6c1a2d5 2245 case EM_MICROBLAZE:
7ba29e2a 2246 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2247 case EM_RL78: return "Renesas RL78";
c7927a3c 2248 case EM_RX: return "Renesas RX";
a3c62988 2249 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2250 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2251 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2252 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2253 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2254 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2255 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2256 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2257 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2258 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2259 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2260 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2261 default:
35d9dd2f 2262 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2263 return buff;
2264 }
2265}
2266
f3485b74 2267static void
d3ba0551 2268decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2269{
2270 unsigned eabi;
2271 int unknown = 0;
2272
2273 eabi = EF_ARM_EABI_VERSION (e_flags);
2274 e_flags &= ~ EF_ARM_EABIMASK;
2275
2276 /* Handle "generic" ARM flags. */
2277 if (e_flags & EF_ARM_RELEXEC)
2278 {
2279 strcat (buf, ", relocatable executable");
2280 e_flags &= ~ EF_ARM_RELEXEC;
2281 }
76da6bbe 2282
f3485b74
NC		 2283 /* Now handle EABI specific flags. */
2284 switch (eabi)
2285 {
2286 default:
2c71103e 2287 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2288 if (e_flags)
2289 unknown = 1;
2290 break;
2291
2292 case EF_ARM_EABI_VER1:
a5bcd848 2293 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2294 while (e_flags)
2295 {
2296 unsigned flag;
76da6bbe 2297
f3485b74
NC		 2298 /* Process flags one bit at a time. */
2299 flag = e_flags & - e_flags;
2300 e_flags &= ~ flag;
76da6bbe 2301
f3485b74
NC		 2302 switch (flag)
2303 {
a5bcd848 2304 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2305 strcat (buf, ", sorted symbol tables");
2306 break;
76da6bbe 2307
f3485b74
NC		 2308 default:
2309 unknown = 1;
2310 break;
2311 }
2312 }
2313 break;
76da6bbe 2314
a5bcd848
PB		 2315 case EF_ARM_EABI_VER2:
2316 strcat (buf, ", Version2 EABI");
2317 while (e_flags)
2318 {
2319 unsigned flag;
2320
2321 /* Process flags one bit at a time. */
2322 flag = e_flags & - e_flags;
2323 e_flags &= ~ flag;
2324
2325 switch (flag)
2326 {
2327 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2328 strcat (buf, ", sorted symbol tables");
2329 break;
2330
2331 case EF_ARM_DYNSYMSUSESEGIDX:
2332 strcat (buf, ", dynamic symbols use segment index");
2333 break;
2334
2335 case EF_ARM_MAPSYMSFIRST:
2336 strcat (buf, ", mapping symbols precede others");
2337 break;
2338
2339 default:
2340 unknown = 1;
2341 break;
2342 }
2343 }
2344 break;
2345
d507cf36
PB		 2346 case EF_ARM_EABI_VER3:
2347 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2348 break;
2349
2350 case EF_ARM_EABI_VER4:
2351 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2352 while (e_flags)
2353 {
2354 unsigned flag;
2355
2356 /* Process flags one bit at a time. */
2357 flag = e_flags & - e_flags;
2358 e_flags &= ~ flag;
2359
2360 switch (flag)
2361 {
2362 case EF_ARM_BE8:
2363 strcat (buf, ", BE8");
2364 break;
2365
2366 case EF_ARM_LE8:
2367 strcat (buf, ", LE8");
2368 break;
2369
2370 default:
2371 unknown = 1;
2372 break;
2373 }
2374 break;
2375 }
2376 break;
3a4a14e9
PB		 2377
2378 case EF_ARM_EABI_VER5:
2379 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2380 while (e_flags)
2381 {
2382 unsigned flag;
2383
2384 /* Process flags one bit at a time. */
2385 flag = e_flags & - e_flags;
2386 e_flags &= ~ flag;
2387
2388 switch (flag)
2389 {
2390 case EF_ARM_BE8:
2391 strcat (buf, ", BE8");
2392 break;
2393
2394 case EF_ARM_LE8:
2395 strcat (buf, ", LE8");
2396 break;
2397
3bfcb652
NC		 2398 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2399 strcat (buf, ", soft-float ABI");
2400 break;
2401
2402 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2403 strcat (buf, ", hard-float ABI");
2404 break;
2405
d507cf36
PB		 2406 default:
2407 unknown = 1;
2408 break;
2409 }
2410 }
2411 break;
2412
f3485b74 2413 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2414 strcat (buf, ", GNU EABI");
f3485b74
NC		 2415 while (e_flags)
2416 {
2417 unsigned flag;
76da6bbe 2418
f3485b74
NC		 2419 /* Process flags one bit at a time. */
2420 flag = e_flags & - e_flags;
2421 e_flags &= ~ flag;
76da6bbe 2422
f3485b74
NC		 2423 switch (flag)
2424 {
a5bcd848 2425 case EF_ARM_INTERWORK:
f3485b74
NC		 2426 strcat (buf, ", interworking enabled");
2427 break;
76da6bbe 2428
a5bcd848 2429 case EF_ARM_APCS_26:
f3485b74
NC		 2430 strcat (buf, ", uses APCS/26");
2431 break;
76da6bbe 2432
a5bcd848 2433 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2434 strcat (buf, ", uses APCS/float");
2435 break;
76da6bbe 2436
a5bcd848 2437 case EF_ARM_PIC:
f3485b74
NC		 2438 strcat (buf, ", position independent");
2439 break;
76da6bbe 2440
a5bcd848 2441 case EF_ARM_ALIGN8:
f3485b74
NC		 2442 strcat (buf, ", 8 bit structure alignment");
2443 break;
76da6bbe 2444
a5bcd848 2445 case EF_ARM_NEW_ABI:
f3485b74
NC		 2446 strcat (buf, ", uses new ABI");
2447 break;
76da6bbe 2448
a5bcd848 2449 case EF_ARM_OLD_ABI:
f3485b74
NC		 2450 strcat (buf, ", uses old ABI");
2451 break;
76da6bbe 2452
a5bcd848 2453 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2454 strcat (buf, ", software FP");
2455 break;
76da6bbe 2456
90e01f86
ILT		 2457 case EF_ARM_VFP_FLOAT:
2458 strcat (buf, ", VFP");
2459 break;
2460
fde78edd
NC		 2461 case EF_ARM_MAVERICK_FLOAT:
2462 strcat (buf, ", Maverick FP");
2463 break;
2464
f3485b74
NC		 2465 default:
2466 unknown = 1;
2467 break;
2468 }
2469 }
2470 }
f3485b74
NC		 2471
2472 if (unknown)
2b692964 2473 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2474}
2475
343433df
AB		 2476static void
2477decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2478{
2479 --size; /* Leave space for null terminator. */
2480
2481 switch (e_flags & EF_AVR_MACH)
2482 {
2483 case E_AVR_MACH_AVR1:
2484 strncat (buf, ", avr:1", size);
2485 break;
2486 case E_AVR_MACH_AVR2:
2487 strncat (buf, ", avr:2", size);
2488 break;
2489 case E_AVR_MACH_AVR25:
2490 strncat (buf, ", avr:25", size);
2491 break;
2492 case E_AVR_MACH_AVR3:
2493 strncat (buf, ", avr:3", size);
2494 break;
2495 case E_AVR_MACH_AVR31:
2496 strncat (buf, ", avr:31", size);
2497 break;
2498 case E_AVR_MACH_AVR35:
2499 strncat (buf, ", avr:35", size);
2500 break;
2501 case E_AVR_MACH_AVR4:
2502 strncat (buf, ", avr:4", size);
2503 break;
2504 case E_AVR_MACH_AVR5:
2505 strncat (buf, ", avr:5", size);
2506 break;
2507 case E_AVR_MACH_AVR51:
2508 strncat (buf, ", avr:51", size);
2509 break;
2510 case E_AVR_MACH_AVR6:
2511 strncat (buf, ", avr:6", size);
2512 break;
2513 case E_AVR_MACH_AVRTINY:
2514 strncat (buf, ", avr:100", size);
2515 break;
2516 case E_AVR_MACH_XMEGA1:
2517 strncat (buf, ", avr:101", size);
2518 break;
2519 case E_AVR_MACH_XMEGA2:
2520 strncat (buf, ", avr:102", size);
2521 break;
2522 case E_AVR_MACH_XMEGA3:
2523 strncat (buf, ", avr:103", size);
2524 break;
2525 case E_AVR_MACH_XMEGA4:
2526 strncat (buf, ", avr:104", size);
2527 break;
2528 case E_AVR_MACH_XMEGA5:
2529 strncat (buf, ", avr:105", size);
2530 break;
2531 case E_AVR_MACH_XMEGA6:
2532 strncat (buf, ", avr:106", size);
2533 break;
2534 case E_AVR_MACH_XMEGA7:
2535 strncat (buf, ", avr:107", size);
2536 break;
2537 default:
2538 strncat (buf, ", avr:<unknown>", size);
2539 break;
2540 }
2541
2542 size -= strlen (buf);
2543 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2544 strncat (buf, ", link-relax", size);
2545}
2546
35c08157
KLC		 2547static void
2548decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2549{
2550 unsigned abi;
2551 unsigned arch;
2552 unsigned config;
2553 unsigned version;
2554 int has_fpu = 0;
2555 int r = 0;
2556
2557 static const char *ABI_STRINGS[] =
2558 {
2559 "ABI v0", /* use r5 as return register; only used in N1213HC */
2560 "ABI v1", /* use r0 as return register */
2561 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2562 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2563 "AABI",
2564 "ABI2 FP+"
35c08157
KLC		 2565 };
2566 static const char *VER_STRINGS[] =
2567 {
2568 "Andes ELF V1.3 or older",
2569 "Andes ELF V1.3.1",
2570 "Andes ELF V1.4"
2571 };
2572 static const char *ARCH_STRINGS[] =
2573 {
2574 "",
2575 "Andes Star v1.0",
2576 "Andes Star v2.0",
2577 "Andes Star v3.0",
2578 "Andes Star v3.0m"
2579 };
2580
2581 abi = EF_NDS_ABI & e_flags;
2582 arch = EF_NDS_ARCH & e_flags;
2583 config = EF_NDS_INST & e_flags;
2584 version = EF_NDS32_ELF_VERSION & e_flags;
2585
2586 memset (buf, 0, size);
2587
2588 switch (abi)
2589 {
2590 case E_NDS_ABI_V0:
2591 case E_NDS_ABI_V1:
2592 case E_NDS_ABI_V2:
2593 case E_NDS_ABI_V2FP:
2594 case E_NDS_ABI_AABI:
40c7a7cb 2595 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2596 /* In case there are holes in the array. */
2597 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2598 break;
2599
2600 default:
2601 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2602 break;
2603 }
2604
2605 switch (version)
2606 {
2607 case E_NDS32_ELF_VER_1_2:
2608 case E_NDS32_ELF_VER_1_3:
2609 case E_NDS32_ELF_VER_1_4:
2610 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2611 break;
2612
2613 default:
2614 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2615 break;
2616 }
2617
2618 if (E_NDS_ABI_V0 == abi)
2619 {
2620 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2621 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2622 if (arch == E_NDS_ARCH_STAR_V1_0)
2623 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2624 return;
2625 }
2626
2627 switch (arch)
2628 {
2629 case E_NDS_ARCH_STAR_V1_0:
2630 case E_NDS_ARCH_STAR_V2_0:
2631 case E_NDS_ARCH_STAR_V3_0:
2632 case E_NDS_ARCH_STAR_V3_M:
2633 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2634 break;
2635
2636 default:
2637 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2638 /* ARCH version determines how the e_flags are interpreted.
2639 If it is unknown, we cannot proceed. */
2640 return;
2641 }
2642
2643 /* Newer ABI; Now handle architecture specific flags. */
2644 if (arch == E_NDS_ARCH_STAR_V1_0)
2645 {
2646 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2647 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2648
2649 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2650 r += snprintf (buf + r, size -r, ", MAC");
2651
2652 if (config & E_NDS32_HAS_DIV_INST)
2653 r += snprintf (buf + r, size -r, ", DIV");
2654
2655 if (config & E_NDS32_HAS_16BIT_INST)
2656 r += snprintf (buf + r, size -r, ", 16b");
2657 }
2658 else
2659 {
2660 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2661 {
2662 if (version <= E_NDS32_ELF_VER_1_3)
2663 r += snprintf (buf + r, size -r, ", [B8]");
2664 else
2665 r += snprintf (buf + r, size -r, ", EX9");
2666 }
2667
2668 if (config & E_NDS32_HAS_MAC_DX_INST)
2669 r += snprintf (buf + r, size -r, ", MAC_DX");
2670
2671 if (config & E_NDS32_HAS_DIV_DX_INST)
2672 r += snprintf (buf + r, size -r, ", DIV_DX");
2673
2674 if (config & E_NDS32_HAS_16BIT_INST)
2675 {
2676 if (version <= E_NDS32_ELF_VER_1_3)
2677 r += snprintf (buf + r, size -r, ", 16b");
2678 else
2679 r += snprintf (buf + r, size -r, ", IFC");
2680 }
2681 }
2682
2683 if (config & E_NDS32_HAS_EXT_INST)
2684 r += snprintf (buf + r, size -r, ", PERF1");
2685
2686 if (config & E_NDS32_HAS_EXT2_INST)
2687 r += snprintf (buf + r, size -r, ", PERF2");
2688
2689 if (config & E_NDS32_HAS_FPU_INST)
2690 {
2691 has_fpu = 1;
2692 r += snprintf (buf + r, size -r, ", FPU_SP");
2693 }
2694
2695 if (config & E_NDS32_HAS_FPU_DP_INST)
2696 {
2697 has_fpu = 1;
2698 r += snprintf (buf + r, size -r, ", FPU_DP");
2699 }
2700
2701 if (config & E_NDS32_HAS_FPU_MAC_INST)
2702 {
2703 has_fpu = 1;
2704 r += snprintf (buf + r, size -r, ", FPU_MAC");
2705 }
2706
2707 if (has_fpu)
2708 {
2709 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2710 {
2711 case E_NDS32_FPU_REG_8SP_4DP:
2712 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2713 break;
2714 case E_NDS32_FPU_REG_16SP_8DP:
2715 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2716 break;
2717 case E_NDS32_FPU_REG_32SP_16DP:
2718 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2719 break;
2720 case E_NDS32_FPU_REG_32SP_32DP:
2721 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2722 break;
2723 }
2724 }
2725
2726 if (config & E_NDS32_HAS_AUDIO_INST)
2727 r += snprintf (buf + r, size -r, ", AUDIO");
2728
2729 if (config & E_NDS32_HAS_STRING_INST)
2730 r += snprintf (buf + r, size -r, ", STR");
2731
2732 if (config & E_NDS32_HAS_REDUCED_REGS)
2733 r += snprintf (buf + r, size -r, ", 16REG");
2734
2735 if (config & E_NDS32_HAS_VIDEO_INST)
2736 {
2737 if (version <= E_NDS32_ELF_VER_1_3)
2738 r += snprintf (buf + r, size -r, ", VIDEO");
2739 else
2740 r += snprintf (buf + r, size -r, ", SATURATION");
2741 }
2742
2743 if (config & E_NDS32_HAS_ENCRIPT_INST)
2744 r += snprintf (buf + r, size -r, ", ENCRP");
2745
2746 if (config & E_NDS32_HAS_L2C_INST)
2747 r += snprintf (buf + r, size -r, ", L2C");
2748}
2749
252b5132 2750static char *
d3ba0551 2751get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2752{
b34976b6 2753 static char buf[1024];
252b5132
RH		 2754
2755 buf[0] = '\0';
76da6bbe 2756
252b5132
RH		 2757 if (e_flags)
2758 {
2759 switch (e_machine)
2760 {
2761 default:
2762 break;
2763
f3485b74
NC		 2764 case EM_ARM:
2765 decode_ARM_machine_flags (e_flags, buf);
2766 break;
76da6bbe 2767
343433df
AB		 2768 case EM_AVR:
2769 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2770 break;
2771
781303ce
MF		 2772 case EM_BLACKFIN:
2773 if (e_flags & EF_BFIN_PIC)
2774 strcat (buf, ", PIC");
2775
2776 if (e_flags & EF_BFIN_FDPIC)
2777 strcat (buf, ", FDPIC");
2778
2779 if (e_flags & EF_BFIN_CODE_IN_L1)
2780 strcat (buf, ", code in L1");
2781
2782 if (e_flags & EF_BFIN_DATA_IN_L1)
2783 strcat (buf, ", data in L1");
2784
2785 break;
2786
ec2dfb42
AO		 2787 case EM_CYGNUS_FRV:
2788 switch (e_flags & EF_FRV_CPU_MASK)
2789 {
2790 case EF_FRV_CPU_GENERIC:
2791 break;
2792
2793 default:
2794 strcat (buf, ", fr???");
2795 break;
57346661 2796
ec2dfb42
AO		 2797 case EF_FRV_CPU_FR300:
2798 strcat (buf, ", fr300");
2799 break;
2800
2801 case EF_FRV_CPU_FR400:
2802 strcat (buf, ", fr400");
2803 break;
2804 case EF_FRV_CPU_FR405:
2805 strcat (buf, ", fr405");
2806 break;
2807
2808 case EF_FRV_CPU_FR450:
2809 strcat (buf, ", fr450");
2810 break;
2811
2812 case EF_FRV_CPU_FR500:
2813 strcat (buf, ", fr500");
2814 break;
2815 case EF_FRV_CPU_FR550:
2816 strcat (buf, ", fr550");
2817 break;
2818
2819 case EF_FRV_CPU_SIMPLE:
2820 strcat (buf, ", simple");
2821 break;
2822 case EF_FRV_CPU_TOMCAT:
2823 strcat (buf, ", tomcat");
2824 break;
2825 }
1c877e87 2826 break;
ec2dfb42 2827
53c7db4b 2828 case EM_68K:
425c6cb0 2829 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2830 strcat (buf, ", m68000");
425c6cb0 2831 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2832 strcat (buf, ", cpu32");
2833 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2834 strcat (buf, ", fido_a");
425c6cb0 2835 else
266abb8f 2836 {
2cf0635d
NC		 2837 char const * isa = _("unknown");
2838 char const * mac = _("unknown mac");
2839 char const * additional = NULL;
0112cd26 2840
c694fd50 2841 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2842 {
c694fd50 2843 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2844 isa = "A";
2845 additional = ", nodiv";
2846 break;
c694fd50 2847 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2848 isa = "A";
2849 break;
c694fd50 2850 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2851 isa = "A+";
2852 break;
c694fd50 2853 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2854 isa = "B";
2855 additional = ", nousp";
2856 break;
c694fd50 2857 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2858 isa = "B";
2859 break;
f608cd77
NS		 2860 case EF_M68K_CF_ISA_C:
2861 isa = "C";
2862 break;
2863 case EF_M68K_CF_ISA_C_NODIV:
2864 isa = "C";
2865 additional = ", nodiv";
2866 break;
266abb8f
NS		 2867 }
2868 strcat (buf, ", cf, isa ");
2869 strcat (buf, isa);
0b2e31dc
NS		 2870 if (additional)
2871 strcat (buf, additional);
c694fd50 2872 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2873 strcat (buf, ", float");
c694fd50 2874 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2875 {
2876 case 0:
2877 mac = NULL;
2878 break;
c694fd50 2879 case EF_M68K_CF_MAC:
266abb8f
NS		 2880 mac = "mac";
2881 break;
c694fd50 2882 case EF_M68K_CF_EMAC:
266abb8f
NS		 2883 mac = "emac";
2884 break;
f608cd77
NS		 2885 case EF_M68K_CF_EMAC_B:
2886 mac = "emac_b";
2887 break;
266abb8f
NS		 2888 }
2889 if (mac)
2890 {
2891 strcat (buf, ", ");
2892 strcat (buf, mac);
2893 }
266abb8f 2894 }
53c7db4b 2895 break;
33c63f9d 2896
153a2776
NC		 2897 case EM_CYGNUS_MEP:
2898 switch (e_flags & EF_MEP_CPU_MASK)
2899 {
2900 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2901 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2902 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2903 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2904 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2905 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2906 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2907 }
2908
2909 switch (e_flags & EF_MEP_COP_MASK)
2910 {
2911 case EF_MEP_COP_NONE: break;
2912 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2913 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2914 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2915 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2916 default: strcat (buf, _("<unknown MeP copro type>")); break;
2917 }
2918
2919 if (e_flags & EF_MEP_LIBRARY)
2920 strcat (buf, ", Built for Library");
2921
2922 if (e_flags & EF_MEP_INDEX_MASK)
2923 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2924 e_flags & EF_MEP_INDEX_MASK);
2925
2926 if (e_flags & ~ EF_MEP_ALL_FLAGS)
2927 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2928 e_flags & ~ EF_MEP_ALL_FLAGS);
2929 break;
2930
252b5132
RH		 2931 case EM_PPC:
2932 if (e_flags & EF_PPC_EMB)
2933 strcat (buf, ", emb");
2934
2935 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2936 strcat (buf, _(", relocatable"));
252b5132
RH		 2937
2938 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2939 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2940 break;
2941
ee67d69a
AM		 2942 case EM_PPC64:
2943 if (e_flags & EF_PPC64_ABI)
2944 {
2945 char abi[] = ", abiv0";
2946
2947 abi[6] += e_flags & EF_PPC64_ABI;
2948 strcat (buf, abi);
2949 }
2950 break;
2951
708e2187
NC		 2952 case EM_V800:
2953 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2954 strcat (buf, ", RH850 ABI");
0b4362b0 2955
708e2187
NC		 2956 if (e_flags & EF_V800_850E3)
2957 strcat (buf, ", V3 architecture");
2958
2959 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2960 strcat (buf, ", FPU not used");
2961
2962 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2963 strcat (buf, ", regmode: COMMON");
2964
2965 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2966 strcat (buf, ", r4 not used");
2967
2968 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2969 strcat (buf, ", r30 not used");
2970
2971 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2972 strcat (buf, ", r5 not used");
2973
2974 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2975 strcat (buf, ", r2 not used");
2976
2977 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2978 {
2979 switch (e_flags & - e_flags)
2980 {
2981 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2982 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2983 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2984 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2985 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2986 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2987 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2988 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2989 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2990 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2991 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2992 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2993 default: break;
2994 }
2995 }
2996 break;
2997
2b0337b0 2998 case EM_V850:
252b5132
RH		 2999 case EM_CYGNUS_V850:
3000 switch (e_flags & EF_V850_ARCH)
3001 {
78c8d46c
NC		 3002 case E_V850E3V5_ARCH:
3003 strcat (buf, ", v850e3v5");
3004 break;
1cd986c5
NC		 3005 case E_V850E2V3_ARCH:
3006 strcat (buf, ", v850e2v3");
3007 break;
3008 case E_V850E2_ARCH:
3009 strcat (buf, ", v850e2");
3010 break;
3011 case E_V850E1_ARCH:
3012 strcat (buf, ", v850e1");
8ad30312 3013 break;
252b5132
RH		 3014 case E_V850E_ARCH:
3015 strcat (buf, ", v850e");
3016 break;
252b5132
RH		 3017 case E_V850_ARCH:
3018 strcat (buf, ", v850");
3019 break;
3020 default:
2b692964 3021 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3022 break;
3023 }
3024 break;
3025
2b0337b0 3026 case EM_M32R:
252b5132
RH		 3027 case EM_CYGNUS_M32R:
3028 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3029 strcat (buf, ", m32r");
252b5132
RH		 3030 break;
3031
3032 case EM_MIPS:
4fe85591 3033 case EM_MIPS_RS3_LE:
252b5132
RH		 3034 if (e_flags & EF_MIPS_NOREORDER)
3035 strcat (buf, ", noreorder");
3036
3037 if (e_flags & EF_MIPS_PIC)
3038 strcat (buf, ", pic");
3039
3040 if (e_flags & EF_MIPS_CPIC)
3041 strcat (buf, ", cpic");
3042
d1bdd336
TS		 3043 if (e_flags & EF_MIPS_UCODE)
3044 strcat (buf, ", ugen_reserved");
3045
252b5132
RH		 3046 if (e_flags & EF_MIPS_ABI2)
3047 strcat (buf, ", abi2");
3048
43521d43
TS		 3049 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3050 strcat (buf, ", odk first");
3051
a5d22d2a
TS		 3052 if (e_flags & EF_MIPS_32BITMODE)
3053 strcat (buf, ", 32bitmode");
3054
ba92f887
MR		 3055 if (e_flags & EF_MIPS_NAN2008)
3056 strcat (buf, ", nan2008");
3057
fef1b0b3
SE		 3058 if (e_flags & EF_MIPS_FP64)
3059 strcat (buf, ", fp64");
3060
156c2f8b
NC		 3061 switch ((e_flags & EF_MIPS_MACH))
3062 {
3063 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3064 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3065 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3066 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3067 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3068 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3069 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3070 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3071 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3072 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3073 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3074 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3075 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3076 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3077 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3078 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3079 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3080 case 0:
3081 /* We simply ignore the field in this case to avoid confusion:
3082 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3083 extension. */
3084 break;
2b692964 3085 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3086 }
43521d43
TS		 3087
3088 switch ((e_flags & EF_MIPS_ABI))
3089 {
3090 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3091 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3092 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3093 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3094 case 0:
3095 /* We simply ignore the field in this case to avoid confusion:
3096 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3097 This means it is likely to be an o32 file, but not for
3098 sure. */
3099 break;
2b692964 3100 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3101 }
3102
3103 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3104 strcat (buf, ", mdmx");
3105
3106 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3107 strcat (buf, ", mips16");
3108
df58fc94
RS		 3109 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3110 strcat (buf, ", micromips");
3111
43521d43
TS		 3112 switch ((e_flags & EF_MIPS_ARCH))
3113 {
3114 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3115 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3116 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3117 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3118 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3119 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3120 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3121 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3122 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3123 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3124 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3125 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3126 }
252b5132 3127 break;
351b4b40 3128
35c08157
KLC		 3129 case EM_NDS32:
3130 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3131 break;
3132
ccde1100
AO		 3133 case EM_SH:
3134 switch ((e_flags & EF_SH_MACH_MASK))
3135 {
3136 case EF_SH1: strcat (buf, ", sh1"); break;
3137 case EF_SH2: strcat (buf, ", sh2"); break;
3138 case EF_SH3: strcat (buf, ", sh3"); break;
3139 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3140 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3141 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3142 case EF_SH3E: strcat (buf, ", sh3e"); break;
3143 case EF_SH4: strcat (buf, ", sh4"); break;
3144 case EF_SH5: strcat (buf, ", sh5"); break;
3145 case EF_SH2E: strcat (buf, ", sh2e"); break;
3146 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3147 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3148 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3149 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3150 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3151 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3152 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3153 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3154 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3155 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3156 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3157 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3158 }
3159
cec6a5b8
MR		 3160 if (e_flags & EF_SH_PIC)
3161 strcat (buf, ", pic");
3162
3163 if (e_flags & EF_SH_FDPIC)
3164 strcat (buf, ", fdpic");
ccde1100 3165 break;
948f632f 3166
73589c9d
CS		 3167 case EM_OR1K:
3168 if (e_flags & EF_OR1K_NODELAY)
3169 strcat (buf, ", no delay");
3170 break;
57346661 3171
351b4b40
RH		 3172 case EM_SPARCV9:
3173 if (e_flags & EF_SPARC_32PLUS)
3174 strcat (buf, ", v8+");
3175
3176 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3177 strcat (buf, ", ultrasparcI");
3178
3179 if (e_flags & EF_SPARC_SUN_US3)
3180 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3181
3182 if (e_flags & EF_SPARC_HAL_R1)
3183 strcat (buf, ", halr1");
3184
3185 if (e_flags & EF_SPARC_LEDATA)
3186 strcat (buf, ", ledata");
3187
3188 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3189 strcat (buf, ", tso");
3190
3191 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3192 strcat (buf, ", pso");
3193
3194 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3195 strcat (buf, ", rmo");
3196 break;
7d466069 3197
103f02d3
UD		 3198 case EM_PARISC:
3199 switch (e_flags & EF_PARISC_ARCH)
3200 {
3201 case EFA_PARISC_1_0:
3202 strcpy (buf, ", PA-RISC 1.0");
3203 break;
3204 case EFA_PARISC_1_1:
3205 strcpy (buf, ", PA-RISC 1.1");
3206 break;
3207 case EFA_PARISC_2_0:
3208 strcpy (buf, ", PA-RISC 2.0");
3209 break;
3210 default:
3211 break;
3212 }
3213 if (e_flags & EF_PARISC_TRAPNIL)
3214 strcat (buf, ", trapnil");
3215 if (e_flags & EF_PARISC_EXT)
3216 strcat (buf, ", ext");
3217 if (e_flags & EF_PARISC_LSB)
3218 strcat (buf, ", lsb");
3219 if (e_flags & EF_PARISC_WIDE)
3220 strcat (buf, ", wide");
3221 if (e_flags & EF_PARISC_NO_KABP)
3222 strcat (buf, ", no kabp");
3223 if (e_flags & EF_PARISC_LAZYSWAP)
3224 strcat (buf, ", lazyswap");
30800947 3225 break;
76da6bbe 3226
7d466069 3227 case EM_PJ:
2b0337b0 3228 case EM_PJ_OLD:
7d466069
ILT		 3229 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3230 strcat (buf, ", new calling convention");
3231
3232 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3233 strcat (buf, ", gnu calling convention");
3234 break;
4d6ed7c8
NC		 3235
3236 case EM_IA_64:
3237 if ((e_flags & EF_IA_64_ABI64))
3238 strcat (buf, ", 64-bit");
3239 else
3240 strcat (buf, ", 32-bit");
3241 if ((e_flags & EF_IA_64_REDUCEDFP))
3242 strcat (buf, ", reduced fp model");
3243 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3244 strcat (buf, ", no function descriptors, constant gp");
3245 else if ((e_flags & EF_IA_64_CONS_GP))
3246 strcat (buf, ", constant gp");
3247 if ((e_flags & EF_IA_64_ABSOLUTE))
3248 strcat (buf, ", absolute");
28f997cf
TG		 3249 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3250 {
3251 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3252 strcat (buf, ", vms_linkages");
3253 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3254 {
3255 case EF_IA_64_VMS_COMCOD_SUCCESS:
3256 break;
3257 case EF_IA_64_VMS_COMCOD_WARNING:
3258 strcat (buf, ", warning");
3259 break;
3260 case EF_IA_64_VMS_COMCOD_ERROR:
3261 strcat (buf, ", error");
3262 break;
3263 case EF_IA_64_VMS_COMCOD_ABORT:
3264 strcat (buf, ", abort");
3265 break;
3266 default:
bee0ee85
NC		 3267 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3268 e_flags & EF_IA_64_VMS_COMCOD);
3269 strcat (buf, ", <unknown>");
28f997cf
TG		 3270 }
3271 }
4d6ed7c8 3272 break;
179d3252
JT		 3273
3274 case EM_VAX:
3275 if ((e_flags & EF_VAX_NONPIC))
3276 strcat (buf, ", non-PIC");
3277 if ((e_flags & EF_VAX_DFLOAT))
3278 strcat (buf, ", D-Float");
3279 if ((e_flags & EF_VAX_GFLOAT))
3280 strcat (buf, ", G-Float");
3281 break;
c7927a3c 3282
619ed720
EB		 3283 case EM_VISIUM:
3284 if (e_flags & EF_VISIUM_ARCH_MCM)
3285 strcat (buf, ", mcm");
3286 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3287 strcat (buf, ", mcm24");
3288 if (e_flags & EF_VISIUM_ARCH_GR6)
3289 strcat (buf, ", gr6");
3290 break;
3291
4046d87a 3292 case EM_RL78:
1740ba0c
NC		 3293 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3294 {
3295 case E_FLAG_RL78_ANY_CPU: break;
3296 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3297 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3298 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3299 }
856ea05c
KP		 3300 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3301 strcat (buf, ", 64-bit doubles");
4046d87a 3302 break;
0b4362b0 3303
c7927a3c
NC		 3304 case EM_RX:
3305 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3306 strcat (buf, ", 64-bit doubles");
3307 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3308 strcat (buf, ", dsp");
d4cb0ea0 3309 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3310 strcat (buf, ", pid");
708e2187
NC		 3311 if (e_flags & E_FLAG_RX_ABI)
3312 strcat (buf, ", RX ABI");
3525236c
NC		 3313 if (e_flags & E_FLAG_RX_SINSNS_SET)
3314 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3315 ? ", uses String instructions" : ", bans String instructions");
d4cb0ea0 3316 break;
55786da2
AK		 3317
3318 case EM_S390:
3319 if (e_flags & EF_S390_HIGH_GPRS)
3320 strcat (buf, ", highgprs");
d4cb0ea0 3321 break;
40b36596
JM		 3322
3323 case EM_TI_C6000:
3324 if ((e_flags & EF_C6000_REL))
3325 strcat (buf, ", relocatable module");
d4cb0ea0 3326 break;
13761a11
NC		 3327
3328 case EM_MSP430:
3329 strcat (buf, _(": architecture variant: "));
3330 switch (e_flags & EF_MSP430_MACH)
3331 {
3332 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3333 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3334 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3335 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3336 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3337 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3338 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3339 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3340 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3341 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3342 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3343 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3344 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3345 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3346 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3347 default:
3348 strcat (buf, _(": unknown")); break;
3349 }
3350
3351 if (e_flags & ~ EF_MSP430_MACH)
3352 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3353 }
3354 }
3355
3356 return buf;
3357}
3358
252b5132 3359static const char *
d3ba0551
AM		 3360get_osabi_name (unsigned int osabi)
3361{
3362 static char buff[32];
3363
3364 switch (osabi)
3365 {
3366 case ELFOSABI_NONE: return "UNIX - System V";
3367 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3368 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3369 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3370 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3371 case ELFOSABI_AIX: return "UNIX - AIX";
3372 case ELFOSABI_IRIX: return "UNIX - IRIX";
3373 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3374 case ELFOSABI_TRU64: return "UNIX - TRU64";
3375 case ELFOSABI_MODESTO: return "Novell - Modesto";
3376 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3377 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3378 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3379 case ELFOSABI_AROS: return "AROS";
11636f9e 3380 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3381 default:
40b36596
JM		 3382 if (osabi >= 64)
3383 switch (elf_header.e_machine)
3384 {
3385 case EM_ARM:
3386 switch (osabi)
3387 {
3388 case ELFOSABI_ARM: return "ARM";
3389 default:
3390 break;
3391 }
3392 break;
3393
3394 case EM_MSP430:
3395 case EM_MSP430_OLD:
619ed720 3396 case EM_VISIUM:
40b36596
JM		 3397 switch (osabi)
3398 {
3399 case ELFOSABI_STANDALONE: return _("Standalone App");
3400 default:
3401 break;
3402 }
3403 break;
3404
3405 case EM_TI_C6000:
3406 switch (osabi)
3407 {
3408 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3409 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3410 default:
3411 break;
3412 }
3413 break;
3414
3415 default:
3416 break;
3417 }
e9e44622 3418 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3419 return buff;
3420 }
3421}
3422
a06ea964
NC		 3423static const char *
3424get_aarch64_segment_type (unsigned long type)
3425{
3426 switch (type)
3427 {
3428 case PT_AARCH64_ARCHEXT:
3429 return "AARCH64_ARCHEXT";
3430 default:
3431 break;
3432 }
3433
3434 return NULL;
3435}
3436
b294bdf8
MM		 3437static const char *
3438get_arm_segment_type (unsigned long type)
3439{
3440 switch (type)
3441 {
3442 case PT_ARM_EXIDX:
3443 return "EXIDX";
3444 default:
3445 break;
3446 }
3447
3448 return NULL;
3449}
3450
d3ba0551
AM		 3451static const char *
3452get_mips_segment_type (unsigned long type)
252b5132
RH		 3453{
3454 switch (type)
3455 {
3456 case PT_MIPS_REGINFO:
3457 return "REGINFO";
3458 case PT_MIPS_RTPROC:
3459 return "RTPROC";
3460 case PT_MIPS_OPTIONS:
3461 return "OPTIONS";
351cdf24
MF		 3462 case PT_MIPS_ABIFLAGS:
3463 return "ABIFLAGS";
252b5132
RH		 3464 default:
3465 break;
3466 }
3467
3468 return NULL;
3469}
3470
103f02d3 3471static const char *
d3ba0551 3472get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3473{
3474 switch (type)
3475 {
3476 case PT_HP_TLS: return "HP_TLS";
3477 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3478 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3479 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3480 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3481 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3482 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3483 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3484 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3485 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3486 case PT_HP_PARALLEL: return "HP_PARALLEL";
3487 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3488 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3489 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3490 case PT_HP_STACK: return "HP_STACK";
3491 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3492 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3493 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3494 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3495 default:
3496 break;
3497 }
3498
3499 return NULL;
3500}
3501
4d6ed7c8 3502static const char *
d3ba0551 3503get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3504{
3505 switch (type)
3506 {
3507 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3508 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3509 case PT_HP_TLS: return "HP_TLS";
3510 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3511 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3512 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3513 default:
3514 break;
3515 }
3516
3517 return NULL;
3518}
3519
40b36596
JM		 3520static const char *
3521get_tic6x_segment_type (unsigned long type)
3522{
3523 switch (type)
3524 {
3525 case PT_C6000_PHATTR: return "C6000_PHATTR";
3526 default:
3527 break;
3528 }
3529
3530 return NULL;
3531}
3532
252b5132 3533static const char *
d3ba0551 3534get_segment_type (unsigned long p_type)
252b5132 3535{
b34976b6 3536 static char buff[32];
252b5132
RH		 3537
3538 switch (p_type)
3539 {
b34976b6
AM		 3540 case PT_NULL: return "NULL";
3541 case PT_LOAD: return "LOAD";
252b5132 3542 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3543 case PT_INTERP: return "INTERP";
3544 case PT_NOTE: return "NOTE";
3545 case PT_SHLIB: return "SHLIB";
3546 case PT_PHDR: return "PHDR";
13ae64f3 3547 case PT_TLS: return "TLS";
252b5132 3548
65765700
JJ		 3549 case PT_GNU_EH_FRAME:
3550 return "GNU_EH_FRAME";
2b05f1b7 3551 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3552 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3553
252b5132
RH		 3554 default:
3555 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3556 {
2cf0635d 3557 const char * result;
103f02d3 3558
252b5132
RH		 3559 switch (elf_header.e_machine)
3560 {
a06ea964
NC		 3561 case EM_AARCH64:
3562 result = get_aarch64_segment_type (p_type);
3563 break;
b294bdf8
MM		 3564 case EM_ARM:
3565 result = get_arm_segment_type (p_type);
3566 break;
252b5132 3567 case EM_MIPS:
4fe85591 3568 case EM_MIPS_RS3_LE:
252b5132
RH		 3569 result = get_mips_segment_type (p_type);
3570 break;
103f02d3
UD		 3571 case EM_PARISC:
3572 result = get_parisc_segment_type (p_type);
3573 break;
4d6ed7c8
NC		 3574 case EM_IA_64:
3575 result = get_ia64_segment_type (p_type);
3576 break;
40b36596
JM		 3577 case EM_TI_C6000:
3578 result = get_tic6x_segment_type (p_type);
3579 break;
252b5132
RH		 3580 default:
3581 result = NULL;
3582 break;
3583 }
103f02d3 3584
252b5132
RH		 3585 if (result != NULL)
3586 return result;
103f02d3 3587
252b5132
RH		 3588 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3589 }
3590 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3591 {
2cf0635d 3592 const char * result;
103f02d3
UD		 3593
3594 switch (elf_header.e_machine)
3595 {
3596 case EM_PARISC:
3597 result = get_parisc_segment_type (p_type);
3598 break;
00428cca
AM		 3599 case EM_IA_64:
3600 result = get_ia64_segment_type (p_type);
3601 break;
103f02d3
UD		 3602 default:
3603 result = NULL;
3604 break;
3605 }
3606
3607 if (result != NULL)
3608 return result;
3609
3610 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3611 }
252b5132 3612 else
e9e44622 3613 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3614
3615 return buff;
3616 }
3617}
3618
3619static const char *
d3ba0551 3620get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3621{
3622 switch (sh_type)
3623 {
b34976b6
AM		 3624 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3625 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3626 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3627 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3628 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3629 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3630 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3631 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3632 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3633 case SHT_MIPS_RELD: return "MIPS_RELD";
3634 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3635 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3636 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3637 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3638 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3639 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3640 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3641 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3642 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3643 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3644 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3645 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3646 case SHT_MIPS_LINE: return "MIPS_LINE";
3647 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3648 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3649 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3650 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3651 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3652 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3653 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3654 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3655 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3656 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3657 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3658 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3659 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3660 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3661 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3662 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3663 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3664 default:
3665 break;
3666 }
3667 return NULL;
3668}
3669
103f02d3 3670static const char *
d3ba0551 3671get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3672{
3673 switch (sh_type)
3674 {
3675 case SHT_PARISC_EXT: return "PARISC_EXT";
3676 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3677 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3678 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3679 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3680 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3681 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3682 default:
3683 break;
3684 }
3685 return NULL;
3686}
3687
4d6ed7c8 3688static const char *
d3ba0551 3689get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3690{
18bd398b 3691 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3692 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3693 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3694
4d6ed7c8
NC		 3695 switch (sh_type)
3696 {
148b93f2
NC		 3697 case SHT_IA_64_EXT: return "IA_64_EXT";
3698 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3699 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3700 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3701 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3702 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3703 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3704 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3705 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3706 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3707 default:
3708 break;
3709 }
3710 return NULL;
3711}
3712
d2b2c203
DJ		 3713static const char *
3714get_x86_64_section_type_name (unsigned int sh_type)
3715{
3716 switch (sh_type)
3717 {
3718 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3719 default:
3720 break;
3721 }
3722 return NULL;
3723}
3724
a06ea964
NC		 3725static const char *
3726get_aarch64_section_type_name (unsigned int sh_type)
3727{
3728 switch (sh_type)
3729 {
3730 case SHT_AARCH64_ATTRIBUTES:
3731 return "AARCH64_ATTRIBUTES";
3732 default:
3733 break;
3734 }
3735 return NULL;
3736}
3737
40a18ebd
NC		 3738static const char *
3739get_arm_section_type_name (unsigned int sh_type)
3740{
3741 switch (sh_type)
3742 {
7f6fed87
NC		 3743 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3744 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3745 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3746 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3747 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3748 default:
3749 break;
3750 }
3751 return NULL;
3752}
3753
40b36596
JM		 3754static const char *
3755get_tic6x_section_type_name (unsigned int sh_type)
3756{
3757 switch (sh_type)
3758 {
3759 case SHT_C6000_UNWIND:
3760 return "C6000_UNWIND";
3761 case SHT_C6000_PREEMPTMAP:
3762 return "C6000_PREEMPTMAP";
3763 case SHT_C6000_ATTRIBUTES:
3764 return "C6000_ATTRIBUTES";
3765 case SHT_TI_ICODE:
3766 return "TI_ICODE";
3767 case SHT_TI_XREF:
3768 return "TI_XREF";
3769 case SHT_TI_HANDLER:
3770 return "TI_HANDLER";
3771 case SHT_TI_INITINFO:
3772 return "TI_INITINFO";
3773 case SHT_TI_PHATTRS:
3774 return "TI_PHATTRS";
3775 default:
3776 break;
3777 }
3778 return NULL;
3779}
3780
13761a11
NC		 3781static const char *
3782get_msp430x_section_type_name (unsigned int sh_type)
3783{
3784 switch (sh_type)
3785 {
3786 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3787 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3788 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3789 default: return NULL;
3790 }
3791}
3792
685080f2
NC		 3793static const char *
3794get_v850_section_type_name (unsigned int sh_type)
3795{
3796 switch (sh_type)
3797 {
3798 case SHT_V850_SCOMMON: return "V850 Small Common";
3799 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3800 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3801 case SHT_RENESAS_IOP: return "RENESAS IOP";
3802 case SHT_RENESAS_INFO: return "RENESAS INFO";
3803 default: return NULL;
3804 }
3805}
3806
252b5132 3807static const char *
d3ba0551 3808get_section_type_name (unsigned int sh_type)
252b5132 3809{
b34976b6 3810 static char buff[32];
252b5132
RH		 3811
3812 switch (sh_type)
3813 {
3814 case SHT_NULL: return "NULL";
3815 case SHT_PROGBITS: return "PROGBITS";
3816 case SHT_SYMTAB: return "SYMTAB";
3817 case SHT_STRTAB: return "STRTAB";
3818 case SHT_RELA: return "RELA";
3819 case SHT_HASH: return "HASH";
3820 case SHT_DYNAMIC: return "DYNAMIC";
3821 case SHT_NOTE: return "NOTE";
3822 case SHT_NOBITS: return "NOBITS";
3823 case SHT_REL: return "REL";
3824 case SHT_SHLIB: return "SHLIB";
3825 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3826 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3827 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3828 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3829 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3830 case SHT_GROUP: return "GROUP";
3831 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3832 case SHT_GNU_verdef: return "VERDEF";
3833 case SHT_GNU_verneed: return "VERNEED";
3834 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3835 case 0x6ffffff0: return "VERSYM";
3836 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3837 case 0x7ffffffd: return "AUXILIARY";
3838 case 0x7fffffff: return "FILTER";
047b2264 3839 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3840
3841 default:
3842 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3843 {
2cf0635d 3844 const char * result;
252b5132
RH		 3845
3846 switch (elf_header.e_machine)
3847 {
3848 case EM_MIPS:
4fe85591 3849 case EM_MIPS_RS3_LE:
252b5132
RH		 3850 result = get_mips_section_type_name (sh_type);
3851 break;
103f02d3
UD		 3852 case EM_PARISC:
3853 result = get_parisc_section_type_name (sh_type);
3854 break;
4d6ed7c8
NC		 3855 case EM_IA_64:
3856 result = get_ia64_section_type_name (sh_type);
3857 break;
d2b2c203 3858 case EM_X86_64:
8a9036a4 3859 case EM_L1OM:
7a9068fe 3860 case EM_K1OM:
d2b2c203
DJ		 3861 result = get_x86_64_section_type_name (sh_type);
3862 break;
a06ea964
NC		 3863 case EM_AARCH64:
3864 result = get_aarch64_section_type_name (sh_type);
3865 break;
40a18ebd
NC		 3866 case EM_ARM:
3867 result = get_arm_section_type_name (sh_type);
3868 break;
40b36596
JM		 3869 case EM_TI_C6000:
3870 result = get_tic6x_section_type_name (sh_type);
3871 break;
13761a11
NC		 3872 case EM_MSP430:
3873 result = get_msp430x_section_type_name (sh_type);
3874 break;
685080f2
NC		 3875 case EM_V800:
3876 case EM_V850:
3877 case EM_CYGNUS_V850:
3878 result = get_v850_section_type_name (sh_type);
3879 break;
252b5132
RH		 3880 default:
3881 result = NULL;
3882 break;
3883 }
3884
3885 if (result != NULL)
3886 return result;
3887
c91d0dfb 3888 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3889 }
3890 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3891 {
2cf0635d 3892 const char * result;
148b93f2
NC		 3893
3894 switch (elf_header.e_machine)
3895 {
3896 case EM_IA_64:
3897 result = get_ia64_section_type_name (sh_type);
3898 break;
3899 default:
3900 result = NULL;
3901 break;
3902 }
3903
3904 if (result != NULL)
3905 return result;
3906
3907 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3908 }
252b5132 3909 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3910 {
3911 switch (elf_header.e_machine)
3912 {
3913 case EM_V800:
3914 case EM_V850:
3915 case EM_CYGNUS_V850:
3916 return get_v850_section_type_name (sh_type);
3917 default:
3918 break;
3919 }
3920
3921 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3922 }
252b5132 3923 else
a7dbfd1c
NC		 3924 /* This message is probably going to be displayed in a 15
3925 character wide field, so put the hex value first. */
3926 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3927
252b5132
RH		 3928 return buff;
3929 }
3930}
3931
2979dc34 3932#define OPTION_DEBUG_DUMP 512
2c610e4b 3933#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3934#define OPTION_DWARF_DEPTH 514
3935#define OPTION_DWARF_START 515
4723351a 3936#define OPTION_DWARF_CHECK 516
2979dc34 3937
85b1c36d 3938static struct option options[] =
252b5132 3939{
b34976b6 3940 {"all", no_argument, 0, 'a'},
252b5132
RH		 3941 {"file-header", no_argument, 0, 'h'},
3942 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3943 {"headers", no_argument, 0, 'e'},
3944 {"histogram", no_argument, 0, 'I'},
3945 {"segments", no_argument, 0, 'l'},
3946 {"sections", no_argument, 0, 'S'},
252b5132 3947 {"section-headers", no_argument, 0, 'S'},
f5842774 3948 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3949 {"section-details", no_argument, 0, 't'},
595cf52e 3950 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3951 {"symbols", no_argument, 0, 's'},
3952 {"syms", no_argument, 0, 's'},
2c610e4b 3953 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3954 {"relocs", no_argument, 0, 'r'},
3955 {"notes", no_argument, 0, 'n'},
3956 {"dynamic", no_argument, 0, 'd'},
a952a375 3957 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3958 {"version-info", no_argument, 0, 'V'},
3959 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3960 {"unwind", no_argument, 0, 'u'},
4145f1d5 3961 {"archive-index", no_argument, 0, 'c'},
b34976b6 3962 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3963 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3964 {"string-dump", required_argument, 0, 'p'},
0e602686 3965 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 3966#ifdef SUPPORT_DISASSEMBLY
3967 {"instruction-dump", required_argument, 0, 'i'},
3968#endif
cf13d699 3969 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3970
fd2f0033
TT		 3971 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3972 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3973 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3974
b34976b6
AM		 3975 {"version", no_argument, 0, 'v'},
3976 {"wide", no_argument, 0, 'W'},
3977 {"help", no_argument, 0, 'H'},
3978 {0, no_argument, 0, 0}
252b5132
RH		 3979};
3980
3981static void
2cf0635d 3982usage (FILE * stream)
252b5132 3983{
92f01d61
JM		 3984 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3985 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3986 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3987 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3988 -h --file-header Display the ELF file header\n\
3989 -l --program-headers Display the program headers\n\
3990 --segments An alias for --program-headers\n\
3991 -S --section-headers Display the sections' header\n\
3992 --sections An alias for --section-headers\n\
f5842774 3993 -g --section-groups Display the section groups\n\
5477e8a0 3994 -t --section-details Display the section details\n\
8b53311e
NC		 3995 -e --headers Equivalent to: -h -l -S\n\
3996 -s --syms Display the symbol table\n\
3f08eb35 3997 --symbols An alias for --syms\n\
2c610e4b 3998 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3999 -n --notes Display the core notes (if present)\n\
4000 -r --relocs Display the relocations (if present)\n\
4001 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4002 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4003 -V --version-info Display the version sections (if present)\n\
1b31d05e 4004 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4005 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4006 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4007 -x --hex-dump=<number|name>\n\
4008 Dump the contents of section <number|name> as bytes\n\
4009 -p --string-dump=<number|name>\n\
4010 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4011 -R --relocated-dump=<number|name>\n\
4012 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4013 -z --decompress Decompress section before dumping it\n\
f9f0e732 4014 -w[lLiaprmfFsoRt] or\n\
1ed06042 4015 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4016 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4017 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4018 =addr,=cu_index]\n\
8b53311e 4019 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4020 fprintf (stream, _("\
4021 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4022 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4023 or deeper\n"));
252b5132 4024#ifdef SUPPORT_DISASSEMBLY
92f01d61 4025 fprintf (stream, _("\
09c11c86
NC		 4026 -i --instruction-dump=<number|name>\n\
4027 Disassemble the contents of section <number|name>\n"));
252b5132 4028#endif
92f01d61 4029 fprintf (stream, _("\
8b53311e
NC		 4030 -I --histogram Display histogram of bucket list lengths\n\
4031 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4032 @<file> Read options from <file>\n\
8b53311e
NC		 4033 -H --help Display this information\n\
4034 -v --version Display the version number of readelf\n"));
1118d252 4035
92f01d61
JM		 4036 if (REPORT_BUGS_TO[0] && stream == stdout)
4037 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4038
92f01d61 4039 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4040}
4041
18bd398b
NC		 4042/* Record the fact that the user wants the contents of section number
4043 SECTION to be displayed using the method(s) encoded as flags bits
4044 in TYPE. Note, TYPE can be zero if we are creating the array for
4045 the first time. */
4046
252b5132 4047static void
09c11c86 4048request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4049{
4050 if (section >= num_dump_sects)
4051 {
2cf0635d 4052 dump_type * new_dump_sects;
252b5132 4053
3f5e193b
NC		 4054 new_dump_sects = (dump_type *) calloc (section + 1,
4055 sizeof (* dump_sects));
252b5132
RH		 4056
4057 if (new_dump_sects == NULL)
591a748a 4058 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4059 else
4060 {
4061 /* Copy current flag settings. */
09c11c86 4062 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4063
4064 free (dump_sects);
4065
4066 dump_sects = new_dump_sects;
4067 num_dump_sects = section + 1;
4068 }
4069 }
4070
4071 if (dump_sects)
b34976b6 4072 dump_sects[section] |= type;
252b5132
RH		 4073
4074 return;
4075}
4076
aef1f6d0
DJ		 4077/* Request a dump by section name. */
4078
4079static void
2cf0635d 4080request_dump_byname (const char * section, dump_type type)
aef1f6d0 4081{
2cf0635d 4082 struct dump_list_entry * new_request;
aef1f6d0 4083
3f5e193b
NC		 4084 new_request = (struct dump_list_entry *)
4085 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4086 if (!new_request)
591a748a 4087 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4088
4089 new_request->name = strdup (section);
4090 if (!new_request->name)
591a748a 4091 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4092
4093 new_request->type = type;
4094
4095 new_request->next = dump_sects_byname;
4096 dump_sects_byname = new_request;
4097}
4098
cf13d699
NC		 4099static inline void
4100request_dump (dump_type type)
4101{
4102 int section;
4103 char * cp;
4104
4105 do_dump++;
4106 section = strtoul (optarg, & cp, 0);
4107
4108 if (! *cp && section >= 0)
4109 request_dump_bynumber (section, type);
4110 else
4111 request_dump_byname (optarg, type);
4112}
4113
4114
252b5132 4115static void
2cf0635d 4116parse_args (int argc, char ** argv)
252b5132
RH		 4117{
4118 int c;
4119
4120 if (argc < 2)
92f01d61 4121 usage (stderr);
252b5132
RH		 4122
4123 while ((c = getopt_long
0e602686 4124 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4125 {
252b5132
RH		 4126 switch (c)
4127 {
4128 case 0:
4129 /* Long options. */
4130 break;
4131 case 'H':
92f01d61 4132 usage (stdout);
252b5132
RH		 4133 break;
4134
4135 case 'a':
b34976b6
AM		 4136 do_syms++;
4137 do_reloc++;
4138 do_unwind++;
4139 do_dynamic++;
4140 do_header++;
4141 do_sections++;
f5842774 4142 do_section_groups++;
b34976b6
AM		 4143 do_segments++;
4144 do_version++;
4145 do_histogram++;
4146 do_arch++;
4147 do_notes++;
252b5132 4148 break;
f5842774
L		 4149 case 'g':
4150 do_section_groups++;
4151 break;
5477e8a0 4152 case 't':
595cf52e 4153 case 'N':
5477e8a0
L		 4154 do_sections++;
4155 do_section_details++;
595cf52e 4156 break;
252b5132 4157 case 'e':
b34976b6
AM		 4158 do_header++;
4159 do_sections++;
4160 do_segments++;
252b5132 4161 break;
a952a375 4162 case 'A':
b34976b6 4163 do_arch++;
a952a375 4164 break;
252b5132 4165 case 'D':
b34976b6 4166 do_using_dynamic++;
252b5132
RH		 4167 break;
4168 case 'r':
b34976b6 4169 do_reloc++;
252b5132 4170 break;
4d6ed7c8 4171 case 'u':
b34976b6 4172 do_unwind++;
4d6ed7c8 4173 break;
252b5132 4174 case 'h':
b34976b6 4175 do_header++;
252b5132
RH		 4176 break;
4177 case 'l':
b34976b6 4178 do_segments++;
252b5132
RH		 4179 break;
4180 case 's':
b34976b6 4181 do_syms++;
252b5132
RH		 4182 break;
4183 case 'S':
b34976b6 4184 do_sections++;
252b5132
RH		 4185 break;
4186 case 'd':
b34976b6 4187 do_dynamic++;
252b5132 4188 break;
a952a375 4189 case 'I':
b34976b6 4190 do_histogram++;
a952a375 4191 break;
779fe533 4192 case 'n':
b34976b6 4193 do_notes++;
779fe533 4194 break;
4145f1d5
NC		 4195 case 'c':
4196 do_archive_index++;
4197 break;
252b5132 4198 case 'x':
cf13d699 4199 request_dump (HEX_DUMP);
aef1f6d0 4200 break;
09c11c86 4201 case 'p':
cf13d699
NC		 4202 request_dump (STRING_DUMP);
4203 break;
4204 case 'R':
4205 request_dump (RELOC_DUMP);
09c11c86 4206 break;
0e602686
NC		 4207 case 'z':
4208 decompress_dumps++;
4209 break;
252b5132 4210 case 'w':
b34976b6 4211 do_dump++;
252b5132 4212 if (optarg == 0)
613ff48b
CC		 4213 {
4214 do_debugging = 1;
4215 dwarf_select_sections_all ();
4216 }
252b5132
RH		 4217 else
4218 {
4219 do_debugging = 0;
4cb93e3b 4220 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4221 }
4222 break;
2979dc34 4223 case OPTION_DEBUG_DUMP:
b34976b6 4224 do_dump++;
2979dc34
JJ		 4225 if (optarg == 0)
4226 do_debugging = 1;
4227 else
4228 {
2979dc34 4229 do_debugging = 0;
4cb93e3b 4230 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4231 }
4232 break;
fd2f0033
TT		 4233 case OPTION_DWARF_DEPTH:
4234 {
4235 char *cp;
4236
4237 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4238 }
4239 break;
4240 case OPTION_DWARF_START:
4241 {
4242 char *cp;
4243
4244 dwarf_start_die = strtoul (optarg, & cp, 0);
4245 }
4246 break;
4723351a
CC		 4247 case OPTION_DWARF_CHECK:
4248 dwarf_check = 1;
4249 break;
2c610e4b
L		 4250 case OPTION_DYN_SYMS:
4251 do_dyn_syms++;
4252 break;
252b5132
RH		 4253#ifdef SUPPORT_DISASSEMBLY
4254 case 'i':
cf13d699
NC		 4255 request_dump (DISASS_DUMP);
4256 break;
252b5132
RH		 4257#endif
4258 case 'v':
4259 print_version (program_name);
4260 break;
4261 case 'V':
b34976b6 4262 do_version++;
252b5132 4263 break;
d974e256 4264 case 'W':
b34976b6 4265 do_wide++;
d974e256 4266 break;
252b5132 4267 default:
252b5132
RH		 4268 /* xgettext:c-format */
4269 error (_("Invalid option '-%c'\n"), c);
4270 /* Drop through. */
4271 case '?':
92f01d61 4272 usage (stderr);
252b5132
RH		 4273 }
4274 }
4275
4d6ed7c8 4276 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4277 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4278 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4279 && !do_section_groups && !do_archive_index
4280 && !do_dyn_syms)
92f01d61 4281 usage (stderr);
252b5132
RH		 4282}
4283
4284static const char *
d3ba0551 4285get_elf_class (unsigned int elf_class)
252b5132 4286{
b34976b6 4287 static char buff[32];
103f02d3 4288
252b5132
RH		 4289 switch (elf_class)
4290 {
4291 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4292 case ELFCLASS32: return "ELF32";
4293 case ELFCLASS64: return "ELF64";
ab5e7794 4294 default:
e9e44622 4295 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4296 return buff;
252b5132
RH		 4297 }
4298}
4299
4300static const char *
d3ba0551 4301get_data_encoding (unsigned int encoding)
252b5132 4302{
b34976b6 4303 static char buff[32];
103f02d3 4304
252b5132
RH		 4305 switch (encoding)
4306 {
4307 case ELFDATANONE: return _("none");
33c63f9d
CM		 4308 case ELFDATA2LSB: return _("2's complement, little endian");
4309 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4310 default:
e9e44622 4311 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4312 return buff;
252b5132
RH		 4313 }
4314}
4315
252b5132 4316/* Decode the data held in 'elf_header'. */
ee42cf8c 4317
252b5132 4318static int
d3ba0551 4319process_file_header (void)
252b5132 4320{
b34976b6
AM		 4321 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4322 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4323 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4324 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4325 {
4326 error
4327 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4328 return 0;
4329 }
4330
2dc4cec1
L		 4331 init_dwarf_regnames (elf_header.e_machine);
4332
252b5132
RH		 4333 if (do_header)
4334 {
4335 int i;
4336
4337 printf (_("ELF Header:\n"));
4338 printf (_(" Magic: "));
b34976b6
AM		 4339 for (i = 0; i < EI_NIDENT; i++)
4340 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4341 printf ("\n");
4342 printf (_(" Class: %s\n"),
b34976b6 4343 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4344 printf (_(" Data: %s\n"),
b34976b6 4345 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4346 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4347 elf_header.e_ident[EI_VERSION],
4348 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4349 ? "(current)"
b34976b6 4350 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4351 ? _("<unknown: %lx>")
789be9f7 4352 : "")));
252b5132 4353 printf (_(" OS/ABI: %s\n"),
b34976b6 4354 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4355 printf (_(" ABI Version: %d\n"),
b34976b6 4356 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4357 printf (_(" Type: %s\n"),
4358 get_file_type (elf_header.e_type));
4359 printf (_(" Machine: %s\n"),
4360 get_machine_name (elf_header.e_machine));
4361 printf (_(" Version: 0x%lx\n"),
4362 (unsigned long) elf_header.e_version);
76da6bbe 4363
f7a99963
NC		 4364 printf (_(" Entry point address: "));
4365 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4366 printf (_("\n Start of program headers: "));
4367 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4368 printf (_(" (bytes into file)\n Start of section headers: "));
4369 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4370 printf (_(" (bytes into file)\n"));
76da6bbe 4371
252b5132
RH		 4372 printf (_(" Flags: 0x%lx%s\n"),
4373 (unsigned long) elf_header.e_flags,
4374 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4375 printf (_(" Size of this header: %ld (bytes)\n"),
4376 (long) elf_header.e_ehsize);
4377 printf (_(" Size of program headers: %ld (bytes)\n"),
4378 (long) elf_header.e_phentsize);
2046a35d 4379 printf (_(" Number of program headers: %ld"),
252b5132 4380 (long) elf_header.e_phnum);
2046a35d
AM		 4381 if (section_headers != NULL
4382 && elf_header.e_phnum == PN_XNUM
4383 && section_headers[0].sh_info != 0)
cc5914eb 4384 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4385 putc ('\n', stdout);
252b5132
RH		 4386 printf (_(" Size of section headers: %ld (bytes)\n"),
4387 (long) elf_header.e_shentsize);
560f3c1c 4388 printf (_(" Number of section headers: %ld"),
252b5132 4389 (long) elf_header.e_shnum);
4fbb74a6 4390 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4391 printf (" (%ld)", (long) section_headers[0].sh_size);
4392 putc ('\n', stdout);
4393 printf (_(" Section header string table index: %ld"),
252b5132 4394 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4395 if (section_headers != NULL
4396 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4397 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4398 else if (elf_header.e_shstrndx != SHN_UNDEF
4399 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4400 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4401 putc ('\n', stdout);
4402 }
4403
4404 if (section_headers != NULL)
4405 {
2046a35d
AM		 4406 if (elf_header.e_phnum == PN_XNUM
4407 && section_headers[0].sh_info != 0)
4408 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4409 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4410 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4411 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4412 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4413 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4414 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4415 free (section_headers);
4416 section_headers = NULL;
252b5132 4417 }
103f02d3 4418
9ea033b2
NC		 4419 return 1;
4420}
4421
e0a31db1 4422static bfd_boolean
91d6fa6a 4423get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4424{
2cf0635d
NC		 4425 Elf32_External_Phdr * phdrs;
4426 Elf32_External_Phdr * external;
4427 Elf_Internal_Phdr * internal;
b34976b6 4428 unsigned int i;
e0a31db1
NC		 4429 unsigned int size = elf_header.e_phentsize;
4430 unsigned int num = elf_header.e_phnum;
4431
4432 /* PR binutils/17531: Cope with unexpected section header sizes. */
4433 if (size == 0 || num == 0)
4434 return FALSE;
4435 if (size < sizeof * phdrs)
4436 {
4437 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4438 return FALSE;
4439 }
4440 if (size > sizeof * phdrs)
4441 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4442
3f5e193b 4443 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4444 size, num, _("program headers"));
4445 if (phdrs == NULL)
4446 return FALSE;
9ea033b2 4447
91d6fa6a 4448 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4449 i < elf_header.e_phnum;
b34976b6 4450 i++, internal++, external++)
252b5132 4451 {
9ea033b2
NC		 4452 internal->p_type = BYTE_GET (external->p_type);
4453 internal->p_offset = BYTE_GET (external->p_offset);
4454 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4455 internal->p_paddr = BYTE_GET (external->p_paddr);
4456 internal->p_filesz = BYTE_GET (external->p_filesz);
4457 internal->p_memsz = BYTE_GET (external->p_memsz);
4458 internal->p_flags = BYTE_GET (external->p_flags);
4459 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4460 }
4461
9ea033b2 4462 free (phdrs);
e0a31db1 4463 return TRUE;
252b5132
RH		 4464}
4465
e0a31db1 4466static bfd_boolean
91d6fa6a 4467get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4468{
2cf0635d
NC		 4469 Elf64_External_Phdr * phdrs;
4470 Elf64_External_Phdr * external;
4471 Elf_Internal_Phdr * internal;
b34976b6 4472 unsigned int i;
e0a31db1
NC		 4473 unsigned int size = elf_header.e_phentsize;
4474 unsigned int num = elf_header.e_phnum;
4475
4476 /* PR binutils/17531: Cope with unexpected section header sizes. */
4477 if (size == 0 || num == 0)
4478 return FALSE;
4479 if (size < sizeof * phdrs)
4480 {
4481 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4482 return FALSE;
4483 }
4484 if (size > sizeof * phdrs)
4485 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4486
3f5e193b 4487 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4488 size, num, _("program headers"));
a6e9f9df 4489 if (!phdrs)
e0a31db1 4490 return FALSE;
9ea033b2 4491
91d6fa6a 4492 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4493 i < elf_header.e_phnum;
b34976b6 4494 i++, internal++, external++)
9ea033b2
NC		 4495 {
4496 internal->p_type = BYTE_GET (external->p_type);
4497 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4498 internal->p_offset = BYTE_GET (external->p_offset);
4499 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4500 internal->p_paddr = BYTE_GET (external->p_paddr);
4501 internal->p_filesz = BYTE_GET (external->p_filesz);
4502 internal->p_memsz = BYTE_GET (external->p_memsz);
4503 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4504 }
4505
4506 free (phdrs);
e0a31db1 4507 return TRUE;
9ea033b2 4508}
252b5132 4509
d93f0186
NC		 4510/* Returns 1 if the program headers were read into `program_headers'. */
4511
4512static int
2cf0635d 4513get_program_headers (FILE * file)
d93f0186 4514{
2cf0635d 4515 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4516
4517 /* Check cache of prior read. */
4518 if (program_headers != NULL)
4519 return 1;
4520
3f5e193b
NC		 4521 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4522 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4523
4524 if (phdrs == NULL)
4525 {
8b73c356
NC		 4526 error (_("Out of memory reading %u program headers\n"),
4527 elf_header.e_phnum);
d93f0186
NC		 4528 return 0;
4529 }
4530
4531 if (is_32bit_elf
4532 ? get_32bit_program_headers (file, phdrs)
4533 : get_64bit_program_headers (file, phdrs))
4534 {
4535 program_headers = phdrs;
4536 return 1;
4537 }
4538
4539 free (phdrs);
4540 return 0;
4541}
4542
2f62977e
NC		 4543/* Returns 1 if the program headers were loaded. */
4544
252b5132 4545static int
2cf0635d 4546process_program_headers (FILE * file)
252b5132 4547{
2cf0635d 4548 Elf_Internal_Phdr * segment;
b34976b6 4549 unsigned int i;
252b5132
RH		 4550
4551 if (elf_header.e_phnum == 0)
4552 {
82f2dbf7
NC		 4553 /* PR binutils/12467. */
4554 if (elf_header.e_phoff != 0)
4555 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4556 " header offset, but no program headers\n"));
82f2dbf7 4557 else if (do_segments)
252b5132 4558 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4559 return 0;
252b5132
RH		 4560 }
4561
4562 if (do_segments && !do_header)
4563 {
f7a99963
NC		 4564 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4565 printf (_("Entry point "));
4566 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4567 printf (_("\nThere are %d program headers, starting at offset "),
4568 elf_header.e_phnum);
4569 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4570 printf ("\n");
252b5132
RH		 4571 }
4572
d93f0186 4573 if (! get_program_headers (file))
252b5132 4574 return 0;
103f02d3 4575
252b5132
RH		 4576 if (do_segments)
4577 {
3a1a2036
NC		 4578 if (elf_header.e_phnum > 1)
4579 printf (_("\nProgram Headers:\n"));
4580 else
4581 printf (_("\nProgram Headers:\n"));
76da6bbe 4582
f7a99963
NC		 4583 if (is_32bit_elf)
4584 printf
4585 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4586 else if (do_wide)
4587 printf
4588 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4589 else
4590 {
4591 printf
4592 (_(" Type Offset VirtAddr PhysAddr\n"));
4593 printf
4594 (_(" FileSiz MemSiz Flags Align\n"));
4595 }
252b5132
RH		 4596 }
4597
252b5132 4598 dynamic_addr = 0;
1b228002 4599 dynamic_size = 0;
252b5132
RH		 4600
4601 for (i = 0, segment = program_headers;
4602 i < elf_header.e_phnum;
b34976b6 4603 i++, segment++)
252b5132
RH		 4604 {
4605 if (do_segments)
4606 {
103f02d3 4607 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4608
4609 if (is_32bit_elf)
4610 {
4611 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4612 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4613 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4614 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4615 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4616 printf ("%c%c%c ",
4617 (segment->p_flags & PF_R ? 'R' : ' '),
4618 (segment->p_flags & PF_W ? 'W' : ' '),
4619 (segment->p_flags & PF_X ? 'E' : ' '));
4620 printf ("%#lx", (unsigned long) segment->p_align);
4621 }
d974e256
JJ		 4622 else if (do_wide)
4623 {
4624 if ((unsigned long) segment->p_offset == segment->p_offset)
4625 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4626 else
4627 {
4628 print_vma (segment->p_offset, FULL_HEX);
4629 putchar (' ');
4630 }
4631
4632 print_vma (segment->p_vaddr, FULL_HEX);
4633 putchar (' ');
4634 print_vma (segment->p_paddr, FULL_HEX);
4635 putchar (' ');
4636
4637 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4638 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4639 else
4640 {
4641 print_vma (segment->p_filesz, FULL_HEX);
4642 putchar (' ');
4643 }
4644
4645 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4646 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4647 else
4648 {
f48e6c45 4649 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4650 }
4651
4652 printf (" %c%c%c ",
4653 (segment->p_flags & PF_R ? 'R' : ' '),
4654 (segment->p_flags & PF_W ? 'W' : ' '),
4655 (segment->p_flags & PF_X ? 'E' : ' '));
4656
4657 if ((unsigned long) segment->p_align == segment->p_align)
4658 printf ("%#lx", (unsigned long) segment->p_align);
4659 else
4660 {
4661 print_vma (segment->p_align, PREFIX_HEX);
4662 }
4663 }
f7a99963
NC		 4664 else
4665 {
4666 print_vma (segment->p_offset, FULL_HEX);
4667 putchar (' ');
4668 print_vma (segment->p_vaddr, FULL_HEX);
4669 putchar (' ');
4670 print_vma (segment->p_paddr, FULL_HEX);
4671 printf ("\n ");
4672 print_vma (segment->p_filesz, FULL_HEX);
4673 putchar (' ');
4674 print_vma (segment->p_memsz, FULL_HEX);
4675 printf (" %c%c%c ",
4676 (segment->p_flags & PF_R ? 'R' : ' '),
4677 (segment->p_flags & PF_W ? 'W' : ' '),
4678 (segment->p_flags & PF_X ? 'E' : ' '));
4679 print_vma (segment->p_align, HEX);
4680 }
252b5132
RH		 4681 }
4682
f54498b4
NC		 4683 if (do_segments)
4684 putc ('\n', stdout);
4685
252b5132
RH		 4686 switch (segment->p_type)
4687 {
252b5132
RH		 4688 case PT_DYNAMIC:
4689 if (dynamic_addr)
4690 error (_("more than one dynamic segment\n"));
4691
20737c13
AM		 4692 /* By default, assume that the .dynamic section is the first
4693 section in the DYNAMIC segment. */
4694 dynamic_addr = segment->p_offset;
4695 dynamic_size = segment->p_filesz;
f54498b4
NC		 4696 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4697 if (dynamic_addr + dynamic_size >= current_file_size)
4698 {
4699 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4700 dynamic_addr = dynamic_size = 0;
4701 }
20737c13 4702
b2d38a17
NC		 4703 /* Try to locate the .dynamic section. If there is
4704 a section header table, we can easily locate it. */
4705 if (section_headers != NULL)
4706 {
2cf0635d 4707 Elf_Internal_Shdr * sec;
b2d38a17 4708
89fac5e3
RS		 4709 sec = find_section (".dynamic");
4710 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4711 {
28f997cf
TG		 4712 /* A corresponding .dynamic section is expected, but on
4713 IA-64/OpenVMS it is OK for it to be missing. */
4714 if (!is_ia64_vms ())
4715 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4716 break;
4717 }
4718
42bb2e33 4719 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4720 {
4721 dynamic_size = 0;
4722 break;
4723 }
42bb2e33 4724
b2d38a17
NC		 4725 dynamic_addr = sec->sh_offset;
4726 dynamic_size = sec->sh_size;
4727
4728 if (dynamic_addr < segment->p_offset
4729 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4730 warn (_("the .dynamic section is not contained"
4731 " within the dynamic segment\n"));
b2d38a17 4732 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4733 warn (_("the .dynamic section is not the first section"
4734 " in the dynamic segment.\n"));
b2d38a17 4735 }
252b5132
RH		 4736 break;
4737
4738 case PT_INTERP:
fb52b2f4
NC		 4739 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4740 SEEK_SET))
252b5132
RH		 4741 error (_("Unable to find program interpreter name\n"));
4742 else
4743 {
f8eae8b2 4744 char fmt [32];
9495b2e6 4745 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4746
4747 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4748 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4749
252b5132 4750 program_interpreter[0] = 0;
7bd7b3ef
AM		 4751 if (fscanf (file, fmt, program_interpreter) <= 0)
4752 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4753
4754 if (do_segments)
f54498b4 4755 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4756 program_interpreter);
4757 }
4758 break;
4759 }
252b5132
RH		 4760 }
4761
c256ffe7 4762 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4763 {
4764 printf (_("\n Section to Segment mapping:\n"));
4765 printf (_(" Segment Sections...\n"));
4766
252b5132
RH		 4767 for (i = 0; i < elf_header.e_phnum; i++)
4768 {
9ad5cbcf 4769 unsigned int j;
2cf0635d 4770 Elf_Internal_Shdr * section;
252b5132
RH		 4771
4772 segment = program_headers + i;
b391a3e3 4773 section = section_headers + 1;
252b5132
RH		 4774
4775 printf (" %2.2d ", i);
4776
b34976b6 4777 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4778 {
f4638467
AM		 4779 if (!ELF_TBSS_SPECIAL (section, segment)
4780 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4781 printf ("%s ", printable_section_name (section));
252b5132
RH		 4782 }
4783
4784 putc ('\n',stdout);
4785 }
4786 }
4787
252b5132
RH		 4788 return 1;
4789}
4790
4791
d93f0186
NC		 4792/* Find the file offset corresponding to VMA by using the program headers. */
4793
4794static long
2cf0635d 4795offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4796{
2cf0635d 4797 Elf_Internal_Phdr * seg;
d93f0186
NC		 4798
4799 if (! get_program_headers (file))
4800 {
4801 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4802 return (long) vma;
4803 }
4804
4805 for (seg = program_headers;
4806 seg < program_headers + elf_header.e_phnum;
4807 ++seg)
4808 {
4809 if (seg->p_type != PT_LOAD)
4810 continue;
4811
4812 if (vma >= (seg->p_vaddr & -seg->p_align)
4813 && vma + size <= seg->p_vaddr + seg->p_filesz)
4814 return vma - seg->p_vaddr + seg->p_offset;
4815 }
4816
4817 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4818 (unsigned long) vma);
d93f0186
NC		 4819 return (long) vma;
4820}
4821
4822
049b0c3a
NC		 4823/* Allocate memory and load the sections headers into the global pointer
4824 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4825 generate any error messages if the load fails. */
4826
4827static bfd_boolean
4828get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4829{
2cf0635d
NC		 4830 Elf32_External_Shdr * shdrs;
4831 Elf_Internal_Shdr * internal;
b34976b6 4832 unsigned int i;
049b0c3a
NC		 4833 unsigned int size = elf_header.e_shentsize;
4834 unsigned int num = probe ? 1 : elf_header.e_shnum;
4835
4836 /* PR binutils/17531: Cope with unexpected section header sizes. */
4837 if (size == 0 || num == 0)
4838 return FALSE;
4839 if (size < sizeof * shdrs)
4840 {
4841 if (! probe)
4842 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4843 return FALSE;
4844 }
4845 if (!probe && size > sizeof * shdrs)
4846 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4847
3f5e193b 4848 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4849 size, num,
4850 probe ? NULL : _("section headers"));
4851 if (shdrs == NULL)
4852 return FALSE;
252b5132 4853
049b0c3a
NC		 4854 if (section_headers != NULL)
4855 free (section_headers);
3f5e193b
NC		 4856 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4857 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4858 if (section_headers == NULL)
4859 {
049b0c3a 4860 if (!probe)
8b73c356 4861 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4862 return FALSE;
252b5132
RH		 4863 }
4864
4865 for (i = 0, internal = section_headers;
560f3c1c 4866 i < num;
b34976b6 4867 i++, internal++)
252b5132
RH		 4868 {
4869 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4870 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4871 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4872 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4873 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4874 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4875 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4876 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4877 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4878 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4879 }
4880
4881 free (shdrs);
049b0c3a 4882 return TRUE;
252b5132
RH		 4883}
4884
049b0c3a
NC		 4885static bfd_boolean
4886get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4887{
2cf0635d
NC		 4888 Elf64_External_Shdr * shdrs;
4889 Elf_Internal_Shdr * internal;
b34976b6 4890 unsigned int i;
049b0c3a
NC		 4891 unsigned int size = elf_header.e_shentsize;
4892 unsigned int num = probe ? 1 : elf_header.e_shnum;
4893
4894 /* PR binutils/17531: Cope with unexpected section header sizes. */
4895 if (size == 0 || num == 0)
4896 return FALSE;
4897 if (size < sizeof * shdrs)
4898 {
4899 if (! probe)
4900 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4901 return FALSE;
4902 }
4903 if (! probe && size > sizeof * shdrs)
4904 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4905
3f5e193b 4906 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4907 size, num,
4908 probe ? NULL : _("section headers"));
4909 if (shdrs == NULL)
4910 return FALSE;
9ea033b2 4911
049b0c3a
NC		 4912 if (section_headers != NULL)
4913 free (section_headers);
3f5e193b
NC		 4914 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4915 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4916 if (section_headers == NULL)
4917 {
049b0c3a 4918 if (! probe)
8b73c356 4919 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4920 return FALSE;
9ea033b2
NC		 4921 }
4922
4923 for (i = 0, internal = section_headers;
560f3c1c 4924 i < num;
b34976b6 4925 i++, internal++)
9ea033b2
NC		 4926 {
4927 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4928 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4929 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4930 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4931 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4932 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4933 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4934 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4935 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4936 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4937 }
4938
4939 free (shdrs);
049b0c3a 4940 return TRUE;
9ea033b2
NC		 4941}
4942
252b5132 4943static Elf_Internal_Sym *
ba5cdace
NC		 4944get_32bit_elf_symbols (FILE * file,
4945 Elf_Internal_Shdr * section,
4946 unsigned long * num_syms_return)
252b5132 4947{
ba5cdace 4948 unsigned long number = 0;
dd24e3da 4949 Elf32_External_Sym * esyms = NULL;
ba5cdace 4950 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4951 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4952 Elf_Internal_Sym * psym;
b34976b6 4953 unsigned int j;
252b5132 4954
c9c1d674
EG		 4955 if (section->sh_size == 0)
4956 {
4957 if (num_syms_return != NULL)
4958 * num_syms_return = 0;
4959 return NULL;
4960 }
4961
dd24e3da 4962 /* Run some sanity checks first. */
c9c1d674 4963 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4964 {
c9c1d674
EG		 4965 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4966 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4967 goto exit_point;
dd24e3da
NC		 4968 }
4969
f54498b4
NC		 4970 if (section->sh_size > current_file_size)
4971 {
4972 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4973 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4974 goto exit_point;
4975 }
4976
dd24e3da
NC		 4977 number = section->sh_size / section->sh_entsize;
4978
4979 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4980 {
c9c1d674 4981 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4982 (unsigned long) section->sh_size,
4983 printable_section_name (section),
4984 (unsigned long) section->sh_entsize);
ba5cdace 4985 goto exit_point;
dd24e3da
NC		 4986 }
4987
3f5e193b
NC		 4988 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4989 section->sh_size, _("symbols"));
dd24e3da 4990 if (esyms == NULL)
ba5cdace 4991 goto exit_point;
252b5132 4992
6a40cf0c
NC		 4993 {
4994 elf_section_list * entry;
4995
4996 shndx = NULL;
4997 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
4998 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 4999 {
6a40cf0c
NC		 5000 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5001 entry->hdr->sh_offset,
5002 1, entry->hdr->sh_size,
5003 _("symbol table section indicies"));
5004 if (shndx == NULL)
5005 goto exit_point;
5006 /* PR17531: file: heap-buffer-overflow */
5007 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5008 {
5009 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5010 printable_section_name (entry->hdr),
5011 (unsigned long) entry->hdr->sh_size,
5012 (unsigned long) section->sh_size);
5013 goto exit_point;
5014 }
c9c1d674 5015 }
6a40cf0c 5016 }
9ad5cbcf 5017
3f5e193b 5018 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5019
5020 if (isyms == NULL)
5021 {
8b73c356
NC		 5022 error (_("Out of memory reading %lu symbols\n"),
5023 (unsigned long) number);
dd24e3da 5024 goto exit_point;
252b5132
RH		 5025 }
5026
dd24e3da 5027 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5028 {
5029 psym->st_name = BYTE_GET (esyms[j].st_name);
5030 psym->st_value = BYTE_GET (esyms[j].st_value);
5031 psym->st_size = BYTE_GET (esyms[j].st_size);
5032 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5033 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5034 psym->st_shndx
5035 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5036 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5037 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5038 psym->st_info = BYTE_GET (esyms[j].st_info);
5039 psym->st_other = BYTE_GET (esyms[j].st_other);
5040 }
5041
dd24e3da 5042 exit_point:
ba5cdace 5043 if (shndx != NULL)
9ad5cbcf 5044 free (shndx);
ba5cdace 5045 if (esyms != NULL)
dd24e3da 5046 free (esyms);
252b5132 5047
ba5cdace
NC		 5048 if (num_syms_return != NULL)
5049 * num_syms_return = isyms == NULL ? 0 : number;
5050
252b5132
RH		 5051 return isyms;
5052}
5053
9ea033b2 5054static Elf_Internal_Sym *
ba5cdace
NC		 5055get_64bit_elf_symbols (FILE * file,
5056 Elf_Internal_Shdr * section,
5057 unsigned long * num_syms_return)
9ea033b2 5058{
ba5cdace
NC		 5059 unsigned long number = 0;
5060 Elf64_External_Sym * esyms = NULL;
5061 Elf_External_Sym_Shndx * shndx = NULL;
5062 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5063 Elf_Internal_Sym * psym;
b34976b6 5064 unsigned int j;
9ea033b2 5065
c9c1d674
EG		 5066 if (section->sh_size == 0)
5067 {
5068 if (num_syms_return != NULL)
5069 * num_syms_return = 0;
5070 return NULL;
5071 }
5072
dd24e3da 5073 /* Run some sanity checks first. */
c9c1d674 5074 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5075 {
c9c1d674 5076 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5077 printable_section_name (section),
5078 (unsigned long) section->sh_entsize);
ba5cdace 5079 goto exit_point;
dd24e3da
NC		 5080 }
5081
f54498b4
NC		 5082 if (section->sh_size > current_file_size)
5083 {
5084 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5085 printable_section_name (section),
5086 (unsigned long) section->sh_size);
f54498b4
NC		 5087 goto exit_point;
5088 }
5089
dd24e3da
NC		 5090 number = section->sh_size / section->sh_entsize;
5091
5092 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5093 {
c9c1d674 5094 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5095 (unsigned long) section->sh_size,
5096 printable_section_name (section),
5097 (unsigned long) section->sh_entsize);
ba5cdace 5098 goto exit_point;
dd24e3da
NC		 5099 }
5100
3f5e193b
NC		 5101 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5102 section->sh_size, _("symbols"));
a6e9f9df 5103 if (!esyms)
ba5cdace 5104 goto exit_point;
9ea033b2 5105
6a40cf0c
NC		 5106 {
5107 elf_section_list * entry;
5108
5109 shndx = NULL;
5110 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5111 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5112 {
6a40cf0c
NC		 5113 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5114 entry->hdr->sh_offset,
5115 1, entry->hdr->sh_size,
5116 _("symbol table section indicies"));
5117 if (shndx == NULL)
5118 goto exit_point;
5119 /* PR17531: file: heap-buffer-overflow */
5120 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5121 {
5122 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5123 printable_section_name (entry->hdr),
5124 (unsigned long) entry->hdr->sh_size,
5125 (unsigned long) section->sh_size);
5126 goto exit_point;
5127 }
c9c1d674 5128 }
6a40cf0c 5129 }
9ad5cbcf 5130
3f5e193b 5131 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5132
5133 if (isyms == NULL)
5134 {
8b73c356
NC		 5135 error (_("Out of memory reading %lu symbols\n"),
5136 (unsigned long) number);
ba5cdace 5137 goto exit_point;
9ea033b2
NC		 5138 }
5139
ba5cdace 5140 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5141 {
5142 psym->st_name = BYTE_GET (esyms[j].st_name);
5143 psym->st_info = BYTE_GET (esyms[j].st_info);
5144 psym->st_other = BYTE_GET (esyms[j].st_other);
5145 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5146
4fbb74a6 5147 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5148 psym->st_shndx
5149 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5150 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5151 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5152
66543521
AM		 5153 psym->st_value = BYTE_GET (esyms[j].st_value);
5154 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5155 }
5156
ba5cdace
NC		 5157 exit_point:
5158 if (shndx != NULL)
9ad5cbcf 5159 free (shndx);
ba5cdace
NC		 5160 if (esyms != NULL)
5161 free (esyms);
5162
5163 if (num_syms_return != NULL)
5164 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5165
5166 return isyms;
5167}
5168
d1133906 5169static const char *
d3ba0551 5170get_elf_section_flags (bfd_vma sh_flags)
d1133906 5171{
5477e8a0 5172 static char buff[1024];
2cf0635d 5173 char * p = buff;
8d5ff12c 5174 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5175 int sindex;
5176 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5177 bfd_vma os_flags = 0;
5178 bfd_vma proc_flags = 0;
5179 bfd_vma unknown_flags = 0;
148b93f2 5180 static const struct
5477e8a0 5181 {
2cf0635d 5182 const char * str;
5477e8a0
L		 5183 int len;
5184 }
5185 flags [] =
5186 {
cfcac11d
NC		 5187 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5188 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5189 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5190 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5191 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5192 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5193 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5194 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5195 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5196 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5197 /* IA-64 specific. */
5198 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5199 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5200 /* IA-64 OpenVMS specific. */
5201 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5202 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5203 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5204 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5205 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5206 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5207 /* Generic. */
cfcac11d 5208 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5209 /* SPARC specific. */
77115a4a
L		 5210 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5211 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5212 };
5213
5214 if (do_section_details)
5215 {
8d5ff12c
L		 5216 sprintf (buff, "[%*.*lx]: ",
5217 field_size, field_size, (unsigned long) sh_flags);
5218 p += field_size + 4;
5477e8a0 5219 }
76da6bbe 5220
d1133906
NC		 5221 while (sh_flags)
5222 {
5223 bfd_vma flag;
5224
5225 flag = sh_flags & - sh_flags;
5226 sh_flags &= ~ flag;
76da6bbe 5227
5477e8a0 5228 if (do_section_details)
d1133906 5229 {
5477e8a0
L		 5230 switch (flag)
5231 {
91d6fa6a
NC		 5232 case SHF_WRITE: sindex = 0; break;
5233 case SHF_ALLOC: sindex = 1; break;
5234 case SHF_EXECINSTR: sindex = 2; break;
5235 case SHF_MERGE: sindex = 3; break;
5236 case SHF_STRINGS: sindex = 4; break;
5237 case SHF_INFO_LINK: sindex = 5; break;
5238 case SHF_LINK_ORDER: sindex = 6; break;
5239 case SHF_OS_NONCONFORMING: sindex = 7; break;
5240 case SHF_GROUP: sindex = 8; break;
5241 case SHF_TLS: sindex = 9; break;
18ae9cc1 5242 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5243 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5244
5477e8a0 5245 default:
91d6fa6a 5246 sindex = -1;
cfcac11d 5247 switch (elf_header.e_machine)
148b93f2 5248 {
cfcac11d 5249 case EM_IA_64:
148b93f2 5250 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5251 sindex = 10;
148b93f2 5252 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5253 sindex = 11;
148b93f2
NC		 5254#ifdef BFD64
5255 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5256 switch (flag)
5257 {
91d6fa6a
NC		 5258 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5259 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5260 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5261 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5262 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5263 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5264 default: break;
5265 }
5266#endif
cfcac11d
NC		 5267 break;
5268
caa83f8b 5269 case EM_386:
22abe556 5270 case EM_IAMCU:
caa83f8b 5271 case EM_X86_64:
7f502d6c 5272 case EM_L1OM:
7a9068fe 5273 case EM_K1OM:
cfcac11d
NC		 5274 case EM_OLD_SPARCV9:
5275 case EM_SPARC32PLUS:
5276 case EM_SPARCV9:
5277 case EM_SPARC:
18ae9cc1 5278 if (flag == SHF_ORDERED)
91d6fa6a 5279 sindex = 19;
cfcac11d
NC		 5280 break;
5281 default:
5282 break;
148b93f2 5283 }
5477e8a0
L		 5284 }
5285
91d6fa6a 5286 if (sindex != -1)
5477e8a0 5287 {
8d5ff12c
L		 5288 if (p != buff + field_size + 4)
5289 {
5290 if (size < (10 + 2))
bee0ee85
NC		 5291 {
5292 warn (_("Internal error: not enough buffer room for section flag info"));
5293 return _("<unknown>");
5294 }
8d5ff12c
L		 5295 size -= 2;
5296 *p++ = ',';
5297 *p++ = ' ';
5298 }
5299
91d6fa6a
NC		 5300 size -= flags [sindex].len;
5301 p = stpcpy (p, flags [sindex].str);
5477e8a0 5302 }
3b22753a 5303 else if (flag & SHF_MASKOS)
8d5ff12c 5304 os_flags |= flag;
d1133906 5305 else if (flag & SHF_MASKPROC)
8d5ff12c 5306 proc_flags |= flag;
d1133906 5307 else
8d5ff12c 5308 unknown_flags |= flag;
5477e8a0
L		 5309 }
5310 else
5311 {
5312 switch (flag)
5313 {
5314 case SHF_WRITE: *p = 'W'; break;
5315 case SHF_ALLOC: *p = 'A'; break;
5316 case SHF_EXECINSTR: *p = 'X'; break;
5317 case SHF_MERGE: *p = 'M'; break;
5318 case SHF_STRINGS: *p = 'S'; break;
5319 case SHF_INFO_LINK: *p = 'I'; break;
5320 case SHF_LINK_ORDER: *p = 'L'; break;
5321 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5322 case SHF_GROUP: *p = 'G'; break;
5323 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5324 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5325 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5326
5327 default:
8a9036a4 5328 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5329 || elf_header.e_machine == EM_L1OM
5330 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5331 && flag == SHF_X86_64_LARGE)
5332 *p = 'l';
5333 else if (flag & SHF_MASKOS)
5334 {
5335 *p = 'o';
5336 sh_flags &= ~ SHF_MASKOS;
5337 }
5338 else if (flag & SHF_MASKPROC)
5339 {
5340 *p = 'p';
5341 sh_flags &= ~ SHF_MASKPROC;
5342 }
5343 else
5344 *p = 'x';
5345 break;
5346 }
5347 p++;
d1133906
NC		 5348 }
5349 }
76da6bbe 5350
8d5ff12c
L		 5351 if (do_section_details)
5352 {
5353 if (os_flags)
5354 {
5355 size -= 5 + field_size;
5356 if (p != buff + field_size + 4)
5357 {
5358 if (size < (2 + 1))
bee0ee85
NC		 5359 {
5360 warn (_("Internal error: not enough buffer room for section flag info"));
5361 return _("<unknown>");
5362 }
8d5ff12c
L		 5363 size -= 2;
5364 *p++ = ',';
5365 *p++ = ' ';
5366 }
5367 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5368 (unsigned long) os_flags);
5369 p += 5 + field_size;
5370 }
5371 if (proc_flags)
5372 {
5373 size -= 7 + field_size;
5374 if (p != buff + field_size + 4)
5375 {
5376 if (size < (2 + 1))
bee0ee85
NC		 5377 {
5378 warn (_("Internal error: not enough buffer room for section flag info"));
5379 return _("<unknown>");
5380 }
8d5ff12c
L		 5381 size -= 2;
5382 *p++ = ',';
5383 *p++ = ' ';
5384 }
5385 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5386 (unsigned long) proc_flags);
5387 p += 7 + field_size;
5388 }
5389 if (unknown_flags)
5390 {
5391 size -= 10 + field_size;
5392 if (p != buff + field_size + 4)
5393 {
5394 if (size < (2 + 1))
bee0ee85
NC		 5395 {
5396 warn (_("Internal error: not enough buffer room for section flag info"));
5397 return _("<unknown>");
5398 }
8d5ff12c
L		 5399 size -= 2;
5400 *p++ = ',';
5401 *p++ = ' ';
5402 }
2b692964 5403 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5404 (unsigned long) unknown_flags);
5405 p += 10 + field_size;
5406 }
5407 }
5408
e9e44622 5409 *p = '\0';
d1133906
NC		 5410 return buff;
5411}
5412
77115a4a
L		 5413static unsigned int
5414get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5415{
5416 if (is_32bit_elf)
5417 {
5418 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5419 chdr->ch_type = BYTE_GET (echdr->ch_type);
5420 chdr->ch_size = BYTE_GET (echdr->ch_size);
5421 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5422 return sizeof (*echdr);
5423 }
5424 else
5425 {
5426 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5427 chdr->ch_type = BYTE_GET (echdr->ch_type);
5428 chdr->ch_size = BYTE_GET (echdr->ch_size);
5429 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5430 return sizeof (*echdr);
5431 }
5432}
5433
252b5132 5434static int
2cf0635d 5435process_section_headers (FILE * file)
252b5132 5436{
2cf0635d 5437 Elf_Internal_Shdr * section;
b34976b6 5438 unsigned int i;
252b5132
RH		 5439
5440 section_headers = NULL;
5441
5442 if (elf_header.e_shnum == 0)
5443 {
82f2dbf7
NC		 5444 /* PR binutils/12467. */
5445 if (elf_header.e_shoff != 0)
5446 warn (_("possibly corrupt ELF file header - it has a non-zero"
5447 " section header offset, but no section headers\n"));
5448 else if (do_sections)
252b5132
RH		 5449 printf (_("\nThere are no sections in this file.\n"));
5450
5451 return 1;
5452 }
5453
5454 if (do_sections && !do_header)
9ea033b2 5455 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5456 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5457
9ea033b2
NC		 5458 if (is_32bit_elf)
5459 {
049b0c3a 5460 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5461 return 0;
5462 }
049b0c3a 5463 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5464 return 0;
5465
5466 /* Read in the string table, so that we have names to display. */
0b49d371 5467 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5468 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5469 {
4fbb74a6 5470 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5471
c256ffe7
JJ		 5472 if (section->sh_size != 0)
5473 {
3f5e193b
NC		 5474 string_table = (char *) get_data (NULL, file, section->sh_offset,
5475 1, section->sh_size,
5476 _("string table"));
0de14b54 5477
c256ffe7
JJ		 5478 string_table_length = string_table != NULL ? section->sh_size : 0;
5479 }
252b5132
RH		 5480 }
5481
5482 /* Scan the sections for the dynamic symbol table
e3c8793a 5483 and dynamic string table and debug sections. */
252b5132
RH		 5484 dynamic_symbols = NULL;
5485 dynamic_strings = NULL;
5486 dynamic_syminfo = NULL;
6a40cf0c 5487 symtab_shndx_list = NULL;
103f02d3 5488
89fac5e3
RS		 5489 eh_addr_size = is_32bit_elf ? 4 : 8;
5490 switch (elf_header.e_machine)
5491 {
5492 case EM_MIPS:
5493 case EM_MIPS_RS3_LE:
5494 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5495 FDE addresses. However, the ABI also has a semi-official ILP32
5496 variant for which the normal FDE address size rules apply.
5497
5498 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5499 section, where XX is the size of longs in bits. Unfortunately,
5500 earlier compilers provided no way of distinguishing ILP32 objects
5501 from LP64 objects, so if there's any doubt, we should assume that
5502 the official LP64 form is being used. */
5503 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5504 && find_section (".gcc_compiled_long32") == NULL)
5505 eh_addr_size = 8;
5506 break;
0f56a26a
DD		 5507
5508 case EM_H8_300:
5509 case EM_H8_300H:
5510 switch (elf_header.e_flags & EF_H8_MACH)
5511 {
5512 case E_H8_MACH_H8300:
5513 case E_H8_MACH_H8300HN:
5514 case E_H8_MACH_H8300SN:
5515 case E_H8_MACH_H8300SXN:
5516 eh_addr_size = 2;
5517 break;
5518 case E_H8_MACH_H8300H:
5519 case E_H8_MACH_H8300S:
5520 case E_H8_MACH_H8300SX:
5521 eh_addr_size = 4;
5522 break;
5523 }
f4236fe4
DD		 5524 break;
5525
ff7eeb89 5526 case EM_M32C_OLD:
f4236fe4
DD		 5527 case EM_M32C:
5528 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5529 {
5530 case EF_M32C_CPU_M16C:
5531 eh_addr_size = 2;
5532 break;
5533 }
5534 break;
89fac5e3
RS		 5535 }
5536
76ca31c0
NC		 5537#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5538 do \
5539 { \
5540 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5541 if (section->sh_entsize != expected_entsize) \
9dd3a467 5542 { \
76ca31c0
NC		 5543 char buf[40]; \
5544 sprintf_vma (buf, section->sh_entsize); \
5545 /* Note: coded this way so that there is a single string for \
5546 translation. */ \
5547 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5548 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5549 (unsigned) expected_entsize); \
9dd3a467 5550 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5551 } \
5552 } \
08d8fa11 5553 while (0)
9dd3a467
NC		 5554
5555#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5556 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5557 sizeof (Elf64_External_##type))
5558
252b5132
RH		 5559 for (i = 0, section = section_headers;
5560 i < elf_header.e_shnum;
b34976b6 5561 i++, section++)
252b5132 5562 {
2cf0635d 5563 char * name = SECTION_NAME (section);
252b5132
RH		 5564
5565 if (section->sh_type == SHT_DYNSYM)
5566 {
5567 if (dynamic_symbols != NULL)
5568 {
5569 error (_("File contains multiple dynamic symbol tables\n"));
5570 continue;
5571 }
5572
08d8fa11 5573 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5574 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5575 }
5576 else if (section->sh_type == SHT_STRTAB
18bd398b 5577 && streq (name, ".dynstr"))
252b5132
RH		 5578 {
5579 if (dynamic_strings != NULL)
5580 {
5581 error (_("File contains multiple dynamic string tables\n"));
5582 continue;
5583 }
5584
3f5e193b
NC		 5585 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5586 1, section->sh_size,
5587 _("dynamic strings"));
59245841 5588 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5589 }
9ad5cbcf
AM		 5590 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5591 {
6a40cf0c
NC		 5592 elf_section_list * entry = xmalloc (sizeof * entry);
5593 entry->hdr = section;
5594 entry->next = symtab_shndx_list;
5595 symtab_shndx_list = entry;
9ad5cbcf 5596 }
08d8fa11
JJ		 5597 else if (section->sh_type == SHT_SYMTAB)
5598 CHECK_ENTSIZE (section, i, Sym);
5599 else if (section->sh_type == SHT_GROUP)
5600 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5601 else if (section->sh_type == SHT_REL)
5602 CHECK_ENTSIZE (section, i, Rel);
5603 else if (section->sh_type == SHT_RELA)
5604 CHECK_ENTSIZE (section, i, Rela);
252b5132 5605 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5606 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5607 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5608 || do_debug_str || do_debug_loc || do_debug_ranges
5609 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5610 && (const_strneq (name, ".debug_")
5611 || const_strneq (name, ".zdebug_")))
252b5132 5612 {
1b315056
CS		 5613 if (name[1] == 'z')
5614 name += sizeof (".zdebug_") - 1;
5615 else
5616 name += sizeof (".debug_") - 1;
252b5132
RH		 5617
5618 if (do_debugging
4723351a
CC		 5619 || (do_debug_info && const_strneq (name, "info"))
5620 || (do_debug_info && const_strneq (name, "types"))
5621 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5622 || (do_debug_lines && strcmp (name, "line") == 0)
5623 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5624 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5625 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5626 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5627 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5628 || (do_debug_aranges && const_strneq (name, "aranges"))
5629 || (do_debug_ranges && const_strneq (name, "ranges"))
5630 || (do_debug_frames && const_strneq (name, "frame"))
5631 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5632 || (do_debug_macinfo && const_strneq (name, "macro"))
5633 || (do_debug_str && const_strneq (name, "str"))
5634 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5635 || (do_debug_addr && const_strneq (name, "addr"))
5636 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5637 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5638 )
09c11c86 5639 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5640 }
a262ae96 5641 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5642 else if ((do_debugging || do_debug_info)
0112cd26 5643 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5644 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5645 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5646 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5647 else if (do_gdb_index && streq (name, ".gdb_index"))
5648 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5649 /* Trace sections for Itanium VMS. */
5650 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5651 || do_trace_aranges)
5652 && const_strneq (name, ".trace_"))
5653 {
5654 name += sizeof (".trace_") - 1;
5655
5656 if (do_debugging
5657 || (do_trace_info && streq (name, "info"))
5658 || (do_trace_abbrevs && streq (name, "abbrev"))
5659 || (do_trace_aranges && streq (name, "aranges"))
5660 )
5661 request_dump_bynumber (i, DEBUG_DUMP);
5662 }
252b5132
RH		 5663 }
5664
5665 if (! do_sections)
5666 return 1;
5667
3a1a2036
NC		 5668 if (elf_header.e_shnum > 1)
5669 printf (_("\nSection Headers:\n"));
5670 else
5671 printf (_("\nSection Header:\n"));
76da6bbe 5672
f7a99963 5673 if (is_32bit_elf)
595cf52e 5674 {
5477e8a0 5675 if (do_section_details)
595cf52e
L		 5676 {
5677 printf (_(" [Nr] Name\n"));
5477e8a0 5678 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5679 }
5680 else
5681 printf
5682 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5683 }
d974e256 5684 else if (do_wide)
595cf52e 5685 {
5477e8a0 5686 if (do_section_details)
595cf52e
L		 5687 {
5688 printf (_(" [Nr] Name\n"));
5477e8a0 5689 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5690 }
5691 else
5692 printf
5693 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5694 }
f7a99963
NC		 5695 else
5696 {
5477e8a0 5697 if (do_section_details)
595cf52e
L		 5698 {
5699 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5700 printf (_(" Type Address Offset Link\n"));
5701 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5702 }
5703 else
5704 {
5705 printf (_(" [Nr] Name Type Address Offset\n"));
5706 printf (_(" Size EntSize Flags Link Info Align\n"));
5707 }
f7a99963 5708 }
252b5132 5709
5477e8a0
L		 5710 if (do_section_details)
5711 printf (_(" Flags\n"));
5712
252b5132
RH		 5713 for (i = 0, section = section_headers;
5714 i < elf_header.e_shnum;
b34976b6 5715 i++, section++)
252b5132 5716 {
7bfd842d 5717 printf (" [%2u] ", i);
5477e8a0 5718 if (do_section_details)
74e1a04b 5719 printf ("%s\n ", printable_section_name (section));
595cf52e 5720 else
74e1a04b 5721 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5722
ea52a088
NC		 5723 printf (do_wide ? " %-15s " : " %-15.15s ",
5724 get_section_type_name (section->sh_type));
0b4362b0 5725
f7a99963
NC		 5726 if (is_32bit_elf)
5727 {
cfcac11d
NC		 5728 const char * link_too_big = NULL;
5729
f7a99963 5730 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5731
f7a99963
NC		 5732 printf ( " %6.6lx %6.6lx %2.2lx",
5733 (unsigned long) section->sh_offset,
5734 (unsigned long) section->sh_size,
5735 (unsigned long) section->sh_entsize);
d1133906 5736
5477e8a0
L		 5737 if (do_section_details)
5738 fputs (" ", stdout);
5739 else
5740 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5741
cfcac11d
NC		 5742 if (section->sh_link >= elf_header.e_shnum)
5743 {
5744 link_too_big = "";
5745 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5746 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5747 switch (elf_header.e_machine)
5748 {
caa83f8b 5749 case EM_386:
22abe556 5750 case EM_IAMCU:
caa83f8b 5751 case EM_X86_64:
7f502d6c 5752 case EM_L1OM:
7a9068fe 5753 case EM_K1OM:
cfcac11d
NC		 5754 case EM_OLD_SPARCV9:
5755 case EM_SPARC32PLUS:
5756 case EM_SPARCV9:
5757 case EM_SPARC:
5758 if (section->sh_link == (SHN_BEFORE & 0xffff))
5759 link_too_big = "BEFORE";
5760 else if (section->sh_link == (SHN_AFTER & 0xffff))
5761 link_too_big = "AFTER";
5762 break;
5763 default:
5764 break;
5765 }
5766 }
5767
5768 if (do_section_details)
5769 {
5770 if (link_too_big != NULL && * link_too_big)
5771 printf ("<%s> ", link_too_big);
5772 else
5773 printf ("%2u ", section->sh_link);
5774 printf ("%3u %2lu\n", section->sh_info,
5775 (unsigned long) section->sh_addralign);
5776 }
5777 else
5778 printf ("%2u %3u %2lu\n",
5779 section->sh_link,
5780 section->sh_info,
5781 (unsigned long) section->sh_addralign);
5782
5783 if (link_too_big && ! * link_too_big)
5784 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5785 i, section->sh_link);
f7a99963 5786 }
d974e256
JJ		 5787 else if (do_wide)
5788 {
5789 print_vma (section->sh_addr, LONG_HEX);
5790
5791 if ((long) section->sh_offset == section->sh_offset)
5792 printf (" %6.6lx", (unsigned long) section->sh_offset);
5793 else
5794 {
5795 putchar (' ');
5796 print_vma (section->sh_offset, LONG_HEX);
5797 }
5798
5799 if ((unsigned long) section->sh_size == section->sh_size)
5800 printf (" %6.6lx", (unsigned long) section->sh_size);
5801 else
5802 {
5803 putchar (' ');
5804 print_vma (section->sh_size, LONG_HEX);
5805 }
5806
5807 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5808 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5809 else
5810 {
5811 putchar (' ');
5812 print_vma (section->sh_entsize, LONG_HEX);
5813 }
5814
5477e8a0
L		 5815 if (do_section_details)
5816 fputs (" ", stdout);
5817 else
5818 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5819
72de5009 5820 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5821
5822 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5823 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5824 else
5825 {
5826 print_vma (section->sh_addralign, DEC);
5827 putchar ('\n');
5828 }
5829 }
5477e8a0 5830 else if (do_section_details)
595cf52e 5831 {
5477e8a0 5832 printf (" %-15.15s ",
595cf52e 5833 get_section_type_name (section->sh_type));
595cf52e
L		 5834 print_vma (section->sh_addr, LONG_HEX);
5835 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5836 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5837 else
5838 {
5839 printf (" ");
5840 print_vma (section->sh_offset, LONG_HEX);
5841 }
72de5009 5842 printf (" %u\n ", section->sh_link);
595cf52e 5843 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5844 putchar (' ');
595cf52e
L		 5845 print_vma (section->sh_entsize, LONG_HEX);
5846
72de5009
AM		 5847 printf (" %-16u %lu\n",
5848 section->sh_info,
595cf52e
L		 5849 (unsigned long) section->sh_addralign);
5850 }
f7a99963
NC		 5851 else
5852 {
5853 putchar (' ');
5854 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5855 if ((long) section->sh_offset == section->sh_offset)
5856 printf (" %8.8lx", (unsigned long) section->sh_offset);
5857 else
5858 {
5859 printf (" ");
5860 print_vma (section->sh_offset, LONG_HEX);
5861 }
f7a99963
NC		 5862 printf ("\n ");
5863 print_vma (section->sh_size, LONG_HEX);
5864 printf (" ");
5865 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5866
d1133906 5867 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5868
72de5009
AM		 5869 printf (" %2u %3u %lu\n",
5870 section->sh_link,
5871 section->sh_info,
f7a99963
NC		 5872 (unsigned long) section->sh_addralign);
5873 }
5477e8a0
L		 5874
5875 if (do_section_details)
77115a4a
L		 5876 {
5877 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5878 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5879 {
5880 /* Minimum section size is 12 bytes for 32-bit compression
5881 header + 12 bytes for compressed data header. */
5882 unsigned char buf[24];
5883 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5884 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5885 sizeof (buf), _("compression header")))
5886 {
5887 Elf_Internal_Chdr chdr;
5888 get_compression_header (&chdr, buf);
5889 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5890 printf (" ZLIB, ");
5891 else
5892 printf (_(" [<unknown>: 0x%x], "),
5893 chdr.ch_type);
5894 print_vma (chdr.ch_size, LONG_HEX);
5895 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5896 }
5897 }
5898 }
252b5132
RH		 5899 }
5900
5477e8a0 5901 if (!do_section_details)
3dbcc61d
NC		 5902 {
5903 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5904 || elf_header.e_machine == EM_L1OM
5905 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5906 printf (_("Key to Flags:\n\
5907 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5908 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5909 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5910 else
5911 printf (_("Key to Flags:\n\
e3c8793a 5912 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5913 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5914 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5915 }
d1133906 5916
252b5132
RH		 5917 return 1;
5918}
5919
f5842774
L		 5920static const char *
5921get_group_flags (unsigned int flags)
5922{
5923 static char buff[32];
5924 switch (flags)
5925 {
220453ec
AM		 5926 case 0:
5927 return "";
5928
f5842774 5929 case GRP_COMDAT:
220453ec 5930 return "COMDAT ";
f5842774
L		 5931
5932 default:
220453ec 5933 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5934 break;
5935 }
5936 return buff;
5937}
5938
5939static int
2cf0635d 5940process_section_groups (FILE * file)
f5842774 5941{
2cf0635d 5942 Elf_Internal_Shdr * section;
f5842774 5943 unsigned int i;
2cf0635d
NC		 5944 struct group * group;
5945 Elf_Internal_Shdr * symtab_sec;
5946 Elf_Internal_Shdr * strtab_sec;
5947 Elf_Internal_Sym * symtab;
ba5cdace 5948 unsigned long num_syms;
2cf0635d 5949 char * strtab;
c256ffe7 5950 size_t strtab_size;
d1f5c6e3
L		 5951
5952 /* Don't process section groups unless needed. */
5953 if (!do_unwind && !do_section_groups)
5954 return 1;
f5842774
L		 5955
5956 if (elf_header.e_shnum == 0)
5957 {
5958 if (do_section_groups)
82f2dbf7 5959 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5960
5961 return 1;
5962 }
5963
5964 if (section_headers == NULL)
5965 {
5966 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5967 /* PR 13622: This can happen with a corrupt ELF header. */
5968 return 0;
f5842774
L		 5969 }
5970
3f5e193b
NC		 5971 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5972 sizeof (struct group *));
e4b17d5c
L		 5973
5974 if (section_headers_groups == NULL)
5975 {
8b73c356
NC		 5976 error (_("Out of memory reading %u section group headers\n"),
5977 elf_header.e_shnum);
e4b17d5c
L		 5978 return 0;
5979 }
5980
f5842774 5981 /* Scan the sections for the group section. */
d1f5c6e3 5982 group_count = 0;
f5842774
L		 5983 for (i = 0, section = section_headers;
5984 i < elf_header.e_shnum;
5985 i++, section++)
e4b17d5c
L		 5986 if (section->sh_type == SHT_GROUP)
5987 group_count++;
5988
d1f5c6e3
L		 5989 if (group_count == 0)
5990 {
5991 if (do_section_groups)
5992 printf (_("\nThere are no section groups in this file.\n"));
5993
5994 return 1;
5995 }
5996
3f5e193b 5997 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5998
5999 if (section_groups == NULL)
6000 {
8b73c356
NC		 6001 error (_("Out of memory reading %lu groups\n"),
6002 (unsigned long) group_count);
e4b17d5c
L		 6003 return 0;
6004 }
6005
d1f5c6e3
L		 6006 symtab_sec = NULL;
6007 strtab_sec = NULL;
6008 symtab = NULL;
ba5cdace 6009 num_syms = 0;
d1f5c6e3 6010 strtab = NULL;
c256ffe7 6011 strtab_size = 0;
e4b17d5c
L		 6012 for (i = 0, section = section_headers, group = section_groups;
6013 i < elf_header.e_shnum;
6014 i++, section++)
f5842774
L		 6015 {
6016 if (section->sh_type == SHT_GROUP)
6017 {
74e1a04b
NC		 6018 const char * name = printable_section_name (section);
6019 const char * group_name;
2cf0635d
NC		 6020 unsigned char * start;
6021 unsigned char * indices;
f5842774 6022 unsigned int entry, j, size;
2cf0635d
NC		 6023 Elf_Internal_Shdr * sec;
6024 Elf_Internal_Sym * sym;
f5842774
L		 6025
6026 /* Get the symbol table. */
4fbb74a6
AM		 6027 if (section->sh_link >= elf_header.e_shnum
6028 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6029 != SHT_SYMTAB))
f5842774
L		 6030 {
6031 error (_("Bad sh_link in group section `%s'\n"), name);
6032 continue;
6033 }
d1f5c6e3
L		 6034
6035 if (symtab_sec != sec)
6036 {
6037 symtab_sec = sec;
6038 if (symtab)
6039 free (symtab);
ba5cdace 6040 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6041 }
f5842774 6042
dd24e3da
NC		 6043 if (symtab == NULL)
6044 {
6045 error (_("Corrupt header in group section `%s'\n"), name);
6046 continue;
6047 }
6048
ba5cdace
NC		 6049 if (section->sh_info >= num_syms)
6050 {
6051 error (_("Bad sh_info in group section `%s'\n"), name);
6052 continue;
6053 }
6054
f5842774
L		 6055 sym = symtab + section->sh_info;
6056
6057 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6058 {
4fbb74a6
AM		 6059 if (sym->st_shndx == 0
6060 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6061 {
6062 error (_("Bad sh_info in group section `%s'\n"), name);
6063 continue;
6064 }
ba2685cc 6065
4fbb74a6 6066 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6067 strtab_sec = NULL;
6068 if (strtab)
6069 free (strtab);
f5842774 6070 strtab = NULL;
c256ffe7 6071 strtab_size = 0;
f5842774
L		 6072 }
6073 else
6074 {
6075 /* Get the string table. */
4fbb74a6 6076 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6077 {
6078 strtab_sec = NULL;
6079 if (strtab)
6080 free (strtab);
6081 strtab = NULL;
6082 strtab_size = 0;
6083 }
6084 else if (strtab_sec
4fbb74a6 6085 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6086 {
6087 strtab_sec = sec;
6088 if (strtab)
6089 free (strtab);
071436c6 6090
3f5e193b 6091 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6092 1, strtab_sec->sh_size,
6093 _("string table"));
c256ffe7 6094 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6095 }
c256ffe7 6096 group_name = sym->st_name < strtab_size
2b692964 6097 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6098 }
6099
c9c1d674
EG		 6100 /* PR 17531: file: loop. */
6101 if (section->sh_entsize > section->sh_size)
6102 {
6103 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6104 printable_section_name (section),
8066deb1
AM		 6105 (unsigned long) section->sh_entsize,
6106 (unsigned long) section->sh_size);
c9c1d674
EG		 6107 break;
6108 }
6109
3f5e193b
NC		 6110 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6111 1, section->sh_size,
6112 _("section data"));
59245841
NC		 6113 if (start == NULL)
6114 continue;
f5842774
L		 6115
6116 indices = start;
6117 size = (section->sh_size / section->sh_entsize) - 1;
6118 entry = byte_get (indices, 4);
6119 indices += 4;
e4b17d5c
L		 6120
6121 if (do_section_groups)
6122 {
2b692964 6123 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6124 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6125
e4b17d5c
L		 6126 printf (_(" [Index] Name\n"));
6127 }
6128
6129 group->group_index = i;
6130
f5842774
L		 6131 for (j = 0; j < size; j++)
6132 {
2cf0635d 6133 struct group_list * g;
e4b17d5c 6134
f5842774
L		 6135 entry = byte_get (indices, 4);
6136 indices += 4;
6137
4fbb74a6 6138 if (entry >= elf_header.e_shnum)
391cb864 6139 {
57028622
NC		 6140 static unsigned num_group_errors = 0;
6141
6142 if (num_group_errors ++ < 10)
6143 {
6144 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6145 entry, i, elf_header.e_shnum - 1);
6146 if (num_group_errors == 10)
6147 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6148 }
391cb864
L		 6149 continue;
6150 }
391cb864 6151
4fbb74a6 6152 if (section_headers_groups [entry] != NULL)
e4b17d5c 6153 {
d1f5c6e3
L		 6154 if (entry)
6155 {
57028622
NC		 6156 static unsigned num_errs = 0;
6157
6158 if (num_errs ++ < 10)
6159 {
6160 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6161 entry, i,
6162 section_headers_groups [entry]->group_index);
6163 if (num_errs == 10)
6164 warn (_("Further error messages about already contained group sections suppressed\n"));
6165 }
d1f5c6e3
L		 6166 continue;
6167 }
6168 else
6169 {
6170 /* Intel C/C++ compiler may put section 0 in a
6171 section group. We just warn it the first time
6172 and ignore it afterwards. */
6173 static int warned = 0;
6174 if (!warned)
6175 {
6176 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6177 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6178 warned++;
6179 }
6180 }
e4b17d5c
L		 6181 }
6182
4fbb74a6 6183 section_headers_groups [entry] = group;
e4b17d5c
L		 6184
6185 if (do_section_groups)
6186 {
4fbb74a6 6187 sec = section_headers + entry;
74e1a04b 6188 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6189 }
6190
3f5e193b 6191 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6192 g->section_index = entry;
6193 g->next = group->root;
6194 group->root = g;
f5842774
L		 6195 }
6196
f5842774
L		 6197 if (start)
6198 free (start);
e4b17d5c
L		 6199
6200 group++;
f5842774
L		 6201 }
6202 }
6203
d1f5c6e3
L		 6204 if (symtab)
6205 free (symtab);
6206 if (strtab)
6207 free (strtab);
f5842774
L		 6208 return 1;
6209}
6210
28f997cf
TG		 6211/* Data used to display dynamic fixups. */
6212
6213struct ia64_vms_dynfixup
6214{
6215 bfd_vma needed_ident; /* Library ident number. */
6216 bfd_vma needed; /* Index in the dstrtab of the library name. */
6217 bfd_vma fixup_needed; /* Index of the library. */
6218 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6219 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6220};
6221
6222/* Data used to display dynamic relocations. */
6223
6224struct ia64_vms_dynimgrela
6225{
6226 bfd_vma img_rela_cnt; /* Number of relocations. */
6227 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6228};
6229
6230/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6231 library). */
6232
6233static void
6234dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6235 const char *strtab, unsigned int strtab_sz)
6236{
6237 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6238 long i;
6239 const char *lib_name;
6240
6241 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6242 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6243 _("dynamic section image fixups"));
6244 if (!imfs)
6245 return;
6246
6247 if (fixup->needed < strtab_sz)
6248 lib_name = strtab + fixup->needed;
6249 else
6250 {
6251 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6252 (unsigned long) fixup->needed);
28f997cf
TG		 6253 lib_name = "???";
6254 }
6255 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6256 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6257 printf
6258 (_("Seg Offset Type SymVec DataType\n"));
6259
6260 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6261 {
6262 unsigned int type;
6263 const char *rtype;
6264
6265 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6266 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6267 type = BYTE_GET (imfs [i].type);
6268 rtype = elf_ia64_reloc_type (type);
6269 if (rtype == NULL)
6270 printf (" 0x%08x ", type);
6271 else
6272 printf (" %-32s ", rtype);
6273 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6274 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6275 }
6276
6277 free (imfs);
6278}
6279
6280/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6281
6282static void
6283dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6284{
6285 Elf64_External_VMS_IMAGE_RELA *imrs;
6286 long i;
6287
6288 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6289 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6290 _("dynamic section image relocations"));
28f997cf
TG		 6291 if (!imrs)
6292 return;
6293
6294 printf (_("\nImage relocs\n"));
6295 printf
6296 (_("Seg Offset Type Addend Seg Sym Off\n"));
6297
6298 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6299 {
6300 unsigned int type;
6301 const char *rtype;
6302
6303 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6304 printf ("%08" BFD_VMA_FMT "x ",
6305 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6306 type = BYTE_GET (imrs [i].type);
6307 rtype = elf_ia64_reloc_type (type);
6308 if (rtype == NULL)
6309 printf ("0x%08x ", type);
6310 else
6311 printf ("%-31s ", rtype);
6312 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6313 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6314 printf ("%08" BFD_VMA_FMT "x\n",
6315 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6316 }
6317
6318 free (imrs);
6319}
6320
6321/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6322
6323static int
6324process_ia64_vms_dynamic_relocs (FILE *file)
6325{
6326 struct ia64_vms_dynfixup fixup;
6327 struct ia64_vms_dynimgrela imgrela;
6328 Elf_Internal_Dyn *entry;
6329 int res = 0;
6330 bfd_vma strtab_off = 0;
6331 bfd_vma strtab_sz = 0;
6332 char *strtab = NULL;
6333
6334 memset (&fixup, 0, sizeof (fixup));
6335 memset (&imgrela, 0, sizeof (imgrela));
6336
6337 /* Note: the order of the entries is specified by the OpenVMS specs. */
6338 for (entry = dynamic_section;
6339 entry < dynamic_section + dynamic_nent;
6340 entry++)
6341 {
6342 switch (entry->d_tag)
6343 {
6344 case DT_IA_64_VMS_STRTAB_OFFSET:
6345 strtab_off = entry->d_un.d_val;
6346 break;
6347 case DT_STRSZ:
6348 strtab_sz = entry->d_un.d_val;
6349 if (strtab == NULL)
6350 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6351 1, strtab_sz, _("dynamic string section"));
6352 break;
6353
6354 case DT_IA_64_VMS_NEEDED_IDENT:
6355 fixup.needed_ident = entry->d_un.d_val;
6356 break;
6357 case DT_NEEDED:
6358 fixup.needed = entry->d_un.d_val;
6359 break;
6360 case DT_IA_64_VMS_FIXUP_NEEDED:
6361 fixup.fixup_needed = entry->d_un.d_val;
6362 break;
6363 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6364 fixup.fixup_rela_cnt = entry->d_un.d_val;
6365 break;
6366 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6367 fixup.fixup_rela_off = entry->d_un.d_val;
6368 res++;
6369 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6370 break;
6371
6372 case DT_IA_64_VMS_IMG_RELA_CNT:
6373 imgrela.img_rela_cnt = entry->d_un.d_val;
6374 break;
6375 case DT_IA_64_VMS_IMG_RELA_OFF:
6376 imgrela.img_rela_off = entry->d_un.d_val;
6377 res++;
6378 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6379 break;
6380
6381 default:
6382 break;
6383 }
6384 }
6385
6386 if (strtab != NULL)
6387 free (strtab);
6388
6389 return res;
6390}
6391
85b1c36d 6392static struct
566b0d53 6393{
2cf0635d 6394 const char * name;
566b0d53
L		 6395 int reloc;
6396 int size;
6397 int rela;
6398} dynamic_relocations [] =
6399{
6400 { "REL", DT_REL, DT_RELSZ, FALSE },
6401 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6402 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6403};
6404
252b5132 6405/* Process the reloc section. */
18bd398b 6406
252b5132 6407static int
2cf0635d 6408process_relocs (FILE * file)
252b5132 6409{
b34976b6
AM		 6410 unsigned long rel_size;
6411 unsigned long rel_offset;
252b5132
RH		 6412
6413
6414 if (!do_reloc)
6415 return 1;
6416
6417 if (do_using_dynamic)
6418 {
566b0d53 6419 int is_rela;
2cf0635d 6420 const char * name;
566b0d53
L		 6421 int has_dynamic_reloc;
6422 unsigned int i;
0de14b54 6423
566b0d53 6424 has_dynamic_reloc = 0;
252b5132 6425
566b0d53 6426 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6427 {
566b0d53
L		 6428 is_rela = dynamic_relocations [i].rela;
6429 name = dynamic_relocations [i].name;
6430 rel_size = dynamic_info [dynamic_relocations [i].size];
6431 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6432
566b0d53
L		 6433 has_dynamic_reloc |= rel_size;
6434
6435 if (is_rela == UNKNOWN)
aa903cfb 6436 {
566b0d53
L		 6437 if (dynamic_relocations [i].reloc == DT_JMPREL)
6438 switch (dynamic_info[DT_PLTREL])
6439 {
6440 case DT_REL:
6441 is_rela = FALSE;
6442 break;
6443 case DT_RELA:
6444 is_rela = TRUE;
6445 break;
6446 }
aa903cfb 6447 }
252b5132 6448
566b0d53
L		 6449 if (rel_size)
6450 {
6451 printf
6452 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6453 name, rel_offset, rel_size);
252b5132 6454
d93f0186
NC		 6455 dump_relocations (file,
6456 offset_from_vma (file, rel_offset, rel_size),
6457 rel_size,
566b0d53 6458 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6459 dynamic_strings, dynamic_strings_length,
6460 is_rela, 1);
566b0d53 6461 }
252b5132 6462 }
566b0d53 6463
28f997cf
TG		 6464 if (is_ia64_vms ())
6465 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6466
566b0d53 6467 if (! has_dynamic_reloc)
252b5132
RH		 6468 printf (_("\nThere are no dynamic relocations in this file.\n"));
6469 }
6470 else
6471 {
2cf0635d 6472 Elf_Internal_Shdr * section;
b34976b6
AM		 6473 unsigned long i;
6474 int found = 0;
252b5132
RH		 6475
6476 for (i = 0, section = section_headers;
6477 i < elf_header.e_shnum;
b34976b6 6478 i++, section++)
252b5132
RH		 6479 {
6480 if ( section->sh_type != SHT_RELA
6481 && section->sh_type != SHT_REL)
6482 continue;
6483
6484 rel_offset = section->sh_offset;
6485 rel_size = section->sh_size;
6486
6487 if (rel_size)
6488 {
2cf0635d 6489 Elf_Internal_Shdr * strsec;
b34976b6 6490 int is_rela;
103f02d3 6491
252b5132
RH		 6492 printf (_("\nRelocation section "));
6493
6494 if (string_table == NULL)
19936277 6495 printf ("%d", section->sh_name);
252b5132 6496 else
74e1a04b 6497 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6498
6499 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6500 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6501
d79b3d50
NC		 6502 is_rela = section->sh_type == SHT_RELA;
6503
4fbb74a6
AM		 6504 if (section->sh_link != 0
6505 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6506 {
2cf0635d
NC		 6507 Elf_Internal_Shdr * symsec;
6508 Elf_Internal_Sym * symtab;
d79b3d50 6509 unsigned long nsyms;
c256ffe7 6510 unsigned long strtablen = 0;
2cf0635d 6511 char * strtab = NULL;
57346661 6512
4fbb74a6 6513 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6514 if (symsec->sh_type != SHT_SYMTAB
6515 && symsec->sh_type != SHT_DYNSYM)
6516 continue;
6517
ba5cdace 6518 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6519
af3fc3bc
AM		 6520 if (symtab == NULL)
6521 continue;
252b5132 6522
4fbb74a6
AM		 6523 if (symsec->sh_link != 0
6524 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6525 {
4fbb74a6 6526 strsec = section_headers + symsec->sh_link;
103f02d3 6527
3f5e193b 6528 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6529 1, strsec->sh_size,
6530 _("string table"));
c256ffe7
JJ		 6531 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6532 }
252b5132 6533
d79b3d50 6534 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6535 symtab, nsyms, strtab, strtablen,
6536 is_rela,
6537 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6538 if (strtab)
6539 free (strtab);
6540 free (symtab);
6541 }
6542 else
6543 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6544 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6545
6546 found = 1;
6547 }
6548 }
6549
6550 if (! found)
6551 printf (_("\nThere are no relocations in this file.\n"));
6552 }
6553
6554 return 1;
6555}
6556
4d6ed7c8
NC		 6557/* An absolute address consists of a section and an offset. If the
6558 section is NULL, the offset itself is the address, otherwise, the
6559 address equals to LOAD_ADDRESS(section) + offset. */
6560
6561struct absaddr
948f632f
DA		 6562{
6563 unsigned short section;
6564 bfd_vma offset;
6565};
4d6ed7c8 6566
1949de15
L		 6567#define ABSADDR(a) \
6568 ((a).section \
6569 ? section_headers [(a).section].sh_addr + (a).offset \
6570 : (a).offset)
6571
948f632f
DA		 6572/* Find the nearest symbol at or below ADDR. Returns the symbol
6573 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6574
4d6ed7c8 6575static void
2cf0635d 6576find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6577 unsigned long nsyms,
6578 const char * strtab,
6579 unsigned long strtab_size,
6580 struct absaddr addr,
6581 const char ** symname,
6582 bfd_vma * offset)
4d6ed7c8 6583{
d3ba0551 6584 bfd_vma dist = 0x100000;
2cf0635d 6585 Elf_Internal_Sym * sym;
948f632f
DA		 6586 Elf_Internal_Sym * beg;
6587 Elf_Internal_Sym * end;
2cf0635d 6588 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6589
0b6ae522 6590 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6591 beg = symtab;
6592 end = symtab + nsyms;
0b6ae522 6593
948f632f 6594 while (beg < end)
4d6ed7c8 6595 {
948f632f
DA		 6596 bfd_vma value;
6597
6598 sym = beg + (end - beg) / 2;
0b6ae522 6599
948f632f 6600 value = sym->st_value;
0b6ae522
DJ		 6601 REMOVE_ARCH_BITS (value);
6602
948f632f 6603 if (sym->st_name != 0
4d6ed7c8 6604 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6605 && addr.offset >= value
6606 && addr.offset - value < dist)
4d6ed7c8
NC		 6607 {
6608 best = sym;
0b6ae522 6609 dist = addr.offset - value;
4d6ed7c8
NC		 6610 if (!dist)
6611 break;
6612 }
948f632f
DA		 6613
6614 if (addr.offset < value)
6615 end = sym;
6616 else
6617 beg = sym + 1;
4d6ed7c8 6618 }
1b31d05e 6619
4d6ed7c8
NC		 6620 if (best)
6621 {
57346661 6622 *symname = (best->st_name >= strtab_size
2b692964 6623 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6624 *offset = dist;
6625 return;
6626 }
1b31d05e 6627
4d6ed7c8
NC		 6628 *symname = NULL;
6629 *offset = addr.offset;
6630}
6631
948f632f
DA		 6632static int
6633symcmp (const void *p, const void *q)
6634{
6635 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6636 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6637
6638 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6639}
6640
6641/* Process the unwind section. */
6642
6643#include "unwind-ia64.h"
6644
6645struct ia64_unw_table_entry
6646{
6647 struct absaddr start;
6648 struct absaddr end;
6649 struct absaddr info;
6650};
6651
6652struct ia64_unw_aux_info
6653{
6654 struct ia64_unw_table_entry *table; /* Unwind table. */
6655 unsigned long table_len; /* Length of unwind table. */
6656 unsigned char * info; /* Unwind info. */
6657 unsigned long info_size; /* Size of unwind info. */
6658 bfd_vma info_addr; /* Starting address of unwind info. */
6659 bfd_vma seg_base; /* Starting address of segment. */
6660 Elf_Internal_Sym * symtab; /* The symbol table. */
6661 unsigned long nsyms; /* Number of symbols. */
6662 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6663 unsigned long nfuns; /* Number of entries in funtab. */
6664 char * strtab; /* The string table. */
6665 unsigned long strtab_size; /* Size of string table. */
6666};
6667
4d6ed7c8 6668static void
2cf0635d 6669dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6670{
2cf0635d 6671 struct ia64_unw_table_entry * tp;
948f632f 6672 unsigned long j, nfuns;
4d6ed7c8 6673 int in_body;
7036c0e1 6674
948f632f
DA		 6675 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6676 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6677 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6678 aux->funtab[nfuns++] = aux->symtab[j];
6679 aux->nfuns = nfuns;
6680 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6681
4d6ed7c8
NC		 6682 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6683 {
6684 bfd_vma stamp;
6685 bfd_vma offset;
2cf0635d
NC		 6686 const unsigned char * dp;
6687 const unsigned char * head;
53774b7e 6688 const unsigned char * end;
2cf0635d 6689 const char * procname;
4d6ed7c8 6690
948f632f 6691 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6692 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6693
6694 fputs ("\n<", stdout);
6695
6696 if (procname)
6697 {
6698 fputs (procname, stdout);
6699
6700 if (offset)
6701 printf ("+%lx", (unsigned long) offset);
6702 }
6703
6704 fputs (">: [", stdout);
6705 print_vma (tp->start.offset, PREFIX_HEX);
6706 fputc ('-', stdout);
6707 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6708 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6709 (unsigned long) (tp->info.offset - aux->seg_base));
6710
53774b7e
NC		 6711 /* PR 17531: file: 86232b32. */
6712 if (aux->info == NULL)
6713 continue;
6714
6715 /* PR 17531: file: 0997b4d1. */
6716 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6717 {
6718 warn (_("Invalid offset %lx in table entry %ld\n"),
6719 (long) tp->info.offset, (long) (tp - aux->table));
6720 continue;
6721 }
6722
1949de15 6723 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6724 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6725
86f55779 6726 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6727 (unsigned) UNW_VER (stamp),
6728 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6729 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6730 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6731 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6732
6733 if (UNW_VER (stamp) != 1)
6734 {
2b692964 6735 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6736 continue;
6737 }
6738
6739 in_body = 0;
53774b7e
NC		 6740 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6741 /* PR 17531: file: 16ceda89. */
6742 if (end > aux->info + aux->info_size)
6743 end = aux->info + aux->info_size;
6744 for (dp = head + 8; dp < end;)
b4477bc8 6745 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6746 }
948f632f
DA		 6747
6748 free (aux->funtab);
4d6ed7c8
NC		 6749}
6750
53774b7e 6751static bfd_boolean
2cf0635d
NC		 6752slurp_ia64_unwind_table (FILE * file,
6753 struct ia64_unw_aux_info * aux,
6754 Elf_Internal_Shdr * sec)
4d6ed7c8 6755{
89fac5e3 6756 unsigned long size, nrelas, i;
2cf0635d
NC		 6757 Elf_Internal_Phdr * seg;
6758 struct ia64_unw_table_entry * tep;
6759 Elf_Internal_Shdr * relsec;
6760 Elf_Internal_Rela * rela;
6761 Elf_Internal_Rela * rp;
6762 unsigned char * table;
6763 unsigned char * tp;
6764 Elf_Internal_Sym * sym;
6765 const char * relname;
4d6ed7c8 6766
53774b7e
NC		 6767 aux->table_len = 0;
6768
4d6ed7c8
NC		 6769 /* First, find the starting address of the segment that includes
6770 this section: */
6771
6772 if (elf_header.e_phnum)
6773 {
d93f0186 6774 if (! get_program_headers (file))
53774b7e 6775 return FALSE;
4d6ed7c8 6776
d93f0186
NC		 6777 for (seg = program_headers;
6778 seg < program_headers + elf_header.e_phnum;
6779 ++seg)
4d6ed7c8
NC		 6780 {
6781 if (seg->p_type != PT_LOAD)
6782 continue;
6783
6784 if (sec->sh_addr >= seg->p_vaddr
6785 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6786 {
6787 aux->seg_base = seg->p_vaddr;
6788 break;
6789 }
6790 }
4d6ed7c8
NC		 6791 }
6792
6793 /* Second, build the unwind table from the contents of the unwind section: */
6794 size = sec->sh_size;
3f5e193b
NC		 6795 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6796 _("unwind table"));
a6e9f9df 6797 if (!table)
53774b7e 6798 return FALSE;
4d6ed7c8 6799
53774b7e 6800 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6801 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6802 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6803 tep = aux->table;
53774b7e
NC		 6804
6805 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6806 {
6807 tep->start.section = SHN_UNDEF;
6808 tep->end.section = SHN_UNDEF;
6809 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6810 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6811 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6812 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6813 tep->start.offset += aux->seg_base;
6814 tep->end.offset += aux->seg_base;
6815 tep->info.offset += aux->seg_base;
6816 }
6817 free (table);
6818
41e92641 6819 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6820 for (relsec = section_headers;
6821 relsec < section_headers + elf_header.e_shnum;
6822 ++relsec)
6823 {
6824 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6825 || relsec->sh_info >= elf_header.e_shnum
6826 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6827 continue;
6828
6829 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6830 & rela, & nrelas))
53774b7e
NC		 6831 {
6832 free (aux->table);
6833 aux->table = NULL;
6834 aux->table_len = 0;
6835 return FALSE;
6836 }
4d6ed7c8
NC		 6837
6838 for (rp = rela; rp < rela + nrelas; ++rp)
6839 {
aca88567
NC		 6840 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6841 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6842
82b1b41b
NC		 6843 /* PR 17531: file: 9fa67536. */
6844 if (relname == NULL)
6845 {
6846 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6847 continue;
6848 }
948f632f 6849
0112cd26 6850 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6851 {
82b1b41b 6852 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6853 continue;
6854 }
6855
89fac5e3 6856 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6857
53774b7e
NC		 6858 /* PR 17531: file: 5bc8d9bf. */
6859 if (i >= aux->table_len)
6860 {
6861 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6862 continue;
6863 }
6864
6865 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6866 {
6867 case 0:
6868 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6869 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6870 break;
6871 case 1:
6872 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6873 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6874 break;
6875 case 2:
6876 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6877 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6878 break;
6879 default:
6880 break;
6881 }
6882 }
6883
6884 free (rela);
6885 }
6886
53774b7e 6887 return TRUE;
4d6ed7c8
NC		 6888}
6889
1b31d05e 6890static void
2cf0635d 6891ia64_process_unwind (FILE * file)
4d6ed7c8 6892{
2cf0635d
NC		 6893 Elf_Internal_Shdr * sec;
6894 Elf_Internal_Shdr * unwsec = NULL;
6895 Elf_Internal_Shdr * strsec;
89fac5e3 6896 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6897 struct ia64_unw_aux_info aux;
f1467e33 6898
4d6ed7c8
NC		 6899 memset (& aux, 0, sizeof (aux));
6900
4d6ed7c8
NC		 6901 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6902 {
c256ffe7 6903 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6904 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6905 {
ba5cdace 6906 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6907
4fbb74a6 6908 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6909 if (aux.strtab != NULL)
6910 {
6911 error (_("Multiple auxillary string tables encountered\n"));
6912 free (aux.strtab);
6913 }
3f5e193b
NC		 6914 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6915 1, strsec->sh_size,
6916 _("string table"));
c256ffe7 6917 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6918 }
6919 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6920 unwcount++;
6921 }
6922
6923 if (!unwcount)
6924 printf (_("\nThere are no unwind sections in this file.\n"));
6925
6926 while (unwcount-- > 0)
6927 {
2cf0635d 6928 char * suffix;
579f31ac
JJ		 6929 size_t len, len2;
6930
4082ef84 6931 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6932 i < elf_header.e_shnum; ++i, ++sec)
6933 if (sec->sh_type == SHT_IA_64_UNWIND)
6934 {
6935 unwsec = sec;
6936 break;
6937 }
4082ef84
NC		 6938 /* We have already counted the number of SHT_IA64_UNWIND
6939 sections so the loop above should never fail. */
6940 assert (unwsec != NULL);
579f31ac
JJ		 6941
6942 unwstart = i + 1;
6943 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6944
e4b17d5c
L		 6945 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6946 {
6947 /* We need to find which section group it is in. */
4082ef84 6948 struct group_list * g;
e4b17d5c 6949
4082ef84
NC		 6950 if (section_headers_groups == NULL
6951 || section_headers_groups [i] == NULL)
6952 i = elf_header.e_shnum;
6953 else
e4b17d5c 6954 {
4082ef84 6955 g = section_headers_groups [i]->root;
18bd398b 6956
4082ef84
NC		 6957 for (; g != NULL; g = g->next)
6958 {
6959 sec = section_headers + g->section_index;
e4b17d5c 6960
4082ef84
NC		 6961 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6962 break;
6963 }
6964
6965 if (g == NULL)
6966 i = elf_header.e_shnum;
6967 }
e4b17d5c 6968 }
18bd398b 6969 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6970 {
18bd398b 6971 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6972 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6973 suffix = SECTION_NAME (unwsec) + len;
6974 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6975 ++i, ++sec)
18bd398b
NC		 6976 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6977 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6978 break;
6979 }
6980 else
6981 {
6982 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6983 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6984 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6985 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6986 suffix = "";
18bd398b 6987 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6988 suffix = SECTION_NAME (unwsec) + len;
6989 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6990 ++i, ++sec)
18bd398b
NC		 6991 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6992 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6993 break;
6994 }
6995
6996 if (i == elf_header.e_shnum)
6997 {
6998 printf (_("\nCould not find unwind info section for "));
6999
7000 if (string_table == NULL)
7001 printf ("%d", unwsec->sh_name);
7002 else
74e1a04b 7003 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7004 }
7005 else
4d6ed7c8 7006 {
4d6ed7c8 7007 aux.info_addr = sec->sh_addr;
3f5e193b 7008 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7009 sec->sh_size,
7010 _("unwind info"));
59245841 7011 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7012
579f31ac 7013 printf (_("\nUnwind section "));
4d6ed7c8 7014
579f31ac
JJ		 7015 if (string_table == NULL)
7016 printf ("%d", unwsec->sh_name);
7017 else
74e1a04b 7018 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7019
579f31ac 7020 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7021 (unsigned long) unwsec->sh_offset,
89fac5e3 7022 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7023
53774b7e
NC		 7024 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7025 && aux.table_len > 0)
579f31ac
JJ		 7026 dump_ia64_unwind (& aux);
7027
7028 if (aux.table)
7029 free ((char *) aux.table);
7030 if (aux.info)
7031 free ((char *) aux.info);
7032 aux.table = NULL;
7033 aux.info = NULL;
7034 }
4d6ed7c8 7035 }
4d6ed7c8 7036
4d6ed7c8
NC		 7037 if (aux.symtab)
7038 free (aux.symtab);
7039 if (aux.strtab)
7040 free ((char *) aux.strtab);
4d6ed7c8
NC		 7041}
7042
3f5e193b
NC		 7043struct hppa_unw_table_entry
7044 {
7045 struct absaddr start;
7046 struct absaddr end;
948f632f 7047 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7048 unsigned int Millicode:1; /* 1 */
7049 unsigned int Millicode_save_sr0:1; /* 2 */
7050 unsigned int Region_description:2; /* 3..4 */
7051 unsigned int reserved1:1; /* 5 */
7052 unsigned int Entry_SR:1; /* 6 */
7053 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7054 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7055 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7056 unsigned int Variable_Frame:1; /* 17 */
7057 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7058 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7059 unsigned int Stack_Overflow_Check:1; /* 20 */
7060 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7061 unsigned int Ada_Region:1; /* 22 */
7062 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7063 unsigned int cxx_try_catch:1; /* 24 */
7064 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7065 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7066 unsigned int Save_SP:1; /* 27 */
7067 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7068 unsigned int Save_MRP_in_frame:1; /* 29 */
7069 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7070 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7071
948f632f
DA		 7072 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7073 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7074 unsigned int Large_frame:1; /* 2 */
948f632f 7075 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7076 unsigned int reserved4:1; /* 4 */
7077 unsigned int Total_frame_size:27; /* 5..31 */
7078 };
7079
57346661 7080struct hppa_unw_aux_info
948f632f
DA		 7081{
7082 struct hppa_unw_table_entry * table; /* Unwind table. */
7083 unsigned long table_len; /* Length of unwind table. */
7084 bfd_vma seg_base; /* Starting address of segment. */
7085 Elf_Internal_Sym * symtab; /* The symbol table. */
7086 unsigned long nsyms; /* Number of symbols. */
7087 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7088 unsigned long nfuns; /* Number of entries in funtab. */
7089 char * strtab; /* The string table. */
7090 unsigned long strtab_size; /* Size of string table. */
7091};
57346661
AM		 7092
7093static void
2cf0635d 7094dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7095{
2cf0635d 7096 struct hppa_unw_table_entry * tp;
948f632f
DA		 7097 unsigned long j, nfuns;
7098
7099 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7100 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7101 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7102 aux->funtab[nfuns++] = aux->symtab[j];
7103 aux->nfuns = nfuns;
7104 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7105
57346661
AM		 7106 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7107 {
7108 bfd_vma offset;
2cf0635d 7109 const char * procname;
57346661 7110
948f632f 7111 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7112 aux->strtab_size, tp->start, &procname,
7113 &offset);
7114
7115 fputs ("\n<", stdout);
7116
7117 if (procname)
7118 {
7119 fputs (procname, stdout);
7120
7121 if (offset)
7122 printf ("+%lx", (unsigned long) offset);
7123 }
7124
7125 fputs (">: [", stdout);
7126 print_vma (tp->start.offset, PREFIX_HEX);
7127 fputc ('-', stdout);
7128 print_vma (tp->end.offset, PREFIX_HEX);
7129 printf ("]\n\t");
7130
18bd398b
NC		 7131#define PF(_m) if (tp->_m) printf (#_m " ");
7132#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7133 PF(Cannot_unwind);
7134 PF(Millicode);
7135 PF(Millicode_save_sr0);
18bd398b 7136 /* PV(Region_description); */
57346661
AM		 7137 PF(Entry_SR);
7138 PV(Entry_FR);
7139 PV(Entry_GR);
7140 PF(Args_stored);
7141 PF(Variable_Frame);
7142 PF(Separate_Package_Body);
7143 PF(Frame_Extension_Millicode);
7144 PF(Stack_Overflow_Check);
7145 PF(Two_Instruction_SP_Increment);
7146 PF(Ada_Region);
7147 PF(cxx_info);
7148 PF(cxx_try_catch);
7149 PF(sched_entry_seq);
7150 PF(Save_SP);
7151 PF(Save_RP);
7152 PF(Save_MRP_in_frame);
7153 PF(extn_ptr_defined);
7154 PF(Cleanup_defined);
7155 PF(MPE_XL_interrupt_marker);
7156 PF(HP_UX_interrupt_marker);
7157 PF(Large_frame);
7158 PF(Pseudo_SP_Set);
7159 PV(Total_frame_size);
7160#undef PF
7161#undef PV
7162 }
7163
18bd398b 7164 printf ("\n");
948f632f
DA		 7165
7166 free (aux->funtab);
57346661
AM		 7167}
7168
7169static int
2cf0635d
NC		 7170slurp_hppa_unwind_table (FILE * file,
7171 struct hppa_unw_aux_info * aux,
7172 Elf_Internal_Shdr * sec)
57346661 7173{
1c0751b2 7174 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7175 Elf_Internal_Phdr * seg;
7176 struct hppa_unw_table_entry * tep;
7177 Elf_Internal_Shdr * relsec;
7178 Elf_Internal_Rela * rela;
7179 Elf_Internal_Rela * rp;
7180 unsigned char * table;
7181 unsigned char * tp;
7182 Elf_Internal_Sym * sym;
7183 const char * relname;
57346661 7184
57346661
AM		 7185 /* First, find the starting address of the segment that includes
7186 this section. */
7187
7188 if (elf_header.e_phnum)
7189 {
7190 if (! get_program_headers (file))
7191 return 0;
7192
7193 for (seg = program_headers;
7194 seg < program_headers + elf_header.e_phnum;
7195 ++seg)
7196 {
7197 if (seg->p_type != PT_LOAD)
7198 continue;
7199
7200 if (sec->sh_addr >= seg->p_vaddr
7201 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7202 {
7203 aux->seg_base = seg->p_vaddr;
7204 break;
7205 }
7206 }
7207 }
7208
7209 /* Second, build the unwind table from the contents of the unwind
7210 section. */
7211 size = sec->sh_size;
3f5e193b
NC		 7212 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7213 _("unwind table"));
57346661
AM		 7214 if (!table)
7215 return 0;
7216
1c0751b2
DA		 7217 unw_ent_size = 16;
7218 nentries = size / unw_ent_size;
7219 size = unw_ent_size * nentries;
57346661 7220
3f5e193b
NC		 7221 tep = aux->table = (struct hppa_unw_table_entry *)
7222 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7223
1c0751b2 7224 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7225 {
7226 unsigned int tmp1, tmp2;
7227
7228 tep->start.section = SHN_UNDEF;
7229 tep->end.section = SHN_UNDEF;
7230
1c0751b2
DA		 7231 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7232 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7233 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7234 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7235
7236 tep->start.offset += aux->seg_base;
7237 tep->end.offset += aux->seg_base;
57346661
AM		 7238
7239 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7240 tep->Millicode = (tmp1 >> 30) & 0x1;
7241 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7242 tep->Region_description = (tmp1 >> 27) & 0x3;
7243 tep->reserved1 = (tmp1 >> 26) & 0x1;
7244 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7245 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7246 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7247 tep->Args_stored = (tmp1 >> 15) & 0x1;
7248 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7249 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7250 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7251 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7252 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7253 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7254 tep->cxx_info = (tmp1 >> 8) & 0x1;
7255 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7256 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7257 tep->reserved2 = (tmp1 >> 5) & 0x1;
7258 tep->Save_SP = (tmp1 >> 4) & 0x1;
7259 tep->Save_RP = (tmp1 >> 3) & 0x1;
7260 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7261 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7262 tep->Cleanup_defined = tmp1 & 0x1;
7263
7264 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7265 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7266 tep->Large_frame = (tmp2 >> 29) & 0x1;
7267 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7268 tep->reserved4 = (tmp2 >> 27) & 0x1;
7269 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7270 }
7271 free (table);
7272
7273 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7274 for (relsec = section_headers;
7275 relsec < section_headers + elf_header.e_shnum;
7276 ++relsec)
7277 {
7278 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7279 || relsec->sh_info >= elf_header.e_shnum
7280 || section_headers + relsec->sh_info != sec)
57346661
AM		 7281 continue;
7282
7283 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7284 & rela, & nrelas))
7285 return 0;
7286
7287 for (rp = rela; rp < rela + nrelas; ++rp)
7288 {
aca88567
NC		 7289 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7290 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7291
7292 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7293 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7294 {
7295 warn (_("Skipping unexpected relocation type %s\n"), relname);
7296 continue;
7297 }
7298
7299 i = rp->r_offset / unw_ent_size;
7300
89fac5e3 7301 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7302 {
7303 case 0:
7304 aux->table[i].start.section = sym->st_shndx;
1e456d54 7305 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7306 break;
7307 case 1:
7308 aux->table[i].end.section = sym->st_shndx;
1e456d54 7309 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7310 break;
7311 default:
7312 break;
7313 }
7314 }
7315
7316 free (rela);
7317 }
7318
1c0751b2 7319 aux->table_len = nentries;
57346661
AM		 7320
7321 return 1;
7322}
7323
1b31d05e 7324static void
2cf0635d 7325hppa_process_unwind (FILE * file)
57346661 7326{
57346661 7327 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7328 Elf_Internal_Shdr * unwsec = NULL;
7329 Elf_Internal_Shdr * strsec;
7330 Elf_Internal_Shdr * sec;
18bd398b 7331 unsigned long i;
57346661 7332
c256ffe7 7333 if (string_table == NULL)
1b31d05e
NC		 7334 return;
7335
7336 memset (& aux, 0, sizeof (aux));
57346661
AM		 7337
7338 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7339 {
c256ffe7 7340 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7341 && sec->sh_link < elf_header.e_shnum)
57346661 7342 {
ba5cdace 7343 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7344
4fbb74a6 7345 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7346 if (aux.strtab != NULL)
7347 {
7348 error (_("Multiple auxillary string tables encountered\n"));
7349 free (aux.strtab);
7350 }
3f5e193b
NC		 7351 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7352 1, strsec->sh_size,
7353 _("string table"));
c256ffe7 7354 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7355 }
18bd398b 7356 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7357 unwsec = sec;
7358 }
7359
7360 if (!unwsec)
7361 printf (_("\nThere are no unwind sections in this file.\n"));
7362
7363 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7364 {
18bd398b 7365 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7366 {
74e1a04b
NC		 7367 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7368 printable_section_name (sec),
57346661 7369 (unsigned long) sec->sh_offset,
89fac5e3 7370 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7371
7372 slurp_hppa_unwind_table (file, &aux, sec);
7373 if (aux.table_len > 0)
7374 dump_hppa_unwind (&aux);
7375
7376 if (aux.table)
7377 free ((char *) aux.table);
7378 aux.table = NULL;
7379 }
7380 }
7381
7382 if (aux.symtab)
7383 free (aux.symtab);
7384 if (aux.strtab)
7385 free ((char *) aux.strtab);
57346661
AM		 7386}
7387
0b6ae522
DJ		 7388struct arm_section
7389{
a734115a
NC		 7390 unsigned char * data; /* The unwind data. */
7391 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7392 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7393 unsigned long nrelas; /* The number of relocations. */
7394 unsigned int rel_type; /* REL or RELA ? */
7395 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7396};
7397
7398struct arm_unw_aux_info
7399{
a734115a
NC		 7400 FILE * file; /* The file containing the unwind sections. */
7401 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7402 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7403 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7404 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7405 char * strtab; /* The file's string table. */
7406 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7407};
7408
7409static const char *
7410arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7411 bfd_vma fn, struct absaddr addr)
7412{
7413 const char *procname;
7414 bfd_vma sym_offset;
7415
7416 if (addr.section == SHN_UNDEF)
7417 addr.offset = fn;
7418
948f632f 7419 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7420 aux->strtab_size, addr, &procname,
7421 &sym_offset);
7422
7423 print_vma (fn, PREFIX_HEX);
7424
7425 if (procname)
7426 {
7427 fputs (" <", stdout);
7428 fputs (procname, stdout);
7429
7430 if (sym_offset)
7431 printf ("+0x%lx", (unsigned long) sym_offset);
7432 fputc ('>', stdout);
7433 }
7434
7435 return procname;
7436}
7437
7438static void
7439arm_free_section (struct arm_section *arm_sec)
7440{
7441 if (arm_sec->data != NULL)
7442 free (arm_sec->data);
7443
7444 if (arm_sec->rela != NULL)
7445 free (arm_sec->rela);
7446}
7447
a734115a
NC		 7448/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7449 cached section and install SEC instead.
7450 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7451 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7452 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7453 relocation's offset in ADDR.
1b31d05e
NC		 7454 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7455 into the string table of the symbol associated with the reloc. If no
7456 reloc was applied store -1 there.
7457 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7458
7459static bfd_boolean
1b31d05e
NC		 7460get_unwind_section_word (struct arm_unw_aux_info * aux,
7461 struct arm_section * arm_sec,
7462 Elf_Internal_Shdr * sec,
7463 bfd_vma word_offset,
7464 unsigned int * wordp,
7465 struct absaddr * addr,
7466 bfd_vma * sym_name)
0b6ae522
DJ		 7467{
7468 Elf_Internal_Rela *rp;
7469 Elf_Internal_Sym *sym;
7470 const char * relname;
7471 unsigned int word;
7472 bfd_boolean wrapped;
7473
e0a31db1
NC		 7474 if (sec == NULL || arm_sec == NULL)
7475 return FALSE;
7476
0b6ae522
DJ		 7477 addr->section = SHN_UNDEF;
7478 addr->offset = 0;
7479
1b31d05e
NC		 7480 if (sym_name != NULL)
7481 *sym_name = (bfd_vma) -1;
7482
a734115a 7483 /* If necessary, update the section cache. */
0b6ae522
DJ		 7484 if (sec != arm_sec->sec)
7485 {
7486 Elf_Internal_Shdr *relsec;
7487
7488 arm_free_section (arm_sec);
7489
7490 arm_sec->sec = sec;
7491 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7492 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7493 arm_sec->rela = NULL;
7494 arm_sec->nrelas = 0;
7495
7496 for (relsec = section_headers;
7497 relsec < section_headers + elf_header.e_shnum;
7498 ++relsec)
7499 {
7500 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7501 || section_headers + relsec->sh_info != sec
7502 /* PR 15745: Check the section type as well. */
7503 || (relsec->sh_type != SHT_REL
7504 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7505 continue;
7506
a734115a 7507 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7508 if (relsec->sh_type == SHT_REL)
7509 {
7510 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7511 relsec->sh_size,
7512 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7513 return FALSE;
0b6ae522 7514 }
1ae40aa4 7515 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7516 {
7517 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7518 relsec->sh_size,
7519 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7520 return FALSE;
0b6ae522 7521 }
1ae40aa4 7522 break;
0b6ae522
DJ		 7523 }
7524
7525 arm_sec->next_rela = arm_sec->rela;
7526 }
7527
a734115a 7528 /* If there is no unwind data we can do nothing. */
0b6ae522 7529 if (arm_sec->data == NULL)
a734115a 7530 return FALSE;
0b6ae522 7531
e0a31db1 7532 /* If the offset is invalid then fail. */
1a915552
NC		 7533 if (word_offset > (sec->sh_size - 4)
7534 /* PR 18879 */
7535 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7536 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7537 return FALSE;
7538
a734115a 7539 /* Get the word at the required offset. */
0b6ae522
DJ		 7540 word = byte_get (arm_sec->data + word_offset, 4);
7541
0eff7165
NC		 7542 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7543 if (arm_sec->rela == NULL)
7544 {
7545 * wordp = word;
7546 return TRUE;
7547 }
7548
a734115a 7549 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7550 wrapped = FALSE;
7551 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7552 {
7553 bfd_vma prelval, offset;
7554
7555 if (rp->r_offset > word_offset && !wrapped)
7556 {
7557 rp = arm_sec->rela;
7558 wrapped = TRUE;
7559 }
7560 if (rp->r_offset > word_offset)
7561 break;
7562
7563 if (rp->r_offset & 3)
7564 {
7565 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7566 (unsigned long) rp->r_offset);
7567 continue;
7568 }
7569
7570 if (rp->r_offset < word_offset)
7571 continue;
7572
74e1a04b
NC		 7573 /* PR 17531: file: 027-161405-0.004 */
7574 if (aux->symtab == NULL)
7575 continue;
7576
0b6ae522
DJ		 7577 if (arm_sec->rel_type == SHT_REL)
7578 {
7579 offset = word & 0x7fffffff;
7580 if (offset & 0x40000000)
7581 offset |= ~ (bfd_vma) 0x7fffffff;
7582 }
a734115a 7583 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7584 offset = rp->r_addend;
a734115a 7585 else
74e1a04b
NC		 7586 {
7587 error (_("Unknown section relocation type %d encountered\n"),
7588 arm_sec->rel_type);
7589 break;
7590 }
0b6ae522 7591
071436c6
NC		 7592 /* PR 17531 file: 027-1241568-0.004. */
7593 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7594 {
7595 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7596 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7597 break;
7598 }
7599
7600 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7601 offset += sym->st_value;
7602 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7603
a734115a
NC		 7604 /* Check that we are processing the expected reloc type. */
7605 if (elf_header.e_machine == EM_ARM)
7606 {
7607 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7608 if (relname == NULL)
7609 {
7610 warn (_("Skipping unknown ARM relocation type: %d\n"),
7611 (int) ELF32_R_TYPE (rp->r_info));
7612 continue;
7613 }
a734115a
NC		 7614
7615 if (streq (relname, "R_ARM_NONE"))
7616 continue;
0b4362b0 7617
a734115a
NC		 7618 if (! streq (relname, "R_ARM_PREL31"))
7619 {
071436c6 7620 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7621 continue;
7622 }
7623 }
7624 else if (elf_header.e_machine == EM_TI_C6000)
7625 {
7626 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7627 if (relname == NULL)
7628 {
7629 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7630 (int) ELF32_R_TYPE (rp->r_info));
7631 continue;
7632 }
0b4362b0 7633
a734115a
NC		 7634 if (streq (relname, "R_C6000_NONE"))
7635 continue;
7636
7637 if (! streq (relname, "R_C6000_PREL31"))
7638 {
071436c6 7639 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7640 continue;
7641 }
7642
7643 prelval >>= 1;
7644 }
7645 else
74e1a04b
NC		 7646 {
7647 /* This function currently only supports ARM and TI unwinders. */
7648 warn (_("Only TI and ARM unwinders are currently supported\n"));
7649 break;
7650 }
fa197c1c 7651
0b6ae522
DJ		 7652 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7653 addr->section = sym->st_shndx;
7654 addr->offset = offset;
74e1a04b 7655
1b31d05e
NC		 7656 if (sym_name)
7657 * sym_name = sym->st_name;
0b6ae522
DJ		 7658 break;
7659 }
7660
7661 *wordp = word;
7662 arm_sec->next_rela = rp;
7663
a734115a 7664 return TRUE;
0b6ae522
DJ		 7665}
7666
a734115a
NC		 7667static const char *tic6x_unwind_regnames[16] =
7668{
0b4362b0
RM		 7669 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7670 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7671 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7672};
fa197c1c 7673
0b6ae522 7674static void
fa197c1c 7675decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7676{
fa197c1c
PB		 7677 int i;
7678
7679 for (i = 12; mask; mask >>= 1, i--)
7680 {
7681 if (mask & 1)
7682 {
7683 fputs (tic6x_unwind_regnames[i], stdout);
7684 if (mask > 1)
7685 fputs (", ", stdout);
7686 }
7687 }
7688}
0b6ae522
DJ		 7689
7690#define ADVANCE \
7691 if (remaining == 0 && more_words) \
7692 { \
7693 data_offset += 4; \
1b31d05e
NC		 7694 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7695 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7696 return; \
7697 remaining = 4; \
7698 more_words--; \
7699 } \
7700
7701#define GET_OP(OP) \
7702 ADVANCE; \
7703 if (remaining) \
7704 { \
7705 remaining--; \
7706 (OP) = word >> 24; \
7707 word <<= 8; \
7708 } \
7709 else \
7710 { \
2b692964 7711 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7712 return; \
7713 } \
cc5914eb 7714 printf ("0x%02x ", OP)
0b6ae522 7715
fa197c1c 7716static void
948f632f
DA		 7717decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7718 unsigned int word,
7719 unsigned int remaining,
7720 unsigned int more_words,
7721 bfd_vma data_offset,
7722 Elf_Internal_Shdr * data_sec,
7723 struct arm_section * data_arm_sec)
fa197c1c
PB		 7724{
7725 struct absaddr addr;
0b6ae522
DJ		 7726
7727 /* Decode the unwinding instructions. */
7728 while (1)
7729 {
7730 unsigned int op, op2;
7731
7732 ADVANCE;
7733 if (remaining == 0)
7734 break;
7735 remaining--;
7736 op = word >> 24;
7737 word <<= 8;
7738
cc5914eb 7739 printf (" 0x%02x ", op);
0b6ae522
DJ		 7740
7741 if ((op & 0xc0) == 0x00)
7742 {
7743 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7744
cc5914eb 7745 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7746 }
7747 else if ((op & 0xc0) == 0x40)
7748 {
7749 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7750
cc5914eb 7751 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7752 }
7753 else if ((op & 0xf0) == 0x80)
7754 {
7755 GET_OP (op2);
7756 if (op == 0x80 && op2 == 0)
7757 printf (_("Refuse to unwind"));
7758 else
7759 {
7760 unsigned int mask = ((op & 0x0f) << 8) | op2;
7761 int first = 1;
7762 int i;
2b692964 7763
0b6ae522
DJ		 7764 printf ("pop {");
7765 for (i = 0; i < 12; i++)
7766 if (mask & (1 << i))
7767 {
7768 if (first)
7769 first = 0;
7770 else
7771 printf (", ");
7772 printf ("r%d", 4 + i);
7773 }
7774 printf ("}");
7775 }
7776 }
7777 else if ((op & 0xf0) == 0x90)
7778 {
7779 if (op == 0x9d || op == 0x9f)
7780 printf (_(" [Reserved]"));
7781 else
cc5914eb 7782 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7783 }
7784 else if ((op & 0xf0) == 0xa0)
7785 {
7786 int end = 4 + (op & 0x07);
7787 int first = 1;
7788 int i;
61865e30 7789
0b6ae522
DJ		 7790 printf (" pop {");
7791 for (i = 4; i <= end; i++)
7792 {
7793 if (first)
7794 first = 0;
7795 else
7796 printf (", ");
7797 printf ("r%d", i);
7798 }
7799 if (op & 0x08)
7800 {
1b31d05e 7801 if (!first)
0b6ae522
DJ		 7802 printf (", ");
7803 printf ("r14");
7804 }
7805 printf ("}");
7806 }
7807 else if (op == 0xb0)
7808 printf (_(" finish"));
7809 else if (op == 0xb1)
7810 {
7811 GET_OP (op2);
7812 if (op2 == 0 || (op2 & 0xf0) != 0)
7813 printf (_("[Spare]"));
7814 else
7815 {
7816 unsigned int mask = op2 & 0x0f;
7817 int first = 1;
7818 int i;
61865e30 7819
0b6ae522
DJ		 7820 printf ("pop {");
7821 for (i = 0; i < 12; i++)
7822 if (mask & (1 << i))
7823 {
7824 if (first)
7825 first = 0;
7826 else
7827 printf (", ");
7828 printf ("r%d", i);
7829 }
7830 printf ("}");
7831 }
7832 }
7833 else if (op == 0xb2)
7834 {
b115cf96 7835 unsigned char buf[9];
0b6ae522
DJ		 7836 unsigned int i, len;
7837 unsigned long offset;
61865e30 7838
b115cf96 7839 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7840 {
7841 GET_OP (buf[i]);
7842 if ((buf[i] & 0x80) == 0)
7843 break;
7844 }
4082ef84
NC		 7845 if (i == sizeof (buf))
7846 printf (_("corrupt change to vsp"));
7847 else
7848 {
7849 offset = read_uleb128 (buf, &len, buf + i + 1);
7850 assert (len == i + 1);
7851 offset = offset * 4 + 0x204;
7852 printf ("vsp = vsp + %ld", offset);
7853 }
0b6ae522 7854 }
61865e30 7855 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7856 {
61865e30
NC		 7857 unsigned int first, last;
7858
7859 GET_OP (op2);
7860 first = op2 >> 4;
7861 last = op2 & 0x0f;
7862 if (op == 0xc8)
7863 first = first + 16;
7864 printf ("pop {D%d", first);
7865 if (last)
7866 printf ("-D%d", first + last);
7867 printf ("}");
7868 }
7869 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7870 {
7871 unsigned int count = op & 0x07;
7872
7873 printf ("pop {D8");
7874 if (count)
7875 printf ("-D%d", 8 + count);
7876 printf ("}");
7877 }
7878 else if (op >= 0xc0 && op <= 0xc5)
7879 {
7880 unsigned int count = op & 0x07;
7881
7882 printf (" pop {wR10");
7883 if (count)
7884 printf ("-wR%d", 10 + count);
7885 printf ("}");
7886 }
7887 else if (op == 0xc6)
7888 {
7889 unsigned int first, last;
7890
7891 GET_OP (op2);
7892 first = op2 >> 4;
7893 last = op2 & 0x0f;
7894 printf ("pop {wR%d", first);
7895 if (last)
7896 printf ("-wR%d", first + last);
7897 printf ("}");
7898 }
7899 else if (op == 0xc7)
7900 {
7901 GET_OP (op2);
7902 if (op2 == 0 || (op2 & 0xf0) != 0)
7903 printf (_("[Spare]"));
0b6ae522
DJ		 7904 else
7905 {
61865e30
NC		 7906 unsigned int mask = op2 & 0x0f;
7907 int first = 1;
7908 int i;
7909
7910 printf ("pop {");
7911 for (i = 0; i < 4; i++)
7912 if (mask & (1 << i))
7913 {
7914 if (first)
7915 first = 0;
7916 else
7917 printf (", ");
7918 printf ("wCGR%d", i);
7919 }
7920 printf ("}");
0b6ae522
DJ		 7921 }
7922 }
61865e30
NC		 7923 else
7924 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7925 printf ("\n");
7926 }
fa197c1c
PB		 7927}
7928
7929static void
948f632f
DA		 7930decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7931 unsigned int word,
7932 unsigned int remaining,
7933 unsigned int more_words,
7934 bfd_vma data_offset,
7935 Elf_Internal_Shdr * data_sec,
7936 struct arm_section * data_arm_sec)
fa197c1c
PB		 7937{
7938 struct absaddr addr;
7939
7940 /* Decode the unwinding instructions. */
7941 while (1)
7942 {
7943 unsigned int op, op2;
7944
7945 ADVANCE;
7946 if (remaining == 0)
7947 break;
7948 remaining--;
7949 op = word >> 24;
7950 word <<= 8;
7951
9cf03b7e 7952 printf (" 0x%02x ", op);
fa197c1c
PB		 7953
7954 if ((op & 0xc0) == 0x00)
7955 {
7956 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7957 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7958 }
7959 else if ((op & 0xc0) == 0x80)
7960 {
7961 GET_OP (op2);
7962 if (op == 0x80 && op2 == 0)
7963 printf (_("Refuse to unwind"));
7964 else
7965 {
7966 unsigned int mask = ((op & 0x1f) << 8) | op2;
7967 if (op & 0x20)
7968 printf ("pop compact {");
7969 else
7970 printf ("pop {");
7971
7972 decode_tic6x_unwind_regmask (mask);
7973 printf("}");
7974 }
7975 }
7976 else if ((op & 0xf0) == 0xc0)
7977 {
7978 unsigned int reg;
7979 unsigned int nregs;
7980 unsigned int i;
7981 const char *name;
a734115a
NC		 7982 struct
7983 {
fa197c1c
PB		 7984 unsigned int offset;
7985 unsigned int reg;
7986 } regpos[16];
7987
7988 /* Scan entire instruction first so that GET_OP output is not
7989 interleaved with disassembly. */
7990 nregs = 0;
7991 for (i = 0; nregs < (op & 0xf); i++)
7992 {
7993 GET_OP (op2);
7994 reg = op2 >> 4;
7995 if (reg != 0xf)
7996 {
7997 regpos[nregs].offset = i * 2;
7998 regpos[nregs].reg = reg;
7999 nregs++;
8000 }
8001
8002 reg = op2 & 0xf;
8003 if (reg != 0xf)
8004 {
8005 regpos[nregs].offset = i * 2 + 1;
8006 regpos[nregs].reg = reg;
8007 nregs++;
8008 }
8009 }
8010
8011 printf (_("pop frame {"));
8012 reg = nregs - 1;
8013 for (i = i * 2; i > 0; i--)
8014 {
8015 if (regpos[reg].offset == i - 1)
8016 {
8017 name = tic6x_unwind_regnames[regpos[reg].reg];
8018 if (reg > 0)
8019 reg--;
8020 }
8021 else
8022 name = _("[pad]");
8023
8024 fputs (name, stdout);
8025 if (i > 1)
8026 printf (", ");
8027 }
8028
8029 printf ("}");
8030 }
8031 else if (op == 0xd0)
8032 printf (" MOV FP, SP");
8033 else if (op == 0xd1)
8034 printf (" __c6xabi_pop_rts");
8035 else if (op == 0xd2)
8036 {
8037 unsigned char buf[9];
8038 unsigned int i, len;
8039 unsigned long offset;
a734115a 8040
fa197c1c
PB		 8041 for (i = 0; i < sizeof (buf); i++)
8042 {
8043 GET_OP (buf[i]);
8044 if ((buf[i] & 0x80) == 0)
8045 break;
8046 }
0eff7165
NC		 8047 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8048 if (i == sizeof (buf))
8049 {
8050 printf ("<corrupt sp adjust>\n");
8051 warn (_("Corrupt stack pointer adjustment detected\n"));
8052 return;
8053 }
948f632f 8054
f6f0e17b 8055 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8056 assert (len == i + 1);
8057 offset = offset * 8 + 0x408;
8058 printf (_("sp = sp + %ld"), offset);
8059 }
8060 else if ((op & 0xf0) == 0xe0)
8061 {
8062 if ((op & 0x0f) == 7)
8063 printf (" RETURN");
8064 else
8065 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8066 }
8067 else
8068 {
8069 printf (_(" [unsupported opcode]"));
8070 }
8071 putchar ('\n');
8072 }
8073}
8074
8075static bfd_vma
a734115a 8076arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8077{
8078 bfd_vma offset;
8079
8080 offset = word & 0x7fffffff;
8081 if (offset & 0x40000000)
8082 offset |= ~ (bfd_vma) 0x7fffffff;
8083
8084 if (elf_header.e_machine == EM_TI_C6000)
8085 offset <<= 1;
8086
8087 return offset + where;
8088}
8089
8090static void
1b31d05e
NC		 8091decode_arm_unwind (struct arm_unw_aux_info * aux,
8092 unsigned int word,
8093 unsigned int remaining,
8094 bfd_vma data_offset,
8095 Elf_Internal_Shdr * data_sec,
8096 struct arm_section * data_arm_sec)
fa197c1c
PB		 8097{
8098 int per_index;
8099 unsigned int more_words = 0;
37e14bc3 8100 struct absaddr addr;
1b31d05e 8101 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8102
8103 if (remaining == 0)
8104 {
1b31d05e
NC		 8105 /* Fetch the first word.
8106 Note - when decoding an object file the address extracted
8107 here will always be 0. So we also pass in the sym_name
8108 parameter so that we can find the symbol associated with
8109 the personality routine. */
8110 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8111 & word, & addr, & sym_name))
fa197c1c 8112 return;
1b31d05e 8113
fa197c1c
PB		 8114 remaining = 4;
8115 }
8116
8117 if ((word & 0x80000000) == 0)
8118 {
8119 /* Expand prel31 for personality routine. */
8120 bfd_vma fn;
8121 const char *procname;
8122
a734115a 8123 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8124 printf (_(" Personality routine: "));
1b31d05e
NC		 8125 if (fn == 0
8126 && addr.section == SHN_UNDEF && addr.offset == 0
8127 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8128 {
8129 procname = aux->strtab + sym_name;
8130 print_vma (fn, PREFIX_HEX);
8131 if (procname)
8132 {
8133 fputs (" <", stdout);
8134 fputs (procname, stdout);
8135 fputc ('>', stdout);
8136 }
8137 }
8138 else
8139 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8140 fputc ('\n', stdout);
8141
8142 /* The GCC personality routines use the standard compact
8143 encoding, starting with one byte giving the number of
8144 words. */
8145 if (procname != NULL
8146 && (const_strneq (procname, "__gcc_personality_v0")
8147 || const_strneq (procname, "__gxx_personality_v0")
8148 || const_strneq (procname, "__gcj_personality_v0")
8149 || const_strneq (procname, "__gnu_objc_personality_v0")))
8150 {
8151 remaining = 0;
8152 more_words = 1;
8153 ADVANCE;
8154 if (!remaining)
8155 {
8156 printf (_(" [Truncated data]\n"));
8157 return;
8158 }
8159 more_words = word >> 24;
8160 word <<= 8;
8161 remaining--;
8162 per_index = -1;
8163 }
8164 else
8165 return;
8166 }
8167 else
8168 {
1b31d05e 8169 /* ARM EHABI Section 6.3:
0b4362b0 8170
1b31d05e 8171 An exception-handling table entry for the compact model looks like:
0b4362b0 8172
1b31d05e
NC		 8173 31 30-28 27-24 23-0
8174 -- ----- ----- ----
8175 1 0 index Data for personalityRoutine[index] */
8176
8177 if (elf_header.e_machine == EM_ARM
8178 && (word & 0x70000000))
83c257ca 8179 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8180
fa197c1c 8181 per_index = (word >> 24) & 0x7f;
1b31d05e 8182 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8183 if (per_index == 0)
8184 {
8185 more_words = 0;
8186 word <<= 8;
8187 remaining--;
8188 }
8189 else if (per_index < 3)
8190 {
8191 more_words = (word >> 16) & 0xff;
8192 word <<= 16;
8193 remaining -= 2;
8194 }
8195 }
8196
8197 switch (elf_header.e_machine)
8198 {
8199 case EM_ARM:
8200 if (per_index < 3)
8201 {
8202 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8203 data_offset, data_sec, data_arm_sec);
8204 }
8205 else
1b31d05e
NC		 8206 {
8207 warn (_("Unknown ARM compact model index encountered\n"));
8208 printf (_(" [reserved]\n"));
8209 }
fa197c1c
PB		 8210 break;
8211
8212 case EM_TI_C6000:
8213 if (per_index < 3)
8214 {
8215 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8216 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8217 }
8218 else if (per_index < 5)
8219 {
8220 if (((word >> 17) & 0x7f) == 0x7f)
8221 printf (_(" Restore stack from frame pointer\n"));
8222 else
8223 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8224 printf (_(" Registers restored: "));
8225 if (per_index == 4)
8226 printf (" (compact) ");
8227 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8228 putchar ('\n');
8229 printf (_(" Return register: %s\n"),
8230 tic6x_unwind_regnames[word & 0xf]);
8231 }
8232 else
1b31d05e 8233 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8234 break;
8235
8236 default:
74e1a04b 8237 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8238 elf_header.e_machine);
fa197c1c 8239 }
0b6ae522
DJ		 8240
8241 /* Decode the descriptors. Not implemented. */
8242}
8243
8244static void
8245dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8246{
8247 struct arm_section exidx_arm_sec, extab_arm_sec;
8248 unsigned int i, exidx_len;
948f632f 8249 unsigned long j, nfuns;
0b6ae522
DJ		 8250
8251 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8252 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8253 exidx_len = exidx_sec->sh_size / 8;
8254
948f632f
DA		 8255 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8256 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8257 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8258 aux->funtab[nfuns++] = aux->symtab[j];
8259 aux->nfuns = nfuns;
8260 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8261
0b6ae522
DJ		 8262 for (i = 0; i < exidx_len; i++)
8263 {
8264 unsigned int exidx_fn, exidx_entry;
8265 struct absaddr fn_addr, entry_addr;
8266 bfd_vma fn;
8267
8268 fputc ('\n', stdout);
8269
1b31d05e
NC		 8270 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8271 8 * i, & exidx_fn, & fn_addr, NULL)
8272 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8273 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8274 {
948f632f 8275 free (aux->funtab);
1b31d05e
NC		 8276 arm_free_section (& exidx_arm_sec);
8277 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8278 return;
8279 }
8280
83c257ca
NC		 8281 /* ARM EHABI, Section 5:
8282 An index table entry consists of 2 words.
8283 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8284 if (exidx_fn & 0x80000000)
8285 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8286
a734115a 8287 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8288
a734115a 8289 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8290 fputs (": ", stdout);
8291
8292 if (exidx_entry == 1)
8293 {
8294 print_vma (exidx_entry, PREFIX_HEX);
8295 fputs (" [cantunwind]\n", stdout);
8296 }
8297 else if (exidx_entry & 0x80000000)
8298 {
8299 print_vma (exidx_entry, PREFIX_HEX);
8300 fputc ('\n', stdout);
8301 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8302 }
8303 else
8304 {
8f73510c 8305 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8306 Elf_Internal_Shdr *table_sec;
8307
8308 fputs ("@", stdout);
a734115a 8309 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8310 print_vma (table, PREFIX_HEX);
8311 printf ("\n");
8312
8313 /* Locate the matching .ARM.extab. */
8314 if (entry_addr.section != SHN_UNDEF
8315 && entry_addr.section < elf_header.e_shnum)
8316 {
8317 table_sec = section_headers + entry_addr.section;
8318 table_offset = entry_addr.offset;
1a915552
NC		 8319 /* PR 18879 */
8320 if (table_offset > table_sec->sh_size
8321 || ((bfd_signed_vma) table_offset) < 0)
8322 {
8323 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8324 (unsigned long) table_offset,
8325 printable_section_name (table_sec));
8326 continue;
8327 }
0b6ae522
DJ		 8328 }
8329 else
8330 {
8331 table_sec = find_section_by_address (table);
8332 if (table_sec != NULL)
8333 table_offset = table - table_sec->sh_addr;
8334 }
8335 if (table_sec == NULL)
8336 {
8337 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8338 (unsigned long) table);
8339 continue;
8340 }
8341 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8342 &extab_arm_sec);
8343 }
8344 }
8345
8346 printf ("\n");
8347
948f632f 8348 free (aux->funtab);
0b6ae522
DJ		 8349 arm_free_section (&exidx_arm_sec);
8350 arm_free_section (&extab_arm_sec);
8351}
8352
fa197c1c 8353/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8354
8355static void
0b6ae522
DJ		 8356arm_process_unwind (FILE *file)
8357{
8358 struct arm_unw_aux_info aux;
8359 Elf_Internal_Shdr *unwsec = NULL;
8360 Elf_Internal_Shdr *strsec;
8361 Elf_Internal_Shdr *sec;
8362 unsigned long i;
fa197c1c 8363 unsigned int sec_type;
0b6ae522 8364
fa197c1c
PB		 8365 switch (elf_header.e_machine)
8366 {
8367 case EM_ARM:
8368 sec_type = SHT_ARM_EXIDX;
8369 break;
8370
8371 case EM_TI_C6000:
8372 sec_type = SHT_C6000_UNWIND;
8373 break;
8374
0b4362b0 8375 default:
74e1a04b 8376 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8377 elf_header.e_machine);
8378 return;
fa197c1c
PB		 8379 }
8380
0b6ae522 8381 if (string_table == NULL)
1b31d05e
NC		 8382 return;
8383
8384 memset (& aux, 0, sizeof (aux));
8385 aux.file = file;
0b6ae522
DJ		 8386
8387 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8388 {
8389 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8390 {
ba5cdace 8391 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8392
8393 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8394
8395 /* PR binutils/17531 file: 011-12666-0.004. */
8396 if (aux.strtab != NULL)
8397 {
4082ef84 8398 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8399 free (aux.strtab);
8400 }
0b6ae522
DJ		 8401 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8402 1, strsec->sh_size, _("string table"));
8403 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8404 }
fa197c1c 8405 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8406 unwsec = sec;
8407 }
8408
1b31d05e 8409 if (unwsec == NULL)
0b6ae522 8410 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8411 else
8412 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8413 {
8414 if (sec->sh_type == sec_type)
8415 {
8416 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8417 printable_section_name (sec),
1b31d05e
NC		 8418 (unsigned long) sec->sh_offset,
8419 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8420
1b31d05e
NC		 8421 dump_arm_unwind (&aux, sec);
8422 }
8423 }
0b6ae522
DJ		 8424
8425 if (aux.symtab)
8426 free (aux.symtab);
8427 if (aux.strtab)
8428 free ((char *) aux.strtab);
0b6ae522
DJ		 8429}
8430
1b31d05e 8431static void
2cf0635d 8432process_unwind (FILE * file)
57346661 8433{
2cf0635d
NC		 8434 struct unwind_handler
8435 {
57346661 8436 int machtype;
1b31d05e 8437 void (* handler)(FILE *);
2cf0635d
NC		 8438 } handlers[] =
8439 {
0b6ae522 8440 { EM_ARM, arm_process_unwind },
57346661
AM		 8441 { EM_IA_64, ia64_process_unwind },
8442 { EM_PARISC, hppa_process_unwind },
fa197c1c 8443 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8444 { 0, 0 }
8445 };
8446 int i;
8447
8448 if (!do_unwind)
1b31d05e 8449 return;
57346661
AM		 8450
8451 for (i = 0; handlers[i].handler != NULL; i++)
8452 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8453 {
8454 handlers[i].handler (file);
8455 return;
8456 }
57346661 8457
1b31d05e
NC		 8458 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8459 get_machine_name (elf_header.e_machine));
57346661
AM		 8460}
8461
252b5132 8462static void
2cf0635d 8463dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8464{
8465 switch (entry->d_tag)
8466 {
8467 case DT_MIPS_FLAGS:
8468 if (entry->d_un.d_val == 0)
4b68bca3 8469 printf (_("NONE"));
252b5132
RH		 8470 else
8471 {
8472 static const char * opts[] =
8473 {
8474 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8475 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8476 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8477 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8478 "RLD_ORDER_SAFE"
8479 };
8480 unsigned int cnt;
8481 int first = 1;
2b692964 8482
60bca95a 8483 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8484 if (entry->d_un.d_val & (1 << cnt))
8485 {
8486 printf ("%s%s", first ? "" : " ", opts[cnt]);
8487 first = 0;
8488 }
252b5132
RH		 8489 }
8490 break;
103f02d3 8491
252b5132 8492 case DT_MIPS_IVERSION:
d79b3d50 8493 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8494 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8495 else
76ca31c0
NC		 8496 {
8497 char buf[40];
8498 sprintf_vma (buf, entry->d_un.d_ptr);
8499 /* Note: coded this way so that there is a single string for translation. */
8500 printf (_("<corrupt: %s>"), buf);
8501 }
252b5132 8502 break;
103f02d3 8503
252b5132
RH		 8504 case DT_MIPS_TIME_STAMP:
8505 {
8506 char timebuf[20];
2cf0635d 8507 struct tm * tmp;
91d6fa6a 8508 time_t atime = entry->d_un.d_val;
82b1b41b 8509
91d6fa6a 8510 tmp = gmtime (&atime);
82b1b41b
NC		 8511 /* PR 17531: file: 6accc532. */
8512 if (tmp == NULL)
8513 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8514 else
8515 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8516 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8517 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8518 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8519 }
8520 break;
103f02d3 8521
252b5132
RH		 8522 case DT_MIPS_RLD_VERSION:
8523 case DT_MIPS_LOCAL_GOTNO:
8524 case DT_MIPS_CONFLICTNO:
8525 case DT_MIPS_LIBLISTNO:
8526 case DT_MIPS_SYMTABNO:
8527 case DT_MIPS_UNREFEXTNO:
8528 case DT_MIPS_HIPAGENO:
8529 case DT_MIPS_DELTA_CLASS_NO:
8530 case DT_MIPS_DELTA_INSTANCE_NO:
8531 case DT_MIPS_DELTA_RELOC_NO:
8532 case DT_MIPS_DELTA_SYM_NO:
8533 case DT_MIPS_DELTA_CLASSSYM_NO:
8534 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8535 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8536 break;
103f02d3
UD		 8537
8538 default:
4b68bca3 8539 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8540 }
4b68bca3 8541 putchar ('\n');
103f02d3
UD		 8542}
8543
103f02d3 8544static void
2cf0635d 8545dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8546{
8547 switch (entry->d_tag)
8548 {
8549 case DT_HP_DLD_FLAGS:
8550 {
8551 static struct
8552 {
8553 long int bit;
2cf0635d 8554 const char * str;
5e220199
NC		 8555 }
8556 flags[] =
8557 {
8558 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8559 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8560 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8561 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8562 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8563 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8564 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8565 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8566 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8567 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8568 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8569 { DT_HP_GST, "HP_GST" },
8570 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8571 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8572 { DT_HP_NODELETE, "HP_NODELETE" },
8573 { DT_HP_GROUP, "HP_GROUP" },
8574 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8575 };
103f02d3 8576 int first = 1;
5e220199 8577 size_t cnt;
f7a99963 8578 bfd_vma val = entry->d_un.d_val;
103f02d3 8579
60bca95a 8580 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8581 if (val & flags[cnt].bit)
30800947
NC		 8582 {
8583 if (! first)
8584 putchar (' ');
8585 fputs (flags[cnt].str, stdout);
8586 first = 0;
8587 val ^= flags[cnt].bit;
8588 }
76da6bbe 8589
103f02d3 8590 if (val != 0 || first)
f7a99963
NC		 8591 {
8592 if (! first)
8593 putchar (' ');
8594 print_vma (val, HEX);
8595 }
103f02d3
UD		 8596 }
8597 break;
76da6bbe 8598
252b5132 8599 default:
f7a99963
NC		 8600 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8601 break;
252b5132 8602 }
35b1837e 8603 putchar ('\n');
252b5132
RH		 8604}
8605
28f997cf
TG		 8606#ifdef BFD64
8607
8608/* VMS vs Unix time offset and factor. */
8609
8610#define VMS_EPOCH_OFFSET 35067168000000000LL
8611#define VMS_GRANULARITY_FACTOR 10000000
8612
8613/* Display a VMS time in a human readable format. */
8614
8615static void
8616print_vms_time (bfd_int64_t vmstime)
8617{
8618 struct tm *tm;
8619 time_t unxtime;
8620
8621 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8622 tm = gmtime (&unxtime);
8623 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8624 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8625 tm->tm_hour, tm->tm_min, tm->tm_sec);
8626}
8627#endif /* BFD64 */
8628
ecc51f48 8629static void
2cf0635d 8630dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8631{
8632 switch (entry->d_tag)
8633 {
0de14b54 8634 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8635 /* First 3 slots reserved. */
ecc51f48
NC		 8636 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8637 printf (" -- ");
8638 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8639 break;
8640
28f997cf
TG		 8641 case DT_IA_64_VMS_LINKTIME:
8642#ifdef BFD64
8643 print_vms_time (entry->d_un.d_val);
8644#endif
8645 break;
8646
8647 case DT_IA_64_VMS_LNKFLAGS:
8648 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8649 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8650 printf (" CALL_DEBUG");
8651 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8652 printf (" NOP0BUFS");
8653 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8654 printf (" P0IMAGE");
8655 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8656 printf (" MKTHREADS");
8657 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8658 printf (" UPCALLS");
8659 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8660 printf (" IMGSTA");
8661 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8662 printf (" INITIALIZE");
8663 if (entry->d_un.d_val & VMS_LF_MAIN)
8664 printf (" MAIN");
8665 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8666 printf (" EXE_INIT");
8667 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8668 printf (" TBK_IN_IMG");
8669 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8670 printf (" DBG_IN_IMG");
8671 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8672 printf (" TBK_IN_DSF");
8673 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8674 printf (" DBG_IN_DSF");
8675 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8676 printf (" SIGNATURES");
8677 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8678 printf (" REL_SEG_OFF");
8679 break;
8680
bdf4d63a
JJ		 8681 default:
8682 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8683 break;
ecc51f48 8684 }
bdf4d63a 8685 putchar ('\n');
ecc51f48
NC		 8686}
8687
252b5132 8688static int
2cf0635d 8689get_32bit_dynamic_section (FILE * file)
252b5132 8690{
2cf0635d
NC		 8691 Elf32_External_Dyn * edyn;
8692 Elf32_External_Dyn * ext;
8693 Elf_Internal_Dyn * entry;
103f02d3 8694
3f5e193b
NC		 8695 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8696 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8697 if (!edyn)
8698 return 0;
103f02d3 8699
071436c6
NC		 8700 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8701 might not have the luxury of section headers. Look for the DT_NULL
8702 terminator to determine the number of entries. */
ba2685cc 8703 for (ext = edyn, dynamic_nent = 0;
53c3012c 8704 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8705 ext++)
8706 {
8707 dynamic_nent++;
8708 if (BYTE_GET (ext->d_tag) == DT_NULL)
8709 break;
8710 }
252b5132 8711
3f5e193b
NC		 8712 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8713 sizeof (* entry));
b2d38a17 8714 if (dynamic_section == NULL)
252b5132 8715 {
8b73c356
NC		 8716 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8717 (unsigned long) dynamic_nent);
9ea033b2
NC		 8718 free (edyn);
8719 return 0;
8720 }
252b5132 8721
fb514b26 8722 for (ext = edyn, entry = dynamic_section;
ba2685cc 8723 entry < dynamic_section + dynamic_nent;
fb514b26 8724 ext++, entry++)
9ea033b2 8725 {
fb514b26
AM		 8726 entry->d_tag = BYTE_GET (ext->d_tag);
8727 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8728 }
8729
9ea033b2
NC		 8730 free (edyn);
8731
8732 return 1;
8733}
8734
8735static int
2cf0635d 8736get_64bit_dynamic_section (FILE * file)
9ea033b2 8737{
2cf0635d
NC		 8738 Elf64_External_Dyn * edyn;
8739 Elf64_External_Dyn * ext;
8740 Elf_Internal_Dyn * entry;
103f02d3 8741
071436c6 8742 /* Read in the data. */
3f5e193b
NC		 8743 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8744 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8745 if (!edyn)
8746 return 0;
103f02d3 8747
071436c6
NC		 8748 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8749 might not have the luxury of section headers. Look for the DT_NULL
8750 terminator to determine the number of entries. */
ba2685cc 8751 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8752 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8753 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8754 ext++)
8755 {
8756 dynamic_nent++;
66543521 8757 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8758 break;
8759 }
252b5132 8760
3f5e193b
NC		 8761 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8762 sizeof (* entry));
b2d38a17 8763 if (dynamic_section == NULL)
252b5132 8764 {
8b73c356
NC		 8765 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8766 (unsigned long) dynamic_nent);
252b5132
RH		 8767 free (edyn);
8768 return 0;
8769 }
8770
071436c6 8771 /* Convert from external to internal formats. */
fb514b26 8772 for (ext = edyn, entry = dynamic_section;
ba2685cc 8773 entry < dynamic_section + dynamic_nent;
fb514b26 8774 ext++, entry++)
252b5132 8775 {
66543521
AM		 8776 entry->d_tag = BYTE_GET (ext->d_tag);
8777 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8778 }
8779
8780 free (edyn);
8781
9ea033b2
NC		 8782 return 1;
8783}
8784
e9e44622
JJ		 8785static void
8786print_dynamic_flags (bfd_vma flags)
d1133906 8787{
e9e44622 8788 int first = 1;
13ae64f3 8789
d1133906
NC		 8790 while (flags)
8791 {
8792 bfd_vma flag;
8793
8794 flag = flags & - flags;
8795 flags &= ~ flag;
8796
e9e44622
JJ		 8797 if (first)
8798 first = 0;
8799 else
8800 putc (' ', stdout);
13ae64f3 8801
d1133906
NC		 8802 switch (flag)
8803 {
e9e44622
JJ		 8804 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8805 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8806 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8807 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8808 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8809 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8810 }
8811 }
e9e44622 8812 puts ("");
d1133906
NC		 8813}
8814
b2d38a17
NC		 8815/* Parse and display the contents of the dynamic section. */
8816
9ea033b2 8817static int
2cf0635d 8818process_dynamic_section (FILE * file)
9ea033b2 8819{
2cf0635d 8820 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8821
8822 if (dynamic_size == 0)
8823 {
8824 if (do_dynamic)
b2d38a17 8825 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8826
8827 return 1;
8828 }
8829
8830 if (is_32bit_elf)
8831 {
b2d38a17 8832 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8833 return 0;
8834 }
b2d38a17 8835 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8836 return 0;
8837
252b5132
RH		 8838 /* Find the appropriate symbol table. */
8839 if (dynamic_symbols == NULL)
8840 {
86dba8ee
AM		 8841 for (entry = dynamic_section;
8842 entry < dynamic_section + dynamic_nent;
8843 ++entry)
252b5132 8844 {
c8286bd1 8845 Elf_Internal_Shdr section;
252b5132
RH		 8846
8847 if (entry->d_tag != DT_SYMTAB)
8848 continue;
8849
8850 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8851
8852 /* Since we do not know how big the symbol table is,
8853 we default to reading in the entire file (!) and
8854 processing that. This is overkill, I know, but it
e3c8793a 8855 should work. */
d93f0186 8856 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8857
fb52b2f4
NC		 8858 if (archive_file_offset != 0)
8859 section.sh_size = archive_file_size - section.sh_offset;
8860 else
8861 {
8862 if (fseek (file, 0, SEEK_END))
591a748a 8863 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8864
8865 section.sh_size = ftell (file) - section.sh_offset;
8866 }
252b5132 8867
9ea033b2 8868 if (is_32bit_elf)
9ad5cbcf 8869 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8870 else
9ad5cbcf 8871 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8872 section.sh_name = string_table_length;
252b5132 8873
ba5cdace 8874 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8875 if (num_dynamic_syms < 1)
252b5132
RH		 8876 {
8877 error (_("Unable to determine the number of symbols to load\n"));
8878 continue;
8879 }
252b5132
RH		 8880 }
8881 }
8882
8883 /* Similarly find a string table. */
8884 if (dynamic_strings == NULL)
8885 {
86dba8ee
AM		 8886 for (entry = dynamic_section;
8887 entry < dynamic_section + dynamic_nent;
8888 ++entry)
252b5132
RH		 8889 {
8890 unsigned long offset;
b34976b6 8891 long str_tab_len;
252b5132
RH		 8892
8893 if (entry->d_tag != DT_STRTAB)
8894 continue;
8895
8896 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8897
8898 /* Since we do not know how big the string table is,
8899 we default to reading in the entire file (!) and
8900 processing that. This is overkill, I know, but it
e3c8793a 8901 should work. */
252b5132 8902
d93f0186 8903 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8904
8905 if (archive_file_offset != 0)
8906 str_tab_len = archive_file_size - offset;
8907 else
8908 {
8909 if (fseek (file, 0, SEEK_END))
8910 error (_("Unable to seek to end of file\n"));
8911 str_tab_len = ftell (file) - offset;
8912 }
252b5132
RH		 8913
8914 if (str_tab_len < 1)
8915 {
8916 error
8917 (_("Unable to determine the length of the dynamic string table\n"));
8918 continue;
8919 }
8920
3f5e193b
NC		 8921 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8922 str_tab_len,
8923 _("dynamic string table"));
59245841 8924 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8925 break;
8926 }
8927 }
8928
8929 /* And find the syminfo section if available. */
8930 if (dynamic_syminfo == NULL)
8931 {
3e8bba36 8932 unsigned long syminsz = 0;
252b5132 8933
86dba8ee
AM		 8934 for (entry = dynamic_section;
8935 entry < dynamic_section + dynamic_nent;
8936 ++entry)
252b5132
RH		 8937 {
8938 if (entry->d_tag == DT_SYMINENT)
8939 {
8940 /* Note: these braces are necessary to avoid a syntax
8941 error from the SunOS4 C compiler. */
049b0c3a
NC		 8942 /* PR binutils/17531: A corrupt file can trigger this test.
8943 So do not use an assert, instead generate an error message. */
8944 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8945 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8946 (int) entry->d_un.d_val);
252b5132
RH		 8947 }
8948 else if (entry->d_tag == DT_SYMINSZ)
8949 syminsz = entry->d_un.d_val;
8950 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8951 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8952 syminsz);
252b5132
RH		 8953 }
8954
8955 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8956 {
2cf0635d
NC		 8957 Elf_External_Syminfo * extsyminfo;
8958 Elf_External_Syminfo * extsym;
8959 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8960
8961 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8962 extsyminfo = (Elf_External_Syminfo *)
8963 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8964 _("symbol information"));
a6e9f9df
AM		 8965 if (!extsyminfo)
8966 return 0;
252b5132 8967
3f5e193b 8968 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8969 if (dynamic_syminfo == NULL)
8970 {
8b73c356
NC		 8971 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8972 (unsigned long) syminsz);
252b5132
RH		 8973 return 0;
8974 }
8975
8976 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8977 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8978 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8979 ++syminfo, ++extsym)
252b5132 8980 {
86dba8ee
AM		 8981 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8982 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8983 }
8984
8985 free (extsyminfo);
8986 }
8987 }
8988
8989 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8990 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8991 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8992 if (do_dynamic)
8993 printf (_(" Tag Type Name/Value\n"));
8994
86dba8ee
AM		 8995 for (entry = dynamic_section;
8996 entry < dynamic_section + dynamic_nent;
8997 entry++)
252b5132
RH		 8998 {
8999 if (do_dynamic)
f7a99963 9000 {
2cf0635d 9001 const char * dtype;
e699b9ff 9002
f7a99963
NC		 9003 putchar (' ');
9004 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9005 dtype = get_dynamic_type (entry->d_tag);
9006 printf (" (%s)%*s", dtype,
9007 ((is_32bit_elf ? 27 : 19)
9008 - (int) strlen (dtype)),
f7a99963
NC		 9009 " ");
9010 }
252b5132
RH		 9011
9012 switch (entry->d_tag)
9013 {
d1133906
NC		 9014 case DT_FLAGS:
9015 if (do_dynamic)
e9e44622 9016 print_dynamic_flags (entry->d_un.d_val);
d1133906 9017 break;
76da6bbe 9018
252b5132
RH		 9019 case DT_AUXILIARY:
9020 case DT_FILTER:
019148e4
L		 9021 case DT_CONFIG:
9022 case DT_DEPAUDIT:
9023 case DT_AUDIT:
252b5132
RH		 9024 if (do_dynamic)
9025 {
019148e4 9026 switch (entry->d_tag)
b34976b6 9027 {
019148e4
L		 9028 case DT_AUXILIARY:
9029 printf (_("Auxiliary library"));
9030 break;
9031
9032 case DT_FILTER:
9033 printf (_("Filter library"));
9034 break;
9035
b34976b6 9036 case DT_CONFIG:
019148e4
L		 9037 printf (_("Configuration file"));
9038 break;
9039
9040 case DT_DEPAUDIT:
9041 printf (_("Dependency audit library"));
9042 break;
9043
9044 case DT_AUDIT:
9045 printf (_("Audit library"));
9046 break;
9047 }
252b5132 9048
d79b3d50
NC		 9049 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9050 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9051 else
f7a99963
NC		 9052 {
9053 printf (": ");
9054 print_vma (entry->d_un.d_val, PREFIX_HEX);
9055 putchar ('\n');
9056 }
252b5132
RH		 9057 }
9058 break;
9059
dcefbbbd 9060 case DT_FEATURE:
252b5132
RH		 9061 if (do_dynamic)
9062 {
9063 printf (_("Flags:"));
86f55779 9064
252b5132
RH		 9065 if (entry->d_un.d_val == 0)
9066 printf (_(" None\n"));
9067 else
9068 {
9069 unsigned long int val = entry->d_un.d_val;
86f55779 9070
252b5132
RH		 9071 if (val & DTF_1_PARINIT)
9072 {
9073 printf (" PARINIT");
9074 val ^= DTF_1_PARINIT;
9075 }
dcefbbbd
L		 9076 if (val & DTF_1_CONFEXP)
9077 {
9078 printf (" CONFEXP");
9079 val ^= DTF_1_CONFEXP;
9080 }
252b5132
RH		 9081 if (val != 0)
9082 printf (" %lx", val);
9083 puts ("");
9084 }
9085 }
9086 break;
9087
9088 case DT_POSFLAG_1:
9089 if (do_dynamic)
9090 {
9091 printf (_("Flags:"));
86f55779 9092
252b5132
RH		 9093 if (entry->d_un.d_val == 0)
9094 printf (_(" None\n"));
9095 else
9096 {
9097 unsigned long int val = entry->d_un.d_val;
86f55779 9098
252b5132
RH		 9099 if (val & DF_P1_LAZYLOAD)
9100 {
9101 printf (" LAZYLOAD");
9102 val ^= DF_P1_LAZYLOAD;
9103 }
9104 if (val & DF_P1_GROUPPERM)
9105 {
9106 printf (" GROUPPERM");
9107 val ^= DF_P1_GROUPPERM;
9108 }
9109 if (val != 0)
9110 printf (" %lx", val);
9111 puts ("");
9112 }
9113 }
9114 break;
9115
9116 case DT_FLAGS_1:
9117 if (do_dynamic)
9118 {
9119 printf (_("Flags:"));
9120 if (entry->d_un.d_val == 0)
9121 printf (_(" None\n"));
9122 else
9123 {
9124 unsigned long int val = entry->d_un.d_val;
86f55779 9125
252b5132
RH		 9126 if (val & DF_1_NOW)
9127 {
9128 printf (" NOW");
9129 val ^= DF_1_NOW;
9130 }
9131 if (val & DF_1_GLOBAL)
9132 {
9133 printf (" GLOBAL");
9134 val ^= DF_1_GLOBAL;
9135 }
9136 if (val & DF_1_GROUP)
9137 {
9138 printf (" GROUP");
9139 val ^= DF_1_GROUP;
9140 }
9141 if (val & DF_1_NODELETE)
9142 {
9143 printf (" NODELETE");
9144 val ^= DF_1_NODELETE;
9145 }
9146 if (val & DF_1_LOADFLTR)
9147 {
9148 printf (" LOADFLTR");
9149 val ^= DF_1_LOADFLTR;
9150 }
9151 if (val & DF_1_INITFIRST)
9152 {
9153 printf (" INITFIRST");
9154 val ^= DF_1_INITFIRST;
9155 }
9156 if (val & DF_1_NOOPEN)
9157 {
9158 printf (" NOOPEN");
9159 val ^= DF_1_NOOPEN;
9160 }
9161 if (val & DF_1_ORIGIN)
9162 {
9163 printf (" ORIGIN");
9164 val ^= DF_1_ORIGIN;
9165 }
9166 if (val & DF_1_DIRECT)
9167 {
9168 printf (" DIRECT");
9169 val ^= DF_1_DIRECT;
9170 }
9171 if (val & DF_1_TRANS)
9172 {
9173 printf (" TRANS");
9174 val ^= DF_1_TRANS;
9175 }
9176 if (val & DF_1_INTERPOSE)
9177 {
9178 printf (" INTERPOSE");
9179 val ^= DF_1_INTERPOSE;
9180 }
f7db6139 9181 if (val & DF_1_NODEFLIB)
dcefbbbd 9182 {
f7db6139
L		 9183 printf (" NODEFLIB");
9184 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9185 }
9186 if (val & DF_1_NODUMP)
9187 {
9188 printf (" NODUMP");
9189 val ^= DF_1_NODUMP;
9190 }
34b60028 9191 if (val & DF_1_CONFALT)
dcefbbbd 9192 {
34b60028
L		 9193 printf (" CONFALT");
9194 val ^= DF_1_CONFALT;
9195 }
9196 if (val & DF_1_ENDFILTEE)
9197 {
9198 printf (" ENDFILTEE");
9199 val ^= DF_1_ENDFILTEE;
9200 }
9201 if (val & DF_1_DISPRELDNE)
9202 {
9203 printf (" DISPRELDNE");
9204 val ^= DF_1_DISPRELDNE;
9205 }
9206 if (val & DF_1_DISPRELPND)
9207 {
9208 printf (" DISPRELPND");
9209 val ^= DF_1_DISPRELPND;
9210 }
9211 if (val & DF_1_NODIRECT)
9212 {
9213 printf (" NODIRECT");
9214 val ^= DF_1_NODIRECT;
9215 }
9216 if (val & DF_1_IGNMULDEF)
9217 {
9218 printf (" IGNMULDEF");
9219 val ^= DF_1_IGNMULDEF;
9220 }
9221 if (val & DF_1_NOKSYMS)
9222 {
9223 printf (" NOKSYMS");
9224 val ^= DF_1_NOKSYMS;
9225 }
9226 if (val & DF_1_NOHDR)
9227 {
9228 printf (" NOHDR");
9229 val ^= DF_1_NOHDR;
9230 }
9231 if (val & DF_1_EDITED)
9232 {
9233 printf (" EDITED");
9234 val ^= DF_1_EDITED;
9235 }
9236 if (val & DF_1_NORELOC)
9237 {
9238 printf (" NORELOC");
9239 val ^= DF_1_NORELOC;
9240 }
9241 if (val & DF_1_SYMINTPOSE)
9242 {
9243 printf (" SYMINTPOSE");
9244 val ^= DF_1_SYMINTPOSE;
9245 }
9246 if (val & DF_1_GLOBAUDIT)
9247 {
9248 printf (" GLOBAUDIT");
9249 val ^= DF_1_GLOBAUDIT;
9250 }
9251 if (val & DF_1_SINGLETON)
9252 {
9253 printf (" SINGLETON");
9254 val ^= DF_1_SINGLETON;
dcefbbbd 9255 }
5c383f02
RO		 9256 if (val & DF_1_STUB)
9257 {
9258 printf (" STUB");
9259 val ^= DF_1_STUB;
9260 }
9261 if (val & DF_1_PIE)
9262 {
9263 printf (" PIE");
9264 val ^= DF_1_PIE;
9265 }
252b5132
RH		 9266 if (val != 0)
9267 printf (" %lx", val);
9268 puts ("");
9269 }
9270 }
9271 break;
9272
9273 case DT_PLTREL:
566b0d53 9274 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9275 if (do_dynamic)
9276 puts (get_dynamic_type (entry->d_un.d_val));
9277 break;
9278
9279 case DT_NULL :
9280 case DT_NEEDED :
9281 case DT_PLTGOT :
9282 case DT_HASH :
9283 case DT_STRTAB :
9284 case DT_SYMTAB :
9285 case DT_RELA :
9286 case DT_INIT :
9287 case DT_FINI :
9288 case DT_SONAME :
9289 case DT_RPATH :
9290 case DT_SYMBOLIC:
9291 case DT_REL :
9292 case DT_DEBUG :
9293 case DT_TEXTREL :
9294 case DT_JMPREL :
019148e4 9295 case DT_RUNPATH :
252b5132
RH		 9296 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9297
9298 if (do_dynamic)
9299 {
2cf0635d 9300 char * name;
252b5132 9301
d79b3d50
NC		 9302 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9303 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9304 else
d79b3d50 9305 name = NULL;
252b5132
RH		 9306
9307 if (name)
9308 {
9309 switch (entry->d_tag)
9310 {
9311 case DT_NEEDED:
9312 printf (_("Shared library: [%s]"), name);
9313
18bd398b 9314 if (streq (name, program_interpreter))
f7a99963 9315 printf (_(" program interpreter"));
252b5132
RH		 9316 break;
9317
9318 case DT_SONAME:
f7a99963 9319 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9320 break;
9321
9322 case DT_RPATH:
f7a99963 9323 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9324 break;
9325
019148e4
L		 9326 case DT_RUNPATH:
9327 printf (_("Library runpath: [%s]"), name);
9328 break;
9329
252b5132 9330 default:
f7a99963
NC		 9331 print_vma (entry->d_un.d_val, PREFIX_HEX);
9332 break;
252b5132
RH		 9333 }
9334 }
9335 else
f7a99963
NC		 9336 print_vma (entry->d_un.d_val, PREFIX_HEX);
9337
9338 putchar ('\n');
252b5132
RH		 9339 }
9340 break;
9341
9342 case DT_PLTRELSZ:
9343 case DT_RELASZ :
9344 case DT_STRSZ :
9345 case DT_RELSZ :
9346 case DT_RELAENT :
9347 case DT_SYMENT :
9348 case DT_RELENT :
566b0d53 9349 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9350 case DT_PLTPADSZ:
9351 case DT_MOVEENT :
9352 case DT_MOVESZ :
9353 case DT_INIT_ARRAYSZ:
9354 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9355 case DT_GNU_CONFLICTSZ:
9356 case DT_GNU_LIBLISTSZ:
252b5132 9357 if (do_dynamic)
f7a99963
NC		 9358 {
9359 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9360 printf (_(" (bytes)\n"));
f7a99963 9361 }
252b5132
RH		 9362 break;
9363
9364 case DT_VERDEFNUM:
9365 case DT_VERNEEDNUM:
9366 case DT_RELACOUNT:
9367 case DT_RELCOUNT:
9368 if (do_dynamic)
f7a99963
NC		 9369 {
9370 print_vma (entry->d_un.d_val, UNSIGNED);
9371 putchar ('\n');
9372 }
252b5132
RH		 9373 break;
9374
9375 case DT_SYMINSZ:
9376 case DT_SYMINENT:
9377 case DT_SYMINFO:
9378 case DT_USED:
9379 case DT_INIT_ARRAY:
9380 case DT_FINI_ARRAY:
9381 if (do_dynamic)
9382 {
d79b3d50
NC		 9383 if (entry->d_tag == DT_USED
9384 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9385 {
2cf0635d 9386 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9387
b34976b6 9388 if (*name)
252b5132
RH		 9389 {
9390 printf (_("Not needed object: [%s]\n"), name);
9391 break;
9392 }
9393 }
103f02d3 9394
f7a99963
NC		 9395 print_vma (entry->d_un.d_val, PREFIX_HEX);
9396 putchar ('\n');
252b5132
RH		 9397 }
9398 break;
9399
9400 case DT_BIND_NOW:
9401 /* The value of this entry is ignored. */
35b1837e
AM		 9402 if (do_dynamic)
9403 putchar ('\n');
252b5132 9404 break;
103f02d3 9405
047b2264
JJ		 9406 case DT_GNU_PRELINKED:
9407 if (do_dynamic)
9408 {
2cf0635d 9409 struct tm * tmp;
91d6fa6a 9410 time_t atime = entry->d_un.d_val;
047b2264 9411
91d6fa6a 9412 tmp = gmtime (&atime);
071436c6
NC		 9413 /* PR 17533 file: 041-1244816-0.004. */
9414 if (tmp == NULL)
5a2cbcf4
L		 9415 printf (_("<corrupt time val: %lx"),
9416 (unsigned long) atime);
071436c6
NC		 9417 else
9418 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9419 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9420 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9421
9422 }
9423 break;
9424
fdc90cb4
JJ		 9425 case DT_GNU_HASH:
9426 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9427 if (do_dynamic)
9428 {
9429 print_vma (entry->d_un.d_val, PREFIX_HEX);
9430 putchar ('\n');
9431 }
9432 break;
9433
252b5132
RH		 9434 default:
9435 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9436 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9437 entry->d_un.d_val;
9438
9439 if (do_dynamic)
9440 {
9441 switch (elf_header.e_machine)
9442 {
9443 case EM_MIPS:
4fe85591 9444 case EM_MIPS_RS3_LE:
b2d38a17 9445 dynamic_section_mips_val (entry);
252b5132 9446 break;
103f02d3 9447 case EM_PARISC:
b2d38a17 9448 dynamic_section_parisc_val (entry);
103f02d3 9449 break;
ecc51f48 9450 case EM_IA_64:
b2d38a17 9451 dynamic_section_ia64_val (entry);
ecc51f48 9452 break;
252b5132 9453 default:
f7a99963
NC		 9454 print_vma (entry->d_un.d_val, PREFIX_HEX);
9455 putchar ('\n');
252b5132
RH		 9456 }
9457 }
9458 break;
9459 }
9460 }
9461
9462 return 1;
9463}
9464
9465static char *
d3ba0551 9466get_ver_flags (unsigned int flags)
252b5132 9467{
b34976b6 9468 static char buff[32];
252b5132
RH		 9469
9470 buff[0] = 0;
9471
9472 if (flags == 0)
9473 return _("none");
9474
9475 if (flags & VER_FLG_BASE)
9476 strcat (buff, "BASE ");
9477
9478 if (flags & VER_FLG_WEAK)
9479 {
9480 if (flags & VER_FLG_BASE)
9481 strcat (buff, "| ");
9482
9483 strcat (buff, "WEAK ");
9484 }
9485
44ec90b9
RO		 9486 if (flags & VER_FLG_INFO)
9487 {
9488 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9489 strcat (buff, "| ");
9490
9491 strcat (buff, "INFO ");
9492 }
9493
9494 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9495 strcat (buff, _("| <unknown>"));
252b5132
RH		 9496
9497 return buff;
9498}
9499
9500/* Display the contents of the version sections. */
98fb390a 9501
252b5132 9502static int
2cf0635d 9503process_version_sections (FILE * file)
252b5132 9504{
2cf0635d 9505 Elf_Internal_Shdr * section;
b34976b6
AM		 9506 unsigned i;
9507 int found = 0;
252b5132
RH		 9508
9509 if (! do_version)
9510 return 1;
9511
9512 for (i = 0, section = section_headers;
9513 i < elf_header.e_shnum;
b34976b6 9514 i++, section++)
252b5132
RH		 9515 {
9516 switch (section->sh_type)
9517 {
9518 case SHT_GNU_verdef:
9519 {
2cf0635d 9520 Elf_External_Verdef * edefs;
b34976b6
AM		 9521 unsigned int idx;
9522 unsigned int cnt;
2cf0635d 9523 char * endbuf;
252b5132
RH		 9524
9525 found = 1;
9526
74e1a04b
NC		 9527 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9528 printable_section_name (section),
9529 section->sh_info);
252b5132
RH		 9530
9531 printf (_(" Addr: 0x"));
9532 printf_vma (section->sh_addr);
74e1a04b 9533 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9534 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9535 printable_section_name_from_index (section->sh_link));
252b5132 9536
3f5e193b
NC		 9537 edefs = (Elf_External_Verdef *)
9538 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9539 _("version definition section"));
a6e9f9df
AM		 9540 if (!edefs)
9541 break;
59245841 9542 endbuf = (char *) edefs + section->sh_size;
252b5132 9543
b34976b6 9544 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9545 {
2cf0635d
NC		 9546 char * vstart;
9547 Elf_External_Verdef * edef;
b34976b6 9548 Elf_Internal_Verdef ent;
2cf0635d 9549 Elf_External_Verdaux * eaux;
b34976b6
AM		 9550 Elf_Internal_Verdaux aux;
9551 int j;
9552 int isum;
103f02d3 9553
7e26601c
NC		 9554 /* Check for very large indicies. */
9555 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9556 break;
9557
252b5132 9558 vstart = ((char *) edefs) + idx;
54806181
AM		 9559 if (vstart + sizeof (*edef) > endbuf)
9560 break;
252b5132
RH		 9561
9562 edef = (Elf_External_Verdef *) vstart;
9563
9564 ent.vd_version = BYTE_GET (edef->vd_version);
9565 ent.vd_flags = BYTE_GET (edef->vd_flags);
9566 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9567 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9568 ent.vd_hash = BYTE_GET (edef->vd_hash);
9569 ent.vd_aux = BYTE_GET (edef->vd_aux);
9570 ent.vd_next = BYTE_GET (edef->vd_next);
9571
9572 printf (_(" %#06x: Rev: %d Flags: %s"),
9573 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9574
9575 printf (_(" Index: %d Cnt: %d "),
9576 ent.vd_ndx, ent.vd_cnt);
9577
dd24e3da 9578 /* Check for overflow. */
7e26601c 9579 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9580 break;
9581
252b5132
RH		 9582 vstart += ent.vd_aux;
9583
9584 eaux = (Elf_External_Verdaux *) vstart;
9585
9586 aux.vda_name = BYTE_GET (eaux->vda_name);
9587 aux.vda_next = BYTE_GET (eaux->vda_next);
9588
d79b3d50
NC		 9589 if (VALID_DYNAMIC_NAME (aux.vda_name))
9590 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9591 else
9592 printf (_("Name index: %ld\n"), aux.vda_name);
9593
9594 isum = idx + ent.vd_aux;
9595
b34976b6 9596 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9597 {
dd24e3da 9598 /* Check for overflow. */
7e26601c 9599 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9600 break;
9601
252b5132
RH		 9602 isum += aux.vda_next;
9603 vstart += aux.vda_next;
9604
9605 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9606 if (vstart + sizeof (*eaux) > endbuf)
9607 break;
252b5132
RH		 9608
9609 aux.vda_name = BYTE_GET (eaux->vda_name);
9610 aux.vda_next = BYTE_GET (eaux->vda_next);
9611
d79b3d50 9612 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9613 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9614 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9615 else
9616 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9617 isum, j, aux.vda_name);
9618 }
dd24e3da 9619
54806181
AM		 9620 if (j < ent.vd_cnt)
9621 printf (_(" Version def aux past end of section\n"));
252b5132 9622
5d921cbd
NC		 9623 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9624 if (idx + ent.vd_next <= idx)
9625 break;
9626
252b5132
RH		 9627 idx += ent.vd_next;
9628 }
dd24e3da 9629
54806181
AM		 9630 if (cnt < section->sh_info)
9631 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9632
9633 free (edefs);
9634 }
9635 break;
103f02d3 9636
252b5132
RH		 9637 case SHT_GNU_verneed:
9638 {
2cf0635d 9639 Elf_External_Verneed * eneed;
b34976b6
AM		 9640 unsigned int idx;
9641 unsigned int cnt;
2cf0635d 9642 char * endbuf;
252b5132
RH		 9643
9644 found = 1;
9645
72de5009 9646 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9647 printable_section_name (section), section->sh_info);
252b5132
RH		 9648
9649 printf (_(" Addr: 0x"));
9650 printf_vma (section->sh_addr);
72de5009 9651 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9652 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9653 printable_section_name_from_index (section->sh_link));
252b5132 9654
3f5e193b
NC		 9655 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9656 section->sh_offset, 1,
9657 section->sh_size,
9cf03b7e 9658 _("Version Needs section"));
a6e9f9df
AM		 9659 if (!eneed)
9660 break;
59245841 9661 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9662
9663 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9664 {
2cf0635d 9665 Elf_External_Verneed * entry;
b34976b6
AM		 9666 Elf_Internal_Verneed ent;
9667 int j;
9668 int isum;
2cf0635d 9669 char * vstart;
252b5132 9670
7e26601c 9671 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9672 break;
9673
252b5132 9674 vstart = ((char *) eneed) + idx;
54806181
AM		 9675 if (vstart + sizeof (*entry) > endbuf)
9676 break;
252b5132
RH		 9677
9678 entry = (Elf_External_Verneed *) vstart;
9679
9680 ent.vn_version = BYTE_GET (entry->vn_version);
9681 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9682 ent.vn_file = BYTE_GET (entry->vn_file);
9683 ent.vn_aux = BYTE_GET (entry->vn_aux);
9684 ent.vn_next = BYTE_GET (entry->vn_next);
9685
9686 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9687
d79b3d50
NC		 9688 if (VALID_DYNAMIC_NAME (ent.vn_file))
9689 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9690 else
9691 printf (_(" File: %lx"), ent.vn_file);
9692
9693 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9694
dd24e3da 9695 /* Check for overflow. */
7e26601c 9696 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9697 break;
252b5132
RH		 9698 vstart += ent.vn_aux;
9699
9700 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9701 {
2cf0635d 9702 Elf_External_Vernaux * eaux;
b34976b6 9703 Elf_Internal_Vernaux aux;
252b5132 9704
54806181
AM		 9705 if (vstart + sizeof (*eaux) > endbuf)
9706 break;
252b5132
RH		 9707 eaux = (Elf_External_Vernaux *) vstart;
9708
9709 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9710 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9711 aux.vna_other = BYTE_GET (eaux->vna_other);
9712 aux.vna_name = BYTE_GET (eaux->vna_name);
9713 aux.vna_next = BYTE_GET (eaux->vna_next);
9714
d79b3d50 9715 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9716 printf (_(" %#06x: Name: %s"),
d79b3d50 9717 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9718 else
ecc2063b 9719 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9720 isum, aux.vna_name);
9721
9722 printf (_(" Flags: %s Version: %d\n"),
9723 get_ver_flags (aux.vna_flags), aux.vna_other);
9724
dd24e3da 9725 /* Check for overflow. */
53774b7e
NC		 9726 if (aux.vna_next > (size_t) (endbuf - vstart)
9727 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9728 {
9729 warn (_("Invalid vna_next field of %lx\n"),
9730 aux.vna_next);
9731 j = ent.vn_cnt;
9732 break;
9733 }
252b5132
RH		 9734 isum += aux.vna_next;
9735 vstart += aux.vna_next;
9736 }
9cf03b7e 9737
54806181 9738 if (j < ent.vn_cnt)
9cf03b7e 9739 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9740
bcf83b2a 9741 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9742 {
9743 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9744 cnt = section->sh_info;
9745 break;
9746 }
252b5132
RH		 9747 idx += ent.vn_next;
9748 }
9cf03b7e 9749
54806181 9750 if (cnt < section->sh_info)
9cf03b7e 9751 warn (_("Missing Version Needs information\n"));
103f02d3 9752
252b5132
RH		 9753 free (eneed);
9754 }
9755 break;
9756
9757 case SHT_GNU_versym:
9758 {
2cf0635d 9759 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9760 size_t total;
9761 unsigned int cnt;
2cf0635d
NC		 9762 unsigned char * edata;
9763 unsigned short * data;
9764 char * strtab;
9765 Elf_Internal_Sym * symbols;
9766 Elf_Internal_Shdr * string_sec;
ba5cdace 9767 unsigned long num_syms;
d3ba0551 9768 long off;
252b5132 9769
4fbb74a6 9770 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9771 break;
9772
4fbb74a6 9773 link_section = section_headers + section->sh_link;
08d8fa11 9774 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9775
4fbb74a6 9776 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9777 break;
9778
252b5132
RH		 9779 found = 1;
9780
ba5cdace 9781 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9782 if (symbols == NULL)
9783 break;
252b5132 9784
4fbb74a6 9785 string_sec = section_headers + link_section->sh_link;
252b5132 9786
3f5e193b
NC		 9787 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9788 string_sec->sh_size,
9789 _("version string table"));
a6e9f9df 9790 if (!strtab)
0429c154
MS		 9791 {
9792 free (symbols);
9793 break;
9794 }
252b5132 9795
8b73c356
NC		 9796 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9797 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9798
9799 printf (_(" Addr: "));
9800 printf_vma (section->sh_addr);
72de5009 9801 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9802 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9803 printable_section_name (link_section));
252b5132 9804
d3ba0551
AM		 9805 off = offset_from_vma (file,
9806 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9807 total * sizeof (short));
3f5e193b
NC		 9808 edata = (unsigned char *) get_data (NULL, file, off, total,
9809 sizeof (short),
9810 _("version symbol data"));
a6e9f9df
AM		 9811 if (!edata)
9812 {
9813 free (strtab);
0429c154 9814 free (symbols);
a6e9f9df
AM		 9815 break;
9816 }
252b5132 9817
3f5e193b 9818 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9819
9820 for (cnt = total; cnt --;)
b34976b6
AM		 9821 data[cnt] = byte_get (edata + cnt * sizeof (short),
9822 sizeof (short));
252b5132
RH		 9823
9824 free (edata);
9825
9826 for (cnt = 0; cnt < total; cnt += 4)
9827 {
9828 int j, nn;
00d93f34 9829 int check_def, check_need;
2cf0635d 9830 char * name;
252b5132
RH		 9831
9832 printf (" %03x:", cnt);
9833
9834 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9835 switch (data[cnt + j])
252b5132
RH		 9836 {
9837 case 0:
9838 fputs (_(" 0 (*local*) "), stdout);
9839 break;
9840
9841 case 1:
9842 fputs (_(" 1 (*global*) "), stdout);
9843 break;
9844
9845 default:
c244d050
NC		 9846 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9847 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9848
dd24e3da 9849 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9850 array, break to avoid an out-of-bounds read. */
9851 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9852 {
9853 warn (_("invalid index into symbol array\n"));
9854 break;
9855 }
9856
00d93f34
JJ		 9857 check_def = 1;
9858 check_need = 1;
4fbb74a6
AM		 9859 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9860 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9861 != SHT_NOBITS)
252b5132 9862 {
b34976b6 9863 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9864 check_def = 0;
9865 else
9866 check_need = 0;
252b5132 9867 }
00d93f34
JJ		 9868
9869 if (check_need
b34976b6 9870 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9871 {
b34976b6
AM		 9872 Elf_Internal_Verneed ivn;
9873 unsigned long offset;
252b5132 9874
d93f0186
NC		 9875 offset = offset_from_vma
9876 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9877 sizeof (Elf_External_Verneed));
252b5132 9878
b34976b6 9879 do
252b5132 9880 {
b34976b6
AM		 9881 Elf_Internal_Vernaux ivna;
9882 Elf_External_Verneed evn;
9883 Elf_External_Vernaux evna;
9884 unsigned long a_off;
252b5132 9885
59245841
NC		 9886 if (get_data (&evn, file, offset, sizeof (evn), 1,
9887 _("version need")) == NULL)
9888 break;
0b4362b0 9889
252b5132
RH		 9890 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9891 ivn.vn_next = BYTE_GET (evn.vn_next);
9892
9893 a_off = offset + ivn.vn_aux;
9894
9895 do
9896 {
59245841
NC		 9897 if (get_data (&evna, file, a_off, sizeof (evna),
9898 1, _("version need aux (2)")) == NULL)
9899 {
9900 ivna.vna_next = 0;
9901 ivna.vna_other = 0;
9902 }
9903 else
9904 {
9905 ivna.vna_next = BYTE_GET (evna.vna_next);
9906 ivna.vna_other = BYTE_GET (evna.vna_other);
9907 }
252b5132
RH		 9908
9909 a_off += ivna.vna_next;
9910 }
b34976b6 9911 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9912 && ivna.vna_next != 0);
9913
b34976b6 9914 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9915 {
9916 ivna.vna_name = BYTE_GET (evna.vna_name);
9917
54806181
AM		 9918 if (ivna.vna_name >= string_sec->sh_size)
9919 name = _("*invalid*");
9920 else
9921 name = strtab + ivna.vna_name;
252b5132 9922 nn += printf ("(%s%-*s",
16062207
ILT		 9923 name,
9924 12 - (int) strlen (name),
252b5132 9925 ")");
00d93f34 9926 check_def = 0;
252b5132
RH		 9927 break;
9928 }
9929
9930 offset += ivn.vn_next;
9931 }
9932 while (ivn.vn_next);
9933 }
00d93f34 9934
b34976b6
AM		 9935 if (check_def && data[cnt + j] != 0x8001
9936 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9937 {
b34976b6
AM		 9938 Elf_Internal_Verdef ivd;
9939 Elf_External_Verdef evd;
9940 unsigned long offset;
252b5132 9941
d93f0186
NC		 9942 offset = offset_from_vma
9943 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9944 sizeof evd);
252b5132
RH		 9945
9946 do
9947 {
59245841
NC		 9948 if (get_data (&evd, file, offset, sizeof (evd), 1,
9949 _("version def")) == NULL)
9950 {
9951 ivd.vd_next = 0;
948f632f 9952 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9953 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9954 break;
59245841
NC		 9955 }
9956 else
9957 {
9958 ivd.vd_next = BYTE_GET (evd.vd_next);
9959 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9960 }
252b5132
RH		 9961
9962 offset += ivd.vd_next;
9963 }
c244d050 9964 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9965 && ivd.vd_next != 0);
9966
c244d050 9967 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9968 {
b34976b6
AM		 9969 Elf_External_Verdaux evda;
9970 Elf_Internal_Verdaux ivda;
252b5132
RH		 9971
9972 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9973
59245841
NC		 9974 if (get_data (&evda, file,
9975 offset - ivd.vd_next + ivd.vd_aux,
9976 sizeof (evda), 1,
9977 _("version def aux")) == NULL)
9978 break;
252b5132
RH		 9979
9980 ivda.vda_name = BYTE_GET (evda.vda_name);
9981
54806181
AM		 9982 if (ivda.vda_name >= string_sec->sh_size)
9983 name = _("*invalid*");
9984 else
9985 name = strtab + ivda.vda_name;
252b5132 9986 nn += printf ("(%s%-*s",
16062207
ILT		 9987 name,
9988 12 - (int) strlen (name),
252b5132
RH		 9989 ")");
9990 }
9991 }
9992
9993 if (nn < 18)
9994 printf ("%*c", 18 - nn, ' ');
9995 }
9996
9997 putchar ('\n');
9998 }
9999
10000 free (data);
10001 free (strtab);
10002 free (symbols);
10003 }
10004 break;
103f02d3 10005
252b5132
RH		 10006 default:
10007 break;
10008 }
10009 }
10010
10011 if (! found)
10012 printf (_("\nNo version information found in this file.\n"));
10013
10014 return 1;
10015}
10016
d1133906 10017static const char *
d3ba0551 10018get_symbol_binding (unsigned int binding)
252b5132 10019{
b34976b6 10020 static char buff[32];
252b5132
RH		 10021
10022 switch (binding)
10023 {
b34976b6
AM		 10024 case STB_LOCAL: return "LOCAL";
10025 case STB_GLOBAL: return "GLOBAL";
10026 case STB_WEAK: return "WEAK";
252b5132
RH		 10027 default:
10028 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10029 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10030 binding);
252b5132 10031 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10032 {
10033 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10034 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10035 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10036 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10037 return "UNIQUE";
10038 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10039 }
252b5132 10040 else
e9e44622 10041 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10042 return buff;
10043 }
10044}
10045
d1133906 10046static const char *
d3ba0551 10047get_symbol_type (unsigned int type)
252b5132 10048{
b34976b6 10049 static char buff[32];
252b5132
RH		 10050
10051 switch (type)
10052 {
b34976b6
AM		 10053 case STT_NOTYPE: return "NOTYPE";
10054 case STT_OBJECT: return "OBJECT";
10055 case STT_FUNC: return "FUNC";
10056 case STT_SECTION: return "SECTION";
10057 case STT_FILE: return "FILE";
10058 case STT_COMMON: return "COMMON";
10059 case STT_TLS: return "TLS";
15ab5209
DB		 10060 case STT_RELC: return "RELC";
10061 case STT_SRELC: return "SRELC";
252b5132
RH		 10062 default:
10063 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10064 {
3510a7b8
NC		 10065 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10066 return "THUMB_FUNC";
103f02d3 10067
351b4b40 10068 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10069 return "REGISTER";
10070
10071 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10072 return "PARISC_MILLI";
10073
e9e44622 10074 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10075 }
252b5132 10076 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10077 {
10078 if (elf_header.e_machine == EM_PARISC)
10079 {
10080 if (type == STT_HP_OPAQUE)
10081 return "HP_OPAQUE";
10082 if (type == STT_HP_STUB)
10083 return "HP_STUB";
10084 }
10085
d8045f23 10086 if (type == STT_GNU_IFUNC
9c55345c 10087 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10088 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10089 /* GNU is still using the default value 0. */
d8045f23
NC		 10090 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10091 return "IFUNC";
10092
e9e44622 10093 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10094 }
252b5132 10095 else
e9e44622 10096 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10097 return buff;
10098 }
10099}
10100
d1133906 10101static const char *
d3ba0551 10102get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10103{
10104 switch (visibility)
10105 {
b34976b6
AM		 10106 case STV_DEFAULT: return "DEFAULT";
10107 case STV_INTERNAL: return "INTERNAL";
10108 case STV_HIDDEN: return "HIDDEN";
d1133906 10109 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10110 default:
10111 error (_("Unrecognized visibility value: %u"), visibility);
10112 return _("<unknown>");
d1133906
NC		 10113 }
10114}
10115
5e2b0d47
NC		 10116static const char *
10117get_mips_symbol_other (unsigned int other)
10118{
10119 switch (other)
10120 {
df58fc94
RS		 10121 case STO_OPTIONAL:
10122 return "OPTIONAL";
10123 case STO_MIPS_PLT:
10124 return "MIPS PLT";
10125 case STO_MIPS_PIC:
10126 return "MIPS PIC";
10127 case STO_MICROMIPS:
10128 return "MICROMIPS";
10129 case STO_MICROMIPS | STO_MIPS_PIC:
10130 return "MICROMIPS, MIPS PIC";
10131 case STO_MIPS16:
10132 return "MIPS16";
10133 default:
10134 return NULL;
5e2b0d47
NC		 10135 }
10136}
10137
28f997cf
TG		 10138static const char *
10139get_ia64_symbol_other (unsigned int other)
10140{
10141 if (is_ia64_vms ())
10142 {
10143 static char res[32];
10144
10145 res[0] = 0;
10146
10147 /* Function types is for images and .STB files only. */
10148 switch (elf_header.e_type)
10149 {
10150 case ET_DYN:
10151 case ET_EXEC:
10152 switch (VMS_ST_FUNC_TYPE (other))
10153 {
10154 case VMS_SFT_CODE_ADDR:
10155 strcat (res, " CA");
10156 break;
10157 case VMS_SFT_SYMV_IDX:
10158 strcat (res, " VEC");
10159 break;
10160 case VMS_SFT_FD:
10161 strcat (res, " FD");
10162 break;
10163 case VMS_SFT_RESERVE:
10164 strcat (res, " RSV");
10165 break;
10166 default:
bee0ee85
NC		 10167 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10168 VMS_ST_FUNC_TYPE (other));
10169 strcat (res, " <unknown>");
10170 break;
28f997cf
TG		 10171 }
10172 break;
10173 default:
10174 break;
10175 }
10176 switch (VMS_ST_LINKAGE (other))
10177 {
10178 case VMS_STL_IGNORE:
10179 strcat (res, " IGN");
10180 break;
10181 case VMS_STL_RESERVE:
10182 strcat (res, " RSV");
10183 break;
10184 case VMS_STL_STD:
10185 strcat (res, " STD");
10186 break;
10187 case VMS_STL_LNK:
10188 strcat (res, " LNK");
10189 break;
10190 default:
bee0ee85
NC		 10191 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10192 VMS_ST_LINKAGE (other));
10193 strcat (res, " <unknown>");
10194 break;
28f997cf
TG		 10195 }
10196
10197 if (res[0] != 0)
10198 return res + 1;
10199 else
10200 return res;
10201 }
10202 return NULL;
10203}
10204
6911b7dc
AM		 10205static const char *
10206get_ppc64_symbol_other (unsigned int other)
10207{
10208 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10209 {
10210 static char buf[32];
10211 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10212 PPC64_LOCAL_ENTRY_OFFSET (other));
10213 return buf;
10214 }
10215 return NULL;
10216}
10217
5e2b0d47
NC		 10218static const char *
10219get_symbol_other (unsigned int other)
10220{
10221 const char * result = NULL;
10222 static char buff [32];
10223
10224 if (other == 0)
10225 return "";
10226
10227 switch (elf_header.e_machine)
10228 {
10229 case EM_MIPS:
10230 result = get_mips_symbol_other (other);
28f997cf
TG		 10231 break;
10232 case EM_IA_64:
10233 result = get_ia64_symbol_other (other);
10234 break;
6911b7dc
AM		 10235 case EM_PPC64:
10236 result = get_ppc64_symbol_other (other);
10237 break;
5e2b0d47
NC		 10238 default:
10239 break;
10240 }
10241
10242 if (result)
10243 return result;
10244
10245 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10246 return buff;
10247}
10248
d1133906 10249static const char *
d3ba0551 10250get_symbol_index_type (unsigned int type)
252b5132 10251{
b34976b6 10252 static char buff[32];
5cf1065c 10253
252b5132
RH		 10254 switch (type)
10255 {
b34976b6
AM		 10256 case SHN_UNDEF: return "UND";
10257 case SHN_ABS: return "ABS";
10258 case SHN_COMMON: return "COM";
252b5132 10259 default:
9ce701e2
L		 10260 if (type == SHN_IA_64_ANSI_COMMON
10261 && elf_header.e_machine == EM_IA_64
10262 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10263 return "ANSI_COM";
8a9036a4 10264 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10265 || elf_header.e_machine == EM_L1OM
10266 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10267 && type == SHN_X86_64_LCOMMON)
10268 return "LARGE_COM";
ac145307
BS		 10269 else if ((type == SHN_MIPS_SCOMMON
10270 && elf_header.e_machine == EM_MIPS)
10271 || (type == SHN_TIC6X_SCOMMON
10272 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10273 return "SCOM";
10274 else if (type == SHN_MIPS_SUNDEFINED
10275 && elf_header.e_machine == EM_MIPS)
10276 return "SUND";
9ce701e2 10277 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10278 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10279 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10280 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10281 else if (type >= SHN_LORESERVE)
10282 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10283 else if (type >= elf_header.e_shnum)
e0a31db1 10284 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10285 else
232e7cb8 10286 sprintf (buff, "%3d", type);
5cf1065c 10287 break;
252b5132 10288 }
5cf1065c
NC		 10289
10290 return buff;
252b5132
RH		 10291}
10292
66543521 10293static bfd_vma *
57028622 10294get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10295{
2cf0635d
NC		 10296 unsigned char * e_data;
10297 bfd_vma * i_data;
252b5132 10298
57028622
NC		 10299 /* If the size_t type is smaller than the bfd_size_type, eg because
10300 you are building a 32-bit tool on a 64-bit host, then make sure
10301 that when (number) is cast to (size_t) no information is lost. */
10302 if (sizeof (size_t) < sizeof (bfd_size_type)
10303 && (bfd_size_type) ((size_t) number) != number)
10304 {
10305 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10306 (unsigned long long) number, ent_size);
10307 return NULL;
10308 }
948f632f 10309
3102e897
NC		 10310 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10311 attempting to allocate memory when the read is bound to fail. */
10312 if (ent_size * number > current_file_size)
10313 {
57028622
NC		 10314 error (_("Invalid number of dynamic entries: %llu\n"),
10315 (unsigned long long) number);
3102e897
NC		 10316 return NULL;
10317 }
10318
57028622 10319 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10320 if (e_data == NULL)
10321 {
57028622
NC		 10322 error (_("Out of memory reading %llu dynamic entries\n"),
10323 (unsigned long long) number);
252b5132
RH		 10324 return NULL;
10325 }
10326
57028622 10327 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10328 {
57028622
NC		 10329 error (_("Unable to read in %llu bytes of dynamic data\n"),
10330 (unsigned long long) (number * ent_size));
3102e897 10331 free (e_data);
252b5132
RH		 10332 return NULL;
10333 }
10334
57028622 10335 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10336 if (i_data == NULL)
10337 {
57028622
NC		 10338 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10339 (unsigned long long) number);
252b5132
RH		 10340 free (e_data);
10341 return NULL;
10342 }
10343
10344 while (number--)
66543521 10345 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10346
10347 free (e_data);
10348
10349 return i_data;
10350}
10351
6bd1a22c
L		 10352static void
10353print_dynamic_symbol (bfd_vma si, unsigned long hn)
10354{
2cf0635d 10355 Elf_Internal_Sym * psym;
6bd1a22c
L		 10356 int n;
10357
6bd1a22c
L		 10358 n = print_vma (si, DEC_5);
10359 if (n < 5)
0b4362b0 10360 fputs (&" "[n], stdout);
6bd1a22c 10361 printf (" %3lu: ", hn);
e0a31db1
NC		 10362
10363 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10364 {
3102e897
NC		 10365 printf (_("<No info available for dynamic symbol number %lu>\n"),
10366 (unsigned long) si);
e0a31db1
NC		 10367 return;
10368 }
10369
10370 psym = dynamic_symbols + si;
6bd1a22c
L		 10371 print_vma (psym->st_value, LONG_HEX);
10372 putchar (' ');
10373 print_vma (psym->st_size, DEC_5);
10374
f4be36b3
AM		 10375 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10376 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10377 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10378 /* Check to see if any other bits in the st_other field are set.
10379 Note - displaying this information disrupts the layout of the
10380 table being generated, but for the moment this case is very
10381 rare. */
10382 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10383 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10384 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10385 if (VALID_DYNAMIC_NAME (psym->st_name))
10386 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10387 else
2b692964 10388 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10389 putchar ('\n');
10390}
10391
bb4d2ac2
L		 10392static const char *
10393get_symbol_version_string (FILE *file, int is_dynsym,
10394 const char *strtab,
10395 unsigned long int strtab_size,
10396 unsigned int si, Elf_Internal_Sym *psym,
10397 enum versioned_symbol_info *sym_info,
10398 unsigned short *vna_other)
10399{
10400 const char *version_string = NULL;
10401
10402 if (is_dynsym
10403 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10404 {
10405 unsigned char data[2];
10406 unsigned short vers_data;
10407 unsigned long offset;
10408 int is_nobits;
10409 int check_def;
10410
10411 offset = offset_from_vma
10412 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10413 sizeof data + si * sizeof (vers_data));
10414
10415 if (get_data (&data, file, offset + si * sizeof (vers_data),
10416 sizeof (data), 1, _("version data")) == NULL)
10417 return NULL;
10418
10419 vers_data = byte_get (data, 2);
10420
53774b7e
NC		 10421 is_nobits = (section_headers != NULL
10422 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10423 && section_headers[psym->st_shndx].sh_type
10424 == SHT_NOBITS);
10425
10426 check_def = (psym->st_shndx != SHN_UNDEF);
10427
10428 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10429 {
10430 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10431 && (is_nobits || ! check_def))
10432 {
10433 Elf_External_Verneed evn;
10434 Elf_Internal_Verneed ivn;
10435 Elf_Internal_Vernaux ivna;
10436
10437 /* We must test both. */
10438 offset = offset_from_vma
10439 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10440 sizeof evn);
10441
10442 do
10443 {
10444 unsigned long vna_off;
10445
10446 if (get_data (&evn, file, offset, sizeof (evn), 1,
10447 _("version need")) == NULL)
10448 {
10449 ivna.vna_next = 0;
10450 ivna.vna_other = 0;
10451 ivna.vna_name = 0;
10452 break;
10453 }
10454
10455 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10456 ivn.vn_next = BYTE_GET (evn.vn_next);
10457
10458 vna_off = offset + ivn.vn_aux;
10459
10460 do
10461 {
10462 Elf_External_Vernaux evna;
10463
10464 if (get_data (&evna, file, vna_off,
10465 sizeof (evna), 1,
10466 _("version need aux (3)")) == NULL)
10467 {
10468 ivna.vna_next = 0;
10469 ivna.vna_other = 0;
10470 ivna.vna_name = 0;
10471 }
10472 else
10473 {
10474 ivna.vna_other = BYTE_GET (evna.vna_other);
10475 ivna.vna_next = BYTE_GET (evna.vna_next);
10476 ivna.vna_name = BYTE_GET (evna.vna_name);
10477 }
10478
10479 vna_off += ivna.vna_next;
10480 }
10481 while (ivna.vna_other != vers_data
10482 && ivna.vna_next != 0);
10483
10484 if (ivna.vna_other == vers_data)
10485 break;
10486
10487 offset += ivn.vn_next;
10488 }
10489 while (ivn.vn_next != 0);
10490
10491 if (ivna.vna_other == vers_data)
10492 {
10493 *sym_info = symbol_undefined;
10494 *vna_other = ivna.vna_other;
10495 version_string = (ivna.vna_name < strtab_size
10496 ? strtab + ivna.vna_name
10497 : _("<corrupt>"));
10498 check_def = 0;
10499 }
10500 else if (! is_nobits)
10501 error (_("bad dynamic symbol\n"));
10502 else
10503 check_def = 1;
10504 }
10505
10506 if (check_def)
10507 {
10508 if (vers_data != 0x8001
10509 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10510 {
10511 Elf_Internal_Verdef ivd;
10512 Elf_Internal_Verdaux ivda;
10513 Elf_External_Verdaux evda;
10514 unsigned long off;
10515
10516 off = offset_from_vma
10517 (file,
10518 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10519 sizeof (Elf_External_Verdef));
10520
10521 do
10522 {
10523 Elf_External_Verdef evd;
10524
10525 if (get_data (&evd, file, off, sizeof (evd),
10526 1, _("version def")) == NULL)
10527 {
10528 ivd.vd_ndx = 0;
10529 ivd.vd_aux = 0;
10530 ivd.vd_next = 0;
10531 }
10532 else
10533 {
10534 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10535 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10536 ivd.vd_next = BYTE_GET (evd.vd_next);
10537 }
10538
10539 off += ivd.vd_next;
10540 }
10541 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10542 && ivd.vd_next != 0);
10543
10544 off -= ivd.vd_next;
10545 off += ivd.vd_aux;
10546
10547 if (get_data (&evda, file, off, sizeof (evda),
10548 1, _("version def aux")) == NULL)
10549 return version_string;
10550
10551 ivda.vda_name = BYTE_GET (evda.vda_name);
10552
10553 if (psym->st_name != ivda.vda_name)
10554 {
10555 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10556 ? symbol_hidden : symbol_public);
10557 version_string = (ivda.vda_name < strtab_size
10558 ? strtab + ivda.vda_name
10559 : _("<corrupt>"));
10560 }
10561 }
10562 }
10563 }
10564 }
10565 return version_string;
10566}
10567
e3c8793a 10568/* Dump the symbol table. */
252b5132 10569static int
2cf0635d 10570process_symbol_table (FILE * file)
252b5132 10571{
2cf0635d 10572 Elf_Internal_Shdr * section;
8b73c356
NC		 10573 bfd_size_type nbuckets = 0;
10574 bfd_size_type nchains = 0;
2cf0635d
NC		 10575 bfd_vma * buckets = NULL;
10576 bfd_vma * chains = NULL;
fdc90cb4 10577 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10578 bfd_vma * gnubuckets = NULL;
10579 bfd_vma * gnuchains = NULL;
6bd1a22c 10580 bfd_vma gnusymidx = 0;
071436c6 10581 bfd_size_type ngnuchains = 0;
252b5132 10582
2c610e4b 10583 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10584 return 1;
10585
6bd1a22c
L		 10586 if (dynamic_info[DT_HASH]
10587 && (do_histogram
2c610e4b
L		 10588 || (do_using_dynamic
10589 && !do_dyn_syms
10590 && dynamic_strings != NULL)))
252b5132 10591 {
66543521
AM		 10592 unsigned char nb[8];
10593 unsigned char nc[8];
8b73c356 10594 unsigned int hash_ent_size = 4;
66543521
AM		 10595
10596 if ((elf_header.e_machine == EM_ALPHA
10597 || elf_header.e_machine == EM_S390
10598 || elf_header.e_machine == EM_S390_OLD)
10599 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10600 hash_ent_size = 8;
10601
fb52b2f4
NC		 10602 if (fseek (file,
10603 (archive_file_offset
10604 + offset_from_vma (file, dynamic_info[DT_HASH],
10605 sizeof nb + sizeof nc)),
d93f0186 10606 SEEK_SET))
252b5132 10607 {
591a748a 10608 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10609 goto no_hash;
252b5132
RH		 10610 }
10611
66543521 10612 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10613 {
10614 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10615 goto no_hash;
252b5132
RH		 10616 }
10617
66543521 10618 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10619 {
10620 error (_("Failed to read in number of chains\n"));
d3a44ec6 10621 goto no_hash;
252b5132
RH		 10622 }
10623
66543521
AM		 10624 nbuckets = byte_get (nb, hash_ent_size);
10625 nchains = byte_get (nc, hash_ent_size);
252b5132 10626
66543521
AM		 10627 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10628 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10629
d3a44ec6 10630 no_hash:
252b5132 10631 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10632 {
10633 if (do_using_dynamic)
10634 return 0;
10635 free (buckets);
10636 free (chains);
10637 buckets = NULL;
10638 chains = NULL;
10639 nbuckets = 0;
10640 nchains = 0;
10641 }
252b5132
RH		 10642 }
10643
6bd1a22c
L		 10644 if (dynamic_info_DT_GNU_HASH
10645 && (do_histogram
2c610e4b
L		 10646 || (do_using_dynamic
10647 && !do_dyn_syms
10648 && dynamic_strings != NULL)))
252b5132 10649 {
6bd1a22c
L		 10650 unsigned char nb[16];
10651 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10652 bfd_vma buckets_vma;
10653
10654 if (fseek (file,
10655 (archive_file_offset
10656 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10657 sizeof nb)),
10658 SEEK_SET))
10659 {
10660 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10661 goto no_gnu_hash;
6bd1a22c 10662 }
252b5132 10663
6bd1a22c
L		 10664 if (fread (nb, 16, 1, file) != 1)
10665 {
10666 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10667 goto no_gnu_hash;
6bd1a22c
L		 10668 }
10669
10670 ngnubuckets = byte_get (nb, 4);
10671 gnusymidx = byte_get (nb + 4, 4);
10672 bitmaskwords = byte_get (nb + 8, 4);
10673 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10674 if (is_32bit_elf)
6bd1a22c 10675 buckets_vma += bitmaskwords * 4;
f7a99963 10676 else
6bd1a22c 10677 buckets_vma += bitmaskwords * 8;
252b5132 10678
6bd1a22c
L		 10679 if (fseek (file,
10680 (archive_file_offset
10681 + offset_from_vma (file, buckets_vma, 4)),
10682 SEEK_SET))
252b5132 10683 {
6bd1a22c 10684 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10685 goto no_gnu_hash;
6bd1a22c
L		 10686 }
10687
10688 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10689
6bd1a22c 10690 if (gnubuckets == NULL)
d3a44ec6 10691 goto no_gnu_hash;
6bd1a22c
L		 10692
10693 for (i = 0; i < ngnubuckets; i++)
10694 if (gnubuckets[i] != 0)
10695 {
10696 if (gnubuckets[i] < gnusymidx)
10697 return 0;
10698
10699 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10700 maxchain = gnubuckets[i];
10701 }
10702
10703 if (maxchain == 0xffffffff)
d3a44ec6 10704 goto no_gnu_hash;
6bd1a22c
L		 10705
10706 maxchain -= gnusymidx;
10707
10708 if (fseek (file,
10709 (archive_file_offset
10710 + offset_from_vma (file, buckets_vma
10711 + 4 * (ngnubuckets + maxchain), 4)),
10712 SEEK_SET))
10713 {
10714 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10715 goto no_gnu_hash;
6bd1a22c
L		 10716 }
10717
10718 do
10719 {
10720 if (fread (nb, 4, 1, file) != 1)
252b5132 10721 {
6bd1a22c 10722 error (_("Failed to determine last chain length\n"));
d3a44ec6 10723 goto no_gnu_hash;
6bd1a22c 10724 }
252b5132 10725
6bd1a22c 10726 if (maxchain + 1 == 0)
d3a44ec6 10727 goto no_gnu_hash;
252b5132 10728
6bd1a22c
L		 10729 ++maxchain;
10730 }
10731 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10732
6bd1a22c
L		 10733 if (fseek (file,
10734 (archive_file_offset
10735 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10736 SEEK_SET))
10737 {
10738 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10739 goto no_gnu_hash;
6bd1a22c
L		 10740 }
10741
10742 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10743 ngnuchains = maxchain;
6bd1a22c 10744
d3a44ec6 10745 no_gnu_hash:
6bd1a22c 10746 if (gnuchains == NULL)
d3a44ec6
JJ		 10747 {
10748 free (gnubuckets);
d3a44ec6
JJ		 10749 gnubuckets = NULL;
10750 ngnubuckets = 0;
f64fddf1
NC		 10751 if (do_using_dynamic)
10752 return 0;
d3a44ec6 10753 }
6bd1a22c
L		 10754 }
10755
10756 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10757 && do_syms
10758 && do_using_dynamic
3102e897
NC		 10759 && dynamic_strings != NULL
10760 && dynamic_symbols != NULL)
6bd1a22c
L		 10761 {
10762 unsigned long hn;
10763
10764 if (dynamic_info[DT_HASH])
10765 {
10766 bfd_vma si;
10767
10768 printf (_("\nSymbol table for image:\n"));
10769 if (is_32bit_elf)
10770 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10771 else
10772 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10773
10774 for (hn = 0; hn < nbuckets; hn++)
10775 {
10776 if (! buckets[hn])
10777 continue;
10778
10779 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10780 print_dynamic_symbol (si, hn);
252b5132
RH		 10781 }
10782 }
6bd1a22c
L		 10783
10784 if (dynamic_info_DT_GNU_HASH)
10785 {
10786 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10787 if (is_32bit_elf)
10788 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10789 else
10790 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10791
10792 for (hn = 0; hn < ngnubuckets; ++hn)
10793 if (gnubuckets[hn] != 0)
10794 {
10795 bfd_vma si = gnubuckets[hn];
10796 bfd_vma off = si - gnusymidx;
10797
10798 do
10799 {
10800 print_dynamic_symbol (si, hn);
10801 si++;
10802 }
071436c6 10803 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10804 }
10805 }
252b5132 10806 }
8b73c356
NC		 10807 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10808 && section_headers != NULL)
252b5132 10809 {
b34976b6 10810 unsigned int i;
252b5132
RH		 10811
10812 for (i = 0, section = section_headers;
10813 i < elf_header.e_shnum;
10814 i++, section++)
10815 {
b34976b6 10816 unsigned int si;
2cf0635d 10817 char * strtab = NULL;
c256ffe7 10818 unsigned long int strtab_size = 0;
2cf0635d
NC		 10819 Elf_Internal_Sym * symtab;
10820 Elf_Internal_Sym * psym;
ba5cdace 10821 unsigned long num_syms;
252b5132 10822
2c610e4b
L		 10823 if ((section->sh_type != SHT_SYMTAB
10824 && section->sh_type != SHT_DYNSYM)
10825 || (!do_syms
10826 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10827 continue;
10828
dd24e3da
NC		 10829 if (section->sh_entsize == 0)
10830 {
10831 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10832 printable_section_name (section));
dd24e3da
NC		 10833 continue;
10834 }
10835
252b5132 10836 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10837 printable_section_name (section),
252b5132 10838 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10839
f7a99963 10840 if (is_32bit_elf)
ca47b30c 10841 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10842 else
ca47b30c 10843 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10844
ba5cdace 10845 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10846 if (symtab == NULL)
10847 continue;
10848
10849 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10850 {
10851 strtab = string_table;
10852 strtab_size = string_table_length;
10853 }
4fbb74a6 10854 else if (section->sh_link < elf_header.e_shnum)
252b5132 10855 {
2cf0635d 10856 Elf_Internal_Shdr * string_sec;
252b5132 10857
4fbb74a6 10858 string_sec = section_headers + section->sh_link;
252b5132 10859
3f5e193b
NC		 10860 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10861 1, string_sec->sh_size,
10862 _("string table"));
c256ffe7 10863 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10864 }
10865
ba5cdace 10866 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10867 {
bb4d2ac2
L		 10868 const char *version_string;
10869 enum versioned_symbol_info sym_info;
10870 unsigned short vna_other;
10871
5e220199 10872 printf ("%6d: ", si);
f7a99963
NC		 10873 print_vma (psym->st_value, LONG_HEX);
10874 putchar (' ');
10875 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10876 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10877 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10878 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10879 /* Check to see if any other bits in the st_other field are set.
10880 Note - displaying this information disrupts the layout of the
10881 table being generated, but for the moment this case is very rare. */
10882 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10883 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10884 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10885 print_symbol (25, psym->st_name < strtab_size
2b692964 10886 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10887
bb4d2ac2
L		 10888 version_string
10889 = get_symbol_version_string (file,
10890 section->sh_type == SHT_DYNSYM,
10891 strtab, strtab_size, si,
10892 psym, &sym_info, &vna_other);
10893 if (version_string)
252b5132 10894 {
bb4d2ac2
L		 10895 if (sym_info == symbol_undefined)
10896 printf ("@%s (%d)", version_string, vna_other);
10897 else
10898 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10899 version_string);
252b5132
RH		 10900 }
10901
10902 putchar ('\n');
10903 }
10904
10905 free (symtab);
10906 if (strtab != string_table)
10907 free (strtab);
10908 }
10909 }
10910 else if (do_syms)
10911 printf
10912 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10913
10914 if (do_histogram && buckets != NULL)
10915 {
2cf0635d
NC		 10916 unsigned long * lengths;
10917 unsigned long * counts;
66543521
AM		 10918 unsigned long hn;
10919 bfd_vma si;
10920 unsigned long maxlength = 0;
10921 unsigned long nzero_counts = 0;
10922 unsigned long nsyms = 0;
94d15024 10923 unsigned long chained;
252b5132 10924
66543521
AM		 10925 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10926 (unsigned long) nbuckets);
252b5132 10927
3f5e193b 10928 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10929 if (lengths == NULL)
10930 {
8b73c356 10931 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10932 return 0;
10933 }
8b73c356
NC		 10934
10935 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10936 for (hn = 0; hn < nbuckets; ++hn)
10937 {
94d15024
MF		 10938 for (si = buckets[hn], chained = 0;
10939 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10940 si = chains[si], ++chained)
252b5132 10941 {
b34976b6 10942 ++nsyms;
252b5132 10943 if (maxlength < ++lengths[hn])
b34976b6 10944 ++maxlength;
252b5132 10945 }
94d15024
MF		 10946
10947 /* PR binutils/17531: A corrupt binary could contain broken
10948 histogram data. Do not go into an infinite loop trying
10949 to process it. */
10950 if (chained > nchains)
10951 {
10952 error (_("histogram chain is corrupt\n"));
10953 break;
10954 }
252b5132
RH		 10955 }
10956
3f5e193b 10957 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10958 if (counts == NULL)
10959 {
b2e951ec 10960 free (lengths);
8b73c356 10961 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10962 return 0;
10963 }
10964
10965 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10966 ++counts[lengths[hn]];
252b5132 10967
103f02d3 10968 if (nbuckets > 0)
252b5132 10969 {
66543521
AM		 10970 unsigned long i;
10971 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10972 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10973 for (i = 1; i <= maxlength; ++i)
103f02d3 10974 {
66543521
AM		 10975 nzero_counts += counts[i] * i;
10976 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10977 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10978 (nzero_counts * 100.0) / nsyms);
10979 }
252b5132
RH		 10980 }
10981
10982 free (counts);
10983 free (lengths);
10984 }
10985
10986 if (buckets != NULL)
10987 {
10988 free (buckets);
10989 free (chains);
10990 }
10991
d3a44ec6 10992 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10993 {
2cf0635d
NC		 10994 unsigned long * lengths;
10995 unsigned long * counts;
fdc90cb4
JJ		 10996 unsigned long hn;
10997 unsigned long maxlength = 0;
10998 unsigned long nzero_counts = 0;
10999 unsigned long nsyms = 0;
fdc90cb4 11000
8b73c356
NC		 11001 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11002 (unsigned long) ngnubuckets);
11003
3f5e193b 11004 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11005 if (lengths == NULL)
11006 {
8b73c356 11007 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11008 return 0;
11009 }
11010
fdc90cb4
JJ		 11011 printf (_(" Length Number %% of total Coverage\n"));
11012
11013 for (hn = 0; hn < ngnubuckets; ++hn)
11014 if (gnubuckets[hn] != 0)
11015 {
11016 bfd_vma off, length = 1;
11017
6bd1a22c 11018 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11019 /* PR 17531 file: 010-77222-0.004. */
11020 off < ngnuchains && (gnuchains[off] & 1) == 0;
11021 ++off)
fdc90cb4
JJ		 11022 ++length;
11023 lengths[hn] = length;
11024 if (length > maxlength)
11025 maxlength = length;
11026 nsyms += length;
11027 }
11028
3f5e193b 11029 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11030 if (counts == NULL)
11031 {
b2e951ec 11032 free (lengths);
8b73c356 11033 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11034 return 0;
11035 }
11036
11037 for (hn = 0; hn < ngnubuckets; ++hn)
11038 ++counts[lengths[hn]];
11039
11040 if (ngnubuckets > 0)
11041 {
11042 unsigned long j;
11043 printf (" 0 %-10lu (%5.1f%%)\n",
11044 counts[0], (counts[0] * 100.0) / ngnubuckets);
11045 for (j = 1; j <= maxlength; ++j)
11046 {
11047 nzero_counts += counts[j] * j;
11048 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11049 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11050 (nzero_counts * 100.0) / nsyms);
11051 }
11052 }
11053
11054 free (counts);
11055 free (lengths);
11056 free (gnubuckets);
11057 free (gnuchains);
11058 }
11059
252b5132
RH		 11060 return 1;
11061}
11062
11063static int
2cf0635d 11064process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11065{
b4c96d0d 11066 unsigned int i;
252b5132
RH		 11067
11068 if (dynamic_syminfo == NULL
11069 || !do_dynamic)
11070 /* No syminfo, this is ok. */
11071 return 1;
11072
11073 /* There better should be a dynamic symbol section. */
11074 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11075 return 0;
11076
11077 if (dynamic_addr)
11078 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11079 dynamic_syminfo_offset, dynamic_syminfo_nent);
11080
11081 printf (_(" Num: Name BoundTo Flags\n"));
11082 for (i = 0; i < dynamic_syminfo_nent; ++i)
11083 {
11084 unsigned short int flags = dynamic_syminfo[i].si_flags;
11085
31104126 11086 printf ("%4d: ", i);
4082ef84
NC		 11087 if (i >= num_dynamic_syms)
11088 printf (_("<corrupt index>"));
11089 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11090 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11091 else
2b692964 11092 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11093 putchar (' ');
252b5132
RH		 11094
11095 switch (dynamic_syminfo[i].si_boundto)
11096 {
11097 case SYMINFO_BT_SELF:
11098 fputs ("SELF ", stdout);
11099 break;
11100 case SYMINFO_BT_PARENT:
11101 fputs ("PARENT ", stdout);
11102 break;
11103 default:
11104 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11105 && dynamic_syminfo[i].si_boundto < dynamic_nent
11106 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11107 {
d79b3d50 11108 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11109 putchar (' ' );
11110 }
252b5132
RH		 11111 else
11112 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11113 break;
11114 }
11115
11116 if (flags & SYMINFO_FLG_DIRECT)
11117 printf (" DIRECT");
11118 if (flags & SYMINFO_FLG_PASSTHRU)
11119 printf (" PASSTHRU");
11120 if (flags & SYMINFO_FLG_COPY)
11121 printf (" COPY");
11122 if (flags & SYMINFO_FLG_LAZYLOAD)
11123 printf (" LAZYLOAD");
11124
11125 puts ("");
11126 }
11127
11128 return 1;
11129}
11130
cf13d699
NC		 11131/* Check to see if the given reloc needs to be handled in a target specific
11132 manner. If so then process the reloc and return TRUE otherwise return
11133 FALSE. */
09c11c86 11134
cf13d699
NC		 11135static bfd_boolean
11136target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11137 unsigned char * start,
11138 Elf_Internal_Sym * symtab)
252b5132 11139{
cf13d699 11140 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11141
cf13d699 11142 switch (elf_header.e_machine)
252b5132 11143 {
13761a11
NC		 11144 case EM_MSP430:
11145 case EM_MSP430_OLD:
11146 {
11147 static Elf_Internal_Sym * saved_sym = NULL;
11148
11149 switch (reloc_type)
11150 {
11151 case 10: /* R_MSP430_SYM_DIFF */
11152 if (uses_msp430x_relocs ())
11153 break;
11154 case 21: /* R_MSP430X_SYM_DIFF */
11155 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11156 return TRUE;
11157
11158 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11159 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11160 goto handle_sym_diff;
0b4362b0 11161
13761a11
NC		 11162 case 5: /* R_MSP430_16_BYTE */
11163 case 9: /* R_MSP430_8 */
11164 if (uses_msp430x_relocs ())
11165 break;
11166 goto handle_sym_diff;
11167
11168 case 2: /* R_MSP430_ABS16 */
11169 case 15: /* R_MSP430X_ABS16 */
11170 if (! uses_msp430x_relocs ())
11171 break;
11172 goto handle_sym_diff;
0b4362b0 11173
13761a11
NC		 11174 handle_sym_diff:
11175 if (saved_sym != NULL)
11176 {
11177 bfd_vma value;
11178
11179 value = reloc->r_addend
11180 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11181 - saved_sym->st_value);
11182
11183 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11184
11185 saved_sym = NULL;
11186 return TRUE;
11187 }
11188 break;
11189
11190 default:
11191 if (saved_sym != NULL)
071436c6 11192 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11193 break;
11194 }
11195 break;
11196 }
11197
cf13d699
NC		 11198 case EM_MN10300:
11199 case EM_CYGNUS_MN10300:
11200 {
11201 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11202
cf13d699
NC		 11203 switch (reloc_type)
11204 {
11205 case 34: /* R_MN10300_ALIGN */
11206 return TRUE;
11207 case 33: /* R_MN10300_SYM_DIFF */
11208 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11209 return TRUE;
11210 case 1: /* R_MN10300_32 */
11211 case 2: /* R_MN10300_16 */
11212 if (saved_sym != NULL)
11213 {
11214 bfd_vma value;
252b5132 11215
cf13d699
NC		 11216 value = reloc->r_addend
11217 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11218 - saved_sym->st_value);
252b5132 11219
cf13d699 11220 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11221
cf13d699
NC		 11222 saved_sym = NULL;
11223 return TRUE;
11224 }
11225 break;
11226 default:
11227 if (saved_sym != NULL)
071436c6 11228 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11229 break;
11230 }
11231 break;
11232 }
6ff71e76
NC		 11233
11234 case EM_RL78:
11235 {
11236 static bfd_vma saved_sym1 = 0;
11237 static bfd_vma saved_sym2 = 0;
11238 static bfd_vma value;
11239
11240 switch (reloc_type)
11241 {
11242 case 0x80: /* R_RL78_SYM. */
11243 saved_sym1 = saved_sym2;
11244 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11245 saved_sym2 += reloc->r_addend;
11246 return TRUE;
11247
11248 case 0x83: /* R_RL78_OPsub. */
11249 value = saved_sym1 - saved_sym2;
11250 saved_sym2 = saved_sym1 = 0;
11251 return TRUE;
11252 break;
11253
11254 case 0x41: /* R_RL78_ABS32. */
11255 byte_put (start + reloc->r_offset, value, 4);
11256 value = 0;
11257 return TRUE;
11258
11259 case 0x43: /* R_RL78_ABS16. */
11260 byte_put (start + reloc->r_offset, value, 2);
11261 value = 0;
11262 return TRUE;
11263
11264 default:
11265 break;
11266 }
11267 break;
11268 }
252b5132
RH		 11269 }
11270
cf13d699 11271 return FALSE;
252b5132
RH		 11272}
11273
aca88567
NC		 11274/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11275 DWARF debug sections. This is a target specific test. Note - we do not
11276 go through the whole including-target-headers-multiple-times route, (as
11277 we have already done with <elf/h8.h>) because this would become very
11278 messy and even then this function would have to contain target specific
11279 information (the names of the relocs instead of their numeric values).
11280 FIXME: This is not the correct way to solve this problem. The proper way
11281 is to have target specific reloc sizing and typing functions created by
11282 the reloc-macros.h header, in the same way that it already creates the
11283 reloc naming functions. */
11284
11285static bfd_boolean
11286is_32bit_abs_reloc (unsigned int reloc_type)
11287{
11288 switch (elf_header.e_machine)
11289 {
41e92641 11290 case EM_386:
22abe556 11291 case EM_IAMCU:
41e92641 11292 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11293 case EM_68K:
11294 return reloc_type == 1; /* R_68K_32. */
11295 case EM_860:
11296 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11297 case EM_960:
11298 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11299 case EM_AARCH64:
11300 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11301 case EM_ALPHA:
137b6b5f 11302 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11303 case EM_ARC:
11304 return reloc_type == 1; /* R_ARC_32. */
11305 case EM_ARM:
11306 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11307 case EM_AVR_OLD:
aca88567
NC		 11308 case EM_AVR:
11309 return reloc_type == 1;
cfb8c092
NC		 11310 case EM_ADAPTEVA_EPIPHANY:
11311 return reloc_type == 3;
aca88567
NC		 11312 case EM_BLACKFIN:
11313 return reloc_type == 0x12; /* R_byte4_data. */
11314 case EM_CRIS:
11315 return reloc_type == 3; /* R_CRIS_32. */
11316 case EM_CR16:
11317 return reloc_type == 3; /* R_CR16_NUM32. */
11318 case EM_CRX:
11319 return reloc_type == 15; /* R_CRX_NUM32. */
11320 case EM_CYGNUS_FRV:
11321 return reloc_type == 1;
41e92641
NC		 11322 case EM_CYGNUS_D10V:
11323 case EM_D10V:
11324 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11325 case EM_CYGNUS_D30V:
11326 case EM_D30V:
11327 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11328 case EM_DLX:
11329 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11330 case EM_CYGNUS_FR30:
11331 case EM_FR30:
11332 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11333 case EM_FT32:
11334 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11335 case EM_H8S:
11336 case EM_H8_300:
11337 case EM_H8_300H:
11338 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11339 case EM_IA_64:
d1c4b12b
NC		 11340 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11341 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11342 case EM_IP2K_OLD:
11343 case EM_IP2K:
11344 return reloc_type == 2; /* R_IP2K_32. */
11345 case EM_IQ2000:
11346 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11347 case EM_LATTICEMICO32:
11348 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11349 case EM_M32C_OLD:
aca88567
NC		 11350 case EM_M32C:
11351 return reloc_type == 3; /* R_M32C_32. */
11352 case EM_M32R:
11353 return reloc_type == 34; /* R_M32R_32_RELA. */
11354 case EM_MCORE:
11355 return reloc_type == 1; /* R_MCORE_ADDR32. */
11356 case EM_CYGNUS_MEP:
11357 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11358 case EM_METAG:
11359 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11360 case EM_MICROBLAZE:
11361 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11362 case EM_MIPS:
11363 return reloc_type == 2; /* R_MIPS_32. */
11364 case EM_MMIX:
11365 return reloc_type == 4; /* R_MMIX_32. */
11366 case EM_CYGNUS_MN10200:
11367 case EM_MN10200:
11368 return reloc_type == 1; /* R_MN10200_32. */
11369 case EM_CYGNUS_MN10300:
11370 case EM_MN10300:
11371 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11372 case EM_MOXIE:
11373 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11374 case EM_MSP430_OLD:
11375 case EM_MSP430:
13761a11 11376 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11377 case EM_MT:
11378 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11379 case EM_NDS32:
11380 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11381 case EM_ALTERA_NIOS2:
36591ba1 11382 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11383 case EM_NIOS32:
11384 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11385 case EM_OR1K:
11386 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11387 case EM_PARISC:
5fda8eca
NC		 11388 return (reloc_type == 1 /* R_PARISC_DIR32. */
11389 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11390 case EM_PJ:
11391 case EM_PJ_OLD:
11392 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11393 case EM_PPC64:
11394 return reloc_type == 1; /* R_PPC64_ADDR32. */
11395 case EM_PPC:
11396 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11397 case EM_RL78:
11398 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11399 case EM_RX:
11400 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11401 case EM_S370:
11402 return reloc_type == 1; /* R_I370_ADDR31. */
11403 case EM_S390_OLD:
11404 case EM_S390:
11405 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11406 case EM_SCORE:
11407 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11408 case EM_SH:
11409 return reloc_type == 1; /* R_SH_DIR32. */
11410 case EM_SPARC32PLUS:
11411 case EM_SPARCV9:
11412 case EM_SPARC:
11413 return reloc_type == 3 /* R_SPARC_32. */
11414 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11415 case EM_SPU:
11416 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11417 case EM_TI_C6000:
11418 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11419 case EM_TILEGX:
11420 return reloc_type == 2; /* R_TILEGX_32. */
11421 case EM_TILEPRO:
11422 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11423 case EM_CYGNUS_V850:
11424 case EM_V850:
11425 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11426 case EM_V800:
11427 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11428 case EM_VAX:
11429 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11430 case EM_VISIUM:
11431 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11432 case EM_X86_64:
8a9036a4 11433 case EM_L1OM:
7a9068fe 11434 case EM_K1OM:
aca88567 11435 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11436 case EM_XC16X:
11437 case EM_C166:
11438 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11439 case EM_XGATE:
11440 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11441 case EM_XSTORMY16:
11442 return reloc_type == 1; /* R_XSTROMY16_32. */
11443 case EM_XTENSA_OLD:
11444 case EM_XTENSA:
11445 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11446 default:
bee0ee85
NC		 11447 {
11448 static unsigned int prev_warn = 0;
11449
11450 /* Avoid repeating the same warning multiple times. */
11451 if (prev_warn != elf_header.e_machine)
11452 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11453 elf_header.e_machine);
11454 prev_warn = elf_header.e_machine;
11455 return FALSE;
11456 }
aca88567
NC		 11457 }
11458}
11459
11460/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11461 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11462
11463static bfd_boolean
11464is_32bit_pcrel_reloc (unsigned int reloc_type)
11465{
11466 switch (elf_header.e_machine)
11467 {
41e92641 11468 case EM_386:
22abe556 11469 case EM_IAMCU:
3e0873ac 11470 return reloc_type == 2; /* R_386_PC32. */
aca88567 11471 case EM_68K:
3e0873ac 11472 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11473 case EM_AARCH64:
11474 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11475 case EM_ADAPTEVA_EPIPHANY:
11476 return reloc_type == 6;
aca88567
NC		 11477 case EM_ALPHA:
11478 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11479 case EM_ARM:
3e0873ac 11480 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11481 case EM_MICROBLAZE:
11482 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11483 case EM_OR1K:
11484 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11485 case EM_PARISC:
85acf597 11486 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11487 case EM_PPC:
11488 return reloc_type == 26; /* R_PPC_REL32. */
11489 case EM_PPC64:
3e0873ac 11490 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11491 case EM_S390_OLD:
11492 case EM_S390:
3e0873ac 11493 return reloc_type == 5; /* R_390_PC32. */
aca88567 11494 case EM_SH:
3e0873ac 11495 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11496 case EM_SPARC32PLUS:
11497 case EM_SPARCV9:
11498 case EM_SPARC:
3e0873ac 11499 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11500 case EM_SPU:
11501 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11502 case EM_TILEGX:
11503 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11504 case EM_TILEPRO:
11505 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11506 case EM_VISIUM:
11507 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11508 case EM_X86_64:
8a9036a4 11509 case EM_L1OM:
7a9068fe 11510 case EM_K1OM:
3e0873ac 11511 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11512 case EM_XTENSA_OLD:
11513 case EM_XTENSA:
11514 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11515 default:
11516 /* Do not abort or issue an error message here. Not all targets use
11517 pc-relative 32-bit relocs in their DWARF debug information and we
11518 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11519 more helpful warning message will be generated by apply_relocations
11520 anyway, so just return. */
aca88567
NC		 11521 return FALSE;
11522 }
11523}
11524
11525/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11526 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11527
11528static bfd_boolean
11529is_64bit_abs_reloc (unsigned int reloc_type)
11530{
11531 switch (elf_header.e_machine)
11532 {
a06ea964
NC		 11533 case EM_AARCH64:
11534 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11535 case EM_ALPHA:
11536 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11537 case EM_IA_64:
11538 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11539 case EM_PARISC:
11540 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11541 case EM_PPC64:
11542 return reloc_type == 38; /* R_PPC64_ADDR64. */
11543 case EM_SPARC32PLUS:
11544 case EM_SPARCV9:
11545 case EM_SPARC:
11546 return reloc_type == 54; /* R_SPARC_UA64. */
11547 case EM_X86_64:
8a9036a4 11548 case EM_L1OM:
7a9068fe 11549 case EM_K1OM:
aca88567 11550 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11551 case EM_S390_OLD:
11552 case EM_S390:
aa137e4d
NC		 11553 return reloc_type == 22; /* R_S390_64. */
11554 case EM_TILEGX:
11555 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11556 case EM_MIPS:
aa137e4d 11557 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11558 default:
11559 return FALSE;
11560 }
11561}
11562
85acf597
RH		 11563/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11564 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11565
11566static bfd_boolean
11567is_64bit_pcrel_reloc (unsigned int reloc_type)
11568{
11569 switch (elf_header.e_machine)
11570 {
a06ea964
NC		 11571 case EM_AARCH64:
11572 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11573 case EM_ALPHA:
aa137e4d 11574 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11575 case EM_IA_64:
aa137e4d 11576 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11577 case EM_PARISC:
aa137e4d 11578 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11579 case EM_PPC64:
aa137e4d 11580 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11581 case EM_SPARC32PLUS:
11582 case EM_SPARCV9:
11583 case EM_SPARC:
aa137e4d 11584 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11585 case EM_X86_64:
8a9036a4 11586 case EM_L1OM:
7a9068fe 11587 case EM_K1OM:
aa137e4d 11588 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11589 case EM_S390_OLD:
11590 case EM_S390:
aa137e4d
NC		 11591 return reloc_type == 23; /* R_S390_PC64. */
11592 case EM_TILEGX:
11593 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11594 default:
11595 return FALSE;
11596 }
11597}
11598
4dc3c23d
AM		 11599/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11600 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11601
11602static bfd_boolean
11603is_24bit_abs_reloc (unsigned int reloc_type)
11604{
11605 switch (elf_header.e_machine)
11606 {
11607 case EM_CYGNUS_MN10200:
11608 case EM_MN10200:
11609 return reloc_type == 4; /* R_MN10200_24. */
11610 default:
11611 return FALSE;
11612 }
11613}
11614
aca88567
NC		 11615/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11616 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11617
11618static bfd_boolean
11619is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11620{
11621 switch (elf_header.e_machine)
11622 {
aca88567
NC		 11623 case EM_AVR_OLD:
11624 case EM_AVR:
11625 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11626 case EM_ADAPTEVA_EPIPHANY:
11627 return reloc_type == 5;
41e92641
NC		 11628 case EM_CYGNUS_D10V:
11629 case EM_D10V:
11630 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11631 case EM_H8S:
11632 case EM_H8_300:
11633 case EM_H8_300H:
aca88567
NC		 11634 return reloc_type == R_H8_DIR16;
11635 case EM_IP2K_OLD:
11636 case EM_IP2K:
11637 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11638 case EM_M32C_OLD:
f4236fe4
DD		 11639 case EM_M32C:
11640 return reloc_type == 1; /* R_M32C_16 */
aca88567 11641 case EM_MSP430:
13761a11
NC		 11642 if (uses_msp430x_relocs ())
11643 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11644 case EM_MSP430_OLD:
aca88567 11645 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11646 case EM_NDS32:
11647 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11648 case EM_ALTERA_NIOS2:
36591ba1 11649 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11650 case EM_NIOS32:
11651 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11652 case EM_OR1K:
11653 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11654 case EM_TI_C6000:
11655 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11656 case EM_XC16X:
11657 case EM_C166:
11658 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11659 case EM_CYGNUS_MN10200:
11660 case EM_MN10200:
11661 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11662 case EM_CYGNUS_MN10300:
11663 case EM_MN10300:
11664 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11665 case EM_VISIUM:
11666 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11667 case EM_XGATE:
11668 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11669 default:
aca88567 11670 return FALSE;
4b78141a
NC		 11671 }
11672}
11673
2a7b2e88
JK		 11674/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11675 relocation entries (possibly formerly used for SHT_GROUP sections). */
11676
11677static bfd_boolean
11678is_none_reloc (unsigned int reloc_type)
11679{
11680 switch (elf_header.e_machine)
11681 {
cb8f3167
NC		 11682 case EM_68K: /* R_68K_NONE. */
11683 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11684 case EM_SPARC32PLUS:
11685 case EM_SPARCV9:
cb8f3167
NC		 11686 case EM_SPARC: /* R_SPARC_NONE. */
11687 case EM_MIPS: /* R_MIPS_NONE. */
11688 case EM_PARISC: /* R_PARISC_NONE. */
11689 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11690 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11691 case EM_PPC: /* R_PPC_NONE. */
11692 case EM_PPC64: /* R_PPC64_NONE. */
11693 case EM_ARM: /* R_ARM_NONE. */
11694 case EM_IA_64: /* R_IA64_NONE. */
11695 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11696 case EM_S390_OLD:
cb8f3167
NC		 11697 case EM_S390: /* R_390_NONE. */
11698 case EM_CRIS: /* R_CRIS_NONE. */
11699 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11700 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11701 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11702 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11703 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11704 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11705 case EM_M32R: /* R_M32R_NONE. */
40b36596 11706 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11707 case EM_TILEGX: /* R_TILEGX_NONE. */
11708 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11709 case EM_XC16X:
11710 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11711 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11712 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11713 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11714 return reloc_type == 0;
a06ea964
NC		 11715 case EM_AARCH64:
11716 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11717 case EM_NDS32:
11718 return (reloc_type == 0 /* R_XTENSA_NONE. */
11719 || reloc_type == 204 /* R_NDS32_DIFF8. */
11720 || reloc_type == 205 /* R_NDS32_DIFF16. */
11721 || reloc_type == 206 /* R_NDS32_DIFF32. */
11722 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11723 case EM_XTENSA_OLD:
11724 case EM_XTENSA:
4dc3c23d
AM		 11725 return (reloc_type == 0 /* R_XTENSA_NONE. */
11726 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11727 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11728 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11729 case EM_METAG:
11730 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11731 }
11732 return FALSE;
11733}
11734
d1c4b12b
NC		 11735/* Returns TRUE if there is a relocation against
11736 section NAME at OFFSET bytes. */
11737
11738bfd_boolean
11739reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11740{
11741 Elf_Internal_Rela * relocs;
11742 Elf_Internal_Rela * rp;
11743
11744 if (dsec == NULL || dsec->reloc_info == NULL)
11745 return FALSE;
11746
11747 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11748
11749 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11750 if (rp->r_offset == offset)
11751 return TRUE;
11752
11753 return FALSE;
11754}
11755
cf13d699
NC		 11756/* Apply relocations to a section.
11757 Note: So far support has been added only for those relocations
11758 which can be found in debug sections.
d1c4b12b
NC		 11759 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11760 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11761 FIXME: Add support for more relocations ? */
1b315056 11762
cf13d699 11763static void
d1c4b12b
NC		 11764apply_relocations (void * file,
11765 const Elf_Internal_Shdr * section,
11766 unsigned char * start,
11767 bfd_size_type size,
11768 void ** relocs_return,
11769 unsigned long * num_relocs_return)
1b315056 11770{
cf13d699 11771 Elf_Internal_Shdr * relsec;
0d2a7a93 11772 unsigned char * end = start + size;
cb8f3167 11773
d1c4b12b
NC		 11774 if (relocs_return != NULL)
11775 {
11776 * (Elf_Internal_Rela **) relocs_return = NULL;
11777 * num_relocs_return = 0;
11778 }
11779
cf13d699
NC		 11780 if (elf_header.e_type != ET_REL)
11781 return;
1b315056 11782
cf13d699 11783 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11784 for (relsec = section_headers;
11785 relsec < section_headers + elf_header.e_shnum;
11786 ++relsec)
252b5132 11787 {
41e92641
NC		 11788 bfd_boolean is_rela;
11789 unsigned long num_relocs;
2cf0635d
NC		 11790 Elf_Internal_Rela * relocs;
11791 Elf_Internal_Rela * rp;
11792 Elf_Internal_Shdr * symsec;
11793 Elf_Internal_Sym * symtab;
ba5cdace 11794 unsigned long num_syms;
2cf0635d 11795 Elf_Internal_Sym * sym;
252b5132 11796
41e92641 11797 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11798 || relsec->sh_info >= elf_header.e_shnum
11799 || section_headers + relsec->sh_info != section
c256ffe7 11800 || relsec->sh_size == 0
4fbb74a6 11801 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11802 continue;
428409d5 11803
41e92641
NC		 11804 is_rela = relsec->sh_type == SHT_RELA;
11805
11806 if (is_rela)
11807 {
3f5e193b
NC		 11808 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11809 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11810 return;
11811 }
11812 else
11813 {
3f5e193b
NC		 11814 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11815 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11816 return;
11817 }
11818
11819 /* SH uses RELA but uses in place value instead of the addend field. */
11820 if (elf_header.e_machine == EM_SH)
11821 is_rela = FALSE;
428409d5 11822
4fbb74a6 11823 symsec = section_headers + relsec->sh_link;
ba5cdace 11824 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11825
41e92641 11826 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11827 {
41e92641
NC		 11828 bfd_vma addend;
11829 unsigned int reloc_type;
11830 unsigned int reloc_size;
91d6fa6a 11831 unsigned char * rloc;
ba5cdace 11832 unsigned long sym_index;
4b78141a 11833
aca88567 11834 reloc_type = get_reloc_type (rp->r_info);
41e92641 11835
98fb390a 11836 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11837 continue;
98fb390a
NC		 11838 else if (is_none_reloc (reloc_type))
11839 continue;
11840 else if (is_32bit_abs_reloc (reloc_type)
11841 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11842 reloc_size = 4;
85acf597
RH		 11843 else if (is_64bit_abs_reloc (reloc_type)
11844 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11845 reloc_size = 8;
4dc3c23d
AM		 11846 else if (is_24bit_abs_reloc (reloc_type))
11847 reloc_size = 3;
aca88567
NC		 11848 else if (is_16bit_abs_reloc (reloc_type))
11849 reloc_size = 2;
11850 else
4b78141a 11851 {
bee0ee85
NC		 11852 static unsigned int prev_reloc = 0;
11853 if (reloc_type != prev_reloc)
11854 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11855 reloc_type, printable_section_name (section));
11856 prev_reloc = reloc_type;
4b78141a
NC		 11857 continue;
11858 }
103f02d3 11859
91d6fa6a 11860 rloc = start + rp->r_offset;
c8da6823 11861 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11862 {
11863 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11864 (unsigned long) rp->r_offset,
74e1a04b 11865 printable_section_name (section));
700dd8b7
L		 11866 continue;
11867 }
103f02d3 11868
ba5cdace
NC		 11869 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11870 if (sym_index >= num_syms)
11871 {
11872 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11873 sym_index, printable_section_name (section));
ba5cdace
NC		 11874 continue;
11875 }
11876 sym = symtab + sym_index;
41e92641
NC		 11877
11878 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11879 make sure that it is of an appropriate type.
11880
11881 Relocations against symbols without type can happen.
11882 Gcc -feliminate-dwarf2-dups may generate symbols
11883 without type for debug info.
11884
11885 Icc generates relocations against function symbols
11886 instead of local labels.
11887
11888 Relocations against object symbols can happen, eg when
11889 referencing a global array. For an example of this see
11890 the _clz.o binary in libgcc.a. */
aca88567 11891 if (sym != symtab
55f25fc3 11892 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11893 {
41e92641 11894 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11895 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11896 (long int)(rp - relocs),
74e1a04b 11897 printable_section_name (relsec));
aca88567 11898 continue;
5b18a4bc 11899 }
252b5132 11900
4dc3c23d
AM		 11901 addend = 0;
11902 if (is_rela)
11903 addend += rp->r_addend;
c47320c3
AM		 11904 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11905 partial_inplace. */
4dc3c23d
AM		 11906 if (!is_rela
11907 || (elf_header.e_machine == EM_XTENSA
11908 && reloc_type == 1)
11909 || ((elf_header.e_machine == EM_PJ
11910 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11911 && reloc_type == 1)
11912 || ((elf_header.e_machine == EM_D30V
11913 || elf_header.e_machine == EM_CYGNUS_D30V)
11914 && reloc_type == 12))
91d6fa6a 11915 addend += byte_get (rloc, reloc_size);
cb8f3167 11916
85acf597
RH		 11917 if (is_32bit_pcrel_reloc (reloc_type)
11918 || is_64bit_pcrel_reloc (reloc_type))
11919 {
11920 /* On HPPA, all pc-relative relocations are biased by 8. */
11921 if (elf_header.e_machine == EM_PARISC)
11922 addend -= 8;
91d6fa6a 11923 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11924 reloc_size);
11925 }
41e92641 11926 else
91d6fa6a 11927 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11928 }
252b5132 11929
5b18a4bc 11930 free (symtab);
d1c4b12b
NC		 11931
11932 if (relocs_return)
11933 {
11934 * (Elf_Internal_Rela **) relocs_return = relocs;
11935 * num_relocs_return = num_relocs;
11936 }
11937 else
11938 free (relocs);
11939
5b18a4bc
NC		 11940 break;
11941 }
5b18a4bc 11942}
103f02d3 11943
cf13d699
NC		 11944#ifdef SUPPORT_DISASSEMBLY
11945static int
11946disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11947{
74e1a04b 11948 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11949
74e1a04b 11950 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11951
11952 return 1;
11953}
11954#endif
11955
11956/* Reads in the contents of SECTION from FILE, returning a pointer
11957 to a malloc'ed buffer or NULL if something went wrong. */
11958
11959static char *
11960get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11961{
11962 bfd_size_type num_bytes;
11963
11964 num_bytes = section->sh_size;
11965
11966 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11967 {
11968 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11969 printable_section_name (section));
cf13d699
NC		 11970 return NULL;
11971 }
11972
3f5e193b
NC		 11973 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11974 _("section contents"));
cf13d699
NC		 11975}
11976
0e602686
NC		 11977/* Uncompresses a section that was compressed using zlib, in place. */
11978
11979static bfd_boolean
11980uncompress_section_contents (unsigned char **buffer,
11981 dwarf_size_type uncompressed_size,
11982 dwarf_size_type *size)
11983{
11984 dwarf_size_type compressed_size = *size;
11985 unsigned char * compressed_buffer = *buffer;
11986 unsigned char * uncompressed_buffer;
11987 z_stream strm;
11988 int rc;
11989
11990 /* It is possible the section consists of several compressed
11991 buffers concatenated together, so we uncompress in a loop. */
11992 /* PR 18313: The state field in the z_stream structure is supposed
11993 to be invisible to the user (ie us), but some compilers will
11994 still complain about it being used without initialisation. So
11995 we first zero the entire z_stream structure and then set the fields
11996 that we need. */
11997 memset (& strm, 0, sizeof strm);
11998 strm.avail_in = compressed_size;
11999 strm.next_in = (Bytef *) compressed_buffer;
12000 strm.avail_out = uncompressed_size;
12001 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12002
12003 rc = inflateInit (& strm);
12004 while (strm.avail_in > 0)
12005 {
12006 if (rc != Z_OK)
12007 goto fail;
12008 strm.next_out = ((Bytef *) uncompressed_buffer
12009 + (uncompressed_size - strm.avail_out));
12010 rc = inflate (&strm, Z_FINISH);
12011 if (rc != Z_STREAM_END)
12012 goto fail;
12013 rc = inflateReset (& strm);
12014 }
12015 rc = inflateEnd (& strm);
12016 if (rc != Z_OK
12017 || strm.avail_out != 0)
12018 goto fail;
12019
12020 *buffer = uncompressed_buffer;
12021 *size = uncompressed_size;
12022 return TRUE;
12023
12024 fail:
12025 free (uncompressed_buffer);
12026 /* Indicate decompression failure. */
12027 *buffer = NULL;
12028 return FALSE;
12029}
dd24e3da 12030
cf13d699
NC		 12031static void
12032dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12033{
0e602686
NC		 12034 Elf_Internal_Shdr * relsec;
12035 bfd_size_type num_bytes;
fd8008d8
L		 12036 unsigned char * data;
12037 unsigned char * end;
12038 unsigned char * real_start;
12039 unsigned char * start;
0e602686 12040 bfd_boolean some_strings_shown;
cf13d699 12041
fd8008d8
L		 12042 real_start = start = (unsigned char *) get_section_contents (section,
12043 file);
cf13d699
NC		 12044 if (start == NULL)
12045 return;
0e602686 12046 num_bytes = section->sh_size;
cf13d699 12047
74e1a04b 12048 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12049
0e602686
NC		 12050 if (decompress_dumps)
12051 {
12052 dwarf_size_type new_size = num_bytes;
12053 dwarf_size_type uncompressed_size = 0;
12054
12055 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12056 {
12057 Elf_Internal_Chdr chdr;
12058 unsigned int compression_header_size
12059 = get_compression_header (& chdr, (unsigned char *) start);
12060
813dabb9 12061 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12062 {
813dabb9
L		 12063 warn (_("section '%s' has unsupported compress type: %d\n"),
12064 printable_section_name (section), chdr.ch_type);
12065 return;
12066 }
12067 else if (chdr.ch_addralign != section->sh_addralign)
12068 {
12069 warn (_("compressed section '%s' is corrupted\n"),
12070 printable_section_name (section));
12071 return;
0e602686 12072 }
813dabb9
L		 12073 uncompressed_size = chdr.ch_size;
12074 start += compression_header_size;
12075 new_size -= compression_header_size;
0e602686
NC		 12076 }
12077 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12078 {
12079 /* Read the zlib header. In this case, it should be "ZLIB"
12080 followed by the uncompressed section size, 8 bytes in
12081 big-endian order. */
12082 uncompressed_size = start[4]; uncompressed_size <<= 8;
12083 uncompressed_size += start[5]; uncompressed_size <<= 8;
12084 uncompressed_size += start[6]; uncompressed_size <<= 8;
12085 uncompressed_size += start[7]; uncompressed_size <<= 8;
12086 uncompressed_size += start[8]; uncompressed_size <<= 8;
12087 uncompressed_size += start[9]; uncompressed_size <<= 8;
12088 uncompressed_size += start[10]; uncompressed_size <<= 8;
12089 uncompressed_size += start[11];
12090 start += 12;
12091 new_size -= 12;
12092 }
12093
12094 if (uncompressed_size
fd8008d8 12095 && uncompress_section_contents (& start,
0e602686
NC		 12096 uncompressed_size, & new_size))
12097 num_bytes = new_size;
12098 }
fd8008d8 12099
cf13d699
NC		 12100 /* If the section being dumped has relocations against it the user might
12101 be expecting these relocations to have been applied. Check for this
12102 case and issue a warning message in order to avoid confusion.
12103 FIXME: Maybe we ought to have an option that dumps a section with
12104 relocs applied ? */
12105 for (relsec = section_headers;
12106 relsec < section_headers + elf_header.e_shnum;
12107 ++relsec)
12108 {
12109 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12110 || relsec->sh_info >= elf_header.e_shnum
12111 || section_headers + relsec->sh_info != section
12112 || relsec->sh_size == 0
12113 || relsec->sh_link >= elf_header.e_shnum)
12114 continue;
12115
12116 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12117 break;
12118 }
12119
cf13d699
NC		 12120 data = start;
12121 end = start + num_bytes;
12122 some_strings_shown = FALSE;
12123
12124 while (data < end)
12125 {
12126 while (!ISPRINT (* data))
12127 if (++ data >= end)
12128 break;
12129
12130 if (data < end)
12131 {
071436c6
NC		 12132 size_t maxlen = end - data;
12133
cf13d699 12134#ifndef __MSVCRT__
c975cc98
NC		 12135 /* PR 11128: Use two separate invocations in order to work
12136 around bugs in the Solaris 8 implementation of printf. */
12137 printf (" [%6tx] ", data - start);
cf13d699 12138#else
071436c6 12139 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12140#endif
4082ef84
NC		 12141 if (maxlen > 0)
12142 {
fd8008d8 12143 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12144 putchar ('\n');
fd8008d8 12145 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12146 }
12147 else
12148 {
12149 printf (_("<corrupt>\n"));
12150 data = end;
12151 }
cf13d699
NC		 12152 some_strings_shown = TRUE;
12153 }
12154 }
12155
12156 if (! some_strings_shown)
12157 printf (_(" No strings found in this section."));
12158
0e602686 12159 free (real_start);
cf13d699
NC		 12160
12161 putchar ('\n');
12162}
12163
12164static void
12165dump_section_as_bytes (Elf_Internal_Shdr * section,
12166 FILE * file,
12167 bfd_boolean relocate)
12168{
12169 Elf_Internal_Shdr * relsec;
0e602686
NC		 12170 bfd_size_type bytes;
12171 bfd_size_type section_size;
12172 bfd_vma addr;
12173 unsigned char * data;
12174 unsigned char * real_start;
12175 unsigned char * start;
12176
12177 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12178 if (start == NULL)
12179 return;
0e602686 12180 section_size = section->sh_size;
cf13d699 12181
74e1a04b 12182 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12183
0e602686
NC		 12184 if (decompress_dumps)
12185 {
12186 dwarf_size_type new_size = section_size;
12187 dwarf_size_type uncompressed_size = 0;
12188
12189 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12190 {
12191 Elf_Internal_Chdr chdr;
12192 unsigned int compression_header_size
12193 = get_compression_header (& chdr, start);
12194
813dabb9 12195 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12196 {
813dabb9
L		 12197 warn (_("section '%s' has unsupported compress type: %d\n"),
12198 printable_section_name (section), chdr.ch_type);
12199 return;
0e602686 12200 }
813dabb9
L		 12201 else if (chdr.ch_addralign != section->sh_addralign)
12202 {
12203 warn (_("compressed section '%s' is corrupted\n"),
12204 printable_section_name (section));
12205 return;
12206 }
12207 uncompressed_size = chdr.ch_size;
12208 start += compression_header_size;
12209 new_size -= compression_header_size;
0e602686
NC		 12210 }
12211 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12212 {
12213 /* Read the zlib header. In this case, it should be "ZLIB"
12214 followed by the uncompressed section size, 8 bytes in
12215 big-endian order. */
12216 uncompressed_size = start[4]; uncompressed_size <<= 8;
12217 uncompressed_size += start[5]; uncompressed_size <<= 8;
12218 uncompressed_size += start[6]; uncompressed_size <<= 8;
12219 uncompressed_size += start[7]; uncompressed_size <<= 8;
12220 uncompressed_size += start[8]; uncompressed_size <<= 8;
12221 uncompressed_size += start[9]; uncompressed_size <<= 8;
12222 uncompressed_size += start[10]; uncompressed_size <<= 8;
12223 uncompressed_size += start[11];
12224 start += 12;
12225 new_size -= 12;
12226 }
12227
12228 if (uncompressed_size
12229 && uncompress_section_contents (& start, uncompressed_size,
12230 & new_size))
12231 section_size = new_size;
12232 }
14ae95f2 12233
cf13d699
NC		 12234 if (relocate)
12235 {
0e602686 12236 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12237 }
12238 else
12239 {
12240 /* If the section being dumped has relocations against it the user might
12241 be expecting these relocations to have been applied. Check for this
12242 case and issue a warning message in order to avoid confusion.
12243 FIXME: Maybe we ought to have an option that dumps a section with
12244 relocs applied ? */
12245 for (relsec = section_headers;
12246 relsec < section_headers + elf_header.e_shnum;
12247 ++relsec)
12248 {
12249 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12250 || relsec->sh_info >= elf_header.e_shnum
12251 || section_headers + relsec->sh_info != section
12252 || relsec->sh_size == 0
12253 || relsec->sh_link >= elf_header.e_shnum)
12254 continue;
12255
12256 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12257 break;
12258 }
12259 }
12260
12261 addr = section->sh_addr;
0e602686 12262 bytes = section_size;
cf13d699
NC		 12263 data = start;
12264
12265 while (bytes)
12266 {
12267 int j;
12268 int k;
12269 int lbytes;
12270
12271 lbytes = (bytes > 16 ? 16 : bytes);
12272
12273 printf (" 0x%8.8lx ", (unsigned long) addr);
12274
12275 for (j = 0; j < 16; j++)
12276 {
12277 if (j < lbytes)
12278 printf ("%2.2x", data[j]);
12279 else
12280 printf (" ");
12281
12282 if ((j & 3) == 3)
12283 printf (" ");
12284 }
12285
12286 for (j = 0; j < lbytes; j++)
12287 {
12288 k = data[j];
12289 if (k >= ' ' && k < 0x7f)
12290 printf ("%c", k);
12291 else
12292 printf (".");
12293 }
12294
12295 putchar ('\n');
12296
12297 data += lbytes;
12298 addr += lbytes;
12299 bytes -= lbytes;
12300 }
12301
0e602686 12302 free (real_start);
cf13d699
NC		 12303
12304 putchar ('\n');
12305}
12306
d966045b
DJ		 12307static int
12308load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12309 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12310{
2cf0635d 12311 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12312 char buf [64];
1007acb3 12313
19e6b90e
L		 12314 /* If it is already loaded, do nothing. */
12315 if (section->start != NULL)
12316 return 1;
1007acb3 12317
19e6b90e
L		 12318 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12319 section->address = sec->sh_addr;
06614111 12320 section->user_data = NULL;
3f5e193b
NC		 12321 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12322 sec->sh_offset, 1,
12323 sec->sh_size, buf);
59245841
NC		 12324 if (section->start == NULL)
12325 section->size = 0;
12326 else
12327 {
77115a4a
L		 12328 unsigned char *start = section->start;
12329 dwarf_size_type size = sec->sh_size;
dab394de 12330 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12331
12332 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12333 {
12334 Elf_Internal_Chdr chdr;
12335 unsigned int compression_header_size
12336 = get_compression_header (&chdr, start);
813dabb9
L		 12337 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12338 {
12339 warn (_("section '%s' has unsupported compress type: %d\n"),
12340 section->name, chdr.ch_type);
12341 return 0;
12342 }
12343 else if (chdr.ch_addralign != sec->sh_addralign)
12344 {
12345 warn (_("compressed section '%s' is corrupted\n"),
12346 section->name);
12347 return 0;
12348 }
dab394de 12349 uncompressed_size = chdr.ch_size;
77115a4a
L		 12350 start += compression_header_size;
12351 size -= compression_header_size;
12352 }
dab394de
L		 12353 else if (size > 12 && streq ((char *) start, "ZLIB"))
12354 {
12355 /* Read the zlib header. In this case, it should be "ZLIB"
12356 followed by the uncompressed section size, 8 bytes in
12357 big-endian order. */
12358 uncompressed_size = start[4]; uncompressed_size <<= 8;
12359 uncompressed_size += start[5]; uncompressed_size <<= 8;
12360 uncompressed_size += start[6]; uncompressed_size <<= 8;
12361 uncompressed_size += start[7]; uncompressed_size <<= 8;
12362 uncompressed_size += start[8]; uncompressed_size <<= 8;
12363 uncompressed_size += start[9]; uncompressed_size <<= 8;
12364 uncompressed_size += start[10]; uncompressed_size <<= 8;
12365 uncompressed_size += start[11];
12366 start += 12;
12367 size -= 12;
12368 }
12369
12370 if (uncompressed_size
12371 && uncompress_section_contents (&start, uncompressed_size,
12372 &size))
77115a4a
L		 12373 {
12374 /* Free the compressed buffer, update the section buffer
12375 and the section size if uncompress is successful. */
12376 free (section->start);
12377 section->start = start;
77115a4a
L		 12378 }
12379 section->size = size;
59245841 12380 }
4a114e3e 12381
1b315056
CS		 12382 if (section->start == NULL)
12383 return 0;
12384
19e6b90e 12385 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12386 apply_relocations ((FILE *) file, sec, section->start, section->size,
12387 & section->reloc_info, & section->num_relocs);
12388 else
12389 {
12390 section->reloc_info = NULL;
12391 section->num_relocs = 0;
12392 }
1007acb3 12393
1b315056 12394 return 1;
1007acb3
L		 12395}
12396
657d0d47
CC		 12397/* If this is not NULL, load_debug_section will only look for sections
12398 within the list of sections given here. */
12399unsigned int *section_subset = NULL;
12400
d966045b 12401int
2cf0635d 12402load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12403{
2cf0635d
NC		 12404 struct dwarf_section * section = &debug_displays [debug].section;
12405 Elf_Internal_Shdr * sec;
d966045b
DJ		 12406
12407 /* Locate the debug section. */
657d0d47 12408 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12409 if (sec != NULL)
12410 section->name = section->uncompressed_name;
12411 else
12412 {
657d0d47 12413 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12414 if (sec != NULL)
12415 section->name = section->compressed_name;
12416 }
12417 if (sec == NULL)
12418 return 0;
12419
657d0d47
CC		 12420 /* If we're loading from a subset of sections, and we've loaded
12421 a section matching this name before, it's likely that it's a
12422 different one. */
12423 if (section_subset != NULL)
12424 free_debug_section (debug);
12425
3f5e193b 12426 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12427}
12428
19e6b90e
L		 12429void
12430free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12431{
2cf0635d 12432 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12433
19e6b90e
L		 12434 if (section->start == NULL)
12435 return;
1007acb3 12436
19e6b90e
L		 12437 free ((char *) section->start);
12438 section->start = NULL;
12439 section->address = 0;
12440 section->size = 0;
1007acb3
L		 12441}
12442
1007acb3 12443static int
657d0d47 12444display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12445{
2cf0635d 12446 char * name = SECTION_NAME (section);
74e1a04b 12447 const char * print_name = printable_section_name (section);
19e6b90e
L		 12448 bfd_size_type length;
12449 int result = 1;
3f5e193b 12450 int i;
1007acb3 12451
19e6b90e
L		 12452 length = section->sh_size;
12453 if (length == 0)
1007acb3 12454 {
74e1a04b 12455 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12456 return 0;
1007acb3 12457 }
5dff79d8
NC		 12458 if (section->sh_type == SHT_NOBITS)
12459 {
12460 /* There is no point in dumping the contents of a debugging section
12461 which has the NOBITS type - the bits in the file will be random.
12462 This can happen when a file containing a .eh_frame section is
12463 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12464 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12465 print_name);
5dff79d8
NC		 12466 return 0;
12467 }
1007acb3 12468
0112cd26 12469 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12470 name = ".debug_info";
1007acb3 12471
19e6b90e
L		 12472 /* See if we know how to display the contents of this section. */
12473 for (i = 0; i < max; i++)
1b315056 12474 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12475 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12476 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12477 {
2cf0635d 12478 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12479 int secondary = (section != find_section (name));
12480
12481 if (secondary)
3f5e193b 12482 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12483
b40bf0a2
NC		 12484 if (i == line && const_strneq (name, ".debug_line."))
12485 sec->name = name;
12486 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12487 sec->name = sec->uncompressed_name;
12488 else
12489 sec->name = sec->compressed_name;
3f5e193b
NC		 12490 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12491 section, file))
19e6b90e 12492 {
657d0d47
CC		 12493 /* If this debug section is part of a CU/TU set in a .dwp file,
12494 restrict load_debug_section to the sections in that set. */
12495 section_subset = find_cu_tu_set (file, shndx);
12496
19e6b90e 12497 result &= debug_displays[i].display (sec, file);
1007acb3 12498
657d0d47
CC		 12499 section_subset = NULL;
12500
d966045b 12501 if (secondary || (i != info && i != abbrev))
3f5e193b 12502 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12503 }
1007acb3 12504
19e6b90e
L		 12505 break;
12506 }
1007acb3 12507
19e6b90e 12508 if (i == max)
1007acb3 12509 {
74e1a04b 12510 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12511 result = 0;
1007acb3
L		 12512 }
12513
19e6b90e 12514 return result;
5b18a4bc 12515}
103f02d3 12516
aef1f6d0
DJ		 12517/* Set DUMP_SECTS for all sections where dumps were requested
12518 based on section name. */
12519
12520static void
12521initialise_dumps_byname (void)
12522{
2cf0635d 12523 struct dump_list_entry * cur;
aef1f6d0
DJ		 12524
12525 for (cur = dump_sects_byname; cur; cur = cur->next)
12526 {
12527 unsigned int i;
12528 int any;
12529
12530 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12531 if (streq (SECTION_NAME (section_headers + i), cur->name))
12532 {
09c11c86 12533 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12534 any = 1;
12535 }
12536
12537 if (!any)
12538 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12539 cur->name);
12540 }
12541}
12542
5b18a4bc 12543static void
2cf0635d 12544process_section_contents (FILE * file)
5b18a4bc 12545{
2cf0635d 12546 Elf_Internal_Shdr * section;
19e6b90e 12547 unsigned int i;
103f02d3 12548
19e6b90e
L		 12549 if (! do_dump)
12550 return;
103f02d3 12551
aef1f6d0
DJ		 12552 initialise_dumps_byname ();
12553
19e6b90e
L		 12554 for (i = 0, section = section_headers;
12555 i < elf_header.e_shnum && i < num_dump_sects;
12556 i++, section++)
12557 {
12558#ifdef SUPPORT_DISASSEMBLY
12559 if (dump_sects[i] & DISASS_DUMP)
12560 disassemble_section (section, file);
12561#endif
12562 if (dump_sects[i] & HEX_DUMP)
cf13d699 12563 dump_section_as_bytes (section, file, FALSE);
103f02d3 12564
cf13d699
NC		 12565 if (dump_sects[i] & RELOC_DUMP)
12566 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12567
12568 if (dump_sects[i] & STRING_DUMP)
12569 dump_section_as_strings (section, file);
cf13d699
NC		 12570
12571 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12572 display_debug_section (i, section, file);
5b18a4bc 12573 }
103f02d3 12574
19e6b90e
L		 12575 /* Check to see if the user requested a
12576 dump of a section that does not exist. */
12577 while (i++ < num_dump_sects)
12578 if (dump_sects[i])
12579 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12580}
103f02d3 12581
5b18a4bc 12582static void
19e6b90e 12583process_mips_fpe_exception (int mask)
5b18a4bc 12584{
19e6b90e
L		 12585 if (mask)
12586 {
12587 int first = 1;
12588 if (mask & OEX_FPU_INEX)
12589 fputs ("INEX", stdout), first = 0;
12590 if (mask & OEX_FPU_UFLO)
12591 printf ("%sUFLO", first ? "" : "|"), first = 0;
12592 if (mask & OEX_FPU_OFLO)
12593 printf ("%sOFLO", first ? "" : "|"), first = 0;
12594 if (mask & OEX_FPU_DIV0)
12595 printf ("%sDIV0", first ? "" : "|"), first = 0;
12596 if (mask & OEX_FPU_INVAL)
12597 printf ("%sINVAL", first ? "" : "|");
12598 }
5b18a4bc 12599 else
19e6b90e 12600 fputs ("0", stdout);
5b18a4bc 12601}
103f02d3 12602
f6f0e17b
NC		 12603/* Display's the value of TAG at location P. If TAG is
12604 greater than 0 it is assumed to be an unknown tag, and
12605 a message is printed to this effect. Otherwise it is
12606 assumed that a message has already been printed.
12607
12608 If the bottom bit of TAG is set it assumed to have a
12609 string value, otherwise it is assumed to have an integer
12610 value.
12611
12612 Returns an updated P pointing to the first unread byte
12613 beyond the end of TAG's value.
12614
12615 Reads at or beyond END will not be made. */
12616
12617static unsigned char *
12618display_tag_value (int tag,
12619 unsigned char * p,
12620 const unsigned char * const end)
12621{
12622 unsigned long val;
12623
12624 if (tag > 0)
12625 printf (" Tag_unknown_%d: ", tag);
12626
12627 if (p >= end)
12628 {
4082ef84 12629 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12630 }
12631 else if (tag & 1)
12632 {
071436c6
NC		 12633 /* PR 17531 file: 027-19978-0.004. */
12634 size_t maxlen = (end - p) - 1;
12635
12636 putchar ('"');
4082ef84
NC		 12637 if (maxlen > 0)
12638 {
12639 print_symbol ((int) maxlen, (const char *) p);
12640 p += strnlen ((char *) p, maxlen) + 1;
12641 }
12642 else
12643 {
12644 printf (_("<corrupt string tag>"));
12645 p = (unsigned char *) end;
12646 }
071436c6 12647 printf ("\"\n");
f6f0e17b
NC		 12648 }
12649 else
12650 {
12651 unsigned int len;
12652
12653 val = read_uleb128 (p, &len, end);
12654 p += len;
12655 printf ("%ld (0x%lx)\n", val, val);
12656 }
12657
4082ef84 12658 assert (p <= end);
f6f0e17b
NC		 12659 return p;
12660}
12661
11c1ff18
PB		 12662/* ARM EABI attributes section. */
12663typedef struct
12664{
70e99720 12665 unsigned int tag;
2cf0635d 12666 const char * name;
11c1ff18 12667 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12668 unsigned int type;
2cf0635d 12669 const char ** table;
11c1ff18
PB		 12670} arm_attr_public_tag;
12671
2cf0635d 12672static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12673 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12674 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12675static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12676static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12677 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12678static const char * arm_attr_tag_FP_arch[] =
bca38921 12679 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12680 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12681static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12682static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12683 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12684static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12685 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12686 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12687static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12688 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12689static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12690 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12691static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12692 {"Absolute", "PC-relative", "None"};
2cf0635d 12693static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12694 {"None", "direct", "GOT-indirect"};
2cf0635d 12695static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12696 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12697static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12698static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12699 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12700static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12701static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12702static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12703 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12704static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12705 {"Unused", "small", "int", "forced to int"};
2cf0635d 12706static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12707 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12708static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12709 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12710static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12711 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12712static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12713 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12714 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12715static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12716 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12717 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12718static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12719static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12720 {"Not Allowed", "Allowed"};
2cf0635d 12721static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12722 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12723static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12724 {"Not Allowed", "Allowed"};
12725static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12726 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12727 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12728static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12729static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12730 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12731 "TrustZone and Virtualization Extensions"};
dd24e3da 12732static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12733 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12734
12735#define LOOKUP(id, name) \
12736 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12737static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12738{
12739 {4, "CPU_raw_name", 1, NULL},
12740 {5, "CPU_name", 1, NULL},
12741 LOOKUP(6, CPU_arch),
12742 {7, "CPU_arch_profile", 0, NULL},
12743 LOOKUP(8, ARM_ISA_use),
12744 LOOKUP(9, THUMB_ISA_use),
75375b3e 12745 LOOKUP(10, FP_arch),
11c1ff18 12746 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12747 LOOKUP(12, Advanced_SIMD_arch),
12748 LOOKUP(13, PCS_config),
11c1ff18
PB		 12749 LOOKUP(14, ABI_PCS_R9_use),
12750 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12751 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12752 LOOKUP(17, ABI_PCS_GOT_use),
12753 LOOKUP(18, ABI_PCS_wchar_t),
12754 LOOKUP(19, ABI_FP_rounding),
12755 LOOKUP(20, ABI_FP_denormal),
12756 LOOKUP(21, ABI_FP_exceptions),
12757 LOOKUP(22, ABI_FP_user_exceptions),
12758 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12759 {24, "ABI_align_needed", 0, NULL},
12760 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12761 LOOKUP(26, ABI_enum_size),
12762 LOOKUP(27, ABI_HardFP_use),
12763 LOOKUP(28, ABI_VFP_args),
12764 LOOKUP(29, ABI_WMMX_args),
12765 LOOKUP(30, ABI_optimization_goals),
12766 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12767 {32, "compatibility", 0, NULL},
f5f53991 12768 LOOKUP(34, CPU_unaligned_access),
75375b3e 12769 LOOKUP(36, FP_HP_extension),
8e79c3df 12770 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12771 LOOKUP(42, MPextension_use),
12772 LOOKUP(44, DIV_use),
f5f53991
AS		 12773 {64, "nodefaults", 0, NULL},
12774 {65, "also_compatible_with", 0, NULL},
12775 LOOKUP(66, T2EE_use),
12776 {67, "conformance", 1, NULL},
12777 LOOKUP(68, Virtualization_use),
cd21e546 12778 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12779};
12780#undef LOOKUP
12781
11c1ff18 12782static unsigned char *
f6f0e17b
NC		 12783display_arm_attribute (unsigned char * p,
12784 const unsigned char * const end)
11c1ff18 12785{
70e99720 12786 unsigned int tag;
11c1ff18 12787 unsigned int len;
70e99720 12788 unsigned int val;
2cf0635d 12789 arm_attr_public_tag * attr;
11c1ff18 12790 unsigned i;
70e99720 12791 unsigned int type;
11c1ff18 12792
f6f0e17b 12793 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12794 p += len;
12795 attr = NULL;
2cf0635d 12796 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12797 {
12798 if (arm_attr_public_tags[i].tag == tag)
12799 {
12800 attr = &arm_attr_public_tags[i];
12801 break;
12802 }
12803 }
12804
12805 if (attr)
12806 {
12807 printf (" Tag_%s: ", attr->name);
12808 switch (attr->type)
12809 {
12810 case 0:
12811 switch (tag)
12812 {
12813 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12814 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12815 p += len;
12816 switch (val)
12817 {
2b692964
NC		 12818 case 0: printf (_("None\n")); break;
12819 case 'A': printf (_("Application\n")); break;
12820 case 'R': printf (_("Realtime\n")); break;
12821 case 'M': printf (_("Microcontroller\n")); break;
12822 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12823 default: printf ("??? (%d)\n", val); break;
12824 }
12825 break;
12826
75375b3e 12827 case 24: /* Tag_align_needed. */
f6f0e17b 12828 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12829 p += len;
12830 switch (val)
12831 {
2b692964
NC		 12832 case 0: printf (_("None\n")); break;
12833 case 1: printf (_("8-byte\n")); break;
12834 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12835 case 3: printf ("??? 3\n"); break;
12836 default:
12837 if (val <= 12)
dd24e3da 12838 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12839 1 << val);
12840 else
12841 printf ("??? (%d)\n", val);
12842 break;
12843 }
12844 break;
12845
12846 case 25: /* Tag_align_preserved. */
f6f0e17b 12847 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12848 p += len;
12849 switch (val)
12850 {
2b692964
NC		 12851 case 0: printf (_("None\n")); break;
12852 case 1: printf (_("8-byte, except leaf SP\n")); break;
12853 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12854 case 3: printf ("??? 3\n"); break;
12855 default:
12856 if (val <= 12)
dd24e3da 12857 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12858 1 << val);
12859 else
12860 printf ("??? (%d)\n", val);
12861 break;
12862 }
12863 break;
12864
11c1ff18 12865 case 32: /* Tag_compatibility. */
071436c6 12866 {
071436c6
NC		 12867 val = read_uleb128 (p, &len, end);
12868 p += len;
071436c6 12869 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12870 if (p < end - 1)
12871 {
12872 size_t maxlen = (end - p) - 1;
12873
12874 print_symbol ((int) maxlen, (const char *) p);
12875 p += strnlen ((char *) p, maxlen) + 1;
12876 }
12877 else
12878 {
12879 printf (_("<corrupt>"));
12880 p = (unsigned char *) end;
12881 }
071436c6 12882 putchar ('\n');
071436c6 12883 }
11c1ff18
PB		 12884 break;
12885
f5f53991 12886 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12887 /* PR 17531: file: 001-505008-0.01. */
12888 if (p < end)
12889 p++;
2b692964 12890 printf (_("True\n"));
f5f53991
AS		 12891 break;
12892
12893 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12894 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12895 p += len;
12896 if (val == 6 /* Tag_CPU_arch. */)
12897 {
f6f0e17b 12898 val = read_uleb128 (p, &len, end);
f5f53991 12899 p += len;
071436c6 12900 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12901 printf ("??? (%d)\n", val);
12902 else
12903 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12904 }
12905 else
12906 printf ("???\n");
071436c6
NC		 12907 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12908 ;
f5f53991
AS		 12909 break;
12910
11c1ff18 12911 default:
bee0ee85
NC		 12912 printf (_("<unknown: %d>\n"), tag);
12913 break;
11c1ff18
PB		 12914 }
12915 return p;
12916
12917 case 1:
f6f0e17b 12918 return display_tag_value (-1, p, end);
11c1ff18 12919 case 2:
f6f0e17b 12920 return display_tag_value (0, p, end);
11c1ff18
PB		 12921
12922 default:
12923 assert (attr->type & 0x80);
f6f0e17b 12924 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12925 p += len;
12926 type = attr->type & 0x7f;
12927 if (val >= type)
12928 printf ("??? (%d)\n", val);
12929 else
12930 printf ("%s\n", attr->table[val]);
12931 return p;
12932 }
12933 }
11c1ff18 12934
f6f0e17b 12935 return display_tag_value (tag, p, end);
11c1ff18
PB		 12936}
12937
104d59d1 12938static unsigned char *
60bca95a 12939display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12940 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12941 const unsigned char * const end)
104d59d1
JM		 12942{
12943 int tag;
12944 unsigned int len;
12945 int val;
104d59d1 12946
f6f0e17b 12947 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12948 p += len;
12949
12950 /* Tag_compatibility is the only generic GNU attribute defined at
12951 present. */
12952 if (tag == 32)
12953 {
f6f0e17b 12954 val = read_uleb128 (p, &len, end);
104d59d1 12955 p += len;
071436c6
NC		 12956
12957 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12958 if (p == end)
12959 {
071436c6 12960 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12961 warn (_("corrupt vendor attribute\n"));
12962 }
12963 else
12964 {
4082ef84
NC		 12965 if (p < end - 1)
12966 {
12967 size_t maxlen = (end - p) - 1;
071436c6 12968
4082ef84
NC		 12969 print_symbol ((int) maxlen, (const char *) p);
12970 p += strnlen ((char *) p, maxlen) + 1;
12971 }
12972 else
12973 {
12974 printf (_("<corrupt>"));
12975 p = (unsigned char *) end;
12976 }
071436c6 12977 putchar ('\n');
f6f0e17b 12978 }
104d59d1
JM		 12979 return p;
12980 }
12981
12982 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12983 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12984
f6f0e17b 12985 return display_tag_value (tag, p, end);
104d59d1
JM		 12986}
12987
34c8bcba 12988static unsigned char *
f6f0e17b
NC		 12989display_power_gnu_attribute (unsigned char * p,
12990 int tag,
12991 const unsigned char * const end)
34c8bcba 12992{
34c8bcba
JM		 12993 unsigned int len;
12994 int val;
12995
12996 if (tag == Tag_GNU_Power_ABI_FP)
12997 {
f6f0e17b 12998 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12999 p += len;
13000 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 13001
34c8bcba
JM		 13002 switch (val)
13003 {
13004 case 0:
2b692964 13005 printf (_("Hard or soft float\n"));
34c8bcba
JM		 13006 break;
13007 case 1:
2b692964 13008 printf (_("Hard float\n"));
34c8bcba
JM		 13009 break;
13010 case 2:
2b692964 13011 printf (_("Soft float\n"));
34c8bcba 13012 break;
3c7b9897 13013 case 3:
2b692964 13014 printf (_("Single-precision hard float\n"));
3c7b9897 13015 break;
34c8bcba
JM		 13016 default:
13017 printf ("??? (%d)\n", val);
13018 break;
13019 }
13020 return p;
13021 }
13022
c6e65352
DJ		 13023 if (tag == Tag_GNU_Power_ABI_Vector)
13024 {
f6f0e17b 13025 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13026 p += len;
13027 printf (" Tag_GNU_Power_ABI_Vector: ");
13028 switch (val)
13029 {
13030 case 0:
2b692964 13031 printf (_("Any\n"));
c6e65352
DJ		 13032 break;
13033 case 1:
2b692964 13034 printf (_("Generic\n"));
c6e65352
DJ		 13035 break;
13036 case 2:
13037 printf ("AltiVec\n");
13038 break;
13039 case 3:
13040 printf ("SPE\n");
13041 break;
13042 default:
13043 printf ("??? (%d)\n", val);
13044 break;
13045 }
13046 return p;
13047 }
13048
f82e0623
NF		 13049 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13050 {
f6f0e17b
NC		 13051 if (p == end)
13052 {
071436c6 13053 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13054 return p;
13055 }
0b4362b0 13056
f6f0e17b 13057 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13058 p += len;
13059 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13060 switch (val)
13061 {
13062 case 0:
2b692964 13063 printf (_("Any\n"));
f82e0623
NF		 13064 break;
13065 case 1:
13066 printf ("r3/r4\n");
13067 break;
13068 case 2:
2b692964 13069 printf (_("Memory\n"));
f82e0623
NF		 13070 break;
13071 default:
13072 printf ("??? (%d)\n", val);
13073 break;
13074 }
13075 return p;
13076 }
13077
f6f0e17b 13078 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13079}
13080
643f7afb
AK		 13081static unsigned char *
13082display_s390_gnu_attribute (unsigned char * p,
13083 int tag,
13084 const unsigned char * const end)
13085{
13086 unsigned int len;
13087 int val;
13088
13089 if (tag == Tag_GNU_S390_ABI_Vector)
13090 {
13091 val = read_uleb128 (p, &len, end);
13092 p += len;
13093 printf (" Tag_GNU_S390_ABI_Vector: ");
13094
13095 switch (val)
13096 {
13097 case 0:
13098 printf (_("any\n"));
13099 break;
13100 case 1:
13101 printf (_("software\n"));
13102 break;
13103 case 2:
13104 printf (_("hardware\n"));
13105 break;
13106 default:
13107 printf ("??? (%d)\n", val);
13108 break;
13109 }
13110 return p;
13111 }
13112
13113 return display_tag_value (tag & 1, p, end);
13114}
13115
9e8c70f9
DM		 13116static void
13117display_sparc_hwcaps (int mask)
13118{
13119 if (mask)
13120 {
13121 int first = 1;
071436c6 13122
9e8c70f9
DM		 13123 if (mask & ELF_SPARC_HWCAP_MUL32)
13124 fputs ("mul32", stdout), first = 0;
13125 if (mask & ELF_SPARC_HWCAP_DIV32)
13126 printf ("%sdiv32", first ? "" : "|"), first = 0;
13127 if (mask & ELF_SPARC_HWCAP_FSMULD)
13128 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13129 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13130 printf ("%sv8plus", first ? "" : "|"), first = 0;
13131 if (mask & ELF_SPARC_HWCAP_POPC)
13132 printf ("%spopc", first ? "" : "|"), first = 0;
13133 if (mask & ELF_SPARC_HWCAP_VIS)
13134 printf ("%svis", first ? "" : "|"), first = 0;
13135 if (mask & ELF_SPARC_HWCAP_VIS2)
13136 printf ("%svis2", first ? "" : "|"), first = 0;
13137 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13138 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13139 if (mask & ELF_SPARC_HWCAP_FMAF)
13140 printf ("%sfmaf", first ? "" : "|"), first = 0;
13141 if (mask & ELF_SPARC_HWCAP_VIS3)
13142 printf ("%svis3", first ? "" : "|"), first = 0;
13143 if (mask & ELF_SPARC_HWCAP_HPC)
13144 printf ("%shpc", first ? "" : "|"), first = 0;
13145 if (mask & ELF_SPARC_HWCAP_RANDOM)
13146 printf ("%srandom", first ? "" : "|"), first = 0;
13147 if (mask & ELF_SPARC_HWCAP_TRANS)
13148 printf ("%strans", first ? "" : "|"), first = 0;
13149 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13150 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13151 if (mask & ELF_SPARC_HWCAP_IMA)
13152 printf ("%sima", first ? "" : "|"), first = 0;
13153 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13154 printf ("%scspare", first ? "" : "|"), first = 0;
13155 }
13156 else
071436c6
NC		 13157 fputc ('0', stdout);
13158 fputc ('\n', stdout);
9e8c70f9
DM		 13159}
13160
3d68f91c
JM		 13161static void
13162display_sparc_hwcaps2 (int mask)
13163{
13164 if (mask)
13165 {
13166 int first = 1;
071436c6 13167
3d68f91c
JM		 13168 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13169 fputs ("fjathplus", stdout), first = 0;
13170 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13171 printf ("%svis3b", first ? "" : "|"), first = 0;
13172 if (mask & ELF_SPARC_HWCAP2_ADP)
13173 printf ("%sadp", first ? "" : "|"), first = 0;
13174 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13175 printf ("%ssparc5", first ? "" : "|"), first = 0;
13176 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13177 printf ("%smwait", first ? "" : "|"), first = 0;
13178 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13179 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13180 if (mask & ELF_SPARC_HWCAP2_XMONT)
13181 printf ("%sxmont2", first ? "" : "|"), first = 0;
13182 if (mask & ELF_SPARC_HWCAP2_NSEC)
13183 printf ("%snsec", first ? "" : "|"), first = 0;
13184 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13185 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13186 if (mask & ELF_SPARC_HWCAP2_FJDES)
13187 printf ("%sfjdes", first ? "" : "|"), first = 0;
13188 if (mask & ELF_SPARC_HWCAP2_FJAES)
13189 printf ("%sfjaes", first ? "" : "|"), first = 0;
13190 }
13191 else
071436c6
NC		 13192 fputc ('0', stdout);
13193 fputc ('\n', stdout);
3d68f91c
JM		 13194}
13195
9e8c70f9 13196static unsigned char *
f6f0e17b
NC		 13197display_sparc_gnu_attribute (unsigned char * p,
13198 int tag,
13199 const unsigned char * const end)
9e8c70f9 13200{
3d68f91c
JM		 13201 unsigned int len;
13202 int val;
13203
9e8c70f9
DM		 13204 if (tag == Tag_GNU_Sparc_HWCAPS)
13205 {
f6f0e17b 13206 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13207 p += len;
13208 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13209 display_sparc_hwcaps (val);
13210 return p;
3d68f91c
JM		 13211 }
13212 if (tag == Tag_GNU_Sparc_HWCAPS2)
13213 {
13214 val = read_uleb128 (p, &len, end);
13215 p += len;
13216 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13217 display_sparc_hwcaps2 (val);
13218 return p;
13219 }
9e8c70f9 13220
f6f0e17b 13221 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13222}
13223
351cdf24
MF		 13224static void
13225print_mips_fp_abi_value (int val)
13226{
13227 switch (val)
13228 {
13229 case Val_GNU_MIPS_ABI_FP_ANY:
13230 printf (_("Hard or soft float\n"));
13231 break;
13232 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13233 printf (_("Hard float (double precision)\n"));
13234 break;
13235 case Val_GNU_MIPS_ABI_FP_SINGLE:
13236 printf (_("Hard float (single precision)\n"));
13237 break;
13238 case Val_GNU_MIPS_ABI_FP_SOFT:
13239 printf (_("Soft float\n"));
13240 break;
13241 case Val_GNU_MIPS_ABI_FP_OLD_64:
13242 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13243 break;
13244 case Val_GNU_MIPS_ABI_FP_XX:
13245 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13246 break;
13247 case Val_GNU_MIPS_ABI_FP_64:
13248 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13249 break;
13250 case Val_GNU_MIPS_ABI_FP_64A:
13251 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13252 break;
3350cc01
CM		 13253 case Val_GNU_MIPS_ABI_FP_NAN2008:
13254 printf (_("NaN 2008 compatibility\n"));
13255 break;
351cdf24
MF		 13256 default:
13257 printf ("??? (%d)\n", val);
13258 break;
13259 }
13260}
13261
2cf19d5c 13262static unsigned char *
f6f0e17b
NC		 13263display_mips_gnu_attribute (unsigned char * p,
13264 int tag,
13265 const unsigned char * const end)
2cf19d5c 13266{
2cf19d5c
JM		 13267 if (tag == Tag_GNU_MIPS_ABI_FP)
13268 {
f6f0e17b
NC		 13269 unsigned int len;
13270 int val;
13271
13272 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13273 p += len;
13274 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13275
351cdf24
MF		 13276 print_mips_fp_abi_value (val);
13277
2cf19d5c
JM		 13278 return p;
13279 }
13280
a9f58168
CF		 13281 if (tag == Tag_GNU_MIPS_ABI_MSA)
13282 {
13283 unsigned int len;
13284 int val;
13285
13286 val = read_uleb128 (p, &len, end);
13287 p += len;
13288 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13289
13290 switch (val)
13291 {
13292 case Val_GNU_MIPS_ABI_MSA_ANY:
13293 printf (_("Any MSA or not\n"));
13294 break;
13295 case Val_GNU_MIPS_ABI_MSA_128:
13296 printf (_("128-bit MSA\n"));
13297 break;
13298 default:
13299 printf ("??? (%d)\n", val);
13300 break;
13301 }
13302 return p;
13303 }
13304
f6f0e17b 13305 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13306}
13307
59e6276b 13308static unsigned char *
f6f0e17b
NC		 13309display_tic6x_attribute (unsigned char * p,
13310 const unsigned char * const end)
59e6276b
JM		 13311{
13312 int tag;
13313 unsigned int len;
13314 int val;
13315
f6f0e17b 13316 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13317 p += len;
13318
13319 switch (tag)
13320 {
75fa6dc1 13321 case Tag_ISA:
f6f0e17b 13322 val = read_uleb128 (p, &len, end);
59e6276b 13323 p += len;
75fa6dc1 13324 printf (" Tag_ISA: ");
59e6276b
JM		 13325
13326 switch (val)
13327 {
75fa6dc1 13328 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13329 printf (_("None\n"));
13330 break;
75fa6dc1 13331 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13332 printf ("C62x\n");
13333 break;
75fa6dc1 13334 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13335 printf ("C67x\n");
13336 break;
75fa6dc1 13337 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13338 printf ("C67x+\n");
13339 break;
75fa6dc1 13340 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13341 printf ("C64x\n");
13342 break;
75fa6dc1 13343 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13344 printf ("C64x+\n");
13345 break;
75fa6dc1 13346 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13347 printf ("C674x\n");
13348 break;
13349 default:
13350 printf ("??? (%d)\n", val);
13351 break;
13352 }
13353 return p;
13354
87779176 13355 case Tag_ABI_wchar_t:
f6f0e17b 13356 val = read_uleb128 (p, &len, end);
87779176
JM		 13357 p += len;
13358 printf (" Tag_ABI_wchar_t: ");
13359 switch (val)
13360 {
13361 case 0:
13362 printf (_("Not used\n"));
13363 break;
13364 case 1:
13365 printf (_("2 bytes\n"));
13366 break;
13367 case 2:
13368 printf (_("4 bytes\n"));
13369 break;
13370 default:
13371 printf ("??? (%d)\n", val);
13372 break;
13373 }
13374 return p;
13375
13376 case Tag_ABI_stack_align_needed:
f6f0e17b 13377 val = read_uleb128 (p, &len, end);
87779176
JM		 13378 p += len;
13379 printf (" Tag_ABI_stack_align_needed: ");
13380 switch (val)
13381 {
13382 case 0:
13383 printf (_("8-byte\n"));
13384 break;
13385 case 1:
13386 printf (_("16-byte\n"));
13387 break;
13388 default:
13389 printf ("??? (%d)\n", val);
13390 break;
13391 }
13392 return p;
13393
13394 case Tag_ABI_stack_align_preserved:
f6f0e17b 13395 val = read_uleb128 (p, &len, end);
87779176
JM		 13396 p += len;
13397 printf (" Tag_ABI_stack_align_preserved: ");
13398 switch (val)
13399 {
13400 case 0:
13401 printf (_("8-byte\n"));
13402 break;
13403 case 1:
13404 printf (_("16-byte\n"));
13405 break;
13406 default:
13407 printf ("??? (%d)\n", val);
13408 break;
13409 }
13410 return p;
13411
b5593623 13412 case Tag_ABI_DSBT:
f6f0e17b 13413 val = read_uleb128 (p, &len, end);
b5593623
JM		 13414 p += len;
13415 printf (" Tag_ABI_DSBT: ");
13416 switch (val)
13417 {
13418 case 0:
13419 printf (_("DSBT addressing not used\n"));
13420 break;
13421 case 1:
13422 printf (_("DSBT addressing used\n"));
13423 break;
13424 default:
13425 printf ("??? (%d)\n", val);
13426 break;
13427 }
13428 return p;
13429
87779176 13430 case Tag_ABI_PID:
f6f0e17b 13431 val = read_uleb128 (p, &len, end);
87779176
JM		 13432 p += len;
13433 printf (" Tag_ABI_PID: ");
13434 switch (val)
13435 {
13436 case 0:
13437 printf (_("Data addressing position-dependent\n"));
13438 break;
13439 case 1:
13440 printf (_("Data addressing position-independent, GOT near DP\n"));
13441 break;
13442 case 2:
13443 printf (_("Data addressing position-independent, GOT far from DP\n"));
13444 break;
13445 default:
13446 printf ("??? (%d)\n", val);
13447 break;
13448 }
13449 return p;
13450
13451 case Tag_ABI_PIC:
f6f0e17b 13452 val = read_uleb128 (p, &len, end);
87779176
JM		 13453 p += len;
13454 printf (" Tag_ABI_PIC: ");
13455 switch (val)
13456 {
13457 case 0:
13458 printf (_("Code addressing position-dependent\n"));
13459 break;
13460 case 1:
13461 printf (_("Code addressing position-independent\n"));
13462 break;
13463 default:
13464 printf ("??? (%d)\n", val);
13465 break;
13466 }
13467 return p;
13468
13469 case Tag_ABI_array_object_alignment:
f6f0e17b 13470 val = read_uleb128 (p, &len, end);
87779176
JM		 13471 p += len;
13472 printf (" Tag_ABI_array_object_alignment: ");
13473 switch (val)
13474 {
13475 case 0:
13476 printf (_("8-byte\n"));
13477 break;
13478 case 1:
13479 printf (_("4-byte\n"));
13480 break;
13481 case 2:
13482 printf (_("16-byte\n"));
13483 break;
13484 default:
13485 printf ("??? (%d)\n", val);
13486 break;
13487 }
13488 return p;
13489
13490 case Tag_ABI_array_object_align_expected:
f6f0e17b 13491 val = read_uleb128 (p, &len, end);
87779176
JM		 13492 p += len;
13493 printf (" Tag_ABI_array_object_align_expected: ");
13494 switch (val)
13495 {
13496 case 0:
13497 printf (_("8-byte\n"));
13498 break;
13499 case 1:
13500 printf (_("4-byte\n"));
13501 break;
13502 case 2:
13503 printf (_("16-byte\n"));
13504 break;
13505 default:
13506 printf ("??? (%d)\n", val);
13507 break;
13508 }
13509 return p;
13510
3cbd1c06 13511 case Tag_ABI_compatibility:
071436c6 13512 {
071436c6
NC		 13513 val = read_uleb128 (p, &len, end);
13514 p += len;
13515 printf (" Tag_ABI_compatibility: ");
071436c6 13516 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13517 if (p < end - 1)
13518 {
13519 size_t maxlen = (end - p) - 1;
13520
13521 print_symbol ((int) maxlen, (const char *) p);
13522 p += strnlen ((char *) p, maxlen) + 1;
13523 }
13524 else
13525 {
13526 printf (_("<corrupt>"));
13527 p = (unsigned char *) end;
13528 }
071436c6 13529 putchar ('\n');
071436c6
NC		 13530 return p;
13531 }
87779176
JM		 13532
13533 case Tag_ABI_conformance:
071436c6 13534 {
4082ef84
NC		 13535 printf (" Tag_ABI_conformance: \"");
13536 if (p < end - 1)
13537 {
13538 size_t maxlen = (end - p) - 1;
071436c6 13539
4082ef84
NC		 13540 print_symbol ((int) maxlen, (const char *) p);
13541 p += strnlen ((char *) p, maxlen) + 1;
13542 }
13543 else
13544 {
13545 printf (_("<corrupt>"));
13546 p = (unsigned char *) end;
13547 }
071436c6 13548 printf ("\"\n");
071436c6
NC		 13549 return p;
13550 }
59e6276b
JM		 13551 }
13552
f6f0e17b
NC		 13553 return display_tag_value (tag, p, end);
13554}
59e6276b 13555
f6f0e17b
NC		 13556static void
13557display_raw_attribute (unsigned char * p, unsigned char * end)
13558{
13559 unsigned long addr = 0;
13560 size_t bytes = end - p;
13561
e0a31db1 13562 assert (end > p);
f6f0e17b 13563 while (bytes)
87779176 13564 {
f6f0e17b
NC		 13565 int j;
13566 int k;
13567 int lbytes = (bytes > 16 ? 16 : bytes);
13568
13569 printf (" 0x%8.8lx ", addr);
13570
13571 for (j = 0; j < 16; j++)
13572 {
13573 if (j < lbytes)
13574 printf ("%2.2x", p[j]);
13575 else
13576 printf (" ");
13577
13578 if ((j & 3) == 3)
13579 printf (" ");
13580 }
13581
13582 for (j = 0; j < lbytes; j++)
13583 {
13584 k = p[j];
13585 if (k >= ' ' && k < 0x7f)
13586 printf ("%c", k);
13587 else
13588 printf (".");
13589 }
13590
13591 putchar ('\n');
13592
13593 p += lbytes;
13594 bytes -= lbytes;
13595 addr += lbytes;
87779176 13596 }
59e6276b 13597
f6f0e17b 13598 putchar ('\n');
59e6276b
JM		 13599}
13600
13761a11
NC		 13601static unsigned char *
13602display_msp430x_attribute (unsigned char * p,
13603 const unsigned char * const end)
13604{
13605 unsigned int len;
13606 int val;
13607 int tag;
13608
13609 tag = read_uleb128 (p, & len, end);
13610 p += len;
0b4362b0 13611
13761a11
NC		 13612 switch (tag)
13613 {
13614 case OFBA_MSPABI_Tag_ISA:
13615 val = read_uleb128 (p, &len, end);
13616 p += len;
13617 printf (" Tag_ISA: ");
13618 switch (val)
13619 {
13620 case 0: printf (_("None\n")); break;
13621 case 1: printf (_("MSP430\n")); break;
13622 case 2: printf (_("MSP430X\n")); break;
13623 default: printf ("??? (%d)\n", val); break;
13624 }
13625 break;
13626
13627 case OFBA_MSPABI_Tag_Code_Model:
13628 val = read_uleb128 (p, &len, end);
13629 p += len;
13630 printf (" Tag_Code_Model: ");
13631 switch (val)
13632 {
13633 case 0: printf (_("None\n")); break;
13634 case 1: printf (_("Small\n")); break;
13635 case 2: printf (_("Large\n")); break;
13636 default: printf ("??? (%d)\n", val); break;
13637 }
13638 break;
13639
13640 case OFBA_MSPABI_Tag_Data_Model:
13641 val = read_uleb128 (p, &len, end);
13642 p += len;
13643 printf (" Tag_Data_Model: ");
13644 switch (val)
13645 {
13646 case 0: printf (_("None\n")); break;
13647 case 1: printf (_("Small\n")); break;
13648 case 2: printf (_("Large\n")); break;
13649 case 3: printf (_("Restricted Large\n")); break;
13650 default: printf ("??? (%d)\n", val); break;
13651 }
13652 break;
13653
13654 default:
13655 printf (_(" <unknown tag %d>: "), tag);
13656
13657 if (tag & 1)
13658 {
071436c6 13659 putchar ('"');
4082ef84
NC		 13660 if (p < end - 1)
13661 {
13662 size_t maxlen = (end - p) - 1;
13663
13664 print_symbol ((int) maxlen, (const char *) p);
13665 p += strnlen ((char *) p, maxlen) + 1;
13666 }
13667 else
13668 {
13669 printf (_("<corrupt>"));
13670 p = (unsigned char *) end;
13671 }
071436c6 13672 printf ("\"\n");
13761a11
NC		 13673 }
13674 else
13675 {
13676 val = read_uleb128 (p, &len, end);
13677 p += len;
13678 printf ("%d (0x%x)\n", val, val);
13679 }
13680 break;
13681 }
13682
4082ef84 13683 assert (p <= end);
13761a11
NC		 13684 return p;
13685}
13686
11c1ff18 13687static int
60bca95a
NC		 13688process_attributes (FILE * file,
13689 const char * public_name,
104d59d1 13690 unsigned int proc_type,
f6f0e17b
NC		 13691 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13692 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13693{
2cf0635d 13694 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13695 unsigned i;
13696
13697 /* Find the section header so that we get the size. */
13698 for (i = 0, sect = section_headers;
13699 i < elf_header.e_shnum;
13700 i++, sect++)
13701 {
071436c6
NC		 13702 unsigned char * contents;
13703 unsigned char * p;
13704
104d59d1 13705 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13706 continue;
13707
3f5e193b
NC		 13708 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13709 sect->sh_size, _("attributes"));
60bca95a 13710 if (contents == NULL)
11c1ff18 13711 continue;
60bca95a 13712
11c1ff18
PB		 13713 p = contents;
13714 if (*p == 'A')
13715 {
071436c6
NC		 13716 bfd_vma section_len;
13717
13718 section_len = sect->sh_size - 1;
11c1ff18 13719 p++;
60bca95a 13720
071436c6 13721 while (section_len > 0)
11c1ff18 13722 {
071436c6 13723 bfd_vma attr_len;
e9847026 13724 unsigned int namelen;
11c1ff18 13725 bfd_boolean public_section;
104d59d1 13726 bfd_boolean gnu_section;
11c1ff18 13727
071436c6 13728 if (section_len <= 4)
e0a31db1
NC		 13729 {
13730 error (_("Tag section ends prematurely\n"));
13731 break;
13732 }
071436c6 13733 attr_len = byte_get (p, 4);
11c1ff18 13734 p += 4;
60bca95a 13735
071436c6 13736 if (attr_len > section_len)
11c1ff18 13737 {
071436c6
NC		 13738 error (_("Bad attribute length (%u > %u)\n"),
13739 (unsigned) attr_len, (unsigned) section_len);
13740 attr_len = section_len;
11c1ff18 13741 }
74e1a04b 13742 /* PR 17531: file: 001-101425-0.004 */
071436c6 13743 else if (attr_len < 5)
74e1a04b 13744 {
071436c6 13745 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13746 break;
13747 }
e9847026 13748
071436c6
NC		 13749 section_len -= attr_len;
13750 attr_len -= 4;
13751
13752 namelen = strnlen ((char *) p, attr_len) + 1;
13753 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13754 {
13755 error (_("Corrupt attribute section name\n"));
13756 break;
13757 }
13758
071436c6
NC		 13759 printf (_("Attribute Section: "));
13760 print_symbol (INT_MAX, (const char *) p);
13761 putchar ('\n');
60bca95a
NC		 13762
13763 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13764 public_section = TRUE;
13765 else
13766 public_section = FALSE;
60bca95a
NC		 13767
13768 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13769 gnu_section = TRUE;
13770 else
13771 gnu_section = FALSE;
60bca95a 13772
11c1ff18 13773 p += namelen;
071436c6 13774 attr_len -= namelen;
e0a31db1 13775
071436c6 13776 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13777 {
e0a31db1 13778 int tag;
11c1ff18
PB		 13779 int val;
13780 bfd_vma size;
071436c6 13781 unsigned char * end;
60bca95a 13782
e0a31db1 13783 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13784 if (attr_len < 6)
e0a31db1
NC		 13785 {
13786 error (_("Unused bytes at end of section\n"));
13787 section_len = 0;
13788 break;
13789 }
13790
13791 tag = *(p++);
11c1ff18 13792 size = byte_get (p, 4);
071436c6 13793 if (size > attr_len)
11c1ff18 13794 {
e9847026 13795 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13796 (unsigned) size, (unsigned) attr_len);
13797 size = attr_len;
11c1ff18 13798 }
e0a31db1
NC		 13799 /* PR binutils/17531: Safe handling of corrupt files. */
13800 if (size < 6)
13801 {
13802 error (_("Bad subsection length (%u < 6)\n"),
13803 (unsigned) size);
13804 section_len = 0;
13805 break;
13806 }
60bca95a 13807
071436c6 13808 attr_len -= size;
11c1ff18 13809 end = p + size - 1;
071436c6 13810 assert (end <= contents + sect->sh_size);
11c1ff18 13811 p += 4;
60bca95a 13812
11c1ff18
PB		 13813 switch (tag)
13814 {
13815 case 1:
2b692964 13816 printf (_("File Attributes\n"));
11c1ff18
PB		 13817 break;
13818 case 2:
2b692964 13819 printf (_("Section Attributes:"));
11c1ff18
PB		 13820 goto do_numlist;
13821 case 3:
2b692964 13822 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13823 do_numlist:
13824 for (;;)
13825 {
91d6fa6a 13826 unsigned int j;
60bca95a 13827
f6f0e17b 13828 val = read_uleb128 (p, &j, end);
91d6fa6a 13829 p += j;
11c1ff18
PB		 13830 if (val == 0)
13831 break;
13832 printf (" %d", val);
13833 }
13834 printf ("\n");
13835 break;
13836 default:
2b692964 13837 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13838 public_section = FALSE;
13839 break;
13840 }
60bca95a 13841
071436c6 13842 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13843 {
13844 while (p < end)
f6f0e17b 13845 p = display_pub_attribute (p, end);
071436c6 13846 assert (p <= end);
104d59d1 13847 }
071436c6 13848 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13849 {
13850 while (p < end)
13851 p = display_gnu_attribute (p,
f6f0e17b
NC		 13852 display_proc_gnu_attribute,
13853 end);
071436c6 13854 assert (p <= end);
11c1ff18 13855 }
071436c6 13856 else if (p < end)
11c1ff18 13857 {
071436c6 13858 printf (_(" Unknown attribute:\n"));
f6f0e17b 13859 display_raw_attribute (p, end);
11c1ff18
PB		 13860 p = end;
13861 }
071436c6
NC		 13862 else
13863 attr_len = 0;
11c1ff18
PB		 13864 }
13865 }
13866 }
13867 else
e9847026 13868 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13869
60bca95a 13870 free (contents);
11c1ff18
PB		 13871 }
13872 return 1;
13873}
13874
104d59d1 13875static int
2cf0635d 13876process_arm_specific (FILE * file)
104d59d1
JM		 13877{
13878 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13879 display_arm_attribute, NULL);
13880}
13881
34c8bcba 13882static int
2cf0635d 13883process_power_specific (FILE * file)
34c8bcba
JM		 13884{
13885 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13886 display_power_gnu_attribute);
13887}
13888
643f7afb
AK		 13889static int
13890process_s390_specific (FILE * file)
13891{
13892 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13893 display_s390_gnu_attribute);
13894}
13895
9e8c70f9
DM		 13896static int
13897process_sparc_specific (FILE * file)
13898{
13899 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13900 display_sparc_gnu_attribute);
13901}
13902
59e6276b
JM		 13903static int
13904process_tic6x_specific (FILE * file)
13905{
13906 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13907 display_tic6x_attribute, NULL);
13908}
13909
13761a11
NC		 13910static int
13911process_msp430x_specific (FILE * file)
13912{
13913 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13914 display_msp430x_attribute, NULL);
13915}
13916
ccb4c951
RS		 13917/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13918 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13919 and return the VMA of the next entry, or -1 if there was a problem.
13920 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13921
13922static bfd_vma
82b1b41b
NC		 13923print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13924 unsigned char * data_end)
ccb4c951
RS		 13925{
13926 printf (" ");
13927 print_vma (addr, LONG_HEX);
13928 printf (" ");
13929 if (addr < pltgot + 0xfff0)
13930 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13931 else
13932 printf ("%10s", "");
13933 printf (" ");
13934 if (data == NULL)
2b692964 13935 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13936 else
13937 {
13938 bfd_vma entry;
82b1b41b 13939 unsigned char * from = data + addr - pltgot;
ccb4c951 13940
82b1b41b
NC		 13941 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13942 {
13943 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13944 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13945 return (bfd_vma) -1;
13946 }
13947 else
13948 {
13949 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13950 print_vma (entry, LONG_HEX);
13951 }
ccb4c951
RS		 13952 }
13953 return addr + (is_32bit_elf ? 4 : 8);
13954}
13955
861fb55a
DJ		 13956/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13957 PLTGOT. Print the Address and Initial fields of an entry at VMA
13958 ADDR and return the VMA of the next entry. */
13959
13960static bfd_vma
2cf0635d 13961print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13962{
13963 printf (" ");
13964 print_vma (addr, LONG_HEX);
13965 printf (" ");
13966 if (data == NULL)
2b692964 13967 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13968 else
13969 {
13970 bfd_vma entry;
13971
13972 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13973 print_vma (entry, LONG_HEX);
13974 }
13975 return addr + (is_32bit_elf ? 4 : 8);
13976}
13977
351cdf24
MF		 13978static void
13979print_mips_ases (unsigned int mask)
13980{
13981 if (mask & AFL_ASE_DSP)
13982 fputs ("\n\tDSP ASE", stdout);
13983 if (mask & AFL_ASE_DSPR2)
13984 fputs ("\n\tDSP R2 ASE", stdout);
13985 if (mask & AFL_ASE_EVA)
13986 fputs ("\n\tEnhanced VA Scheme", stdout);
13987 if (mask & AFL_ASE_MCU)
13988 fputs ("\n\tMCU (MicroController) ASE", stdout);
13989 if (mask & AFL_ASE_MDMX)
13990 fputs ("\n\tMDMX ASE", stdout);
13991 if (mask & AFL_ASE_MIPS3D)
13992 fputs ("\n\tMIPS-3D ASE", stdout);
13993 if (mask & AFL_ASE_MT)
13994 fputs ("\n\tMT ASE", stdout);
13995 if (mask & AFL_ASE_SMARTMIPS)
13996 fputs ("\n\tSmartMIPS ASE", stdout);
13997 if (mask & AFL_ASE_VIRT)
13998 fputs ("\n\tVZ ASE", stdout);
13999 if (mask & AFL_ASE_MSA)
14000 fputs ("\n\tMSA ASE", stdout);
14001 if (mask & AFL_ASE_MIPS16)
14002 fputs ("\n\tMIPS16 ASE", stdout);
14003 if (mask & AFL_ASE_MICROMIPS)
14004 fputs ("\n\tMICROMIPS ASE", stdout);
14005 if (mask & AFL_ASE_XPA)
14006 fputs ("\n\tXPA ASE", stdout);
14007 if (mask == 0)
14008 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14009 else if ((mask & ~AFL_ASE_MASK) != 0)
14010 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14011}
14012
14013static void
14014print_mips_isa_ext (unsigned int isa_ext)
14015{
14016 switch (isa_ext)
14017 {
14018 case 0:
14019 fputs (_("None"), stdout);
14020 break;
14021 case AFL_EXT_XLR:
14022 fputs ("RMI XLR", stdout);
14023 break;
2c629856
N		 14024 case AFL_EXT_OCTEON3:
14025 fputs ("Cavium Networks Octeon3", stdout);
14026 break;
351cdf24
MF		 14027 case AFL_EXT_OCTEON2:
14028 fputs ("Cavium Networks Octeon2", stdout);
14029 break;
14030 case AFL_EXT_OCTEONP:
14031 fputs ("Cavium Networks OcteonP", stdout);
14032 break;
14033 case AFL_EXT_LOONGSON_3A:
14034 fputs ("Loongson 3A", stdout);
14035 break;
14036 case AFL_EXT_OCTEON:
14037 fputs ("Cavium Networks Octeon", stdout);
14038 break;
14039 case AFL_EXT_5900:
14040 fputs ("Toshiba R5900", stdout);
14041 break;
14042 case AFL_EXT_4650:
14043 fputs ("MIPS R4650", stdout);
14044 break;
14045 case AFL_EXT_4010:
14046 fputs ("LSI R4010", stdout);
14047 break;
14048 case AFL_EXT_4100:
14049 fputs ("NEC VR4100", stdout);
14050 break;
14051 case AFL_EXT_3900:
14052 fputs ("Toshiba R3900", stdout);
14053 break;
14054 case AFL_EXT_10000:
14055 fputs ("MIPS R10000", stdout);
14056 break;
14057 case AFL_EXT_SB1:
14058 fputs ("Broadcom SB-1", stdout);
14059 break;
14060 case AFL_EXT_4111:
14061 fputs ("NEC VR4111/VR4181", stdout);
14062 break;
14063 case AFL_EXT_4120:
14064 fputs ("NEC VR4120", stdout);
14065 break;
14066 case AFL_EXT_5400:
14067 fputs ("NEC VR5400", stdout);
14068 break;
14069 case AFL_EXT_5500:
14070 fputs ("NEC VR5500", stdout);
14071 break;
14072 case AFL_EXT_LOONGSON_2E:
14073 fputs ("ST Microelectronics Loongson 2E", stdout);
14074 break;
14075 case AFL_EXT_LOONGSON_2F:
14076 fputs ("ST Microelectronics Loongson 2F", stdout);
14077 break;
14078 default:
00ac7aa0 14079 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14080 }
14081}
14082
14083static int
14084get_mips_reg_size (int reg_size)
14085{
14086 return (reg_size == AFL_REG_NONE) ? 0
14087 : (reg_size == AFL_REG_32) ? 32
14088 : (reg_size == AFL_REG_64) ? 64
14089 : (reg_size == AFL_REG_128) ? 128
14090 : -1;
14091}
14092
19e6b90e 14093static int
2cf0635d 14094process_mips_specific (FILE * file)
5b18a4bc 14095{
2cf0635d 14096 Elf_Internal_Dyn * entry;
351cdf24 14097 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14098 size_t liblist_offset = 0;
14099 size_t liblistno = 0;
14100 size_t conflictsno = 0;
14101 size_t options_offset = 0;
14102 size_t conflicts_offset = 0;
861fb55a
DJ		 14103 size_t pltrelsz = 0;
14104 size_t pltrel = 0;
ccb4c951 14105 bfd_vma pltgot = 0;
861fb55a
DJ		 14106 bfd_vma mips_pltgot = 0;
14107 bfd_vma jmprel = 0;
ccb4c951
RS		 14108 bfd_vma local_gotno = 0;
14109 bfd_vma gotsym = 0;
14110 bfd_vma symtabno = 0;
103f02d3 14111
2cf19d5c
JM		 14112 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14113 display_mips_gnu_attribute);
14114
351cdf24
MF		 14115 sect = find_section (".MIPS.abiflags");
14116
14117 if (sect != NULL)
14118 {
14119 Elf_External_ABIFlags_v0 *abiflags_ext;
14120 Elf_Internal_ABIFlags_v0 abiflags_in;
14121
14122 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14123 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14124 else
14125 {
14126 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14127 sect->sh_size, _("MIPS ABI Flags section"));
14128 if (abiflags_ext)
14129 {
14130 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14131 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14132 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14133 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14134 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14135 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14136 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14137 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14138 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14139 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14140 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14141
14142 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14143 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14144 if (abiflags_in.isa_rev > 1)
14145 printf ("r%d", abiflags_in.isa_rev);
14146 printf ("\nGPR size: %d",
14147 get_mips_reg_size (abiflags_in.gpr_size));
14148 printf ("\nCPR1 size: %d",
14149 get_mips_reg_size (abiflags_in.cpr1_size));
14150 printf ("\nCPR2 size: %d",
14151 get_mips_reg_size (abiflags_in.cpr2_size));
14152 fputs ("\nFP ABI: ", stdout);
14153 print_mips_fp_abi_value (abiflags_in.fp_abi);
14154 fputs ("ISA Extension: ", stdout);
14155 print_mips_isa_ext (abiflags_in.isa_ext);
14156 fputs ("\nASEs:", stdout);
14157 print_mips_ases (abiflags_in.ases);
14158 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14159 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14160 fputc ('\n', stdout);
14161 free (abiflags_ext);
14162 }
14163 }
14164 }
14165
19e6b90e
L		 14166 /* We have a lot of special sections. Thanks SGI! */
14167 if (dynamic_section == NULL)
14168 /* No information available. */
14169 return 0;
252b5132 14170
071436c6
NC		 14171 for (entry = dynamic_section;
14172 /* PR 17531 file: 012-50589-0.004. */
14173 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14174 ++entry)
252b5132
RH		 14175 switch (entry->d_tag)
14176 {
14177 case DT_MIPS_LIBLIST:
d93f0186
NC		 14178 liblist_offset
14179 = offset_from_vma (file, entry->d_un.d_val,
14180 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14181 break;
14182 case DT_MIPS_LIBLISTNO:
14183 liblistno = entry->d_un.d_val;
14184 break;
14185 case DT_MIPS_OPTIONS:
d93f0186 14186 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14187 break;
14188 case DT_MIPS_CONFLICT:
d93f0186
NC		 14189 conflicts_offset
14190 = offset_from_vma (file, entry->d_un.d_val,
14191 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14192 break;
14193 case DT_MIPS_CONFLICTNO:
14194 conflictsno = entry->d_un.d_val;
14195 break;
ccb4c951 14196 case DT_PLTGOT:
861fb55a
DJ		 14197 pltgot = entry->d_un.d_ptr;
14198 break;
ccb4c951
RS		 14199 case DT_MIPS_LOCAL_GOTNO:
14200 local_gotno = entry->d_un.d_val;
14201 break;
14202 case DT_MIPS_GOTSYM:
14203 gotsym = entry->d_un.d_val;
14204 break;
14205 case DT_MIPS_SYMTABNO:
14206 symtabno = entry->d_un.d_val;
14207 break;
861fb55a
DJ		 14208 case DT_MIPS_PLTGOT:
14209 mips_pltgot = entry->d_un.d_ptr;
14210 break;
14211 case DT_PLTREL:
14212 pltrel = entry->d_un.d_val;
14213 break;
14214 case DT_PLTRELSZ:
14215 pltrelsz = entry->d_un.d_val;
14216 break;
14217 case DT_JMPREL:
14218 jmprel = entry->d_un.d_ptr;
14219 break;
252b5132
RH		 14220 default:
14221 break;
14222 }
14223
14224 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14225 {
2cf0635d 14226 Elf32_External_Lib * elib;
252b5132
RH		 14227 size_t cnt;
14228
3f5e193b
NC		 14229 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14230 liblistno,
14231 sizeof (Elf32_External_Lib),
9cf03b7e 14232 _("liblist section data"));
a6e9f9df 14233 if (elib)
252b5132 14234 {
2b692964 14235 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14236 (unsigned long) liblistno);
2b692964 14237 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14238 stdout);
14239
14240 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14241 {
a6e9f9df 14242 Elf32_Lib liblist;
91d6fa6a 14243 time_t atime;
a6e9f9df 14244 char timebuf[20];
2cf0635d 14245 struct tm * tmp;
a6e9f9df
AM		 14246
14247 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14248 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14249 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14250 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14251 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14252
91d6fa6a 14253 tmp = gmtime (&atime);
e9e44622
JJ		 14254 snprintf (timebuf, sizeof (timebuf),
14255 "%04u-%02u-%02uT%02u:%02u:%02u",
14256 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14257 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14258
31104126 14259 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14260 if (VALID_DYNAMIC_NAME (liblist.l_name))
14261 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14262 else
2b692964 14263 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14264 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14265 liblist.l_version);
a6e9f9df
AM		 14266
14267 if (liblist.l_flags == 0)
2b692964 14268 puts (_(" NONE"));
a6e9f9df
AM		 14269 else
14270 {
14271 static const struct
252b5132 14272 {
2cf0635d 14273 const char * name;
a6e9f9df 14274 int bit;
252b5132 14275 }
a6e9f9df
AM		 14276 l_flags_vals[] =
14277 {
14278 { " EXACT_MATCH", LL_EXACT_MATCH },
14279 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14280 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14281 { " EXPORTS", LL_EXPORTS },
14282 { " DELAY_LOAD", LL_DELAY_LOAD },
14283 { " DELTA", LL_DELTA }
14284 };
14285 int flags = liblist.l_flags;
14286 size_t fcnt;
14287
60bca95a 14288 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14289 if ((flags & l_flags_vals[fcnt].bit) != 0)
14290 {
14291 fputs (l_flags_vals[fcnt].name, stdout);
14292 flags ^= l_flags_vals[fcnt].bit;
14293 }
14294 if (flags != 0)
14295 printf (" %#x", (unsigned int) flags);
252b5132 14296
a6e9f9df
AM		 14297 puts ("");
14298 }
252b5132 14299 }
252b5132 14300
a6e9f9df
AM		 14301 free (elib);
14302 }
252b5132
RH		 14303 }
14304
14305 if (options_offset != 0)
14306 {
2cf0635d 14307 Elf_External_Options * eopt;
2cf0635d
NC		 14308 Elf_Internal_Options * iopt;
14309 Elf_Internal_Options * option;
252b5132
RH		 14310 size_t offset;
14311 int cnt;
351cdf24 14312 sect = section_headers;
252b5132
RH		 14313
14314 /* Find the section header so that we get the size. */
071436c6 14315 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14316 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14317 if (sect == NULL)
14318 {
14319 error (_("No MIPS_OPTIONS header found\n"));
14320 return 0;
14321 }
252b5132 14322
3f5e193b
NC		 14323 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14324 sect->sh_size, _("options"));
a6e9f9df 14325 if (eopt)
252b5132 14326 {
3f5e193b
NC		 14327 iopt = (Elf_Internal_Options *)
14328 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14329 if (iopt == NULL)
14330 {
8b73c356 14331 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14332 return 0;
14333 }
76da6bbe 14334
a6e9f9df
AM		 14335 offset = cnt = 0;
14336 option = iopt;
252b5132 14337
82b1b41b 14338 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14339 {
2cf0635d 14340 Elf_External_Options * eoption;
252b5132 14341
a6e9f9df 14342 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14343
a6e9f9df
AM		 14344 option->kind = BYTE_GET (eoption->kind);
14345 option->size = BYTE_GET (eoption->size);
14346 option->section = BYTE_GET (eoption->section);
14347 option->info = BYTE_GET (eoption->info);
76da6bbe 14348
82b1b41b
NC		 14349 /* PR 17531: file: ffa0fa3b. */
14350 if (option->size < sizeof (* eopt)
14351 || offset + option->size > sect->sh_size)
14352 {
55325047
NC		 14353 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14354 return 0;
82b1b41b 14355 }
a6e9f9df 14356 offset += option->size;
14ae95f2 14357
a6e9f9df
AM		 14358 ++option;
14359 ++cnt;
14360 }
252b5132 14361
a6e9f9df 14362 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14363 printable_section_name (sect), cnt);
76da6bbe 14364
a6e9f9df 14365 option = iopt;
82b1b41b 14366 offset = 0;
252b5132 14367
a6e9f9df 14368 while (cnt-- > 0)
252b5132 14369 {
a6e9f9df
AM		 14370 size_t len;
14371
14372 switch (option->kind)
252b5132 14373 {
a6e9f9df
AM		 14374 case ODK_NULL:
14375 /* This shouldn't happen. */
14376 printf (" NULL %d %lx", option->section, option->info);
14377 break;
14378 case ODK_REGINFO:
14379 printf (" REGINFO ");
14380 if (elf_header.e_machine == EM_MIPS)
14381 {
14382 /* 32bit form. */
2cf0635d 14383 Elf32_External_RegInfo * ereg;
b34976b6 14384 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14385
14386 ereg = (Elf32_External_RegInfo *) (option + 1);
14387 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14388 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14389 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14390 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14391 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14392 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14393
14394 printf ("GPR %08lx GP 0x%lx\n",
14395 reginfo.ri_gprmask,
14396 (unsigned long) reginfo.ri_gp_value);
14397 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14398 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14399 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14400 }
14401 else
14402 {
14403 /* 64 bit form. */
2cf0635d 14404 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14405 Elf64_Internal_RegInfo reginfo;
14406
14407 ereg = (Elf64_External_RegInfo *) (option + 1);
14408 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14409 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14410 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14411 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14412 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14413 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14414
14415 printf ("GPR %08lx GP 0x",
14416 reginfo.ri_gprmask);
14417 printf_vma (reginfo.ri_gp_value);
14418 printf ("\n");
14419
14420 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14421 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14422 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14423 }
14424 ++option;
14425 continue;
14426 case ODK_EXCEPTIONS:
14427 fputs (" EXCEPTIONS fpe_min(", stdout);
14428 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14429 fputs (") fpe_max(", stdout);
14430 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14431 fputs (")", stdout);
14432
14433 if (option->info & OEX_PAGE0)
14434 fputs (" PAGE0", stdout);
14435 if (option->info & OEX_SMM)
14436 fputs (" SMM", stdout);
14437 if (option->info & OEX_FPDBUG)
14438 fputs (" FPDBUG", stdout);
14439 if (option->info & OEX_DISMISS)
14440 fputs (" DISMISS", stdout);
14441 break;
14442 case ODK_PAD:
14443 fputs (" PAD ", stdout);
14444 if (option->info & OPAD_PREFIX)
14445 fputs (" PREFIX", stdout);
14446 if (option->info & OPAD_POSTFIX)
14447 fputs (" POSTFIX", stdout);
14448 if (option->info & OPAD_SYMBOL)
14449 fputs (" SYMBOL", stdout);
14450 break;
14451 case ODK_HWPATCH:
14452 fputs (" HWPATCH ", stdout);
14453 if (option->info & OHW_R4KEOP)
14454 fputs (" R4KEOP", stdout);
14455 if (option->info & OHW_R8KPFETCH)
14456 fputs (" R8KPFETCH", stdout);
14457 if (option->info & OHW_R5KEOP)
14458 fputs (" R5KEOP", stdout);
14459 if (option->info & OHW_R5KCVTL)
14460 fputs (" R5KCVTL", stdout);
14461 break;
14462 case ODK_FILL:
14463 fputs (" FILL ", stdout);
14464 /* XXX Print content of info word? */
14465 break;
14466 case ODK_TAGS:
14467 fputs (" TAGS ", stdout);
14468 /* XXX Print content of info word? */
14469 break;
14470 case ODK_HWAND:
14471 fputs (" HWAND ", stdout);
14472 if (option->info & OHWA0_R4KEOP_CHECKED)
14473 fputs (" R4KEOP_CHECKED", stdout);
14474 if (option->info & OHWA0_R4KEOP_CLEAN)
14475 fputs (" R4KEOP_CLEAN", stdout);
14476 break;
14477 case ODK_HWOR:
14478 fputs (" HWOR ", stdout);
14479 if (option->info & OHWA0_R4KEOP_CHECKED)
14480 fputs (" R4KEOP_CHECKED", stdout);
14481 if (option->info & OHWA0_R4KEOP_CLEAN)
14482 fputs (" R4KEOP_CLEAN", stdout);
14483 break;
14484 case ODK_GP_GROUP:
14485 printf (" GP_GROUP %#06lx self-contained %#06lx",
14486 option->info & OGP_GROUP,
14487 (option->info & OGP_SELF) >> 16);
14488 break;
14489 case ODK_IDENT:
14490 printf (" IDENT %#06lx self-contained %#06lx",
14491 option->info & OGP_GROUP,
14492 (option->info & OGP_SELF) >> 16);
14493 break;
14494 default:
14495 /* This shouldn't happen. */
14496 printf (" %3d ??? %d %lx",
14497 option->kind, option->section, option->info);
14498 break;
252b5132 14499 }
a6e9f9df 14500
2cf0635d 14501 len = sizeof (* eopt);
a6e9f9df 14502 while (len < option->size)
82b1b41b 14503 {
7e27a9d5 14504 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14505
82b1b41b
NC		 14506 if (ISPRINT (datum))
14507 printf ("%c", datum);
14508 else
14509 printf ("\\%03o", datum);
14510 len ++;
14511 }
a6e9f9df 14512 fputs ("\n", stdout);
82b1b41b
NC		 14513
14514 offset += option->size;
252b5132 14515 ++option;
252b5132
RH		 14516 }
14517
a6e9f9df 14518 free (eopt);
252b5132 14519 }
252b5132
RH		 14520 }
14521
14522 if (conflicts_offset != 0 && conflictsno != 0)
14523 {
2cf0635d 14524 Elf32_Conflict * iconf;
252b5132
RH		 14525 size_t cnt;
14526
14527 if (dynamic_symbols == NULL)
14528 {
591a748a 14529 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14530 return 0;
14531 }
14532
3f5e193b 14533 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14534 if (iconf == NULL)
14535 {
8b73c356 14536 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14537 return 0;
14538 }
14539
9ea033b2 14540 if (is_32bit_elf)
252b5132 14541 {
2cf0635d 14542 Elf32_External_Conflict * econf32;
a6e9f9df 14543
3f5e193b
NC		 14544 econf32 = (Elf32_External_Conflict *)
14545 get_data (NULL, file, conflicts_offset, conflictsno,
14546 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14547 if (!econf32)
14548 return 0;
252b5132
RH		 14549
14550 for (cnt = 0; cnt < conflictsno; ++cnt)
14551 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14552
14553 free (econf32);
252b5132
RH		 14554 }
14555 else
14556 {
2cf0635d 14557 Elf64_External_Conflict * econf64;
a6e9f9df 14558
3f5e193b
NC		 14559 econf64 = (Elf64_External_Conflict *)
14560 get_data (NULL, file, conflicts_offset, conflictsno,
14561 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14562 if (!econf64)
14563 return 0;
252b5132
RH		 14564
14565 for (cnt = 0; cnt < conflictsno; ++cnt)
14566 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14567
14568 free (econf64);
252b5132
RH		 14569 }
14570
c7e7ca54
NC		 14571 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14572 (unsigned long) conflictsno);
252b5132
RH		 14573 puts (_(" Num: Index Value Name"));
14574
14575 for (cnt = 0; cnt < conflictsno; ++cnt)
14576 {
b34976b6 14577 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14578
14579 if (iconf[cnt] >= num_dynamic_syms)
14580 printf (_("<corrupt symbol index>"));
d79b3d50 14581 else
e0a31db1
NC		 14582 {
14583 Elf_Internal_Sym * psym;
14584
14585 psym = & dynamic_symbols[iconf[cnt]];
14586 print_vma (psym->st_value, FULL_HEX);
14587 putchar (' ');
14588 if (VALID_DYNAMIC_NAME (psym->st_name))
14589 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14590 else
14591 printf (_("<corrupt: %14ld>"), psym->st_name);
14592 }
31104126 14593 putchar ('\n');
252b5132
RH		 14594 }
14595
252b5132
RH		 14596 free (iconf);
14597 }
14598
ccb4c951
RS		 14599 if (pltgot != 0 && local_gotno != 0)
14600 {
91d6fa6a 14601 bfd_vma ent, local_end, global_end;
bbeee7ea 14602 size_t i, offset;
2cf0635d 14603 unsigned char * data;
82b1b41b 14604 unsigned char * data_end;
bbeee7ea 14605 int addr_size;
ccb4c951 14606
91d6fa6a 14607 ent = pltgot;
ccb4c951
RS		 14608 addr_size = (is_32bit_elf ? 4 : 8);
14609 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14610
74e1a04b
NC		 14611 /* PR binutils/17533 file: 012-111227-0.004 */
14612 if (symtabno < gotsym)
14613 {
14614 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14615 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14616 return 0;
14617 }
82b1b41b 14618
74e1a04b 14619 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14620 /* PR 17531: file: 54c91a34. */
14621 if (global_end < local_end)
14622 {
14623 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14624 return 0;
14625 }
948f632f 14626
ccb4c951 14627 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14628 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14629 global_end - pltgot, 1,
14630 _("Global Offset Table data"));
59245841
NC		 14631 if (data == NULL)
14632 return 0;
82b1b41b 14633 data_end = data + (global_end - pltgot);
59245841 14634
ccb4c951
RS		 14635 printf (_("\nPrimary GOT:\n"));
14636 printf (_(" Canonical gp value: "));
14637 print_vma (pltgot + 0x7ff0, LONG_HEX);
14638 printf ("\n\n");
14639
14640 printf (_(" Reserved entries:\n"));
14641 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14642 addr_size * 2, _("Address"), _("Access"),
14643 addr_size * 2, _("Initial"));
82b1b41b 14644 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14645 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14646 if (ent == (bfd_vma) -1)
14647 goto got_print_fail;
ccb4c951 14648 if (data
91d6fa6a 14649 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14650 >> (addr_size * 8 - 1)) != 0)
14651 {
82b1b41b 14652 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14653 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14654 if (ent == (bfd_vma) -1)
14655 goto got_print_fail;
ccb4c951
RS		 14656 }
14657 printf ("\n");
14658
91d6fa6a 14659 if (ent < local_end)
ccb4c951
RS		 14660 {
14661 printf (_(" Local entries:\n"));
cc5914eb 14662 printf (" %*s %10s %*s\n",
2b692964
NC		 14663 addr_size * 2, _("Address"), _("Access"),
14664 addr_size * 2, _("Initial"));
91d6fa6a 14665 while (ent < local_end)
ccb4c951 14666 {
82b1b41b 14667 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14668 printf ("\n");
82b1b41b
NC		 14669 if (ent == (bfd_vma) -1)
14670 goto got_print_fail;
ccb4c951
RS		 14671 }
14672 printf ("\n");
14673 }
14674
14675 if (gotsym < symtabno)
14676 {
14677 int sym_width;
14678
14679 printf (_(" Global entries:\n"));
cc5914eb 14680 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14681 addr_size * 2, _("Address"),
14682 _("Access"),
2b692964 14683 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14684 addr_size * 2, _("Sym.Val."),
14685 _("Type"),
14686 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14687 _("Ndx"), _("Name"));
0b4362b0 14688
ccb4c951 14689 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14690
ccb4c951
RS		 14691 for (i = gotsym; i < symtabno; i++)
14692 {
82b1b41b 14693 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14694 printf (" ");
e0a31db1
NC		 14695
14696 if (dynamic_symbols == NULL)
14697 printf (_("<no dynamic symbols>"));
14698 else if (i < num_dynamic_syms)
14699 {
14700 Elf_Internal_Sym * psym = dynamic_symbols + i;
14701
14702 print_vma (psym->st_value, LONG_HEX);
14703 printf (" %-7s %3s ",
14704 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14705 get_symbol_index_type (psym->st_shndx));
14706
14707 if (VALID_DYNAMIC_NAME (psym->st_name))
14708 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14709 else
14710 printf (_("<corrupt: %14ld>"), psym->st_name);
14711 }
ccb4c951 14712 else
7fc5ac57
JBG		 14713 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14714 (unsigned long) i);
e0a31db1 14715
ccb4c951 14716 printf ("\n");
82b1b41b
NC		 14717 if (ent == (bfd_vma) -1)
14718 break;
ccb4c951
RS		 14719 }
14720 printf ("\n");
14721 }
14722
82b1b41b 14723 got_print_fail:
ccb4c951
RS		 14724 if (data)
14725 free (data);
14726 }
14727
861fb55a
DJ		 14728 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14729 {
91d6fa6a 14730 bfd_vma ent, end;
861fb55a
DJ		 14731 size_t offset, rel_offset;
14732 unsigned long count, i;
2cf0635d 14733 unsigned char * data;
861fb55a 14734 int addr_size, sym_width;
2cf0635d 14735 Elf_Internal_Rela * rels;
861fb55a
DJ		 14736
14737 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14738 if (pltrel == DT_RELA)
14739 {
14740 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14741 return 0;
14742 }
14743 else
14744 {
14745 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14746 return 0;
14747 }
14748
91d6fa6a 14749 ent = mips_pltgot;
861fb55a
DJ		 14750 addr_size = (is_32bit_elf ? 4 : 8);
14751 end = mips_pltgot + (2 + count) * addr_size;
14752
14753 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14754 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14755 1, _("Procedure Linkage Table data"));
59245841
NC		 14756 if (data == NULL)
14757 return 0;
14758
9cf03b7e 14759 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14760 printf (_(" Reserved entries:\n"));
14761 printf (_(" %*s %*s Purpose\n"),
2b692964 14762 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14763 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14764 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14765 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14766 printf (_(" Module pointer\n"));
861fb55a
DJ		 14767 printf ("\n");
14768
14769 printf (_(" Entries:\n"));
cc5914eb 14770 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14771 addr_size * 2, _("Address"),
14772 addr_size * 2, _("Initial"),
14773 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14774 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14775 for (i = 0; i < count; i++)
14776 {
df97ab2a 14777 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14778
91d6fa6a 14779 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14780 printf (" ");
e0a31db1 14781
df97ab2a
MF		 14782 if (idx >= num_dynamic_syms)
14783 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14784 else
e0a31db1 14785 {
df97ab2a 14786 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14787
14788 print_vma (psym->st_value, LONG_HEX);
14789 printf (" %-7s %3s ",
14790 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14791 get_symbol_index_type (psym->st_shndx));
14792 if (VALID_DYNAMIC_NAME (psym->st_name))
14793 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14794 else
14795 printf (_("<corrupt: %14ld>"), psym->st_name);
14796 }
861fb55a
DJ		 14797 printf ("\n");
14798 }
14799 printf ("\n");
14800
14801 if (data)
14802 free (data);
14803 free (rels);
14804 }
14805
252b5132
RH		 14806 return 1;
14807}
14808
35c08157
KLC		 14809static int
14810process_nds32_specific (FILE * file)
14811{
14812 Elf_Internal_Shdr *sect = NULL;
14813
14814 sect = find_section (".nds32_e_flags");
14815 if (sect != NULL)
14816 {
14817 unsigned int *flag;
14818
14819 printf ("\nNDS32 elf flags section:\n");
14820 flag = get_data (NULL, file, sect->sh_offset, 1,
14821 sect->sh_size, _("NDS32 elf flags section"));
14822
14823 switch ((*flag) & 0x3)
14824 {
14825 case 0:
14826 printf ("(VEC_SIZE):\tNo entry.\n");
14827 break;
14828 case 1:
14829 printf ("(VEC_SIZE):\t4 bytes\n");
14830 break;
14831 case 2:
14832 printf ("(VEC_SIZE):\t16 bytes\n");
14833 break;
14834 case 3:
14835 printf ("(VEC_SIZE):\treserved\n");
14836 break;
14837 }
14838 }
14839
14840 return TRUE;
14841}
14842
047b2264 14843static int
2cf0635d 14844process_gnu_liblist (FILE * file)
047b2264 14845{
2cf0635d
NC		 14846 Elf_Internal_Shdr * section;
14847 Elf_Internal_Shdr * string_sec;
14848 Elf32_External_Lib * elib;
14849 char * strtab;
c256ffe7 14850 size_t strtab_size;
047b2264
JJ		 14851 size_t cnt;
14852 unsigned i;
14853
14854 if (! do_arch)
14855 return 0;
14856
14857 for (i = 0, section = section_headers;
14858 i < elf_header.e_shnum;
b34976b6 14859 i++, section++)
047b2264
JJ		 14860 {
14861 switch (section->sh_type)
14862 {
14863 case SHT_GNU_LIBLIST:
4fbb74a6 14864 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14865 break;
14866
3f5e193b
NC		 14867 elib = (Elf32_External_Lib *)
14868 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14869 _("liblist section data"));
047b2264
JJ		 14870
14871 if (elib == NULL)
14872 break;
4fbb74a6 14873 string_sec = section_headers + section->sh_link;
047b2264 14874
3f5e193b
NC		 14875 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14876 string_sec->sh_size,
14877 _("liblist string table"));
047b2264
JJ		 14878 if (strtab == NULL
14879 || section->sh_entsize != sizeof (Elf32_External_Lib))
14880 {
14881 free (elib);
2842702f 14882 free (strtab);
047b2264
JJ		 14883 break;
14884 }
59245841 14885 strtab_size = string_sec->sh_size;
047b2264
JJ		 14886
14887 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14888 printable_section_name (section),
0af1713e 14889 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14890
2b692964 14891 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14892
14893 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14894 ++cnt)
14895 {
14896 Elf32_Lib liblist;
91d6fa6a 14897 time_t atime;
047b2264 14898 char timebuf[20];
2cf0635d 14899 struct tm * tmp;
047b2264
JJ		 14900
14901 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14902 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14903 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14904 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14905 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14906
91d6fa6a 14907 tmp = gmtime (&atime);
e9e44622
JJ		 14908 snprintf (timebuf, sizeof (timebuf),
14909 "%04u-%02u-%02uT%02u:%02u:%02u",
14910 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14911 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14912
14913 printf ("%3lu: ", (unsigned long) cnt);
14914 if (do_wide)
c256ffe7 14915 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14916 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14917 else
c256ffe7 14918 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14919 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14920 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14921 liblist.l_version, liblist.l_flags);
14922 }
14923
14924 free (elib);
2842702f 14925 free (strtab);
047b2264
JJ		 14926 }
14927 }
14928
14929 return 1;
14930}
14931
9437c45b 14932static const char *
d3ba0551 14933get_note_type (unsigned e_type)
779fe533
NC		 14934{
14935 static char buff[64];
103f02d3 14936
1ec5cd37
NC		 14937 if (elf_header.e_type == ET_CORE)
14938 switch (e_type)
14939 {
57346661 14940 case NT_AUXV:
1ec5cd37 14941 return _("NT_AUXV (auxiliary vector)");
57346661 14942 case NT_PRSTATUS:
1ec5cd37 14943 return _("NT_PRSTATUS (prstatus structure)");
57346661 14944 case NT_FPREGSET:
1ec5cd37 14945 return _("NT_FPREGSET (floating point registers)");
57346661 14946 case NT_PRPSINFO:
1ec5cd37 14947 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14948 case NT_TASKSTRUCT:
1ec5cd37 14949 return _("NT_TASKSTRUCT (task structure)");
57346661 14950 case NT_PRXFPREG:
1ec5cd37 14951 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14952 case NT_PPC_VMX:
14953 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14954 case NT_PPC_VSX:
14955 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14956 case NT_386_TLS:
14957 return _("NT_386_TLS (x86 TLS information)");
14958 case NT_386_IOPERM:
14959 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14960 case NT_X86_XSTATE:
14961 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14962 case NT_S390_HIGH_GPRS:
14963 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14964 case NT_S390_TIMER:
14965 return _("NT_S390_TIMER (s390 timer register)");
14966 case NT_S390_TODCMP:
14967 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14968 case NT_S390_TODPREG:
14969 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14970 case NT_S390_CTRS:
14971 return _("NT_S390_CTRS (s390 control registers)");
14972 case NT_S390_PREFIX:
14973 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14974 case NT_S390_LAST_BREAK:
14975 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14976 case NT_S390_SYSTEM_CALL:
14977 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14978 case NT_S390_TDB:
14979 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14980 case NT_S390_VXRS_LOW:
14981 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14982 case NT_S390_VXRS_HIGH:
14983 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14984 case NT_ARM_VFP:
14985 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14986 case NT_ARM_TLS:
14987 return _("NT_ARM_TLS (AArch TLS registers)");
14988 case NT_ARM_HW_BREAK:
14989 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14990 case NT_ARM_HW_WATCH:
14991 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14992 case NT_PSTATUS:
1ec5cd37 14993 return _("NT_PSTATUS (pstatus structure)");
57346661 14994 case NT_FPREGS:
1ec5cd37 14995 return _("NT_FPREGS (floating point registers)");
57346661 14996 case NT_PSINFO:
1ec5cd37 14997 return _("NT_PSINFO (psinfo structure)");
57346661 14998 case NT_LWPSTATUS:
1ec5cd37 14999 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15000 case NT_LWPSINFO:
1ec5cd37 15001 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15002 case NT_WIN32PSTATUS:
1ec5cd37 15003 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15004 case NT_SIGINFO:
15005 return _("NT_SIGINFO (siginfo_t data)");
15006 case NT_FILE:
15007 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15008 default:
15009 break;
15010 }
15011 else
15012 switch (e_type)
15013 {
15014 case NT_VERSION:
15015 return _("NT_VERSION (version)");
15016 case NT_ARCH:
15017 return _("NT_ARCH (architecture)");
15018 default:
15019 break;
15020 }
15021
e9e44622 15022 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15023 return buff;
779fe533
NC		 15024}
15025
9ece1fa9
TT		 15026static int
15027print_core_note (Elf_Internal_Note *pnote)
15028{
15029 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15030 bfd_vma count, page_size;
15031 unsigned char *descdata, *filenames, *descend;
15032
15033 if (pnote->type != NT_FILE)
15034 return 1;
15035
15036#ifndef BFD64
15037 if (!is_32bit_elf)
15038 {
15039 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15040 /* Still "successful". */
15041 return 1;
15042 }
15043#endif
15044
15045 if (pnote->descsz < 2 * addr_size)
15046 {
15047 printf (_(" Malformed note - too short for header\n"));
15048 return 0;
15049 }
15050
15051 descdata = (unsigned char *) pnote->descdata;
15052 descend = descdata + pnote->descsz;
15053
15054 if (descdata[pnote->descsz - 1] != '\0')
15055 {
15056 printf (_(" Malformed note - does not end with \\0\n"));
15057 return 0;
15058 }
15059
15060 count = byte_get (descdata, addr_size);
15061 descdata += addr_size;
15062
15063 page_size = byte_get (descdata, addr_size);
15064 descdata += addr_size;
15065
15066 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15067 {
15068 printf (_(" Malformed note - too short for supplied file count\n"));
15069 return 0;
15070 }
15071
15072 printf (_(" Page size: "));
15073 print_vma (page_size, DEC);
15074 printf ("\n");
15075
15076 printf (_(" %*s%*s%*s\n"),
15077 (int) (2 + 2 * addr_size), _("Start"),
15078 (int) (4 + 2 * addr_size), _("End"),
15079 (int) (4 + 2 * addr_size), _("Page Offset"));
15080 filenames = descdata + count * 3 * addr_size;
15081 while (--count > 0)
15082 {
15083 bfd_vma start, end, file_ofs;
15084
15085 if (filenames == descend)
15086 {
15087 printf (_(" Malformed note - filenames end too early\n"));
15088 return 0;
15089 }
15090
15091 start = byte_get (descdata, addr_size);
15092 descdata += addr_size;
15093 end = byte_get (descdata, addr_size);
15094 descdata += addr_size;
15095 file_ofs = byte_get (descdata, addr_size);
15096 descdata += addr_size;
15097
15098 printf (" ");
15099 print_vma (start, FULL_HEX);
15100 printf (" ");
15101 print_vma (end, FULL_HEX);
15102 printf (" ");
15103 print_vma (file_ofs, FULL_HEX);
15104 printf ("\n %s\n", filenames);
15105
15106 filenames += 1 + strlen ((char *) filenames);
15107 }
15108
15109 return 1;
15110}
15111
1118d252
RM		 15112static const char *
15113get_gnu_elf_note_type (unsigned e_type)
15114{
15115 static char buff[64];
15116
15117 switch (e_type)
15118 {
15119 case NT_GNU_ABI_TAG:
15120 return _("NT_GNU_ABI_TAG (ABI version tag)");
15121 case NT_GNU_HWCAP:
15122 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15123 case NT_GNU_BUILD_ID:
15124 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15125 case NT_GNU_GOLD_VERSION:
15126 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15127 default:
15128 break;
15129 }
15130
15131 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15132 return buff;
15133}
15134
664f90a3
TT		 15135static int
15136print_gnu_note (Elf_Internal_Note *pnote)
15137{
15138 switch (pnote->type)
15139 {
15140 case NT_GNU_BUILD_ID:
15141 {
15142 unsigned long i;
15143
15144 printf (_(" Build ID: "));
15145 for (i = 0; i < pnote->descsz; ++i)
15146 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15147 printf ("\n");
664f90a3
TT		 15148 }
15149 break;
15150
15151 case NT_GNU_ABI_TAG:
15152 {
15153 unsigned long os, major, minor, subminor;
15154 const char *osname;
15155
3102e897
NC		 15156 /* PR 17531: file: 030-599401-0.004. */
15157 if (pnote->descsz < 16)
15158 {
15159 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15160 break;
15161 }
15162
664f90a3
TT		 15163 os = byte_get ((unsigned char *) pnote->descdata, 4);
15164 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15165 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15166 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15167
15168 switch (os)
15169 {
15170 case GNU_ABI_TAG_LINUX:
15171 osname = "Linux";
15172 break;
15173 case GNU_ABI_TAG_HURD:
15174 osname = "Hurd";
15175 break;
15176 case GNU_ABI_TAG_SOLARIS:
15177 osname = "Solaris";
15178 break;
15179 case GNU_ABI_TAG_FREEBSD:
15180 osname = "FreeBSD";
15181 break;
15182 case GNU_ABI_TAG_NETBSD:
15183 osname = "NetBSD";
15184 break;
14ae95f2
RM		 15185 case GNU_ABI_TAG_SYLLABLE:
15186 osname = "Syllable";
15187 break;
15188 case GNU_ABI_TAG_NACL:
15189 osname = "NaCl";
15190 break;
664f90a3
TT		 15191 default:
15192 osname = "Unknown";
15193 break;
15194 }
15195
15196 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15197 major, minor, subminor);
15198 }
15199 break;
926c5385
CC		 15200
15201 case NT_GNU_GOLD_VERSION:
15202 {
15203 unsigned long i;
15204
15205 printf (_(" Version: "));
15206 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15207 printf ("%c", pnote->descdata[i]);
15208 printf ("\n");
15209 }
15210 break;
664f90a3
TT		 15211 }
15212
15213 return 1;
15214}
15215
685080f2
NC		 15216static const char *
15217get_v850_elf_note_type (enum v850_notes n_type)
15218{
15219 static char buff[64];
15220
15221 switch (n_type)
15222 {
15223 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15224 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15225 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15226 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15227 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15228 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15229 default:
15230 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15231 return buff;
15232 }
15233}
15234
15235static int
15236print_v850_note (Elf_Internal_Note * pnote)
15237{
15238 unsigned int val;
15239
15240 if (pnote->descsz != 4)
15241 return 0;
15242 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15243
15244 if (val == 0)
15245 {
15246 printf (_("not set\n"));
15247 return 1;
15248 }
15249
15250 switch (pnote->type)
15251 {
15252 case V850_NOTE_ALIGNMENT:
15253 switch (val)
15254 {
15255 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15256 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15257 }
15258 break;
14ae95f2 15259
685080f2
NC		 15260 case V850_NOTE_DATA_SIZE:
15261 switch (val)
15262 {
15263 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15264 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15265 }
15266 break;
14ae95f2 15267
685080f2
NC		 15268 case V850_NOTE_FPU_INFO:
15269 switch (val)
15270 {
15271 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15272 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15273 }
15274 break;
14ae95f2 15275
685080f2
NC		 15276 case V850_NOTE_MMU_INFO:
15277 case V850_NOTE_CACHE_INFO:
15278 case V850_NOTE_SIMD_INFO:
15279 if (val == EF_RH850_SIMD)
15280 {
15281 printf (_("yes\n"));
15282 return 1;
15283 }
15284 break;
15285
15286 default:
15287 /* An 'unknown note type' message will already have been displayed. */
15288 break;
15289 }
15290
15291 printf (_("unknown value: %x\n"), val);
15292 return 0;
15293}
15294
9437c45b 15295static const char *
d3ba0551 15296get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15297{
15298 static char buff[64];
15299
b4db1224 15300 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15301 {
15302 /* NetBSD core "procinfo" structure. */
15303 return _("NetBSD procinfo structure");
15304 }
15305
15306 /* As of Jan 2002 there are no other machine-independent notes
15307 defined for NetBSD core files. If the note type is less
15308 than the start of the machine-dependent note types, we don't
15309 understand it. */
15310
b4db1224 15311 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15312 {
e9e44622 15313 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15314 return buff;
15315 }
15316
15317 switch (elf_header.e_machine)
15318 {
15319 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15320 and PT_GETFPREGS == mach+2. */
15321
15322 case EM_OLD_ALPHA:
15323 case EM_ALPHA:
15324 case EM_SPARC:
15325 case EM_SPARC32PLUS:
15326 case EM_SPARCV9:
15327 switch (e_type)
15328 {
2b692964 15329 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15330 return _("PT_GETREGS (reg structure)");
2b692964 15331 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15332 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15333 default:
15334 break;
15335 }
15336 break;
15337
15338 /* On all other arch's, PT_GETREGS == mach+1 and
15339 PT_GETFPREGS == mach+3. */
15340 default:
15341 switch (e_type)
15342 {
2b692964 15343 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15344 return _("PT_GETREGS (reg structure)");
2b692964 15345 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15346 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15347 default:
15348 break;
15349 }
15350 }
15351
9cf03b7e 15352 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15353 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15354 return buff;
15355}
15356
70616151
TT		 15357static const char *
15358get_stapsdt_note_type (unsigned e_type)
15359{
15360 static char buff[64];
15361
15362 switch (e_type)
15363 {
15364 case NT_STAPSDT:
15365 return _("NT_STAPSDT (SystemTap probe descriptors)");
15366
15367 default:
15368 break;
15369 }
15370
15371 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15372 return buff;
15373}
15374
c6a9fc58
TT		 15375static int
15376print_stapsdt_note (Elf_Internal_Note *pnote)
15377{
15378 int addr_size = is_32bit_elf ? 4 : 8;
15379 char *data = pnote->descdata;
15380 char *data_end = pnote->descdata + pnote->descsz;
15381 bfd_vma pc, base_addr, semaphore;
15382 char *provider, *probe, *arg_fmt;
15383
15384 pc = byte_get ((unsigned char *) data, addr_size);
15385 data += addr_size;
15386 base_addr = byte_get ((unsigned char *) data, addr_size);
15387 data += addr_size;
15388 semaphore = byte_get ((unsigned char *) data, addr_size);
15389 data += addr_size;
15390
15391 provider = data;
15392 data += strlen (data) + 1;
15393 probe = data;
15394 data += strlen (data) + 1;
15395 arg_fmt = data;
15396 data += strlen (data) + 1;
15397
15398 printf (_(" Provider: %s\n"), provider);
15399 printf (_(" Name: %s\n"), probe);
15400 printf (_(" Location: "));
15401 print_vma (pc, FULL_HEX);
15402 printf (_(", Base: "));
15403 print_vma (base_addr, FULL_HEX);
15404 printf (_(", Semaphore: "));
15405 print_vma (semaphore, FULL_HEX);
9cf03b7e 15406 printf ("\n");
c6a9fc58
TT		 15407 printf (_(" Arguments: %s\n"), arg_fmt);
15408
15409 return data == data_end;
15410}
15411
00e98fc7
TG		 15412static const char *
15413get_ia64_vms_note_type (unsigned e_type)
15414{
15415 static char buff[64];
15416
15417 switch (e_type)
15418 {
15419 case NT_VMS_MHD:
15420 return _("NT_VMS_MHD (module header)");
15421 case NT_VMS_LNM:
15422 return _("NT_VMS_LNM (language name)");
15423 case NT_VMS_SRC:
15424 return _("NT_VMS_SRC (source files)");
15425 case NT_VMS_TITLE:
9cf03b7e 15426 return "NT_VMS_TITLE";
00e98fc7
TG		 15427 case NT_VMS_EIDC:
15428 return _("NT_VMS_EIDC (consistency check)");
15429 case NT_VMS_FPMODE:
15430 return _("NT_VMS_FPMODE (FP mode)");
15431 case NT_VMS_LINKTIME:
9cf03b7e 15432 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15433 case NT_VMS_IMGNAM:
15434 return _("NT_VMS_IMGNAM (image name)");
15435 case NT_VMS_IMGID:
15436 return _("NT_VMS_IMGID (image id)");
15437 case NT_VMS_LINKID:
15438 return _("NT_VMS_LINKID (link id)");
15439 case NT_VMS_IMGBID:
15440 return _("NT_VMS_IMGBID (build id)");
15441 case NT_VMS_GSTNAM:
15442 return _("NT_VMS_GSTNAM (sym table name)");
15443 case NT_VMS_ORIG_DYN:
9cf03b7e 15444 return "NT_VMS_ORIG_DYN";
00e98fc7 15445 case NT_VMS_PATCHTIME:
9cf03b7e 15446 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15447 default:
15448 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15449 return buff;
15450 }
15451}
15452
15453static int
15454print_ia64_vms_note (Elf_Internal_Note * pnote)
15455{
15456 switch (pnote->type)
15457 {
15458 case NT_VMS_MHD:
15459 if (pnote->descsz > 36)
15460 {
15461 size_t l = strlen (pnote->descdata + 34);
15462 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15463 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15464 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15465 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15466 }
15467 else
15468 printf (_(" Invalid size\n"));
15469 break;
15470 case NT_VMS_LNM:
15471 printf (_(" Language: %s\n"), pnote->descdata);
15472 break;
15473#ifdef BFD64
15474 case NT_VMS_FPMODE:
9cf03b7e 15475 printf (_(" Floating Point mode: "));
4a5cb34f 15476 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15477 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15478 break;
15479 case NT_VMS_LINKTIME:
15480 printf (_(" Link time: "));
15481 print_vms_time
15482 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15483 printf ("\n");
15484 break;
15485 case NT_VMS_PATCHTIME:
15486 printf (_(" Patch time: "));
15487 print_vms_time
15488 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15489 printf ("\n");
15490 break;
15491 case NT_VMS_ORIG_DYN:
15492 printf (_(" Major id: %u, minor id: %u\n"),
15493 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15494 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15495 printf (_(" Last modified : "));
00e98fc7
TG		 15496 print_vms_time
15497 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15498 printf (_("\n Link flags : "));
4a5cb34f 15499 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15500 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15501 printf (_(" Header flags: 0x%08x\n"),
948f632f 15502 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15503 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15504 break;
15505#endif
15506 case NT_VMS_IMGNAM:
15507 printf (_(" Image name: %s\n"), pnote->descdata);
15508 break;
15509 case NT_VMS_GSTNAM:
15510 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15511 break;
15512 case NT_VMS_IMGID:
15513 printf (_(" Image id: %s\n"), pnote->descdata);
15514 break;
15515 case NT_VMS_LINKID:
15516 printf (_(" Linker id: %s\n"), pnote->descdata);
15517 break;
15518 default:
15519 break;
15520 }
15521 return 1;
15522}
15523
6d118b09
NC		 15524/* Note that by the ELF standard, the name field is already null byte
15525 terminated, and namesz includes the terminating null byte.
15526 I.E. the value of namesz for the name "FSF" is 4.
15527
e3c8793a 15528 If the value of namesz is zero, there is no name present. */
779fe533 15529static int
2cf0635d 15530process_note (Elf_Internal_Note * pnote)
779fe533 15531{
2cf0635d
NC		 15532 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15533 const char * nt;
9437c45b
JT		 15534
15535 if (pnote->namesz == 0)
1ec5cd37
NC		 15536 /* If there is no note name, then use the default set of
15537 note type strings. */
15538 nt = get_note_type (pnote->type);
15539
1118d252
RM		 15540 else if (const_strneq (pnote->namedata, "GNU"))
15541 /* GNU-specific object file notes. */
15542 nt = get_gnu_elf_note_type (pnote->type);
15543
0112cd26 15544 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15545 /* NetBSD-specific core file notes. */
15546 nt = get_netbsd_elfcore_note_type (pnote->type);
15547
b15fa79e
AM		 15548 else if (strneq (pnote->namedata, "SPU/", 4))
15549 {
15550 /* SPU-specific core file notes. */
15551 nt = pnote->namedata + 4;
15552 name = "SPU";
15553 }
15554
00e98fc7
TG		 15555 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15556 /* VMS/ia64-specific file notes. */
15557 nt = get_ia64_vms_note_type (pnote->type);
15558
70616151
TT		 15559 else if (const_strneq (pnote->namedata, "stapsdt"))
15560 nt = get_stapsdt_note_type (pnote->type);
15561
9437c45b 15562 else
1ec5cd37
NC		 15563 /* Don't recognize this note name; just use the default set of
15564 note type strings. */
00e98fc7 15565 nt = get_note_type (pnote->type);
9437c45b 15566
2aee03ae 15567 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15568
15569 if (const_strneq (pnote->namedata, "IPF/VMS"))
15570 return print_ia64_vms_note (pnote);
664f90a3
TT		 15571 else if (const_strneq (pnote->namedata, "GNU"))
15572 return print_gnu_note (pnote);
c6a9fc58
TT		 15573 else if (const_strneq (pnote->namedata, "stapsdt"))
15574 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15575 else if (const_strneq (pnote->namedata, "CORE"))
15576 return print_core_note (pnote);
00e98fc7
TG		 15577 else
15578 return 1;
779fe533
NC		 15579}
15580
6d118b09 15581
779fe533 15582static int
2cf0635d 15583process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15584{
2cf0635d
NC		 15585 Elf_External_Note * pnotes;
15586 Elf_External_Note * external;
c8071705 15587 char * end;
b34976b6 15588 int res = 1;
103f02d3 15589
779fe533
NC		 15590 if (length <= 0)
15591 return 0;
103f02d3 15592
3f5e193b 15593 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15594 _("notes"));
dd24e3da 15595 if (pnotes == NULL)
a6e9f9df 15596 return 0;
779fe533 15597
103f02d3 15598 external = pnotes;
103f02d3 15599
9dd3a467 15600 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15601 (unsigned long) offset, (unsigned long) length);
2aee03ae 15602 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15603
c8071705
NC		 15604 end = (char *) pnotes + length;
15605 while ((char *) external < end)
779fe533 15606 {
b34976b6 15607 Elf_Internal_Note inote;
15b42fb0
AM		 15608 size_t min_notesz;
15609 char *next;
2cf0635d 15610 char * temp = NULL;
c8071705 15611 size_t data_remaining = end - (char *) external;
6d118b09 15612
00e98fc7 15613 if (!is_ia64_vms ())
15b42fb0 15614 {
9dd3a467
NC		 15615 /* PR binutils/15191
15616 Make sure that there is enough data to read. */
15b42fb0
AM		 15617 min_notesz = offsetof (Elf_External_Note, name);
15618 if (data_remaining < min_notesz)
9dd3a467
NC		 15619 {
15620 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15621 (int) data_remaining);
15622 break;
15623 }
15b42fb0
AM		 15624 inote.type = BYTE_GET (external->type);
15625 inote.namesz = BYTE_GET (external->namesz);
15626 inote.namedata = external->name;
15627 inote.descsz = BYTE_GET (external->descsz);
15628 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15629 /* PR 17531: file: 3443835e. */
c8071705 15630 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15631 {
15632 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15633 inote.descdata = inote.namedata;
15634 inote.namesz = 0;
15635 }
14ae95f2 15636
15b42fb0
AM		 15637 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15638 next = inote.descdata + align_power (inote.descsz, 2);
15639 }
00e98fc7 15640 else
15b42fb0
AM		 15641 {
15642 Elf64_External_VMS_Note *vms_external;
00e98fc7 15643
9dd3a467
NC		 15644 /* PR binutils/15191
15645 Make sure that there is enough data to read. */
15b42fb0
AM		 15646 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15647 if (data_remaining < min_notesz)
9dd3a467
NC		 15648 {
15649 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15650 (int) data_remaining);
15651 break;
15652 }
3e55a963 15653
15b42fb0
AM		 15654 vms_external = (Elf64_External_VMS_Note *) external;
15655 inote.type = BYTE_GET (vms_external->type);
15656 inote.namesz = BYTE_GET (vms_external->namesz);
15657 inote.namedata = vms_external->name;
15658 inote.descsz = BYTE_GET (vms_external->descsz);
15659 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15660 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15661 next = inote.descdata + align_power (inote.descsz, 3);
15662 }
15663
15664 if (inote.descdata < (char *) external + min_notesz
15665 || next < (char *) external + min_notesz
5d921cbd
NC		 15666 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15667 || inote.namedata + inote.namesz < inote.namedata
15668 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15669 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15670 {
15b42fb0 15671 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15672 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15673 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15674 inote.type, inote.namesz, inote.descsz);
15675 break;
15676 }
15677
15b42fb0 15678 external = (Elf_External_Note *) next;
dd24e3da 15679
6d118b09
NC		 15680 /* Verify that name is null terminated. It appears that at least
15681 one version of Linux (RedHat 6.0) generates corefiles that don't
15682 comply with the ELF spec by failing to include the null byte in
15683 namesz. */
8b971f9f 15684 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15685 {
3f5e193b 15686 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15687 if (temp == NULL)
15688 {
8b73c356 15689 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15690 res = 0;
15691 break;
15692 }
76da6bbe 15693
6d118b09
NC		 15694 strncpy (temp, inote.namedata, inote.namesz);
15695 temp[inote.namesz] = 0;
76da6bbe 15696
6d118b09
NC		 15697 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15698 inote.namedata = temp;
15699 }
15700
15701 res &= process_note (& inote);
103f02d3 15702
6d118b09
NC		 15703 if (temp != NULL)
15704 {
15705 free (temp);
15706 temp = NULL;
15707 }
779fe533
NC		 15708 }
15709
15710 free (pnotes);
103f02d3 15711
779fe533
NC		 15712 return res;
15713}
15714
15715static int
2cf0635d 15716process_corefile_note_segments (FILE * file)
779fe533 15717{
2cf0635d 15718 Elf_Internal_Phdr * segment;
b34976b6
AM		 15719 unsigned int i;
15720 int res = 1;
103f02d3 15721
d93f0186 15722 if (! get_program_headers (file))
779fe533 15723 return 0;
103f02d3 15724
779fe533
NC		 15725 for (i = 0, segment = program_headers;
15726 i < elf_header.e_phnum;
b34976b6 15727 i++, segment++)
779fe533
NC		 15728 {
15729 if (segment->p_type == PT_NOTE)
103f02d3 15730 res &= process_corefile_note_segment (file,
30800947
NC		 15731 (bfd_vma) segment->p_offset,
15732 (bfd_vma) segment->p_filesz);
779fe533 15733 }
103f02d3 15734
779fe533
NC		 15735 return res;
15736}
15737
685080f2
NC		 15738static int
15739process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15740{
15741 Elf_External_Note * pnotes;
15742 Elf_External_Note * external;
c8071705 15743 char * end;
685080f2
NC		 15744 int res = 1;
15745
15746 if (length <= 0)
15747 return 0;
15748
15749 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15750 _("v850 notes"));
15751 if (pnotes == NULL)
15752 return 0;
15753
15754 external = pnotes;
c8071705 15755 end = (char*) pnotes + length;
685080f2
NC		 15756
15757 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15758 (unsigned long) offset, (unsigned long) length);
15759
c8071705 15760 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15761 {
15762 Elf_External_Note * next;
15763 Elf_Internal_Note inote;
15764
15765 inote.type = BYTE_GET (external->type);
15766 inote.namesz = BYTE_GET (external->namesz);
15767 inote.namedata = external->name;
15768 inote.descsz = BYTE_GET (external->descsz);
15769 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15770 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15771
c8071705
NC		 15772 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15773 {
15774 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15775 inote.descdata = inote.namedata;
15776 inote.namesz = 0;
15777 }
15778
685080f2
NC		 15779 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15780
c8071705 15781 if ( ((char *) next > end)
685080f2
NC		 15782 || ((char *) next < (char *) pnotes))
15783 {
15784 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15785 (unsigned long) ((char *) external - (char *) pnotes));
15786 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15787 inote.type, inote.namesz, inote.descsz);
15788 break;
15789 }
15790
15791 external = next;
15792
15793 /* Prevent out-of-bounds indexing. */
c8071705 15794 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15795 || inote.namedata + inote.namesz < inote.namedata)
15796 {
15797 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15798 (unsigned long) ((char *) external - (char *) pnotes));
15799 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15800 inote.type, inote.namesz, inote.descsz);
15801 break;
15802 }
15803
15804 printf (" %s: ", get_v850_elf_note_type (inote.type));
15805
15806 if (! print_v850_note (& inote))
15807 {
15808 res = 0;
15809 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15810 inote.namesz, inote.descsz);
15811 }
15812 }
15813
15814 free (pnotes);
15815
15816 return res;
15817}
15818
779fe533 15819static int
2cf0635d 15820process_note_sections (FILE * file)
1ec5cd37 15821{
2cf0635d 15822 Elf_Internal_Shdr * section;
1ec5cd37 15823 unsigned long i;
df565f32 15824 int n = 0;
1ec5cd37
NC		 15825 int res = 1;
15826
15827 for (i = 0, section = section_headers;
fa1908fd 15828 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15829 i++, section++)
685080f2
NC		 15830 {
15831 if (section->sh_type == SHT_NOTE)
15832 {
15833 res &= process_corefile_note_segment (file,
15834 (bfd_vma) section->sh_offset,
15835 (bfd_vma) section->sh_size);
15836 n++;
15837 }
15838
15839 if (( elf_header.e_machine == EM_V800
15840 || elf_header.e_machine == EM_V850
15841 || elf_header.e_machine == EM_CYGNUS_V850)
15842 && section->sh_type == SHT_RENESAS_INFO)
15843 {
15844 res &= process_v850_notes (file,
15845 (bfd_vma) section->sh_offset,
15846 (bfd_vma) section->sh_size);
15847 n++;
15848 }
15849 }
df565f32
NC		 15850
15851 if (n == 0)
15852 /* Try processing NOTE segments instead. */
15853 return process_corefile_note_segments (file);
1ec5cd37
NC		 15854
15855 return res;
15856}
15857
15858static int
2cf0635d 15859process_notes (FILE * file)
779fe533
NC		 15860{
15861 /* If we have not been asked to display the notes then do nothing. */
15862 if (! do_notes)
15863 return 1;
103f02d3 15864
779fe533 15865 if (elf_header.e_type != ET_CORE)
1ec5cd37 15866 return process_note_sections (file);
103f02d3 15867
779fe533 15868 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15869 if (elf_header.e_phnum > 0)
15870 return process_corefile_note_segments (file);
779fe533 15871
1ec5cd37
NC		 15872 printf (_("No note segments present in the core file.\n"));
15873 return 1;
779fe533
NC		 15874}
15875
252b5132 15876static int
2cf0635d 15877process_arch_specific (FILE * file)
252b5132 15878{
a952a375
NC		 15879 if (! do_arch)
15880 return 1;
15881
252b5132
RH		 15882 switch (elf_header.e_machine)
15883 {
11c1ff18
PB		 15884 case EM_ARM:
15885 return process_arm_specific (file);
252b5132 15886 case EM_MIPS:
4fe85591 15887 case EM_MIPS_RS3_LE:
252b5132
RH		 15888 return process_mips_specific (file);
15889 break;
35c08157
KLC		 15890 case EM_NDS32:
15891 return process_nds32_specific (file);
15892 break;
34c8bcba
JM		 15893 case EM_PPC:
15894 return process_power_specific (file);
15895 break;
643f7afb
AK		 15896 case EM_S390:
15897 case EM_S390_OLD:
15898 return process_s390_specific (file);
15899 break;
9e8c70f9
DM		 15900 case EM_SPARC:
15901 case EM_SPARC32PLUS:
15902 case EM_SPARCV9:
15903 return process_sparc_specific (file);
15904 break;
59e6276b
JM		 15905 case EM_TI_C6000:
15906 return process_tic6x_specific (file);
15907 break;
13761a11
NC		 15908 case EM_MSP430:
15909 return process_msp430x_specific (file);
252b5132
RH		 15910 default:
15911 break;
15912 }
15913 return 1;
15914}
15915
15916static int
2cf0635d 15917get_file_header (FILE * file)
252b5132 15918{
9ea033b2
NC		 15919 /* Read in the identity array. */
15920 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15921 return 0;
15922
9ea033b2 15923 /* Determine how to read the rest of the header. */
b34976b6 15924 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15925 {
15926 default: /* fall through */
15927 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15928 case ELFDATA2LSB:
15929 byte_get = byte_get_little_endian;
15930 byte_put = byte_put_little_endian;
15931 break;
15932 case ELFDATA2MSB:
15933 byte_get = byte_get_big_endian;
15934 byte_put = byte_put_big_endian;
15935 break;
9ea033b2
NC		 15936 }
15937
15938 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15939 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15940
15941 /* Read in the rest of the header. */
15942 if (is_32bit_elf)
15943 {
15944 Elf32_External_Ehdr ehdr32;
252b5132 15945
9ea033b2
NC		 15946 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15947 return 0;
103f02d3 15948
9ea033b2
NC		 15949 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15950 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15951 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15952 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15953 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15954 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15955 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15956 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15957 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15958 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15959 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15960 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15961 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15962 }
252b5132 15963 else
9ea033b2
NC		 15964 {
15965 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15966
15967 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15968 we will not be able to cope with the 64bit data found in
15969 64 ELF files. Detect this now and abort before we start
50c2245b 15970 overwriting things. */
a952a375
NC		 15971 if (sizeof (bfd_vma) < 8)
15972 {
e3c8793a
NC		 15973 error (_("This instance of readelf has been built without support for a\n\
1597464 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15975 return 0;
15976 }
103f02d3 15977
9ea033b2
NC		 15978 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15979 return 0;
103f02d3 15980
9ea033b2
NC		 15981 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15982 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15983 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15984 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15985 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15986 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15987 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15988 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15989 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15990 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15991 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15992 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15993 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15994 }
252b5132 15995
7ece0d85
JJ		 15996 if (elf_header.e_shoff)
15997 {
15998 /* There may be some extensions in the first section header. Don't
15999 bomb if we can't read it. */
16000 if (is_32bit_elf)
049b0c3a 16001 get_32bit_section_headers (file, TRUE);
7ece0d85 16002 else
049b0c3a 16003 get_64bit_section_headers (file, TRUE);
7ece0d85 16004 }
560f3c1c 16005
252b5132
RH		 16006 return 1;
16007}
16008
fb52b2f4
NC		 16009/* Process one ELF object file according to the command line options.
16010 This file may actually be stored in an archive. The file is
16011 positioned at the start of the ELF object. */
16012
ff78d6d6 16013static int
2cf0635d 16014process_object (char * file_name, FILE * file)
252b5132 16015{
252b5132
RH		 16016 unsigned int i;
16017
252b5132
RH		 16018 if (! get_file_header (file))
16019 {
16020 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16021 return 1;
252b5132
RH		 16022 }
16023
16024 /* Initialise per file variables. */
60bca95a 16025 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16026 version_info[i] = 0;
16027
60bca95a 16028 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16029 dynamic_info[i] = 0;
5115b233 16030 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16031
16032 /* Process the file. */
16033 if (show_name)
16034 printf (_("\nFile: %s\n"), file_name);
16035
18bd398b
NC		 16036 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16037 Note we do this even if cmdline_dump_sects is empty because we
16038 must make sure that the dump_sets array is zeroed out before each
16039 object file is processed. */
16040 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16041 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16042
16043 if (num_cmdline_dump_sects > 0)
16044 {
16045 if (num_dump_sects == 0)
16046 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16047 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16048
16049 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16050 memcpy (dump_sects, cmdline_dump_sects,
16051 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16052 }
d70c5fc7 16053
252b5132 16054 if (! process_file_header ())
fb52b2f4 16055 return 1;
252b5132 16056
d1f5c6e3 16057 if (! process_section_headers (file))
2f62977e 16058 {
d1f5c6e3
L		 16059 /* Without loaded section headers we cannot process lots of
16060 things. */
2f62977e 16061 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16062
2f62977e 16063 if (! do_using_dynamic)
2c610e4b 16064 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16065 }
252b5132 16066
d1f5c6e3
L		 16067 if (! process_section_groups (file))
16068 {
16069 /* Without loaded section groups we cannot process unwind. */
16070 do_unwind = 0;
16071 }
16072
2f62977e 16073 if (process_program_headers (file))
b2d38a17 16074 process_dynamic_section (file);
252b5132
RH		 16075
16076 process_relocs (file);
16077
4d6ed7c8
NC		 16078 process_unwind (file);
16079
252b5132
RH		 16080 process_symbol_table (file);
16081
16082 process_syminfo (file);
16083
16084 process_version_sections (file);
16085
16086 process_section_contents (file);
f5842774 16087
1ec5cd37 16088 process_notes (file);
103f02d3 16089
047b2264
JJ		 16090 process_gnu_liblist (file);
16091
252b5132
RH		 16092 process_arch_specific (file);
16093
d93f0186
NC		 16094 if (program_headers)
16095 {
16096 free (program_headers);
16097 program_headers = NULL;
16098 }
16099
252b5132
RH		 16100 if (section_headers)
16101 {
16102 free (section_headers);
16103 section_headers = NULL;
16104 }
16105
16106 if (string_table)
16107 {
16108 free (string_table);
16109 string_table = NULL;
d40ac9bd 16110 string_table_length = 0;
252b5132
RH		 16111 }
16112
16113 if (dynamic_strings)
16114 {
16115 free (dynamic_strings);
16116 dynamic_strings = NULL;
d79b3d50 16117 dynamic_strings_length = 0;
252b5132
RH		 16118 }
16119
16120 if (dynamic_symbols)
16121 {
16122 free (dynamic_symbols);
16123 dynamic_symbols = NULL;
19936277 16124 num_dynamic_syms = 0;
252b5132
RH		 16125 }
16126
16127 if (dynamic_syminfo)
16128 {
16129 free (dynamic_syminfo);
16130 dynamic_syminfo = NULL;
16131 }
ff78d6d6 16132
293c573e
MR		 16133 if (dynamic_section)
16134 {
16135 free (dynamic_section);
16136 dynamic_section = NULL;
16137 }
16138
e4b17d5c
L		 16139 if (section_headers_groups)
16140 {
16141 free (section_headers_groups);
16142 section_headers_groups = NULL;
16143 }
16144
16145 if (section_groups)
16146 {
2cf0635d
NC		 16147 struct group_list * g;
16148 struct group_list * next;
e4b17d5c
L		 16149
16150 for (i = 0; i < group_count; i++)
16151 {
16152 for (g = section_groups [i].root; g != NULL; g = next)
16153 {
16154 next = g->next;
16155 free (g);
16156 }
16157 }
16158
16159 free (section_groups);
16160 section_groups = NULL;
16161 }
16162
19e6b90e 16163 free_debug_memory ();
18bd398b 16164
ff78d6d6 16165 return 0;
252b5132
RH		 16166}
16167
2cf0635d
NC		 16168/* Process an ELF archive.
16169 On entry the file is positioned just after the ARMAG string. */
16170
16171static int
16172process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16173{
16174 struct archive_info arch;
16175 struct archive_info nested_arch;
16176 size_t got;
2cf0635d
NC		 16177 int ret;
16178
16179 show_name = 1;
16180
16181 /* The ARCH structure is used to hold information about this archive. */
16182 arch.file_name = NULL;
16183 arch.file = NULL;
16184 arch.index_array = NULL;
16185 arch.sym_table = NULL;
16186 arch.longnames = NULL;
16187
16188 /* The NESTED_ARCH structure is used as a single-item cache of information
16189 about a nested archive (when members of a thin archive reside within
16190 another regular archive file). */
16191 nested_arch.file_name = NULL;
16192 nested_arch.file = NULL;
16193 nested_arch.index_array = NULL;
16194 nested_arch.sym_table = NULL;
16195 nested_arch.longnames = NULL;
16196
16197 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16198 {
16199 ret = 1;
16200 goto out;
4145f1d5 16201 }
fb52b2f4 16202
4145f1d5
NC		 16203 if (do_archive_index)
16204 {
2cf0635d 16205 if (arch.sym_table == NULL)
4145f1d5
NC		 16206 error (_("%s: unable to dump the index as none was found\n"), file_name);
16207 else
16208 {
591f7597 16209 unsigned long i, l;
4145f1d5
NC		 16210 unsigned long current_pos;
16211
591f7597
NC		 16212 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16213 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16214 current_pos = ftell (file);
16215
2cf0635d 16216 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16217 {
2cf0635d
NC		 16218 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16219 {
16220 char * member_name;
4145f1d5 16221
2cf0635d
NC		 16222 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16223
16224 if (member_name != NULL)
16225 {
16226 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16227
16228 if (qualified_name != NULL)
16229 {
c2a7d3f5
NC		 16230 printf (_("Contents of binary %s at offset "), qualified_name);
16231 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16232 putchar ('\n');
2cf0635d
NC		 16233 free (qualified_name);
16234 }
4145f1d5
NC		 16235 }
16236 }
2cf0635d
NC		 16237
16238 if (l >= arch.sym_size)
4145f1d5
NC		 16239 {
16240 error (_("%s: end of the symbol table reached before the end of the index\n"),
16241 file_name);
cb8f3167 16242 break;
4145f1d5 16243 }
591f7597
NC		 16244 /* PR 17531: file: 0b6630b2. */
16245 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16246 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16247 }
16248
c2a7d3f5
NC		 16249 if (arch.uses_64bit_indicies)
16250 l = (l + 7) & ~ 7;
16251 else
16252 l += l & 1;
16253
2cf0635d 16254 if (l < arch.sym_size)
c2a7d3f5
NC		 16255 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16256 file_name, arch.sym_size - l);
4145f1d5 16257
4145f1d5
NC		 16258 if (fseek (file, current_pos, SEEK_SET) != 0)
16259 {
16260 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16261 ret = 1;
16262 goto out;
4145f1d5 16263 }
fb52b2f4 16264 }
4145f1d5
NC		 16265
16266 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16267 && !do_segments && !do_header && !do_dump && !do_version
16268 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16269 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16270 {
16271 ret = 0; /* Archive index only. */
16272 goto out;
16273 }
fb52b2f4
NC		 16274 }
16275
d989285c 16276 ret = 0;
fb52b2f4
NC		 16277
16278 while (1)
16279 {
2cf0635d
NC		 16280 char * name;
16281 size_t namelen;
16282 char * qualified_name;
16283
16284 /* Read the next archive header. */
16285 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16286 {
16287 error (_("%s: failed to seek to next archive header\n"), file_name);
16288 return 1;
16289 }
16290 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16291 if (got != sizeof arch.arhdr)
16292 {
16293 if (got == 0)
16294 break;
16295 error (_("%s: failed to read archive header\n"), file_name);
16296 ret = 1;
16297 break;
16298 }
16299 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16300 {
16301 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16302 ret = 1;
16303 break;
16304 }
16305
16306 arch.next_arhdr_offset += sizeof arch.arhdr;
16307
16308 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16309 if (archive_file_size & 01)
16310 ++archive_file_size;
16311
16312 name = get_archive_member_name (&arch, &nested_arch);
16313 if (name == NULL)
fb52b2f4 16314 {
0fd3a477 16315 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16316 ret = 1;
16317 break;
fb52b2f4 16318 }
2cf0635d 16319 namelen = strlen (name);
fb52b2f4 16320
2cf0635d
NC		 16321 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16322 if (qualified_name == NULL)
fb52b2f4 16323 {
2cf0635d 16324 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16325 ret = 1;
16326 break;
fb52b2f4
NC		 16327 }
16328
2cf0635d
NC		 16329 if (is_thin_archive && arch.nested_member_origin == 0)
16330 {
16331 /* This is a proxy for an external member of a thin archive. */
16332 FILE * member_file;
16333 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16334 if (member_file_name == NULL)
16335 {
16336 ret = 1;
16337 break;
16338 }
16339
16340 member_file = fopen (member_file_name, "rb");
16341 if (member_file == NULL)
16342 {
16343 error (_("Input file '%s' is not readable.\n"), member_file_name);
16344 free (member_file_name);
16345 ret = 1;
16346 break;
16347 }
16348
16349 archive_file_offset = arch.nested_member_origin;
16350
16351 ret |= process_object (qualified_name, member_file);
16352
16353 fclose (member_file);
16354 free (member_file_name);
16355 }
16356 else if (is_thin_archive)
16357 {
a043396b
NC		 16358 /* PR 15140: Allow for corrupt thin archives. */
16359 if (nested_arch.file == NULL)
16360 {
16361 error (_("%s: contains corrupt thin archive: %s\n"),
16362 file_name, name);
16363 ret = 1;
16364 break;
16365 }
16366
2cf0635d
NC		 16367 /* This is a proxy for a member of a nested archive. */
16368 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16369
16370 /* The nested archive file will have been opened and setup by
16371 get_archive_member_name. */
16372 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16373 {
16374 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16375 ret = 1;
16376 break;
16377 }
16378
16379 ret |= process_object (qualified_name, nested_arch.file);
16380 }
16381 else
16382 {
16383 archive_file_offset = arch.next_arhdr_offset;
16384 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16385
2cf0635d
NC		 16386 ret |= process_object (qualified_name, file);
16387 }
fb52b2f4 16388
2b52916e
L		 16389 if (dump_sects != NULL)
16390 {
16391 free (dump_sects);
16392 dump_sects = NULL;
16393 num_dump_sects = 0;
16394 }
16395
2cf0635d 16396 free (qualified_name);
fb52b2f4
NC		 16397 }
16398
4145f1d5 16399 out:
2cf0635d
NC		 16400 if (nested_arch.file != NULL)
16401 fclose (nested_arch.file);
16402 release_archive (&nested_arch);
16403 release_archive (&arch);
fb52b2f4 16404
d989285c 16405 return ret;
fb52b2f4
NC		 16406}
16407
16408static int
2cf0635d 16409process_file (char * file_name)
fb52b2f4 16410{
2cf0635d 16411 FILE * file;
fb52b2f4
NC		 16412 struct stat statbuf;
16413 char armag[SARMAG];
16414 int ret;
16415
16416 if (stat (file_name, &statbuf) < 0)
16417 {
f24ddbdd
NC		 16418 if (errno == ENOENT)
16419 error (_("'%s': No such file\n"), file_name);
16420 else
16421 error (_("Could not locate '%s'. System error message: %s\n"),
16422 file_name, strerror (errno));
16423 return 1;
16424 }
16425
16426 if (! S_ISREG (statbuf.st_mode))
16427 {
16428 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16429 return 1;
16430 }
16431
16432 file = fopen (file_name, "rb");
16433 if (file == NULL)
16434 {
f24ddbdd 16435 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16436 return 1;
16437 }
16438
16439 if (fread (armag, SARMAG, 1, file) != 1)
16440 {
4145f1d5 16441 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16442 fclose (file);
16443 return 1;
16444 }
16445
f54498b4
NC		 16446 current_file_size = (bfd_size_type) statbuf.st_size;
16447
fb52b2f4 16448 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16449 ret = process_archive (file_name, file, FALSE);
16450 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16451 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16452 else
16453 {
4145f1d5
NC		 16454 if (do_archive_index)
16455 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16456 file_name);
16457
fb52b2f4
NC		 16458 rewind (file);
16459 archive_file_size = archive_file_offset = 0;
16460 ret = process_object (file_name, file);
16461 }
16462
16463 fclose (file);
16464
f54498b4 16465 current_file_size = 0;
fb52b2f4
NC		 16466 return ret;
16467}
16468
252b5132
RH		 16469#ifdef SUPPORT_DISASSEMBLY
16470/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16471 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16472 symbols. */
252b5132
RH		 16473
16474void
2cf0635d 16475print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16476{
16477 fprintf (outfile,"0x%8.8x", addr);
16478}
16479
e3c8793a 16480/* Needed by the i386 disassembler. */
252b5132
RH		 16481void
16482db_task_printsym (unsigned int addr)
16483{
16484 print_address (addr, stderr);
16485}
16486#endif
16487
16488int
2cf0635d 16489main (int argc, char ** argv)
252b5132 16490{
ff78d6d6
L		 16491 int err;
16492
252b5132
RH		 16493#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16494 setlocale (LC_MESSAGES, "");
3882b010
L		 16495#endif
16496#if defined (HAVE_SETLOCALE)
16497 setlocale (LC_CTYPE, "");
252b5132
RH		 16498#endif
16499 bindtextdomain (PACKAGE, LOCALEDIR);
16500 textdomain (PACKAGE);
16501
869b9d07
MM		 16502 expandargv (&argc, &argv);
16503
252b5132
RH		 16504 parse_args (argc, argv);
16505
18bd398b 16506 if (num_dump_sects > 0)
59f14fc0 16507 {
18bd398b 16508 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16509 cmdline_dump_sects = (dump_type *)
16510 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16511 if (cmdline_dump_sects == NULL)
591a748a 16512 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16513 else
16514 {
09c11c86
NC		 16515 memcpy (cmdline_dump_sects, dump_sects,
16516 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16517 num_cmdline_dump_sects = num_dump_sects;
16518 }
16519 }
16520
18bd398b
NC		 16521 if (optind < (argc - 1))
16522 show_name = 1;
5656ba2c
L		 16523 else if (optind >= argc)
16524 {
16525 warn (_("Nothing to do.\n"));
16526 usage (stderr);
16527 }
18bd398b 16528
ff78d6d6 16529 err = 0;
252b5132 16530 while (optind < argc)
18bd398b 16531 err |= process_file (argv[optind++]);
252b5132
RH		 16532
16533 if (dump_sects != NULL)
16534 free (dump_sects);
59f14fc0
AS		 16535 if (cmdline_dump_sects != NULL)
16536 free (cmdline_dump_sects);
252b5132 16537
ff78d6d6 16538 return err;
252b5132 16539}
A mirror of the official binutils-gdb repository