]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
opcodes/ppc-opc.c: Add dscr and ctrl SPR mnemonics
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
b90efa5b 2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
2cf0635d 167char * program_name = "readelf";
c9c1d674 168static unsigned long archive_file_offset;
85b1c36d 169static unsigned long archive_file_size;
f54498b4 170static bfd_size_type current_file_size;
85b1c36d
BE		 171static unsigned long dynamic_addr;
172static bfd_size_type dynamic_size;
8b73c356 173static size_t dynamic_nent;
2cf0635d 174static char * dynamic_strings;
85b1c36d 175static unsigned long dynamic_strings_length;
2cf0635d 176static char * string_table;
85b1c36d
BE		 177static unsigned long string_table_length;
178static unsigned long num_dynamic_syms;
2cf0635d
NC		 179static Elf_Internal_Sym * dynamic_symbols;
180static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 181static unsigned long dynamic_syminfo_offset;
182static unsigned int dynamic_syminfo_nent;
f8eae8b2 183static char program_interpreter[PATH_MAX];
bb8a0291 184static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 185static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 186static bfd_vma version_info[16];
187static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 188static Elf_Internal_Shdr * section_headers;
189static Elf_Internal_Phdr * program_headers;
190static Elf_Internal_Dyn * dynamic_section;
191static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 192static int show_name;
193static int do_dynamic;
194static int do_syms;
2c610e4b 195static int do_dyn_syms;
85b1c36d
BE		 196static int do_reloc;
197static int do_sections;
198static int do_section_groups;
5477e8a0 199static int do_section_details;
85b1c36d
BE		 200static int do_segments;
201static int do_unwind;
202static int do_using_dynamic;
203static int do_header;
204static int do_dump;
205static int do_version;
85b1c36d
BE		 206static int do_histogram;
207static int do_debugging;
85b1c36d
BE		 208static int do_arch;
209static int do_notes;
4145f1d5 210static int do_archive_index;
85b1c36d 211static int is_32bit_elf;
0e602686 212static int decompress_dumps;
252b5132 213
e4b17d5c
L		 214struct group_list
215{
2cf0635d 216 struct group_list * next;
e4b17d5c
L		 217 unsigned int section_index;
218};
219
220struct group
221{
2cf0635d 222 struct group_list * root;
e4b17d5c
L		 223 unsigned int group_index;
224};
225
85b1c36d 226static size_t group_count;
2cf0635d
NC		 227static struct group * section_groups;
228static struct group ** section_headers_groups;
e4b17d5c 229
09c11c86
NC		 230
231/* Flag bits indicating particular types of dump. */
232#define HEX_DUMP (1 << 0) /* The -x command line switch. */
233#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
234#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
235#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 236#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 237
238typedef unsigned char dump_type;
239
240/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 241struct dump_list_entry
242{
2cf0635d 243 char * name;
09c11c86 244 dump_type type;
2cf0635d 245 struct dump_list_entry * next;
aef1f6d0 246};
2cf0635d 247static struct dump_list_entry * dump_sects_byname;
aef1f6d0 248
09c11c86
NC		 249/* A dynamic array of flags indicating for which sections a dump
250 has been requested via command line switches. */
251static dump_type * cmdline_dump_sects = NULL;
252static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 253
254/* A dynamic array of flags indicating for which sections a dump of
255 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 256 basis and then initialised from the cmdline_dump_sects array,
257 the results of interpreting the -w switch, and the
258 dump_sects_byname list. */
09c11c86
NC		 259static dump_type * dump_sects = NULL;
260static unsigned int num_dump_sects = 0;
252b5132 261
252b5132 262
c256ffe7 263/* How to print a vma value. */
843dd992
NC		 264typedef enum print_mode
265{
266 HEX,
267 DEC,
268 DEC_5,
269 UNSIGNED,
270 PREFIX_HEX,
271 FULL_HEX,
272 LONG_HEX
273}
274print_mode;
275
bb4d2ac2
L		 276/* Versioned symbol info. */
277enum versioned_symbol_info
278{
279 symbol_undefined,
280 symbol_hidden,
281 symbol_public
282};
283
284static const char *get_symbol_version_string
285 (FILE *file, int is_dynsym, const char *strtab,
286 unsigned long int strtab_size, unsigned int si,
287 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
288 unsigned short *vna_other);
289
9c19a809
NC		 290#define UNKNOWN -1
291
2b692964
NC		 292#define SECTION_NAME(X) \
293 ((X) == NULL ? _("<none>") \
294 : string_table == NULL ? _("<no-name>") \
295 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 296 : string_table + (X)->sh_name))
252b5132 297
ee42cf8c 298#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 299
ba5cdace
NC		 300#define GET_ELF_SYMBOLS(file, section, sym_count) \
301 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
302 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 303
d79b3d50
NC		 304#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
305/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
306 already been called and verified that the string exists. */
307#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 308
61865e30
NC		 309#define REMOVE_ARCH_BITS(ADDR) \
310 do \
311 { \
312 if (elf_header.e_machine == EM_ARM) \
313 (ADDR) &= ~1; \
314 } \
315 while (0)
d79b3d50 316\f
c9c1d674
EG		 317/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
318 the offset of the current archive member, if we are examining an archive.
59245841
NC		 319 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
320 using malloc and fill that. In either case return the pointer to the start of
321 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 322 and REASON is not NULL then emit an error message using REASON as part of the
323 context. */
59245841 324
c256ffe7 325static void *
57028622
NC		 326get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
327 bfd_size_type nmemb, const char * reason)
a6e9f9df 328{
2cf0635d 329 void * mvar;
57028622 330 bfd_size_type amt = size * nmemb;
a6e9f9df 331
c256ffe7 332 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 333 return NULL;
334
57028622
NC		 335 /* If the size_t type is smaller than the bfd_size_type, eg because
336 you are building a 32-bit tool on a 64-bit host, then make sure
337 that when the sizes are cast to (size_t) no information is lost. */
338 if (sizeof (size_t) < sizeof (bfd_size_type)
339 && ( (bfd_size_type) ((size_t) size) != size
340 || (bfd_size_type) ((size_t) nmemb) != nmemb))
341 {
342 if (reason)
343 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
344 (unsigned long long) nmemb, (unsigned long long) size, reason);
345 return NULL;
346 }
347
348 /* Check for size overflow. */
349 if (amt < nmemb)
350 {
351 if (reason)
352 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
353 (unsigned long long) nmemb, (unsigned long long) size, reason);
354 return NULL;
355 }
356
c9c1d674
EG		 357 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
358 attempting to allocate memory when the read is bound to fail. */
359 if (amt > current_file_size
360 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 361 {
049b0c3a 362 if (reason)
57028622
NC		 363 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
364 (unsigned long long) amt, reason);
a6e9f9df
AM		 365 return NULL;
366 }
367
c9c1d674 368 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 369 {
370 if (reason)
c9c1d674
EG		 371 error (_("Unable to seek to 0x%lx for %s\n"),
372 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 373 return NULL;
374 }
375
a6e9f9df
AM		 376 mvar = var;
377 if (mvar == NULL)
378 {
c256ffe7 379 /* Check for overflow. */
57028622 380 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 381 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 382 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 383
384 if (mvar == NULL)
385 {
049b0c3a 386 if (reason)
57028622
NC		 387 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
388 (unsigned long long) amt, reason);
a6e9f9df
AM		 389 return NULL;
390 }
c256ffe7 391
c9c1d674 392 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 393 }
394
57028622 395 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 396 {
049b0c3a 397 if (reason)
57028622
NC		 398 error (_("Unable to read in 0x%llx bytes of %s\n"),
399 (unsigned long long) amt, reason);
a6e9f9df
AM		 400 if (mvar != var)
401 free (mvar);
402 return NULL;
403 }
404
405 return mvar;
406}
407
14a91970 408/* Print a VMA value. */
cb8f3167 409
66543521 410static int
14a91970 411print_vma (bfd_vma vma, print_mode mode)
66543521 412{
66543521
AM		 413 int nc = 0;
414
14a91970 415 switch (mode)
66543521 416 {
14a91970
AM		 417 case FULL_HEX:
418 nc = printf ("0x");
419 /* Drop through. */
66543521 420
14a91970 421 case LONG_HEX:
f7a99963 422#ifdef BFD64
14a91970 423 if (is_32bit_elf)
437c2fb7 424 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 425#endif
14a91970
AM		 426 printf_vma (vma);
427 return nc + 16;
b19aac67 428
14a91970
AM		 429 case DEC_5:
430 if (vma <= 99999)
431 return printf ("%5" BFD_VMA_FMT "d", vma);
432 /* Drop through. */
66543521 433
14a91970
AM		 434 case PREFIX_HEX:
435 nc = printf ("0x");
436 /* Drop through. */
66543521 437
14a91970
AM		 438 case HEX:
439 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 440
14a91970
AM		 441 case DEC:
442 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 443
14a91970
AM		 444 case UNSIGNED:
445 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 446 }
66543521 447 return 0;
f7a99963
NC		 448}
449
7bfd842d 450/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 451 multibye characters (assuming the host environment supports them).
31104126 452
7bfd842d
NC		 453 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
454
455 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
456 padding as necessary.
171191ba
NC		 457
458 Returns the number of emitted characters. */
459
460static unsigned int
7a88bc9c 461print_symbol (int width, const char *symbol)
31104126 462{
171191ba 463 bfd_boolean extra_padding = FALSE;
7bfd842d 464 int num_printed = 0;
3bfcb652 465#ifdef HAVE_MBSTATE_T
7bfd842d 466 mbstate_t state;
3bfcb652 467#endif
7bfd842d 468 int width_remaining;
961c521f 469
7bfd842d 470 if (width < 0)
961c521f 471 {
961c521f
NC		 472 /* Keep the width positive. This also helps. */
473 width = - width;
171191ba 474 extra_padding = TRUE;
0b4362b0 475 }
74e1a04b 476 assert (width != 0);
961c521f 477
7bfd842d
NC		 478 if (do_wide)
479 /* Set the remaining width to a very large value.
480 This simplifies the code below. */
481 width_remaining = INT_MAX;
482 else
483 width_remaining = width;
cb8f3167 484
3bfcb652 485#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 486 /* Initialise the multibyte conversion state. */
487 memset (& state, 0, sizeof (state));
3bfcb652 488#endif
961c521f 489
7bfd842d
NC		 490 while (width_remaining)
491 {
492 size_t n;
7bfd842d 493 const char c = *symbol++;
961c521f 494
7bfd842d 495 if (c == 0)
961c521f
NC		 496 break;
497
7bfd842d
NC		 498 /* Do not print control characters directly as they can affect terminal
499 settings. Such characters usually appear in the names generated
500 by the assembler for local labels. */
501 if (ISCNTRL (c))
961c521f 502 {
7bfd842d 503 if (width_remaining < 2)
961c521f
NC		 504 break;
505
7bfd842d
NC		 506 printf ("^%c", c + 0x40);
507 width_remaining -= 2;
171191ba 508 num_printed += 2;
961c521f 509 }
7bfd842d
NC		 510 else if (ISPRINT (c))
511 {
512 putchar (c);
513 width_remaining --;
514 num_printed ++;
515 }
961c521f
NC		 516 else
517 {
3bfcb652
NC		 518#ifdef HAVE_MBSTATE_T
519 wchar_t w;
520#endif
7bfd842d
NC		 521 /* Let printf do the hard work of displaying multibyte characters. */
522 printf ("%.1s", symbol - 1);
523 width_remaining --;
524 num_printed ++;
525
3bfcb652 526#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 527 /* Try to find out how many bytes made up the character that was
528 just printed. Advance the symbol pointer past the bytes that
529 were displayed. */
530 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 531#else
532 n = 1;
533#endif
7bfd842d
NC		 534 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
535 symbol += (n - 1);
961c521f 536 }
961c521f 537 }
171191ba 538
7bfd842d 539 if (extra_padding && num_printed < width)
171191ba
NC		 540 {
541 /* Fill in the remaining spaces. */
7bfd842d
NC		 542 printf ("%-*s", width - num_printed, " ");
543 num_printed = width;
171191ba
NC		 544 }
545
546 return num_printed;
31104126
NC		 547}
548
74e1a04b
NC		 549/* Returns a pointer to a static buffer containing a printable version of
550 the given section's name. Like print_symbol, except that it does not try
551 to print multibyte characters, it just interprets them as hex values. */
552
553static const char *
0d2a7a93 554printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 555{
556#define MAX_PRINT_SEC_NAME_LEN 128
557 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
558 const char * name = SECTION_NAME (sec);
559 char * buf = sec_name_buf;
560 char c;
561 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
562
563 while ((c = * name ++) != 0)
564 {
565 if (ISCNTRL (c))
566 {
567 if (remaining < 2)
568 break;
948f632f 569
74e1a04b
NC		 570 * buf ++ = '^';
571 * buf ++ = c + 0x40;
572 remaining -= 2;
573 }
574 else if (ISPRINT (c))
575 {
576 * buf ++ = c;
577 remaining -= 1;
578 }
579 else
580 {
581 static char hex[17] = "0123456789ABCDEF";
582
583 if (remaining < 4)
584 break;
585 * buf ++ = '<';
586 * buf ++ = hex[(c & 0xf0) >> 4];
587 * buf ++ = hex[c & 0x0f];
588 * buf ++ = '>';
589 remaining -= 4;
590 }
591
592 if (remaining == 0)
593 break;
594 }
595
596 * buf = 0;
597 return sec_name_buf;
598}
599
600static const char *
601printable_section_name_from_index (unsigned long ndx)
602{
603 if (ndx >= elf_header.e_shnum)
604 return _("<corrupt>");
605
606 return printable_section_name (section_headers + ndx);
607}
608
89fac5e3
RS		 609/* Return a pointer to section NAME, or NULL if no such section exists. */
610
611static Elf_Internal_Shdr *
2cf0635d 612find_section (const char * name)
89fac5e3
RS		 613{
614 unsigned int i;
615
616 for (i = 0; i < elf_header.e_shnum; i++)
617 if (streq (SECTION_NAME (section_headers + i), name))
618 return section_headers + i;
619
620 return NULL;
621}
622
0b6ae522
DJ		 623/* Return a pointer to a section containing ADDR, or NULL if no such
624 section exists. */
625
626static Elf_Internal_Shdr *
627find_section_by_address (bfd_vma addr)
628{
629 unsigned int i;
630
631 for (i = 0; i < elf_header.e_shnum; i++)
632 {
633 Elf_Internal_Shdr *sec = section_headers + i;
634 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
635 return sec;
636 }
637
638 return NULL;
639}
640
071436c6
NC		 641static Elf_Internal_Shdr *
642find_section_by_type (unsigned int type)
643{
644 unsigned int i;
645
646 for (i = 0; i < elf_header.e_shnum; i++)
647 {
648 Elf_Internal_Shdr *sec = section_headers + i;
649 if (sec->sh_type == type)
650 return sec;
651 }
652
653 return NULL;
654}
655
657d0d47
CC		 656/* Return a pointer to section NAME, or NULL if no such section exists,
657 restricted to the list of sections given in SET. */
658
659static Elf_Internal_Shdr *
660find_section_in_set (const char * name, unsigned int * set)
661{
662 unsigned int i;
663
664 if (set != NULL)
665 {
666 while ((i = *set++) > 0)
667 if (streq (SECTION_NAME (section_headers + i), name))
668 return section_headers + i;
669 }
670
671 return find_section (name);
672}
673
0b6ae522
DJ		 674/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
675 bytes read. */
676
f6f0e17b
NC		 677static inline unsigned long
678read_uleb128 (unsigned char *data,
679 unsigned int *length_return,
680 const unsigned char * const end)
0b6ae522 681{
f6f0e17b 682 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 683}
684
28f997cf
TG		 685/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
686 This OS has so many departures from the ELF standard that we test it at
687 many places. */
688
689static inline int
690is_ia64_vms (void)
691{
692 return elf_header.e_machine == EM_IA_64
693 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
694}
695
bcedfee6 696/* Guess the relocation size commonly used by the specific machines. */
252b5132 697
252b5132 698static int
2dc4cec1 699guess_is_rela (unsigned int e_machine)
252b5132 700{
9c19a809 701 switch (e_machine)
252b5132
RH		 702 {
703 /* Targets that use REL relocations. */
252b5132 704 case EM_386:
22abe556 705 case EM_IAMCU:
63fcb9e9 706 case EM_960:
e9f53129 707 case EM_ARM:
2b0337b0 708 case EM_D10V:
252b5132 709 case EM_CYGNUS_D10V:
e9f53129 710 case EM_DLX:
252b5132 711 case EM_MIPS:
4fe85591 712 case EM_MIPS_RS3_LE:
e9f53129 713 case EM_CYGNUS_M32R:
1c0d3aa6 714 case EM_SCORE:
f6c1a2d5 715 case EM_XGATE:
9c19a809 716 return FALSE;
103f02d3 717
252b5132
RH		 718 /* Targets that use RELA relocations. */
719 case EM_68K:
e9f53129 720 case EM_860:
a06ea964 721 case EM_AARCH64:
cfb8c092 722 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 723 case EM_ALPHA:
724 case EM_ALTERA_NIOS2:
725 case EM_AVR:
726 case EM_AVR_OLD:
727 case EM_BLACKFIN:
60bca95a 728 case EM_CR16:
e9f53129
AM		 729 case EM_CRIS:
730 case EM_CRX:
2b0337b0 731 case EM_D30V:
252b5132 732 case EM_CYGNUS_D30V:
2b0337b0 733 case EM_FR30:
3f8107ab 734 case EM_FT32:
252b5132 735 case EM_CYGNUS_FR30:
5c70f934 736 case EM_CYGNUS_FRV:
e9f53129
AM		 737 case EM_H8S:
738 case EM_H8_300:
739 case EM_H8_300H:
800eeca4 740 case EM_IA_64:
1e4cf259
NC		 741 case EM_IP2K:
742 case EM_IP2K_OLD:
3b36097d 743 case EM_IQ2000:
84e94c90 744 case EM_LATTICEMICO32:
ff7eeb89 745 case EM_M32C_OLD:
49f58d10 746 case EM_M32C:
e9f53129
AM		 747 case EM_M32R:
748 case EM_MCORE:
15ab5209 749 case EM_CYGNUS_MEP:
a3c62988 750 case EM_METAG:
e9f53129
AM		 751 case EM_MMIX:
752 case EM_MN10200:
753 case EM_CYGNUS_MN10200:
754 case EM_MN10300:
755 case EM_CYGNUS_MN10300:
5506d11a 756 case EM_MOXIE:
e9f53129
AM		 757 case EM_MSP430:
758 case EM_MSP430_OLD:
d031aafb 759 case EM_MT:
35c08157 760 case EM_NDS32:
64fd6348 761 case EM_NIOS32:
73589c9d 762 case EM_OR1K:
e9f53129
AM		 763 case EM_PPC64:
764 case EM_PPC:
99c513f6 765 case EM_RL78:
c7927a3c 766 case EM_RX:
e9f53129
AM		 767 case EM_S390:
768 case EM_S390_OLD:
769 case EM_SH:
770 case EM_SPARC:
771 case EM_SPARC32PLUS:
772 case EM_SPARCV9:
773 case EM_SPU:
40b36596 774 case EM_TI_C6000:
aa137e4d
NC		 775 case EM_TILEGX:
776 case EM_TILEPRO:
708e2187 777 case EM_V800:
e9f53129
AM		 778 case EM_V850:
779 case EM_CYGNUS_V850:
780 case EM_VAX:
619ed720 781 case EM_VISIUM:
e9f53129 782 case EM_X86_64:
8a9036a4 783 case EM_L1OM:
7a9068fe 784 case EM_K1OM:
e9f53129
AM		 785 case EM_XSTORMY16:
786 case EM_XTENSA:
787 case EM_XTENSA_OLD:
7ba29e2a
NC		 788 case EM_MICROBLAZE:
789 case EM_MICROBLAZE_OLD:
9c19a809 790 return TRUE;
103f02d3 791
e9f53129
AM		 792 case EM_68HC05:
793 case EM_68HC08:
794 case EM_68HC11:
795 case EM_68HC16:
796 case EM_FX66:
797 case EM_ME16:
d1133906 798 case EM_MMA:
d1133906
NC		 799 case EM_NCPU:
800 case EM_NDR1:
e9f53129 801 case EM_PCP:
d1133906 802 case EM_ST100:
e9f53129 803 case EM_ST19:
d1133906 804 case EM_ST7:
e9f53129
AM		 805 case EM_ST9PLUS:
806 case EM_STARCORE:
d1133906 807 case EM_SVX:
e9f53129 808 case EM_TINYJ:
9c19a809
NC		 809 default:
810 warn (_("Don't know about relocations on this machine architecture\n"));
811 return FALSE;
812 }
813}
252b5132 814
9c19a809 815static int
2cf0635d 816slurp_rela_relocs (FILE * file,
d3ba0551
AM		 817 unsigned long rel_offset,
818 unsigned long rel_size,
2cf0635d
NC		 819 Elf_Internal_Rela ** relasp,
820 unsigned long * nrelasp)
9c19a809 821{
2cf0635d 822 Elf_Internal_Rela * relas;
8b73c356 823 size_t nrelas;
4d6ed7c8 824 unsigned int i;
252b5132 825
4d6ed7c8
NC		 826 if (is_32bit_elf)
827 {
2cf0635d 828 Elf32_External_Rela * erelas;
103f02d3 829
3f5e193b 830 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 831 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 832 if (!erelas)
833 return 0;
252b5132 834
4d6ed7c8 835 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 836
3f5e193b
NC		 837 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
838 sizeof (Elf_Internal_Rela));
103f02d3 839
4d6ed7c8
NC		 840 if (relas == NULL)
841 {
c256ffe7 842 free (erelas);
591a748a 843 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 844 return 0;
845 }
103f02d3 846
4d6ed7c8
NC		 847 for (i = 0; i < nrelas; i++)
848 {
849 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
850 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 851 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 852 }
103f02d3 853
4d6ed7c8
NC		 854 free (erelas);
855 }
856 else
857 {
2cf0635d 858 Elf64_External_Rela * erelas;
103f02d3 859
3f5e193b 860 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 861 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 862 if (!erelas)
863 return 0;
4d6ed7c8
NC		 864
865 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 866
3f5e193b
NC		 867 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
868 sizeof (Elf_Internal_Rela));
103f02d3 869
4d6ed7c8
NC		 870 if (relas == NULL)
871 {
c256ffe7 872 free (erelas);
591a748a 873 error (_("out of memory parsing relocs\n"));
4d6ed7c8 874 return 0;
9c19a809 875 }
4d6ed7c8
NC		 876
877 for (i = 0; i < nrelas; i++)
9c19a809 878 {
66543521
AM		 879 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
880 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 881 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 882
883 /* The #ifdef BFD64 below is to prevent a compile time
884 warning. We know that if we do not have a 64 bit data
885 type that we will never execute this code anyway. */
886#ifdef BFD64
887 if (elf_header.e_machine == EM_MIPS
888 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
889 {
890 /* In little-endian objects, r_info isn't really a
891 64-bit little-endian value: it has a 32-bit
892 little-endian symbol index followed by four
893 individual byte fields. Reorder INFO
894 accordingly. */
91d6fa6a
NC		 895 bfd_vma inf = relas[i].r_info;
896 inf = (((inf & 0xffffffff) << 32)
897 | ((inf >> 56) & 0xff)
898 | ((inf >> 40) & 0xff00)
899 | ((inf >> 24) & 0xff0000)
900 | ((inf >> 8) & 0xff000000));
901 relas[i].r_info = inf;
861fb55a
DJ		 902 }
903#endif /* BFD64 */
4d6ed7c8 904 }
103f02d3 905
4d6ed7c8
NC		 906 free (erelas);
907 }
908 *relasp = relas;
909 *nrelasp = nrelas;
910 return 1;
911}
103f02d3 912
4d6ed7c8 913static int
2cf0635d 914slurp_rel_relocs (FILE * file,
d3ba0551
AM		 915 unsigned long rel_offset,
916 unsigned long rel_size,
2cf0635d
NC		 917 Elf_Internal_Rela ** relsp,
918 unsigned long * nrelsp)
4d6ed7c8 919{
2cf0635d 920 Elf_Internal_Rela * rels;
8b73c356 921 size_t nrels;
4d6ed7c8 922 unsigned int i;
103f02d3 923
4d6ed7c8
NC		 924 if (is_32bit_elf)
925 {
2cf0635d 926 Elf32_External_Rel * erels;
103f02d3 927
3f5e193b 928 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 929 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 930 if (!erels)
931 return 0;
103f02d3 932
4d6ed7c8 933 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 934
3f5e193b 935 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 936
4d6ed7c8
NC		 937 if (rels == NULL)
938 {
c256ffe7 939 free (erels);
591a748a 940 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 941 return 0;
942 }
943
944 for (i = 0; i < nrels; i++)
945 {
946 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
947 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 948 rels[i].r_addend = 0;
9ea033b2 949 }
4d6ed7c8
NC		 950
951 free (erels);
9c19a809
NC		 952 }
953 else
954 {
2cf0635d 955 Elf64_External_Rel * erels;
9ea033b2 956
3f5e193b 957 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 958 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 959 if (!erels)
960 return 0;
103f02d3 961
4d6ed7c8 962 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 963
3f5e193b 964 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 965
4d6ed7c8 966 if (rels == NULL)
9c19a809 967 {
c256ffe7 968 free (erels);
591a748a 969 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 970 return 0;
971 }
103f02d3 972
4d6ed7c8
NC		 973 for (i = 0; i < nrels; i++)
974 {
66543521
AM		 975 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
976 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 977 rels[i].r_addend = 0;
861fb55a
DJ		 978
979 /* The #ifdef BFD64 below is to prevent a compile time
980 warning. We know that if we do not have a 64 bit data
981 type that we will never execute this code anyway. */
982#ifdef BFD64
983 if (elf_header.e_machine == EM_MIPS
984 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
985 {
986 /* In little-endian objects, r_info isn't really a
987 64-bit little-endian value: it has a 32-bit
988 little-endian symbol index followed by four
989 individual byte fields. Reorder INFO
990 accordingly. */
91d6fa6a
NC		 991 bfd_vma inf = rels[i].r_info;
992 inf = (((inf & 0xffffffff) << 32)
993 | ((inf >> 56) & 0xff)
994 | ((inf >> 40) & 0xff00)
995 | ((inf >> 24) & 0xff0000)
996 | ((inf >> 8) & 0xff000000));
997 rels[i].r_info = inf;
861fb55a
DJ		 998 }
999#endif /* BFD64 */
4d6ed7c8 1000 }
103f02d3 1001
4d6ed7c8
NC		 1002 free (erels);
1003 }
1004 *relsp = rels;
1005 *nrelsp = nrels;
1006 return 1;
1007}
103f02d3 1008
aca88567
NC		 1009/* Returns the reloc type extracted from the reloc info field. */
1010
1011static unsigned int
1012get_reloc_type (bfd_vma reloc_info)
1013{
1014 if (is_32bit_elf)
1015 return ELF32_R_TYPE (reloc_info);
1016
1017 switch (elf_header.e_machine)
1018 {
1019 case EM_MIPS:
1020 /* Note: We assume that reloc_info has already been adjusted for us. */
1021 return ELF64_MIPS_R_TYPE (reloc_info);
1022
1023 case EM_SPARCV9:
1024 return ELF64_R_TYPE_ID (reloc_info);
1025
1026 default:
1027 return ELF64_R_TYPE (reloc_info);
1028 }
1029}
1030
1031/* Return the symbol index extracted from the reloc info field. */
1032
1033static bfd_vma
1034get_reloc_symindex (bfd_vma reloc_info)
1035{
1036 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1037}
1038
13761a11
NC		 1039static inline bfd_boolean
1040uses_msp430x_relocs (void)
1041{
1042 return
1043 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1044 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1045 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1046 /* TI compiler uses ELFOSABI_NONE. */
1047 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1048}
1049
d3ba0551
AM		 1050/* Display the contents of the relocation data found at the specified
1051 offset. */
ee42cf8c 1052
41e92641 1053static void
2cf0635d 1054dump_relocations (FILE * file,
d3ba0551
AM		 1055 unsigned long rel_offset,
1056 unsigned long rel_size,
2cf0635d 1057 Elf_Internal_Sym * symtab,
d3ba0551 1058 unsigned long nsyms,
2cf0635d 1059 char * strtab,
d79b3d50 1060 unsigned long strtablen,
bb4d2ac2
L		 1061 int is_rela,
1062 int is_dynsym)
4d6ed7c8 1063{
b34976b6 1064 unsigned int i;
2cf0635d 1065 Elf_Internal_Rela * rels;
103f02d3 1066
4d6ed7c8
NC		 1067 if (is_rela == UNKNOWN)
1068 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1069
4d6ed7c8
NC		 1070 if (is_rela)
1071 {
c8286bd1 1072 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1073 return;
4d6ed7c8
NC		 1074 }
1075 else
1076 {
1077 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1078 return;
252b5132
RH		 1079 }
1080
410f7a12
L		 1081 if (is_32bit_elf)
1082 {
1083 if (is_rela)
2c71103e
NC		 1084 {
1085 if (do_wide)
1086 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1087 else
1088 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1089 }
410f7a12 1090 else
2c71103e
NC		 1091 {
1092 if (do_wide)
1093 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1094 else
1095 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1096 }
410f7a12 1097 }
252b5132 1098 else
410f7a12
L		 1099 {
1100 if (is_rela)
2c71103e
NC		 1101 {
1102 if (do_wide)
8beeaeb7 1103 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1104 else
1105 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1106 }
410f7a12 1107 else
2c71103e
NC		 1108 {
1109 if (do_wide)
8beeaeb7 1110 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1111 else
1112 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1113 }
410f7a12 1114 }
252b5132
RH		 1115
1116 for (i = 0; i < rel_size; i++)
1117 {
2cf0635d 1118 const char * rtype;
b34976b6 1119 bfd_vma offset;
91d6fa6a 1120 bfd_vma inf;
b34976b6
AM		 1121 bfd_vma symtab_index;
1122 bfd_vma type;
103f02d3 1123
b34976b6 1124 offset = rels[i].r_offset;
91d6fa6a 1125 inf = rels[i].r_info;
103f02d3 1126
91d6fa6a
NC		 1127 type = get_reloc_type (inf);
1128 symtab_index = get_reloc_symindex (inf);
252b5132 1129
410f7a12
L		 1130 if (is_32bit_elf)
1131 {
39dbeff8
AM		 1132 printf ("%8.8lx %8.8lx ",
1133 (unsigned long) offset & 0xffffffff,
91d6fa6a 1134 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1135 }
1136 else
1137 {
39dbeff8
AM		 1138#if BFD_HOST_64BIT_LONG
1139 printf (do_wide
1140 ? "%16.16lx %16.16lx "
1141 : "%12.12lx %12.12lx ",
91d6fa6a 1142 offset, inf);
39dbeff8 1143#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1144#ifndef __MSVCRT__
39dbeff8
AM		 1145 printf (do_wide
1146 ? "%16.16llx %16.16llx "
1147 : "%12.12llx %12.12llx ",
91d6fa6a 1148 offset, inf);
6e3d6dc1
NC		 1149#else
1150 printf (do_wide
1151 ? "%16.16I64x %16.16I64x "
1152 : "%12.12I64x %12.12I64x ",
91d6fa6a 1153 offset, inf);
6e3d6dc1 1154#endif
39dbeff8 1155#else
2c71103e
NC		 1156 printf (do_wide
1157 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1158 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1159 _bfd_int64_high (offset),
1160 _bfd_int64_low (offset),
91d6fa6a
NC		 1161 _bfd_int64_high (inf),
1162 _bfd_int64_low (inf));
9ea033b2 1163#endif
410f7a12 1164 }
103f02d3 1165
252b5132
RH		 1166 switch (elf_header.e_machine)
1167 {
1168 default:
1169 rtype = NULL;
1170 break;
1171
a06ea964
NC		 1172 case EM_AARCH64:
1173 rtype = elf_aarch64_reloc_type (type);
1174 break;
1175
2b0337b0 1176 case EM_M32R:
252b5132 1177 case EM_CYGNUS_M32R:
9ea033b2 1178 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1179 break;
1180
1181 case EM_386:
22abe556 1182 case EM_IAMCU:
9ea033b2 1183 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1184 break;
1185
ba2685cc
AM		 1186 case EM_68HC11:
1187 case EM_68HC12:
1188 rtype = elf_m68hc11_reloc_type (type);
1189 break;
75751cd9 1190
252b5132 1191 case EM_68K:
9ea033b2 1192 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1193 break;
1194
63fcb9e9 1195 case EM_960:
9ea033b2 1196 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1197 break;
1198
adde6300 1199 case EM_AVR:
2b0337b0 1200 case EM_AVR_OLD:
adde6300
AM		 1201 rtype = elf_avr_reloc_type (type);
1202 break;
1203
9ea033b2
NC		 1204 case EM_OLD_SPARCV9:
1205 case EM_SPARC32PLUS:
1206 case EM_SPARCV9:
252b5132 1207 case EM_SPARC:
9ea033b2 1208 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1209 break;
1210
e9f53129
AM		 1211 case EM_SPU:
1212 rtype = elf_spu_reloc_type (type);
1213 break;
1214
708e2187
NC		 1215 case EM_V800:
1216 rtype = v800_reloc_type (type);
1217 break;
2b0337b0 1218 case EM_V850:
252b5132 1219 case EM_CYGNUS_V850:
9ea033b2 1220 rtype = v850_reloc_type (type);
252b5132
RH		 1221 break;
1222
2b0337b0 1223 case EM_D10V:
252b5132 1224 case EM_CYGNUS_D10V:
9ea033b2 1225 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1226 break;
1227
2b0337b0 1228 case EM_D30V:
252b5132 1229 case EM_CYGNUS_D30V:
9ea033b2 1230 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1231 break;
1232
d172d4ba
NC		 1233 case EM_DLX:
1234 rtype = elf_dlx_reloc_type (type);
1235 break;
1236
252b5132 1237 case EM_SH:
9ea033b2 1238 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1239 break;
1240
2b0337b0 1241 case EM_MN10300:
252b5132 1242 case EM_CYGNUS_MN10300:
9ea033b2 1243 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1244 break;
1245
2b0337b0 1246 case EM_MN10200:
252b5132 1247 case EM_CYGNUS_MN10200:
9ea033b2 1248 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1249 break;
1250
2b0337b0 1251 case EM_FR30:
252b5132 1252 case EM_CYGNUS_FR30:
9ea033b2 1253 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1254 break;
1255
ba2685cc
AM		 1256 case EM_CYGNUS_FRV:
1257 rtype = elf_frv_reloc_type (type);
1258 break;
5c70f934 1259
3f8107ab
AM		 1260 case EM_FT32:
1261 rtype = elf_ft32_reloc_type (type);
1262 break;
1263
252b5132 1264 case EM_MCORE:
9ea033b2 1265 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1266 break;
1267
3c3bdf30
NC		 1268 case EM_MMIX:
1269 rtype = elf_mmix_reloc_type (type);
1270 break;
1271
5506d11a
AM		 1272 case EM_MOXIE:
1273 rtype = elf_moxie_reloc_type (type);
1274 break;
1275
2469cfa2 1276 case EM_MSP430:
13761a11
NC		 1277 if (uses_msp430x_relocs ())
1278 {
1279 rtype = elf_msp430x_reloc_type (type);
1280 break;
1281 }
2469cfa2
NC		 1282 case EM_MSP430_OLD:
1283 rtype = elf_msp430_reloc_type (type);
1284 break;
1285
35c08157
KLC		 1286 case EM_NDS32:
1287 rtype = elf_nds32_reloc_type (type);
1288 break;
1289
252b5132 1290 case EM_PPC:
9ea033b2 1291 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1292 break;
1293
c833c019
AM		 1294 case EM_PPC64:
1295 rtype = elf_ppc64_reloc_type (type);
1296 break;
1297
252b5132 1298 case EM_MIPS:
4fe85591 1299 case EM_MIPS_RS3_LE:
9ea033b2 1300 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1301 break;
1302
1303 case EM_ALPHA:
9ea033b2 1304 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1305 break;
1306
1307 case EM_ARM:
9ea033b2 1308 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1309 break;
1310
584da044 1311 case EM_ARC:
9ea033b2 1312 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1313 break;
1314
1315 case EM_PARISC:
69e617ca 1316 rtype = elf_hppa_reloc_type (type);
252b5132 1317 break;
7d466069 1318
b8720f9d
JL		 1319 case EM_H8_300:
1320 case EM_H8_300H:
1321 case EM_H8S:
1322 rtype = elf_h8_reloc_type (type);
1323 break;
1324
73589c9d
CS		 1325 case EM_OR1K:
1326 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1327 break;
1328
7d466069 1329 case EM_PJ:
2b0337b0 1330 case EM_PJ_OLD:
7d466069
ILT		 1331 rtype = elf_pj_reloc_type (type);
1332 break;
800eeca4
JW		 1333 case EM_IA_64:
1334 rtype = elf_ia64_reloc_type (type);
1335 break;
1b61cf92
HPN		 1336
1337 case EM_CRIS:
1338 rtype = elf_cris_reloc_type (type);
1339 break;
535c37ff
JE		 1340
1341 case EM_860:
1342 rtype = elf_i860_reloc_type (type);
1343 break;
bcedfee6
NC		 1344
1345 case EM_X86_64:
8a9036a4 1346 case EM_L1OM:
7a9068fe 1347 case EM_K1OM:
bcedfee6
NC		 1348 rtype = elf_x86_64_reloc_type (type);
1349 break;
a85d7ed0 1350
35b1837e
AM		 1351 case EM_S370:
1352 rtype = i370_reloc_type (type);
1353 break;
1354
53c7db4b
KH		 1355 case EM_S390_OLD:
1356 case EM_S390:
1357 rtype = elf_s390_reloc_type (type);
1358 break;
93fbbb04 1359
1c0d3aa6
NC		 1360 case EM_SCORE:
1361 rtype = elf_score_reloc_type (type);
1362 break;
1363
93fbbb04
GK		 1364 case EM_XSTORMY16:
1365 rtype = elf_xstormy16_reloc_type (type);
1366 break;
179d3252 1367
1fe1f39c
NC		 1368 case EM_CRX:
1369 rtype = elf_crx_reloc_type (type);
1370 break;
1371
179d3252
JT		 1372 case EM_VAX:
1373 rtype = elf_vax_reloc_type (type);
1374 break;
1e4cf259 1375
619ed720
EB		 1376 case EM_VISIUM:
1377 rtype = elf_visium_reloc_type (type);
1378 break;
1379
cfb8c092
NC		 1380 case EM_ADAPTEVA_EPIPHANY:
1381 rtype = elf_epiphany_reloc_type (type);
1382 break;
1383
1e4cf259
NC		 1384 case EM_IP2K:
1385 case EM_IP2K_OLD:
1386 rtype = elf_ip2k_reloc_type (type);
1387 break;
3b36097d
SC		 1388
1389 case EM_IQ2000:
1390 rtype = elf_iq2000_reloc_type (type);
1391 break;
88da6820
NC		 1392
1393 case EM_XTENSA_OLD:
1394 case EM_XTENSA:
1395 rtype = elf_xtensa_reloc_type (type);
1396 break;
a34e3ecb 1397
84e94c90
NC		 1398 case EM_LATTICEMICO32:
1399 rtype = elf_lm32_reloc_type (type);
1400 break;
1401
ff7eeb89 1402 case EM_M32C_OLD:
49f58d10
JB		 1403 case EM_M32C:
1404 rtype = elf_m32c_reloc_type (type);
1405 break;
1406
d031aafb
NS		 1407 case EM_MT:
1408 rtype = elf_mt_reloc_type (type);
a34e3ecb 1409 break;
1d65ded4
CM		 1410
1411 case EM_BLACKFIN:
1412 rtype = elf_bfin_reloc_type (type);
1413 break;
15ab5209
DB		 1414
1415 case EM_CYGNUS_MEP:
1416 rtype = elf_mep_reloc_type (type);
1417 break;
60bca95a
NC		 1418
1419 case EM_CR16:
1420 rtype = elf_cr16_reloc_type (type);
1421 break;
dd24e3da 1422
7ba29e2a
NC		 1423 case EM_MICROBLAZE:
1424 case EM_MICROBLAZE_OLD:
1425 rtype = elf_microblaze_reloc_type (type);
1426 break;
c7927a3c 1427
99c513f6
DD		 1428 case EM_RL78:
1429 rtype = elf_rl78_reloc_type (type);
1430 break;
1431
c7927a3c
NC		 1432 case EM_RX:
1433 rtype = elf_rx_reloc_type (type);
1434 break;
c29aca4a 1435
a3c62988
NC		 1436 case EM_METAG:
1437 rtype = elf_metag_reloc_type (type);
1438 break;
1439
c29aca4a
NC		 1440 case EM_XC16X:
1441 case EM_C166:
1442 rtype = elf_xc16x_reloc_type (type);
1443 break;
40b36596
JM		 1444
1445 case EM_TI_C6000:
1446 rtype = elf_tic6x_reloc_type (type);
1447 break;
aa137e4d
NC		 1448
1449 case EM_TILEGX:
1450 rtype = elf_tilegx_reloc_type (type);
1451 break;
1452
1453 case EM_TILEPRO:
1454 rtype = elf_tilepro_reloc_type (type);
1455 break;
f6c1a2d5
NC		 1456
1457 case EM_XGATE:
1458 rtype = elf_xgate_reloc_type (type);
1459 break;
36591ba1
SL		 1460
1461 case EM_ALTERA_NIOS2:
1462 rtype = elf_nios2_reloc_type (type);
1463 break;
252b5132
RH		 1464 }
1465
1466 if (rtype == NULL)
39dbeff8 1467 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1468 else
8beeaeb7 1469 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1470
7ace3541 1471 if (elf_header.e_machine == EM_ALPHA
157c2599 1472 && rtype != NULL
7ace3541
RH		 1473 && streq (rtype, "R_ALPHA_LITUSE")
1474 && is_rela)
1475 {
1476 switch (rels[i].r_addend)
1477 {
1478 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1479 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1480 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1481 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1482 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1483 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1484 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1485 default: rtype = NULL;
1486 }
1487 if (rtype)
1488 printf (" (%s)", rtype);
1489 else
1490 {
1491 putchar (' ');
1492 printf (_("<unknown addend: %lx>"),
1493 (unsigned long) rels[i].r_addend);
1494 }
1495 }
1496 else if (symtab_index)
252b5132 1497 {
af3fc3bc 1498 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1499 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1500 else
19936277 1501 {
2cf0635d 1502 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1503 const char * version_string;
1504 enum versioned_symbol_info sym_info;
1505 unsigned short vna_other;
19936277 1506
af3fc3bc 1507 psym = symtab + symtab_index;
103f02d3 1508
bb4d2ac2
L		 1509 version_string
1510 = get_symbol_version_string (file, is_dynsym,
1511 strtab, strtablen,
1512 symtab_index,
1513 psym,
1514 &sym_info,
1515 &vna_other);
1516
af3fc3bc 1517 printf (" ");
171191ba 1518
d8045f23
NC		 1519 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1520 {
1521 const char * name;
1522 unsigned int len;
1523 unsigned int width = is_32bit_elf ? 8 : 14;
1524
1525 /* Relocations against GNU_IFUNC symbols do not use the value
1526 of the symbol as the address to relocate against. Instead
1527 they invoke the function named by the symbol and use its
1528 result as the address for relocation.
1529
1530 To indicate this to the user, do not display the value of
1531 the symbol in the "Symbols's Value" field. Instead show
1532 its name followed by () as a hint that the symbol is
1533 invoked. */
1534
1535 if (strtab == NULL
1536 || psym->st_name == 0
1537 || psym->st_name >= strtablen)
1538 name = "??";
1539 else
1540 name = strtab + psym->st_name;
1541
1542 len = print_symbol (width, name);
bb4d2ac2
L		 1543 if (version_string)
1544 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1545 version_string);
d8045f23
NC		 1546 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1547 }
1548 else
1549 {
1550 print_vma (psym->st_value, LONG_HEX);
171191ba 1551
d8045f23
NC		 1552 printf (is_32bit_elf ? " " : " ");
1553 }
103f02d3 1554
af3fc3bc 1555 if (psym->st_name == 0)
f1ef08cb 1556 {
2cf0635d 1557 const char * sec_name = "<null>";
f1ef08cb
AM		 1558 char name_buf[40];
1559
1560 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1561 {
4fbb74a6 1562 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1563 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1564 else if (psym->st_shndx == SHN_ABS)
1565 sec_name = "ABS";
1566 else if (psym->st_shndx == SHN_COMMON)
1567 sec_name = "COMMON";
ac145307
BS		 1568 else if ((elf_header.e_machine == EM_MIPS
1569 && psym->st_shndx == SHN_MIPS_SCOMMON)
1570 || (elf_header.e_machine == EM_TI_C6000
1571 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1572 sec_name = "SCOMMON";
1573 else if (elf_header.e_machine == EM_MIPS
1574 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1575 sec_name = "SUNDEF";
8a9036a4 1576 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1577 || elf_header.e_machine == EM_L1OM
1578 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1579 && psym->st_shndx == SHN_X86_64_LCOMMON)
1580 sec_name = "LARGE_COMMON";
9ce701e2
L		 1581 else if (elf_header.e_machine == EM_IA_64
1582 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1583 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1584 sec_name = "ANSI_COM";
28f997cf 1585 else if (is_ia64_vms ()
148b93f2
NC		 1586 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1587 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1588 else
1589 {
1590 sprintf (name_buf, "<section 0x%x>",
1591 (unsigned int) psym->st_shndx);
1592 sec_name = name_buf;
1593 }
1594 }
1595 print_symbol (22, sec_name);
1596 }
af3fc3bc 1597 else if (strtab == NULL)
d79b3d50 1598 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1599 else if (psym->st_name >= strtablen)
d79b3d50 1600 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1601 else
bb4d2ac2
L		 1602 {
1603 print_symbol (22, strtab + psym->st_name);
1604 if (version_string)
1605 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1606 version_string);
1607 }
103f02d3 1608
af3fc3bc 1609 if (is_rela)
171191ba 1610 {
7360e63f 1611 bfd_vma off = rels[i].r_addend;
171191ba 1612
7360e63f 1613 if ((bfd_signed_vma) off < 0)
598aaa76 1614 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1615 else
598aaa76 1616 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1617 }
19936277 1618 }
252b5132 1619 }
1b228002 1620 else if (is_rela)
f7a99963 1621 {
7360e63f 1622 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1623
1624 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1625 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1626 printf ("-%" BFD_VMA_FMT "x", - off);
1627 else
1628 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1629 }
252b5132 1630
157c2599
NC		 1631 if (elf_header.e_machine == EM_SPARCV9
1632 && rtype != NULL
1633 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1634 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1635
252b5132 1636 putchar ('\n');
2c71103e 1637
aca88567 1638#ifdef BFD64
53c7db4b 1639 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1640 {
91d6fa6a
NC		 1641 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1642 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1643 const char * rtype2 = elf_mips_reloc_type (type2);
1644 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1645
2c71103e
NC		 1646 printf (" Type2: ");
1647
1648 if (rtype2 == NULL)
39dbeff8
AM		 1649 printf (_("unrecognized: %-7lx"),
1650 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1651 else
1652 printf ("%-17.17s", rtype2);
1653
18bd398b 1654 printf ("\n Type3: ");
2c71103e
NC		 1655
1656 if (rtype3 == NULL)
39dbeff8
AM		 1657 printf (_("unrecognized: %-7lx"),
1658 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1659 else
1660 printf ("%-17.17s", rtype3);
1661
53c7db4b 1662 putchar ('\n');
2c71103e 1663 }
aca88567 1664#endif /* BFD64 */
252b5132
RH		 1665 }
1666
c8286bd1 1667 free (rels);
252b5132
RH		 1668}
1669
1670static const char *
d3ba0551 1671get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1672{
1673 switch (type)
1674 {
1675 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1676 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1677 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1678 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1679 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1680 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1681 case DT_MIPS_MSYM: return "MIPS_MSYM";
1682 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1683 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1684 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1685 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1686 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1687 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1688 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1689 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1690 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1691 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1692 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1693 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1694 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1695 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1696 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1697 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1698 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1699 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1700 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1701 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1702 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1703 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1704 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1705 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1706 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1707 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1708 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1709 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1710 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1711 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1712 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1713 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1714 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1715 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1716 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1717 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1718 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1719 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1720 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1721 default:
1722 return NULL;
1723 }
1724}
1725
9a097730 1726static const char *
d3ba0551 1727get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1728{
1729 switch (type)
1730 {
1731 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1732 default:
1733 return NULL;
1734 }
103f02d3
UD		 1735}
1736
7490d522
AM		 1737static const char *
1738get_ppc_dynamic_type (unsigned long type)
1739{
1740 switch (type)
1741 {
a7f2871e 1742 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1743 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1744 default:
1745 return NULL;
1746 }
1747}
1748
f1cb7e17 1749static const char *
d3ba0551 1750get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1751{
1752 switch (type)
1753 {
a7f2871e
AM		 1754 case DT_PPC64_GLINK: return "PPC64_GLINK";
1755 case DT_PPC64_OPD: return "PPC64_OPD";
1756 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1757 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1758 default:
1759 return NULL;
1760 }
1761}
1762
103f02d3 1763static const char *
d3ba0551 1764get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1765{
1766 switch (type)
1767 {
1768 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1769 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1770 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1771 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1772 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1773 case DT_HP_PREINIT: return "HP_PREINIT";
1774 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1775 case DT_HP_NEEDED: return "HP_NEEDED";
1776 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1777 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1778 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1779 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1780 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1781 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1782 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1783 case DT_HP_FILTERED: return "HP_FILTERED";
1784 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1785 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1786 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1787 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1788 case DT_PLT: return "PLT";
1789 case DT_PLT_SIZE: return "PLT_SIZE";
1790 case DT_DLT: return "DLT";
1791 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1792 default:
1793 return NULL;
1794 }
1795}
9a097730 1796
ecc51f48 1797static const char *
d3ba0551 1798get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1799{
1800 switch (type)
1801 {
148b93f2
NC		 1802 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1803 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1804 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1805 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1806 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1807 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1808 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1809 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1810 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1811 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1812 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1813 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1814 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1815 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1816 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1817 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1818 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1819 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1820 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1821 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1822 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1823 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1824 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1825 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1826 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1827 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1828 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1829 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1830 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1831 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1832 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1833 default:
1834 return NULL;
1835 }
1836}
1837
fabcb361
RH		 1838static const char *
1839get_alpha_dynamic_type (unsigned long type)
1840{
1841 switch (type)
1842 {
1843 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1844 default:
1845 return NULL;
1846 }
1847}
1848
1c0d3aa6
NC		 1849static const char *
1850get_score_dynamic_type (unsigned long type)
1851{
1852 switch (type)
1853 {
1854 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1855 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1856 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1857 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1858 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1859 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1860 default:
1861 return NULL;
1862 }
1863}
1864
40b36596
JM		 1865static const char *
1866get_tic6x_dynamic_type (unsigned long type)
1867{
1868 switch (type)
1869 {
1870 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1871 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1872 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1873 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1874 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1875 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1876 default:
1877 return NULL;
1878 }
1879}
1c0d3aa6 1880
36591ba1
SL		 1881static const char *
1882get_nios2_dynamic_type (unsigned long type)
1883{
1884 switch (type)
1885 {
1886 case DT_NIOS2_GP: return "NIOS2_GP";
1887 default:
1888 return NULL;
1889 }
1890}
1891
252b5132 1892static const char *
d3ba0551 1893get_dynamic_type (unsigned long type)
252b5132 1894{
e9e44622 1895 static char buff[64];
252b5132
RH		 1896
1897 switch (type)
1898 {
1899 case DT_NULL: return "NULL";
1900 case DT_NEEDED: return "NEEDED";
1901 case DT_PLTRELSZ: return "PLTRELSZ";
1902 case DT_PLTGOT: return "PLTGOT";
1903 case DT_HASH: return "HASH";
1904 case DT_STRTAB: return "STRTAB";
1905 case DT_SYMTAB: return "SYMTAB";
1906 case DT_RELA: return "RELA";
1907 case DT_RELASZ: return "RELASZ";
1908 case DT_RELAENT: return "RELAENT";
1909 case DT_STRSZ: return "STRSZ";
1910 case DT_SYMENT: return "SYMENT";
1911 case DT_INIT: return "INIT";
1912 case DT_FINI: return "FINI";
1913 case DT_SONAME: return "SONAME";
1914 case DT_RPATH: return "RPATH";
1915 case DT_SYMBOLIC: return "SYMBOLIC";
1916 case DT_REL: return "REL";
1917 case DT_RELSZ: return "RELSZ";
1918 case DT_RELENT: return "RELENT";
1919 case DT_PLTREL: return "PLTREL";
1920 case DT_DEBUG: return "DEBUG";
1921 case DT_TEXTREL: return "TEXTREL";
1922 case DT_JMPREL: return "JMPREL";
1923 case DT_BIND_NOW: return "BIND_NOW";
1924 case DT_INIT_ARRAY: return "INIT_ARRAY";
1925 case DT_FINI_ARRAY: return "FINI_ARRAY";
1926 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1927 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1928 case DT_RUNPATH: return "RUNPATH";
1929 case DT_FLAGS: return "FLAGS";
2d0e6f43 1930
d1133906
NC		 1931 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1932 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1933
05107a46 1934 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1935 case DT_PLTPADSZ: return "PLTPADSZ";
1936 case DT_MOVEENT: return "MOVEENT";
1937 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1938 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1939 case DT_POSFLAG_1: return "POSFLAG_1";
1940 case DT_SYMINSZ: return "SYMINSZ";
1941 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1942
252b5132 1943 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1944 case DT_CONFIG: return "CONFIG";
1945 case DT_DEPAUDIT: return "DEPAUDIT";
1946 case DT_AUDIT: return "AUDIT";
1947 case DT_PLTPAD: return "PLTPAD";
1948 case DT_MOVETAB: return "MOVETAB";
252b5132 1949 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1950
252b5132 1951 case DT_VERSYM: return "VERSYM";
103f02d3 1952
67a4f2b7
AO		 1953 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1954 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1955 case DT_RELACOUNT: return "RELACOUNT";
1956 case DT_RELCOUNT: return "RELCOUNT";
1957 case DT_FLAGS_1: return "FLAGS_1";
1958 case DT_VERDEF: return "VERDEF";
1959 case DT_VERDEFNUM: return "VERDEFNUM";
1960 case DT_VERNEED: return "VERNEED";
1961 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1962
019148e4 1963 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1964 case DT_USED: return "USED";
1965 case DT_FILTER: return "FILTER";
103f02d3 1966
047b2264
JJ		 1967 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1968 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1969 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1970 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1971 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1972 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1973
252b5132
RH		 1974 default:
1975 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1976 {
2cf0635d 1977 const char * result;
103f02d3 1978
252b5132
RH		 1979 switch (elf_header.e_machine)
1980 {
1981 case EM_MIPS:
4fe85591 1982 case EM_MIPS_RS3_LE:
252b5132
RH		 1983 result = get_mips_dynamic_type (type);
1984 break;
9a097730
RH		 1985 case EM_SPARCV9:
1986 result = get_sparc64_dynamic_type (type);
1987 break;
7490d522
AM		 1988 case EM_PPC:
1989 result = get_ppc_dynamic_type (type);
1990 break;
f1cb7e17
AM		 1991 case EM_PPC64:
1992 result = get_ppc64_dynamic_type (type);
1993 break;
ecc51f48
NC		 1994 case EM_IA_64:
1995 result = get_ia64_dynamic_type (type);
1996 break;
fabcb361
RH		 1997 case EM_ALPHA:
1998 result = get_alpha_dynamic_type (type);
1999 break;
1c0d3aa6
NC		 2000 case EM_SCORE:
2001 result = get_score_dynamic_type (type);
2002 break;
40b36596
JM		 2003 case EM_TI_C6000:
2004 result = get_tic6x_dynamic_type (type);
2005 break;
36591ba1
SL		 2006 case EM_ALTERA_NIOS2:
2007 result = get_nios2_dynamic_type (type);
2008 break;
252b5132
RH		 2009 default:
2010 result = NULL;
2011 break;
2012 }
2013
2014 if (result != NULL)
2015 return result;
2016
e9e44622 2017 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2018 }
eec8f817
DA		 2019 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2020 || (elf_header.e_machine == EM_PARISC
2021 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2022 {
2cf0635d 2023 const char * result;
103f02d3
UD		 2024
2025 switch (elf_header.e_machine)
2026 {
2027 case EM_PARISC:
2028 result = get_parisc_dynamic_type (type);
2029 break;
148b93f2
NC		 2030 case EM_IA_64:
2031 result = get_ia64_dynamic_type (type);
2032 break;
103f02d3
UD		 2033 default:
2034 result = NULL;
2035 break;
2036 }
2037
2038 if (result != NULL)
2039 return result;
2040
e9e44622
JJ		 2041 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2042 type);
103f02d3 2043 }
252b5132 2044 else
e9e44622 2045 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2046
252b5132
RH		 2047 return buff;
2048 }
2049}
2050
2051static char *
d3ba0551 2052get_file_type (unsigned e_type)
252b5132 2053{
b34976b6 2054 static char buff[32];
252b5132
RH		 2055
2056 switch (e_type)
2057 {
2058 case ET_NONE: return _("NONE (None)");
2059 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2060 case ET_EXEC: return _("EXEC (Executable file)");
2061 case ET_DYN: return _("DYN (Shared object file)");
2062 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2063
2064 default:
2065 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2066 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2067 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2068 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2069 else
e9e44622 2070 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2071 return buff;
2072 }
2073}
2074
2075static char *
d3ba0551 2076get_machine_name (unsigned e_machine)
252b5132 2077{
b34976b6 2078 static char buff[64]; /* XXX */
252b5132
RH		 2079
2080 switch (e_machine)
2081 {
c45021f2 2082 case EM_NONE: return _("None");
a06ea964 2083 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2084 case EM_M32: return "WE32100";
2085 case EM_SPARC: return "Sparc";
e9f53129 2086 case EM_SPU: return "SPU";
c45021f2
NC		 2087 case EM_386: return "Intel 80386";
2088 case EM_68K: return "MC68000";
2089 case EM_88K: return "MC88000";
22abe556 2090 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2091 case EM_860: return "Intel 80860";
2092 case EM_MIPS: return "MIPS R3000";
2093 case EM_S370: return "IBM System/370";
7036c0e1 2094 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2095 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2096 case EM_PARISC: return "HPPA";
252b5132 2097 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2098 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2099 case EM_960: return "Intel 90860";
2100 case EM_PPC: return "PowerPC";
285d1771 2101 case EM_PPC64: return "PowerPC64";
c45021f2 2102 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2103 case EM_FT32: return "FTDI FT32";
c45021f2 2104 case EM_RH32: return "TRW RH32";
b34976b6 2105 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2106 case EM_ARM: return "ARM";
2107 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2108 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2109 case EM_SPARCV9: return "Sparc v9";
2110 case EM_TRICORE: return "Siemens Tricore";
584da044 2111 case EM_ARC: return "ARC";
c2dcd04e
NC		 2112 case EM_H8_300: return "Renesas H8/300";
2113 case EM_H8_300H: return "Renesas H8/300H";
2114 case EM_H8S: return "Renesas H8S";
2115 case EM_H8_500: return "Renesas H8/500";
30800947 2116 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2117 case EM_MIPS_X: return "Stanford MIPS-X";
2118 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2119 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2120 case EM_CYGNUS_D10V:
2121 case EM_D10V: return "d10v";
2122 case EM_CYGNUS_D30V:
b34976b6 2123 case EM_D30V: return "d30v";
2b0337b0 2124 case EM_CYGNUS_M32R:
26597c86 2125 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2126 case EM_CYGNUS_V850:
708e2187 2127 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2128 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2129 case EM_CYGNUS_MN10300:
2130 case EM_MN10300: return "mn10300";
2131 case EM_CYGNUS_MN10200:
2132 case EM_MN10200: return "mn10200";
5506d11a 2133 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2134 case EM_CYGNUS_FR30:
2135 case EM_FR30: return "Fujitsu FR30";
b34976b6 2136 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2137 case EM_PJ_OLD:
b34976b6 2138 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2139 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2140 case EM_PCP: return "Siemens PCP";
2141 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2142 case EM_NDR1: return "Denso NDR1 microprocesspr";
2143 case EM_STARCORE: return "Motorola Star*Core processor";
2144 case EM_ME16: return "Toyota ME16 processor";
2145 case EM_ST100: return "STMicroelectronics ST100 processor";
2146 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2147 case EM_PDSP: return "Sony DSP processor";
2148 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2149 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2150 case EM_FX66: return "Siemens FX66 microcontroller";
2151 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2152 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2153 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2154 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2155 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2156 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2157 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2158 case EM_SVX: return "Silicon Graphics SVx";
2159 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2160 case EM_VAX: return "Digital VAX";
619ed720 2161 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2162 case EM_AVR_OLD:
b34976b6 2163 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2164 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2165 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2166 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2167 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2168 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2169 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2170 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2171 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2172 case EM_L1OM: return "Intel L1OM";
7a9068fe 2173 case EM_K1OM: return "Intel K1OM";
b7498e0e 2174 case EM_S390_OLD:
b34976b6 2175 case EM_S390: return "IBM S/390";
1c0d3aa6 2176 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2177 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2178 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2179 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2180 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2181 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2182 case EM_DLX: return "OpenDLX";
1e4cf259 2183 case EM_IP2K_OLD:
b34976b6 2184 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2185 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2186 case EM_XTENSA_OLD:
2187 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2188 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2189 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2190 case EM_NS32K: return "National Semiconductor 32000 series";
2191 case EM_TPC: return "Tenor Network TPC processor";
2192 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2193 case EM_MAX: return "MAX Processor";
2194 case EM_CR: return "National Semiconductor CompactRISC";
2195 case EM_F2MC16: return "Fujitsu F2MC16";
2196 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2197 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2198 case EM_M32C_OLD:
49f58d10 2199 case EM_M32C: return "Renesas M32c";
d031aafb 2200 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2201 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2202 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2203 case EM_SEP: return "Sharp embedded microprocessor";
2204 case EM_ARCA: return "Arca RISC microprocessor";
2205 case EM_UNICORE: return "Unicore";
2206 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2207 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2208 case EM_NIOS32: return "Altera Nios";
2209 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2210 case EM_C166:
d70c5fc7 2211 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2212 case EM_M16C: return "Renesas M16C series microprocessors";
2213 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2214 case EM_CE: return "Freescale Communication Engine RISC core";
2215 case EM_TSK3000: return "Altium TSK3000 core";
2216 case EM_RS08: return "Freescale RS08 embedded processor";
2217 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2218 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2219 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2220 case EM_SE_C17: return "Seiko Epson C17 family";
2221 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2222 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2223 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2224 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2225 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2226 case EM_R32C: return "Renesas R32C series microprocessors";
2227 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2228 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2229 case EM_8051: return "Intel 8051 and variants";
2230 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2231 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2232 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2233 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2234 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2235 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2236 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2237 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2238 case EM_CR16:
f6c1a2d5 2239 case EM_MICROBLAZE:
7ba29e2a 2240 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2241 case EM_RL78: return "Renesas RL78";
c7927a3c 2242 case EM_RX: return "Renesas RX";
a3c62988 2243 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2244 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2245 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2246 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2247 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2248 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2249 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2250 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2251 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2252 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2253 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2254 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2255 default:
35d9dd2f 2256 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2257 return buff;
2258 }
2259}
2260
f3485b74 2261static void
d3ba0551 2262decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2263{
2264 unsigned eabi;
2265 int unknown = 0;
2266
2267 eabi = EF_ARM_EABI_VERSION (e_flags);
2268 e_flags &= ~ EF_ARM_EABIMASK;
2269
2270 /* Handle "generic" ARM flags. */
2271 if (e_flags & EF_ARM_RELEXEC)
2272 {
2273 strcat (buf, ", relocatable executable");
2274 e_flags &= ~ EF_ARM_RELEXEC;
2275 }
76da6bbe 2276
f3485b74
NC		 2277 /* Now handle EABI specific flags. */
2278 switch (eabi)
2279 {
2280 default:
2c71103e 2281 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2282 if (e_flags)
2283 unknown = 1;
2284 break;
2285
2286 case EF_ARM_EABI_VER1:
a5bcd848 2287 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2288 while (e_flags)
2289 {
2290 unsigned flag;
76da6bbe 2291
f3485b74
NC		 2292 /* Process flags one bit at a time. */
2293 flag = e_flags & - e_flags;
2294 e_flags &= ~ flag;
76da6bbe 2295
f3485b74
NC		 2296 switch (flag)
2297 {
a5bcd848 2298 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2299 strcat (buf, ", sorted symbol tables");
2300 break;
76da6bbe 2301
f3485b74
NC		 2302 default:
2303 unknown = 1;
2304 break;
2305 }
2306 }
2307 break;
76da6bbe 2308
a5bcd848
PB		 2309 case EF_ARM_EABI_VER2:
2310 strcat (buf, ", Version2 EABI");
2311 while (e_flags)
2312 {
2313 unsigned flag;
2314
2315 /* Process flags one bit at a time. */
2316 flag = e_flags & - e_flags;
2317 e_flags &= ~ flag;
2318
2319 switch (flag)
2320 {
2321 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2322 strcat (buf, ", sorted symbol tables");
2323 break;
2324
2325 case EF_ARM_DYNSYMSUSESEGIDX:
2326 strcat (buf, ", dynamic symbols use segment index");
2327 break;
2328
2329 case EF_ARM_MAPSYMSFIRST:
2330 strcat (buf, ", mapping symbols precede others");
2331 break;
2332
2333 default:
2334 unknown = 1;
2335 break;
2336 }
2337 }
2338 break;
2339
d507cf36
PB		 2340 case EF_ARM_EABI_VER3:
2341 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2342 break;
2343
2344 case EF_ARM_EABI_VER4:
2345 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2346 while (e_flags)
2347 {
2348 unsigned flag;
2349
2350 /* Process flags one bit at a time. */
2351 flag = e_flags & - e_flags;
2352 e_flags &= ~ flag;
2353
2354 switch (flag)
2355 {
2356 case EF_ARM_BE8:
2357 strcat (buf, ", BE8");
2358 break;
2359
2360 case EF_ARM_LE8:
2361 strcat (buf, ", LE8");
2362 break;
2363
2364 default:
2365 unknown = 1;
2366 break;
2367 }
2368 break;
2369 }
2370 break;
3a4a14e9
PB		 2371
2372 case EF_ARM_EABI_VER5:
2373 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2374 while (e_flags)
2375 {
2376 unsigned flag;
2377
2378 /* Process flags one bit at a time. */
2379 flag = e_flags & - e_flags;
2380 e_flags &= ~ flag;
2381
2382 switch (flag)
2383 {
2384 case EF_ARM_BE8:
2385 strcat (buf, ", BE8");
2386 break;
2387
2388 case EF_ARM_LE8:
2389 strcat (buf, ", LE8");
2390 break;
2391
3bfcb652
NC		 2392 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2393 strcat (buf, ", soft-float ABI");
2394 break;
2395
2396 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2397 strcat (buf, ", hard-float ABI");
2398 break;
2399
d507cf36
PB		 2400 default:
2401 unknown = 1;
2402 break;
2403 }
2404 }
2405 break;
2406
f3485b74 2407 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2408 strcat (buf, ", GNU EABI");
f3485b74
NC		 2409 while (e_flags)
2410 {
2411 unsigned flag;
76da6bbe 2412
f3485b74
NC		 2413 /* Process flags one bit at a time. */
2414 flag = e_flags & - e_flags;
2415 e_flags &= ~ flag;
76da6bbe 2416
f3485b74
NC		 2417 switch (flag)
2418 {
a5bcd848 2419 case EF_ARM_INTERWORK:
f3485b74
NC		 2420 strcat (buf, ", interworking enabled");
2421 break;
76da6bbe 2422
a5bcd848 2423 case EF_ARM_APCS_26:
f3485b74
NC		 2424 strcat (buf, ", uses APCS/26");
2425 break;
76da6bbe 2426
a5bcd848 2427 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2428 strcat (buf, ", uses APCS/float");
2429 break;
76da6bbe 2430
a5bcd848 2431 case EF_ARM_PIC:
f3485b74
NC		 2432 strcat (buf, ", position independent");
2433 break;
76da6bbe 2434
a5bcd848 2435 case EF_ARM_ALIGN8:
f3485b74
NC		 2436 strcat (buf, ", 8 bit structure alignment");
2437 break;
76da6bbe 2438
a5bcd848 2439 case EF_ARM_NEW_ABI:
f3485b74
NC		 2440 strcat (buf, ", uses new ABI");
2441 break;
76da6bbe 2442
a5bcd848 2443 case EF_ARM_OLD_ABI:
f3485b74
NC		 2444 strcat (buf, ", uses old ABI");
2445 break;
76da6bbe 2446
a5bcd848 2447 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2448 strcat (buf, ", software FP");
2449 break;
76da6bbe 2450
90e01f86
ILT		 2451 case EF_ARM_VFP_FLOAT:
2452 strcat (buf, ", VFP");
2453 break;
2454
fde78edd
NC		 2455 case EF_ARM_MAVERICK_FLOAT:
2456 strcat (buf, ", Maverick FP");
2457 break;
2458
f3485b74
NC		 2459 default:
2460 unknown = 1;
2461 break;
2462 }
2463 }
2464 }
f3485b74
NC		 2465
2466 if (unknown)
2b692964 2467 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2468}
2469
343433df
AB		 2470static void
2471decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2472{
2473 --size; /* Leave space for null terminator. */
2474
2475 switch (e_flags & EF_AVR_MACH)
2476 {
2477 case E_AVR_MACH_AVR1:
2478 strncat (buf, ", avr:1", size);
2479 break;
2480 case E_AVR_MACH_AVR2:
2481 strncat (buf, ", avr:2", size);
2482 break;
2483 case E_AVR_MACH_AVR25:
2484 strncat (buf, ", avr:25", size);
2485 break;
2486 case E_AVR_MACH_AVR3:
2487 strncat (buf, ", avr:3", size);
2488 break;
2489 case E_AVR_MACH_AVR31:
2490 strncat (buf, ", avr:31", size);
2491 break;
2492 case E_AVR_MACH_AVR35:
2493 strncat (buf, ", avr:35", size);
2494 break;
2495 case E_AVR_MACH_AVR4:
2496 strncat (buf, ", avr:4", size);
2497 break;
2498 case E_AVR_MACH_AVR5:
2499 strncat (buf, ", avr:5", size);
2500 break;
2501 case E_AVR_MACH_AVR51:
2502 strncat (buf, ", avr:51", size);
2503 break;
2504 case E_AVR_MACH_AVR6:
2505 strncat (buf, ", avr:6", size);
2506 break;
2507 case E_AVR_MACH_AVRTINY:
2508 strncat (buf, ", avr:100", size);
2509 break;
2510 case E_AVR_MACH_XMEGA1:
2511 strncat (buf, ", avr:101", size);
2512 break;
2513 case E_AVR_MACH_XMEGA2:
2514 strncat (buf, ", avr:102", size);
2515 break;
2516 case E_AVR_MACH_XMEGA3:
2517 strncat (buf, ", avr:103", size);
2518 break;
2519 case E_AVR_MACH_XMEGA4:
2520 strncat (buf, ", avr:104", size);
2521 break;
2522 case E_AVR_MACH_XMEGA5:
2523 strncat (buf, ", avr:105", size);
2524 break;
2525 case E_AVR_MACH_XMEGA6:
2526 strncat (buf, ", avr:106", size);
2527 break;
2528 case E_AVR_MACH_XMEGA7:
2529 strncat (buf, ", avr:107", size);
2530 break;
2531 default:
2532 strncat (buf, ", avr:<unknown>", size);
2533 break;
2534 }
2535
2536 size -= strlen (buf);
2537 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2538 strncat (buf, ", link-relax", size);
2539}
2540
35c08157
KLC		 2541static void
2542decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2543{
2544 unsigned abi;
2545 unsigned arch;
2546 unsigned config;
2547 unsigned version;
2548 int has_fpu = 0;
2549 int r = 0;
2550
2551 static const char *ABI_STRINGS[] =
2552 {
2553 "ABI v0", /* use r5 as return register; only used in N1213HC */
2554 "ABI v1", /* use r0 as return register */
2555 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2556 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2557 "AABI",
2558 "ABI2 FP+"
35c08157
KLC		 2559 };
2560 static const char *VER_STRINGS[] =
2561 {
2562 "Andes ELF V1.3 or older",
2563 "Andes ELF V1.3.1",
2564 "Andes ELF V1.4"
2565 };
2566 static const char *ARCH_STRINGS[] =
2567 {
2568 "",
2569 "Andes Star v1.0",
2570 "Andes Star v2.0",
2571 "Andes Star v3.0",
2572 "Andes Star v3.0m"
2573 };
2574
2575 abi = EF_NDS_ABI & e_flags;
2576 arch = EF_NDS_ARCH & e_flags;
2577 config = EF_NDS_INST & e_flags;
2578 version = EF_NDS32_ELF_VERSION & e_flags;
2579
2580 memset (buf, 0, size);
2581
2582 switch (abi)
2583 {
2584 case E_NDS_ABI_V0:
2585 case E_NDS_ABI_V1:
2586 case E_NDS_ABI_V2:
2587 case E_NDS_ABI_V2FP:
2588 case E_NDS_ABI_AABI:
40c7a7cb 2589 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2590 /* In case there are holes in the array. */
2591 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2592 break;
2593
2594 default:
2595 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2596 break;
2597 }
2598
2599 switch (version)
2600 {
2601 case E_NDS32_ELF_VER_1_2:
2602 case E_NDS32_ELF_VER_1_3:
2603 case E_NDS32_ELF_VER_1_4:
2604 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2605 break;
2606
2607 default:
2608 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2609 break;
2610 }
2611
2612 if (E_NDS_ABI_V0 == abi)
2613 {
2614 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2615 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2616 if (arch == E_NDS_ARCH_STAR_V1_0)
2617 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2618 return;
2619 }
2620
2621 switch (arch)
2622 {
2623 case E_NDS_ARCH_STAR_V1_0:
2624 case E_NDS_ARCH_STAR_V2_0:
2625 case E_NDS_ARCH_STAR_V3_0:
2626 case E_NDS_ARCH_STAR_V3_M:
2627 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2628 break;
2629
2630 default:
2631 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2632 /* ARCH version determines how the e_flags are interpreted.
2633 If it is unknown, we cannot proceed. */
2634 return;
2635 }
2636
2637 /* Newer ABI; Now handle architecture specific flags. */
2638 if (arch == E_NDS_ARCH_STAR_V1_0)
2639 {
2640 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2641 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2642
2643 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2644 r += snprintf (buf + r, size -r, ", MAC");
2645
2646 if (config & E_NDS32_HAS_DIV_INST)
2647 r += snprintf (buf + r, size -r, ", DIV");
2648
2649 if (config & E_NDS32_HAS_16BIT_INST)
2650 r += snprintf (buf + r, size -r, ", 16b");
2651 }
2652 else
2653 {
2654 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2655 {
2656 if (version <= E_NDS32_ELF_VER_1_3)
2657 r += snprintf (buf + r, size -r, ", [B8]");
2658 else
2659 r += snprintf (buf + r, size -r, ", EX9");
2660 }
2661
2662 if (config & E_NDS32_HAS_MAC_DX_INST)
2663 r += snprintf (buf + r, size -r, ", MAC_DX");
2664
2665 if (config & E_NDS32_HAS_DIV_DX_INST)
2666 r += snprintf (buf + r, size -r, ", DIV_DX");
2667
2668 if (config & E_NDS32_HAS_16BIT_INST)
2669 {
2670 if (version <= E_NDS32_ELF_VER_1_3)
2671 r += snprintf (buf + r, size -r, ", 16b");
2672 else
2673 r += snprintf (buf + r, size -r, ", IFC");
2674 }
2675 }
2676
2677 if (config & E_NDS32_HAS_EXT_INST)
2678 r += snprintf (buf + r, size -r, ", PERF1");
2679
2680 if (config & E_NDS32_HAS_EXT2_INST)
2681 r += snprintf (buf + r, size -r, ", PERF2");
2682
2683 if (config & E_NDS32_HAS_FPU_INST)
2684 {
2685 has_fpu = 1;
2686 r += snprintf (buf + r, size -r, ", FPU_SP");
2687 }
2688
2689 if (config & E_NDS32_HAS_FPU_DP_INST)
2690 {
2691 has_fpu = 1;
2692 r += snprintf (buf + r, size -r, ", FPU_DP");
2693 }
2694
2695 if (config & E_NDS32_HAS_FPU_MAC_INST)
2696 {
2697 has_fpu = 1;
2698 r += snprintf (buf + r, size -r, ", FPU_MAC");
2699 }
2700
2701 if (has_fpu)
2702 {
2703 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2704 {
2705 case E_NDS32_FPU_REG_8SP_4DP:
2706 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2707 break;
2708 case E_NDS32_FPU_REG_16SP_8DP:
2709 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2710 break;
2711 case E_NDS32_FPU_REG_32SP_16DP:
2712 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2713 break;
2714 case E_NDS32_FPU_REG_32SP_32DP:
2715 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2716 break;
2717 }
2718 }
2719
2720 if (config & E_NDS32_HAS_AUDIO_INST)
2721 r += snprintf (buf + r, size -r, ", AUDIO");
2722
2723 if (config & E_NDS32_HAS_STRING_INST)
2724 r += snprintf (buf + r, size -r, ", STR");
2725
2726 if (config & E_NDS32_HAS_REDUCED_REGS)
2727 r += snprintf (buf + r, size -r, ", 16REG");
2728
2729 if (config & E_NDS32_HAS_VIDEO_INST)
2730 {
2731 if (version <= E_NDS32_ELF_VER_1_3)
2732 r += snprintf (buf + r, size -r, ", VIDEO");
2733 else
2734 r += snprintf (buf + r, size -r, ", SATURATION");
2735 }
2736
2737 if (config & E_NDS32_HAS_ENCRIPT_INST)
2738 r += snprintf (buf + r, size -r, ", ENCRP");
2739
2740 if (config & E_NDS32_HAS_L2C_INST)
2741 r += snprintf (buf + r, size -r, ", L2C");
2742}
2743
252b5132 2744static char *
d3ba0551 2745get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2746{
b34976b6 2747 static char buf[1024];
252b5132
RH		 2748
2749 buf[0] = '\0';
76da6bbe 2750
252b5132
RH		 2751 if (e_flags)
2752 {
2753 switch (e_machine)
2754 {
2755 default:
2756 break;
2757
f3485b74
NC		 2758 case EM_ARM:
2759 decode_ARM_machine_flags (e_flags, buf);
2760 break;
76da6bbe 2761
343433df
AB		 2762 case EM_AVR:
2763 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2764 break;
2765
781303ce
MF		 2766 case EM_BLACKFIN:
2767 if (e_flags & EF_BFIN_PIC)
2768 strcat (buf, ", PIC");
2769
2770 if (e_flags & EF_BFIN_FDPIC)
2771 strcat (buf, ", FDPIC");
2772
2773 if (e_flags & EF_BFIN_CODE_IN_L1)
2774 strcat (buf, ", code in L1");
2775
2776 if (e_flags & EF_BFIN_DATA_IN_L1)
2777 strcat (buf, ", data in L1");
2778
2779 break;
2780
ec2dfb42
AO		 2781 case EM_CYGNUS_FRV:
2782 switch (e_flags & EF_FRV_CPU_MASK)
2783 {
2784 case EF_FRV_CPU_GENERIC:
2785 break;
2786
2787 default:
2788 strcat (buf, ", fr???");
2789 break;
57346661 2790
ec2dfb42
AO		 2791 case EF_FRV_CPU_FR300:
2792 strcat (buf, ", fr300");
2793 break;
2794
2795 case EF_FRV_CPU_FR400:
2796 strcat (buf, ", fr400");
2797 break;
2798 case EF_FRV_CPU_FR405:
2799 strcat (buf, ", fr405");
2800 break;
2801
2802 case EF_FRV_CPU_FR450:
2803 strcat (buf, ", fr450");
2804 break;
2805
2806 case EF_FRV_CPU_FR500:
2807 strcat (buf, ", fr500");
2808 break;
2809 case EF_FRV_CPU_FR550:
2810 strcat (buf, ", fr550");
2811 break;
2812
2813 case EF_FRV_CPU_SIMPLE:
2814 strcat (buf, ", simple");
2815 break;
2816 case EF_FRV_CPU_TOMCAT:
2817 strcat (buf, ", tomcat");
2818 break;
2819 }
1c877e87 2820 break;
ec2dfb42 2821
53c7db4b 2822 case EM_68K:
425c6cb0 2823 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2824 strcat (buf, ", m68000");
425c6cb0 2825 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2826 strcat (buf, ", cpu32");
2827 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2828 strcat (buf, ", fido_a");
425c6cb0 2829 else
266abb8f 2830 {
2cf0635d
NC		 2831 char const * isa = _("unknown");
2832 char const * mac = _("unknown mac");
2833 char const * additional = NULL;
0112cd26 2834
c694fd50 2835 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2836 {
c694fd50 2837 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2838 isa = "A";
2839 additional = ", nodiv";
2840 break;
c694fd50 2841 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2842 isa = "A";
2843 break;
c694fd50 2844 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2845 isa = "A+";
2846 break;
c694fd50 2847 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2848 isa = "B";
2849 additional = ", nousp";
2850 break;
c694fd50 2851 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2852 isa = "B";
2853 break;
f608cd77
NS		 2854 case EF_M68K_CF_ISA_C:
2855 isa = "C";
2856 break;
2857 case EF_M68K_CF_ISA_C_NODIV:
2858 isa = "C";
2859 additional = ", nodiv";
2860 break;
266abb8f
NS		 2861 }
2862 strcat (buf, ", cf, isa ");
2863 strcat (buf, isa);
0b2e31dc
NS		 2864 if (additional)
2865 strcat (buf, additional);
c694fd50 2866 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2867 strcat (buf, ", float");
c694fd50 2868 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2869 {
2870 case 0:
2871 mac = NULL;
2872 break;
c694fd50 2873 case EF_M68K_CF_MAC:
266abb8f
NS		 2874 mac = "mac";
2875 break;
c694fd50 2876 case EF_M68K_CF_EMAC:
266abb8f
NS		 2877 mac = "emac";
2878 break;
f608cd77
NS		 2879 case EF_M68K_CF_EMAC_B:
2880 mac = "emac_b";
2881 break;
266abb8f
NS		 2882 }
2883 if (mac)
2884 {
2885 strcat (buf, ", ");
2886 strcat (buf, mac);
2887 }
266abb8f 2888 }
53c7db4b 2889 break;
33c63f9d 2890
153a2776
NC		 2891 case EM_CYGNUS_MEP:
2892 switch (e_flags & EF_MEP_CPU_MASK)
2893 {
2894 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2895 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2896 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2897 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2898 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2899 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2900 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2901 }
2902
2903 switch (e_flags & EF_MEP_COP_MASK)
2904 {
2905 case EF_MEP_COP_NONE: break;
2906 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2907 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2908 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2909 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2910 default: strcat (buf, _("<unknown MeP copro type>")); break;
2911 }
2912
2913 if (e_flags & EF_MEP_LIBRARY)
2914 strcat (buf, ", Built for Library");
2915
2916 if (e_flags & EF_MEP_INDEX_MASK)
2917 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2918 e_flags & EF_MEP_INDEX_MASK);
2919
2920 if (e_flags & ~ EF_MEP_ALL_FLAGS)
2921 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2922 e_flags & ~ EF_MEP_ALL_FLAGS);
2923 break;
2924
252b5132
RH		 2925 case EM_PPC:
2926 if (e_flags & EF_PPC_EMB)
2927 strcat (buf, ", emb");
2928
2929 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2930 strcat (buf, _(", relocatable"));
252b5132
RH		 2931
2932 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2933 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2934 break;
2935
ee67d69a
AM		 2936 case EM_PPC64:
2937 if (e_flags & EF_PPC64_ABI)
2938 {
2939 char abi[] = ", abiv0";
2940
2941 abi[6] += e_flags & EF_PPC64_ABI;
2942 strcat (buf, abi);
2943 }
2944 break;
2945
708e2187
NC		 2946 case EM_V800:
2947 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2948 strcat (buf, ", RH850 ABI");
0b4362b0 2949
708e2187
NC		 2950 if (e_flags & EF_V800_850E3)
2951 strcat (buf, ", V3 architecture");
2952
2953 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2954 strcat (buf, ", FPU not used");
2955
2956 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2957 strcat (buf, ", regmode: COMMON");
2958
2959 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2960 strcat (buf, ", r4 not used");
2961
2962 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2963 strcat (buf, ", r30 not used");
2964
2965 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2966 strcat (buf, ", r5 not used");
2967
2968 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2969 strcat (buf, ", r2 not used");
2970
2971 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2972 {
2973 switch (e_flags & - e_flags)
2974 {
2975 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2976 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2977 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2978 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2979 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2980 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2981 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2982 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2983 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2984 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2985 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2986 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2987 default: break;
2988 }
2989 }
2990 break;
2991
2b0337b0 2992 case EM_V850:
252b5132
RH		 2993 case EM_CYGNUS_V850:
2994 switch (e_flags & EF_V850_ARCH)
2995 {
78c8d46c
NC		 2996 case E_V850E3V5_ARCH:
2997 strcat (buf, ", v850e3v5");
2998 break;
1cd986c5
NC		 2999 case E_V850E2V3_ARCH:
3000 strcat (buf, ", v850e2v3");
3001 break;
3002 case E_V850E2_ARCH:
3003 strcat (buf, ", v850e2");
3004 break;
3005 case E_V850E1_ARCH:
3006 strcat (buf, ", v850e1");
8ad30312 3007 break;
252b5132
RH		 3008 case E_V850E_ARCH:
3009 strcat (buf, ", v850e");
3010 break;
252b5132
RH		 3011 case E_V850_ARCH:
3012 strcat (buf, ", v850");
3013 break;
3014 default:
2b692964 3015 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3016 break;
3017 }
3018 break;
3019
2b0337b0 3020 case EM_M32R:
252b5132
RH		 3021 case EM_CYGNUS_M32R:
3022 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3023 strcat (buf, ", m32r");
252b5132
RH		 3024 break;
3025
3026 case EM_MIPS:
4fe85591 3027 case EM_MIPS_RS3_LE:
252b5132
RH		 3028 if (e_flags & EF_MIPS_NOREORDER)
3029 strcat (buf, ", noreorder");
3030
3031 if (e_flags & EF_MIPS_PIC)
3032 strcat (buf, ", pic");
3033
3034 if (e_flags & EF_MIPS_CPIC)
3035 strcat (buf, ", cpic");
3036
d1bdd336
TS		 3037 if (e_flags & EF_MIPS_UCODE)
3038 strcat (buf, ", ugen_reserved");
3039
252b5132
RH		 3040 if (e_flags & EF_MIPS_ABI2)
3041 strcat (buf, ", abi2");
3042
43521d43
TS		 3043 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3044 strcat (buf, ", odk first");
3045
a5d22d2a
TS		 3046 if (e_flags & EF_MIPS_32BITMODE)
3047 strcat (buf, ", 32bitmode");
3048
ba92f887
MR		 3049 if (e_flags & EF_MIPS_NAN2008)
3050 strcat (buf, ", nan2008");
3051
fef1b0b3
SE		 3052 if (e_flags & EF_MIPS_FP64)
3053 strcat (buf, ", fp64");
3054
156c2f8b
NC		 3055 switch ((e_flags & EF_MIPS_MACH))
3056 {
3057 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3058 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3059 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3060 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3061 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3062 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3063 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3064 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3065 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3066 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3067 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3068 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3069 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3070 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3071 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3072 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3073 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3074 case 0:
3075 /* We simply ignore the field in this case to avoid confusion:
3076 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3077 extension. */
3078 break;
2b692964 3079 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3080 }
43521d43
TS		 3081
3082 switch ((e_flags & EF_MIPS_ABI))
3083 {
3084 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3085 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3086 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3087 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3088 case 0:
3089 /* We simply ignore the field in this case to avoid confusion:
3090 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3091 This means it is likely to be an o32 file, but not for
3092 sure. */
3093 break;
2b692964 3094 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3095 }
3096
3097 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3098 strcat (buf, ", mdmx");
3099
3100 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3101 strcat (buf, ", mips16");
3102
df58fc94
RS		 3103 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3104 strcat (buf, ", micromips");
3105
43521d43
TS		 3106 switch ((e_flags & EF_MIPS_ARCH))
3107 {
3108 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3109 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3110 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3111 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3112 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3113 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3114 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3115 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3116 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3117 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3118 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3119 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3120 }
252b5132 3121 break;
351b4b40 3122
35c08157
KLC		 3123 case EM_NDS32:
3124 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3125 break;
3126
ccde1100
AO		 3127 case EM_SH:
3128 switch ((e_flags & EF_SH_MACH_MASK))
3129 {
3130 case EF_SH1: strcat (buf, ", sh1"); break;
3131 case EF_SH2: strcat (buf, ", sh2"); break;
3132 case EF_SH3: strcat (buf, ", sh3"); break;
3133 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3134 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3135 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3136 case EF_SH3E: strcat (buf, ", sh3e"); break;
3137 case EF_SH4: strcat (buf, ", sh4"); break;
3138 case EF_SH5: strcat (buf, ", sh5"); break;
3139 case EF_SH2E: strcat (buf, ", sh2e"); break;
3140 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3141 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3142 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3143 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3144 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3145 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3146 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3147 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3148 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3149 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3150 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3151 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3152 }
3153
cec6a5b8
MR		 3154 if (e_flags & EF_SH_PIC)
3155 strcat (buf, ", pic");
3156
3157 if (e_flags & EF_SH_FDPIC)
3158 strcat (buf, ", fdpic");
ccde1100 3159 break;
948f632f 3160
73589c9d
CS		 3161 case EM_OR1K:
3162 if (e_flags & EF_OR1K_NODELAY)
3163 strcat (buf, ", no delay");
3164 break;
57346661 3165
351b4b40
RH		 3166 case EM_SPARCV9:
3167 if (e_flags & EF_SPARC_32PLUS)
3168 strcat (buf, ", v8+");
3169
3170 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3171 strcat (buf, ", ultrasparcI");
3172
3173 if (e_flags & EF_SPARC_SUN_US3)
3174 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3175
3176 if (e_flags & EF_SPARC_HAL_R1)
3177 strcat (buf, ", halr1");
3178
3179 if (e_flags & EF_SPARC_LEDATA)
3180 strcat (buf, ", ledata");
3181
3182 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3183 strcat (buf, ", tso");
3184
3185 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3186 strcat (buf, ", pso");
3187
3188 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3189 strcat (buf, ", rmo");
3190 break;
7d466069 3191
103f02d3
UD		 3192 case EM_PARISC:
3193 switch (e_flags & EF_PARISC_ARCH)
3194 {
3195 case EFA_PARISC_1_0:
3196 strcpy (buf, ", PA-RISC 1.0");
3197 break;
3198 case EFA_PARISC_1_1:
3199 strcpy (buf, ", PA-RISC 1.1");
3200 break;
3201 case EFA_PARISC_2_0:
3202 strcpy (buf, ", PA-RISC 2.0");
3203 break;
3204 default:
3205 break;
3206 }
3207 if (e_flags & EF_PARISC_TRAPNIL)
3208 strcat (buf, ", trapnil");
3209 if (e_flags & EF_PARISC_EXT)
3210 strcat (buf, ", ext");
3211 if (e_flags & EF_PARISC_LSB)
3212 strcat (buf, ", lsb");
3213 if (e_flags & EF_PARISC_WIDE)
3214 strcat (buf, ", wide");
3215 if (e_flags & EF_PARISC_NO_KABP)
3216 strcat (buf, ", no kabp");
3217 if (e_flags & EF_PARISC_LAZYSWAP)
3218 strcat (buf, ", lazyswap");
30800947 3219 break;
76da6bbe 3220
7d466069 3221 case EM_PJ:
2b0337b0 3222 case EM_PJ_OLD:
7d466069
ILT		 3223 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3224 strcat (buf, ", new calling convention");
3225
3226 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3227 strcat (buf, ", gnu calling convention");
3228 break;
4d6ed7c8
NC		 3229
3230 case EM_IA_64:
3231 if ((e_flags & EF_IA_64_ABI64))
3232 strcat (buf, ", 64-bit");
3233 else
3234 strcat (buf, ", 32-bit");
3235 if ((e_flags & EF_IA_64_REDUCEDFP))
3236 strcat (buf, ", reduced fp model");
3237 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3238 strcat (buf, ", no function descriptors, constant gp");
3239 else if ((e_flags & EF_IA_64_CONS_GP))
3240 strcat (buf, ", constant gp");
3241 if ((e_flags & EF_IA_64_ABSOLUTE))
3242 strcat (buf, ", absolute");
28f997cf
TG		 3243 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3244 {
3245 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3246 strcat (buf, ", vms_linkages");
3247 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3248 {
3249 case EF_IA_64_VMS_COMCOD_SUCCESS:
3250 break;
3251 case EF_IA_64_VMS_COMCOD_WARNING:
3252 strcat (buf, ", warning");
3253 break;
3254 case EF_IA_64_VMS_COMCOD_ERROR:
3255 strcat (buf, ", error");
3256 break;
3257 case EF_IA_64_VMS_COMCOD_ABORT:
3258 strcat (buf, ", abort");
3259 break;
3260 default:
bee0ee85
NC		 3261 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3262 e_flags & EF_IA_64_VMS_COMCOD);
3263 strcat (buf, ", <unknown>");
28f997cf
TG		 3264 }
3265 }
4d6ed7c8 3266 break;
179d3252
JT		 3267
3268 case EM_VAX:
3269 if ((e_flags & EF_VAX_NONPIC))
3270 strcat (buf, ", non-PIC");
3271 if ((e_flags & EF_VAX_DFLOAT))
3272 strcat (buf, ", D-Float");
3273 if ((e_flags & EF_VAX_GFLOAT))
3274 strcat (buf, ", G-Float");
3275 break;
c7927a3c 3276
619ed720
EB		 3277 case EM_VISIUM:
3278 if (e_flags & EF_VISIUM_ARCH_MCM)
3279 strcat (buf, ", mcm");
3280 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3281 strcat (buf, ", mcm24");
3282 if (e_flags & EF_VISIUM_ARCH_GR6)
3283 strcat (buf, ", gr6");
3284 break;
3285
4046d87a 3286 case EM_RL78:
1740ba0c
NC		 3287 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3288 {
3289 case E_FLAG_RL78_ANY_CPU: break;
3290 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3291 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3292 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3293 }
856ea05c
KP		 3294 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3295 strcat (buf, ", 64-bit doubles");
4046d87a 3296 break;
0b4362b0 3297
c7927a3c
NC		 3298 case EM_RX:
3299 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3300 strcat (buf, ", 64-bit doubles");
3301 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3302 strcat (buf, ", dsp");
d4cb0ea0 3303 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3304 strcat (buf, ", pid");
708e2187
NC		 3305 if (e_flags & E_FLAG_RX_ABI)
3306 strcat (buf, ", RX ABI");
3525236c
NC		 3307 if (e_flags & E_FLAG_RX_SINSNS_SET)
3308 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3309 ? ", uses String instructions" : ", bans String instructions");
d4cb0ea0 3310 break;
55786da2
AK		 3311
3312 case EM_S390:
3313 if (e_flags & EF_S390_HIGH_GPRS)
3314 strcat (buf, ", highgprs");
d4cb0ea0 3315 break;
40b36596
JM		 3316
3317 case EM_TI_C6000:
3318 if ((e_flags & EF_C6000_REL))
3319 strcat (buf, ", relocatable module");
d4cb0ea0 3320 break;
13761a11
NC		 3321
3322 case EM_MSP430:
3323 strcat (buf, _(": architecture variant: "));
3324 switch (e_flags & EF_MSP430_MACH)
3325 {
3326 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3327 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3328 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3329 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3330 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3331 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3332 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3333 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3334 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3335 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3336 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3337 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3338 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3339 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3340 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3341 default:
3342 strcat (buf, _(": unknown")); break;
3343 }
3344
3345 if (e_flags & ~ EF_MSP430_MACH)
3346 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3347 }
3348 }
3349
3350 return buf;
3351}
3352
252b5132 3353static const char *
d3ba0551
AM		 3354get_osabi_name (unsigned int osabi)
3355{
3356 static char buff[32];
3357
3358 switch (osabi)
3359 {
3360 case ELFOSABI_NONE: return "UNIX - System V";
3361 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3362 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3363 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3364 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3365 case ELFOSABI_AIX: return "UNIX - AIX";
3366 case ELFOSABI_IRIX: return "UNIX - IRIX";
3367 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3368 case ELFOSABI_TRU64: return "UNIX - TRU64";
3369 case ELFOSABI_MODESTO: return "Novell - Modesto";
3370 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3371 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3372 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3373 case ELFOSABI_AROS: return "AROS";
11636f9e 3374 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3375 default:
40b36596
JM		 3376 if (osabi >= 64)
3377 switch (elf_header.e_machine)
3378 {
3379 case EM_ARM:
3380 switch (osabi)
3381 {
3382 case ELFOSABI_ARM: return "ARM";
3383 default:
3384 break;
3385 }
3386 break;
3387
3388 case EM_MSP430:
3389 case EM_MSP430_OLD:
619ed720 3390 case EM_VISIUM:
40b36596
JM		 3391 switch (osabi)
3392 {
3393 case ELFOSABI_STANDALONE: return _("Standalone App");
3394 default:
3395 break;
3396 }
3397 break;
3398
3399 case EM_TI_C6000:
3400 switch (osabi)
3401 {
3402 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3403 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3404 default:
3405 break;
3406 }
3407 break;
3408
3409 default:
3410 break;
3411 }
e9e44622 3412 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3413 return buff;
3414 }
3415}
3416
a06ea964
NC		 3417static const char *
3418get_aarch64_segment_type (unsigned long type)
3419{
3420 switch (type)
3421 {
3422 case PT_AARCH64_ARCHEXT:
3423 return "AARCH64_ARCHEXT";
3424 default:
3425 break;
3426 }
3427
3428 return NULL;
3429}
3430
b294bdf8
MM		 3431static const char *
3432get_arm_segment_type (unsigned long type)
3433{
3434 switch (type)
3435 {
3436 case PT_ARM_EXIDX:
3437 return "EXIDX";
3438 default:
3439 break;
3440 }
3441
3442 return NULL;
3443}
3444
d3ba0551
AM		 3445static const char *
3446get_mips_segment_type (unsigned long type)
252b5132
RH		 3447{
3448 switch (type)
3449 {
3450 case PT_MIPS_REGINFO:
3451 return "REGINFO";
3452 case PT_MIPS_RTPROC:
3453 return "RTPROC";
3454 case PT_MIPS_OPTIONS:
3455 return "OPTIONS";
351cdf24
MF		 3456 case PT_MIPS_ABIFLAGS:
3457 return "ABIFLAGS";
252b5132
RH		 3458 default:
3459 break;
3460 }
3461
3462 return NULL;
3463}
3464
103f02d3 3465static const char *
d3ba0551 3466get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3467{
3468 switch (type)
3469 {
3470 case PT_HP_TLS: return "HP_TLS";
3471 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3472 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3473 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3474 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3475 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3476 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3477 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3478 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3479 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3480 case PT_HP_PARALLEL: return "HP_PARALLEL";
3481 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3482 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3483 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3484 case PT_HP_STACK: return "HP_STACK";
3485 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3486 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3487 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3488 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3489 default:
3490 break;
3491 }
3492
3493 return NULL;
3494}
3495
4d6ed7c8 3496static const char *
d3ba0551 3497get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3498{
3499 switch (type)
3500 {
3501 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3502 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3503 case PT_HP_TLS: return "HP_TLS";
3504 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3505 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3506 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3507 default:
3508 break;
3509 }
3510
3511 return NULL;
3512}
3513
40b36596
JM		 3514static const char *
3515get_tic6x_segment_type (unsigned long type)
3516{
3517 switch (type)
3518 {
3519 case PT_C6000_PHATTR: return "C6000_PHATTR";
3520 default:
3521 break;
3522 }
3523
3524 return NULL;
3525}
3526
252b5132 3527static const char *
d3ba0551 3528get_segment_type (unsigned long p_type)
252b5132 3529{
b34976b6 3530 static char buff[32];
252b5132
RH		 3531
3532 switch (p_type)
3533 {
b34976b6
AM		 3534 case PT_NULL: return "NULL";
3535 case PT_LOAD: return "LOAD";
252b5132 3536 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3537 case PT_INTERP: return "INTERP";
3538 case PT_NOTE: return "NOTE";
3539 case PT_SHLIB: return "SHLIB";
3540 case PT_PHDR: return "PHDR";
13ae64f3 3541 case PT_TLS: return "TLS";
252b5132 3542
65765700
JJ		 3543 case PT_GNU_EH_FRAME:
3544 return "GNU_EH_FRAME";
2b05f1b7 3545 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3546 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3547
252b5132
RH		 3548 default:
3549 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3550 {
2cf0635d 3551 const char * result;
103f02d3 3552
252b5132
RH		 3553 switch (elf_header.e_machine)
3554 {
a06ea964
NC		 3555 case EM_AARCH64:
3556 result = get_aarch64_segment_type (p_type);
3557 break;
b294bdf8
MM		 3558 case EM_ARM:
3559 result = get_arm_segment_type (p_type);
3560 break;
252b5132 3561 case EM_MIPS:
4fe85591 3562 case EM_MIPS_RS3_LE:
252b5132
RH		 3563 result = get_mips_segment_type (p_type);
3564 break;
103f02d3
UD		 3565 case EM_PARISC:
3566 result = get_parisc_segment_type (p_type);
3567 break;
4d6ed7c8
NC		 3568 case EM_IA_64:
3569 result = get_ia64_segment_type (p_type);
3570 break;
40b36596
JM		 3571 case EM_TI_C6000:
3572 result = get_tic6x_segment_type (p_type);
3573 break;
252b5132
RH		 3574 default:
3575 result = NULL;
3576 break;
3577 }
103f02d3 3578
252b5132
RH		 3579 if (result != NULL)
3580 return result;
103f02d3 3581
252b5132
RH		 3582 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3583 }
3584 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3585 {
2cf0635d 3586 const char * result;
103f02d3
UD		 3587
3588 switch (elf_header.e_machine)
3589 {
3590 case EM_PARISC:
3591 result = get_parisc_segment_type (p_type);
3592 break;
00428cca
AM		 3593 case EM_IA_64:
3594 result = get_ia64_segment_type (p_type);
3595 break;
103f02d3
UD		 3596 default:
3597 result = NULL;
3598 break;
3599 }
3600
3601 if (result != NULL)
3602 return result;
3603
3604 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3605 }
252b5132 3606 else
e9e44622 3607 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3608
3609 return buff;
3610 }
3611}
3612
3613static const char *
d3ba0551 3614get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3615{
3616 switch (sh_type)
3617 {
b34976b6
AM		 3618 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3619 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3620 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3621 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3622 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3623 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3624 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3625 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3626 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3627 case SHT_MIPS_RELD: return "MIPS_RELD";
3628 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3629 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3630 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3631 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3632 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3633 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3634 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3635 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3636 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3637 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3638 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3639 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3640 case SHT_MIPS_LINE: return "MIPS_LINE";
3641 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3642 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3643 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3644 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3645 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3646 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3647 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3648 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3649 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3650 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3651 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3652 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3653 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3654 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3655 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3656 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3657 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3658 default:
3659 break;
3660 }
3661 return NULL;
3662}
3663
103f02d3 3664static const char *
d3ba0551 3665get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3666{
3667 switch (sh_type)
3668 {
3669 case SHT_PARISC_EXT: return "PARISC_EXT";
3670 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3671 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3672 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3673 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3674 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3675 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3676 default:
3677 break;
3678 }
3679 return NULL;
3680}
3681
4d6ed7c8 3682static const char *
d3ba0551 3683get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3684{
18bd398b 3685 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3686 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3687 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3688
4d6ed7c8
NC		 3689 switch (sh_type)
3690 {
148b93f2
NC		 3691 case SHT_IA_64_EXT: return "IA_64_EXT";
3692 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3693 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3694 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3695 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3696 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3697 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3698 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3699 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3700 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3701 default:
3702 break;
3703 }
3704 return NULL;
3705}
3706
d2b2c203
DJ		 3707static const char *
3708get_x86_64_section_type_name (unsigned int sh_type)
3709{
3710 switch (sh_type)
3711 {
3712 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3713 default:
3714 break;
3715 }
3716 return NULL;
3717}
3718
a06ea964
NC		 3719static const char *
3720get_aarch64_section_type_name (unsigned int sh_type)
3721{
3722 switch (sh_type)
3723 {
3724 case SHT_AARCH64_ATTRIBUTES:
3725 return "AARCH64_ATTRIBUTES";
3726 default:
3727 break;
3728 }
3729 return NULL;
3730}
3731
40a18ebd
NC		 3732static const char *
3733get_arm_section_type_name (unsigned int sh_type)
3734{
3735 switch (sh_type)
3736 {
7f6fed87
NC		 3737 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3738 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3739 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3740 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3741 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3742 default:
3743 break;
3744 }
3745 return NULL;
3746}
3747
40b36596
JM		 3748static const char *
3749get_tic6x_section_type_name (unsigned int sh_type)
3750{
3751 switch (sh_type)
3752 {
3753 case SHT_C6000_UNWIND:
3754 return "C6000_UNWIND";
3755 case SHT_C6000_PREEMPTMAP:
3756 return "C6000_PREEMPTMAP";
3757 case SHT_C6000_ATTRIBUTES:
3758 return "C6000_ATTRIBUTES";
3759 case SHT_TI_ICODE:
3760 return "TI_ICODE";
3761 case SHT_TI_XREF:
3762 return "TI_XREF";
3763 case SHT_TI_HANDLER:
3764 return "TI_HANDLER";
3765 case SHT_TI_INITINFO:
3766 return "TI_INITINFO";
3767 case SHT_TI_PHATTRS:
3768 return "TI_PHATTRS";
3769 default:
3770 break;
3771 }
3772 return NULL;
3773}
3774
13761a11
NC		 3775static const char *
3776get_msp430x_section_type_name (unsigned int sh_type)
3777{
3778 switch (sh_type)
3779 {
3780 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3781 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3782 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3783 default: return NULL;
3784 }
3785}
3786
685080f2
NC		 3787static const char *
3788get_v850_section_type_name (unsigned int sh_type)
3789{
3790 switch (sh_type)
3791 {
3792 case SHT_V850_SCOMMON: return "V850 Small Common";
3793 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3794 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3795 case SHT_RENESAS_IOP: return "RENESAS IOP";
3796 case SHT_RENESAS_INFO: return "RENESAS INFO";
3797 default: return NULL;
3798 }
3799}
3800
252b5132 3801static const char *
d3ba0551 3802get_section_type_name (unsigned int sh_type)
252b5132 3803{
b34976b6 3804 static char buff[32];
252b5132
RH		 3805
3806 switch (sh_type)
3807 {
3808 case SHT_NULL: return "NULL";
3809 case SHT_PROGBITS: return "PROGBITS";
3810 case SHT_SYMTAB: return "SYMTAB";
3811 case SHT_STRTAB: return "STRTAB";
3812 case SHT_RELA: return "RELA";
3813 case SHT_HASH: return "HASH";
3814 case SHT_DYNAMIC: return "DYNAMIC";
3815 case SHT_NOTE: return "NOTE";
3816 case SHT_NOBITS: return "NOBITS";
3817 case SHT_REL: return "REL";
3818 case SHT_SHLIB: return "SHLIB";
3819 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3820 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3821 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3822 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3823 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3824 case SHT_GROUP: return "GROUP";
3825 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3826 case SHT_GNU_verdef: return "VERDEF";
3827 case SHT_GNU_verneed: return "VERNEED";
3828 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3829 case 0x6ffffff0: return "VERSYM";
3830 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3831 case 0x7ffffffd: return "AUXILIARY";
3832 case 0x7fffffff: return "FILTER";
047b2264 3833 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3834
3835 default:
3836 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3837 {
2cf0635d 3838 const char * result;
252b5132
RH		 3839
3840 switch (elf_header.e_machine)
3841 {
3842 case EM_MIPS:
4fe85591 3843 case EM_MIPS_RS3_LE:
252b5132
RH		 3844 result = get_mips_section_type_name (sh_type);
3845 break;
103f02d3
UD		 3846 case EM_PARISC:
3847 result = get_parisc_section_type_name (sh_type);
3848 break;
4d6ed7c8
NC		 3849 case EM_IA_64:
3850 result = get_ia64_section_type_name (sh_type);
3851 break;
d2b2c203 3852 case EM_X86_64:
8a9036a4 3853 case EM_L1OM:
7a9068fe 3854 case EM_K1OM:
d2b2c203
DJ		 3855 result = get_x86_64_section_type_name (sh_type);
3856 break;
a06ea964
NC		 3857 case EM_AARCH64:
3858 result = get_aarch64_section_type_name (sh_type);
3859 break;
40a18ebd
NC		 3860 case EM_ARM:
3861 result = get_arm_section_type_name (sh_type);
3862 break;
40b36596
JM		 3863 case EM_TI_C6000:
3864 result = get_tic6x_section_type_name (sh_type);
3865 break;
13761a11
NC		 3866 case EM_MSP430:
3867 result = get_msp430x_section_type_name (sh_type);
3868 break;
685080f2
NC		 3869 case EM_V800:
3870 case EM_V850:
3871 case EM_CYGNUS_V850:
3872 result = get_v850_section_type_name (sh_type);
3873 break;
252b5132
RH		 3874 default:
3875 result = NULL;
3876 break;
3877 }
3878
3879 if (result != NULL)
3880 return result;
3881
c91d0dfb 3882 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3883 }
3884 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3885 {
2cf0635d 3886 const char * result;
148b93f2
NC		 3887
3888 switch (elf_header.e_machine)
3889 {
3890 case EM_IA_64:
3891 result = get_ia64_section_type_name (sh_type);
3892 break;
3893 default:
3894 result = NULL;
3895 break;
3896 }
3897
3898 if (result != NULL)
3899 return result;
3900
3901 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3902 }
252b5132 3903 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3904 {
3905 switch (elf_header.e_machine)
3906 {
3907 case EM_V800:
3908 case EM_V850:
3909 case EM_CYGNUS_V850:
3910 return get_v850_section_type_name (sh_type);
3911 default:
3912 break;
3913 }
3914
3915 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3916 }
252b5132 3917 else
a7dbfd1c
NC		 3918 /* This message is probably going to be displayed in a 15
3919 character wide field, so put the hex value first. */
3920 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3921
252b5132
RH		 3922 return buff;
3923 }
3924}
3925
2979dc34 3926#define OPTION_DEBUG_DUMP 512
2c610e4b 3927#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3928#define OPTION_DWARF_DEPTH 514
3929#define OPTION_DWARF_START 515
4723351a 3930#define OPTION_DWARF_CHECK 516
2979dc34 3931
85b1c36d 3932static struct option options[] =
252b5132 3933{
b34976b6 3934 {"all", no_argument, 0, 'a'},
252b5132
RH		 3935 {"file-header", no_argument, 0, 'h'},
3936 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3937 {"headers", no_argument, 0, 'e'},
3938 {"histogram", no_argument, 0, 'I'},
3939 {"segments", no_argument, 0, 'l'},
3940 {"sections", no_argument, 0, 'S'},
252b5132 3941 {"section-headers", no_argument, 0, 'S'},
f5842774 3942 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3943 {"section-details", no_argument, 0, 't'},
595cf52e 3944 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3945 {"symbols", no_argument, 0, 's'},
3946 {"syms", no_argument, 0, 's'},
2c610e4b 3947 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3948 {"relocs", no_argument, 0, 'r'},
3949 {"notes", no_argument, 0, 'n'},
3950 {"dynamic", no_argument, 0, 'd'},
a952a375 3951 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3952 {"version-info", no_argument, 0, 'V'},
3953 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3954 {"unwind", no_argument, 0, 'u'},
4145f1d5 3955 {"archive-index", no_argument, 0, 'c'},
b34976b6 3956 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3957 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3958 {"string-dump", required_argument, 0, 'p'},
0e602686 3959 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 3960#ifdef SUPPORT_DISASSEMBLY
3961 {"instruction-dump", required_argument, 0, 'i'},
3962#endif
cf13d699 3963 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3964
fd2f0033
TT		 3965 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3966 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3967 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3968
b34976b6
AM		 3969 {"version", no_argument, 0, 'v'},
3970 {"wide", no_argument, 0, 'W'},
3971 {"help", no_argument, 0, 'H'},
3972 {0, no_argument, 0, 0}
252b5132
RH		 3973};
3974
3975static void
2cf0635d 3976usage (FILE * stream)
252b5132 3977{
92f01d61
JM		 3978 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3979 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3980 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3981 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3982 -h --file-header Display the ELF file header\n\
3983 -l --program-headers Display the program headers\n\
3984 --segments An alias for --program-headers\n\
3985 -S --section-headers Display the sections' header\n\
3986 --sections An alias for --section-headers\n\
f5842774 3987 -g --section-groups Display the section groups\n\
5477e8a0 3988 -t --section-details Display the section details\n\
8b53311e
NC		 3989 -e --headers Equivalent to: -h -l -S\n\
3990 -s --syms Display the symbol table\n\
3f08eb35 3991 --symbols An alias for --syms\n\
2c610e4b 3992 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3993 -n --notes Display the core notes (if present)\n\
3994 -r --relocs Display the relocations (if present)\n\
3995 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3996 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3997 -V --version-info Display the version sections (if present)\n\
1b31d05e 3998 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3999 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4000 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4001 -x --hex-dump=<number|name>\n\
4002 Dump the contents of section <number|name> as bytes\n\
4003 -p --string-dump=<number|name>\n\
4004 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4005 -R --relocated-dump=<number|name>\n\
4006 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4007 -z --decompress Decompress section before dumping it\n\
f9f0e732 4008 -w[lLiaprmfFsoRt] or\n\
1ed06042 4009 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4010 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4011 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4012 =addr,=cu_index]\n\
8b53311e 4013 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4014 fprintf (stream, _("\
4015 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4016 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4017 or deeper\n"));
252b5132 4018#ifdef SUPPORT_DISASSEMBLY
92f01d61 4019 fprintf (stream, _("\
09c11c86
NC		 4020 -i --instruction-dump=<number|name>\n\
4021 Disassemble the contents of section <number|name>\n"));
252b5132 4022#endif
92f01d61 4023 fprintf (stream, _("\
8b53311e
NC		 4024 -I --histogram Display histogram of bucket list lengths\n\
4025 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4026 @<file> Read options from <file>\n\
8b53311e
NC		 4027 -H --help Display this information\n\
4028 -v --version Display the version number of readelf\n"));
1118d252 4029
92f01d61
JM		 4030 if (REPORT_BUGS_TO[0] && stream == stdout)
4031 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4032
92f01d61 4033 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4034}
4035
18bd398b
NC		 4036/* Record the fact that the user wants the contents of section number
4037 SECTION to be displayed using the method(s) encoded as flags bits
4038 in TYPE. Note, TYPE can be zero if we are creating the array for
4039 the first time. */
4040
252b5132 4041static void
09c11c86 4042request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4043{
4044 if (section >= num_dump_sects)
4045 {
2cf0635d 4046 dump_type * new_dump_sects;
252b5132 4047
3f5e193b
NC		 4048 new_dump_sects = (dump_type *) calloc (section + 1,
4049 sizeof (* dump_sects));
252b5132
RH		 4050
4051 if (new_dump_sects == NULL)
591a748a 4052 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4053 else
4054 {
4055 /* Copy current flag settings. */
09c11c86 4056 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4057
4058 free (dump_sects);
4059
4060 dump_sects = new_dump_sects;
4061 num_dump_sects = section + 1;
4062 }
4063 }
4064
4065 if (dump_sects)
b34976b6 4066 dump_sects[section] |= type;
252b5132
RH		 4067
4068 return;
4069}
4070
aef1f6d0
DJ		 4071/* Request a dump by section name. */
4072
4073static void
2cf0635d 4074request_dump_byname (const char * section, dump_type type)
aef1f6d0 4075{
2cf0635d 4076 struct dump_list_entry * new_request;
aef1f6d0 4077
3f5e193b
NC		 4078 new_request = (struct dump_list_entry *)
4079 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4080 if (!new_request)
591a748a 4081 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4082
4083 new_request->name = strdup (section);
4084 if (!new_request->name)
591a748a 4085 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4086
4087 new_request->type = type;
4088
4089 new_request->next = dump_sects_byname;
4090 dump_sects_byname = new_request;
4091}
4092
cf13d699
NC		 4093static inline void
4094request_dump (dump_type type)
4095{
4096 int section;
4097 char * cp;
4098
4099 do_dump++;
4100 section = strtoul (optarg, & cp, 0);
4101
4102 if (! *cp && section >= 0)
4103 request_dump_bynumber (section, type);
4104 else
4105 request_dump_byname (optarg, type);
4106}
4107
4108
252b5132 4109static void
2cf0635d 4110parse_args (int argc, char ** argv)
252b5132
RH		 4111{
4112 int c;
4113
4114 if (argc < 2)
92f01d61 4115 usage (stderr);
252b5132
RH		 4116
4117 while ((c = getopt_long
0e602686 4118 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4119 {
252b5132
RH		 4120 switch (c)
4121 {
4122 case 0:
4123 /* Long options. */
4124 break;
4125 case 'H':
92f01d61 4126 usage (stdout);
252b5132
RH		 4127 break;
4128
4129 case 'a':
b34976b6
AM		 4130 do_syms++;
4131 do_reloc++;
4132 do_unwind++;
4133 do_dynamic++;
4134 do_header++;
4135 do_sections++;
f5842774 4136 do_section_groups++;
b34976b6
AM		 4137 do_segments++;
4138 do_version++;
4139 do_histogram++;
4140 do_arch++;
4141 do_notes++;
252b5132 4142 break;
f5842774
L		 4143 case 'g':
4144 do_section_groups++;
4145 break;
5477e8a0 4146 case 't':
595cf52e 4147 case 'N':
5477e8a0
L		 4148 do_sections++;
4149 do_section_details++;
595cf52e 4150 break;
252b5132 4151 case 'e':
b34976b6
AM		 4152 do_header++;
4153 do_sections++;
4154 do_segments++;
252b5132 4155 break;
a952a375 4156 case 'A':
b34976b6 4157 do_arch++;
a952a375 4158 break;
252b5132 4159 case 'D':
b34976b6 4160 do_using_dynamic++;
252b5132
RH		 4161 break;
4162 case 'r':
b34976b6 4163 do_reloc++;
252b5132 4164 break;
4d6ed7c8 4165 case 'u':
b34976b6 4166 do_unwind++;
4d6ed7c8 4167 break;
252b5132 4168 case 'h':
b34976b6 4169 do_header++;
252b5132
RH		 4170 break;
4171 case 'l':
b34976b6 4172 do_segments++;
252b5132
RH		 4173 break;
4174 case 's':
b34976b6 4175 do_syms++;
252b5132
RH		 4176 break;
4177 case 'S':
b34976b6 4178 do_sections++;
252b5132
RH		 4179 break;
4180 case 'd':
b34976b6 4181 do_dynamic++;
252b5132 4182 break;
a952a375 4183 case 'I':
b34976b6 4184 do_histogram++;
a952a375 4185 break;
779fe533 4186 case 'n':
b34976b6 4187 do_notes++;
779fe533 4188 break;
4145f1d5
NC		 4189 case 'c':
4190 do_archive_index++;
4191 break;
252b5132 4192 case 'x':
cf13d699 4193 request_dump (HEX_DUMP);
aef1f6d0 4194 break;
09c11c86 4195 case 'p':
cf13d699
NC		 4196 request_dump (STRING_DUMP);
4197 break;
4198 case 'R':
4199 request_dump (RELOC_DUMP);
09c11c86 4200 break;
0e602686
NC		 4201 case 'z':
4202 decompress_dumps++;
4203 break;
252b5132 4204 case 'w':
b34976b6 4205 do_dump++;
252b5132 4206 if (optarg == 0)
613ff48b
CC		 4207 {
4208 do_debugging = 1;
4209 dwarf_select_sections_all ();
4210 }
252b5132
RH		 4211 else
4212 {
4213 do_debugging = 0;
4cb93e3b 4214 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4215 }
4216 break;
2979dc34 4217 case OPTION_DEBUG_DUMP:
b34976b6 4218 do_dump++;
2979dc34
JJ		 4219 if (optarg == 0)
4220 do_debugging = 1;
4221 else
4222 {
2979dc34 4223 do_debugging = 0;
4cb93e3b 4224 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4225 }
4226 break;
fd2f0033
TT		 4227 case OPTION_DWARF_DEPTH:
4228 {
4229 char *cp;
4230
4231 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4232 }
4233 break;
4234 case OPTION_DWARF_START:
4235 {
4236 char *cp;
4237
4238 dwarf_start_die = strtoul (optarg, & cp, 0);
4239 }
4240 break;
4723351a
CC		 4241 case OPTION_DWARF_CHECK:
4242 dwarf_check = 1;
4243 break;
2c610e4b
L		 4244 case OPTION_DYN_SYMS:
4245 do_dyn_syms++;
4246 break;
252b5132
RH		 4247#ifdef SUPPORT_DISASSEMBLY
4248 case 'i':
cf13d699
NC		 4249 request_dump (DISASS_DUMP);
4250 break;
252b5132
RH		 4251#endif
4252 case 'v':
4253 print_version (program_name);
4254 break;
4255 case 'V':
b34976b6 4256 do_version++;
252b5132 4257 break;
d974e256 4258 case 'W':
b34976b6 4259 do_wide++;
d974e256 4260 break;
252b5132 4261 default:
252b5132
RH		 4262 /* xgettext:c-format */
4263 error (_("Invalid option '-%c'\n"), c);
4264 /* Drop through. */
4265 case '?':
92f01d61 4266 usage (stderr);
252b5132
RH		 4267 }
4268 }
4269
4d6ed7c8 4270 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4271 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4272 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4273 && !do_section_groups && !do_archive_index
4274 && !do_dyn_syms)
92f01d61 4275 usage (stderr);
252b5132
RH		 4276}
4277
4278static const char *
d3ba0551 4279get_elf_class (unsigned int elf_class)
252b5132 4280{
b34976b6 4281 static char buff[32];
103f02d3 4282
252b5132
RH		 4283 switch (elf_class)
4284 {
4285 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4286 case ELFCLASS32: return "ELF32";
4287 case ELFCLASS64: return "ELF64";
ab5e7794 4288 default:
e9e44622 4289 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4290 return buff;
252b5132
RH		 4291 }
4292}
4293
4294static const char *
d3ba0551 4295get_data_encoding (unsigned int encoding)
252b5132 4296{
b34976b6 4297 static char buff[32];
103f02d3 4298
252b5132
RH		 4299 switch (encoding)
4300 {
4301 case ELFDATANONE: return _("none");
33c63f9d
CM		 4302 case ELFDATA2LSB: return _("2's complement, little endian");
4303 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4304 default:
e9e44622 4305 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4306 return buff;
252b5132
RH		 4307 }
4308}
4309
252b5132 4310/* Decode the data held in 'elf_header'. */
ee42cf8c 4311
252b5132 4312static int
d3ba0551 4313process_file_header (void)
252b5132 4314{
b34976b6
AM		 4315 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4316 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4317 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4318 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4319 {
4320 error
4321 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4322 return 0;
4323 }
4324
2dc4cec1
L		 4325 init_dwarf_regnames (elf_header.e_machine);
4326
252b5132
RH		 4327 if (do_header)
4328 {
4329 int i;
4330
4331 printf (_("ELF Header:\n"));
4332 printf (_(" Magic: "));
b34976b6
AM		 4333 for (i = 0; i < EI_NIDENT; i++)
4334 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4335 printf ("\n");
4336 printf (_(" Class: %s\n"),
b34976b6 4337 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4338 printf (_(" Data: %s\n"),
b34976b6 4339 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4340 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4341 elf_header.e_ident[EI_VERSION],
4342 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4343 ? "(current)"
b34976b6 4344 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4345 ? _("<unknown: %lx>")
789be9f7 4346 : "")));
252b5132 4347 printf (_(" OS/ABI: %s\n"),
b34976b6 4348 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4349 printf (_(" ABI Version: %d\n"),
b34976b6 4350 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4351 printf (_(" Type: %s\n"),
4352 get_file_type (elf_header.e_type));
4353 printf (_(" Machine: %s\n"),
4354 get_machine_name (elf_header.e_machine));
4355 printf (_(" Version: 0x%lx\n"),
4356 (unsigned long) elf_header.e_version);
76da6bbe 4357
f7a99963
NC		 4358 printf (_(" Entry point address: "));
4359 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4360 printf (_("\n Start of program headers: "));
4361 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4362 printf (_(" (bytes into file)\n Start of section headers: "));
4363 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4364 printf (_(" (bytes into file)\n"));
76da6bbe 4365
252b5132
RH		 4366 printf (_(" Flags: 0x%lx%s\n"),
4367 (unsigned long) elf_header.e_flags,
4368 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4369 printf (_(" Size of this header: %ld (bytes)\n"),
4370 (long) elf_header.e_ehsize);
4371 printf (_(" Size of program headers: %ld (bytes)\n"),
4372 (long) elf_header.e_phentsize);
2046a35d 4373 printf (_(" Number of program headers: %ld"),
252b5132 4374 (long) elf_header.e_phnum);
2046a35d
AM		 4375 if (section_headers != NULL
4376 && elf_header.e_phnum == PN_XNUM
4377 && section_headers[0].sh_info != 0)
cc5914eb 4378 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4379 putc ('\n', stdout);
252b5132
RH		 4380 printf (_(" Size of section headers: %ld (bytes)\n"),
4381 (long) elf_header.e_shentsize);
560f3c1c 4382 printf (_(" Number of section headers: %ld"),
252b5132 4383 (long) elf_header.e_shnum);
4fbb74a6 4384 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4385 printf (" (%ld)", (long) section_headers[0].sh_size);
4386 putc ('\n', stdout);
4387 printf (_(" Section header string table index: %ld"),
252b5132 4388 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4389 if (section_headers != NULL
4390 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4391 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4392 else if (elf_header.e_shstrndx != SHN_UNDEF
4393 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4394 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4395 putc ('\n', stdout);
4396 }
4397
4398 if (section_headers != NULL)
4399 {
2046a35d
AM		 4400 if (elf_header.e_phnum == PN_XNUM
4401 && section_headers[0].sh_info != 0)
4402 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4403 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4404 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4405 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4406 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4407 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4408 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4409 free (section_headers);
4410 section_headers = NULL;
252b5132 4411 }
103f02d3 4412
9ea033b2
NC		 4413 return 1;
4414}
4415
e0a31db1 4416static bfd_boolean
91d6fa6a 4417get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4418{
2cf0635d
NC		 4419 Elf32_External_Phdr * phdrs;
4420 Elf32_External_Phdr * external;
4421 Elf_Internal_Phdr * internal;
b34976b6 4422 unsigned int i;
e0a31db1
NC		 4423 unsigned int size = elf_header.e_phentsize;
4424 unsigned int num = elf_header.e_phnum;
4425
4426 /* PR binutils/17531: Cope with unexpected section header sizes. */
4427 if (size == 0 || num == 0)
4428 return FALSE;
4429 if (size < sizeof * phdrs)
4430 {
4431 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4432 return FALSE;
4433 }
4434 if (size > sizeof * phdrs)
4435 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4436
3f5e193b 4437 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4438 size, num, _("program headers"));
4439 if (phdrs == NULL)
4440 return FALSE;
9ea033b2 4441
91d6fa6a 4442 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4443 i < elf_header.e_phnum;
b34976b6 4444 i++, internal++, external++)
252b5132 4445 {
9ea033b2
NC		 4446 internal->p_type = BYTE_GET (external->p_type);
4447 internal->p_offset = BYTE_GET (external->p_offset);
4448 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4449 internal->p_paddr = BYTE_GET (external->p_paddr);
4450 internal->p_filesz = BYTE_GET (external->p_filesz);
4451 internal->p_memsz = BYTE_GET (external->p_memsz);
4452 internal->p_flags = BYTE_GET (external->p_flags);
4453 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4454 }
4455
9ea033b2 4456 free (phdrs);
e0a31db1 4457 return TRUE;
252b5132
RH		 4458}
4459
e0a31db1 4460static bfd_boolean
91d6fa6a 4461get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4462{
2cf0635d
NC		 4463 Elf64_External_Phdr * phdrs;
4464 Elf64_External_Phdr * external;
4465 Elf_Internal_Phdr * internal;
b34976b6 4466 unsigned int i;
e0a31db1
NC		 4467 unsigned int size = elf_header.e_phentsize;
4468 unsigned int num = elf_header.e_phnum;
4469
4470 /* PR binutils/17531: Cope with unexpected section header sizes. */
4471 if (size == 0 || num == 0)
4472 return FALSE;
4473 if (size < sizeof * phdrs)
4474 {
4475 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4476 return FALSE;
4477 }
4478 if (size > sizeof * phdrs)
4479 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4480
3f5e193b 4481 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4482 size, num, _("program headers"));
a6e9f9df 4483 if (!phdrs)
e0a31db1 4484 return FALSE;
9ea033b2 4485
91d6fa6a 4486 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4487 i < elf_header.e_phnum;
b34976b6 4488 i++, internal++, external++)
9ea033b2
NC		 4489 {
4490 internal->p_type = BYTE_GET (external->p_type);
4491 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4492 internal->p_offset = BYTE_GET (external->p_offset);
4493 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4494 internal->p_paddr = BYTE_GET (external->p_paddr);
4495 internal->p_filesz = BYTE_GET (external->p_filesz);
4496 internal->p_memsz = BYTE_GET (external->p_memsz);
4497 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4498 }
4499
4500 free (phdrs);
e0a31db1 4501 return TRUE;
9ea033b2 4502}
252b5132 4503
d93f0186
NC		 4504/* Returns 1 if the program headers were read into `program_headers'. */
4505
4506static int
2cf0635d 4507get_program_headers (FILE * file)
d93f0186 4508{
2cf0635d 4509 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4510
4511 /* Check cache of prior read. */
4512 if (program_headers != NULL)
4513 return 1;
4514
3f5e193b
NC		 4515 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4516 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4517
4518 if (phdrs == NULL)
4519 {
8b73c356
NC		 4520 error (_("Out of memory reading %u program headers\n"),
4521 elf_header.e_phnum);
d93f0186
NC		 4522 return 0;
4523 }
4524
4525 if (is_32bit_elf
4526 ? get_32bit_program_headers (file, phdrs)
4527 : get_64bit_program_headers (file, phdrs))
4528 {
4529 program_headers = phdrs;
4530 return 1;
4531 }
4532
4533 free (phdrs);
4534 return 0;
4535}
4536
2f62977e
NC		 4537/* Returns 1 if the program headers were loaded. */
4538
252b5132 4539static int
2cf0635d 4540process_program_headers (FILE * file)
252b5132 4541{
2cf0635d 4542 Elf_Internal_Phdr * segment;
b34976b6 4543 unsigned int i;
252b5132
RH		 4544
4545 if (elf_header.e_phnum == 0)
4546 {
82f2dbf7
NC		 4547 /* PR binutils/12467. */
4548 if (elf_header.e_phoff != 0)
4549 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4550 " header offset, but no program headers\n"));
82f2dbf7 4551 else if (do_segments)
252b5132 4552 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4553 return 0;
252b5132
RH		 4554 }
4555
4556 if (do_segments && !do_header)
4557 {
f7a99963
NC		 4558 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4559 printf (_("Entry point "));
4560 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4561 printf (_("\nThere are %d program headers, starting at offset "),
4562 elf_header.e_phnum);
4563 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4564 printf ("\n");
252b5132
RH		 4565 }
4566
d93f0186 4567 if (! get_program_headers (file))
252b5132 4568 return 0;
103f02d3 4569
252b5132
RH		 4570 if (do_segments)
4571 {
3a1a2036
NC		 4572 if (elf_header.e_phnum > 1)
4573 printf (_("\nProgram Headers:\n"));
4574 else
4575 printf (_("\nProgram Headers:\n"));
76da6bbe 4576
f7a99963
NC		 4577 if (is_32bit_elf)
4578 printf
4579 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4580 else if (do_wide)
4581 printf
4582 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4583 else
4584 {
4585 printf
4586 (_(" Type Offset VirtAddr PhysAddr\n"));
4587 printf
4588 (_(" FileSiz MemSiz Flags Align\n"));
4589 }
252b5132
RH		 4590 }
4591
252b5132 4592 dynamic_addr = 0;
1b228002 4593 dynamic_size = 0;
252b5132
RH		 4594
4595 for (i = 0, segment = program_headers;
4596 i < elf_header.e_phnum;
b34976b6 4597 i++, segment++)
252b5132
RH		 4598 {
4599 if (do_segments)
4600 {
103f02d3 4601 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4602
4603 if (is_32bit_elf)
4604 {
4605 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4606 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4607 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4608 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4609 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4610 printf ("%c%c%c ",
4611 (segment->p_flags & PF_R ? 'R' : ' '),
4612 (segment->p_flags & PF_W ? 'W' : ' '),
4613 (segment->p_flags & PF_X ? 'E' : ' '));
4614 printf ("%#lx", (unsigned long) segment->p_align);
4615 }
d974e256
JJ		 4616 else if (do_wide)
4617 {
4618 if ((unsigned long) segment->p_offset == segment->p_offset)
4619 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4620 else
4621 {
4622 print_vma (segment->p_offset, FULL_HEX);
4623 putchar (' ');
4624 }
4625
4626 print_vma (segment->p_vaddr, FULL_HEX);
4627 putchar (' ');
4628 print_vma (segment->p_paddr, FULL_HEX);
4629 putchar (' ');
4630
4631 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4632 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4633 else
4634 {
4635 print_vma (segment->p_filesz, FULL_HEX);
4636 putchar (' ');
4637 }
4638
4639 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4640 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4641 else
4642 {
f48e6c45 4643 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4644 }
4645
4646 printf (" %c%c%c ",
4647 (segment->p_flags & PF_R ? 'R' : ' '),
4648 (segment->p_flags & PF_W ? 'W' : ' '),
4649 (segment->p_flags & PF_X ? 'E' : ' '));
4650
4651 if ((unsigned long) segment->p_align == segment->p_align)
4652 printf ("%#lx", (unsigned long) segment->p_align);
4653 else
4654 {
4655 print_vma (segment->p_align, PREFIX_HEX);
4656 }
4657 }
f7a99963
NC		 4658 else
4659 {
4660 print_vma (segment->p_offset, FULL_HEX);
4661 putchar (' ');
4662 print_vma (segment->p_vaddr, FULL_HEX);
4663 putchar (' ');
4664 print_vma (segment->p_paddr, FULL_HEX);
4665 printf ("\n ");
4666 print_vma (segment->p_filesz, FULL_HEX);
4667 putchar (' ');
4668 print_vma (segment->p_memsz, FULL_HEX);
4669 printf (" %c%c%c ",
4670 (segment->p_flags & PF_R ? 'R' : ' '),
4671 (segment->p_flags & PF_W ? 'W' : ' '),
4672 (segment->p_flags & PF_X ? 'E' : ' '));
4673 print_vma (segment->p_align, HEX);
4674 }
252b5132
RH		 4675 }
4676
f54498b4
NC		 4677 if (do_segments)
4678 putc ('\n', stdout);
4679
252b5132
RH		 4680 switch (segment->p_type)
4681 {
252b5132
RH		 4682 case PT_DYNAMIC:
4683 if (dynamic_addr)
4684 error (_("more than one dynamic segment\n"));
4685
20737c13
AM		 4686 /* By default, assume that the .dynamic section is the first
4687 section in the DYNAMIC segment. */
4688 dynamic_addr = segment->p_offset;
4689 dynamic_size = segment->p_filesz;
f54498b4
NC		 4690 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4691 if (dynamic_addr + dynamic_size >= current_file_size)
4692 {
4693 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4694 dynamic_addr = dynamic_size = 0;
4695 }
20737c13 4696
b2d38a17
NC		 4697 /* Try to locate the .dynamic section. If there is
4698 a section header table, we can easily locate it. */
4699 if (section_headers != NULL)
4700 {
2cf0635d 4701 Elf_Internal_Shdr * sec;
b2d38a17 4702
89fac5e3
RS		 4703 sec = find_section (".dynamic");
4704 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4705 {
28f997cf
TG		 4706 /* A corresponding .dynamic section is expected, but on
4707 IA-64/OpenVMS it is OK for it to be missing. */
4708 if (!is_ia64_vms ())
4709 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4710 break;
4711 }
4712
42bb2e33 4713 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4714 {
4715 dynamic_size = 0;
4716 break;
4717 }
42bb2e33 4718
b2d38a17
NC		 4719 dynamic_addr = sec->sh_offset;
4720 dynamic_size = sec->sh_size;
4721
4722 if (dynamic_addr < segment->p_offset
4723 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4724 warn (_("the .dynamic section is not contained"
4725 " within the dynamic segment\n"));
b2d38a17 4726 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4727 warn (_("the .dynamic section is not the first section"
4728 " in the dynamic segment.\n"));
b2d38a17 4729 }
252b5132
RH		 4730 break;
4731
4732 case PT_INTERP:
fb52b2f4
NC		 4733 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4734 SEEK_SET))
252b5132
RH		 4735 error (_("Unable to find program interpreter name\n"));
4736 else
4737 {
f8eae8b2 4738 char fmt [32];
9495b2e6 4739 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4740
4741 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4742 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4743
252b5132 4744 program_interpreter[0] = 0;
7bd7b3ef
AM		 4745 if (fscanf (file, fmt, program_interpreter) <= 0)
4746 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4747
4748 if (do_segments)
f54498b4 4749 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4750 program_interpreter);
4751 }
4752 break;
4753 }
252b5132
RH		 4754 }
4755
c256ffe7 4756 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4757 {
4758 printf (_("\n Section to Segment mapping:\n"));
4759 printf (_(" Segment Sections...\n"));
4760
252b5132
RH		 4761 for (i = 0; i < elf_header.e_phnum; i++)
4762 {
9ad5cbcf 4763 unsigned int j;
2cf0635d 4764 Elf_Internal_Shdr * section;
252b5132
RH		 4765
4766 segment = program_headers + i;
b391a3e3 4767 section = section_headers + 1;
252b5132
RH		 4768
4769 printf (" %2.2d ", i);
4770
b34976b6 4771 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4772 {
f4638467
AM		 4773 if (!ELF_TBSS_SPECIAL (section, segment)
4774 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4775 printf ("%s ", printable_section_name (section));
252b5132
RH		 4776 }
4777
4778 putc ('\n',stdout);
4779 }
4780 }
4781
252b5132
RH		 4782 return 1;
4783}
4784
4785
d93f0186
NC		 4786/* Find the file offset corresponding to VMA by using the program headers. */
4787
4788static long
2cf0635d 4789offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4790{
2cf0635d 4791 Elf_Internal_Phdr * seg;
d93f0186
NC		 4792
4793 if (! get_program_headers (file))
4794 {
4795 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4796 return (long) vma;
4797 }
4798
4799 for (seg = program_headers;
4800 seg < program_headers + elf_header.e_phnum;
4801 ++seg)
4802 {
4803 if (seg->p_type != PT_LOAD)
4804 continue;
4805
4806 if (vma >= (seg->p_vaddr & -seg->p_align)
4807 && vma + size <= seg->p_vaddr + seg->p_filesz)
4808 return vma - seg->p_vaddr + seg->p_offset;
4809 }
4810
4811 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4812 (unsigned long) vma);
d93f0186
NC		 4813 return (long) vma;
4814}
4815
4816
049b0c3a
NC		 4817/* Allocate memory and load the sections headers into the global pointer
4818 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4819 generate any error messages if the load fails. */
4820
4821static bfd_boolean
4822get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4823{
2cf0635d
NC		 4824 Elf32_External_Shdr * shdrs;
4825 Elf_Internal_Shdr * internal;
b34976b6 4826 unsigned int i;
049b0c3a
NC		 4827 unsigned int size = elf_header.e_shentsize;
4828 unsigned int num = probe ? 1 : elf_header.e_shnum;
4829
4830 /* PR binutils/17531: Cope with unexpected section header sizes. */
4831 if (size == 0 || num == 0)
4832 return FALSE;
4833 if (size < sizeof * shdrs)
4834 {
4835 if (! probe)
4836 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4837 return FALSE;
4838 }
4839 if (!probe && size > sizeof * shdrs)
4840 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4841
3f5e193b 4842 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4843 size, num,
4844 probe ? NULL : _("section headers"));
4845 if (shdrs == NULL)
4846 return FALSE;
252b5132 4847
049b0c3a
NC		 4848 if (section_headers != NULL)
4849 free (section_headers);
3f5e193b
NC		 4850 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4851 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4852 if (section_headers == NULL)
4853 {
049b0c3a 4854 if (!probe)
8b73c356 4855 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4856 return FALSE;
252b5132
RH		 4857 }
4858
4859 for (i = 0, internal = section_headers;
560f3c1c 4860 i < num;
b34976b6 4861 i++, internal++)
252b5132
RH		 4862 {
4863 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4864 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4865 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4866 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4867 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4868 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4869 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4870 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4871 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4872 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4873 }
4874
4875 free (shdrs);
049b0c3a 4876 return TRUE;
252b5132
RH		 4877}
4878
049b0c3a
NC		 4879static bfd_boolean
4880get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4881{
2cf0635d
NC		 4882 Elf64_External_Shdr * shdrs;
4883 Elf_Internal_Shdr * internal;
b34976b6 4884 unsigned int i;
049b0c3a
NC		 4885 unsigned int size = elf_header.e_shentsize;
4886 unsigned int num = probe ? 1 : elf_header.e_shnum;
4887
4888 /* PR binutils/17531: Cope with unexpected section header sizes. */
4889 if (size == 0 || num == 0)
4890 return FALSE;
4891 if (size < sizeof * shdrs)
4892 {
4893 if (! probe)
4894 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4895 return FALSE;
4896 }
4897 if (! probe && size > sizeof * shdrs)
4898 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4899
3f5e193b 4900 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4901 size, num,
4902 probe ? NULL : _("section headers"));
4903 if (shdrs == NULL)
4904 return FALSE;
9ea033b2 4905
049b0c3a
NC		 4906 if (section_headers != NULL)
4907 free (section_headers);
3f5e193b
NC		 4908 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4909 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4910 if (section_headers == NULL)
4911 {
049b0c3a 4912 if (! probe)
8b73c356 4913 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4914 return FALSE;
9ea033b2
NC		 4915 }
4916
4917 for (i = 0, internal = section_headers;
560f3c1c 4918 i < num;
b34976b6 4919 i++, internal++)
9ea033b2
NC		 4920 {
4921 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4922 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4923 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4924 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4925 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4926 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4927 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4928 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4929 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4930 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4931 }
4932
4933 free (shdrs);
049b0c3a 4934 return TRUE;
9ea033b2
NC		 4935}
4936
252b5132 4937static Elf_Internal_Sym *
ba5cdace
NC		 4938get_32bit_elf_symbols (FILE * file,
4939 Elf_Internal_Shdr * section,
4940 unsigned long * num_syms_return)
252b5132 4941{
ba5cdace 4942 unsigned long number = 0;
dd24e3da 4943 Elf32_External_Sym * esyms = NULL;
ba5cdace 4944 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4945 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4946 Elf_Internal_Sym * psym;
b34976b6 4947 unsigned int j;
252b5132 4948
c9c1d674
EG		 4949 if (section->sh_size == 0)
4950 {
4951 if (num_syms_return != NULL)
4952 * num_syms_return = 0;
4953 return NULL;
4954 }
4955
dd24e3da 4956 /* Run some sanity checks first. */
c9c1d674 4957 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4958 {
c9c1d674
EG		 4959 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4960 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4961 goto exit_point;
dd24e3da
NC		 4962 }
4963
f54498b4
NC		 4964 if (section->sh_size > current_file_size)
4965 {
4966 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4967 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4968 goto exit_point;
4969 }
4970
dd24e3da
NC		 4971 number = section->sh_size / section->sh_entsize;
4972
4973 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4974 {
c9c1d674 4975 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4976 (unsigned long) section->sh_size,
4977 printable_section_name (section),
4978 (unsigned long) section->sh_entsize);
ba5cdace 4979 goto exit_point;
dd24e3da
NC		 4980 }
4981
3f5e193b
NC		 4982 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4983 section->sh_size, _("symbols"));
dd24e3da 4984 if (esyms == NULL)
ba5cdace 4985 goto exit_point;
252b5132 4986
9ad5cbcf
AM		 4987 shndx = NULL;
4988 if (symtab_shndx_hdr != NULL
4989 && (symtab_shndx_hdr->sh_link
4fbb74a6 4990 == (unsigned long) (section - section_headers)))
9ad5cbcf 4991 {
3f5e193b
NC		 4992 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4993 symtab_shndx_hdr->sh_offset,
4994 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4995 _("symbol table section indicies"));
dd24e3da
NC		 4996 if (shndx == NULL)
4997 goto exit_point;
c9c1d674
EG		 4998 /* PR17531: file: heap-buffer-overflow */
4999 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5000 {
5001 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5002 printable_section_name (symtab_shndx_hdr),
5003 (unsigned long) symtab_shndx_hdr->sh_size,
5004 (unsigned long) section->sh_size);
5005 goto exit_point;
5006 }
9ad5cbcf
AM		 5007 }
5008
3f5e193b 5009 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5010
5011 if (isyms == NULL)
5012 {
8b73c356
NC		 5013 error (_("Out of memory reading %lu symbols\n"),
5014 (unsigned long) number);
dd24e3da 5015 goto exit_point;
252b5132
RH		 5016 }
5017
dd24e3da 5018 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5019 {
5020 psym->st_name = BYTE_GET (esyms[j].st_name);
5021 psym->st_value = BYTE_GET (esyms[j].st_value);
5022 psym->st_size = BYTE_GET (esyms[j].st_size);
5023 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5024 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5025 psym->st_shndx
5026 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5027 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5028 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5029 psym->st_info = BYTE_GET (esyms[j].st_info);
5030 psym->st_other = BYTE_GET (esyms[j].st_other);
5031 }
5032
dd24e3da 5033 exit_point:
ba5cdace 5034 if (shndx != NULL)
9ad5cbcf 5035 free (shndx);
ba5cdace 5036 if (esyms != NULL)
dd24e3da 5037 free (esyms);
252b5132 5038
ba5cdace
NC		 5039 if (num_syms_return != NULL)
5040 * num_syms_return = isyms == NULL ? 0 : number;
5041
252b5132
RH		 5042 return isyms;
5043}
5044
9ea033b2 5045static Elf_Internal_Sym *
ba5cdace
NC		 5046get_64bit_elf_symbols (FILE * file,
5047 Elf_Internal_Shdr * section,
5048 unsigned long * num_syms_return)
9ea033b2 5049{
ba5cdace
NC		 5050 unsigned long number = 0;
5051 Elf64_External_Sym * esyms = NULL;
5052 Elf_External_Sym_Shndx * shndx = NULL;
5053 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5054 Elf_Internal_Sym * psym;
b34976b6 5055 unsigned int j;
9ea033b2 5056
c9c1d674
EG		 5057 if (section->sh_size == 0)
5058 {
5059 if (num_syms_return != NULL)
5060 * num_syms_return = 0;
5061 return NULL;
5062 }
5063
dd24e3da 5064 /* Run some sanity checks first. */
c9c1d674 5065 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5066 {
c9c1d674 5067 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5068 printable_section_name (section),
5069 (unsigned long) section->sh_entsize);
ba5cdace 5070 goto exit_point;
dd24e3da
NC		 5071 }
5072
f54498b4
NC		 5073 if (section->sh_size > current_file_size)
5074 {
5075 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5076 printable_section_name (section),
5077 (unsigned long) section->sh_size);
f54498b4
NC		 5078 goto exit_point;
5079 }
5080
dd24e3da
NC		 5081 number = section->sh_size / section->sh_entsize;
5082
5083 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5084 {
c9c1d674 5085 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5086 (unsigned long) section->sh_size,
5087 printable_section_name (section),
5088 (unsigned long) section->sh_entsize);
ba5cdace 5089 goto exit_point;
dd24e3da
NC		 5090 }
5091
3f5e193b
NC		 5092 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5093 section->sh_size, _("symbols"));
a6e9f9df 5094 if (!esyms)
ba5cdace 5095 goto exit_point;
9ea033b2 5096
9ad5cbcf
AM		 5097 if (symtab_shndx_hdr != NULL
5098 && (symtab_shndx_hdr->sh_link
4fbb74a6 5099 == (unsigned long) (section - section_headers)))
9ad5cbcf 5100 {
3f5e193b
NC		 5101 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5102 symtab_shndx_hdr->sh_offset,
5103 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5104 _("symbol table section indicies"));
ba5cdace
NC		 5105 if (shndx == NULL)
5106 goto exit_point;
c9c1d674
EG		 5107 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5108 {
5109 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5110 printable_section_name (symtab_shndx_hdr),
5111 (unsigned long) symtab_shndx_hdr->sh_size,
5112 (unsigned long) section->sh_size);
5113 goto exit_point;
5114 }
9ad5cbcf
AM		 5115 }
5116
3f5e193b 5117 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5118
5119 if (isyms == NULL)
5120 {
8b73c356
NC		 5121 error (_("Out of memory reading %lu symbols\n"),
5122 (unsigned long) number);
ba5cdace 5123 goto exit_point;
9ea033b2
NC		 5124 }
5125
ba5cdace 5126 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5127 {
5128 psym->st_name = BYTE_GET (esyms[j].st_name);
5129 psym->st_info = BYTE_GET (esyms[j].st_info);
5130 psym->st_other = BYTE_GET (esyms[j].st_other);
5131 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5132
4fbb74a6 5133 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5134 psym->st_shndx
5135 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5136 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5137 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5138
66543521
AM		 5139 psym->st_value = BYTE_GET (esyms[j].st_value);
5140 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5141 }
5142
ba5cdace
NC		 5143 exit_point:
5144 if (shndx != NULL)
9ad5cbcf 5145 free (shndx);
ba5cdace
NC		 5146 if (esyms != NULL)
5147 free (esyms);
5148
5149 if (num_syms_return != NULL)
5150 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5151
5152 return isyms;
5153}
5154
d1133906 5155static const char *
d3ba0551 5156get_elf_section_flags (bfd_vma sh_flags)
d1133906 5157{
5477e8a0 5158 static char buff[1024];
2cf0635d 5159 char * p = buff;
8d5ff12c 5160 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5161 int sindex;
5162 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5163 bfd_vma os_flags = 0;
5164 bfd_vma proc_flags = 0;
5165 bfd_vma unknown_flags = 0;
148b93f2 5166 static const struct
5477e8a0 5167 {
2cf0635d 5168 const char * str;
5477e8a0
L		 5169 int len;
5170 }
5171 flags [] =
5172 {
cfcac11d
NC		 5173 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5174 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5175 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5176 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5177 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5178 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5179 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5180 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5181 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5182 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5183 /* IA-64 specific. */
5184 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5185 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5186 /* IA-64 OpenVMS specific. */
5187 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5188 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5189 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5190 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5191 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5192 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5193 /* Generic. */
cfcac11d 5194 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5195 /* SPARC specific. */
77115a4a
L		 5196 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5197 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5198 };
5199
5200 if (do_section_details)
5201 {
8d5ff12c
L		 5202 sprintf (buff, "[%*.*lx]: ",
5203 field_size, field_size, (unsigned long) sh_flags);
5204 p += field_size + 4;
5477e8a0 5205 }
76da6bbe 5206
d1133906
NC		 5207 while (sh_flags)
5208 {
5209 bfd_vma flag;
5210
5211 flag = sh_flags & - sh_flags;
5212 sh_flags &= ~ flag;
76da6bbe 5213
5477e8a0 5214 if (do_section_details)
d1133906 5215 {
5477e8a0
L		 5216 switch (flag)
5217 {
91d6fa6a
NC		 5218 case SHF_WRITE: sindex = 0; break;
5219 case SHF_ALLOC: sindex = 1; break;
5220 case SHF_EXECINSTR: sindex = 2; break;
5221 case SHF_MERGE: sindex = 3; break;
5222 case SHF_STRINGS: sindex = 4; break;
5223 case SHF_INFO_LINK: sindex = 5; break;
5224 case SHF_LINK_ORDER: sindex = 6; break;
5225 case SHF_OS_NONCONFORMING: sindex = 7; break;
5226 case SHF_GROUP: sindex = 8; break;
5227 case SHF_TLS: sindex = 9; break;
18ae9cc1 5228 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5229 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5230
5477e8a0 5231 default:
91d6fa6a 5232 sindex = -1;
cfcac11d 5233 switch (elf_header.e_machine)
148b93f2 5234 {
cfcac11d 5235 case EM_IA_64:
148b93f2 5236 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5237 sindex = 10;
148b93f2 5238 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5239 sindex = 11;
148b93f2
NC		 5240#ifdef BFD64
5241 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5242 switch (flag)
5243 {
91d6fa6a
NC		 5244 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5245 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5246 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5247 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5248 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5249 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5250 default: break;
5251 }
5252#endif
cfcac11d
NC		 5253 break;
5254
caa83f8b 5255 case EM_386:
22abe556 5256 case EM_IAMCU:
caa83f8b 5257 case EM_X86_64:
7f502d6c 5258 case EM_L1OM:
7a9068fe 5259 case EM_K1OM:
cfcac11d
NC		 5260 case EM_OLD_SPARCV9:
5261 case EM_SPARC32PLUS:
5262 case EM_SPARCV9:
5263 case EM_SPARC:
18ae9cc1 5264 if (flag == SHF_ORDERED)
91d6fa6a 5265 sindex = 19;
cfcac11d
NC		 5266 break;
5267 default:
5268 break;
148b93f2 5269 }
5477e8a0
L		 5270 }
5271
91d6fa6a 5272 if (sindex != -1)
5477e8a0 5273 {
8d5ff12c
L		 5274 if (p != buff + field_size + 4)
5275 {
5276 if (size < (10 + 2))
bee0ee85
NC		 5277 {
5278 warn (_("Internal error: not enough buffer room for section flag info"));
5279 return _("<unknown>");
5280 }
8d5ff12c
L		 5281 size -= 2;
5282 *p++ = ',';
5283 *p++ = ' ';
5284 }
5285
91d6fa6a
NC		 5286 size -= flags [sindex].len;
5287 p = stpcpy (p, flags [sindex].str);
5477e8a0 5288 }
3b22753a 5289 else if (flag & SHF_MASKOS)
8d5ff12c 5290 os_flags |= flag;
d1133906 5291 else if (flag & SHF_MASKPROC)
8d5ff12c 5292 proc_flags |= flag;
d1133906 5293 else
8d5ff12c 5294 unknown_flags |= flag;
5477e8a0
L		 5295 }
5296 else
5297 {
5298 switch (flag)
5299 {
5300 case SHF_WRITE: *p = 'W'; break;
5301 case SHF_ALLOC: *p = 'A'; break;
5302 case SHF_EXECINSTR: *p = 'X'; break;
5303 case SHF_MERGE: *p = 'M'; break;
5304 case SHF_STRINGS: *p = 'S'; break;
5305 case SHF_INFO_LINK: *p = 'I'; break;
5306 case SHF_LINK_ORDER: *p = 'L'; break;
5307 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5308 case SHF_GROUP: *p = 'G'; break;
5309 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5310 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5311 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5312
5313 default:
8a9036a4 5314 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5315 || elf_header.e_machine == EM_L1OM
5316 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5317 && flag == SHF_X86_64_LARGE)
5318 *p = 'l';
5319 else if (flag & SHF_MASKOS)
5320 {
5321 *p = 'o';
5322 sh_flags &= ~ SHF_MASKOS;
5323 }
5324 else if (flag & SHF_MASKPROC)
5325 {
5326 *p = 'p';
5327 sh_flags &= ~ SHF_MASKPROC;
5328 }
5329 else
5330 *p = 'x';
5331 break;
5332 }
5333 p++;
d1133906
NC		 5334 }
5335 }
76da6bbe 5336
8d5ff12c
L		 5337 if (do_section_details)
5338 {
5339 if (os_flags)
5340 {
5341 size -= 5 + field_size;
5342 if (p != buff + field_size + 4)
5343 {
5344 if (size < (2 + 1))
bee0ee85
NC		 5345 {
5346 warn (_("Internal error: not enough buffer room for section flag info"));
5347 return _("<unknown>");
5348 }
8d5ff12c
L		 5349 size -= 2;
5350 *p++ = ',';
5351 *p++ = ' ';
5352 }
5353 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5354 (unsigned long) os_flags);
5355 p += 5 + field_size;
5356 }
5357 if (proc_flags)
5358 {
5359 size -= 7 + field_size;
5360 if (p != buff + field_size + 4)
5361 {
5362 if (size < (2 + 1))
bee0ee85
NC		 5363 {
5364 warn (_("Internal error: not enough buffer room for section flag info"));
5365 return _("<unknown>");
5366 }
8d5ff12c
L		 5367 size -= 2;
5368 *p++ = ',';
5369 *p++ = ' ';
5370 }
5371 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5372 (unsigned long) proc_flags);
5373 p += 7 + field_size;
5374 }
5375 if (unknown_flags)
5376 {
5377 size -= 10 + field_size;
5378 if (p != buff + field_size + 4)
5379 {
5380 if (size < (2 + 1))
bee0ee85
NC		 5381 {
5382 warn (_("Internal error: not enough buffer room for section flag info"));
5383 return _("<unknown>");
5384 }
8d5ff12c
L		 5385 size -= 2;
5386 *p++ = ',';
5387 *p++ = ' ';
5388 }
2b692964 5389 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5390 (unsigned long) unknown_flags);
5391 p += 10 + field_size;
5392 }
5393 }
5394
e9e44622 5395 *p = '\0';
d1133906
NC		 5396 return buff;
5397}
5398
77115a4a
L		 5399static unsigned int
5400get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5401{
5402 if (is_32bit_elf)
5403 {
5404 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5405 chdr->ch_type = BYTE_GET (echdr->ch_type);
5406 chdr->ch_size = BYTE_GET (echdr->ch_size);
5407 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5408 return sizeof (*echdr);
5409 }
5410 else
5411 {
5412 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5413 chdr->ch_type = BYTE_GET (echdr->ch_type);
5414 chdr->ch_size = BYTE_GET (echdr->ch_size);
5415 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5416 return sizeof (*echdr);
5417 }
5418}
5419
252b5132 5420static int
2cf0635d 5421process_section_headers (FILE * file)
252b5132 5422{
2cf0635d 5423 Elf_Internal_Shdr * section;
b34976b6 5424 unsigned int i;
252b5132
RH		 5425
5426 section_headers = NULL;
5427
5428 if (elf_header.e_shnum == 0)
5429 {
82f2dbf7
NC		 5430 /* PR binutils/12467. */
5431 if (elf_header.e_shoff != 0)
5432 warn (_("possibly corrupt ELF file header - it has a non-zero"
5433 " section header offset, but no section headers\n"));
5434 else if (do_sections)
252b5132
RH		 5435 printf (_("\nThere are no sections in this file.\n"));
5436
5437 return 1;
5438 }
5439
5440 if (do_sections && !do_header)
9ea033b2 5441 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5442 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5443
9ea033b2
NC		 5444 if (is_32bit_elf)
5445 {
049b0c3a 5446 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5447 return 0;
5448 }
049b0c3a 5449 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5450 return 0;
5451
5452 /* Read in the string table, so that we have names to display. */
0b49d371 5453 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5454 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5455 {
4fbb74a6 5456 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5457
c256ffe7
JJ		 5458 if (section->sh_size != 0)
5459 {
3f5e193b
NC		 5460 string_table = (char *) get_data (NULL, file, section->sh_offset,
5461 1, section->sh_size,
5462 _("string table"));
0de14b54 5463
c256ffe7
JJ		 5464 string_table_length = string_table != NULL ? section->sh_size : 0;
5465 }
252b5132
RH		 5466 }
5467
5468 /* Scan the sections for the dynamic symbol table
e3c8793a 5469 and dynamic string table and debug sections. */
252b5132
RH		 5470 dynamic_symbols = NULL;
5471 dynamic_strings = NULL;
5472 dynamic_syminfo = NULL;
f1ef08cb 5473 symtab_shndx_hdr = NULL;
103f02d3 5474
89fac5e3
RS		 5475 eh_addr_size = is_32bit_elf ? 4 : 8;
5476 switch (elf_header.e_machine)
5477 {
5478 case EM_MIPS:
5479 case EM_MIPS_RS3_LE:
5480 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5481 FDE addresses. However, the ABI also has a semi-official ILP32
5482 variant for which the normal FDE address size rules apply.
5483
5484 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5485 section, where XX is the size of longs in bits. Unfortunately,
5486 earlier compilers provided no way of distinguishing ILP32 objects
5487 from LP64 objects, so if there's any doubt, we should assume that
5488 the official LP64 form is being used. */
5489 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5490 && find_section (".gcc_compiled_long32") == NULL)
5491 eh_addr_size = 8;
5492 break;
0f56a26a
DD		 5493
5494 case EM_H8_300:
5495 case EM_H8_300H:
5496 switch (elf_header.e_flags & EF_H8_MACH)
5497 {
5498 case E_H8_MACH_H8300:
5499 case E_H8_MACH_H8300HN:
5500 case E_H8_MACH_H8300SN:
5501 case E_H8_MACH_H8300SXN:
5502 eh_addr_size = 2;
5503 break;
5504 case E_H8_MACH_H8300H:
5505 case E_H8_MACH_H8300S:
5506 case E_H8_MACH_H8300SX:
5507 eh_addr_size = 4;
5508 break;
5509 }
f4236fe4
DD		 5510 break;
5511
ff7eeb89 5512 case EM_M32C_OLD:
f4236fe4
DD		 5513 case EM_M32C:
5514 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5515 {
5516 case EF_M32C_CPU_M16C:
5517 eh_addr_size = 2;
5518 break;
5519 }
5520 break;
89fac5e3
RS		 5521 }
5522
76ca31c0
NC		 5523#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5524 do \
5525 { \
5526 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5527 if (section->sh_entsize != expected_entsize) \
9dd3a467 5528 { \
76ca31c0
NC		 5529 char buf[40]; \
5530 sprintf_vma (buf, section->sh_entsize); \
5531 /* Note: coded this way so that there is a single string for \
5532 translation. */ \
5533 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5534 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5535 (unsigned) expected_entsize); \
9dd3a467 5536 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5537 } \
5538 } \
08d8fa11 5539 while (0)
9dd3a467
NC		 5540
5541#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5542 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5543 sizeof (Elf64_External_##type))
5544
252b5132
RH		 5545 for (i = 0, section = section_headers;
5546 i < elf_header.e_shnum;
b34976b6 5547 i++, section++)
252b5132 5548 {
2cf0635d 5549 char * name = SECTION_NAME (section);
252b5132
RH		 5550
5551 if (section->sh_type == SHT_DYNSYM)
5552 {
5553 if (dynamic_symbols != NULL)
5554 {
5555 error (_("File contains multiple dynamic symbol tables\n"));
5556 continue;
5557 }
5558
08d8fa11 5559 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5560 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5561 }
5562 else if (section->sh_type == SHT_STRTAB
18bd398b 5563 && streq (name, ".dynstr"))
252b5132
RH		 5564 {
5565 if (dynamic_strings != NULL)
5566 {
5567 error (_("File contains multiple dynamic string tables\n"));
5568 continue;
5569 }
5570
3f5e193b
NC		 5571 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5572 1, section->sh_size,
5573 _("dynamic strings"));
59245841 5574 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5575 }
9ad5cbcf
AM		 5576 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5577 {
5578 if (symtab_shndx_hdr != NULL)
5579 {
5580 error (_("File contains multiple symtab shndx tables\n"));
5581 continue;
5582 }
5583 symtab_shndx_hdr = section;
5584 }
08d8fa11
JJ		 5585 else if (section->sh_type == SHT_SYMTAB)
5586 CHECK_ENTSIZE (section, i, Sym);
5587 else if (section->sh_type == SHT_GROUP)
5588 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5589 else if (section->sh_type == SHT_REL)
5590 CHECK_ENTSIZE (section, i, Rel);
5591 else if (section->sh_type == SHT_RELA)
5592 CHECK_ENTSIZE (section, i, Rela);
252b5132 5593 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5594 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5595 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5596 || do_debug_str || do_debug_loc || do_debug_ranges
5597 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5598 && (const_strneq (name, ".debug_")
5599 || const_strneq (name, ".zdebug_")))
252b5132 5600 {
1b315056
CS		 5601 if (name[1] == 'z')
5602 name += sizeof (".zdebug_") - 1;
5603 else
5604 name += sizeof (".debug_") - 1;
252b5132
RH		 5605
5606 if (do_debugging
4723351a
CC		 5607 || (do_debug_info && const_strneq (name, "info"))
5608 || (do_debug_info && const_strneq (name, "types"))
5609 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5610 || (do_debug_lines && strcmp (name, "line") == 0)
5611 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5612 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5613 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5614 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5615 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5616 || (do_debug_aranges && const_strneq (name, "aranges"))
5617 || (do_debug_ranges && const_strneq (name, "ranges"))
5618 || (do_debug_frames && const_strneq (name, "frame"))
5619 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5620 || (do_debug_macinfo && const_strneq (name, "macro"))
5621 || (do_debug_str && const_strneq (name, "str"))
5622 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5623 || (do_debug_addr && const_strneq (name, "addr"))
5624 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5625 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5626 )
09c11c86 5627 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5628 }
a262ae96 5629 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5630 else if ((do_debugging || do_debug_info)
0112cd26 5631 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5632 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5633 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5634 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5635 else if (do_gdb_index && streq (name, ".gdb_index"))
5636 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5637 /* Trace sections for Itanium VMS. */
5638 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5639 || do_trace_aranges)
5640 && const_strneq (name, ".trace_"))
5641 {
5642 name += sizeof (".trace_") - 1;
5643
5644 if (do_debugging
5645 || (do_trace_info && streq (name, "info"))
5646 || (do_trace_abbrevs && streq (name, "abbrev"))
5647 || (do_trace_aranges && streq (name, "aranges"))
5648 )
5649 request_dump_bynumber (i, DEBUG_DUMP);
5650 }
252b5132
RH		 5651 }
5652
5653 if (! do_sections)
5654 return 1;
5655
3a1a2036
NC		 5656 if (elf_header.e_shnum > 1)
5657 printf (_("\nSection Headers:\n"));
5658 else
5659 printf (_("\nSection Header:\n"));
76da6bbe 5660
f7a99963 5661 if (is_32bit_elf)
595cf52e 5662 {
5477e8a0 5663 if (do_section_details)
595cf52e
L		 5664 {
5665 printf (_(" [Nr] Name\n"));
5477e8a0 5666 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5667 }
5668 else
5669 printf
5670 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5671 }
d974e256 5672 else if (do_wide)
595cf52e 5673 {
5477e8a0 5674 if (do_section_details)
595cf52e
L		 5675 {
5676 printf (_(" [Nr] Name\n"));
5477e8a0 5677 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5678 }
5679 else
5680 printf
5681 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5682 }
f7a99963
NC		 5683 else
5684 {
5477e8a0 5685 if (do_section_details)
595cf52e
L		 5686 {
5687 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5688 printf (_(" Type Address Offset Link\n"));
5689 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5690 }
5691 else
5692 {
5693 printf (_(" [Nr] Name Type Address Offset\n"));
5694 printf (_(" Size EntSize Flags Link Info Align\n"));
5695 }
f7a99963 5696 }
252b5132 5697
5477e8a0
L		 5698 if (do_section_details)
5699 printf (_(" Flags\n"));
5700
252b5132
RH		 5701 for (i = 0, section = section_headers;
5702 i < elf_header.e_shnum;
b34976b6 5703 i++, section++)
252b5132 5704 {
7bfd842d 5705 printf (" [%2u] ", i);
5477e8a0 5706 if (do_section_details)
74e1a04b 5707 printf ("%s\n ", printable_section_name (section));
595cf52e 5708 else
74e1a04b 5709 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5710
ea52a088
NC		 5711 printf (do_wide ? " %-15s " : " %-15.15s ",
5712 get_section_type_name (section->sh_type));
0b4362b0 5713
f7a99963
NC		 5714 if (is_32bit_elf)
5715 {
cfcac11d
NC		 5716 const char * link_too_big = NULL;
5717
f7a99963 5718 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5719
f7a99963
NC		 5720 printf ( " %6.6lx %6.6lx %2.2lx",
5721 (unsigned long) section->sh_offset,
5722 (unsigned long) section->sh_size,
5723 (unsigned long) section->sh_entsize);
d1133906 5724
5477e8a0
L		 5725 if (do_section_details)
5726 fputs (" ", stdout);
5727 else
5728 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5729
cfcac11d
NC		 5730 if (section->sh_link >= elf_header.e_shnum)
5731 {
5732 link_too_big = "";
5733 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5734 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5735 switch (elf_header.e_machine)
5736 {
caa83f8b 5737 case EM_386:
22abe556 5738 case EM_IAMCU:
caa83f8b 5739 case EM_X86_64:
7f502d6c 5740 case EM_L1OM:
7a9068fe 5741 case EM_K1OM:
cfcac11d
NC		 5742 case EM_OLD_SPARCV9:
5743 case EM_SPARC32PLUS:
5744 case EM_SPARCV9:
5745 case EM_SPARC:
5746 if (section->sh_link == (SHN_BEFORE & 0xffff))
5747 link_too_big = "BEFORE";
5748 else if (section->sh_link == (SHN_AFTER & 0xffff))
5749 link_too_big = "AFTER";
5750 break;
5751 default:
5752 break;
5753 }
5754 }
5755
5756 if (do_section_details)
5757 {
5758 if (link_too_big != NULL && * link_too_big)
5759 printf ("<%s> ", link_too_big);
5760 else
5761 printf ("%2u ", section->sh_link);
5762 printf ("%3u %2lu\n", section->sh_info,
5763 (unsigned long) section->sh_addralign);
5764 }
5765 else
5766 printf ("%2u %3u %2lu\n",
5767 section->sh_link,
5768 section->sh_info,
5769 (unsigned long) section->sh_addralign);
5770
5771 if (link_too_big && ! * link_too_big)
5772 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5773 i, section->sh_link);
f7a99963 5774 }
d974e256
JJ		 5775 else if (do_wide)
5776 {
5777 print_vma (section->sh_addr, LONG_HEX);
5778
5779 if ((long) section->sh_offset == section->sh_offset)
5780 printf (" %6.6lx", (unsigned long) section->sh_offset);
5781 else
5782 {
5783 putchar (' ');
5784 print_vma (section->sh_offset, LONG_HEX);
5785 }
5786
5787 if ((unsigned long) section->sh_size == section->sh_size)
5788 printf (" %6.6lx", (unsigned long) section->sh_size);
5789 else
5790 {
5791 putchar (' ');
5792 print_vma (section->sh_size, LONG_HEX);
5793 }
5794
5795 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5796 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5797 else
5798 {
5799 putchar (' ');
5800 print_vma (section->sh_entsize, LONG_HEX);
5801 }
5802
5477e8a0
L		 5803 if (do_section_details)
5804 fputs (" ", stdout);
5805 else
5806 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5807
72de5009 5808 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5809
5810 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5811 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5812 else
5813 {
5814 print_vma (section->sh_addralign, DEC);
5815 putchar ('\n');
5816 }
5817 }
5477e8a0 5818 else if (do_section_details)
595cf52e 5819 {
5477e8a0 5820 printf (" %-15.15s ",
595cf52e 5821 get_section_type_name (section->sh_type));
595cf52e
L		 5822 print_vma (section->sh_addr, LONG_HEX);
5823 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5824 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5825 else
5826 {
5827 printf (" ");
5828 print_vma (section->sh_offset, LONG_HEX);
5829 }
72de5009 5830 printf (" %u\n ", section->sh_link);
595cf52e 5831 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5832 putchar (' ');
595cf52e
L		 5833 print_vma (section->sh_entsize, LONG_HEX);
5834
72de5009
AM		 5835 printf (" %-16u %lu\n",
5836 section->sh_info,
595cf52e
L		 5837 (unsigned long) section->sh_addralign);
5838 }
f7a99963
NC		 5839 else
5840 {
5841 putchar (' ');
5842 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5843 if ((long) section->sh_offset == section->sh_offset)
5844 printf (" %8.8lx", (unsigned long) section->sh_offset);
5845 else
5846 {
5847 printf (" ");
5848 print_vma (section->sh_offset, LONG_HEX);
5849 }
f7a99963
NC		 5850 printf ("\n ");
5851 print_vma (section->sh_size, LONG_HEX);
5852 printf (" ");
5853 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5854
d1133906 5855 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5856
72de5009
AM		 5857 printf (" %2u %3u %lu\n",
5858 section->sh_link,
5859 section->sh_info,
f7a99963
NC		 5860 (unsigned long) section->sh_addralign);
5861 }
5477e8a0
L		 5862
5863 if (do_section_details)
77115a4a
L		 5864 {
5865 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5866 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5867 {
5868 /* Minimum section size is 12 bytes for 32-bit compression
5869 header + 12 bytes for compressed data header. */
5870 unsigned char buf[24];
5871 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5872 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5873 sizeof (buf), _("compression header")))
5874 {
5875 Elf_Internal_Chdr chdr;
5876 get_compression_header (&chdr, buf);
5877 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5878 printf (" ZLIB, ");
5879 else
5880 printf (_(" [<unknown>: 0x%x], "),
5881 chdr.ch_type);
5882 print_vma (chdr.ch_size, LONG_HEX);
5883 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5884 }
5885 }
5886 }
252b5132
RH		 5887 }
5888
5477e8a0 5889 if (!do_section_details)
3dbcc61d
NC		 5890 {
5891 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5892 || elf_header.e_machine == EM_L1OM
5893 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5894 printf (_("Key to Flags:\n\
5895 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5896 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5897 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5898 else
5899 printf (_("Key to Flags:\n\
e3c8793a 5900 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5901 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5902 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5903 }
d1133906 5904
252b5132
RH		 5905 return 1;
5906}
5907
f5842774
L		 5908static const char *
5909get_group_flags (unsigned int flags)
5910{
5911 static char buff[32];
5912 switch (flags)
5913 {
220453ec
AM		 5914 case 0:
5915 return "";
5916
f5842774 5917 case GRP_COMDAT:
220453ec 5918 return "COMDAT ";
f5842774
L		 5919
5920 default:
220453ec 5921 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5922 break;
5923 }
5924 return buff;
5925}
5926
5927static int
2cf0635d 5928process_section_groups (FILE * file)
f5842774 5929{
2cf0635d 5930 Elf_Internal_Shdr * section;
f5842774 5931 unsigned int i;
2cf0635d
NC		 5932 struct group * group;
5933 Elf_Internal_Shdr * symtab_sec;
5934 Elf_Internal_Shdr * strtab_sec;
5935 Elf_Internal_Sym * symtab;
ba5cdace 5936 unsigned long num_syms;
2cf0635d 5937 char * strtab;
c256ffe7 5938 size_t strtab_size;
d1f5c6e3
L		 5939
5940 /* Don't process section groups unless needed. */
5941 if (!do_unwind && !do_section_groups)
5942 return 1;
f5842774
L		 5943
5944 if (elf_header.e_shnum == 0)
5945 {
5946 if (do_section_groups)
82f2dbf7 5947 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5948
5949 return 1;
5950 }
5951
5952 if (section_headers == NULL)
5953 {
5954 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5955 /* PR 13622: This can happen with a corrupt ELF header. */
5956 return 0;
f5842774
L		 5957 }
5958
3f5e193b
NC		 5959 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5960 sizeof (struct group *));
e4b17d5c
L		 5961
5962 if (section_headers_groups == NULL)
5963 {
8b73c356
NC		 5964 error (_("Out of memory reading %u section group headers\n"),
5965 elf_header.e_shnum);
e4b17d5c
L		 5966 return 0;
5967 }
5968
f5842774 5969 /* Scan the sections for the group section. */
d1f5c6e3 5970 group_count = 0;
f5842774
L		 5971 for (i = 0, section = section_headers;
5972 i < elf_header.e_shnum;
5973 i++, section++)
e4b17d5c
L		 5974 if (section->sh_type == SHT_GROUP)
5975 group_count++;
5976
d1f5c6e3
L		 5977 if (group_count == 0)
5978 {
5979 if (do_section_groups)
5980 printf (_("\nThere are no section groups in this file.\n"));
5981
5982 return 1;
5983 }
5984
3f5e193b 5985 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5986
5987 if (section_groups == NULL)
5988 {
8b73c356
NC		 5989 error (_("Out of memory reading %lu groups\n"),
5990 (unsigned long) group_count);
e4b17d5c
L		 5991 return 0;
5992 }
5993
d1f5c6e3
L		 5994 symtab_sec = NULL;
5995 strtab_sec = NULL;
5996 symtab = NULL;
ba5cdace 5997 num_syms = 0;
d1f5c6e3 5998 strtab = NULL;
c256ffe7 5999 strtab_size = 0;
e4b17d5c
L		 6000 for (i = 0, section = section_headers, group = section_groups;
6001 i < elf_header.e_shnum;
6002 i++, section++)
f5842774
L		 6003 {
6004 if (section->sh_type == SHT_GROUP)
6005 {
74e1a04b
NC		 6006 const char * name = printable_section_name (section);
6007 const char * group_name;
2cf0635d
NC		 6008 unsigned char * start;
6009 unsigned char * indices;
f5842774 6010 unsigned int entry, j, size;
2cf0635d
NC		 6011 Elf_Internal_Shdr * sec;
6012 Elf_Internal_Sym * sym;
f5842774
L		 6013
6014 /* Get the symbol table. */
4fbb74a6
AM		 6015 if (section->sh_link >= elf_header.e_shnum
6016 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6017 != SHT_SYMTAB))
f5842774
L		 6018 {
6019 error (_("Bad sh_link in group section `%s'\n"), name);
6020 continue;
6021 }
d1f5c6e3
L		 6022
6023 if (symtab_sec != sec)
6024 {
6025 symtab_sec = sec;
6026 if (symtab)
6027 free (symtab);
ba5cdace 6028 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6029 }
f5842774 6030
dd24e3da
NC		 6031 if (symtab == NULL)
6032 {
6033 error (_("Corrupt header in group section `%s'\n"), name);
6034 continue;
6035 }
6036
ba5cdace
NC		 6037 if (section->sh_info >= num_syms)
6038 {
6039 error (_("Bad sh_info in group section `%s'\n"), name);
6040 continue;
6041 }
6042
f5842774
L		 6043 sym = symtab + section->sh_info;
6044
6045 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6046 {
4fbb74a6
AM		 6047 if (sym->st_shndx == 0
6048 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6049 {
6050 error (_("Bad sh_info in group section `%s'\n"), name);
6051 continue;
6052 }
ba2685cc 6053
4fbb74a6 6054 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6055 strtab_sec = NULL;
6056 if (strtab)
6057 free (strtab);
f5842774 6058 strtab = NULL;
c256ffe7 6059 strtab_size = 0;
f5842774
L		 6060 }
6061 else
6062 {
6063 /* Get the string table. */
4fbb74a6 6064 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6065 {
6066 strtab_sec = NULL;
6067 if (strtab)
6068 free (strtab);
6069 strtab = NULL;
6070 strtab_size = 0;
6071 }
6072 else if (strtab_sec
4fbb74a6 6073 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6074 {
6075 strtab_sec = sec;
6076 if (strtab)
6077 free (strtab);
071436c6 6078
3f5e193b 6079 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6080 1, strtab_sec->sh_size,
6081 _("string table"));
c256ffe7 6082 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6083 }
c256ffe7 6084 group_name = sym->st_name < strtab_size
2b692964 6085 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6086 }
6087
c9c1d674
EG		 6088 /* PR 17531: file: loop. */
6089 if (section->sh_entsize > section->sh_size)
6090 {
6091 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6092 printable_section_name (section),
8066deb1
AM		 6093 (unsigned long) section->sh_entsize,
6094 (unsigned long) section->sh_size);
c9c1d674
EG		 6095 break;
6096 }
6097
3f5e193b
NC		 6098 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6099 1, section->sh_size,
6100 _("section data"));
59245841
NC		 6101 if (start == NULL)
6102 continue;
f5842774
L		 6103
6104 indices = start;
6105 size = (section->sh_size / section->sh_entsize) - 1;
6106 entry = byte_get (indices, 4);
6107 indices += 4;
e4b17d5c
L		 6108
6109 if (do_section_groups)
6110 {
2b692964 6111 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6112 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6113
e4b17d5c
L		 6114 printf (_(" [Index] Name\n"));
6115 }
6116
6117 group->group_index = i;
6118
f5842774
L		 6119 for (j = 0; j < size; j++)
6120 {
2cf0635d 6121 struct group_list * g;
e4b17d5c 6122
f5842774
L		 6123 entry = byte_get (indices, 4);
6124 indices += 4;
6125
4fbb74a6 6126 if (entry >= elf_header.e_shnum)
391cb864 6127 {
57028622
NC		 6128 static unsigned num_group_errors = 0;
6129
6130 if (num_group_errors ++ < 10)
6131 {
6132 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6133 entry, i, elf_header.e_shnum - 1);
6134 if (num_group_errors == 10)
6135 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6136 }
391cb864
L		 6137 continue;
6138 }
391cb864 6139
4fbb74a6 6140 if (section_headers_groups [entry] != NULL)
e4b17d5c 6141 {
d1f5c6e3
L		 6142 if (entry)
6143 {
57028622
NC		 6144 static unsigned num_errs = 0;
6145
6146 if (num_errs ++ < 10)
6147 {
6148 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6149 entry, i,
6150 section_headers_groups [entry]->group_index);
6151 if (num_errs == 10)
6152 warn (_("Further error messages about already contained group sections suppressed\n"));
6153 }
d1f5c6e3
L		 6154 continue;
6155 }
6156 else
6157 {
6158 /* Intel C/C++ compiler may put section 0 in a
6159 section group. We just warn it the first time
6160 and ignore it afterwards. */
6161 static int warned = 0;
6162 if (!warned)
6163 {
6164 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6165 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6166 warned++;
6167 }
6168 }
e4b17d5c
L		 6169 }
6170
4fbb74a6 6171 section_headers_groups [entry] = group;
e4b17d5c
L		 6172
6173 if (do_section_groups)
6174 {
4fbb74a6 6175 sec = section_headers + entry;
74e1a04b 6176 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6177 }
6178
3f5e193b 6179 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6180 g->section_index = entry;
6181 g->next = group->root;
6182 group->root = g;
f5842774
L		 6183 }
6184
f5842774
L		 6185 if (start)
6186 free (start);
e4b17d5c
L		 6187
6188 group++;
f5842774
L		 6189 }
6190 }
6191
d1f5c6e3
L		 6192 if (symtab)
6193 free (symtab);
6194 if (strtab)
6195 free (strtab);
f5842774
L		 6196 return 1;
6197}
6198
28f997cf
TG		 6199/* Data used to display dynamic fixups. */
6200
6201struct ia64_vms_dynfixup
6202{
6203 bfd_vma needed_ident; /* Library ident number. */
6204 bfd_vma needed; /* Index in the dstrtab of the library name. */
6205 bfd_vma fixup_needed; /* Index of the library. */
6206 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6207 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6208};
6209
6210/* Data used to display dynamic relocations. */
6211
6212struct ia64_vms_dynimgrela
6213{
6214 bfd_vma img_rela_cnt; /* Number of relocations. */
6215 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6216};
6217
6218/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6219 library). */
6220
6221static void
6222dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6223 const char *strtab, unsigned int strtab_sz)
6224{
6225 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6226 long i;
6227 const char *lib_name;
6228
6229 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6230 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6231 _("dynamic section image fixups"));
6232 if (!imfs)
6233 return;
6234
6235 if (fixup->needed < strtab_sz)
6236 lib_name = strtab + fixup->needed;
6237 else
6238 {
6239 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6240 (unsigned long) fixup->needed);
28f997cf
TG		 6241 lib_name = "???";
6242 }
6243 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6244 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6245 printf
6246 (_("Seg Offset Type SymVec DataType\n"));
6247
6248 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6249 {
6250 unsigned int type;
6251 const char *rtype;
6252
6253 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6254 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6255 type = BYTE_GET (imfs [i].type);
6256 rtype = elf_ia64_reloc_type (type);
6257 if (rtype == NULL)
6258 printf (" 0x%08x ", type);
6259 else
6260 printf (" %-32s ", rtype);
6261 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6262 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6263 }
6264
6265 free (imfs);
6266}
6267
6268/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6269
6270static void
6271dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6272{
6273 Elf64_External_VMS_IMAGE_RELA *imrs;
6274 long i;
6275
6276 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6277 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6278 _("dynamic section image relocations"));
28f997cf
TG		 6279 if (!imrs)
6280 return;
6281
6282 printf (_("\nImage relocs\n"));
6283 printf
6284 (_("Seg Offset Type Addend Seg Sym Off\n"));
6285
6286 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6287 {
6288 unsigned int type;
6289 const char *rtype;
6290
6291 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6292 printf ("%08" BFD_VMA_FMT "x ",
6293 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6294 type = BYTE_GET (imrs [i].type);
6295 rtype = elf_ia64_reloc_type (type);
6296 if (rtype == NULL)
6297 printf ("0x%08x ", type);
6298 else
6299 printf ("%-31s ", rtype);
6300 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6301 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6302 printf ("%08" BFD_VMA_FMT "x\n",
6303 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6304 }
6305
6306 free (imrs);
6307}
6308
6309/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6310
6311static int
6312process_ia64_vms_dynamic_relocs (FILE *file)
6313{
6314 struct ia64_vms_dynfixup fixup;
6315 struct ia64_vms_dynimgrela imgrela;
6316 Elf_Internal_Dyn *entry;
6317 int res = 0;
6318 bfd_vma strtab_off = 0;
6319 bfd_vma strtab_sz = 0;
6320 char *strtab = NULL;
6321
6322 memset (&fixup, 0, sizeof (fixup));
6323 memset (&imgrela, 0, sizeof (imgrela));
6324
6325 /* Note: the order of the entries is specified by the OpenVMS specs. */
6326 for (entry = dynamic_section;
6327 entry < dynamic_section + dynamic_nent;
6328 entry++)
6329 {
6330 switch (entry->d_tag)
6331 {
6332 case DT_IA_64_VMS_STRTAB_OFFSET:
6333 strtab_off = entry->d_un.d_val;
6334 break;
6335 case DT_STRSZ:
6336 strtab_sz = entry->d_un.d_val;
6337 if (strtab == NULL)
6338 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6339 1, strtab_sz, _("dynamic string section"));
6340 break;
6341
6342 case DT_IA_64_VMS_NEEDED_IDENT:
6343 fixup.needed_ident = entry->d_un.d_val;
6344 break;
6345 case DT_NEEDED:
6346 fixup.needed = entry->d_un.d_val;
6347 break;
6348 case DT_IA_64_VMS_FIXUP_NEEDED:
6349 fixup.fixup_needed = entry->d_un.d_val;
6350 break;
6351 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6352 fixup.fixup_rela_cnt = entry->d_un.d_val;
6353 break;
6354 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6355 fixup.fixup_rela_off = entry->d_un.d_val;
6356 res++;
6357 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6358 break;
6359
6360 case DT_IA_64_VMS_IMG_RELA_CNT:
6361 imgrela.img_rela_cnt = entry->d_un.d_val;
6362 break;
6363 case DT_IA_64_VMS_IMG_RELA_OFF:
6364 imgrela.img_rela_off = entry->d_un.d_val;
6365 res++;
6366 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6367 break;
6368
6369 default:
6370 break;
6371 }
6372 }
6373
6374 if (strtab != NULL)
6375 free (strtab);
6376
6377 return res;
6378}
6379
85b1c36d 6380static struct
566b0d53 6381{
2cf0635d 6382 const char * name;
566b0d53
L		 6383 int reloc;
6384 int size;
6385 int rela;
6386} dynamic_relocations [] =
6387{
6388 { "REL", DT_REL, DT_RELSZ, FALSE },
6389 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6390 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6391};
6392
252b5132 6393/* Process the reloc section. */
18bd398b 6394
252b5132 6395static int
2cf0635d 6396process_relocs (FILE * file)
252b5132 6397{
b34976b6
AM		 6398 unsigned long rel_size;
6399 unsigned long rel_offset;
252b5132
RH		 6400
6401
6402 if (!do_reloc)
6403 return 1;
6404
6405 if (do_using_dynamic)
6406 {
566b0d53 6407 int is_rela;
2cf0635d 6408 const char * name;
566b0d53
L		 6409 int has_dynamic_reloc;
6410 unsigned int i;
0de14b54 6411
566b0d53 6412 has_dynamic_reloc = 0;
252b5132 6413
566b0d53 6414 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6415 {
566b0d53
L		 6416 is_rela = dynamic_relocations [i].rela;
6417 name = dynamic_relocations [i].name;
6418 rel_size = dynamic_info [dynamic_relocations [i].size];
6419 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6420
566b0d53
L		 6421 has_dynamic_reloc |= rel_size;
6422
6423 if (is_rela == UNKNOWN)
aa903cfb 6424 {
566b0d53
L		 6425 if (dynamic_relocations [i].reloc == DT_JMPREL)
6426 switch (dynamic_info[DT_PLTREL])
6427 {
6428 case DT_REL:
6429 is_rela = FALSE;
6430 break;
6431 case DT_RELA:
6432 is_rela = TRUE;
6433 break;
6434 }
aa903cfb 6435 }
252b5132 6436
566b0d53
L		 6437 if (rel_size)
6438 {
6439 printf
6440 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6441 name, rel_offset, rel_size);
252b5132 6442
d93f0186
NC		 6443 dump_relocations (file,
6444 offset_from_vma (file, rel_offset, rel_size),
6445 rel_size,
566b0d53 6446 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6447 dynamic_strings, dynamic_strings_length,
6448 is_rela, 1);
566b0d53 6449 }
252b5132 6450 }
566b0d53 6451
28f997cf
TG		 6452 if (is_ia64_vms ())
6453 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6454
566b0d53 6455 if (! has_dynamic_reloc)
252b5132
RH		 6456 printf (_("\nThere are no dynamic relocations in this file.\n"));
6457 }
6458 else
6459 {
2cf0635d 6460 Elf_Internal_Shdr * section;
b34976b6
AM		 6461 unsigned long i;
6462 int found = 0;
252b5132
RH		 6463
6464 for (i = 0, section = section_headers;
6465 i < elf_header.e_shnum;
b34976b6 6466 i++, section++)
252b5132
RH		 6467 {
6468 if ( section->sh_type != SHT_RELA
6469 && section->sh_type != SHT_REL)
6470 continue;
6471
6472 rel_offset = section->sh_offset;
6473 rel_size = section->sh_size;
6474
6475 if (rel_size)
6476 {
2cf0635d 6477 Elf_Internal_Shdr * strsec;
b34976b6 6478 int is_rela;
103f02d3 6479
252b5132
RH		 6480 printf (_("\nRelocation section "));
6481
6482 if (string_table == NULL)
19936277 6483 printf ("%d", section->sh_name);
252b5132 6484 else
74e1a04b 6485 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6486
6487 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6488 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6489
d79b3d50
NC		 6490 is_rela = section->sh_type == SHT_RELA;
6491
4fbb74a6
AM		 6492 if (section->sh_link != 0
6493 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6494 {
2cf0635d
NC		 6495 Elf_Internal_Shdr * symsec;
6496 Elf_Internal_Sym * symtab;
d79b3d50 6497 unsigned long nsyms;
c256ffe7 6498 unsigned long strtablen = 0;
2cf0635d 6499 char * strtab = NULL;
57346661 6500
4fbb74a6 6501 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6502 if (symsec->sh_type != SHT_SYMTAB
6503 && symsec->sh_type != SHT_DYNSYM)
6504 continue;
6505
ba5cdace 6506 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6507
af3fc3bc
AM		 6508 if (symtab == NULL)
6509 continue;
252b5132 6510
4fbb74a6
AM		 6511 if (symsec->sh_link != 0
6512 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6513 {
4fbb74a6 6514 strsec = section_headers + symsec->sh_link;
103f02d3 6515
3f5e193b 6516 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6517 1, strsec->sh_size,
6518 _("string table"));
c256ffe7
JJ		 6519 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6520 }
252b5132 6521
d79b3d50 6522 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6523 symtab, nsyms, strtab, strtablen,
6524 is_rela,
6525 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6526 if (strtab)
6527 free (strtab);
6528 free (symtab);
6529 }
6530 else
6531 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6532 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6533
6534 found = 1;
6535 }
6536 }
6537
6538 if (! found)
6539 printf (_("\nThere are no relocations in this file.\n"));
6540 }
6541
6542 return 1;
6543}
6544
4d6ed7c8
NC		 6545/* An absolute address consists of a section and an offset. If the
6546 section is NULL, the offset itself is the address, otherwise, the
6547 address equals to LOAD_ADDRESS(section) + offset. */
6548
6549struct absaddr
948f632f
DA		 6550{
6551 unsigned short section;
6552 bfd_vma offset;
6553};
4d6ed7c8 6554
1949de15
L		 6555#define ABSADDR(a) \
6556 ((a).section \
6557 ? section_headers [(a).section].sh_addr + (a).offset \
6558 : (a).offset)
6559
948f632f
DA		 6560/* Find the nearest symbol at or below ADDR. Returns the symbol
6561 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6562
4d6ed7c8 6563static void
2cf0635d 6564find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6565 unsigned long nsyms,
6566 const char * strtab,
6567 unsigned long strtab_size,
6568 struct absaddr addr,
6569 const char ** symname,
6570 bfd_vma * offset)
4d6ed7c8 6571{
d3ba0551 6572 bfd_vma dist = 0x100000;
2cf0635d 6573 Elf_Internal_Sym * sym;
948f632f
DA		 6574 Elf_Internal_Sym * beg;
6575 Elf_Internal_Sym * end;
2cf0635d 6576 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6577
0b6ae522 6578 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6579 beg = symtab;
6580 end = symtab + nsyms;
0b6ae522 6581
948f632f 6582 while (beg < end)
4d6ed7c8 6583 {
948f632f
DA		 6584 bfd_vma value;
6585
6586 sym = beg + (end - beg) / 2;
0b6ae522 6587
948f632f 6588 value = sym->st_value;
0b6ae522
DJ		 6589 REMOVE_ARCH_BITS (value);
6590
948f632f 6591 if (sym->st_name != 0
4d6ed7c8 6592 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6593 && addr.offset >= value
6594 && addr.offset - value < dist)
4d6ed7c8
NC		 6595 {
6596 best = sym;
0b6ae522 6597 dist = addr.offset - value;
4d6ed7c8
NC		 6598 if (!dist)
6599 break;
6600 }
948f632f
DA		 6601
6602 if (addr.offset < value)
6603 end = sym;
6604 else
6605 beg = sym + 1;
4d6ed7c8 6606 }
1b31d05e 6607
4d6ed7c8
NC		 6608 if (best)
6609 {
57346661 6610 *symname = (best->st_name >= strtab_size
2b692964 6611 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6612 *offset = dist;
6613 return;
6614 }
1b31d05e 6615
4d6ed7c8
NC		 6616 *symname = NULL;
6617 *offset = addr.offset;
6618}
6619
948f632f
DA		 6620static int
6621symcmp (const void *p, const void *q)
6622{
6623 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6624 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6625
6626 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6627}
6628
6629/* Process the unwind section. */
6630
6631#include "unwind-ia64.h"
6632
6633struct ia64_unw_table_entry
6634{
6635 struct absaddr start;
6636 struct absaddr end;
6637 struct absaddr info;
6638};
6639
6640struct ia64_unw_aux_info
6641{
6642 struct ia64_unw_table_entry *table; /* Unwind table. */
6643 unsigned long table_len; /* Length of unwind table. */
6644 unsigned char * info; /* Unwind info. */
6645 unsigned long info_size; /* Size of unwind info. */
6646 bfd_vma info_addr; /* Starting address of unwind info. */
6647 bfd_vma seg_base; /* Starting address of segment. */
6648 Elf_Internal_Sym * symtab; /* The symbol table. */
6649 unsigned long nsyms; /* Number of symbols. */
6650 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6651 unsigned long nfuns; /* Number of entries in funtab. */
6652 char * strtab; /* The string table. */
6653 unsigned long strtab_size; /* Size of string table. */
6654};
6655
4d6ed7c8 6656static void
2cf0635d 6657dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6658{
2cf0635d 6659 struct ia64_unw_table_entry * tp;
948f632f 6660 unsigned long j, nfuns;
4d6ed7c8 6661 int in_body;
7036c0e1 6662
948f632f
DA		 6663 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6664 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6665 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6666 aux->funtab[nfuns++] = aux->symtab[j];
6667 aux->nfuns = nfuns;
6668 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6669
4d6ed7c8
NC		 6670 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6671 {
6672 bfd_vma stamp;
6673 bfd_vma offset;
2cf0635d
NC		 6674 const unsigned char * dp;
6675 const unsigned char * head;
53774b7e 6676 const unsigned char * end;
2cf0635d 6677 const char * procname;
4d6ed7c8 6678
948f632f 6679 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6680 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6681
6682 fputs ("\n<", stdout);
6683
6684 if (procname)
6685 {
6686 fputs (procname, stdout);
6687
6688 if (offset)
6689 printf ("+%lx", (unsigned long) offset);
6690 }
6691
6692 fputs (">: [", stdout);
6693 print_vma (tp->start.offset, PREFIX_HEX);
6694 fputc ('-', stdout);
6695 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6696 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6697 (unsigned long) (tp->info.offset - aux->seg_base));
6698
53774b7e
NC		 6699 /* PR 17531: file: 86232b32. */
6700 if (aux->info == NULL)
6701 continue;
6702
6703 /* PR 17531: file: 0997b4d1. */
6704 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6705 {
6706 warn (_("Invalid offset %lx in table entry %ld\n"),
6707 (long) tp->info.offset, (long) (tp - aux->table));
6708 continue;
6709 }
6710
1949de15 6711 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6712 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6713
86f55779 6714 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6715 (unsigned) UNW_VER (stamp),
6716 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6717 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6718 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6719 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6720
6721 if (UNW_VER (stamp) != 1)
6722 {
2b692964 6723 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6724 continue;
6725 }
6726
6727 in_body = 0;
53774b7e
NC		 6728 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6729 /* PR 17531: file: 16ceda89. */
6730 if (end > aux->info + aux->info_size)
6731 end = aux->info + aux->info_size;
6732 for (dp = head + 8; dp < end;)
b4477bc8 6733 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6734 }
948f632f
DA		 6735
6736 free (aux->funtab);
4d6ed7c8
NC		 6737}
6738
53774b7e 6739static bfd_boolean
2cf0635d
NC		 6740slurp_ia64_unwind_table (FILE * file,
6741 struct ia64_unw_aux_info * aux,
6742 Elf_Internal_Shdr * sec)
4d6ed7c8 6743{
89fac5e3 6744 unsigned long size, nrelas, i;
2cf0635d
NC		 6745 Elf_Internal_Phdr * seg;
6746 struct ia64_unw_table_entry * tep;
6747 Elf_Internal_Shdr * relsec;
6748 Elf_Internal_Rela * rela;
6749 Elf_Internal_Rela * rp;
6750 unsigned char * table;
6751 unsigned char * tp;
6752 Elf_Internal_Sym * sym;
6753 const char * relname;
4d6ed7c8 6754
53774b7e
NC		 6755 aux->table_len = 0;
6756
4d6ed7c8
NC		 6757 /* First, find the starting address of the segment that includes
6758 this section: */
6759
6760 if (elf_header.e_phnum)
6761 {
d93f0186 6762 if (! get_program_headers (file))
53774b7e 6763 return FALSE;
4d6ed7c8 6764
d93f0186
NC		 6765 for (seg = program_headers;
6766 seg < program_headers + elf_header.e_phnum;
6767 ++seg)
4d6ed7c8
NC		 6768 {
6769 if (seg->p_type != PT_LOAD)
6770 continue;
6771
6772 if (sec->sh_addr >= seg->p_vaddr
6773 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6774 {
6775 aux->seg_base = seg->p_vaddr;
6776 break;
6777 }
6778 }
4d6ed7c8
NC		 6779 }
6780
6781 /* Second, build the unwind table from the contents of the unwind section: */
6782 size = sec->sh_size;
3f5e193b
NC		 6783 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6784 _("unwind table"));
a6e9f9df 6785 if (!table)
53774b7e 6786 return FALSE;
4d6ed7c8 6787
53774b7e 6788 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6789 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6790 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6791 tep = aux->table;
53774b7e
NC		 6792
6793 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6794 {
6795 tep->start.section = SHN_UNDEF;
6796 tep->end.section = SHN_UNDEF;
6797 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6798 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6799 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6800 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6801 tep->start.offset += aux->seg_base;
6802 tep->end.offset += aux->seg_base;
6803 tep->info.offset += aux->seg_base;
6804 }
6805 free (table);
6806
41e92641 6807 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6808 for (relsec = section_headers;
6809 relsec < section_headers + elf_header.e_shnum;
6810 ++relsec)
6811 {
6812 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6813 || relsec->sh_info >= elf_header.e_shnum
6814 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6815 continue;
6816
6817 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6818 & rela, & nrelas))
53774b7e
NC		 6819 {
6820 free (aux->table);
6821 aux->table = NULL;
6822 aux->table_len = 0;
6823 return FALSE;
6824 }
4d6ed7c8
NC		 6825
6826 for (rp = rela; rp < rela + nrelas; ++rp)
6827 {
aca88567
NC		 6828 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6829 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6830
82b1b41b
NC		 6831 /* PR 17531: file: 9fa67536. */
6832 if (relname == NULL)
6833 {
6834 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6835 continue;
6836 }
948f632f 6837
0112cd26 6838 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6839 {
82b1b41b 6840 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6841 continue;
6842 }
6843
89fac5e3 6844 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6845
53774b7e
NC		 6846 /* PR 17531: file: 5bc8d9bf. */
6847 if (i >= aux->table_len)
6848 {
6849 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6850 continue;
6851 }
6852
6853 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6854 {
6855 case 0:
6856 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6857 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6858 break;
6859 case 1:
6860 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6861 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6862 break;
6863 case 2:
6864 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6865 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6866 break;
6867 default:
6868 break;
6869 }
6870 }
6871
6872 free (rela);
6873 }
6874
53774b7e 6875 return TRUE;
4d6ed7c8
NC		 6876}
6877
1b31d05e 6878static void
2cf0635d 6879ia64_process_unwind (FILE * file)
4d6ed7c8 6880{
2cf0635d
NC		 6881 Elf_Internal_Shdr * sec;
6882 Elf_Internal_Shdr * unwsec = NULL;
6883 Elf_Internal_Shdr * strsec;
89fac5e3 6884 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6885 struct ia64_unw_aux_info aux;
f1467e33 6886
4d6ed7c8
NC		 6887 memset (& aux, 0, sizeof (aux));
6888
4d6ed7c8
NC		 6889 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6890 {
c256ffe7 6891 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6892 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6893 {
ba5cdace 6894 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6895
4fbb74a6 6896 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6897 if (aux.strtab != NULL)
6898 {
6899 error (_("Multiple auxillary string tables encountered\n"));
6900 free (aux.strtab);
6901 }
3f5e193b
NC		 6902 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6903 1, strsec->sh_size,
6904 _("string table"));
c256ffe7 6905 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6906 }
6907 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6908 unwcount++;
6909 }
6910
6911 if (!unwcount)
6912 printf (_("\nThere are no unwind sections in this file.\n"));
6913
6914 while (unwcount-- > 0)
6915 {
2cf0635d 6916 char * suffix;
579f31ac
JJ		 6917 size_t len, len2;
6918
4082ef84 6919 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6920 i < elf_header.e_shnum; ++i, ++sec)
6921 if (sec->sh_type == SHT_IA_64_UNWIND)
6922 {
6923 unwsec = sec;
6924 break;
6925 }
4082ef84
NC		 6926 /* We have already counted the number of SHT_IA64_UNWIND
6927 sections so the loop above should never fail. */
6928 assert (unwsec != NULL);
579f31ac
JJ		 6929
6930 unwstart = i + 1;
6931 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6932
e4b17d5c
L		 6933 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6934 {
6935 /* We need to find which section group it is in. */
4082ef84 6936 struct group_list * g;
e4b17d5c 6937
4082ef84
NC		 6938 if (section_headers_groups == NULL
6939 || section_headers_groups [i] == NULL)
6940 i = elf_header.e_shnum;
6941 else
e4b17d5c 6942 {
4082ef84 6943 g = section_headers_groups [i]->root;
18bd398b 6944
4082ef84
NC		 6945 for (; g != NULL; g = g->next)
6946 {
6947 sec = section_headers + g->section_index;
e4b17d5c 6948
4082ef84
NC		 6949 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6950 break;
6951 }
6952
6953 if (g == NULL)
6954 i = elf_header.e_shnum;
6955 }
e4b17d5c 6956 }
18bd398b 6957 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6958 {
18bd398b 6959 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6960 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6961 suffix = SECTION_NAME (unwsec) + len;
6962 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6963 ++i, ++sec)
18bd398b
NC		 6964 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6965 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6966 break;
6967 }
6968 else
6969 {
6970 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6971 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6972 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6973 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6974 suffix = "";
18bd398b 6975 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6976 suffix = SECTION_NAME (unwsec) + len;
6977 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6978 ++i, ++sec)
18bd398b
NC		 6979 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6980 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6981 break;
6982 }
6983
6984 if (i == elf_header.e_shnum)
6985 {
6986 printf (_("\nCould not find unwind info section for "));
6987
6988 if (string_table == NULL)
6989 printf ("%d", unwsec->sh_name);
6990 else
74e1a04b 6991 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6992 }
6993 else
4d6ed7c8 6994 {
4d6ed7c8 6995 aux.info_addr = sec->sh_addr;
3f5e193b 6996 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6997 sec->sh_size,
6998 _("unwind info"));
59245841 6999 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7000
579f31ac 7001 printf (_("\nUnwind section "));
4d6ed7c8 7002
579f31ac
JJ		 7003 if (string_table == NULL)
7004 printf ("%d", unwsec->sh_name);
7005 else
74e1a04b 7006 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7007
579f31ac 7008 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7009 (unsigned long) unwsec->sh_offset,
89fac5e3 7010 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7011
53774b7e
NC		 7012 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7013 && aux.table_len > 0)
579f31ac
JJ		 7014 dump_ia64_unwind (& aux);
7015
7016 if (aux.table)
7017 free ((char *) aux.table);
7018 if (aux.info)
7019 free ((char *) aux.info);
7020 aux.table = NULL;
7021 aux.info = NULL;
7022 }
4d6ed7c8 7023 }
4d6ed7c8 7024
4d6ed7c8
NC		 7025 if (aux.symtab)
7026 free (aux.symtab);
7027 if (aux.strtab)
7028 free ((char *) aux.strtab);
4d6ed7c8
NC		 7029}
7030
3f5e193b
NC		 7031struct hppa_unw_table_entry
7032 {
7033 struct absaddr start;
7034 struct absaddr end;
948f632f 7035 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7036 unsigned int Millicode:1; /* 1 */
7037 unsigned int Millicode_save_sr0:1; /* 2 */
7038 unsigned int Region_description:2; /* 3..4 */
7039 unsigned int reserved1:1; /* 5 */
7040 unsigned int Entry_SR:1; /* 6 */
7041 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7042 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7043 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7044 unsigned int Variable_Frame:1; /* 17 */
7045 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7046 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7047 unsigned int Stack_Overflow_Check:1; /* 20 */
7048 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7049 unsigned int Ada_Region:1; /* 22 */
7050 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7051 unsigned int cxx_try_catch:1; /* 24 */
7052 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7053 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7054 unsigned int Save_SP:1; /* 27 */
7055 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7056 unsigned int Save_MRP_in_frame:1; /* 29 */
7057 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7058 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7059
948f632f
DA		 7060 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7061 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7062 unsigned int Large_frame:1; /* 2 */
948f632f 7063 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7064 unsigned int reserved4:1; /* 4 */
7065 unsigned int Total_frame_size:27; /* 5..31 */
7066 };
7067
57346661 7068struct hppa_unw_aux_info
948f632f
DA		 7069{
7070 struct hppa_unw_table_entry * table; /* Unwind table. */
7071 unsigned long table_len; /* Length of unwind table. */
7072 bfd_vma seg_base; /* Starting address of segment. */
7073 Elf_Internal_Sym * symtab; /* The symbol table. */
7074 unsigned long nsyms; /* Number of symbols. */
7075 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7076 unsigned long nfuns; /* Number of entries in funtab. */
7077 char * strtab; /* The string table. */
7078 unsigned long strtab_size; /* Size of string table. */
7079};
57346661
AM		 7080
7081static void
2cf0635d 7082dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7083{
2cf0635d 7084 struct hppa_unw_table_entry * tp;
948f632f
DA		 7085 unsigned long j, nfuns;
7086
7087 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7088 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7089 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7090 aux->funtab[nfuns++] = aux->symtab[j];
7091 aux->nfuns = nfuns;
7092 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7093
57346661
AM		 7094 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7095 {
7096 bfd_vma offset;
2cf0635d 7097 const char * procname;
57346661 7098
948f632f 7099 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7100 aux->strtab_size, tp->start, &procname,
7101 &offset);
7102
7103 fputs ("\n<", stdout);
7104
7105 if (procname)
7106 {
7107 fputs (procname, stdout);
7108
7109 if (offset)
7110 printf ("+%lx", (unsigned long) offset);
7111 }
7112
7113 fputs (">: [", stdout);
7114 print_vma (tp->start.offset, PREFIX_HEX);
7115 fputc ('-', stdout);
7116 print_vma (tp->end.offset, PREFIX_HEX);
7117 printf ("]\n\t");
7118
18bd398b
NC		 7119#define PF(_m) if (tp->_m) printf (#_m " ");
7120#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7121 PF(Cannot_unwind);
7122 PF(Millicode);
7123 PF(Millicode_save_sr0);
18bd398b 7124 /* PV(Region_description); */
57346661
AM		 7125 PF(Entry_SR);
7126 PV(Entry_FR);
7127 PV(Entry_GR);
7128 PF(Args_stored);
7129 PF(Variable_Frame);
7130 PF(Separate_Package_Body);
7131 PF(Frame_Extension_Millicode);
7132 PF(Stack_Overflow_Check);
7133 PF(Two_Instruction_SP_Increment);
7134 PF(Ada_Region);
7135 PF(cxx_info);
7136 PF(cxx_try_catch);
7137 PF(sched_entry_seq);
7138 PF(Save_SP);
7139 PF(Save_RP);
7140 PF(Save_MRP_in_frame);
7141 PF(extn_ptr_defined);
7142 PF(Cleanup_defined);
7143 PF(MPE_XL_interrupt_marker);
7144 PF(HP_UX_interrupt_marker);
7145 PF(Large_frame);
7146 PF(Pseudo_SP_Set);
7147 PV(Total_frame_size);
7148#undef PF
7149#undef PV
7150 }
7151
18bd398b 7152 printf ("\n");
948f632f
DA		 7153
7154 free (aux->funtab);
57346661
AM		 7155}
7156
7157static int
2cf0635d
NC		 7158slurp_hppa_unwind_table (FILE * file,
7159 struct hppa_unw_aux_info * aux,
7160 Elf_Internal_Shdr * sec)
57346661 7161{
1c0751b2 7162 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7163 Elf_Internal_Phdr * seg;
7164 struct hppa_unw_table_entry * tep;
7165 Elf_Internal_Shdr * relsec;
7166 Elf_Internal_Rela * rela;
7167 Elf_Internal_Rela * rp;
7168 unsigned char * table;
7169 unsigned char * tp;
7170 Elf_Internal_Sym * sym;
7171 const char * relname;
57346661 7172
57346661
AM		 7173 /* First, find the starting address of the segment that includes
7174 this section. */
7175
7176 if (elf_header.e_phnum)
7177 {
7178 if (! get_program_headers (file))
7179 return 0;
7180
7181 for (seg = program_headers;
7182 seg < program_headers + elf_header.e_phnum;
7183 ++seg)
7184 {
7185 if (seg->p_type != PT_LOAD)
7186 continue;
7187
7188 if (sec->sh_addr >= seg->p_vaddr
7189 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7190 {
7191 aux->seg_base = seg->p_vaddr;
7192 break;
7193 }
7194 }
7195 }
7196
7197 /* Second, build the unwind table from the contents of the unwind
7198 section. */
7199 size = sec->sh_size;
3f5e193b
NC		 7200 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7201 _("unwind table"));
57346661
AM		 7202 if (!table)
7203 return 0;
7204
1c0751b2
DA		 7205 unw_ent_size = 16;
7206 nentries = size / unw_ent_size;
7207 size = unw_ent_size * nentries;
57346661 7208
3f5e193b
NC		 7209 tep = aux->table = (struct hppa_unw_table_entry *)
7210 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7211
1c0751b2 7212 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7213 {
7214 unsigned int tmp1, tmp2;
7215
7216 tep->start.section = SHN_UNDEF;
7217 tep->end.section = SHN_UNDEF;
7218
1c0751b2
DA		 7219 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7220 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7221 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7222 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7223
7224 tep->start.offset += aux->seg_base;
7225 tep->end.offset += aux->seg_base;
57346661
AM		 7226
7227 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7228 tep->Millicode = (tmp1 >> 30) & 0x1;
7229 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7230 tep->Region_description = (tmp1 >> 27) & 0x3;
7231 tep->reserved1 = (tmp1 >> 26) & 0x1;
7232 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7233 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7234 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7235 tep->Args_stored = (tmp1 >> 15) & 0x1;
7236 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7237 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7238 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7239 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7240 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7241 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7242 tep->cxx_info = (tmp1 >> 8) & 0x1;
7243 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7244 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7245 tep->reserved2 = (tmp1 >> 5) & 0x1;
7246 tep->Save_SP = (tmp1 >> 4) & 0x1;
7247 tep->Save_RP = (tmp1 >> 3) & 0x1;
7248 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7249 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7250 tep->Cleanup_defined = tmp1 & 0x1;
7251
7252 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7253 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7254 tep->Large_frame = (tmp2 >> 29) & 0x1;
7255 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7256 tep->reserved4 = (tmp2 >> 27) & 0x1;
7257 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7258 }
7259 free (table);
7260
7261 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7262 for (relsec = section_headers;
7263 relsec < section_headers + elf_header.e_shnum;
7264 ++relsec)
7265 {
7266 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7267 || relsec->sh_info >= elf_header.e_shnum
7268 || section_headers + relsec->sh_info != sec)
57346661
AM		 7269 continue;
7270
7271 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7272 & rela, & nrelas))
7273 return 0;
7274
7275 for (rp = rela; rp < rela + nrelas; ++rp)
7276 {
aca88567
NC		 7277 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7278 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7279
7280 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7281 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7282 {
7283 warn (_("Skipping unexpected relocation type %s\n"), relname);
7284 continue;
7285 }
7286
7287 i = rp->r_offset / unw_ent_size;
7288
89fac5e3 7289 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7290 {
7291 case 0:
7292 aux->table[i].start.section = sym->st_shndx;
1e456d54 7293 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7294 break;
7295 case 1:
7296 aux->table[i].end.section = sym->st_shndx;
1e456d54 7297 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7298 break;
7299 default:
7300 break;
7301 }
7302 }
7303
7304 free (rela);
7305 }
7306
1c0751b2 7307 aux->table_len = nentries;
57346661
AM		 7308
7309 return 1;
7310}
7311
1b31d05e 7312static void
2cf0635d 7313hppa_process_unwind (FILE * file)
57346661 7314{
57346661 7315 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7316 Elf_Internal_Shdr * unwsec = NULL;
7317 Elf_Internal_Shdr * strsec;
7318 Elf_Internal_Shdr * sec;
18bd398b 7319 unsigned long i;
57346661 7320
c256ffe7 7321 if (string_table == NULL)
1b31d05e
NC		 7322 return;
7323
7324 memset (& aux, 0, sizeof (aux));
57346661
AM		 7325
7326 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7327 {
c256ffe7 7328 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7329 && sec->sh_link < elf_header.e_shnum)
57346661 7330 {
ba5cdace 7331 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7332
4fbb74a6 7333 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7334 if (aux.strtab != NULL)
7335 {
7336 error (_("Multiple auxillary string tables encountered\n"));
7337 free (aux.strtab);
7338 }
3f5e193b
NC		 7339 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7340 1, strsec->sh_size,
7341 _("string table"));
c256ffe7 7342 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7343 }
18bd398b 7344 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7345 unwsec = sec;
7346 }
7347
7348 if (!unwsec)
7349 printf (_("\nThere are no unwind sections in this file.\n"));
7350
7351 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7352 {
18bd398b 7353 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7354 {
74e1a04b
NC		 7355 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7356 printable_section_name (sec),
57346661 7357 (unsigned long) sec->sh_offset,
89fac5e3 7358 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7359
7360 slurp_hppa_unwind_table (file, &aux, sec);
7361 if (aux.table_len > 0)
7362 dump_hppa_unwind (&aux);
7363
7364 if (aux.table)
7365 free ((char *) aux.table);
7366 aux.table = NULL;
7367 }
7368 }
7369
7370 if (aux.symtab)
7371 free (aux.symtab);
7372 if (aux.strtab)
7373 free ((char *) aux.strtab);
57346661
AM		 7374}
7375
0b6ae522
DJ		 7376struct arm_section
7377{
a734115a
NC		 7378 unsigned char * data; /* The unwind data. */
7379 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7380 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7381 unsigned long nrelas; /* The number of relocations. */
7382 unsigned int rel_type; /* REL or RELA ? */
7383 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7384};
7385
7386struct arm_unw_aux_info
7387{
a734115a
NC		 7388 FILE * file; /* The file containing the unwind sections. */
7389 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7390 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7391 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7392 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7393 char * strtab; /* The file's string table. */
7394 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7395};
7396
7397static const char *
7398arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7399 bfd_vma fn, struct absaddr addr)
7400{
7401 const char *procname;
7402 bfd_vma sym_offset;
7403
7404 if (addr.section == SHN_UNDEF)
7405 addr.offset = fn;
7406
948f632f 7407 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7408 aux->strtab_size, addr, &procname,
7409 &sym_offset);
7410
7411 print_vma (fn, PREFIX_HEX);
7412
7413 if (procname)
7414 {
7415 fputs (" <", stdout);
7416 fputs (procname, stdout);
7417
7418 if (sym_offset)
7419 printf ("+0x%lx", (unsigned long) sym_offset);
7420 fputc ('>', stdout);
7421 }
7422
7423 return procname;
7424}
7425
7426static void
7427arm_free_section (struct arm_section *arm_sec)
7428{
7429 if (arm_sec->data != NULL)
7430 free (arm_sec->data);
7431
7432 if (arm_sec->rela != NULL)
7433 free (arm_sec->rela);
7434}
7435
a734115a
NC		 7436/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7437 cached section and install SEC instead.
7438 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7439 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7440 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7441 relocation's offset in ADDR.
1b31d05e
NC		 7442 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7443 into the string table of the symbol associated with the reloc. If no
7444 reloc was applied store -1 there.
7445 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7446
7447static bfd_boolean
1b31d05e
NC		 7448get_unwind_section_word (struct arm_unw_aux_info * aux,
7449 struct arm_section * arm_sec,
7450 Elf_Internal_Shdr * sec,
7451 bfd_vma word_offset,
7452 unsigned int * wordp,
7453 struct absaddr * addr,
7454 bfd_vma * sym_name)
0b6ae522
DJ		 7455{
7456 Elf_Internal_Rela *rp;
7457 Elf_Internal_Sym *sym;
7458 const char * relname;
7459 unsigned int word;
7460 bfd_boolean wrapped;
7461
e0a31db1
NC		 7462 if (sec == NULL || arm_sec == NULL)
7463 return FALSE;
7464
0b6ae522
DJ		 7465 addr->section = SHN_UNDEF;
7466 addr->offset = 0;
7467
1b31d05e
NC		 7468 if (sym_name != NULL)
7469 *sym_name = (bfd_vma) -1;
7470
a734115a 7471 /* If necessary, update the section cache. */
0b6ae522
DJ		 7472 if (sec != arm_sec->sec)
7473 {
7474 Elf_Internal_Shdr *relsec;
7475
7476 arm_free_section (arm_sec);
7477
7478 arm_sec->sec = sec;
7479 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7480 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7481 arm_sec->rela = NULL;
7482 arm_sec->nrelas = 0;
7483
7484 for (relsec = section_headers;
7485 relsec < section_headers + elf_header.e_shnum;
7486 ++relsec)
7487 {
7488 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7489 || section_headers + relsec->sh_info != sec
7490 /* PR 15745: Check the section type as well. */
7491 || (relsec->sh_type != SHT_REL
7492 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7493 continue;
7494
a734115a 7495 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7496 if (relsec->sh_type == SHT_REL)
7497 {
7498 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7499 relsec->sh_size,
7500 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7501 return FALSE;
0b6ae522 7502 }
1ae40aa4 7503 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7504 {
7505 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7506 relsec->sh_size,
7507 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7508 return FALSE;
0b6ae522 7509 }
1ae40aa4 7510 break;
0b6ae522
DJ		 7511 }
7512
7513 arm_sec->next_rela = arm_sec->rela;
7514 }
7515
a734115a 7516 /* If there is no unwind data we can do nothing. */
0b6ae522 7517 if (arm_sec->data == NULL)
a734115a 7518 return FALSE;
0b6ae522 7519
e0a31db1 7520 /* If the offset is invalid then fail. */
1a915552
NC		 7521 if (word_offset > (sec->sh_size - 4)
7522 /* PR 18879 */
7523 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7524 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7525 return FALSE;
7526
a734115a 7527 /* Get the word at the required offset. */
0b6ae522
DJ		 7528 word = byte_get (arm_sec->data + word_offset, 4);
7529
0eff7165
NC		 7530 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7531 if (arm_sec->rela == NULL)
7532 {
7533 * wordp = word;
7534 return TRUE;
7535 }
7536
a734115a 7537 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7538 wrapped = FALSE;
7539 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7540 {
7541 bfd_vma prelval, offset;
7542
7543 if (rp->r_offset > word_offset && !wrapped)
7544 {
7545 rp = arm_sec->rela;
7546 wrapped = TRUE;
7547 }
7548 if (rp->r_offset > word_offset)
7549 break;
7550
7551 if (rp->r_offset & 3)
7552 {
7553 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7554 (unsigned long) rp->r_offset);
7555 continue;
7556 }
7557
7558 if (rp->r_offset < word_offset)
7559 continue;
7560
74e1a04b
NC		 7561 /* PR 17531: file: 027-161405-0.004 */
7562 if (aux->symtab == NULL)
7563 continue;
7564
0b6ae522
DJ		 7565 if (arm_sec->rel_type == SHT_REL)
7566 {
7567 offset = word & 0x7fffffff;
7568 if (offset & 0x40000000)
7569 offset |= ~ (bfd_vma) 0x7fffffff;
7570 }
a734115a 7571 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7572 offset = rp->r_addend;
a734115a 7573 else
74e1a04b
NC		 7574 {
7575 error (_("Unknown section relocation type %d encountered\n"),
7576 arm_sec->rel_type);
7577 break;
7578 }
0b6ae522 7579
071436c6
NC		 7580 /* PR 17531 file: 027-1241568-0.004. */
7581 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7582 {
7583 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7584 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7585 break;
7586 }
7587
7588 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7589 offset += sym->st_value;
7590 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7591
a734115a
NC		 7592 /* Check that we are processing the expected reloc type. */
7593 if (elf_header.e_machine == EM_ARM)
7594 {
7595 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7596 if (relname == NULL)
7597 {
7598 warn (_("Skipping unknown ARM relocation type: %d\n"),
7599 (int) ELF32_R_TYPE (rp->r_info));
7600 continue;
7601 }
a734115a
NC		 7602
7603 if (streq (relname, "R_ARM_NONE"))
7604 continue;
0b4362b0 7605
a734115a
NC		 7606 if (! streq (relname, "R_ARM_PREL31"))
7607 {
071436c6 7608 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7609 continue;
7610 }
7611 }
7612 else if (elf_header.e_machine == EM_TI_C6000)
7613 {
7614 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7615 if (relname == NULL)
7616 {
7617 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7618 (int) ELF32_R_TYPE (rp->r_info));
7619 continue;
7620 }
0b4362b0 7621
a734115a
NC		 7622 if (streq (relname, "R_C6000_NONE"))
7623 continue;
7624
7625 if (! streq (relname, "R_C6000_PREL31"))
7626 {
071436c6 7627 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7628 continue;
7629 }
7630
7631 prelval >>= 1;
7632 }
7633 else
74e1a04b
NC		 7634 {
7635 /* This function currently only supports ARM and TI unwinders. */
7636 warn (_("Only TI and ARM unwinders are currently supported\n"));
7637 break;
7638 }
fa197c1c 7639
0b6ae522
DJ		 7640 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7641 addr->section = sym->st_shndx;
7642 addr->offset = offset;
74e1a04b 7643
1b31d05e
NC		 7644 if (sym_name)
7645 * sym_name = sym->st_name;
0b6ae522
DJ		 7646 break;
7647 }
7648
7649 *wordp = word;
7650 arm_sec->next_rela = rp;
7651
a734115a 7652 return TRUE;
0b6ae522
DJ		 7653}
7654
a734115a
NC		 7655static const char *tic6x_unwind_regnames[16] =
7656{
0b4362b0
RM		 7657 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7658 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7659 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7660};
fa197c1c 7661
0b6ae522 7662static void
fa197c1c 7663decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7664{
fa197c1c
PB		 7665 int i;
7666
7667 for (i = 12; mask; mask >>= 1, i--)
7668 {
7669 if (mask & 1)
7670 {
7671 fputs (tic6x_unwind_regnames[i], stdout);
7672 if (mask > 1)
7673 fputs (", ", stdout);
7674 }
7675 }
7676}
0b6ae522
DJ		 7677
7678#define ADVANCE \
7679 if (remaining == 0 && more_words) \
7680 { \
7681 data_offset += 4; \
1b31d05e
NC		 7682 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7683 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7684 return; \
7685 remaining = 4; \
7686 more_words--; \
7687 } \
7688
7689#define GET_OP(OP) \
7690 ADVANCE; \
7691 if (remaining) \
7692 { \
7693 remaining--; \
7694 (OP) = word >> 24; \
7695 word <<= 8; \
7696 } \
7697 else \
7698 { \
2b692964 7699 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7700 return; \
7701 } \
cc5914eb 7702 printf ("0x%02x ", OP)
0b6ae522 7703
fa197c1c 7704static void
948f632f
DA		 7705decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7706 unsigned int word,
7707 unsigned int remaining,
7708 unsigned int more_words,
7709 bfd_vma data_offset,
7710 Elf_Internal_Shdr * data_sec,
7711 struct arm_section * data_arm_sec)
fa197c1c
PB		 7712{
7713 struct absaddr addr;
0b6ae522
DJ		 7714
7715 /* Decode the unwinding instructions. */
7716 while (1)
7717 {
7718 unsigned int op, op2;
7719
7720 ADVANCE;
7721 if (remaining == 0)
7722 break;
7723 remaining--;
7724 op = word >> 24;
7725 word <<= 8;
7726
cc5914eb 7727 printf (" 0x%02x ", op);
0b6ae522
DJ		 7728
7729 if ((op & 0xc0) == 0x00)
7730 {
7731 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7732
cc5914eb 7733 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7734 }
7735 else if ((op & 0xc0) == 0x40)
7736 {
7737 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7738
cc5914eb 7739 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7740 }
7741 else if ((op & 0xf0) == 0x80)
7742 {
7743 GET_OP (op2);
7744 if (op == 0x80 && op2 == 0)
7745 printf (_("Refuse to unwind"));
7746 else
7747 {
7748 unsigned int mask = ((op & 0x0f) << 8) | op2;
7749 int first = 1;
7750 int i;
2b692964 7751
0b6ae522
DJ		 7752 printf ("pop {");
7753 for (i = 0; i < 12; i++)
7754 if (mask & (1 << i))
7755 {
7756 if (first)
7757 first = 0;
7758 else
7759 printf (", ");
7760 printf ("r%d", 4 + i);
7761 }
7762 printf ("}");
7763 }
7764 }
7765 else if ((op & 0xf0) == 0x90)
7766 {
7767 if (op == 0x9d || op == 0x9f)
7768 printf (_(" [Reserved]"));
7769 else
cc5914eb 7770 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7771 }
7772 else if ((op & 0xf0) == 0xa0)
7773 {
7774 int end = 4 + (op & 0x07);
7775 int first = 1;
7776 int i;
61865e30 7777
0b6ae522
DJ		 7778 printf (" pop {");
7779 for (i = 4; i <= end; i++)
7780 {
7781 if (first)
7782 first = 0;
7783 else
7784 printf (", ");
7785 printf ("r%d", i);
7786 }
7787 if (op & 0x08)
7788 {
1b31d05e 7789 if (!first)
0b6ae522
DJ		 7790 printf (", ");
7791 printf ("r14");
7792 }
7793 printf ("}");
7794 }
7795 else if (op == 0xb0)
7796 printf (_(" finish"));
7797 else if (op == 0xb1)
7798 {
7799 GET_OP (op2);
7800 if (op2 == 0 || (op2 & 0xf0) != 0)
7801 printf (_("[Spare]"));
7802 else
7803 {
7804 unsigned int mask = op2 & 0x0f;
7805 int first = 1;
7806 int i;
61865e30 7807
0b6ae522
DJ		 7808 printf ("pop {");
7809 for (i = 0; i < 12; i++)
7810 if (mask & (1 << i))
7811 {
7812 if (first)
7813 first = 0;
7814 else
7815 printf (", ");
7816 printf ("r%d", i);
7817 }
7818 printf ("}");
7819 }
7820 }
7821 else if (op == 0xb2)
7822 {
b115cf96 7823 unsigned char buf[9];
0b6ae522
DJ		 7824 unsigned int i, len;
7825 unsigned long offset;
61865e30 7826
b115cf96 7827 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7828 {
7829 GET_OP (buf[i]);
7830 if ((buf[i] & 0x80) == 0)
7831 break;
7832 }
4082ef84
NC		 7833 if (i == sizeof (buf))
7834 printf (_("corrupt change to vsp"));
7835 else
7836 {
7837 offset = read_uleb128 (buf, &len, buf + i + 1);
7838 assert (len == i + 1);
7839 offset = offset * 4 + 0x204;
7840 printf ("vsp = vsp + %ld", offset);
7841 }
0b6ae522 7842 }
61865e30 7843 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7844 {
61865e30
NC		 7845 unsigned int first, last;
7846
7847 GET_OP (op2);
7848 first = op2 >> 4;
7849 last = op2 & 0x0f;
7850 if (op == 0xc8)
7851 first = first + 16;
7852 printf ("pop {D%d", first);
7853 if (last)
7854 printf ("-D%d", first + last);
7855 printf ("}");
7856 }
7857 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7858 {
7859 unsigned int count = op & 0x07;
7860
7861 printf ("pop {D8");
7862 if (count)
7863 printf ("-D%d", 8 + count);
7864 printf ("}");
7865 }
7866 else if (op >= 0xc0 && op <= 0xc5)
7867 {
7868 unsigned int count = op & 0x07;
7869
7870 printf (" pop {wR10");
7871 if (count)
7872 printf ("-wR%d", 10 + count);
7873 printf ("}");
7874 }
7875 else if (op == 0xc6)
7876 {
7877 unsigned int first, last;
7878
7879 GET_OP (op2);
7880 first = op2 >> 4;
7881 last = op2 & 0x0f;
7882 printf ("pop {wR%d", first);
7883 if (last)
7884 printf ("-wR%d", first + last);
7885 printf ("}");
7886 }
7887 else if (op == 0xc7)
7888 {
7889 GET_OP (op2);
7890 if (op2 == 0 || (op2 & 0xf0) != 0)
7891 printf (_("[Spare]"));
0b6ae522
DJ		 7892 else
7893 {
61865e30
NC		 7894 unsigned int mask = op2 & 0x0f;
7895 int first = 1;
7896 int i;
7897
7898 printf ("pop {");
7899 for (i = 0; i < 4; i++)
7900 if (mask & (1 << i))
7901 {
7902 if (first)
7903 first = 0;
7904 else
7905 printf (", ");
7906 printf ("wCGR%d", i);
7907 }
7908 printf ("}");
0b6ae522
DJ		 7909 }
7910 }
61865e30
NC		 7911 else
7912 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7913 printf ("\n");
7914 }
fa197c1c
PB		 7915}
7916
7917static void
948f632f
DA		 7918decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7919 unsigned int word,
7920 unsigned int remaining,
7921 unsigned int more_words,
7922 bfd_vma data_offset,
7923 Elf_Internal_Shdr * data_sec,
7924 struct arm_section * data_arm_sec)
fa197c1c
PB		 7925{
7926 struct absaddr addr;
7927
7928 /* Decode the unwinding instructions. */
7929 while (1)
7930 {
7931 unsigned int op, op2;
7932
7933 ADVANCE;
7934 if (remaining == 0)
7935 break;
7936 remaining--;
7937 op = word >> 24;
7938 word <<= 8;
7939
9cf03b7e 7940 printf (" 0x%02x ", op);
fa197c1c
PB		 7941
7942 if ((op & 0xc0) == 0x00)
7943 {
7944 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7945 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7946 }
7947 else if ((op & 0xc0) == 0x80)
7948 {
7949 GET_OP (op2);
7950 if (op == 0x80 && op2 == 0)
7951 printf (_("Refuse to unwind"));
7952 else
7953 {
7954 unsigned int mask = ((op & 0x1f) << 8) | op2;
7955 if (op & 0x20)
7956 printf ("pop compact {");
7957 else
7958 printf ("pop {");
7959
7960 decode_tic6x_unwind_regmask (mask);
7961 printf("}");
7962 }
7963 }
7964 else if ((op & 0xf0) == 0xc0)
7965 {
7966 unsigned int reg;
7967 unsigned int nregs;
7968 unsigned int i;
7969 const char *name;
a734115a
NC		 7970 struct
7971 {
fa197c1c
PB		 7972 unsigned int offset;
7973 unsigned int reg;
7974 } regpos[16];
7975
7976 /* Scan entire instruction first so that GET_OP output is not
7977 interleaved with disassembly. */
7978 nregs = 0;
7979 for (i = 0; nregs < (op & 0xf); i++)
7980 {
7981 GET_OP (op2);
7982 reg = op2 >> 4;
7983 if (reg != 0xf)
7984 {
7985 regpos[nregs].offset = i * 2;
7986 regpos[nregs].reg = reg;
7987 nregs++;
7988 }
7989
7990 reg = op2 & 0xf;
7991 if (reg != 0xf)
7992 {
7993 regpos[nregs].offset = i * 2 + 1;
7994 regpos[nregs].reg = reg;
7995 nregs++;
7996 }
7997 }
7998
7999 printf (_("pop frame {"));
8000 reg = nregs - 1;
8001 for (i = i * 2; i > 0; i--)
8002 {
8003 if (regpos[reg].offset == i - 1)
8004 {
8005 name = tic6x_unwind_regnames[regpos[reg].reg];
8006 if (reg > 0)
8007 reg--;
8008 }
8009 else
8010 name = _("[pad]");
8011
8012 fputs (name, stdout);
8013 if (i > 1)
8014 printf (", ");
8015 }
8016
8017 printf ("}");
8018 }
8019 else if (op == 0xd0)
8020 printf (" MOV FP, SP");
8021 else if (op == 0xd1)
8022 printf (" __c6xabi_pop_rts");
8023 else if (op == 0xd2)
8024 {
8025 unsigned char buf[9];
8026 unsigned int i, len;
8027 unsigned long offset;
a734115a 8028
fa197c1c
PB		 8029 for (i = 0; i < sizeof (buf); i++)
8030 {
8031 GET_OP (buf[i]);
8032 if ((buf[i] & 0x80) == 0)
8033 break;
8034 }
0eff7165
NC		 8035 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8036 if (i == sizeof (buf))
8037 {
8038 printf ("<corrupt sp adjust>\n");
8039 warn (_("Corrupt stack pointer adjustment detected\n"));
8040 return;
8041 }
948f632f 8042
f6f0e17b 8043 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8044 assert (len == i + 1);
8045 offset = offset * 8 + 0x408;
8046 printf (_("sp = sp + %ld"), offset);
8047 }
8048 else if ((op & 0xf0) == 0xe0)
8049 {
8050 if ((op & 0x0f) == 7)
8051 printf (" RETURN");
8052 else
8053 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8054 }
8055 else
8056 {
8057 printf (_(" [unsupported opcode]"));
8058 }
8059 putchar ('\n');
8060 }
8061}
8062
8063static bfd_vma
a734115a 8064arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8065{
8066 bfd_vma offset;
8067
8068 offset = word & 0x7fffffff;
8069 if (offset & 0x40000000)
8070 offset |= ~ (bfd_vma) 0x7fffffff;
8071
8072 if (elf_header.e_machine == EM_TI_C6000)
8073 offset <<= 1;
8074
8075 return offset + where;
8076}
8077
8078static void
1b31d05e
NC		 8079decode_arm_unwind (struct arm_unw_aux_info * aux,
8080 unsigned int word,
8081 unsigned int remaining,
8082 bfd_vma data_offset,
8083 Elf_Internal_Shdr * data_sec,
8084 struct arm_section * data_arm_sec)
fa197c1c
PB		 8085{
8086 int per_index;
8087 unsigned int more_words = 0;
37e14bc3 8088 struct absaddr addr;
1b31d05e 8089 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8090
8091 if (remaining == 0)
8092 {
1b31d05e
NC		 8093 /* Fetch the first word.
8094 Note - when decoding an object file the address extracted
8095 here will always be 0. So we also pass in the sym_name
8096 parameter so that we can find the symbol associated with
8097 the personality routine. */
8098 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8099 & word, & addr, & sym_name))
fa197c1c 8100 return;
1b31d05e 8101
fa197c1c
PB		 8102 remaining = 4;
8103 }
8104
8105 if ((word & 0x80000000) == 0)
8106 {
8107 /* Expand prel31 for personality routine. */
8108 bfd_vma fn;
8109 const char *procname;
8110
a734115a 8111 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8112 printf (_(" Personality routine: "));
1b31d05e
NC		 8113 if (fn == 0
8114 && addr.section == SHN_UNDEF && addr.offset == 0
8115 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8116 {
8117 procname = aux->strtab + sym_name;
8118 print_vma (fn, PREFIX_HEX);
8119 if (procname)
8120 {
8121 fputs (" <", stdout);
8122 fputs (procname, stdout);
8123 fputc ('>', stdout);
8124 }
8125 }
8126 else
8127 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8128 fputc ('\n', stdout);
8129
8130 /* The GCC personality routines use the standard compact
8131 encoding, starting with one byte giving the number of
8132 words. */
8133 if (procname != NULL
8134 && (const_strneq (procname, "__gcc_personality_v0")
8135 || const_strneq (procname, "__gxx_personality_v0")
8136 || const_strneq (procname, "__gcj_personality_v0")
8137 || const_strneq (procname, "__gnu_objc_personality_v0")))
8138 {
8139 remaining = 0;
8140 more_words = 1;
8141 ADVANCE;
8142 if (!remaining)
8143 {
8144 printf (_(" [Truncated data]\n"));
8145 return;
8146 }
8147 more_words = word >> 24;
8148 word <<= 8;
8149 remaining--;
8150 per_index = -1;
8151 }
8152 else
8153 return;
8154 }
8155 else
8156 {
1b31d05e 8157 /* ARM EHABI Section 6.3:
0b4362b0 8158
1b31d05e 8159 An exception-handling table entry for the compact model looks like:
0b4362b0 8160
1b31d05e
NC		 8161 31 30-28 27-24 23-0
8162 -- ----- ----- ----
8163 1 0 index Data for personalityRoutine[index] */
8164
8165 if (elf_header.e_machine == EM_ARM
8166 && (word & 0x70000000))
83c257ca 8167 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8168
fa197c1c 8169 per_index = (word >> 24) & 0x7f;
1b31d05e 8170 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8171 if (per_index == 0)
8172 {
8173 more_words = 0;
8174 word <<= 8;
8175 remaining--;
8176 }
8177 else if (per_index < 3)
8178 {
8179 more_words = (word >> 16) & 0xff;
8180 word <<= 16;
8181 remaining -= 2;
8182 }
8183 }
8184
8185 switch (elf_header.e_machine)
8186 {
8187 case EM_ARM:
8188 if (per_index < 3)
8189 {
8190 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8191 data_offset, data_sec, data_arm_sec);
8192 }
8193 else
1b31d05e
NC		 8194 {
8195 warn (_("Unknown ARM compact model index encountered\n"));
8196 printf (_(" [reserved]\n"));
8197 }
fa197c1c
PB		 8198 break;
8199
8200 case EM_TI_C6000:
8201 if (per_index < 3)
8202 {
8203 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8204 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8205 }
8206 else if (per_index < 5)
8207 {
8208 if (((word >> 17) & 0x7f) == 0x7f)
8209 printf (_(" Restore stack from frame pointer\n"));
8210 else
8211 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8212 printf (_(" Registers restored: "));
8213 if (per_index == 4)
8214 printf (" (compact) ");
8215 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8216 putchar ('\n');
8217 printf (_(" Return register: %s\n"),
8218 tic6x_unwind_regnames[word & 0xf]);
8219 }
8220 else
1b31d05e 8221 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8222 break;
8223
8224 default:
74e1a04b 8225 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8226 elf_header.e_machine);
fa197c1c 8227 }
0b6ae522
DJ		 8228
8229 /* Decode the descriptors. Not implemented. */
8230}
8231
8232static void
8233dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8234{
8235 struct arm_section exidx_arm_sec, extab_arm_sec;
8236 unsigned int i, exidx_len;
948f632f 8237 unsigned long j, nfuns;
0b6ae522
DJ		 8238
8239 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8240 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8241 exidx_len = exidx_sec->sh_size / 8;
8242
948f632f
DA		 8243 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8244 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8245 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8246 aux->funtab[nfuns++] = aux->symtab[j];
8247 aux->nfuns = nfuns;
8248 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8249
0b6ae522
DJ		 8250 for (i = 0; i < exidx_len; i++)
8251 {
8252 unsigned int exidx_fn, exidx_entry;
8253 struct absaddr fn_addr, entry_addr;
8254 bfd_vma fn;
8255
8256 fputc ('\n', stdout);
8257
1b31d05e
NC		 8258 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8259 8 * i, & exidx_fn, & fn_addr, NULL)
8260 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8261 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8262 {
948f632f 8263 free (aux->funtab);
1b31d05e
NC		 8264 arm_free_section (& exidx_arm_sec);
8265 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8266 return;
8267 }
8268
83c257ca
NC		 8269 /* ARM EHABI, Section 5:
8270 An index table entry consists of 2 words.
8271 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8272 if (exidx_fn & 0x80000000)
8273 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8274
a734115a 8275 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8276
a734115a 8277 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8278 fputs (": ", stdout);
8279
8280 if (exidx_entry == 1)
8281 {
8282 print_vma (exidx_entry, PREFIX_HEX);
8283 fputs (" [cantunwind]\n", stdout);
8284 }
8285 else if (exidx_entry & 0x80000000)
8286 {
8287 print_vma (exidx_entry, PREFIX_HEX);
8288 fputc ('\n', stdout);
8289 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8290 }
8291 else
8292 {
8f73510c 8293 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8294 Elf_Internal_Shdr *table_sec;
8295
8296 fputs ("@", stdout);
a734115a 8297 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8298 print_vma (table, PREFIX_HEX);
8299 printf ("\n");
8300
8301 /* Locate the matching .ARM.extab. */
8302 if (entry_addr.section != SHN_UNDEF
8303 && entry_addr.section < elf_header.e_shnum)
8304 {
8305 table_sec = section_headers + entry_addr.section;
8306 table_offset = entry_addr.offset;
1a915552
NC		 8307 /* PR 18879 */
8308 if (table_offset > table_sec->sh_size
8309 || ((bfd_signed_vma) table_offset) < 0)
8310 {
8311 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8312 (unsigned long) table_offset,
8313 printable_section_name (table_sec));
8314 continue;
8315 }
0b6ae522
DJ		 8316 }
8317 else
8318 {
8319 table_sec = find_section_by_address (table);
8320 if (table_sec != NULL)
8321 table_offset = table - table_sec->sh_addr;
8322 }
8323 if (table_sec == NULL)
8324 {
8325 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8326 (unsigned long) table);
8327 continue;
8328 }
8329 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8330 &extab_arm_sec);
8331 }
8332 }
8333
8334 printf ("\n");
8335
948f632f 8336 free (aux->funtab);
0b6ae522
DJ		 8337 arm_free_section (&exidx_arm_sec);
8338 arm_free_section (&extab_arm_sec);
8339}
8340
fa197c1c 8341/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8342
8343static void
0b6ae522
DJ		 8344arm_process_unwind (FILE *file)
8345{
8346 struct arm_unw_aux_info aux;
8347 Elf_Internal_Shdr *unwsec = NULL;
8348 Elf_Internal_Shdr *strsec;
8349 Elf_Internal_Shdr *sec;
8350 unsigned long i;
fa197c1c 8351 unsigned int sec_type;
0b6ae522 8352
fa197c1c
PB		 8353 switch (elf_header.e_machine)
8354 {
8355 case EM_ARM:
8356 sec_type = SHT_ARM_EXIDX;
8357 break;
8358
8359 case EM_TI_C6000:
8360 sec_type = SHT_C6000_UNWIND;
8361 break;
8362
0b4362b0 8363 default:
74e1a04b 8364 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8365 elf_header.e_machine);
8366 return;
fa197c1c
PB		 8367 }
8368
0b6ae522 8369 if (string_table == NULL)
1b31d05e
NC		 8370 return;
8371
8372 memset (& aux, 0, sizeof (aux));
8373 aux.file = file;
0b6ae522
DJ		 8374
8375 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8376 {
8377 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8378 {
ba5cdace 8379 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8380
8381 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8382
8383 /* PR binutils/17531 file: 011-12666-0.004. */
8384 if (aux.strtab != NULL)
8385 {
4082ef84 8386 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8387 free (aux.strtab);
8388 }
0b6ae522
DJ		 8389 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8390 1, strsec->sh_size, _("string table"));
8391 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8392 }
fa197c1c 8393 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8394 unwsec = sec;
8395 }
8396
1b31d05e 8397 if (unwsec == NULL)
0b6ae522 8398 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8399 else
8400 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8401 {
8402 if (sec->sh_type == sec_type)
8403 {
8404 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8405 printable_section_name (sec),
1b31d05e
NC		 8406 (unsigned long) sec->sh_offset,
8407 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8408
1b31d05e
NC		 8409 dump_arm_unwind (&aux, sec);
8410 }
8411 }
0b6ae522
DJ		 8412
8413 if (aux.symtab)
8414 free (aux.symtab);
8415 if (aux.strtab)
8416 free ((char *) aux.strtab);
0b6ae522
DJ		 8417}
8418
1b31d05e 8419static void
2cf0635d 8420process_unwind (FILE * file)
57346661 8421{
2cf0635d
NC		 8422 struct unwind_handler
8423 {
57346661 8424 int machtype;
1b31d05e 8425 void (* handler)(FILE *);
2cf0635d
NC		 8426 } handlers[] =
8427 {
0b6ae522 8428 { EM_ARM, arm_process_unwind },
57346661
AM		 8429 { EM_IA_64, ia64_process_unwind },
8430 { EM_PARISC, hppa_process_unwind },
fa197c1c 8431 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8432 { 0, 0 }
8433 };
8434 int i;
8435
8436 if (!do_unwind)
1b31d05e 8437 return;
57346661
AM		 8438
8439 for (i = 0; handlers[i].handler != NULL; i++)
8440 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8441 {
8442 handlers[i].handler (file);
8443 return;
8444 }
57346661 8445
1b31d05e
NC		 8446 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8447 get_machine_name (elf_header.e_machine));
57346661
AM		 8448}
8449
252b5132 8450static void
2cf0635d 8451dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8452{
8453 switch (entry->d_tag)
8454 {
8455 case DT_MIPS_FLAGS:
8456 if (entry->d_un.d_val == 0)
4b68bca3 8457 printf (_("NONE"));
252b5132
RH		 8458 else
8459 {
8460 static const char * opts[] =
8461 {
8462 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8463 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8464 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8465 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8466 "RLD_ORDER_SAFE"
8467 };
8468 unsigned int cnt;
8469 int first = 1;
2b692964 8470
60bca95a 8471 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8472 if (entry->d_un.d_val & (1 << cnt))
8473 {
8474 printf ("%s%s", first ? "" : " ", opts[cnt]);
8475 first = 0;
8476 }
252b5132
RH		 8477 }
8478 break;
103f02d3 8479
252b5132 8480 case DT_MIPS_IVERSION:
d79b3d50 8481 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8482 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8483 else
76ca31c0
NC		 8484 {
8485 char buf[40];
8486 sprintf_vma (buf, entry->d_un.d_ptr);
8487 /* Note: coded this way so that there is a single string for translation. */
8488 printf (_("<corrupt: %s>"), buf);
8489 }
252b5132 8490 break;
103f02d3 8491
252b5132
RH		 8492 case DT_MIPS_TIME_STAMP:
8493 {
8494 char timebuf[20];
2cf0635d 8495 struct tm * tmp;
91d6fa6a 8496 time_t atime = entry->d_un.d_val;
82b1b41b 8497
91d6fa6a 8498 tmp = gmtime (&atime);
82b1b41b
NC		 8499 /* PR 17531: file: 6accc532. */
8500 if (tmp == NULL)
8501 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8502 else
8503 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8504 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8505 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8506 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8507 }
8508 break;
103f02d3 8509
252b5132
RH		 8510 case DT_MIPS_RLD_VERSION:
8511 case DT_MIPS_LOCAL_GOTNO:
8512 case DT_MIPS_CONFLICTNO:
8513 case DT_MIPS_LIBLISTNO:
8514 case DT_MIPS_SYMTABNO:
8515 case DT_MIPS_UNREFEXTNO:
8516 case DT_MIPS_HIPAGENO:
8517 case DT_MIPS_DELTA_CLASS_NO:
8518 case DT_MIPS_DELTA_INSTANCE_NO:
8519 case DT_MIPS_DELTA_RELOC_NO:
8520 case DT_MIPS_DELTA_SYM_NO:
8521 case DT_MIPS_DELTA_CLASSSYM_NO:
8522 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8523 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8524 break;
103f02d3
UD		 8525
8526 default:
4b68bca3 8527 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8528 }
4b68bca3 8529 putchar ('\n');
103f02d3
UD		 8530}
8531
103f02d3 8532static void
2cf0635d 8533dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8534{
8535 switch (entry->d_tag)
8536 {
8537 case DT_HP_DLD_FLAGS:
8538 {
8539 static struct
8540 {
8541 long int bit;
2cf0635d 8542 const char * str;
5e220199
NC		 8543 }
8544 flags[] =
8545 {
8546 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8547 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8548 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8549 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8550 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8551 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8552 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8553 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8554 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8555 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8556 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8557 { DT_HP_GST, "HP_GST" },
8558 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8559 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8560 { DT_HP_NODELETE, "HP_NODELETE" },
8561 { DT_HP_GROUP, "HP_GROUP" },
8562 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8563 };
103f02d3 8564 int first = 1;
5e220199 8565 size_t cnt;
f7a99963 8566 bfd_vma val = entry->d_un.d_val;
103f02d3 8567
60bca95a 8568 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8569 if (val & flags[cnt].bit)
30800947
NC		 8570 {
8571 if (! first)
8572 putchar (' ');
8573 fputs (flags[cnt].str, stdout);
8574 first = 0;
8575 val ^= flags[cnt].bit;
8576 }
76da6bbe 8577
103f02d3 8578 if (val != 0 || first)
f7a99963
NC		 8579 {
8580 if (! first)
8581 putchar (' ');
8582 print_vma (val, HEX);
8583 }
103f02d3
UD		 8584 }
8585 break;
76da6bbe 8586
252b5132 8587 default:
f7a99963
NC		 8588 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8589 break;
252b5132 8590 }
35b1837e 8591 putchar ('\n');
252b5132
RH		 8592}
8593
28f997cf
TG		 8594#ifdef BFD64
8595
8596/* VMS vs Unix time offset and factor. */
8597
8598#define VMS_EPOCH_OFFSET 35067168000000000LL
8599#define VMS_GRANULARITY_FACTOR 10000000
8600
8601/* Display a VMS time in a human readable format. */
8602
8603static void
8604print_vms_time (bfd_int64_t vmstime)
8605{
8606 struct tm *tm;
8607 time_t unxtime;
8608
8609 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8610 tm = gmtime (&unxtime);
8611 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8612 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8613 tm->tm_hour, tm->tm_min, tm->tm_sec);
8614}
8615#endif /* BFD64 */
8616
ecc51f48 8617static void
2cf0635d 8618dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8619{
8620 switch (entry->d_tag)
8621 {
0de14b54 8622 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8623 /* First 3 slots reserved. */
ecc51f48
NC		 8624 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8625 printf (" -- ");
8626 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8627 break;
8628
28f997cf
TG		 8629 case DT_IA_64_VMS_LINKTIME:
8630#ifdef BFD64
8631 print_vms_time (entry->d_un.d_val);
8632#endif
8633 break;
8634
8635 case DT_IA_64_VMS_LNKFLAGS:
8636 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8637 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8638 printf (" CALL_DEBUG");
8639 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8640 printf (" NOP0BUFS");
8641 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8642 printf (" P0IMAGE");
8643 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8644 printf (" MKTHREADS");
8645 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8646 printf (" UPCALLS");
8647 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8648 printf (" IMGSTA");
8649 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8650 printf (" INITIALIZE");
8651 if (entry->d_un.d_val & VMS_LF_MAIN)
8652 printf (" MAIN");
8653 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8654 printf (" EXE_INIT");
8655 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8656 printf (" TBK_IN_IMG");
8657 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8658 printf (" DBG_IN_IMG");
8659 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8660 printf (" TBK_IN_DSF");
8661 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8662 printf (" DBG_IN_DSF");
8663 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8664 printf (" SIGNATURES");
8665 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8666 printf (" REL_SEG_OFF");
8667 break;
8668
bdf4d63a
JJ		 8669 default:
8670 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8671 break;
ecc51f48 8672 }
bdf4d63a 8673 putchar ('\n');
ecc51f48
NC		 8674}
8675
252b5132 8676static int
2cf0635d 8677get_32bit_dynamic_section (FILE * file)
252b5132 8678{
2cf0635d
NC		 8679 Elf32_External_Dyn * edyn;
8680 Elf32_External_Dyn * ext;
8681 Elf_Internal_Dyn * entry;
103f02d3 8682
3f5e193b
NC		 8683 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8684 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8685 if (!edyn)
8686 return 0;
103f02d3 8687
071436c6
NC		 8688 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8689 might not have the luxury of section headers. Look for the DT_NULL
8690 terminator to determine the number of entries. */
ba2685cc 8691 for (ext = edyn, dynamic_nent = 0;
53c3012c 8692 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8693 ext++)
8694 {
8695 dynamic_nent++;
8696 if (BYTE_GET (ext->d_tag) == DT_NULL)
8697 break;
8698 }
252b5132 8699
3f5e193b
NC		 8700 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8701 sizeof (* entry));
b2d38a17 8702 if (dynamic_section == NULL)
252b5132 8703 {
8b73c356
NC		 8704 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8705 (unsigned long) dynamic_nent);
9ea033b2
NC		 8706 free (edyn);
8707 return 0;
8708 }
252b5132 8709
fb514b26 8710 for (ext = edyn, entry = dynamic_section;
ba2685cc 8711 entry < dynamic_section + dynamic_nent;
fb514b26 8712 ext++, entry++)
9ea033b2 8713 {
fb514b26
AM		 8714 entry->d_tag = BYTE_GET (ext->d_tag);
8715 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8716 }
8717
9ea033b2
NC		 8718 free (edyn);
8719
8720 return 1;
8721}
8722
8723static int
2cf0635d 8724get_64bit_dynamic_section (FILE * file)
9ea033b2 8725{
2cf0635d
NC		 8726 Elf64_External_Dyn * edyn;
8727 Elf64_External_Dyn * ext;
8728 Elf_Internal_Dyn * entry;
103f02d3 8729
071436c6 8730 /* Read in the data. */
3f5e193b
NC		 8731 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8732 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8733 if (!edyn)
8734 return 0;
103f02d3 8735
071436c6
NC		 8736 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8737 might not have the luxury of section headers. Look for the DT_NULL
8738 terminator to determine the number of entries. */
ba2685cc 8739 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8740 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8741 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8742 ext++)
8743 {
8744 dynamic_nent++;
66543521 8745 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8746 break;
8747 }
252b5132 8748
3f5e193b
NC		 8749 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8750 sizeof (* entry));
b2d38a17 8751 if (dynamic_section == NULL)
252b5132 8752 {
8b73c356
NC		 8753 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8754 (unsigned long) dynamic_nent);
252b5132
RH		 8755 free (edyn);
8756 return 0;
8757 }
8758
071436c6 8759 /* Convert from external to internal formats. */
fb514b26 8760 for (ext = edyn, entry = dynamic_section;
ba2685cc 8761 entry < dynamic_section + dynamic_nent;
fb514b26 8762 ext++, entry++)
252b5132 8763 {
66543521
AM		 8764 entry->d_tag = BYTE_GET (ext->d_tag);
8765 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8766 }
8767
8768 free (edyn);
8769
9ea033b2
NC		 8770 return 1;
8771}
8772
e9e44622
JJ		 8773static void
8774print_dynamic_flags (bfd_vma flags)
d1133906 8775{
e9e44622 8776 int first = 1;
13ae64f3 8777
d1133906
NC		 8778 while (flags)
8779 {
8780 bfd_vma flag;
8781
8782 flag = flags & - flags;
8783 flags &= ~ flag;
8784
e9e44622
JJ		 8785 if (first)
8786 first = 0;
8787 else
8788 putc (' ', stdout);
13ae64f3 8789
d1133906
NC		 8790 switch (flag)
8791 {
e9e44622
JJ		 8792 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8793 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8794 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8795 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8796 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8797 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8798 }
8799 }
e9e44622 8800 puts ("");
d1133906
NC		 8801}
8802
b2d38a17
NC		 8803/* Parse and display the contents of the dynamic section. */
8804
9ea033b2 8805static int
2cf0635d 8806process_dynamic_section (FILE * file)
9ea033b2 8807{
2cf0635d 8808 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8809
8810 if (dynamic_size == 0)
8811 {
8812 if (do_dynamic)
b2d38a17 8813 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8814
8815 return 1;
8816 }
8817
8818 if (is_32bit_elf)
8819 {
b2d38a17 8820 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8821 return 0;
8822 }
b2d38a17 8823 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8824 return 0;
8825
252b5132
RH		 8826 /* Find the appropriate symbol table. */
8827 if (dynamic_symbols == NULL)
8828 {
86dba8ee
AM		 8829 for (entry = dynamic_section;
8830 entry < dynamic_section + dynamic_nent;
8831 ++entry)
252b5132 8832 {
c8286bd1 8833 Elf_Internal_Shdr section;
252b5132
RH		 8834
8835 if (entry->d_tag != DT_SYMTAB)
8836 continue;
8837
8838 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8839
8840 /* Since we do not know how big the symbol table is,
8841 we default to reading in the entire file (!) and
8842 processing that. This is overkill, I know, but it
e3c8793a 8843 should work. */
d93f0186 8844 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8845
fb52b2f4
NC		 8846 if (archive_file_offset != 0)
8847 section.sh_size = archive_file_size - section.sh_offset;
8848 else
8849 {
8850 if (fseek (file, 0, SEEK_END))
591a748a 8851 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8852
8853 section.sh_size = ftell (file) - section.sh_offset;
8854 }
252b5132 8855
9ea033b2 8856 if (is_32bit_elf)
9ad5cbcf 8857 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8858 else
9ad5cbcf 8859 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8860 section.sh_name = string_table_length;
252b5132 8861
ba5cdace 8862 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8863 if (num_dynamic_syms < 1)
252b5132
RH		 8864 {
8865 error (_("Unable to determine the number of symbols to load\n"));
8866 continue;
8867 }
252b5132
RH		 8868 }
8869 }
8870
8871 /* Similarly find a string table. */
8872 if (dynamic_strings == NULL)
8873 {
86dba8ee
AM		 8874 for (entry = dynamic_section;
8875 entry < dynamic_section + dynamic_nent;
8876 ++entry)
252b5132
RH		 8877 {
8878 unsigned long offset;
b34976b6 8879 long str_tab_len;
252b5132
RH		 8880
8881 if (entry->d_tag != DT_STRTAB)
8882 continue;
8883
8884 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8885
8886 /* Since we do not know how big the string table is,
8887 we default to reading in the entire file (!) and
8888 processing that. This is overkill, I know, but it
e3c8793a 8889 should work. */
252b5132 8890
d93f0186 8891 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8892
8893 if (archive_file_offset != 0)
8894 str_tab_len = archive_file_size - offset;
8895 else
8896 {
8897 if (fseek (file, 0, SEEK_END))
8898 error (_("Unable to seek to end of file\n"));
8899 str_tab_len = ftell (file) - offset;
8900 }
252b5132
RH		 8901
8902 if (str_tab_len < 1)
8903 {
8904 error
8905 (_("Unable to determine the length of the dynamic string table\n"));
8906 continue;
8907 }
8908
3f5e193b
NC		 8909 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8910 str_tab_len,
8911 _("dynamic string table"));
59245841 8912 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8913 break;
8914 }
8915 }
8916
8917 /* And find the syminfo section if available. */
8918 if (dynamic_syminfo == NULL)
8919 {
3e8bba36 8920 unsigned long syminsz = 0;
252b5132 8921
86dba8ee
AM		 8922 for (entry = dynamic_section;
8923 entry < dynamic_section + dynamic_nent;
8924 ++entry)
252b5132
RH		 8925 {
8926 if (entry->d_tag == DT_SYMINENT)
8927 {
8928 /* Note: these braces are necessary to avoid a syntax
8929 error from the SunOS4 C compiler. */
049b0c3a
NC		 8930 /* PR binutils/17531: A corrupt file can trigger this test.
8931 So do not use an assert, instead generate an error message. */
8932 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8933 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8934 (int) entry->d_un.d_val);
252b5132
RH		 8935 }
8936 else if (entry->d_tag == DT_SYMINSZ)
8937 syminsz = entry->d_un.d_val;
8938 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8939 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8940 syminsz);
252b5132
RH		 8941 }
8942
8943 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8944 {
2cf0635d
NC		 8945 Elf_External_Syminfo * extsyminfo;
8946 Elf_External_Syminfo * extsym;
8947 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8948
8949 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8950 extsyminfo = (Elf_External_Syminfo *)
8951 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8952 _("symbol information"));
a6e9f9df
AM		 8953 if (!extsyminfo)
8954 return 0;
252b5132 8955
3f5e193b 8956 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8957 if (dynamic_syminfo == NULL)
8958 {
8b73c356
NC		 8959 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8960 (unsigned long) syminsz);
252b5132
RH		 8961 return 0;
8962 }
8963
8964 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8965 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8966 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8967 ++syminfo, ++extsym)
252b5132 8968 {
86dba8ee
AM		 8969 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8970 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8971 }
8972
8973 free (extsyminfo);
8974 }
8975 }
8976
8977 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8978 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8979 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8980 if (do_dynamic)
8981 printf (_(" Tag Type Name/Value\n"));
8982
86dba8ee
AM		 8983 for (entry = dynamic_section;
8984 entry < dynamic_section + dynamic_nent;
8985 entry++)
252b5132
RH		 8986 {
8987 if (do_dynamic)
f7a99963 8988 {
2cf0635d 8989 const char * dtype;
e699b9ff 8990
f7a99963
NC		 8991 putchar (' ');
8992 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8993 dtype = get_dynamic_type (entry->d_tag);
8994 printf (" (%s)%*s", dtype,
8995 ((is_32bit_elf ? 27 : 19)
8996 - (int) strlen (dtype)),
f7a99963
NC		 8997 " ");
8998 }
252b5132
RH		 8999
9000 switch (entry->d_tag)
9001 {
d1133906
NC		 9002 case DT_FLAGS:
9003 if (do_dynamic)
e9e44622 9004 print_dynamic_flags (entry->d_un.d_val);
d1133906 9005 break;
76da6bbe 9006
252b5132
RH		 9007 case DT_AUXILIARY:
9008 case DT_FILTER:
019148e4
L		 9009 case DT_CONFIG:
9010 case DT_DEPAUDIT:
9011 case DT_AUDIT:
252b5132
RH		 9012 if (do_dynamic)
9013 {
019148e4 9014 switch (entry->d_tag)
b34976b6 9015 {
019148e4
L		 9016 case DT_AUXILIARY:
9017 printf (_("Auxiliary library"));
9018 break;
9019
9020 case DT_FILTER:
9021 printf (_("Filter library"));
9022 break;
9023
b34976b6 9024 case DT_CONFIG:
019148e4
L		 9025 printf (_("Configuration file"));
9026 break;
9027
9028 case DT_DEPAUDIT:
9029 printf (_("Dependency audit library"));
9030 break;
9031
9032 case DT_AUDIT:
9033 printf (_("Audit library"));
9034 break;
9035 }
252b5132 9036
d79b3d50
NC		 9037 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9038 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9039 else
f7a99963
NC		 9040 {
9041 printf (": ");
9042 print_vma (entry->d_un.d_val, PREFIX_HEX);
9043 putchar ('\n');
9044 }
252b5132
RH		 9045 }
9046 break;
9047
dcefbbbd 9048 case DT_FEATURE:
252b5132
RH		 9049 if (do_dynamic)
9050 {
9051 printf (_("Flags:"));
86f55779 9052
252b5132
RH		 9053 if (entry->d_un.d_val == 0)
9054 printf (_(" None\n"));
9055 else
9056 {
9057 unsigned long int val = entry->d_un.d_val;
86f55779 9058
252b5132
RH		 9059 if (val & DTF_1_PARINIT)
9060 {
9061 printf (" PARINIT");
9062 val ^= DTF_1_PARINIT;
9063 }
dcefbbbd
L		 9064 if (val & DTF_1_CONFEXP)
9065 {
9066 printf (" CONFEXP");
9067 val ^= DTF_1_CONFEXP;
9068 }
252b5132
RH		 9069 if (val != 0)
9070 printf (" %lx", val);
9071 puts ("");
9072 }
9073 }
9074 break;
9075
9076 case DT_POSFLAG_1:
9077 if (do_dynamic)
9078 {
9079 printf (_("Flags:"));
86f55779 9080
252b5132
RH		 9081 if (entry->d_un.d_val == 0)
9082 printf (_(" None\n"));
9083 else
9084 {
9085 unsigned long int val = entry->d_un.d_val;
86f55779 9086
252b5132
RH		 9087 if (val & DF_P1_LAZYLOAD)
9088 {
9089 printf (" LAZYLOAD");
9090 val ^= DF_P1_LAZYLOAD;
9091 }
9092 if (val & DF_P1_GROUPPERM)
9093 {
9094 printf (" GROUPPERM");
9095 val ^= DF_P1_GROUPPERM;
9096 }
9097 if (val != 0)
9098 printf (" %lx", val);
9099 puts ("");
9100 }
9101 }
9102 break;
9103
9104 case DT_FLAGS_1:
9105 if (do_dynamic)
9106 {
9107 printf (_("Flags:"));
9108 if (entry->d_un.d_val == 0)
9109 printf (_(" None\n"));
9110 else
9111 {
9112 unsigned long int val = entry->d_un.d_val;
86f55779 9113
252b5132
RH		 9114 if (val & DF_1_NOW)
9115 {
9116 printf (" NOW");
9117 val ^= DF_1_NOW;
9118 }
9119 if (val & DF_1_GLOBAL)
9120 {
9121 printf (" GLOBAL");
9122 val ^= DF_1_GLOBAL;
9123 }
9124 if (val & DF_1_GROUP)
9125 {
9126 printf (" GROUP");
9127 val ^= DF_1_GROUP;
9128 }
9129 if (val & DF_1_NODELETE)
9130 {
9131 printf (" NODELETE");
9132 val ^= DF_1_NODELETE;
9133 }
9134 if (val & DF_1_LOADFLTR)
9135 {
9136 printf (" LOADFLTR");
9137 val ^= DF_1_LOADFLTR;
9138 }
9139 if (val & DF_1_INITFIRST)
9140 {
9141 printf (" INITFIRST");
9142 val ^= DF_1_INITFIRST;
9143 }
9144 if (val & DF_1_NOOPEN)
9145 {
9146 printf (" NOOPEN");
9147 val ^= DF_1_NOOPEN;
9148 }
9149 if (val & DF_1_ORIGIN)
9150 {
9151 printf (" ORIGIN");
9152 val ^= DF_1_ORIGIN;
9153 }
9154 if (val & DF_1_DIRECT)
9155 {
9156 printf (" DIRECT");
9157 val ^= DF_1_DIRECT;
9158 }
9159 if (val & DF_1_TRANS)
9160 {
9161 printf (" TRANS");
9162 val ^= DF_1_TRANS;
9163 }
9164 if (val & DF_1_INTERPOSE)
9165 {
9166 printf (" INTERPOSE");
9167 val ^= DF_1_INTERPOSE;
9168 }
f7db6139 9169 if (val & DF_1_NODEFLIB)
dcefbbbd 9170 {
f7db6139
L		 9171 printf (" NODEFLIB");
9172 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9173 }
9174 if (val & DF_1_NODUMP)
9175 {
9176 printf (" NODUMP");
9177 val ^= DF_1_NODUMP;
9178 }
34b60028 9179 if (val & DF_1_CONFALT)
dcefbbbd 9180 {
34b60028
L		 9181 printf (" CONFALT");
9182 val ^= DF_1_CONFALT;
9183 }
9184 if (val & DF_1_ENDFILTEE)
9185 {
9186 printf (" ENDFILTEE");
9187 val ^= DF_1_ENDFILTEE;
9188 }
9189 if (val & DF_1_DISPRELDNE)
9190 {
9191 printf (" DISPRELDNE");
9192 val ^= DF_1_DISPRELDNE;
9193 }
9194 if (val & DF_1_DISPRELPND)
9195 {
9196 printf (" DISPRELPND");
9197 val ^= DF_1_DISPRELPND;
9198 }
9199 if (val & DF_1_NODIRECT)
9200 {
9201 printf (" NODIRECT");
9202 val ^= DF_1_NODIRECT;
9203 }
9204 if (val & DF_1_IGNMULDEF)
9205 {
9206 printf (" IGNMULDEF");
9207 val ^= DF_1_IGNMULDEF;
9208 }
9209 if (val & DF_1_NOKSYMS)
9210 {
9211 printf (" NOKSYMS");
9212 val ^= DF_1_NOKSYMS;
9213 }
9214 if (val & DF_1_NOHDR)
9215 {
9216 printf (" NOHDR");
9217 val ^= DF_1_NOHDR;
9218 }
9219 if (val & DF_1_EDITED)
9220 {
9221 printf (" EDITED");
9222 val ^= DF_1_EDITED;
9223 }
9224 if (val & DF_1_NORELOC)
9225 {
9226 printf (" NORELOC");
9227 val ^= DF_1_NORELOC;
9228 }
9229 if (val & DF_1_SYMINTPOSE)
9230 {
9231 printf (" SYMINTPOSE");
9232 val ^= DF_1_SYMINTPOSE;
9233 }
9234 if (val & DF_1_GLOBAUDIT)
9235 {
9236 printf (" GLOBAUDIT");
9237 val ^= DF_1_GLOBAUDIT;
9238 }
9239 if (val & DF_1_SINGLETON)
9240 {
9241 printf (" SINGLETON");
9242 val ^= DF_1_SINGLETON;
dcefbbbd 9243 }
252b5132
RH		 9244 if (val != 0)
9245 printf (" %lx", val);
9246 puts ("");
9247 }
9248 }
9249 break;
9250
9251 case DT_PLTREL:
566b0d53 9252 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9253 if (do_dynamic)
9254 puts (get_dynamic_type (entry->d_un.d_val));
9255 break;
9256
9257 case DT_NULL :
9258 case DT_NEEDED :
9259 case DT_PLTGOT :
9260 case DT_HASH :
9261 case DT_STRTAB :
9262 case DT_SYMTAB :
9263 case DT_RELA :
9264 case DT_INIT :
9265 case DT_FINI :
9266 case DT_SONAME :
9267 case DT_RPATH :
9268 case DT_SYMBOLIC:
9269 case DT_REL :
9270 case DT_DEBUG :
9271 case DT_TEXTREL :
9272 case DT_JMPREL :
019148e4 9273 case DT_RUNPATH :
252b5132
RH		 9274 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9275
9276 if (do_dynamic)
9277 {
2cf0635d 9278 char * name;
252b5132 9279
d79b3d50
NC		 9280 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9281 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9282 else
d79b3d50 9283 name = NULL;
252b5132
RH		 9284
9285 if (name)
9286 {
9287 switch (entry->d_tag)
9288 {
9289 case DT_NEEDED:
9290 printf (_("Shared library: [%s]"), name);
9291
18bd398b 9292 if (streq (name, program_interpreter))
f7a99963 9293 printf (_(" program interpreter"));
252b5132
RH		 9294 break;
9295
9296 case DT_SONAME:
f7a99963 9297 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9298 break;
9299
9300 case DT_RPATH:
f7a99963 9301 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9302 break;
9303
019148e4
L		 9304 case DT_RUNPATH:
9305 printf (_("Library runpath: [%s]"), name);
9306 break;
9307
252b5132 9308 default:
f7a99963
NC		 9309 print_vma (entry->d_un.d_val, PREFIX_HEX);
9310 break;
252b5132
RH		 9311 }
9312 }
9313 else
f7a99963
NC		 9314 print_vma (entry->d_un.d_val, PREFIX_HEX);
9315
9316 putchar ('\n');
252b5132
RH		 9317 }
9318 break;
9319
9320 case DT_PLTRELSZ:
9321 case DT_RELASZ :
9322 case DT_STRSZ :
9323 case DT_RELSZ :
9324 case DT_RELAENT :
9325 case DT_SYMENT :
9326 case DT_RELENT :
566b0d53 9327 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9328 case DT_PLTPADSZ:
9329 case DT_MOVEENT :
9330 case DT_MOVESZ :
9331 case DT_INIT_ARRAYSZ:
9332 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9333 case DT_GNU_CONFLICTSZ:
9334 case DT_GNU_LIBLISTSZ:
252b5132 9335 if (do_dynamic)
f7a99963
NC		 9336 {
9337 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9338 printf (_(" (bytes)\n"));
f7a99963 9339 }
252b5132
RH		 9340 break;
9341
9342 case DT_VERDEFNUM:
9343 case DT_VERNEEDNUM:
9344 case DT_RELACOUNT:
9345 case DT_RELCOUNT:
9346 if (do_dynamic)
f7a99963
NC		 9347 {
9348 print_vma (entry->d_un.d_val, UNSIGNED);
9349 putchar ('\n');
9350 }
252b5132
RH		 9351 break;
9352
9353 case DT_SYMINSZ:
9354 case DT_SYMINENT:
9355 case DT_SYMINFO:
9356 case DT_USED:
9357 case DT_INIT_ARRAY:
9358 case DT_FINI_ARRAY:
9359 if (do_dynamic)
9360 {
d79b3d50
NC		 9361 if (entry->d_tag == DT_USED
9362 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9363 {
2cf0635d 9364 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9365
b34976b6 9366 if (*name)
252b5132
RH		 9367 {
9368 printf (_("Not needed object: [%s]\n"), name);
9369 break;
9370 }
9371 }
103f02d3 9372
f7a99963
NC		 9373 print_vma (entry->d_un.d_val, PREFIX_HEX);
9374 putchar ('\n');
252b5132
RH		 9375 }
9376 break;
9377
9378 case DT_BIND_NOW:
9379 /* The value of this entry is ignored. */
35b1837e
AM		 9380 if (do_dynamic)
9381 putchar ('\n');
252b5132 9382 break;
103f02d3 9383
047b2264
JJ		 9384 case DT_GNU_PRELINKED:
9385 if (do_dynamic)
9386 {
2cf0635d 9387 struct tm * tmp;
91d6fa6a 9388 time_t atime = entry->d_un.d_val;
047b2264 9389
91d6fa6a 9390 tmp = gmtime (&atime);
071436c6
NC		 9391 /* PR 17533 file: 041-1244816-0.004. */
9392 if (tmp == NULL)
5a2cbcf4
L		 9393 printf (_("<corrupt time val: %lx"),
9394 (unsigned long) atime);
071436c6
NC		 9395 else
9396 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9397 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9398 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9399
9400 }
9401 break;
9402
fdc90cb4
JJ		 9403 case DT_GNU_HASH:
9404 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9405 if (do_dynamic)
9406 {
9407 print_vma (entry->d_un.d_val, PREFIX_HEX);
9408 putchar ('\n');
9409 }
9410 break;
9411
252b5132
RH		 9412 default:
9413 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9414 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9415 entry->d_un.d_val;
9416
9417 if (do_dynamic)
9418 {
9419 switch (elf_header.e_machine)
9420 {
9421 case EM_MIPS:
4fe85591 9422 case EM_MIPS_RS3_LE:
b2d38a17 9423 dynamic_section_mips_val (entry);
252b5132 9424 break;
103f02d3 9425 case EM_PARISC:
b2d38a17 9426 dynamic_section_parisc_val (entry);
103f02d3 9427 break;
ecc51f48 9428 case EM_IA_64:
b2d38a17 9429 dynamic_section_ia64_val (entry);
ecc51f48 9430 break;
252b5132 9431 default:
f7a99963
NC		 9432 print_vma (entry->d_un.d_val, PREFIX_HEX);
9433 putchar ('\n');
252b5132
RH		 9434 }
9435 }
9436 break;
9437 }
9438 }
9439
9440 return 1;
9441}
9442
9443static char *
d3ba0551 9444get_ver_flags (unsigned int flags)
252b5132 9445{
b34976b6 9446 static char buff[32];
252b5132
RH		 9447
9448 buff[0] = 0;
9449
9450 if (flags == 0)
9451 return _("none");
9452
9453 if (flags & VER_FLG_BASE)
9454 strcat (buff, "BASE ");
9455
9456 if (flags & VER_FLG_WEAK)
9457 {
9458 if (flags & VER_FLG_BASE)
9459 strcat (buff, "| ");
9460
9461 strcat (buff, "WEAK ");
9462 }
9463
44ec90b9
RO		 9464 if (flags & VER_FLG_INFO)
9465 {
9466 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9467 strcat (buff, "| ");
9468
9469 strcat (buff, "INFO ");
9470 }
9471
9472 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9473 strcat (buff, _("| <unknown>"));
252b5132
RH		 9474
9475 return buff;
9476}
9477
9478/* Display the contents of the version sections. */
98fb390a 9479
252b5132 9480static int
2cf0635d 9481process_version_sections (FILE * file)
252b5132 9482{
2cf0635d 9483 Elf_Internal_Shdr * section;
b34976b6
AM		 9484 unsigned i;
9485 int found = 0;
252b5132
RH		 9486
9487 if (! do_version)
9488 return 1;
9489
9490 for (i = 0, section = section_headers;
9491 i < elf_header.e_shnum;
b34976b6 9492 i++, section++)
252b5132
RH		 9493 {
9494 switch (section->sh_type)
9495 {
9496 case SHT_GNU_verdef:
9497 {
2cf0635d 9498 Elf_External_Verdef * edefs;
b34976b6
AM		 9499 unsigned int idx;
9500 unsigned int cnt;
2cf0635d 9501 char * endbuf;
252b5132
RH		 9502
9503 found = 1;
9504
74e1a04b
NC		 9505 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9506 printable_section_name (section),
9507 section->sh_info);
252b5132
RH		 9508
9509 printf (_(" Addr: 0x"));
9510 printf_vma (section->sh_addr);
74e1a04b 9511 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9512 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9513 printable_section_name_from_index (section->sh_link));
252b5132 9514
3f5e193b
NC		 9515 edefs = (Elf_External_Verdef *)
9516 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9517 _("version definition section"));
a6e9f9df
AM		 9518 if (!edefs)
9519 break;
59245841 9520 endbuf = (char *) edefs + section->sh_size;
252b5132 9521
b34976b6 9522 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9523 {
2cf0635d
NC		 9524 char * vstart;
9525 Elf_External_Verdef * edef;
b34976b6 9526 Elf_Internal_Verdef ent;
2cf0635d 9527 Elf_External_Verdaux * eaux;
b34976b6
AM		 9528 Elf_Internal_Verdaux aux;
9529 int j;
9530 int isum;
103f02d3 9531
7e26601c
NC		 9532 /* Check for very large indicies. */
9533 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9534 break;
9535
252b5132 9536 vstart = ((char *) edefs) + idx;
54806181
AM		 9537 if (vstart + sizeof (*edef) > endbuf)
9538 break;
252b5132
RH		 9539
9540 edef = (Elf_External_Verdef *) vstart;
9541
9542 ent.vd_version = BYTE_GET (edef->vd_version);
9543 ent.vd_flags = BYTE_GET (edef->vd_flags);
9544 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9545 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9546 ent.vd_hash = BYTE_GET (edef->vd_hash);
9547 ent.vd_aux = BYTE_GET (edef->vd_aux);
9548 ent.vd_next = BYTE_GET (edef->vd_next);
9549
9550 printf (_(" %#06x: Rev: %d Flags: %s"),
9551 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9552
9553 printf (_(" Index: %d Cnt: %d "),
9554 ent.vd_ndx, ent.vd_cnt);
9555
dd24e3da 9556 /* Check for overflow. */
7e26601c 9557 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9558 break;
9559
252b5132
RH		 9560 vstart += ent.vd_aux;
9561
9562 eaux = (Elf_External_Verdaux *) vstart;
9563
9564 aux.vda_name = BYTE_GET (eaux->vda_name);
9565 aux.vda_next = BYTE_GET (eaux->vda_next);
9566
d79b3d50
NC		 9567 if (VALID_DYNAMIC_NAME (aux.vda_name))
9568 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9569 else
9570 printf (_("Name index: %ld\n"), aux.vda_name);
9571
9572 isum = idx + ent.vd_aux;
9573
b34976b6 9574 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9575 {
dd24e3da 9576 /* Check for overflow. */
7e26601c 9577 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9578 break;
9579
252b5132
RH		 9580 isum += aux.vda_next;
9581 vstart += aux.vda_next;
9582
9583 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9584 if (vstart + sizeof (*eaux) > endbuf)
9585 break;
252b5132
RH		 9586
9587 aux.vda_name = BYTE_GET (eaux->vda_name);
9588 aux.vda_next = BYTE_GET (eaux->vda_next);
9589
d79b3d50 9590 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9591 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9592 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9593 else
9594 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9595 isum, j, aux.vda_name);
9596 }
dd24e3da 9597
54806181
AM		 9598 if (j < ent.vd_cnt)
9599 printf (_(" Version def aux past end of section\n"));
252b5132 9600
5d921cbd
NC		 9601 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9602 if (idx + ent.vd_next <= idx)
9603 break;
9604
252b5132
RH		 9605 idx += ent.vd_next;
9606 }
dd24e3da 9607
54806181
AM		 9608 if (cnt < section->sh_info)
9609 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9610
9611 free (edefs);
9612 }
9613 break;
103f02d3 9614
252b5132
RH		 9615 case SHT_GNU_verneed:
9616 {
2cf0635d 9617 Elf_External_Verneed * eneed;
b34976b6
AM		 9618 unsigned int idx;
9619 unsigned int cnt;
2cf0635d 9620 char * endbuf;
252b5132
RH		 9621
9622 found = 1;
9623
72de5009 9624 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9625 printable_section_name (section), section->sh_info);
252b5132
RH		 9626
9627 printf (_(" Addr: 0x"));
9628 printf_vma (section->sh_addr);
72de5009 9629 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9630 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9631 printable_section_name_from_index (section->sh_link));
252b5132 9632
3f5e193b
NC		 9633 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9634 section->sh_offset, 1,
9635 section->sh_size,
9cf03b7e 9636 _("Version Needs section"));
a6e9f9df
AM		 9637 if (!eneed)
9638 break;
59245841 9639 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9640
9641 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9642 {
2cf0635d 9643 Elf_External_Verneed * entry;
b34976b6
AM		 9644 Elf_Internal_Verneed ent;
9645 int j;
9646 int isum;
2cf0635d 9647 char * vstart;
252b5132 9648
7e26601c 9649 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9650 break;
9651
252b5132 9652 vstart = ((char *) eneed) + idx;
54806181
AM		 9653 if (vstart + sizeof (*entry) > endbuf)
9654 break;
252b5132
RH		 9655
9656 entry = (Elf_External_Verneed *) vstart;
9657
9658 ent.vn_version = BYTE_GET (entry->vn_version);
9659 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9660 ent.vn_file = BYTE_GET (entry->vn_file);
9661 ent.vn_aux = BYTE_GET (entry->vn_aux);
9662 ent.vn_next = BYTE_GET (entry->vn_next);
9663
9664 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9665
d79b3d50
NC		 9666 if (VALID_DYNAMIC_NAME (ent.vn_file))
9667 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9668 else
9669 printf (_(" File: %lx"), ent.vn_file);
9670
9671 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9672
dd24e3da 9673 /* Check for overflow. */
7e26601c 9674 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9675 break;
252b5132
RH		 9676 vstart += ent.vn_aux;
9677
9678 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9679 {
2cf0635d 9680 Elf_External_Vernaux * eaux;
b34976b6 9681 Elf_Internal_Vernaux aux;
252b5132 9682
54806181
AM		 9683 if (vstart + sizeof (*eaux) > endbuf)
9684 break;
252b5132
RH		 9685 eaux = (Elf_External_Vernaux *) vstart;
9686
9687 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9688 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9689 aux.vna_other = BYTE_GET (eaux->vna_other);
9690 aux.vna_name = BYTE_GET (eaux->vna_name);
9691 aux.vna_next = BYTE_GET (eaux->vna_next);
9692
d79b3d50 9693 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9694 printf (_(" %#06x: Name: %s"),
d79b3d50 9695 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9696 else
ecc2063b 9697 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9698 isum, aux.vna_name);
9699
9700 printf (_(" Flags: %s Version: %d\n"),
9701 get_ver_flags (aux.vna_flags), aux.vna_other);
9702
dd24e3da 9703 /* Check for overflow. */
53774b7e
NC		 9704 if (aux.vna_next > (size_t) (endbuf - vstart)
9705 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9706 {
9707 warn (_("Invalid vna_next field of %lx\n"),
9708 aux.vna_next);
9709 j = ent.vn_cnt;
9710 break;
9711 }
252b5132
RH		 9712 isum += aux.vna_next;
9713 vstart += aux.vna_next;
9714 }
9cf03b7e 9715
54806181 9716 if (j < ent.vn_cnt)
9cf03b7e 9717 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9718
bcf83b2a 9719 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9720 {
9721 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9722 cnt = section->sh_info;
9723 break;
9724 }
252b5132
RH		 9725 idx += ent.vn_next;
9726 }
9cf03b7e 9727
54806181 9728 if (cnt < section->sh_info)
9cf03b7e 9729 warn (_("Missing Version Needs information\n"));
103f02d3 9730
252b5132
RH		 9731 free (eneed);
9732 }
9733 break;
9734
9735 case SHT_GNU_versym:
9736 {
2cf0635d 9737 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9738 size_t total;
9739 unsigned int cnt;
2cf0635d
NC		 9740 unsigned char * edata;
9741 unsigned short * data;
9742 char * strtab;
9743 Elf_Internal_Sym * symbols;
9744 Elf_Internal_Shdr * string_sec;
ba5cdace 9745 unsigned long num_syms;
d3ba0551 9746 long off;
252b5132 9747
4fbb74a6 9748 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9749 break;
9750
4fbb74a6 9751 link_section = section_headers + section->sh_link;
08d8fa11 9752 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9753
4fbb74a6 9754 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9755 break;
9756
252b5132
RH		 9757 found = 1;
9758
ba5cdace 9759 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9760 if (symbols == NULL)
9761 break;
252b5132 9762
4fbb74a6 9763 string_sec = section_headers + link_section->sh_link;
252b5132 9764
3f5e193b
NC		 9765 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9766 string_sec->sh_size,
9767 _("version string table"));
a6e9f9df 9768 if (!strtab)
0429c154
MS		 9769 {
9770 free (symbols);
9771 break;
9772 }
252b5132 9773
8b73c356
NC		 9774 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9775 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9776
9777 printf (_(" Addr: "));
9778 printf_vma (section->sh_addr);
72de5009 9779 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9780 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9781 printable_section_name (link_section));
252b5132 9782
d3ba0551
AM		 9783 off = offset_from_vma (file,
9784 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9785 total * sizeof (short));
3f5e193b
NC		 9786 edata = (unsigned char *) get_data (NULL, file, off, total,
9787 sizeof (short),
9788 _("version symbol data"));
a6e9f9df
AM		 9789 if (!edata)
9790 {
9791 free (strtab);
0429c154 9792 free (symbols);
a6e9f9df
AM		 9793 break;
9794 }
252b5132 9795
3f5e193b 9796 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9797
9798 for (cnt = total; cnt --;)
b34976b6
AM		 9799 data[cnt] = byte_get (edata + cnt * sizeof (short),
9800 sizeof (short));
252b5132
RH		 9801
9802 free (edata);
9803
9804 for (cnt = 0; cnt < total; cnt += 4)
9805 {
9806 int j, nn;
00d93f34 9807 int check_def, check_need;
2cf0635d 9808 char * name;
252b5132
RH		 9809
9810 printf (" %03x:", cnt);
9811
9812 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9813 switch (data[cnt + j])
252b5132
RH		 9814 {
9815 case 0:
9816 fputs (_(" 0 (*local*) "), stdout);
9817 break;
9818
9819 case 1:
9820 fputs (_(" 1 (*global*) "), stdout);
9821 break;
9822
9823 default:
c244d050
NC		 9824 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9825 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9826
dd24e3da 9827 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9828 array, break to avoid an out-of-bounds read. */
9829 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9830 {
9831 warn (_("invalid index into symbol array\n"));
9832 break;
9833 }
9834
00d93f34
JJ		 9835 check_def = 1;
9836 check_need = 1;
4fbb74a6
AM		 9837 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9838 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9839 != SHT_NOBITS)
252b5132 9840 {
b34976b6 9841 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9842 check_def = 0;
9843 else
9844 check_need = 0;
252b5132 9845 }
00d93f34
JJ		 9846
9847 if (check_need
b34976b6 9848 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9849 {
b34976b6
AM		 9850 Elf_Internal_Verneed ivn;
9851 unsigned long offset;
252b5132 9852
d93f0186
NC		 9853 offset = offset_from_vma
9854 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9855 sizeof (Elf_External_Verneed));
252b5132 9856
b34976b6 9857 do
252b5132 9858 {
b34976b6
AM		 9859 Elf_Internal_Vernaux ivna;
9860 Elf_External_Verneed evn;
9861 Elf_External_Vernaux evna;
9862 unsigned long a_off;
252b5132 9863
59245841
NC		 9864 if (get_data (&evn, file, offset, sizeof (evn), 1,
9865 _("version need")) == NULL)
9866 break;
0b4362b0 9867
252b5132
RH		 9868 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9869 ivn.vn_next = BYTE_GET (evn.vn_next);
9870
9871 a_off = offset + ivn.vn_aux;
9872
9873 do
9874 {
59245841
NC		 9875 if (get_data (&evna, file, a_off, sizeof (evna),
9876 1, _("version need aux (2)")) == NULL)
9877 {
9878 ivna.vna_next = 0;
9879 ivna.vna_other = 0;
9880 }
9881 else
9882 {
9883 ivna.vna_next = BYTE_GET (evna.vna_next);
9884 ivna.vna_other = BYTE_GET (evna.vna_other);
9885 }
252b5132
RH		 9886
9887 a_off += ivna.vna_next;
9888 }
b34976b6 9889 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9890 && ivna.vna_next != 0);
9891
b34976b6 9892 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9893 {
9894 ivna.vna_name = BYTE_GET (evna.vna_name);
9895
54806181
AM		 9896 if (ivna.vna_name >= string_sec->sh_size)
9897 name = _("*invalid*");
9898 else
9899 name = strtab + ivna.vna_name;
252b5132 9900 nn += printf ("(%s%-*s",
16062207
ILT		 9901 name,
9902 12 - (int) strlen (name),
252b5132 9903 ")");
00d93f34 9904 check_def = 0;
252b5132
RH		 9905 break;
9906 }
9907
9908 offset += ivn.vn_next;
9909 }
9910 while (ivn.vn_next);
9911 }
00d93f34 9912
b34976b6
AM		 9913 if (check_def && data[cnt + j] != 0x8001
9914 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9915 {
b34976b6
AM		 9916 Elf_Internal_Verdef ivd;
9917 Elf_External_Verdef evd;
9918 unsigned long offset;
252b5132 9919
d93f0186
NC		 9920 offset = offset_from_vma
9921 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9922 sizeof evd);
252b5132
RH		 9923
9924 do
9925 {
59245841
NC		 9926 if (get_data (&evd, file, offset, sizeof (evd), 1,
9927 _("version def")) == NULL)
9928 {
9929 ivd.vd_next = 0;
948f632f 9930 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9931 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9932 break;
59245841
NC		 9933 }
9934 else
9935 {
9936 ivd.vd_next = BYTE_GET (evd.vd_next);
9937 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9938 }
252b5132
RH		 9939
9940 offset += ivd.vd_next;
9941 }
c244d050 9942 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9943 && ivd.vd_next != 0);
9944
c244d050 9945 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9946 {
b34976b6
AM		 9947 Elf_External_Verdaux evda;
9948 Elf_Internal_Verdaux ivda;
252b5132
RH		 9949
9950 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9951
59245841
NC		 9952 if (get_data (&evda, file,
9953 offset - ivd.vd_next + ivd.vd_aux,
9954 sizeof (evda), 1,
9955 _("version def aux")) == NULL)
9956 break;
252b5132
RH		 9957
9958 ivda.vda_name = BYTE_GET (evda.vda_name);
9959
54806181
AM		 9960 if (ivda.vda_name >= string_sec->sh_size)
9961 name = _("*invalid*");
9962 else
9963 name = strtab + ivda.vda_name;
252b5132 9964 nn += printf ("(%s%-*s",
16062207
ILT		 9965 name,
9966 12 - (int) strlen (name),
252b5132
RH		 9967 ")");
9968 }
9969 }
9970
9971 if (nn < 18)
9972 printf ("%*c", 18 - nn, ' ');
9973 }
9974
9975 putchar ('\n');
9976 }
9977
9978 free (data);
9979 free (strtab);
9980 free (symbols);
9981 }
9982 break;
103f02d3 9983
252b5132
RH		 9984 default:
9985 break;
9986 }
9987 }
9988
9989 if (! found)
9990 printf (_("\nNo version information found in this file.\n"));
9991
9992 return 1;
9993}
9994
d1133906 9995static const char *
d3ba0551 9996get_symbol_binding (unsigned int binding)
252b5132 9997{
b34976b6 9998 static char buff[32];
252b5132
RH		 9999
10000 switch (binding)
10001 {
b34976b6
AM		 10002 case STB_LOCAL: return "LOCAL";
10003 case STB_GLOBAL: return "GLOBAL";
10004 case STB_WEAK: return "WEAK";
252b5132
RH		 10005 default:
10006 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10007 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10008 binding);
252b5132 10009 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10010 {
10011 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10012 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10013 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10014 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10015 return "UNIQUE";
10016 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10017 }
252b5132 10018 else
e9e44622 10019 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10020 return buff;
10021 }
10022}
10023
d1133906 10024static const char *
d3ba0551 10025get_symbol_type (unsigned int type)
252b5132 10026{
b34976b6 10027 static char buff[32];
252b5132
RH		 10028
10029 switch (type)
10030 {
b34976b6
AM		 10031 case STT_NOTYPE: return "NOTYPE";
10032 case STT_OBJECT: return "OBJECT";
10033 case STT_FUNC: return "FUNC";
10034 case STT_SECTION: return "SECTION";
10035 case STT_FILE: return "FILE";
10036 case STT_COMMON: return "COMMON";
10037 case STT_TLS: return "TLS";
15ab5209
DB		 10038 case STT_RELC: return "RELC";
10039 case STT_SRELC: return "SRELC";
252b5132
RH		 10040 default:
10041 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10042 {
3510a7b8
NC		 10043 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10044 return "THUMB_FUNC";
103f02d3 10045
351b4b40 10046 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10047 return "REGISTER";
10048
10049 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10050 return "PARISC_MILLI";
10051
e9e44622 10052 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10053 }
252b5132 10054 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10055 {
10056 if (elf_header.e_machine == EM_PARISC)
10057 {
10058 if (type == STT_HP_OPAQUE)
10059 return "HP_OPAQUE";
10060 if (type == STT_HP_STUB)
10061 return "HP_STUB";
10062 }
10063
d8045f23 10064 if (type == STT_GNU_IFUNC
9c55345c 10065 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10066 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10067 /* GNU is still using the default value 0. */
d8045f23
NC		 10068 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10069 return "IFUNC";
10070
e9e44622 10071 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10072 }
252b5132 10073 else
e9e44622 10074 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10075 return buff;
10076 }
10077}
10078
d1133906 10079static const char *
d3ba0551 10080get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10081{
10082 switch (visibility)
10083 {
b34976b6
AM		 10084 case STV_DEFAULT: return "DEFAULT";
10085 case STV_INTERNAL: return "INTERNAL";
10086 case STV_HIDDEN: return "HIDDEN";
d1133906 10087 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10088 default:
10089 error (_("Unrecognized visibility value: %u"), visibility);
10090 return _("<unknown>");
d1133906
NC		 10091 }
10092}
10093
5e2b0d47
NC		 10094static const char *
10095get_mips_symbol_other (unsigned int other)
10096{
10097 switch (other)
10098 {
df58fc94
RS		 10099 case STO_OPTIONAL:
10100 return "OPTIONAL";
10101 case STO_MIPS_PLT:
10102 return "MIPS PLT";
10103 case STO_MIPS_PIC:
10104 return "MIPS PIC";
10105 case STO_MICROMIPS:
10106 return "MICROMIPS";
10107 case STO_MICROMIPS | STO_MIPS_PIC:
10108 return "MICROMIPS, MIPS PIC";
10109 case STO_MIPS16:
10110 return "MIPS16";
10111 default:
10112 return NULL;
5e2b0d47
NC		 10113 }
10114}
10115
28f997cf
TG		 10116static const char *
10117get_ia64_symbol_other (unsigned int other)
10118{
10119 if (is_ia64_vms ())
10120 {
10121 static char res[32];
10122
10123 res[0] = 0;
10124
10125 /* Function types is for images and .STB files only. */
10126 switch (elf_header.e_type)
10127 {
10128 case ET_DYN:
10129 case ET_EXEC:
10130 switch (VMS_ST_FUNC_TYPE (other))
10131 {
10132 case VMS_SFT_CODE_ADDR:
10133 strcat (res, " CA");
10134 break;
10135 case VMS_SFT_SYMV_IDX:
10136 strcat (res, " VEC");
10137 break;
10138 case VMS_SFT_FD:
10139 strcat (res, " FD");
10140 break;
10141 case VMS_SFT_RESERVE:
10142 strcat (res, " RSV");
10143 break;
10144 default:
bee0ee85
NC		 10145 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10146 VMS_ST_FUNC_TYPE (other));
10147 strcat (res, " <unknown>");
10148 break;
28f997cf
TG		 10149 }
10150 break;
10151 default:
10152 break;
10153 }
10154 switch (VMS_ST_LINKAGE (other))
10155 {
10156 case VMS_STL_IGNORE:
10157 strcat (res, " IGN");
10158 break;
10159 case VMS_STL_RESERVE:
10160 strcat (res, " RSV");
10161 break;
10162 case VMS_STL_STD:
10163 strcat (res, " STD");
10164 break;
10165 case VMS_STL_LNK:
10166 strcat (res, " LNK");
10167 break;
10168 default:
bee0ee85
NC		 10169 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10170 VMS_ST_LINKAGE (other));
10171 strcat (res, " <unknown>");
10172 break;
28f997cf
TG		 10173 }
10174
10175 if (res[0] != 0)
10176 return res + 1;
10177 else
10178 return res;
10179 }
10180 return NULL;
10181}
10182
6911b7dc
AM		 10183static const char *
10184get_ppc64_symbol_other (unsigned int other)
10185{
10186 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10187 {
10188 static char buf[32];
10189 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10190 PPC64_LOCAL_ENTRY_OFFSET (other));
10191 return buf;
10192 }
10193 return NULL;
10194}
10195
5e2b0d47
NC		 10196static const char *
10197get_symbol_other (unsigned int other)
10198{
10199 const char * result = NULL;
10200 static char buff [32];
10201
10202 if (other == 0)
10203 return "";
10204
10205 switch (elf_header.e_machine)
10206 {
10207 case EM_MIPS:
10208 result = get_mips_symbol_other (other);
28f997cf
TG		 10209 break;
10210 case EM_IA_64:
10211 result = get_ia64_symbol_other (other);
10212 break;
6911b7dc
AM		 10213 case EM_PPC64:
10214 result = get_ppc64_symbol_other (other);
10215 break;
5e2b0d47
NC		 10216 default:
10217 break;
10218 }
10219
10220 if (result)
10221 return result;
10222
10223 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10224 return buff;
10225}
10226
d1133906 10227static const char *
d3ba0551 10228get_symbol_index_type (unsigned int type)
252b5132 10229{
b34976b6 10230 static char buff[32];
5cf1065c 10231
252b5132
RH		 10232 switch (type)
10233 {
b34976b6
AM		 10234 case SHN_UNDEF: return "UND";
10235 case SHN_ABS: return "ABS";
10236 case SHN_COMMON: return "COM";
252b5132 10237 default:
9ce701e2
L		 10238 if (type == SHN_IA_64_ANSI_COMMON
10239 && elf_header.e_machine == EM_IA_64
10240 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10241 return "ANSI_COM";
8a9036a4 10242 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10243 || elf_header.e_machine == EM_L1OM
10244 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10245 && type == SHN_X86_64_LCOMMON)
10246 return "LARGE_COM";
ac145307
BS		 10247 else if ((type == SHN_MIPS_SCOMMON
10248 && elf_header.e_machine == EM_MIPS)
10249 || (type == SHN_TIC6X_SCOMMON
10250 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10251 return "SCOM";
10252 else if (type == SHN_MIPS_SUNDEFINED
10253 && elf_header.e_machine == EM_MIPS)
10254 return "SUND";
9ce701e2 10255 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10256 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10257 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10258 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10259 else if (type >= SHN_LORESERVE)
10260 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10261 else if (type >= elf_header.e_shnum)
e0a31db1 10262 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10263 else
232e7cb8 10264 sprintf (buff, "%3d", type);
5cf1065c 10265 break;
252b5132 10266 }
5cf1065c
NC		 10267
10268 return buff;
252b5132
RH		 10269}
10270
66543521 10271static bfd_vma *
57028622 10272get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10273{
2cf0635d
NC		 10274 unsigned char * e_data;
10275 bfd_vma * i_data;
252b5132 10276
57028622
NC		 10277 /* If the size_t type is smaller than the bfd_size_type, eg because
10278 you are building a 32-bit tool on a 64-bit host, then make sure
10279 that when (number) is cast to (size_t) no information is lost. */
10280 if (sizeof (size_t) < sizeof (bfd_size_type)
10281 && (bfd_size_type) ((size_t) number) != number)
10282 {
10283 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10284 (unsigned long long) number, ent_size);
10285 return NULL;
10286 }
948f632f 10287
3102e897
NC		 10288 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10289 attempting to allocate memory when the read is bound to fail. */
10290 if (ent_size * number > current_file_size)
10291 {
57028622
NC		 10292 error (_("Invalid number of dynamic entries: %llu\n"),
10293 (unsigned long long) number);
3102e897
NC		 10294 return NULL;
10295 }
10296
57028622 10297 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10298 if (e_data == NULL)
10299 {
57028622
NC		 10300 error (_("Out of memory reading %llu dynamic entries\n"),
10301 (unsigned long long) number);
252b5132
RH		 10302 return NULL;
10303 }
10304
57028622 10305 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10306 {
57028622
NC		 10307 error (_("Unable to read in %llu bytes of dynamic data\n"),
10308 (unsigned long long) (number * ent_size));
3102e897 10309 free (e_data);
252b5132
RH		 10310 return NULL;
10311 }
10312
57028622 10313 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10314 if (i_data == NULL)
10315 {
57028622
NC		 10316 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10317 (unsigned long long) number);
252b5132
RH		 10318 free (e_data);
10319 return NULL;
10320 }
10321
10322 while (number--)
66543521 10323 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10324
10325 free (e_data);
10326
10327 return i_data;
10328}
10329
6bd1a22c
L		 10330static void
10331print_dynamic_symbol (bfd_vma si, unsigned long hn)
10332{
2cf0635d 10333 Elf_Internal_Sym * psym;
6bd1a22c
L		 10334 int n;
10335
6bd1a22c
L		 10336 n = print_vma (si, DEC_5);
10337 if (n < 5)
0b4362b0 10338 fputs (&" "[n], stdout);
6bd1a22c 10339 printf (" %3lu: ", hn);
e0a31db1
NC		 10340
10341 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10342 {
3102e897
NC		 10343 printf (_("<No info available for dynamic symbol number %lu>\n"),
10344 (unsigned long) si);
e0a31db1
NC		 10345 return;
10346 }
10347
10348 psym = dynamic_symbols + si;
6bd1a22c
L		 10349 print_vma (psym->st_value, LONG_HEX);
10350 putchar (' ');
10351 print_vma (psym->st_size, DEC_5);
10352
f4be36b3
AM		 10353 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10354 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10355 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10356 /* Check to see if any other bits in the st_other field are set.
10357 Note - displaying this information disrupts the layout of the
10358 table being generated, but for the moment this case is very
10359 rare. */
10360 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10361 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10362 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10363 if (VALID_DYNAMIC_NAME (psym->st_name))
10364 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10365 else
2b692964 10366 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10367 putchar ('\n');
10368}
10369
bb4d2ac2
L		 10370static const char *
10371get_symbol_version_string (FILE *file, int is_dynsym,
10372 const char *strtab,
10373 unsigned long int strtab_size,
10374 unsigned int si, Elf_Internal_Sym *psym,
10375 enum versioned_symbol_info *sym_info,
10376 unsigned short *vna_other)
10377{
10378 const char *version_string = NULL;
10379
10380 if (is_dynsym
10381 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10382 {
10383 unsigned char data[2];
10384 unsigned short vers_data;
10385 unsigned long offset;
10386 int is_nobits;
10387 int check_def;
10388
10389 offset = offset_from_vma
10390 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10391 sizeof data + si * sizeof (vers_data));
10392
10393 if (get_data (&data, file, offset + si * sizeof (vers_data),
10394 sizeof (data), 1, _("version data")) == NULL)
10395 return NULL;
10396
10397 vers_data = byte_get (data, 2);
10398
53774b7e
NC		 10399 is_nobits = (section_headers != NULL
10400 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10401 && section_headers[psym->st_shndx].sh_type
10402 == SHT_NOBITS);
10403
10404 check_def = (psym->st_shndx != SHN_UNDEF);
10405
10406 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10407 {
10408 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10409 && (is_nobits || ! check_def))
10410 {
10411 Elf_External_Verneed evn;
10412 Elf_Internal_Verneed ivn;
10413 Elf_Internal_Vernaux ivna;
10414
10415 /* We must test both. */
10416 offset = offset_from_vma
10417 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10418 sizeof evn);
10419
10420 do
10421 {
10422 unsigned long vna_off;
10423
10424 if (get_data (&evn, file, offset, sizeof (evn), 1,
10425 _("version need")) == NULL)
10426 {
10427 ivna.vna_next = 0;
10428 ivna.vna_other = 0;
10429 ivna.vna_name = 0;
10430 break;
10431 }
10432
10433 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10434 ivn.vn_next = BYTE_GET (evn.vn_next);
10435
10436 vna_off = offset + ivn.vn_aux;
10437
10438 do
10439 {
10440 Elf_External_Vernaux evna;
10441
10442 if (get_data (&evna, file, vna_off,
10443 sizeof (evna), 1,
10444 _("version need aux (3)")) == NULL)
10445 {
10446 ivna.vna_next = 0;
10447 ivna.vna_other = 0;
10448 ivna.vna_name = 0;
10449 }
10450 else
10451 {
10452 ivna.vna_other = BYTE_GET (evna.vna_other);
10453 ivna.vna_next = BYTE_GET (evna.vna_next);
10454 ivna.vna_name = BYTE_GET (evna.vna_name);
10455 }
10456
10457 vna_off += ivna.vna_next;
10458 }
10459 while (ivna.vna_other != vers_data
10460 && ivna.vna_next != 0);
10461
10462 if (ivna.vna_other == vers_data)
10463 break;
10464
10465 offset += ivn.vn_next;
10466 }
10467 while (ivn.vn_next != 0);
10468
10469 if (ivna.vna_other == vers_data)
10470 {
10471 *sym_info = symbol_undefined;
10472 *vna_other = ivna.vna_other;
10473 version_string = (ivna.vna_name < strtab_size
10474 ? strtab + ivna.vna_name
10475 : _("<corrupt>"));
10476 check_def = 0;
10477 }
10478 else if (! is_nobits)
10479 error (_("bad dynamic symbol\n"));
10480 else
10481 check_def = 1;
10482 }
10483
10484 if (check_def)
10485 {
10486 if (vers_data != 0x8001
10487 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10488 {
10489 Elf_Internal_Verdef ivd;
10490 Elf_Internal_Verdaux ivda;
10491 Elf_External_Verdaux evda;
10492 unsigned long off;
10493
10494 off = offset_from_vma
10495 (file,
10496 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10497 sizeof (Elf_External_Verdef));
10498
10499 do
10500 {
10501 Elf_External_Verdef evd;
10502
10503 if (get_data (&evd, file, off, sizeof (evd),
10504 1, _("version def")) == NULL)
10505 {
10506 ivd.vd_ndx = 0;
10507 ivd.vd_aux = 0;
10508 ivd.vd_next = 0;
10509 }
10510 else
10511 {
10512 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10513 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10514 ivd.vd_next = BYTE_GET (evd.vd_next);
10515 }
10516
10517 off += ivd.vd_next;
10518 }
10519 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10520 && ivd.vd_next != 0);
10521
10522 off -= ivd.vd_next;
10523 off += ivd.vd_aux;
10524
10525 if (get_data (&evda, file, off, sizeof (evda),
10526 1, _("version def aux")) == NULL)
10527 return version_string;
10528
10529 ivda.vda_name = BYTE_GET (evda.vda_name);
10530
10531 if (psym->st_name != ivda.vda_name)
10532 {
10533 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10534 ? symbol_hidden : symbol_public);
10535 version_string = (ivda.vda_name < strtab_size
10536 ? strtab + ivda.vda_name
10537 : _("<corrupt>"));
10538 }
10539 }
10540 }
10541 }
10542 }
10543 return version_string;
10544}
10545
e3c8793a 10546/* Dump the symbol table. */
252b5132 10547static int
2cf0635d 10548process_symbol_table (FILE * file)
252b5132 10549{
2cf0635d 10550 Elf_Internal_Shdr * section;
8b73c356
NC		 10551 bfd_size_type nbuckets = 0;
10552 bfd_size_type nchains = 0;
2cf0635d
NC		 10553 bfd_vma * buckets = NULL;
10554 bfd_vma * chains = NULL;
fdc90cb4 10555 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10556 bfd_vma * gnubuckets = NULL;
10557 bfd_vma * gnuchains = NULL;
6bd1a22c 10558 bfd_vma gnusymidx = 0;
071436c6 10559 bfd_size_type ngnuchains = 0;
252b5132 10560
2c610e4b 10561 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10562 return 1;
10563
6bd1a22c
L		 10564 if (dynamic_info[DT_HASH]
10565 && (do_histogram
2c610e4b
L		 10566 || (do_using_dynamic
10567 && !do_dyn_syms
10568 && dynamic_strings != NULL)))
252b5132 10569 {
66543521
AM		 10570 unsigned char nb[8];
10571 unsigned char nc[8];
8b73c356 10572 unsigned int hash_ent_size = 4;
66543521
AM		 10573
10574 if ((elf_header.e_machine == EM_ALPHA
10575 || elf_header.e_machine == EM_S390
10576 || elf_header.e_machine == EM_S390_OLD)
10577 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10578 hash_ent_size = 8;
10579
fb52b2f4
NC		 10580 if (fseek (file,
10581 (archive_file_offset
10582 + offset_from_vma (file, dynamic_info[DT_HASH],
10583 sizeof nb + sizeof nc)),
d93f0186 10584 SEEK_SET))
252b5132 10585 {
591a748a 10586 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10587 goto no_hash;
252b5132
RH		 10588 }
10589
66543521 10590 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10591 {
10592 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10593 goto no_hash;
252b5132
RH		 10594 }
10595
66543521 10596 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10597 {
10598 error (_("Failed to read in number of chains\n"));
d3a44ec6 10599 goto no_hash;
252b5132
RH		 10600 }
10601
66543521
AM		 10602 nbuckets = byte_get (nb, hash_ent_size);
10603 nchains = byte_get (nc, hash_ent_size);
252b5132 10604
66543521
AM		 10605 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10606 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10607
d3a44ec6 10608 no_hash:
252b5132 10609 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10610 {
10611 if (do_using_dynamic)
10612 return 0;
10613 free (buckets);
10614 free (chains);
10615 buckets = NULL;
10616 chains = NULL;
10617 nbuckets = 0;
10618 nchains = 0;
10619 }
252b5132
RH		 10620 }
10621
6bd1a22c
L		 10622 if (dynamic_info_DT_GNU_HASH
10623 && (do_histogram
2c610e4b
L		 10624 || (do_using_dynamic
10625 && !do_dyn_syms
10626 && dynamic_strings != NULL)))
252b5132 10627 {
6bd1a22c
L		 10628 unsigned char nb[16];
10629 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10630 bfd_vma buckets_vma;
10631
10632 if (fseek (file,
10633 (archive_file_offset
10634 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10635 sizeof nb)),
10636 SEEK_SET))
10637 {
10638 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10639 goto no_gnu_hash;
6bd1a22c 10640 }
252b5132 10641
6bd1a22c
L		 10642 if (fread (nb, 16, 1, file) != 1)
10643 {
10644 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10645 goto no_gnu_hash;
6bd1a22c
L		 10646 }
10647
10648 ngnubuckets = byte_get (nb, 4);
10649 gnusymidx = byte_get (nb + 4, 4);
10650 bitmaskwords = byte_get (nb + 8, 4);
10651 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10652 if (is_32bit_elf)
6bd1a22c 10653 buckets_vma += bitmaskwords * 4;
f7a99963 10654 else
6bd1a22c 10655 buckets_vma += bitmaskwords * 8;
252b5132 10656
6bd1a22c
L		 10657 if (fseek (file,
10658 (archive_file_offset
10659 + offset_from_vma (file, buckets_vma, 4)),
10660 SEEK_SET))
252b5132 10661 {
6bd1a22c 10662 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10663 goto no_gnu_hash;
6bd1a22c
L		 10664 }
10665
10666 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10667
6bd1a22c 10668 if (gnubuckets == NULL)
d3a44ec6 10669 goto no_gnu_hash;
6bd1a22c
L		 10670
10671 for (i = 0; i < ngnubuckets; i++)
10672 if (gnubuckets[i] != 0)
10673 {
10674 if (gnubuckets[i] < gnusymidx)
10675 return 0;
10676
10677 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10678 maxchain = gnubuckets[i];
10679 }
10680
10681 if (maxchain == 0xffffffff)
d3a44ec6 10682 goto no_gnu_hash;
6bd1a22c
L		 10683
10684 maxchain -= gnusymidx;
10685
10686 if (fseek (file,
10687 (archive_file_offset
10688 + offset_from_vma (file, buckets_vma
10689 + 4 * (ngnubuckets + maxchain), 4)),
10690 SEEK_SET))
10691 {
10692 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10693 goto no_gnu_hash;
6bd1a22c
L		 10694 }
10695
10696 do
10697 {
10698 if (fread (nb, 4, 1, file) != 1)
252b5132 10699 {
6bd1a22c 10700 error (_("Failed to determine last chain length\n"));
d3a44ec6 10701 goto no_gnu_hash;
6bd1a22c 10702 }
252b5132 10703
6bd1a22c 10704 if (maxchain + 1 == 0)
d3a44ec6 10705 goto no_gnu_hash;
252b5132 10706
6bd1a22c
L		 10707 ++maxchain;
10708 }
10709 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10710
6bd1a22c
L		 10711 if (fseek (file,
10712 (archive_file_offset
10713 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10714 SEEK_SET))
10715 {
10716 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10717 goto no_gnu_hash;
6bd1a22c
L		 10718 }
10719
10720 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10721 ngnuchains = maxchain;
6bd1a22c 10722
d3a44ec6 10723 no_gnu_hash:
6bd1a22c 10724 if (gnuchains == NULL)
d3a44ec6
JJ		 10725 {
10726 free (gnubuckets);
d3a44ec6
JJ		 10727 gnubuckets = NULL;
10728 ngnubuckets = 0;
f64fddf1
NC		 10729 if (do_using_dynamic)
10730 return 0;
d3a44ec6 10731 }
6bd1a22c
L		 10732 }
10733
10734 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10735 && do_syms
10736 && do_using_dynamic
3102e897
NC		 10737 && dynamic_strings != NULL
10738 && dynamic_symbols != NULL)
6bd1a22c
L		 10739 {
10740 unsigned long hn;
10741
10742 if (dynamic_info[DT_HASH])
10743 {
10744 bfd_vma si;
10745
10746 printf (_("\nSymbol table for image:\n"));
10747 if (is_32bit_elf)
10748 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10749 else
10750 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10751
10752 for (hn = 0; hn < nbuckets; hn++)
10753 {
10754 if (! buckets[hn])
10755 continue;
10756
10757 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10758 print_dynamic_symbol (si, hn);
252b5132
RH		 10759 }
10760 }
6bd1a22c
L		 10761
10762 if (dynamic_info_DT_GNU_HASH)
10763 {
10764 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10765 if (is_32bit_elf)
10766 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10767 else
10768 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10769
10770 for (hn = 0; hn < ngnubuckets; ++hn)
10771 if (gnubuckets[hn] != 0)
10772 {
10773 bfd_vma si = gnubuckets[hn];
10774 bfd_vma off = si - gnusymidx;
10775
10776 do
10777 {
10778 print_dynamic_symbol (si, hn);
10779 si++;
10780 }
071436c6 10781 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10782 }
10783 }
252b5132 10784 }
8b73c356
NC		 10785 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10786 && section_headers != NULL)
252b5132 10787 {
b34976b6 10788 unsigned int i;
252b5132
RH		 10789
10790 for (i = 0, section = section_headers;
10791 i < elf_header.e_shnum;
10792 i++, section++)
10793 {
b34976b6 10794 unsigned int si;
2cf0635d 10795 char * strtab = NULL;
c256ffe7 10796 unsigned long int strtab_size = 0;
2cf0635d
NC		 10797 Elf_Internal_Sym * symtab;
10798 Elf_Internal_Sym * psym;
ba5cdace 10799 unsigned long num_syms;
252b5132 10800
2c610e4b
L		 10801 if ((section->sh_type != SHT_SYMTAB
10802 && section->sh_type != SHT_DYNSYM)
10803 || (!do_syms
10804 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10805 continue;
10806
dd24e3da
NC		 10807 if (section->sh_entsize == 0)
10808 {
10809 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10810 printable_section_name (section));
dd24e3da
NC		 10811 continue;
10812 }
10813
252b5132 10814 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10815 printable_section_name (section),
252b5132 10816 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10817
f7a99963 10818 if (is_32bit_elf)
ca47b30c 10819 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10820 else
ca47b30c 10821 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10822
ba5cdace 10823 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10824 if (symtab == NULL)
10825 continue;
10826
10827 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10828 {
10829 strtab = string_table;
10830 strtab_size = string_table_length;
10831 }
4fbb74a6 10832 else if (section->sh_link < elf_header.e_shnum)
252b5132 10833 {
2cf0635d 10834 Elf_Internal_Shdr * string_sec;
252b5132 10835
4fbb74a6 10836 string_sec = section_headers + section->sh_link;
252b5132 10837
3f5e193b
NC		 10838 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10839 1, string_sec->sh_size,
10840 _("string table"));
c256ffe7 10841 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10842 }
10843
ba5cdace 10844 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10845 {
bb4d2ac2
L		 10846 const char *version_string;
10847 enum versioned_symbol_info sym_info;
10848 unsigned short vna_other;
10849
5e220199 10850 printf ("%6d: ", si);
f7a99963
NC		 10851 print_vma (psym->st_value, LONG_HEX);
10852 putchar (' ');
10853 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10854 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10855 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10856 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10857 /* Check to see if any other bits in the st_other field are set.
10858 Note - displaying this information disrupts the layout of the
10859 table being generated, but for the moment this case is very rare. */
10860 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10861 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10862 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10863 print_symbol (25, psym->st_name < strtab_size
2b692964 10864 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10865
bb4d2ac2
L		 10866 version_string
10867 = get_symbol_version_string (file,
10868 section->sh_type == SHT_DYNSYM,
10869 strtab, strtab_size, si,
10870 psym, &sym_info, &vna_other);
10871 if (version_string)
252b5132 10872 {
bb4d2ac2
L		 10873 if (sym_info == symbol_undefined)
10874 printf ("@%s (%d)", version_string, vna_other);
10875 else
10876 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10877 version_string);
252b5132
RH		 10878 }
10879
10880 putchar ('\n');
10881 }
10882
10883 free (symtab);
10884 if (strtab != string_table)
10885 free (strtab);
10886 }
10887 }
10888 else if (do_syms)
10889 printf
10890 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10891
10892 if (do_histogram && buckets != NULL)
10893 {
2cf0635d
NC		 10894 unsigned long * lengths;
10895 unsigned long * counts;
66543521
AM		 10896 unsigned long hn;
10897 bfd_vma si;
10898 unsigned long maxlength = 0;
10899 unsigned long nzero_counts = 0;
10900 unsigned long nsyms = 0;
94d15024 10901 unsigned long chained;
252b5132 10902
66543521
AM		 10903 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10904 (unsigned long) nbuckets);
252b5132 10905
3f5e193b 10906 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10907 if (lengths == NULL)
10908 {
8b73c356 10909 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10910 return 0;
10911 }
8b73c356
NC		 10912
10913 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10914 for (hn = 0; hn < nbuckets; ++hn)
10915 {
94d15024
MF		 10916 for (si = buckets[hn], chained = 0;
10917 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10918 si = chains[si], ++chained)
252b5132 10919 {
b34976b6 10920 ++nsyms;
252b5132 10921 if (maxlength < ++lengths[hn])
b34976b6 10922 ++maxlength;
252b5132 10923 }
94d15024
MF		 10924
10925 /* PR binutils/17531: A corrupt binary could contain broken
10926 histogram data. Do not go into an infinite loop trying
10927 to process it. */
10928 if (chained > nchains)
10929 {
10930 error (_("histogram chain is corrupt\n"));
10931 break;
10932 }
252b5132
RH		 10933 }
10934
3f5e193b 10935 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10936 if (counts == NULL)
10937 {
b2e951ec 10938 free (lengths);
8b73c356 10939 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10940 return 0;
10941 }
10942
10943 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10944 ++counts[lengths[hn]];
252b5132 10945
103f02d3 10946 if (nbuckets > 0)
252b5132 10947 {
66543521
AM		 10948 unsigned long i;
10949 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10950 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10951 for (i = 1; i <= maxlength; ++i)
103f02d3 10952 {
66543521
AM		 10953 nzero_counts += counts[i] * i;
10954 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10955 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10956 (nzero_counts * 100.0) / nsyms);
10957 }
252b5132
RH		 10958 }
10959
10960 free (counts);
10961 free (lengths);
10962 }
10963
10964 if (buckets != NULL)
10965 {
10966 free (buckets);
10967 free (chains);
10968 }
10969
d3a44ec6 10970 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10971 {
2cf0635d
NC		 10972 unsigned long * lengths;
10973 unsigned long * counts;
fdc90cb4
JJ		 10974 unsigned long hn;
10975 unsigned long maxlength = 0;
10976 unsigned long nzero_counts = 0;
10977 unsigned long nsyms = 0;
fdc90cb4 10978
8b73c356
NC		 10979 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10980 (unsigned long) ngnubuckets);
10981
3f5e193b 10982 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10983 if (lengths == NULL)
10984 {
8b73c356 10985 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10986 return 0;
10987 }
10988
fdc90cb4
JJ		 10989 printf (_(" Length Number %% of total Coverage\n"));
10990
10991 for (hn = 0; hn < ngnubuckets; ++hn)
10992 if (gnubuckets[hn] != 0)
10993 {
10994 bfd_vma off, length = 1;
10995
6bd1a22c 10996 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10997 /* PR 17531 file: 010-77222-0.004. */
10998 off < ngnuchains && (gnuchains[off] & 1) == 0;
10999 ++off)
fdc90cb4
JJ		 11000 ++length;
11001 lengths[hn] = length;
11002 if (length > maxlength)
11003 maxlength = length;
11004 nsyms += length;
11005 }
11006
3f5e193b 11007 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11008 if (counts == NULL)
11009 {
b2e951ec 11010 free (lengths);
8b73c356 11011 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11012 return 0;
11013 }
11014
11015 for (hn = 0; hn < ngnubuckets; ++hn)
11016 ++counts[lengths[hn]];
11017
11018 if (ngnubuckets > 0)
11019 {
11020 unsigned long j;
11021 printf (" 0 %-10lu (%5.1f%%)\n",
11022 counts[0], (counts[0] * 100.0) / ngnubuckets);
11023 for (j = 1; j <= maxlength; ++j)
11024 {
11025 nzero_counts += counts[j] * j;
11026 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11027 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11028 (nzero_counts * 100.0) / nsyms);
11029 }
11030 }
11031
11032 free (counts);
11033 free (lengths);
11034 free (gnubuckets);
11035 free (gnuchains);
11036 }
11037
252b5132
RH		 11038 return 1;
11039}
11040
11041static int
2cf0635d 11042process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11043{
b4c96d0d 11044 unsigned int i;
252b5132
RH		 11045
11046 if (dynamic_syminfo == NULL
11047 || !do_dynamic)
11048 /* No syminfo, this is ok. */
11049 return 1;
11050
11051 /* There better should be a dynamic symbol section. */
11052 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11053 return 0;
11054
11055 if (dynamic_addr)
11056 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11057 dynamic_syminfo_offset, dynamic_syminfo_nent);
11058
11059 printf (_(" Num: Name BoundTo Flags\n"));
11060 for (i = 0; i < dynamic_syminfo_nent; ++i)
11061 {
11062 unsigned short int flags = dynamic_syminfo[i].si_flags;
11063
31104126 11064 printf ("%4d: ", i);
4082ef84
NC		 11065 if (i >= num_dynamic_syms)
11066 printf (_("<corrupt index>"));
11067 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11068 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11069 else
2b692964 11070 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11071 putchar (' ');
252b5132
RH		 11072
11073 switch (dynamic_syminfo[i].si_boundto)
11074 {
11075 case SYMINFO_BT_SELF:
11076 fputs ("SELF ", stdout);
11077 break;
11078 case SYMINFO_BT_PARENT:
11079 fputs ("PARENT ", stdout);
11080 break;
11081 default:
11082 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11083 && dynamic_syminfo[i].si_boundto < dynamic_nent
11084 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11085 {
d79b3d50 11086 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11087 putchar (' ' );
11088 }
252b5132
RH		 11089 else
11090 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11091 break;
11092 }
11093
11094 if (flags & SYMINFO_FLG_DIRECT)
11095 printf (" DIRECT");
11096 if (flags & SYMINFO_FLG_PASSTHRU)
11097 printf (" PASSTHRU");
11098 if (flags & SYMINFO_FLG_COPY)
11099 printf (" COPY");
11100 if (flags & SYMINFO_FLG_LAZYLOAD)
11101 printf (" LAZYLOAD");
11102
11103 puts ("");
11104 }
11105
11106 return 1;
11107}
11108
cf13d699
NC		 11109/* Check to see if the given reloc needs to be handled in a target specific
11110 manner. If so then process the reloc and return TRUE otherwise return
11111 FALSE. */
09c11c86 11112
cf13d699
NC		 11113static bfd_boolean
11114target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11115 unsigned char * start,
11116 Elf_Internal_Sym * symtab)
252b5132 11117{
cf13d699 11118 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11119
cf13d699 11120 switch (elf_header.e_machine)
252b5132 11121 {
13761a11
NC		 11122 case EM_MSP430:
11123 case EM_MSP430_OLD:
11124 {
11125 static Elf_Internal_Sym * saved_sym = NULL;
11126
11127 switch (reloc_type)
11128 {
11129 case 10: /* R_MSP430_SYM_DIFF */
11130 if (uses_msp430x_relocs ())
11131 break;
11132 case 21: /* R_MSP430X_SYM_DIFF */
11133 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11134 return TRUE;
11135
11136 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11137 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11138 goto handle_sym_diff;
0b4362b0 11139
13761a11
NC		 11140 case 5: /* R_MSP430_16_BYTE */
11141 case 9: /* R_MSP430_8 */
11142 if (uses_msp430x_relocs ())
11143 break;
11144 goto handle_sym_diff;
11145
11146 case 2: /* R_MSP430_ABS16 */
11147 case 15: /* R_MSP430X_ABS16 */
11148 if (! uses_msp430x_relocs ())
11149 break;
11150 goto handle_sym_diff;
0b4362b0 11151
13761a11
NC		 11152 handle_sym_diff:
11153 if (saved_sym != NULL)
11154 {
11155 bfd_vma value;
11156
11157 value = reloc->r_addend
11158 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11159 - saved_sym->st_value);
11160
11161 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11162
11163 saved_sym = NULL;
11164 return TRUE;
11165 }
11166 break;
11167
11168 default:
11169 if (saved_sym != NULL)
071436c6 11170 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11171 break;
11172 }
11173 break;
11174 }
11175
cf13d699
NC		 11176 case EM_MN10300:
11177 case EM_CYGNUS_MN10300:
11178 {
11179 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11180
cf13d699
NC		 11181 switch (reloc_type)
11182 {
11183 case 34: /* R_MN10300_ALIGN */
11184 return TRUE;
11185 case 33: /* R_MN10300_SYM_DIFF */
11186 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11187 return TRUE;
11188 case 1: /* R_MN10300_32 */
11189 case 2: /* R_MN10300_16 */
11190 if (saved_sym != NULL)
11191 {
11192 bfd_vma value;
252b5132 11193
cf13d699
NC		 11194 value = reloc->r_addend
11195 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11196 - saved_sym->st_value);
252b5132 11197
cf13d699 11198 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11199
cf13d699
NC		 11200 saved_sym = NULL;
11201 return TRUE;
11202 }
11203 break;
11204 default:
11205 if (saved_sym != NULL)
071436c6 11206 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11207 break;
11208 }
11209 break;
11210 }
6ff71e76
NC		 11211
11212 case EM_RL78:
11213 {
11214 static bfd_vma saved_sym1 = 0;
11215 static bfd_vma saved_sym2 = 0;
11216 static bfd_vma value;
11217
11218 switch (reloc_type)
11219 {
11220 case 0x80: /* R_RL78_SYM. */
11221 saved_sym1 = saved_sym2;
11222 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11223 saved_sym2 += reloc->r_addend;
11224 return TRUE;
11225
11226 case 0x83: /* R_RL78_OPsub. */
11227 value = saved_sym1 - saved_sym2;
11228 saved_sym2 = saved_sym1 = 0;
11229 return TRUE;
11230 break;
11231
11232 case 0x41: /* R_RL78_ABS32. */
11233 byte_put (start + reloc->r_offset, value, 4);
11234 value = 0;
11235 return TRUE;
11236
11237 case 0x43: /* R_RL78_ABS16. */
11238 byte_put (start + reloc->r_offset, value, 2);
11239 value = 0;
11240 return TRUE;
11241
11242 default:
11243 break;
11244 }
11245 break;
11246 }
252b5132
RH		 11247 }
11248
cf13d699 11249 return FALSE;
252b5132
RH		 11250}
11251
aca88567
NC		 11252/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11253 DWARF debug sections. This is a target specific test. Note - we do not
11254 go through the whole including-target-headers-multiple-times route, (as
11255 we have already done with <elf/h8.h>) because this would become very
11256 messy and even then this function would have to contain target specific
11257 information (the names of the relocs instead of their numeric values).
11258 FIXME: This is not the correct way to solve this problem. The proper way
11259 is to have target specific reloc sizing and typing functions created by
11260 the reloc-macros.h header, in the same way that it already creates the
11261 reloc naming functions. */
11262
11263static bfd_boolean
11264is_32bit_abs_reloc (unsigned int reloc_type)
11265{
11266 switch (elf_header.e_machine)
11267 {
41e92641 11268 case EM_386:
22abe556 11269 case EM_IAMCU:
41e92641 11270 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11271 case EM_68K:
11272 return reloc_type == 1; /* R_68K_32. */
11273 case EM_860:
11274 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11275 case EM_960:
11276 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11277 case EM_AARCH64:
11278 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11279 case EM_ALPHA:
137b6b5f 11280 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11281 case EM_ARC:
11282 return reloc_type == 1; /* R_ARC_32. */
11283 case EM_ARM:
11284 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11285 case EM_AVR_OLD:
aca88567
NC		 11286 case EM_AVR:
11287 return reloc_type == 1;
cfb8c092
NC		 11288 case EM_ADAPTEVA_EPIPHANY:
11289 return reloc_type == 3;
aca88567
NC		 11290 case EM_BLACKFIN:
11291 return reloc_type == 0x12; /* R_byte4_data. */
11292 case EM_CRIS:
11293 return reloc_type == 3; /* R_CRIS_32. */
11294 case EM_CR16:
11295 return reloc_type == 3; /* R_CR16_NUM32. */
11296 case EM_CRX:
11297 return reloc_type == 15; /* R_CRX_NUM32. */
11298 case EM_CYGNUS_FRV:
11299 return reloc_type == 1;
41e92641
NC		 11300 case EM_CYGNUS_D10V:
11301 case EM_D10V:
11302 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11303 case EM_CYGNUS_D30V:
11304 case EM_D30V:
11305 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11306 case EM_DLX:
11307 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11308 case EM_CYGNUS_FR30:
11309 case EM_FR30:
11310 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11311 case EM_FT32:
11312 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11313 case EM_H8S:
11314 case EM_H8_300:
11315 case EM_H8_300H:
11316 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11317 case EM_IA_64:
d1c4b12b
NC		 11318 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11319 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11320 case EM_IP2K_OLD:
11321 case EM_IP2K:
11322 return reloc_type == 2; /* R_IP2K_32. */
11323 case EM_IQ2000:
11324 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11325 case EM_LATTICEMICO32:
11326 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11327 case EM_M32C_OLD:
aca88567
NC		 11328 case EM_M32C:
11329 return reloc_type == 3; /* R_M32C_32. */
11330 case EM_M32R:
11331 return reloc_type == 34; /* R_M32R_32_RELA. */
11332 case EM_MCORE:
11333 return reloc_type == 1; /* R_MCORE_ADDR32. */
11334 case EM_CYGNUS_MEP:
11335 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11336 case EM_METAG:
11337 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11338 case EM_MICROBLAZE:
11339 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11340 case EM_MIPS:
11341 return reloc_type == 2; /* R_MIPS_32. */
11342 case EM_MMIX:
11343 return reloc_type == 4; /* R_MMIX_32. */
11344 case EM_CYGNUS_MN10200:
11345 case EM_MN10200:
11346 return reloc_type == 1; /* R_MN10200_32. */
11347 case EM_CYGNUS_MN10300:
11348 case EM_MN10300:
11349 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11350 case EM_MOXIE:
11351 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11352 case EM_MSP430_OLD:
11353 case EM_MSP430:
13761a11 11354 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11355 case EM_MT:
11356 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11357 case EM_NDS32:
11358 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11359 case EM_ALTERA_NIOS2:
36591ba1 11360 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11361 case EM_NIOS32:
11362 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11363 case EM_OR1K:
11364 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11365 case EM_PARISC:
5fda8eca
NC		 11366 return (reloc_type == 1 /* R_PARISC_DIR32. */
11367 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11368 case EM_PJ:
11369 case EM_PJ_OLD:
11370 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11371 case EM_PPC64:
11372 return reloc_type == 1; /* R_PPC64_ADDR32. */
11373 case EM_PPC:
11374 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11375 case EM_RL78:
11376 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11377 case EM_RX:
11378 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11379 case EM_S370:
11380 return reloc_type == 1; /* R_I370_ADDR31. */
11381 case EM_S390_OLD:
11382 case EM_S390:
11383 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11384 case EM_SCORE:
11385 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11386 case EM_SH:
11387 return reloc_type == 1; /* R_SH_DIR32. */
11388 case EM_SPARC32PLUS:
11389 case EM_SPARCV9:
11390 case EM_SPARC:
11391 return reloc_type == 3 /* R_SPARC_32. */
11392 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11393 case EM_SPU:
11394 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11395 case EM_TI_C6000:
11396 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11397 case EM_TILEGX:
11398 return reloc_type == 2; /* R_TILEGX_32. */
11399 case EM_TILEPRO:
11400 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11401 case EM_CYGNUS_V850:
11402 case EM_V850:
11403 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11404 case EM_V800:
11405 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11406 case EM_VAX:
11407 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11408 case EM_VISIUM:
11409 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11410 case EM_X86_64:
8a9036a4 11411 case EM_L1OM:
7a9068fe 11412 case EM_K1OM:
aca88567 11413 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11414 case EM_XC16X:
11415 case EM_C166:
11416 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11417 case EM_XGATE:
11418 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11419 case EM_XSTORMY16:
11420 return reloc_type == 1; /* R_XSTROMY16_32. */
11421 case EM_XTENSA_OLD:
11422 case EM_XTENSA:
11423 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11424 default:
bee0ee85
NC		 11425 {
11426 static unsigned int prev_warn = 0;
11427
11428 /* Avoid repeating the same warning multiple times. */
11429 if (prev_warn != elf_header.e_machine)
11430 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11431 elf_header.e_machine);
11432 prev_warn = elf_header.e_machine;
11433 return FALSE;
11434 }
aca88567
NC		 11435 }
11436}
11437
11438/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11439 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11440
11441static bfd_boolean
11442is_32bit_pcrel_reloc (unsigned int reloc_type)
11443{
11444 switch (elf_header.e_machine)
11445 {
41e92641 11446 case EM_386:
22abe556 11447 case EM_IAMCU:
3e0873ac 11448 return reloc_type == 2; /* R_386_PC32. */
aca88567 11449 case EM_68K:
3e0873ac 11450 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11451 case EM_AARCH64:
11452 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11453 case EM_ADAPTEVA_EPIPHANY:
11454 return reloc_type == 6;
aca88567
NC		 11455 case EM_ALPHA:
11456 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11457 case EM_ARM:
3e0873ac 11458 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11459 case EM_MICROBLAZE:
11460 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11461 case EM_OR1K:
11462 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11463 case EM_PARISC:
85acf597 11464 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11465 case EM_PPC:
11466 return reloc_type == 26; /* R_PPC_REL32. */
11467 case EM_PPC64:
3e0873ac 11468 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11469 case EM_S390_OLD:
11470 case EM_S390:
3e0873ac 11471 return reloc_type == 5; /* R_390_PC32. */
aca88567 11472 case EM_SH:
3e0873ac 11473 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11474 case EM_SPARC32PLUS:
11475 case EM_SPARCV9:
11476 case EM_SPARC:
3e0873ac 11477 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11478 case EM_SPU:
11479 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11480 case EM_TILEGX:
11481 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11482 case EM_TILEPRO:
11483 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11484 case EM_VISIUM:
11485 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11486 case EM_X86_64:
8a9036a4 11487 case EM_L1OM:
7a9068fe 11488 case EM_K1OM:
3e0873ac 11489 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11490 case EM_XTENSA_OLD:
11491 case EM_XTENSA:
11492 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11493 default:
11494 /* Do not abort or issue an error message here. Not all targets use
11495 pc-relative 32-bit relocs in their DWARF debug information and we
11496 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11497 more helpful warning message will be generated by apply_relocations
11498 anyway, so just return. */
aca88567
NC		 11499 return FALSE;
11500 }
11501}
11502
11503/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11504 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11505
11506static bfd_boolean
11507is_64bit_abs_reloc (unsigned int reloc_type)
11508{
11509 switch (elf_header.e_machine)
11510 {
a06ea964
NC		 11511 case EM_AARCH64:
11512 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11513 case EM_ALPHA:
11514 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11515 case EM_IA_64:
11516 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11517 case EM_PARISC:
11518 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11519 case EM_PPC64:
11520 return reloc_type == 38; /* R_PPC64_ADDR64. */
11521 case EM_SPARC32PLUS:
11522 case EM_SPARCV9:
11523 case EM_SPARC:
11524 return reloc_type == 54; /* R_SPARC_UA64. */
11525 case EM_X86_64:
8a9036a4 11526 case EM_L1OM:
7a9068fe 11527 case EM_K1OM:
aca88567 11528 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11529 case EM_S390_OLD:
11530 case EM_S390:
aa137e4d
NC		 11531 return reloc_type == 22; /* R_S390_64. */
11532 case EM_TILEGX:
11533 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11534 case EM_MIPS:
aa137e4d 11535 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11536 default:
11537 return FALSE;
11538 }
11539}
11540
85acf597
RH		 11541/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11542 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11543
11544static bfd_boolean
11545is_64bit_pcrel_reloc (unsigned int reloc_type)
11546{
11547 switch (elf_header.e_machine)
11548 {
a06ea964
NC		 11549 case EM_AARCH64:
11550 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11551 case EM_ALPHA:
aa137e4d 11552 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11553 case EM_IA_64:
aa137e4d 11554 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11555 case EM_PARISC:
aa137e4d 11556 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11557 case EM_PPC64:
aa137e4d 11558 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11559 case EM_SPARC32PLUS:
11560 case EM_SPARCV9:
11561 case EM_SPARC:
aa137e4d 11562 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11563 case EM_X86_64:
8a9036a4 11564 case EM_L1OM:
7a9068fe 11565 case EM_K1OM:
aa137e4d 11566 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11567 case EM_S390_OLD:
11568 case EM_S390:
aa137e4d
NC		 11569 return reloc_type == 23; /* R_S390_PC64. */
11570 case EM_TILEGX:
11571 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11572 default:
11573 return FALSE;
11574 }
11575}
11576
4dc3c23d
AM		 11577/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11578 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11579
11580static bfd_boolean
11581is_24bit_abs_reloc (unsigned int reloc_type)
11582{
11583 switch (elf_header.e_machine)
11584 {
11585 case EM_CYGNUS_MN10200:
11586 case EM_MN10200:
11587 return reloc_type == 4; /* R_MN10200_24. */
11588 default:
11589 return FALSE;
11590 }
11591}
11592
aca88567
NC		 11593/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11594 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11595
11596static bfd_boolean
11597is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11598{
11599 switch (elf_header.e_machine)
11600 {
aca88567
NC		 11601 case EM_AVR_OLD:
11602 case EM_AVR:
11603 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11604 case EM_ADAPTEVA_EPIPHANY:
11605 return reloc_type == 5;
41e92641
NC		 11606 case EM_CYGNUS_D10V:
11607 case EM_D10V:
11608 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11609 case EM_H8S:
11610 case EM_H8_300:
11611 case EM_H8_300H:
aca88567
NC		 11612 return reloc_type == R_H8_DIR16;
11613 case EM_IP2K_OLD:
11614 case EM_IP2K:
11615 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11616 case EM_M32C_OLD:
f4236fe4
DD		 11617 case EM_M32C:
11618 return reloc_type == 1; /* R_M32C_16 */
aca88567 11619 case EM_MSP430:
13761a11
NC		 11620 if (uses_msp430x_relocs ())
11621 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11622 case EM_MSP430_OLD:
aca88567 11623 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11624 case EM_NDS32:
11625 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11626 case EM_ALTERA_NIOS2:
36591ba1 11627 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11628 case EM_NIOS32:
11629 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11630 case EM_OR1K:
11631 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11632 case EM_TI_C6000:
11633 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11634 case EM_XC16X:
11635 case EM_C166:
11636 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11637 case EM_CYGNUS_MN10200:
11638 case EM_MN10200:
11639 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11640 case EM_CYGNUS_MN10300:
11641 case EM_MN10300:
11642 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11643 case EM_VISIUM:
11644 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11645 case EM_XGATE:
11646 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11647 default:
aca88567 11648 return FALSE;
4b78141a
NC		 11649 }
11650}
11651
2a7b2e88
JK		 11652/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11653 relocation entries (possibly formerly used for SHT_GROUP sections). */
11654
11655static bfd_boolean
11656is_none_reloc (unsigned int reloc_type)
11657{
11658 switch (elf_header.e_machine)
11659 {
cb8f3167
NC		 11660 case EM_68K: /* R_68K_NONE. */
11661 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11662 case EM_SPARC32PLUS:
11663 case EM_SPARCV9:
cb8f3167
NC		 11664 case EM_SPARC: /* R_SPARC_NONE. */
11665 case EM_MIPS: /* R_MIPS_NONE. */
11666 case EM_PARISC: /* R_PARISC_NONE. */
11667 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11668 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11669 case EM_PPC: /* R_PPC_NONE. */
11670 case EM_PPC64: /* R_PPC64_NONE. */
11671 case EM_ARM: /* R_ARM_NONE. */
11672 case EM_IA_64: /* R_IA64_NONE. */
11673 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11674 case EM_S390_OLD:
cb8f3167
NC		 11675 case EM_S390: /* R_390_NONE. */
11676 case EM_CRIS: /* R_CRIS_NONE. */
11677 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11678 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11679 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11680 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11681 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11682 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11683 case EM_M32R: /* R_M32R_NONE. */
40b36596 11684 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11685 case EM_TILEGX: /* R_TILEGX_NONE. */
11686 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11687 case EM_XC16X:
11688 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11689 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11690 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11691 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11692 return reloc_type == 0;
a06ea964
NC		 11693 case EM_AARCH64:
11694 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11695 case EM_NDS32:
11696 return (reloc_type == 0 /* R_XTENSA_NONE. */
11697 || reloc_type == 204 /* R_NDS32_DIFF8. */
11698 || reloc_type == 205 /* R_NDS32_DIFF16. */
11699 || reloc_type == 206 /* R_NDS32_DIFF32. */
11700 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11701 case EM_XTENSA_OLD:
11702 case EM_XTENSA:
4dc3c23d
AM		 11703 return (reloc_type == 0 /* R_XTENSA_NONE. */
11704 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11705 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11706 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11707 case EM_METAG:
11708 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11709 }
11710 return FALSE;
11711}
11712
d1c4b12b
NC		 11713/* Returns TRUE if there is a relocation against
11714 section NAME at OFFSET bytes. */
11715
11716bfd_boolean
11717reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11718{
11719 Elf_Internal_Rela * relocs;
11720 Elf_Internal_Rela * rp;
11721
11722 if (dsec == NULL || dsec->reloc_info == NULL)
11723 return FALSE;
11724
11725 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11726
11727 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11728 if (rp->r_offset == offset)
11729 return TRUE;
11730
11731 return FALSE;
11732}
11733
cf13d699
NC		 11734/* Apply relocations to a section.
11735 Note: So far support has been added only for those relocations
11736 which can be found in debug sections.
d1c4b12b
NC		 11737 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11738 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11739 FIXME: Add support for more relocations ? */
1b315056 11740
cf13d699 11741static void
d1c4b12b
NC		 11742apply_relocations (void * file,
11743 const Elf_Internal_Shdr * section,
11744 unsigned char * start,
11745 bfd_size_type size,
11746 void ** relocs_return,
11747 unsigned long * num_relocs_return)
1b315056 11748{
cf13d699 11749 Elf_Internal_Shdr * relsec;
0d2a7a93 11750 unsigned char * end = start + size;
cb8f3167 11751
d1c4b12b
NC		 11752 if (relocs_return != NULL)
11753 {
11754 * (Elf_Internal_Rela **) relocs_return = NULL;
11755 * num_relocs_return = 0;
11756 }
11757
cf13d699
NC		 11758 if (elf_header.e_type != ET_REL)
11759 return;
1b315056 11760
cf13d699 11761 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11762 for (relsec = section_headers;
11763 relsec < section_headers + elf_header.e_shnum;
11764 ++relsec)
252b5132 11765 {
41e92641
NC		 11766 bfd_boolean is_rela;
11767 unsigned long num_relocs;
2cf0635d
NC		 11768 Elf_Internal_Rela * relocs;
11769 Elf_Internal_Rela * rp;
11770 Elf_Internal_Shdr * symsec;
11771 Elf_Internal_Sym * symtab;
ba5cdace 11772 unsigned long num_syms;
2cf0635d 11773 Elf_Internal_Sym * sym;
252b5132 11774
41e92641 11775 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11776 || relsec->sh_info >= elf_header.e_shnum
11777 || section_headers + relsec->sh_info != section
c256ffe7 11778 || relsec->sh_size == 0
4fbb74a6 11779 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11780 continue;
428409d5 11781
41e92641
NC		 11782 is_rela = relsec->sh_type == SHT_RELA;
11783
11784 if (is_rela)
11785 {
3f5e193b
NC		 11786 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11787 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11788 return;
11789 }
11790 else
11791 {
3f5e193b
NC		 11792 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11793 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11794 return;
11795 }
11796
11797 /* SH uses RELA but uses in place value instead of the addend field. */
11798 if (elf_header.e_machine == EM_SH)
11799 is_rela = FALSE;
428409d5 11800
4fbb74a6 11801 symsec = section_headers + relsec->sh_link;
ba5cdace 11802 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11803
41e92641 11804 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11805 {
41e92641
NC		 11806 bfd_vma addend;
11807 unsigned int reloc_type;
11808 unsigned int reloc_size;
91d6fa6a 11809 unsigned char * rloc;
ba5cdace 11810 unsigned long sym_index;
4b78141a 11811
aca88567 11812 reloc_type = get_reloc_type (rp->r_info);
41e92641 11813
98fb390a 11814 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11815 continue;
98fb390a
NC		 11816 else if (is_none_reloc (reloc_type))
11817 continue;
11818 else if (is_32bit_abs_reloc (reloc_type)
11819 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11820 reloc_size = 4;
85acf597
RH		 11821 else if (is_64bit_abs_reloc (reloc_type)
11822 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11823 reloc_size = 8;
4dc3c23d
AM		 11824 else if (is_24bit_abs_reloc (reloc_type))
11825 reloc_size = 3;
aca88567
NC		 11826 else if (is_16bit_abs_reloc (reloc_type))
11827 reloc_size = 2;
11828 else
4b78141a 11829 {
bee0ee85
NC		 11830 static unsigned int prev_reloc = 0;
11831 if (reloc_type != prev_reloc)
11832 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11833 reloc_type, printable_section_name (section));
11834 prev_reloc = reloc_type;
4b78141a
NC		 11835 continue;
11836 }
103f02d3 11837
91d6fa6a 11838 rloc = start + rp->r_offset;
c8da6823 11839 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11840 {
11841 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11842 (unsigned long) rp->r_offset,
74e1a04b 11843 printable_section_name (section));
700dd8b7
L		 11844 continue;
11845 }
103f02d3 11846
ba5cdace
NC		 11847 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11848 if (sym_index >= num_syms)
11849 {
11850 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11851 sym_index, printable_section_name (section));
ba5cdace
NC		 11852 continue;
11853 }
11854 sym = symtab + sym_index;
41e92641
NC		 11855
11856 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11857 make sure that it is of an appropriate type.
11858
11859 Relocations against symbols without type can happen.
11860 Gcc -feliminate-dwarf2-dups may generate symbols
11861 without type for debug info.
11862
11863 Icc generates relocations against function symbols
11864 instead of local labels.
11865
11866 Relocations against object symbols can happen, eg when
11867 referencing a global array. For an example of this see
11868 the _clz.o binary in libgcc.a. */
aca88567 11869 if (sym != symtab
55f25fc3 11870 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11871 {
41e92641 11872 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11873 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11874 (long int)(rp - relocs),
74e1a04b 11875 printable_section_name (relsec));
aca88567 11876 continue;
5b18a4bc 11877 }
252b5132 11878
4dc3c23d
AM		 11879 addend = 0;
11880 if (is_rela)
11881 addend += rp->r_addend;
c47320c3
AM		 11882 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11883 partial_inplace. */
4dc3c23d
AM		 11884 if (!is_rela
11885 || (elf_header.e_machine == EM_XTENSA
11886 && reloc_type == 1)
11887 || ((elf_header.e_machine == EM_PJ
11888 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11889 && reloc_type == 1)
11890 || ((elf_header.e_machine == EM_D30V
11891 || elf_header.e_machine == EM_CYGNUS_D30V)
11892 && reloc_type == 12))
91d6fa6a 11893 addend += byte_get (rloc, reloc_size);
cb8f3167 11894
85acf597
RH		 11895 if (is_32bit_pcrel_reloc (reloc_type)
11896 || is_64bit_pcrel_reloc (reloc_type))
11897 {
11898 /* On HPPA, all pc-relative relocations are biased by 8. */
11899 if (elf_header.e_machine == EM_PARISC)
11900 addend -= 8;
91d6fa6a 11901 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11902 reloc_size);
11903 }
41e92641 11904 else
91d6fa6a 11905 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11906 }
252b5132 11907
5b18a4bc 11908 free (symtab);
d1c4b12b
NC		 11909
11910 if (relocs_return)
11911 {
11912 * (Elf_Internal_Rela **) relocs_return = relocs;
11913 * num_relocs_return = num_relocs;
11914 }
11915 else
11916 free (relocs);
11917
5b18a4bc
NC		 11918 break;
11919 }
5b18a4bc 11920}
103f02d3 11921
cf13d699
NC		 11922#ifdef SUPPORT_DISASSEMBLY
11923static int
11924disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11925{
74e1a04b 11926 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11927
74e1a04b 11928 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11929
11930 return 1;
11931}
11932#endif
11933
11934/* Reads in the contents of SECTION from FILE, returning a pointer
11935 to a malloc'ed buffer or NULL if something went wrong. */
11936
11937static char *
11938get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11939{
11940 bfd_size_type num_bytes;
11941
11942 num_bytes = section->sh_size;
11943
11944 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11945 {
11946 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11947 printable_section_name (section));
cf13d699
NC		 11948 return NULL;
11949 }
11950
3f5e193b
NC		 11951 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11952 _("section contents"));
cf13d699
NC		 11953}
11954
0e602686
NC		 11955/* Uncompresses a section that was compressed using zlib, in place. */
11956
11957static bfd_boolean
11958uncompress_section_contents (unsigned char **buffer,
11959 dwarf_size_type uncompressed_size,
11960 dwarf_size_type *size)
11961{
11962 dwarf_size_type compressed_size = *size;
11963 unsigned char * compressed_buffer = *buffer;
11964 unsigned char * uncompressed_buffer;
11965 z_stream strm;
11966 int rc;
11967
11968 /* It is possible the section consists of several compressed
11969 buffers concatenated together, so we uncompress in a loop. */
11970 /* PR 18313: The state field in the z_stream structure is supposed
11971 to be invisible to the user (ie us), but some compilers will
11972 still complain about it being used without initialisation. So
11973 we first zero the entire z_stream structure and then set the fields
11974 that we need. */
11975 memset (& strm, 0, sizeof strm);
11976 strm.avail_in = compressed_size;
11977 strm.next_in = (Bytef *) compressed_buffer;
11978 strm.avail_out = uncompressed_size;
11979 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11980
11981 rc = inflateInit (& strm);
11982 while (strm.avail_in > 0)
11983 {
11984 if (rc != Z_OK)
11985 goto fail;
11986 strm.next_out = ((Bytef *) uncompressed_buffer
11987 + (uncompressed_size - strm.avail_out));
11988 rc = inflate (&strm, Z_FINISH);
11989 if (rc != Z_STREAM_END)
11990 goto fail;
11991 rc = inflateReset (& strm);
11992 }
11993 rc = inflateEnd (& strm);
11994 if (rc != Z_OK
11995 || strm.avail_out != 0)
11996 goto fail;
11997
11998 *buffer = uncompressed_buffer;
11999 *size = uncompressed_size;
12000 return TRUE;
12001
12002 fail:
12003 free (uncompressed_buffer);
12004 /* Indicate decompression failure. */
12005 *buffer = NULL;
12006 return FALSE;
12007}
dd24e3da 12008
cf13d699
NC		 12009static void
12010dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12011{
0e602686
NC		 12012 Elf_Internal_Shdr * relsec;
12013 bfd_size_type num_bytes;
fd8008d8
L		 12014 unsigned char * data;
12015 unsigned char * end;
12016 unsigned char * real_start;
12017 unsigned char * start;
0e602686 12018 bfd_boolean some_strings_shown;
cf13d699 12019
fd8008d8
L		 12020 real_start = start = (unsigned char *) get_section_contents (section,
12021 file);
cf13d699
NC		 12022 if (start == NULL)
12023 return;
0e602686 12024 num_bytes = section->sh_size;
cf13d699 12025
74e1a04b 12026 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12027
0e602686
NC		 12028 if (decompress_dumps)
12029 {
12030 dwarf_size_type new_size = num_bytes;
12031 dwarf_size_type uncompressed_size = 0;
12032
12033 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12034 {
12035 Elf_Internal_Chdr chdr;
12036 unsigned int compression_header_size
12037 = get_compression_header (& chdr, (unsigned char *) start);
12038
813dabb9 12039 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12040 {
813dabb9
L		 12041 warn (_("section '%s' has unsupported compress type: %d\n"),
12042 printable_section_name (section), chdr.ch_type);
12043 return;
12044 }
12045 else if (chdr.ch_addralign != section->sh_addralign)
12046 {
12047 warn (_("compressed section '%s' is corrupted\n"),
12048 printable_section_name (section));
12049 return;
0e602686 12050 }
813dabb9
L		 12051 uncompressed_size = chdr.ch_size;
12052 start += compression_header_size;
12053 new_size -= compression_header_size;
0e602686
NC		 12054 }
12055 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12056 {
12057 /* Read the zlib header. In this case, it should be "ZLIB"
12058 followed by the uncompressed section size, 8 bytes in
12059 big-endian order. */
12060 uncompressed_size = start[4]; uncompressed_size <<= 8;
12061 uncompressed_size += start[5]; uncompressed_size <<= 8;
12062 uncompressed_size += start[6]; uncompressed_size <<= 8;
12063 uncompressed_size += start[7]; uncompressed_size <<= 8;
12064 uncompressed_size += start[8]; uncompressed_size <<= 8;
12065 uncompressed_size += start[9]; uncompressed_size <<= 8;
12066 uncompressed_size += start[10]; uncompressed_size <<= 8;
12067 uncompressed_size += start[11];
12068 start += 12;
12069 new_size -= 12;
12070 }
12071
12072 if (uncompressed_size
fd8008d8 12073 && uncompress_section_contents (& start,
0e602686
NC		 12074 uncompressed_size, & new_size))
12075 num_bytes = new_size;
12076 }
fd8008d8 12077
cf13d699
NC		 12078 /* If the section being dumped has relocations against it the user might
12079 be expecting these relocations to have been applied. Check for this
12080 case and issue a warning message in order to avoid confusion.
12081 FIXME: Maybe we ought to have an option that dumps a section with
12082 relocs applied ? */
12083 for (relsec = section_headers;
12084 relsec < section_headers + elf_header.e_shnum;
12085 ++relsec)
12086 {
12087 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12088 || relsec->sh_info >= elf_header.e_shnum
12089 || section_headers + relsec->sh_info != section
12090 || relsec->sh_size == 0
12091 || relsec->sh_link >= elf_header.e_shnum)
12092 continue;
12093
12094 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12095 break;
12096 }
12097
cf13d699
NC		 12098 data = start;
12099 end = start + num_bytes;
12100 some_strings_shown = FALSE;
12101
12102 while (data < end)
12103 {
12104 while (!ISPRINT (* data))
12105 if (++ data >= end)
12106 break;
12107
12108 if (data < end)
12109 {
071436c6
NC		 12110 size_t maxlen = end - data;
12111
cf13d699 12112#ifndef __MSVCRT__
c975cc98
NC		 12113 /* PR 11128: Use two separate invocations in order to work
12114 around bugs in the Solaris 8 implementation of printf. */
12115 printf (" [%6tx] ", data - start);
cf13d699 12116#else
071436c6 12117 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12118#endif
4082ef84
NC		 12119 if (maxlen > 0)
12120 {
fd8008d8 12121 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12122 putchar ('\n');
fd8008d8 12123 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12124 }
12125 else
12126 {
12127 printf (_("<corrupt>\n"));
12128 data = end;
12129 }
cf13d699
NC		 12130 some_strings_shown = TRUE;
12131 }
12132 }
12133
12134 if (! some_strings_shown)
12135 printf (_(" No strings found in this section."));
12136
0e602686 12137 free (real_start);
cf13d699
NC		 12138
12139 putchar ('\n');
12140}
12141
12142static void
12143dump_section_as_bytes (Elf_Internal_Shdr * section,
12144 FILE * file,
12145 bfd_boolean relocate)
12146{
12147 Elf_Internal_Shdr * relsec;
0e602686
NC		 12148 bfd_size_type bytes;
12149 bfd_size_type section_size;
12150 bfd_vma addr;
12151 unsigned char * data;
12152 unsigned char * real_start;
12153 unsigned char * start;
12154
12155 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12156 if (start == NULL)
12157 return;
0e602686 12158 section_size = section->sh_size;
cf13d699 12159
74e1a04b 12160 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12161
0e602686
NC		 12162 if (decompress_dumps)
12163 {
12164 dwarf_size_type new_size = section_size;
12165 dwarf_size_type uncompressed_size = 0;
12166
12167 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12168 {
12169 Elf_Internal_Chdr chdr;
12170 unsigned int compression_header_size
12171 = get_compression_header (& chdr, start);
12172
813dabb9 12173 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12174 {
813dabb9
L		 12175 warn (_("section '%s' has unsupported compress type: %d\n"),
12176 printable_section_name (section), chdr.ch_type);
12177 return;
0e602686 12178 }
813dabb9
L		 12179 else if (chdr.ch_addralign != section->sh_addralign)
12180 {
12181 warn (_("compressed section '%s' is corrupted\n"),
12182 printable_section_name (section));
12183 return;
12184 }
12185 uncompressed_size = chdr.ch_size;
12186 start += compression_header_size;
12187 new_size -= compression_header_size;
0e602686
NC		 12188 }
12189 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12190 {
12191 /* Read the zlib header. In this case, it should be "ZLIB"
12192 followed by the uncompressed section size, 8 bytes in
12193 big-endian order. */
12194 uncompressed_size = start[4]; uncompressed_size <<= 8;
12195 uncompressed_size += start[5]; uncompressed_size <<= 8;
12196 uncompressed_size += start[6]; uncompressed_size <<= 8;
12197 uncompressed_size += start[7]; uncompressed_size <<= 8;
12198 uncompressed_size += start[8]; uncompressed_size <<= 8;
12199 uncompressed_size += start[9]; uncompressed_size <<= 8;
12200 uncompressed_size += start[10]; uncompressed_size <<= 8;
12201 uncompressed_size += start[11];
12202 start += 12;
12203 new_size -= 12;
12204 }
12205
12206 if (uncompressed_size
12207 && uncompress_section_contents (& start, uncompressed_size,
12208 & new_size))
12209 section_size = new_size;
12210 }
14ae95f2 12211
cf13d699
NC		 12212 if (relocate)
12213 {
0e602686 12214 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12215 }
12216 else
12217 {
12218 /* If the section being dumped has relocations against it the user might
12219 be expecting these relocations to have been applied. Check for this
12220 case and issue a warning message in order to avoid confusion.
12221 FIXME: Maybe we ought to have an option that dumps a section with
12222 relocs applied ? */
12223 for (relsec = section_headers;
12224 relsec < section_headers + elf_header.e_shnum;
12225 ++relsec)
12226 {
12227 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12228 || relsec->sh_info >= elf_header.e_shnum
12229 || section_headers + relsec->sh_info != section
12230 || relsec->sh_size == 0
12231 || relsec->sh_link >= elf_header.e_shnum)
12232 continue;
12233
12234 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12235 break;
12236 }
12237 }
12238
12239 addr = section->sh_addr;
0e602686 12240 bytes = section_size;
cf13d699
NC		 12241 data = start;
12242
12243 while (bytes)
12244 {
12245 int j;
12246 int k;
12247 int lbytes;
12248
12249 lbytes = (bytes > 16 ? 16 : bytes);
12250
12251 printf (" 0x%8.8lx ", (unsigned long) addr);
12252
12253 for (j = 0; j < 16; j++)
12254 {
12255 if (j < lbytes)
12256 printf ("%2.2x", data[j]);
12257 else
12258 printf (" ");
12259
12260 if ((j & 3) == 3)
12261 printf (" ");
12262 }
12263
12264 for (j = 0; j < lbytes; j++)
12265 {
12266 k = data[j];
12267 if (k >= ' ' && k < 0x7f)
12268 printf ("%c", k);
12269 else
12270 printf (".");
12271 }
12272
12273 putchar ('\n');
12274
12275 data += lbytes;
12276 addr += lbytes;
12277 bytes -= lbytes;
12278 }
12279
0e602686 12280 free (real_start);
cf13d699
NC		 12281
12282 putchar ('\n');
12283}
12284
d966045b
DJ		 12285static int
12286load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12287 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12288{
2cf0635d 12289 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12290 char buf [64];
1007acb3 12291
19e6b90e
L		 12292 /* If it is already loaded, do nothing. */
12293 if (section->start != NULL)
12294 return 1;
1007acb3 12295
19e6b90e
L		 12296 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12297 section->address = sec->sh_addr;
06614111 12298 section->user_data = NULL;
3f5e193b
NC		 12299 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12300 sec->sh_offset, 1,
12301 sec->sh_size, buf);
59245841
NC		 12302 if (section->start == NULL)
12303 section->size = 0;
12304 else
12305 {
77115a4a
L		 12306 unsigned char *start = section->start;
12307 dwarf_size_type size = sec->sh_size;
dab394de 12308 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12309
12310 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12311 {
12312 Elf_Internal_Chdr chdr;
12313 unsigned int compression_header_size
12314 = get_compression_header (&chdr, start);
813dabb9
L		 12315 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12316 {
12317 warn (_("section '%s' has unsupported compress type: %d\n"),
12318 section->name, chdr.ch_type);
12319 return 0;
12320 }
12321 else if (chdr.ch_addralign != sec->sh_addralign)
12322 {
12323 warn (_("compressed section '%s' is corrupted\n"),
12324 section->name);
12325 return 0;
12326 }
dab394de 12327 uncompressed_size = chdr.ch_size;
77115a4a
L		 12328 start += compression_header_size;
12329 size -= compression_header_size;
12330 }
dab394de
L		 12331 else if (size > 12 && streq ((char *) start, "ZLIB"))
12332 {
12333 /* Read the zlib header. In this case, it should be "ZLIB"
12334 followed by the uncompressed section size, 8 bytes in
12335 big-endian order. */
12336 uncompressed_size = start[4]; uncompressed_size <<= 8;
12337 uncompressed_size += start[5]; uncompressed_size <<= 8;
12338 uncompressed_size += start[6]; uncompressed_size <<= 8;
12339 uncompressed_size += start[7]; uncompressed_size <<= 8;
12340 uncompressed_size += start[8]; uncompressed_size <<= 8;
12341 uncompressed_size += start[9]; uncompressed_size <<= 8;
12342 uncompressed_size += start[10]; uncompressed_size <<= 8;
12343 uncompressed_size += start[11];
12344 start += 12;
12345 size -= 12;
12346 }
12347
12348 if (uncompressed_size
12349 && uncompress_section_contents (&start, uncompressed_size,
12350 &size))
77115a4a
L		 12351 {
12352 /* Free the compressed buffer, update the section buffer
12353 and the section size if uncompress is successful. */
12354 free (section->start);
12355 section->start = start;
77115a4a
L		 12356 }
12357 section->size = size;
59245841 12358 }
4a114e3e 12359
1b315056
CS		 12360 if (section->start == NULL)
12361 return 0;
12362
19e6b90e 12363 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12364 apply_relocations ((FILE *) file, sec, section->start, section->size,
12365 & section->reloc_info, & section->num_relocs);
12366 else
12367 {
12368 section->reloc_info = NULL;
12369 section->num_relocs = 0;
12370 }
1007acb3 12371
1b315056 12372 return 1;
1007acb3
L		 12373}
12374
657d0d47
CC		 12375/* If this is not NULL, load_debug_section will only look for sections
12376 within the list of sections given here. */
12377unsigned int *section_subset = NULL;
12378
d966045b 12379int
2cf0635d 12380load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12381{
2cf0635d
NC		 12382 struct dwarf_section * section = &debug_displays [debug].section;
12383 Elf_Internal_Shdr * sec;
d966045b
DJ		 12384
12385 /* Locate the debug section. */
657d0d47 12386 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12387 if (sec != NULL)
12388 section->name = section->uncompressed_name;
12389 else
12390 {
657d0d47 12391 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12392 if (sec != NULL)
12393 section->name = section->compressed_name;
12394 }
12395 if (sec == NULL)
12396 return 0;
12397
657d0d47
CC		 12398 /* If we're loading from a subset of sections, and we've loaded
12399 a section matching this name before, it's likely that it's a
12400 different one. */
12401 if (section_subset != NULL)
12402 free_debug_section (debug);
12403
3f5e193b 12404 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12405}
12406
19e6b90e
L		 12407void
12408free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12409{
2cf0635d 12410 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12411
19e6b90e
L		 12412 if (section->start == NULL)
12413 return;
1007acb3 12414
19e6b90e
L		 12415 free ((char *) section->start);
12416 section->start = NULL;
12417 section->address = 0;
12418 section->size = 0;
1007acb3
L		 12419}
12420
1007acb3 12421static int
657d0d47 12422display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12423{
2cf0635d 12424 char * name = SECTION_NAME (section);
74e1a04b 12425 const char * print_name = printable_section_name (section);
19e6b90e
L		 12426 bfd_size_type length;
12427 int result = 1;
3f5e193b 12428 int i;
1007acb3 12429
19e6b90e
L		 12430 length = section->sh_size;
12431 if (length == 0)
1007acb3 12432 {
74e1a04b 12433 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12434 return 0;
1007acb3 12435 }
5dff79d8
NC		 12436 if (section->sh_type == SHT_NOBITS)
12437 {
12438 /* There is no point in dumping the contents of a debugging section
12439 which has the NOBITS type - the bits in the file will be random.
12440 This can happen when a file containing a .eh_frame section is
12441 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12442 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12443 print_name);
5dff79d8
NC		 12444 return 0;
12445 }
1007acb3 12446
0112cd26 12447 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12448 name = ".debug_info";
1007acb3 12449
19e6b90e
L		 12450 /* See if we know how to display the contents of this section. */
12451 for (i = 0; i < max; i++)
1b315056 12452 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12453 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12454 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12455 {
2cf0635d 12456 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12457 int secondary = (section != find_section (name));
12458
12459 if (secondary)
3f5e193b 12460 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12461
b40bf0a2
NC		 12462 if (i == line && const_strneq (name, ".debug_line."))
12463 sec->name = name;
12464 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12465 sec->name = sec->uncompressed_name;
12466 else
12467 sec->name = sec->compressed_name;
3f5e193b
NC		 12468 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12469 section, file))
19e6b90e 12470 {
657d0d47
CC		 12471 /* If this debug section is part of a CU/TU set in a .dwp file,
12472 restrict load_debug_section to the sections in that set. */
12473 section_subset = find_cu_tu_set (file, shndx);
12474
19e6b90e 12475 result &= debug_displays[i].display (sec, file);
1007acb3 12476
657d0d47
CC		 12477 section_subset = NULL;
12478
d966045b 12479 if (secondary || (i != info && i != abbrev))
3f5e193b 12480 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12481 }
1007acb3 12482
19e6b90e
L		 12483 break;
12484 }
1007acb3 12485
19e6b90e 12486 if (i == max)
1007acb3 12487 {
74e1a04b 12488 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12489 result = 0;
1007acb3
L		 12490 }
12491
19e6b90e 12492 return result;
5b18a4bc 12493}
103f02d3 12494
aef1f6d0
DJ		 12495/* Set DUMP_SECTS for all sections where dumps were requested
12496 based on section name. */
12497
12498static void
12499initialise_dumps_byname (void)
12500{
2cf0635d 12501 struct dump_list_entry * cur;
aef1f6d0
DJ		 12502
12503 for (cur = dump_sects_byname; cur; cur = cur->next)
12504 {
12505 unsigned int i;
12506 int any;
12507
12508 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12509 if (streq (SECTION_NAME (section_headers + i), cur->name))
12510 {
09c11c86 12511 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12512 any = 1;
12513 }
12514
12515 if (!any)
12516 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12517 cur->name);
12518 }
12519}
12520
5b18a4bc 12521static void
2cf0635d 12522process_section_contents (FILE * file)
5b18a4bc 12523{
2cf0635d 12524 Elf_Internal_Shdr * section;
19e6b90e 12525 unsigned int i;
103f02d3 12526
19e6b90e
L		 12527 if (! do_dump)
12528 return;
103f02d3 12529
aef1f6d0
DJ		 12530 initialise_dumps_byname ();
12531
19e6b90e
L		 12532 for (i = 0, section = section_headers;
12533 i < elf_header.e_shnum && i < num_dump_sects;
12534 i++, section++)
12535 {
12536#ifdef SUPPORT_DISASSEMBLY
12537 if (dump_sects[i] & DISASS_DUMP)
12538 disassemble_section (section, file);
12539#endif
12540 if (dump_sects[i] & HEX_DUMP)
cf13d699 12541 dump_section_as_bytes (section, file, FALSE);
103f02d3 12542
cf13d699
NC		 12543 if (dump_sects[i] & RELOC_DUMP)
12544 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12545
12546 if (dump_sects[i] & STRING_DUMP)
12547 dump_section_as_strings (section, file);
cf13d699
NC		 12548
12549 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12550 display_debug_section (i, section, file);
5b18a4bc 12551 }
103f02d3 12552
19e6b90e
L		 12553 /* Check to see if the user requested a
12554 dump of a section that does not exist. */
12555 while (i++ < num_dump_sects)
12556 if (dump_sects[i])
12557 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12558}
103f02d3 12559
5b18a4bc 12560static void
19e6b90e 12561process_mips_fpe_exception (int mask)
5b18a4bc 12562{
19e6b90e
L		 12563 if (mask)
12564 {
12565 int first = 1;
12566 if (mask & OEX_FPU_INEX)
12567 fputs ("INEX", stdout), first = 0;
12568 if (mask & OEX_FPU_UFLO)
12569 printf ("%sUFLO", first ? "" : "|"), first = 0;
12570 if (mask & OEX_FPU_OFLO)
12571 printf ("%sOFLO", first ? "" : "|"), first = 0;
12572 if (mask & OEX_FPU_DIV0)
12573 printf ("%sDIV0", first ? "" : "|"), first = 0;
12574 if (mask & OEX_FPU_INVAL)
12575 printf ("%sINVAL", first ? "" : "|");
12576 }
5b18a4bc 12577 else
19e6b90e 12578 fputs ("0", stdout);
5b18a4bc 12579}
103f02d3 12580
f6f0e17b
NC		 12581/* Display's the value of TAG at location P. If TAG is
12582 greater than 0 it is assumed to be an unknown tag, and
12583 a message is printed to this effect. Otherwise it is
12584 assumed that a message has already been printed.
12585
12586 If the bottom bit of TAG is set it assumed to have a
12587 string value, otherwise it is assumed to have an integer
12588 value.
12589
12590 Returns an updated P pointing to the first unread byte
12591 beyond the end of TAG's value.
12592
12593 Reads at or beyond END will not be made. */
12594
12595static unsigned char *
12596display_tag_value (int tag,
12597 unsigned char * p,
12598 const unsigned char * const end)
12599{
12600 unsigned long val;
12601
12602 if (tag > 0)
12603 printf (" Tag_unknown_%d: ", tag);
12604
12605 if (p >= end)
12606 {
4082ef84 12607 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12608 }
12609 else if (tag & 1)
12610 {
071436c6
NC		 12611 /* PR 17531 file: 027-19978-0.004. */
12612 size_t maxlen = (end - p) - 1;
12613
12614 putchar ('"');
4082ef84
NC		 12615 if (maxlen > 0)
12616 {
12617 print_symbol ((int) maxlen, (const char *) p);
12618 p += strnlen ((char *) p, maxlen) + 1;
12619 }
12620 else
12621 {
12622 printf (_("<corrupt string tag>"));
12623 p = (unsigned char *) end;
12624 }
071436c6 12625 printf ("\"\n");
f6f0e17b
NC		 12626 }
12627 else
12628 {
12629 unsigned int len;
12630
12631 val = read_uleb128 (p, &len, end);
12632 p += len;
12633 printf ("%ld (0x%lx)\n", val, val);
12634 }
12635
4082ef84 12636 assert (p <= end);
f6f0e17b
NC		 12637 return p;
12638}
12639
11c1ff18
PB		 12640/* ARM EABI attributes section. */
12641typedef struct
12642{
70e99720 12643 unsigned int tag;
2cf0635d 12644 const char * name;
11c1ff18 12645 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12646 unsigned int type;
2cf0635d 12647 const char ** table;
11c1ff18
PB		 12648} arm_attr_public_tag;
12649
2cf0635d 12650static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12651 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12652 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12653static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12654static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12655 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12656static const char * arm_attr_tag_FP_arch[] =
bca38921 12657 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12658 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12659static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12660static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12661 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12662static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12663 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12664 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12665static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12666 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12667static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12668 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12669static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12670 {"Absolute", "PC-relative", "None"};
2cf0635d 12671static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12672 {"None", "direct", "GOT-indirect"};
2cf0635d 12673static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12674 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12675static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12676static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12677 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12678static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12679static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12680static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12681 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12682static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12683 {"Unused", "small", "int", "forced to int"};
2cf0635d 12684static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12685 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12686static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12687 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12688static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12689 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12690static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12691 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12692 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12693static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12694 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12695 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12696static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12697static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12698 {"Not Allowed", "Allowed"};
2cf0635d 12699static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12700 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12701static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12702 {"Not Allowed", "Allowed"};
12703static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12704 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12705 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12706static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12707static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12708 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12709 "TrustZone and Virtualization Extensions"};
dd24e3da 12710static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12711 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12712
12713#define LOOKUP(id, name) \
12714 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12715static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12716{
12717 {4, "CPU_raw_name", 1, NULL},
12718 {5, "CPU_name", 1, NULL},
12719 LOOKUP(6, CPU_arch),
12720 {7, "CPU_arch_profile", 0, NULL},
12721 LOOKUP(8, ARM_ISA_use),
12722 LOOKUP(9, THUMB_ISA_use),
75375b3e 12723 LOOKUP(10, FP_arch),
11c1ff18 12724 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12725 LOOKUP(12, Advanced_SIMD_arch),
12726 LOOKUP(13, PCS_config),
11c1ff18
PB		 12727 LOOKUP(14, ABI_PCS_R9_use),
12728 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12729 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12730 LOOKUP(17, ABI_PCS_GOT_use),
12731 LOOKUP(18, ABI_PCS_wchar_t),
12732 LOOKUP(19, ABI_FP_rounding),
12733 LOOKUP(20, ABI_FP_denormal),
12734 LOOKUP(21, ABI_FP_exceptions),
12735 LOOKUP(22, ABI_FP_user_exceptions),
12736 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12737 {24, "ABI_align_needed", 0, NULL},
12738 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12739 LOOKUP(26, ABI_enum_size),
12740 LOOKUP(27, ABI_HardFP_use),
12741 LOOKUP(28, ABI_VFP_args),
12742 LOOKUP(29, ABI_WMMX_args),
12743 LOOKUP(30, ABI_optimization_goals),
12744 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12745 {32, "compatibility", 0, NULL},
f5f53991 12746 LOOKUP(34, CPU_unaligned_access),
75375b3e 12747 LOOKUP(36, FP_HP_extension),
8e79c3df 12748 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12749 LOOKUP(42, MPextension_use),
12750 LOOKUP(44, DIV_use),
f5f53991
AS		 12751 {64, "nodefaults", 0, NULL},
12752 {65, "also_compatible_with", 0, NULL},
12753 LOOKUP(66, T2EE_use),
12754 {67, "conformance", 1, NULL},
12755 LOOKUP(68, Virtualization_use),
cd21e546 12756 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12757};
12758#undef LOOKUP
12759
11c1ff18 12760static unsigned char *
f6f0e17b
NC		 12761display_arm_attribute (unsigned char * p,
12762 const unsigned char * const end)
11c1ff18 12763{
70e99720 12764 unsigned int tag;
11c1ff18 12765 unsigned int len;
70e99720 12766 unsigned int val;
2cf0635d 12767 arm_attr_public_tag * attr;
11c1ff18 12768 unsigned i;
70e99720 12769 unsigned int type;
11c1ff18 12770
f6f0e17b 12771 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12772 p += len;
12773 attr = NULL;
2cf0635d 12774 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12775 {
12776 if (arm_attr_public_tags[i].tag == tag)
12777 {
12778 attr = &arm_attr_public_tags[i];
12779 break;
12780 }
12781 }
12782
12783 if (attr)
12784 {
12785 printf (" Tag_%s: ", attr->name);
12786 switch (attr->type)
12787 {
12788 case 0:
12789 switch (tag)
12790 {
12791 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12792 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12793 p += len;
12794 switch (val)
12795 {
2b692964
NC		 12796 case 0: printf (_("None\n")); break;
12797 case 'A': printf (_("Application\n")); break;
12798 case 'R': printf (_("Realtime\n")); break;
12799 case 'M': printf (_("Microcontroller\n")); break;
12800 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12801 default: printf ("??? (%d)\n", val); break;
12802 }
12803 break;
12804
75375b3e 12805 case 24: /* Tag_align_needed. */
f6f0e17b 12806 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12807 p += len;
12808 switch (val)
12809 {
2b692964
NC		 12810 case 0: printf (_("None\n")); break;
12811 case 1: printf (_("8-byte\n")); break;
12812 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12813 case 3: printf ("??? 3\n"); break;
12814 default:
12815 if (val <= 12)
dd24e3da 12816 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12817 1 << val);
12818 else
12819 printf ("??? (%d)\n", val);
12820 break;
12821 }
12822 break;
12823
12824 case 25: /* Tag_align_preserved. */
f6f0e17b 12825 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12826 p += len;
12827 switch (val)
12828 {
2b692964
NC		 12829 case 0: printf (_("None\n")); break;
12830 case 1: printf (_("8-byte, except leaf SP\n")); break;
12831 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12832 case 3: printf ("??? 3\n"); break;
12833 default:
12834 if (val <= 12)
dd24e3da 12835 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12836 1 << val);
12837 else
12838 printf ("??? (%d)\n", val);
12839 break;
12840 }
12841 break;
12842
11c1ff18 12843 case 32: /* Tag_compatibility. */
071436c6 12844 {
071436c6
NC		 12845 val = read_uleb128 (p, &len, end);
12846 p += len;
071436c6 12847 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12848 if (p < end - 1)
12849 {
12850 size_t maxlen = (end - p) - 1;
12851
12852 print_symbol ((int) maxlen, (const char *) p);
12853 p += strnlen ((char *) p, maxlen) + 1;
12854 }
12855 else
12856 {
12857 printf (_("<corrupt>"));
12858 p = (unsigned char *) end;
12859 }
071436c6 12860 putchar ('\n');
071436c6 12861 }
11c1ff18
PB		 12862 break;
12863
f5f53991 12864 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12865 /* PR 17531: file: 001-505008-0.01. */
12866 if (p < end)
12867 p++;
2b692964 12868 printf (_("True\n"));
f5f53991
AS		 12869 break;
12870
12871 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12872 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12873 p += len;
12874 if (val == 6 /* Tag_CPU_arch. */)
12875 {
f6f0e17b 12876 val = read_uleb128 (p, &len, end);
f5f53991 12877 p += len;
071436c6 12878 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12879 printf ("??? (%d)\n", val);
12880 else
12881 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12882 }
12883 else
12884 printf ("???\n");
071436c6
NC		 12885 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12886 ;
f5f53991
AS		 12887 break;
12888
11c1ff18 12889 default:
bee0ee85
NC		 12890 printf (_("<unknown: %d>\n"), tag);
12891 break;
11c1ff18
PB		 12892 }
12893 return p;
12894
12895 case 1:
f6f0e17b 12896 return display_tag_value (-1, p, end);
11c1ff18 12897 case 2:
f6f0e17b 12898 return display_tag_value (0, p, end);
11c1ff18
PB		 12899
12900 default:
12901 assert (attr->type & 0x80);
f6f0e17b 12902 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12903 p += len;
12904 type = attr->type & 0x7f;
12905 if (val >= type)
12906 printf ("??? (%d)\n", val);
12907 else
12908 printf ("%s\n", attr->table[val]);
12909 return p;
12910 }
12911 }
11c1ff18 12912
f6f0e17b 12913 return display_tag_value (tag, p, end);
11c1ff18
PB		 12914}
12915
104d59d1 12916static unsigned char *
60bca95a 12917display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12918 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12919 const unsigned char * const end)
104d59d1
JM		 12920{
12921 int tag;
12922 unsigned int len;
12923 int val;
104d59d1 12924
f6f0e17b 12925 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12926 p += len;
12927
12928 /* Tag_compatibility is the only generic GNU attribute defined at
12929 present. */
12930 if (tag == 32)
12931 {
f6f0e17b 12932 val = read_uleb128 (p, &len, end);
104d59d1 12933 p += len;
071436c6
NC		 12934
12935 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12936 if (p == end)
12937 {
071436c6 12938 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12939 warn (_("corrupt vendor attribute\n"));
12940 }
12941 else
12942 {
4082ef84
NC		 12943 if (p < end - 1)
12944 {
12945 size_t maxlen = (end - p) - 1;
071436c6 12946
4082ef84
NC		 12947 print_symbol ((int) maxlen, (const char *) p);
12948 p += strnlen ((char *) p, maxlen) + 1;
12949 }
12950 else
12951 {
12952 printf (_("<corrupt>"));
12953 p = (unsigned char *) end;
12954 }
071436c6 12955 putchar ('\n');
f6f0e17b 12956 }
104d59d1
JM		 12957 return p;
12958 }
12959
12960 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12961 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12962
f6f0e17b 12963 return display_tag_value (tag, p, end);
104d59d1
JM		 12964}
12965
34c8bcba 12966static unsigned char *
f6f0e17b
NC		 12967display_power_gnu_attribute (unsigned char * p,
12968 int tag,
12969 const unsigned char * const end)
34c8bcba 12970{
34c8bcba
JM		 12971 unsigned int len;
12972 int val;
12973
12974 if (tag == Tag_GNU_Power_ABI_FP)
12975 {
f6f0e17b 12976 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12977 p += len;
12978 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12979
34c8bcba
JM		 12980 switch (val)
12981 {
12982 case 0:
2b692964 12983 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12984 break;
12985 case 1:
2b692964 12986 printf (_("Hard float\n"));
34c8bcba
JM		 12987 break;
12988 case 2:
2b692964 12989 printf (_("Soft float\n"));
34c8bcba 12990 break;
3c7b9897 12991 case 3:
2b692964 12992 printf (_("Single-precision hard float\n"));
3c7b9897 12993 break;
34c8bcba
JM		 12994 default:
12995 printf ("??? (%d)\n", val);
12996 break;
12997 }
12998 return p;
12999 }
13000
c6e65352
DJ		 13001 if (tag == Tag_GNU_Power_ABI_Vector)
13002 {
f6f0e17b 13003 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13004 p += len;
13005 printf (" Tag_GNU_Power_ABI_Vector: ");
13006 switch (val)
13007 {
13008 case 0:
2b692964 13009 printf (_("Any\n"));
c6e65352
DJ		 13010 break;
13011 case 1:
2b692964 13012 printf (_("Generic\n"));
c6e65352
DJ		 13013 break;
13014 case 2:
13015 printf ("AltiVec\n");
13016 break;
13017 case 3:
13018 printf ("SPE\n");
13019 break;
13020 default:
13021 printf ("??? (%d)\n", val);
13022 break;
13023 }
13024 return p;
13025 }
13026
f82e0623
NF		 13027 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13028 {
f6f0e17b
NC		 13029 if (p == end)
13030 {
071436c6 13031 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13032 return p;
13033 }
0b4362b0 13034
f6f0e17b 13035 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13036 p += len;
13037 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13038 switch (val)
13039 {
13040 case 0:
2b692964 13041 printf (_("Any\n"));
f82e0623
NF		 13042 break;
13043 case 1:
13044 printf ("r3/r4\n");
13045 break;
13046 case 2:
2b692964 13047 printf (_("Memory\n"));
f82e0623
NF		 13048 break;
13049 default:
13050 printf ("??? (%d)\n", val);
13051 break;
13052 }
13053 return p;
13054 }
13055
f6f0e17b 13056 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13057}
13058
643f7afb
AK		 13059static unsigned char *
13060display_s390_gnu_attribute (unsigned char * p,
13061 int tag,
13062 const unsigned char * const end)
13063{
13064 unsigned int len;
13065 int val;
13066
13067 if (tag == Tag_GNU_S390_ABI_Vector)
13068 {
13069 val = read_uleb128 (p, &len, end);
13070 p += len;
13071 printf (" Tag_GNU_S390_ABI_Vector: ");
13072
13073 switch (val)
13074 {
13075 case 0:
13076 printf (_("any\n"));
13077 break;
13078 case 1:
13079 printf (_("software\n"));
13080 break;
13081 case 2:
13082 printf (_("hardware\n"));
13083 break;
13084 default:
13085 printf ("??? (%d)\n", val);
13086 break;
13087 }
13088 return p;
13089 }
13090
13091 return display_tag_value (tag & 1, p, end);
13092}
13093
9e8c70f9
DM		 13094static void
13095display_sparc_hwcaps (int mask)
13096{
13097 if (mask)
13098 {
13099 int first = 1;
071436c6 13100
9e8c70f9
DM		 13101 if (mask & ELF_SPARC_HWCAP_MUL32)
13102 fputs ("mul32", stdout), first = 0;
13103 if (mask & ELF_SPARC_HWCAP_DIV32)
13104 printf ("%sdiv32", first ? "" : "|"), first = 0;
13105 if (mask & ELF_SPARC_HWCAP_FSMULD)
13106 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13107 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13108 printf ("%sv8plus", first ? "" : "|"), first = 0;
13109 if (mask & ELF_SPARC_HWCAP_POPC)
13110 printf ("%spopc", first ? "" : "|"), first = 0;
13111 if (mask & ELF_SPARC_HWCAP_VIS)
13112 printf ("%svis", first ? "" : "|"), first = 0;
13113 if (mask & ELF_SPARC_HWCAP_VIS2)
13114 printf ("%svis2", first ? "" : "|"), first = 0;
13115 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13116 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13117 if (mask & ELF_SPARC_HWCAP_FMAF)
13118 printf ("%sfmaf", first ? "" : "|"), first = 0;
13119 if (mask & ELF_SPARC_HWCAP_VIS3)
13120 printf ("%svis3", first ? "" : "|"), first = 0;
13121 if (mask & ELF_SPARC_HWCAP_HPC)
13122 printf ("%shpc", first ? "" : "|"), first = 0;
13123 if (mask & ELF_SPARC_HWCAP_RANDOM)
13124 printf ("%srandom", first ? "" : "|"), first = 0;
13125 if (mask & ELF_SPARC_HWCAP_TRANS)
13126 printf ("%strans", first ? "" : "|"), first = 0;
13127 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13128 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13129 if (mask & ELF_SPARC_HWCAP_IMA)
13130 printf ("%sima", first ? "" : "|"), first = 0;
13131 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13132 printf ("%scspare", first ? "" : "|"), first = 0;
13133 }
13134 else
071436c6
NC		 13135 fputc ('0', stdout);
13136 fputc ('\n', stdout);
9e8c70f9
DM		 13137}
13138
3d68f91c
JM		 13139static void
13140display_sparc_hwcaps2 (int mask)
13141{
13142 if (mask)
13143 {
13144 int first = 1;
071436c6 13145
3d68f91c
JM		 13146 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13147 fputs ("fjathplus", stdout), first = 0;
13148 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13149 printf ("%svis3b", first ? "" : "|"), first = 0;
13150 if (mask & ELF_SPARC_HWCAP2_ADP)
13151 printf ("%sadp", first ? "" : "|"), first = 0;
13152 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13153 printf ("%ssparc5", first ? "" : "|"), first = 0;
13154 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13155 printf ("%smwait", first ? "" : "|"), first = 0;
13156 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13157 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13158 if (mask & ELF_SPARC_HWCAP2_XMONT)
13159 printf ("%sxmont2", first ? "" : "|"), first = 0;
13160 if (mask & ELF_SPARC_HWCAP2_NSEC)
13161 printf ("%snsec", first ? "" : "|"), first = 0;
13162 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13163 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13164 if (mask & ELF_SPARC_HWCAP2_FJDES)
13165 printf ("%sfjdes", first ? "" : "|"), first = 0;
13166 if (mask & ELF_SPARC_HWCAP2_FJAES)
13167 printf ("%sfjaes", first ? "" : "|"), first = 0;
13168 }
13169 else
071436c6
NC		 13170 fputc ('0', stdout);
13171 fputc ('\n', stdout);
3d68f91c
JM		 13172}
13173
9e8c70f9 13174static unsigned char *
f6f0e17b
NC		 13175display_sparc_gnu_attribute (unsigned char * p,
13176 int tag,
13177 const unsigned char * const end)
9e8c70f9 13178{
3d68f91c
JM		 13179 unsigned int len;
13180 int val;
13181
9e8c70f9
DM		 13182 if (tag == Tag_GNU_Sparc_HWCAPS)
13183 {
f6f0e17b 13184 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13185 p += len;
13186 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13187 display_sparc_hwcaps (val);
13188 return p;
3d68f91c
JM		 13189 }
13190 if (tag == Tag_GNU_Sparc_HWCAPS2)
13191 {
13192 val = read_uleb128 (p, &len, end);
13193 p += len;
13194 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13195 display_sparc_hwcaps2 (val);
13196 return p;
13197 }
9e8c70f9 13198
f6f0e17b 13199 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13200}
13201
351cdf24
MF		 13202static void
13203print_mips_fp_abi_value (int val)
13204{
13205 switch (val)
13206 {
13207 case Val_GNU_MIPS_ABI_FP_ANY:
13208 printf (_("Hard or soft float\n"));
13209 break;
13210 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13211 printf (_("Hard float (double precision)\n"));
13212 break;
13213 case Val_GNU_MIPS_ABI_FP_SINGLE:
13214 printf (_("Hard float (single precision)\n"));
13215 break;
13216 case Val_GNU_MIPS_ABI_FP_SOFT:
13217 printf (_("Soft float\n"));
13218 break;
13219 case Val_GNU_MIPS_ABI_FP_OLD_64:
13220 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13221 break;
13222 case Val_GNU_MIPS_ABI_FP_XX:
13223 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13224 break;
13225 case Val_GNU_MIPS_ABI_FP_64:
13226 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13227 break;
13228 case Val_GNU_MIPS_ABI_FP_64A:
13229 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13230 break;
3350cc01
CM		 13231 case Val_GNU_MIPS_ABI_FP_NAN2008:
13232 printf (_("NaN 2008 compatibility\n"));
13233 break;
351cdf24
MF		 13234 default:
13235 printf ("??? (%d)\n", val);
13236 break;
13237 }
13238}
13239
2cf19d5c 13240static unsigned char *
f6f0e17b
NC		 13241display_mips_gnu_attribute (unsigned char * p,
13242 int tag,
13243 const unsigned char * const end)
2cf19d5c 13244{
2cf19d5c
JM		 13245 if (tag == Tag_GNU_MIPS_ABI_FP)
13246 {
f6f0e17b
NC		 13247 unsigned int len;
13248 int val;
13249
13250 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13251 p += len;
13252 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13253
351cdf24
MF		 13254 print_mips_fp_abi_value (val);
13255
2cf19d5c
JM		 13256 return p;
13257 }
13258
a9f58168
CF		 13259 if (tag == Tag_GNU_MIPS_ABI_MSA)
13260 {
13261 unsigned int len;
13262 int val;
13263
13264 val = read_uleb128 (p, &len, end);
13265 p += len;
13266 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13267
13268 switch (val)
13269 {
13270 case Val_GNU_MIPS_ABI_MSA_ANY:
13271 printf (_("Any MSA or not\n"));
13272 break;
13273 case Val_GNU_MIPS_ABI_MSA_128:
13274 printf (_("128-bit MSA\n"));
13275 break;
13276 default:
13277 printf ("??? (%d)\n", val);
13278 break;
13279 }
13280 return p;
13281 }
13282
f6f0e17b 13283 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13284}
13285
59e6276b 13286static unsigned char *
f6f0e17b
NC		 13287display_tic6x_attribute (unsigned char * p,
13288 const unsigned char * const end)
59e6276b
JM		 13289{
13290 int tag;
13291 unsigned int len;
13292 int val;
13293
f6f0e17b 13294 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13295 p += len;
13296
13297 switch (tag)
13298 {
75fa6dc1 13299 case Tag_ISA:
f6f0e17b 13300 val = read_uleb128 (p, &len, end);
59e6276b 13301 p += len;
75fa6dc1 13302 printf (" Tag_ISA: ");
59e6276b
JM		 13303
13304 switch (val)
13305 {
75fa6dc1 13306 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13307 printf (_("None\n"));
13308 break;
75fa6dc1 13309 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13310 printf ("C62x\n");
13311 break;
75fa6dc1 13312 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13313 printf ("C67x\n");
13314 break;
75fa6dc1 13315 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13316 printf ("C67x+\n");
13317 break;
75fa6dc1 13318 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13319 printf ("C64x\n");
13320 break;
75fa6dc1 13321 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13322 printf ("C64x+\n");
13323 break;
75fa6dc1 13324 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13325 printf ("C674x\n");
13326 break;
13327 default:
13328 printf ("??? (%d)\n", val);
13329 break;
13330 }
13331 return p;
13332
87779176 13333 case Tag_ABI_wchar_t:
f6f0e17b 13334 val = read_uleb128 (p, &len, end);
87779176
JM		 13335 p += len;
13336 printf (" Tag_ABI_wchar_t: ");
13337 switch (val)
13338 {
13339 case 0:
13340 printf (_("Not used\n"));
13341 break;
13342 case 1:
13343 printf (_("2 bytes\n"));
13344 break;
13345 case 2:
13346 printf (_("4 bytes\n"));
13347 break;
13348 default:
13349 printf ("??? (%d)\n", val);
13350 break;
13351 }
13352 return p;
13353
13354 case Tag_ABI_stack_align_needed:
f6f0e17b 13355 val = read_uleb128 (p, &len, end);
87779176
JM		 13356 p += len;
13357 printf (" Tag_ABI_stack_align_needed: ");
13358 switch (val)
13359 {
13360 case 0:
13361 printf (_("8-byte\n"));
13362 break;
13363 case 1:
13364 printf (_("16-byte\n"));
13365 break;
13366 default:
13367 printf ("??? (%d)\n", val);
13368 break;
13369 }
13370 return p;
13371
13372 case Tag_ABI_stack_align_preserved:
f6f0e17b 13373 val = read_uleb128 (p, &len, end);
87779176
JM		 13374 p += len;
13375 printf (" Tag_ABI_stack_align_preserved: ");
13376 switch (val)
13377 {
13378 case 0:
13379 printf (_("8-byte\n"));
13380 break;
13381 case 1:
13382 printf (_("16-byte\n"));
13383 break;
13384 default:
13385 printf ("??? (%d)\n", val);
13386 break;
13387 }
13388 return p;
13389
b5593623 13390 case Tag_ABI_DSBT:
f6f0e17b 13391 val = read_uleb128 (p, &len, end);
b5593623
JM		 13392 p += len;
13393 printf (" Tag_ABI_DSBT: ");
13394 switch (val)
13395 {
13396 case 0:
13397 printf (_("DSBT addressing not used\n"));
13398 break;
13399 case 1:
13400 printf (_("DSBT addressing used\n"));
13401 break;
13402 default:
13403 printf ("??? (%d)\n", val);
13404 break;
13405 }
13406 return p;
13407
87779176 13408 case Tag_ABI_PID:
f6f0e17b 13409 val = read_uleb128 (p, &len, end);
87779176
JM		 13410 p += len;
13411 printf (" Tag_ABI_PID: ");
13412 switch (val)
13413 {
13414 case 0:
13415 printf (_("Data addressing position-dependent\n"));
13416 break;
13417 case 1:
13418 printf (_("Data addressing position-independent, GOT near DP\n"));
13419 break;
13420 case 2:
13421 printf (_("Data addressing position-independent, GOT far from DP\n"));
13422 break;
13423 default:
13424 printf ("??? (%d)\n", val);
13425 break;
13426 }
13427 return p;
13428
13429 case Tag_ABI_PIC:
f6f0e17b 13430 val = read_uleb128 (p, &len, end);
87779176
JM		 13431 p += len;
13432 printf (" Tag_ABI_PIC: ");
13433 switch (val)
13434 {
13435 case 0:
13436 printf (_("Code addressing position-dependent\n"));
13437 break;
13438 case 1:
13439 printf (_("Code addressing position-independent\n"));
13440 break;
13441 default:
13442 printf ("??? (%d)\n", val);
13443 break;
13444 }
13445 return p;
13446
13447 case Tag_ABI_array_object_alignment:
f6f0e17b 13448 val = read_uleb128 (p, &len, end);
87779176
JM		 13449 p += len;
13450 printf (" Tag_ABI_array_object_alignment: ");
13451 switch (val)
13452 {
13453 case 0:
13454 printf (_("8-byte\n"));
13455 break;
13456 case 1:
13457 printf (_("4-byte\n"));
13458 break;
13459 case 2:
13460 printf (_("16-byte\n"));
13461 break;
13462 default:
13463 printf ("??? (%d)\n", val);
13464 break;
13465 }
13466 return p;
13467
13468 case Tag_ABI_array_object_align_expected:
f6f0e17b 13469 val = read_uleb128 (p, &len, end);
87779176
JM		 13470 p += len;
13471 printf (" Tag_ABI_array_object_align_expected: ");
13472 switch (val)
13473 {
13474 case 0:
13475 printf (_("8-byte\n"));
13476 break;
13477 case 1:
13478 printf (_("4-byte\n"));
13479 break;
13480 case 2:
13481 printf (_("16-byte\n"));
13482 break;
13483 default:
13484 printf ("??? (%d)\n", val);
13485 break;
13486 }
13487 return p;
13488
3cbd1c06 13489 case Tag_ABI_compatibility:
071436c6 13490 {
071436c6
NC		 13491 val = read_uleb128 (p, &len, end);
13492 p += len;
13493 printf (" Tag_ABI_compatibility: ");
071436c6 13494 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13495 if (p < end - 1)
13496 {
13497 size_t maxlen = (end - p) - 1;
13498
13499 print_symbol ((int) maxlen, (const char *) p);
13500 p += strnlen ((char *) p, maxlen) + 1;
13501 }
13502 else
13503 {
13504 printf (_("<corrupt>"));
13505 p = (unsigned char *) end;
13506 }
071436c6 13507 putchar ('\n');
071436c6
NC		 13508 return p;
13509 }
87779176
JM		 13510
13511 case Tag_ABI_conformance:
071436c6 13512 {
4082ef84
NC		 13513 printf (" Tag_ABI_conformance: \"");
13514 if (p < end - 1)
13515 {
13516 size_t maxlen = (end - p) - 1;
071436c6 13517
4082ef84
NC		 13518 print_symbol ((int) maxlen, (const char *) p);
13519 p += strnlen ((char *) p, maxlen) + 1;
13520 }
13521 else
13522 {
13523 printf (_("<corrupt>"));
13524 p = (unsigned char *) end;
13525 }
071436c6 13526 printf ("\"\n");
071436c6
NC		 13527 return p;
13528 }
59e6276b
JM		 13529 }
13530
f6f0e17b
NC		 13531 return display_tag_value (tag, p, end);
13532}
59e6276b 13533
f6f0e17b
NC		 13534static void
13535display_raw_attribute (unsigned char * p, unsigned char * end)
13536{
13537 unsigned long addr = 0;
13538 size_t bytes = end - p;
13539
e0a31db1 13540 assert (end > p);
f6f0e17b 13541 while (bytes)
87779176 13542 {
f6f0e17b
NC		 13543 int j;
13544 int k;
13545 int lbytes = (bytes > 16 ? 16 : bytes);
13546
13547 printf (" 0x%8.8lx ", addr);
13548
13549 for (j = 0; j < 16; j++)
13550 {
13551 if (j < lbytes)
13552 printf ("%2.2x", p[j]);
13553 else
13554 printf (" ");
13555
13556 if ((j & 3) == 3)
13557 printf (" ");
13558 }
13559
13560 for (j = 0; j < lbytes; j++)
13561 {
13562 k = p[j];
13563 if (k >= ' ' && k < 0x7f)
13564 printf ("%c", k);
13565 else
13566 printf (".");
13567 }
13568
13569 putchar ('\n');
13570
13571 p += lbytes;
13572 bytes -= lbytes;
13573 addr += lbytes;
87779176 13574 }
59e6276b 13575
f6f0e17b 13576 putchar ('\n');
59e6276b
JM		 13577}
13578
13761a11
NC		 13579static unsigned char *
13580display_msp430x_attribute (unsigned char * p,
13581 const unsigned char * const end)
13582{
13583 unsigned int len;
13584 int val;
13585 int tag;
13586
13587 tag = read_uleb128 (p, & len, end);
13588 p += len;
0b4362b0 13589
13761a11
NC		 13590 switch (tag)
13591 {
13592 case OFBA_MSPABI_Tag_ISA:
13593 val = read_uleb128 (p, &len, end);
13594 p += len;
13595 printf (" Tag_ISA: ");
13596 switch (val)
13597 {
13598 case 0: printf (_("None\n")); break;
13599 case 1: printf (_("MSP430\n")); break;
13600 case 2: printf (_("MSP430X\n")); break;
13601 default: printf ("??? (%d)\n", val); break;
13602 }
13603 break;
13604
13605 case OFBA_MSPABI_Tag_Code_Model:
13606 val = read_uleb128 (p, &len, end);
13607 p += len;
13608 printf (" Tag_Code_Model: ");
13609 switch (val)
13610 {
13611 case 0: printf (_("None\n")); break;
13612 case 1: printf (_("Small\n")); break;
13613 case 2: printf (_("Large\n")); break;
13614 default: printf ("??? (%d)\n", val); break;
13615 }
13616 break;
13617
13618 case OFBA_MSPABI_Tag_Data_Model:
13619 val = read_uleb128 (p, &len, end);
13620 p += len;
13621 printf (" Tag_Data_Model: ");
13622 switch (val)
13623 {
13624 case 0: printf (_("None\n")); break;
13625 case 1: printf (_("Small\n")); break;
13626 case 2: printf (_("Large\n")); break;
13627 case 3: printf (_("Restricted Large\n")); break;
13628 default: printf ("??? (%d)\n", val); break;
13629 }
13630 break;
13631
13632 default:
13633 printf (_(" <unknown tag %d>: "), tag);
13634
13635 if (tag & 1)
13636 {
071436c6 13637 putchar ('"');
4082ef84
NC		 13638 if (p < end - 1)
13639 {
13640 size_t maxlen = (end - p) - 1;
13641
13642 print_symbol ((int) maxlen, (const char *) p);
13643 p += strnlen ((char *) p, maxlen) + 1;
13644 }
13645 else
13646 {
13647 printf (_("<corrupt>"));
13648 p = (unsigned char *) end;
13649 }
071436c6 13650 printf ("\"\n");
13761a11
NC		 13651 }
13652 else
13653 {
13654 val = read_uleb128 (p, &len, end);
13655 p += len;
13656 printf ("%d (0x%x)\n", val, val);
13657 }
13658 break;
13659 }
13660
4082ef84 13661 assert (p <= end);
13761a11
NC		 13662 return p;
13663}
13664
11c1ff18 13665static int
60bca95a
NC		 13666process_attributes (FILE * file,
13667 const char * public_name,
104d59d1 13668 unsigned int proc_type,
f6f0e17b
NC		 13669 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13670 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13671{
2cf0635d 13672 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13673 unsigned i;
13674
13675 /* Find the section header so that we get the size. */
13676 for (i = 0, sect = section_headers;
13677 i < elf_header.e_shnum;
13678 i++, sect++)
13679 {
071436c6
NC		 13680 unsigned char * contents;
13681 unsigned char * p;
13682
104d59d1 13683 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13684 continue;
13685
3f5e193b
NC		 13686 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13687 sect->sh_size, _("attributes"));
60bca95a 13688 if (contents == NULL)
11c1ff18 13689 continue;
60bca95a 13690
11c1ff18
PB		 13691 p = contents;
13692 if (*p == 'A')
13693 {
071436c6
NC		 13694 bfd_vma section_len;
13695
13696 section_len = sect->sh_size - 1;
11c1ff18 13697 p++;
60bca95a 13698
071436c6 13699 while (section_len > 0)
11c1ff18 13700 {
071436c6 13701 bfd_vma attr_len;
e9847026 13702 unsigned int namelen;
11c1ff18 13703 bfd_boolean public_section;
104d59d1 13704 bfd_boolean gnu_section;
11c1ff18 13705
071436c6 13706 if (section_len <= 4)
e0a31db1
NC		 13707 {
13708 error (_("Tag section ends prematurely\n"));
13709 break;
13710 }
071436c6 13711 attr_len = byte_get (p, 4);
11c1ff18 13712 p += 4;
60bca95a 13713
071436c6 13714 if (attr_len > section_len)
11c1ff18 13715 {
071436c6
NC		 13716 error (_("Bad attribute length (%u > %u)\n"),
13717 (unsigned) attr_len, (unsigned) section_len);
13718 attr_len = section_len;
11c1ff18 13719 }
74e1a04b 13720 /* PR 17531: file: 001-101425-0.004 */
071436c6 13721 else if (attr_len < 5)
74e1a04b 13722 {
071436c6 13723 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13724 break;
13725 }
e9847026 13726
071436c6
NC		 13727 section_len -= attr_len;
13728 attr_len -= 4;
13729
13730 namelen = strnlen ((char *) p, attr_len) + 1;
13731 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13732 {
13733 error (_("Corrupt attribute section name\n"));
13734 break;
13735 }
13736
071436c6
NC		 13737 printf (_("Attribute Section: "));
13738 print_symbol (INT_MAX, (const char *) p);
13739 putchar ('\n');
60bca95a
NC		 13740
13741 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13742 public_section = TRUE;
13743 else
13744 public_section = FALSE;
60bca95a
NC		 13745
13746 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13747 gnu_section = TRUE;
13748 else
13749 gnu_section = FALSE;
60bca95a 13750
11c1ff18 13751 p += namelen;
071436c6 13752 attr_len -= namelen;
e0a31db1 13753
071436c6 13754 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13755 {
e0a31db1 13756 int tag;
11c1ff18
PB		 13757 int val;
13758 bfd_vma size;
071436c6 13759 unsigned char * end;
60bca95a 13760
e0a31db1 13761 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13762 if (attr_len < 6)
e0a31db1
NC		 13763 {
13764 error (_("Unused bytes at end of section\n"));
13765 section_len = 0;
13766 break;
13767 }
13768
13769 tag = *(p++);
11c1ff18 13770 size = byte_get (p, 4);
071436c6 13771 if (size > attr_len)
11c1ff18 13772 {
e9847026 13773 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13774 (unsigned) size, (unsigned) attr_len);
13775 size = attr_len;
11c1ff18 13776 }
e0a31db1
NC		 13777 /* PR binutils/17531: Safe handling of corrupt files. */
13778 if (size < 6)
13779 {
13780 error (_("Bad subsection length (%u < 6)\n"),
13781 (unsigned) size);
13782 section_len = 0;
13783 break;
13784 }
60bca95a 13785
071436c6 13786 attr_len -= size;
11c1ff18 13787 end = p + size - 1;
071436c6 13788 assert (end <= contents + sect->sh_size);
11c1ff18 13789 p += 4;
60bca95a 13790
11c1ff18
PB		 13791 switch (tag)
13792 {
13793 case 1:
2b692964 13794 printf (_("File Attributes\n"));
11c1ff18
PB		 13795 break;
13796 case 2:
2b692964 13797 printf (_("Section Attributes:"));
11c1ff18
PB		 13798 goto do_numlist;
13799 case 3:
2b692964 13800 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13801 do_numlist:
13802 for (;;)
13803 {
91d6fa6a 13804 unsigned int j;
60bca95a 13805
f6f0e17b 13806 val = read_uleb128 (p, &j, end);
91d6fa6a 13807 p += j;
11c1ff18
PB		 13808 if (val == 0)
13809 break;
13810 printf (" %d", val);
13811 }
13812 printf ("\n");
13813 break;
13814 default:
2b692964 13815 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13816 public_section = FALSE;
13817 break;
13818 }
60bca95a 13819
071436c6 13820 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13821 {
13822 while (p < end)
f6f0e17b 13823 p = display_pub_attribute (p, end);
071436c6 13824 assert (p <= end);
104d59d1 13825 }
071436c6 13826 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13827 {
13828 while (p < end)
13829 p = display_gnu_attribute (p,
f6f0e17b
NC		 13830 display_proc_gnu_attribute,
13831 end);
071436c6 13832 assert (p <= end);
11c1ff18 13833 }
071436c6 13834 else if (p < end)
11c1ff18 13835 {
071436c6 13836 printf (_(" Unknown attribute:\n"));
f6f0e17b 13837 display_raw_attribute (p, end);
11c1ff18
PB		 13838 p = end;
13839 }
071436c6
NC		 13840 else
13841 attr_len = 0;
11c1ff18
PB		 13842 }
13843 }
13844 }
13845 else
e9847026 13846 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13847
60bca95a 13848 free (contents);
11c1ff18
PB		 13849 }
13850 return 1;
13851}
13852
104d59d1 13853static int
2cf0635d 13854process_arm_specific (FILE * file)
104d59d1
JM		 13855{
13856 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13857 display_arm_attribute, NULL);
13858}
13859
34c8bcba 13860static int
2cf0635d 13861process_power_specific (FILE * file)
34c8bcba
JM		 13862{
13863 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13864 display_power_gnu_attribute);
13865}
13866
643f7afb
AK		 13867static int
13868process_s390_specific (FILE * file)
13869{
13870 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13871 display_s390_gnu_attribute);
13872}
13873
9e8c70f9
DM		 13874static int
13875process_sparc_specific (FILE * file)
13876{
13877 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13878 display_sparc_gnu_attribute);
13879}
13880
59e6276b
JM		 13881static int
13882process_tic6x_specific (FILE * file)
13883{
13884 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13885 display_tic6x_attribute, NULL);
13886}
13887
13761a11
NC		 13888static int
13889process_msp430x_specific (FILE * file)
13890{
13891 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13892 display_msp430x_attribute, NULL);
13893}
13894
ccb4c951
RS		 13895/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13896 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13897 and return the VMA of the next entry, or -1 if there was a problem.
13898 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13899
13900static bfd_vma
82b1b41b
NC		 13901print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13902 unsigned char * data_end)
ccb4c951
RS		 13903{
13904 printf (" ");
13905 print_vma (addr, LONG_HEX);
13906 printf (" ");
13907 if (addr < pltgot + 0xfff0)
13908 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13909 else
13910 printf ("%10s", "");
13911 printf (" ");
13912 if (data == NULL)
2b692964 13913 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13914 else
13915 {
13916 bfd_vma entry;
82b1b41b 13917 unsigned char * from = data + addr - pltgot;
ccb4c951 13918
82b1b41b
NC		 13919 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13920 {
13921 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13922 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13923 return (bfd_vma) -1;
13924 }
13925 else
13926 {
13927 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13928 print_vma (entry, LONG_HEX);
13929 }
ccb4c951
RS		 13930 }
13931 return addr + (is_32bit_elf ? 4 : 8);
13932}
13933
861fb55a
DJ		 13934/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13935 PLTGOT. Print the Address and Initial fields of an entry at VMA
13936 ADDR and return the VMA of the next entry. */
13937
13938static bfd_vma
2cf0635d 13939print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13940{
13941 printf (" ");
13942 print_vma (addr, LONG_HEX);
13943 printf (" ");
13944 if (data == NULL)
2b692964 13945 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13946 else
13947 {
13948 bfd_vma entry;
13949
13950 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13951 print_vma (entry, LONG_HEX);
13952 }
13953 return addr + (is_32bit_elf ? 4 : 8);
13954}
13955
351cdf24
MF		 13956static void
13957print_mips_ases (unsigned int mask)
13958{
13959 if (mask & AFL_ASE_DSP)
13960 fputs ("\n\tDSP ASE", stdout);
13961 if (mask & AFL_ASE_DSPR2)
13962 fputs ("\n\tDSP R2 ASE", stdout);
13963 if (mask & AFL_ASE_EVA)
13964 fputs ("\n\tEnhanced VA Scheme", stdout);
13965 if (mask & AFL_ASE_MCU)
13966 fputs ("\n\tMCU (MicroController) ASE", stdout);
13967 if (mask & AFL_ASE_MDMX)
13968 fputs ("\n\tMDMX ASE", stdout);
13969 if (mask & AFL_ASE_MIPS3D)
13970 fputs ("\n\tMIPS-3D ASE", stdout);
13971 if (mask & AFL_ASE_MT)
13972 fputs ("\n\tMT ASE", stdout);
13973 if (mask & AFL_ASE_SMARTMIPS)
13974 fputs ("\n\tSmartMIPS ASE", stdout);
13975 if (mask & AFL_ASE_VIRT)
13976 fputs ("\n\tVZ ASE", stdout);
13977 if (mask & AFL_ASE_MSA)
13978 fputs ("\n\tMSA ASE", stdout);
13979 if (mask & AFL_ASE_MIPS16)
13980 fputs ("\n\tMIPS16 ASE", stdout);
13981 if (mask & AFL_ASE_MICROMIPS)
13982 fputs ("\n\tMICROMIPS ASE", stdout);
13983 if (mask & AFL_ASE_XPA)
13984 fputs ("\n\tXPA ASE", stdout);
13985 if (mask == 0)
13986 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13987 else if ((mask & ~AFL_ASE_MASK) != 0)
13988 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13989}
13990
13991static void
13992print_mips_isa_ext (unsigned int isa_ext)
13993{
13994 switch (isa_ext)
13995 {
13996 case 0:
13997 fputs (_("None"), stdout);
13998 break;
13999 case AFL_EXT_XLR:
14000 fputs ("RMI XLR", stdout);
14001 break;
2c629856
N		 14002 case AFL_EXT_OCTEON3:
14003 fputs ("Cavium Networks Octeon3", stdout);
14004 break;
351cdf24
MF		 14005 case AFL_EXT_OCTEON2:
14006 fputs ("Cavium Networks Octeon2", stdout);
14007 break;
14008 case AFL_EXT_OCTEONP:
14009 fputs ("Cavium Networks OcteonP", stdout);
14010 break;
14011 case AFL_EXT_LOONGSON_3A:
14012 fputs ("Loongson 3A", stdout);
14013 break;
14014 case AFL_EXT_OCTEON:
14015 fputs ("Cavium Networks Octeon", stdout);
14016 break;
14017 case AFL_EXT_5900:
14018 fputs ("Toshiba R5900", stdout);
14019 break;
14020 case AFL_EXT_4650:
14021 fputs ("MIPS R4650", stdout);
14022 break;
14023 case AFL_EXT_4010:
14024 fputs ("LSI R4010", stdout);
14025 break;
14026 case AFL_EXT_4100:
14027 fputs ("NEC VR4100", stdout);
14028 break;
14029 case AFL_EXT_3900:
14030 fputs ("Toshiba R3900", stdout);
14031 break;
14032 case AFL_EXT_10000:
14033 fputs ("MIPS R10000", stdout);
14034 break;
14035 case AFL_EXT_SB1:
14036 fputs ("Broadcom SB-1", stdout);
14037 break;
14038 case AFL_EXT_4111:
14039 fputs ("NEC VR4111/VR4181", stdout);
14040 break;
14041 case AFL_EXT_4120:
14042 fputs ("NEC VR4120", stdout);
14043 break;
14044 case AFL_EXT_5400:
14045 fputs ("NEC VR5400", stdout);
14046 break;
14047 case AFL_EXT_5500:
14048 fputs ("NEC VR5500", stdout);
14049 break;
14050 case AFL_EXT_LOONGSON_2E:
14051 fputs ("ST Microelectronics Loongson 2E", stdout);
14052 break;
14053 case AFL_EXT_LOONGSON_2F:
14054 fputs ("ST Microelectronics Loongson 2F", stdout);
14055 break;
14056 default:
00ac7aa0 14057 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14058 }
14059}
14060
14061static int
14062get_mips_reg_size (int reg_size)
14063{
14064 return (reg_size == AFL_REG_NONE) ? 0
14065 : (reg_size == AFL_REG_32) ? 32
14066 : (reg_size == AFL_REG_64) ? 64
14067 : (reg_size == AFL_REG_128) ? 128
14068 : -1;
14069}
14070
19e6b90e 14071static int
2cf0635d 14072process_mips_specific (FILE * file)
5b18a4bc 14073{
2cf0635d 14074 Elf_Internal_Dyn * entry;
351cdf24 14075 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14076 size_t liblist_offset = 0;
14077 size_t liblistno = 0;
14078 size_t conflictsno = 0;
14079 size_t options_offset = 0;
14080 size_t conflicts_offset = 0;
861fb55a
DJ		 14081 size_t pltrelsz = 0;
14082 size_t pltrel = 0;
ccb4c951 14083 bfd_vma pltgot = 0;
861fb55a
DJ		 14084 bfd_vma mips_pltgot = 0;
14085 bfd_vma jmprel = 0;
ccb4c951
RS		 14086 bfd_vma local_gotno = 0;
14087 bfd_vma gotsym = 0;
14088 bfd_vma symtabno = 0;
103f02d3 14089
2cf19d5c
JM		 14090 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14091 display_mips_gnu_attribute);
14092
351cdf24
MF		 14093 sect = find_section (".MIPS.abiflags");
14094
14095 if (sect != NULL)
14096 {
14097 Elf_External_ABIFlags_v0 *abiflags_ext;
14098 Elf_Internal_ABIFlags_v0 abiflags_in;
14099
14100 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14101 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14102 else
14103 {
14104 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14105 sect->sh_size, _("MIPS ABI Flags section"));
14106 if (abiflags_ext)
14107 {
14108 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14109 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14110 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14111 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14112 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14113 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14114 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14115 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14116 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14117 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14118 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14119
14120 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14121 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14122 if (abiflags_in.isa_rev > 1)
14123 printf ("r%d", abiflags_in.isa_rev);
14124 printf ("\nGPR size: %d",
14125 get_mips_reg_size (abiflags_in.gpr_size));
14126 printf ("\nCPR1 size: %d",
14127 get_mips_reg_size (abiflags_in.cpr1_size));
14128 printf ("\nCPR2 size: %d",
14129 get_mips_reg_size (abiflags_in.cpr2_size));
14130 fputs ("\nFP ABI: ", stdout);
14131 print_mips_fp_abi_value (abiflags_in.fp_abi);
14132 fputs ("ISA Extension: ", stdout);
14133 print_mips_isa_ext (abiflags_in.isa_ext);
14134 fputs ("\nASEs:", stdout);
14135 print_mips_ases (abiflags_in.ases);
14136 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14137 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14138 fputc ('\n', stdout);
14139 free (abiflags_ext);
14140 }
14141 }
14142 }
14143
19e6b90e
L		 14144 /* We have a lot of special sections. Thanks SGI! */
14145 if (dynamic_section == NULL)
14146 /* No information available. */
14147 return 0;
252b5132 14148
071436c6
NC		 14149 for (entry = dynamic_section;
14150 /* PR 17531 file: 012-50589-0.004. */
14151 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14152 ++entry)
252b5132
RH		 14153 switch (entry->d_tag)
14154 {
14155 case DT_MIPS_LIBLIST:
d93f0186
NC		 14156 liblist_offset
14157 = offset_from_vma (file, entry->d_un.d_val,
14158 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14159 break;
14160 case DT_MIPS_LIBLISTNO:
14161 liblistno = entry->d_un.d_val;
14162 break;
14163 case DT_MIPS_OPTIONS:
d93f0186 14164 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14165 break;
14166 case DT_MIPS_CONFLICT:
d93f0186
NC		 14167 conflicts_offset
14168 = offset_from_vma (file, entry->d_un.d_val,
14169 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14170 break;
14171 case DT_MIPS_CONFLICTNO:
14172 conflictsno = entry->d_un.d_val;
14173 break;
ccb4c951 14174 case DT_PLTGOT:
861fb55a
DJ		 14175 pltgot = entry->d_un.d_ptr;
14176 break;
ccb4c951
RS		 14177 case DT_MIPS_LOCAL_GOTNO:
14178 local_gotno = entry->d_un.d_val;
14179 break;
14180 case DT_MIPS_GOTSYM:
14181 gotsym = entry->d_un.d_val;
14182 break;
14183 case DT_MIPS_SYMTABNO:
14184 symtabno = entry->d_un.d_val;
14185 break;
861fb55a
DJ		 14186 case DT_MIPS_PLTGOT:
14187 mips_pltgot = entry->d_un.d_ptr;
14188 break;
14189 case DT_PLTREL:
14190 pltrel = entry->d_un.d_val;
14191 break;
14192 case DT_PLTRELSZ:
14193 pltrelsz = entry->d_un.d_val;
14194 break;
14195 case DT_JMPREL:
14196 jmprel = entry->d_un.d_ptr;
14197 break;
252b5132
RH		 14198 default:
14199 break;
14200 }
14201
14202 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14203 {
2cf0635d 14204 Elf32_External_Lib * elib;
252b5132
RH		 14205 size_t cnt;
14206
3f5e193b
NC		 14207 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14208 liblistno,
14209 sizeof (Elf32_External_Lib),
9cf03b7e 14210 _("liblist section data"));
a6e9f9df 14211 if (elib)
252b5132 14212 {
2b692964 14213 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14214 (unsigned long) liblistno);
2b692964 14215 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14216 stdout);
14217
14218 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14219 {
a6e9f9df 14220 Elf32_Lib liblist;
91d6fa6a 14221 time_t atime;
a6e9f9df 14222 char timebuf[20];
2cf0635d 14223 struct tm * tmp;
a6e9f9df
AM		 14224
14225 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14226 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14227 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14228 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14229 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14230
91d6fa6a 14231 tmp = gmtime (&atime);
e9e44622
JJ		 14232 snprintf (timebuf, sizeof (timebuf),
14233 "%04u-%02u-%02uT%02u:%02u:%02u",
14234 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14235 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14236
31104126 14237 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14238 if (VALID_DYNAMIC_NAME (liblist.l_name))
14239 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14240 else
2b692964 14241 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14242 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14243 liblist.l_version);
a6e9f9df
AM		 14244
14245 if (liblist.l_flags == 0)
2b692964 14246 puts (_(" NONE"));
a6e9f9df
AM		 14247 else
14248 {
14249 static const struct
252b5132 14250 {
2cf0635d 14251 const char * name;
a6e9f9df 14252 int bit;
252b5132 14253 }
a6e9f9df
AM		 14254 l_flags_vals[] =
14255 {
14256 { " EXACT_MATCH", LL_EXACT_MATCH },
14257 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14258 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14259 { " EXPORTS", LL_EXPORTS },
14260 { " DELAY_LOAD", LL_DELAY_LOAD },
14261 { " DELTA", LL_DELTA }
14262 };
14263 int flags = liblist.l_flags;
14264 size_t fcnt;
14265
60bca95a 14266 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14267 if ((flags & l_flags_vals[fcnt].bit) != 0)
14268 {
14269 fputs (l_flags_vals[fcnt].name, stdout);
14270 flags ^= l_flags_vals[fcnt].bit;
14271 }
14272 if (flags != 0)
14273 printf (" %#x", (unsigned int) flags);
252b5132 14274
a6e9f9df
AM		 14275 puts ("");
14276 }
252b5132 14277 }
252b5132 14278
a6e9f9df
AM		 14279 free (elib);
14280 }
252b5132
RH		 14281 }
14282
14283 if (options_offset != 0)
14284 {
2cf0635d 14285 Elf_External_Options * eopt;
2cf0635d
NC		 14286 Elf_Internal_Options * iopt;
14287 Elf_Internal_Options * option;
252b5132
RH		 14288 size_t offset;
14289 int cnt;
351cdf24 14290 sect = section_headers;
252b5132
RH		 14291
14292 /* Find the section header so that we get the size. */
071436c6 14293 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14294 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14295 if (sect == NULL)
14296 {
14297 error (_("No MIPS_OPTIONS header found\n"));
14298 return 0;
14299 }
252b5132 14300
3f5e193b
NC		 14301 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14302 sect->sh_size, _("options"));
a6e9f9df 14303 if (eopt)
252b5132 14304 {
3f5e193b
NC		 14305 iopt = (Elf_Internal_Options *)
14306 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14307 if (iopt == NULL)
14308 {
8b73c356 14309 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14310 return 0;
14311 }
76da6bbe 14312
a6e9f9df
AM		 14313 offset = cnt = 0;
14314 option = iopt;
252b5132 14315
82b1b41b 14316 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14317 {
2cf0635d 14318 Elf_External_Options * eoption;
252b5132 14319
a6e9f9df 14320 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14321
a6e9f9df
AM		 14322 option->kind = BYTE_GET (eoption->kind);
14323 option->size = BYTE_GET (eoption->size);
14324 option->section = BYTE_GET (eoption->section);
14325 option->info = BYTE_GET (eoption->info);
76da6bbe 14326
82b1b41b
NC		 14327 /* PR 17531: file: ffa0fa3b. */
14328 if (option->size < sizeof (* eopt)
14329 || offset + option->size > sect->sh_size)
14330 {
55325047
NC		 14331 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14332 return 0;
82b1b41b 14333 }
a6e9f9df 14334 offset += option->size;
14ae95f2 14335
a6e9f9df
AM		 14336 ++option;
14337 ++cnt;
14338 }
252b5132 14339
a6e9f9df 14340 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14341 printable_section_name (sect), cnt);
76da6bbe 14342
a6e9f9df 14343 option = iopt;
82b1b41b 14344 offset = 0;
252b5132 14345
a6e9f9df 14346 while (cnt-- > 0)
252b5132 14347 {
a6e9f9df
AM		 14348 size_t len;
14349
14350 switch (option->kind)
252b5132 14351 {
a6e9f9df
AM		 14352 case ODK_NULL:
14353 /* This shouldn't happen. */
14354 printf (" NULL %d %lx", option->section, option->info);
14355 break;
14356 case ODK_REGINFO:
14357 printf (" REGINFO ");
14358 if (elf_header.e_machine == EM_MIPS)
14359 {
14360 /* 32bit form. */
2cf0635d 14361 Elf32_External_RegInfo * ereg;
b34976b6 14362 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14363
14364 ereg = (Elf32_External_RegInfo *) (option + 1);
14365 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14366 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14367 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14368 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14369 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14370 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14371
14372 printf ("GPR %08lx GP 0x%lx\n",
14373 reginfo.ri_gprmask,
14374 (unsigned long) reginfo.ri_gp_value);
14375 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14376 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14377 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14378 }
14379 else
14380 {
14381 /* 64 bit form. */
2cf0635d 14382 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14383 Elf64_Internal_RegInfo reginfo;
14384
14385 ereg = (Elf64_External_RegInfo *) (option + 1);
14386 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14387 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14388 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14389 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14390 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14391 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14392
14393 printf ("GPR %08lx GP 0x",
14394 reginfo.ri_gprmask);
14395 printf_vma (reginfo.ri_gp_value);
14396 printf ("\n");
14397
14398 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14399 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14400 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14401 }
14402 ++option;
14403 continue;
14404 case ODK_EXCEPTIONS:
14405 fputs (" EXCEPTIONS fpe_min(", stdout);
14406 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14407 fputs (") fpe_max(", stdout);
14408 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14409 fputs (")", stdout);
14410
14411 if (option->info & OEX_PAGE0)
14412 fputs (" PAGE0", stdout);
14413 if (option->info & OEX_SMM)
14414 fputs (" SMM", stdout);
14415 if (option->info & OEX_FPDBUG)
14416 fputs (" FPDBUG", stdout);
14417 if (option->info & OEX_DISMISS)
14418 fputs (" DISMISS", stdout);
14419 break;
14420 case ODK_PAD:
14421 fputs (" PAD ", stdout);
14422 if (option->info & OPAD_PREFIX)
14423 fputs (" PREFIX", stdout);
14424 if (option->info & OPAD_POSTFIX)
14425 fputs (" POSTFIX", stdout);
14426 if (option->info & OPAD_SYMBOL)
14427 fputs (" SYMBOL", stdout);
14428 break;
14429 case ODK_HWPATCH:
14430 fputs (" HWPATCH ", stdout);
14431 if (option->info & OHW_R4KEOP)
14432 fputs (" R4KEOP", stdout);
14433 if (option->info & OHW_R8KPFETCH)
14434 fputs (" R8KPFETCH", stdout);
14435 if (option->info & OHW_R5KEOP)
14436 fputs (" R5KEOP", stdout);
14437 if (option->info & OHW_R5KCVTL)
14438 fputs (" R5KCVTL", stdout);
14439 break;
14440 case ODK_FILL:
14441 fputs (" FILL ", stdout);
14442 /* XXX Print content of info word? */
14443 break;
14444 case ODK_TAGS:
14445 fputs (" TAGS ", stdout);
14446 /* XXX Print content of info word? */
14447 break;
14448 case ODK_HWAND:
14449 fputs (" HWAND ", stdout);
14450 if (option->info & OHWA0_R4KEOP_CHECKED)
14451 fputs (" R4KEOP_CHECKED", stdout);
14452 if (option->info & OHWA0_R4KEOP_CLEAN)
14453 fputs (" R4KEOP_CLEAN", stdout);
14454 break;
14455 case ODK_HWOR:
14456 fputs (" HWOR ", stdout);
14457 if (option->info & OHWA0_R4KEOP_CHECKED)
14458 fputs (" R4KEOP_CHECKED", stdout);
14459 if (option->info & OHWA0_R4KEOP_CLEAN)
14460 fputs (" R4KEOP_CLEAN", stdout);
14461 break;
14462 case ODK_GP_GROUP:
14463 printf (" GP_GROUP %#06lx self-contained %#06lx",
14464 option->info & OGP_GROUP,
14465 (option->info & OGP_SELF) >> 16);
14466 break;
14467 case ODK_IDENT:
14468 printf (" IDENT %#06lx self-contained %#06lx",
14469 option->info & OGP_GROUP,
14470 (option->info & OGP_SELF) >> 16);
14471 break;
14472 default:
14473 /* This shouldn't happen. */
14474 printf (" %3d ??? %d %lx",
14475 option->kind, option->section, option->info);
14476 break;
252b5132 14477 }
a6e9f9df 14478
2cf0635d 14479 len = sizeof (* eopt);
a6e9f9df 14480 while (len < option->size)
82b1b41b 14481 {
7e27a9d5 14482 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14483
82b1b41b
NC		 14484 if (ISPRINT (datum))
14485 printf ("%c", datum);
14486 else
14487 printf ("\\%03o", datum);
14488 len ++;
14489 }
a6e9f9df 14490 fputs ("\n", stdout);
82b1b41b
NC		 14491
14492 offset += option->size;
252b5132 14493 ++option;
252b5132
RH		 14494 }
14495
a6e9f9df 14496 free (eopt);
252b5132 14497 }
252b5132
RH		 14498 }
14499
14500 if (conflicts_offset != 0 && conflictsno != 0)
14501 {
2cf0635d 14502 Elf32_Conflict * iconf;
252b5132
RH		 14503 size_t cnt;
14504
14505 if (dynamic_symbols == NULL)
14506 {
591a748a 14507 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14508 return 0;
14509 }
14510
3f5e193b 14511 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14512 if (iconf == NULL)
14513 {
8b73c356 14514 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14515 return 0;
14516 }
14517
9ea033b2 14518 if (is_32bit_elf)
252b5132 14519 {
2cf0635d 14520 Elf32_External_Conflict * econf32;
a6e9f9df 14521
3f5e193b
NC		 14522 econf32 = (Elf32_External_Conflict *)
14523 get_data (NULL, file, conflicts_offset, conflictsno,
14524 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14525 if (!econf32)
14526 return 0;
252b5132
RH		 14527
14528 for (cnt = 0; cnt < conflictsno; ++cnt)
14529 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14530
14531 free (econf32);
252b5132
RH		 14532 }
14533 else
14534 {
2cf0635d 14535 Elf64_External_Conflict * econf64;
a6e9f9df 14536
3f5e193b
NC		 14537 econf64 = (Elf64_External_Conflict *)
14538 get_data (NULL, file, conflicts_offset, conflictsno,
14539 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14540 if (!econf64)
14541 return 0;
252b5132
RH		 14542
14543 for (cnt = 0; cnt < conflictsno; ++cnt)
14544 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14545
14546 free (econf64);
252b5132
RH		 14547 }
14548
c7e7ca54
NC		 14549 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14550 (unsigned long) conflictsno);
252b5132
RH		 14551 puts (_(" Num: Index Value Name"));
14552
14553 for (cnt = 0; cnt < conflictsno; ++cnt)
14554 {
b34976b6 14555 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14556
14557 if (iconf[cnt] >= num_dynamic_syms)
14558 printf (_("<corrupt symbol index>"));
d79b3d50 14559 else
e0a31db1
NC		 14560 {
14561 Elf_Internal_Sym * psym;
14562
14563 psym = & dynamic_symbols[iconf[cnt]];
14564 print_vma (psym->st_value, FULL_HEX);
14565 putchar (' ');
14566 if (VALID_DYNAMIC_NAME (psym->st_name))
14567 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14568 else
14569 printf (_("<corrupt: %14ld>"), psym->st_name);
14570 }
31104126 14571 putchar ('\n');
252b5132
RH		 14572 }
14573
252b5132
RH		 14574 free (iconf);
14575 }
14576
ccb4c951
RS		 14577 if (pltgot != 0 && local_gotno != 0)
14578 {
91d6fa6a 14579 bfd_vma ent, local_end, global_end;
bbeee7ea 14580 size_t i, offset;
2cf0635d 14581 unsigned char * data;
82b1b41b 14582 unsigned char * data_end;
bbeee7ea 14583 int addr_size;
ccb4c951 14584
91d6fa6a 14585 ent = pltgot;
ccb4c951
RS		 14586 addr_size = (is_32bit_elf ? 4 : 8);
14587 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14588
74e1a04b
NC		 14589 /* PR binutils/17533 file: 012-111227-0.004 */
14590 if (symtabno < gotsym)
14591 {
14592 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14593 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14594 return 0;
14595 }
82b1b41b 14596
74e1a04b 14597 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14598 /* PR 17531: file: 54c91a34. */
14599 if (global_end < local_end)
14600 {
14601 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14602 return 0;
14603 }
948f632f 14604
ccb4c951 14605 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14606 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14607 global_end - pltgot, 1,
14608 _("Global Offset Table data"));
59245841
NC		 14609 if (data == NULL)
14610 return 0;
82b1b41b 14611 data_end = data + (global_end - pltgot);
59245841 14612
ccb4c951
RS		 14613 printf (_("\nPrimary GOT:\n"));
14614 printf (_(" Canonical gp value: "));
14615 print_vma (pltgot + 0x7ff0, LONG_HEX);
14616 printf ("\n\n");
14617
14618 printf (_(" Reserved entries:\n"));
14619 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14620 addr_size * 2, _("Address"), _("Access"),
14621 addr_size * 2, _("Initial"));
82b1b41b 14622 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14623 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14624 if (ent == (bfd_vma) -1)
14625 goto got_print_fail;
ccb4c951 14626 if (data
91d6fa6a 14627 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14628 >> (addr_size * 8 - 1)) != 0)
14629 {
82b1b41b 14630 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14631 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14632 if (ent == (bfd_vma) -1)
14633 goto got_print_fail;
ccb4c951
RS		 14634 }
14635 printf ("\n");
14636
91d6fa6a 14637 if (ent < local_end)
ccb4c951
RS		 14638 {
14639 printf (_(" Local entries:\n"));
cc5914eb 14640 printf (" %*s %10s %*s\n",
2b692964
NC		 14641 addr_size * 2, _("Address"), _("Access"),
14642 addr_size * 2, _("Initial"));
91d6fa6a 14643 while (ent < local_end)
ccb4c951 14644 {
82b1b41b 14645 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14646 printf ("\n");
82b1b41b
NC		 14647 if (ent == (bfd_vma) -1)
14648 goto got_print_fail;
ccb4c951
RS		 14649 }
14650 printf ("\n");
14651 }
14652
14653 if (gotsym < symtabno)
14654 {
14655 int sym_width;
14656
14657 printf (_(" Global entries:\n"));
cc5914eb 14658 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14659 addr_size * 2, _("Address"),
14660 _("Access"),
2b692964 14661 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14662 addr_size * 2, _("Sym.Val."),
14663 _("Type"),
14664 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14665 _("Ndx"), _("Name"));
0b4362b0 14666
ccb4c951 14667 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14668
ccb4c951
RS		 14669 for (i = gotsym; i < symtabno; i++)
14670 {
82b1b41b 14671 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14672 printf (" ");
e0a31db1
NC		 14673
14674 if (dynamic_symbols == NULL)
14675 printf (_("<no dynamic symbols>"));
14676 else if (i < num_dynamic_syms)
14677 {
14678 Elf_Internal_Sym * psym = dynamic_symbols + i;
14679
14680 print_vma (psym->st_value, LONG_HEX);
14681 printf (" %-7s %3s ",
14682 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14683 get_symbol_index_type (psym->st_shndx));
14684
14685 if (VALID_DYNAMIC_NAME (psym->st_name))
14686 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14687 else
14688 printf (_("<corrupt: %14ld>"), psym->st_name);
14689 }
ccb4c951 14690 else
7fc5ac57
JBG		 14691 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14692 (unsigned long) i);
e0a31db1 14693
ccb4c951 14694 printf ("\n");
82b1b41b
NC		 14695 if (ent == (bfd_vma) -1)
14696 break;
ccb4c951
RS		 14697 }
14698 printf ("\n");
14699 }
14700
82b1b41b 14701 got_print_fail:
ccb4c951
RS		 14702 if (data)
14703 free (data);
14704 }
14705
861fb55a
DJ		 14706 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14707 {
91d6fa6a 14708 bfd_vma ent, end;
861fb55a
DJ		 14709 size_t offset, rel_offset;
14710 unsigned long count, i;
2cf0635d 14711 unsigned char * data;
861fb55a 14712 int addr_size, sym_width;
2cf0635d 14713 Elf_Internal_Rela * rels;
861fb55a
DJ		 14714
14715 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14716 if (pltrel == DT_RELA)
14717 {
14718 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14719 return 0;
14720 }
14721 else
14722 {
14723 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14724 return 0;
14725 }
14726
91d6fa6a 14727 ent = mips_pltgot;
861fb55a
DJ		 14728 addr_size = (is_32bit_elf ? 4 : 8);
14729 end = mips_pltgot + (2 + count) * addr_size;
14730
14731 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14732 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14733 1, _("Procedure Linkage Table data"));
59245841
NC		 14734 if (data == NULL)
14735 return 0;
14736
9cf03b7e 14737 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14738 printf (_(" Reserved entries:\n"));
14739 printf (_(" %*s %*s Purpose\n"),
2b692964 14740 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14741 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14742 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14743 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14744 printf (_(" Module pointer\n"));
861fb55a
DJ		 14745 printf ("\n");
14746
14747 printf (_(" Entries:\n"));
cc5914eb 14748 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14749 addr_size * 2, _("Address"),
14750 addr_size * 2, _("Initial"),
14751 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14752 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14753 for (i = 0; i < count; i++)
14754 {
df97ab2a 14755 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14756
91d6fa6a 14757 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14758 printf (" ");
e0a31db1 14759
df97ab2a
MF		 14760 if (idx >= num_dynamic_syms)
14761 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14762 else
e0a31db1 14763 {
df97ab2a 14764 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14765
14766 print_vma (psym->st_value, LONG_HEX);
14767 printf (" %-7s %3s ",
14768 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14769 get_symbol_index_type (psym->st_shndx));
14770 if (VALID_DYNAMIC_NAME (psym->st_name))
14771 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14772 else
14773 printf (_("<corrupt: %14ld>"), psym->st_name);
14774 }
861fb55a
DJ		 14775 printf ("\n");
14776 }
14777 printf ("\n");
14778
14779 if (data)
14780 free (data);
14781 free (rels);
14782 }
14783
252b5132
RH		 14784 return 1;
14785}
14786
35c08157
KLC		 14787static int
14788process_nds32_specific (FILE * file)
14789{
14790 Elf_Internal_Shdr *sect = NULL;
14791
14792 sect = find_section (".nds32_e_flags");
14793 if (sect != NULL)
14794 {
14795 unsigned int *flag;
14796
14797 printf ("\nNDS32 elf flags section:\n");
14798 flag = get_data (NULL, file, sect->sh_offset, 1,
14799 sect->sh_size, _("NDS32 elf flags section"));
14800
14801 switch ((*flag) & 0x3)
14802 {
14803 case 0:
14804 printf ("(VEC_SIZE):\tNo entry.\n");
14805 break;
14806 case 1:
14807 printf ("(VEC_SIZE):\t4 bytes\n");
14808 break;
14809 case 2:
14810 printf ("(VEC_SIZE):\t16 bytes\n");
14811 break;
14812 case 3:
14813 printf ("(VEC_SIZE):\treserved\n");
14814 break;
14815 }
14816 }
14817
14818 return TRUE;
14819}
14820
047b2264 14821static int
2cf0635d 14822process_gnu_liblist (FILE * file)
047b2264 14823{
2cf0635d
NC		 14824 Elf_Internal_Shdr * section;
14825 Elf_Internal_Shdr * string_sec;
14826 Elf32_External_Lib * elib;
14827 char * strtab;
c256ffe7 14828 size_t strtab_size;
047b2264
JJ		 14829 size_t cnt;
14830 unsigned i;
14831
14832 if (! do_arch)
14833 return 0;
14834
14835 for (i = 0, section = section_headers;
14836 i < elf_header.e_shnum;
b34976b6 14837 i++, section++)
047b2264
JJ		 14838 {
14839 switch (section->sh_type)
14840 {
14841 case SHT_GNU_LIBLIST:
4fbb74a6 14842 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14843 break;
14844
3f5e193b
NC		 14845 elib = (Elf32_External_Lib *)
14846 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14847 _("liblist section data"));
047b2264
JJ		 14848
14849 if (elib == NULL)
14850 break;
4fbb74a6 14851 string_sec = section_headers + section->sh_link;
047b2264 14852
3f5e193b
NC		 14853 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14854 string_sec->sh_size,
14855 _("liblist string table"));
047b2264
JJ		 14856 if (strtab == NULL
14857 || section->sh_entsize != sizeof (Elf32_External_Lib))
14858 {
14859 free (elib);
2842702f 14860 free (strtab);
047b2264
JJ		 14861 break;
14862 }
59245841 14863 strtab_size = string_sec->sh_size;
047b2264
JJ		 14864
14865 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14866 printable_section_name (section),
0af1713e 14867 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14868
2b692964 14869 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14870
14871 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14872 ++cnt)
14873 {
14874 Elf32_Lib liblist;
91d6fa6a 14875 time_t atime;
047b2264 14876 char timebuf[20];
2cf0635d 14877 struct tm * tmp;
047b2264
JJ		 14878
14879 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14880 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14881 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14882 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14883 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14884
91d6fa6a 14885 tmp = gmtime (&atime);
e9e44622
JJ		 14886 snprintf (timebuf, sizeof (timebuf),
14887 "%04u-%02u-%02uT%02u:%02u:%02u",
14888 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14889 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14890
14891 printf ("%3lu: ", (unsigned long) cnt);
14892 if (do_wide)
c256ffe7 14893 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14894 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14895 else
c256ffe7 14896 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14897 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14898 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14899 liblist.l_version, liblist.l_flags);
14900 }
14901
14902 free (elib);
2842702f 14903 free (strtab);
047b2264
JJ		 14904 }
14905 }
14906
14907 return 1;
14908}
14909
9437c45b 14910static const char *
d3ba0551 14911get_note_type (unsigned e_type)
779fe533
NC		 14912{
14913 static char buff[64];
103f02d3 14914
1ec5cd37
NC		 14915 if (elf_header.e_type == ET_CORE)
14916 switch (e_type)
14917 {
57346661 14918 case NT_AUXV:
1ec5cd37 14919 return _("NT_AUXV (auxiliary vector)");
57346661 14920 case NT_PRSTATUS:
1ec5cd37 14921 return _("NT_PRSTATUS (prstatus structure)");
57346661 14922 case NT_FPREGSET:
1ec5cd37 14923 return _("NT_FPREGSET (floating point registers)");
57346661 14924 case NT_PRPSINFO:
1ec5cd37 14925 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14926 case NT_TASKSTRUCT:
1ec5cd37 14927 return _("NT_TASKSTRUCT (task structure)");
57346661 14928 case NT_PRXFPREG:
1ec5cd37 14929 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14930 case NT_PPC_VMX:
14931 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14932 case NT_PPC_VSX:
14933 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14934 case NT_386_TLS:
14935 return _("NT_386_TLS (x86 TLS information)");
14936 case NT_386_IOPERM:
14937 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14938 case NT_X86_XSTATE:
14939 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14940 case NT_S390_HIGH_GPRS:
14941 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14942 case NT_S390_TIMER:
14943 return _("NT_S390_TIMER (s390 timer register)");
14944 case NT_S390_TODCMP:
14945 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14946 case NT_S390_TODPREG:
14947 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14948 case NT_S390_CTRS:
14949 return _("NT_S390_CTRS (s390 control registers)");
14950 case NT_S390_PREFIX:
14951 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14952 case NT_S390_LAST_BREAK:
14953 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14954 case NT_S390_SYSTEM_CALL:
14955 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14956 case NT_S390_TDB:
14957 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14958 case NT_S390_VXRS_LOW:
14959 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14960 case NT_S390_VXRS_HIGH:
14961 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14962 case NT_ARM_VFP:
14963 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14964 case NT_ARM_TLS:
14965 return _("NT_ARM_TLS (AArch TLS registers)");
14966 case NT_ARM_HW_BREAK:
14967 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14968 case NT_ARM_HW_WATCH:
14969 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14970 case NT_PSTATUS:
1ec5cd37 14971 return _("NT_PSTATUS (pstatus structure)");
57346661 14972 case NT_FPREGS:
1ec5cd37 14973 return _("NT_FPREGS (floating point registers)");
57346661 14974 case NT_PSINFO:
1ec5cd37 14975 return _("NT_PSINFO (psinfo structure)");
57346661 14976 case NT_LWPSTATUS:
1ec5cd37 14977 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14978 case NT_LWPSINFO:
1ec5cd37 14979 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14980 case NT_WIN32PSTATUS:
1ec5cd37 14981 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14982 case NT_SIGINFO:
14983 return _("NT_SIGINFO (siginfo_t data)");
14984 case NT_FILE:
14985 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14986 default:
14987 break;
14988 }
14989 else
14990 switch (e_type)
14991 {
14992 case NT_VERSION:
14993 return _("NT_VERSION (version)");
14994 case NT_ARCH:
14995 return _("NT_ARCH (architecture)");
14996 default:
14997 break;
14998 }
14999
e9e44622 15000 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15001 return buff;
779fe533
NC		 15002}
15003
9ece1fa9
TT		 15004static int
15005print_core_note (Elf_Internal_Note *pnote)
15006{
15007 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15008 bfd_vma count, page_size;
15009 unsigned char *descdata, *filenames, *descend;
15010
15011 if (pnote->type != NT_FILE)
15012 return 1;
15013
15014#ifndef BFD64
15015 if (!is_32bit_elf)
15016 {
15017 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15018 /* Still "successful". */
15019 return 1;
15020 }
15021#endif
15022
15023 if (pnote->descsz < 2 * addr_size)
15024 {
15025 printf (_(" Malformed note - too short for header\n"));
15026 return 0;
15027 }
15028
15029 descdata = (unsigned char *) pnote->descdata;
15030 descend = descdata + pnote->descsz;
15031
15032 if (descdata[pnote->descsz - 1] != '\0')
15033 {
15034 printf (_(" Malformed note - does not end with \\0\n"));
15035 return 0;
15036 }
15037
15038 count = byte_get (descdata, addr_size);
15039 descdata += addr_size;
15040
15041 page_size = byte_get (descdata, addr_size);
15042 descdata += addr_size;
15043
15044 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15045 {
15046 printf (_(" Malformed note - too short for supplied file count\n"));
15047 return 0;
15048 }
15049
15050 printf (_(" Page size: "));
15051 print_vma (page_size, DEC);
15052 printf ("\n");
15053
15054 printf (_(" %*s%*s%*s\n"),
15055 (int) (2 + 2 * addr_size), _("Start"),
15056 (int) (4 + 2 * addr_size), _("End"),
15057 (int) (4 + 2 * addr_size), _("Page Offset"));
15058 filenames = descdata + count * 3 * addr_size;
15059 while (--count > 0)
15060 {
15061 bfd_vma start, end, file_ofs;
15062
15063 if (filenames == descend)
15064 {
15065 printf (_(" Malformed note - filenames end too early\n"));
15066 return 0;
15067 }
15068
15069 start = byte_get (descdata, addr_size);
15070 descdata += addr_size;
15071 end = byte_get (descdata, addr_size);
15072 descdata += addr_size;
15073 file_ofs = byte_get (descdata, addr_size);
15074 descdata += addr_size;
15075
15076 printf (" ");
15077 print_vma (start, FULL_HEX);
15078 printf (" ");
15079 print_vma (end, FULL_HEX);
15080 printf (" ");
15081 print_vma (file_ofs, FULL_HEX);
15082 printf ("\n %s\n", filenames);
15083
15084 filenames += 1 + strlen ((char *) filenames);
15085 }
15086
15087 return 1;
15088}
15089
1118d252
RM		 15090static const char *
15091get_gnu_elf_note_type (unsigned e_type)
15092{
15093 static char buff[64];
15094
15095 switch (e_type)
15096 {
15097 case NT_GNU_ABI_TAG:
15098 return _("NT_GNU_ABI_TAG (ABI version tag)");
15099 case NT_GNU_HWCAP:
15100 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15101 case NT_GNU_BUILD_ID:
15102 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15103 case NT_GNU_GOLD_VERSION:
15104 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15105 default:
15106 break;
15107 }
15108
15109 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15110 return buff;
15111}
15112
664f90a3
TT		 15113static int
15114print_gnu_note (Elf_Internal_Note *pnote)
15115{
15116 switch (pnote->type)
15117 {
15118 case NT_GNU_BUILD_ID:
15119 {
15120 unsigned long i;
15121
15122 printf (_(" Build ID: "));
15123 for (i = 0; i < pnote->descsz; ++i)
15124 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15125 printf ("\n");
664f90a3
TT		 15126 }
15127 break;
15128
15129 case NT_GNU_ABI_TAG:
15130 {
15131 unsigned long os, major, minor, subminor;
15132 const char *osname;
15133
3102e897
NC		 15134 /* PR 17531: file: 030-599401-0.004. */
15135 if (pnote->descsz < 16)
15136 {
15137 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15138 break;
15139 }
15140
664f90a3
TT		 15141 os = byte_get ((unsigned char *) pnote->descdata, 4);
15142 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15143 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15144 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15145
15146 switch (os)
15147 {
15148 case GNU_ABI_TAG_LINUX:
15149 osname = "Linux";
15150 break;
15151 case GNU_ABI_TAG_HURD:
15152 osname = "Hurd";
15153 break;
15154 case GNU_ABI_TAG_SOLARIS:
15155 osname = "Solaris";
15156 break;
15157 case GNU_ABI_TAG_FREEBSD:
15158 osname = "FreeBSD";
15159 break;
15160 case GNU_ABI_TAG_NETBSD:
15161 osname = "NetBSD";
15162 break;
14ae95f2
RM		 15163 case GNU_ABI_TAG_SYLLABLE:
15164 osname = "Syllable";
15165 break;
15166 case GNU_ABI_TAG_NACL:
15167 osname = "NaCl";
15168 break;
664f90a3
TT		 15169 default:
15170 osname = "Unknown";
15171 break;
15172 }
15173
15174 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15175 major, minor, subminor);
15176 }
15177 break;
926c5385
CC		 15178
15179 case NT_GNU_GOLD_VERSION:
15180 {
15181 unsigned long i;
15182
15183 printf (_(" Version: "));
15184 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15185 printf ("%c", pnote->descdata[i]);
15186 printf ("\n");
15187 }
15188 break;
664f90a3
TT		 15189 }
15190
15191 return 1;
15192}
15193
685080f2
NC		 15194static const char *
15195get_v850_elf_note_type (enum v850_notes n_type)
15196{
15197 static char buff[64];
15198
15199 switch (n_type)
15200 {
15201 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15202 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15203 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15204 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15205 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15206 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15207 default:
15208 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15209 return buff;
15210 }
15211}
15212
15213static int
15214print_v850_note (Elf_Internal_Note * pnote)
15215{
15216 unsigned int val;
15217
15218 if (pnote->descsz != 4)
15219 return 0;
15220 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15221
15222 if (val == 0)
15223 {
15224 printf (_("not set\n"));
15225 return 1;
15226 }
15227
15228 switch (pnote->type)
15229 {
15230 case V850_NOTE_ALIGNMENT:
15231 switch (val)
15232 {
15233 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15234 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15235 }
15236 break;
14ae95f2 15237
685080f2
NC		 15238 case V850_NOTE_DATA_SIZE:
15239 switch (val)
15240 {
15241 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15242 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15243 }
15244 break;
14ae95f2 15245
685080f2
NC		 15246 case V850_NOTE_FPU_INFO:
15247 switch (val)
15248 {
15249 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15250 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15251 }
15252 break;
14ae95f2 15253
685080f2
NC		 15254 case V850_NOTE_MMU_INFO:
15255 case V850_NOTE_CACHE_INFO:
15256 case V850_NOTE_SIMD_INFO:
15257 if (val == EF_RH850_SIMD)
15258 {
15259 printf (_("yes\n"));
15260 return 1;
15261 }
15262 break;
15263
15264 default:
15265 /* An 'unknown note type' message will already have been displayed. */
15266 break;
15267 }
15268
15269 printf (_("unknown value: %x\n"), val);
15270 return 0;
15271}
15272
9437c45b 15273static const char *
d3ba0551 15274get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15275{
15276 static char buff[64];
15277
b4db1224 15278 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15279 {
15280 /* NetBSD core "procinfo" structure. */
15281 return _("NetBSD procinfo structure");
15282 }
15283
15284 /* As of Jan 2002 there are no other machine-independent notes
15285 defined for NetBSD core files. If the note type is less
15286 than the start of the machine-dependent note types, we don't
15287 understand it. */
15288
b4db1224 15289 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15290 {
e9e44622 15291 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15292 return buff;
15293 }
15294
15295 switch (elf_header.e_machine)
15296 {
15297 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15298 and PT_GETFPREGS == mach+2. */
15299
15300 case EM_OLD_ALPHA:
15301 case EM_ALPHA:
15302 case EM_SPARC:
15303 case EM_SPARC32PLUS:
15304 case EM_SPARCV9:
15305 switch (e_type)
15306 {
2b692964 15307 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15308 return _("PT_GETREGS (reg structure)");
2b692964 15309 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15310 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15311 default:
15312 break;
15313 }
15314 break;
15315
15316 /* On all other arch's, PT_GETREGS == mach+1 and
15317 PT_GETFPREGS == mach+3. */
15318 default:
15319 switch (e_type)
15320 {
2b692964 15321 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15322 return _("PT_GETREGS (reg structure)");
2b692964 15323 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15324 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15325 default:
15326 break;
15327 }
15328 }
15329
9cf03b7e 15330 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15331 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15332 return buff;
15333}
15334
70616151
TT		 15335static const char *
15336get_stapsdt_note_type (unsigned e_type)
15337{
15338 static char buff[64];
15339
15340 switch (e_type)
15341 {
15342 case NT_STAPSDT:
15343 return _("NT_STAPSDT (SystemTap probe descriptors)");
15344
15345 default:
15346 break;
15347 }
15348
15349 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15350 return buff;
15351}
15352
c6a9fc58
TT		 15353static int
15354print_stapsdt_note (Elf_Internal_Note *pnote)
15355{
15356 int addr_size = is_32bit_elf ? 4 : 8;
15357 char *data = pnote->descdata;
15358 char *data_end = pnote->descdata + pnote->descsz;
15359 bfd_vma pc, base_addr, semaphore;
15360 char *provider, *probe, *arg_fmt;
15361
15362 pc = byte_get ((unsigned char *) data, addr_size);
15363 data += addr_size;
15364 base_addr = byte_get ((unsigned char *) data, addr_size);
15365 data += addr_size;
15366 semaphore = byte_get ((unsigned char *) data, addr_size);
15367 data += addr_size;
15368
15369 provider = data;
15370 data += strlen (data) + 1;
15371 probe = data;
15372 data += strlen (data) + 1;
15373 arg_fmt = data;
15374 data += strlen (data) + 1;
15375
15376 printf (_(" Provider: %s\n"), provider);
15377 printf (_(" Name: %s\n"), probe);
15378 printf (_(" Location: "));
15379 print_vma (pc, FULL_HEX);
15380 printf (_(", Base: "));
15381 print_vma (base_addr, FULL_HEX);
15382 printf (_(", Semaphore: "));
15383 print_vma (semaphore, FULL_HEX);
9cf03b7e 15384 printf ("\n");
c6a9fc58
TT		 15385 printf (_(" Arguments: %s\n"), arg_fmt);
15386
15387 return data == data_end;
15388}
15389
00e98fc7
TG		 15390static const char *
15391get_ia64_vms_note_type (unsigned e_type)
15392{
15393 static char buff[64];
15394
15395 switch (e_type)
15396 {
15397 case NT_VMS_MHD:
15398 return _("NT_VMS_MHD (module header)");
15399 case NT_VMS_LNM:
15400 return _("NT_VMS_LNM (language name)");
15401 case NT_VMS_SRC:
15402 return _("NT_VMS_SRC (source files)");
15403 case NT_VMS_TITLE:
9cf03b7e 15404 return "NT_VMS_TITLE";
00e98fc7
TG		 15405 case NT_VMS_EIDC:
15406 return _("NT_VMS_EIDC (consistency check)");
15407 case NT_VMS_FPMODE:
15408 return _("NT_VMS_FPMODE (FP mode)");
15409 case NT_VMS_LINKTIME:
9cf03b7e 15410 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15411 case NT_VMS_IMGNAM:
15412 return _("NT_VMS_IMGNAM (image name)");
15413 case NT_VMS_IMGID:
15414 return _("NT_VMS_IMGID (image id)");
15415 case NT_VMS_LINKID:
15416 return _("NT_VMS_LINKID (link id)");
15417 case NT_VMS_IMGBID:
15418 return _("NT_VMS_IMGBID (build id)");
15419 case NT_VMS_GSTNAM:
15420 return _("NT_VMS_GSTNAM (sym table name)");
15421 case NT_VMS_ORIG_DYN:
9cf03b7e 15422 return "NT_VMS_ORIG_DYN";
00e98fc7 15423 case NT_VMS_PATCHTIME:
9cf03b7e 15424 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15425 default:
15426 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15427 return buff;
15428 }
15429}
15430
15431static int
15432print_ia64_vms_note (Elf_Internal_Note * pnote)
15433{
15434 switch (pnote->type)
15435 {
15436 case NT_VMS_MHD:
15437 if (pnote->descsz > 36)
15438 {
15439 size_t l = strlen (pnote->descdata + 34);
15440 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15441 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15442 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15443 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15444 }
15445 else
15446 printf (_(" Invalid size\n"));
15447 break;
15448 case NT_VMS_LNM:
15449 printf (_(" Language: %s\n"), pnote->descdata);
15450 break;
15451#ifdef BFD64
15452 case NT_VMS_FPMODE:
9cf03b7e 15453 printf (_(" Floating Point mode: "));
4a5cb34f 15454 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15455 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15456 break;
15457 case NT_VMS_LINKTIME:
15458 printf (_(" Link time: "));
15459 print_vms_time
15460 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15461 printf ("\n");
15462 break;
15463 case NT_VMS_PATCHTIME:
15464 printf (_(" Patch time: "));
15465 print_vms_time
15466 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15467 printf ("\n");
15468 break;
15469 case NT_VMS_ORIG_DYN:
15470 printf (_(" Major id: %u, minor id: %u\n"),
15471 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15472 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15473 printf (_(" Last modified : "));
00e98fc7
TG		 15474 print_vms_time
15475 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15476 printf (_("\n Link flags : "));
4a5cb34f 15477 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15478 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15479 printf (_(" Header flags: 0x%08x\n"),
948f632f 15480 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15481 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15482 break;
15483#endif
15484 case NT_VMS_IMGNAM:
15485 printf (_(" Image name: %s\n"), pnote->descdata);
15486 break;
15487 case NT_VMS_GSTNAM:
15488 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15489 break;
15490 case NT_VMS_IMGID:
15491 printf (_(" Image id: %s\n"), pnote->descdata);
15492 break;
15493 case NT_VMS_LINKID:
15494 printf (_(" Linker id: %s\n"), pnote->descdata);
15495 break;
15496 default:
15497 break;
15498 }
15499 return 1;
15500}
15501
6d118b09
NC		 15502/* Note that by the ELF standard, the name field is already null byte
15503 terminated, and namesz includes the terminating null byte.
15504 I.E. the value of namesz for the name "FSF" is 4.
15505
e3c8793a 15506 If the value of namesz is zero, there is no name present. */
779fe533 15507static int
2cf0635d 15508process_note (Elf_Internal_Note * pnote)
779fe533 15509{
2cf0635d
NC		 15510 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15511 const char * nt;
9437c45b
JT		 15512
15513 if (pnote->namesz == 0)
1ec5cd37
NC		 15514 /* If there is no note name, then use the default set of
15515 note type strings. */
15516 nt = get_note_type (pnote->type);
15517
1118d252
RM		 15518 else if (const_strneq (pnote->namedata, "GNU"))
15519 /* GNU-specific object file notes. */
15520 nt = get_gnu_elf_note_type (pnote->type);
15521
0112cd26 15522 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15523 /* NetBSD-specific core file notes. */
15524 nt = get_netbsd_elfcore_note_type (pnote->type);
15525
b15fa79e
AM		 15526 else if (strneq (pnote->namedata, "SPU/", 4))
15527 {
15528 /* SPU-specific core file notes. */
15529 nt = pnote->namedata + 4;
15530 name = "SPU";
15531 }
15532
00e98fc7
TG		 15533 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15534 /* VMS/ia64-specific file notes. */
15535 nt = get_ia64_vms_note_type (pnote->type);
15536
70616151
TT		 15537 else if (const_strneq (pnote->namedata, "stapsdt"))
15538 nt = get_stapsdt_note_type (pnote->type);
15539
9437c45b 15540 else
1ec5cd37
NC		 15541 /* Don't recognize this note name; just use the default set of
15542 note type strings. */
00e98fc7 15543 nt = get_note_type (pnote->type);
9437c45b 15544
2aee03ae 15545 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15546
15547 if (const_strneq (pnote->namedata, "IPF/VMS"))
15548 return print_ia64_vms_note (pnote);
664f90a3
TT		 15549 else if (const_strneq (pnote->namedata, "GNU"))
15550 return print_gnu_note (pnote);
c6a9fc58
TT		 15551 else if (const_strneq (pnote->namedata, "stapsdt"))
15552 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15553 else if (const_strneq (pnote->namedata, "CORE"))
15554 return print_core_note (pnote);
00e98fc7
TG		 15555 else
15556 return 1;
779fe533
NC		 15557}
15558
6d118b09 15559
779fe533 15560static int
2cf0635d 15561process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15562{
2cf0635d
NC		 15563 Elf_External_Note * pnotes;
15564 Elf_External_Note * external;
c8071705 15565 char * end;
b34976b6 15566 int res = 1;
103f02d3 15567
779fe533
NC		 15568 if (length <= 0)
15569 return 0;
103f02d3 15570
3f5e193b 15571 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15572 _("notes"));
dd24e3da 15573 if (pnotes == NULL)
a6e9f9df 15574 return 0;
779fe533 15575
103f02d3 15576 external = pnotes;
103f02d3 15577
9dd3a467 15578 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15579 (unsigned long) offset, (unsigned long) length);
2aee03ae 15580 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15581
c8071705
NC		 15582 end = (char *) pnotes + length;
15583 while ((char *) external < end)
779fe533 15584 {
b34976b6 15585 Elf_Internal_Note inote;
15b42fb0
AM		 15586 size_t min_notesz;
15587 char *next;
2cf0635d 15588 char * temp = NULL;
c8071705 15589 size_t data_remaining = end - (char *) external;
6d118b09 15590
00e98fc7 15591 if (!is_ia64_vms ())
15b42fb0 15592 {
9dd3a467
NC		 15593 /* PR binutils/15191
15594 Make sure that there is enough data to read. */
15b42fb0
AM		 15595 min_notesz = offsetof (Elf_External_Note, name);
15596 if (data_remaining < min_notesz)
9dd3a467
NC		 15597 {
15598 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15599 (int) data_remaining);
15600 break;
15601 }
15b42fb0
AM		 15602 inote.type = BYTE_GET (external->type);
15603 inote.namesz = BYTE_GET (external->namesz);
15604 inote.namedata = external->name;
15605 inote.descsz = BYTE_GET (external->descsz);
15606 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15607 /* PR 17531: file: 3443835e. */
c8071705 15608 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15609 {
15610 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15611 inote.descdata = inote.namedata;
15612 inote.namesz = 0;
15613 }
14ae95f2 15614
15b42fb0
AM		 15615 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15616 next = inote.descdata + align_power (inote.descsz, 2);
15617 }
00e98fc7 15618 else
15b42fb0
AM		 15619 {
15620 Elf64_External_VMS_Note *vms_external;
00e98fc7 15621
9dd3a467
NC		 15622 /* PR binutils/15191
15623 Make sure that there is enough data to read. */
15b42fb0
AM		 15624 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15625 if (data_remaining < min_notesz)
9dd3a467
NC		 15626 {
15627 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15628 (int) data_remaining);
15629 break;
15630 }
3e55a963 15631
15b42fb0
AM		 15632 vms_external = (Elf64_External_VMS_Note *) external;
15633 inote.type = BYTE_GET (vms_external->type);
15634 inote.namesz = BYTE_GET (vms_external->namesz);
15635 inote.namedata = vms_external->name;
15636 inote.descsz = BYTE_GET (vms_external->descsz);
15637 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15638 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15639 next = inote.descdata + align_power (inote.descsz, 3);
15640 }
15641
15642 if (inote.descdata < (char *) external + min_notesz
15643 || next < (char *) external + min_notesz
5d921cbd
NC		 15644 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15645 || inote.namedata + inote.namesz < inote.namedata
15646 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15647 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15648 {
15b42fb0 15649 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15650 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15651 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15652 inote.type, inote.namesz, inote.descsz);
15653 break;
15654 }
15655
15b42fb0 15656 external = (Elf_External_Note *) next;
dd24e3da 15657
6d118b09
NC		 15658 /* Verify that name is null terminated. It appears that at least
15659 one version of Linux (RedHat 6.0) generates corefiles that don't
15660 comply with the ELF spec by failing to include the null byte in
15661 namesz. */
8b971f9f 15662 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15663 {
3f5e193b 15664 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15665 if (temp == NULL)
15666 {
8b73c356 15667 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15668 res = 0;
15669 break;
15670 }
76da6bbe 15671
6d118b09
NC		 15672 strncpy (temp, inote.namedata, inote.namesz);
15673 temp[inote.namesz] = 0;
76da6bbe 15674
6d118b09
NC		 15675 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15676 inote.namedata = temp;
15677 }
15678
15679 res &= process_note (& inote);
103f02d3 15680
6d118b09
NC		 15681 if (temp != NULL)
15682 {
15683 free (temp);
15684 temp = NULL;
15685 }
779fe533
NC		 15686 }
15687
15688 free (pnotes);
103f02d3 15689
779fe533
NC		 15690 return res;
15691}
15692
15693static int
2cf0635d 15694process_corefile_note_segments (FILE * file)
779fe533 15695{
2cf0635d 15696 Elf_Internal_Phdr * segment;
b34976b6
AM		 15697 unsigned int i;
15698 int res = 1;
103f02d3 15699
d93f0186 15700 if (! get_program_headers (file))
779fe533 15701 return 0;
103f02d3 15702
779fe533
NC		 15703 for (i = 0, segment = program_headers;
15704 i < elf_header.e_phnum;
b34976b6 15705 i++, segment++)
779fe533
NC		 15706 {
15707 if (segment->p_type == PT_NOTE)
103f02d3 15708 res &= process_corefile_note_segment (file,
30800947
NC		 15709 (bfd_vma) segment->p_offset,
15710 (bfd_vma) segment->p_filesz);
779fe533 15711 }
103f02d3 15712
779fe533
NC		 15713 return res;
15714}
15715
685080f2
NC		 15716static int
15717process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15718{
15719 Elf_External_Note * pnotes;
15720 Elf_External_Note * external;
c8071705 15721 char * end;
685080f2
NC		 15722 int res = 1;
15723
15724 if (length <= 0)
15725 return 0;
15726
15727 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15728 _("v850 notes"));
15729 if (pnotes == NULL)
15730 return 0;
15731
15732 external = pnotes;
c8071705 15733 end = (char*) pnotes + length;
685080f2
NC		 15734
15735 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15736 (unsigned long) offset, (unsigned long) length);
15737
c8071705 15738 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15739 {
15740 Elf_External_Note * next;
15741 Elf_Internal_Note inote;
15742
15743 inote.type = BYTE_GET (external->type);
15744 inote.namesz = BYTE_GET (external->namesz);
15745 inote.namedata = external->name;
15746 inote.descsz = BYTE_GET (external->descsz);
15747 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15748 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15749
c8071705
NC		 15750 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15751 {
15752 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15753 inote.descdata = inote.namedata;
15754 inote.namesz = 0;
15755 }
15756
685080f2
NC		 15757 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15758
c8071705 15759 if ( ((char *) next > end)
685080f2
NC		 15760 || ((char *) next < (char *) pnotes))
15761 {
15762 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15763 (unsigned long) ((char *) external - (char *) pnotes));
15764 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15765 inote.type, inote.namesz, inote.descsz);
15766 break;
15767 }
15768
15769 external = next;
15770
15771 /* Prevent out-of-bounds indexing. */
c8071705 15772 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15773 || inote.namedata + inote.namesz < inote.namedata)
15774 {
15775 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15776 (unsigned long) ((char *) external - (char *) pnotes));
15777 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15778 inote.type, inote.namesz, inote.descsz);
15779 break;
15780 }
15781
15782 printf (" %s: ", get_v850_elf_note_type (inote.type));
15783
15784 if (! print_v850_note (& inote))
15785 {
15786 res = 0;
15787 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15788 inote.namesz, inote.descsz);
15789 }
15790 }
15791
15792 free (pnotes);
15793
15794 return res;
15795}
15796
779fe533 15797static int
2cf0635d 15798process_note_sections (FILE * file)
1ec5cd37 15799{
2cf0635d 15800 Elf_Internal_Shdr * section;
1ec5cd37 15801 unsigned long i;
df565f32 15802 int n = 0;
1ec5cd37
NC		 15803 int res = 1;
15804
15805 for (i = 0, section = section_headers;
fa1908fd 15806 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15807 i++, section++)
685080f2
NC		 15808 {
15809 if (section->sh_type == SHT_NOTE)
15810 {
15811 res &= process_corefile_note_segment (file,
15812 (bfd_vma) section->sh_offset,
15813 (bfd_vma) section->sh_size);
15814 n++;
15815 }
15816
15817 if (( elf_header.e_machine == EM_V800
15818 || elf_header.e_machine == EM_V850
15819 || elf_header.e_machine == EM_CYGNUS_V850)
15820 && section->sh_type == SHT_RENESAS_INFO)
15821 {
15822 res &= process_v850_notes (file,
15823 (bfd_vma) section->sh_offset,
15824 (bfd_vma) section->sh_size);
15825 n++;
15826 }
15827 }
df565f32
NC		 15828
15829 if (n == 0)
15830 /* Try processing NOTE segments instead. */
15831 return process_corefile_note_segments (file);
1ec5cd37
NC		 15832
15833 return res;
15834}
15835
15836static int
2cf0635d 15837process_notes (FILE * file)
779fe533
NC		 15838{
15839 /* If we have not been asked to display the notes then do nothing. */
15840 if (! do_notes)
15841 return 1;
103f02d3 15842
779fe533 15843 if (elf_header.e_type != ET_CORE)
1ec5cd37 15844 return process_note_sections (file);
103f02d3 15845
779fe533 15846 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15847 if (elf_header.e_phnum > 0)
15848 return process_corefile_note_segments (file);
779fe533 15849
1ec5cd37
NC		 15850 printf (_("No note segments present in the core file.\n"));
15851 return 1;
779fe533
NC		 15852}
15853
252b5132 15854static int
2cf0635d 15855process_arch_specific (FILE * file)
252b5132 15856{
a952a375
NC		 15857 if (! do_arch)
15858 return 1;
15859
252b5132
RH		 15860 switch (elf_header.e_machine)
15861 {
11c1ff18
PB		 15862 case EM_ARM:
15863 return process_arm_specific (file);
252b5132 15864 case EM_MIPS:
4fe85591 15865 case EM_MIPS_RS3_LE:
252b5132
RH		 15866 return process_mips_specific (file);
15867 break;
35c08157
KLC		 15868 case EM_NDS32:
15869 return process_nds32_specific (file);
15870 break;
34c8bcba
JM		 15871 case EM_PPC:
15872 return process_power_specific (file);
15873 break;
643f7afb
AK		 15874 case EM_S390:
15875 case EM_S390_OLD:
15876 return process_s390_specific (file);
15877 break;
9e8c70f9
DM		 15878 case EM_SPARC:
15879 case EM_SPARC32PLUS:
15880 case EM_SPARCV9:
15881 return process_sparc_specific (file);
15882 break;
59e6276b
JM		 15883 case EM_TI_C6000:
15884 return process_tic6x_specific (file);
15885 break;
13761a11
NC		 15886 case EM_MSP430:
15887 return process_msp430x_specific (file);
252b5132
RH		 15888 default:
15889 break;
15890 }
15891 return 1;
15892}
15893
15894static int
2cf0635d 15895get_file_header (FILE * file)
252b5132 15896{
9ea033b2
NC		 15897 /* Read in the identity array. */
15898 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15899 return 0;
15900
9ea033b2 15901 /* Determine how to read the rest of the header. */
b34976b6 15902 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15903 {
15904 default: /* fall through */
15905 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15906 case ELFDATA2LSB:
15907 byte_get = byte_get_little_endian;
15908 byte_put = byte_put_little_endian;
15909 break;
15910 case ELFDATA2MSB:
15911 byte_get = byte_get_big_endian;
15912 byte_put = byte_put_big_endian;
15913 break;
9ea033b2
NC		 15914 }
15915
15916 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15917 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15918
15919 /* Read in the rest of the header. */
15920 if (is_32bit_elf)
15921 {
15922 Elf32_External_Ehdr ehdr32;
252b5132 15923
9ea033b2
NC		 15924 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15925 return 0;
103f02d3 15926
9ea033b2
NC		 15927 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15928 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15929 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15930 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15931 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15932 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15933 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15934 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15935 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15936 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15937 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15938 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15939 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15940 }
252b5132 15941 else
9ea033b2
NC		 15942 {
15943 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15944
15945 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15946 we will not be able to cope with the 64bit data found in
15947 64 ELF files. Detect this now and abort before we start
50c2245b 15948 overwriting things. */
a952a375
NC		 15949 if (sizeof (bfd_vma) < 8)
15950 {
e3c8793a
NC		 15951 error (_("This instance of readelf has been built without support for a\n\
1595264 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15953 return 0;
15954 }
103f02d3 15955
9ea033b2
NC		 15956 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15957 return 0;
103f02d3 15958
9ea033b2
NC		 15959 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15960 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15961 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15962 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15963 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15964 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15965 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15966 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15967 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15968 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15969 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15970 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15971 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15972 }
252b5132 15973
7ece0d85
JJ		 15974 if (elf_header.e_shoff)
15975 {
15976 /* There may be some extensions in the first section header. Don't
15977 bomb if we can't read it. */
15978 if (is_32bit_elf)
049b0c3a 15979 get_32bit_section_headers (file, TRUE);
7ece0d85 15980 else
049b0c3a 15981 get_64bit_section_headers (file, TRUE);
7ece0d85 15982 }
560f3c1c 15983
252b5132
RH		 15984 return 1;
15985}
15986
fb52b2f4
NC		 15987/* Process one ELF object file according to the command line options.
15988 This file may actually be stored in an archive. The file is
15989 positioned at the start of the ELF object. */
15990
ff78d6d6 15991static int
2cf0635d 15992process_object (char * file_name, FILE * file)
252b5132 15993{
252b5132
RH		 15994 unsigned int i;
15995
252b5132
RH		 15996 if (! get_file_header (file))
15997 {
15998 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15999 return 1;
252b5132
RH		 16000 }
16001
16002 /* Initialise per file variables. */
60bca95a 16003 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16004 version_info[i] = 0;
16005
60bca95a 16006 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16007 dynamic_info[i] = 0;
5115b233 16008 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16009
16010 /* Process the file. */
16011 if (show_name)
16012 printf (_("\nFile: %s\n"), file_name);
16013
18bd398b
NC		 16014 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16015 Note we do this even if cmdline_dump_sects is empty because we
16016 must make sure that the dump_sets array is zeroed out before each
16017 object file is processed. */
16018 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16019 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16020
16021 if (num_cmdline_dump_sects > 0)
16022 {
16023 if (num_dump_sects == 0)
16024 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16025 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16026
16027 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16028 memcpy (dump_sects, cmdline_dump_sects,
16029 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16030 }
d70c5fc7 16031
252b5132 16032 if (! process_file_header ())
fb52b2f4 16033 return 1;
252b5132 16034
d1f5c6e3 16035 if (! process_section_headers (file))
2f62977e 16036 {
d1f5c6e3
L		 16037 /* Without loaded section headers we cannot process lots of
16038 things. */
2f62977e 16039 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16040
2f62977e 16041 if (! do_using_dynamic)
2c610e4b 16042 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16043 }
252b5132 16044
d1f5c6e3
L		 16045 if (! process_section_groups (file))
16046 {
16047 /* Without loaded section groups we cannot process unwind. */
16048 do_unwind = 0;
16049 }
16050
2f62977e 16051 if (process_program_headers (file))
b2d38a17 16052 process_dynamic_section (file);
252b5132
RH		 16053
16054 process_relocs (file);
16055
4d6ed7c8
NC		 16056 process_unwind (file);
16057
252b5132
RH		 16058 process_symbol_table (file);
16059
16060 process_syminfo (file);
16061
16062 process_version_sections (file);
16063
16064 process_section_contents (file);
f5842774 16065
1ec5cd37 16066 process_notes (file);
103f02d3 16067
047b2264
JJ		 16068 process_gnu_liblist (file);
16069
252b5132
RH		 16070 process_arch_specific (file);
16071
d93f0186
NC		 16072 if (program_headers)
16073 {
16074 free (program_headers);
16075 program_headers = NULL;
16076 }
16077
252b5132
RH		 16078 if (section_headers)
16079 {
16080 free (section_headers);
16081 section_headers = NULL;
16082 }
16083
16084 if (string_table)
16085 {
16086 free (string_table);
16087 string_table = NULL;
d40ac9bd 16088 string_table_length = 0;
252b5132
RH		 16089 }
16090
16091 if (dynamic_strings)
16092 {
16093 free (dynamic_strings);
16094 dynamic_strings = NULL;
d79b3d50 16095 dynamic_strings_length = 0;
252b5132
RH		 16096 }
16097
16098 if (dynamic_symbols)
16099 {
16100 free (dynamic_symbols);
16101 dynamic_symbols = NULL;
19936277 16102 num_dynamic_syms = 0;
252b5132
RH		 16103 }
16104
16105 if (dynamic_syminfo)
16106 {
16107 free (dynamic_syminfo);
16108 dynamic_syminfo = NULL;
16109 }
ff78d6d6 16110
293c573e
MR		 16111 if (dynamic_section)
16112 {
16113 free (dynamic_section);
16114 dynamic_section = NULL;
16115 }
16116
e4b17d5c
L		 16117 if (section_headers_groups)
16118 {
16119 free (section_headers_groups);
16120 section_headers_groups = NULL;
16121 }
16122
16123 if (section_groups)
16124 {
2cf0635d
NC		 16125 struct group_list * g;
16126 struct group_list * next;
e4b17d5c
L		 16127
16128 for (i = 0; i < group_count; i++)
16129 {
16130 for (g = section_groups [i].root; g != NULL; g = next)
16131 {
16132 next = g->next;
16133 free (g);
16134 }
16135 }
16136
16137 free (section_groups);
16138 section_groups = NULL;
16139 }
16140
19e6b90e 16141 free_debug_memory ();
18bd398b 16142
ff78d6d6 16143 return 0;
252b5132
RH		 16144}
16145
2cf0635d
NC		 16146/* Process an ELF archive.
16147 On entry the file is positioned just after the ARMAG string. */
16148
16149static int
16150process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16151{
16152 struct archive_info arch;
16153 struct archive_info nested_arch;
16154 size_t got;
2cf0635d
NC		 16155 int ret;
16156
16157 show_name = 1;
16158
16159 /* The ARCH structure is used to hold information about this archive. */
16160 arch.file_name = NULL;
16161 arch.file = NULL;
16162 arch.index_array = NULL;
16163 arch.sym_table = NULL;
16164 arch.longnames = NULL;
16165
16166 /* The NESTED_ARCH structure is used as a single-item cache of information
16167 about a nested archive (when members of a thin archive reside within
16168 another regular archive file). */
16169 nested_arch.file_name = NULL;
16170 nested_arch.file = NULL;
16171 nested_arch.index_array = NULL;
16172 nested_arch.sym_table = NULL;
16173 nested_arch.longnames = NULL;
16174
16175 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16176 {
16177 ret = 1;
16178 goto out;
4145f1d5 16179 }
fb52b2f4 16180
4145f1d5
NC		 16181 if (do_archive_index)
16182 {
2cf0635d 16183 if (arch.sym_table == NULL)
4145f1d5
NC		 16184 error (_("%s: unable to dump the index as none was found\n"), file_name);
16185 else
16186 {
591f7597 16187 unsigned long i, l;
4145f1d5
NC		 16188 unsigned long current_pos;
16189
591f7597
NC		 16190 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16191 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16192 current_pos = ftell (file);
16193
2cf0635d 16194 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16195 {
2cf0635d
NC		 16196 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16197 {
16198 char * member_name;
4145f1d5 16199
2cf0635d
NC		 16200 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16201
16202 if (member_name != NULL)
16203 {
16204 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16205
16206 if (qualified_name != NULL)
16207 {
c2a7d3f5
NC		 16208 printf (_("Contents of binary %s at offset "), qualified_name);
16209 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16210 putchar ('\n');
2cf0635d
NC		 16211 free (qualified_name);
16212 }
4145f1d5
NC		 16213 }
16214 }
2cf0635d
NC		 16215
16216 if (l >= arch.sym_size)
4145f1d5
NC		 16217 {
16218 error (_("%s: end of the symbol table reached before the end of the index\n"),
16219 file_name);
cb8f3167 16220 break;
4145f1d5 16221 }
591f7597
NC		 16222 /* PR 17531: file: 0b6630b2. */
16223 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16224 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16225 }
16226
c2a7d3f5
NC		 16227 if (arch.uses_64bit_indicies)
16228 l = (l + 7) & ~ 7;
16229 else
16230 l += l & 1;
16231
2cf0635d 16232 if (l < arch.sym_size)
c2a7d3f5
NC		 16233 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16234 file_name, arch.sym_size - l);
4145f1d5 16235
4145f1d5
NC		 16236 if (fseek (file, current_pos, SEEK_SET) != 0)
16237 {
16238 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16239 ret = 1;
16240 goto out;
4145f1d5 16241 }
fb52b2f4 16242 }
4145f1d5
NC		 16243
16244 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16245 && !do_segments && !do_header && !do_dump && !do_version
16246 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16247 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16248 {
16249 ret = 0; /* Archive index only. */
16250 goto out;
16251 }
fb52b2f4
NC		 16252 }
16253
d989285c 16254 ret = 0;
fb52b2f4
NC		 16255
16256 while (1)
16257 {
2cf0635d
NC		 16258 char * name;
16259 size_t namelen;
16260 char * qualified_name;
16261
16262 /* Read the next archive header. */
16263 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16264 {
16265 error (_("%s: failed to seek to next archive header\n"), file_name);
16266 return 1;
16267 }
16268 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16269 if (got != sizeof arch.arhdr)
16270 {
16271 if (got == 0)
16272 break;
16273 error (_("%s: failed to read archive header\n"), file_name);
16274 ret = 1;
16275 break;
16276 }
16277 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16278 {
16279 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16280 ret = 1;
16281 break;
16282 }
16283
16284 arch.next_arhdr_offset += sizeof arch.arhdr;
16285
16286 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16287 if (archive_file_size & 01)
16288 ++archive_file_size;
16289
16290 name = get_archive_member_name (&arch, &nested_arch);
16291 if (name == NULL)
fb52b2f4 16292 {
0fd3a477 16293 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16294 ret = 1;
16295 break;
fb52b2f4 16296 }
2cf0635d 16297 namelen = strlen (name);
fb52b2f4 16298
2cf0635d
NC		 16299 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16300 if (qualified_name == NULL)
fb52b2f4 16301 {
2cf0635d 16302 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16303 ret = 1;
16304 break;
fb52b2f4
NC		 16305 }
16306
2cf0635d
NC		 16307 if (is_thin_archive && arch.nested_member_origin == 0)
16308 {
16309 /* This is a proxy for an external member of a thin archive. */
16310 FILE * member_file;
16311 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16312 if (member_file_name == NULL)
16313 {
16314 ret = 1;
16315 break;
16316 }
16317
16318 member_file = fopen (member_file_name, "rb");
16319 if (member_file == NULL)
16320 {
16321 error (_("Input file '%s' is not readable.\n"), member_file_name);
16322 free (member_file_name);
16323 ret = 1;
16324 break;
16325 }
16326
16327 archive_file_offset = arch.nested_member_origin;
16328
16329 ret |= process_object (qualified_name, member_file);
16330
16331 fclose (member_file);
16332 free (member_file_name);
16333 }
16334 else if (is_thin_archive)
16335 {
a043396b
NC		 16336 /* PR 15140: Allow for corrupt thin archives. */
16337 if (nested_arch.file == NULL)
16338 {
16339 error (_("%s: contains corrupt thin archive: %s\n"),
16340 file_name, name);
16341 ret = 1;
16342 break;
16343 }
16344
2cf0635d
NC		 16345 /* This is a proxy for a member of a nested archive. */
16346 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16347
16348 /* The nested archive file will have been opened and setup by
16349 get_archive_member_name. */
16350 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16351 {
16352 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16353 ret = 1;
16354 break;
16355 }
16356
16357 ret |= process_object (qualified_name, nested_arch.file);
16358 }
16359 else
16360 {
16361 archive_file_offset = arch.next_arhdr_offset;
16362 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16363
2cf0635d
NC		 16364 ret |= process_object (qualified_name, file);
16365 }
fb52b2f4 16366
2b52916e
L		 16367 if (dump_sects != NULL)
16368 {
16369 free (dump_sects);
16370 dump_sects = NULL;
16371 num_dump_sects = 0;
16372 }
16373
2cf0635d 16374 free (qualified_name);
fb52b2f4
NC		 16375 }
16376
4145f1d5 16377 out:
2cf0635d
NC		 16378 if (nested_arch.file != NULL)
16379 fclose (nested_arch.file);
16380 release_archive (&nested_arch);
16381 release_archive (&arch);
fb52b2f4 16382
d989285c 16383 return ret;
fb52b2f4
NC		 16384}
16385
16386static int
2cf0635d 16387process_file (char * file_name)
fb52b2f4 16388{
2cf0635d 16389 FILE * file;
fb52b2f4
NC		 16390 struct stat statbuf;
16391 char armag[SARMAG];
16392 int ret;
16393
16394 if (stat (file_name, &statbuf) < 0)
16395 {
f24ddbdd
NC		 16396 if (errno == ENOENT)
16397 error (_("'%s': No such file\n"), file_name);
16398 else
16399 error (_("Could not locate '%s'. System error message: %s\n"),
16400 file_name, strerror (errno));
16401 return 1;
16402 }
16403
16404 if (! S_ISREG (statbuf.st_mode))
16405 {
16406 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16407 return 1;
16408 }
16409
16410 file = fopen (file_name, "rb");
16411 if (file == NULL)
16412 {
f24ddbdd 16413 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16414 return 1;
16415 }
16416
16417 if (fread (armag, SARMAG, 1, file) != 1)
16418 {
4145f1d5 16419 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16420 fclose (file);
16421 return 1;
16422 }
16423
f54498b4
NC		 16424 current_file_size = (bfd_size_type) statbuf.st_size;
16425
fb52b2f4 16426 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16427 ret = process_archive (file_name, file, FALSE);
16428 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16429 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16430 else
16431 {
4145f1d5
NC		 16432 if (do_archive_index)
16433 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16434 file_name);
16435
fb52b2f4
NC		 16436 rewind (file);
16437 archive_file_size = archive_file_offset = 0;
16438 ret = process_object (file_name, file);
16439 }
16440
16441 fclose (file);
16442
f54498b4 16443 current_file_size = 0;
fb52b2f4
NC		 16444 return ret;
16445}
16446
252b5132
RH		 16447#ifdef SUPPORT_DISASSEMBLY
16448/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16449 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16450 symbols. */
252b5132
RH		 16451
16452void
2cf0635d 16453print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16454{
16455 fprintf (outfile,"0x%8.8x", addr);
16456}
16457
e3c8793a 16458/* Needed by the i386 disassembler. */
252b5132
RH		 16459void
16460db_task_printsym (unsigned int addr)
16461{
16462 print_address (addr, stderr);
16463}
16464#endif
16465
16466int
2cf0635d 16467main (int argc, char ** argv)
252b5132 16468{
ff78d6d6
L		 16469 int err;
16470
252b5132
RH		 16471#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16472 setlocale (LC_MESSAGES, "");
3882b010
L		 16473#endif
16474#if defined (HAVE_SETLOCALE)
16475 setlocale (LC_CTYPE, "");
252b5132
RH		 16476#endif
16477 bindtextdomain (PACKAGE, LOCALEDIR);
16478 textdomain (PACKAGE);
16479
869b9d07
MM		 16480 expandargv (&argc, &argv);
16481
252b5132
RH		 16482 parse_args (argc, argv);
16483
18bd398b 16484 if (num_dump_sects > 0)
59f14fc0 16485 {
18bd398b 16486 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16487 cmdline_dump_sects = (dump_type *)
16488 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16489 if (cmdline_dump_sects == NULL)
591a748a 16490 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16491 else
16492 {
09c11c86
NC		 16493 memcpy (cmdline_dump_sects, dump_sects,
16494 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16495 num_cmdline_dump_sects = num_dump_sects;
16496 }
16497 }
16498
18bd398b
NC		 16499 if (optind < (argc - 1))
16500 show_name = 1;
5656ba2c
L		 16501 else if (optind >= argc)
16502 {
16503 warn (_("Nothing to do.\n"));
16504 usage (stderr);
16505 }
18bd398b 16506
ff78d6d6 16507 err = 0;
252b5132 16508 while (optind < argc)
18bd398b 16509 err |= process_file (argv[optind++]);
252b5132
RH		 16510
16511 if (dump_sects != NULL)
16512 free (dump_sects);
59f14fc0
AS		 16513 if (cmdline_dump_sects != NULL)
16514 free (cmdline_dump_sects);
252b5132 16515
ff78d6d6 16516 return err;
252b5132 16517}
A mirror of the official binutils-gdb repository