projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gold: Add s390 -fsplit-stack support.
[deliverable/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
6f2750fe 2 Copyright (C) 1998-2016 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:
886a2506
NC		 731 case EM_ARC:
732 case EM_ARC_COMPACT:
733 case EM_ARC_COMPACT2:
e9f53129
AM		 734 case EM_AVR:
735 case EM_AVR_OLD:
736 case EM_BLACKFIN:
60bca95a 737 case EM_CR16:
e9f53129
AM		 738 case EM_CRIS:
739 case EM_CRX:
2b0337b0 740 case EM_D30V:
252b5132 741 case EM_CYGNUS_D30V:
2b0337b0 742 case EM_FR30:
3f8107ab 743 case EM_FT32:
252b5132 744 case EM_CYGNUS_FR30:
5c70f934 745 case EM_CYGNUS_FRV:
e9f53129
AM		 746 case EM_H8S:
747 case EM_H8_300:
748 case EM_H8_300H:
800eeca4 749 case EM_IA_64:
1e4cf259
NC		 750 case EM_IP2K:
751 case EM_IP2K_OLD:
3b36097d 752 case EM_IQ2000:
84e94c90 753 case EM_LATTICEMICO32:
ff7eeb89 754 case EM_M32C_OLD:
49f58d10 755 case EM_M32C:
e9f53129
AM		 756 case EM_M32R:
757 case EM_MCORE:
15ab5209 758 case EM_CYGNUS_MEP:
a3c62988 759 case EM_METAG:
e9f53129
AM		 760 case EM_MMIX:
761 case EM_MN10200:
762 case EM_CYGNUS_MN10200:
763 case EM_MN10300:
764 case EM_CYGNUS_MN10300:
5506d11a 765 case EM_MOXIE:
e9f53129
AM		 766 case EM_MSP430:
767 case EM_MSP430_OLD:
d031aafb 768 case EM_MT:
35c08157 769 case EM_NDS32:
64fd6348 770 case EM_NIOS32:
73589c9d 771 case EM_OR1K:
e9f53129
AM		 772 case EM_PPC64:
773 case EM_PPC:
99c513f6 774 case EM_RL78:
c7927a3c 775 case EM_RX:
e9f53129
AM		 776 case EM_S390:
777 case EM_S390_OLD:
778 case EM_SH:
779 case EM_SPARC:
780 case EM_SPARC32PLUS:
781 case EM_SPARCV9:
782 case EM_SPU:
40b36596 783 case EM_TI_C6000:
aa137e4d
NC		 784 case EM_TILEGX:
785 case EM_TILEPRO:
708e2187 786 case EM_V800:
e9f53129
AM		 787 case EM_V850:
788 case EM_CYGNUS_V850:
789 case EM_VAX:
619ed720 790 case EM_VISIUM:
e9f53129 791 case EM_X86_64:
8a9036a4 792 case EM_L1OM:
7a9068fe 793 case EM_K1OM:
e9f53129
AM		 794 case EM_XSTORMY16:
795 case EM_XTENSA:
796 case EM_XTENSA_OLD:
7ba29e2a
NC		 797 case EM_MICROBLAZE:
798 case EM_MICROBLAZE_OLD:
9c19a809 799 return TRUE;
103f02d3 800
e9f53129
AM		 801 case EM_68HC05:
802 case EM_68HC08:
803 case EM_68HC11:
804 case EM_68HC16:
805 case EM_FX66:
806 case EM_ME16:
d1133906 807 case EM_MMA:
d1133906
NC		 808 case EM_NCPU:
809 case EM_NDR1:
e9f53129 810 case EM_PCP:
d1133906 811 case EM_ST100:
e9f53129 812 case EM_ST19:
d1133906 813 case EM_ST7:
e9f53129
AM		 814 case EM_ST9PLUS:
815 case EM_STARCORE:
d1133906 816 case EM_SVX:
e9f53129 817 case EM_TINYJ:
9c19a809
NC		 818 default:
819 warn (_("Don't know about relocations on this machine architecture\n"));
820 return FALSE;
821 }
822}
252b5132 823
9c19a809 824static int
2cf0635d 825slurp_rela_relocs (FILE * file,
d3ba0551
AM		 826 unsigned long rel_offset,
827 unsigned long rel_size,
2cf0635d
NC		 828 Elf_Internal_Rela ** relasp,
829 unsigned long * nrelasp)
9c19a809 830{
2cf0635d 831 Elf_Internal_Rela * relas;
8b73c356 832 size_t nrelas;
4d6ed7c8 833 unsigned int i;
252b5132 834
4d6ed7c8
NC		 835 if (is_32bit_elf)
836 {
2cf0635d 837 Elf32_External_Rela * erelas;
103f02d3 838
3f5e193b 839 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 840 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 841 if (!erelas)
842 return 0;
252b5132 843
4d6ed7c8 844 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 845
3f5e193b
NC		 846 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
847 sizeof (Elf_Internal_Rela));
103f02d3 848
4d6ed7c8
NC		 849 if (relas == NULL)
850 {
c256ffe7 851 free (erelas);
591a748a 852 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 853 return 0;
854 }
103f02d3 855
4d6ed7c8
NC		 856 for (i = 0; i < nrelas; i++)
857 {
858 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
859 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 860 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 861 }
103f02d3 862
4d6ed7c8
NC		 863 free (erelas);
864 }
865 else
866 {
2cf0635d 867 Elf64_External_Rela * erelas;
103f02d3 868
3f5e193b 869 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 870 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 871 if (!erelas)
872 return 0;
4d6ed7c8
NC		 873
874 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 875
3f5e193b
NC		 876 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
877 sizeof (Elf_Internal_Rela));
103f02d3 878
4d6ed7c8
NC		 879 if (relas == NULL)
880 {
c256ffe7 881 free (erelas);
591a748a 882 error (_("out of memory parsing relocs\n"));
4d6ed7c8 883 return 0;
9c19a809 884 }
4d6ed7c8
NC		 885
886 for (i = 0; i < nrelas; i++)
9c19a809 887 {
66543521
AM		 888 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
889 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 890 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 891
892 /* The #ifdef BFD64 below is to prevent a compile time
893 warning. We know that if we do not have a 64 bit data
894 type that we will never execute this code anyway. */
895#ifdef BFD64
896 if (elf_header.e_machine == EM_MIPS
897 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
898 {
899 /* In little-endian objects, r_info isn't really a
900 64-bit little-endian value: it has a 32-bit
901 little-endian symbol index followed by four
902 individual byte fields. Reorder INFO
903 accordingly. */
91d6fa6a
NC		 904 bfd_vma inf = relas[i].r_info;
905 inf = (((inf & 0xffffffff) << 32)
906 | ((inf >> 56) & 0xff)
907 | ((inf >> 40) & 0xff00)
908 | ((inf >> 24) & 0xff0000)
909 | ((inf >> 8) & 0xff000000));
910 relas[i].r_info = inf;
861fb55a
DJ		 911 }
912#endif /* BFD64 */
4d6ed7c8 913 }
103f02d3 914
4d6ed7c8
NC		 915 free (erelas);
916 }
917 *relasp = relas;
918 *nrelasp = nrelas;
919 return 1;
920}
103f02d3 921
4d6ed7c8 922static int
2cf0635d 923slurp_rel_relocs (FILE * file,
d3ba0551
AM		 924 unsigned long rel_offset,
925 unsigned long rel_size,
2cf0635d
NC		 926 Elf_Internal_Rela ** relsp,
927 unsigned long * nrelsp)
4d6ed7c8 928{
2cf0635d 929 Elf_Internal_Rela * rels;
8b73c356 930 size_t nrels;
4d6ed7c8 931 unsigned int i;
103f02d3 932
4d6ed7c8
NC		 933 if (is_32bit_elf)
934 {
2cf0635d 935 Elf32_External_Rel * erels;
103f02d3 936
3f5e193b 937 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 938 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 939 if (!erels)
940 return 0;
103f02d3 941
4d6ed7c8 942 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 943
3f5e193b 944 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 945
4d6ed7c8
NC		 946 if (rels == NULL)
947 {
c256ffe7 948 free (erels);
591a748a 949 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 950 return 0;
951 }
952
953 for (i = 0; i < nrels; i++)
954 {
955 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
956 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 957 rels[i].r_addend = 0;
9ea033b2 958 }
4d6ed7c8
NC		 959
960 free (erels);
9c19a809
NC		 961 }
962 else
963 {
2cf0635d 964 Elf64_External_Rel * erels;
9ea033b2 965
3f5e193b 966 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 967 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 968 if (!erels)
969 return 0;
103f02d3 970
4d6ed7c8 971 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 972
3f5e193b 973 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 974
4d6ed7c8 975 if (rels == NULL)
9c19a809 976 {
c256ffe7 977 free (erels);
591a748a 978 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 979 return 0;
980 }
103f02d3 981
4d6ed7c8
NC		 982 for (i = 0; i < nrels; i++)
983 {
66543521
AM		 984 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
985 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 986 rels[i].r_addend = 0;
861fb55a
DJ		 987
988 /* The #ifdef BFD64 below is to prevent a compile time
989 warning. We know that if we do not have a 64 bit data
990 type that we will never execute this code anyway. */
991#ifdef BFD64
992 if (elf_header.e_machine == EM_MIPS
993 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
994 {
995 /* In little-endian objects, r_info isn't really a
996 64-bit little-endian value: it has a 32-bit
997 little-endian symbol index followed by four
998 individual byte fields. Reorder INFO
999 accordingly. */
91d6fa6a
NC		 1000 bfd_vma inf = rels[i].r_info;
1001 inf = (((inf & 0xffffffff) << 32)
1002 | ((inf >> 56) & 0xff)
1003 | ((inf >> 40) & 0xff00)
1004 | ((inf >> 24) & 0xff0000)
1005 | ((inf >> 8) & 0xff000000));
1006 rels[i].r_info = inf;
861fb55a
DJ		 1007 }
1008#endif /* BFD64 */
4d6ed7c8 1009 }
103f02d3 1010
4d6ed7c8
NC		 1011 free (erels);
1012 }
1013 *relsp = rels;
1014 *nrelsp = nrels;
1015 return 1;
1016}
103f02d3 1017
aca88567
NC		 1018/* Returns the reloc type extracted from the reloc info field. */
1019
1020static unsigned int
1021get_reloc_type (bfd_vma reloc_info)
1022{
1023 if (is_32bit_elf)
1024 return ELF32_R_TYPE (reloc_info);
1025
1026 switch (elf_header.e_machine)
1027 {
1028 case EM_MIPS:
1029 /* Note: We assume that reloc_info has already been adjusted for us. */
1030 return ELF64_MIPS_R_TYPE (reloc_info);
1031
1032 case EM_SPARCV9:
1033 return ELF64_R_TYPE_ID (reloc_info);
1034
1035 default:
1036 return ELF64_R_TYPE (reloc_info);
1037 }
1038}
1039
1040/* Return the symbol index extracted from the reloc info field. */
1041
1042static bfd_vma
1043get_reloc_symindex (bfd_vma reloc_info)
1044{
1045 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1046}
1047
13761a11
NC		 1048static inline bfd_boolean
1049uses_msp430x_relocs (void)
1050{
1051 return
1052 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1053 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1054 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1055 /* TI compiler uses ELFOSABI_NONE. */
1056 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1057}
1058
d3ba0551
AM		 1059/* Display the contents of the relocation data found at the specified
1060 offset. */
ee42cf8c 1061
41e92641 1062static void
2cf0635d 1063dump_relocations (FILE * file,
d3ba0551
AM		 1064 unsigned long rel_offset,
1065 unsigned long rel_size,
2cf0635d 1066 Elf_Internal_Sym * symtab,
d3ba0551 1067 unsigned long nsyms,
2cf0635d 1068 char * strtab,
d79b3d50 1069 unsigned long strtablen,
bb4d2ac2
L		 1070 int is_rela,
1071 int is_dynsym)
4d6ed7c8 1072{
b34976b6 1073 unsigned int i;
2cf0635d 1074 Elf_Internal_Rela * rels;
103f02d3 1075
4d6ed7c8
NC		 1076 if (is_rela == UNKNOWN)
1077 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1078
4d6ed7c8
NC		 1079 if (is_rela)
1080 {
c8286bd1 1081 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1082 return;
4d6ed7c8
NC		 1083 }
1084 else
1085 {
1086 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1087 return;
252b5132
RH		 1088 }
1089
410f7a12
L		 1090 if (is_32bit_elf)
1091 {
1092 if (is_rela)
2c71103e
NC		 1093 {
1094 if (do_wide)
1095 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1096 else
1097 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1098 }
410f7a12 1099 else
2c71103e
NC		 1100 {
1101 if (do_wide)
1102 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1103 else
1104 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1105 }
410f7a12 1106 }
252b5132 1107 else
410f7a12
L		 1108 {
1109 if (is_rela)
2c71103e
NC		 1110 {
1111 if (do_wide)
8beeaeb7 1112 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1113 else
1114 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1115 }
410f7a12 1116 else
2c71103e
NC		 1117 {
1118 if (do_wide)
8beeaeb7 1119 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1120 else
1121 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1122 }
410f7a12 1123 }
252b5132
RH		 1124
1125 for (i = 0; i < rel_size; i++)
1126 {
2cf0635d 1127 const char * rtype;
b34976b6 1128 bfd_vma offset;
91d6fa6a 1129 bfd_vma inf;
b34976b6
AM		 1130 bfd_vma symtab_index;
1131 bfd_vma type;
103f02d3 1132
b34976b6 1133 offset = rels[i].r_offset;
91d6fa6a 1134 inf = rels[i].r_info;
103f02d3 1135
91d6fa6a
NC		 1136 type = get_reloc_type (inf);
1137 symtab_index = get_reloc_symindex (inf);
252b5132 1138
410f7a12
L		 1139 if (is_32bit_elf)
1140 {
39dbeff8
AM		 1141 printf ("%8.8lx %8.8lx ",
1142 (unsigned long) offset & 0xffffffff,
91d6fa6a 1143 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1144 }
1145 else
1146 {
39dbeff8
AM		 1147#if BFD_HOST_64BIT_LONG
1148 printf (do_wide
1149 ? "%16.16lx %16.16lx "
1150 : "%12.12lx %12.12lx ",
91d6fa6a 1151 offset, inf);
39dbeff8 1152#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1153#ifndef __MSVCRT__
39dbeff8
AM		 1154 printf (do_wide
1155 ? "%16.16llx %16.16llx "
1156 : "%12.12llx %12.12llx ",
91d6fa6a 1157 offset, inf);
6e3d6dc1
NC		 1158#else
1159 printf (do_wide
1160 ? "%16.16I64x %16.16I64x "
1161 : "%12.12I64x %12.12I64x ",
91d6fa6a 1162 offset, inf);
6e3d6dc1 1163#endif
39dbeff8 1164#else
2c71103e
NC		 1165 printf (do_wide
1166 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1167 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1168 _bfd_int64_high (offset),
1169 _bfd_int64_low (offset),
91d6fa6a
NC		 1170 _bfd_int64_high (inf),
1171 _bfd_int64_low (inf));
9ea033b2 1172#endif
410f7a12 1173 }
103f02d3 1174
252b5132
RH		 1175 switch (elf_header.e_machine)
1176 {
1177 default:
1178 rtype = NULL;
1179 break;
1180
a06ea964
NC		 1181 case EM_AARCH64:
1182 rtype = elf_aarch64_reloc_type (type);
1183 break;
1184
2b0337b0 1185 case EM_M32R:
252b5132 1186 case EM_CYGNUS_M32R:
9ea033b2 1187 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1188 break;
1189
1190 case EM_386:
22abe556 1191 case EM_IAMCU:
9ea033b2 1192 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1193 break;
1194
ba2685cc
AM		 1195 case EM_68HC11:
1196 case EM_68HC12:
1197 rtype = elf_m68hc11_reloc_type (type);
1198 break;
75751cd9 1199
252b5132 1200 case EM_68K:
9ea033b2 1201 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1202 break;
1203
63fcb9e9 1204 case EM_960:
9ea033b2 1205 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1206 break;
1207
adde6300 1208 case EM_AVR:
2b0337b0 1209 case EM_AVR_OLD:
adde6300
AM		 1210 rtype = elf_avr_reloc_type (type);
1211 break;
1212
9ea033b2
NC		 1213 case EM_OLD_SPARCV9:
1214 case EM_SPARC32PLUS:
1215 case EM_SPARCV9:
252b5132 1216 case EM_SPARC:
9ea033b2 1217 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1218 break;
1219
e9f53129
AM		 1220 case EM_SPU:
1221 rtype = elf_spu_reloc_type (type);
1222 break;
1223
708e2187
NC		 1224 case EM_V800:
1225 rtype = v800_reloc_type (type);
1226 break;
2b0337b0 1227 case EM_V850:
252b5132 1228 case EM_CYGNUS_V850:
9ea033b2 1229 rtype = v850_reloc_type (type);
252b5132
RH		 1230 break;
1231
2b0337b0 1232 case EM_D10V:
252b5132 1233 case EM_CYGNUS_D10V:
9ea033b2 1234 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1235 break;
1236
2b0337b0 1237 case EM_D30V:
252b5132 1238 case EM_CYGNUS_D30V:
9ea033b2 1239 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1240 break;
1241
d172d4ba
NC		 1242 case EM_DLX:
1243 rtype = elf_dlx_reloc_type (type);
1244 break;
1245
252b5132 1246 case EM_SH:
9ea033b2 1247 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1248 break;
1249
2b0337b0 1250 case EM_MN10300:
252b5132 1251 case EM_CYGNUS_MN10300:
9ea033b2 1252 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1253 break;
1254
2b0337b0 1255 case EM_MN10200:
252b5132 1256 case EM_CYGNUS_MN10200:
9ea033b2 1257 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1258 break;
1259
2b0337b0 1260 case EM_FR30:
252b5132 1261 case EM_CYGNUS_FR30:
9ea033b2 1262 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1263 break;
1264
ba2685cc
AM		 1265 case EM_CYGNUS_FRV:
1266 rtype = elf_frv_reloc_type (type);
1267 break;
5c70f934 1268
3f8107ab
AM		 1269 case EM_FT32:
1270 rtype = elf_ft32_reloc_type (type);
1271 break;
1272
252b5132 1273 case EM_MCORE:
9ea033b2 1274 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1275 break;
1276
3c3bdf30
NC		 1277 case EM_MMIX:
1278 rtype = elf_mmix_reloc_type (type);
1279 break;
1280
5506d11a
AM		 1281 case EM_MOXIE:
1282 rtype = elf_moxie_reloc_type (type);
1283 break;
1284
2469cfa2 1285 case EM_MSP430:
13761a11
NC		 1286 if (uses_msp430x_relocs ())
1287 {
1288 rtype = elf_msp430x_reloc_type (type);
1289 break;
1290 }
2469cfa2
NC		 1291 case EM_MSP430_OLD:
1292 rtype = elf_msp430_reloc_type (type);
1293 break;
1294
35c08157
KLC		 1295 case EM_NDS32:
1296 rtype = elf_nds32_reloc_type (type);
1297 break;
1298
252b5132 1299 case EM_PPC:
9ea033b2 1300 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1301 break;
1302
c833c019
AM		 1303 case EM_PPC64:
1304 rtype = elf_ppc64_reloc_type (type);
1305 break;
1306
252b5132 1307 case EM_MIPS:
4fe85591 1308 case EM_MIPS_RS3_LE:
9ea033b2 1309 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1310 break;
1311
1312 case EM_ALPHA:
9ea033b2 1313 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1314 break;
1315
1316 case EM_ARM:
9ea033b2 1317 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1318 break;
1319
584da044 1320 case EM_ARC:
886a2506
NC		 1321 case EM_ARC_COMPACT:
1322 case EM_ARC_COMPACT2:
9ea033b2 1323 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1324 break;
1325
1326 case EM_PARISC:
69e617ca 1327 rtype = elf_hppa_reloc_type (type);
252b5132 1328 break;
7d466069 1329
b8720f9d
JL		 1330 case EM_H8_300:
1331 case EM_H8_300H:
1332 case EM_H8S:
1333 rtype = elf_h8_reloc_type (type);
1334 break;
1335
73589c9d
CS		 1336 case EM_OR1K:
1337 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1338 break;
1339
7d466069 1340 case EM_PJ:
2b0337b0 1341 case EM_PJ_OLD:
7d466069
ILT		 1342 rtype = elf_pj_reloc_type (type);
1343 break;
800eeca4
JW		 1344 case EM_IA_64:
1345 rtype = elf_ia64_reloc_type (type);
1346 break;
1b61cf92
HPN		 1347
1348 case EM_CRIS:
1349 rtype = elf_cris_reloc_type (type);
1350 break;
535c37ff
JE		 1351
1352 case EM_860:
1353 rtype = elf_i860_reloc_type (type);
1354 break;
bcedfee6
NC		 1355
1356 case EM_X86_64:
8a9036a4 1357 case EM_L1OM:
7a9068fe 1358 case EM_K1OM:
bcedfee6
NC		 1359 rtype = elf_x86_64_reloc_type (type);
1360 break;
a85d7ed0 1361
35b1837e
AM		 1362 case EM_S370:
1363 rtype = i370_reloc_type (type);
1364 break;
1365
53c7db4b
KH		 1366 case EM_S390_OLD:
1367 case EM_S390:
1368 rtype = elf_s390_reloc_type (type);
1369 break;
93fbbb04 1370
1c0d3aa6
NC		 1371 case EM_SCORE:
1372 rtype = elf_score_reloc_type (type);
1373 break;
1374
93fbbb04
GK		 1375 case EM_XSTORMY16:
1376 rtype = elf_xstormy16_reloc_type (type);
1377 break;
179d3252 1378
1fe1f39c
NC		 1379 case EM_CRX:
1380 rtype = elf_crx_reloc_type (type);
1381 break;
1382
179d3252
JT		 1383 case EM_VAX:
1384 rtype = elf_vax_reloc_type (type);
1385 break;
1e4cf259 1386
619ed720
EB		 1387 case EM_VISIUM:
1388 rtype = elf_visium_reloc_type (type);
1389 break;
1390
cfb8c092
NC		 1391 case EM_ADAPTEVA_EPIPHANY:
1392 rtype = elf_epiphany_reloc_type (type);
1393 break;
1394
1e4cf259
NC		 1395 case EM_IP2K:
1396 case EM_IP2K_OLD:
1397 rtype = elf_ip2k_reloc_type (type);
1398 break;
3b36097d
SC		 1399
1400 case EM_IQ2000:
1401 rtype = elf_iq2000_reloc_type (type);
1402 break;
88da6820
NC		 1403
1404 case EM_XTENSA_OLD:
1405 case EM_XTENSA:
1406 rtype = elf_xtensa_reloc_type (type);
1407 break;
a34e3ecb 1408
84e94c90
NC		 1409 case EM_LATTICEMICO32:
1410 rtype = elf_lm32_reloc_type (type);
1411 break;
1412
ff7eeb89 1413 case EM_M32C_OLD:
49f58d10
JB		 1414 case EM_M32C:
1415 rtype = elf_m32c_reloc_type (type);
1416 break;
1417
d031aafb
NS		 1418 case EM_MT:
1419 rtype = elf_mt_reloc_type (type);
a34e3ecb 1420 break;
1d65ded4
CM		 1421
1422 case EM_BLACKFIN:
1423 rtype = elf_bfin_reloc_type (type);
1424 break;
15ab5209
DB		 1425
1426 case EM_CYGNUS_MEP:
1427 rtype = elf_mep_reloc_type (type);
1428 break;
60bca95a
NC		 1429
1430 case EM_CR16:
1431 rtype = elf_cr16_reloc_type (type);
1432 break;
dd24e3da 1433
7ba29e2a
NC		 1434 case EM_MICROBLAZE:
1435 case EM_MICROBLAZE_OLD:
1436 rtype = elf_microblaze_reloc_type (type);
1437 break;
c7927a3c 1438
99c513f6
DD		 1439 case EM_RL78:
1440 rtype = elf_rl78_reloc_type (type);
1441 break;
1442
c7927a3c
NC		 1443 case EM_RX:
1444 rtype = elf_rx_reloc_type (type);
1445 break;
c29aca4a 1446
a3c62988
NC		 1447 case EM_METAG:
1448 rtype = elf_metag_reloc_type (type);
1449 break;
1450
c29aca4a
NC		 1451 case EM_XC16X:
1452 case EM_C166:
1453 rtype = elf_xc16x_reloc_type (type);
1454 break;
40b36596
JM		 1455
1456 case EM_TI_C6000:
1457 rtype = elf_tic6x_reloc_type (type);
1458 break;
aa137e4d
NC		 1459
1460 case EM_TILEGX:
1461 rtype = elf_tilegx_reloc_type (type);
1462 break;
1463
1464 case EM_TILEPRO:
1465 rtype = elf_tilepro_reloc_type (type);
1466 break;
f6c1a2d5
NC		 1467
1468 case EM_XGATE:
1469 rtype = elf_xgate_reloc_type (type);
1470 break;
36591ba1
SL		 1471
1472 case EM_ALTERA_NIOS2:
1473 rtype = elf_nios2_reloc_type (type);
1474 break;
252b5132
RH		 1475 }
1476
1477 if (rtype == NULL)
39dbeff8 1478 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1479 else
8beeaeb7 1480 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1481
7ace3541 1482 if (elf_header.e_machine == EM_ALPHA
157c2599 1483 && rtype != NULL
7ace3541
RH		 1484 && streq (rtype, "R_ALPHA_LITUSE")
1485 && is_rela)
1486 {
1487 switch (rels[i].r_addend)
1488 {
1489 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1490 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1491 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1492 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1493 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1494 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1495 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1496 default: rtype = NULL;
1497 }
1498 if (rtype)
1499 printf (" (%s)", rtype);
1500 else
1501 {
1502 putchar (' ');
1503 printf (_("<unknown addend: %lx>"),
1504 (unsigned long) rels[i].r_addend);
1505 }
1506 }
1507 else if (symtab_index)
252b5132 1508 {
af3fc3bc 1509 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1510 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1511 else
19936277 1512 {
2cf0635d 1513 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1514 const char * version_string;
1515 enum versioned_symbol_info sym_info;
1516 unsigned short vna_other;
19936277 1517
af3fc3bc 1518 psym = symtab + symtab_index;
103f02d3 1519
bb4d2ac2
L		 1520 version_string
1521 = get_symbol_version_string (file, is_dynsym,
1522 strtab, strtablen,
1523 symtab_index,
1524 psym,
1525 &sym_info,
1526 &vna_other);
1527
af3fc3bc 1528 printf (" ");
171191ba 1529
d8045f23
NC		 1530 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1531 {
1532 const char * name;
1533 unsigned int len;
1534 unsigned int width = is_32bit_elf ? 8 : 14;
1535
1536 /* Relocations against GNU_IFUNC symbols do not use the value
1537 of the symbol as the address to relocate against. Instead
1538 they invoke the function named by the symbol and use its
1539 result as the address for relocation.
1540
1541 To indicate this to the user, do not display the value of
1542 the symbol in the "Symbols's Value" field. Instead show
1543 its name followed by () as a hint that the symbol is
1544 invoked. */
1545
1546 if (strtab == NULL
1547 || psym->st_name == 0
1548 || psym->st_name >= strtablen)
1549 name = "??";
1550 else
1551 name = strtab + psym->st_name;
1552
1553 len = print_symbol (width, name);
bb4d2ac2
L		 1554 if (version_string)
1555 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1556 version_string);
d8045f23
NC		 1557 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1558 }
1559 else
1560 {
1561 print_vma (psym->st_value, LONG_HEX);
171191ba 1562
d8045f23
NC		 1563 printf (is_32bit_elf ? " " : " ");
1564 }
103f02d3 1565
af3fc3bc 1566 if (psym->st_name == 0)
f1ef08cb 1567 {
2cf0635d 1568 const char * sec_name = "<null>";
f1ef08cb
AM		 1569 char name_buf[40];
1570
1571 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1572 {
4fbb74a6 1573 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1574 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1575 else if (psym->st_shndx == SHN_ABS)
1576 sec_name = "ABS";
1577 else if (psym->st_shndx == SHN_COMMON)
1578 sec_name = "COMMON";
ac145307
BS		 1579 else if ((elf_header.e_machine == EM_MIPS
1580 && psym->st_shndx == SHN_MIPS_SCOMMON)
1581 || (elf_header.e_machine == EM_TI_C6000
1582 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1583 sec_name = "SCOMMON";
1584 else if (elf_header.e_machine == EM_MIPS
1585 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1586 sec_name = "SUNDEF";
8a9036a4 1587 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1588 || elf_header.e_machine == EM_L1OM
1589 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1590 && psym->st_shndx == SHN_X86_64_LCOMMON)
1591 sec_name = "LARGE_COMMON";
9ce701e2
L		 1592 else if (elf_header.e_machine == EM_IA_64
1593 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1594 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1595 sec_name = "ANSI_COM";
28f997cf 1596 else if (is_ia64_vms ()
148b93f2
NC		 1597 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1598 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1599 else
1600 {
1601 sprintf (name_buf, "<section 0x%x>",
1602 (unsigned int) psym->st_shndx);
1603 sec_name = name_buf;
1604 }
1605 }
1606 print_symbol (22, sec_name);
1607 }
af3fc3bc 1608 else if (strtab == NULL)
d79b3d50 1609 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1610 else if (psym->st_name >= strtablen)
d79b3d50 1611 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1612 else
bb4d2ac2
L		 1613 {
1614 print_symbol (22, strtab + psym->st_name);
1615 if (version_string)
1616 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1617 version_string);
1618 }
103f02d3 1619
af3fc3bc 1620 if (is_rela)
171191ba 1621 {
7360e63f 1622 bfd_vma off = rels[i].r_addend;
171191ba 1623
7360e63f 1624 if ((bfd_signed_vma) off < 0)
598aaa76 1625 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1626 else
598aaa76 1627 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1628 }
19936277 1629 }
252b5132 1630 }
1b228002 1631 else if (is_rela)
f7a99963 1632 {
7360e63f 1633 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1634
1635 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1636 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1637 printf ("-%" BFD_VMA_FMT "x", - off);
1638 else
1639 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1640 }
252b5132 1641
157c2599
NC		 1642 if (elf_header.e_machine == EM_SPARCV9
1643 && rtype != NULL
1644 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1645 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1646
252b5132 1647 putchar ('\n');
2c71103e 1648
aca88567 1649#ifdef BFD64
53c7db4b 1650 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1651 {
91d6fa6a
NC		 1652 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1653 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1654 const char * rtype2 = elf_mips_reloc_type (type2);
1655 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1656
2c71103e
NC		 1657 printf (" Type2: ");
1658
1659 if (rtype2 == NULL)
39dbeff8
AM		 1660 printf (_("unrecognized: %-7lx"),
1661 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1662 else
1663 printf ("%-17.17s", rtype2);
1664
18bd398b 1665 printf ("\n Type3: ");
2c71103e
NC		 1666
1667 if (rtype3 == NULL)
39dbeff8
AM		 1668 printf (_("unrecognized: %-7lx"),
1669 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1670 else
1671 printf ("%-17.17s", rtype3);
1672
53c7db4b 1673 putchar ('\n');
2c71103e 1674 }
aca88567 1675#endif /* BFD64 */
252b5132
RH		 1676 }
1677
c8286bd1 1678 free (rels);
252b5132
RH		 1679}
1680
1681static const char *
d3ba0551 1682get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1683{
1684 switch (type)
1685 {
1686 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1687 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1688 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1689 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1690 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1691 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1692 case DT_MIPS_MSYM: return "MIPS_MSYM";
1693 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1694 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1695 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1696 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1697 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1698 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1699 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1700 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1701 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1702 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1703 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1704 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1705 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1706 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1707 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1708 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1709 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1710 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1711 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1712 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1713 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1714 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1715 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1716 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1717 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1718 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1719 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1720 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1721 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1722 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1723 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1724 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1725 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1726 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1727 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1728 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1729 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1730 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1731 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1732 default:
1733 return NULL;
1734 }
1735}
1736
9a097730 1737static const char *
d3ba0551 1738get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1739{
1740 switch (type)
1741 {
1742 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1743 default:
1744 return NULL;
1745 }
103f02d3
UD		 1746}
1747
7490d522
AM		 1748static const char *
1749get_ppc_dynamic_type (unsigned long type)
1750{
1751 switch (type)
1752 {
a7f2871e 1753 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1754 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1755 default:
1756 return NULL;
1757 }
1758}
1759
f1cb7e17 1760static const char *
d3ba0551 1761get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1762{
1763 switch (type)
1764 {
a7f2871e
AM		 1765 case DT_PPC64_GLINK: return "PPC64_GLINK";
1766 case DT_PPC64_OPD: return "PPC64_OPD";
1767 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1768 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1769 default:
1770 return NULL;
1771 }
1772}
1773
103f02d3 1774static const char *
d3ba0551 1775get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1776{
1777 switch (type)
1778 {
1779 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1780 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1781 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1782 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1783 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1784 case DT_HP_PREINIT: return "HP_PREINIT";
1785 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1786 case DT_HP_NEEDED: return "HP_NEEDED";
1787 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1788 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1789 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1790 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1791 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1792 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1793 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1794 case DT_HP_FILTERED: return "HP_FILTERED";
1795 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1796 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1797 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1798 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1799 case DT_PLT: return "PLT";
1800 case DT_PLT_SIZE: return "PLT_SIZE";
1801 case DT_DLT: return "DLT";
1802 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1803 default:
1804 return NULL;
1805 }
1806}
9a097730 1807
ecc51f48 1808static const char *
d3ba0551 1809get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1810{
1811 switch (type)
1812 {
148b93f2
NC		 1813 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1814 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1815 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1816 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1817 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1818 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1819 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1820 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1821 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1822 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1823 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1824 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1825 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1826 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1827 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1828 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1829 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1830 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1831 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1832 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1833 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1834 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1835 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1836 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1837 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1838 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1839 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1840 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1841 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1842 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1843 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1844 default:
1845 return NULL;
1846 }
1847}
1848
fabcb361
RH		 1849static const char *
1850get_alpha_dynamic_type (unsigned long type)
1851{
1852 switch (type)
1853 {
1854 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1855 default:
1856 return NULL;
1857 }
1858}
1859
1c0d3aa6
NC		 1860static const char *
1861get_score_dynamic_type (unsigned long type)
1862{
1863 switch (type)
1864 {
1865 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1866 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1867 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1868 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1869 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1870 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1871 default:
1872 return NULL;
1873 }
1874}
1875
40b36596
JM		 1876static const char *
1877get_tic6x_dynamic_type (unsigned long type)
1878{
1879 switch (type)
1880 {
1881 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1882 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1883 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1884 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1885 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1886 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1887 default:
1888 return NULL;
1889 }
1890}
1c0d3aa6 1891
36591ba1
SL		 1892static const char *
1893get_nios2_dynamic_type (unsigned long type)
1894{
1895 switch (type)
1896 {
1897 case DT_NIOS2_GP: return "NIOS2_GP";
1898 default:
1899 return NULL;
1900 }
1901}
1902
252b5132 1903static const char *
d3ba0551 1904get_dynamic_type (unsigned long type)
252b5132 1905{
e9e44622 1906 static char buff[64];
252b5132
RH		 1907
1908 switch (type)
1909 {
1910 case DT_NULL: return "NULL";
1911 case DT_NEEDED: return "NEEDED";
1912 case DT_PLTRELSZ: return "PLTRELSZ";
1913 case DT_PLTGOT: return "PLTGOT";
1914 case DT_HASH: return "HASH";
1915 case DT_STRTAB: return "STRTAB";
1916 case DT_SYMTAB: return "SYMTAB";
1917 case DT_RELA: return "RELA";
1918 case DT_RELASZ: return "RELASZ";
1919 case DT_RELAENT: return "RELAENT";
1920 case DT_STRSZ: return "STRSZ";
1921 case DT_SYMENT: return "SYMENT";
1922 case DT_INIT: return "INIT";
1923 case DT_FINI: return "FINI";
1924 case DT_SONAME: return "SONAME";
1925 case DT_RPATH: return "RPATH";
1926 case DT_SYMBOLIC: return "SYMBOLIC";
1927 case DT_REL: return "REL";
1928 case DT_RELSZ: return "RELSZ";
1929 case DT_RELENT: return "RELENT";
1930 case DT_PLTREL: return "PLTREL";
1931 case DT_DEBUG: return "DEBUG";
1932 case DT_TEXTREL: return "TEXTREL";
1933 case DT_JMPREL: return "JMPREL";
1934 case DT_BIND_NOW: return "BIND_NOW";
1935 case DT_INIT_ARRAY: return "INIT_ARRAY";
1936 case DT_FINI_ARRAY: return "FINI_ARRAY";
1937 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1938 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1939 case DT_RUNPATH: return "RUNPATH";
1940 case DT_FLAGS: return "FLAGS";
2d0e6f43 1941
d1133906
NC		 1942 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1943 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1944
05107a46 1945 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1946 case DT_PLTPADSZ: return "PLTPADSZ";
1947 case DT_MOVEENT: return "MOVEENT";
1948 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1949 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1950 case DT_POSFLAG_1: return "POSFLAG_1";
1951 case DT_SYMINSZ: return "SYMINSZ";
1952 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1953
252b5132 1954 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1955 case DT_CONFIG: return "CONFIG";
1956 case DT_DEPAUDIT: return "DEPAUDIT";
1957 case DT_AUDIT: return "AUDIT";
1958 case DT_PLTPAD: return "PLTPAD";
1959 case DT_MOVETAB: return "MOVETAB";
252b5132 1960 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1961
252b5132 1962 case DT_VERSYM: return "VERSYM";
103f02d3 1963
67a4f2b7
AO		 1964 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1965 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1966 case DT_RELACOUNT: return "RELACOUNT";
1967 case DT_RELCOUNT: return "RELCOUNT";
1968 case DT_FLAGS_1: return "FLAGS_1";
1969 case DT_VERDEF: return "VERDEF";
1970 case DT_VERDEFNUM: return "VERDEFNUM";
1971 case DT_VERNEED: return "VERNEED";
1972 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1973
019148e4 1974 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1975 case DT_USED: return "USED";
1976 case DT_FILTER: return "FILTER";
103f02d3 1977
047b2264
JJ		 1978 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1979 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1980 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1981 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1982 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1983 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1984
252b5132
RH		 1985 default:
1986 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1987 {
2cf0635d 1988 const char * result;
103f02d3 1989
252b5132
RH		 1990 switch (elf_header.e_machine)
1991 {
1992 case EM_MIPS:
4fe85591 1993 case EM_MIPS_RS3_LE:
252b5132
RH		 1994 result = get_mips_dynamic_type (type);
1995 break;
9a097730
RH		 1996 case EM_SPARCV9:
1997 result = get_sparc64_dynamic_type (type);
1998 break;
7490d522
AM		 1999 case EM_PPC:
2000 result = get_ppc_dynamic_type (type);
2001 break;
f1cb7e17
AM		 2002 case EM_PPC64:
2003 result = get_ppc64_dynamic_type (type);
2004 break;
ecc51f48
NC		 2005 case EM_IA_64:
2006 result = get_ia64_dynamic_type (type);
2007 break;
fabcb361
RH		 2008 case EM_ALPHA:
2009 result = get_alpha_dynamic_type (type);
2010 break;
1c0d3aa6
NC		 2011 case EM_SCORE:
2012 result = get_score_dynamic_type (type);
2013 break;
40b36596
JM		 2014 case EM_TI_C6000:
2015 result = get_tic6x_dynamic_type (type);
2016 break;
36591ba1
SL		 2017 case EM_ALTERA_NIOS2:
2018 result = get_nios2_dynamic_type (type);
2019 break;
252b5132
RH		 2020 default:
2021 result = NULL;
2022 break;
2023 }
2024
2025 if (result != NULL)
2026 return result;
2027
e9e44622 2028 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2029 }
eec8f817
DA		 2030 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2031 || (elf_header.e_machine == EM_PARISC
2032 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2033 {
2cf0635d 2034 const char * result;
103f02d3
UD		 2035
2036 switch (elf_header.e_machine)
2037 {
2038 case EM_PARISC:
2039 result = get_parisc_dynamic_type (type);
2040 break;
148b93f2
NC		 2041 case EM_IA_64:
2042 result = get_ia64_dynamic_type (type);
2043 break;
103f02d3
UD		 2044 default:
2045 result = NULL;
2046 break;
2047 }
2048
2049 if (result != NULL)
2050 return result;
2051
e9e44622
JJ		 2052 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2053 type);
103f02d3 2054 }
252b5132 2055 else
e9e44622 2056 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2057
252b5132
RH		 2058 return buff;
2059 }
2060}
2061
2062static char *
d3ba0551 2063get_file_type (unsigned e_type)
252b5132 2064{
b34976b6 2065 static char buff[32];
252b5132
RH		 2066
2067 switch (e_type)
2068 {
2069 case ET_NONE: return _("NONE (None)");
2070 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2071 case ET_EXEC: return _("EXEC (Executable file)");
2072 case ET_DYN: return _("DYN (Shared object file)");
2073 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2074
2075 default:
2076 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2077 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2078 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2079 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2080 else
e9e44622 2081 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2082 return buff;
2083 }
2084}
2085
2086static char *
d3ba0551 2087get_machine_name (unsigned e_machine)
252b5132 2088{
b34976b6 2089 static char buff[64]; /* XXX */
252b5132
RH		 2090
2091 switch (e_machine)
2092 {
c45021f2 2093 case EM_NONE: return _("None");
a06ea964 2094 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2095 case EM_M32: return "WE32100";
2096 case EM_SPARC: return "Sparc";
e9f53129 2097 case EM_SPU: return "SPU";
c45021f2
NC		 2098 case EM_386: return "Intel 80386";
2099 case EM_68K: return "MC68000";
2100 case EM_88K: return "MC88000";
22abe556 2101 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2102 case EM_860: return "Intel 80860";
2103 case EM_MIPS: return "MIPS R3000";
2104 case EM_S370: return "IBM System/370";
7036c0e1 2105 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2106 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2107 case EM_PARISC: return "HPPA";
252b5132 2108 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2109 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2110 case EM_960: return "Intel 90860";
2111 case EM_PPC: return "PowerPC";
285d1771 2112 case EM_PPC64: return "PowerPC64";
c45021f2 2113 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2114 case EM_FT32: return "FTDI FT32";
c45021f2 2115 case EM_RH32: return "TRW RH32";
b34976b6 2116 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2117 case EM_ARM: return "ARM";
2118 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2119 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2120 case EM_SPARCV9: return "Sparc v9";
2121 case EM_TRICORE: return "Siemens Tricore";
584da044 2122 case EM_ARC: return "ARC";
886a2506
NC		 2123 case EM_ARC_COMPACT: return "ARCompact";
2124 case EM_ARC_COMPACT2: return "ARCv2";
c2dcd04e
NC		 2125 case EM_H8_300: return "Renesas H8/300";
2126 case EM_H8_300H: return "Renesas H8/300H";
2127 case EM_H8S: return "Renesas H8S";
2128 case EM_H8_500: return "Renesas H8/500";
30800947 2129 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2130 case EM_MIPS_X: return "Stanford MIPS-X";
2131 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2132 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2133 case EM_CYGNUS_D10V:
2134 case EM_D10V: return "d10v";
2135 case EM_CYGNUS_D30V:
b34976b6 2136 case EM_D30V: return "d30v";
2b0337b0 2137 case EM_CYGNUS_M32R:
26597c86 2138 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2139 case EM_CYGNUS_V850:
708e2187 2140 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2141 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2142 case EM_CYGNUS_MN10300:
2143 case EM_MN10300: return "mn10300";
2144 case EM_CYGNUS_MN10200:
2145 case EM_MN10200: return "mn10200";
5506d11a 2146 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2147 case EM_CYGNUS_FR30:
2148 case EM_FR30: return "Fujitsu FR30";
b34976b6 2149 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2150 case EM_PJ_OLD:
b34976b6 2151 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2152 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2153 case EM_PCP: return "Siemens PCP";
2154 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2155 case EM_NDR1: return "Denso NDR1 microprocesspr";
2156 case EM_STARCORE: return "Motorola Star*Core processor";
2157 case EM_ME16: return "Toyota ME16 processor";
2158 case EM_ST100: return "STMicroelectronics ST100 processor";
2159 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2160 case EM_PDSP: return "Sony DSP processor";
2161 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2162 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2163 case EM_FX66: return "Siemens FX66 microcontroller";
2164 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2165 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2166 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2167 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2168 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2169 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2170 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2171 case EM_SVX: return "Silicon Graphics SVx";
2172 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2173 case EM_VAX: return "Digital VAX";
619ed720 2174 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2175 case EM_AVR_OLD:
b34976b6 2176 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2177 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2178 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2179 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2180 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2181 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2182 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2183 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2184 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2185 case EM_L1OM: return "Intel L1OM";
7a9068fe 2186 case EM_K1OM: return "Intel K1OM";
b7498e0e 2187 case EM_S390_OLD:
b34976b6 2188 case EM_S390: return "IBM S/390";
1c0d3aa6 2189 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2190 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2191 case EM_OR1K: return "OpenRISC 1000";
1fe1f39c 2192 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2193 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2194 case EM_DLX: return "OpenDLX";
1e4cf259 2195 case EM_IP2K_OLD:
b34976b6 2196 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2197 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2198 case EM_XTENSA_OLD:
2199 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2200 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2201 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2202 case EM_NS32K: return "National Semiconductor 32000 series";
2203 case EM_TPC: return "Tenor Network TPC processor";
2204 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2205 case EM_MAX: return "MAX Processor";
2206 case EM_CR: return "National Semiconductor CompactRISC";
2207 case EM_F2MC16: return "Fujitsu F2MC16";
2208 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2209 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2210 case EM_M32C_OLD:
49f58d10 2211 case EM_M32C: return "Renesas M32c";
d031aafb 2212 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2213 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2214 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2215 case EM_SEP: return "Sharp embedded microprocessor";
2216 case EM_ARCA: return "Arca RISC microprocessor";
2217 case EM_UNICORE: return "Unicore";
2218 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2219 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2220 case EM_NIOS32: return "Altera Nios";
2221 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2222 case EM_C166:
d70c5fc7 2223 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2224 case EM_M16C: return "Renesas M16C series microprocessors";
2225 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2226 case EM_CE: return "Freescale Communication Engine RISC core";
2227 case EM_TSK3000: return "Altium TSK3000 core";
2228 case EM_RS08: return "Freescale RS08 embedded processor";
2229 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2230 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2231 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2232 case EM_SE_C17: return "Seiko Epson C17 family";
2233 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2234 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2235 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2236 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2237 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2238 case EM_R32C: return "Renesas R32C series microprocessors";
2239 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2240 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2241 case EM_8051: return "Intel 8051 and variants";
2242 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2243 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2244 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2245 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2246 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2247 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2248 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2249 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2250 case EM_CR16:
f6c1a2d5 2251 case EM_MICROBLAZE:
7ba29e2a 2252 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2253 case EM_RL78: return "Renesas RL78";
c7927a3c 2254 case EM_RX: return "Renesas RX";
a3c62988 2255 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2256 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2257 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2258 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2259 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2260 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2261 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2262 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2263 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2264 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2265 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2266 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2267 default:
35d9dd2f 2268 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2269 return buff;
2270 }
2271}
2272
f3485b74 2273static void
d3ba0551 2274decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2275{
2276 unsigned eabi;
2277 int unknown = 0;
2278
2279 eabi = EF_ARM_EABI_VERSION (e_flags);
2280 e_flags &= ~ EF_ARM_EABIMASK;
2281
2282 /* Handle "generic" ARM flags. */
2283 if (e_flags & EF_ARM_RELEXEC)
2284 {
2285 strcat (buf, ", relocatable executable");
2286 e_flags &= ~ EF_ARM_RELEXEC;
2287 }
76da6bbe 2288
f3485b74
NC		 2289 /* Now handle EABI specific flags. */
2290 switch (eabi)
2291 {
2292 default:
2c71103e 2293 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2294 if (e_flags)
2295 unknown = 1;
2296 break;
2297
2298 case EF_ARM_EABI_VER1:
a5bcd848 2299 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2300 while (e_flags)
2301 {
2302 unsigned flag;
76da6bbe 2303
f3485b74
NC		 2304 /* Process flags one bit at a time. */
2305 flag = e_flags & - e_flags;
2306 e_flags &= ~ flag;
76da6bbe 2307
f3485b74
NC		 2308 switch (flag)
2309 {
a5bcd848 2310 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2311 strcat (buf, ", sorted symbol tables");
2312 break;
76da6bbe 2313
f3485b74
NC		 2314 default:
2315 unknown = 1;
2316 break;
2317 }
2318 }
2319 break;
76da6bbe 2320
a5bcd848
PB		 2321 case EF_ARM_EABI_VER2:
2322 strcat (buf, ", Version2 EABI");
2323 while (e_flags)
2324 {
2325 unsigned flag;
2326
2327 /* Process flags one bit at a time. */
2328 flag = e_flags & - e_flags;
2329 e_flags &= ~ flag;
2330
2331 switch (flag)
2332 {
2333 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2334 strcat (buf, ", sorted symbol tables");
2335 break;
2336
2337 case EF_ARM_DYNSYMSUSESEGIDX:
2338 strcat (buf, ", dynamic symbols use segment index");
2339 break;
2340
2341 case EF_ARM_MAPSYMSFIRST:
2342 strcat (buf, ", mapping symbols precede others");
2343 break;
2344
2345 default:
2346 unknown = 1;
2347 break;
2348 }
2349 }
2350 break;
2351
d507cf36
PB		 2352 case EF_ARM_EABI_VER3:
2353 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2354 break;
2355
2356 case EF_ARM_EABI_VER4:
2357 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2358 while (e_flags)
2359 {
2360 unsigned flag;
2361
2362 /* Process flags one bit at a time. */
2363 flag = e_flags & - e_flags;
2364 e_flags &= ~ flag;
2365
2366 switch (flag)
2367 {
2368 case EF_ARM_BE8:
2369 strcat (buf, ", BE8");
2370 break;
2371
2372 case EF_ARM_LE8:
2373 strcat (buf, ", LE8");
2374 break;
2375
2376 default:
2377 unknown = 1;
2378 break;
2379 }
2380 break;
2381 }
2382 break;
3a4a14e9
PB		 2383
2384 case EF_ARM_EABI_VER5:
2385 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2386 while (e_flags)
2387 {
2388 unsigned flag;
2389
2390 /* Process flags one bit at a time. */
2391 flag = e_flags & - e_flags;
2392 e_flags &= ~ flag;
2393
2394 switch (flag)
2395 {
2396 case EF_ARM_BE8:
2397 strcat (buf, ", BE8");
2398 break;
2399
2400 case EF_ARM_LE8:
2401 strcat (buf, ", LE8");
2402 break;
2403
3bfcb652
NC		 2404 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2405 strcat (buf, ", soft-float ABI");
2406 break;
2407
2408 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2409 strcat (buf, ", hard-float ABI");
2410 break;
2411
d507cf36
PB		 2412 default:
2413 unknown = 1;
2414 break;
2415 }
2416 }
2417 break;
2418
f3485b74 2419 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2420 strcat (buf, ", GNU EABI");
f3485b74
NC		 2421 while (e_flags)
2422 {
2423 unsigned flag;
76da6bbe 2424
f3485b74
NC		 2425 /* Process flags one bit at a time. */
2426 flag = e_flags & - e_flags;
2427 e_flags &= ~ flag;
76da6bbe 2428
f3485b74
NC		 2429 switch (flag)
2430 {
a5bcd848 2431 case EF_ARM_INTERWORK:
f3485b74
NC		 2432 strcat (buf, ", interworking enabled");
2433 break;
76da6bbe 2434
a5bcd848 2435 case EF_ARM_APCS_26:
f3485b74
NC		 2436 strcat (buf, ", uses APCS/26");
2437 break;
76da6bbe 2438
a5bcd848 2439 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2440 strcat (buf, ", uses APCS/float");
2441 break;
76da6bbe 2442
a5bcd848 2443 case EF_ARM_PIC:
f3485b74
NC		 2444 strcat (buf, ", position independent");
2445 break;
76da6bbe 2446
a5bcd848 2447 case EF_ARM_ALIGN8:
f3485b74
NC		 2448 strcat (buf, ", 8 bit structure alignment");
2449 break;
76da6bbe 2450
a5bcd848 2451 case EF_ARM_NEW_ABI:
f3485b74
NC		 2452 strcat (buf, ", uses new ABI");
2453 break;
76da6bbe 2454
a5bcd848 2455 case EF_ARM_OLD_ABI:
f3485b74
NC		 2456 strcat (buf, ", uses old ABI");
2457 break;
76da6bbe 2458
a5bcd848 2459 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2460 strcat (buf, ", software FP");
2461 break;
76da6bbe 2462
90e01f86
ILT		 2463 case EF_ARM_VFP_FLOAT:
2464 strcat (buf, ", VFP");
2465 break;
2466
fde78edd
NC		 2467 case EF_ARM_MAVERICK_FLOAT:
2468 strcat (buf, ", Maverick FP");
2469 break;
2470
f3485b74
NC		 2471 default:
2472 unknown = 1;
2473 break;
2474 }
2475 }
2476 }
f3485b74
NC		 2477
2478 if (unknown)
2b692964 2479 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2480}
2481
343433df
AB		 2482static void
2483decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2484{
2485 --size; /* Leave space for null terminator. */
2486
2487 switch (e_flags & EF_AVR_MACH)
2488 {
2489 case E_AVR_MACH_AVR1:
2490 strncat (buf, ", avr:1", size);
2491 break;
2492 case E_AVR_MACH_AVR2:
2493 strncat (buf, ", avr:2", size);
2494 break;
2495 case E_AVR_MACH_AVR25:
2496 strncat (buf, ", avr:25", size);
2497 break;
2498 case E_AVR_MACH_AVR3:
2499 strncat (buf, ", avr:3", size);
2500 break;
2501 case E_AVR_MACH_AVR31:
2502 strncat (buf, ", avr:31", size);
2503 break;
2504 case E_AVR_MACH_AVR35:
2505 strncat (buf, ", avr:35", size);
2506 break;
2507 case E_AVR_MACH_AVR4:
2508 strncat (buf, ", avr:4", size);
2509 break;
2510 case E_AVR_MACH_AVR5:
2511 strncat (buf, ", avr:5", size);
2512 break;
2513 case E_AVR_MACH_AVR51:
2514 strncat (buf, ", avr:51", size);
2515 break;
2516 case E_AVR_MACH_AVR6:
2517 strncat (buf, ", avr:6", size);
2518 break;
2519 case E_AVR_MACH_AVRTINY:
2520 strncat (buf, ", avr:100", size);
2521 break;
2522 case E_AVR_MACH_XMEGA1:
2523 strncat (buf, ", avr:101", size);
2524 break;
2525 case E_AVR_MACH_XMEGA2:
2526 strncat (buf, ", avr:102", size);
2527 break;
2528 case E_AVR_MACH_XMEGA3:
2529 strncat (buf, ", avr:103", size);
2530 break;
2531 case E_AVR_MACH_XMEGA4:
2532 strncat (buf, ", avr:104", size);
2533 break;
2534 case E_AVR_MACH_XMEGA5:
2535 strncat (buf, ", avr:105", size);
2536 break;
2537 case E_AVR_MACH_XMEGA6:
2538 strncat (buf, ", avr:106", size);
2539 break;
2540 case E_AVR_MACH_XMEGA7:
2541 strncat (buf, ", avr:107", size);
2542 break;
2543 default:
2544 strncat (buf, ", avr:<unknown>", size);
2545 break;
2546 }
2547
2548 size -= strlen (buf);
2549 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2550 strncat (buf, ", link-relax", size);
2551}
2552
35c08157
KLC		 2553static void
2554decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2555{
2556 unsigned abi;
2557 unsigned arch;
2558 unsigned config;
2559 unsigned version;
2560 int has_fpu = 0;
2561 int r = 0;
2562
2563 static const char *ABI_STRINGS[] =
2564 {
2565 "ABI v0", /* use r5 as return register; only used in N1213HC */
2566 "ABI v1", /* use r0 as return register */
2567 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2569 "AABI",
2570 "ABI2 FP+"
35c08157
KLC		 2571 };
2572 static const char *VER_STRINGS[] =
2573 {
2574 "Andes ELF V1.3 or older",
2575 "Andes ELF V1.3.1",
2576 "Andes ELF V1.4"
2577 };
2578 static const char *ARCH_STRINGS[] =
2579 {
2580 "",
2581 "Andes Star v1.0",
2582 "Andes Star v2.0",
2583 "Andes Star v3.0",
2584 "Andes Star v3.0m"
2585 };
2586
2587 abi = EF_NDS_ABI & e_flags;
2588 arch = EF_NDS_ARCH & e_flags;
2589 config = EF_NDS_INST & e_flags;
2590 version = EF_NDS32_ELF_VERSION & e_flags;
2591
2592 memset (buf, 0, size);
2593
2594 switch (abi)
2595 {
2596 case E_NDS_ABI_V0:
2597 case E_NDS_ABI_V1:
2598 case E_NDS_ABI_V2:
2599 case E_NDS_ABI_V2FP:
2600 case E_NDS_ABI_AABI:
40c7a7cb 2601 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2602 /* In case there are holes in the array. */
2603 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2604 break;
2605
2606 default:
2607 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2608 break;
2609 }
2610
2611 switch (version)
2612 {
2613 case E_NDS32_ELF_VER_1_2:
2614 case E_NDS32_ELF_VER_1_3:
2615 case E_NDS32_ELF_VER_1_4:
2616 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2617 break;
2618
2619 default:
2620 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2621 break;
2622 }
2623
2624 if (E_NDS_ABI_V0 == abi)
2625 {
2626 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2627 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628 if (arch == E_NDS_ARCH_STAR_V1_0)
2629 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2630 return;
2631 }
2632
2633 switch (arch)
2634 {
2635 case E_NDS_ARCH_STAR_V1_0:
2636 case E_NDS_ARCH_STAR_V2_0:
2637 case E_NDS_ARCH_STAR_V3_0:
2638 case E_NDS_ARCH_STAR_V3_M:
2639 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2640 break;
2641
2642 default:
2643 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2644 /* ARCH version determines how the e_flags are interpreted.
2645 If it is unknown, we cannot proceed. */
2646 return;
2647 }
2648
2649 /* Newer ABI; Now handle architecture specific flags. */
2650 if (arch == E_NDS_ARCH_STAR_V1_0)
2651 {
2652 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2653 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2654
2655 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2656 r += snprintf (buf + r, size -r, ", MAC");
2657
2658 if (config & E_NDS32_HAS_DIV_INST)
2659 r += snprintf (buf + r, size -r, ", DIV");
2660
2661 if (config & E_NDS32_HAS_16BIT_INST)
2662 r += snprintf (buf + r, size -r, ", 16b");
2663 }
2664 else
2665 {
2666 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2667 {
2668 if (version <= E_NDS32_ELF_VER_1_3)
2669 r += snprintf (buf + r, size -r, ", [B8]");
2670 else
2671 r += snprintf (buf + r, size -r, ", EX9");
2672 }
2673
2674 if (config & E_NDS32_HAS_MAC_DX_INST)
2675 r += snprintf (buf + r, size -r, ", MAC_DX");
2676
2677 if (config & E_NDS32_HAS_DIV_DX_INST)
2678 r += snprintf (buf + r, size -r, ", DIV_DX");
2679
2680 if (config & E_NDS32_HAS_16BIT_INST)
2681 {
2682 if (version <= E_NDS32_ELF_VER_1_3)
2683 r += snprintf (buf + r, size -r, ", 16b");
2684 else
2685 r += snprintf (buf + r, size -r, ", IFC");
2686 }
2687 }
2688
2689 if (config & E_NDS32_HAS_EXT_INST)
2690 r += snprintf (buf + r, size -r, ", PERF1");
2691
2692 if (config & E_NDS32_HAS_EXT2_INST)
2693 r += snprintf (buf + r, size -r, ", PERF2");
2694
2695 if (config & E_NDS32_HAS_FPU_INST)
2696 {
2697 has_fpu = 1;
2698 r += snprintf (buf + r, size -r, ", FPU_SP");
2699 }
2700
2701 if (config & E_NDS32_HAS_FPU_DP_INST)
2702 {
2703 has_fpu = 1;
2704 r += snprintf (buf + r, size -r, ", FPU_DP");
2705 }
2706
2707 if (config & E_NDS32_HAS_FPU_MAC_INST)
2708 {
2709 has_fpu = 1;
2710 r += snprintf (buf + r, size -r, ", FPU_MAC");
2711 }
2712
2713 if (has_fpu)
2714 {
2715 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2716 {
2717 case E_NDS32_FPU_REG_8SP_4DP:
2718 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2719 break;
2720 case E_NDS32_FPU_REG_16SP_8DP:
2721 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2722 break;
2723 case E_NDS32_FPU_REG_32SP_16DP:
2724 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2725 break;
2726 case E_NDS32_FPU_REG_32SP_32DP:
2727 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2728 break;
2729 }
2730 }
2731
2732 if (config & E_NDS32_HAS_AUDIO_INST)
2733 r += snprintf (buf + r, size -r, ", AUDIO");
2734
2735 if (config & E_NDS32_HAS_STRING_INST)
2736 r += snprintf (buf + r, size -r, ", STR");
2737
2738 if (config & E_NDS32_HAS_REDUCED_REGS)
2739 r += snprintf (buf + r, size -r, ", 16REG");
2740
2741 if (config & E_NDS32_HAS_VIDEO_INST)
2742 {
2743 if (version <= E_NDS32_ELF_VER_1_3)
2744 r += snprintf (buf + r, size -r, ", VIDEO");
2745 else
2746 r += snprintf (buf + r, size -r, ", SATURATION");
2747 }
2748
2749 if (config & E_NDS32_HAS_ENCRIPT_INST)
2750 r += snprintf (buf + r, size -r, ", ENCRP");
2751
2752 if (config & E_NDS32_HAS_L2C_INST)
2753 r += snprintf (buf + r, size -r, ", L2C");
2754}
2755
252b5132 2756static char *
d3ba0551 2757get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2758{
b34976b6 2759 static char buf[1024];
252b5132
RH		 2760
2761 buf[0] = '\0';
76da6bbe 2762
252b5132
RH		 2763 if (e_flags)
2764 {
2765 switch (e_machine)
2766 {
2767 default:
2768 break;
2769
886a2506
NC		 2770 case EM_ARC_COMPACT2:
2771 switch (e_flags & EF_ARC_MACH_MSK)
2772 {
2773 case EF_ARC_CPU_ARCV2EM:
2774 strcat (buf, ", ARC EM");
2775 break;
2776 case EF_ARC_CPU_ARCV2HS:
2777 strcat (buf, ", ARC HS");
2778 break;
34e967a5
MC		 2779 case EF_ARC_CPU_GENERIC:
2780 strcat (buf, ", ARC generic");
2781 break;
2782 case E_ARC_MACH_ARC600:
2783 strcat (buf, ", ARC600");
2784 break;
2785 case E_ARC_MACH_ARC601:
2786 strcat (buf, ", ARC601");
2787 break;
2788 case E_ARC_MACH_ARC700:
2789 strcat (buf, ", ARC700");
2790 break;
886a2506 2791 default:
34e967a5 2792 strcat (buf, ", unrecognized cpu flag for ARCv2");
886a2506
NC		 2793 break;
2794 }
2795 switch (e_flags & EF_ARC_OSABI_MSK)
2796 {
34e967a5
MC		 2797 case E_ARC_OSABI_ORIG:
2798 strcat (buf, ", (ABI:legacy)");
2799 break;
2800 case E_ARC_OSABI_V2:
2801 strcat (buf, ", (ABI:v2)");
2802 break;
2803 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
886a2506
NC		 2804 case E_ARC_OSABI_V3:
2805 strcat (buf, ", v3 no-legacy-syscalls ABI");
2806 break;
34e967a5
MC		 2807 default:
2808 strcat (buf, ", unrecognised ARC OSABI flag");
2809 break;
886a2506
NC		 2810 }
2811 break;
2812
2813 case EM_ARC_COMPACT:
2814 switch (e_flags & EF_ARC_MACH_MSK)
2815 {
2816 case E_ARC_MACH_ARC600:
2817 strcat (buf, ", ARC 600");
2818 break;
2819 case E_ARC_MACH_ARC601:
2820 strcat (buf, ", ARC 601");
2821 break;
2822 case E_ARC_MACH_ARC700:
2823 strcat (buf, ", ARC 700");
2824 break;
2825 default:
2826 strcat (buf, ", Generic ARCompact");
2827 break;
2828 }
2829 switch (e_flags & EF_ARC_OSABI_MSK)
2830 {
2831 case E_ARC_OSABI_ORIG:
2832 strcat (buf, ", legacy syscall ABI");
2833 break;
2834 case E_ARC_OSABI_V2:
2835 /* For 3.2+ Linux kernels which use asm-generic
2836 hdrs. */
2837 strcat (buf, ", v2 syscall ABI");
2838 break;
2839 case E_ARC_OSABI_V3:
2840 /* Upstream 3.9+ kernels which don't use any legacy
2841 syscalls. */
2842 strcat (buf, ", v3 no-legacy-syscalls ABI");
2843 break;
2844 }
2845 break;
2846
f3485b74
NC		 2847 case EM_ARM:
2848 decode_ARM_machine_flags (e_flags, buf);
2849 break;
76da6bbe 2850
343433df
AB		 2851 case EM_AVR:
2852 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2853 break;
2854
781303ce
MF		 2855 case EM_BLACKFIN:
2856 if (e_flags & EF_BFIN_PIC)
2857 strcat (buf, ", PIC");
2858
2859 if (e_flags & EF_BFIN_FDPIC)
2860 strcat (buf, ", FDPIC");
2861
2862 if (e_flags & EF_BFIN_CODE_IN_L1)
2863 strcat (buf, ", code in L1");
2864
2865 if (e_flags & EF_BFIN_DATA_IN_L1)
2866 strcat (buf, ", data in L1");
2867
2868 break;
2869
ec2dfb42
AO		 2870 case EM_CYGNUS_FRV:
2871 switch (e_flags & EF_FRV_CPU_MASK)
2872 {
2873 case EF_FRV_CPU_GENERIC:
2874 break;
2875
2876 default:
2877 strcat (buf, ", fr???");
2878 break;
57346661 2879
ec2dfb42
AO		 2880 case EF_FRV_CPU_FR300:
2881 strcat (buf, ", fr300");
2882 break;
2883
2884 case EF_FRV_CPU_FR400:
2885 strcat (buf, ", fr400");
2886 break;
2887 case EF_FRV_CPU_FR405:
2888 strcat (buf, ", fr405");
2889 break;
2890
2891 case EF_FRV_CPU_FR450:
2892 strcat (buf, ", fr450");
2893 break;
2894
2895 case EF_FRV_CPU_FR500:
2896 strcat (buf, ", fr500");
2897 break;
2898 case EF_FRV_CPU_FR550:
2899 strcat (buf, ", fr550");
2900 break;
2901
2902 case EF_FRV_CPU_SIMPLE:
2903 strcat (buf, ", simple");
2904 break;
2905 case EF_FRV_CPU_TOMCAT:
2906 strcat (buf, ", tomcat");
2907 break;
2908 }
1c877e87 2909 break;
ec2dfb42 2910
53c7db4b 2911 case EM_68K:
425c6cb0 2912 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2913 strcat (buf, ", m68000");
425c6cb0 2914 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2915 strcat (buf, ", cpu32");
2916 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2917 strcat (buf, ", fido_a");
425c6cb0 2918 else
266abb8f 2919 {
2cf0635d
NC		 2920 char const * isa = _("unknown");
2921 char const * mac = _("unknown mac");
2922 char const * additional = NULL;
0112cd26 2923
c694fd50 2924 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2925 {
c694fd50 2926 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2927 isa = "A";
2928 additional = ", nodiv";
2929 break;
c694fd50 2930 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2931 isa = "A";
2932 break;
c694fd50 2933 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2934 isa = "A+";
2935 break;
c694fd50 2936 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2937 isa = "B";
2938 additional = ", nousp";
2939 break;
c694fd50 2940 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2941 isa = "B";
2942 break;
f608cd77
NS		 2943 case EF_M68K_CF_ISA_C:
2944 isa = "C";
2945 break;
2946 case EF_M68K_CF_ISA_C_NODIV:
2947 isa = "C";
2948 additional = ", nodiv";
2949 break;
266abb8f
NS		 2950 }
2951 strcat (buf, ", cf, isa ");
2952 strcat (buf, isa);
0b2e31dc
NS		 2953 if (additional)
2954 strcat (buf, additional);
c694fd50 2955 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2956 strcat (buf, ", float");
c694fd50 2957 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2958 {
2959 case 0:
2960 mac = NULL;
2961 break;
c694fd50 2962 case EF_M68K_CF_MAC:
266abb8f
NS		 2963 mac = "mac";
2964 break;
c694fd50 2965 case EF_M68K_CF_EMAC:
266abb8f
NS		 2966 mac = "emac";
2967 break;
f608cd77
NS		 2968 case EF_M68K_CF_EMAC_B:
2969 mac = "emac_b";
2970 break;
266abb8f
NS		 2971 }
2972 if (mac)
2973 {
2974 strcat (buf, ", ");
2975 strcat (buf, mac);
2976 }
266abb8f 2977 }
53c7db4b 2978 break;
33c63f9d 2979
153a2776
NC		 2980 case EM_CYGNUS_MEP:
2981 switch (e_flags & EF_MEP_CPU_MASK)
2982 {
2983 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2984 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2985 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2986 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2987 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2988 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2989 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2990 }
2991
2992 switch (e_flags & EF_MEP_COP_MASK)
2993 {
2994 case EF_MEP_COP_NONE: break;
2995 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2996 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2997 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2998 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2999 default: strcat (buf, _("<unknown MeP copro type>")); break;
3000 }
3001
3002 if (e_flags & EF_MEP_LIBRARY)
3003 strcat (buf, ", Built for Library");
3004
3005 if (e_flags & EF_MEP_INDEX_MASK)
3006 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3007 e_flags & EF_MEP_INDEX_MASK);
3008
3009 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3010 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3011 e_flags & ~ EF_MEP_ALL_FLAGS);
3012 break;
3013
252b5132
RH		 3014 case EM_PPC:
3015 if (e_flags & EF_PPC_EMB)
3016 strcat (buf, ", emb");
3017
3018 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 3019 strcat (buf, _(", relocatable"));
252b5132
RH		 3020
3021 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 3022 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 3023 break;
3024
ee67d69a
AM		 3025 case EM_PPC64:
3026 if (e_flags & EF_PPC64_ABI)
3027 {
3028 char abi[] = ", abiv0";
3029
3030 abi[6] += e_flags & EF_PPC64_ABI;
3031 strcat (buf, abi);
3032 }
3033 break;
3034
708e2187
NC		 3035 case EM_V800:
3036 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3037 strcat (buf, ", RH850 ABI");
0b4362b0 3038
708e2187
NC		 3039 if (e_flags & EF_V800_850E3)
3040 strcat (buf, ", V3 architecture");
3041
3042 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3043 strcat (buf, ", FPU not used");
3044
3045 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3046 strcat (buf, ", regmode: COMMON");
3047
3048 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3049 strcat (buf, ", r4 not used");
3050
3051 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3052 strcat (buf, ", r30 not used");
3053
3054 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3055 strcat (buf, ", r5 not used");
3056
3057 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3058 strcat (buf, ", r2 not used");
3059
3060 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3061 {
3062 switch (e_flags & - e_flags)
3063 {
3064 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3065 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 3066 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3067 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 3068 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3069 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3070 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3071 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3072 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3073 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3074 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3075 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3076 default: break;
3077 }
3078 }
3079 break;
3080
2b0337b0 3081 case EM_V850:
252b5132
RH		 3082 case EM_CYGNUS_V850:
3083 switch (e_flags & EF_V850_ARCH)
3084 {
78c8d46c
NC		 3085 case E_V850E3V5_ARCH:
3086 strcat (buf, ", v850e3v5");
3087 break;
1cd986c5
NC		 3088 case E_V850E2V3_ARCH:
3089 strcat (buf, ", v850e2v3");
3090 break;
3091 case E_V850E2_ARCH:
3092 strcat (buf, ", v850e2");
3093 break;
3094 case E_V850E1_ARCH:
3095 strcat (buf, ", v850e1");
8ad30312 3096 break;
252b5132
RH		 3097 case E_V850E_ARCH:
3098 strcat (buf, ", v850e");
3099 break;
252b5132
RH		 3100 case E_V850_ARCH:
3101 strcat (buf, ", v850");
3102 break;
3103 default:
2b692964 3104 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3105 break;
3106 }
3107 break;
3108
2b0337b0 3109 case EM_M32R:
252b5132
RH		 3110 case EM_CYGNUS_M32R:
3111 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3112 strcat (buf, ", m32r");
252b5132
RH		 3113 break;
3114
3115 case EM_MIPS:
4fe85591 3116 case EM_MIPS_RS3_LE:
252b5132
RH		 3117 if (e_flags & EF_MIPS_NOREORDER)
3118 strcat (buf, ", noreorder");
3119
3120 if (e_flags & EF_MIPS_PIC)
3121 strcat (buf, ", pic");
3122
3123 if (e_flags & EF_MIPS_CPIC)
3124 strcat (buf, ", cpic");
3125
d1bdd336
TS		 3126 if (e_flags & EF_MIPS_UCODE)
3127 strcat (buf, ", ugen_reserved");
3128
252b5132
RH		 3129 if (e_flags & EF_MIPS_ABI2)
3130 strcat (buf, ", abi2");
3131
43521d43
TS		 3132 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3133 strcat (buf, ", odk first");
3134
a5d22d2a
TS		 3135 if (e_flags & EF_MIPS_32BITMODE)
3136 strcat (buf, ", 32bitmode");
3137
ba92f887
MR		 3138 if (e_flags & EF_MIPS_NAN2008)
3139 strcat (buf, ", nan2008");
3140
fef1b0b3
SE		 3141 if (e_flags & EF_MIPS_FP64)
3142 strcat (buf, ", fp64");
3143
156c2f8b
NC		 3144 switch ((e_flags & EF_MIPS_MACH))
3145 {
3146 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3147 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3148 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3149 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3150 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3151 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3152 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3153 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3154 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3155 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3156 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3157 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3158 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3159 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3160 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3161 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3162 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3163 case 0:
3164 /* We simply ignore the field in this case to avoid confusion:
3165 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3166 extension. */
3167 break;
2b692964 3168 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3169 }
43521d43
TS		 3170
3171 switch ((e_flags & EF_MIPS_ABI))
3172 {
3173 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3174 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3175 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3176 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3177 case 0:
3178 /* We simply ignore the field in this case to avoid confusion:
3179 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3180 This means it is likely to be an o32 file, but not for
3181 sure. */
3182 break;
2b692964 3183 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3184 }
3185
3186 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3187 strcat (buf, ", mdmx");
3188
3189 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3190 strcat (buf, ", mips16");
3191
df58fc94
RS		 3192 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3193 strcat (buf, ", micromips");
3194
43521d43
TS		 3195 switch ((e_flags & EF_MIPS_ARCH))
3196 {
3197 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3198 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3199 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3200 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3201 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3202 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3203 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3204 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3205 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3206 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3207 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3208 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3209 }
252b5132 3210 break;
351b4b40 3211
35c08157
KLC		 3212 case EM_NDS32:
3213 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3214 break;
3215
ccde1100
AO		 3216 case EM_SH:
3217 switch ((e_flags & EF_SH_MACH_MASK))
3218 {
3219 case EF_SH1: strcat (buf, ", sh1"); break;
3220 case EF_SH2: strcat (buf, ", sh2"); break;
3221 case EF_SH3: strcat (buf, ", sh3"); break;
3222 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3223 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3224 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3225 case EF_SH3E: strcat (buf, ", sh3e"); break;
3226 case EF_SH4: strcat (buf, ", sh4"); break;
3227 case EF_SH5: strcat (buf, ", sh5"); break;
3228 case EF_SH2E: strcat (buf, ", sh2e"); break;
3229 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3230 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3231 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3232 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3233 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3234 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3235 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3236 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3237 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3238 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3239 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3240 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3241 }
3242
cec6a5b8
MR		 3243 if (e_flags & EF_SH_PIC)
3244 strcat (buf, ", pic");
3245
3246 if (e_flags & EF_SH_FDPIC)
3247 strcat (buf, ", fdpic");
ccde1100 3248 break;
948f632f 3249
73589c9d
CS		 3250 case EM_OR1K:
3251 if (e_flags & EF_OR1K_NODELAY)
3252 strcat (buf, ", no delay");
3253 break;
57346661 3254
351b4b40
RH		 3255 case EM_SPARCV9:
3256 if (e_flags & EF_SPARC_32PLUS)
3257 strcat (buf, ", v8+");
3258
3259 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3260 strcat (buf, ", ultrasparcI");
3261
3262 if (e_flags & EF_SPARC_SUN_US3)
3263 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3264
3265 if (e_flags & EF_SPARC_HAL_R1)
3266 strcat (buf, ", halr1");
3267
3268 if (e_flags & EF_SPARC_LEDATA)
3269 strcat (buf, ", ledata");
3270
3271 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3272 strcat (buf, ", tso");
3273
3274 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3275 strcat (buf, ", pso");
3276
3277 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3278 strcat (buf, ", rmo");
3279 break;
7d466069 3280
103f02d3
UD		 3281 case EM_PARISC:
3282 switch (e_flags & EF_PARISC_ARCH)
3283 {
3284 case EFA_PARISC_1_0:
3285 strcpy (buf, ", PA-RISC 1.0");
3286 break;
3287 case EFA_PARISC_1_1:
3288 strcpy (buf, ", PA-RISC 1.1");
3289 break;
3290 case EFA_PARISC_2_0:
3291 strcpy (buf, ", PA-RISC 2.0");
3292 break;
3293 default:
3294 break;
3295 }
3296 if (e_flags & EF_PARISC_TRAPNIL)
3297 strcat (buf, ", trapnil");
3298 if (e_flags & EF_PARISC_EXT)
3299 strcat (buf, ", ext");
3300 if (e_flags & EF_PARISC_LSB)
3301 strcat (buf, ", lsb");
3302 if (e_flags & EF_PARISC_WIDE)
3303 strcat (buf, ", wide");
3304 if (e_flags & EF_PARISC_NO_KABP)
3305 strcat (buf, ", no kabp");
3306 if (e_flags & EF_PARISC_LAZYSWAP)
3307 strcat (buf, ", lazyswap");
30800947 3308 break;
76da6bbe 3309
7d466069 3310 case EM_PJ:
2b0337b0 3311 case EM_PJ_OLD:
7d466069
ILT		 3312 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3313 strcat (buf, ", new calling convention");
3314
3315 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3316 strcat (buf, ", gnu calling convention");
3317 break;
4d6ed7c8
NC		 3318
3319 case EM_IA_64:
3320 if ((e_flags & EF_IA_64_ABI64))
3321 strcat (buf, ", 64-bit");
3322 else
3323 strcat (buf, ", 32-bit");
3324 if ((e_flags & EF_IA_64_REDUCEDFP))
3325 strcat (buf, ", reduced fp model");
3326 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3327 strcat (buf, ", no function descriptors, constant gp");
3328 else if ((e_flags & EF_IA_64_CONS_GP))
3329 strcat (buf, ", constant gp");
3330 if ((e_flags & EF_IA_64_ABSOLUTE))
3331 strcat (buf, ", absolute");
28f997cf
TG		 3332 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3333 {
3334 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3335 strcat (buf, ", vms_linkages");
3336 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3337 {
3338 case EF_IA_64_VMS_COMCOD_SUCCESS:
3339 break;
3340 case EF_IA_64_VMS_COMCOD_WARNING:
3341 strcat (buf, ", warning");
3342 break;
3343 case EF_IA_64_VMS_COMCOD_ERROR:
3344 strcat (buf, ", error");
3345 break;
3346 case EF_IA_64_VMS_COMCOD_ABORT:
3347 strcat (buf, ", abort");
3348 break;
3349 default:
bee0ee85
NC		 3350 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3351 e_flags & EF_IA_64_VMS_COMCOD);
3352 strcat (buf, ", <unknown>");
28f997cf
TG		 3353 }
3354 }
4d6ed7c8 3355 break;
179d3252
JT		 3356
3357 case EM_VAX:
3358 if ((e_flags & EF_VAX_NONPIC))
3359 strcat (buf, ", non-PIC");
3360 if ((e_flags & EF_VAX_DFLOAT))
3361 strcat (buf, ", D-Float");
3362 if ((e_flags & EF_VAX_GFLOAT))
3363 strcat (buf, ", G-Float");
3364 break;
c7927a3c 3365
619ed720
EB		 3366 case EM_VISIUM:
3367 if (e_flags & EF_VISIUM_ARCH_MCM)
3368 strcat (buf, ", mcm");
3369 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3370 strcat (buf, ", mcm24");
3371 if (e_flags & EF_VISIUM_ARCH_GR6)
3372 strcat (buf, ", gr6");
3373 break;
3374
4046d87a 3375 case EM_RL78:
1740ba0c
NC		 3376 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3377 {
3378 case E_FLAG_RL78_ANY_CPU: break;
3379 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3380 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3381 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3382 }
856ea05c
KP		 3383 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3384 strcat (buf, ", 64-bit doubles");
4046d87a 3385 break;
0b4362b0 3386
c7927a3c
NC		 3387 case EM_RX:
3388 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3389 strcat (buf, ", 64-bit doubles");
3390 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3391 strcat (buf, ", dsp");
d4cb0ea0 3392 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3393 strcat (buf, ", pid");
708e2187
NC		 3394 if (e_flags & E_FLAG_RX_ABI)
3395 strcat (buf, ", RX ABI");
3525236c
NC		 3396 if (e_flags & E_FLAG_RX_SINSNS_SET)
3397 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3398 ? ", uses String instructions" : ", bans String instructions");
a117b0a5
YS		 3399 if (e_flags & E_FLAG_RX_V2)
3400 strcat (buf, ", V2");
d4cb0ea0 3401 break;
55786da2
AK		 3402
3403 case EM_S390:
3404 if (e_flags & EF_S390_HIGH_GPRS)
3405 strcat (buf, ", highgprs");
d4cb0ea0 3406 break;
40b36596
JM		 3407
3408 case EM_TI_C6000:
3409 if ((e_flags & EF_C6000_REL))
3410 strcat (buf, ", relocatable module");
d4cb0ea0 3411 break;
13761a11
NC		 3412
3413 case EM_MSP430:
3414 strcat (buf, _(": architecture variant: "));
3415 switch (e_flags & EF_MSP430_MACH)
3416 {
3417 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3418 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3419 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3420 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3421 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3422 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3423 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3424 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3425 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3426 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3427 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3428 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3429 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3430 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3431 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3432 default:
3433 strcat (buf, _(": unknown")); break;
3434 }
3435
3436 if (e_flags & ~ EF_MSP430_MACH)
3437 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3438 }
3439 }
3440
3441 return buf;
3442}
3443
252b5132 3444static const char *
d3ba0551
AM		 3445get_osabi_name (unsigned int osabi)
3446{
3447 static char buff[32];
3448
3449 switch (osabi)
3450 {
3451 case ELFOSABI_NONE: return "UNIX - System V";
3452 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3453 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3454 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3455 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3456 case ELFOSABI_AIX: return "UNIX - AIX";
3457 case ELFOSABI_IRIX: return "UNIX - IRIX";
3458 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3459 case ELFOSABI_TRU64: return "UNIX - TRU64";
3460 case ELFOSABI_MODESTO: return "Novell - Modesto";
3461 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3462 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3463 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3464 case ELFOSABI_AROS: return "AROS";
11636f9e 3465 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3466 default:
40b36596
JM		 3467 if (osabi >= 64)
3468 switch (elf_header.e_machine)
3469 {
3470 case EM_ARM:
3471 switch (osabi)
3472 {
3473 case ELFOSABI_ARM: return "ARM";
3474 default:
3475 break;
3476 }
3477 break;
3478
3479 case EM_MSP430:
3480 case EM_MSP430_OLD:
619ed720 3481 case EM_VISIUM:
40b36596
JM		 3482 switch (osabi)
3483 {
3484 case ELFOSABI_STANDALONE: return _("Standalone App");
3485 default:
3486 break;
3487 }
3488 break;
3489
3490 case EM_TI_C6000:
3491 switch (osabi)
3492 {
3493 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3494 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3495 default:
3496 break;
3497 }
3498 break;
3499
3500 default:
3501 break;
3502 }
e9e44622 3503 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3504 return buff;
3505 }
3506}
3507
a06ea964
NC		 3508static const char *
3509get_aarch64_segment_type (unsigned long type)
3510{
3511 switch (type)
3512 {
3513 case PT_AARCH64_ARCHEXT:
3514 return "AARCH64_ARCHEXT";
3515 default:
3516 break;
3517 }
3518
3519 return NULL;
3520}
3521
b294bdf8
MM		 3522static const char *
3523get_arm_segment_type (unsigned long type)
3524{
3525 switch (type)
3526 {
3527 case PT_ARM_EXIDX:
3528 return "EXIDX";
3529 default:
3530 break;
3531 }
3532
3533 return NULL;
3534}
3535
d3ba0551
AM		 3536static const char *
3537get_mips_segment_type (unsigned long type)
252b5132
RH		 3538{
3539 switch (type)
3540 {
3541 case PT_MIPS_REGINFO:
3542 return "REGINFO";
3543 case PT_MIPS_RTPROC:
3544 return "RTPROC";
3545 case PT_MIPS_OPTIONS:
3546 return "OPTIONS";
351cdf24
MF		 3547 case PT_MIPS_ABIFLAGS:
3548 return "ABIFLAGS";
252b5132
RH		 3549 default:
3550 break;
3551 }
3552
3553 return NULL;
3554}
3555
103f02d3 3556static const char *
d3ba0551 3557get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3558{
3559 switch (type)
3560 {
3561 case PT_HP_TLS: return "HP_TLS";
3562 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3563 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3564 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3565 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3566 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3567 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3568 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3569 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3570 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3571 case PT_HP_PARALLEL: return "HP_PARALLEL";
3572 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3573 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3574 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3575 case PT_HP_STACK: return "HP_STACK";
3576 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3577 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3578 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3579 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3580 default:
3581 break;
3582 }
3583
3584 return NULL;
3585}
3586
4d6ed7c8 3587static const char *
d3ba0551 3588get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3589{
3590 switch (type)
3591 {
3592 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3593 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3594 case PT_HP_TLS: return "HP_TLS";
3595 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3596 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3597 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3598 default:
3599 break;
3600 }
3601
3602 return NULL;
3603}
3604
40b36596
JM		 3605static const char *
3606get_tic6x_segment_type (unsigned long type)
3607{
3608 switch (type)
3609 {
3610 case PT_C6000_PHATTR: return "C6000_PHATTR";
3611 default:
3612 break;
3613 }
3614
3615 return NULL;
3616}
3617
252b5132 3618static const char *
d3ba0551 3619get_segment_type (unsigned long p_type)
252b5132 3620{
b34976b6 3621 static char buff[32];
252b5132
RH		 3622
3623 switch (p_type)
3624 {
b34976b6
AM		 3625 case PT_NULL: return "NULL";
3626 case PT_LOAD: return "LOAD";
252b5132 3627 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3628 case PT_INTERP: return "INTERP";
3629 case PT_NOTE: return "NOTE";
3630 case PT_SHLIB: return "SHLIB";
3631 case PT_PHDR: return "PHDR";
13ae64f3 3632 case PT_TLS: return "TLS";
252b5132 3633
65765700
JJ		 3634 case PT_GNU_EH_FRAME:
3635 return "GNU_EH_FRAME";
2b05f1b7 3636 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3637 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3638
252b5132
RH		 3639 default:
3640 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3641 {
2cf0635d 3642 const char * result;
103f02d3 3643
252b5132
RH		 3644 switch (elf_header.e_machine)
3645 {
a06ea964
NC		 3646 case EM_AARCH64:
3647 result = get_aarch64_segment_type (p_type);
3648 break;
b294bdf8
MM		 3649 case EM_ARM:
3650 result = get_arm_segment_type (p_type);
3651 break;
252b5132 3652 case EM_MIPS:
4fe85591 3653 case EM_MIPS_RS3_LE:
252b5132
RH		 3654 result = get_mips_segment_type (p_type);
3655 break;
103f02d3
UD		 3656 case EM_PARISC:
3657 result = get_parisc_segment_type (p_type);
3658 break;
4d6ed7c8
NC		 3659 case EM_IA_64:
3660 result = get_ia64_segment_type (p_type);
3661 break;
40b36596
JM		 3662 case EM_TI_C6000:
3663 result = get_tic6x_segment_type (p_type);
3664 break;
252b5132
RH		 3665 default:
3666 result = NULL;
3667 break;
3668 }
103f02d3 3669
252b5132
RH		 3670 if (result != NULL)
3671 return result;
103f02d3 3672
252b5132
RH		 3673 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3674 }
3675 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3676 {
2cf0635d 3677 const char * result;
103f02d3
UD		 3678
3679 switch (elf_header.e_machine)
3680 {
3681 case EM_PARISC:
3682 result = get_parisc_segment_type (p_type);
3683 break;
00428cca
AM		 3684 case EM_IA_64:
3685 result = get_ia64_segment_type (p_type);
3686 break;
103f02d3
UD		 3687 default:
3688 result = NULL;
3689 break;
3690 }
3691
3692 if (result != NULL)
3693 return result;
3694
3695 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3696 }
252b5132 3697 else
e9e44622 3698 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3699
3700 return buff;
3701 }
3702}
3703
3704static const char *
d3ba0551 3705get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3706{
3707 switch (sh_type)
3708 {
b34976b6
AM		 3709 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3710 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3711 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3712 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3713 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3714 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3715 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3716 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3717 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3718 case SHT_MIPS_RELD: return "MIPS_RELD";
3719 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3720 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3721 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3722 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3723 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3724 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3725 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3726 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3727 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3728 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3729 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3730 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3731 case SHT_MIPS_LINE: return "MIPS_LINE";
3732 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3733 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3734 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3735 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3736 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3737 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3738 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3739 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3740 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3741 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3742 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3743 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3744 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3745 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3746 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3747 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3748 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3749 default:
3750 break;
3751 }
3752 return NULL;
3753}
3754
103f02d3 3755static const char *
d3ba0551 3756get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3757{
3758 switch (sh_type)
3759 {
3760 case SHT_PARISC_EXT: return "PARISC_EXT";
3761 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3762 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3763 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3764 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3765 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3766 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3767 default:
3768 break;
3769 }
3770 return NULL;
3771}
3772
4d6ed7c8 3773static const char *
d3ba0551 3774get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3775{
18bd398b 3776 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3777 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3778 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3779
4d6ed7c8
NC		 3780 switch (sh_type)
3781 {
148b93f2
NC		 3782 case SHT_IA_64_EXT: return "IA_64_EXT";
3783 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3784 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3785 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3786 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3787 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3788 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3789 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3790 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3791 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3792 default:
3793 break;
3794 }
3795 return NULL;
3796}
3797
d2b2c203
DJ		 3798static const char *
3799get_x86_64_section_type_name (unsigned int sh_type)
3800{
3801 switch (sh_type)
3802 {
3803 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3804 default:
3805 break;
3806 }
3807 return NULL;
3808}
3809
a06ea964
NC		 3810static const char *
3811get_aarch64_section_type_name (unsigned int sh_type)
3812{
3813 switch (sh_type)
3814 {
3815 case SHT_AARCH64_ATTRIBUTES:
3816 return "AARCH64_ATTRIBUTES";
3817 default:
3818 break;
3819 }
3820 return NULL;
3821}
3822
40a18ebd
NC		 3823static const char *
3824get_arm_section_type_name (unsigned int sh_type)
3825{
3826 switch (sh_type)
3827 {
7f6fed87
NC		 3828 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3829 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3830 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3831 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3832 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3833 default:
3834 break;
3835 }
3836 return NULL;
3837}
3838
40b36596
JM		 3839static const char *
3840get_tic6x_section_type_name (unsigned int sh_type)
3841{
3842 switch (sh_type)
3843 {
3844 case SHT_C6000_UNWIND:
3845 return "C6000_UNWIND";
3846 case SHT_C6000_PREEMPTMAP:
3847 return "C6000_PREEMPTMAP";
3848 case SHT_C6000_ATTRIBUTES:
3849 return "C6000_ATTRIBUTES";
3850 case SHT_TI_ICODE:
3851 return "TI_ICODE";
3852 case SHT_TI_XREF:
3853 return "TI_XREF";
3854 case SHT_TI_HANDLER:
3855 return "TI_HANDLER";
3856 case SHT_TI_INITINFO:
3857 return "TI_INITINFO";
3858 case SHT_TI_PHATTRS:
3859 return "TI_PHATTRS";
3860 default:
3861 break;
3862 }
3863 return NULL;
3864}
3865
13761a11
NC		 3866static const char *
3867get_msp430x_section_type_name (unsigned int sh_type)
3868{
3869 switch (sh_type)
3870 {
3871 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3872 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3873 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3874 default: return NULL;
3875 }
3876}
3877
685080f2
NC		 3878static const char *
3879get_v850_section_type_name (unsigned int sh_type)
3880{
3881 switch (sh_type)
3882 {
3883 case SHT_V850_SCOMMON: return "V850 Small Common";
3884 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3885 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3886 case SHT_RENESAS_IOP: return "RENESAS IOP";
3887 case SHT_RENESAS_INFO: return "RENESAS INFO";
3888 default: return NULL;
3889 }
3890}
3891
252b5132 3892static const char *
d3ba0551 3893get_section_type_name (unsigned int sh_type)
252b5132 3894{
b34976b6 3895 static char buff[32];
252b5132
RH		 3896
3897 switch (sh_type)
3898 {
3899 case SHT_NULL: return "NULL";
3900 case SHT_PROGBITS: return "PROGBITS";
3901 case SHT_SYMTAB: return "SYMTAB";
3902 case SHT_STRTAB: return "STRTAB";
3903 case SHT_RELA: return "RELA";
3904 case SHT_HASH: return "HASH";
3905 case SHT_DYNAMIC: return "DYNAMIC";
3906 case SHT_NOTE: return "NOTE";
3907 case SHT_NOBITS: return "NOBITS";
3908 case SHT_REL: return "REL";
3909 case SHT_SHLIB: return "SHLIB";
3910 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3911 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3912 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3913 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3914 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3915 case SHT_GROUP: return "GROUP";
3916 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3917 case SHT_GNU_verdef: return "VERDEF";
3918 case SHT_GNU_verneed: return "VERNEED";
3919 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3920 case 0x6ffffff0: return "VERSYM";
3921 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3922 case 0x7ffffffd: return "AUXILIARY";
3923 case 0x7fffffff: return "FILTER";
047b2264 3924 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3925
3926 default:
3927 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3928 {
2cf0635d 3929 const char * result;
252b5132
RH		 3930
3931 switch (elf_header.e_machine)
3932 {
3933 case EM_MIPS:
4fe85591 3934 case EM_MIPS_RS3_LE:
252b5132
RH		 3935 result = get_mips_section_type_name (sh_type);
3936 break;
103f02d3
UD		 3937 case EM_PARISC:
3938 result = get_parisc_section_type_name (sh_type);
3939 break;
4d6ed7c8
NC		 3940 case EM_IA_64:
3941 result = get_ia64_section_type_name (sh_type);
3942 break;
d2b2c203 3943 case EM_X86_64:
8a9036a4 3944 case EM_L1OM:
7a9068fe 3945 case EM_K1OM:
d2b2c203
DJ		 3946 result = get_x86_64_section_type_name (sh_type);
3947 break;
a06ea964
NC		 3948 case EM_AARCH64:
3949 result = get_aarch64_section_type_name (sh_type);
3950 break;
40a18ebd
NC		 3951 case EM_ARM:
3952 result = get_arm_section_type_name (sh_type);
3953 break;
40b36596
JM		 3954 case EM_TI_C6000:
3955 result = get_tic6x_section_type_name (sh_type);
3956 break;
13761a11
NC		 3957 case EM_MSP430:
3958 result = get_msp430x_section_type_name (sh_type);
3959 break;
685080f2
NC		 3960 case EM_V800:
3961 case EM_V850:
3962 case EM_CYGNUS_V850:
3963 result = get_v850_section_type_name (sh_type);
3964 break;
252b5132
RH		 3965 default:
3966 result = NULL;
3967 break;
3968 }
3969
3970 if (result != NULL)
3971 return result;
3972
c91d0dfb 3973 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3974 }
3975 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3976 {
2cf0635d 3977 const char * result;
148b93f2
NC		 3978
3979 switch (elf_header.e_machine)
3980 {
3981 case EM_IA_64:
3982 result = get_ia64_section_type_name (sh_type);
3983 break;
3984 default:
3985 result = NULL;
3986 break;
3987 }
3988
3989 if (result != NULL)
3990 return result;
3991
3992 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3993 }
252b5132 3994 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3995 {
3996 switch (elf_header.e_machine)
3997 {
3998 case EM_V800:
3999 case EM_V850:
4000 case EM_CYGNUS_V850:
4001 return get_v850_section_type_name (sh_type);
4002 default:
4003 break;
4004 }
4005
4006 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
4007 }
252b5132 4008 else
a7dbfd1c
NC		 4009 /* This message is probably going to be displayed in a 15
4010 character wide field, so put the hex value first. */
4011 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 4012
252b5132
RH		 4013 return buff;
4014 }
4015}
4016
2979dc34 4017#define OPTION_DEBUG_DUMP 512
2c610e4b 4018#define OPTION_DYN_SYMS 513
fd2f0033
TT		 4019#define OPTION_DWARF_DEPTH 514
4020#define OPTION_DWARF_START 515
4723351a 4021#define OPTION_DWARF_CHECK 516
2979dc34 4022
85b1c36d 4023static struct option options[] =
252b5132 4024{
b34976b6 4025 {"all", no_argument, 0, 'a'},
252b5132
RH		 4026 {"file-header", no_argument, 0, 'h'},
4027 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4028 {"headers", no_argument, 0, 'e'},
4029 {"histogram", no_argument, 0, 'I'},
4030 {"segments", no_argument, 0, 'l'},
4031 {"sections", no_argument, 0, 'S'},
252b5132 4032 {"section-headers", no_argument, 0, 'S'},
f5842774 4033 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4034 {"section-details", no_argument, 0, 't'},
595cf52e 4035 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4036 {"symbols", no_argument, 0, 's'},
4037 {"syms", no_argument, 0, 's'},
2c610e4b 4038 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4039 {"relocs", no_argument, 0, 'r'},
4040 {"notes", no_argument, 0, 'n'},
4041 {"dynamic", no_argument, 0, 'd'},
a952a375 4042 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4043 {"version-info", no_argument, 0, 'V'},
4044 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4045 {"unwind", no_argument, 0, 'u'},
4145f1d5 4046 {"archive-index", no_argument, 0, 'c'},
b34976b6 4047 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4048 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4049 {"string-dump", required_argument, 0, 'p'},
0e602686 4050 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4051#ifdef SUPPORT_DISASSEMBLY
4052 {"instruction-dump", required_argument, 0, 'i'},
4053#endif
cf13d699 4054 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4055
fd2f0033
TT		 4056 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4057 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4058 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4059
b34976b6
AM		 4060 {"version", no_argument, 0, 'v'},
4061 {"wide", no_argument, 0, 'W'},
4062 {"help", no_argument, 0, 'H'},
4063 {0, no_argument, 0, 0}
252b5132
RH		 4064};
4065
4066static void
2cf0635d 4067usage (FILE * stream)
252b5132 4068{
92f01d61
JM		 4069 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4070 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4071 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4072 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4073 -h --file-header Display the ELF file header\n\
4074 -l --program-headers Display the program headers\n\
4075 --segments An alias for --program-headers\n\
4076 -S --section-headers Display the sections' header\n\
4077 --sections An alias for --section-headers\n\
f5842774 4078 -g --section-groups Display the section groups\n\
5477e8a0 4079 -t --section-details Display the section details\n\
8b53311e
NC		 4080 -e --headers Equivalent to: -h -l -S\n\
4081 -s --syms Display the symbol table\n\
3f08eb35 4082 --symbols An alias for --syms\n\
2c610e4b 4083 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4084 -n --notes Display the core notes (if present)\n\
4085 -r --relocs Display the relocations (if present)\n\
4086 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4087 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4088 -V --version-info Display the version sections (if present)\n\
1b31d05e 4089 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4090 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4091 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4092 -x --hex-dump=<number|name>\n\
4093 Dump the contents of section <number|name> as bytes\n\
4094 -p --string-dump=<number|name>\n\
4095 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4096 -R --relocated-dump=<number|name>\n\
4097 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4098 -z --decompress Decompress section before dumping it\n\
f9f0e732 4099 -w[lLiaprmfFsoRt] or\n\
1ed06042 4100 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4101 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4102 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4103 =addr,=cu_index]\n\
8b53311e 4104 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4105 fprintf (stream, _("\
4106 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4107 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4108 or deeper\n"));
252b5132 4109#ifdef SUPPORT_DISASSEMBLY
92f01d61 4110 fprintf (stream, _("\
09c11c86
NC		 4111 -i --instruction-dump=<number|name>\n\
4112 Disassemble the contents of section <number|name>\n"));
252b5132 4113#endif
92f01d61 4114 fprintf (stream, _("\
8b53311e
NC		 4115 -I --histogram Display histogram of bucket list lengths\n\
4116 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4117 @<file> Read options from <file>\n\
8b53311e
NC		 4118 -H --help Display this information\n\
4119 -v --version Display the version number of readelf\n"));
1118d252 4120
92f01d61
JM		 4121 if (REPORT_BUGS_TO[0] && stream == stdout)
4122 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4123
92f01d61 4124 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4125}
4126
18bd398b
NC		 4127/* Record the fact that the user wants the contents of section number
4128 SECTION to be displayed using the method(s) encoded as flags bits
4129 in TYPE. Note, TYPE can be zero if we are creating the array for
4130 the first time. */
4131
252b5132 4132static void
09c11c86 4133request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4134{
4135 if (section >= num_dump_sects)
4136 {
2cf0635d 4137 dump_type * new_dump_sects;
252b5132 4138
3f5e193b
NC		 4139 new_dump_sects = (dump_type *) calloc (section + 1,
4140 sizeof (* dump_sects));
252b5132
RH		 4141
4142 if (new_dump_sects == NULL)
591a748a 4143 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4144 else
4145 {
4146 /* Copy current flag settings. */
09c11c86 4147 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4148
4149 free (dump_sects);
4150
4151 dump_sects = new_dump_sects;
4152 num_dump_sects = section + 1;
4153 }
4154 }
4155
4156 if (dump_sects)
b34976b6 4157 dump_sects[section] |= type;
252b5132
RH		 4158
4159 return;
4160}
4161
aef1f6d0
DJ		 4162/* Request a dump by section name. */
4163
4164static void
2cf0635d 4165request_dump_byname (const char * section, dump_type type)
aef1f6d0 4166{
2cf0635d 4167 struct dump_list_entry * new_request;
aef1f6d0 4168
3f5e193b
NC		 4169 new_request = (struct dump_list_entry *)
4170 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4171 if (!new_request)
591a748a 4172 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4173
4174 new_request->name = strdup (section);
4175 if (!new_request->name)
591a748a 4176 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4177
4178 new_request->type = type;
4179
4180 new_request->next = dump_sects_byname;
4181 dump_sects_byname = new_request;
4182}
4183
cf13d699
NC		 4184static inline void
4185request_dump (dump_type type)
4186{
4187 int section;
4188 char * cp;
4189
4190 do_dump++;
4191 section = strtoul (optarg, & cp, 0);
4192
4193 if (! *cp && section >= 0)
4194 request_dump_bynumber (section, type);
4195 else
4196 request_dump_byname (optarg, type);
4197}
4198
4199
252b5132 4200static void
2cf0635d 4201parse_args (int argc, char ** argv)
252b5132
RH		 4202{
4203 int c;
4204
4205 if (argc < 2)
92f01d61 4206 usage (stderr);
252b5132
RH		 4207
4208 while ((c = getopt_long
0e602686 4209 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4210 {
252b5132
RH		 4211 switch (c)
4212 {
4213 case 0:
4214 /* Long options. */
4215 break;
4216 case 'H':
92f01d61 4217 usage (stdout);
252b5132
RH		 4218 break;
4219
4220 case 'a':
b34976b6
AM		 4221 do_syms++;
4222 do_reloc++;
4223 do_unwind++;
4224 do_dynamic++;
4225 do_header++;
4226 do_sections++;
f5842774 4227 do_section_groups++;
b34976b6
AM		 4228 do_segments++;
4229 do_version++;
4230 do_histogram++;
4231 do_arch++;
4232 do_notes++;
252b5132 4233 break;
f5842774
L		 4234 case 'g':
4235 do_section_groups++;
4236 break;
5477e8a0 4237 case 't':
595cf52e 4238 case 'N':
5477e8a0
L		 4239 do_sections++;
4240 do_section_details++;
595cf52e 4241 break;
252b5132 4242 case 'e':
b34976b6
AM		 4243 do_header++;
4244 do_sections++;
4245 do_segments++;
252b5132 4246 break;
a952a375 4247 case 'A':
b34976b6 4248 do_arch++;
a952a375 4249 break;
252b5132 4250 case 'D':
b34976b6 4251 do_using_dynamic++;
252b5132
RH		 4252 break;
4253 case 'r':
b34976b6 4254 do_reloc++;
252b5132 4255 break;
4d6ed7c8 4256 case 'u':
b34976b6 4257 do_unwind++;
4d6ed7c8 4258 break;
252b5132 4259 case 'h':
b34976b6 4260 do_header++;
252b5132
RH		 4261 break;
4262 case 'l':
b34976b6 4263 do_segments++;
252b5132
RH		 4264 break;
4265 case 's':
b34976b6 4266 do_syms++;
252b5132
RH		 4267 break;
4268 case 'S':
b34976b6 4269 do_sections++;
252b5132
RH		 4270 break;
4271 case 'd':
b34976b6 4272 do_dynamic++;
252b5132 4273 break;
a952a375 4274 case 'I':
b34976b6 4275 do_histogram++;
a952a375 4276 break;
779fe533 4277 case 'n':
b34976b6 4278 do_notes++;
779fe533 4279 break;
4145f1d5
NC		 4280 case 'c':
4281 do_archive_index++;
4282 break;
252b5132 4283 case 'x':
cf13d699 4284 request_dump (HEX_DUMP);
aef1f6d0 4285 break;
09c11c86 4286 case 'p':
cf13d699
NC		 4287 request_dump (STRING_DUMP);
4288 break;
4289 case 'R':
4290 request_dump (RELOC_DUMP);
09c11c86 4291 break;
0e602686
NC		 4292 case 'z':
4293 decompress_dumps++;
4294 break;
252b5132 4295 case 'w':
b34976b6 4296 do_dump++;
252b5132 4297 if (optarg == 0)
613ff48b
CC		 4298 {
4299 do_debugging = 1;
4300 dwarf_select_sections_all ();
4301 }
252b5132
RH		 4302 else
4303 {
4304 do_debugging = 0;
4cb93e3b 4305 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4306 }
4307 break;
2979dc34 4308 case OPTION_DEBUG_DUMP:
b34976b6 4309 do_dump++;
2979dc34
JJ		 4310 if (optarg == 0)
4311 do_debugging = 1;
4312 else
4313 {
2979dc34 4314 do_debugging = 0;
4cb93e3b 4315 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4316 }
4317 break;
fd2f0033
TT		 4318 case OPTION_DWARF_DEPTH:
4319 {
4320 char *cp;
4321
4322 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4323 }
4324 break;
4325 case OPTION_DWARF_START:
4326 {
4327 char *cp;
4328
4329 dwarf_start_die = strtoul (optarg, & cp, 0);
4330 }
4331 break;
4723351a
CC		 4332 case OPTION_DWARF_CHECK:
4333 dwarf_check = 1;
4334 break;
2c610e4b
L		 4335 case OPTION_DYN_SYMS:
4336 do_dyn_syms++;
4337 break;
252b5132
RH		 4338#ifdef SUPPORT_DISASSEMBLY
4339 case 'i':
cf13d699
NC		 4340 request_dump (DISASS_DUMP);
4341 break;
252b5132
RH		 4342#endif
4343 case 'v':
4344 print_version (program_name);
4345 break;
4346 case 'V':
b34976b6 4347 do_version++;
252b5132 4348 break;
d974e256 4349 case 'W':
b34976b6 4350 do_wide++;
d974e256 4351 break;
252b5132 4352 default:
252b5132
RH		 4353 /* xgettext:c-format */
4354 error (_("Invalid option '-%c'\n"), c);
4355 /* Drop through. */
4356 case '?':
92f01d61 4357 usage (stderr);
252b5132
RH		 4358 }
4359 }
4360
4d6ed7c8 4361 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4362 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4363 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4364 && !do_section_groups && !do_archive_index
4365 && !do_dyn_syms)
92f01d61 4366 usage (stderr);
252b5132
RH		 4367}
4368
4369static const char *
d3ba0551 4370get_elf_class (unsigned int elf_class)
252b5132 4371{
b34976b6 4372 static char buff[32];
103f02d3 4373
252b5132
RH		 4374 switch (elf_class)
4375 {
4376 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4377 case ELFCLASS32: return "ELF32";
4378 case ELFCLASS64: return "ELF64";
ab5e7794 4379 default:
e9e44622 4380 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4381 return buff;
252b5132
RH		 4382 }
4383}
4384
4385static const char *
d3ba0551 4386get_data_encoding (unsigned int encoding)
252b5132 4387{
b34976b6 4388 static char buff[32];
103f02d3 4389
252b5132
RH		 4390 switch (encoding)
4391 {
4392 case ELFDATANONE: return _("none");
33c63f9d
CM		 4393 case ELFDATA2LSB: return _("2's complement, little endian");
4394 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4395 default:
e9e44622 4396 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4397 return buff;
252b5132
RH		 4398 }
4399}
4400
252b5132 4401/* Decode the data held in 'elf_header'. */
ee42cf8c 4402
252b5132 4403static int
d3ba0551 4404process_file_header (void)
252b5132 4405{
b34976b6
AM		 4406 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4407 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4408 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4409 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4410 {
4411 error
4412 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4413 return 0;
4414 }
4415
2dc4cec1
L		 4416 init_dwarf_regnames (elf_header.e_machine);
4417
252b5132
RH		 4418 if (do_header)
4419 {
4420 int i;
4421
4422 printf (_("ELF Header:\n"));
4423 printf (_(" Magic: "));
b34976b6
AM		 4424 for (i = 0; i < EI_NIDENT; i++)
4425 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4426 printf ("\n");
4427 printf (_(" Class: %s\n"),
b34976b6 4428 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4429 printf (_(" Data: %s\n"),
b34976b6 4430 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4431 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4432 elf_header.e_ident[EI_VERSION],
4433 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4434 ? "(current)"
b34976b6 4435 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4436 ? _("<unknown: %lx>")
789be9f7 4437 : "")));
252b5132 4438 printf (_(" OS/ABI: %s\n"),
b34976b6 4439 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4440 printf (_(" ABI Version: %d\n"),
b34976b6 4441 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4442 printf (_(" Type: %s\n"),
4443 get_file_type (elf_header.e_type));
4444 printf (_(" Machine: %s\n"),
4445 get_machine_name (elf_header.e_machine));
4446 printf (_(" Version: 0x%lx\n"),
4447 (unsigned long) elf_header.e_version);
76da6bbe 4448
f7a99963
NC		 4449 printf (_(" Entry point address: "));
4450 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4451 printf (_("\n Start of program headers: "));
4452 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4453 printf (_(" (bytes into file)\n Start of section headers: "));
4454 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4455 printf (_(" (bytes into file)\n"));
76da6bbe 4456
252b5132
RH		 4457 printf (_(" Flags: 0x%lx%s\n"),
4458 (unsigned long) elf_header.e_flags,
4459 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4460 printf (_(" Size of this header: %ld (bytes)\n"),
4461 (long) elf_header.e_ehsize);
4462 printf (_(" Size of program headers: %ld (bytes)\n"),
4463 (long) elf_header.e_phentsize);
2046a35d 4464 printf (_(" Number of program headers: %ld"),
252b5132 4465 (long) elf_header.e_phnum);
2046a35d
AM		 4466 if (section_headers != NULL
4467 && elf_header.e_phnum == PN_XNUM
4468 && section_headers[0].sh_info != 0)
cc5914eb 4469 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4470 putc ('\n', stdout);
252b5132
RH		 4471 printf (_(" Size of section headers: %ld (bytes)\n"),
4472 (long) elf_header.e_shentsize);
560f3c1c 4473 printf (_(" Number of section headers: %ld"),
252b5132 4474 (long) elf_header.e_shnum);
4fbb74a6 4475 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4476 printf (" (%ld)", (long) section_headers[0].sh_size);
4477 putc ('\n', stdout);
4478 printf (_(" Section header string table index: %ld"),
252b5132 4479 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4480 if (section_headers != NULL
4481 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4482 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4483 else if (elf_header.e_shstrndx != SHN_UNDEF
4484 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4485 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4486 putc ('\n', stdout);
4487 }
4488
4489 if (section_headers != NULL)
4490 {
2046a35d
AM		 4491 if (elf_header.e_phnum == PN_XNUM
4492 && section_headers[0].sh_info != 0)
4493 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4494 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4495 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4496 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4497 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4498 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4499 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4500 free (section_headers);
4501 section_headers = NULL;
252b5132 4502 }
103f02d3 4503
9ea033b2
NC		 4504 return 1;
4505}
4506
e0a31db1 4507static bfd_boolean
91d6fa6a 4508get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4509{
2cf0635d
NC		 4510 Elf32_External_Phdr * phdrs;
4511 Elf32_External_Phdr * external;
4512 Elf_Internal_Phdr * internal;
b34976b6 4513 unsigned int i;
e0a31db1
NC		 4514 unsigned int size = elf_header.e_phentsize;
4515 unsigned int num = elf_header.e_phnum;
4516
4517 /* PR binutils/17531: Cope with unexpected section header sizes. */
4518 if (size == 0 || num == 0)
4519 return FALSE;
4520 if (size < sizeof * phdrs)
4521 {
4522 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4523 return FALSE;
4524 }
4525 if (size > sizeof * phdrs)
4526 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4527
3f5e193b 4528 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4529 size, num, _("program headers"));
4530 if (phdrs == NULL)
4531 return FALSE;
9ea033b2 4532
91d6fa6a 4533 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4534 i < elf_header.e_phnum;
b34976b6 4535 i++, internal++, external++)
252b5132 4536 {
9ea033b2
NC		 4537 internal->p_type = BYTE_GET (external->p_type);
4538 internal->p_offset = BYTE_GET (external->p_offset);
4539 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4540 internal->p_paddr = BYTE_GET (external->p_paddr);
4541 internal->p_filesz = BYTE_GET (external->p_filesz);
4542 internal->p_memsz = BYTE_GET (external->p_memsz);
4543 internal->p_flags = BYTE_GET (external->p_flags);
4544 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4545 }
4546
9ea033b2 4547 free (phdrs);
e0a31db1 4548 return TRUE;
252b5132
RH		 4549}
4550
e0a31db1 4551static bfd_boolean
91d6fa6a 4552get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4553{
2cf0635d
NC		 4554 Elf64_External_Phdr * phdrs;
4555 Elf64_External_Phdr * external;
4556 Elf_Internal_Phdr * internal;
b34976b6 4557 unsigned int i;
e0a31db1
NC		 4558 unsigned int size = elf_header.e_phentsize;
4559 unsigned int num = elf_header.e_phnum;
4560
4561 /* PR binutils/17531: Cope with unexpected section header sizes. */
4562 if (size == 0 || num == 0)
4563 return FALSE;
4564 if (size < sizeof * phdrs)
4565 {
4566 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4567 return FALSE;
4568 }
4569 if (size > sizeof * phdrs)
4570 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4571
3f5e193b 4572 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4573 size, num, _("program headers"));
a6e9f9df 4574 if (!phdrs)
e0a31db1 4575 return FALSE;
9ea033b2 4576
91d6fa6a 4577 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4578 i < elf_header.e_phnum;
b34976b6 4579 i++, internal++, external++)
9ea033b2
NC		 4580 {
4581 internal->p_type = BYTE_GET (external->p_type);
4582 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4583 internal->p_offset = BYTE_GET (external->p_offset);
4584 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4585 internal->p_paddr = BYTE_GET (external->p_paddr);
4586 internal->p_filesz = BYTE_GET (external->p_filesz);
4587 internal->p_memsz = BYTE_GET (external->p_memsz);
4588 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4589 }
4590
4591 free (phdrs);
e0a31db1 4592 return TRUE;
9ea033b2 4593}
252b5132 4594
d93f0186
NC		 4595/* Returns 1 if the program headers were read into `program_headers'. */
4596
4597static int
2cf0635d 4598get_program_headers (FILE * file)
d93f0186 4599{
2cf0635d 4600 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4601
4602 /* Check cache of prior read. */
4603 if (program_headers != NULL)
4604 return 1;
4605
3f5e193b
NC		 4606 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4607 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4608
4609 if (phdrs == NULL)
4610 {
8b73c356
NC		 4611 error (_("Out of memory reading %u program headers\n"),
4612 elf_header.e_phnum);
d93f0186
NC		 4613 return 0;
4614 }
4615
4616 if (is_32bit_elf
4617 ? get_32bit_program_headers (file, phdrs)
4618 : get_64bit_program_headers (file, phdrs))
4619 {
4620 program_headers = phdrs;
4621 return 1;
4622 }
4623
4624 free (phdrs);
4625 return 0;
4626}
4627
2f62977e
NC		 4628/* Returns 1 if the program headers were loaded. */
4629
252b5132 4630static int
2cf0635d 4631process_program_headers (FILE * file)
252b5132 4632{
2cf0635d 4633 Elf_Internal_Phdr * segment;
b34976b6 4634 unsigned int i;
252b5132
RH		 4635
4636 if (elf_header.e_phnum == 0)
4637 {
82f2dbf7
NC		 4638 /* PR binutils/12467. */
4639 if (elf_header.e_phoff != 0)
4640 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4641 " header offset, but no program headers\n"));
82f2dbf7 4642 else if (do_segments)
252b5132 4643 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4644 return 0;
252b5132
RH		 4645 }
4646
4647 if (do_segments && !do_header)
4648 {
f7a99963
NC		 4649 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4650 printf (_("Entry point "));
4651 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4652 printf (_("\nThere are %d program headers, starting at offset "),
4653 elf_header.e_phnum);
4654 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4655 printf ("\n");
252b5132
RH		 4656 }
4657
d93f0186 4658 if (! get_program_headers (file))
252b5132 4659 return 0;
103f02d3 4660
252b5132
RH		 4661 if (do_segments)
4662 {
3a1a2036
NC		 4663 if (elf_header.e_phnum > 1)
4664 printf (_("\nProgram Headers:\n"));
4665 else
4666 printf (_("\nProgram Headers:\n"));
76da6bbe 4667
f7a99963
NC		 4668 if (is_32bit_elf)
4669 printf
4670 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4671 else if (do_wide)
4672 printf
4673 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4674 else
4675 {
4676 printf
4677 (_(" Type Offset VirtAddr PhysAddr\n"));
4678 printf
4679 (_(" FileSiz MemSiz Flags Align\n"));
4680 }
252b5132
RH		 4681 }
4682
252b5132 4683 dynamic_addr = 0;
1b228002 4684 dynamic_size = 0;
252b5132
RH		 4685
4686 for (i = 0, segment = program_headers;
4687 i < elf_header.e_phnum;
b34976b6 4688 i++, segment++)
252b5132
RH		 4689 {
4690 if (do_segments)
4691 {
103f02d3 4692 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4693
4694 if (is_32bit_elf)
4695 {
4696 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4697 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4698 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4699 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4700 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4701 printf ("%c%c%c ",
4702 (segment->p_flags & PF_R ? 'R' : ' '),
4703 (segment->p_flags & PF_W ? 'W' : ' '),
4704 (segment->p_flags & PF_X ? 'E' : ' '));
4705 printf ("%#lx", (unsigned long) segment->p_align);
4706 }
d974e256
JJ		 4707 else if (do_wide)
4708 {
4709 if ((unsigned long) segment->p_offset == segment->p_offset)
4710 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4711 else
4712 {
4713 print_vma (segment->p_offset, FULL_HEX);
4714 putchar (' ');
4715 }
4716
4717 print_vma (segment->p_vaddr, FULL_HEX);
4718 putchar (' ');
4719 print_vma (segment->p_paddr, FULL_HEX);
4720 putchar (' ');
4721
4722 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4723 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4724 else
4725 {
4726 print_vma (segment->p_filesz, FULL_HEX);
4727 putchar (' ');
4728 }
4729
4730 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4731 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4732 else
4733 {
f48e6c45 4734 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4735 }
4736
4737 printf (" %c%c%c ",
4738 (segment->p_flags & PF_R ? 'R' : ' '),
4739 (segment->p_flags & PF_W ? 'W' : ' '),
4740 (segment->p_flags & PF_X ? 'E' : ' '));
4741
4742 if ((unsigned long) segment->p_align == segment->p_align)
4743 printf ("%#lx", (unsigned long) segment->p_align);
4744 else
4745 {
4746 print_vma (segment->p_align, PREFIX_HEX);
4747 }
4748 }
f7a99963
NC		 4749 else
4750 {
4751 print_vma (segment->p_offset, FULL_HEX);
4752 putchar (' ');
4753 print_vma (segment->p_vaddr, FULL_HEX);
4754 putchar (' ');
4755 print_vma (segment->p_paddr, FULL_HEX);
4756 printf ("\n ");
4757 print_vma (segment->p_filesz, FULL_HEX);
4758 putchar (' ');
4759 print_vma (segment->p_memsz, FULL_HEX);
4760 printf (" %c%c%c ",
4761 (segment->p_flags & PF_R ? 'R' : ' '),
4762 (segment->p_flags & PF_W ? 'W' : ' '),
4763 (segment->p_flags & PF_X ? 'E' : ' '));
4764 print_vma (segment->p_align, HEX);
4765 }
252b5132
RH		 4766 }
4767
f54498b4
NC		 4768 if (do_segments)
4769 putc ('\n', stdout);
4770
252b5132
RH		 4771 switch (segment->p_type)
4772 {
252b5132
RH		 4773 case PT_DYNAMIC:
4774 if (dynamic_addr)
4775 error (_("more than one dynamic segment\n"));
4776
20737c13
AM		 4777 /* By default, assume that the .dynamic section is the first
4778 section in the DYNAMIC segment. */
4779 dynamic_addr = segment->p_offset;
4780 dynamic_size = segment->p_filesz;
f54498b4
NC		 4781 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4782 if (dynamic_addr + dynamic_size >= current_file_size)
4783 {
4784 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4785 dynamic_addr = dynamic_size = 0;
4786 }
20737c13 4787
b2d38a17
NC		 4788 /* Try to locate the .dynamic section. If there is
4789 a section header table, we can easily locate it. */
4790 if (section_headers != NULL)
4791 {
2cf0635d 4792 Elf_Internal_Shdr * sec;
b2d38a17 4793
89fac5e3
RS		 4794 sec = find_section (".dynamic");
4795 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4796 {
28f997cf
TG		 4797 /* A corresponding .dynamic section is expected, but on
4798 IA-64/OpenVMS it is OK for it to be missing. */
4799 if (!is_ia64_vms ())
4800 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4801 break;
4802 }
4803
42bb2e33 4804 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4805 {
4806 dynamic_size = 0;
4807 break;
4808 }
42bb2e33 4809
b2d38a17
NC		 4810 dynamic_addr = sec->sh_offset;
4811 dynamic_size = sec->sh_size;
4812
4813 if (dynamic_addr < segment->p_offset
4814 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4815 warn (_("the .dynamic section is not contained"
4816 " within the dynamic segment\n"));
b2d38a17 4817 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4818 warn (_("the .dynamic section is not the first section"
4819 " in the dynamic segment.\n"));
b2d38a17 4820 }
252b5132
RH		 4821 break;
4822
4823 case PT_INTERP:
fb52b2f4
NC		 4824 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4825 SEEK_SET))
252b5132
RH		 4826 error (_("Unable to find program interpreter name\n"));
4827 else
4828 {
f8eae8b2 4829 char fmt [32];
9495b2e6 4830 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4831
4832 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4833 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4834
252b5132 4835 program_interpreter[0] = 0;
7bd7b3ef
AM		 4836 if (fscanf (file, fmt, program_interpreter) <= 0)
4837 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4838
4839 if (do_segments)
f54498b4 4840 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4841 program_interpreter);
4842 }
4843 break;
4844 }
252b5132
RH		 4845 }
4846
c256ffe7 4847 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4848 {
4849 printf (_("\n Section to Segment mapping:\n"));
4850 printf (_(" Segment Sections...\n"));
4851
252b5132
RH		 4852 for (i = 0; i < elf_header.e_phnum; i++)
4853 {
9ad5cbcf 4854 unsigned int j;
2cf0635d 4855 Elf_Internal_Shdr * section;
252b5132
RH		 4856
4857 segment = program_headers + i;
b391a3e3 4858 section = section_headers + 1;
252b5132
RH		 4859
4860 printf (" %2.2d ", i);
4861
b34976b6 4862 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4863 {
f4638467
AM		 4864 if (!ELF_TBSS_SPECIAL (section, segment)
4865 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4866 printf ("%s ", printable_section_name (section));
252b5132
RH		 4867 }
4868
4869 putc ('\n',stdout);
4870 }
4871 }
4872
252b5132
RH		 4873 return 1;
4874}
4875
4876
d93f0186
NC		 4877/* Find the file offset corresponding to VMA by using the program headers. */
4878
4879static long
2cf0635d 4880offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4881{
2cf0635d 4882 Elf_Internal_Phdr * seg;
d93f0186
NC		 4883
4884 if (! get_program_headers (file))
4885 {
4886 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4887 return (long) vma;
4888 }
4889
4890 for (seg = program_headers;
4891 seg < program_headers + elf_header.e_phnum;
4892 ++seg)
4893 {
4894 if (seg->p_type != PT_LOAD)
4895 continue;
4896
4897 if (vma >= (seg->p_vaddr & -seg->p_align)
4898 && vma + size <= seg->p_vaddr + seg->p_filesz)
4899 return vma - seg->p_vaddr + seg->p_offset;
4900 }
4901
4902 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4903 (unsigned long) vma);
d93f0186
NC		 4904 return (long) vma;
4905}
4906
4907
049b0c3a
NC		 4908/* Allocate memory and load the sections headers into the global pointer
4909 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4910 generate any error messages if the load fails. */
4911
4912static bfd_boolean
4913get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4914{
2cf0635d
NC		 4915 Elf32_External_Shdr * shdrs;
4916 Elf_Internal_Shdr * internal;
b34976b6 4917 unsigned int i;
049b0c3a
NC		 4918 unsigned int size = elf_header.e_shentsize;
4919 unsigned int num = probe ? 1 : elf_header.e_shnum;
4920
4921 /* PR binutils/17531: Cope with unexpected section header sizes. */
4922 if (size == 0 || num == 0)
4923 return FALSE;
4924 if (size < sizeof * shdrs)
4925 {
4926 if (! probe)
4927 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4928 return FALSE;
4929 }
4930 if (!probe && size > sizeof * shdrs)
4931 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4932
3f5e193b 4933 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4934 size, num,
4935 probe ? NULL : _("section headers"));
4936 if (shdrs == NULL)
4937 return FALSE;
252b5132 4938
049b0c3a
NC		 4939 if (section_headers != NULL)
4940 free (section_headers);
3f5e193b
NC		 4941 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4942 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4943 if (section_headers == NULL)
4944 {
049b0c3a 4945 if (!probe)
8b73c356 4946 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4947 return FALSE;
252b5132
RH		 4948 }
4949
4950 for (i = 0, internal = section_headers;
560f3c1c 4951 i < num;
b34976b6 4952 i++, internal++)
252b5132
RH		 4953 {
4954 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4955 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4956 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4957 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4958 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4959 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4960 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4961 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4962 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4963 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4964 }
4965
4966 free (shdrs);
049b0c3a 4967 return TRUE;
252b5132
RH		 4968}
4969
049b0c3a
NC		 4970static bfd_boolean
4971get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4972{
2cf0635d
NC		 4973 Elf64_External_Shdr * shdrs;
4974 Elf_Internal_Shdr * internal;
b34976b6 4975 unsigned int i;
049b0c3a
NC		 4976 unsigned int size = elf_header.e_shentsize;
4977 unsigned int num = probe ? 1 : elf_header.e_shnum;
4978
4979 /* PR binutils/17531: Cope with unexpected section header sizes. */
4980 if (size == 0 || num == 0)
4981 return FALSE;
4982 if (size < sizeof * shdrs)
4983 {
4984 if (! probe)
4985 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4986 return FALSE;
4987 }
4988 if (! probe && size > sizeof * shdrs)
4989 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4990
3f5e193b 4991 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4992 size, num,
4993 probe ? NULL : _("section headers"));
4994 if (shdrs == NULL)
4995 return FALSE;
9ea033b2 4996
049b0c3a
NC		 4997 if (section_headers != NULL)
4998 free (section_headers);
3f5e193b
NC		 4999 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5000 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 5001 if (section_headers == NULL)
5002 {
049b0c3a 5003 if (! probe)
8b73c356 5004 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5005 return FALSE;
9ea033b2
NC		 5006 }
5007
5008 for (i = 0, internal = section_headers;
560f3c1c 5009 i < num;
b34976b6 5010 i++, internal++)
9ea033b2
NC		 5011 {
5012 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5013 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 5014 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5015 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5016 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5017 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 5018 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5019 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5020 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5021 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5022 }
5023
5024 free (shdrs);
049b0c3a 5025 return TRUE;
9ea033b2
NC		 5026}
5027
252b5132 5028static Elf_Internal_Sym *
ba5cdace
NC		 5029get_32bit_elf_symbols (FILE * file,
5030 Elf_Internal_Shdr * section,
5031 unsigned long * num_syms_return)
252b5132 5032{
ba5cdace 5033 unsigned long number = 0;
dd24e3da 5034 Elf32_External_Sym * esyms = NULL;
ba5cdace 5035 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5036 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5037 Elf_Internal_Sym * psym;
b34976b6 5038 unsigned int j;
252b5132 5039
c9c1d674
EG		 5040 if (section->sh_size == 0)
5041 {
5042 if (num_syms_return != NULL)
5043 * num_syms_return = 0;
5044 return NULL;
5045 }
5046
dd24e3da 5047 /* Run some sanity checks first. */
c9c1d674 5048 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5049 {
c9c1d674
EG		 5050 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5051 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5052 goto exit_point;
dd24e3da
NC		 5053 }
5054
f54498b4
NC		 5055 if (section->sh_size > current_file_size)
5056 {
5057 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5058 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5059 goto exit_point;
5060 }
5061
dd24e3da
NC		 5062 number = section->sh_size / section->sh_entsize;
5063
5064 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5065 {
c9c1d674 5066 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5067 (unsigned long) section->sh_size,
5068 printable_section_name (section),
5069 (unsigned long) section->sh_entsize);
ba5cdace 5070 goto exit_point;
dd24e3da
NC		 5071 }
5072
3f5e193b
NC		 5073 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5074 section->sh_size, _("symbols"));
dd24e3da 5075 if (esyms == NULL)
ba5cdace 5076 goto exit_point;
252b5132 5077
6a40cf0c
NC		 5078 {
5079 elf_section_list * entry;
5080
5081 shndx = NULL;
5082 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5083 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5084 {
6a40cf0c
NC		 5085 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5086 entry->hdr->sh_offset,
5087 1, entry->hdr->sh_size,
5088 _("symbol table section indicies"));
5089 if (shndx == NULL)
5090 goto exit_point;
5091 /* PR17531: file: heap-buffer-overflow */
5092 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5093 {
5094 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5095 printable_section_name (entry->hdr),
5096 (unsigned long) entry->hdr->sh_size,
5097 (unsigned long) section->sh_size);
5098 goto exit_point;
5099 }
c9c1d674 5100 }
6a40cf0c 5101 }
9ad5cbcf 5102
3f5e193b 5103 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5104
5105 if (isyms == NULL)
5106 {
8b73c356
NC		 5107 error (_("Out of memory reading %lu symbols\n"),
5108 (unsigned long) number);
dd24e3da 5109 goto exit_point;
252b5132
RH		 5110 }
5111
dd24e3da 5112 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5113 {
5114 psym->st_name = BYTE_GET (esyms[j].st_name);
5115 psym->st_value = BYTE_GET (esyms[j].st_value);
5116 psym->st_size = BYTE_GET (esyms[j].st_size);
5117 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5118 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5119 psym->st_shndx
5120 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5121 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5122 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5123 psym->st_info = BYTE_GET (esyms[j].st_info);
5124 psym->st_other = BYTE_GET (esyms[j].st_other);
5125 }
5126
dd24e3da 5127 exit_point:
ba5cdace 5128 if (shndx != NULL)
9ad5cbcf 5129 free (shndx);
ba5cdace 5130 if (esyms != NULL)
dd24e3da 5131 free (esyms);
252b5132 5132
ba5cdace
NC		 5133 if (num_syms_return != NULL)
5134 * num_syms_return = isyms == NULL ? 0 : number;
5135
252b5132
RH		 5136 return isyms;
5137}
5138
9ea033b2 5139static Elf_Internal_Sym *
ba5cdace
NC		 5140get_64bit_elf_symbols (FILE * file,
5141 Elf_Internal_Shdr * section,
5142 unsigned long * num_syms_return)
9ea033b2 5143{
ba5cdace
NC		 5144 unsigned long number = 0;
5145 Elf64_External_Sym * esyms = NULL;
5146 Elf_External_Sym_Shndx * shndx = NULL;
5147 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5148 Elf_Internal_Sym * psym;
b34976b6 5149 unsigned int j;
9ea033b2 5150
c9c1d674
EG		 5151 if (section->sh_size == 0)
5152 {
5153 if (num_syms_return != NULL)
5154 * num_syms_return = 0;
5155 return NULL;
5156 }
5157
dd24e3da 5158 /* Run some sanity checks first. */
c9c1d674 5159 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5160 {
c9c1d674 5161 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5162 printable_section_name (section),
5163 (unsigned long) section->sh_entsize);
ba5cdace 5164 goto exit_point;
dd24e3da
NC		 5165 }
5166
f54498b4
NC		 5167 if (section->sh_size > current_file_size)
5168 {
5169 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5170 printable_section_name (section),
5171 (unsigned long) section->sh_size);
f54498b4
NC		 5172 goto exit_point;
5173 }
5174
dd24e3da
NC		 5175 number = section->sh_size / section->sh_entsize;
5176
5177 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5178 {
c9c1d674 5179 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5180 (unsigned long) section->sh_size,
5181 printable_section_name (section),
5182 (unsigned long) section->sh_entsize);
ba5cdace 5183 goto exit_point;
dd24e3da
NC		 5184 }
5185
3f5e193b
NC		 5186 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5187 section->sh_size, _("symbols"));
a6e9f9df 5188 if (!esyms)
ba5cdace 5189 goto exit_point;
9ea033b2 5190
6a40cf0c
NC		 5191 {
5192 elf_section_list * entry;
5193
5194 shndx = NULL;
5195 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5196 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5197 {
6a40cf0c
NC		 5198 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5199 entry->hdr->sh_offset,
5200 1, entry->hdr->sh_size,
5201 _("symbol table section indicies"));
5202 if (shndx == NULL)
5203 goto exit_point;
5204 /* PR17531: file: heap-buffer-overflow */
5205 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5206 {
5207 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5208 printable_section_name (entry->hdr),
5209 (unsigned long) entry->hdr->sh_size,
5210 (unsigned long) section->sh_size);
5211 goto exit_point;
5212 }
c9c1d674 5213 }
6a40cf0c 5214 }
9ad5cbcf 5215
3f5e193b 5216 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5217
5218 if (isyms == NULL)
5219 {
8b73c356
NC		 5220 error (_("Out of memory reading %lu symbols\n"),
5221 (unsigned long) number);
ba5cdace 5222 goto exit_point;
9ea033b2
NC		 5223 }
5224
ba5cdace 5225 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5226 {
5227 psym->st_name = BYTE_GET (esyms[j].st_name);
5228 psym->st_info = BYTE_GET (esyms[j].st_info);
5229 psym->st_other = BYTE_GET (esyms[j].st_other);
5230 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5231
4fbb74a6 5232 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5233 psym->st_shndx
5234 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5235 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5236 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5237
66543521
AM		 5238 psym->st_value = BYTE_GET (esyms[j].st_value);
5239 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5240 }
5241
ba5cdace
NC		 5242 exit_point:
5243 if (shndx != NULL)
9ad5cbcf 5244 free (shndx);
ba5cdace
NC		 5245 if (esyms != NULL)
5246 free (esyms);
5247
5248 if (num_syms_return != NULL)
5249 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5250
5251 return isyms;
5252}
5253
d1133906 5254static const char *
d3ba0551 5255get_elf_section_flags (bfd_vma sh_flags)
d1133906 5256{
5477e8a0 5257 static char buff[1024];
2cf0635d 5258 char * p = buff;
8d5ff12c 5259 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5260 int sindex;
5261 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5262 bfd_vma os_flags = 0;
5263 bfd_vma proc_flags = 0;
5264 bfd_vma unknown_flags = 0;
148b93f2 5265 static const struct
5477e8a0 5266 {
2cf0635d 5267 const char * str;
5477e8a0
L		 5268 int len;
5269 }
5270 flags [] =
5271 {
cfcac11d
NC		 5272 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5273 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5274 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5275 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5276 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5277 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5278 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5279 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5280 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5281 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5282 /* IA-64 specific. */
5283 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5284 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5285 /* IA-64 OpenVMS specific. */
5286 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5287 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5288 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5289 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5290 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5291 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5292 /* Generic. */
cfcac11d 5293 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5294 /* SPARC specific. */
77115a4a 5295 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
ac4c9b04
MG		 5296 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5297 /* ARM specific. */
5298 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5299 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5300 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5477e8a0
L		 5301 };
5302
5303 if (do_section_details)
5304 {
8d5ff12c
L		 5305 sprintf (buff, "[%*.*lx]: ",
5306 field_size, field_size, (unsigned long) sh_flags);
5307 p += field_size + 4;
5477e8a0 5308 }
76da6bbe 5309
d1133906
NC		 5310 while (sh_flags)
5311 {
5312 bfd_vma flag;
5313
5314 flag = sh_flags & - sh_flags;
5315 sh_flags &= ~ flag;
76da6bbe 5316
5477e8a0 5317 if (do_section_details)
d1133906 5318 {
5477e8a0
L		 5319 switch (flag)
5320 {
91d6fa6a
NC		 5321 case SHF_WRITE: sindex = 0; break;
5322 case SHF_ALLOC: sindex = 1; break;
5323 case SHF_EXECINSTR: sindex = 2; break;
5324 case SHF_MERGE: sindex = 3; break;
5325 case SHF_STRINGS: sindex = 4; break;
5326 case SHF_INFO_LINK: sindex = 5; break;
5327 case SHF_LINK_ORDER: sindex = 6; break;
5328 case SHF_OS_NONCONFORMING: sindex = 7; break;
5329 case SHF_GROUP: sindex = 8; break;
5330 case SHF_TLS: sindex = 9; break;
18ae9cc1 5331 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5332 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5333
5477e8a0 5334 default:
91d6fa6a 5335 sindex = -1;
cfcac11d 5336 switch (elf_header.e_machine)
148b93f2 5337 {
cfcac11d 5338 case EM_IA_64:
148b93f2 5339 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5340 sindex = 10;
148b93f2 5341 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5342 sindex = 11;
148b93f2
NC		 5343#ifdef BFD64
5344 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5345 switch (flag)
5346 {
91d6fa6a
NC		 5347 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5348 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5349 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5350 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5351 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5352 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5353 default: break;
5354 }
5355#endif
cfcac11d
NC		 5356 break;
5357
caa83f8b 5358 case EM_386:
22abe556 5359 case EM_IAMCU:
caa83f8b 5360 case EM_X86_64:
7f502d6c 5361 case EM_L1OM:
7a9068fe 5362 case EM_K1OM:
cfcac11d
NC		 5363 case EM_OLD_SPARCV9:
5364 case EM_SPARC32PLUS:
5365 case EM_SPARCV9:
5366 case EM_SPARC:
18ae9cc1 5367 if (flag == SHF_ORDERED)
91d6fa6a 5368 sindex = 19;
cfcac11d 5369 break;
ac4c9b04
MG		 5370
5371 case EM_ARM:
5372 switch (flag)
5373 {
5374 case SHF_ENTRYSECT: sindex = 21; break;
5375 case SHF_ARM_NOREAD: sindex = 22; break;
5376 case SHF_COMDEF: sindex = 23; break;
5377 default: break;
5378 }
5379 break;
5380
cfcac11d
NC		 5381 default:
5382 break;
148b93f2 5383 }
5477e8a0
L		 5384 }
5385
91d6fa6a 5386 if (sindex != -1)
5477e8a0 5387 {
8d5ff12c
L		 5388 if (p != buff + field_size + 4)
5389 {
5390 if (size < (10 + 2))
bee0ee85
NC		 5391 {
5392 warn (_("Internal error: not enough buffer room for section flag info"));
5393 return _("<unknown>");
5394 }
8d5ff12c
L		 5395 size -= 2;
5396 *p++ = ',';
5397 *p++ = ' ';
5398 }
5399
91d6fa6a
NC		 5400 size -= flags [sindex].len;
5401 p = stpcpy (p, flags [sindex].str);
5477e8a0 5402 }
3b22753a 5403 else if (flag & SHF_MASKOS)
8d5ff12c 5404 os_flags |= flag;
d1133906 5405 else if (flag & SHF_MASKPROC)
8d5ff12c 5406 proc_flags |= flag;
d1133906 5407 else
8d5ff12c 5408 unknown_flags |= flag;
5477e8a0
L		 5409 }
5410 else
5411 {
5412 switch (flag)
5413 {
5414 case SHF_WRITE: *p = 'W'; break;
5415 case SHF_ALLOC: *p = 'A'; break;
5416 case SHF_EXECINSTR: *p = 'X'; break;
5417 case SHF_MERGE: *p = 'M'; break;
5418 case SHF_STRINGS: *p = 'S'; break;
5419 case SHF_INFO_LINK: *p = 'I'; break;
5420 case SHF_LINK_ORDER: *p = 'L'; break;
5421 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5422 case SHF_GROUP: *p = 'G'; break;
5423 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5424 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5425 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5426
5427 default:
8a9036a4 5428 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5429 || elf_header.e_machine == EM_L1OM
5430 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5431 && flag == SHF_X86_64_LARGE)
5432 *p = 'l';
91f68a68
MG		 5433 else if (elf_header.e_machine == EM_ARM
5434 && flag == SHF_ARM_NOREAD)
5435 *p = 'y';
5477e8a0
L		 5436 else if (flag & SHF_MASKOS)
5437 {
5438 *p = 'o';
5439 sh_flags &= ~ SHF_MASKOS;
5440 }
5441 else if (flag & SHF_MASKPROC)
5442 {
5443 *p = 'p';
5444 sh_flags &= ~ SHF_MASKPROC;
5445 }
5446 else
5447 *p = 'x';
5448 break;
5449 }
5450 p++;
d1133906
NC		 5451 }
5452 }
76da6bbe 5453
8d5ff12c
L		 5454 if (do_section_details)
5455 {
5456 if (os_flags)
5457 {
5458 size -= 5 + field_size;
5459 if (p != buff + field_size + 4)
5460 {
5461 if (size < (2 + 1))
bee0ee85
NC		 5462 {
5463 warn (_("Internal error: not enough buffer room for section flag info"));
5464 return _("<unknown>");
5465 }
8d5ff12c
L		 5466 size -= 2;
5467 *p++ = ',';
5468 *p++ = ' ';
5469 }
5470 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5471 (unsigned long) os_flags);
5472 p += 5 + field_size;
5473 }
5474 if (proc_flags)
5475 {
5476 size -= 7 + field_size;
5477 if (p != buff + field_size + 4)
5478 {
5479 if (size < (2 + 1))
bee0ee85
NC		 5480 {
5481 warn (_("Internal error: not enough buffer room for section flag info"));
5482 return _("<unknown>");
5483 }
8d5ff12c
L		 5484 size -= 2;
5485 *p++ = ',';
5486 *p++ = ' ';
5487 }
5488 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5489 (unsigned long) proc_flags);
5490 p += 7 + field_size;
5491 }
5492 if (unknown_flags)
5493 {
5494 size -= 10 + field_size;
5495 if (p != buff + field_size + 4)
5496 {
5497 if (size < (2 + 1))
bee0ee85
NC		 5498 {
5499 warn (_("Internal error: not enough buffer room for section flag info"));
5500 return _("<unknown>");
5501 }
8d5ff12c
L		 5502 size -= 2;
5503 *p++ = ',';
5504 *p++ = ' ';
5505 }
2b692964 5506 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5507 (unsigned long) unknown_flags);
5508 p += 10 + field_size;
5509 }
5510 }
5511
e9e44622 5512 *p = '\0';
d1133906
NC		 5513 return buff;
5514}
5515
77115a4a
L		 5516static unsigned int
5517get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5518{
5519 if (is_32bit_elf)
5520 {
5521 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5522 chdr->ch_type = BYTE_GET (echdr->ch_type);
5523 chdr->ch_size = BYTE_GET (echdr->ch_size);
5524 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5525 return sizeof (*echdr);
5526 }
5527 else
5528 {
5529 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5530 chdr->ch_type = BYTE_GET (echdr->ch_type);
5531 chdr->ch_size = BYTE_GET (echdr->ch_size);
5532 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5533 return sizeof (*echdr);
5534 }
5535}
5536
252b5132 5537static int
2cf0635d 5538process_section_headers (FILE * file)
252b5132 5539{
2cf0635d 5540 Elf_Internal_Shdr * section;
b34976b6 5541 unsigned int i;
252b5132
RH		 5542
5543 section_headers = NULL;
5544
5545 if (elf_header.e_shnum == 0)
5546 {
82f2dbf7
NC		 5547 /* PR binutils/12467. */
5548 if (elf_header.e_shoff != 0)
5549 warn (_("possibly corrupt ELF file header - it has a non-zero"
5550 " section header offset, but no section headers\n"));
5551 else if (do_sections)
252b5132
RH		 5552 printf (_("\nThere are no sections in this file.\n"));
5553
5554 return 1;
5555 }
5556
5557 if (do_sections && !do_header)
9ea033b2 5558 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5559 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5560
9ea033b2
NC		 5561 if (is_32bit_elf)
5562 {
049b0c3a 5563 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5564 return 0;
5565 }
049b0c3a 5566 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5567 return 0;
5568
5569 /* Read in the string table, so that we have names to display. */
0b49d371 5570 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5571 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5572 {
4fbb74a6 5573 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5574
c256ffe7
JJ		 5575 if (section->sh_size != 0)
5576 {
3f5e193b
NC		 5577 string_table = (char *) get_data (NULL, file, section->sh_offset,
5578 1, section->sh_size,
5579 _("string table"));
0de14b54 5580
c256ffe7
JJ		 5581 string_table_length = string_table != NULL ? section->sh_size : 0;
5582 }
252b5132
RH		 5583 }
5584
5585 /* Scan the sections for the dynamic symbol table
e3c8793a 5586 and dynamic string table and debug sections. */
252b5132
RH		 5587 dynamic_symbols = NULL;
5588 dynamic_strings = NULL;
5589 dynamic_syminfo = NULL;
6a40cf0c 5590 symtab_shndx_list = NULL;
103f02d3 5591
89fac5e3
RS		 5592 eh_addr_size = is_32bit_elf ? 4 : 8;
5593 switch (elf_header.e_machine)
5594 {
5595 case EM_MIPS:
5596 case EM_MIPS_RS3_LE:
5597 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5598 FDE addresses. However, the ABI also has a semi-official ILP32
5599 variant for which the normal FDE address size rules apply.
5600
5601 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5602 section, where XX is the size of longs in bits. Unfortunately,
5603 earlier compilers provided no way of distinguishing ILP32 objects
5604 from LP64 objects, so if there's any doubt, we should assume that
5605 the official LP64 form is being used. */
5606 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5607 && find_section (".gcc_compiled_long32") == NULL)
5608 eh_addr_size = 8;
5609 break;
0f56a26a
DD		 5610
5611 case EM_H8_300:
5612 case EM_H8_300H:
5613 switch (elf_header.e_flags & EF_H8_MACH)
5614 {
5615 case E_H8_MACH_H8300:
5616 case E_H8_MACH_H8300HN:
5617 case E_H8_MACH_H8300SN:
5618 case E_H8_MACH_H8300SXN:
5619 eh_addr_size = 2;
5620 break;
5621 case E_H8_MACH_H8300H:
5622 case E_H8_MACH_H8300S:
5623 case E_H8_MACH_H8300SX:
5624 eh_addr_size = 4;
5625 break;
5626 }
f4236fe4
DD		 5627 break;
5628
ff7eeb89 5629 case EM_M32C_OLD:
f4236fe4
DD		 5630 case EM_M32C:
5631 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5632 {
5633 case EF_M32C_CPU_M16C:
5634 eh_addr_size = 2;
5635 break;
5636 }
5637 break;
89fac5e3
RS		 5638 }
5639
76ca31c0
NC		 5640#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5641 do \
5642 { \
5643 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5644 if (section->sh_entsize != expected_entsize) \
9dd3a467 5645 { \
76ca31c0
NC		 5646 char buf[40]; \
5647 sprintf_vma (buf, section->sh_entsize); \
5648 /* Note: coded this way so that there is a single string for \
5649 translation. */ \
5650 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5651 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5652 (unsigned) expected_entsize); \
9dd3a467 5653 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5654 } \
5655 } \
08d8fa11 5656 while (0)
9dd3a467
NC		 5657
5658#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5659 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5660 sizeof (Elf64_External_##type))
5661
252b5132
RH		 5662 for (i = 0, section = section_headers;
5663 i < elf_header.e_shnum;
b34976b6 5664 i++, section++)
252b5132 5665 {
2cf0635d 5666 char * name = SECTION_NAME (section);
252b5132
RH		 5667
5668 if (section->sh_type == SHT_DYNSYM)
5669 {
5670 if (dynamic_symbols != NULL)
5671 {
5672 error (_("File contains multiple dynamic symbol tables\n"));
5673 continue;
5674 }
5675
08d8fa11 5676 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5677 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5678 }
5679 else if (section->sh_type == SHT_STRTAB
18bd398b 5680 && streq (name, ".dynstr"))
252b5132
RH		 5681 {
5682 if (dynamic_strings != NULL)
5683 {
5684 error (_("File contains multiple dynamic string tables\n"));
5685 continue;
5686 }
5687
3f5e193b
NC		 5688 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5689 1, section->sh_size,
5690 _("dynamic strings"));
59245841 5691 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5692 }
9ad5cbcf
AM		 5693 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5694 {
6a40cf0c
NC		 5695 elf_section_list * entry = xmalloc (sizeof * entry);
5696 entry->hdr = section;
5697 entry->next = symtab_shndx_list;
5698 symtab_shndx_list = entry;
9ad5cbcf 5699 }
08d8fa11
JJ		 5700 else if (section->sh_type == SHT_SYMTAB)
5701 CHECK_ENTSIZE (section, i, Sym);
5702 else if (section->sh_type == SHT_GROUP)
5703 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5704 else if (section->sh_type == SHT_REL)
5705 CHECK_ENTSIZE (section, i, Rel);
5706 else if (section->sh_type == SHT_RELA)
5707 CHECK_ENTSIZE (section, i, Rela);
252b5132 5708 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5709 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5710 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5711 || do_debug_str || do_debug_loc || do_debug_ranges
5712 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5713 && (const_strneq (name, ".debug_")
5714 || const_strneq (name, ".zdebug_")))
252b5132 5715 {
1b315056
CS		 5716 if (name[1] == 'z')
5717 name += sizeof (".zdebug_") - 1;
5718 else
5719 name += sizeof (".debug_") - 1;
252b5132
RH		 5720
5721 if (do_debugging
4723351a
CC		 5722 || (do_debug_info && const_strneq (name, "info"))
5723 || (do_debug_info && const_strneq (name, "types"))
5724 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5725 || (do_debug_lines && strcmp (name, "line") == 0)
5726 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5727 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5728 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5729 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5730 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5731 || (do_debug_aranges && const_strneq (name, "aranges"))
5732 || (do_debug_ranges && const_strneq (name, "ranges"))
5733 || (do_debug_frames && const_strneq (name, "frame"))
5734 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5735 || (do_debug_macinfo && const_strneq (name, "macro"))
5736 || (do_debug_str && const_strneq (name, "str"))
5737 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5738 || (do_debug_addr && const_strneq (name, "addr"))
5739 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5740 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5741 )
09c11c86 5742 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5743 }
a262ae96 5744 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5745 else if ((do_debugging || do_debug_info)
0112cd26 5746 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5747 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5748 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5749 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5750 else if (do_gdb_index && streq (name, ".gdb_index"))
5751 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5752 /* Trace sections for Itanium VMS. */
5753 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5754 || do_trace_aranges)
5755 && const_strneq (name, ".trace_"))
5756 {
5757 name += sizeof (".trace_") - 1;
5758
5759 if (do_debugging
5760 || (do_trace_info && streq (name, "info"))
5761 || (do_trace_abbrevs && streq (name, "abbrev"))
5762 || (do_trace_aranges && streq (name, "aranges"))
5763 )
5764 request_dump_bynumber (i, DEBUG_DUMP);
5765 }
252b5132
RH		 5766 }
5767
5768 if (! do_sections)
5769 return 1;
5770
3a1a2036
NC		 5771 if (elf_header.e_shnum > 1)
5772 printf (_("\nSection Headers:\n"));
5773 else
5774 printf (_("\nSection Header:\n"));
76da6bbe 5775
f7a99963 5776 if (is_32bit_elf)
595cf52e 5777 {
5477e8a0 5778 if (do_section_details)
595cf52e
L		 5779 {
5780 printf (_(" [Nr] Name\n"));
5477e8a0 5781 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5782 }
5783 else
5784 printf
5785 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5786 }
d974e256 5787 else if (do_wide)
595cf52e 5788 {
5477e8a0 5789 if (do_section_details)
595cf52e
L		 5790 {
5791 printf (_(" [Nr] Name\n"));
5477e8a0 5792 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5793 }
5794 else
5795 printf
5796 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5797 }
f7a99963
NC		 5798 else
5799 {
5477e8a0 5800 if (do_section_details)
595cf52e
L		 5801 {
5802 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5803 printf (_(" Type Address Offset Link\n"));
5804 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5805 }
5806 else
5807 {
5808 printf (_(" [Nr] Name Type Address Offset\n"));
5809 printf (_(" Size EntSize Flags Link Info Align\n"));
5810 }
f7a99963 5811 }
252b5132 5812
5477e8a0
L		 5813 if (do_section_details)
5814 printf (_(" Flags\n"));
5815
252b5132
RH		 5816 for (i = 0, section = section_headers;
5817 i < elf_header.e_shnum;
b34976b6 5818 i++, section++)
252b5132 5819 {
7bfd842d 5820 printf (" [%2u] ", i);
5477e8a0 5821 if (do_section_details)
74e1a04b 5822 printf ("%s\n ", printable_section_name (section));
595cf52e 5823 else
74e1a04b 5824 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5825
ea52a088
NC		 5826 printf (do_wide ? " %-15s " : " %-15.15s ",
5827 get_section_type_name (section->sh_type));
0b4362b0 5828
f7a99963
NC		 5829 if (is_32bit_elf)
5830 {
cfcac11d
NC		 5831 const char * link_too_big = NULL;
5832
f7a99963 5833 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5834
f7a99963
NC		 5835 printf ( " %6.6lx %6.6lx %2.2lx",
5836 (unsigned long) section->sh_offset,
5837 (unsigned long) section->sh_size,
5838 (unsigned long) section->sh_entsize);
d1133906 5839
5477e8a0
L		 5840 if (do_section_details)
5841 fputs (" ", stdout);
5842 else
5843 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5844
cfcac11d
NC		 5845 if (section->sh_link >= elf_header.e_shnum)
5846 {
5847 link_too_big = "";
5848 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5849 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5850 switch (elf_header.e_machine)
5851 {
caa83f8b 5852 case EM_386:
22abe556 5853 case EM_IAMCU:
caa83f8b 5854 case EM_X86_64:
7f502d6c 5855 case EM_L1OM:
7a9068fe 5856 case EM_K1OM:
cfcac11d
NC		 5857 case EM_OLD_SPARCV9:
5858 case EM_SPARC32PLUS:
5859 case EM_SPARCV9:
5860 case EM_SPARC:
5861 if (section->sh_link == (SHN_BEFORE & 0xffff))
5862 link_too_big = "BEFORE";
5863 else if (section->sh_link == (SHN_AFTER & 0xffff))
5864 link_too_big = "AFTER";
5865 break;
5866 default:
5867 break;
5868 }
5869 }
5870
5871 if (do_section_details)
5872 {
5873 if (link_too_big != NULL && * link_too_big)
5874 printf ("<%s> ", link_too_big);
5875 else
5876 printf ("%2u ", section->sh_link);
5877 printf ("%3u %2lu\n", section->sh_info,
5878 (unsigned long) section->sh_addralign);
5879 }
5880 else
5881 printf ("%2u %3u %2lu\n",
5882 section->sh_link,
5883 section->sh_info,
5884 (unsigned long) section->sh_addralign);
5885
5886 if (link_too_big && ! * link_too_big)
5887 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5888 i, section->sh_link);
f7a99963 5889 }
d974e256
JJ		 5890 else if (do_wide)
5891 {
5892 print_vma (section->sh_addr, LONG_HEX);
5893
5894 if ((long) section->sh_offset == section->sh_offset)
5895 printf (" %6.6lx", (unsigned long) section->sh_offset);
5896 else
5897 {
5898 putchar (' ');
5899 print_vma (section->sh_offset, LONG_HEX);
5900 }
5901
5902 if ((unsigned long) section->sh_size == section->sh_size)
5903 printf (" %6.6lx", (unsigned long) section->sh_size);
5904 else
5905 {
5906 putchar (' ');
5907 print_vma (section->sh_size, LONG_HEX);
5908 }
5909
5910 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5911 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5912 else
5913 {
5914 putchar (' ');
5915 print_vma (section->sh_entsize, LONG_HEX);
5916 }
5917
5477e8a0
L		 5918 if (do_section_details)
5919 fputs (" ", stdout);
5920 else
5921 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5922
72de5009 5923 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5924
5925 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5926 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5927 else
5928 {
5929 print_vma (section->sh_addralign, DEC);
5930 putchar ('\n');
5931 }
5932 }
5477e8a0 5933 else if (do_section_details)
595cf52e 5934 {
5477e8a0 5935 printf (" %-15.15s ",
595cf52e 5936 get_section_type_name (section->sh_type));
595cf52e
L		 5937 print_vma (section->sh_addr, LONG_HEX);
5938 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5939 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5940 else
5941 {
5942 printf (" ");
5943 print_vma (section->sh_offset, LONG_HEX);
5944 }
72de5009 5945 printf (" %u\n ", section->sh_link);
595cf52e 5946 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5947 putchar (' ');
595cf52e
L		 5948 print_vma (section->sh_entsize, LONG_HEX);
5949
72de5009
AM		 5950 printf (" %-16u %lu\n",
5951 section->sh_info,
595cf52e
L		 5952 (unsigned long) section->sh_addralign);
5953 }
f7a99963
NC		 5954 else
5955 {
5956 putchar (' ');
5957 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5958 if ((long) section->sh_offset == section->sh_offset)
5959 printf (" %8.8lx", (unsigned long) section->sh_offset);
5960 else
5961 {
5962 printf (" ");
5963 print_vma (section->sh_offset, LONG_HEX);
5964 }
f7a99963
NC		 5965 printf ("\n ");
5966 print_vma (section->sh_size, LONG_HEX);
5967 printf (" ");
5968 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5969
d1133906 5970 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5971
72de5009
AM		 5972 printf (" %2u %3u %lu\n",
5973 section->sh_link,
5974 section->sh_info,
f7a99963
NC		 5975 (unsigned long) section->sh_addralign);
5976 }
5477e8a0
L		 5977
5978 if (do_section_details)
77115a4a
L		 5979 {
5980 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5981 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5982 {
5983 /* Minimum section size is 12 bytes for 32-bit compression
5984 header + 12 bytes for compressed data header. */
5985 unsigned char buf[24];
5986 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5987 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5988 sizeof (buf), _("compression header")))
5989 {
5990 Elf_Internal_Chdr chdr;
5991 get_compression_header (&chdr, buf);
5992 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5993 printf (" ZLIB, ");
5994 else
5995 printf (_(" [<unknown>: 0x%x], "),
5996 chdr.ch_type);
5997 print_vma (chdr.ch_size, LONG_HEX);
5998 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5999 }
6000 }
6001 }
252b5132
RH		 6002 }
6003
5477e8a0 6004 if (!do_section_details)
3dbcc61d
NC		 6005 {
6006 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 6007 || elf_header.e_machine == EM_L1OM
6008 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 6009 printf (_("Key to Flags:\n\
6010 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
6011 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
91f68a68
MG		 6012 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
6013 else if (elf_header.e_machine == EM_ARM)
6014 printf (_("Key to Flags:\n\
6015 W (write), A (alloc), X (execute), M (merge), S (strings), y (noread)\n\
6016 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
3dbcc61d
NC		 6017 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
6018 else
6019 printf (_("Key to Flags:\n\
e3c8793a 6020 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 6021 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 6022 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 6023 }
d1133906 6024
252b5132
RH		 6025 return 1;
6026}
6027
f5842774
L		 6028static const char *
6029get_group_flags (unsigned int flags)
6030{
6031 static char buff[32];
6032 switch (flags)
6033 {
220453ec
AM		 6034 case 0:
6035 return "";
6036
f5842774 6037 case GRP_COMDAT:
220453ec 6038 return "COMDAT ";
f5842774
L		 6039
6040 default:
220453ec 6041 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 6042 break;
6043 }
6044 return buff;
6045}
6046
6047static int
2cf0635d 6048process_section_groups (FILE * file)
f5842774 6049{
2cf0635d 6050 Elf_Internal_Shdr * section;
f5842774 6051 unsigned int i;
2cf0635d
NC		 6052 struct group * group;
6053 Elf_Internal_Shdr * symtab_sec;
6054 Elf_Internal_Shdr * strtab_sec;
6055 Elf_Internal_Sym * symtab;
ba5cdace 6056 unsigned long num_syms;
2cf0635d 6057 char * strtab;
c256ffe7 6058 size_t strtab_size;
d1f5c6e3
L		 6059
6060 /* Don't process section groups unless needed. */
6061 if (!do_unwind && !do_section_groups)
6062 return 1;
f5842774
L		 6063
6064 if (elf_header.e_shnum == 0)
6065 {
6066 if (do_section_groups)
82f2dbf7 6067 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6068
6069 return 1;
6070 }
6071
6072 if (section_headers == NULL)
6073 {
6074 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6075 /* PR 13622: This can happen with a corrupt ELF header. */
6076 return 0;
f5842774
L		 6077 }
6078
3f5e193b
NC		 6079 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6080 sizeof (struct group *));
e4b17d5c
L		 6081
6082 if (section_headers_groups == NULL)
6083 {
8b73c356
NC		 6084 error (_("Out of memory reading %u section group headers\n"),
6085 elf_header.e_shnum);
e4b17d5c
L		 6086 return 0;
6087 }
6088
f5842774 6089 /* Scan the sections for the group section. */
d1f5c6e3 6090 group_count = 0;
f5842774
L		 6091 for (i = 0, section = section_headers;
6092 i < elf_header.e_shnum;
6093 i++, section++)
e4b17d5c
L		 6094 if (section->sh_type == SHT_GROUP)
6095 group_count++;
6096
d1f5c6e3
L		 6097 if (group_count == 0)
6098 {
6099 if (do_section_groups)
6100 printf (_("\nThere are no section groups in this file.\n"));
6101
6102 return 1;
6103 }
6104
3f5e193b 6105 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6106
6107 if (section_groups == NULL)
6108 {
8b73c356
NC		 6109 error (_("Out of memory reading %lu groups\n"),
6110 (unsigned long) group_count);
e4b17d5c
L		 6111 return 0;
6112 }
6113
d1f5c6e3
L		 6114 symtab_sec = NULL;
6115 strtab_sec = NULL;
6116 symtab = NULL;
ba5cdace 6117 num_syms = 0;
d1f5c6e3 6118 strtab = NULL;
c256ffe7 6119 strtab_size = 0;
e4b17d5c
L		 6120 for (i = 0, section = section_headers, group = section_groups;
6121 i < elf_header.e_shnum;
6122 i++, section++)
f5842774
L		 6123 {
6124 if (section->sh_type == SHT_GROUP)
6125 {
74e1a04b
NC		 6126 const char * name = printable_section_name (section);
6127 const char * group_name;
2cf0635d
NC		 6128 unsigned char * start;
6129 unsigned char * indices;
f5842774 6130 unsigned int entry, j, size;
2cf0635d
NC		 6131 Elf_Internal_Shdr * sec;
6132 Elf_Internal_Sym * sym;
f5842774
L		 6133
6134 /* Get the symbol table. */
4fbb74a6
AM		 6135 if (section->sh_link >= elf_header.e_shnum
6136 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6137 != SHT_SYMTAB))
f5842774
L		 6138 {
6139 error (_("Bad sh_link in group section `%s'\n"), name);
6140 continue;
6141 }
d1f5c6e3
L		 6142
6143 if (symtab_sec != sec)
6144 {
6145 symtab_sec = sec;
6146 if (symtab)
6147 free (symtab);
ba5cdace 6148 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6149 }
f5842774 6150
dd24e3da
NC		 6151 if (symtab == NULL)
6152 {
6153 error (_("Corrupt header in group section `%s'\n"), name);
6154 continue;
6155 }
6156
ba5cdace
NC		 6157 if (section->sh_info >= num_syms)
6158 {
6159 error (_("Bad sh_info in group section `%s'\n"), name);
6160 continue;
6161 }
6162
f5842774
L		 6163 sym = symtab + section->sh_info;
6164
6165 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6166 {
4fbb74a6
AM		 6167 if (sym->st_shndx == 0
6168 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6169 {
6170 error (_("Bad sh_info in group section `%s'\n"), name);
6171 continue;
6172 }
ba2685cc 6173
4fbb74a6 6174 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6175 strtab_sec = NULL;
6176 if (strtab)
6177 free (strtab);
f5842774 6178 strtab = NULL;
c256ffe7 6179 strtab_size = 0;
f5842774
L		 6180 }
6181 else
6182 {
6183 /* Get the string table. */
4fbb74a6 6184 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6185 {
6186 strtab_sec = NULL;
6187 if (strtab)
6188 free (strtab);
6189 strtab = NULL;
6190 strtab_size = 0;
6191 }
6192 else if (strtab_sec
4fbb74a6 6193 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6194 {
6195 strtab_sec = sec;
6196 if (strtab)
6197 free (strtab);
071436c6 6198
3f5e193b 6199 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6200 1, strtab_sec->sh_size,
6201 _("string table"));
c256ffe7 6202 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6203 }
c256ffe7 6204 group_name = sym->st_name < strtab_size
2b692964 6205 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6206 }
6207
c9c1d674
EG		 6208 /* PR 17531: file: loop. */
6209 if (section->sh_entsize > section->sh_size)
6210 {
6211 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6212 printable_section_name (section),
8066deb1
AM		 6213 (unsigned long) section->sh_entsize,
6214 (unsigned long) section->sh_size);
c9c1d674
EG		 6215 break;
6216 }
6217
3f5e193b
NC		 6218 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6219 1, section->sh_size,
6220 _("section data"));
59245841
NC		 6221 if (start == NULL)
6222 continue;
f5842774
L		 6223
6224 indices = start;
6225 size = (section->sh_size / section->sh_entsize) - 1;
6226 entry = byte_get (indices, 4);
6227 indices += 4;
e4b17d5c
L		 6228
6229 if (do_section_groups)
6230 {
2b692964 6231 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6232 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6233
e4b17d5c
L		 6234 printf (_(" [Index] Name\n"));
6235 }
6236
6237 group->group_index = i;
6238
f5842774
L		 6239 for (j = 0; j < size; j++)
6240 {
2cf0635d 6241 struct group_list * g;
e4b17d5c 6242
f5842774
L		 6243 entry = byte_get (indices, 4);
6244 indices += 4;
6245
4fbb74a6 6246 if (entry >= elf_header.e_shnum)
391cb864 6247 {
57028622
NC		 6248 static unsigned num_group_errors = 0;
6249
6250 if (num_group_errors ++ < 10)
6251 {
6252 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6253 entry, i, elf_header.e_shnum - 1);
6254 if (num_group_errors == 10)
6255 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6256 }
391cb864
L		 6257 continue;
6258 }
391cb864 6259
4fbb74a6 6260 if (section_headers_groups [entry] != NULL)
e4b17d5c 6261 {
d1f5c6e3
L		 6262 if (entry)
6263 {
57028622
NC		 6264 static unsigned num_errs = 0;
6265
6266 if (num_errs ++ < 10)
6267 {
6268 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6269 entry, i,
6270 section_headers_groups [entry]->group_index);
6271 if (num_errs == 10)
6272 warn (_("Further error messages about already contained group sections suppressed\n"));
6273 }
d1f5c6e3
L		 6274 continue;
6275 }
6276 else
6277 {
6278 /* Intel C/C++ compiler may put section 0 in a
6279 section group. We just warn it the first time
6280 and ignore it afterwards. */
6281 static int warned = 0;
6282 if (!warned)
6283 {
6284 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6285 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6286 warned++;
6287 }
6288 }
e4b17d5c
L		 6289 }
6290
4fbb74a6 6291 section_headers_groups [entry] = group;
e4b17d5c
L		 6292
6293 if (do_section_groups)
6294 {
4fbb74a6 6295 sec = section_headers + entry;
74e1a04b 6296 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6297 }
6298
3f5e193b 6299 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6300 g->section_index = entry;
6301 g->next = group->root;
6302 group->root = g;
f5842774
L		 6303 }
6304
f5842774
L		 6305 if (start)
6306 free (start);
e4b17d5c
L		 6307
6308 group++;
f5842774
L		 6309 }
6310 }
6311
d1f5c6e3
L		 6312 if (symtab)
6313 free (symtab);
6314 if (strtab)
6315 free (strtab);
f5842774
L		 6316 return 1;
6317}
6318
28f997cf
TG		 6319/* Data used to display dynamic fixups. */
6320
6321struct ia64_vms_dynfixup
6322{
6323 bfd_vma needed_ident; /* Library ident number. */
6324 bfd_vma needed; /* Index in the dstrtab of the library name. */
6325 bfd_vma fixup_needed; /* Index of the library. */
6326 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6327 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6328};
6329
6330/* Data used to display dynamic relocations. */
6331
6332struct ia64_vms_dynimgrela
6333{
6334 bfd_vma img_rela_cnt; /* Number of relocations. */
6335 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6336};
6337
6338/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6339 library). */
6340
6341static void
6342dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6343 const char *strtab, unsigned int strtab_sz)
6344{
6345 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6346 long i;
6347 const char *lib_name;
6348
6349 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6350 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6351 _("dynamic section image fixups"));
6352 if (!imfs)
6353 return;
6354
6355 if (fixup->needed < strtab_sz)
6356 lib_name = strtab + fixup->needed;
6357 else
6358 {
6359 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6360 (unsigned long) fixup->needed);
28f997cf
TG		 6361 lib_name = "???";
6362 }
6363 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6364 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6365 printf
6366 (_("Seg Offset Type SymVec DataType\n"));
6367
6368 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6369 {
6370 unsigned int type;
6371 const char *rtype;
6372
6373 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6374 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6375 type = BYTE_GET (imfs [i].type);
6376 rtype = elf_ia64_reloc_type (type);
6377 if (rtype == NULL)
6378 printf (" 0x%08x ", type);
6379 else
6380 printf (" %-32s ", rtype);
6381 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6382 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6383 }
6384
6385 free (imfs);
6386}
6387
6388/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6389
6390static void
6391dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6392{
6393 Elf64_External_VMS_IMAGE_RELA *imrs;
6394 long i;
6395
6396 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6397 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6398 _("dynamic section image relocations"));
28f997cf
TG		 6399 if (!imrs)
6400 return;
6401
6402 printf (_("\nImage relocs\n"));
6403 printf
6404 (_("Seg Offset Type Addend Seg Sym Off\n"));
6405
6406 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6407 {
6408 unsigned int type;
6409 const char *rtype;
6410
6411 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6412 printf ("%08" BFD_VMA_FMT "x ",
6413 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6414 type = BYTE_GET (imrs [i].type);
6415 rtype = elf_ia64_reloc_type (type);
6416 if (rtype == NULL)
6417 printf ("0x%08x ", type);
6418 else
6419 printf ("%-31s ", rtype);
6420 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6421 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6422 printf ("%08" BFD_VMA_FMT "x\n",
6423 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6424 }
6425
6426 free (imrs);
6427}
6428
6429/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6430
6431static int
6432process_ia64_vms_dynamic_relocs (FILE *file)
6433{
6434 struct ia64_vms_dynfixup fixup;
6435 struct ia64_vms_dynimgrela imgrela;
6436 Elf_Internal_Dyn *entry;
6437 int res = 0;
6438 bfd_vma strtab_off = 0;
6439 bfd_vma strtab_sz = 0;
6440 char *strtab = NULL;
6441
6442 memset (&fixup, 0, sizeof (fixup));
6443 memset (&imgrela, 0, sizeof (imgrela));
6444
6445 /* Note: the order of the entries is specified by the OpenVMS specs. */
6446 for (entry = dynamic_section;
6447 entry < dynamic_section + dynamic_nent;
6448 entry++)
6449 {
6450 switch (entry->d_tag)
6451 {
6452 case DT_IA_64_VMS_STRTAB_OFFSET:
6453 strtab_off = entry->d_un.d_val;
6454 break;
6455 case DT_STRSZ:
6456 strtab_sz = entry->d_un.d_val;
6457 if (strtab == NULL)
6458 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6459 1, strtab_sz, _("dynamic string section"));
6460 break;
6461
6462 case DT_IA_64_VMS_NEEDED_IDENT:
6463 fixup.needed_ident = entry->d_un.d_val;
6464 break;
6465 case DT_NEEDED:
6466 fixup.needed = entry->d_un.d_val;
6467 break;
6468 case DT_IA_64_VMS_FIXUP_NEEDED:
6469 fixup.fixup_needed = entry->d_un.d_val;
6470 break;
6471 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6472 fixup.fixup_rela_cnt = entry->d_un.d_val;
6473 break;
6474 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6475 fixup.fixup_rela_off = entry->d_un.d_val;
6476 res++;
6477 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6478 break;
6479
6480 case DT_IA_64_VMS_IMG_RELA_CNT:
6481 imgrela.img_rela_cnt = entry->d_un.d_val;
6482 break;
6483 case DT_IA_64_VMS_IMG_RELA_OFF:
6484 imgrela.img_rela_off = entry->d_un.d_val;
6485 res++;
6486 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6487 break;
6488
6489 default:
6490 break;
6491 }
6492 }
6493
6494 if (strtab != NULL)
6495 free (strtab);
6496
6497 return res;
6498}
6499
85b1c36d 6500static struct
566b0d53 6501{
2cf0635d 6502 const char * name;
566b0d53
L		 6503 int reloc;
6504 int size;
6505 int rela;
6506} dynamic_relocations [] =
6507{
6508 { "REL", DT_REL, DT_RELSZ, FALSE },
6509 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6510 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6511};
6512
252b5132 6513/* Process the reloc section. */
18bd398b 6514
252b5132 6515static int
2cf0635d 6516process_relocs (FILE * file)
252b5132 6517{
b34976b6
AM		 6518 unsigned long rel_size;
6519 unsigned long rel_offset;
252b5132
RH		 6520
6521
6522 if (!do_reloc)
6523 return 1;
6524
6525 if (do_using_dynamic)
6526 {
566b0d53 6527 int is_rela;
2cf0635d 6528 const char * name;
566b0d53
L		 6529 int has_dynamic_reloc;
6530 unsigned int i;
0de14b54 6531
566b0d53 6532 has_dynamic_reloc = 0;
252b5132 6533
566b0d53 6534 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6535 {
566b0d53
L		 6536 is_rela = dynamic_relocations [i].rela;
6537 name = dynamic_relocations [i].name;
6538 rel_size = dynamic_info [dynamic_relocations [i].size];
6539 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6540
566b0d53
L		 6541 has_dynamic_reloc |= rel_size;
6542
6543 if (is_rela == UNKNOWN)
aa903cfb 6544 {
566b0d53
L		 6545 if (dynamic_relocations [i].reloc == DT_JMPREL)
6546 switch (dynamic_info[DT_PLTREL])
6547 {
6548 case DT_REL:
6549 is_rela = FALSE;
6550 break;
6551 case DT_RELA:
6552 is_rela = TRUE;
6553 break;
6554 }
aa903cfb 6555 }
252b5132 6556
566b0d53
L		 6557 if (rel_size)
6558 {
6559 printf
6560 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6561 name, rel_offset, rel_size);
252b5132 6562
d93f0186
NC		 6563 dump_relocations (file,
6564 offset_from_vma (file, rel_offset, rel_size),
6565 rel_size,
566b0d53 6566 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6567 dynamic_strings, dynamic_strings_length,
6568 is_rela, 1);
566b0d53 6569 }
252b5132 6570 }
566b0d53 6571
28f997cf
TG		 6572 if (is_ia64_vms ())
6573 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6574
566b0d53 6575 if (! has_dynamic_reloc)
252b5132
RH		 6576 printf (_("\nThere are no dynamic relocations in this file.\n"));
6577 }
6578 else
6579 {
2cf0635d 6580 Elf_Internal_Shdr * section;
b34976b6
AM		 6581 unsigned long i;
6582 int found = 0;
252b5132
RH		 6583
6584 for (i = 0, section = section_headers;
6585 i < elf_header.e_shnum;
b34976b6 6586 i++, section++)
252b5132
RH		 6587 {
6588 if ( section->sh_type != SHT_RELA
6589 && section->sh_type != SHT_REL)
6590 continue;
6591
6592 rel_offset = section->sh_offset;
6593 rel_size = section->sh_size;
6594
6595 if (rel_size)
6596 {
2cf0635d 6597 Elf_Internal_Shdr * strsec;
b34976b6 6598 int is_rela;
103f02d3 6599
252b5132
RH		 6600 printf (_("\nRelocation section "));
6601
6602 if (string_table == NULL)
19936277 6603 printf ("%d", section->sh_name);
252b5132 6604 else
74e1a04b 6605 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6606
6607 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6608 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6609
d79b3d50
NC		 6610 is_rela = section->sh_type == SHT_RELA;
6611
4fbb74a6
AM		 6612 if (section->sh_link != 0
6613 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6614 {
2cf0635d
NC		 6615 Elf_Internal_Shdr * symsec;
6616 Elf_Internal_Sym * symtab;
d79b3d50 6617 unsigned long nsyms;
c256ffe7 6618 unsigned long strtablen = 0;
2cf0635d 6619 char * strtab = NULL;
57346661 6620
4fbb74a6 6621 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6622 if (symsec->sh_type != SHT_SYMTAB
6623 && symsec->sh_type != SHT_DYNSYM)
6624 continue;
6625
ba5cdace 6626 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6627
af3fc3bc
AM		 6628 if (symtab == NULL)
6629 continue;
252b5132 6630
4fbb74a6
AM		 6631 if (symsec->sh_link != 0
6632 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6633 {
4fbb74a6 6634 strsec = section_headers + symsec->sh_link;
103f02d3 6635
3f5e193b 6636 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6637 1, strsec->sh_size,
6638 _("string table"));
c256ffe7
JJ		 6639 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6640 }
252b5132 6641
d79b3d50 6642 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6643 symtab, nsyms, strtab, strtablen,
6644 is_rela,
6645 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6646 if (strtab)
6647 free (strtab);
6648 free (symtab);
6649 }
6650 else
6651 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6652 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6653
6654 found = 1;
6655 }
6656 }
6657
6658 if (! found)
6659 printf (_("\nThere are no relocations in this file.\n"));
6660 }
6661
6662 return 1;
6663}
6664
4d6ed7c8
NC		 6665/* An absolute address consists of a section and an offset. If the
6666 section is NULL, the offset itself is the address, otherwise, the
6667 address equals to LOAD_ADDRESS(section) + offset. */
6668
6669struct absaddr
948f632f
DA		 6670{
6671 unsigned short section;
6672 bfd_vma offset;
6673};
4d6ed7c8 6674
1949de15
L		 6675#define ABSADDR(a) \
6676 ((a).section \
6677 ? section_headers [(a).section].sh_addr + (a).offset \
6678 : (a).offset)
6679
948f632f
DA		 6680/* Find the nearest symbol at or below ADDR. Returns the symbol
6681 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6682
4d6ed7c8 6683static void
2cf0635d 6684find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6685 unsigned long nsyms,
6686 const char * strtab,
6687 unsigned long strtab_size,
6688 struct absaddr addr,
6689 const char ** symname,
6690 bfd_vma * offset)
4d6ed7c8 6691{
d3ba0551 6692 bfd_vma dist = 0x100000;
2cf0635d 6693 Elf_Internal_Sym * sym;
948f632f
DA		 6694 Elf_Internal_Sym * beg;
6695 Elf_Internal_Sym * end;
2cf0635d 6696 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6697
0b6ae522 6698 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6699 beg = symtab;
6700 end = symtab + nsyms;
0b6ae522 6701
948f632f 6702 while (beg < end)
4d6ed7c8 6703 {
948f632f
DA		 6704 bfd_vma value;
6705
6706 sym = beg + (end - beg) / 2;
0b6ae522 6707
948f632f 6708 value = sym->st_value;
0b6ae522
DJ		 6709 REMOVE_ARCH_BITS (value);
6710
948f632f 6711 if (sym->st_name != 0
4d6ed7c8 6712 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6713 && addr.offset >= value
6714 && addr.offset - value < dist)
4d6ed7c8
NC		 6715 {
6716 best = sym;
0b6ae522 6717 dist = addr.offset - value;
4d6ed7c8
NC		 6718 if (!dist)
6719 break;
6720 }
948f632f
DA		 6721
6722 if (addr.offset < value)
6723 end = sym;
6724 else
6725 beg = sym + 1;
4d6ed7c8 6726 }
1b31d05e 6727
4d6ed7c8
NC		 6728 if (best)
6729 {
57346661 6730 *symname = (best->st_name >= strtab_size
2b692964 6731 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6732 *offset = dist;
6733 return;
6734 }
1b31d05e 6735
4d6ed7c8
NC		 6736 *symname = NULL;
6737 *offset = addr.offset;
6738}
6739
948f632f
DA		 6740static int
6741symcmp (const void *p, const void *q)
6742{
6743 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6744 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6745
6746 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6747}
6748
6749/* Process the unwind section. */
6750
6751#include "unwind-ia64.h"
6752
6753struct ia64_unw_table_entry
6754{
6755 struct absaddr start;
6756 struct absaddr end;
6757 struct absaddr info;
6758};
6759
6760struct ia64_unw_aux_info
6761{
6762 struct ia64_unw_table_entry *table; /* Unwind table. */
6763 unsigned long table_len; /* Length of unwind table. */
6764 unsigned char * info; /* Unwind info. */
6765 unsigned long info_size; /* Size of unwind info. */
6766 bfd_vma info_addr; /* Starting address of unwind info. */
6767 bfd_vma seg_base; /* Starting address of segment. */
6768 Elf_Internal_Sym * symtab; /* The symbol table. */
6769 unsigned long nsyms; /* Number of symbols. */
6770 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6771 unsigned long nfuns; /* Number of entries in funtab. */
6772 char * strtab; /* The string table. */
6773 unsigned long strtab_size; /* Size of string table. */
6774};
6775
4d6ed7c8 6776static void
2cf0635d 6777dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6778{
2cf0635d 6779 struct ia64_unw_table_entry * tp;
948f632f 6780 unsigned long j, nfuns;
4d6ed7c8 6781 int in_body;
7036c0e1 6782
948f632f
DA		 6783 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6784 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6785 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6786 aux->funtab[nfuns++] = aux->symtab[j];
6787 aux->nfuns = nfuns;
6788 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6789
4d6ed7c8
NC		 6790 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6791 {
6792 bfd_vma stamp;
6793 bfd_vma offset;
2cf0635d
NC		 6794 const unsigned char * dp;
6795 const unsigned char * head;
53774b7e 6796 const unsigned char * end;
2cf0635d 6797 const char * procname;
4d6ed7c8 6798
948f632f 6799 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6800 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6801
6802 fputs ("\n<", stdout);
6803
6804 if (procname)
6805 {
6806 fputs (procname, stdout);
6807
6808 if (offset)
6809 printf ("+%lx", (unsigned long) offset);
6810 }
6811
6812 fputs (">: [", stdout);
6813 print_vma (tp->start.offset, PREFIX_HEX);
6814 fputc ('-', stdout);
6815 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6816 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6817 (unsigned long) (tp->info.offset - aux->seg_base));
6818
53774b7e
NC		 6819 /* PR 17531: file: 86232b32. */
6820 if (aux->info == NULL)
6821 continue;
6822
6823 /* PR 17531: file: 0997b4d1. */
6824 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6825 {
6826 warn (_("Invalid offset %lx in table entry %ld\n"),
6827 (long) tp->info.offset, (long) (tp - aux->table));
6828 continue;
6829 }
6830
1949de15 6831 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6832 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6833
86f55779 6834 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6835 (unsigned) UNW_VER (stamp),
6836 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6837 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6838 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6839 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6840
6841 if (UNW_VER (stamp) != 1)
6842 {
2b692964 6843 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6844 continue;
6845 }
6846
6847 in_body = 0;
53774b7e
NC		 6848 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6849 /* PR 17531: file: 16ceda89. */
6850 if (end > aux->info + aux->info_size)
6851 end = aux->info + aux->info_size;
6852 for (dp = head + 8; dp < end;)
b4477bc8 6853 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6854 }
948f632f
DA		 6855
6856 free (aux->funtab);
4d6ed7c8
NC		 6857}
6858
53774b7e 6859static bfd_boolean
2cf0635d
NC		 6860slurp_ia64_unwind_table (FILE * file,
6861 struct ia64_unw_aux_info * aux,
6862 Elf_Internal_Shdr * sec)
4d6ed7c8 6863{
89fac5e3 6864 unsigned long size, nrelas, i;
2cf0635d
NC		 6865 Elf_Internal_Phdr * seg;
6866 struct ia64_unw_table_entry * tep;
6867 Elf_Internal_Shdr * relsec;
6868 Elf_Internal_Rela * rela;
6869 Elf_Internal_Rela * rp;
6870 unsigned char * table;
6871 unsigned char * tp;
6872 Elf_Internal_Sym * sym;
6873 const char * relname;
4d6ed7c8 6874
53774b7e
NC		 6875 aux->table_len = 0;
6876
4d6ed7c8
NC		 6877 /* First, find the starting address of the segment that includes
6878 this section: */
6879
6880 if (elf_header.e_phnum)
6881 {
d93f0186 6882 if (! get_program_headers (file))
53774b7e 6883 return FALSE;
4d6ed7c8 6884
d93f0186
NC		 6885 for (seg = program_headers;
6886 seg < program_headers + elf_header.e_phnum;
6887 ++seg)
4d6ed7c8
NC		 6888 {
6889 if (seg->p_type != PT_LOAD)
6890 continue;
6891
6892 if (sec->sh_addr >= seg->p_vaddr
6893 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6894 {
6895 aux->seg_base = seg->p_vaddr;
6896 break;
6897 }
6898 }
4d6ed7c8
NC		 6899 }
6900
6901 /* Second, build the unwind table from the contents of the unwind section: */
6902 size = sec->sh_size;
3f5e193b
NC		 6903 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6904 _("unwind table"));
a6e9f9df 6905 if (!table)
53774b7e 6906 return FALSE;
4d6ed7c8 6907
53774b7e 6908 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6909 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6910 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6911 tep = aux->table;
53774b7e
NC		 6912
6913 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6914 {
6915 tep->start.section = SHN_UNDEF;
6916 tep->end.section = SHN_UNDEF;
6917 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6918 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6919 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6920 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6921 tep->start.offset += aux->seg_base;
6922 tep->end.offset += aux->seg_base;
6923 tep->info.offset += aux->seg_base;
6924 }
6925 free (table);
6926
41e92641 6927 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6928 for (relsec = section_headers;
6929 relsec < section_headers + elf_header.e_shnum;
6930 ++relsec)
6931 {
6932 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6933 || relsec->sh_info >= elf_header.e_shnum
6934 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6935 continue;
6936
6937 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6938 & rela, & nrelas))
53774b7e
NC		 6939 {
6940 free (aux->table);
6941 aux->table = NULL;
6942 aux->table_len = 0;
6943 return FALSE;
6944 }
4d6ed7c8
NC		 6945
6946 for (rp = rela; rp < rela + nrelas; ++rp)
6947 {
aca88567
NC		 6948 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6949 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6950
82b1b41b
NC		 6951 /* PR 17531: file: 9fa67536. */
6952 if (relname == NULL)
6953 {
6954 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6955 continue;
6956 }
948f632f 6957
0112cd26 6958 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6959 {
82b1b41b 6960 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6961 continue;
6962 }
6963
89fac5e3 6964 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6965
53774b7e
NC		 6966 /* PR 17531: file: 5bc8d9bf. */
6967 if (i >= aux->table_len)
6968 {
6969 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6970 continue;
6971 }
6972
6973 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6974 {
6975 case 0:
6976 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6977 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6978 break;
6979 case 1:
6980 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6981 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6982 break;
6983 case 2:
6984 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6985 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6986 break;
6987 default:
6988 break;
6989 }
6990 }
6991
6992 free (rela);
6993 }
6994
53774b7e 6995 return TRUE;
4d6ed7c8
NC		 6996}
6997
1b31d05e 6998static void
2cf0635d 6999ia64_process_unwind (FILE * file)
4d6ed7c8 7000{
2cf0635d
NC		 7001 Elf_Internal_Shdr * sec;
7002 Elf_Internal_Shdr * unwsec = NULL;
7003 Elf_Internal_Shdr * strsec;
89fac5e3 7004 unsigned long i, unwcount = 0, unwstart = 0;
57346661 7005 struct ia64_unw_aux_info aux;
f1467e33 7006
4d6ed7c8
NC		 7007 memset (& aux, 0, sizeof (aux));
7008
4d6ed7c8
NC		 7009 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7010 {
c256ffe7 7011 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7012 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 7013 {
ba5cdace 7014 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 7015
4fbb74a6 7016 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7017 if (aux.strtab != NULL)
7018 {
7019 error (_("Multiple auxillary string tables encountered\n"));
7020 free (aux.strtab);
7021 }
3f5e193b
NC		 7022 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7023 1, strsec->sh_size,
7024 _("string table"));
c256ffe7 7025 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 7026 }
7027 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7028 unwcount++;
7029 }
7030
7031 if (!unwcount)
7032 printf (_("\nThere are no unwind sections in this file.\n"));
7033
7034 while (unwcount-- > 0)
7035 {
2cf0635d 7036 char * suffix;
579f31ac
JJ		 7037 size_t len, len2;
7038
4082ef84 7039 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7040 i < elf_header.e_shnum; ++i, ++sec)
7041 if (sec->sh_type == SHT_IA_64_UNWIND)
7042 {
7043 unwsec = sec;
7044 break;
7045 }
4082ef84
NC		 7046 /* We have already counted the number of SHT_IA64_UNWIND
7047 sections so the loop above should never fail. */
7048 assert (unwsec != NULL);
579f31ac
JJ		 7049
7050 unwstart = i + 1;
7051 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7052
e4b17d5c
L		 7053 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7054 {
7055 /* We need to find which section group it is in. */
4082ef84 7056 struct group_list * g;
e4b17d5c 7057
4082ef84
NC		 7058 if (section_headers_groups == NULL
7059 || section_headers_groups [i] == NULL)
7060 i = elf_header.e_shnum;
7061 else
e4b17d5c 7062 {
4082ef84 7063 g = section_headers_groups [i]->root;
18bd398b 7064
4082ef84
NC		 7065 for (; g != NULL; g = g->next)
7066 {
7067 sec = section_headers + g->section_index;
e4b17d5c 7068
4082ef84
NC		 7069 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7070 break;
7071 }
7072
7073 if (g == NULL)
7074 i = elf_header.e_shnum;
7075 }
e4b17d5c 7076 }
18bd398b 7077 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7078 {
18bd398b 7079 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7080 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7081 suffix = SECTION_NAME (unwsec) + len;
7082 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7083 ++i, ++sec)
18bd398b
NC		 7084 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7085 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7086 break;
7087 }
7088 else
7089 {
7090 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7091 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7092 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7093 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7094 suffix = "";
18bd398b 7095 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7096 suffix = SECTION_NAME (unwsec) + len;
7097 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7098 ++i, ++sec)
18bd398b
NC		 7099 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7100 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7101 break;
7102 }
7103
7104 if (i == elf_header.e_shnum)
7105 {
7106 printf (_("\nCould not find unwind info section for "));
7107
7108 if (string_table == NULL)
7109 printf ("%d", unwsec->sh_name);
7110 else
74e1a04b 7111 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7112 }
7113 else
4d6ed7c8 7114 {
4d6ed7c8 7115 aux.info_addr = sec->sh_addr;
3f5e193b 7116 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7117 sec->sh_size,
7118 _("unwind info"));
59245841 7119 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7120
579f31ac 7121 printf (_("\nUnwind section "));
4d6ed7c8 7122
579f31ac
JJ		 7123 if (string_table == NULL)
7124 printf ("%d", unwsec->sh_name);
7125 else
74e1a04b 7126 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7127
579f31ac 7128 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7129 (unsigned long) unwsec->sh_offset,
89fac5e3 7130 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7131
53774b7e
NC		 7132 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7133 && aux.table_len > 0)
579f31ac
JJ		 7134 dump_ia64_unwind (& aux);
7135
7136 if (aux.table)
7137 free ((char *) aux.table);
7138 if (aux.info)
7139 free ((char *) aux.info);
7140 aux.table = NULL;
7141 aux.info = NULL;
7142 }
4d6ed7c8 7143 }
4d6ed7c8 7144
4d6ed7c8
NC		 7145 if (aux.symtab)
7146 free (aux.symtab);
7147 if (aux.strtab)
7148 free ((char *) aux.strtab);
4d6ed7c8
NC		 7149}
7150
3f5e193b
NC		 7151struct hppa_unw_table_entry
7152 {
7153 struct absaddr start;
7154 struct absaddr end;
948f632f 7155 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7156 unsigned int Millicode:1; /* 1 */
7157 unsigned int Millicode_save_sr0:1; /* 2 */
7158 unsigned int Region_description:2; /* 3..4 */
7159 unsigned int reserved1:1; /* 5 */
7160 unsigned int Entry_SR:1; /* 6 */
7161 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7162 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7163 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7164 unsigned int Variable_Frame:1; /* 17 */
7165 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7166 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7167 unsigned int Stack_Overflow_Check:1; /* 20 */
7168 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7169 unsigned int Ada_Region:1; /* 22 */
7170 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7171 unsigned int cxx_try_catch:1; /* 24 */
7172 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7173 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7174 unsigned int Save_SP:1; /* 27 */
7175 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7176 unsigned int Save_MRP_in_frame:1; /* 29 */
7177 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7178 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7179
948f632f
DA		 7180 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7181 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7182 unsigned int Large_frame:1; /* 2 */
948f632f 7183 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7184 unsigned int reserved4:1; /* 4 */
7185 unsigned int Total_frame_size:27; /* 5..31 */
7186 };
7187
57346661 7188struct hppa_unw_aux_info
948f632f
DA		 7189{
7190 struct hppa_unw_table_entry * table; /* Unwind table. */
7191 unsigned long table_len; /* Length of unwind table. */
7192 bfd_vma seg_base; /* Starting address of segment. */
7193 Elf_Internal_Sym * symtab; /* The symbol table. */
7194 unsigned long nsyms; /* Number of symbols. */
7195 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7196 unsigned long nfuns; /* Number of entries in funtab. */
7197 char * strtab; /* The string table. */
7198 unsigned long strtab_size; /* Size of string table. */
7199};
57346661
AM		 7200
7201static void
2cf0635d 7202dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7203{
2cf0635d 7204 struct hppa_unw_table_entry * tp;
948f632f
DA		 7205 unsigned long j, nfuns;
7206
7207 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7208 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7209 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7210 aux->funtab[nfuns++] = aux->symtab[j];
7211 aux->nfuns = nfuns;
7212 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7213
57346661
AM		 7214 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7215 {
7216 bfd_vma offset;
2cf0635d 7217 const char * procname;
57346661 7218
948f632f 7219 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7220 aux->strtab_size, tp->start, &procname,
7221 &offset);
7222
7223 fputs ("\n<", stdout);
7224
7225 if (procname)
7226 {
7227 fputs (procname, stdout);
7228
7229 if (offset)
7230 printf ("+%lx", (unsigned long) offset);
7231 }
7232
7233 fputs (">: [", stdout);
7234 print_vma (tp->start.offset, PREFIX_HEX);
7235 fputc ('-', stdout);
7236 print_vma (tp->end.offset, PREFIX_HEX);
7237 printf ("]\n\t");
7238
18bd398b
NC		 7239#define PF(_m) if (tp->_m) printf (#_m " ");
7240#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7241 PF(Cannot_unwind);
7242 PF(Millicode);
7243 PF(Millicode_save_sr0);
18bd398b 7244 /* PV(Region_description); */
57346661
AM		 7245 PF(Entry_SR);
7246 PV(Entry_FR);
7247 PV(Entry_GR);
7248 PF(Args_stored);
7249 PF(Variable_Frame);
7250 PF(Separate_Package_Body);
7251 PF(Frame_Extension_Millicode);
7252 PF(Stack_Overflow_Check);
7253 PF(Two_Instruction_SP_Increment);
7254 PF(Ada_Region);
7255 PF(cxx_info);
7256 PF(cxx_try_catch);
7257 PF(sched_entry_seq);
7258 PF(Save_SP);
7259 PF(Save_RP);
7260 PF(Save_MRP_in_frame);
7261 PF(extn_ptr_defined);
7262 PF(Cleanup_defined);
7263 PF(MPE_XL_interrupt_marker);
7264 PF(HP_UX_interrupt_marker);
7265 PF(Large_frame);
7266 PF(Pseudo_SP_Set);
7267 PV(Total_frame_size);
7268#undef PF
7269#undef PV
7270 }
7271
18bd398b 7272 printf ("\n");
948f632f
DA		 7273
7274 free (aux->funtab);
57346661
AM		 7275}
7276
7277static int
2cf0635d
NC		 7278slurp_hppa_unwind_table (FILE * file,
7279 struct hppa_unw_aux_info * aux,
7280 Elf_Internal_Shdr * sec)
57346661 7281{
1c0751b2 7282 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7283 Elf_Internal_Phdr * seg;
7284 struct hppa_unw_table_entry * tep;
7285 Elf_Internal_Shdr * relsec;
7286 Elf_Internal_Rela * rela;
7287 Elf_Internal_Rela * rp;
7288 unsigned char * table;
7289 unsigned char * tp;
7290 Elf_Internal_Sym * sym;
7291 const char * relname;
57346661 7292
57346661
AM		 7293 /* First, find the starting address of the segment that includes
7294 this section. */
7295
7296 if (elf_header.e_phnum)
7297 {
7298 if (! get_program_headers (file))
7299 return 0;
7300
7301 for (seg = program_headers;
7302 seg < program_headers + elf_header.e_phnum;
7303 ++seg)
7304 {
7305 if (seg->p_type != PT_LOAD)
7306 continue;
7307
7308 if (sec->sh_addr >= seg->p_vaddr
7309 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7310 {
7311 aux->seg_base = seg->p_vaddr;
7312 break;
7313 }
7314 }
7315 }
7316
7317 /* Second, build the unwind table from the contents of the unwind
7318 section. */
7319 size = sec->sh_size;
3f5e193b
NC		 7320 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7321 _("unwind table"));
57346661
AM		 7322 if (!table)
7323 return 0;
7324
1c0751b2
DA		 7325 unw_ent_size = 16;
7326 nentries = size / unw_ent_size;
7327 size = unw_ent_size * nentries;
57346661 7328
3f5e193b
NC		 7329 tep = aux->table = (struct hppa_unw_table_entry *)
7330 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7331
1c0751b2 7332 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7333 {
7334 unsigned int tmp1, tmp2;
7335
7336 tep->start.section = SHN_UNDEF;
7337 tep->end.section = SHN_UNDEF;
7338
1c0751b2
DA		 7339 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7340 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7341 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7342 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7343
7344 tep->start.offset += aux->seg_base;
7345 tep->end.offset += aux->seg_base;
57346661
AM		 7346
7347 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7348 tep->Millicode = (tmp1 >> 30) & 0x1;
7349 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7350 tep->Region_description = (tmp1 >> 27) & 0x3;
7351 tep->reserved1 = (tmp1 >> 26) & 0x1;
7352 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7353 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7354 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7355 tep->Args_stored = (tmp1 >> 15) & 0x1;
7356 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7357 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7358 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7359 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7360 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7361 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7362 tep->cxx_info = (tmp1 >> 8) & 0x1;
7363 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7364 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7365 tep->reserved2 = (tmp1 >> 5) & 0x1;
7366 tep->Save_SP = (tmp1 >> 4) & 0x1;
7367 tep->Save_RP = (tmp1 >> 3) & 0x1;
7368 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7369 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7370 tep->Cleanup_defined = tmp1 & 0x1;
7371
7372 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7373 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7374 tep->Large_frame = (tmp2 >> 29) & 0x1;
7375 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7376 tep->reserved4 = (tmp2 >> 27) & 0x1;
7377 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7378 }
7379 free (table);
7380
7381 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7382 for (relsec = section_headers;
7383 relsec < section_headers + elf_header.e_shnum;
7384 ++relsec)
7385 {
7386 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7387 || relsec->sh_info >= elf_header.e_shnum
7388 || section_headers + relsec->sh_info != sec)
57346661
AM		 7389 continue;
7390
7391 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7392 & rela, & nrelas))
7393 return 0;
7394
7395 for (rp = rela; rp < rela + nrelas; ++rp)
7396 {
aca88567
NC		 7397 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7398 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7399
7400 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7401 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7402 {
7403 warn (_("Skipping unexpected relocation type %s\n"), relname);
7404 continue;
7405 }
7406
7407 i = rp->r_offset / unw_ent_size;
7408
89fac5e3 7409 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7410 {
7411 case 0:
7412 aux->table[i].start.section = sym->st_shndx;
1e456d54 7413 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7414 break;
7415 case 1:
7416 aux->table[i].end.section = sym->st_shndx;
1e456d54 7417 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7418 break;
7419 default:
7420 break;
7421 }
7422 }
7423
7424 free (rela);
7425 }
7426
1c0751b2 7427 aux->table_len = nentries;
57346661
AM		 7428
7429 return 1;
7430}
7431
1b31d05e 7432static void
2cf0635d 7433hppa_process_unwind (FILE * file)
57346661 7434{
57346661 7435 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7436 Elf_Internal_Shdr * unwsec = NULL;
7437 Elf_Internal_Shdr * strsec;
7438 Elf_Internal_Shdr * sec;
18bd398b 7439 unsigned long i;
57346661 7440
c256ffe7 7441 if (string_table == NULL)
1b31d05e
NC		 7442 return;
7443
7444 memset (& aux, 0, sizeof (aux));
57346661
AM		 7445
7446 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7447 {
c256ffe7 7448 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7449 && sec->sh_link < elf_header.e_shnum)
57346661 7450 {
ba5cdace 7451 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7452
4fbb74a6 7453 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7454 if (aux.strtab != NULL)
7455 {
7456 error (_("Multiple auxillary string tables encountered\n"));
7457 free (aux.strtab);
7458 }
3f5e193b
NC		 7459 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7460 1, strsec->sh_size,
7461 _("string table"));
c256ffe7 7462 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7463 }
18bd398b 7464 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7465 unwsec = sec;
7466 }
7467
7468 if (!unwsec)
7469 printf (_("\nThere are no unwind sections in this file.\n"));
7470
7471 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7472 {
18bd398b 7473 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7474 {
74e1a04b
NC		 7475 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7476 printable_section_name (sec),
57346661 7477 (unsigned long) sec->sh_offset,
89fac5e3 7478 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7479
7480 slurp_hppa_unwind_table (file, &aux, sec);
7481 if (aux.table_len > 0)
7482 dump_hppa_unwind (&aux);
7483
7484 if (aux.table)
7485 free ((char *) aux.table);
7486 aux.table = NULL;
7487 }
7488 }
7489
7490 if (aux.symtab)
7491 free (aux.symtab);
7492 if (aux.strtab)
7493 free ((char *) aux.strtab);
57346661
AM		 7494}
7495
0b6ae522
DJ		 7496struct arm_section
7497{
a734115a
NC		 7498 unsigned char * data; /* The unwind data. */
7499 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7500 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7501 unsigned long nrelas; /* The number of relocations. */
7502 unsigned int rel_type; /* REL or RELA ? */
7503 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7504};
7505
7506struct arm_unw_aux_info
7507{
a734115a
NC		 7508 FILE * file; /* The file containing the unwind sections. */
7509 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7510 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7511 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7512 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7513 char * strtab; /* The file's string table. */
7514 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7515};
7516
7517static const char *
7518arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7519 bfd_vma fn, struct absaddr addr)
7520{
7521 const char *procname;
7522 bfd_vma sym_offset;
7523
7524 if (addr.section == SHN_UNDEF)
7525 addr.offset = fn;
7526
948f632f 7527 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7528 aux->strtab_size, addr, &procname,
7529 &sym_offset);
7530
7531 print_vma (fn, PREFIX_HEX);
7532
7533 if (procname)
7534 {
7535 fputs (" <", stdout);
7536 fputs (procname, stdout);
7537
7538 if (sym_offset)
7539 printf ("+0x%lx", (unsigned long) sym_offset);
7540 fputc ('>', stdout);
7541 }
7542
7543 return procname;
7544}
7545
7546static void
7547arm_free_section (struct arm_section *arm_sec)
7548{
7549 if (arm_sec->data != NULL)
7550 free (arm_sec->data);
7551
7552 if (arm_sec->rela != NULL)
7553 free (arm_sec->rela);
7554}
7555
a734115a
NC		 7556/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7557 cached section and install SEC instead.
7558 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7559 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7560 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7561 relocation's offset in ADDR.
1b31d05e
NC		 7562 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7563 into the string table of the symbol associated with the reloc. If no
7564 reloc was applied store -1 there.
7565 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7566
7567static bfd_boolean
1b31d05e
NC		 7568get_unwind_section_word (struct arm_unw_aux_info * aux,
7569 struct arm_section * arm_sec,
7570 Elf_Internal_Shdr * sec,
7571 bfd_vma word_offset,
7572 unsigned int * wordp,
7573 struct absaddr * addr,
7574 bfd_vma * sym_name)
0b6ae522
DJ		 7575{
7576 Elf_Internal_Rela *rp;
7577 Elf_Internal_Sym *sym;
7578 const char * relname;
7579 unsigned int word;
7580 bfd_boolean wrapped;
7581
e0a31db1
NC		 7582 if (sec == NULL || arm_sec == NULL)
7583 return FALSE;
7584
0b6ae522
DJ		 7585 addr->section = SHN_UNDEF;
7586 addr->offset = 0;
7587
1b31d05e
NC		 7588 if (sym_name != NULL)
7589 *sym_name = (bfd_vma) -1;
7590
a734115a 7591 /* If necessary, update the section cache. */
0b6ae522
DJ		 7592 if (sec != arm_sec->sec)
7593 {
7594 Elf_Internal_Shdr *relsec;
7595
7596 arm_free_section (arm_sec);
7597
7598 arm_sec->sec = sec;
7599 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7600 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7601 arm_sec->rela = NULL;
7602 arm_sec->nrelas = 0;
7603
7604 for (relsec = section_headers;
7605 relsec < section_headers + elf_header.e_shnum;
7606 ++relsec)
7607 {
7608 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7609 || section_headers + relsec->sh_info != sec
7610 /* PR 15745: Check the section type as well. */
7611 || (relsec->sh_type != SHT_REL
7612 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7613 continue;
7614
a734115a 7615 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7616 if (relsec->sh_type == SHT_REL)
7617 {
7618 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7619 relsec->sh_size,
7620 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7621 return FALSE;
0b6ae522 7622 }
1ae40aa4 7623 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7624 {
7625 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7626 relsec->sh_size,
7627 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7628 return FALSE;
0b6ae522 7629 }
1ae40aa4 7630 break;
0b6ae522
DJ		 7631 }
7632
7633 arm_sec->next_rela = arm_sec->rela;
7634 }
7635
a734115a 7636 /* If there is no unwind data we can do nothing. */
0b6ae522 7637 if (arm_sec->data == NULL)
a734115a 7638 return FALSE;
0b6ae522 7639
e0a31db1 7640 /* If the offset is invalid then fail. */
1a915552
NC		 7641 if (word_offset > (sec->sh_size - 4)
7642 /* PR 18879 */
7643 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7644 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7645 return FALSE;
7646
a734115a 7647 /* Get the word at the required offset. */
0b6ae522
DJ		 7648 word = byte_get (arm_sec->data + word_offset, 4);
7649
0eff7165
NC		 7650 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7651 if (arm_sec->rela == NULL)
7652 {
7653 * wordp = word;
7654 return TRUE;
7655 }
7656
a734115a 7657 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7658 wrapped = FALSE;
7659 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7660 {
7661 bfd_vma prelval, offset;
7662
7663 if (rp->r_offset > word_offset && !wrapped)
7664 {
7665 rp = arm_sec->rela;
7666 wrapped = TRUE;
7667 }
7668 if (rp->r_offset > word_offset)
7669 break;
7670
7671 if (rp->r_offset & 3)
7672 {
7673 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7674 (unsigned long) rp->r_offset);
7675 continue;
7676 }
7677
7678 if (rp->r_offset < word_offset)
7679 continue;
7680
74e1a04b
NC		 7681 /* PR 17531: file: 027-161405-0.004 */
7682 if (aux->symtab == NULL)
7683 continue;
7684
0b6ae522
DJ		 7685 if (arm_sec->rel_type == SHT_REL)
7686 {
7687 offset = word & 0x7fffffff;
7688 if (offset & 0x40000000)
7689 offset |= ~ (bfd_vma) 0x7fffffff;
7690 }
a734115a 7691 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7692 offset = rp->r_addend;
a734115a 7693 else
74e1a04b
NC		 7694 {
7695 error (_("Unknown section relocation type %d encountered\n"),
7696 arm_sec->rel_type);
7697 break;
7698 }
0b6ae522 7699
071436c6
NC		 7700 /* PR 17531 file: 027-1241568-0.004. */
7701 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7702 {
7703 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7704 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7705 break;
7706 }
7707
7708 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7709 offset += sym->st_value;
7710 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7711
a734115a
NC		 7712 /* Check that we are processing the expected reloc type. */
7713 if (elf_header.e_machine == EM_ARM)
7714 {
7715 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7716 if (relname == NULL)
7717 {
7718 warn (_("Skipping unknown ARM relocation type: %d\n"),
7719 (int) ELF32_R_TYPE (rp->r_info));
7720 continue;
7721 }
a734115a
NC		 7722
7723 if (streq (relname, "R_ARM_NONE"))
7724 continue;
0b4362b0 7725
a734115a
NC		 7726 if (! streq (relname, "R_ARM_PREL31"))
7727 {
071436c6 7728 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7729 continue;
7730 }
7731 }
7732 else if (elf_header.e_machine == EM_TI_C6000)
7733 {
7734 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7735 if (relname == NULL)
7736 {
7737 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7738 (int) ELF32_R_TYPE (rp->r_info));
7739 continue;
7740 }
0b4362b0 7741
a734115a
NC		 7742 if (streq (relname, "R_C6000_NONE"))
7743 continue;
7744
7745 if (! streq (relname, "R_C6000_PREL31"))
7746 {
071436c6 7747 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7748 continue;
7749 }
7750
7751 prelval >>= 1;
7752 }
7753 else
74e1a04b
NC		 7754 {
7755 /* This function currently only supports ARM and TI unwinders. */
7756 warn (_("Only TI and ARM unwinders are currently supported\n"));
7757 break;
7758 }
fa197c1c 7759
0b6ae522
DJ		 7760 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7761 addr->section = sym->st_shndx;
7762 addr->offset = offset;
74e1a04b 7763
1b31d05e
NC		 7764 if (sym_name)
7765 * sym_name = sym->st_name;
0b6ae522
DJ		 7766 break;
7767 }
7768
7769 *wordp = word;
7770 arm_sec->next_rela = rp;
7771
a734115a 7772 return TRUE;
0b6ae522
DJ		 7773}
7774
a734115a
NC		 7775static const char *tic6x_unwind_regnames[16] =
7776{
0b4362b0
RM		 7777 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7778 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7779 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7780};
fa197c1c 7781
0b6ae522 7782static void
fa197c1c 7783decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7784{
fa197c1c
PB		 7785 int i;
7786
7787 for (i = 12; mask; mask >>= 1, i--)
7788 {
7789 if (mask & 1)
7790 {
7791 fputs (tic6x_unwind_regnames[i], stdout);
7792 if (mask > 1)
7793 fputs (", ", stdout);
7794 }
7795 }
7796}
0b6ae522
DJ		 7797
7798#define ADVANCE \
7799 if (remaining == 0 && more_words) \
7800 { \
7801 data_offset += 4; \
1b31d05e
NC		 7802 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7803 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7804 return; \
7805 remaining = 4; \
7806 more_words--; \
7807 } \
7808
7809#define GET_OP(OP) \
7810 ADVANCE; \
7811 if (remaining) \
7812 { \
7813 remaining--; \
7814 (OP) = word >> 24; \
7815 word <<= 8; \
7816 } \
7817 else \
7818 { \
2b692964 7819 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7820 return; \
7821 } \
cc5914eb 7822 printf ("0x%02x ", OP)
0b6ae522 7823
fa197c1c 7824static void
948f632f
DA		 7825decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7826 unsigned int word,
7827 unsigned int remaining,
7828 unsigned int more_words,
7829 bfd_vma data_offset,
7830 Elf_Internal_Shdr * data_sec,
7831 struct arm_section * data_arm_sec)
fa197c1c
PB		 7832{
7833 struct absaddr addr;
0b6ae522
DJ		 7834
7835 /* Decode the unwinding instructions. */
7836 while (1)
7837 {
7838 unsigned int op, op2;
7839
7840 ADVANCE;
7841 if (remaining == 0)
7842 break;
7843 remaining--;
7844 op = word >> 24;
7845 word <<= 8;
7846
cc5914eb 7847 printf (" 0x%02x ", op);
0b6ae522
DJ		 7848
7849 if ((op & 0xc0) == 0x00)
7850 {
7851 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7852
cc5914eb 7853 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7854 }
7855 else if ((op & 0xc0) == 0x40)
7856 {
7857 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7858
cc5914eb 7859 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7860 }
7861 else if ((op & 0xf0) == 0x80)
7862 {
7863 GET_OP (op2);
7864 if (op == 0x80 && op2 == 0)
7865 printf (_("Refuse to unwind"));
7866 else
7867 {
7868 unsigned int mask = ((op & 0x0f) << 8) | op2;
7869 int first = 1;
7870 int i;
2b692964 7871
0b6ae522
DJ		 7872 printf ("pop {");
7873 for (i = 0; i < 12; i++)
7874 if (mask & (1 << i))
7875 {
7876 if (first)
7877 first = 0;
7878 else
7879 printf (", ");
7880 printf ("r%d", 4 + i);
7881 }
7882 printf ("}");
7883 }
7884 }
7885 else if ((op & 0xf0) == 0x90)
7886 {
7887 if (op == 0x9d || op == 0x9f)
7888 printf (_(" [Reserved]"));
7889 else
cc5914eb 7890 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7891 }
7892 else if ((op & 0xf0) == 0xa0)
7893 {
7894 int end = 4 + (op & 0x07);
7895 int first = 1;
7896 int i;
61865e30 7897
0b6ae522
DJ		 7898 printf (" pop {");
7899 for (i = 4; i <= end; i++)
7900 {
7901 if (first)
7902 first = 0;
7903 else
7904 printf (", ");
7905 printf ("r%d", i);
7906 }
7907 if (op & 0x08)
7908 {
1b31d05e 7909 if (!first)
0b6ae522
DJ		 7910 printf (", ");
7911 printf ("r14");
7912 }
7913 printf ("}");
7914 }
7915 else if (op == 0xb0)
7916 printf (_(" finish"));
7917 else if (op == 0xb1)
7918 {
7919 GET_OP (op2);
7920 if (op2 == 0 || (op2 & 0xf0) != 0)
7921 printf (_("[Spare]"));
7922 else
7923 {
7924 unsigned int mask = op2 & 0x0f;
7925 int first = 1;
7926 int i;
61865e30 7927
0b6ae522
DJ		 7928 printf ("pop {");
7929 for (i = 0; i < 12; i++)
7930 if (mask & (1 << i))
7931 {
7932 if (first)
7933 first = 0;
7934 else
7935 printf (", ");
7936 printf ("r%d", i);
7937 }
7938 printf ("}");
7939 }
7940 }
7941 else if (op == 0xb2)
7942 {
b115cf96 7943 unsigned char buf[9];
0b6ae522
DJ		 7944 unsigned int i, len;
7945 unsigned long offset;
61865e30 7946
b115cf96 7947 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7948 {
7949 GET_OP (buf[i]);
7950 if ((buf[i] & 0x80) == 0)
7951 break;
7952 }
4082ef84
NC		 7953 if (i == sizeof (buf))
7954 printf (_("corrupt change to vsp"));
7955 else
7956 {
7957 offset = read_uleb128 (buf, &len, buf + i + 1);
7958 assert (len == i + 1);
7959 offset = offset * 4 + 0x204;
7960 printf ("vsp = vsp + %ld", offset);
7961 }
0b6ae522 7962 }
61865e30 7963 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7964 {
61865e30
NC		 7965 unsigned int first, last;
7966
7967 GET_OP (op2);
7968 first = op2 >> 4;
7969 last = op2 & 0x0f;
7970 if (op == 0xc8)
7971 first = first + 16;
7972 printf ("pop {D%d", first);
7973 if (last)
7974 printf ("-D%d", first + last);
7975 printf ("}");
7976 }
7977 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7978 {
7979 unsigned int count = op & 0x07;
7980
7981 printf ("pop {D8");
7982 if (count)
7983 printf ("-D%d", 8 + count);
7984 printf ("}");
7985 }
7986 else if (op >= 0xc0 && op <= 0xc5)
7987 {
7988 unsigned int count = op & 0x07;
7989
7990 printf (" pop {wR10");
7991 if (count)
7992 printf ("-wR%d", 10 + count);
7993 printf ("}");
7994 }
7995 else if (op == 0xc6)
7996 {
7997 unsigned int first, last;
7998
7999 GET_OP (op2);
8000 first = op2 >> 4;
8001 last = op2 & 0x0f;
8002 printf ("pop {wR%d", first);
8003 if (last)
8004 printf ("-wR%d", first + last);
8005 printf ("}");
8006 }
8007 else if (op == 0xc7)
8008 {
8009 GET_OP (op2);
8010 if (op2 == 0 || (op2 & 0xf0) != 0)
8011 printf (_("[Spare]"));
0b6ae522
DJ		 8012 else
8013 {
61865e30
NC		 8014 unsigned int mask = op2 & 0x0f;
8015 int first = 1;
8016 int i;
8017
8018 printf ("pop {");
8019 for (i = 0; i < 4; i++)
8020 if (mask & (1 << i))
8021 {
8022 if (first)
8023 first = 0;
8024 else
8025 printf (", ");
8026 printf ("wCGR%d", i);
8027 }
8028 printf ("}");
0b6ae522
DJ		 8029 }
8030 }
61865e30
NC		 8031 else
8032 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 8033 printf ("\n");
8034 }
fa197c1c
PB		 8035}
8036
8037static void
948f632f
DA		 8038decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8039 unsigned int word,
8040 unsigned int remaining,
8041 unsigned int more_words,
8042 bfd_vma data_offset,
8043 Elf_Internal_Shdr * data_sec,
8044 struct arm_section * data_arm_sec)
fa197c1c
PB		 8045{
8046 struct absaddr addr;
8047
8048 /* Decode the unwinding instructions. */
8049 while (1)
8050 {
8051 unsigned int op, op2;
8052
8053 ADVANCE;
8054 if (remaining == 0)
8055 break;
8056 remaining--;
8057 op = word >> 24;
8058 word <<= 8;
8059
9cf03b7e 8060 printf (" 0x%02x ", op);
fa197c1c
PB		 8061
8062 if ((op & 0xc0) == 0x00)
8063 {
8064 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8065 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8066 }
8067 else if ((op & 0xc0) == 0x80)
8068 {
8069 GET_OP (op2);
8070 if (op == 0x80 && op2 == 0)
8071 printf (_("Refuse to unwind"));
8072 else
8073 {
8074 unsigned int mask = ((op & 0x1f) << 8) | op2;
8075 if (op & 0x20)
8076 printf ("pop compact {");
8077 else
8078 printf ("pop {");
8079
8080 decode_tic6x_unwind_regmask (mask);
8081 printf("}");
8082 }
8083 }
8084 else if ((op & 0xf0) == 0xc0)
8085 {
8086 unsigned int reg;
8087 unsigned int nregs;
8088 unsigned int i;
8089 const char *name;
a734115a
NC		 8090 struct
8091 {
fa197c1c
PB		 8092 unsigned int offset;
8093 unsigned int reg;
8094 } regpos[16];
8095
8096 /* Scan entire instruction first so that GET_OP output is not
8097 interleaved with disassembly. */
8098 nregs = 0;
8099 for (i = 0; nregs < (op & 0xf); i++)
8100 {
8101 GET_OP (op2);
8102 reg = op2 >> 4;
8103 if (reg != 0xf)
8104 {
8105 regpos[nregs].offset = i * 2;
8106 regpos[nregs].reg = reg;
8107 nregs++;
8108 }
8109
8110 reg = op2 & 0xf;
8111 if (reg != 0xf)
8112 {
8113 regpos[nregs].offset = i * 2 + 1;
8114 regpos[nregs].reg = reg;
8115 nregs++;
8116 }
8117 }
8118
8119 printf (_("pop frame {"));
8120 reg = nregs - 1;
8121 for (i = i * 2; i > 0; i--)
8122 {
8123 if (regpos[reg].offset == i - 1)
8124 {
8125 name = tic6x_unwind_regnames[regpos[reg].reg];
8126 if (reg > 0)
8127 reg--;
8128 }
8129 else
8130 name = _("[pad]");
8131
8132 fputs (name, stdout);
8133 if (i > 1)
8134 printf (", ");
8135 }
8136
8137 printf ("}");
8138 }
8139 else if (op == 0xd0)
8140 printf (" MOV FP, SP");
8141 else if (op == 0xd1)
8142 printf (" __c6xabi_pop_rts");
8143 else if (op == 0xd2)
8144 {
8145 unsigned char buf[9];
8146 unsigned int i, len;
8147 unsigned long offset;
a734115a 8148
fa197c1c
PB		 8149 for (i = 0; i < sizeof (buf); i++)
8150 {
8151 GET_OP (buf[i]);
8152 if ((buf[i] & 0x80) == 0)
8153 break;
8154 }
0eff7165
NC		 8155 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8156 if (i == sizeof (buf))
8157 {
8158 printf ("<corrupt sp adjust>\n");
8159 warn (_("Corrupt stack pointer adjustment detected\n"));
8160 return;
8161 }
948f632f 8162
f6f0e17b 8163 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8164 assert (len == i + 1);
8165 offset = offset * 8 + 0x408;
8166 printf (_("sp = sp + %ld"), offset);
8167 }
8168 else if ((op & 0xf0) == 0xe0)
8169 {
8170 if ((op & 0x0f) == 7)
8171 printf (" RETURN");
8172 else
8173 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8174 }
8175 else
8176 {
8177 printf (_(" [unsupported opcode]"));
8178 }
8179 putchar ('\n');
8180 }
8181}
8182
8183static bfd_vma
a734115a 8184arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8185{
8186 bfd_vma offset;
8187
8188 offset = word & 0x7fffffff;
8189 if (offset & 0x40000000)
8190 offset |= ~ (bfd_vma) 0x7fffffff;
8191
8192 if (elf_header.e_machine == EM_TI_C6000)
8193 offset <<= 1;
8194
8195 return offset + where;
8196}
8197
8198static void
1b31d05e
NC		 8199decode_arm_unwind (struct arm_unw_aux_info * aux,
8200 unsigned int word,
8201 unsigned int remaining,
8202 bfd_vma data_offset,
8203 Elf_Internal_Shdr * data_sec,
8204 struct arm_section * data_arm_sec)
fa197c1c
PB		 8205{
8206 int per_index;
8207 unsigned int more_words = 0;
37e14bc3 8208 struct absaddr addr;
1b31d05e 8209 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8210
8211 if (remaining == 0)
8212 {
1b31d05e
NC		 8213 /* Fetch the first word.
8214 Note - when decoding an object file the address extracted
8215 here will always be 0. So we also pass in the sym_name
8216 parameter so that we can find the symbol associated with
8217 the personality routine. */
8218 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8219 & word, & addr, & sym_name))
fa197c1c 8220 return;
1b31d05e 8221
fa197c1c
PB		 8222 remaining = 4;
8223 }
8224
8225 if ((word & 0x80000000) == 0)
8226 {
8227 /* Expand prel31 for personality routine. */
8228 bfd_vma fn;
8229 const char *procname;
8230
a734115a 8231 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8232 printf (_(" Personality routine: "));
1b31d05e
NC		 8233 if (fn == 0
8234 && addr.section == SHN_UNDEF && addr.offset == 0
8235 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8236 {
8237 procname = aux->strtab + sym_name;
8238 print_vma (fn, PREFIX_HEX);
8239 if (procname)
8240 {
8241 fputs (" <", stdout);
8242 fputs (procname, stdout);
8243 fputc ('>', stdout);
8244 }
8245 }
8246 else
8247 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8248 fputc ('\n', stdout);
8249
8250 /* The GCC personality routines use the standard compact
8251 encoding, starting with one byte giving the number of
8252 words. */
8253 if (procname != NULL
8254 && (const_strneq (procname, "__gcc_personality_v0")
8255 || const_strneq (procname, "__gxx_personality_v0")
8256 || const_strneq (procname, "__gcj_personality_v0")
8257 || const_strneq (procname, "__gnu_objc_personality_v0")))
8258 {
8259 remaining = 0;
8260 more_words = 1;
8261 ADVANCE;
8262 if (!remaining)
8263 {
8264 printf (_(" [Truncated data]\n"));
8265 return;
8266 }
8267 more_words = word >> 24;
8268 word <<= 8;
8269 remaining--;
8270 per_index = -1;
8271 }
8272 else
8273 return;
8274 }
8275 else
8276 {
1b31d05e 8277 /* ARM EHABI Section 6.3:
0b4362b0 8278
1b31d05e 8279 An exception-handling table entry for the compact model looks like:
0b4362b0 8280
1b31d05e
NC		 8281 31 30-28 27-24 23-0
8282 -- ----- ----- ----
8283 1 0 index Data for personalityRoutine[index] */
8284
8285 if (elf_header.e_machine == EM_ARM
8286 && (word & 0x70000000))
83c257ca 8287 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8288
fa197c1c 8289 per_index = (word >> 24) & 0x7f;
1b31d05e 8290 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8291 if (per_index == 0)
8292 {
8293 more_words = 0;
8294 word <<= 8;
8295 remaining--;
8296 }
8297 else if (per_index < 3)
8298 {
8299 more_words = (word >> 16) & 0xff;
8300 word <<= 16;
8301 remaining -= 2;
8302 }
8303 }
8304
8305 switch (elf_header.e_machine)
8306 {
8307 case EM_ARM:
8308 if (per_index < 3)
8309 {
8310 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8311 data_offset, data_sec, data_arm_sec);
8312 }
8313 else
1b31d05e
NC		 8314 {
8315 warn (_("Unknown ARM compact model index encountered\n"));
8316 printf (_(" [reserved]\n"));
8317 }
fa197c1c
PB		 8318 break;
8319
8320 case EM_TI_C6000:
8321 if (per_index < 3)
8322 {
8323 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8324 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8325 }
8326 else if (per_index < 5)
8327 {
8328 if (((word >> 17) & 0x7f) == 0x7f)
8329 printf (_(" Restore stack from frame pointer\n"));
8330 else
8331 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8332 printf (_(" Registers restored: "));
8333 if (per_index == 4)
8334 printf (" (compact) ");
8335 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8336 putchar ('\n');
8337 printf (_(" Return register: %s\n"),
8338 tic6x_unwind_regnames[word & 0xf]);
8339 }
8340 else
1b31d05e 8341 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8342 break;
8343
8344 default:
74e1a04b 8345 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8346 elf_header.e_machine);
fa197c1c 8347 }
0b6ae522
DJ		 8348
8349 /* Decode the descriptors. Not implemented. */
8350}
8351
8352static void
8353dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8354{
8355 struct arm_section exidx_arm_sec, extab_arm_sec;
8356 unsigned int i, exidx_len;
948f632f 8357 unsigned long j, nfuns;
0b6ae522
DJ		 8358
8359 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8360 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8361 exidx_len = exidx_sec->sh_size / 8;
8362
948f632f
DA		 8363 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8364 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8365 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8366 aux->funtab[nfuns++] = aux->symtab[j];
8367 aux->nfuns = nfuns;
8368 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8369
0b6ae522
DJ		 8370 for (i = 0; i < exidx_len; i++)
8371 {
8372 unsigned int exidx_fn, exidx_entry;
8373 struct absaddr fn_addr, entry_addr;
8374 bfd_vma fn;
8375
8376 fputc ('\n', stdout);
8377
1b31d05e
NC		 8378 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8379 8 * i, & exidx_fn, & fn_addr, NULL)
8380 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8381 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8382 {
948f632f 8383 free (aux->funtab);
1b31d05e
NC		 8384 arm_free_section (& exidx_arm_sec);
8385 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8386 return;
8387 }
8388
83c257ca
NC		 8389 /* ARM EHABI, Section 5:
8390 An index table entry consists of 2 words.
8391 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8392 if (exidx_fn & 0x80000000)
8393 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8394
a734115a 8395 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8396
a734115a 8397 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8398 fputs (": ", stdout);
8399
8400 if (exidx_entry == 1)
8401 {
8402 print_vma (exidx_entry, PREFIX_HEX);
8403 fputs (" [cantunwind]\n", stdout);
8404 }
8405 else if (exidx_entry & 0x80000000)
8406 {
8407 print_vma (exidx_entry, PREFIX_HEX);
8408 fputc ('\n', stdout);
8409 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8410 }
8411 else
8412 {
8f73510c 8413 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8414 Elf_Internal_Shdr *table_sec;
8415
8416 fputs ("@", stdout);
a734115a 8417 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8418 print_vma (table, PREFIX_HEX);
8419 printf ("\n");
8420
8421 /* Locate the matching .ARM.extab. */
8422 if (entry_addr.section != SHN_UNDEF
8423 && entry_addr.section < elf_header.e_shnum)
8424 {
8425 table_sec = section_headers + entry_addr.section;
8426 table_offset = entry_addr.offset;
1a915552
NC		 8427 /* PR 18879 */
8428 if (table_offset > table_sec->sh_size
8429 || ((bfd_signed_vma) table_offset) < 0)
8430 {
8431 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8432 (unsigned long) table_offset,
8433 printable_section_name (table_sec));
8434 continue;
8435 }
0b6ae522
DJ		 8436 }
8437 else
8438 {
8439 table_sec = find_section_by_address (table);
8440 if (table_sec != NULL)
8441 table_offset = table - table_sec->sh_addr;
8442 }
8443 if (table_sec == NULL)
8444 {
8445 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8446 (unsigned long) table);
8447 continue;
8448 }
8449 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8450 &extab_arm_sec);
8451 }
8452 }
8453
8454 printf ("\n");
8455
948f632f 8456 free (aux->funtab);
0b6ae522
DJ		 8457 arm_free_section (&exidx_arm_sec);
8458 arm_free_section (&extab_arm_sec);
8459}
8460
fa197c1c 8461/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8462
8463static void
0b6ae522
DJ		 8464arm_process_unwind (FILE *file)
8465{
8466 struct arm_unw_aux_info aux;
8467 Elf_Internal_Shdr *unwsec = NULL;
8468 Elf_Internal_Shdr *strsec;
8469 Elf_Internal_Shdr *sec;
8470 unsigned long i;
fa197c1c 8471 unsigned int sec_type;
0b6ae522 8472
fa197c1c
PB		 8473 switch (elf_header.e_machine)
8474 {
8475 case EM_ARM:
8476 sec_type = SHT_ARM_EXIDX;
8477 break;
8478
8479 case EM_TI_C6000:
8480 sec_type = SHT_C6000_UNWIND;
8481 break;
8482
0b4362b0 8483 default:
74e1a04b 8484 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8485 elf_header.e_machine);
8486 return;
fa197c1c
PB		 8487 }
8488
0b6ae522 8489 if (string_table == NULL)
1b31d05e
NC		 8490 return;
8491
8492 memset (& aux, 0, sizeof (aux));
8493 aux.file = file;
0b6ae522
DJ		 8494
8495 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8496 {
8497 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8498 {
ba5cdace 8499 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8500
8501 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8502
8503 /* PR binutils/17531 file: 011-12666-0.004. */
8504 if (aux.strtab != NULL)
8505 {
4082ef84 8506 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8507 free (aux.strtab);
8508 }
0b6ae522
DJ		 8509 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8510 1, strsec->sh_size, _("string table"));
8511 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8512 }
fa197c1c 8513 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8514 unwsec = sec;
8515 }
8516
1b31d05e 8517 if (unwsec == NULL)
0b6ae522 8518 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8519 else
8520 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8521 {
8522 if (sec->sh_type == sec_type)
8523 {
8524 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8525 printable_section_name (sec),
1b31d05e
NC		 8526 (unsigned long) sec->sh_offset,
8527 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8528
1b31d05e
NC		 8529 dump_arm_unwind (&aux, sec);
8530 }
8531 }
0b6ae522
DJ		 8532
8533 if (aux.symtab)
8534 free (aux.symtab);
8535 if (aux.strtab)
8536 free ((char *) aux.strtab);
0b6ae522
DJ		 8537}
8538
1b31d05e 8539static void
2cf0635d 8540process_unwind (FILE * file)
57346661 8541{
2cf0635d
NC		 8542 struct unwind_handler
8543 {
57346661 8544 int machtype;
1b31d05e 8545 void (* handler)(FILE *);
2cf0635d
NC		 8546 } handlers[] =
8547 {
0b6ae522 8548 { EM_ARM, arm_process_unwind },
57346661
AM		 8549 { EM_IA_64, ia64_process_unwind },
8550 { EM_PARISC, hppa_process_unwind },
fa197c1c 8551 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8552 { 0, 0 }
8553 };
8554 int i;
8555
8556 if (!do_unwind)
1b31d05e 8557 return;
57346661
AM		 8558
8559 for (i = 0; handlers[i].handler != NULL; i++)
8560 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8561 {
8562 handlers[i].handler (file);
8563 return;
8564 }
57346661 8565
1b31d05e
NC		 8566 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8567 get_machine_name (elf_header.e_machine));
57346661
AM		 8568}
8569
252b5132 8570static void
2cf0635d 8571dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8572{
8573 switch (entry->d_tag)
8574 {
8575 case DT_MIPS_FLAGS:
8576 if (entry->d_un.d_val == 0)
4b68bca3 8577 printf (_("NONE"));
252b5132
RH		 8578 else
8579 {
8580 static const char * opts[] =
8581 {
8582 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8583 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8584 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8585 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8586 "RLD_ORDER_SAFE"
8587 };
8588 unsigned int cnt;
8589 int first = 1;
2b692964 8590
60bca95a 8591 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8592 if (entry->d_un.d_val & (1 << cnt))
8593 {
8594 printf ("%s%s", first ? "" : " ", opts[cnt]);
8595 first = 0;
8596 }
252b5132
RH		 8597 }
8598 break;
103f02d3 8599
252b5132 8600 case DT_MIPS_IVERSION:
d79b3d50 8601 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8602 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8603 else
76ca31c0
NC		 8604 {
8605 char buf[40];
8606 sprintf_vma (buf, entry->d_un.d_ptr);
8607 /* Note: coded this way so that there is a single string for translation. */
8608 printf (_("<corrupt: %s>"), buf);
8609 }
252b5132 8610 break;
103f02d3 8611
252b5132
RH		 8612 case DT_MIPS_TIME_STAMP:
8613 {
8614 char timebuf[20];
2cf0635d 8615 struct tm * tmp;
91d6fa6a 8616 time_t atime = entry->d_un.d_val;
82b1b41b 8617
91d6fa6a 8618 tmp = gmtime (&atime);
82b1b41b
NC		 8619 /* PR 17531: file: 6accc532. */
8620 if (tmp == NULL)
8621 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8622 else
8623 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8624 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8625 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8626 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8627 }
8628 break;
103f02d3 8629
252b5132
RH		 8630 case DT_MIPS_RLD_VERSION:
8631 case DT_MIPS_LOCAL_GOTNO:
8632 case DT_MIPS_CONFLICTNO:
8633 case DT_MIPS_LIBLISTNO:
8634 case DT_MIPS_SYMTABNO:
8635 case DT_MIPS_UNREFEXTNO:
8636 case DT_MIPS_HIPAGENO:
8637 case DT_MIPS_DELTA_CLASS_NO:
8638 case DT_MIPS_DELTA_INSTANCE_NO:
8639 case DT_MIPS_DELTA_RELOC_NO:
8640 case DT_MIPS_DELTA_SYM_NO:
8641 case DT_MIPS_DELTA_CLASSSYM_NO:
8642 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8643 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8644 break;
103f02d3
UD		 8645
8646 default:
4b68bca3 8647 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8648 }
4b68bca3 8649 putchar ('\n');
103f02d3
UD		 8650}
8651
103f02d3 8652static void
2cf0635d 8653dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8654{
8655 switch (entry->d_tag)
8656 {
8657 case DT_HP_DLD_FLAGS:
8658 {
8659 static struct
8660 {
8661 long int bit;
2cf0635d 8662 const char * str;
5e220199
NC		 8663 }
8664 flags[] =
8665 {
8666 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8667 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8668 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8669 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8670 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8671 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8672 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8673 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8674 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8675 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8676 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8677 { DT_HP_GST, "HP_GST" },
8678 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8679 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8680 { DT_HP_NODELETE, "HP_NODELETE" },
8681 { DT_HP_GROUP, "HP_GROUP" },
8682 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8683 };
103f02d3 8684 int first = 1;
5e220199 8685 size_t cnt;
f7a99963 8686 bfd_vma val = entry->d_un.d_val;
103f02d3 8687
60bca95a 8688 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8689 if (val & flags[cnt].bit)
30800947
NC		 8690 {
8691 if (! first)
8692 putchar (' ');
8693 fputs (flags[cnt].str, stdout);
8694 first = 0;
8695 val ^= flags[cnt].bit;
8696 }
76da6bbe 8697
103f02d3 8698 if (val != 0 || first)
f7a99963
NC		 8699 {
8700 if (! first)
8701 putchar (' ');
8702 print_vma (val, HEX);
8703 }
103f02d3
UD		 8704 }
8705 break;
76da6bbe 8706
252b5132 8707 default:
f7a99963
NC		 8708 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8709 break;
252b5132 8710 }
35b1837e 8711 putchar ('\n');
252b5132
RH		 8712}
8713
28f997cf
TG		 8714#ifdef BFD64
8715
8716/* VMS vs Unix time offset and factor. */
8717
8718#define VMS_EPOCH_OFFSET 35067168000000000LL
8719#define VMS_GRANULARITY_FACTOR 10000000
8720
8721/* Display a VMS time in a human readable format. */
8722
8723static void
8724print_vms_time (bfd_int64_t vmstime)
8725{
8726 struct tm *tm;
8727 time_t unxtime;
8728
8729 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8730 tm = gmtime (&unxtime);
8731 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8732 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8733 tm->tm_hour, tm->tm_min, tm->tm_sec);
8734}
8735#endif /* BFD64 */
8736
ecc51f48 8737static void
2cf0635d 8738dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8739{
8740 switch (entry->d_tag)
8741 {
0de14b54 8742 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8743 /* First 3 slots reserved. */
ecc51f48
NC		 8744 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8745 printf (" -- ");
8746 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8747 break;
8748
28f997cf
TG		 8749 case DT_IA_64_VMS_LINKTIME:
8750#ifdef BFD64
8751 print_vms_time (entry->d_un.d_val);
8752#endif
8753 break;
8754
8755 case DT_IA_64_VMS_LNKFLAGS:
8756 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8757 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8758 printf (" CALL_DEBUG");
8759 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8760 printf (" NOP0BUFS");
8761 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8762 printf (" P0IMAGE");
8763 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8764 printf (" MKTHREADS");
8765 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8766 printf (" UPCALLS");
8767 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8768 printf (" IMGSTA");
8769 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8770 printf (" INITIALIZE");
8771 if (entry->d_un.d_val & VMS_LF_MAIN)
8772 printf (" MAIN");
8773 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8774 printf (" EXE_INIT");
8775 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8776 printf (" TBK_IN_IMG");
8777 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8778 printf (" DBG_IN_IMG");
8779 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8780 printf (" TBK_IN_DSF");
8781 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8782 printf (" DBG_IN_DSF");
8783 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8784 printf (" SIGNATURES");
8785 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8786 printf (" REL_SEG_OFF");
8787 break;
8788
bdf4d63a
JJ		 8789 default:
8790 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8791 break;
ecc51f48 8792 }
bdf4d63a 8793 putchar ('\n');
ecc51f48
NC		 8794}
8795
252b5132 8796static int
2cf0635d 8797get_32bit_dynamic_section (FILE * file)
252b5132 8798{
2cf0635d
NC		 8799 Elf32_External_Dyn * edyn;
8800 Elf32_External_Dyn * ext;
8801 Elf_Internal_Dyn * entry;
103f02d3 8802
3f5e193b
NC		 8803 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8804 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8805 if (!edyn)
8806 return 0;
103f02d3 8807
071436c6
NC		 8808 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8809 might not have the luxury of section headers. Look for the DT_NULL
8810 terminator to determine the number of entries. */
ba2685cc 8811 for (ext = edyn, dynamic_nent = 0;
53c3012c 8812 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8813 ext++)
8814 {
8815 dynamic_nent++;
8816 if (BYTE_GET (ext->d_tag) == DT_NULL)
8817 break;
8818 }
252b5132 8819
3f5e193b
NC		 8820 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8821 sizeof (* entry));
b2d38a17 8822 if (dynamic_section == NULL)
252b5132 8823 {
8b73c356
NC		 8824 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8825 (unsigned long) dynamic_nent);
9ea033b2
NC		 8826 free (edyn);
8827 return 0;
8828 }
252b5132 8829
fb514b26 8830 for (ext = edyn, entry = dynamic_section;
ba2685cc 8831 entry < dynamic_section + dynamic_nent;
fb514b26 8832 ext++, entry++)
9ea033b2 8833 {
fb514b26
AM		 8834 entry->d_tag = BYTE_GET (ext->d_tag);
8835 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8836 }
8837
9ea033b2
NC		 8838 free (edyn);
8839
8840 return 1;
8841}
8842
8843static int
2cf0635d 8844get_64bit_dynamic_section (FILE * file)
9ea033b2 8845{
2cf0635d
NC		 8846 Elf64_External_Dyn * edyn;
8847 Elf64_External_Dyn * ext;
8848 Elf_Internal_Dyn * entry;
103f02d3 8849
071436c6 8850 /* Read in the data. */
3f5e193b
NC		 8851 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8852 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8853 if (!edyn)
8854 return 0;
103f02d3 8855
071436c6
NC		 8856 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8857 might not have the luxury of section headers. Look for the DT_NULL
8858 terminator to determine the number of entries. */
ba2685cc 8859 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8860 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8861 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8862 ext++)
8863 {
8864 dynamic_nent++;
66543521 8865 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8866 break;
8867 }
252b5132 8868
3f5e193b
NC		 8869 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8870 sizeof (* entry));
b2d38a17 8871 if (dynamic_section == NULL)
252b5132 8872 {
8b73c356
NC		 8873 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8874 (unsigned long) dynamic_nent);
252b5132
RH		 8875 free (edyn);
8876 return 0;
8877 }
8878
071436c6 8879 /* Convert from external to internal formats. */
fb514b26 8880 for (ext = edyn, entry = dynamic_section;
ba2685cc 8881 entry < dynamic_section + dynamic_nent;
fb514b26 8882 ext++, entry++)
252b5132 8883 {
66543521
AM		 8884 entry->d_tag = BYTE_GET (ext->d_tag);
8885 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8886 }
8887
8888 free (edyn);
8889
9ea033b2
NC		 8890 return 1;
8891}
8892
e9e44622
JJ		 8893static void
8894print_dynamic_flags (bfd_vma flags)
d1133906 8895{
e9e44622 8896 int first = 1;
13ae64f3 8897
d1133906
NC		 8898 while (flags)
8899 {
8900 bfd_vma flag;
8901
8902 flag = flags & - flags;
8903 flags &= ~ flag;
8904
e9e44622
JJ		 8905 if (first)
8906 first = 0;
8907 else
8908 putc (' ', stdout);
13ae64f3 8909
d1133906
NC		 8910 switch (flag)
8911 {
e9e44622
JJ		 8912 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8913 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8914 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8915 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8916 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8917 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8918 }
8919 }
e9e44622 8920 puts ("");
d1133906
NC		 8921}
8922
b2d38a17
NC		 8923/* Parse and display the contents of the dynamic section. */
8924
9ea033b2 8925static int
2cf0635d 8926process_dynamic_section (FILE * file)
9ea033b2 8927{
2cf0635d 8928 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8929
8930 if (dynamic_size == 0)
8931 {
8932 if (do_dynamic)
b2d38a17 8933 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8934
8935 return 1;
8936 }
8937
8938 if (is_32bit_elf)
8939 {
b2d38a17 8940 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8941 return 0;
8942 }
b2d38a17 8943 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8944 return 0;
8945
252b5132
RH		 8946 /* Find the appropriate symbol table. */
8947 if (dynamic_symbols == NULL)
8948 {
86dba8ee
AM		 8949 for (entry = dynamic_section;
8950 entry < dynamic_section + dynamic_nent;
8951 ++entry)
252b5132 8952 {
c8286bd1 8953 Elf_Internal_Shdr section;
252b5132
RH		 8954
8955 if (entry->d_tag != DT_SYMTAB)
8956 continue;
8957
8958 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8959
8960 /* Since we do not know how big the symbol table is,
8961 we default to reading in the entire file (!) and
8962 processing that. This is overkill, I know, but it
e3c8793a 8963 should work. */
d93f0186 8964 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8965
fb52b2f4
NC		 8966 if (archive_file_offset != 0)
8967 section.sh_size = archive_file_size - section.sh_offset;
8968 else
8969 {
8970 if (fseek (file, 0, SEEK_END))
591a748a 8971 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8972
8973 section.sh_size = ftell (file) - section.sh_offset;
8974 }
252b5132 8975
9ea033b2 8976 if (is_32bit_elf)
9ad5cbcf 8977 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8978 else
9ad5cbcf 8979 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8980 section.sh_name = string_table_length;
252b5132 8981
ba5cdace 8982 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8983 if (num_dynamic_syms < 1)
252b5132
RH		 8984 {
8985 error (_("Unable to determine the number of symbols to load\n"));
8986 continue;
8987 }
252b5132
RH		 8988 }
8989 }
8990
8991 /* Similarly find a string table. */
8992 if (dynamic_strings == NULL)
8993 {
86dba8ee
AM		 8994 for (entry = dynamic_section;
8995 entry < dynamic_section + dynamic_nent;
8996 ++entry)
252b5132
RH		 8997 {
8998 unsigned long offset;
b34976b6 8999 long str_tab_len;
252b5132
RH		 9000
9001 if (entry->d_tag != DT_STRTAB)
9002 continue;
9003
9004 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9005
9006 /* Since we do not know how big the string table is,
9007 we default to reading in the entire file (!) and
9008 processing that. This is overkill, I know, but it
e3c8793a 9009 should work. */
252b5132 9010
d93f0186 9011 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 9012
9013 if (archive_file_offset != 0)
9014 str_tab_len = archive_file_size - offset;
9015 else
9016 {
9017 if (fseek (file, 0, SEEK_END))
9018 error (_("Unable to seek to end of file\n"));
9019 str_tab_len = ftell (file) - offset;
9020 }
252b5132
RH		 9021
9022 if (str_tab_len < 1)
9023 {
9024 error
9025 (_("Unable to determine the length of the dynamic string table\n"));
9026 continue;
9027 }
9028
3f5e193b
NC		 9029 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9030 str_tab_len,
9031 _("dynamic string table"));
59245841 9032 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9033 break;
9034 }
9035 }
9036
9037 /* And find the syminfo section if available. */
9038 if (dynamic_syminfo == NULL)
9039 {
3e8bba36 9040 unsigned long syminsz = 0;
252b5132 9041
86dba8ee
AM		 9042 for (entry = dynamic_section;
9043 entry < dynamic_section + dynamic_nent;
9044 ++entry)
252b5132
RH		 9045 {
9046 if (entry->d_tag == DT_SYMINENT)
9047 {
9048 /* Note: these braces are necessary to avoid a syntax
9049 error from the SunOS4 C compiler. */
049b0c3a
NC		 9050 /* PR binutils/17531: A corrupt file can trigger this test.
9051 So do not use an assert, instead generate an error message. */
9052 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9053 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9054 (int) entry->d_un.d_val);
252b5132
RH		 9055 }
9056 else if (entry->d_tag == DT_SYMINSZ)
9057 syminsz = entry->d_un.d_val;
9058 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9059 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9060 syminsz);
252b5132
RH		 9061 }
9062
9063 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9064 {
2cf0635d
NC		 9065 Elf_External_Syminfo * extsyminfo;
9066 Elf_External_Syminfo * extsym;
9067 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9068
9069 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9070 extsyminfo = (Elf_External_Syminfo *)
9071 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9072 _("symbol information"));
a6e9f9df
AM		 9073 if (!extsyminfo)
9074 return 0;
252b5132 9075
3f5e193b 9076 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9077 if (dynamic_syminfo == NULL)
9078 {
8b73c356
NC		 9079 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9080 (unsigned long) syminsz);
252b5132
RH		 9081 return 0;
9082 }
9083
9084 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9085 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9086 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9087 ++syminfo, ++extsym)
252b5132 9088 {
86dba8ee
AM		 9089 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9090 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9091 }
9092
9093 free (extsyminfo);
9094 }
9095 }
9096
9097 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9098 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9099 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9100 if (do_dynamic)
9101 printf (_(" Tag Type Name/Value\n"));
9102
86dba8ee
AM		 9103 for (entry = dynamic_section;
9104 entry < dynamic_section + dynamic_nent;
9105 entry++)
252b5132
RH		 9106 {
9107 if (do_dynamic)
f7a99963 9108 {
2cf0635d 9109 const char * dtype;
e699b9ff 9110
f7a99963
NC		 9111 putchar (' ');
9112 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9113 dtype = get_dynamic_type (entry->d_tag);
9114 printf (" (%s)%*s", dtype,
9115 ((is_32bit_elf ? 27 : 19)
9116 - (int) strlen (dtype)),
f7a99963
NC		 9117 " ");
9118 }
252b5132
RH		 9119
9120 switch (entry->d_tag)
9121 {
d1133906
NC		 9122 case DT_FLAGS:
9123 if (do_dynamic)
e9e44622 9124 print_dynamic_flags (entry->d_un.d_val);
d1133906 9125 break;
76da6bbe 9126
252b5132
RH		 9127 case DT_AUXILIARY:
9128 case DT_FILTER:
019148e4
L		 9129 case DT_CONFIG:
9130 case DT_DEPAUDIT:
9131 case DT_AUDIT:
252b5132
RH		 9132 if (do_dynamic)
9133 {
019148e4 9134 switch (entry->d_tag)
b34976b6 9135 {
019148e4
L		 9136 case DT_AUXILIARY:
9137 printf (_("Auxiliary library"));
9138 break;
9139
9140 case DT_FILTER:
9141 printf (_("Filter library"));
9142 break;
9143
b34976b6 9144 case DT_CONFIG:
019148e4
L		 9145 printf (_("Configuration file"));
9146 break;
9147
9148 case DT_DEPAUDIT:
9149 printf (_("Dependency audit library"));
9150 break;
9151
9152 case DT_AUDIT:
9153 printf (_("Audit library"));
9154 break;
9155 }
252b5132 9156
d79b3d50
NC		 9157 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9158 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9159 else
f7a99963
NC		 9160 {
9161 printf (": ");
9162 print_vma (entry->d_un.d_val, PREFIX_HEX);
9163 putchar ('\n');
9164 }
252b5132
RH		 9165 }
9166 break;
9167
dcefbbbd 9168 case DT_FEATURE:
252b5132
RH		 9169 if (do_dynamic)
9170 {
9171 printf (_("Flags:"));
86f55779 9172
252b5132
RH		 9173 if (entry->d_un.d_val == 0)
9174 printf (_(" None\n"));
9175 else
9176 {
9177 unsigned long int val = entry->d_un.d_val;
86f55779 9178
252b5132
RH		 9179 if (val & DTF_1_PARINIT)
9180 {
9181 printf (" PARINIT");
9182 val ^= DTF_1_PARINIT;
9183 }
dcefbbbd
L		 9184 if (val & DTF_1_CONFEXP)
9185 {
9186 printf (" CONFEXP");
9187 val ^= DTF_1_CONFEXP;
9188 }
252b5132
RH		 9189 if (val != 0)
9190 printf (" %lx", val);
9191 puts ("");
9192 }
9193 }
9194 break;
9195
9196 case DT_POSFLAG_1:
9197 if (do_dynamic)
9198 {
9199 printf (_("Flags:"));
86f55779 9200
252b5132
RH		 9201 if (entry->d_un.d_val == 0)
9202 printf (_(" None\n"));
9203 else
9204 {
9205 unsigned long int val = entry->d_un.d_val;
86f55779 9206
252b5132
RH		 9207 if (val & DF_P1_LAZYLOAD)
9208 {
9209 printf (" LAZYLOAD");
9210 val ^= DF_P1_LAZYLOAD;
9211 }
9212 if (val & DF_P1_GROUPPERM)
9213 {
9214 printf (" GROUPPERM");
9215 val ^= DF_P1_GROUPPERM;
9216 }
9217 if (val != 0)
9218 printf (" %lx", val);
9219 puts ("");
9220 }
9221 }
9222 break;
9223
9224 case DT_FLAGS_1:
9225 if (do_dynamic)
9226 {
9227 printf (_("Flags:"));
9228 if (entry->d_un.d_val == 0)
9229 printf (_(" None\n"));
9230 else
9231 {
9232 unsigned long int val = entry->d_un.d_val;
86f55779 9233
252b5132
RH		 9234 if (val & DF_1_NOW)
9235 {
9236 printf (" NOW");
9237 val ^= DF_1_NOW;
9238 }
9239 if (val & DF_1_GLOBAL)
9240 {
9241 printf (" GLOBAL");
9242 val ^= DF_1_GLOBAL;
9243 }
9244 if (val & DF_1_GROUP)
9245 {
9246 printf (" GROUP");
9247 val ^= DF_1_GROUP;
9248 }
9249 if (val & DF_1_NODELETE)
9250 {
9251 printf (" NODELETE");
9252 val ^= DF_1_NODELETE;
9253 }
9254 if (val & DF_1_LOADFLTR)
9255 {
9256 printf (" LOADFLTR");
9257 val ^= DF_1_LOADFLTR;
9258 }
9259 if (val & DF_1_INITFIRST)
9260 {
9261 printf (" INITFIRST");
9262 val ^= DF_1_INITFIRST;
9263 }
9264 if (val & DF_1_NOOPEN)
9265 {
9266 printf (" NOOPEN");
9267 val ^= DF_1_NOOPEN;
9268 }
9269 if (val & DF_1_ORIGIN)
9270 {
9271 printf (" ORIGIN");
9272 val ^= DF_1_ORIGIN;
9273 }
9274 if (val & DF_1_DIRECT)
9275 {
9276 printf (" DIRECT");
9277 val ^= DF_1_DIRECT;
9278 }
9279 if (val & DF_1_TRANS)
9280 {
9281 printf (" TRANS");
9282 val ^= DF_1_TRANS;
9283 }
9284 if (val & DF_1_INTERPOSE)
9285 {
9286 printf (" INTERPOSE");
9287 val ^= DF_1_INTERPOSE;
9288 }
f7db6139 9289 if (val & DF_1_NODEFLIB)
dcefbbbd 9290 {
f7db6139
L		 9291 printf (" NODEFLIB");
9292 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9293 }
9294 if (val & DF_1_NODUMP)
9295 {
9296 printf (" NODUMP");
9297 val ^= DF_1_NODUMP;
9298 }
34b60028 9299 if (val & DF_1_CONFALT)
dcefbbbd 9300 {
34b60028
L		 9301 printf (" CONFALT");
9302 val ^= DF_1_CONFALT;
9303 }
9304 if (val & DF_1_ENDFILTEE)
9305 {
9306 printf (" ENDFILTEE");
9307 val ^= DF_1_ENDFILTEE;
9308 }
9309 if (val & DF_1_DISPRELDNE)
9310 {
9311 printf (" DISPRELDNE");
9312 val ^= DF_1_DISPRELDNE;
9313 }
9314 if (val & DF_1_DISPRELPND)
9315 {
9316 printf (" DISPRELPND");
9317 val ^= DF_1_DISPRELPND;
9318 }
9319 if (val & DF_1_NODIRECT)
9320 {
9321 printf (" NODIRECT");
9322 val ^= DF_1_NODIRECT;
9323 }
9324 if (val & DF_1_IGNMULDEF)
9325 {
9326 printf (" IGNMULDEF");
9327 val ^= DF_1_IGNMULDEF;
9328 }
9329 if (val & DF_1_NOKSYMS)
9330 {
9331 printf (" NOKSYMS");
9332 val ^= DF_1_NOKSYMS;
9333 }
9334 if (val & DF_1_NOHDR)
9335 {
9336 printf (" NOHDR");
9337 val ^= DF_1_NOHDR;
9338 }
9339 if (val & DF_1_EDITED)
9340 {
9341 printf (" EDITED");
9342 val ^= DF_1_EDITED;
9343 }
9344 if (val & DF_1_NORELOC)
9345 {
9346 printf (" NORELOC");
9347 val ^= DF_1_NORELOC;
9348 }
9349 if (val & DF_1_SYMINTPOSE)
9350 {
9351 printf (" SYMINTPOSE");
9352 val ^= DF_1_SYMINTPOSE;
9353 }
9354 if (val & DF_1_GLOBAUDIT)
9355 {
9356 printf (" GLOBAUDIT");
9357 val ^= DF_1_GLOBAUDIT;
9358 }
9359 if (val & DF_1_SINGLETON)
9360 {
9361 printf (" SINGLETON");
9362 val ^= DF_1_SINGLETON;
dcefbbbd 9363 }
5c383f02
RO		 9364 if (val & DF_1_STUB)
9365 {
9366 printf (" STUB");
9367 val ^= DF_1_STUB;
9368 }
9369 if (val & DF_1_PIE)
9370 {
9371 printf (" PIE");
9372 val ^= DF_1_PIE;
9373 }
252b5132
RH		 9374 if (val != 0)
9375 printf (" %lx", val);
9376 puts ("");
9377 }
9378 }
9379 break;
9380
9381 case DT_PLTREL:
566b0d53 9382 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9383 if (do_dynamic)
9384 puts (get_dynamic_type (entry->d_un.d_val));
9385 break;
9386
9387 case DT_NULL :
9388 case DT_NEEDED :
9389 case DT_PLTGOT :
9390 case DT_HASH :
9391 case DT_STRTAB :
9392 case DT_SYMTAB :
9393 case DT_RELA :
9394 case DT_INIT :
9395 case DT_FINI :
9396 case DT_SONAME :
9397 case DT_RPATH :
9398 case DT_SYMBOLIC:
9399 case DT_REL :
9400 case DT_DEBUG :
9401 case DT_TEXTREL :
9402 case DT_JMPREL :
019148e4 9403 case DT_RUNPATH :
252b5132
RH		 9404 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9405
9406 if (do_dynamic)
9407 {
2cf0635d 9408 char * name;
252b5132 9409
d79b3d50
NC		 9410 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9411 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9412 else
d79b3d50 9413 name = NULL;
252b5132
RH		 9414
9415 if (name)
9416 {
9417 switch (entry->d_tag)
9418 {
9419 case DT_NEEDED:
9420 printf (_("Shared library: [%s]"), name);
9421
18bd398b 9422 if (streq (name, program_interpreter))
f7a99963 9423 printf (_(" program interpreter"));
252b5132
RH		 9424 break;
9425
9426 case DT_SONAME:
f7a99963 9427 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9428 break;
9429
9430 case DT_RPATH:
f7a99963 9431 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9432 break;
9433
019148e4
L		 9434 case DT_RUNPATH:
9435 printf (_("Library runpath: [%s]"), name);
9436 break;
9437
252b5132 9438 default:
f7a99963
NC		 9439 print_vma (entry->d_un.d_val, PREFIX_HEX);
9440 break;
252b5132
RH		 9441 }
9442 }
9443 else
f7a99963
NC		 9444 print_vma (entry->d_un.d_val, PREFIX_HEX);
9445
9446 putchar ('\n');
252b5132
RH		 9447 }
9448 break;
9449
9450 case DT_PLTRELSZ:
9451 case DT_RELASZ :
9452 case DT_STRSZ :
9453 case DT_RELSZ :
9454 case DT_RELAENT :
9455 case DT_SYMENT :
9456 case DT_RELENT :
566b0d53 9457 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9458 case DT_PLTPADSZ:
9459 case DT_MOVEENT :
9460 case DT_MOVESZ :
9461 case DT_INIT_ARRAYSZ:
9462 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9463 case DT_GNU_CONFLICTSZ:
9464 case DT_GNU_LIBLISTSZ:
252b5132 9465 if (do_dynamic)
f7a99963
NC		 9466 {
9467 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9468 printf (_(" (bytes)\n"));
f7a99963 9469 }
252b5132
RH		 9470 break;
9471
9472 case DT_VERDEFNUM:
9473 case DT_VERNEEDNUM:
9474 case DT_RELACOUNT:
9475 case DT_RELCOUNT:
9476 if (do_dynamic)
f7a99963
NC		 9477 {
9478 print_vma (entry->d_un.d_val, UNSIGNED);
9479 putchar ('\n');
9480 }
252b5132
RH		 9481 break;
9482
9483 case DT_SYMINSZ:
9484 case DT_SYMINENT:
9485 case DT_SYMINFO:
9486 case DT_USED:
9487 case DT_INIT_ARRAY:
9488 case DT_FINI_ARRAY:
9489 if (do_dynamic)
9490 {
d79b3d50
NC		 9491 if (entry->d_tag == DT_USED
9492 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9493 {
2cf0635d 9494 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9495
b34976b6 9496 if (*name)
252b5132
RH		 9497 {
9498 printf (_("Not needed object: [%s]\n"), name);
9499 break;
9500 }
9501 }
103f02d3 9502
f7a99963
NC		 9503 print_vma (entry->d_un.d_val, PREFIX_HEX);
9504 putchar ('\n');
252b5132
RH		 9505 }
9506 break;
9507
9508 case DT_BIND_NOW:
9509 /* The value of this entry is ignored. */
35b1837e
AM		 9510 if (do_dynamic)
9511 putchar ('\n');
252b5132 9512 break;
103f02d3 9513
047b2264
JJ		 9514 case DT_GNU_PRELINKED:
9515 if (do_dynamic)
9516 {
2cf0635d 9517 struct tm * tmp;
91d6fa6a 9518 time_t atime = entry->d_un.d_val;
047b2264 9519
91d6fa6a 9520 tmp = gmtime (&atime);
071436c6
NC		 9521 /* PR 17533 file: 041-1244816-0.004. */
9522 if (tmp == NULL)
5a2cbcf4
L		 9523 printf (_("<corrupt time val: %lx"),
9524 (unsigned long) atime);
071436c6
NC		 9525 else
9526 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9527 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9528 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9529
9530 }
9531 break;
9532
fdc90cb4
JJ		 9533 case DT_GNU_HASH:
9534 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9535 if (do_dynamic)
9536 {
9537 print_vma (entry->d_un.d_val, PREFIX_HEX);
9538 putchar ('\n');
9539 }
9540 break;
9541
252b5132
RH		 9542 default:
9543 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9544 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9545 entry->d_un.d_val;
9546
9547 if (do_dynamic)
9548 {
9549 switch (elf_header.e_machine)
9550 {
9551 case EM_MIPS:
4fe85591 9552 case EM_MIPS_RS3_LE:
b2d38a17 9553 dynamic_section_mips_val (entry);
252b5132 9554 break;
103f02d3 9555 case EM_PARISC:
b2d38a17 9556 dynamic_section_parisc_val (entry);
103f02d3 9557 break;
ecc51f48 9558 case EM_IA_64:
b2d38a17 9559 dynamic_section_ia64_val (entry);
ecc51f48 9560 break;
252b5132 9561 default:
f7a99963
NC		 9562 print_vma (entry->d_un.d_val, PREFIX_HEX);
9563 putchar ('\n');
252b5132
RH		 9564 }
9565 }
9566 break;
9567 }
9568 }
9569
9570 return 1;
9571}
9572
9573static char *
d3ba0551 9574get_ver_flags (unsigned int flags)
252b5132 9575{
b34976b6 9576 static char buff[32];
252b5132
RH		 9577
9578 buff[0] = 0;
9579
9580 if (flags == 0)
9581 return _("none");
9582
9583 if (flags & VER_FLG_BASE)
9584 strcat (buff, "BASE ");
9585
9586 if (flags & VER_FLG_WEAK)
9587 {
9588 if (flags & VER_FLG_BASE)
9589 strcat (buff, "| ");
9590
9591 strcat (buff, "WEAK ");
9592 }
9593
44ec90b9
RO		 9594 if (flags & VER_FLG_INFO)
9595 {
9596 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9597 strcat (buff, "| ");
9598
9599 strcat (buff, "INFO ");
9600 }
9601
9602 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9603 strcat (buff, _("| <unknown>"));
252b5132
RH		 9604
9605 return buff;
9606}
9607
9608/* Display the contents of the version sections. */
98fb390a 9609
252b5132 9610static int
2cf0635d 9611process_version_sections (FILE * file)
252b5132 9612{
2cf0635d 9613 Elf_Internal_Shdr * section;
b34976b6
AM		 9614 unsigned i;
9615 int found = 0;
252b5132
RH		 9616
9617 if (! do_version)
9618 return 1;
9619
9620 for (i = 0, section = section_headers;
9621 i < elf_header.e_shnum;
b34976b6 9622 i++, section++)
252b5132
RH		 9623 {
9624 switch (section->sh_type)
9625 {
9626 case SHT_GNU_verdef:
9627 {
2cf0635d 9628 Elf_External_Verdef * edefs;
b34976b6
AM		 9629 unsigned int idx;
9630 unsigned int cnt;
2cf0635d 9631 char * endbuf;
252b5132
RH		 9632
9633 found = 1;
9634
74e1a04b
NC		 9635 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9636 printable_section_name (section),
9637 section->sh_info);
252b5132
RH		 9638
9639 printf (_(" Addr: 0x"));
9640 printf_vma (section->sh_addr);
74e1a04b 9641 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9642 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9643 printable_section_name_from_index (section->sh_link));
252b5132 9644
3f5e193b
NC		 9645 edefs = (Elf_External_Verdef *)
9646 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9647 _("version definition section"));
a6e9f9df
AM		 9648 if (!edefs)
9649 break;
59245841 9650 endbuf = (char *) edefs + section->sh_size;
252b5132 9651
b34976b6 9652 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9653 {
2cf0635d
NC		 9654 char * vstart;
9655 Elf_External_Verdef * edef;
b34976b6 9656 Elf_Internal_Verdef ent;
2cf0635d 9657 Elf_External_Verdaux * eaux;
b34976b6
AM		 9658 Elf_Internal_Verdaux aux;
9659 int j;
9660 int isum;
103f02d3 9661
7e26601c
NC		 9662 /* Check for very large indicies. */
9663 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9664 break;
9665
252b5132 9666 vstart = ((char *) edefs) + idx;
54806181
AM		 9667 if (vstart + sizeof (*edef) > endbuf)
9668 break;
252b5132
RH		 9669
9670 edef = (Elf_External_Verdef *) vstart;
9671
9672 ent.vd_version = BYTE_GET (edef->vd_version);
9673 ent.vd_flags = BYTE_GET (edef->vd_flags);
9674 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9675 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9676 ent.vd_hash = BYTE_GET (edef->vd_hash);
9677 ent.vd_aux = BYTE_GET (edef->vd_aux);
9678 ent.vd_next = BYTE_GET (edef->vd_next);
9679
9680 printf (_(" %#06x: Rev: %d Flags: %s"),
9681 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9682
9683 printf (_(" Index: %d Cnt: %d "),
9684 ent.vd_ndx, ent.vd_cnt);
9685
dd24e3da 9686 /* Check for overflow. */
7e26601c 9687 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9688 break;
9689
252b5132
RH		 9690 vstart += ent.vd_aux;
9691
9692 eaux = (Elf_External_Verdaux *) vstart;
9693
9694 aux.vda_name = BYTE_GET (eaux->vda_name);
9695 aux.vda_next = BYTE_GET (eaux->vda_next);
9696
d79b3d50
NC		 9697 if (VALID_DYNAMIC_NAME (aux.vda_name))
9698 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9699 else
9700 printf (_("Name index: %ld\n"), aux.vda_name);
9701
9702 isum = idx + ent.vd_aux;
9703
b34976b6 9704 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9705 {
dd24e3da 9706 /* Check for overflow. */
7e26601c 9707 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9708 break;
9709
252b5132
RH		 9710 isum += aux.vda_next;
9711 vstart += aux.vda_next;
9712
9713 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9714 if (vstart + sizeof (*eaux) > endbuf)
9715 break;
252b5132
RH		 9716
9717 aux.vda_name = BYTE_GET (eaux->vda_name);
9718 aux.vda_next = BYTE_GET (eaux->vda_next);
9719
d79b3d50 9720 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9721 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9722 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9723 else
9724 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9725 isum, j, aux.vda_name);
9726 }
dd24e3da 9727
54806181
AM		 9728 if (j < ent.vd_cnt)
9729 printf (_(" Version def aux past end of section\n"));
252b5132 9730
5d921cbd
NC		 9731 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9732 if (idx + ent.vd_next <= idx)
9733 break;
9734
252b5132
RH		 9735 idx += ent.vd_next;
9736 }
dd24e3da 9737
54806181
AM		 9738 if (cnt < section->sh_info)
9739 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9740
9741 free (edefs);
9742 }
9743 break;
103f02d3 9744
252b5132
RH		 9745 case SHT_GNU_verneed:
9746 {
2cf0635d 9747 Elf_External_Verneed * eneed;
b34976b6
AM		 9748 unsigned int idx;
9749 unsigned int cnt;
2cf0635d 9750 char * endbuf;
252b5132
RH		 9751
9752 found = 1;
9753
72de5009 9754 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9755 printable_section_name (section), section->sh_info);
252b5132
RH		 9756
9757 printf (_(" Addr: 0x"));
9758 printf_vma (section->sh_addr);
72de5009 9759 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9760 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9761 printable_section_name_from_index (section->sh_link));
252b5132 9762
3f5e193b
NC		 9763 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9764 section->sh_offset, 1,
9765 section->sh_size,
9cf03b7e 9766 _("Version Needs section"));
a6e9f9df
AM		 9767 if (!eneed)
9768 break;
59245841 9769 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9770
9771 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9772 {
2cf0635d 9773 Elf_External_Verneed * entry;
b34976b6
AM		 9774 Elf_Internal_Verneed ent;
9775 int j;
9776 int isum;
2cf0635d 9777 char * vstart;
252b5132 9778
7e26601c 9779 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9780 break;
9781
252b5132 9782 vstart = ((char *) eneed) + idx;
54806181
AM		 9783 if (vstart + sizeof (*entry) > endbuf)
9784 break;
252b5132
RH		 9785
9786 entry = (Elf_External_Verneed *) vstart;
9787
9788 ent.vn_version = BYTE_GET (entry->vn_version);
9789 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9790 ent.vn_file = BYTE_GET (entry->vn_file);
9791 ent.vn_aux = BYTE_GET (entry->vn_aux);
9792 ent.vn_next = BYTE_GET (entry->vn_next);
9793
9794 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9795
d79b3d50
NC		 9796 if (VALID_DYNAMIC_NAME (ent.vn_file))
9797 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9798 else
9799 printf (_(" File: %lx"), ent.vn_file);
9800
9801 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9802
dd24e3da 9803 /* Check for overflow. */
7e26601c 9804 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9805 break;
252b5132
RH		 9806 vstart += ent.vn_aux;
9807
9808 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9809 {
2cf0635d 9810 Elf_External_Vernaux * eaux;
b34976b6 9811 Elf_Internal_Vernaux aux;
252b5132 9812
54806181
AM		 9813 if (vstart + sizeof (*eaux) > endbuf)
9814 break;
252b5132
RH		 9815 eaux = (Elf_External_Vernaux *) vstart;
9816
9817 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9818 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9819 aux.vna_other = BYTE_GET (eaux->vna_other);
9820 aux.vna_name = BYTE_GET (eaux->vna_name);
9821 aux.vna_next = BYTE_GET (eaux->vna_next);
9822
d79b3d50 9823 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9824 printf (_(" %#06x: Name: %s"),
d79b3d50 9825 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9826 else
ecc2063b 9827 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9828 isum, aux.vna_name);
9829
9830 printf (_(" Flags: %s Version: %d\n"),
9831 get_ver_flags (aux.vna_flags), aux.vna_other);
9832
dd24e3da 9833 /* Check for overflow. */
53774b7e
NC		 9834 if (aux.vna_next > (size_t) (endbuf - vstart)
9835 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9836 {
9837 warn (_("Invalid vna_next field of %lx\n"),
9838 aux.vna_next);
9839 j = ent.vn_cnt;
9840 break;
9841 }
252b5132
RH		 9842 isum += aux.vna_next;
9843 vstart += aux.vna_next;
9844 }
9cf03b7e 9845
54806181 9846 if (j < ent.vn_cnt)
9cf03b7e 9847 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9848
bcf83b2a 9849 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9850 {
9851 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9852 cnt = section->sh_info;
9853 break;
9854 }
252b5132
RH		 9855 idx += ent.vn_next;
9856 }
9cf03b7e 9857
54806181 9858 if (cnt < section->sh_info)
9cf03b7e 9859 warn (_("Missing Version Needs information\n"));
103f02d3 9860
252b5132
RH		 9861 free (eneed);
9862 }
9863 break;
9864
9865 case SHT_GNU_versym:
9866 {
2cf0635d 9867 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9868 size_t total;
9869 unsigned int cnt;
2cf0635d
NC		 9870 unsigned char * edata;
9871 unsigned short * data;
9872 char * strtab;
9873 Elf_Internal_Sym * symbols;
9874 Elf_Internal_Shdr * string_sec;
ba5cdace 9875 unsigned long num_syms;
d3ba0551 9876 long off;
252b5132 9877
4fbb74a6 9878 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9879 break;
9880
4fbb74a6 9881 link_section = section_headers + section->sh_link;
08d8fa11 9882 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9883
4fbb74a6 9884 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9885 break;
9886
252b5132
RH		 9887 found = 1;
9888
ba5cdace 9889 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9890 if (symbols == NULL)
9891 break;
252b5132 9892
4fbb74a6 9893 string_sec = section_headers + link_section->sh_link;
252b5132 9894
3f5e193b
NC		 9895 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9896 string_sec->sh_size,
9897 _("version string table"));
a6e9f9df 9898 if (!strtab)
0429c154
MS		 9899 {
9900 free (symbols);
9901 break;
9902 }
252b5132 9903
8b73c356
NC		 9904 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9905 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9906
9907 printf (_(" Addr: "));
9908 printf_vma (section->sh_addr);
72de5009 9909 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9910 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9911 printable_section_name (link_section));
252b5132 9912
d3ba0551
AM		 9913 off = offset_from_vma (file,
9914 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9915 total * sizeof (short));
3f5e193b
NC		 9916 edata = (unsigned char *) get_data (NULL, file, off, total,
9917 sizeof (short),
9918 _("version symbol data"));
a6e9f9df
AM		 9919 if (!edata)
9920 {
9921 free (strtab);
0429c154 9922 free (symbols);
a6e9f9df
AM		 9923 break;
9924 }
252b5132 9925
3f5e193b 9926 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9927
9928 for (cnt = total; cnt --;)
b34976b6
AM		 9929 data[cnt] = byte_get (edata + cnt * sizeof (short),
9930 sizeof (short));
252b5132
RH		 9931
9932 free (edata);
9933
9934 for (cnt = 0; cnt < total; cnt += 4)
9935 {
9936 int j, nn;
ab273396
AM		 9937 char *name;
9938 char *invalid = _("*invalid*");
252b5132
RH		 9939
9940 printf (" %03x:", cnt);
9941
9942 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9943 switch (data[cnt + j])
252b5132
RH		 9944 {
9945 case 0:
9946 fputs (_(" 0 (*local*) "), stdout);
9947 break;
9948
9949 case 1:
9950 fputs (_(" 1 (*global*) "), stdout);
9951 break;
9952
9953 default:
c244d050
NC		 9954 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9955 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9956
dd24e3da 9957 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9958 array, break to avoid an out-of-bounds read. */
9959 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9960 {
9961 warn (_("invalid index into symbol array\n"));
9962 break;
9963 }
9964
ab273396
AM		 9965 name = NULL;
9966 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9967 {
b34976b6
AM		 9968 Elf_Internal_Verneed ivn;
9969 unsigned long offset;
252b5132 9970
d93f0186
NC		 9971 offset = offset_from_vma
9972 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9973 sizeof (Elf_External_Verneed));
252b5132 9974
b34976b6 9975 do
252b5132 9976 {
b34976b6
AM		 9977 Elf_Internal_Vernaux ivna;
9978 Elf_External_Verneed evn;
9979 Elf_External_Vernaux evna;
9980 unsigned long a_off;
252b5132 9981
59245841
NC		 9982 if (get_data (&evn, file, offset, sizeof (evn), 1,
9983 _("version need")) == NULL)
9984 break;
0b4362b0 9985
252b5132
RH		 9986 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9987 ivn.vn_next = BYTE_GET (evn.vn_next);
9988
9989 a_off = offset + ivn.vn_aux;
9990
9991 do
9992 {
59245841
NC		 9993 if (get_data (&evna, file, a_off, sizeof (evna),
9994 1, _("version need aux (2)")) == NULL)
9995 {
9996 ivna.vna_next = 0;
9997 ivna.vna_other = 0;
9998 }
9999 else
10000 {
10001 ivna.vna_next = BYTE_GET (evna.vna_next);
10002 ivna.vna_other = BYTE_GET (evna.vna_other);
10003 }
252b5132
RH		 10004
10005 a_off += ivna.vna_next;
10006 }
b34976b6 10007 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 10008 && ivna.vna_next != 0);
10009
b34976b6 10010 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 10011 {
10012 ivna.vna_name = BYTE_GET (evna.vna_name);
10013
54806181 10014 if (ivna.vna_name >= string_sec->sh_size)
ab273396 10015 name = invalid;
54806181
AM		 10016 else
10017 name = strtab + ivna.vna_name;
252b5132
RH		 10018 break;
10019 }
10020
10021 offset += ivn.vn_next;
10022 }
10023 while (ivn.vn_next);
10024 }
00d93f34 10025
ab273396 10026 if (data[cnt + j] != 0x8001
b34976b6 10027 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10028 {
b34976b6
AM		 10029 Elf_Internal_Verdef ivd;
10030 Elf_External_Verdef evd;
10031 unsigned long offset;
252b5132 10032
d93f0186
NC		 10033 offset = offset_from_vma
10034 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10035 sizeof evd);
252b5132
RH		 10036
10037 do
10038 {
59245841
NC		 10039 if (get_data (&evd, file, offset, sizeof (evd), 1,
10040 _("version def")) == NULL)
10041 {
10042 ivd.vd_next = 0;
948f632f 10043 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10044 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10045 break;
59245841
NC		 10046 }
10047 else
10048 {
10049 ivd.vd_next = BYTE_GET (evd.vd_next);
10050 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10051 }
252b5132
RH		 10052
10053 offset += ivd.vd_next;
10054 }
c244d050 10055 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10056 && ivd.vd_next != 0);
10057
c244d050 10058 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10059 {
b34976b6
AM		 10060 Elf_External_Verdaux evda;
10061 Elf_Internal_Verdaux ivda;
252b5132
RH		 10062
10063 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10064
59245841
NC		 10065 if (get_data (&evda, file,
10066 offset - ivd.vd_next + ivd.vd_aux,
10067 sizeof (evda), 1,
10068 _("version def aux")) == NULL)
10069 break;
252b5132
RH		 10070
10071 ivda.vda_name = BYTE_GET (evda.vda_name);
10072
54806181 10073 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10074 name = invalid;
10075 else if (name != NULL && name != invalid)
10076 name = _("*both*");
54806181
AM		 10077 else
10078 name = strtab + ivda.vda_name;
252b5132
RH		 10079 }
10080 }
ab273396
AM		 10081 if (name != NULL)
10082 nn += printf ("(%s%-*s",
10083 name,
10084 12 - (int) strlen (name),
10085 ")");
252b5132
RH		 10086
10087 if (nn < 18)
10088 printf ("%*c", 18 - nn, ' ');
10089 }
10090
10091 putchar ('\n');
10092 }
10093
10094 free (data);
10095 free (strtab);
10096 free (symbols);
10097 }
10098 break;
103f02d3 10099
252b5132
RH		 10100 default:
10101 break;
10102 }
10103 }
10104
10105 if (! found)
10106 printf (_("\nNo version information found in this file.\n"));
10107
10108 return 1;
10109}
10110
d1133906 10111static const char *
d3ba0551 10112get_symbol_binding (unsigned int binding)
252b5132 10113{
b34976b6 10114 static char buff[32];
252b5132
RH		 10115
10116 switch (binding)
10117 {
b34976b6
AM		 10118 case STB_LOCAL: return "LOCAL";
10119 case STB_GLOBAL: return "GLOBAL";
10120 case STB_WEAK: return "WEAK";
252b5132
RH		 10121 default:
10122 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10123 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10124 binding);
252b5132 10125 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10126 {
10127 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10128 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10129 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10130 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10131 return "UNIQUE";
10132 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10133 }
252b5132 10134 else
e9e44622 10135 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10136 return buff;
10137 }
10138}
10139
d1133906 10140static const char *
d3ba0551 10141get_symbol_type (unsigned int type)
252b5132 10142{
b34976b6 10143 static char buff[32];
252b5132
RH		 10144
10145 switch (type)
10146 {
b34976b6
AM		 10147 case STT_NOTYPE: return "NOTYPE";
10148 case STT_OBJECT: return "OBJECT";
10149 case STT_FUNC: return "FUNC";
10150 case STT_SECTION: return "SECTION";
10151 case STT_FILE: return "FILE";
10152 case STT_COMMON: return "COMMON";
10153 case STT_TLS: return "TLS";
15ab5209
DB		 10154 case STT_RELC: return "RELC";
10155 case STT_SRELC: return "SRELC";
252b5132
RH		 10156 default:
10157 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10158 {
3510a7b8
NC		 10159 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10160 return "THUMB_FUNC";
103f02d3 10161
351b4b40 10162 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10163 return "REGISTER";
10164
10165 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10166 return "PARISC_MILLI";
10167
e9e44622 10168 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10169 }
252b5132 10170 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10171 {
10172 if (elf_header.e_machine == EM_PARISC)
10173 {
10174 if (type == STT_HP_OPAQUE)
10175 return "HP_OPAQUE";
10176 if (type == STT_HP_STUB)
10177 return "HP_STUB";
10178 }
10179
d8045f23 10180 if (type == STT_GNU_IFUNC
9c55345c 10181 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10182 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10183 /* GNU is still using the default value 0. */
d8045f23
NC		 10184 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10185 return "IFUNC";
10186
e9e44622 10187 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10188 }
252b5132 10189 else
e9e44622 10190 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10191 return buff;
10192 }
10193}
10194
d1133906 10195static const char *
d3ba0551 10196get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10197{
10198 switch (visibility)
10199 {
b34976b6
AM		 10200 case STV_DEFAULT: return "DEFAULT";
10201 case STV_INTERNAL: return "INTERNAL";
10202 case STV_HIDDEN: return "HIDDEN";
d1133906 10203 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10204 default:
10205 error (_("Unrecognized visibility value: %u"), visibility);
10206 return _("<unknown>");
d1133906
NC		 10207 }
10208}
10209
5e2b0d47
NC		 10210static const char *
10211get_mips_symbol_other (unsigned int other)
10212{
10213 switch (other)
10214 {
df58fc94
RS		 10215 case STO_OPTIONAL:
10216 return "OPTIONAL";
10217 case STO_MIPS_PLT:
10218 return "MIPS PLT";
10219 case STO_MIPS_PIC:
10220 return "MIPS PIC";
10221 case STO_MICROMIPS:
10222 return "MICROMIPS";
10223 case STO_MICROMIPS | STO_MIPS_PIC:
10224 return "MICROMIPS, MIPS PIC";
10225 case STO_MIPS16:
10226 return "MIPS16";
10227 default:
10228 return NULL;
5e2b0d47
NC		 10229 }
10230}
10231
28f997cf
TG		 10232static const char *
10233get_ia64_symbol_other (unsigned int other)
10234{
10235 if (is_ia64_vms ())
10236 {
10237 static char res[32];
10238
10239 res[0] = 0;
10240
10241 /* Function types is for images and .STB files only. */
10242 switch (elf_header.e_type)
10243 {
10244 case ET_DYN:
10245 case ET_EXEC:
10246 switch (VMS_ST_FUNC_TYPE (other))
10247 {
10248 case VMS_SFT_CODE_ADDR:
10249 strcat (res, " CA");
10250 break;
10251 case VMS_SFT_SYMV_IDX:
10252 strcat (res, " VEC");
10253 break;
10254 case VMS_SFT_FD:
10255 strcat (res, " FD");
10256 break;
10257 case VMS_SFT_RESERVE:
10258 strcat (res, " RSV");
10259 break;
10260 default:
bee0ee85
NC		 10261 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10262 VMS_ST_FUNC_TYPE (other));
10263 strcat (res, " <unknown>");
10264 break;
28f997cf
TG		 10265 }
10266 break;
10267 default:
10268 break;
10269 }
10270 switch (VMS_ST_LINKAGE (other))
10271 {
10272 case VMS_STL_IGNORE:
10273 strcat (res, " IGN");
10274 break;
10275 case VMS_STL_RESERVE:
10276 strcat (res, " RSV");
10277 break;
10278 case VMS_STL_STD:
10279 strcat (res, " STD");
10280 break;
10281 case VMS_STL_LNK:
10282 strcat (res, " LNK");
10283 break;
10284 default:
bee0ee85
NC		 10285 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10286 VMS_ST_LINKAGE (other));
10287 strcat (res, " <unknown>");
10288 break;
28f997cf
TG		 10289 }
10290
10291 if (res[0] != 0)
10292 return res + 1;
10293 else
10294 return res;
10295 }
10296 return NULL;
10297}
10298
6911b7dc
AM		 10299static const char *
10300get_ppc64_symbol_other (unsigned int other)
10301{
10302 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10303 {
10304 static char buf[32];
10305 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10306 PPC64_LOCAL_ENTRY_OFFSET (other));
10307 return buf;
10308 }
10309 return NULL;
10310}
10311
5e2b0d47
NC		 10312static const char *
10313get_symbol_other (unsigned int other)
10314{
10315 const char * result = NULL;
10316 static char buff [32];
10317
10318 if (other == 0)
10319 return "";
10320
10321 switch (elf_header.e_machine)
10322 {
10323 case EM_MIPS:
10324 result = get_mips_symbol_other (other);
28f997cf
TG		 10325 break;
10326 case EM_IA_64:
10327 result = get_ia64_symbol_other (other);
10328 break;
6911b7dc
AM		 10329 case EM_PPC64:
10330 result = get_ppc64_symbol_other (other);
10331 break;
5e2b0d47
NC		 10332 default:
10333 break;
10334 }
10335
10336 if (result)
10337 return result;
10338
10339 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10340 return buff;
10341}
10342
d1133906 10343static const char *
d3ba0551 10344get_symbol_index_type (unsigned int type)
252b5132 10345{
b34976b6 10346 static char buff[32];
5cf1065c 10347
252b5132
RH		 10348 switch (type)
10349 {
b34976b6
AM		 10350 case SHN_UNDEF: return "UND";
10351 case SHN_ABS: return "ABS";
10352 case SHN_COMMON: return "COM";
252b5132 10353 default:
9ce701e2
L		 10354 if (type == SHN_IA_64_ANSI_COMMON
10355 && elf_header.e_machine == EM_IA_64
10356 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10357 return "ANSI_COM";
8a9036a4 10358 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10359 || elf_header.e_machine == EM_L1OM
10360 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10361 && type == SHN_X86_64_LCOMMON)
10362 return "LARGE_COM";
ac145307
BS		 10363 else if ((type == SHN_MIPS_SCOMMON
10364 && elf_header.e_machine == EM_MIPS)
10365 || (type == SHN_TIC6X_SCOMMON
10366 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10367 return "SCOM";
10368 else if (type == SHN_MIPS_SUNDEFINED
10369 && elf_header.e_machine == EM_MIPS)
10370 return "SUND";
9ce701e2 10371 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10372 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10373 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10374 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10375 else if (type >= SHN_LORESERVE)
10376 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10377 else if (type >= elf_header.e_shnum)
e0a31db1 10378 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10379 else
232e7cb8 10380 sprintf (buff, "%3d", type);
5cf1065c 10381 break;
252b5132 10382 }
5cf1065c
NC		 10383
10384 return buff;
252b5132
RH		 10385}
10386
66543521 10387static bfd_vma *
57028622 10388get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10389{
2cf0635d
NC		 10390 unsigned char * e_data;
10391 bfd_vma * i_data;
252b5132 10392
57028622
NC		 10393 /* If the size_t type is smaller than the bfd_size_type, eg because
10394 you are building a 32-bit tool on a 64-bit host, then make sure
10395 that when (number) is cast to (size_t) no information is lost. */
10396 if (sizeof (size_t) < sizeof (bfd_size_type)
10397 && (bfd_size_type) ((size_t) number) != number)
10398 {
10399 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10400 (unsigned long long) number, ent_size);
10401 return NULL;
10402 }
948f632f 10403
3102e897
NC		 10404 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10405 attempting to allocate memory when the read is bound to fail. */
10406 if (ent_size * number > current_file_size)
10407 {
57028622
NC		 10408 error (_("Invalid number of dynamic entries: %llu\n"),
10409 (unsigned long long) number);
3102e897
NC		 10410 return NULL;
10411 }
10412
57028622 10413 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10414 if (e_data == NULL)
10415 {
57028622
NC		 10416 error (_("Out of memory reading %llu dynamic entries\n"),
10417 (unsigned long long) number);
252b5132
RH		 10418 return NULL;
10419 }
10420
57028622 10421 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10422 {
57028622
NC		 10423 error (_("Unable to read in %llu bytes of dynamic data\n"),
10424 (unsigned long long) (number * ent_size));
3102e897 10425 free (e_data);
252b5132
RH		 10426 return NULL;
10427 }
10428
57028622 10429 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10430 if (i_data == NULL)
10431 {
57028622
NC		 10432 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10433 (unsigned long long) number);
252b5132
RH		 10434 free (e_data);
10435 return NULL;
10436 }
10437
10438 while (number--)
66543521 10439 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10440
10441 free (e_data);
10442
10443 return i_data;
10444}
10445
6bd1a22c
L		 10446static void
10447print_dynamic_symbol (bfd_vma si, unsigned long hn)
10448{
2cf0635d 10449 Elf_Internal_Sym * psym;
6bd1a22c
L		 10450 int n;
10451
6bd1a22c
L		 10452 n = print_vma (si, DEC_5);
10453 if (n < 5)
0b4362b0 10454 fputs (&" "[n], stdout);
6bd1a22c 10455 printf (" %3lu: ", hn);
e0a31db1
NC		 10456
10457 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10458 {
3102e897
NC		 10459 printf (_("<No info available for dynamic symbol number %lu>\n"),
10460 (unsigned long) si);
e0a31db1
NC		 10461 return;
10462 }
10463
10464 psym = dynamic_symbols + si;
6bd1a22c
L		 10465 print_vma (psym->st_value, LONG_HEX);
10466 putchar (' ');
10467 print_vma (psym->st_size, DEC_5);
10468
f4be36b3
AM		 10469 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10470 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10471 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10472 /* Check to see if any other bits in the st_other field are set.
10473 Note - displaying this information disrupts the layout of the
10474 table being generated, but for the moment this case is very
10475 rare. */
10476 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10477 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10478 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10479 if (VALID_DYNAMIC_NAME (psym->st_name))
10480 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10481 else
2b692964 10482 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10483 putchar ('\n');
10484}
10485
bb4d2ac2
L		 10486static const char *
10487get_symbol_version_string (FILE *file, int is_dynsym,
10488 const char *strtab,
10489 unsigned long int strtab_size,
10490 unsigned int si, Elf_Internal_Sym *psym,
10491 enum versioned_symbol_info *sym_info,
10492 unsigned short *vna_other)
10493{
ab273396
AM		 10494 unsigned char data[2];
10495 unsigned short vers_data;
10496 unsigned long offset;
bb4d2ac2 10497
ab273396
AM		 10498 if (!is_dynsym
10499 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10500 return NULL;
bb4d2ac2 10501
ab273396
AM		 10502 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10503 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10504
ab273396
AM		 10505 if (get_data (&data, file, offset + si * sizeof (vers_data),
10506 sizeof (data), 1, _("version data")) == NULL)
10507 return NULL;
10508
10509 vers_data = byte_get (data, 2);
bb4d2ac2 10510
ab273396
AM		 10511 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10512 return NULL;
bb4d2ac2 10513
ab273396
AM		 10514 /* Usually we'd only see verdef for defined symbols, and verneed for
10515 undefined symbols. However, symbols defined by the linker in
10516 .dynbss for variables copied from a shared library in order to
10517 avoid text relocations are defined yet have verneed. We could
10518 use a heuristic to detect the special case, for example, check
10519 for verneed first on symbols defined in SHT_NOBITS sections, but
10520 it is simpler and more reliable to just look for both verdef and
10521 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10522
ab273396
AM		 10523 if (psym->st_shndx != SHN_UNDEF
10524 && vers_data != 0x8001
10525 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10526 {
10527 Elf_Internal_Verdef ivd;
10528 Elf_Internal_Verdaux ivda;
10529 Elf_External_Verdaux evda;
10530 unsigned long off;
bb4d2ac2 10531
ab273396
AM		 10532 off = offset_from_vma (file,
10533 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10534 sizeof (Elf_External_Verdef));
10535
10536 do
bb4d2ac2 10537 {
ab273396
AM		 10538 Elf_External_Verdef evd;
10539
10540 if (get_data (&evd, file, off, sizeof (evd), 1,
10541 _("version def")) == NULL)
10542 {
10543 ivd.vd_ndx = 0;
10544 ivd.vd_aux = 0;
10545 ivd.vd_next = 0;
10546 }
10547 else
bb4d2ac2 10548 {
ab273396
AM		 10549 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10550 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10551 ivd.vd_next = BYTE_GET (evd.vd_next);
10552 }
bb4d2ac2 10553
ab273396
AM		 10554 off += ivd.vd_next;
10555 }
10556 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10557
ab273396
AM		 10558 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10559 {
10560 off -= ivd.vd_next;
10561 off += ivd.vd_aux;
bb4d2ac2 10562
ab273396
AM		 10563 if (get_data (&evda, file, off, sizeof (evda), 1,
10564 _("version def aux")) != NULL)
10565 {
10566 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10567
ab273396
AM		 10568 if (psym->st_name != ivda.vda_name)
10569 {
10570 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10571 ? symbol_hidden : symbol_public);
10572 return (ivda.vda_name < strtab_size
10573 ? strtab + ivda.vda_name : _("<corrupt>"));
10574 }
10575 }
10576 }
10577 }
bb4d2ac2 10578
ab273396
AM		 10579 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10580 {
10581 Elf_External_Verneed evn;
10582 Elf_Internal_Verneed ivn;
10583 Elf_Internal_Vernaux ivna;
bb4d2ac2 10584
ab273396
AM		 10585 offset = offset_from_vma (file,
10586 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10587 sizeof evn);
10588 do
10589 {
10590 unsigned long vna_off;
bb4d2ac2 10591
ab273396
AM		 10592 if (get_data (&evn, file, offset, sizeof (evn), 1,
10593 _("version need")) == NULL)
10594 {
10595 ivna.vna_next = 0;
10596 ivna.vna_other = 0;
10597 ivna.vna_name = 0;
10598 break;
10599 }
bb4d2ac2 10600
ab273396
AM		 10601 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10602 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 10603
ab273396 10604 vna_off = offset + ivn.vn_aux;
bb4d2ac2 10605
ab273396
AM		 10606 do
10607 {
10608 Elf_External_Vernaux evna;
bb4d2ac2 10609
ab273396
AM		 10610 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10611 _("version need aux (3)")) == NULL)
bb4d2ac2 10612 {
ab273396
AM		 10613 ivna.vna_next = 0;
10614 ivna.vna_other = 0;
10615 ivna.vna_name = 0;
bb4d2ac2 10616 }
bb4d2ac2 10617 else
bb4d2ac2 10618 {
ab273396
AM		 10619 ivna.vna_other = BYTE_GET (evna.vna_other);
10620 ivna.vna_next = BYTE_GET (evna.vna_next);
10621 ivna.vna_name = BYTE_GET (evna.vna_name);
10622 }
bb4d2ac2 10623
ab273396
AM		 10624 vna_off += ivna.vna_next;
10625 }
10626 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 10627
ab273396
AM		 10628 if (ivna.vna_other == vers_data)
10629 break;
bb4d2ac2 10630
ab273396
AM		 10631 offset += ivn.vn_next;
10632 }
10633 while (ivn.vn_next != 0);
bb4d2ac2 10634
ab273396
AM		 10635 if (ivna.vna_other == vers_data)
10636 {
10637 *sym_info = symbol_undefined;
10638 *vna_other = ivna.vna_other;
10639 return (ivna.vna_name < strtab_size
10640 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 10641 }
10642 }
ab273396 10643 return NULL;
bb4d2ac2
L		 10644}
10645
e3c8793a 10646/* Dump the symbol table. */
252b5132 10647static int
2cf0635d 10648process_symbol_table (FILE * file)
252b5132 10649{
2cf0635d 10650 Elf_Internal_Shdr * section;
8b73c356
NC		 10651 bfd_size_type nbuckets = 0;
10652 bfd_size_type nchains = 0;
2cf0635d
NC		 10653 bfd_vma * buckets = NULL;
10654 bfd_vma * chains = NULL;
fdc90cb4 10655 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10656 bfd_vma * gnubuckets = NULL;
10657 bfd_vma * gnuchains = NULL;
6bd1a22c 10658 bfd_vma gnusymidx = 0;
071436c6 10659 bfd_size_type ngnuchains = 0;
252b5132 10660
2c610e4b 10661 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10662 return 1;
10663
6bd1a22c
L		 10664 if (dynamic_info[DT_HASH]
10665 && (do_histogram
2c610e4b
L		 10666 || (do_using_dynamic
10667 && !do_dyn_syms
10668 && dynamic_strings != NULL)))
252b5132 10669 {
66543521
AM		 10670 unsigned char nb[8];
10671 unsigned char nc[8];
8b73c356 10672 unsigned int hash_ent_size = 4;
66543521
AM		 10673
10674 if ((elf_header.e_machine == EM_ALPHA
10675 || elf_header.e_machine == EM_S390
10676 || elf_header.e_machine == EM_S390_OLD)
10677 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10678 hash_ent_size = 8;
10679
fb52b2f4
NC		 10680 if (fseek (file,
10681 (archive_file_offset
10682 + offset_from_vma (file, dynamic_info[DT_HASH],
10683 sizeof nb + sizeof nc)),
d93f0186 10684 SEEK_SET))
252b5132 10685 {
591a748a 10686 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10687 goto no_hash;
252b5132
RH		 10688 }
10689
66543521 10690 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10691 {
10692 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10693 goto no_hash;
252b5132
RH		 10694 }
10695
66543521 10696 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10697 {
10698 error (_("Failed to read in number of chains\n"));
d3a44ec6 10699 goto no_hash;
252b5132
RH		 10700 }
10701
66543521
AM		 10702 nbuckets = byte_get (nb, hash_ent_size);
10703 nchains = byte_get (nc, hash_ent_size);
252b5132 10704
66543521
AM		 10705 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10706 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10707
d3a44ec6 10708 no_hash:
252b5132 10709 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10710 {
10711 if (do_using_dynamic)
10712 return 0;
10713 free (buckets);
10714 free (chains);
10715 buckets = NULL;
10716 chains = NULL;
10717 nbuckets = 0;
10718 nchains = 0;
10719 }
252b5132
RH		 10720 }
10721
6bd1a22c
L		 10722 if (dynamic_info_DT_GNU_HASH
10723 && (do_histogram
2c610e4b
L		 10724 || (do_using_dynamic
10725 && !do_dyn_syms
10726 && dynamic_strings != NULL)))
252b5132 10727 {
6bd1a22c
L		 10728 unsigned char nb[16];
10729 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10730 bfd_vma buckets_vma;
10731
10732 if (fseek (file,
10733 (archive_file_offset
10734 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10735 sizeof nb)),
10736 SEEK_SET))
10737 {
10738 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10739 goto no_gnu_hash;
6bd1a22c 10740 }
252b5132 10741
6bd1a22c
L		 10742 if (fread (nb, 16, 1, file) != 1)
10743 {
10744 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10745 goto no_gnu_hash;
6bd1a22c
L		 10746 }
10747
10748 ngnubuckets = byte_get (nb, 4);
10749 gnusymidx = byte_get (nb + 4, 4);
10750 bitmaskwords = byte_get (nb + 8, 4);
10751 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10752 if (is_32bit_elf)
6bd1a22c 10753 buckets_vma += bitmaskwords * 4;
f7a99963 10754 else
6bd1a22c 10755 buckets_vma += bitmaskwords * 8;
252b5132 10756
6bd1a22c
L		 10757 if (fseek (file,
10758 (archive_file_offset
10759 + offset_from_vma (file, buckets_vma, 4)),
10760 SEEK_SET))
252b5132 10761 {
6bd1a22c 10762 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10763 goto no_gnu_hash;
6bd1a22c
L		 10764 }
10765
10766 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10767
6bd1a22c 10768 if (gnubuckets == NULL)
d3a44ec6 10769 goto no_gnu_hash;
6bd1a22c
L		 10770
10771 for (i = 0; i < ngnubuckets; i++)
10772 if (gnubuckets[i] != 0)
10773 {
10774 if (gnubuckets[i] < gnusymidx)
10775 return 0;
10776
10777 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10778 maxchain = gnubuckets[i];
10779 }
10780
10781 if (maxchain == 0xffffffff)
d3a44ec6 10782 goto no_gnu_hash;
6bd1a22c
L		 10783
10784 maxchain -= gnusymidx;
10785
10786 if (fseek (file,
10787 (archive_file_offset
10788 + offset_from_vma (file, buckets_vma
10789 + 4 * (ngnubuckets + maxchain), 4)),
10790 SEEK_SET))
10791 {
10792 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10793 goto no_gnu_hash;
6bd1a22c
L		 10794 }
10795
10796 do
10797 {
10798 if (fread (nb, 4, 1, file) != 1)
252b5132 10799 {
6bd1a22c 10800 error (_("Failed to determine last chain length\n"));
d3a44ec6 10801 goto no_gnu_hash;
6bd1a22c 10802 }
252b5132 10803
6bd1a22c 10804 if (maxchain + 1 == 0)
d3a44ec6 10805 goto no_gnu_hash;
252b5132 10806
6bd1a22c
L		 10807 ++maxchain;
10808 }
10809 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10810
6bd1a22c
L		 10811 if (fseek (file,
10812 (archive_file_offset
10813 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10814 SEEK_SET))
10815 {
10816 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10817 goto no_gnu_hash;
6bd1a22c
L		 10818 }
10819
10820 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10821 ngnuchains = maxchain;
6bd1a22c 10822
d3a44ec6 10823 no_gnu_hash:
6bd1a22c 10824 if (gnuchains == NULL)
d3a44ec6
JJ		 10825 {
10826 free (gnubuckets);
d3a44ec6
JJ		 10827 gnubuckets = NULL;
10828 ngnubuckets = 0;
f64fddf1
NC		 10829 if (do_using_dynamic)
10830 return 0;
d3a44ec6 10831 }
6bd1a22c
L		 10832 }
10833
10834 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10835 && do_syms
10836 && do_using_dynamic
3102e897
NC		 10837 && dynamic_strings != NULL
10838 && dynamic_symbols != NULL)
6bd1a22c
L		 10839 {
10840 unsigned long hn;
10841
10842 if (dynamic_info[DT_HASH])
10843 {
10844 bfd_vma si;
10845
10846 printf (_("\nSymbol table for image:\n"));
10847 if (is_32bit_elf)
10848 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10849 else
10850 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10851
10852 for (hn = 0; hn < nbuckets; hn++)
10853 {
10854 if (! buckets[hn])
10855 continue;
10856
10857 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10858 print_dynamic_symbol (si, hn);
252b5132
RH		 10859 }
10860 }
6bd1a22c
L		 10861
10862 if (dynamic_info_DT_GNU_HASH)
10863 {
10864 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10865 if (is_32bit_elf)
10866 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10867 else
10868 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10869
10870 for (hn = 0; hn < ngnubuckets; ++hn)
10871 if (gnubuckets[hn] != 0)
10872 {
10873 bfd_vma si = gnubuckets[hn];
10874 bfd_vma off = si - gnusymidx;
10875
10876 do
10877 {
10878 print_dynamic_symbol (si, hn);
10879 si++;
10880 }
071436c6 10881 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10882 }
10883 }
252b5132 10884 }
8b73c356
NC		 10885 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10886 && section_headers != NULL)
252b5132 10887 {
b34976b6 10888 unsigned int i;
252b5132
RH		 10889
10890 for (i = 0, section = section_headers;
10891 i < elf_header.e_shnum;
10892 i++, section++)
10893 {
b34976b6 10894 unsigned int si;
2cf0635d 10895 char * strtab = NULL;
c256ffe7 10896 unsigned long int strtab_size = 0;
2cf0635d
NC		 10897 Elf_Internal_Sym * symtab;
10898 Elf_Internal_Sym * psym;
ba5cdace 10899 unsigned long num_syms;
252b5132 10900
2c610e4b
L		 10901 if ((section->sh_type != SHT_SYMTAB
10902 && section->sh_type != SHT_DYNSYM)
10903 || (!do_syms
10904 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10905 continue;
10906
dd24e3da
NC		 10907 if (section->sh_entsize == 0)
10908 {
10909 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10910 printable_section_name (section));
dd24e3da
NC		 10911 continue;
10912 }
10913
252b5132 10914 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10915 printable_section_name (section),
252b5132 10916 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10917
f7a99963 10918 if (is_32bit_elf)
ca47b30c 10919 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10920 else
ca47b30c 10921 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10922
ba5cdace 10923 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10924 if (symtab == NULL)
10925 continue;
10926
10927 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10928 {
10929 strtab = string_table;
10930 strtab_size = string_table_length;
10931 }
4fbb74a6 10932 else if (section->sh_link < elf_header.e_shnum)
252b5132 10933 {
2cf0635d 10934 Elf_Internal_Shdr * string_sec;
252b5132 10935
4fbb74a6 10936 string_sec = section_headers + section->sh_link;
252b5132 10937
3f5e193b
NC		 10938 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10939 1, string_sec->sh_size,
10940 _("string table"));
c256ffe7 10941 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10942 }
10943
ba5cdace 10944 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10945 {
bb4d2ac2
L		 10946 const char *version_string;
10947 enum versioned_symbol_info sym_info;
10948 unsigned short vna_other;
10949
5e220199 10950 printf ("%6d: ", si);
f7a99963
NC		 10951 print_vma (psym->st_value, LONG_HEX);
10952 putchar (' ');
10953 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10954 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10955 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10956 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10957 /* Check to see if any other bits in the st_other field are set.
10958 Note - displaying this information disrupts the layout of the
10959 table being generated, but for the moment this case is very rare. */
10960 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10961 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10962 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10963 print_symbol (25, psym->st_name < strtab_size
2b692964 10964 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10965
bb4d2ac2
L		 10966 version_string
10967 = get_symbol_version_string (file,
10968 section->sh_type == SHT_DYNSYM,
10969 strtab, strtab_size, si,
10970 psym, &sym_info, &vna_other);
10971 if (version_string)
252b5132 10972 {
bb4d2ac2
L		 10973 if (sym_info == symbol_undefined)
10974 printf ("@%s (%d)", version_string, vna_other);
10975 else
10976 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10977 version_string);
252b5132
RH		 10978 }
10979
10980 putchar ('\n');
10981 }
10982
10983 free (symtab);
10984 if (strtab != string_table)
10985 free (strtab);
10986 }
10987 }
10988 else if (do_syms)
10989 printf
10990 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10991
10992 if (do_histogram && buckets != NULL)
10993 {
2cf0635d
NC		 10994 unsigned long * lengths;
10995 unsigned long * counts;
66543521
AM		 10996 unsigned long hn;
10997 bfd_vma si;
10998 unsigned long maxlength = 0;
10999 unsigned long nzero_counts = 0;
11000 unsigned long nsyms = 0;
94d15024 11001 unsigned long chained;
252b5132 11002
66543521
AM		 11003 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11004 (unsigned long) nbuckets);
252b5132 11005
3f5e193b 11006 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 11007 if (lengths == NULL)
11008 {
8b73c356 11009 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 11010 return 0;
11011 }
8b73c356
NC		 11012
11013 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 11014 for (hn = 0; hn < nbuckets; ++hn)
11015 {
94d15024
MF		 11016 for (si = buckets[hn], chained = 0;
11017 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11018 si = chains[si], ++chained)
252b5132 11019 {
b34976b6 11020 ++nsyms;
252b5132 11021 if (maxlength < ++lengths[hn])
b34976b6 11022 ++maxlength;
252b5132 11023 }
94d15024
MF		 11024
11025 /* PR binutils/17531: A corrupt binary could contain broken
11026 histogram data. Do not go into an infinite loop trying
11027 to process it. */
11028 if (chained > nchains)
11029 {
11030 error (_("histogram chain is corrupt\n"));
11031 break;
11032 }
252b5132
RH		 11033 }
11034
3f5e193b 11035 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11036 if (counts == NULL)
11037 {
b2e951ec 11038 free (lengths);
8b73c356 11039 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 11040 return 0;
11041 }
11042
11043 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11044 ++counts[lengths[hn]];
252b5132 11045
103f02d3 11046 if (nbuckets > 0)
252b5132 11047 {
66543521
AM		 11048 unsigned long i;
11049 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11050 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11051 for (i = 1; i <= maxlength; ++i)
103f02d3 11052 {
66543521
AM		 11053 nzero_counts += counts[i] * i;
11054 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11055 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11056 (nzero_counts * 100.0) / nsyms);
11057 }
252b5132
RH		 11058 }
11059
11060 free (counts);
11061 free (lengths);
11062 }
11063
11064 if (buckets != NULL)
11065 {
11066 free (buckets);
11067 free (chains);
11068 }
11069
d3a44ec6 11070 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11071 {
2cf0635d
NC		 11072 unsigned long * lengths;
11073 unsigned long * counts;
fdc90cb4
JJ		 11074 unsigned long hn;
11075 unsigned long maxlength = 0;
11076 unsigned long nzero_counts = 0;
11077 unsigned long nsyms = 0;
fdc90cb4 11078
8b73c356
NC		 11079 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11080 (unsigned long) ngnubuckets);
11081
3f5e193b 11082 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11083 if (lengths == NULL)
11084 {
8b73c356 11085 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11086 return 0;
11087 }
11088
fdc90cb4
JJ		 11089 printf (_(" Length Number %% of total Coverage\n"));
11090
11091 for (hn = 0; hn < ngnubuckets; ++hn)
11092 if (gnubuckets[hn] != 0)
11093 {
11094 bfd_vma off, length = 1;
11095
6bd1a22c 11096 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11097 /* PR 17531 file: 010-77222-0.004. */
11098 off < ngnuchains && (gnuchains[off] & 1) == 0;
11099 ++off)
fdc90cb4
JJ		 11100 ++length;
11101 lengths[hn] = length;
11102 if (length > maxlength)
11103 maxlength = length;
11104 nsyms += length;
11105 }
11106
3f5e193b 11107 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11108 if (counts == NULL)
11109 {
b2e951ec 11110 free (lengths);
8b73c356 11111 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11112 return 0;
11113 }
11114
11115 for (hn = 0; hn < ngnubuckets; ++hn)
11116 ++counts[lengths[hn]];
11117
11118 if (ngnubuckets > 0)
11119 {
11120 unsigned long j;
11121 printf (" 0 %-10lu (%5.1f%%)\n",
11122 counts[0], (counts[0] * 100.0) / ngnubuckets);
11123 for (j = 1; j <= maxlength; ++j)
11124 {
11125 nzero_counts += counts[j] * j;
11126 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11127 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11128 (nzero_counts * 100.0) / nsyms);
11129 }
11130 }
11131
11132 free (counts);
11133 free (lengths);
11134 free (gnubuckets);
11135 free (gnuchains);
11136 }
11137
252b5132
RH		 11138 return 1;
11139}
11140
11141static int
2cf0635d 11142process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11143{
b4c96d0d 11144 unsigned int i;
252b5132
RH		 11145
11146 if (dynamic_syminfo == NULL
11147 || !do_dynamic)
11148 /* No syminfo, this is ok. */
11149 return 1;
11150
11151 /* There better should be a dynamic symbol section. */
11152 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11153 return 0;
11154
11155 if (dynamic_addr)
11156 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11157 dynamic_syminfo_offset, dynamic_syminfo_nent);
11158
11159 printf (_(" Num: Name BoundTo Flags\n"));
11160 for (i = 0; i < dynamic_syminfo_nent; ++i)
11161 {
11162 unsigned short int flags = dynamic_syminfo[i].si_flags;
11163
31104126 11164 printf ("%4d: ", i);
4082ef84
NC		 11165 if (i >= num_dynamic_syms)
11166 printf (_("<corrupt index>"));
11167 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11168 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11169 else
2b692964 11170 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11171 putchar (' ');
252b5132
RH		 11172
11173 switch (dynamic_syminfo[i].si_boundto)
11174 {
11175 case SYMINFO_BT_SELF:
11176 fputs ("SELF ", stdout);
11177 break;
11178 case SYMINFO_BT_PARENT:
11179 fputs ("PARENT ", stdout);
11180 break;
11181 default:
11182 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11183 && dynamic_syminfo[i].si_boundto < dynamic_nent
11184 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11185 {
d79b3d50 11186 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11187 putchar (' ' );
11188 }
252b5132
RH		 11189 else
11190 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11191 break;
11192 }
11193
11194 if (flags & SYMINFO_FLG_DIRECT)
11195 printf (" DIRECT");
11196 if (flags & SYMINFO_FLG_PASSTHRU)
11197 printf (" PASSTHRU");
11198 if (flags & SYMINFO_FLG_COPY)
11199 printf (" COPY");
11200 if (flags & SYMINFO_FLG_LAZYLOAD)
11201 printf (" LAZYLOAD");
11202
11203 puts ("");
11204 }
11205
11206 return 1;
11207}
11208
cf13d699
NC		 11209/* Check to see if the given reloc needs to be handled in a target specific
11210 manner. If so then process the reloc and return TRUE otherwise return
11211 FALSE. */
09c11c86 11212
cf13d699
NC		 11213static bfd_boolean
11214target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11215 unsigned char * start,
11216 Elf_Internal_Sym * symtab)
252b5132 11217{
cf13d699 11218 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11219
cf13d699 11220 switch (elf_header.e_machine)
252b5132 11221 {
13761a11
NC		 11222 case EM_MSP430:
11223 case EM_MSP430_OLD:
11224 {
11225 static Elf_Internal_Sym * saved_sym = NULL;
11226
11227 switch (reloc_type)
11228 {
11229 case 10: /* R_MSP430_SYM_DIFF */
11230 if (uses_msp430x_relocs ())
11231 break;
11232 case 21: /* R_MSP430X_SYM_DIFF */
11233 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11234 return TRUE;
11235
11236 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11237 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11238 goto handle_sym_diff;
0b4362b0 11239
13761a11
NC		 11240 case 5: /* R_MSP430_16_BYTE */
11241 case 9: /* R_MSP430_8 */
11242 if (uses_msp430x_relocs ())
11243 break;
11244 goto handle_sym_diff;
11245
11246 case 2: /* R_MSP430_ABS16 */
11247 case 15: /* R_MSP430X_ABS16 */
11248 if (! uses_msp430x_relocs ())
11249 break;
11250 goto handle_sym_diff;
0b4362b0 11251
13761a11
NC		 11252 handle_sym_diff:
11253 if (saved_sym != NULL)
11254 {
11255 bfd_vma value;
11256
11257 value = reloc->r_addend
11258 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11259 - saved_sym->st_value);
11260
11261 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11262
11263 saved_sym = NULL;
11264 return TRUE;
11265 }
11266 break;
11267
11268 default:
11269 if (saved_sym != NULL)
071436c6 11270 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11271 break;
11272 }
11273 break;
11274 }
11275
cf13d699
NC		 11276 case EM_MN10300:
11277 case EM_CYGNUS_MN10300:
11278 {
11279 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11280
cf13d699
NC		 11281 switch (reloc_type)
11282 {
11283 case 34: /* R_MN10300_ALIGN */
11284 return TRUE;
11285 case 33: /* R_MN10300_SYM_DIFF */
11286 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11287 return TRUE;
11288 case 1: /* R_MN10300_32 */
11289 case 2: /* R_MN10300_16 */
11290 if (saved_sym != NULL)
11291 {
11292 bfd_vma value;
252b5132 11293
cf13d699
NC		 11294 value = reloc->r_addend
11295 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11296 - saved_sym->st_value);
252b5132 11297
cf13d699 11298 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11299
cf13d699
NC		 11300 saved_sym = NULL;
11301 return TRUE;
11302 }
11303 break;
11304 default:
11305 if (saved_sym != NULL)
071436c6 11306 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11307 break;
11308 }
11309 break;
11310 }
6ff71e76
NC		 11311
11312 case EM_RL78:
11313 {
11314 static bfd_vma saved_sym1 = 0;
11315 static bfd_vma saved_sym2 = 0;
11316 static bfd_vma value;
11317
11318 switch (reloc_type)
11319 {
11320 case 0x80: /* R_RL78_SYM. */
11321 saved_sym1 = saved_sym2;
11322 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11323 saved_sym2 += reloc->r_addend;
11324 return TRUE;
11325
11326 case 0x83: /* R_RL78_OPsub. */
11327 value = saved_sym1 - saved_sym2;
11328 saved_sym2 = saved_sym1 = 0;
11329 return TRUE;
11330 break;
11331
11332 case 0x41: /* R_RL78_ABS32. */
11333 byte_put (start + reloc->r_offset, value, 4);
11334 value = 0;
11335 return TRUE;
11336
11337 case 0x43: /* R_RL78_ABS16. */
11338 byte_put (start + reloc->r_offset, value, 2);
11339 value = 0;
11340 return TRUE;
11341
11342 default:
11343 break;
11344 }
11345 break;
11346 }
252b5132
RH		 11347 }
11348
cf13d699 11349 return FALSE;
252b5132
RH		 11350}
11351
aca88567
NC		 11352/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11353 DWARF debug sections. This is a target specific test. Note - we do not
11354 go through the whole including-target-headers-multiple-times route, (as
11355 we have already done with <elf/h8.h>) because this would become very
11356 messy and even then this function would have to contain target specific
11357 information (the names of the relocs instead of their numeric values).
11358 FIXME: This is not the correct way to solve this problem. The proper way
11359 is to have target specific reloc sizing and typing functions created by
11360 the reloc-macros.h header, in the same way that it already creates the
11361 reloc naming functions. */
11362
11363static bfd_boolean
11364is_32bit_abs_reloc (unsigned int reloc_type)
11365{
11366 switch (elf_header.e_machine)
11367 {
41e92641 11368 case EM_386:
22abe556 11369 case EM_IAMCU:
41e92641 11370 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11371 case EM_68K:
11372 return reloc_type == 1; /* R_68K_32. */
11373 case EM_860:
11374 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11375 case EM_960:
11376 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11377 case EM_AARCH64:
11378 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11379 case EM_ALPHA:
137b6b5f 11380 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11381 case EM_ARC:
11382 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11383 case EM_ARC_COMPACT:
11384 case EM_ARC_COMPACT2:
11385 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11386 case EM_ARM:
11387 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11388 case EM_AVR_OLD:
aca88567
NC		 11389 case EM_AVR:
11390 return reloc_type == 1;
cfb8c092
NC		 11391 case EM_ADAPTEVA_EPIPHANY:
11392 return reloc_type == 3;
aca88567
NC		 11393 case EM_BLACKFIN:
11394 return reloc_type == 0x12; /* R_byte4_data. */
11395 case EM_CRIS:
11396 return reloc_type == 3; /* R_CRIS_32. */
11397 case EM_CR16:
11398 return reloc_type == 3; /* R_CR16_NUM32. */
11399 case EM_CRX:
11400 return reloc_type == 15; /* R_CRX_NUM32. */
11401 case EM_CYGNUS_FRV:
11402 return reloc_type == 1;
41e92641
NC		 11403 case EM_CYGNUS_D10V:
11404 case EM_D10V:
11405 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11406 case EM_CYGNUS_D30V:
11407 case EM_D30V:
11408 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11409 case EM_DLX:
11410 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11411 case EM_CYGNUS_FR30:
11412 case EM_FR30:
11413 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11414 case EM_FT32:
11415 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11416 case EM_H8S:
11417 case EM_H8_300:
11418 case EM_H8_300H:
11419 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11420 case EM_IA_64:
d1c4b12b
NC		 11421 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11422 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11423 case EM_IP2K_OLD:
11424 case EM_IP2K:
11425 return reloc_type == 2; /* R_IP2K_32. */
11426 case EM_IQ2000:
11427 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11428 case EM_LATTICEMICO32:
11429 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11430 case EM_M32C_OLD:
aca88567
NC		 11431 case EM_M32C:
11432 return reloc_type == 3; /* R_M32C_32. */
11433 case EM_M32R:
11434 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 11435 case EM_68HC11:
11436 case EM_68HC12:
11437 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 11438 case EM_MCORE:
11439 return reloc_type == 1; /* R_MCORE_ADDR32. */
11440 case EM_CYGNUS_MEP:
11441 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11442 case EM_METAG:
11443 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11444 case EM_MICROBLAZE:
11445 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11446 case EM_MIPS:
11447 return reloc_type == 2; /* R_MIPS_32. */
11448 case EM_MMIX:
11449 return reloc_type == 4; /* R_MMIX_32. */
11450 case EM_CYGNUS_MN10200:
11451 case EM_MN10200:
11452 return reloc_type == 1; /* R_MN10200_32. */
11453 case EM_CYGNUS_MN10300:
11454 case EM_MN10300:
11455 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11456 case EM_MOXIE:
11457 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11458 case EM_MSP430_OLD:
11459 case EM_MSP430:
13761a11 11460 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11461 case EM_MT:
11462 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11463 case EM_NDS32:
11464 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11465 case EM_ALTERA_NIOS2:
36591ba1 11466 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11467 case EM_NIOS32:
11468 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11469 case EM_OR1K:
11470 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11471 case EM_PARISC:
5fda8eca
NC		 11472 return (reloc_type == 1 /* R_PARISC_DIR32. */
11473 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11474 case EM_PJ:
11475 case EM_PJ_OLD:
11476 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11477 case EM_PPC64:
11478 return reloc_type == 1; /* R_PPC64_ADDR32. */
11479 case EM_PPC:
11480 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11481 case EM_RL78:
11482 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11483 case EM_RX:
11484 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11485 case EM_S370:
11486 return reloc_type == 1; /* R_I370_ADDR31. */
11487 case EM_S390_OLD:
11488 case EM_S390:
11489 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11490 case EM_SCORE:
11491 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11492 case EM_SH:
11493 return reloc_type == 1; /* R_SH_DIR32. */
11494 case EM_SPARC32PLUS:
11495 case EM_SPARCV9:
11496 case EM_SPARC:
11497 return reloc_type == 3 /* R_SPARC_32. */
11498 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11499 case EM_SPU:
11500 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11501 case EM_TI_C6000:
11502 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11503 case EM_TILEGX:
11504 return reloc_type == 2; /* R_TILEGX_32. */
11505 case EM_TILEPRO:
11506 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11507 case EM_CYGNUS_V850:
11508 case EM_V850:
11509 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11510 case EM_V800:
11511 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11512 case EM_VAX:
11513 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11514 case EM_VISIUM:
11515 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11516 case EM_X86_64:
8a9036a4 11517 case EM_L1OM:
7a9068fe 11518 case EM_K1OM:
aca88567 11519 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11520 case EM_XC16X:
11521 case EM_C166:
11522 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11523 case EM_XGATE:
11524 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11525 case EM_XSTORMY16:
11526 return reloc_type == 1; /* R_XSTROMY16_32. */
11527 case EM_XTENSA_OLD:
11528 case EM_XTENSA:
11529 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11530 default:
bee0ee85
NC		 11531 {
11532 static unsigned int prev_warn = 0;
11533
11534 /* Avoid repeating the same warning multiple times. */
11535 if (prev_warn != elf_header.e_machine)
11536 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11537 elf_header.e_machine);
11538 prev_warn = elf_header.e_machine;
11539 return FALSE;
11540 }
aca88567
NC		 11541 }
11542}
11543
11544/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11545 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11546
11547static bfd_boolean
11548is_32bit_pcrel_reloc (unsigned int reloc_type)
11549{
11550 switch (elf_header.e_machine)
11551 {
41e92641 11552 case EM_386:
22abe556 11553 case EM_IAMCU:
3e0873ac 11554 return reloc_type == 2; /* R_386_PC32. */
aca88567 11555 case EM_68K:
3e0873ac 11556 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11557 case EM_AARCH64:
11558 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11559 case EM_ADAPTEVA_EPIPHANY:
11560 return reloc_type == 6;
aca88567
NC		 11561 case EM_ALPHA:
11562 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11563 case EM_ARM:
3e0873ac 11564 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11565 case EM_MICROBLAZE:
11566 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11567 case EM_OR1K:
11568 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11569 case EM_PARISC:
85acf597 11570 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11571 case EM_PPC:
11572 return reloc_type == 26; /* R_PPC_REL32. */
11573 case EM_PPC64:
3e0873ac 11574 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11575 case EM_S390_OLD:
11576 case EM_S390:
3e0873ac 11577 return reloc_type == 5; /* R_390_PC32. */
aca88567 11578 case EM_SH:
3e0873ac 11579 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11580 case EM_SPARC32PLUS:
11581 case EM_SPARCV9:
11582 case EM_SPARC:
3e0873ac 11583 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11584 case EM_SPU:
11585 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11586 case EM_TILEGX:
11587 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11588 case EM_TILEPRO:
11589 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11590 case EM_VISIUM:
11591 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11592 case EM_X86_64:
8a9036a4 11593 case EM_L1OM:
7a9068fe 11594 case EM_K1OM:
3e0873ac 11595 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11596 case EM_XTENSA_OLD:
11597 case EM_XTENSA:
11598 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11599 default:
11600 /* Do not abort or issue an error message here. Not all targets use
11601 pc-relative 32-bit relocs in their DWARF debug information and we
11602 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11603 more helpful warning message will be generated by apply_relocations
11604 anyway, so just return. */
aca88567
NC		 11605 return FALSE;
11606 }
11607}
11608
11609/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11610 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11611
11612static bfd_boolean
11613is_64bit_abs_reloc (unsigned int reloc_type)
11614{
11615 switch (elf_header.e_machine)
11616 {
a06ea964
NC		 11617 case EM_AARCH64:
11618 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11619 case EM_ALPHA:
11620 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11621 case EM_IA_64:
11622 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11623 case EM_PARISC:
11624 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11625 case EM_PPC64:
11626 return reloc_type == 38; /* R_PPC64_ADDR64. */
11627 case EM_SPARC32PLUS:
11628 case EM_SPARCV9:
11629 case EM_SPARC:
11630 return reloc_type == 54; /* R_SPARC_UA64. */
11631 case EM_X86_64:
8a9036a4 11632 case EM_L1OM:
7a9068fe 11633 case EM_K1OM:
aca88567 11634 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11635 case EM_S390_OLD:
11636 case EM_S390:
aa137e4d
NC		 11637 return reloc_type == 22; /* R_S390_64. */
11638 case EM_TILEGX:
11639 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11640 case EM_MIPS:
aa137e4d 11641 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11642 default:
11643 return FALSE;
11644 }
11645}
11646
85acf597
RH		 11647/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11648 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11649
11650static bfd_boolean
11651is_64bit_pcrel_reloc (unsigned int reloc_type)
11652{
11653 switch (elf_header.e_machine)
11654 {
a06ea964
NC		 11655 case EM_AARCH64:
11656 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11657 case EM_ALPHA:
aa137e4d 11658 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11659 case EM_IA_64:
aa137e4d 11660 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11661 case EM_PARISC:
aa137e4d 11662 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11663 case EM_PPC64:
aa137e4d 11664 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11665 case EM_SPARC32PLUS:
11666 case EM_SPARCV9:
11667 case EM_SPARC:
aa137e4d 11668 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11669 case EM_X86_64:
8a9036a4 11670 case EM_L1OM:
7a9068fe 11671 case EM_K1OM:
aa137e4d 11672 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11673 case EM_S390_OLD:
11674 case EM_S390:
aa137e4d
NC		 11675 return reloc_type == 23; /* R_S390_PC64. */
11676 case EM_TILEGX:
11677 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11678 default:
11679 return FALSE;
11680 }
11681}
11682
4dc3c23d
AM		 11683/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11684 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11685
11686static bfd_boolean
11687is_24bit_abs_reloc (unsigned int reloc_type)
11688{
11689 switch (elf_header.e_machine)
11690 {
11691 case EM_CYGNUS_MN10200:
11692 case EM_MN10200:
11693 return reloc_type == 4; /* R_MN10200_24. */
11694 default:
11695 return FALSE;
11696 }
11697}
11698
aca88567
NC		 11699/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11700 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11701
11702static bfd_boolean
11703is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11704{
11705 switch (elf_header.e_machine)
11706 {
886a2506
NC		 11707 case EM_ARC:
11708 case EM_ARC_COMPACT:
11709 case EM_ARC_COMPACT2:
11710 return reloc_type == 2; /* R_ARC_16. */
aca88567
NC		 11711 case EM_AVR_OLD:
11712 case EM_AVR:
11713 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11714 case EM_ADAPTEVA_EPIPHANY:
11715 return reloc_type == 5;
41e92641
NC		 11716 case EM_CYGNUS_D10V:
11717 case EM_D10V:
11718 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11719 case EM_H8S:
11720 case EM_H8_300:
11721 case EM_H8_300H:
aca88567
NC		 11722 return reloc_type == R_H8_DIR16;
11723 case EM_IP2K_OLD:
11724 case EM_IP2K:
11725 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11726 case EM_M32C_OLD:
f4236fe4
DD		 11727 case EM_M32C:
11728 return reloc_type == 1; /* R_M32C_16 */
aca88567 11729 case EM_MSP430:
13761a11
NC		 11730 if (uses_msp430x_relocs ())
11731 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11732 case EM_MSP430_OLD:
aca88567 11733 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11734 case EM_NDS32:
11735 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11736 case EM_ALTERA_NIOS2:
36591ba1 11737 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11738 case EM_NIOS32:
11739 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11740 case EM_OR1K:
11741 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11742 case EM_TI_C6000:
11743 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11744 case EM_XC16X:
11745 case EM_C166:
11746 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11747 case EM_CYGNUS_MN10200:
11748 case EM_MN10200:
11749 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11750 case EM_CYGNUS_MN10300:
11751 case EM_MN10300:
11752 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11753 case EM_VISIUM:
11754 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11755 case EM_XGATE:
11756 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11757 default:
aca88567 11758 return FALSE;
4b78141a
NC		 11759 }
11760}
11761
2a7b2e88
JK		 11762/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11763 relocation entries (possibly formerly used for SHT_GROUP sections). */
11764
11765static bfd_boolean
11766is_none_reloc (unsigned int reloc_type)
11767{
11768 switch (elf_header.e_machine)
11769 {
cb8f3167
NC		 11770 case EM_68K: /* R_68K_NONE. */
11771 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11772 case EM_SPARC32PLUS:
11773 case EM_SPARCV9:
cb8f3167
NC		 11774 case EM_SPARC: /* R_SPARC_NONE. */
11775 case EM_MIPS: /* R_MIPS_NONE. */
11776 case EM_PARISC: /* R_PARISC_NONE. */
11777 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11778 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11779 case EM_PPC: /* R_PPC_NONE. */
11780 case EM_PPC64: /* R_PPC64_NONE. */
886a2506
NC		 11781 case EM_ARC: /* R_ARC_NONE. */
11782 case EM_ARC_COMPACT: /* R_ARC_NONE. */
11783 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
cb8f3167
NC		 11784 case EM_ARM: /* R_ARM_NONE. */
11785 case EM_IA_64: /* R_IA64_NONE. */
11786 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11787 case EM_S390_OLD:
cb8f3167
NC		 11788 case EM_S390: /* R_390_NONE. */
11789 case EM_CRIS: /* R_CRIS_NONE. */
11790 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11791 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11792 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11793 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11794 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11795 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11796 case EM_M32R: /* R_M32R_NONE. */
40b36596 11797 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11798 case EM_TILEGX: /* R_TILEGX_NONE. */
11799 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11800 case EM_XC16X:
11801 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11802 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11803 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11804 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11805 return reloc_type == 0;
a06ea964
NC		 11806 case EM_AARCH64:
11807 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11808 case EM_NDS32:
11809 return (reloc_type == 0 /* R_XTENSA_NONE. */
11810 || reloc_type == 204 /* R_NDS32_DIFF8. */
11811 || reloc_type == 205 /* R_NDS32_DIFF16. */
11812 || reloc_type == 206 /* R_NDS32_DIFF32. */
11813 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11814 case EM_XTENSA_OLD:
11815 case EM_XTENSA:
4dc3c23d
AM		 11816 return (reloc_type == 0 /* R_XTENSA_NONE. */
11817 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11818 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11819 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11820 case EM_METAG:
11821 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11822 }
11823 return FALSE;
11824}
11825
d1c4b12b
NC		 11826/* Returns TRUE if there is a relocation against
11827 section NAME at OFFSET bytes. */
11828
11829bfd_boolean
11830reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11831{
11832 Elf_Internal_Rela * relocs;
11833 Elf_Internal_Rela * rp;
11834
11835 if (dsec == NULL || dsec->reloc_info == NULL)
11836 return FALSE;
11837
11838 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11839
11840 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11841 if (rp->r_offset == offset)
11842 return TRUE;
11843
11844 return FALSE;
11845}
11846
cf13d699
NC		 11847/* Apply relocations to a section.
11848 Note: So far support has been added only for those relocations
11849 which can be found in debug sections.
d1c4b12b
NC		 11850 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11851 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11852 FIXME: Add support for more relocations ? */
1b315056 11853
cf13d699 11854static void
d1c4b12b
NC		 11855apply_relocations (void * file,
11856 const Elf_Internal_Shdr * section,
11857 unsigned char * start,
11858 bfd_size_type size,
11859 void ** relocs_return,
11860 unsigned long * num_relocs_return)
1b315056 11861{
cf13d699 11862 Elf_Internal_Shdr * relsec;
0d2a7a93 11863 unsigned char * end = start + size;
cb8f3167 11864
d1c4b12b
NC		 11865 if (relocs_return != NULL)
11866 {
11867 * (Elf_Internal_Rela **) relocs_return = NULL;
11868 * num_relocs_return = 0;
11869 }
11870
cf13d699
NC		 11871 if (elf_header.e_type != ET_REL)
11872 return;
1b315056 11873
cf13d699 11874 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11875 for (relsec = section_headers;
11876 relsec < section_headers + elf_header.e_shnum;
11877 ++relsec)
252b5132 11878 {
41e92641
NC		 11879 bfd_boolean is_rela;
11880 unsigned long num_relocs;
2cf0635d
NC		 11881 Elf_Internal_Rela * relocs;
11882 Elf_Internal_Rela * rp;
11883 Elf_Internal_Shdr * symsec;
11884 Elf_Internal_Sym * symtab;
ba5cdace 11885 unsigned long num_syms;
2cf0635d 11886 Elf_Internal_Sym * sym;
252b5132 11887
41e92641 11888 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11889 || relsec->sh_info >= elf_header.e_shnum
11890 || section_headers + relsec->sh_info != section
c256ffe7 11891 || relsec->sh_size == 0
4fbb74a6 11892 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11893 continue;
428409d5 11894
41e92641
NC		 11895 is_rela = relsec->sh_type == SHT_RELA;
11896
11897 if (is_rela)
11898 {
3f5e193b
NC		 11899 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11900 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11901 return;
11902 }
11903 else
11904 {
3f5e193b
NC		 11905 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11906 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11907 return;
11908 }
11909
11910 /* SH uses RELA but uses in place value instead of the addend field. */
11911 if (elf_header.e_machine == EM_SH)
11912 is_rela = FALSE;
428409d5 11913
4fbb74a6 11914 symsec = section_headers + relsec->sh_link;
ba5cdace 11915 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11916
41e92641 11917 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11918 {
41e92641
NC		 11919 bfd_vma addend;
11920 unsigned int reloc_type;
11921 unsigned int reloc_size;
91d6fa6a 11922 unsigned char * rloc;
ba5cdace 11923 unsigned long sym_index;
4b78141a 11924
aca88567 11925 reloc_type = get_reloc_type (rp->r_info);
41e92641 11926
98fb390a 11927 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11928 continue;
98fb390a
NC		 11929 else if (is_none_reloc (reloc_type))
11930 continue;
11931 else if (is_32bit_abs_reloc (reloc_type)
11932 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11933 reloc_size = 4;
85acf597
RH		 11934 else if (is_64bit_abs_reloc (reloc_type)
11935 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11936 reloc_size = 8;
4dc3c23d
AM		 11937 else if (is_24bit_abs_reloc (reloc_type))
11938 reloc_size = 3;
aca88567
NC		 11939 else if (is_16bit_abs_reloc (reloc_type))
11940 reloc_size = 2;
11941 else
4b78141a 11942 {
bee0ee85
NC		 11943 static unsigned int prev_reloc = 0;
11944 if (reloc_type != prev_reloc)
11945 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11946 reloc_type, printable_section_name (section));
11947 prev_reloc = reloc_type;
4b78141a
NC		 11948 continue;
11949 }
103f02d3 11950
91d6fa6a 11951 rloc = start + rp->r_offset;
c8da6823 11952 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11953 {
11954 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11955 (unsigned long) rp->r_offset,
74e1a04b 11956 printable_section_name (section));
700dd8b7
L		 11957 continue;
11958 }
103f02d3 11959
ba5cdace
NC		 11960 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11961 if (sym_index >= num_syms)
11962 {
11963 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11964 sym_index, printable_section_name (section));
ba5cdace
NC		 11965 continue;
11966 }
11967 sym = symtab + sym_index;
41e92641
NC		 11968
11969 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11970 make sure that it is of an appropriate type.
11971
11972 Relocations against symbols without type can happen.
11973 Gcc -feliminate-dwarf2-dups may generate symbols
11974 without type for debug info.
11975
11976 Icc generates relocations against function symbols
11977 instead of local labels.
11978
11979 Relocations against object symbols can happen, eg when
11980 referencing a global array. For an example of this see
11981 the _clz.o binary in libgcc.a. */
aca88567 11982 if (sym != symtab
55f25fc3 11983 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11984 {
41e92641 11985 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11986 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11987 (long int)(rp - relocs),
74e1a04b 11988 printable_section_name (relsec));
aca88567 11989 continue;
5b18a4bc 11990 }
252b5132 11991
4dc3c23d
AM		 11992 addend = 0;
11993 if (is_rela)
11994 addend += rp->r_addend;
c47320c3
AM		 11995 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11996 partial_inplace. */
4dc3c23d
AM		 11997 if (!is_rela
11998 || (elf_header.e_machine == EM_XTENSA
11999 && reloc_type == 1)
12000 || ((elf_header.e_machine == EM_PJ
12001 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 12002 && reloc_type == 1)
12003 || ((elf_header.e_machine == EM_D30V
12004 || elf_header.e_machine == EM_CYGNUS_D30V)
12005 && reloc_type == 12))
91d6fa6a 12006 addend += byte_get (rloc, reloc_size);
cb8f3167 12007
85acf597
RH		 12008 if (is_32bit_pcrel_reloc (reloc_type)
12009 || is_64bit_pcrel_reloc (reloc_type))
12010 {
12011 /* On HPPA, all pc-relative relocations are biased by 8. */
12012 if (elf_header.e_machine == EM_PARISC)
12013 addend -= 8;
91d6fa6a 12014 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 12015 reloc_size);
12016 }
41e92641 12017 else
91d6fa6a 12018 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12019 }
252b5132 12020
5b18a4bc 12021 free (symtab);
d1c4b12b
NC		 12022
12023 if (relocs_return)
12024 {
12025 * (Elf_Internal_Rela **) relocs_return = relocs;
12026 * num_relocs_return = num_relocs;
12027 }
12028 else
12029 free (relocs);
12030
5b18a4bc
NC		 12031 break;
12032 }
5b18a4bc 12033}
103f02d3 12034
cf13d699
NC		 12035#ifdef SUPPORT_DISASSEMBLY
12036static int
12037disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12038{
74e1a04b 12039 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12040
74e1a04b 12041 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12042
12043 return 1;
12044}
12045#endif
12046
12047/* Reads in the contents of SECTION from FILE, returning a pointer
12048 to a malloc'ed buffer or NULL if something went wrong. */
12049
12050static char *
12051get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12052{
12053 bfd_size_type num_bytes;
12054
12055 num_bytes = section->sh_size;
12056
12057 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12058 {
12059 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12060 printable_section_name (section));
cf13d699
NC		 12061 return NULL;
12062 }
12063
3f5e193b
NC		 12064 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12065 _("section contents"));
cf13d699
NC		 12066}
12067
0e602686
NC		 12068/* Uncompresses a section that was compressed using zlib, in place. */
12069
12070static bfd_boolean
12071uncompress_section_contents (unsigned char **buffer,
12072 dwarf_size_type uncompressed_size,
12073 dwarf_size_type *size)
12074{
12075 dwarf_size_type compressed_size = *size;
12076 unsigned char * compressed_buffer = *buffer;
12077 unsigned char * uncompressed_buffer;
12078 z_stream strm;
12079 int rc;
12080
12081 /* It is possible the section consists of several compressed
12082 buffers concatenated together, so we uncompress in a loop. */
12083 /* PR 18313: The state field in the z_stream structure is supposed
12084 to be invisible to the user (ie us), but some compilers will
12085 still complain about it being used without initialisation. So
12086 we first zero the entire z_stream structure and then set the fields
12087 that we need. */
12088 memset (& strm, 0, sizeof strm);
12089 strm.avail_in = compressed_size;
12090 strm.next_in = (Bytef *) compressed_buffer;
12091 strm.avail_out = uncompressed_size;
12092 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12093
12094 rc = inflateInit (& strm);
12095 while (strm.avail_in > 0)
12096 {
12097 if (rc != Z_OK)
12098 goto fail;
12099 strm.next_out = ((Bytef *) uncompressed_buffer
12100 + (uncompressed_size - strm.avail_out));
12101 rc = inflate (&strm, Z_FINISH);
12102 if (rc != Z_STREAM_END)
12103 goto fail;
12104 rc = inflateReset (& strm);
12105 }
12106 rc = inflateEnd (& strm);
12107 if (rc != Z_OK
12108 || strm.avail_out != 0)
12109 goto fail;
12110
12111 *buffer = uncompressed_buffer;
12112 *size = uncompressed_size;
12113 return TRUE;
12114
12115 fail:
12116 free (uncompressed_buffer);
12117 /* Indicate decompression failure. */
12118 *buffer = NULL;
12119 return FALSE;
12120}
dd24e3da 12121
cf13d699
NC		 12122static void
12123dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12124{
0e602686
NC		 12125 Elf_Internal_Shdr * relsec;
12126 bfd_size_type num_bytes;
fd8008d8
L		 12127 unsigned char * data;
12128 unsigned char * end;
12129 unsigned char * real_start;
12130 unsigned char * start;
0e602686 12131 bfd_boolean some_strings_shown;
cf13d699 12132
fd8008d8
L		 12133 real_start = start = (unsigned char *) get_section_contents (section,
12134 file);
cf13d699
NC		 12135 if (start == NULL)
12136 return;
0e602686 12137 num_bytes = section->sh_size;
cf13d699 12138
74e1a04b 12139 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12140
0e602686
NC		 12141 if (decompress_dumps)
12142 {
12143 dwarf_size_type new_size = num_bytes;
12144 dwarf_size_type uncompressed_size = 0;
12145
12146 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12147 {
12148 Elf_Internal_Chdr chdr;
12149 unsigned int compression_header_size
12150 = get_compression_header (& chdr, (unsigned char *) start);
12151
813dabb9 12152 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12153 {
813dabb9
L		 12154 warn (_("section '%s' has unsupported compress type: %d\n"),
12155 printable_section_name (section), chdr.ch_type);
12156 return;
12157 }
12158 else if (chdr.ch_addralign != section->sh_addralign)
12159 {
12160 warn (_("compressed section '%s' is corrupted\n"),
12161 printable_section_name (section));
12162 return;
0e602686 12163 }
813dabb9
L		 12164 uncompressed_size = chdr.ch_size;
12165 start += compression_header_size;
12166 new_size -= compression_header_size;
0e602686
NC		 12167 }
12168 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12169 {
12170 /* Read the zlib header. In this case, it should be "ZLIB"
12171 followed by the uncompressed section size, 8 bytes in
12172 big-endian order. */
12173 uncompressed_size = start[4]; uncompressed_size <<= 8;
12174 uncompressed_size += start[5]; uncompressed_size <<= 8;
12175 uncompressed_size += start[6]; uncompressed_size <<= 8;
12176 uncompressed_size += start[7]; uncompressed_size <<= 8;
12177 uncompressed_size += start[8]; uncompressed_size <<= 8;
12178 uncompressed_size += start[9]; uncompressed_size <<= 8;
12179 uncompressed_size += start[10]; uncompressed_size <<= 8;
12180 uncompressed_size += start[11];
12181 start += 12;
12182 new_size -= 12;
12183 }
12184
12185 if (uncompressed_size
fd8008d8 12186 && uncompress_section_contents (& start,
0e602686
NC		 12187 uncompressed_size, & new_size))
12188 num_bytes = new_size;
12189 }
fd8008d8 12190
cf13d699
NC		 12191 /* If the section being dumped has relocations against it the user might
12192 be expecting these relocations to have been applied. Check for this
12193 case and issue a warning message in order to avoid confusion.
12194 FIXME: Maybe we ought to have an option that dumps a section with
12195 relocs applied ? */
12196 for (relsec = section_headers;
12197 relsec < section_headers + elf_header.e_shnum;
12198 ++relsec)
12199 {
12200 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12201 || relsec->sh_info >= elf_header.e_shnum
12202 || section_headers + relsec->sh_info != section
12203 || relsec->sh_size == 0
12204 || relsec->sh_link >= elf_header.e_shnum)
12205 continue;
12206
12207 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12208 break;
12209 }
12210
cf13d699
NC		 12211 data = start;
12212 end = start + num_bytes;
12213 some_strings_shown = FALSE;
12214
12215 while (data < end)
12216 {
12217 while (!ISPRINT (* data))
12218 if (++ data >= end)
12219 break;
12220
12221 if (data < end)
12222 {
071436c6
NC		 12223 size_t maxlen = end - data;
12224
cf13d699 12225#ifndef __MSVCRT__
c975cc98
NC		 12226 /* PR 11128: Use two separate invocations in order to work
12227 around bugs in the Solaris 8 implementation of printf. */
12228 printf (" [%6tx] ", data - start);
cf13d699 12229#else
071436c6 12230 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12231#endif
4082ef84
NC		 12232 if (maxlen > 0)
12233 {
fd8008d8 12234 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12235 putchar ('\n');
fd8008d8 12236 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12237 }
12238 else
12239 {
12240 printf (_("<corrupt>\n"));
12241 data = end;
12242 }
cf13d699
NC		 12243 some_strings_shown = TRUE;
12244 }
12245 }
12246
12247 if (! some_strings_shown)
12248 printf (_(" No strings found in this section."));
12249
0e602686 12250 free (real_start);
cf13d699
NC		 12251
12252 putchar ('\n');
12253}
12254
12255static void
12256dump_section_as_bytes (Elf_Internal_Shdr * section,
12257 FILE * file,
12258 bfd_boolean relocate)
12259{
12260 Elf_Internal_Shdr * relsec;
0e602686
NC		 12261 bfd_size_type bytes;
12262 bfd_size_type section_size;
12263 bfd_vma addr;
12264 unsigned char * data;
12265 unsigned char * real_start;
12266 unsigned char * start;
12267
12268 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12269 if (start == NULL)
12270 return;
0e602686 12271 section_size = section->sh_size;
cf13d699 12272
74e1a04b 12273 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12274
0e602686
NC		 12275 if (decompress_dumps)
12276 {
12277 dwarf_size_type new_size = section_size;
12278 dwarf_size_type uncompressed_size = 0;
12279
12280 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12281 {
12282 Elf_Internal_Chdr chdr;
12283 unsigned int compression_header_size
12284 = get_compression_header (& chdr, start);
12285
813dabb9 12286 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12287 {
813dabb9
L		 12288 warn (_("section '%s' has unsupported compress type: %d\n"),
12289 printable_section_name (section), chdr.ch_type);
12290 return;
0e602686 12291 }
813dabb9
L		 12292 else if (chdr.ch_addralign != section->sh_addralign)
12293 {
12294 warn (_("compressed section '%s' is corrupted\n"),
12295 printable_section_name (section));
12296 return;
12297 }
12298 uncompressed_size = chdr.ch_size;
12299 start += compression_header_size;
12300 new_size -= compression_header_size;
0e602686
NC		 12301 }
12302 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12303 {
12304 /* Read the zlib header. In this case, it should be "ZLIB"
12305 followed by the uncompressed section size, 8 bytes in
12306 big-endian order. */
12307 uncompressed_size = start[4]; uncompressed_size <<= 8;
12308 uncompressed_size += start[5]; uncompressed_size <<= 8;
12309 uncompressed_size += start[6]; uncompressed_size <<= 8;
12310 uncompressed_size += start[7]; uncompressed_size <<= 8;
12311 uncompressed_size += start[8]; uncompressed_size <<= 8;
12312 uncompressed_size += start[9]; uncompressed_size <<= 8;
12313 uncompressed_size += start[10]; uncompressed_size <<= 8;
12314 uncompressed_size += start[11];
12315 start += 12;
12316 new_size -= 12;
12317 }
12318
12319 if (uncompressed_size
12320 && uncompress_section_contents (& start, uncompressed_size,
12321 & new_size))
12322 section_size = new_size;
12323 }
14ae95f2 12324
cf13d699
NC		 12325 if (relocate)
12326 {
0e602686 12327 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12328 }
12329 else
12330 {
12331 /* If the section being dumped has relocations against it the user might
12332 be expecting these relocations to have been applied. Check for this
12333 case and issue a warning message in order to avoid confusion.
12334 FIXME: Maybe we ought to have an option that dumps a section with
12335 relocs applied ? */
12336 for (relsec = section_headers;
12337 relsec < section_headers + elf_header.e_shnum;
12338 ++relsec)
12339 {
12340 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12341 || relsec->sh_info >= elf_header.e_shnum
12342 || section_headers + relsec->sh_info != section
12343 || relsec->sh_size == 0
12344 || relsec->sh_link >= elf_header.e_shnum)
12345 continue;
12346
12347 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12348 break;
12349 }
12350 }
12351
12352 addr = section->sh_addr;
0e602686 12353 bytes = section_size;
cf13d699
NC		 12354 data = start;
12355
12356 while (bytes)
12357 {
12358 int j;
12359 int k;
12360 int lbytes;
12361
12362 lbytes = (bytes > 16 ? 16 : bytes);
12363
12364 printf (" 0x%8.8lx ", (unsigned long) addr);
12365
12366 for (j = 0; j < 16; j++)
12367 {
12368 if (j < lbytes)
12369 printf ("%2.2x", data[j]);
12370 else
12371 printf (" ");
12372
12373 if ((j & 3) == 3)
12374 printf (" ");
12375 }
12376
12377 for (j = 0; j < lbytes; j++)
12378 {
12379 k = data[j];
12380 if (k >= ' ' && k < 0x7f)
12381 printf ("%c", k);
12382 else
12383 printf (".");
12384 }
12385
12386 putchar ('\n');
12387
12388 data += lbytes;
12389 addr += lbytes;
12390 bytes -= lbytes;
12391 }
12392
0e602686 12393 free (real_start);
cf13d699
NC		 12394
12395 putchar ('\n');
12396}
12397
d966045b
DJ		 12398static int
12399load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12400 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12401{
2cf0635d 12402 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12403 char buf [64];
1007acb3 12404
19e6b90e
L		 12405 /* If it is already loaded, do nothing. */
12406 if (section->start != NULL)
12407 return 1;
1007acb3 12408
19e6b90e
L		 12409 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12410 section->address = sec->sh_addr;
06614111 12411 section->user_data = NULL;
3f5e193b
NC		 12412 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12413 sec->sh_offset, 1,
12414 sec->sh_size, buf);
59245841
NC		 12415 if (section->start == NULL)
12416 section->size = 0;
12417 else
12418 {
77115a4a
L		 12419 unsigned char *start = section->start;
12420 dwarf_size_type size = sec->sh_size;
dab394de 12421 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12422
12423 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12424 {
12425 Elf_Internal_Chdr chdr;
12426 unsigned int compression_header_size
12427 = get_compression_header (&chdr, start);
813dabb9
L		 12428 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12429 {
12430 warn (_("section '%s' has unsupported compress type: %d\n"),
12431 section->name, chdr.ch_type);
12432 return 0;
12433 }
12434 else if (chdr.ch_addralign != sec->sh_addralign)
12435 {
12436 warn (_("compressed section '%s' is corrupted\n"),
12437 section->name);
12438 return 0;
12439 }
dab394de 12440 uncompressed_size = chdr.ch_size;
77115a4a
L		 12441 start += compression_header_size;
12442 size -= compression_header_size;
12443 }
dab394de
L		 12444 else if (size > 12 && streq ((char *) start, "ZLIB"))
12445 {
12446 /* Read the zlib header. In this case, it should be "ZLIB"
12447 followed by the uncompressed section size, 8 bytes in
12448 big-endian order. */
12449 uncompressed_size = start[4]; uncompressed_size <<= 8;
12450 uncompressed_size += start[5]; uncompressed_size <<= 8;
12451 uncompressed_size += start[6]; uncompressed_size <<= 8;
12452 uncompressed_size += start[7]; uncompressed_size <<= 8;
12453 uncompressed_size += start[8]; uncompressed_size <<= 8;
12454 uncompressed_size += start[9]; uncompressed_size <<= 8;
12455 uncompressed_size += start[10]; uncompressed_size <<= 8;
12456 uncompressed_size += start[11];
12457 start += 12;
12458 size -= 12;
12459 }
12460
12461 if (uncompressed_size
12462 && uncompress_section_contents (&start, uncompressed_size,
12463 &size))
77115a4a
L		 12464 {
12465 /* Free the compressed buffer, update the section buffer
12466 and the section size if uncompress is successful. */
12467 free (section->start);
12468 section->start = start;
77115a4a
L		 12469 }
12470 section->size = size;
59245841 12471 }
4a114e3e 12472
1b315056
CS		 12473 if (section->start == NULL)
12474 return 0;
12475
19e6b90e 12476 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12477 apply_relocations ((FILE *) file, sec, section->start, section->size,
12478 & section->reloc_info, & section->num_relocs);
12479 else
12480 {
12481 section->reloc_info = NULL;
12482 section->num_relocs = 0;
12483 }
1007acb3 12484
1b315056 12485 return 1;
1007acb3
L		 12486}
12487
657d0d47
CC		 12488/* If this is not NULL, load_debug_section will only look for sections
12489 within the list of sections given here. */
12490unsigned int *section_subset = NULL;
12491
d966045b 12492int
2cf0635d 12493load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12494{
2cf0635d
NC		 12495 struct dwarf_section * section = &debug_displays [debug].section;
12496 Elf_Internal_Shdr * sec;
d966045b
DJ		 12497
12498 /* Locate the debug section. */
657d0d47 12499 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12500 if (sec != NULL)
12501 section->name = section->uncompressed_name;
12502 else
12503 {
657d0d47 12504 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12505 if (sec != NULL)
12506 section->name = section->compressed_name;
12507 }
12508 if (sec == NULL)
12509 return 0;
12510
657d0d47
CC		 12511 /* If we're loading from a subset of sections, and we've loaded
12512 a section matching this name before, it's likely that it's a
12513 different one. */
12514 if (section_subset != NULL)
12515 free_debug_section (debug);
12516
3f5e193b 12517 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12518}
12519
19e6b90e
L		 12520void
12521free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12522{
2cf0635d 12523 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12524
19e6b90e
L		 12525 if (section->start == NULL)
12526 return;
1007acb3 12527
19e6b90e
L		 12528 free ((char *) section->start);
12529 section->start = NULL;
12530 section->address = 0;
12531 section->size = 0;
1007acb3
L		 12532}
12533
1007acb3 12534static int
657d0d47 12535display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12536{
2cf0635d 12537 char * name = SECTION_NAME (section);
74e1a04b 12538 const char * print_name = printable_section_name (section);
19e6b90e
L		 12539 bfd_size_type length;
12540 int result = 1;
3f5e193b 12541 int i;
1007acb3 12542
19e6b90e
L		 12543 length = section->sh_size;
12544 if (length == 0)
1007acb3 12545 {
74e1a04b 12546 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12547 return 0;
1007acb3 12548 }
5dff79d8
NC		 12549 if (section->sh_type == SHT_NOBITS)
12550 {
12551 /* There is no point in dumping the contents of a debugging section
12552 which has the NOBITS type - the bits in the file will be random.
12553 This can happen when a file containing a .eh_frame section is
12554 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12555 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12556 print_name);
5dff79d8
NC		 12557 return 0;
12558 }
1007acb3 12559
0112cd26 12560 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12561 name = ".debug_info";
1007acb3 12562
19e6b90e
L		 12563 /* See if we know how to display the contents of this section. */
12564 for (i = 0; i < max; i++)
1b315056 12565 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12566 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12567 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12568 {
2cf0635d 12569 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12570 int secondary = (section != find_section (name));
12571
12572 if (secondary)
3f5e193b 12573 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12574
b40bf0a2
NC		 12575 if (i == line && const_strneq (name, ".debug_line."))
12576 sec->name = name;
12577 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12578 sec->name = sec->uncompressed_name;
12579 else
12580 sec->name = sec->compressed_name;
3f5e193b
NC		 12581 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12582 section, file))
19e6b90e 12583 {
657d0d47
CC		 12584 /* If this debug section is part of a CU/TU set in a .dwp file,
12585 restrict load_debug_section to the sections in that set. */
12586 section_subset = find_cu_tu_set (file, shndx);
12587
19e6b90e 12588 result &= debug_displays[i].display (sec, file);
1007acb3 12589
657d0d47
CC		 12590 section_subset = NULL;
12591
d966045b 12592 if (secondary || (i != info && i != abbrev))
3f5e193b 12593 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12594 }
1007acb3 12595
19e6b90e
L		 12596 break;
12597 }
1007acb3 12598
19e6b90e 12599 if (i == max)
1007acb3 12600 {
74e1a04b 12601 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12602 result = 0;
1007acb3
L		 12603 }
12604
19e6b90e 12605 return result;
5b18a4bc 12606}
103f02d3 12607
aef1f6d0
DJ		 12608/* Set DUMP_SECTS for all sections where dumps were requested
12609 based on section name. */
12610
12611static void
12612initialise_dumps_byname (void)
12613{
2cf0635d 12614 struct dump_list_entry * cur;
aef1f6d0
DJ		 12615
12616 for (cur = dump_sects_byname; cur; cur = cur->next)
12617 {
12618 unsigned int i;
12619 int any;
12620
12621 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12622 if (streq (SECTION_NAME (section_headers + i), cur->name))
12623 {
09c11c86 12624 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12625 any = 1;
12626 }
12627
12628 if (!any)
12629 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12630 cur->name);
12631 }
12632}
12633
5b18a4bc 12634static void
2cf0635d 12635process_section_contents (FILE * file)
5b18a4bc 12636{
2cf0635d 12637 Elf_Internal_Shdr * section;
19e6b90e 12638 unsigned int i;
103f02d3 12639
19e6b90e
L		 12640 if (! do_dump)
12641 return;
103f02d3 12642
aef1f6d0
DJ		 12643 initialise_dumps_byname ();
12644
19e6b90e
L		 12645 for (i = 0, section = section_headers;
12646 i < elf_header.e_shnum && i < num_dump_sects;
12647 i++, section++)
12648 {
12649#ifdef SUPPORT_DISASSEMBLY
12650 if (dump_sects[i] & DISASS_DUMP)
12651 disassemble_section (section, file);
12652#endif
12653 if (dump_sects[i] & HEX_DUMP)
cf13d699 12654 dump_section_as_bytes (section, file, FALSE);
103f02d3 12655
cf13d699
NC		 12656 if (dump_sects[i] & RELOC_DUMP)
12657 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12658
12659 if (dump_sects[i] & STRING_DUMP)
12660 dump_section_as_strings (section, file);
cf13d699
NC		 12661
12662 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12663 display_debug_section (i, section, file);
5b18a4bc 12664 }
103f02d3 12665
19e6b90e
L		 12666 /* Check to see if the user requested a
12667 dump of a section that does not exist. */
12668 while (i++ < num_dump_sects)
12669 if (dump_sects[i])
12670 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12671}
103f02d3 12672
5b18a4bc 12673static void
19e6b90e 12674process_mips_fpe_exception (int mask)
5b18a4bc 12675{
19e6b90e
L		 12676 if (mask)
12677 {
12678 int first = 1;
12679 if (mask & OEX_FPU_INEX)
12680 fputs ("INEX", stdout), first = 0;
12681 if (mask & OEX_FPU_UFLO)
12682 printf ("%sUFLO", first ? "" : "|"), first = 0;
12683 if (mask & OEX_FPU_OFLO)
12684 printf ("%sOFLO", first ? "" : "|"), first = 0;
12685 if (mask & OEX_FPU_DIV0)
12686 printf ("%sDIV0", first ? "" : "|"), first = 0;
12687 if (mask & OEX_FPU_INVAL)
12688 printf ("%sINVAL", first ? "" : "|");
12689 }
5b18a4bc 12690 else
19e6b90e 12691 fputs ("0", stdout);
5b18a4bc 12692}
103f02d3 12693
f6f0e17b
NC		 12694/* Display's the value of TAG at location P. If TAG is
12695 greater than 0 it is assumed to be an unknown tag, and
12696 a message is printed to this effect. Otherwise it is
12697 assumed that a message has already been printed.
12698
12699 If the bottom bit of TAG is set it assumed to have a
12700 string value, otherwise it is assumed to have an integer
12701 value.
12702
12703 Returns an updated P pointing to the first unread byte
12704 beyond the end of TAG's value.
12705
12706 Reads at or beyond END will not be made. */
12707
12708static unsigned char *
12709display_tag_value (int tag,
12710 unsigned char * p,
12711 const unsigned char * const end)
12712{
12713 unsigned long val;
12714
12715 if (tag > 0)
12716 printf (" Tag_unknown_%d: ", tag);
12717
12718 if (p >= end)
12719 {
4082ef84 12720 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12721 }
12722 else if (tag & 1)
12723 {
071436c6
NC		 12724 /* PR 17531 file: 027-19978-0.004. */
12725 size_t maxlen = (end - p) - 1;
12726
12727 putchar ('"');
4082ef84
NC		 12728 if (maxlen > 0)
12729 {
12730 print_symbol ((int) maxlen, (const char *) p);
12731 p += strnlen ((char *) p, maxlen) + 1;
12732 }
12733 else
12734 {
12735 printf (_("<corrupt string tag>"));
12736 p = (unsigned char *) end;
12737 }
071436c6 12738 printf ("\"\n");
f6f0e17b
NC		 12739 }
12740 else
12741 {
12742 unsigned int len;
12743
12744 val = read_uleb128 (p, &len, end);
12745 p += len;
12746 printf ("%ld (0x%lx)\n", val, val);
12747 }
12748
4082ef84 12749 assert (p <= end);
f6f0e17b
NC		 12750 return p;
12751}
12752
11c1ff18
PB		 12753/* ARM EABI attributes section. */
12754typedef struct
12755{
70e99720 12756 unsigned int tag;
2cf0635d 12757 const char * name;
11c1ff18 12758 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12759 unsigned int type;
2cf0635d 12760 const char ** table;
11c1ff18
PB		 12761} arm_attr_public_tag;
12762
2cf0635d 12763static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12764 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ff8646ee
TP		 12765 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12766 "v8-M.mainline"};
2cf0635d
NC		 12767static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12768static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 12769 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 12770static const char * arm_attr_tag_FP_arch[] =
bca38921 12771 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12772 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12773static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12774static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12775 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12776static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12777 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12778 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12779static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12780 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12781static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12782 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12783static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12784 {"Absolute", "PC-relative", "None"};
2cf0635d 12785static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12786 {"None", "direct", "GOT-indirect"};
2cf0635d 12787static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12788 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12789static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12790static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12791 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12792static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12793static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12794static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12795 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12796static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12797 {"Unused", "small", "int", "forced to int"};
2cf0635d 12798static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12799 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12800static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12801 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12802static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12803 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12804static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12805 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12806 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12807static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12808 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12809 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12810static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12811static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12812 {"Not Allowed", "Allowed"};
2cf0635d 12813static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12814 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12815static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12816 {"Not Allowed", "Allowed"};
12817static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12818 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12819 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12820static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12821static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12822 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12823 "TrustZone and Virtualization Extensions"};
dd24e3da 12824static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12825 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12826
12827#define LOOKUP(id, name) \
12828 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12829static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12830{
12831 {4, "CPU_raw_name", 1, NULL},
12832 {5, "CPU_name", 1, NULL},
12833 LOOKUP(6, CPU_arch),
12834 {7, "CPU_arch_profile", 0, NULL},
12835 LOOKUP(8, ARM_ISA_use),
12836 LOOKUP(9, THUMB_ISA_use),
75375b3e 12837 LOOKUP(10, FP_arch),
11c1ff18 12838 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12839 LOOKUP(12, Advanced_SIMD_arch),
12840 LOOKUP(13, PCS_config),
11c1ff18
PB		 12841 LOOKUP(14, ABI_PCS_R9_use),
12842 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12843 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12844 LOOKUP(17, ABI_PCS_GOT_use),
12845 LOOKUP(18, ABI_PCS_wchar_t),
12846 LOOKUP(19, ABI_FP_rounding),
12847 LOOKUP(20, ABI_FP_denormal),
12848 LOOKUP(21, ABI_FP_exceptions),
12849 LOOKUP(22, ABI_FP_user_exceptions),
12850 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12851 {24, "ABI_align_needed", 0, NULL},
12852 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12853 LOOKUP(26, ABI_enum_size),
12854 LOOKUP(27, ABI_HardFP_use),
12855 LOOKUP(28, ABI_VFP_args),
12856 LOOKUP(29, ABI_WMMX_args),
12857 LOOKUP(30, ABI_optimization_goals),
12858 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12859 {32, "compatibility", 0, NULL},
f5f53991 12860 LOOKUP(34, CPU_unaligned_access),
75375b3e 12861 LOOKUP(36, FP_HP_extension),
8e79c3df 12862 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12863 LOOKUP(42, MPextension_use),
12864 LOOKUP(44, DIV_use),
f5f53991
AS		 12865 {64, "nodefaults", 0, NULL},
12866 {65, "also_compatible_with", 0, NULL},
12867 LOOKUP(66, T2EE_use),
12868 {67, "conformance", 1, NULL},
12869 LOOKUP(68, Virtualization_use),
cd21e546 12870 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12871};
12872#undef LOOKUP
12873
11c1ff18 12874static unsigned char *
f6f0e17b
NC		 12875display_arm_attribute (unsigned char * p,
12876 const unsigned char * const end)
11c1ff18 12877{
70e99720 12878 unsigned int tag;
11c1ff18 12879 unsigned int len;
70e99720 12880 unsigned int val;
2cf0635d 12881 arm_attr_public_tag * attr;
11c1ff18 12882 unsigned i;
70e99720 12883 unsigned int type;
11c1ff18 12884
f6f0e17b 12885 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12886 p += len;
12887 attr = NULL;
2cf0635d 12888 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12889 {
12890 if (arm_attr_public_tags[i].tag == tag)
12891 {
12892 attr = &arm_attr_public_tags[i];
12893 break;
12894 }
12895 }
12896
12897 if (attr)
12898 {
12899 printf (" Tag_%s: ", attr->name);
12900 switch (attr->type)
12901 {
12902 case 0:
12903 switch (tag)
12904 {
12905 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12906 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12907 p += len;
12908 switch (val)
12909 {
2b692964
NC		 12910 case 0: printf (_("None\n")); break;
12911 case 'A': printf (_("Application\n")); break;
12912 case 'R': printf (_("Realtime\n")); break;
12913 case 'M': printf (_("Microcontroller\n")); break;
12914 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12915 default: printf ("??? (%d)\n", val); break;
12916 }
12917 break;
12918
75375b3e 12919 case 24: /* Tag_align_needed. */
f6f0e17b 12920 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12921 p += len;
12922 switch (val)
12923 {
2b692964
NC		 12924 case 0: printf (_("None\n")); break;
12925 case 1: printf (_("8-byte\n")); break;
12926 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12927 case 3: printf ("??? 3\n"); break;
12928 default:
12929 if (val <= 12)
dd24e3da 12930 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12931 1 << val);
12932 else
12933 printf ("??? (%d)\n", val);
12934 break;
12935 }
12936 break;
12937
12938 case 25: /* Tag_align_preserved. */
f6f0e17b 12939 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12940 p += len;
12941 switch (val)
12942 {
2b692964
NC		 12943 case 0: printf (_("None\n")); break;
12944 case 1: printf (_("8-byte, except leaf SP\n")); break;
12945 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12946 case 3: printf ("??? 3\n"); break;
12947 default:
12948 if (val <= 12)
dd24e3da 12949 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12950 1 << val);
12951 else
12952 printf ("??? (%d)\n", val);
12953 break;
12954 }
12955 break;
12956
11c1ff18 12957 case 32: /* Tag_compatibility. */
071436c6 12958 {
071436c6
NC		 12959 val = read_uleb128 (p, &len, end);
12960 p += len;
071436c6 12961 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12962 if (p < end - 1)
12963 {
12964 size_t maxlen = (end - p) - 1;
12965
12966 print_symbol ((int) maxlen, (const char *) p);
12967 p += strnlen ((char *) p, maxlen) + 1;
12968 }
12969 else
12970 {
12971 printf (_("<corrupt>"));
12972 p = (unsigned char *) end;
12973 }
071436c6 12974 putchar ('\n');
071436c6 12975 }
11c1ff18
PB		 12976 break;
12977
f5f53991 12978 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12979 /* PR 17531: file: 001-505008-0.01. */
12980 if (p < end)
12981 p++;
2b692964 12982 printf (_("True\n"));
f5f53991
AS		 12983 break;
12984
12985 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12986 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12987 p += len;
12988 if (val == 6 /* Tag_CPU_arch. */)
12989 {
f6f0e17b 12990 val = read_uleb128 (p, &len, end);
f5f53991 12991 p += len;
071436c6 12992 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12993 printf ("??? (%d)\n", val);
12994 else
12995 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12996 }
12997 else
12998 printf ("???\n");
071436c6
NC		 12999 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13000 ;
f5f53991
AS		 13001 break;
13002
11c1ff18 13003 default:
bee0ee85
NC		 13004 printf (_("<unknown: %d>\n"), tag);
13005 break;
11c1ff18
PB		 13006 }
13007 return p;
13008
13009 case 1:
f6f0e17b 13010 return display_tag_value (-1, p, end);
11c1ff18 13011 case 2:
f6f0e17b 13012 return display_tag_value (0, p, end);
11c1ff18
PB		 13013
13014 default:
13015 assert (attr->type & 0x80);
f6f0e17b 13016 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13017 p += len;
13018 type = attr->type & 0x7f;
13019 if (val >= type)
13020 printf ("??? (%d)\n", val);
13021 else
13022 printf ("%s\n", attr->table[val]);
13023 return p;
13024 }
13025 }
11c1ff18 13026
f6f0e17b 13027 return display_tag_value (tag, p, end);
11c1ff18
PB		 13028}
13029
104d59d1 13030static unsigned char *
60bca95a 13031display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 13032 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13033 const unsigned char * const end)
104d59d1
JM		 13034{
13035 int tag;
13036 unsigned int len;
13037 int val;
104d59d1 13038
f6f0e17b 13039 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13040 p += len;
13041
13042 /* Tag_compatibility is the only generic GNU attribute defined at
13043 present. */
13044 if (tag == 32)
13045 {
f6f0e17b 13046 val = read_uleb128 (p, &len, end);
104d59d1 13047 p += len;
071436c6
NC		 13048
13049 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13050 if (p == end)
13051 {
071436c6 13052 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13053 warn (_("corrupt vendor attribute\n"));
13054 }
13055 else
13056 {
4082ef84
NC		 13057 if (p < end - 1)
13058 {
13059 size_t maxlen = (end - p) - 1;
071436c6 13060
4082ef84
NC		 13061 print_symbol ((int) maxlen, (const char *) p);
13062 p += strnlen ((char *) p, maxlen) + 1;
13063 }
13064 else
13065 {
13066 printf (_("<corrupt>"));
13067 p = (unsigned char *) end;
13068 }
071436c6 13069 putchar ('\n');
f6f0e17b 13070 }
104d59d1
JM		 13071 return p;
13072 }
13073
13074 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13075 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13076
f6f0e17b 13077 return display_tag_value (tag, p, end);
104d59d1
JM		 13078}
13079
34c8bcba 13080static unsigned char *
f6f0e17b
NC		 13081display_power_gnu_attribute (unsigned char * p,
13082 int tag,
13083 const unsigned char * const end)
34c8bcba 13084{
34c8bcba
JM		 13085 unsigned int len;
13086 int val;
13087
13088 if (tag == Tag_GNU_Power_ABI_FP)
13089 {
f6f0e17b 13090 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13091 p += len;
13092 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 13093
34c8bcba
JM		 13094 switch (val)
13095 {
13096 case 0:
2b692964 13097 printf (_("Hard or soft float\n"));
34c8bcba
JM		 13098 break;
13099 case 1:
2b692964 13100 printf (_("Hard float\n"));
34c8bcba
JM		 13101 break;
13102 case 2:
2b692964 13103 printf (_("Soft float\n"));
34c8bcba 13104 break;
3c7b9897 13105 case 3:
2b692964 13106 printf (_("Single-precision hard float\n"));
3c7b9897 13107 break;
34c8bcba
JM		 13108 default:
13109 printf ("??? (%d)\n", val);
13110 break;
13111 }
13112 return p;
13113 }
13114
c6e65352
DJ		 13115 if (tag == Tag_GNU_Power_ABI_Vector)
13116 {
f6f0e17b 13117 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13118 p += len;
13119 printf (" Tag_GNU_Power_ABI_Vector: ");
13120 switch (val)
13121 {
13122 case 0:
2b692964 13123 printf (_("Any\n"));
c6e65352
DJ		 13124 break;
13125 case 1:
2b692964 13126 printf (_("Generic\n"));
c6e65352
DJ		 13127 break;
13128 case 2:
13129 printf ("AltiVec\n");
13130 break;
13131 case 3:
13132 printf ("SPE\n");
13133 break;
13134 default:
13135 printf ("??? (%d)\n", val);
13136 break;
13137 }
13138 return p;
13139 }
13140
f82e0623
NF		 13141 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13142 {
f6f0e17b
NC		 13143 if (p == end)
13144 {
071436c6 13145 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13146 return p;
13147 }
0b4362b0 13148
f6f0e17b 13149 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13150 p += len;
13151 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13152 switch (val)
13153 {
13154 case 0:
2b692964 13155 printf (_("Any\n"));
f82e0623
NF		 13156 break;
13157 case 1:
13158 printf ("r3/r4\n");
13159 break;
13160 case 2:
2b692964 13161 printf (_("Memory\n"));
f82e0623
NF		 13162 break;
13163 default:
13164 printf ("??? (%d)\n", val);
13165 break;
13166 }
13167 return p;
13168 }
13169
f6f0e17b 13170 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13171}
13172
643f7afb
AK		 13173static unsigned char *
13174display_s390_gnu_attribute (unsigned char * p,
13175 int tag,
13176 const unsigned char * const end)
13177{
13178 unsigned int len;
13179 int val;
13180
13181 if (tag == Tag_GNU_S390_ABI_Vector)
13182 {
13183 val = read_uleb128 (p, &len, end);
13184 p += len;
13185 printf (" Tag_GNU_S390_ABI_Vector: ");
13186
13187 switch (val)
13188 {
13189 case 0:
13190 printf (_("any\n"));
13191 break;
13192 case 1:
13193 printf (_("software\n"));
13194 break;
13195 case 2:
13196 printf (_("hardware\n"));
13197 break;
13198 default:
13199 printf ("??? (%d)\n", val);
13200 break;
13201 }
13202 return p;
13203 }
13204
13205 return display_tag_value (tag & 1, p, end);
13206}
13207
9e8c70f9
DM		 13208static void
13209display_sparc_hwcaps (int mask)
13210{
13211 if (mask)
13212 {
13213 int first = 1;
071436c6 13214
9e8c70f9
DM		 13215 if (mask & ELF_SPARC_HWCAP_MUL32)
13216 fputs ("mul32", stdout), first = 0;
13217 if (mask & ELF_SPARC_HWCAP_DIV32)
13218 printf ("%sdiv32", first ? "" : "|"), first = 0;
13219 if (mask & ELF_SPARC_HWCAP_FSMULD)
13220 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13221 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13222 printf ("%sv8plus", first ? "" : "|"), first = 0;
13223 if (mask & ELF_SPARC_HWCAP_POPC)
13224 printf ("%spopc", first ? "" : "|"), first = 0;
13225 if (mask & ELF_SPARC_HWCAP_VIS)
13226 printf ("%svis", first ? "" : "|"), first = 0;
13227 if (mask & ELF_SPARC_HWCAP_VIS2)
13228 printf ("%svis2", first ? "" : "|"), first = 0;
13229 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13230 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13231 if (mask & ELF_SPARC_HWCAP_FMAF)
13232 printf ("%sfmaf", first ? "" : "|"), first = 0;
13233 if (mask & ELF_SPARC_HWCAP_VIS3)
13234 printf ("%svis3", first ? "" : "|"), first = 0;
13235 if (mask & ELF_SPARC_HWCAP_HPC)
13236 printf ("%shpc", first ? "" : "|"), first = 0;
13237 if (mask & ELF_SPARC_HWCAP_RANDOM)
13238 printf ("%srandom", first ? "" : "|"), first = 0;
13239 if (mask & ELF_SPARC_HWCAP_TRANS)
13240 printf ("%strans", first ? "" : "|"), first = 0;
13241 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13242 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13243 if (mask & ELF_SPARC_HWCAP_IMA)
13244 printf ("%sima", first ? "" : "|"), first = 0;
13245 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13246 printf ("%scspare", first ? "" : "|"), first = 0;
13247 }
13248 else
071436c6
NC		 13249 fputc ('0', stdout);
13250 fputc ('\n', stdout);
9e8c70f9
DM		 13251}
13252
3d68f91c
JM		 13253static void
13254display_sparc_hwcaps2 (int mask)
13255{
13256 if (mask)
13257 {
13258 int first = 1;
071436c6 13259
3d68f91c
JM		 13260 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13261 fputs ("fjathplus", stdout), first = 0;
13262 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13263 printf ("%svis3b", first ? "" : "|"), first = 0;
13264 if (mask & ELF_SPARC_HWCAP2_ADP)
13265 printf ("%sadp", first ? "" : "|"), first = 0;
13266 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13267 printf ("%ssparc5", first ? "" : "|"), first = 0;
13268 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13269 printf ("%smwait", first ? "" : "|"), first = 0;
13270 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13271 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13272 if (mask & ELF_SPARC_HWCAP2_XMONT)
13273 printf ("%sxmont2", first ? "" : "|"), first = 0;
13274 if (mask & ELF_SPARC_HWCAP2_NSEC)
13275 printf ("%snsec", first ? "" : "|"), first = 0;
13276 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13277 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13278 if (mask & ELF_SPARC_HWCAP2_FJDES)
13279 printf ("%sfjdes", first ? "" : "|"), first = 0;
13280 if (mask & ELF_SPARC_HWCAP2_FJAES)
13281 printf ("%sfjaes", first ? "" : "|"), first = 0;
13282 }
13283 else
071436c6
NC		 13284 fputc ('0', stdout);
13285 fputc ('\n', stdout);
3d68f91c
JM		 13286}
13287
9e8c70f9 13288static unsigned char *
f6f0e17b
NC		 13289display_sparc_gnu_attribute (unsigned char * p,
13290 int tag,
13291 const unsigned char * const end)
9e8c70f9 13292{
3d68f91c
JM		 13293 unsigned int len;
13294 int val;
13295
9e8c70f9
DM		 13296 if (tag == Tag_GNU_Sparc_HWCAPS)
13297 {
f6f0e17b 13298 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13299 p += len;
13300 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13301 display_sparc_hwcaps (val);
13302 return p;
3d68f91c
JM		 13303 }
13304 if (tag == Tag_GNU_Sparc_HWCAPS2)
13305 {
13306 val = read_uleb128 (p, &len, end);
13307 p += len;
13308 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13309 display_sparc_hwcaps2 (val);
13310 return p;
13311 }
9e8c70f9 13312
f6f0e17b 13313 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13314}
13315
351cdf24
MF		 13316static void
13317print_mips_fp_abi_value (int val)
13318{
13319 switch (val)
13320 {
13321 case Val_GNU_MIPS_ABI_FP_ANY:
13322 printf (_("Hard or soft float\n"));
13323 break;
13324 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13325 printf (_("Hard float (double precision)\n"));
13326 break;
13327 case Val_GNU_MIPS_ABI_FP_SINGLE:
13328 printf (_("Hard float (single precision)\n"));
13329 break;
13330 case Val_GNU_MIPS_ABI_FP_SOFT:
13331 printf (_("Soft float\n"));
13332 break;
13333 case Val_GNU_MIPS_ABI_FP_OLD_64:
13334 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13335 break;
13336 case Val_GNU_MIPS_ABI_FP_XX:
13337 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13338 break;
13339 case Val_GNU_MIPS_ABI_FP_64:
13340 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13341 break;
13342 case Val_GNU_MIPS_ABI_FP_64A:
13343 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13344 break;
3350cc01
CM		 13345 case Val_GNU_MIPS_ABI_FP_NAN2008:
13346 printf (_("NaN 2008 compatibility\n"));
13347 break;
351cdf24
MF		 13348 default:
13349 printf ("??? (%d)\n", val);
13350 break;
13351 }
13352}
13353
2cf19d5c 13354static unsigned char *
f6f0e17b
NC		 13355display_mips_gnu_attribute (unsigned char * p,
13356 int tag,
13357 const unsigned char * const end)
2cf19d5c 13358{
2cf19d5c
JM		 13359 if (tag == Tag_GNU_MIPS_ABI_FP)
13360 {
f6f0e17b
NC		 13361 unsigned int len;
13362 int val;
13363
13364 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13365 p += len;
13366 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13367
351cdf24
MF		 13368 print_mips_fp_abi_value (val);
13369
2cf19d5c
JM		 13370 return p;
13371 }
13372
a9f58168
CF		 13373 if (tag == Tag_GNU_MIPS_ABI_MSA)
13374 {
13375 unsigned int len;
13376 int val;
13377
13378 val = read_uleb128 (p, &len, end);
13379 p += len;
13380 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13381
13382 switch (val)
13383 {
13384 case Val_GNU_MIPS_ABI_MSA_ANY:
13385 printf (_("Any MSA or not\n"));
13386 break;
13387 case Val_GNU_MIPS_ABI_MSA_128:
13388 printf (_("128-bit MSA\n"));
13389 break;
13390 default:
13391 printf ("??? (%d)\n", val);
13392 break;
13393 }
13394 return p;
13395 }
13396
f6f0e17b 13397 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13398}
13399
59e6276b 13400static unsigned char *
f6f0e17b
NC		 13401display_tic6x_attribute (unsigned char * p,
13402 const unsigned char * const end)
59e6276b
JM		 13403{
13404 int tag;
13405 unsigned int len;
13406 int val;
13407
f6f0e17b 13408 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13409 p += len;
13410
13411 switch (tag)
13412 {
75fa6dc1 13413 case Tag_ISA:
f6f0e17b 13414 val = read_uleb128 (p, &len, end);
59e6276b 13415 p += len;
75fa6dc1 13416 printf (" Tag_ISA: ");
59e6276b
JM		 13417
13418 switch (val)
13419 {
75fa6dc1 13420 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13421 printf (_("None\n"));
13422 break;
75fa6dc1 13423 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13424 printf ("C62x\n");
13425 break;
75fa6dc1 13426 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13427 printf ("C67x\n");
13428 break;
75fa6dc1 13429 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13430 printf ("C67x+\n");
13431 break;
75fa6dc1 13432 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13433 printf ("C64x\n");
13434 break;
75fa6dc1 13435 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13436 printf ("C64x+\n");
13437 break;
75fa6dc1 13438 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13439 printf ("C674x\n");
13440 break;
13441 default:
13442 printf ("??? (%d)\n", val);
13443 break;
13444 }
13445 return p;
13446
87779176 13447 case Tag_ABI_wchar_t:
f6f0e17b 13448 val = read_uleb128 (p, &len, end);
87779176
JM		 13449 p += len;
13450 printf (" Tag_ABI_wchar_t: ");
13451 switch (val)
13452 {
13453 case 0:
13454 printf (_("Not used\n"));
13455 break;
13456 case 1:
13457 printf (_("2 bytes\n"));
13458 break;
13459 case 2:
13460 printf (_("4 bytes\n"));
13461 break;
13462 default:
13463 printf ("??? (%d)\n", val);
13464 break;
13465 }
13466 return p;
13467
13468 case Tag_ABI_stack_align_needed:
f6f0e17b 13469 val = read_uleb128 (p, &len, end);
87779176
JM		 13470 p += len;
13471 printf (" Tag_ABI_stack_align_needed: ");
13472 switch (val)
13473 {
13474 case 0:
13475 printf (_("8-byte\n"));
13476 break;
13477 case 1:
13478 printf (_("16-byte\n"));
13479 break;
13480 default:
13481 printf ("??? (%d)\n", val);
13482 break;
13483 }
13484 return p;
13485
13486 case Tag_ABI_stack_align_preserved:
f6f0e17b 13487 val = read_uleb128 (p, &len, end);
87779176
JM		 13488 p += len;
13489 printf (" Tag_ABI_stack_align_preserved: ");
13490 switch (val)
13491 {
13492 case 0:
13493 printf (_("8-byte\n"));
13494 break;
13495 case 1:
13496 printf (_("16-byte\n"));
13497 break;
13498 default:
13499 printf ("??? (%d)\n", val);
13500 break;
13501 }
13502 return p;
13503
b5593623 13504 case Tag_ABI_DSBT:
f6f0e17b 13505 val = read_uleb128 (p, &len, end);
b5593623
JM		 13506 p += len;
13507 printf (" Tag_ABI_DSBT: ");
13508 switch (val)
13509 {
13510 case 0:
13511 printf (_("DSBT addressing not used\n"));
13512 break;
13513 case 1:
13514 printf (_("DSBT addressing used\n"));
13515 break;
13516 default:
13517 printf ("??? (%d)\n", val);
13518 break;
13519 }
13520 return p;
13521
87779176 13522 case Tag_ABI_PID:
f6f0e17b 13523 val = read_uleb128 (p, &len, end);
87779176
JM		 13524 p += len;
13525 printf (" Tag_ABI_PID: ");
13526 switch (val)
13527 {
13528 case 0:
13529 printf (_("Data addressing position-dependent\n"));
13530 break;
13531 case 1:
13532 printf (_("Data addressing position-independent, GOT near DP\n"));
13533 break;
13534 case 2:
13535 printf (_("Data addressing position-independent, GOT far from DP\n"));
13536 break;
13537 default:
13538 printf ("??? (%d)\n", val);
13539 break;
13540 }
13541 return p;
13542
13543 case Tag_ABI_PIC:
f6f0e17b 13544 val = read_uleb128 (p, &len, end);
87779176
JM		 13545 p += len;
13546 printf (" Tag_ABI_PIC: ");
13547 switch (val)
13548 {
13549 case 0:
13550 printf (_("Code addressing position-dependent\n"));
13551 break;
13552 case 1:
13553 printf (_("Code addressing position-independent\n"));
13554 break;
13555 default:
13556 printf ("??? (%d)\n", val);
13557 break;
13558 }
13559 return p;
13560
13561 case Tag_ABI_array_object_alignment:
f6f0e17b 13562 val = read_uleb128 (p, &len, end);
87779176
JM		 13563 p += len;
13564 printf (" Tag_ABI_array_object_alignment: ");
13565 switch (val)
13566 {
13567 case 0:
13568 printf (_("8-byte\n"));
13569 break;
13570 case 1:
13571 printf (_("4-byte\n"));
13572 break;
13573 case 2:
13574 printf (_("16-byte\n"));
13575 break;
13576 default:
13577 printf ("??? (%d)\n", val);
13578 break;
13579 }
13580 return p;
13581
13582 case Tag_ABI_array_object_align_expected:
f6f0e17b 13583 val = read_uleb128 (p, &len, end);
87779176
JM		 13584 p += len;
13585 printf (" Tag_ABI_array_object_align_expected: ");
13586 switch (val)
13587 {
13588 case 0:
13589 printf (_("8-byte\n"));
13590 break;
13591 case 1:
13592 printf (_("4-byte\n"));
13593 break;
13594 case 2:
13595 printf (_("16-byte\n"));
13596 break;
13597 default:
13598 printf ("??? (%d)\n", val);
13599 break;
13600 }
13601 return p;
13602
3cbd1c06 13603 case Tag_ABI_compatibility:
071436c6 13604 {
071436c6
NC		 13605 val = read_uleb128 (p, &len, end);
13606 p += len;
13607 printf (" Tag_ABI_compatibility: ");
071436c6 13608 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13609 if (p < end - 1)
13610 {
13611 size_t maxlen = (end - p) - 1;
13612
13613 print_symbol ((int) maxlen, (const char *) p);
13614 p += strnlen ((char *) p, maxlen) + 1;
13615 }
13616 else
13617 {
13618 printf (_("<corrupt>"));
13619 p = (unsigned char *) end;
13620 }
071436c6 13621 putchar ('\n');
071436c6
NC		 13622 return p;
13623 }
87779176
JM		 13624
13625 case Tag_ABI_conformance:
071436c6 13626 {
4082ef84
NC		 13627 printf (" Tag_ABI_conformance: \"");
13628 if (p < end - 1)
13629 {
13630 size_t maxlen = (end - p) - 1;
071436c6 13631
4082ef84
NC		 13632 print_symbol ((int) maxlen, (const char *) p);
13633 p += strnlen ((char *) p, maxlen) + 1;
13634 }
13635 else
13636 {
13637 printf (_("<corrupt>"));
13638 p = (unsigned char *) end;
13639 }
071436c6 13640 printf ("\"\n");
071436c6
NC		 13641 return p;
13642 }
59e6276b
JM		 13643 }
13644
f6f0e17b
NC		 13645 return display_tag_value (tag, p, end);
13646}
59e6276b 13647
f6f0e17b
NC		 13648static void
13649display_raw_attribute (unsigned char * p, unsigned char * end)
13650{
13651 unsigned long addr = 0;
13652 size_t bytes = end - p;
13653
e0a31db1 13654 assert (end > p);
f6f0e17b 13655 while (bytes)
87779176 13656 {
f6f0e17b
NC		 13657 int j;
13658 int k;
13659 int lbytes = (bytes > 16 ? 16 : bytes);
13660
13661 printf (" 0x%8.8lx ", addr);
13662
13663 for (j = 0; j < 16; j++)
13664 {
13665 if (j < lbytes)
13666 printf ("%2.2x", p[j]);
13667 else
13668 printf (" ");
13669
13670 if ((j & 3) == 3)
13671 printf (" ");
13672 }
13673
13674 for (j = 0; j < lbytes; j++)
13675 {
13676 k = p[j];
13677 if (k >= ' ' && k < 0x7f)
13678 printf ("%c", k);
13679 else
13680 printf (".");
13681 }
13682
13683 putchar ('\n');
13684
13685 p += lbytes;
13686 bytes -= lbytes;
13687 addr += lbytes;
87779176 13688 }
59e6276b 13689
f6f0e17b 13690 putchar ('\n');
59e6276b
JM		 13691}
13692
13761a11
NC		 13693static unsigned char *
13694display_msp430x_attribute (unsigned char * p,
13695 const unsigned char * const end)
13696{
13697 unsigned int len;
13698 int val;
13699 int tag;
13700
13701 tag = read_uleb128 (p, & len, end);
13702 p += len;
0b4362b0 13703
13761a11
NC		 13704 switch (tag)
13705 {
13706 case OFBA_MSPABI_Tag_ISA:
13707 val = read_uleb128 (p, &len, end);
13708 p += len;
13709 printf (" Tag_ISA: ");
13710 switch (val)
13711 {
13712 case 0: printf (_("None\n")); break;
13713 case 1: printf (_("MSP430\n")); break;
13714 case 2: printf (_("MSP430X\n")); break;
13715 default: printf ("??? (%d)\n", val); break;
13716 }
13717 break;
13718
13719 case OFBA_MSPABI_Tag_Code_Model:
13720 val = read_uleb128 (p, &len, end);
13721 p += len;
13722 printf (" Tag_Code_Model: ");
13723 switch (val)
13724 {
13725 case 0: printf (_("None\n")); break;
13726 case 1: printf (_("Small\n")); break;
13727 case 2: printf (_("Large\n")); break;
13728 default: printf ("??? (%d)\n", val); break;
13729 }
13730 break;
13731
13732 case OFBA_MSPABI_Tag_Data_Model:
13733 val = read_uleb128 (p, &len, end);
13734 p += len;
13735 printf (" Tag_Data_Model: ");
13736 switch (val)
13737 {
13738 case 0: printf (_("None\n")); break;
13739 case 1: printf (_("Small\n")); break;
13740 case 2: printf (_("Large\n")); break;
13741 case 3: printf (_("Restricted Large\n")); break;
13742 default: printf ("??? (%d)\n", val); break;
13743 }
13744 break;
13745
13746 default:
13747 printf (_(" <unknown tag %d>: "), tag);
13748
13749 if (tag & 1)
13750 {
071436c6 13751 putchar ('"');
4082ef84
NC		 13752 if (p < end - 1)
13753 {
13754 size_t maxlen = (end - p) - 1;
13755
13756 print_symbol ((int) maxlen, (const char *) p);
13757 p += strnlen ((char *) p, maxlen) + 1;
13758 }
13759 else
13760 {
13761 printf (_("<corrupt>"));
13762 p = (unsigned char *) end;
13763 }
071436c6 13764 printf ("\"\n");
13761a11
NC		 13765 }
13766 else
13767 {
13768 val = read_uleb128 (p, &len, end);
13769 p += len;
13770 printf ("%d (0x%x)\n", val, val);
13771 }
13772 break;
13773 }
13774
4082ef84 13775 assert (p <= end);
13761a11
NC		 13776 return p;
13777}
13778
11c1ff18 13779static int
60bca95a
NC		 13780process_attributes (FILE * file,
13781 const char * public_name,
104d59d1 13782 unsigned int proc_type,
f6f0e17b
NC		 13783 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13784 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13785{
2cf0635d 13786 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13787 unsigned i;
13788
13789 /* Find the section header so that we get the size. */
13790 for (i = 0, sect = section_headers;
13791 i < elf_header.e_shnum;
13792 i++, sect++)
13793 {
071436c6
NC		 13794 unsigned char * contents;
13795 unsigned char * p;
13796
104d59d1 13797 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13798 continue;
13799
3f5e193b
NC		 13800 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13801 sect->sh_size, _("attributes"));
60bca95a 13802 if (contents == NULL)
11c1ff18 13803 continue;
60bca95a 13804
11c1ff18
PB		 13805 p = contents;
13806 if (*p == 'A')
13807 {
071436c6
NC		 13808 bfd_vma section_len;
13809
13810 section_len = sect->sh_size - 1;
11c1ff18 13811 p++;
60bca95a 13812
071436c6 13813 while (section_len > 0)
11c1ff18 13814 {
071436c6 13815 bfd_vma attr_len;
e9847026 13816 unsigned int namelen;
11c1ff18 13817 bfd_boolean public_section;
104d59d1 13818 bfd_boolean gnu_section;
11c1ff18 13819
071436c6 13820 if (section_len <= 4)
e0a31db1
NC		 13821 {
13822 error (_("Tag section ends prematurely\n"));
13823 break;
13824 }
071436c6 13825 attr_len = byte_get (p, 4);
11c1ff18 13826 p += 4;
60bca95a 13827
071436c6 13828 if (attr_len > section_len)
11c1ff18 13829 {
071436c6
NC		 13830 error (_("Bad attribute length (%u > %u)\n"),
13831 (unsigned) attr_len, (unsigned) section_len);
13832 attr_len = section_len;
11c1ff18 13833 }
74e1a04b 13834 /* PR 17531: file: 001-101425-0.004 */
071436c6 13835 else if (attr_len < 5)
74e1a04b 13836 {
071436c6 13837 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13838 break;
13839 }
e9847026 13840
071436c6
NC		 13841 section_len -= attr_len;
13842 attr_len -= 4;
13843
13844 namelen = strnlen ((char *) p, attr_len) + 1;
13845 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13846 {
13847 error (_("Corrupt attribute section name\n"));
13848 break;
13849 }
13850
071436c6
NC		 13851 printf (_("Attribute Section: "));
13852 print_symbol (INT_MAX, (const char *) p);
13853 putchar ('\n');
60bca95a
NC		 13854
13855 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13856 public_section = TRUE;
13857 else
13858 public_section = FALSE;
60bca95a
NC		 13859
13860 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13861 gnu_section = TRUE;
13862 else
13863 gnu_section = FALSE;
60bca95a 13864
11c1ff18 13865 p += namelen;
071436c6 13866 attr_len -= namelen;
e0a31db1 13867
071436c6 13868 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13869 {
e0a31db1 13870 int tag;
11c1ff18
PB		 13871 int val;
13872 bfd_vma size;
071436c6 13873 unsigned char * end;
60bca95a 13874
e0a31db1 13875 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13876 if (attr_len < 6)
e0a31db1
NC		 13877 {
13878 error (_("Unused bytes at end of section\n"));
13879 section_len = 0;
13880 break;
13881 }
13882
13883 tag = *(p++);
11c1ff18 13884 size = byte_get (p, 4);
071436c6 13885 if (size > attr_len)
11c1ff18 13886 {
e9847026 13887 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13888 (unsigned) size, (unsigned) attr_len);
13889 size = attr_len;
11c1ff18 13890 }
e0a31db1
NC		 13891 /* PR binutils/17531: Safe handling of corrupt files. */
13892 if (size < 6)
13893 {
13894 error (_("Bad subsection length (%u < 6)\n"),
13895 (unsigned) size);
13896 section_len = 0;
13897 break;
13898 }
60bca95a 13899
071436c6 13900 attr_len -= size;
11c1ff18 13901 end = p + size - 1;
071436c6 13902 assert (end <= contents + sect->sh_size);
11c1ff18 13903 p += 4;
60bca95a 13904
11c1ff18
PB		 13905 switch (tag)
13906 {
13907 case 1:
2b692964 13908 printf (_("File Attributes\n"));
11c1ff18
PB		 13909 break;
13910 case 2:
2b692964 13911 printf (_("Section Attributes:"));
11c1ff18
PB		 13912 goto do_numlist;
13913 case 3:
2b692964 13914 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13915 do_numlist:
13916 for (;;)
13917 {
91d6fa6a 13918 unsigned int j;
60bca95a 13919
f6f0e17b 13920 val = read_uleb128 (p, &j, end);
91d6fa6a 13921 p += j;
11c1ff18
PB		 13922 if (val == 0)
13923 break;
13924 printf (" %d", val);
13925 }
13926 printf ("\n");
13927 break;
13928 default:
2b692964 13929 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13930 public_section = FALSE;
13931 break;
13932 }
60bca95a 13933
071436c6 13934 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13935 {
13936 while (p < end)
f6f0e17b 13937 p = display_pub_attribute (p, end);
071436c6 13938 assert (p <= end);
104d59d1 13939 }
071436c6 13940 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13941 {
13942 while (p < end)
13943 p = display_gnu_attribute (p,
f6f0e17b
NC		 13944 display_proc_gnu_attribute,
13945 end);
071436c6 13946 assert (p <= end);
11c1ff18 13947 }
071436c6 13948 else if (p < end)
11c1ff18 13949 {
071436c6 13950 printf (_(" Unknown attribute:\n"));
f6f0e17b 13951 display_raw_attribute (p, end);
11c1ff18
PB		 13952 p = end;
13953 }
071436c6
NC		 13954 else
13955 attr_len = 0;
11c1ff18
PB		 13956 }
13957 }
13958 }
13959 else
e9847026 13960 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13961
60bca95a 13962 free (contents);
11c1ff18
PB		 13963 }
13964 return 1;
13965}
13966
104d59d1 13967static int
2cf0635d 13968process_arm_specific (FILE * file)
104d59d1
JM		 13969{
13970 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13971 display_arm_attribute, NULL);
13972}
13973
34c8bcba 13974static int
2cf0635d 13975process_power_specific (FILE * file)
34c8bcba
JM		 13976{
13977 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13978 display_power_gnu_attribute);
13979}
13980
643f7afb
AK		 13981static int
13982process_s390_specific (FILE * file)
13983{
13984 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13985 display_s390_gnu_attribute);
13986}
13987
9e8c70f9
DM		 13988static int
13989process_sparc_specific (FILE * file)
13990{
13991 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13992 display_sparc_gnu_attribute);
13993}
13994
59e6276b
JM		 13995static int
13996process_tic6x_specific (FILE * file)
13997{
13998 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13999 display_tic6x_attribute, NULL);
14000}
14001
13761a11
NC		 14002static int
14003process_msp430x_specific (FILE * file)
14004{
14005 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
14006 display_msp430x_attribute, NULL);
14007}
14008
ccb4c951
RS		 14009/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14010 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 14011 and return the VMA of the next entry, or -1 if there was a problem.
14012 Does not read from DATA_END or beyond. */
ccb4c951
RS		 14013
14014static bfd_vma
82b1b41b
NC		 14015print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14016 unsigned char * data_end)
ccb4c951
RS		 14017{
14018 printf (" ");
14019 print_vma (addr, LONG_HEX);
14020 printf (" ");
14021 if (addr < pltgot + 0xfff0)
14022 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14023 else
14024 printf ("%10s", "");
14025 printf (" ");
14026 if (data == NULL)
2b692964 14027 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14028 else
14029 {
14030 bfd_vma entry;
82b1b41b 14031 unsigned char * from = data + addr - pltgot;
ccb4c951 14032
82b1b41b
NC		 14033 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14034 {
14035 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14036 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14037 return (bfd_vma) -1;
14038 }
14039 else
14040 {
14041 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14042 print_vma (entry, LONG_HEX);
14043 }
ccb4c951
RS		 14044 }
14045 return addr + (is_32bit_elf ? 4 : 8);
14046}
14047
861fb55a
DJ		 14048/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14049 PLTGOT. Print the Address and Initial fields of an entry at VMA
14050 ADDR and return the VMA of the next entry. */
14051
14052static bfd_vma
2cf0635d 14053print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14054{
14055 printf (" ");
14056 print_vma (addr, LONG_HEX);
14057 printf (" ");
14058 if (data == NULL)
2b692964 14059 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14060 else
14061 {
14062 bfd_vma entry;
14063
14064 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14065 print_vma (entry, LONG_HEX);
14066 }
14067 return addr + (is_32bit_elf ? 4 : 8);
14068}
14069
351cdf24
MF		 14070static void
14071print_mips_ases (unsigned int mask)
14072{
14073 if (mask & AFL_ASE_DSP)
14074 fputs ("\n\tDSP ASE", stdout);
14075 if (mask & AFL_ASE_DSPR2)
14076 fputs ("\n\tDSP R2 ASE", stdout);
14077 if (mask & AFL_ASE_EVA)
14078 fputs ("\n\tEnhanced VA Scheme", stdout);
14079 if (mask & AFL_ASE_MCU)
14080 fputs ("\n\tMCU (MicroController) ASE", stdout);
14081 if (mask & AFL_ASE_MDMX)
14082 fputs ("\n\tMDMX ASE", stdout);
14083 if (mask & AFL_ASE_MIPS3D)
14084 fputs ("\n\tMIPS-3D ASE", stdout);
14085 if (mask & AFL_ASE_MT)
14086 fputs ("\n\tMT ASE", stdout);
14087 if (mask & AFL_ASE_SMARTMIPS)
14088 fputs ("\n\tSmartMIPS ASE", stdout);
14089 if (mask & AFL_ASE_VIRT)
14090 fputs ("\n\tVZ ASE", stdout);
14091 if (mask & AFL_ASE_MSA)
14092 fputs ("\n\tMSA ASE", stdout);
14093 if (mask & AFL_ASE_MIPS16)
14094 fputs ("\n\tMIPS16 ASE", stdout);
14095 if (mask & AFL_ASE_MICROMIPS)
14096 fputs ("\n\tMICROMIPS ASE", stdout);
14097 if (mask & AFL_ASE_XPA)
14098 fputs ("\n\tXPA ASE", stdout);
14099 if (mask == 0)
14100 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14101 else if ((mask & ~AFL_ASE_MASK) != 0)
14102 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14103}
14104
14105static void
14106print_mips_isa_ext (unsigned int isa_ext)
14107{
14108 switch (isa_ext)
14109 {
14110 case 0:
14111 fputs (_("None"), stdout);
14112 break;
14113 case AFL_EXT_XLR:
14114 fputs ("RMI XLR", stdout);
14115 break;
2c629856
N		 14116 case AFL_EXT_OCTEON3:
14117 fputs ("Cavium Networks Octeon3", stdout);
14118 break;
351cdf24
MF		 14119 case AFL_EXT_OCTEON2:
14120 fputs ("Cavium Networks Octeon2", stdout);
14121 break;
14122 case AFL_EXT_OCTEONP:
14123 fputs ("Cavium Networks OcteonP", stdout);
14124 break;
14125 case AFL_EXT_LOONGSON_3A:
14126 fputs ("Loongson 3A", stdout);
14127 break;
14128 case AFL_EXT_OCTEON:
14129 fputs ("Cavium Networks Octeon", stdout);
14130 break;
14131 case AFL_EXT_5900:
14132 fputs ("Toshiba R5900", stdout);
14133 break;
14134 case AFL_EXT_4650:
14135 fputs ("MIPS R4650", stdout);
14136 break;
14137 case AFL_EXT_4010:
14138 fputs ("LSI R4010", stdout);
14139 break;
14140 case AFL_EXT_4100:
14141 fputs ("NEC VR4100", stdout);
14142 break;
14143 case AFL_EXT_3900:
14144 fputs ("Toshiba R3900", stdout);
14145 break;
14146 case AFL_EXT_10000:
14147 fputs ("MIPS R10000", stdout);
14148 break;
14149 case AFL_EXT_SB1:
14150 fputs ("Broadcom SB-1", stdout);
14151 break;
14152 case AFL_EXT_4111:
14153 fputs ("NEC VR4111/VR4181", stdout);
14154 break;
14155 case AFL_EXT_4120:
14156 fputs ("NEC VR4120", stdout);
14157 break;
14158 case AFL_EXT_5400:
14159 fputs ("NEC VR5400", stdout);
14160 break;
14161 case AFL_EXT_5500:
14162 fputs ("NEC VR5500", stdout);
14163 break;
14164 case AFL_EXT_LOONGSON_2E:
14165 fputs ("ST Microelectronics Loongson 2E", stdout);
14166 break;
14167 case AFL_EXT_LOONGSON_2F:
14168 fputs ("ST Microelectronics Loongson 2F", stdout);
14169 break;
14170 default:
00ac7aa0 14171 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14172 }
14173}
14174
14175static int
14176get_mips_reg_size (int reg_size)
14177{
14178 return (reg_size == AFL_REG_NONE) ? 0
14179 : (reg_size == AFL_REG_32) ? 32
14180 : (reg_size == AFL_REG_64) ? 64
14181 : (reg_size == AFL_REG_128) ? 128
14182 : -1;
14183}
14184
19e6b90e 14185static int
2cf0635d 14186process_mips_specific (FILE * file)
5b18a4bc 14187{
2cf0635d 14188 Elf_Internal_Dyn * entry;
351cdf24 14189 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14190 size_t liblist_offset = 0;
14191 size_t liblistno = 0;
14192 size_t conflictsno = 0;
14193 size_t options_offset = 0;
14194 size_t conflicts_offset = 0;
861fb55a
DJ		 14195 size_t pltrelsz = 0;
14196 size_t pltrel = 0;
ccb4c951 14197 bfd_vma pltgot = 0;
861fb55a
DJ		 14198 bfd_vma mips_pltgot = 0;
14199 bfd_vma jmprel = 0;
ccb4c951
RS		 14200 bfd_vma local_gotno = 0;
14201 bfd_vma gotsym = 0;
14202 bfd_vma symtabno = 0;
103f02d3 14203
2cf19d5c
JM		 14204 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14205 display_mips_gnu_attribute);
14206
351cdf24
MF		 14207 sect = find_section (".MIPS.abiflags");
14208
14209 if (sect != NULL)
14210 {
14211 Elf_External_ABIFlags_v0 *abiflags_ext;
14212 Elf_Internal_ABIFlags_v0 abiflags_in;
14213
14214 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14215 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14216 else
14217 {
14218 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14219 sect->sh_size, _("MIPS ABI Flags section"));
14220 if (abiflags_ext)
14221 {
14222 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14223 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14224 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14225 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14226 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14227 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14228 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14229 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14230 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14231 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14232 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14233
14234 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14235 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14236 if (abiflags_in.isa_rev > 1)
14237 printf ("r%d", abiflags_in.isa_rev);
14238 printf ("\nGPR size: %d",
14239 get_mips_reg_size (abiflags_in.gpr_size));
14240 printf ("\nCPR1 size: %d",
14241 get_mips_reg_size (abiflags_in.cpr1_size));
14242 printf ("\nCPR2 size: %d",
14243 get_mips_reg_size (abiflags_in.cpr2_size));
14244 fputs ("\nFP ABI: ", stdout);
14245 print_mips_fp_abi_value (abiflags_in.fp_abi);
14246 fputs ("ISA Extension: ", stdout);
14247 print_mips_isa_ext (abiflags_in.isa_ext);
14248 fputs ("\nASEs:", stdout);
14249 print_mips_ases (abiflags_in.ases);
14250 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14251 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14252 fputc ('\n', stdout);
14253 free (abiflags_ext);
14254 }
14255 }
14256 }
14257
19e6b90e
L		 14258 /* We have a lot of special sections. Thanks SGI! */
14259 if (dynamic_section == NULL)
14260 /* No information available. */
14261 return 0;
252b5132 14262
071436c6
NC		 14263 for (entry = dynamic_section;
14264 /* PR 17531 file: 012-50589-0.004. */
14265 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14266 ++entry)
252b5132
RH		 14267 switch (entry->d_tag)
14268 {
14269 case DT_MIPS_LIBLIST:
d93f0186
NC		 14270 liblist_offset
14271 = offset_from_vma (file, entry->d_un.d_val,
14272 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14273 break;
14274 case DT_MIPS_LIBLISTNO:
14275 liblistno = entry->d_un.d_val;
14276 break;
14277 case DT_MIPS_OPTIONS:
d93f0186 14278 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14279 break;
14280 case DT_MIPS_CONFLICT:
d93f0186
NC		 14281 conflicts_offset
14282 = offset_from_vma (file, entry->d_un.d_val,
14283 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14284 break;
14285 case DT_MIPS_CONFLICTNO:
14286 conflictsno = entry->d_un.d_val;
14287 break;
ccb4c951 14288 case DT_PLTGOT:
861fb55a
DJ		 14289 pltgot = entry->d_un.d_ptr;
14290 break;
ccb4c951
RS		 14291 case DT_MIPS_LOCAL_GOTNO:
14292 local_gotno = entry->d_un.d_val;
14293 break;
14294 case DT_MIPS_GOTSYM:
14295 gotsym = entry->d_un.d_val;
14296 break;
14297 case DT_MIPS_SYMTABNO:
14298 symtabno = entry->d_un.d_val;
14299 break;
861fb55a
DJ		 14300 case DT_MIPS_PLTGOT:
14301 mips_pltgot = entry->d_un.d_ptr;
14302 break;
14303 case DT_PLTREL:
14304 pltrel = entry->d_un.d_val;
14305 break;
14306 case DT_PLTRELSZ:
14307 pltrelsz = entry->d_un.d_val;
14308 break;
14309 case DT_JMPREL:
14310 jmprel = entry->d_un.d_ptr;
14311 break;
252b5132
RH		 14312 default:
14313 break;
14314 }
14315
14316 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14317 {
2cf0635d 14318 Elf32_External_Lib * elib;
252b5132
RH		 14319 size_t cnt;
14320
3f5e193b
NC		 14321 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14322 liblistno,
14323 sizeof (Elf32_External_Lib),
9cf03b7e 14324 _("liblist section data"));
a6e9f9df 14325 if (elib)
252b5132 14326 {
2b692964 14327 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14328 (unsigned long) liblistno);
2b692964 14329 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14330 stdout);
14331
14332 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14333 {
a6e9f9df 14334 Elf32_Lib liblist;
91d6fa6a 14335 time_t atime;
a6e9f9df 14336 char timebuf[20];
2cf0635d 14337 struct tm * tmp;
a6e9f9df
AM		 14338
14339 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14340 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14341 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14342 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14343 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14344
91d6fa6a 14345 tmp = gmtime (&atime);
e9e44622
JJ		 14346 snprintf (timebuf, sizeof (timebuf),
14347 "%04u-%02u-%02uT%02u:%02u:%02u",
14348 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14349 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14350
31104126 14351 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14352 if (VALID_DYNAMIC_NAME (liblist.l_name))
14353 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14354 else
2b692964 14355 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14356 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14357 liblist.l_version);
a6e9f9df
AM		 14358
14359 if (liblist.l_flags == 0)
2b692964 14360 puts (_(" NONE"));
a6e9f9df
AM		 14361 else
14362 {
14363 static const struct
252b5132 14364 {
2cf0635d 14365 const char * name;
a6e9f9df 14366 int bit;
252b5132 14367 }
a6e9f9df
AM		 14368 l_flags_vals[] =
14369 {
14370 { " EXACT_MATCH", LL_EXACT_MATCH },
14371 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14372 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14373 { " EXPORTS", LL_EXPORTS },
14374 { " DELAY_LOAD", LL_DELAY_LOAD },
14375 { " DELTA", LL_DELTA }
14376 };
14377 int flags = liblist.l_flags;
14378 size_t fcnt;
14379
60bca95a 14380 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14381 if ((flags & l_flags_vals[fcnt].bit) != 0)
14382 {
14383 fputs (l_flags_vals[fcnt].name, stdout);
14384 flags ^= l_flags_vals[fcnt].bit;
14385 }
14386 if (flags != 0)
14387 printf (" %#x", (unsigned int) flags);
252b5132 14388
a6e9f9df
AM		 14389 puts ("");
14390 }
252b5132 14391 }
252b5132 14392
a6e9f9df
AM		 14393 free (elib);
14394 }
252b5132
RH		 14395 }
14396
14397 if (options_offset != 0)
14398 {
2cf0635d 14399 Elf_External_Options * eopt;
2cf0635d
NC		 14400 Elf_Internal_Options * iopt;
14401 Elf_Internal_Options * option;
252b5132
RH		 14402 size_t offset;
14403 int cnt;
351cdf24 14404 sect = section_headers;
252b5132
RH		 14405
14406 /* Find the section header so that we get the size. */
071436c6 14407 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14408 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14409 if (sect == NULL)
14410 {
14411 error (_("No MIPS_OPTIONS header found\n"));
14412 return 0;
14413 }
252b5132 14414
3f5e193b
NC		 14415 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14416 sect->sh_size, _("options"));
a6e9f9df 14417 if (eopt)
252b5132 14418 {
3f5e193b
NC		 14419 iopt = (Elf_Internal_Options *)
14420 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14421 if (iopt == NULL)
14422 {
8b73c356 14423 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14424 return 0;
14425 }
76da6bbe 14426
a6e9f9df
AM		 14427 offset = cnt = 0;
14428 option = iopt;
252b5132 14429
82b1b41b 14430 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14431 {
2cf0635d 14432 Elf_External_Options * eoption;
252b5132 14433
a6e9f9df 14434 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14435
a6e9f9df
AM		 14436 option->kind = BYTE_GET (eoption->kind);
14437 option->size = BYTE_GET (eoption->size);
14438 option->section = BYTE_GET (eoption->section);
14439 option->info = BYTE_GET (eoption->info);
76da6bbe 14440
82b1b41b
NC		 14441 /* PR 17531: file: ffa0fa3b. */
14442 if (option->size < sizeof (* eopt)
14443 || offset + option->size > sect->sh_size)
14444 {
55325047
NC		 14445 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14446 return 0;
82b1b41b 14447 }
a6e9f9df 14448 offset += option->size;
14ae95f2 14449
a6e9f9df
AM		 14450 ++option;
14451 ++cnt;
14452 }
252b5132 14453
a6e9f9df 14454 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14455 printable_section_name (sect), cnt);
76da6bbe 14456
a6e9f9df 14457 option = iopt;
82b1b41b 14458 offset = 0;
252b5132 14459
a6e9f9df 14460 while (cnt-- > 0)
252b5132 14461 {
a6e9f9df
AM		 14462 size_t len;
14463
14464 switch (option->kind)
252b5132 14465 {
a6e9f9df
AM		 14466 case ODK_NULL:
14467 /* This shouldn't happen. */
14468 printf (" NULL %d %lx", option->section, option->info);
14469 break;
14470 case ODK_REGINFO:
14471 printf (" REGINFO ");
14472 if (elf_header.e_machine == EM_MIPS)
14473 {
14474 /* 32bit form. */
2cf0635d 14475 Elf32_External_RegInfo * ereg;
b34976b6 14476 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14477
14478 ereg = (Elf32_External_RegInfo *) (option + 1);
14479 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14480 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14481 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14482 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14483 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14484 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14485
14486 printf ("GPR %08lx GP 0x%lx\n",
14487 reginfo.ri_gprmask,
14488 (unsigned long) reginfo.ri_gp_value);
14489 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14490 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14491 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14492 }
14493 else
14494 {
14495 /* 64 bit form. */
2cf0635d 14496 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14497 Elf64_Internal_RegInfo reginfo;
14498
14499 ereg = (Elf64_External_RegInfo *) (option + 1);
14500 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14501 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14502 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14503 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14504 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14505 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14506
14507 printf ("GPR %08lx GP 0x",
14508 reginfo.ri_gprmask);
14509 printf_vma (reginfo.ri_gp_value);
14510 printf ("\n");
14511
14512 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14513 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14514 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14515 }
14516 ++option;
14517 continue;
14518 case ODK_EXCEPTIONS:
14519 fputs (" EXCEPTIONS fpe_min(", stdout);
14520 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14521 fputs (") fpe_max(", stdout);
14522 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14523 fputs (")", stdout);
14524
14525 if (option->info & OEX_PAGE0)
14526 fputs (" PAGE0", stdout);
14527 if (option->info & OEX_SMM)
14528 fputs (" SMM", stdout);
14529 if (option->info & OEX_FPDBUG)
14530 fputs (" FPDBUG", stdout);
14531 if (option->info & OEX_DISMISS)
14532 fputs (" DISMISS", stdout);
14533 break;
14534 case ODK_PAD:
14535 fputs (" PAD ", stdout);
14536 if (option->info & OPAD_PREFIX)
14537 fputs (" PREFIX", stdout);
14538 if (option->info & OPAD_POSTFIX)
14539 fputs (" POSTFIX", stdout);
14540 if (option->info & OPAD_SYMBOL)
14541 fputs (" SYMBOL", stdout);
14542 break;
14543 case ODK_HWPATCH:
14544 fputs (" HWPATCH ", stdout);
14545 if (option->info & OHW_R4KEOP)
14546 fputs (" R4KEOP", stdout);
14547 if (option->info & OHW_R8KPFETCH)
14548 fputs (" R8KPFETCH", stdout);
14549 if (option->info & OHW_R5KEOP)
14550 fputs (" R5KEOP", stdout);
14551 if (option->info & OHW_R5KCVTL)
14552 fputs (" R5KCVTL", stdout);
14553 break;
14554 case ODK_FILL:
14555 fputs (" FILL ", stdout);
14556 /* XXX Print content of info word? */
14557 break;
14558 case ODK_TAGS:
14559 fputs (" TAGS ", stdout);
14560 /* XXX Print content of info word? */
14561 break;
14562 case ODK_HWAND:
14563 fputs (" HWAND ", stdout);
14564 if (option->info & OHWA0_R4KEOP_CHECKED)
14565 fputs (" R4KEOP_CHECKED", stdout);
14566 if (option->info & OHWA0_R4KEOP_CLEAN)
14567 fputs (" R4KEOP_CLEAN", stdout);
14568 break;
14569 case ODK_HWOR:
14570 fputs (" HWOR ", stdout);
14571 if (option->info & OHWA0_R4KEOP_CHECKED)
14572 fputs (" R4KEOP_CHECKED", stdout);
14573 if (option->info & OHWA0_R4KEOP_CLEAN)
14574 fputs (" R4KEOP_CLEAN", stdout);
14575 break;
14576 case ODK_GP_GROUP:
14577 printf (" GP_GROUP %#06lx self-contained %#06lx",
14578 option->info & OGP_GROUP,
14579 (option->info & OGP_SELF) >> 16);
14580 break;
14581 case ODK_IDENT:
14582 printf (" IDENT %#06lx self-contained %#06lx",
14583 option->info & OGP_GROUP,
14584 (option->info & OGP_SELF) >> 16);
14585 break;
14586 default:
14587 /* This shouldn't happen. */
14588 printf (" %3d ??? %d %lx",
14589 option->kind, option->section, option->info);
14590 break;
252b5132 14591 }
a6e9f9df 14592
2cf0635d 14593 len = sizeof (* eopt);
a6e9f9df 14594 while (len < option->size)
82b1b41b 14595 {
7e27a9d5 14596 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14597
82b1b41b
NC		 14598 if (ISPRINT (datum))
14599 printf ("%c", datum);
14600 else
14601 printf ("\\%03o", datum);
14602 len ++;
14603 }
a6e9f9df 14604 fputs ("\n", stdout);
82b1b41b
NC		 14605
14606 offset += option->size;
252b5132 14607 ++option;
252b5132
RH		 14608 }
14609
a6e9f9df 14610 free (eopt);
252b5132 14611 }
252b5132
RH		 14612 }
14613
14614 if (conflicts_offset != 0 && conflictsno != 0)
14615 {
2cf0635d 14616 Elf32_Conflict * iconf;
252b5132
RH		 14617 size_t cnt;
14618
14619 if (dynamic_symbols == NULL)
14620 {
591a748a 14621 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14622 return 0;
14623 }
14624
3f5e193b 14625 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14626 if (iconf == NULL)
14627 {
8b73c356 14628 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14629 return 0;
14630 }
14631
9ea033b2 14632 if (is_32bit_elf)
252b5132 14633 {
2cf0635d 14634 Elf32_External_Conflict * econf32;
a6e9f9df 14635
3f5e193b
NC		 14636 econf32 = (Elf32_External_Conflict *)
14637 get_data (NULL, file, conflicts_offset, conflictsno,
14638 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14639 if (!econf32)
14640 return 0;
252b5132
RH		 14641
14642 for (cnt = 0; cnt < conflictsno; ++cnt)
14643 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14644
14645 free (econf32);
252b5132
RH		 14646 }
14647 else
14648 {
2cf0635d 14649 Elf64_External_Conflict * econf64;
a6e9f9df 14650
3f5e193b
NC		 14651 econf64 = (Elf64_External_Conflict *)
14652 get_data (NULL, file, conflicts_offset, conflictsno,
14653 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14654 if (!econf64)
14655 return 0;
252b5132
RH		 14656
14657 for (cnt = 0; cnt < conflictsno; ++cnt)
14658 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14659
14660 free (econf64);
252b5132
RH		 14661 }
14662
c7e7ca54
NC		 14663 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14664 (unsigned long) conflictsno);
252b5132
RH		 14665 puts (_(" Num: Index Value Name"));
14666
14667 for (cnt = 0; cnt < conflictsno; ++cnt)
14668 {
b34976b6 14669 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14670
14671 if (iconf[cnt] >= num_dynamic_syms)
14672 printf (_("<corrupt symbol index>"));
d79b3d50 14673 else
e0a31db1
NC		 14674 {
14675 Elf_Internal_Sym * psym;
14676
14677 psym = & dynamic_symbols[iconf[cnt]];
14678 print_vma (psym->st_value, FULL_HEX);
14679 putchar (' ');
14680 if (VALID_DYNAMIC_NAME (psym->st_name))
14681 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14682 else
14683 printf (_("<corrupt: %14ld>"), psym->st_name);
14684 }
31104126 14685 putchar ('\n');
252b5132
RH		 14686 }
14687
252b5132
RH		 14688 free (iconf);
14689 }
14690
ccb4c951
RS		 14691 if (pltgot != 0 && local_gotno != 0)
14692 {
91d6fa6a 14693 bfd_vma ent, local_end, global_end;
bbeee7ea 14694 size_t i, offset;
2cf0635d 14695 unsigned char * data;
82b1b41b 14696 unsigned char * data_end;
bbeee7ea 14697 int addr_size;
ccb4c951 14698
91d6fa6a 14699 ent = pltgot;
ccb4c951
RS		 14700 addr_size = (is_32bit_elf ? 4 : 8);
14701 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14702
74e1a04b
NC		 14703 /* PR binutils/17533 file: 012-111227-0.004 */
14704 if (symtabno < gotsym)
14705 {
14706 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14707 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14708 return 0;
14709 }
82b1b41b 14710
74e1a04b 14711 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14712 /* PR 17531: file: 54c91a34. */
14713 if (global_end < local_end)
14714 {
14715 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14716 return 0;
14717 }
948f632f 14718
ccb4c951 14719 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14720 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14721 global_end - pltgot, 1,
14722 _("Global Offset Table data"));
59245841
NC		 14723 if (data == NULL)
14724 return 0;
82b1b41b 14725 data_end = data + (global_end - pltgot);
59245841 14726
ccb4c951
RS		 14727 printf (_("\nPrimary GOT:\n"));
14728 printf (_(" Canonical gp value: "));
14729 print_vma (pltgot + 0x7ff0, LONG_HEX);
14730 printf ("\n\n");
14731
14732 printf (_(" Reserved entries:\n"));
14733 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14734 addr_size * 2, _("Address"), _("Access"),
14735 addr_size * 2, _("Initial"));
82b1b41b 14736 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14737 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14738 if (ent == (bfd_vma) -1)
14739 goto got_print_fail;
ccb4c951 14740 if (data
91d6fa6a 14741 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14742 >> (addr_size * 8 - 1)) != 0)
14743 {
82b1b41b 14744 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14745 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14746 if (ent == (bfd_vma) -1)
14747 goto got_print_fail;
ccb4c951
RS		 14748 }
14749 printf ("\n");
14750
91d6fa6a 14751 if (ent < local_end)
ccb4c951
RS		 14752 {
14753 printf (_(" Local entries:\n"));
cc5914eb 14754 printf (" %*s %10s %*s\n",
2b692964
NC		 14755 addr_size * 2, _("Address"), _("Access"),
14756 addr_size * 2, _("Initial"));
91d6fa6a 14757 while (ent < local_end)
ccb4c951 14758 {
82b1b41b 14759 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14760 printf ("\n");
82b1b41b
NC		 14761 if (ent == (bfd_vma) -1)
14762 goto got_print_fail;
ccb4c951
RS		 14763 }
14764 printf ("\n");
14765 }
14766
14767 if (gotsym < symtabno)
14768 {
14769 int sym_width;
14770
14771 printf (_(" Global entries:\n"));
cc5914eb 14772 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14773 addr_size * 2, _("Address"),
14774 _("Access"),
2b692964 14775 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14776 addr_size * 2, _("Sym.Val."),
14777 _("Type"),
14778 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14779 _("Ndx"), _("Name"));
0b4362b0 14780
ccb4c951 14781 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14782
ccb4c951
RS		 14783 for (i = gotsym; i < symtabno; i++)
14784 {
82b1b41b 14785 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14786 printf (" ");
e0a31db1
NC		 14787
14788 if (dynamic_symbols == NULL)
14789 printf (_("<no dynamic symbols>"));
14790 else if (i < num_dynamic_syms)
14791 {
14792 Elf_Internal_Sym * psym = dynamic_symbols + i;
14793
14794 print_vma (psym->st_value, LONG_HEX);
14795 printf (" %-7s %3s ",
14796 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14797 get_symbol_index_type (psym->st_shndx));
14798
14799 if (VALID_DYNAMIC_NAME (psym->st_name))
14800 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14801 else
14802 printf (_("<corrupt: %14ld>"), psym->st_name);
14803 }
ccb4c951 14804 else
7fc5ac57
JBG		 14805 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14806 (unsigned long) i);
e0a31db1 14807
ccb4c951 14808 printf ("\n");
82b1b41b
NC		 14809 if (ent == (bfd_vma) -1)
14810 break;
ccb4c951
RS		 14811 }
14812 printf ("\n");
14813 }
14814
82b1b41b 14815 got_print_fail:
ccb4c951
RS		 14816 if (data)
14817 free (data);
14818 }
14819
861fb55a
DJ		 14820 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14821 {
91d6fa6a 14822 bfd_vma ent, end;
861fb55a
DJ		 14823 size_t offset, rel_offset;
14824 unsigned long count, i;
2cf0635d 14825 unsigned char * data;
861fb55a 14826 int addr_size, sym_width;
2cf0635d 14827 Elf_Internal_Rela * rels;
861fb55a
DJ		 14828
14829 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14830 if (pltrel == DT_RELA)
14831 {
14832 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14833 return 0;
14834 }
14835 else
14836 {
14837 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14838 return 0;
14839 }
14840
91d6fa6a 14841 ent = mips_pltgot;
861fb55a
DJ		 14842 addr_size = (is_32bit_elf ? 4 : 8);
14843 end = mips_pltgot + (2 + count) * addr_size;
14844
14845 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14846 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14847 1, _("Procedure Linkage Table data"));
59245841
NC		 14848 if (data == NULL)
14849 return 0;
14850
9cf03b7e 14851 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14852 printf (_(" Reserved entries:\n"));
14853 printf (_(" %*s %*s Purpose\n"),
2b692964 14854 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14855 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14856 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14857 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14858 printf (_(" Module pointer\n"));
861fb55a
DJ		 14859 printf ("\n");
14860
14861 printf (_(" Entries:\n"));
cc5914eb 14862 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14863 addr_size * 2, _("Address"),
14864 addr_size * 2, _("Initial"),
14865 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14866 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14867 for (i = 0; i < count; i++)
14868 {
df97ab2a 14869 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14870
91d6fa6a 14871 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14872 printf (" ");
e0a31db1 14873
df97ab2a
MF		 14874 if (idx >= num_dynamic_syms)
14875 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14876 else
e0a31db1 14877 {
df97ab2a 14878 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14879
14880 print_vma (psym->st_value, LONG_HEX);
14881 printf (" %-7s %3s ",
14882 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14883 get_symbol_index_type (psym->st_shndx));
14884 if (VALID_DYNAMIC_NAME (psym->st_name))
14885 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14886 else
14887 printf (_("<corrupt: %14ld>"), psym->st_name);
14888 }
861fb55a
DJ		 14889 printf ("\n");
14890 }
14891 printf ("\n");
14892
14893 if (data)
14894 free (data);
14895 free (rels);
14896 }
14897
252b5132
RH		 14898 return 1;
14899}
14900
35c08157
KLC		 14901static int
14902process_nds32_specific (FILE * file)
14903{
14904 Elf_Internal_Shdr *sect = NULL;
14905
14906 sect = find_section (".nds32_e_flags");
14907 if (sect != NULL)
14908 {
14909 unsigned int *flag;
14910
14911 printf ("\nNDS32 elf flags section:\n");
14912 flag = get_data (NULL, file, sect->sh_offset, 1,
14913 sect->sh_size, _("NDS32 elf flags section"));
14914
14915 switch ((*flag) & 0x3)
14916 {
14917 case 0:
14918 printf ("(VEC_SIZE):\tNo entry.\n");
14919 break;
14920 case 1:
14921 printf ("(VEC_SIZE):\t4 bytes\n");
14922 break;
14923 case 2:
14924 printf ("(VEC_SIZE):\t16 bytes\n");
14925 break;
14926 case 3:
14927 printf ("(VEC_SIZE):\treserved\n");
14928 break;
14929 }
14930 }
14931
14932 return TRUE;
14933}
14934
047b2264 14935static int
2cf0635d 14936process_gnu_liblist (FILE * file)
047b2264 14937{
2cf0635d
NC		 14938 Elf_Internal_Shdr * section;
14939 Elf_Internal_Shdr * string_sec;
14940 Elf32_External_Lib * elib;
14941 char * strtab;
c256ffe7 14942 size_t strtab_size;
047b2264
JJ		 14943 size_t cnt;
14944 unsigned i;
14945
14946 if (! do_arch)
14947 return 0;
14948
14949 for (i = 0, section = section_headers;
14950 i < elf_header.e_shnum;
b34976b6 14951 i++, section++)
047b2264
JJ		 14952 {
14953 switch (section->sh_type)
14954 {
14955 case SHT_GNU_LIBLIST:
4fbb74a6 14956 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14957 break;
14958
3f5e193b
NC		 14959 elib = (Elf32_External_Lib *)
14960 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14961 _("liblist section data"));
047b2264
JJ		 14962
14963 if (elib == NULL)
14964 break;
4fbb74a6 14965 string_sec = section_headers + section->sh_link;
047b2264 14966
3f5e193b
NC		 14967 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14968 string_sec->sh_size,
14969 _("liblist string table"));
047b2264
JJ		 14970 if (strtab == NULL
14971 || section->sh_entsize != sizeof (Elf32_External_Lib))
14972 {
14973 free (elib);
2842702f 14974 free (strtab);
047b2264
JJ		 14975 break;
14976 }
59245841 14977 strtab_size = string_sec->sh_size;
047b2264
JJ		 14978
14979 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14980 printable_section_name (section),
0af1713e 14981 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14982
2b692964 14983 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14984
14985 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14986 ++cnt)
14987 {
14988 Elf32_Lib liblist;
91d6fa6a 14989 time_t atime;
047b2264 14990 char timebuf[20];
2cf0635d 14991 struct tm * tmp;
047b2264
JJ		 14992
14993 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14994 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14995 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14996 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14997 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14998
91d6fa6a 14999 tmp = gmtime (&atime);
e9e44622
JJ		 15000 snprintf (timebuf, sizeof (timebuf),
15001 "%04u-%02u-%02uT%02u:%02u:%02u",
15002 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15003 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 15004
15005 printf ("%3lu: ", (unsigned long) cnt);
15006 if (do_wide)
c256ffe7 15007 printf ("%-20s", liblist.l_name < strtab_size
2b692964 15008 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 15009 else
c256ffe7 15010 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 15011 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 15012 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15013 liblist.l_version, liblist.l_flags);
15014 }
15015
15016 free (elib);
2842702f 15017 free (strtab);
047b2264
JJ		 15018 }
15019 }
15020
15021 return 1;
15022}
15023
9437c45b 15024static const char *
d3ba0551 15025get_note_type (unsigned e_type)
779fe533
NC		 15026{
15027 static char buff[64];
103f02d3 15028
1ec5cd37
NC		 15029 if (elf_header.e_type == ET_CORE)
15030 switch (e_type)
15031 {
57346661 15032 case NT_AUXV:
1ec5cd37 15033 return _("NT_AUXV (auxiliary vector)");
57346661 15034 case NT_PRSTATUS:
1ec5cd37 15035 return _("NT_PRSTATUS (prstatus structure)");
57346661 15036 case NT_FPREGSET:
1ec5cd37 15037 return _("NT_FPREGSET (floating point registers)");
57346661 15038 case NT_PRPSINFO:
1ec5cd37 15039 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15040 case NT_TASKSTRUCT:
1ec5cd37 15041 return _("NT_TASKSTRUCT (task structure)");
57346661 15042 case NT_PRXFPREG:
1ec5cd37 15043 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15044 case NT_PPC_VMX:
15045 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15046 case NT_PPC_VSX:
15047 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15048 case NT_386_TLS:
15049 return _("NT_386_TLS (x86 TLS information)");
15050 case NT_386_IOPERM:
15051 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15052 case NT_X86_XSTATE:
15053 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15054 case NT_S390_HIGH_GPRS:
15055 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15056 case NT_S390_TIMER:
15057 return _("NT_S390_TIMER (s390 timer register)");
15058 case NT_S390_TODCMP:
15059 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15060 case NT_S390_TODPREG:
15061 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15062 case NT_S390_CTRS:
15063 return _("NT_S390_CTRS (s390 control registers)");
15064 case NT_S390_PREFIX:
15065 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15066 case NT_S390_LAST_BREAK:
15067 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15068 case NT_S390_SYSTEM_CALL:
15069 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15070 case NT_S390_TDB:
15071 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15072 case NT_S390_VXRS_LOW:
15073 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15074 case NT_S390_VXRS_HIGH:
15075 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15076 case NT_ARM_VFP:
15077 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15078 case NT_ARM_TLS:
15079 return _("NT_ARM_TLS (AArch TLS registers)");
15080 case NT_ARM_HW_BREAK:
15081 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15082 case NT_ARM_HW_WATCH:
15083 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15084 case NT_PSTATUS:
1ec5cd37 15085 return _("NT_PSTATUS (pstatus structure)");
57346661 15086 case NT_FPREGS:
1ec5cd37 15087 return _("NT_FPREGS (floating point registers)");
57346661 15088 case NT_PSINFO:
1ec5cd37 15089 return _("NT_PSINFO (psinfo structure)");
57346661 15090 case NT_LWPSTATUS:
1ec5cd37 15091 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15092 case NT_LWPSINFO:
1ec5cd37 15093 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15094 case NT_WIN32PSTATUS:
1ec5cd37 15095 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15096 case NT_SIGINFO:
15097 return _("NT_SIGINFO (siginfo_t data)");
15098 case NT_FILE:
15099 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15100 default:
15101 break;
15102 }
15103 else
15104 switch (e_type)
15105 {
15106 case NT_VERSION:
15107 return _("NT_VERSION (version)");
15108 case NT_ARCH:
15109 return _("NT_ARCH (architecture)");
15110 default:
15111 break;
15112 }
15113
e9e44622 15114 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15115 return buff;
779fe533
NC		 15116}
15117
9ece1fa9
TT		 15118static int
15119print_core_note (Elf_Internal_Note *pnote)
15120{
15121 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15122 bfd_vma count, page_size;
15123 unsigned char *descdata, *filenames, *descend;
15124
15125 if (pnote->type != NT_FILE)
15126 return 1;
15127
15128#ifndef BFD64
15129 if (!is_32bit_elf)
15130 {
15131 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15132 /* Still "successful". */
15133 return 1;
15134 }
15135#endif
15136
15137 if (pnote->descsz < 2 * addr_size)
15138 {
15139 printf (_(" Malformed note - too short for header\n"));
15140 return 0;
15141 }
15142
15143 descdata = (unsigned char *) pnote->descdata;
15144 descend = descdata + pnote->descsz;
15145
15146 if (descdata[pnote->descsz - 1] != '\0')
15147 {
15148 printf (_(" Malformed note - does not end with \\0\n"));
15149 return 0;
15150 }
15151
15152 count = byte_get (descdata, addr_size);
15153 descdata += addr_size;
15154
15155 page_size = byte_get (descdata, addr_size);
15156 descdata += addr_size;
15157
15158 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15159 {
15160 printf (_(" Malformed note - too short for supplied file count\n"));
15161 return 0;
15162 }
15163
15164 printf (_(" Page size: "));
15165 print_vma (page_size, DEC);
15166 printf ("\n");
15167
15168 printf (_(" %*s%*s%*s\n"),
15169 (int) (2 + 2 * addr_size), _("Start"),
15170 (int) (4 + 2 * addr_size), _("End"),
15171 (int) (4 + 2 * addr_size), _("Page Offset"));
15172 filenames = descdata + count * 3 * addr_size;
595712bb 15173 while (count-- > 0)
9ece1fa9
TT		 15174 {
15175 bfd_vma start, end, file_ofs;
15176
15177 if (filenames == descend)
15178 {
15179 printf (_(" Malformed note - filenames end too early\n"));
15180 return 0;
15181 }
15182
15183 start = byte_get (descdata, addr_size);
15184 descdata += addr_size;
15185 end = byte_get (descdata, addr_size);
15186 descdata += addr_size;
15187 file_ofs = byte_get (descdata, addr_size);
15188 descdata += addr_size;
15189
15190 printf (" ");
15191 print_vma (start, FULL_HEX);
15192 printf (" ");
15193 print_vma (end, FULL_HEX);
15194 printf (" ");
15195 print_vma (file_ofs, FULL_HEX);
15196 printf ("\n %s\n", filenames);
15197
15198 filenames += 1 + strlen ((char *) filenames);
15199 }
15200
15201 return 1;
15202}
15203
1118d252
RM		 15204static const char *
15205get_gnu_elf_note_type (unsigned e_type)
15206{
15207 static char buff[64];
15208
15209 switch (e_type)
15210 {
15211 case NT_GNU_ABI_TAG:
15212 return _("NT_GNU_ABI_TAG (ABI version tag)");
15213 case NT_GNU_HWCAP:
15214 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15215 case NT_GNU_BUILD_ID:
15216 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15217 case NT_GNU_GOLD_VERSION:
15218 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15219 default:
15220 break;
15221 }
15222
15223 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15224 return buff;
15225}
15226
664f90a3
TT		 15227static int
15228print_gnu_note (Elf_Internal_Note *pnote)
15229{
15230 switch (pnote->type)
15231 {
15232 case NT_GNU_BUILD_ID:
15233 {
15234 unsigned long i;
15235
15236 printf (_(" Build ID: "));
15237 for (i = 0; i < pnote->descsz; ++i)
15238 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15239 printf ("\n");
664f90a3
TT		 15240 }
15241 break;
15242
15243 case NT_GNU_ABI_TAG:
15244 {
15245 unsigned long os, major, minor, subminor;
15246 const char *osname;
15247
3102e897
NC		 15248 /* PR 17531: file: 030-599401-0.004. */
15249 if (pnote->descsz < 16)
15250 {
15251 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15252 break;
15253 }
15254
664f90a3
TT		 15255 os = byte_get ((unsigned char *) pnote->descdata, 4);
15256 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15257 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15258 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15259
15260 switch (os)
15261 {
15262 case GNU_ABI_TAG_LINUX:
15263 osname = "Linux";
15264 break;
15265 case GNU_ABI_TAG_HURD:
15266 osname = "Hurd";
15267 break;
15268 case GNU_ABI_TAG_SOLARIS:
15269 osname = "Solaris";
15270 break;
15271 case GNU_ABI_TAG_FREEBSD:
15272 osname = "FreeBSD";
15273 break;
15274 case GNU_ABI_TAG_NETBSD:
15275 osname = "NetBSD";
15276 break;
14ae95f2
RM		 15277 case GNU_ABI_TAG_SYLLABLE:
15278 osname = "Syllable";
15279 break;
15280 case GNU_ABI_TAG_NACL:
15281 osname = "NaCl";
15282 break;
664f90a3
TT		 15283 default:
15284 osname = "Unknown";
15285 break;
15286 }
15287
15288 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15289 major, minor, subminor);
15290 }
15291 break;
926c5385
CC		 15292
15293 case NT_GNU_GOLD_VERSION:
15294 {
15295 unsigned long i;
15296
15297 printf (_(" Version: "));
15298 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15299 printf ("%c", pnote->descdata[i]);
15300 printf ("\n");
15301 }
15302 break;
664f90a3
TT		 15303 }
15304
15305 return 1;
15306}
15307
685080f2
NC		 15308static const char *
15309get_v850_elf_note_type (enum v850_notes n_type)
15310{
15311 static char buff[64];
15312
15313 switch (n_type)
15314 {
15315 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15316 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15317 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15318 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15319 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15320 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15321 default:
15322 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15323 return buff;
15324 }
15325}
15326
15327static int
15328print_v850_note (Elf_Internal_Note * pnote)
15329{
15330 unsigned int val;
15331
15332 if (pnote->descsz != 4)
15333 return 0;
15334 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15335
15336 if (val == 0)
15337 {
15338 printf (_("not set\n"));
15339 return 1;
15340 }
15341
15342 switch (pnote->type)
15343 {
15344 case V850_NOTE_ALIGNMENT:
15345 switch (val)
15346 {
15347 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15348 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15349 }
15350 break;
14ae95f2 15351
685080f2
NC		 15352 case V850_NOTE_DATA_SIZE:
15353 switch (val)
15354 {
15355 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15356 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15357 }
15358 break;
14ae95f2 15359
685080f2
NC		 15360 case V850_NOTE_FPU_INFO:
15361 switch (val)
15362 {
15363 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15364 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15365 }
15366 break;
14ae95f2 15367
685080f2
NC		 15368 case V850_NOTE_MMU_INFO:
15369 case V850_NOTE_CACHE_INFO:
15370 case V850_NOTE_SIMD_INFO:
15371 if (val == EF_RH850_SIMD)
15372 {
15373 printf (_("yes\n"));
15374 return 1;
15375 }
15376 break;
15377
15378 default:
15379 /* An 'unknown note type' message will already have been displayed. */
15380 break;
15381 }
15382
15383 printf (_("unknown value: %x\n"), val);
15384 return 0;
15385}
15386
c6056a74
SF		 15387static int
15388process_netbsd_elf_note (Elf_Internal_Note * pnote)
15389{
15390 unsigned int version;
15391
15392 switch (pnote->type)
15393 {
15394 case NT_NETBSD_IDENT:
15395 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15396 if ((version / 10000) % 100)
15397 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15398 version, version / 100000000, (version / 1000000) % 100,
15399 (version / 10000) % 100 > 26 ? "Z" : "",
15400 'A' + (version / 10000) % 26);
15401 else
15402 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15403 version, version / 100000000, (version / 1000000) % 100,
15404 (version / 100) % 100);
15405 return 1;
15406
15407 case NT_NETBSD_MARCH:
15408 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15409 pnote->descdata);
15410 return 1;
15411
15412 default:
15413 break;
15414 }
15415
15416 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15417 pnote->type);
15418 return 1;
15419}
15420
f4ddf30f
JB		 15421static const char *
15422get_freebsd_elfcore_note_type (unsigned e_type)
15423{
f4ddf30f
JB		 15424 switch (e_type)
15425 {
15426 case NT_FREEBSD_THRMISC:
15427 return _("NT_THRMISC (thrmisc structure)");
15428 case NT_FREEBSD_PROCSTAT_PROC:
15429 return _("NT_PROCSTAT_PROC (proc data)");
15430 case NT_FREEBSD_PROCSTAT_FILES:
15431 return _("NT_PROCSTAT_FILES (files data)");
15432 case NT_FREEBSD_PROCSTAT_VMMAP:
15433 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15434 case NT_FREEBSD_PROCSTAT_GROUPS:
15435 return _("NT_PROCSTAT_GROUPS (groups data)");
15436 case NT_FREEBSD_PROCSTAT_UMASK:
15437 return _("NT_PROCSTAT_UMASK (umask data)");
15438 case NT_FREEBSD_PROCSTAT_RLIMIT:
15439 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15440 case NT_FREEBSD_PROCSTAT_OSREL:
15441 return _("NT_PROCSTAT_OSREL (osreldate data)");
15442 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
15443 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15444 case NT_FREEBSD_PROCSTAT_AUXV:
15445 return _("NT_PROCSTAT_AUXV (auxv data)");
15446 }
15447 return get_note_type (e_type);
15448}
15449
9437c45b 15450static const char *
d3ba0551 15451get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15452{
15453 static char buff[64];
15454
b4db1224 15455 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15456 {
15457 /* NetBSD core "procinfo" structure. */
15458 return _("NetBSD procinfo structure");
15459 }
15460
15461 /* As of Jan 2002 there are no other machine-independent notes
15462 defined for NetBSD core files. If the note type is less
15463 than the start of the machine-dependent note types, we don't
15464 understand it. */
15465
b4db1224 15466 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15467 {
e9e44622 15468 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15469 return buff;
15470 }
15471
15472 switch (elf_header.e_machine)
15473 {
15474 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15475 and PT_GETFPREGS == mach+2. */
15476
15477 case EM_OLD_ALPHA:
15478 case EM_ALPHA:
15479 case EM_SPARC:
15480 case EM_SPARC32PLUS:
15481 case EM_SPARCV9:
15482 switch (e_type)
15483 {
2b692964 15484 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15485 return _("PT_GETREGS (reg structure)");
2b692964 15486 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15487 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15488 default:
15489 break;
15490 }
15491 break;
15492
15493 /* On all other arch's, PT_GETREGS == mach+1 and
15494 PT_GETFPREGS == mach+3. */
15495 default:
15496 switch (e_type)
15497 {
2b692964 15498 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15499 return _("PT_GETREGS (reg structure)");
2b692964 15500 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15501 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15502 default:
15503 break;
15504 }
15505 }
15506
9cf03b7e 15507 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15508 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15509 return buff;
15510}
15511
70616151
TT		 15512static const char *
15513get_stapsdt_note_type (unsigned e_type)
15514{
15515 static char buff[64];
15516
15517 switch (e_type)
15518 {
15519 case NT_STAPSDT:
15520 return _("NT_STAPSDT (SystemTap probe descriptors)");
15521
15522 default:
15523 break;
15524 }
15525
15526 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15527 return buff;
15528}
15529
c6a9fc58
TT		 15530static int
15531print_stapsdt_note (Elf_Internal_Note *pnote)
15532{
15533 int addr_size = is_32bit_elf ? 4 : 8;
15534 char *data = pnote->descdata;
15535 char *data_end = pnote->descdata + pnote->descsz;
15536 bfd_vma pc, base_addr, semaphore;
15537 char *provider, *probe, *arg_fmt;
15538
15539 pc = byte_get ((unsigned char *) data, addr_size);
15540 data += addr_size;
15541 base_addr = byte_get ((unsigned char *) data, addr_size);
15542 data += addr_size;
15543 semaphore = byte_get ((unsigned char *) data, addr_size);
15544 data += addr_size;
15545
15546 provider = data;
15547 data += strlen (data) + 1;
15548 probe = data;
15549 data += strlen (data) + 1;
15550 arg_fmt = data;
15551 data += strlen (data) + 1;
15552
15553 printf (_(" Provider: %s\n"), provider);
15554 printf (_(" Name: %s\n"), probe);
15555 printf (_(" Location: "));
15556 print_vma (pc, FULL_HEX);
15557 printf (_(", Base: "));
15558 print_vma (base_addr, FULL_HEX);
15559 printf (_(", Semaphore: "));
15560 print_vma (semaphore, FULL_HEX);
9cf03b7e 15561 printf ("\n");
c6a9fc58
TT		 15562 printf (_(" Arguments: %s\n"), arg_fmt);
15563
15564 return data == data_end;
15565}
15566
00e98fc7
TG		 15567static const char *
15568get_ia64_vms_note_type (unsigned e_type)
15569{
15570 static char buff[64];
15571
15572 switch (e_type)
15573 {
15574 case NT_VMS_MHD:
15575 return _("NT_VMS_MHD (module header)");
15576 case NT_VMS_LNM:
15577 return _("NT_VMS_LNM (language name)");
15578 case NT_VMS_SRC:
15579 return _("NT_VMS_SRC (source files)");
15580 case NT_VMS_TITLE:
9cf03b7e 15581 return "NT_VMS_TITLE";
00e98fc7
TG		 15582 case NT_VMS_EIDC:
15583 return _("NT_VMS_EIDC (consistency check)");
15584 case NT_VMS_FPMODE:
15585 return _("NT_VMS_FPMODE (FP mode)");
15586 case NT_VMS_LINKTIME:
9cf03b7e 15587 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15588 case NT_VMS_IMGNAM:
15589 return _("NT_VMS_IMGNAM (image name)");
15590 case NT_VMS_IMGID:
15591 return _("NT_VMS_IMGID (image id)");
15592 case NT_VMS_LINKID:
15593 return _("NT_VMS_LINKID (link id)");
15594 case NT_VMS_IMGBID:
15595 return _("NT_VMS_IMGBID (build id)");
15596 case NT_VMS_GSTNAM:
15597 return _("NT_VMS_GSTNAM (sym table name)");
15598 case NT_VMS_ORIG_DYN:
9cf03b7e 15599 return "NT_VMS_ORIG_DYN";
00e98fc7 15600 case NT_VMS_PATCHTIME:
9cf03b7e 15601 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15602 default:
15603 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15604 return buff;
15605 }
15606}
15607
15608static int
15609print_ia64_vms_note (Elf_Internal_Note * pnote)
15610{
15611 switch (pnote->type)
15612 {
15613 case NT_VMS_MHD:
15614 if (pnote->descsz > 36)
15615 {
15616 size_t l = strlen (pnote->descdata + 34);
15617 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15618 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15619 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15620 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15621 }
15622 else
15623 printf (_(" Invalid size\n"));
15624 break;
15625 case NT_VMS_LNM:
15626 printf (_(" Language: %s\n"), pnote->descdata);
15627 break;
15628#ifdef BFD64
15629 case NT_VMS_FPMODE:
9cf03b7e 15630 printf (_(" Floating Point mode: "));
4a5cb34f 15631 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15632 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15633 break;
15634 case NT_VMS_LINKTIME:
15635 printf (_(" Link time: "));
15636 print_vms_time
15637 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15638 printf ("\n");
15639 break;
15640 case NT_VMS_PATCHTIME:
15641 printf (_(" Patch time: "));
15642 print_vms_time
15643 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15644 printf ("\n");
15645 break;
15646 case NT_VMS_ORIG_DYN:
15647 printf (_(" Major id: %u, minor id: %u\n"),
15648 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15649 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15650 printf (_(" Last modified : "));
00e98fc7
TG		 15651 print_vms_time
15652 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15653 printf (_("\n Link flags : "));
4a5cb34f 15654 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15655 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15656 printf (_(" Header flags: 0x%08x\n"),
948f632f 15657 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15658 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15659 break;
15660#endif
15661 case NT_VMS_IMGNAM:
15662 printf (_(" Image name: %s\n"), pnote->descdata);
15663 break;
15664 case NT_VMS_GSTNAM:
15665 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15666 break;
15667 case NT_VMS_IMGID:
15668 printf (_(" Image id: %s\n"), pnote->descdata);
15669 break;
15670 case NT_VMS_LINKID:
15671 printf (_(" Linker id: %s\n"), pnote->descdata);
15672 break;
15673 default:
15674 break;
15675 }
15676 return 1;
15677}
15678
6d118b09
NC		 15679/* Note that by the ELF standard, the name field is already null byte
15680 terminated, and namesz includes the terminating null byte.
15681 I.E. the value of namesz for the name "FSF" is 4.
15682
e3c8793a 15683 If the value of namesz is zero, there is no name present. */
779fe533 15684static int
2cf0635d 15685process_note (Elf_Internal_Note * pnote)
779fe533 15686{
2cf0635d
NC		 15687 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15688 const char * nt;
9437c45b
JT		 15689
15690 if (pnote->namesz == 0)
1ec5cd37
NC		 15691 /* If there is no note name, then use the default set of
15692 note type strings. */
15693 nt = get_note_type (pnote->type);
15694
1118d252
RM		 15695 else if (const_strneq (pnote->namedata, "GNU"))
15696 /* GNU-specific object file notes. */
15697 nt = get_gnu_elf_note_type (pnote->type);
f4ddf30f
JB		 15698
15699 else if (const_strneq (pnote->namedata, "FreeBSD"))
15700 /* FreeBSD-specific core file notes. */
15701 nt = get_freebsd_elfcore_note_type (pnote->type);
1118d252 15702
0112cd26 15703 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15704 /* NetBSD-specific core file notes. */
15705 nt = get_netbsd_elfcore_note_type (pnote->type);
15706
c6056a74
SF		 15707 else if (const_strneq (pnote->namedata, "NetBSD"))
15708 /* NetBSD-specific core file notes. */
15709 return process_netbsd_elf_note (pnote);
15710
b15fa79e
AM		 15711 else if (strneq (pnote->namedata, "SPU/", 4))
15712 {
15713 /* SPU-specific core file notes. */
15714 nt = pnote->namedata + 4;
15715 name = "SPU";
15716 }
15717
00e98fc7
TG		 15718 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15719 /* VMS/ia64-specific file notes. */
15720 nt = get_ia64_vms_note_type (pnote->type);
15721
70616151
TT		 15722 else if (const_strneq (pnote->namedata, "stapsdt"))
15723 nt = get_stapsdt_note_type (pnote->type);
15724
9437c45b 15725 else
1ec5cd37
NC		 15726 /* Don't recognize this note name; just use the default set of
15727 note type strings. */
00e98fc7 15728 nt = get_note_type (pnote->type);
9437c45b 15729
2aee03ae 15730 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15731
15732 if (const_strneq (pnote->namedata, "IPF/VMS"))
15733 return print_ia64_vms_note (pnote);
664f90a3
TT		 15734 else if (const_strneq (pnote->namedata, "GNU"))
15735 return print_gnu_note (pnote);
c6a9fc58
TT		 15736 else if (const_strneq (pnote->namedata, "stapsdt"))
15737 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15738 else if (const_strneq (pnote->namedata, "CORE"))
15739 return print_core_note (pnote);
00e98fc7
TG		 15740 else
15741 return 1;
779fe533
NC		 15742}
15743
6d118b09 15744
779fe533 15745static int
2cf0635d 15746process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15747{
2cf0635d
NC		 15748 Elf_External_Note * pnotes;
15749 Elf_External_Note * external;
c8071705 15750 char * end;
b34976b6 15751 int res = 1;
103f02d3 15752
779fe533
NC		 15753 if (length <= 0)
15754 return 0;
103f02d3 15755
3f5e193b 15756 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15757 _("notes"));
dd24e3da 15758 if (pnotes == NULL)
a6e9f9df 15759 return 0;
779fe533 15760
103f02d3 15761 external = pnotes;
103f02d3 15762
9dd3a467 15763 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15764 (unsigned long) offset, (unsigned long) length);
2aee03ae 15765 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15766
c8071705
NC		 15767 end = (char *) pnotes + length;
15768 while ((char *) external < end)
779fe533 15769 {
b34976b6 15770 Elf_Internal_Note inote;
15b42fb0
AM		 15771 size_t min_notesz;
15772 char *next;
2cf0635d 15773 char * temp = NULL;
c8071705 15774 size_t data_remaining = end - (char *) external;
6d118b09 15775
00e98fc7 15776 if (!is_ia64_vms ())
15b42fb0 15777 {
9dd3a467
NC		 15778 /* PR binutils/15191
15779 Make sure that there is enough data to read. */
15b42fb0
AM		 15780 min_notesz = offsetof (Elf_External_Note, name);
15781 if (data_remaining < min_notesz)
9dd3a467
NC		 15782 {
15783 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15784 (int) data_remaining);
15785 break;
15786 }
15b42fb0
AM		 15787 inote.type = BYTE_GET (external->type);
15788 inote.namesz = BYTE_GET (external->namesz);
15789 inote.namedata = external->name;
15790 inote.descsz = BYTE_GET (external->descsz);
15791 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15792 /* PR 17531: file: 3443835e. */
c8071705 15793 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15794 {
15795 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15796 inote.descdata = inote.namedata;
15797 inote.namesz = 0;
15798 }
14ae95f2 15799
15b42fb0
AM		 15800 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15801 next = inote.descdata + align_power (inote.descsz, 2);
15802 }
00e98fc7 15803 else
15b42fb0
AM		 15804 {
15805 Elf64_External_VMS_Note *vms_external;
00e98fc7 15806
9dd3a467
NC		 15807 /* PR binutils/15191
15808 Make sure that there is enough data to read. */
15b42fb0
AM		 15809 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15810 if (data_remaining < min_notesz)
9dd3a467
NC		 15811 {
15812 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15813 (int) data_remaining);
15814 break;
15815 }
3e55a963 15816
15b42fb0
AM		 15817 vms_external = (Elf64_External_VMS_Note *) external;
15818 inote.type = BYTE_GET (vms_external->type);
15819 inote.namesz = BYTE_GET (vms_external->namesz);
15820 inote.namedata = vms_external->name;
15821 inote.descsz = BYTE_GET (vms_external->descsz);
15822 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15823 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15824 next = inote.descdata + align_power (inote.descsz, 3);
15825 }
15826
15827 if (inote.descdata < (char *) external + min_notesz
15828 || next < (char *) external + min_notesz
5d921cbd
NC		 15829 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15830 || inote.namedata + inote.namesz < inote.namedata
15831 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15832 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15833 {
15b42fb0 15834 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15835 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15836 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15837 inote.type, inote.namesz, inote.descsz);
15838 break;
15839 }
15840
15b42fb0 15841 external = (Elf_External_Note *) next;
dd24e3da 15842
6d118b09
NC		 15843 /* Verify that name is null terminated. It appears that at least
15844 one version of Linux (RedHat 6.0) generates corefiles that don't
15845 comply with the ELF spec by failing to include the null byte in
15846 namesz. */
8b971f9f 15847 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15848 {
3f5e193b 15849 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15850 if (temp == NULL)
15851 {
8b73c356 15852 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15853 res = 0;
15854 break;
15855 }
76da6bbe 15856
6d118b09
NC		 15857 strncpy (temp, inote.namedata, inote.namesz);
15858 temp[inote.namesz] = 0;
76da6bbe 15859
6d118b09
NC		 15860 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15861 inote.namedata = temp;
15862 }
15863
15864 res &= process_note (& inote);
103f02d3 15865
6d118b09
NC		 15866 if (temp != NULL)
15867 {
15868 free (temp);
15869 temp = NULL;
15870 }
779fe533
NC		 15871 }
15872
15873 free (pnotes);
103f02d3 15874
779fe533
NC		 15875 return res;
15876}
15877
15878static int
2cf0635d 15879process_corefile_note_segments (FILE * file)
779fe533 15880{
2cf0635d 15881 Elf_Internal_Phdr * segment;
b34976b6
AM		 15882 unsigned int i;
15883 int res = 1;
103f02d3 15884
d93f0186 15885 if (! get_program_headers (file))
779fe533 15886 return 0;
103f02d3 15887
779fe533
NC		 15888 for (i = 0, segment = program_headers;
15889 i < elf_header.e_phnum;
b34976b6 15890 i++, segment++)
779fe533
NC		 15891 {
15892 if (segment->p_type == PT_NOTE)
103f02d3 15893 res &= process_corefile_note_segment (file,
30800947
NC		 15894 (bfd_vma) segment->p_offset,
15895 (bfd_vma) segment->p_filesz);
779fe533 15896 }
103f02d3 15897
779fe533
NC		 15898 return res;
15899}
15900
685080f2
NC		 15901static int
15902process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15903{
15904 Elf_External_Note * pnotes;
15905 Elf_External_Note * external;
c8071705 15906 char * end;
685080f2
NC		 15907 int res = 1;
15908
15909 if (length <= 0)
15910 return 0;
15911
15912 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15913 _("v850 notes"));
15914 if (pnotes == NULL)
15915 return 0;
15916
15917 external = pnotes;
c8071705 15918 end = (char*) pnotes + length;
685080f2
NC		 15919
15920 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15921 (unsigned long) offset, (unsigned long) length);
15922
c8071705 15923 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15924 {
15925 Elf_External_Note * next;
15926 Elf_Internal_Note inote;
15927
15928 inote.type = BYTE_GET (external->type);
15929 inote.namesz = BYTE_GET (external->namesz);
15930 inote.namedata = external->name;
15931 inote.descsz = BYTE_GET (external->descsz);
15932 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15933 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15934
c8071705
NC		 15935 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15936 {
15937 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15938 inote.descdata = inote.namedata;
15939 inote.namesz = 0;
15940 }
15941
685080f2
NC		 15942 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15943
c8071705 15944 if ( ((char *) next > end)
685080f2
NC		 15945 || ((char *) next < (char *) pnotes))
15946 {
15947 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15948 (unsigned long) ((char *) external - (char *) pnotes));
15949 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15950 inote.type, inote.namesz, inote.descsz);
15951 break;
15952 }
15953
15954 external = next;
15955
15956 /* Prevent out-of-bounds indexing. */
c8071705 15957 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15958 || inote.namedata + inote.namesz < inote.namedata)
15959 {
15960 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15961 (unsigned long) ((char *) external - (char *) pnotes));
15962 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15963 inote.type, inote.namesz, inote.descsz);
15964 break;
15965 }
15966
15967 printf (" %s: ", get_v850_elf_note_type (inote.type));
15968
15969 if (! print_v850_note (& inote))
15970 {
15971 res = 0;
15972 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15973 inote.namesz, inote.descsz);
15974 }
15975 }
15976
15977 free (pnotes);
15978
15979 return res;
15980}
15981
779fe533 15982static int
2cf0635d 15983process_note_sections (FILE * file)
1ec5cd37 15984{
2cf0635d 15985 Elf_Internal_Shdr * section;
1ec5cd37 15986 unsigned long i;
df565f32 15987 int n = 0;
1ec5cd37
NC		 15988 int res = 1;
15989
15990 for (i = 0, section = section_headers;
fa1908fd 15991 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15992 i++, section++)
685080f2
NC		 15993 {
15994 if (section->sh_type == SHT_NOTE)
15995 {
15996 res &= process_corefile_note_segment (file,
15997 (bfd_vma) section->sh_offset,
15998 (bfd_vma) section->sh_size);
15999 n++;
16000 }
16001
16002 if (( elf_header.e_machine == EM_V800
16003 || elf_header.e_machine == EM_V850
16004 || elf_header.e_machine == EM_CYGNUS_V850)
16005 && section->sh_type == SHT_RENESAS_INFO)
16006 {
16007 res &= process_v850_notes (file,
16008 (bfd_vma) section->sh_offset,
16009 (bfd_vma) section->sh_size);
16010 n++;
16011 }
16012 }
df565f32
NC		 16013
16014 if (n == 0)
16015 /* Try processing NOTE segments instead. */
16016 return process_corefile_note_segments (file);
1ec5cd37
NC		 16017
16018 return res;
16019}
16020
16021static int
2cf0635d 16022process_notes (FILE * file)
779fe533
NC		 16023{
16024 /* If we have not been asked to display the notes then do nothing. */
16025 if (! do_notes)
16026 return 1;
103f02d3 16027
779fe533 16028 if (elf_header.e_type != ET_CORE)
1ec5cd37 16029 return process_note_sections (file);
103f02d3 16030
779fe533 16031 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 16032 if (elf_header.e_phnum > 0)
16033 return process_corefile_note_segments (file);
779fe533 16034
1ec5cd37
NC		 16035 printf (_("No note segments present in the core file.\n"));
16036 return 1;
779fe533
NC		 16037}
16038
252b5132 16039static int
2cf0635d 16040process_arch_specific (FILE * file)
252b5132 16041{
a952a375
NC		 16042 if (! do_arch)
16043 return 1;
16044
252b5132
RH		 16045 switch (elf_header.e_machine)
16046 {
11c1ff18
PB		 16047 case EM_ARM:
16048 return process_arm_specific (file);
252b5132 16049 case EM_MIPS:
4fe85591 16050 case EM_MIPS_RS3_LE:
252b5132
RH		 16051 return process_mips_specific (file);
16052 break;
35c08157
KLC		 16053 case EM_NDS32:
16054 return process_nds32_specific (file);
16055 break;
34c8bcba
JM		 16056 case EM_PPC:
16057 return process_power_specific (file);
16058 break;
643f7afb
AK		 16059 case EM_S390:
16060 case EM_S390_OLD:
16061 return process_s390_specific (file);
16062 break;
9e8c70f9
DM		 16063 case EM_SPARC:
16064 case EM_SPARC32PLUS:
16065 case EM_SPARCV9:
16066 return process_sparc_specific (file);
16067 break;
59e6276b
JM		 16068 case EM_TI_C6000:
16069 return process_tic6x_specific (file);
16070 break;
13761a11
NC		 16071 case EM_MSP430:
16072 return process_msp430x_specific (file);
252b5132
RH		 16073 default:
16074 break;
16075 }
16076 return 1;
16077}
16078
16079static int
2cf0635d 16080get_file_header (FILE * file)
252b5132 16081{
9ea033b2
NC		 16082 /* Read in the identity array. */
16083 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16084 return 0;
16085
9ea033b2 16086 /* Determine how to read the rest of the header. */
b34976b6 16087 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 16088 {
16089 default: /* fall through */
16090 case ELFDATANONE: /* fall through */
adab8cdc
AO		 16091 case ELFDATA2LSB:
16092 byte_get = byte_get_little_endian;
16093 byte_put = byte_put_little_endian;
16094 break;
16095 case ELFDATA2MSB:
16096 byte_get = byte_get_big_endian;
16097 byte_put = byte_put_big_endian;
16098 break;
9ea033b2
NC		 16099 }
16100
16101 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16102 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16103
16104 /* Read in the rest of the header. */
16105 if (is_32bit_elf)
16106 {
16107 Elf32_External_Ehdr ehdr32;
252b5132 16108
9ea033b2
NC		 16109 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16110 return 0;
103f02d3 16111
9ea033b2
NC		 16112 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16113 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16114 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16115 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16116 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16117 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16118 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16119 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16120 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16121 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16122 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16123 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16124 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16125 }
252b5132 16126 else
9ea033b2
NC		 16127 {
16128 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16129
16130 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16131 we will not be able to cope with the 64bit data found in
16132 64 ELF files. Detect this now and abort before we start
50c2245b 16133 overwriting things. */
a952a375
NC		 16134 if (sizeof (bfd_vma) < 8)
16135 {
e3c8793a
NC		 16136 error (_("This instance of readelf has been built without support for a\n\
1613764 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16138 return 0;
16139 }
103f02d3 16140
9ea033b2
NC		 16141 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16142 return 0;
103f02d3 16143
9ea033b2
NC		 16144 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16145 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16146 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16147 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16148 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16149 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16150 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16151 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16152 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16153 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16154 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16155 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16156 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16157 }
252b5132 16158
7ece0d85
JJ		 16159 if (elf_header.e_shoff)
16160 {
16161 /* There may be some extensions in the first section header. Don't
16162 bomb if we can't read it. */
16163 if (is_32bit_elf)
049b0c3a 16164 get_32bit_section_headers (file, TRUE);
7ece0d85 16165 else
049b0c3a 16166 get_64bit_section_headers (file, TRUE);
7ece0d85 16167 }
560f3c1c 16168
252b5132
RH		 16169 return 1;
16170}
16171
fb52b2f4
NC		 16172/* Process one ELF object file according to the command line options.
16173 This file may actually be stored in an archive. The file is
16174 positioned at the start of the ELF object. */
16175
ff78d6d6 16176static int
2cf0635d 16177process_object (char * file_name, FILE * file)
252b5132 16178{
252b5132
RH		 16179 unsigned int i;
16180
252b5132
RH		 16181 if (! get_file_header (file))
16182 {
16183 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16184 return 1;
252b5132
RH		 16185 }
16186
16187 /* Initialise per file variables. */
60bca95a 16188 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16189 version_info[i] = 0;
16190
60bca95a 16191 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16192 dynamic_info[i] = 0;
5115b233 16193 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16194
16195 /* Process the file. */
16196 if (show_name)
16197 printf (_("\nFile: %s\n"), file_name);
16198
18bd398b
NC		 16199 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16200 Note we do this even if cmdline_dump_sects is empty because we
16201 must make sure that the dump_sets array is zeroed out before each
16202 object file is processed. */
16203 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16204 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16205
16206 if (num_cmdline_dump_sects > 0)
16207 {
16208 if (num_dump_sects == 0)
16209 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16210 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16211
16212 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16213 memcpy (dump_sects, cmdline_dump_sects,
16214 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16215 }
d70c5fc7 16216
252b5132 16217 if (! process_file_header ())
fb52b2f4 16218 return 1;
252b5132 16219
d1f5c6e3 16220 if (! process_section_headers (file))
2f62977e 16221 {
d1f5c6e3
L		 16222 /* Without loaded section headers we cannot process lots of
16223 things. */
2f62977e 16224 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16225
2f62977e 16226 if (! do_using_dynamic)
2c610e4b 16227 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16228 }
252b5132 16229
d1f5c6e3
L		 16230 if (! process_section_groups (file))
16231 {
16232 /* Without loaded section groups we cannot process unwind. */
16233 do_unwind = 0;
16234 }
16235
2f62977e 16236 if (process_program_headers (file))
b2d38a17 16237 process_dynamic_section (file);
252b5132
RH		 16238
16239 process_relocs (file);
16240
4d6ed7c8
NC		 16241 process_unwind (file);
16242
252b5132
RH		 16243 process_symbol_table (file);
16244
16245 process_syminfo (file);
16246
16247 process_version_sections (file);
16248
16249 process_section_contents (file);
f5842774 16250
1ec5cd37 16251 process_notes (file);
103f02d3 16252
047b2264
JJ		 16253 process_gnu_liblist (file);
16254
252b5132
RH		 16255 process_arch_specific (file);
16256
d93f0186
NC		 16257 if (program_headers)
16258 {
16259 free (program_headers);
16260 program_headers = NULL;
16261 }
16262
252b5132
RH		 16263 if (section_headers)
16264 {
16265 free (section_headers);
16266 section_headers = NULL;
16267 }
16268
16269 if (string_table)
16270 {
16271 free (string_table);
16272 string_table = NULL;
d40ac9bd 16273 string_table_length = 0;
252b5132
RH		 16274 }
16275
16276 if (dynamic_strings)
16277 {
16278 free (dynamic_strings);
16279 dynamic_strings = NULL;
d79b3d50 16280 dynamic_strings_length = 0;
252b5132
RH		 16281 }
16282
16283 if (dynamic_symbols)
16284 {
16285 free (dynamic_symbols);
16286 dynamic_symbols = NULL;
19936277 16287 num_dynamic_syms = 0;
252b5132
RH		 16288 }
16289
16290 if (dynamic_syminfo)
16291 {
16292 free (dynamic_syminfo);
16293 dynamic_syminfo = NULL;
16294 }
ff78d6d6 16295
293c573e
MR		 16296 if (dynamic_section)
16297 {
16298 free (dynamic_section);
16299 dynamic_section = NULL;
16300 }
16301
e4b17d5c
L		 16302 if (section_headers_groups)
16303 {
16304 free (section_headers_groups);
16305 section_headers_groups = NULL;
16306 }
16307
16308 if (section_groups)
16309 {
2cf0635d
NC		 16310 struct group_list * g;
16311 struct group_list * next;
e4b17d5c
L		 16312
16313 for (i = 0; i < group_count; i++)
16314 {
16315 for (g = section_groups [i].root; g != NULL; g = next)
16316 {
16317 next = g->next;
16318 free (g);
16319 }
16320 }
16321
16322 free (section_groups);
16323 section_groups = NULL;
16324 }
16325
19e6b90e 16326 free_debug_memory ();
18bd398b 16327
ff78d6d6 16328 return 0;
252b5132
RH		 16329}
16330
2cf0635d
NC		 16331/* Process an ELF archive.
16332 On entry the file is positioned just after the ARMAG string. */
16333
16334static int
16335process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16336{
16337 struct archive_info arch;
16338 struct archive_info nested_arch;
16339 size_t got;
2cf0635d
NC		 16340 int ret;
16341
16342 show_name = 1;
16343
16344 /* The ARCH structure is used to hold information about this archive. */
16345 arch.file_name = NULL;
16346 arch.file = NULL;
16347 arch.index_array = NULL;
16348 arch.sym_table = NULL;
16349 arch.longnames = NULL;
16350
16351 /* The NESTED_ARCH structure is used as a single-item cache of information
16352 about a nested archive (when members of a thin archive reside within
16353 another regular archive file). */
16354 nested_arch.file_name = NULL;
16355 nested_arch.file = NULL;
16356 nested_arch.index_array = NULL;
16357 nested_arch.sym_table = NULL;
16358 nested_arch.longnames = NULL;
16359
16360 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16361 {
16362 ret = 1;
16363 goto out;
4145f1d5 16364 }
fb52b2f4 16365
4145f1d5
NC		 16366 if (do_archive_index)
16367 {
2cf0635d 16368 if (arch.sym_table == NULL)
4145f1d5
NC		 16369 error (_("%s: unable to dump the index as none was found\n"), file_name);
16370 else
16371 {
591f7597 16372 unsigned long i, l;
4145f1d5
NC		 16373 unsigned long current_pos;
16374
591f7597
NC		 16375 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16376 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16377 current_pos = ftell (file);
16378
2cf0635d 16379 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16380 {
2cf0635d
NC		 16381 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16382 {
16383 char * member_name;
4145f1d5 16384
2cf0635d
NC		 16385 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16386
16387 if (member_name != NULL)
16388 {
16389 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16390
16391 if (qualified_name != NULL)
16392 {
c2a7d3f5
NC		 16393 printf (_("Contents of binary %s at offset "), qualified_name);
16394 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16395 putchar ('\n');
2cf0635d
NC		 16396 free (qualified_name);
16397 }
4145f1d5
NC		 16398 }
16399 }
2cf0635d
NC		 16400
16401 if (l >= arch.sym_size)
4145f1d5
NC		 16402 {
16403 error (_("%s: end of the symbol table reached before the end of the index\n"),
16404 file_name);
cb8f3167 16405 break;
4145f1d5 16406 }
591f7597
NC		 16407 /* PR 17531: file: 0b6630b2. */
16408 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16409 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16410 }
16411
c2a7d3f5
NC		 16412 if (arch.uses_64bit_indicies)
16413 l = (l + 7) & ~ 7;
16414 else
16415 l += l & 1;
16416
2cf0635d 16417 if (l < arch.sym_size)
c2a7d3f5
NC		 16418 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16419 file_name, arch.sym_size - l);
4145f1d5 16420
4145f1d5
NC		 16421 if (fseek (file, current_pos, SEEK_SET) != 0)
16422 {
16423 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16424 ret = 1;
16425 goto out;
4145f1d5 16426 }
fb52b2f4 16427 }
4145f1d5
NC		 16428
16429 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16430 && !do_segments && !do_header && !do_dump && !do_version
16431 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16432 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16433 {
16434 ret = 0; /* Archive index only. */
16435 goto out;
16436 }
fb52b2f4
NC		 16437 }
16438
d989285c 16439 ret = 0;
fb52b2f4
NC		 16440
16441 while (1)
16442 {
2cf0635d
NC		 16443 char * name;
16444 size_t namelen;
16445 char * qualified_name;
16446
16447 /* Read the next archive header. */
16448 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16449 {
16450 error (_("%s: failed to seek to next archive header\n"), file_name);
16451 return 1;
16452 }
16453 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16454 if (got != sizeof arch.arhdr)
16455 {
16456 if (got == 0)
16457 break;
16458 error (_("%s: failed to read archive header\n"), file_name);
16459 ret = 1;
16460 break;
16461 }
16462 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16463 {
16464 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16465 ret = 1;
16466 break;
16467 }
16468
16469 arch.next_arhdr_offset += sizeof arch.arhdr;
16470
16471 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16472 if (archive_file_size & 01)
16473 ++archive_file_size;
16474
16475 name = get_archive_member_name (&arch, &nested_arch);
16476 if (name == NULL)
fb52b2f4 16477 {
0fd3a477 16478 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16479 ret = 1;
16480 break;
fb52b2f4 16481 }
2cf0635d 16482 namelen = strlen (name);
fb52b2f4 16483
2cf0635d
NC		 16484 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16485 if (qualified_name == NULL)
fb52b2f4 16486 {
2cf0635d 16487 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16488 ret = 1;
16489 break;
fb52b2f4
NC		 16490 }
16491
2cf0635d
NC		 16492 if (is_thin_archive && arch.nested_member_origin == 0)
16493 {
16494 /* This is a proxy for an external member of a thin archive. */
16495 FILE * member_file;
16496 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16497 if (member_file_name == NULL)
16498 {
16499 ret = 1;
16500 break;
16501 }
16502
16503 member_file = fopen (member_file_name, "rb");
16504 if (member_file == NULL)
16505 {
16506 error (_("Input file '%s' is not readable.\n"), member_file_name);
16507 free (member_file_name);
16508 ret = 1;
16509 break;
16510 }
16511
16512 archive_file_offset = arch.nested_member_origin;
16513
16514 ret |= process_object (qualified_name, member_file);
16515
16516 fclose (member_file);
16517 free (member_file_name);
16518 }
16519 else if (is_thin_archive)
16520 {
a043396b
NC		 16521 /* PR 15140: Allow for corrupt thin archives. */
16522 if (nested_arch.file == NULL)
16523 {
16524 error (_("%s: contains corrupt thin archive: %s\n"),
16525 file_name, name);
16526 ret = 1;
16527 break;
16528 }
16529
2cf0635d
NC		 16530 /* This is a proxy for a member of a nested archive. */
16531 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16532
16533 /* The nested archive file will have been opened and setup by
16534 get_archive_member_name. */
16535 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16536 {
16537 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16538 ret = 1;
16539 break;
16540 }
16541
16542 ret |= process_object (qualified_name, nested_arch.file);
16543 }
16544 else
16545 {
16546 archive_file_offset = arch.next_arhdr_offset;
16547 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16548
2cf0635d
NC		 16549 ret |= process_object (qualified_name, file);
16550 }
fb52b2f4 16551
2b52916e
L		 16552 if (dump_sects != NULL)
16553 {
16554 free (dump_sects);
16555 dump_sects = NULL;
16556 num_dump_sects = 0;
16557 }
16558
2cf0635d 16559 free (qualified_name);
fb52b2f4
NC		 16560 }
16561
4145f1d5 16562 out:
2cf0635d
NC		 16563 if (nested_arch.file != NULL)
16564 fclose (nested_arch.file);
16565 release_archive (&nested_arch);
16566 release_archive (&arch);
fb52b2f4 16567
d989285c 16568 return ret;
fb52b2f4
NC		 16569}
16570
16571static int
2cf0635d 16572process_file (char * file_name)
fb52b2f4 16573{
2cf0635d 16574 FILE * file;
fb52b2f4
NC		 16575 struct stat statbuf;
16576 char armag[SARMAG];
16577 int ret;
16578
16579 if (stat (file_name, &statbuf) < 0)
16580 {
f24ddbdd
NC		 16581 if (errno == ENOENT)
16582 error (_("'%s': No such file\n"), file_name);
16583 else
16584 error (_("Could not locate '%s'. System error message: %s\n"),
16585 file_name, strerror (errno));
16586 return 1;
16587 }
16588
16589 if (! S_ISREG (statbuf.st_mode))
16590 {
16591 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16592 return 1;
16593 }
16594
16595 file = fopen (file_name, "rb");
16596 if (file == NULL)
16597 {
f24ddbdd 16598 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16599 return 1;
16600 }
16601
16602 if (fread (armag, SARMAG, 1, file) != 1)
16603 {
4145f1d5 16604 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16605 fclose (file);
16606 return 1;
16607 }
16608
f54498b4
NC		 16609 current_file_size = (bfd_size_type) statbuf.st_size;
16610
fb52b2f4 16611 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16612 ret = process_archive (file_name, file, FALSE);
16613 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16614 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16615 else
16616 {
4145f1d5
NC		 16617 if (do_archive_index)
16618 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16619 file_name);
16620
fb52b2f4
NC		 16621 rewind (file);
16622 archive_file_size = archive_file_offset = 0;
16623 ret = process_object (file_name, file);
16624 }
16625
16626 fclose (file);
16627
f54498b4 16628 current_file_size = 0;
fb52b2f4
NC		 16629 return ret;
16630}
16631
252b5132
RH		 16632#ifdef SUPPORT_DISASSEMBLY
16633/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16634 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16635 symbols. */
252b5132
RH		 16636
16637void
2cf0635d 16638print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16639{
16640 fprintf (outfile,"0x%8.8x", addr);
16641}
16642
e3c8793a 16643/* Needed by the i386 disassembler. */
252b5132
RH		 16644void
16645db_task_printsym (unsigned int addr)
16646{
16647 print_address (addr, stderr);
16648}
16649#endif
16650
16651int
2cf0635d 16652main (int argc, char ** argv)
252b5132 16653{
ff78d6d6
L		 16654 int err;
16655
252b5132
RH		 16656#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16657 setlocale (LC_MESSAGES, "");
3882b010
L		 16658#endif
16659#if defined (HAVE_SETLOCALE)
16660 setlocale (LC_CTYPE, "");
252b5132
RH		 16661#endif
16662 bindtextdomain (PACKAGE, LOCALEDIR);
16663 textdomain (PACKAGE);
16664
869b9d07
MM		 16665 expandargv (&argc, &argv);
16666
252b5132
RH		 16667 parse_args (argc, argv);
16668
18bd398b 16669 if (num_dump_sects > 0)
59f14fc0 16670 {
18bd398b 16671 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16672 cmdline_dump_sects = (dump_type *)
16673 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16674 if (cmdline_dump_sects == NULL)
591a748a 16675 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16676 else
16677 {
09c11c86
NC		 16678 memcpy (cmdline_dump_sects, dump_sects,
16679 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16680 num_cmdline_dump_sects = num_dump_sects;
16681 }
16682 }
16683
18bd398b
NC		 16684 if (optind < (argc - 1))
16685 show_name = 1;
5656ba2c
L		 16686 else if (optind >= argc)
16687 {
16688 warn (_("Nothing to do.\n"));
16689 usage (stderr);
16690 }
18bd398b 16691
ff78d6d6 16692 err = 0;
252b5132 16693 while (optind < argc)
18bd398b 16694 err |= process_file (argv[optind++]);
252b5132
RH		 16695
16696 if (dump_sects != NULL)
16697 free (dump_sects);
59f14fc0
AS		 16698 if (cmdline_dump_sects != NULL)
16699 free (cmdline_dump_sects);
252b5132 16700
ff78d6d6 16701 return err;
252b5132 16702}
GDB Binutils - Deliverables
This page took 2.164756 seconds and 4 git commands to generate.