projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix dw-2 test for 16-bit targets.
[deliverable/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 {
598aaa76 1611 bfd_signed_vma off = rels[i].r_addend;
171191ba 1612
834f871c
NC		 1613 /* PR 17531: file: 2e63226f. */
1614 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1615 printf (" + %" BFD_VMA_FMT "x", off);
1616 else if (off < 0)
598aaa76 1617 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1618 else
598aaa76 1619 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1620 }
19936277 1621 }
252b5132 1622 }
1b228002 1623 else if (is_rela)
f7a99963 1624 {
e04d7088
L		 1625 bfd_signed_vma off = rels[i].r_addend;
1626
1627 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
834f871c
NC		 1628 /* PR 17531: file: 2e63226f. */
1629 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1630 printf ("%" BFD_VMA_FMT "x", off);
1631 else if (off < 0)
e04d7088
L		 1632 printf ("-%" BFD_VMA_FMT "x", - off);
1633 else
1634 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1635 }
252b5132 1636
157c2599
NC		 1637 if (elf_header.e_machine == EM_SPARCV9
1638 && rtype != NULL
1639 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1640 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1641
252b5132 1642 putchar ('\n');
2c71103e 1643
aca88567 1644#ifdef BFD64
53c7db4b 1645 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1646 {
91d6fa6a
NC		 1647 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1648 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1649 const char * rtype2 = elf_mips_reloc_type (type2);
1650 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1651
2c71103e
NC		 1652 printf (" Type2: ");
1653
1654 if (rtype2 == NULL)
39dbeff8
AM		 1655 printf (_("unrecognized: %-7lx"),
1656 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1657 else
1658 printf ("%-17.17s", rtype2);
1659
18bd398b 1660 printf ("\n Type3: ");
2c71103e
NC		 1661
1662 if (rtype3 == NULL)
39dbeff8
AM		 1663 printf (_("unrecognized: %-7lx"),
1664 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1665 else
1666 printf ("%-17.17s", rtype3);
1667
53c7db4b 1668 putchar ('\n');
2c71103e 1669 }
aca88567 1670#endif /* BFD64 */
252b5132
RH		 1671 }
1672
c8286bd1 1673 free (rels);
252b5132
RH		 1674}
1675
1676static const char *
d3ba0551 1677get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1678{
1679 switch (type)
1680 {
1681 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1682 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1683 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1684 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1685 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1686 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1687 case DT_MIPS_MSYM: return "MIPS_MSYM";
1688 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1689 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1690 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1691 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1692 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1693 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1694 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1695 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1696 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1697 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1698 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1699 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1700 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1701 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1702 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1703 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1704 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1705 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1706 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1707 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1708 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1709 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1710 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1711 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1712 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1713 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1714 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1715 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1716 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1717 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1718 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1719 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1720 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1721 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1722 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1723 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1724 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1725 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1726 default:
1727 return NULL;
1728 }
1729}
1730
9a097730 1731static const char *
d3ba0551 1732get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1733{
1734 switch (type)
1735 {
1736 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1737 default:
1738 return NULL;
1739 }
103f02d3
UD		 1740}
1741
7490d522
AM		 1742static const char *
1743get_ppc_dynamic_type (unsigned long type)
1744{
1745 switch (type)
1746 {
a7f2871e 1747 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1748 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1749 default:
1750 return NULL;
1751 }
1752}
1753
f1cb7e17 1754static const char *
d3ba0551 1755get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1756{
1757 switch (type)
1758 {
a7f2871e
AM		 1759 case DT_PPC64_GLINK: return "PPC64_GLINK";
1760 case DT_PPC64_OPD: return "PPC64_OPD";
1761 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1762 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1763 default:
1764 return NULL;
1765 }
1766}
1767
103f02d3 1768static const char *
d3ba0551 1769get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1770{
1771 switch (type)
1772 {
1773 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1774 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1775 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1776 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1777 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1778 case DT_HP_PREINIT: return "HP_PREINIT";
1779 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1780 case DT_HP_NEEDED: return "HP_NEEDED";
1781 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1782 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1783 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1784 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1785 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1786 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1787 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1788 case DT_HP_FILTERED: return "HP_FILTERED";
1789 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1790 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1791 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1792 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1793 case DT_PLT: return "PLT";
1794 case DT_PLT_SIZE: return "PLT_SIZE";
1795 case DT_DLT: return "DLT";
1796 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1797 default:
1798 return NULL;
1799 }
1800}
9a097730 1801
ecc51f48 1802static const char *
d3ba0551 1803get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1804{
1805 switch (type)
1806 {
148b93f2
NC		 1807 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1808 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1809 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1810 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1811 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1812 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1813 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1814 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1815 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1816 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1818 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1819 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1820 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1821 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1822 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1823 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1824 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1825 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1826 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1827 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1828 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1829 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1830 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1831 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1832 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1833 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1834 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1835 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1836 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1837 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1838 default:
1839 return NULL;
1840 }
1841}
1842
fabcb361
RH		 1843static const char *
1844get_alpha_dynamic_type (unsigned long type)
1845{
1846 switch (type)
1847 {
1848 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1849 default:
1850 return NULL;
1851 }
1852}
1853
1c0d3aa6
NC		 1854static const char *
1855get_score_dynamic_type (unsigned long type)
1856{
1857 switch (type)
1858 {
1859 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1860 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1861 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1862 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1863 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1864 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1865 default:
1866 return NULL;
1867 }
1868}
1869
40b36596
JM		 1870static const char *
1871get_tic6x_dynamic_type (unsigned long type)
1872{
1873 switch (type)
1874 {
1875 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1876 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1877 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1878 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1879 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1880 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1881 default:
1882 return NULL;
1883 }
1884}
1c0d3aa6 1885
36591ba1
SL		 1886static const char *
1887get_nios2_dynamic_type (unsigned long type)
1888{
1889 switch (type)
1890 {
1891 case DT_NIOS2_GP: return "NIOS2_GP";
1892 default:
1893 return NULL;
1894 }
1895}
1896
252b5132 1897static const char *
d3ba0551 1898get_dynamic_type (unsigned long type)
252b5132 1899{
e9e44622 1900 static char buff[64];
252b5132
RH		 1901
1902 switch (type)
1903 {
1904 case DT_NULL: return "NULL";
1905 case DT_NEEDED: return "NEEDED";
1906 case DT_PLTRELSZ: return "PLTRELSZ";
1907 case DT_PLTGOT: return "PLTGOT";
1908 case DT_HASH: return "HASH";
1909 case DT_STRTAB: return "STRTAB";
1910 case DT_SYMTAB: return "SYMTAB";
1911 case DT_RELA: return "RELA";
1912 case DT_RELASZ: return "RELASZ";
1913 case DT_RELAENT: return "RELAENT";
1914 case DT_STRSZ: return "STRSZ";
1915 case DT_SYMENT: return "SYMENT";
1916 case DT_INIT: return "INIT";
1917 case DT_FINI: return "FINI";
1918 case DT_SONAME: return "SONAME";
1919 case DT_RPATH: return "RPATH";
1920 case DT_SYMBOLIC: return "SYMBOLIC";
1921 case DT_REL: return "REL";
1922 case DT_RELSZ: return "RELSZ";
1923 case DT_RELENT: return "RELENT";
1924 case DT_PLTREL: return "PLTREL";
1925 case DT_DEBUG: return "DEBUG";
1926 case DT_TEXTREL: return "TEXTREL";
1927 case DT_JMPREL: return "JMPREL";
1928 case DT_BIND_NOW: return "BIND_NOW";
1929 case DT_INIT_ARRAY: return "INIT_ARRAY";
1930 case DT_FINI_ARRAY: return "FINI_ARRAY";
1931 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1932 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1933 case DT_RUNPATH: return "RUNPATH";
1934 case DT_FLAGS: return "FLAGS";
2d0e6f43 1935
d1133906
NC		 1936 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1937 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1938
05107a46 1939 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1940 case DT_PLTPADSZ: return "PLTPADSZ";
1941 case DT_MOVEENT: return "MOVEENT";
1942 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1943 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1944 case DT_POSFLAG_1: return "POSFLAG_1";
1945 case DT_SYMINSZ: return "SYMINSZ";
1946 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1947
252b5132 1948 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1949 case DT_CONFIG: return "CONFIG";
1950 case DT_DEPAUDIT: return "DEPAUDIT";
1951 case DT_AUDIT: return "AUDIT";
1952 case DT_PLTPAD: return "PLTPAD";
1953 case DT_MOVETAB: return "MOVETAB";
252b5132 1954 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1955
252b5132 1956 case DT_VERSYM: return "VERSYM";
103f02d3 1957
67a4f2b7
AO		 1958 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1959 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1960 case DT_RELACOUNT: return "RELACOUNT";
1961 case DT_RELCOUNT: return "RELCOUNT";
1962 case DT_FLAGS_1: return "FLAGS_1";
1963 case DT_VERDEF: return "VERDEF";
1964 case DT_VERDEFNUM: return "VERDEFNUM";
1965 case DT_VERNEED: return "VERNEED";
1966 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1967
019148e4 1968 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1969 case DT_USED: return "USED";
1970 case DT_FILTER: return "FILTER";
103f02d3 1971
047b2264
JJ		 1972 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1973 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1974 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1975 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1976 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1977 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1978
252b5132
RH		 1979 default:
1980 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1981 {
2cf0635d 1982 const char * result;
103f02d3 1983
252b5132
RH		 1984 switch (elf_header.e_machine)
1985 {
1986 case EM_MIPS:
4fe85591 1987 case EM_MIPS_RS3_LE:
252b5132
RH		 1988 result = get_mips_dynamic_type (type);
1989 break;
9a097730
RH		 1990 case EM_SPARCV9:
1991 result = get_sparc64_dynamic_type (type);
1992 break;
7490d522
AM		 1993 case EM_PPC:
1994 result = get_ppc_dynamic_type (type);
1995 break;
f1cb7e17
AM		 1996 case EM_PPC64:
1997 result = get_ppc64_dynamic_type (type);
1998 break;
ecc51f48
NC		 1999 case EM_IA_64:
2000 result = get_ia64_dynamic_type (type);
2001 break;
fabcb361
RH		 2002 case EM_ALPHA:
2003 result = get_alpha_dynamic_type (type);
2004 break;
1c0d3aa6
NC		 2005 case EM_SCORE:
2006 result = get_score_dynamic_type (type);
2007 break;
40b36596
JM		 2008 case EM_TI_C6000:
2009 result = get_tic6x_dynamic_type (type);
2010 break;
36591ba1
SL		 2011 case EM_ALTERA_NIOS2:
2012 result = get_nios2_dynamic_type (type);
2013 break;
252b5132
RH		 2014 default:
2015 result = NULL;
2016 break;
2017 }
2018
2019 if (result != NULL)
2020 return result;
2021
e9e44622 2022 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2023 }
eec8f817
DA		 2024 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2025 || (elf_header.e_machine == EM_PARISC
2026 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2027 {
2cf0635d 2028 const char * result;
103f02d3
UD		 2029
2030 switch (elf_header.e_machine)
2031 {
2032 case EM_PARISC:
2033 result = get_parisc_dynamic_type (type);
2034 break;
148b93f2
NC		 2035 case EM_IA_64:
2036 result = get_ia64_dynamic_type (type);
2037 break;
103f02d3
UD		 2038 default:
2039 result = NULL;
2040 break;
2041 }
2042
2043 if (result != NULL)
2044 return result;
2045
e9e44622
JJ		 2046 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2047 type);
103f02d3 2048 }
252b5132 2049 else
e9e44622 2050 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2051
252b5132
RH		 2052 return buff;
2053 }
2054}
2055
2056static char *
d3ba0551 2057get_file_type (unsigned e_type)
252b5132 2058{
b34976b6 2059 static char buff[32];
252b5132
RH		 2060
2061 switch (e_type)
2062 {
2063 case ET_NONE: return _("NONE (None)");
2064 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2065 case ET_EXEC: return _("EXEC (Executable file)");
2066 case ET_DYN: return _("DYN (Shared object file)");
2067 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2068
2069 default:
2070 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2071 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2072 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2073 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2074 else
e9e44622 2075 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2076 return buff;
2077 }
2078}
2079
2080static char *
d3ba0551 2081get_machine_name (unsigned e_machine)
252b5132 2082{
b34976b6 2083 static char buff[64]; /* XXX */
252b5132
RH		 2084
2085 switch (e_machine)
2086 {
c45021f2 2087 case EM_NONE: return _("None");
a06ea964 2088 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2089 case EM_M32: return "WE32100";
2090 case EM_SPARC: return "Sparc";
e9f53129 2091 case EM_SPU: return "SPU";
c45021f2
NC		 2092 case EM_386: return "Intel 80386";
2093 case EM_68K: return "MC68000";
2094 case EM_88K: return "MC88000";
22abe556 2095 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2096 case EM_860: return "Intel 80860";
2097 case EM_MIPS: return "MIPS R3000";
2098 case EM_S370: return "IBM System/370";
7036c0e1 2099 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2100 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2101 case EM_PARISC: return "HPPA";
252b5132 2102 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2103 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2104 case EM_960: return "Intel 90860";
2105 case EM_PPC: return "PowerPC";
285d1771 2106 case EM_PPC64: return "PowerPC64";
c45021f2 2107 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2108 case EM_FT32: return "FTDI FT32";
c45021f2 2109 case EM_RH32: return "TRW RH32";
b34976b6 2110 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2111 case EM_ARM: return "ARM";
2112 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2113 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2114 case EM_SPARCV9: return "Sparc v9";
2115 case EM_TRICORE: return "Siemens Tricore";
584da044 2116 case EM_ARC: return "ARC";
c2dcd04e
NC		 2117 case EM_H8_300: return "Renesas H8/300";
2118 case EM_H8_300H: return "Renesas H8/300H";
2119 case EM_H8S: return "Renesas H8S";
2120 case EM_H8_500: return "Renesas H8/500";
30800947 2121 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2122 case EM_MIPS_X: return "Stanford MIPS-X";
2123 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2124 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2125 case EM_CYGNUS_D10V:
2126 case EM_D10V: return "d10v";
2127 case EM_CYGNUS_D30V:
b34976b6 2128 case EM_D30V: return "d30v";
2b0337b0 2129 case EM_CYGNUS_M32R:
26597c86 2130 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2131 case EM_CYGNUS_V850:
708e2187 2132 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2133 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2134 case EM_CYGNUS_MN10300:
2135 case EM_MN10300: return "mn10300";
2136 case EM_CYGNUS_MN10200:
2137 case EM_MN10200: return "mn10200";
5506d11a 2138 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2139 case EM_CYGNUS_FR30:
2140 case EM_FR30: return "Fujitsu FR30";
b34976b6 2141 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2142 case EM_PJ_OLD:
b34976b6 2143 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2144 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2145 case EM_PCP: return "Siemens PCP";
2146 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2147 case EM_NDR1: return "Denso NDR1 microprocesspr";
2148 case EM_STARCORE: return "Motorola Star*Core processor";
2149 case EM_ME16: return "Toyota ME16 processor";
2150 case EM_ST100: return "STMicroelectronics ST100 processor";
2151 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2152 case EM_PDSP: return "Sony DSP processor";
2153 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2154 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2155 case EM_FX66: return "Siemens FX66 microcontroller";
2156 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2157 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2158 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2159 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2160 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2161 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2162 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2163 case EM_SVX: return "Silicon Graphics SVx";
2164 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2165 case EM_VAX: return "Digital VAX";
619ed720 2166 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2167 case EM_AVR_OLD:
b34976b6 2168 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2169 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2170 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2171 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2172 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2173 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2174 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2175 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2176 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2177 case EM_L1OM: return "Intel L1OM";
7a9068fe 2178 case EM_K1OM: return "Intel K1OM";
b7498e0e 2179 case EM_S390_OLD:
b34976b6 2180 case EM_S390: return "IBM S/390";
1c0d3aa6 2181 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2182 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2183 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2184 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2185 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2186 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2187 case EM_DLX: return "OpenDLX";
1e4cf259 2188 case EM_IP2K_OLD:
b34976b6 2189 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2190 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2191 case EM_XTENSA_OLD:
2192 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2193 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2194 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2195 case EM_NS32K: return "National Semiconductor 32000 series";
2196 case EM_TPC: return "Tenor Network TPC processor";
2197 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2198 case EM_MAX: return "MAX Processor";
2199 case EM_CR: return "National Semiconductor CompactRISC";
2200 case EM_F2MC16: return "Fujitsu F2MC16";
2201 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2202 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2203 case EM_M32C_OLD:
49f58d10 2204 case EM_M32C: return "Renesas M32c";
d031aafb 2205 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2206 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2207 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2208 case EM_SEP: return "Sharp embedded microprocessor";
2209 case EM_ARCA: return "Arca RISC microprocessor";
2210 case EM_UNICORE: return "Unicore";
2211 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2212 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2213 case EM_NIOS32: return "Altera Nios";
2214 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2215 case EM_C166:
d70c5fc7 2216 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2217 case EM_M16C: return "Renesas M16C series microprocessors";
2218 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2219 case EM_CE: return "Freescale Communication Engine RISC core";
2220 case EM_TSK3000: return "Altium TSK3000 core";
2221 case EM_RS08: return "Freescale RS08 embedded processor";
2222 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2223 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2224 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2225 case EM_SE_C17: return "Seiko Epson C17 family";
2226 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2227 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2228 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2229 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2230 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2231 case EM_R32C: return "Renesas R32C series microprocessors";
2232 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2233 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2234 case EM_8051: return "Intel 8051 and variants";
2235 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2236 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2237 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2238 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2239 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2240 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2241 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2242 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2243 case EM_CR16:
f6c1a2d5 2244 case EM_MICROBLAZE:
7ba29e2a 2245 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2246 case EM_RL78: return "Renesas RL78";
c7927a3c 2247 case EM_RX: return "Renesas RX";
a3c62988 2248 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2249 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2250 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2251 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2252 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2253 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2254 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2255 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2256 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2257 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2258 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2259 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2260 default:
35d9dd2f 2261 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2262 return buff;
2263 }
2264}
2265
f3485b74 2266static void
d3ba0551 2267decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2268{
2269 unsigned eabi;
2270 int unknown = 0;
2271
2272 eabi = EF_ARM_EABI_VERSION (e_flags);
2273 e_flags &= ~ EF_ARM_EABIMASK;
2274
2275 /* Handle "generic" ARM flags. */
2276 if (e_flags & EF_ARM_RELEXEC)
2277 {
2278 strcat (buf, ", relocatable executable");
2279 e_flags &= ~ EF_ARM_RELEXEC;
2280 }
76da6bbe 2281
f3485b74
NC		 2282 /* Now handle EABI specific flags. */
2283 switch (eabi)
2284 {
2285 default:
2c71103e 2286 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2287 if (e_flags)
2288 unknown = 1;
2289 break;
2290
2291 case EF_ARM_EABI_VER1:
a5bcd848 2292 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2293 while (e_flags)
2294 {
2295 unsigned flag;
76da6bbe 2296
f3485b74
NC		 2297 /* Process flags one bit at a time. */
2298 flag = e_flags & - e_flags;
2299 e_flags &= ~ flag;
76da6bbe 2300
f3485b74
NC		 2301 switch (flag)
2302 {
a5bcd848 2303 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2304 strcat (buf, ", sorted symbol tables");
2305 break;
76da6bbe 2306
f3485b74
NC		 2307 default:
2308 unknown = 1;
2309 break;
2310 }
2311 }
2312 break;
76da6bbe 2313
a5bcd848
PB		 2314 case EF_ARM_EABI_VER2:
2315 strcat (buf, ", Version2 EABI");
2316 while (e_flags)
2317 {
2318 unsigned flag;
2319
2320 /* Process flags one bit at a time. */
2321 flag = e_flags & - e_flags;
2322 e_flags &= ~ flag;
2323
2324 switch (flag)
2325 {
2326 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2327 strcat (buf, ", sorted symbol tables");
2328 break;
2329
2330 case EF_ARM_DYNSYMSUSESEGIDX:
2331 strcat (buf, ", dynamic symbols use segment index");
2332 break;
2333
2334 case EF_ARM_MAPSYMSFIRST:
2335 strcat (buf, ", mapping symbols precede others");
2336 break;
2337
2338 default:
2339 unknown = 1;
2340 break;
2341 }
2342 }
2343 break;
2344
d507cf36
PB		 2345 case EF_ARM_EABI_VER3:
2346 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2347 break;
2348
2349 case EF_ARM_EABI_VER4:
2350 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2351 while (e_flags)
2352 {
2353 unsigned flag;
2354
2355 /* Process flags one bit at a time. */
2356 flag = e_flags & - e_flags;
2357 e_flags &= ~ flag;
2358
2359 switch (flag)
2360 {
2361 case EF_ARM_BE8:
2362 strcat (buf, ", BE8");
2363 break;
2364
2365 case EF_ARM_LE8:
2366 strcat (buf, ", LE8");
2367 break;
2368
2369 default:
2370 unknown = 1;
2371 break;
2372 }
2373 break;
2374 }
2375 break;
3a4a14e9
PB		 2376
2377 case EF_ARM_EABI_VER5:
2378 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2379 while (e_flags)
2380 {
2381 unsigned flag;
2382
2383 /* Process flags one bit at a time. */
2384 flag = e_flags & - e_flags;
2385 e_flags &= ~ flag;
2386
2387 switch (flag)
2388 {
2389 case EF_ARM_BE8:
2390 strcat (buf, ", BE8");
2391 break;
2392
2393 case EF_ARM_LE8:
2394 strcat (buf, ", LE8");
2395 break;
2396
3bfcb652
NC		 2397 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2398 strcat (buf, ", soft-float ABI");
2399 break;
2400
2401 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2402 strcat (buf, ", hard-float ABI");
2403 break;
2404
d507cf36
PB		 2405 default:
2406 unknown = 1;
2407 break;
2408 }
2409 }
2410 break;
2411
f3485b74 2412 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2413 strcat (buf, ", GNU EABI");
f3485b74
NC		 2414 while (e_flags)
2415 {
2416 unsigned flag;
76da6bbe 2417
f3485b74
NC		 2418 /* Process flags one bit at a time. */
2419 flag = e_flags & - e_flags;
2420 e_flags &= ~ flag;
76da6bbe 2421
f3485b74
NC		 2422 switch (flag)
2423 {
a5bcd848 2424 case EF_ARM_INTERWORK:
f3485b74
NC		 2425 strcat (buf, ", interworking enabled");
2426 break;
76da6bbe 2427
a5bcd848 2428 case EF_ARM_APCS_26:
f3485b74
NC		 2429 strcat (buf, ", uses APCS/26");
2430 break;
76da6bbe 2431
a5bcd848 2432 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2433 strcat (buf, ", uses APCS/float");
2434 break;
76da6bbe 2435
a5bcd848 2436 case EF_ARM_PIC:
f3485b74
NC		 2437 strcat (buf, ", position independent");
2438 break;
76da6bbe 2439
a5bcd848 2440 case EF_ARM_ALIGN8:
f3485b74
NC		 2441 strcat (buf, ", 8 bit structure alignment");
2442 break;
76da6bbe 2443
a5bcd848 2444 case EF_ARM_NEW_ABI:
f3485b74
NC		 2445 strcat (buf, ", uses new ABI");
2446 break;
76da6bbe 2447
a5bcd848 2448 case EF_ARM_OLD_ABI:
f3485b74
NC		 2449 strcat (buf, ", uses old ABI");
2450 break;
76da6bbe 2451
a5bcd848 2452 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2453 strcat (buf, ", software FP");
2454 break;
76da6bbe 2455
90e01f86
ILT		 2456 case EF_ARM_VFP_FLOAT:
2457 strcat (buf, ", VFP");
2458 break;
2459
fde78edd
NC		 2460 case EF_ARM_MAVERICK_FLOAT:
2461 strcat (buf, ", Maverick FP");
2462 break;
2463
f3485b74
NC		 2464 default:
2465 unknown = 1;
2466 break;
2467 }
2468 }
2469 }
f3485b74
NC		 2470
2471 if (unknown)
2b692964 2472 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2473}
2474
343433df
AB		 2475static void
2476decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2477{
2478 --size; /* Leave space for null terminator. */
2479
2480 switch (e_flags & EF_AVR_MACH)
2481 {
2482 case E_AVR_MACH_AVR1:
2483 strncat (buf, ", avr:1", size);
2484 break;
2485 case E_AVR_MACH_AVR2:
2486 strncat (buf, ", avr:2", size);
2487 break;
2488 case E_AVR_MACH_AVR25:
2489 strncat (buf, ", avr:25", size);
2490 break;
2491 case E_AVR_MACH_AVR3:
2492 strncat (buf, ", avr:3", size);
2493 break;
2494 case E_AVR_MACH_AVR31:
2495 strncat (buf, ", avr:31", size);
2496 break;
2497 case E_AVR_MACH_AVR35:
2498 strncat (buf, ", avr:35", size);
2499 break;
2500 case E_AVR_MACH_AVR4:
2501 strncat (buf, ", avr:4", size);
2502 break;
2503 case E_AVR_MACH_AVR5:
2504 strncat (buf, ", avr:5", size);
2505 break;
2506 case E_AVR_MACH_AVR51:
2507 strncat (buf, ", avr:51", size);
2508 break;
2509 case E_AVR_MACH_AVR6:
2510 strncat (buf, ", avr:6", size);
2511 break;
2512 case E_AVR_MACH_AVRTINY:
2513 strncat (buf, ", avr:100", size);
2514 break;
2515 case E_AVR_MACH_XMEGA1:
2516 strncat (buf, ", avr:101", size);
2517 break;
2518 case E_AVR_MACH_XMEGA2:
2519 strncat (buf, ", avr:102", size);
2520 break;
2521 case E_AVR_MACH_XMEGA3:
2522 strncat (buf, ", avr:103", size);
2523 break;
2524 case E_AVR_MACH_XMEGA4:
2525 strncat (buf, ", avr:104", size);
2526 break;
2527 case E_AVR_MACH_XMEGA5:
2528 strncat (buf, ", avr:105", size);
2529 break;
2530 case E_AVR_MACH_XMEGA6:
2531 strncat (buf, ", avr:106", size);
2532 break;
2533 case E_AVR_MACH_XMEGA7:
2534 strncat (buf, ", avr:107", size);
2535 break;
2536 default:
2537 strncat (buf, ", avr:<unknown>", size);
2538 break;
2539 }
2540
2541 size -= strlen (buf);
2542 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2543 strncat (buf, ", link-relax", size);
2544}
2545
35c08157
KLC		 2546static void
2547decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2548{
2549 unsigned abi;
2550 unsigned arch;
2551 unsigned config;
2552 unsigned version;
2553 int has_fpu = 0;
2554 int r = 0;
2555
2556 static const char *ABI_STRINGS[] =
2557 {
2558 "ABI v0", /* use r5 as return register; only used in N1213HC */
2559 "ABI v1", /* use r0 as return register */
2560 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2561 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2562 "AABI",
2563 "ABI2 FP+"
35c08157
KLC		 2564 };
2565 static const char *VER_STRINGS[] =
2566 {
2567 "Andes ELF V1.3 or older",
2568 "Andes ELF V1.3.1",
2569 "Andes ELF V1.4"
2570 };
2571 static const char *ARCH_STRINGS[] =
2572 {
2573 "",
2574 "Andes Star v1.0",
2575 "Andes Star v2.0",
2576 "Andes Star v3.0",
2577 "Andes Star v3.0m"
2578 };
2579
2580 abi = EF_NDS_ABI & e_flags;
2581 arch = EF_NDS_ARCH & e_flags;
2582 config = EF_NDS_INST & e_flags;
2583 version = EF_NDS32_ELF_VERSION & e_flags;
2584
2585 memset (buf, 0, size);
2586
2587 switch (abi)
2588 {
2589 case E_NDS_ABI_V0:
2590 case E_NDS_ABI_V1:
2591 case E_NDS_ABI_V2:
2592 case E_NDS_ABI_V2FP:
2593 case E_NDS_ABI_AABI:
40c7a7cb 2594 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2595 /* In case there are holes in the array. */
2596 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2597 break;
2598
2599 default:
2600 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2601 break;
2602 }
2603
2604 switch (version)
2605 {
2606 case E_NDS32_ELF_VER_1_2:
2607 case E_NDS32_ELF_VER_1_3:
2608 case E_NDS32_ELF_VER_1_4:
2609 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2610 break;
2611
2612 default:
2613 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2614 break;
2615 }
2616
2617 if (E_NDS_ABI_V0 == abi)
2618 {
2619 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2620 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2621 if (arch == E_NDS_ARCH_STAR_V1_0)
2622 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2623 return;
2624 }
2625
2626 switch (arch)
2627 {
2628 case E_NDS_ARCH_STAR_V1_0:
2629 case E_NDS_ARCH_STAR_V2_0:
2630 case E_NDS_ARCH_STAR_V3_0:
2631 case E_NDS_ARCH_STAR_V3_M:
2632 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2633 break;
2634
2635 default:
2636 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2637 /* ARCH version determines how the e_flags are interpreted.
2638 If it is unknown, we cannot proceed. */
2639 return;
2640 }
2641
2642 /* Newer ABI; Now handle architecture specific flags. */
2643 if (arch == E_NDS_ARCH_STAR_V1_0)
2644 {
2645 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2646 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2647
2648 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2649 r += snprintf (buf + r, size -r, ", MAC");
2650
2651 if (config & E_NDS32_HAS_DIV_INST)
2652 r += snprintf (buf + r, size -r, ", DIV");
2653
2654 if (config & E_NDS32_HAS_16BIT_INST)
2655 r += snprintf (buf + r, size -r, ", 16b");
2656 }
2657 else
2658 {
2659 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2660 {
2661 if (version <= E_NDS32_ELF_VER_1_3)
2662 r += snprintf (buf + r, size -r, ", [B8]");
2663 else
2664 r += snprintf (buf + r, size -r, ", EX9");
2665 }
2666
2667 if (config & E_NDS32_HAS_MAC_DX_INST)
2668 r += snprintf (buf + r, size -r, ", MAC_DX");
2669
2670 if (config & E_NDS32_HAS_DIV_DX_INST)
2671 r += snprintf (buf + r, size -r, ", DIV_DX");
2672
2673 if (config & E_NDS32_HAS_16BIT_INST)
2674 {
2675 if (version <= E_NDS32_ELF_VER_1_3)
2676 r += snprintf (buf + r, size -r, ", 16b");
2677 else
2678 r += snprintf (buf + r, size -r, ", IFC");
2679 }
2680 }
2681
2682 if (config & E_NDS32_HAS_EXT_INST)
2683 r += snprintf (buf + r, size -r, ", PERF1");
2684
2685 if (config & E_NDS32_HAS_EXT2_INST)
2686 r += snprintf (buf + r, size -r, ", PERF2");
2687
2688 if (config & E_NDS32_HAS_FPU_INST)
2689 {
2690 has_fpu = 1;
2691 r += snprintf (buf + r, size -r, ", FPU_SP");
2692 }
2693
2694 if (config & E_NDS32_HAS_FPU_DP_INST)
2695 {
2696 has_fpu = 1;
2697 r += snprintf (buf + r, size -r, ", FPU_DP");
2698 }
2699
2700 if (config & E_NDS32_HAS_FPU_MAC_INST)
2701 {
2702 has_fpu = 1;
2703 r += snprintf (buf + r, size -r, ", FPU_MAC");
2704 }
2705
2706 if (has_fpu)
2707 {
2708 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2709 {
2710 case E_NDS32_FPU_REG_8SP_4DP:
2711 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2712 break;
2713 case E_NDS32_FPU_REG_16SP_8DP:
2714 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2715 break;
2716 case E_NDS32_FPU_REG_32SP_16DP:
2717 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2718 break;
2719 case E_NDS32_FPU_REG_32SP_32DP:
2720 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2721 break;
2722 }
2723 }
2724
2725 if (config & E_NDS32_HAS_AUDIO_INST)
2726 r += snprintf (buf + r, size -r, ", AUDIO");
2727
2728 if (config & E_NDS32_HAS_STRING_INST)
2729 r += snprintf (buf + r, size -r, ", STR");
2730
2731 if (config & E_NDS32_HAS_REDUCED_REGS)
2732 r += snprintf (buf + r, size -r, ", 16REG");
2733
2734 if (config & E_NDS32_HAS_VIDEO_INST)
2735 {
2736 if (version <= E_NDS32_ELF_VER_1_3)
2737 r += snprintf (buf + r, size -r, ", VIDEO");
2738 else
2739 r += snprintf (buf + r, size -r, ", SATURATION");
2740 }
2741
2742 if (config & E_NDS32_HAS_ENCRIPT_INST)
2743 r += snprintf (buf + r, size -r, ", ENCRP");
2744
2745 if (config & E_NDS32_HAS_L2C_INST)
2746 r += snprintf (buf + r, size -r, ", L2C");
2747}
2748
252b5132 2749static char *
d3ba0551 2750get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2751{
b34976b6 2752 static char buf[1024];
252b5132
RH		 2753
2754 buf[0] = '\0';
76da6bbe 2755
252b5132
RH		 2756 if (e_flags)
2757 {
2758 switch (e_machine)
2759 {
2760 default:
2761 break;
2762
f3485b74
NC		 2763 case EM_ARM:
2764 decode_ARM_machine_flags (e_flags, buf);
2765 break;
76da6bbe 2766
343433df
AB		 2767 case EM_AVR:
2768 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2769 break;
2770
781303ce
MF		 2771 case EM_BLACKFIN:
2772 if (e_flags & EF_BFIN_PIC)
2773 strcat (buf, ", PIC");
2774
2775 if (e_flags & EF_BFIN_FDPIC)
2776 strcat (buf, ", FDPIC");
2777
2778 if (e_flags & EF_BFIN_CODE_IN_L1)
2779 strcat (buf, ", code in L1");
2780
2781 if (e_flags & EF_BFIN_DATA_IN_L1)
2782 strcat (buf, ", data in L1");
2783
2784 break;
2785
ec2dfb42
AO		 2786 case EM_CYGNUS_FRV:
2787 switch (e_flags & EF_FRV_CPU_MASK)
2788 {
2789 case EF_FRV_CPU_GENERIC:
2790 break;
2791
2792 default:
2793 strcat (buf, ", fr???");
2794 break;
57346661 2795
ec2dfb42
AO		 2796 case EF_FRV_CPU_FR300:
2797 strcat (buf, ", fr300");
2798 break;
2799
2800 case EF_FRV_CPU_FR400:
2801 strcat (buf, ", fr400");
2802 break;
2803 case EF_FRV_CPU_FR405:
2804 strcat (buf, ", fr405");
2805 break;
2806
2807 case EF_FRV_CPU_FR450:
2808 strcat (buf, ", fr450");
2809 break;
2810
2811 case EF_FRV_CPU_FR500:
2812 strcat (buf, ", fr500");
2813 break;
2814 case EF_FRV_CPU_FR550:
2815 strcat (buf, ", fr550");
2816 break;
2817
2818 case EF_FRV_CPU_SIMPLE:
2819 strcat (buf, ", simple");
2820 break;
2821 case EF_FRV_CPU_TOMCAT:
2822 strcat (buf, ", tomcat");
2823 break;
2824 }
1c877e87 2825 break;
ec2dfb42 2826
53c7db4b 2827 case EM_68K:
425c6cb0 2828 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2829 strcat (buf, ", m68000");
425c6cb0 2830 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2831 strcat (buf, ", cpu32");
2832 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2833 strcat (buf, ", fido_a");
425c6cb0 2834 else
266abb8f 2835 {
2cf0635d
NC		 2836 char const * isa = _("unknown");
2837 char const * mac = _("unknown mac");
2838 char const * additional = NULL;
0112cd26 2839
c694fd50 2840 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2841 {
c694fd50 2842 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2843 isa = "A";
2844 additional = ", nodiv";
2845 break;
c694fd50 2846 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2847 isa = "A";
2848 break;
c694fd50 2849 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2850 isa = "A+";
2851 break;
c694fd50 2852 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2853 isa = "B";
2854 additional = ", nousp";
2855 break;
c694fd50 2856 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2857 isa = "B";
2858 break;
f608cd77
NS		 2859 case EF_M68K_CF_ISA_C:
2860 isa = "C";
2861 break;
2862 case EF_M68K_CF_ISA_C_NODIV:
2863 isa = "C";
2864 additional = ", nodiv";
2865 break;
266abb8f
NS		 2866 }
2867 strcat (buf, ", cf, isa ");
2868 strcat (buf, isa);
0b2e31dc
NS		 2869 if (additional)
2870 strcat (buf, additional);
c694fd50 2871 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2872 strcat (buf, ", float");
c694fd50 2873 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2874 {
2875 case 0:
2876 mac = NULL;
2877 break;
c694fd50 2878 case EF_M68K_CF_MAC:
266abb8f
NS		 2879 mac = "mac";
2880 break;
c694fd50 2881 case EF_M68K_CF_EMAC:
266abb8f
NS		 2882 mac = "emac";
2883 break;
f608cd77
NS		 2884 case EF_M68K_CF_EMAC_B:
2885 mac = "emac_b";
2886 break;
266abb8f
NS		 2887 }
2888 if (mac)
2889 {
2890 strcat (buf, ", ");
2891 strcat (buf, mac);
2892 }
266abb8f 2893 }
53c7db4b 2894 break;
33c63f9d 2895
153a2776
NC		 2896 case EM_CYGNUS_MEP:
2897 switch (e_flags & EF_MEP_CPU_MASK)
2898 {
2899 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2900 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2901 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2902 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2903 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2904 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2905 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2906 }
2907
2908 switch (e_flags & EF_MEP_COP_MASK)
2909 {
2910 case EF_MEP_COP_NONE: break;
2911 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2912 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2913 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2914 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2915 default: strcat (buf, _("<unknown MeP copro type>")); break;
2916 }
2917
2918 if (e_flags & EF_MEP_LIBRARY)
2919 strcat (buf, ", Built for Library");
2920
2921 if (e_flags & EF_MEP_INDEX_MASK)
2922 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2923 e_flags & EF_MEP_INDEX_MASK);
2924
2925 if (e_flags & ~ EF_MEP_ALL_FLAGS)
2926 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2927 e_flags & ~ EF_MEP_ALL_FLAGS);
2928 break;
2929
252b5132
RH		 2930 case EM_PPC:
2931 if (e_flags & EF_PPC_EMB)
2932 strcat (buf, ", emb");
2933
2934 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2935 strcat (buf, _(", relocatable"));
252b5132
RH		 2936
2937 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2938 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2939 break;
2940
ee67d69a
AM		 2941 case EM_PPC64:
2942 if (e_flags & EF_PPC64_ABI)
2943 {
2944 char abi[] = ", abiv0";
2945
2946 abi[6] += e_flags & EF_PPC64_ABI;
2947 strcat (buf, abi);
2948 }
2949 break;
2950
708e2187
NC		 2951 case EM_V800:
2952 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2953 strcat (buf, ", RH850 ABI");
0b4362b0 2954
708e2187
NC		 2955 if (e_flags & EF_V800_850E3)
2956 strcat (buf, ", V3 architecture");
2957
2958 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2959 strcat (buf, ", FPU not used");
2960
2961 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2962 strcat (buf, ", regmode: COMMON");
2963
2964 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2965 strcat (buf, ", r4 not used");
2966
2967 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2968 strcat (buf, ", r30 not used");
2969
2970 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2971 strcat (buf, ", r5 not used");
2972
2973 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2974 strcat (buf, ", r2 not used");
2975
2976 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2977 {
2978 switch (e_flags & - e_flags)
2979 {
2980 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2981 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2982 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2983 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2984 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2985 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2986 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2987 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2988 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2989 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2990 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2991 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2992 default: break;
2993 }
2994 }
2995 break;
2996
2b0337b0 2997 case EM_V850:
252b5132
RH		 2998 case EM_CYGNUS_V850:
2999 switch (e_flags & EF_V850_ARCH)
3000 {
78c8d46c
NC		 3001 case E_V850E3V5_ARCH:
3002 strcat (buf, ", v850e3v5");
3003 break;
1cd986c5
NC		 3004 case E_V850E2V3_ARCH:
3005 strcat (buf, ", v850e2v3");
3006 break;
3007 case E_V850E2_ARCH:
3008 strcat (buf, ", v850e2");
3009 break;
3010 case E_V850E1_ARCH:
3011 strcat (buf, ", v850e1");
8ad30312 3012 break;
252b5132
RH		 3013 case E_V850E_ARCH:
3014 strcat (buf, ", v850e");
3015 break;
252b5132
RH		 3016 case E_V850_ARCH:
3017 strcat (buf, ", v850");
3018 break;
3019 default:
2b692964 3020 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3021 break;
3022 }
3023 break;
3024
2b0337b0 3025 case EM_M32R:
252b5132
RH		 3026 case EM_CYGNUS_M32R:
3027 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3028 strcat (buf, ", m32r");
252b5132
RH		 3029 break;
3030
3031 case EM_MIPS:
4fe85591 3032 case EM_MIPS_RS3_LE:
252b5132
RH		 3033 if (e_flags & EF_MIPS_NOREORDER)
3034 strcat (buf, ", noreorder");
3035
3036 if (e_flags & EF_MIPS_PIC)
3037 strcat (buf, ", pic");
3038
3039 if (e_flags & EF_MIPS_CPIC)
3040 strcat (buf, ", cpic");
3041
d1bdd336
TS		 3042 if (e_flags & EF_MIPS_UCODE)
3043 strcat (buf, ", ugen_reserved");
3044
252b5132
RH		 3045 if (e_flags & EF_MIPS_ABI2)
3046 strcat (buf, ", abi2");
3047
43521d43
TS		 3048 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3049 strcat (buf, ", odk first");
3050
a5d22d2a
TS		 3051 if (e_flags & EF_MIPS_32BITMODE)
3052 strcat (buf, ", 32bitmode");
3053
ba92f887
MR		 3054 if (e_flags & EF_MIPS_NAN2008)
3055 strcat (buf, ", nan2008");
3056
fef1b0b3
SE		 3057 if (e_flags & EF_MIPS_FP64)
3058 strcat (buf, ", fp64");
3059
156c2f8b
NC		 3060 switch ((e_flags & EF_MIPS_MACH))
3061 {
3062 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3063 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3064 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3065 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3066 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3067 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3068 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3069 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3070 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3071 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3072 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3073 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3074 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3075 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3076 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3077 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3078 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3079 case 0:
3080 /* We simply ignore the field in this case to avoid confusion:
3081 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3082 extension. */
3083 break;
2b692964 3084 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3085 }
43521d43
TS		 3086
3087 switch ((e_flags & EF_MIPS_ABI))
3088 {
3089 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3090 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3091 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3092 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3093 case 0:
3094 /* We simply ignore the field in this case to avoid confusion:
3095 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3096 This means it is likely to be an o32 file, but not for
3097 sure. */
3098 break;
2b692964 3099 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3100 }
3101
3102 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3103 strcat (buf, ", mdmx");
3104
3105 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3106 strcat (buf, ", mips16");
3107
df58fc94
RS		 3108 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3109 strcat (buf, ", micromips");
3110
43521d43
TS		 3111 switch ((e_flags & EF_MIPS_ARCH))
3112 {
3113 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3114 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3115 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3116 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3117 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3118 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3119 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3120 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3121 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3122 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3123 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3124 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3125 }
252b5132 3126 break;
351b4b40 3127
35c08157
KLC		 3128 case EM_NDS32:
3129 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3130 break;
3131
ccde1100
AO		 3132 case EM_SH:
3133 switch ((e_flags & EF_SH_MACH_MASK))
3134 {
3135 case EF_SH1: strcat (buf, ", sh1"); break;
3136 case EF_SH2: strcat (buf, ", sh2"); break;
3137 case EF_SH3: strcat (buf, ", sh3"); break;
3138 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3139 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3140 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3141 case EF_SH3E: strcat (buf, ", sh3e"); break;
3142 case EF_SH4: strcat (buf, ", sh4"); break;
3143 case EF_SH5: strcat (buf, ", sh5"); break;
3144 case EF_SH2E: strcat (buf, ", sh2e"); break;
3145 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3146 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3147 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3148 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3149 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3150 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3151 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3152 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3153 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3154 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3155 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3156 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3157 }
3158
cec6a5b8
MR		 3159 if (e_flags & EF_SH_PIC)
3160 strcat (buf, ", pic");
3161
3162 if (e_flags & EF_SH_FDPIC)
3163 strcat (buf, ", fdpic");
ccde1100 3164 break;
948f632f 3165
73589c9d
CS		 3166 case EM_OR1K:
3167 if (e_flags & EF_OR1K_NODELAY)
3168 strcat (buf, ", no delay");
3169 break;
57346661 3170
351b4b40
RH		 3171 case EM_SPARCV9:
3172 if (e_flags & EF_SPARC_32PLUS)
3173 strcat (buf, ", v8+");
3174
3175 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3176 strcat (buf, ", ultrasparcI");
3177
3178 if (e_flags & EF_SPARC_SUN_US3)
3179 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3180
3181 if (e_flags & EF_SPARC_HAL_R1)
3182 strcat (buf, ", halr1");
3183
3184 if (e_flags & EF_SPARC_LEDATA)
3185 strcat (buf, ", ledata");
3186
3187 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3188 strcat (buf, ", tso");
3189
3190 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3191 strcat (buf, ", pso");
3192
3193 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3194 strcat (buf, ", rmo");
3195 break;
7d466069 3196
103f02d3
UD		 3197 case EM_PARISC:
3198 switch (e_flags & EF_PARISC_ARCH)
3199 {
3200 case EFA_PARISC_1_0:
3201 strcpy (buf, ", PA-RISC 1.0");
3202 break;
3203 case EFA_PARISC_1_1:
3204 strcpy (buf, ", PA-RISC 1.1");
3205 break;
3206 case EFA_PARISC_2_0:
3207 strcpy (buf, ", PA-RISC 2.0");
3208 break;
3209 default:
3210 break;
3211 }
3212 if (e_flags & EF_PARISC_TRAPNIL)
3213 strcat (buf, ", trapnil");
3214 if (e_flags & EF_PARISC_EXT)
3215 strcat (buf, ", ext");
3216 if (e_flags & EF_PARISC_LSB)
3217 strcat (buf, ", lsb");
3218 if (e_flags & EF_PARISC_WIDE)
3219 strcat (buf, ", wide");
3220 if (e_flags & EF_PARISC_NO_KABP)
3221 strcat (buf, ", no kabp");
3222 if (e_flags & EF_PARISC_LAZYSWAP)
3223 strcat (buf, ", lazyswap");
30800947 3224 break;
76da6bbe 3225
7d466069 3226 case EM_PJ:
2b0337b0 3227 case EM_PJ_OLD:
7d466069
ILT		 3228 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3229 strcat (buf, ", new calling convention");
3230
3231 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3232 strcat (buf, ", gnu calling convention");
3233 break;
4d6ed7c8
NC		 3234
3235 case EM_IA_64:
3236 if ((e_flags & EF_IA_64_ABI64))
3237 strcat (buf, ", 64-bit");
3238 else
3239 strcat (buf, ", 32-bit");
3240 if ((e_flags & EF_IA_64_REDUCEDFP))
3241 strcat (buf, ", reduced fp model");
3242 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3243 strcat (buf, ", no function descriptors, constant gp");
3244 else if ((e_flags & EF_IA_64_CONS_GP))
3245 strcat (buf, ", constant gp");
3246 if ((e_flags & EF_IA_64_ABSOLUTE))
3247 strcat (buf, ", absolute");
28f997cf
TG		 3248 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3249 {
3250 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3251 strcat (buf, ", vms_linkages");
3252 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3253 {
3254 case EF_IA_64_VMS_COMCOD_SUCCESS:
3255 break;
3256 case EF_IA_64_VMS_COMCOD_WARNING:
3257 strcat (buf, ", warning");
3258 break;
3259 case EF_IA_64_VMS_COMCOD_ERROR:
3260 strcat (buf, ", error");
3261 break;
3262 case EF_IA_64_VMS_COMCOD_ABORT:
3263 strcat (buf, ", abort");
3264 break;
3265 default:
bee0ee85
NC		 3266 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3267 e_flags & EF_IA_64_VMS_COMCOD);
3268 strcat (buf, ", <unknown>");
28f997cf
TG		 3269 }
3270 }
4d6ed7c8 3271 break;
179d3252
JT		 3272
3273 case EM_VAX:
3274 if ((e_flags & EF_VAX_NONPIC))
3275 strcat (buf, ", non-PIC");
3276 if ((e_flags & EF_VAX_DFLOAT))
3277 strcat (buf, ", D-Float");
3278 if ((e_flags & EF_VAX_GFLOAT))
3279 strcat (buf, ", G-Float");
3280 break;
c7927a3c 3281
619ed720
EB		 3282 case EM_VISIUM:
3283 if (e_flags & EF_VISIUM_ARCH_MCM)
3284 strcat (buf, ", mcm");
3285 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3286 strcat (buf, ", mcm24");
3287 if (e_flags & EF_VISIUM_ARCH_GR6)
3288 strcat (buf, ", gr6");
3289 break;
3290
4046d87a 3291 case EM_RL78:
1740ba0c
NC		 3292 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3293 {
3294 case E_FLAG_RL78_ANY_CPU: break;
3295 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3296 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3297 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3298 }
856ea05c
KP		 3299 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3300 strcat (buf, ", 64-bit doubles");
4046d87a 3301 break;
0b4362b0 3302
c7927a3c
NC		 3303 case EM_RX:
3304 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3305 strcat (buf, ", 64-bit doubles");
3306 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3307 strcat (buf, ", dsp");
d4cb0ea0 3308 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3309 strcat (buf, ", pid");
708e2187
NC		 3310 if (e_flags & E_FLAG_RX_ABI)
3311 strcat (buf, ", RX ABI");
3525236c
NC		 3312 if (e_flags & E_FLAG_RX_SINSNS_SET)
3313 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3314 ? ", uses String instructions" : ", bans String instructions");
d4cb0ea0 3315 break;
55786da2
AK		 3316
3317 case EM_S390:
3318 if (e_flags & EF_S390_HIGH_GPRS)
3319 strcat (buf, ", highgprs");
d4cb0ea0 3320 break;
40b36596
JM		 3321
3322 case EM_TI_C6000:
3323 if ((e_flags & EF_C6000_REL))
3324 strcat (buf, ", relocatable module");
d4cb0ea0 3325 break;
13761a11
NC		 3326
3327 case EM_MSP430:
3328 strcat (buf, _(": architecture variant: "));
3329 switch (e_flags & EF_MSP430_MACH)
3330 {
3331 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3332 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3333 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3334 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3335 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3336 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3337 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3338 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3339 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3340 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3341 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3342 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3343 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3344 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3345 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3346 default:
3347 strcat (buf, _(": unknown")); break;
3348 }
3349
3350 if (e_flags & ~ EF_MSP430_MACH)
3351 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3352 }
3353 }
3354
3355 return buf;
3356}
3357
252b5132 3358static const char *
d3ba0551
AM		 3359get_osabi_name (unsigned int osabi)
3360{
3361 static char buff[32];
3362
3363 switch (osabi)
3364 {
3365 case ELFOSABI_NONE: return "UNIX - System V";
3366 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3367 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3368 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3369 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3370 case ELFOSABI_AIX: return "UNIX - AIX";
3371 case ELFOSABI_IRIX: return "UNIX - IRIX";
3372 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3373 case ELFOSABI_TRU64: return "UNIX - TRU64";
3374 case ELFOSABI_MODESTO: return "Novell - Modesto";
3375 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3376 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3377 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3378 case ELFOSABI_AROS: return "AROS";
11636f9e 3379 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3380 default:
40b36596
JM		 3381 if (osabi >= 64)
3382 switch (elf_header.e_machine)
3383 {
3384 case EM_ARM:
3385 switch (osabi)
3386 {
3387 case ELFOSABI_ARM: return "ARM";
3388 default:
3389 break;
3390 }
3391 break;
3392
3393 case EM_MSP430:
3394 case EM_MSP430_OLD:
619ed720 3395 case EM_VISIUM:
40b36596
JM		 3396 switch (osabi)
3397 {
3398 case ELFOSABI_STANDALONE: return _("Standalone App");
3399 default:
3400 break;
3401 }
3402 break;
3403
3404 case EM_TI_C6000:
3405 switch (osabi)
3406 {
3407 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3408 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3409 default:
3410 break;
3411 }
3412 break;
3413
3414 default:
3415 break;
3416 }
e9e44622 3417 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3418 return buff;
3419 }
3420}
3421
a06ea964
NC		 3422static const char *
3423get_aarch64_segment_type (unsigned long type)
3424{
3425 switch (type)
3426 {
3427 case PT_AARCH64_ARCHEXT:
3428 return "AARCH64_ARCHEXT";
3429 default:
3430 break;
3431 }
3432
3433 return NULL;
3434}
3435
b294bdf8
MM		 3436static const char *
3437get_arm_segment_type (unsigned long type)
3438{
3439 switch (type)
3440 {
3441 case PT_ARM_EXIDX:
3442 return "EXIDX";
3443 default:
3444 break;
3445 }
3446
3447 return NULL;
3448}
3449
d3ba0551
AM		 3450static const char *
3451get_mips_segment_type (unsigned long type)
252b5132
RH		 3452{
3453 switch (type)
3454 {
3455 case PT_MIPS_REGINFO:
3456 return "REGINFO";
3457 case PT_MIPS_RTPROC:
3458 return "RTPROC";
3459 case PT_MIPS_OPTIONS:
3460 return "OPTIONS";
351cdf24
MF		 3461 case PT_MIPS_ABIFLAGS:
3462 return "ABIFLAGS";
252b5132
RH		 3463 default:
3464 break;
3465 }
3466
3467 return NULL;
3468}
3469
103f02d3 3470static const char *
d3ba0551 3471get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3472{
3473 switch (type)
3474 {
3475 case PT_HP_TLS: return "HP_TLS";
3476 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3477 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3478 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3479 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3480 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3481 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3482 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3483 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3484 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3485 case PT_HP_PARALLEL: return "HP_PARALLEL";
3486 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3487 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3488 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3489 case PT_HP_STACK: return "HP_STACK";
3490 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3491 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3492 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3493 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3494 default:
3495 break;
3496 }
3497
3498 return NULL;
3499}
3500
4d6ed7c8 3501static const char *
d3ba0551 3502get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3503{
3504 switch (type)
3505 {
3506 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3507 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3508 case PT_HP_TLS: return "HP_TLS";
3509 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3510 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3511 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3512 default:
3513 break;
3514 }
3515
3516 return NULL;
3517}
3518
40b36596
JM		 3519static const char *
3520get_tic6x_segment_type (unsigned long type)
3521{
3522 switch (type)
3523 {
3524 case PT_C6000_PHATTR: return "C6000_PHATTR";
3525 default:
3526 break;
3527 }
3528
3529 return NULL;
3530}
3531
252b5132 3532static const char *
d3ba0551 3533get_segment_type (unsigned long p_type)
252b5132 3534{
b34976b6 3535 static char buff[32];
252b5132
RH		 3536
3537 switch (p_type)
3538 {
b34976b6
AM		 3539 case PT_NULL: return "NULL";
3540 case PT_LOAD: return "LOAD";
252b5132 3541 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3542 case PT_INTERP: return "INTERP";
3543 case PT_NOTE: return "NOTE";
3544 case PT_SHLIB: return "SHLIB";
3545 case PT_PHDR: return "PHDR";
13ae64f3 3546 case PT_TLS: return "TLS";
252b5132 3547
65765700
JJ		 3548 case PT_GNU_EH_FRAME:
3549 return "GNU_EH_FRAME";
2b05f1b7 3550 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3551 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3552
252b5132
RH		 3553 default:
3554 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3555 {
2cf0635d 3556 const char * result;
103f02d3 3557
252b5132
RH		 3558 switch (elf_header.e_machine)
3559 {
a06ea964
NC		 3560 case EM_AARCH64:
3561 result = get_aarch64_segment_type (p_type);
3562 break;
b294bdf8
MM		 3563 case EM_ARM:
3564 result = get_arm_segment_type (p_type);
3565 break;
252b5132 3566 case EM_MIPS:
4fe85591 3567 case EM_MIPS_RS3_LE:
252b5132
RH		 3568 result = get_mips_segment_type (p_type);
3569 break;
103f02d3
UD		 3570 case EM_PARISC:
3571 result = get_parisc_segment_type (p_type);
3572 break;
4d6ed7c8
NC		 3573 case EM_IA_64:
3574 result = get_ia64_segment_type (p_type);
3575 break;
40b36596
JM		 3576 case EM_TI_C6000:
3577 result = get_tic6x_segment_type (p_type);
3578 break;
252b5132
RH		 3579 default:
3580 result = NULL;
3581 break;
3582 }
103f02d3 3583
252b5132
RH		 3584 if (result != NULL)
3585 return result;
103f02d3 3586
252b5132
RH		 3587 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3588 }
3589 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3590 {
2cf0635d 3591 const char * result;
103f02d3
UD		 3592
3593 switch (elf_header.e_machine)
3594 {
3595 case EM_PARISC:
3596 result = get_parisc_segment_type (p_type);
3597 break;
00428cca
AM		 3598 case EM_IA_64:
3599 result = get_ia64_segment_type (p_type);
3600 break;
103f02d3
UD		 3601 default:
3602 result = NULL;
3603 break;
3604 }
3605
3606 if (result != NULL)
3607 return result;
3608
3609 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3610 }
252b5132 3611 else
e9e44622 3612 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3613
3614 return buff;
3615 }
3616}
3617
3618static const char *
d3ba0551 3619get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3620{
3621 switch (sh_type)
3622 {
b34976b6
AM		 3623 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3624 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3625 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3626 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3627 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3628 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3629 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3630 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3631 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3632 case SHT_MIPS_RELD: return "MIPS_RELD";
3633 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3634 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3635 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3636 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3637 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3638 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3639 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3640 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3641 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3642 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3643 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3644 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3645 case SHT_MIPS_LINE: return "MIPS_LINE";
3646 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3647 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3648 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3649 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3650 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3651 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3652 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3653 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3654 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3655 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3656 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3657 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3658 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3659 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3660 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3661 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3662 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3663 default:
3664 break;
3665 }
3666 return NULL;
3667}
3668
103f02d3 3669static const char *
d3ba0551 3670get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3671{
3672 switch (sh_type)
3673 {
3674 case SHT_PARISC_EXT: return "PARISC_EXT";
3675 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3676 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3677 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3678 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3679 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3680 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3681 default:
3682 break;
3683 }
3684 return NULL;
3685}
3686
4d6ed7c8 3687static const char *
d3ba0551 3688get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3689{
18bd398b 3690 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3691 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3692 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3693
4d6ed7c8
NC		 3694 switch (sh_type)
3695 {
148b93f2
NC		 3696 case SHT_IA_64_EXT: return "IA_64_EXT";
3697 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3698 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3699 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3700 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3701 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3702 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3703 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3704 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3705 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3706 default:
3707 break;
3708 }
3709 return NULL;
3710}
3711
d2b2c203
DJ		 3712static const char *
3713get_x86_64_section_type_name (unsigned int sh_type)
3714{
3715 switch (sh_type)
3716 {
3717 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3718 default:
3719 break;
3720 }
3721 return NULL;
3722}
3723
a06ea964
NC		 3724static const char *
3725get_aarch64_section_type_name (unsigned int sh_type)
3726{
3727 switch (sh_type)
3728 {
3729 case SHT_AARCH64_ATTRIBUTES:
3730 return "AARCH64_ATTRIBUTES";
3731 default:
3732 break;
3733 }
3734 return NULL;
3735}
3736
40a18ebd
NC		 3737static const char *
3738get_arm_section_type_name (unsigned int sh_type)
3739{
3740 switch (sh_type)
3741 {
7f6fed87
NC		 3742 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3743 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3744 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3745 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3746 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3747 default:
3748 break;
3749 }
3750 return NULL;
3751}
3752
40b36596
JM		 3753static const char *
3754get_tic6x_section_type_name (unsigned int sh_type)
3755{
3756 switch (sh_type)
3757 {
3758 case SHT_C6000_UNWIND:
3759 return "C6000_UNWIND";
3760 case SHT_C6000_PREEMPTMAP:
3761 return "C6000_PREEMPTMAP";
3762 case SHT_C6000_ATTRIBUTES:
3763 return "C6000_ATTRIBUTES";
3764 case SHT_TI_ICODE:
3765 return "TI_ICODE";
3766 case SHT_TI_XREF:
3767 return "TI_XREF";
3768 case SHT_TI_HANDLER:
3769 return "TI_HANDLER";
3770 case SHT_TI_INITINFO:
3771 return "TI_INITINFO";
3772 case SHT_TI_PHATTRS:
3773 return "TI_PHATTRS";
3774 default:
3775 break;
3776 }
3777 return NULL;
3778}
3779
13761a11
NC		 3780static const char *
3781get_msp430x_section_type_name (unsigned int sh_type)
3782{
3783 switch (sh_type)
3784 {
3785 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3786 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3787 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3788 default: return NULL;
3789 }
3790}
3791
685080f2
NC		 3792static const char *
3793get_v850_section_type_name (unsigned int sh_type)
3794{
3795 switch (sh_type)
3796 {
3797 case SHT_V850_SCOMMON: return "V850 Small Common";
3798 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3799 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3800 case SHT_RENESAS_IOP: return "RENESAS IOP";
3801 case SHT_RENESAS_INFO: return "RENESAS INFO";
3802 default: return NULL;
3803 }
3804}
3805
252b5132 3806static const char *
d3ba0551 3807get_section_type_name (unsigned int sh_type)
252b5132 3808{
b34976b6 3809 static char buff[32];
252b5132
RH		 3810
3811 switch (sh_type)
3812 {
3813 case SHT_NULL: return "NULL";
3814 case SHT_PROGBITS: return "PROGBITS";
3815 case SHT_SYMTAB: return "SYMTAB";
3816 case SHT_STRTAB: return "STRTAB";
3817 case SHT_RELA: return "RELA";
3818 case SHT_HASH: return "HASH";
3819 case SHT_DYNAMIC: return "DYNAMIC";
3820 case SHT_NOTE: return "NOTE";
3821 case SHT_NOBITS: return "NOBITS";
3822 case SHT_REL: return "REL";
3823 case SHT_SHLIB: return "SHLIB";
3824 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3825 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3826 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3827 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3828 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3829 case SHT_GROUP: return "GROUP";
3830 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3831 case SHT_GNU_verdef: return "VERDEF";
3832 case SHT_GNU_verneed: return "VERNEED";
3833 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3834 case 0x6ffffff0: return "VERSYM";
3835 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3836 case 0x7ffffffd: return "AUXILIARY";
3837 case 0x7fffffff: return "FILTER";
047b2264 3838 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3839
3840 default:
3841 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3842 {
2cf0635d 3843 const char * result;
252b5132
RH		 3844
3845 switch (elf_header.e_machine)
3846 {
3847 case EM_MIPS:
4fe85591 3848 case EM_MIPS_RS3_LE:
252b5132
RH		 3849 result = get_mips_section_type_name (sh_type);
3850 break;
103f02d3
UD		 3851 case EM_PARISC:
3852 result = get_parisc_section_type_name (sh_type);
3853 break;
4d6ed7c8
NC		 3854 case EM_IA_64:
3855 result = get_ia64_section_type_name (sh_type);
3856 break;
d2b2c203 3857 case EM_X86_64:
8a9036a4 3858 case EM_L1OM:
7a9068fe 3859 case EM_K1OM:
d2b2c203
DJ		 3860 result = get_x86_64_section_type_name (sh_type);
3861 break;
a06ea964
NC		 3862 case EM_AARCH64:
3863 result = get_aarch64_section_type_name (sh_type);
3864 break;
40a18ebd
NC		 3865 case EM_ARM:
3866 result = get_arm_section_type_name (sh_type);
3867 break;
40b36596
JM		 3868 case EM_TI_C6000:
3869 result = get_tic6x_section_type_name (sh_type);
3870 break;
13761a11
NC		 3871 case EM_MSP430:
3872 result = get_msp430x_section_type_name (sh_type);
3873 break;
685080f2
NC		 3874 case EM_V800:
3875 case EM_V850:
3876 case EM_CYGNUS_V850:
3877 result = get_v850_section_type_name (sh_type);
3878 break;
252b5132
RH		 3879 default:
3880 result = NULL;
3881 break;
3882 }
3883
3884 if (result != NULL)
3885 return result;
3886
c91d0dfb 3887 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3888 }
3889 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3890 {
2cf0635d 3891 const char * result;
148b93f2
NC		 3892
3893 switch (elf_header.e_machine)
3894 {
3895 case EM_IA_64:
3896 result = get_ia64_section_type_name (sh_type);
3897 break;
3898 default:
3899 result = NULL;
3900 break;
3901 }
3902
3903 if (result != NULL)
3904 return result;
3905
3906 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3907 }
252b5132 3908 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3909 {
3910 switch (elf_header.e_machine)
3911 {
3912 case EM_V800:
3913 case EM_V850:
3914 case EM_CYGNUS_V850:
3915 return get_v850_section_type_name (sh_type);
3916 default:
3917 break;
3918 }
3919
3920 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3921 }
252b5132 3922 else
a7dbfd1c
NC		 3923 /* This message is probably going to be displayed in a 15
3924 character wide field, so put the hex value first. */
3925 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3926
252b5132
RH		 3927 return buff;
3928 }
3929}
3930
2979dc34 3931#define OPTION_DEBUG_DUMP 512
2c610e4b 3932#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3933#define OPTION_DWARF_DEPTH 514
3934#define OPTION_DWARF_START 515
4723351a 3935#define OPTION_DWARF_CHECK 516
2979dc34 3936
85b1c36d 3937static struct option options[] =
252b5132 3938{
b34976b6 3939 {"all", no_argument, 0, 'a'},
252b5132
RH		 3940 {"file-header", no_argument, 0, 'h'},
3941 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3942 {"headers", no_argument, 0, 'e'},
3943 {"histogram", no_argument, 0, 'I'},
3944 {"segments", no_argument, 0, 'l'},
3945 {"sections", no_argument, 0, 'S'},
252b5132 3946 {"section-headers", no_argument, 0, 'S'},
f5842774 3947 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3948 {"section-details", no_argument, 0, 't'},
595cf52e 3949 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3950 {"symbols", no_argument, 0, 's'},
3951 {"syms", no_argument, 0, 's'},
2c610e4b 3952 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3953 {"relocs", no_argument, 0, 'r'},
3954 {"notes", no_argument, 0, 'n'},
3955 {"dynamic", no_argument, 0, 'd'},
a952a375 3956 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3957 {"version-info", no_argument, 0, 'V'},
3958 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3959 {"unwind", no_argument, 0, 'u'},
4145f1d5 3960 {"archive-index", no_argument, 0, 'c'},
b34976b6 3961 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3962 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3963 {"string-dump", required_argument, 0, 'p'},
0e602686 3964 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 3965#ifdef SUPPORT_DISASSEMBLY
3966 {"instruction-dump", required_argument, 0, 'i'},
3967#endif
cf13d699 3968 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3969
fd2f0033
TT		 3970 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3971 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3972 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3973
b34976b6
AM		 3974 {"version", no_argument, 0, 'v'},
3975 {"wide", no_argument, 0, 'W'},
3976 {"help", no_argument, 0, 'H'},
3977 {0, no_argument, 0, 0}
252b5132
RH		 3978};
3979
3980static void
2cf0635d 3981usage (FILE * stream)
252b5132 3982{
92f01d61
JM		 3983 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3984 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3985 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3986 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3987 -h --file-header Display the ELF file header\n\
3988 -l --program-headers Display the program headers\n\
3989 --segments An alias for --program-headers\n\
3990 -S --section-headers Display the sections' header\n\
3991 --sections An alias for --section-headers\n\
f5842774 3992 -g --section-groups Display the section groups\n\
5477e8a0 3993 -t --section-details Display the section details\n\
8b53311e
NC		 3994 -e --headers Equivalent to: -h -l -S\n\
3995 -s --syms Display the symbol table\n\
3f08eb35 3996 --symbols An alias for --syms\n\
2c610e4b 3997 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3998 -n --notes Display the core notes (if present)\n\
3999 -r --relocs Display the relocations (if present)\n\
4000 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4001 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4002 -V --version-info Display the version sections (if present)\n\
1b31d05e 4003 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4004 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4005 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4006 -x --hex-dump=<number|name>\n\
4007 Dump the contents of section <number|name> as bytes\n\
4008 -p --string-dump=<number|name>\n\
4009 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4010 -R --relocated-dump=<number|name>\n\
4011 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4012 -z --decompress Decompress section before dumping it\n\
f9f0e732 4013 -w[lLiaprmfFsoRt] or\n\
1ed06042 4014 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4015 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4016 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4017 =addr,=cu_index]\n\
8b53311e 4018 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4019 fprintf (stream, _("\
4020 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4021 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4022 or deeper\n"));
252b5132 4023#ifdef SUPPORT_DISASSEMBLY
92f01d61 4024 fprintf (stream, _("\
09c11c86
NC		 4025 -i --instruction-dump=<number|name>\n\
4026 Disassemble the contents of section <number|name>\n"));
252b5132 4027#endif
92f01d61 4028 fprintf (stream, _("\
8b53311e
NC		 4029 -I --histogram Display histogram of bucket list lengths\n\
4030 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4031 @<file> Read options from <file>\n\
8b53311e
NC		 4032 -H --help Display this information\n\
4033 -v --version Display the version number of readelf\n"));
1118d252 4034
92f01d61
JM		 4035 if (REPORT_BUGS_TO[0] && stream == stdout)
4036 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4037
92f01d61 4038 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4039}
4040
18bd398b
NC		 4041/* Record the fact that the user wants the contents of section number
4042 SECTION to be displayed using the method(s) encoded as flags bits
4043 in TYPE. Note, TYPE can be zero if we are creating the array for
4044 the first time. */
4045
252b5132 4046static void
09c11c86 4047request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4048{
4049 if (section >= num_dump_sects)
4050 {
2cf0635d 4051 dump_type * new_dump_sects;
252b5132 4052
3f5e193b
NC		 4053 new_dump_sects = (dump_type *) calloc (section + 1,
4054 sizeof (* dump_sects));
252b5132
RH		 4055
4056 if (new_dump_sects == NULL)
591a748a 4057 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4058 else
4059 {
4060 /* Copy current flag settings. */
09c11c86 4061 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4062
4063 free (dump_sects);
4064
4065 dump_sects = new_dump_sects;
4066 num_dump_sects = section + 1;
4067 }
4068 }
4069
4070 if (dump_sects)
b34976b6 4071 dump_sects[section] |= type;
252b5132
RH		 4072
4073 return;
4074}
4075
aef1f6d0
DJ		 4076/* Request a dump by section name. */
4077
4078static void
2cf0635d 4079request_dump_byname (const char * section, dump_type type)
aef1f6d0 4080{
2cf0635d 4081 struct dump_list_entry * new_request;
aef1f6d0 4082
3f5e193b
NC		 4083 new_request = (struct dump_list_entry *)
4084 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4085 if (!new_request)
591a748a 4086 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4087
4088 new_request->name = strdup (section);
4089 if (!new_request->name)
591a748a 4090 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4091
4092 new_request->type = type;
4093
4094 new_request->next = dump_sects_byname;
4095 dump_sects_byname = new_request;
4096}
4097
cf13d699
NC		 4098static inline void
4099request_dump (dump_type type)
4100{
4101 int section;
4102 char * cp;
4103
4104 do_dump++;
4105 section = strtoul (optarg, & cp, 0);
4106
4107 if (! *cp && section >= 0)
4108 request_dump_bynumber (section, type);
4109 else
4110 request_dump_byname (optarg, type);
4111}
4112
4113
252b5132 4114static void
2cf0635d 4115parse_args (int argc, char ** argv)
252b5132
RH		 4116{
4117 int c;
4118
4119 if (argc < 2)
92f01d61 4120 usage (stderr);
252b5132
RH		 4121
4122 while ((c = getopt_long
0e602686 4123 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4124 {
252b5132
RH		 4125 switch (c)
4126 {
4127 case 0:
4128 /* Long options. */
4129 break;
4130 case 'H':
92f01d61 4131 usage (stdout);
252b5132
RH		 4132 break;
4133
4134 case 'a':
b34976b6
AM		 4135 do_syms++;
4136 do_reloc++;
4137 do_unwind++;
4138 do_dynamic++;
4139 do_header++;
4140 do_sections++;
f5842774 4141 do_section_groups++;
b34976b6
AM		 4142 do_segments++;
4143 do_version++;
4144 do_histogram++;
4145 do_arch++;
4146 do_notes++;
252b5132 4147 break;
f5842774
L		 4148 case 'g':
4149 do_section_groups++;
4150 break;
5477e8a0 4151 case 't':
595cf52e 4152 case 'N':
5477e8a0
L		 4153 do_sections++;
4154 do_section_details++;
595cf52e 4155 break;
252b5132 4156 case 'e':
b34976b6
AM		 4157 do_header++;
4158 do_sections++;
4159 do_segments++;
252b5132 4160 break;
a952a375 4161 case 'A':
b34976b6 4162 do_arch++;
a952a375 4163 break;
252b5132 4164 case 'D':
b34976b6 4165 do_using_dynamic++;
252b5132
RH		 4166 break;
4167 case 'r':
b34976b6 4168 do_reloc++;
252b5132 4169 break;
4d6ed7c8 4170 case 'u':
b34976b6 4171 do_unwind++;
4d6ed7c8 4172 break;
252b5132 4173 case 'h':
b34976b6 4174 do_header++;
252b5132
RH		 4175 break;
4176 case 'l':
b34976b6 4177 do_segments++;
252b5132
RH		 4178 break;
4179 case 's':
b34976b6 4180 do_syms++;
252b5132
RH		 4181 break;
4182 case 'S':
b34976b6 4183 do_sections++;
252b5132
RH		 4184 break;
4185 case 'd':
b34976b6 4186 do_dynamic++;
252b5132 4187 break;
a952a375 4188 case 'I':
b34976b6 4189 do_histogram++;
a952a375 4190 break;
779fe533 4191 case 'n':
b34976b6 4192 do_notes++;
779fe533 4193 break;
4145f1d5
NC		 4194 case 'c':
4195 do_archive_index++;
4196 break;
252b5132 4197 case 'x':
cf13d699 4198 request_dump (HEX_DUMP);
aef1f6d0 4199 break;
09c11c86 4200 case 'p':
cf13d699
NC		 4201 request_dump (STRING_DUMP);
4202 break;
4203 case 'R':
4204 request_dump (RELOC_DUMP);
09c11c86 4205 break;
0e602686
NC		 4206 case 'z':
4207 decompress_dumps++;
4208 break;
252b5132 4209 case 'w':
b34976b6 4210 do_dump++;
252b5132 4211 if (optarg == 0)
613ff48b
CC		 4212 {
4213 do_debugging = 1;
4214 dwarf_select_sections_all ();
4215 }
252b5132
RH		 4216 else
4217 {
4218 do_debugging = 0;
4cb93e3b 4219 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4220 }
4221 break;
2979dc34 4222 case OPTION_DEBUG_DUMP:
b34976b6 4223 do_dump++;
2979dc34
JJ		 4224 if (optarg == 0)
4225 do_debugging = 1;
4226 else
4227 {
2979dc34 4228 do_debugging = 0;
4cb93e3b 4229 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4230 }
4231 break;
fd2f0033
TT		 4232 case OPTION_DWARF_DEPTH:
4233 {
4234 char *cp;
4235
4236 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4237 }
4238 break;
4239 case OPTION_DWARF_START:
4240 {
4241 char *cp;
4242
4243 dwarf_start_die = strtoul (optarg, & cp, 0);
4244 }
4245 break;
4723351a
CC		 4246 case OPTION_DWARF_CHECK:
4247 dwarf_check = 1;
4248 break;
2c610e4b
L		 4249 case OPTION_DYN_SYMS:
4250 do_dyn_syms++;
4251 break;
252b5132
RH		 4252#ifdef SUPPORT_DISASSEMBLY
4253 case 'i':
cf13d699
NC		 4254 request_dump (DISASS_DUMP);
4255 break;
252b5132
RH		 4256#endif
4257 case 'v':
4258 print_version (program_name);
4259 break;
4260 case 'V':
b34976b6 4261 do_version++;
252b5132 4262 break;
d974e256 4263 case 'W':
b34976b6 4264 do_wide++;
d974e256 4265 break;
252b5132 4266 default:
252b5132
RH		 4267 /* xgettext:c-format */
4268 error (_("Invalid option '-%c'\n"), c);
4269 /* Drop through. */
4270 case '?':
92f01d61 4271 usage (stderr);
252b5132
RH		 4272 }
4273 }
4274
4d6ed7c8 4275 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4276 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4277 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4278 && !do_section_groups && !do_archive_index
4279 && !do_dyn_syms)
92f01d61 4280 usage (stderr);
252b5132
RH		 4281}
4282
4283static const char *
d3ba0551 4284get_elf_class (unsigned int elf_class)
252b5132 4285{
b34976b6 4286 static char buff[32];
103f02d3 4287
252b5132
RH		 4288 switch (elf_class)
4289 {
4290 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4291 case ELFCLASS32: return "ELF32";
4292 case ELFCLASS64: return "ELF64";
ab5e7794 4293 default:
e9e44622 4294 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4295 return buff;
252b5132
RH		 4296 }
4297}
4298
4299static const char *
d3ba0551 4300get_data_encoding (unsigned int encoding)
252b5132 4301{
b34976b6 4302 static char buff[32];
103f02d3 4303
252b5132
RH		 4304 switch (encoding)
4305 {
4306 case ELFDATANONE: return _("none");
33c63f9d
CM		 4307 case ELFDATA2LSB: return _("2's complement, little endian");
4308 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4309 default:
e9e44622 4310 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4311 return buff;
252b5132
RH		 4312 }
4313}
4314
252b5132 4315/* Decode the data held in 'elf_header'. */
ee42cf8c 4316
252b5132 4317static int
d3ba0551 4318process_file_header (void)
252b5132 4319{
b34976b6
AM		 4320 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4321 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4322 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4323 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4324 {
4325 error
4326 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4327 return 0;
4328 }
4329
2dc4cec1
L		 4330 init_dwarf_regnames (elf_header.e_machine);
4331
252b5132
RH		 4332 if (do_header)
4333 {
4334 int i;
4335
4336 printf (_("ELF Header:\n"));
4337 printf (_(" Magic: "));
b34976b6
AM		 4338 for (i = 0; i < EI_NIDENT; i++)
4339 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4340 printf ("\n");
4341 printf (_(" Class: %s\n"),
b34976b6 4342 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4343 printf (_(" Data: %s\n"),
b34976b6 4344 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4345 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4346 elf_header.e_ident[EI_VERSION],
4347 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4348 ? "(current)"
b34976b6 4349 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4350 ? _("<unknown: %lx>")
789be9f7 4351 : "")));
252b5132 4352 printf (_(" OS/ABI: %s\n"),
b34976b6 4353 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4354 printf (_(" ABI Version: %d\n"),
b34976b6 4355 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4356 printf (_(" Type: %s\n"),
4357 get_file_type (elf_header.e_type));
4358 printf (_(" Machine: %s\n"),
4359 get_machine_name (elf_header.e_machine));
4360 printf (_(" Version: 0x%lx\n"),
4361 (unsigned long) elf_header.e_version);
76da6bbe 4362
f7a99963
NC		 4363 printf (_(" Entry point address: "));
4364 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4365 printf (_("\n Start of program headers: "));
4366 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4367 printf (_(" (bytes into file)\n Start of section headers: "));
4368 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4369 printf (_(" (bytes into file)\n"));
76da6bbe 4370
252b5132
RH		 4371 printf (_(" Flags: 0x%lx%s\n"),
4372 (unsigned long) elf_header.e_flags,
4373 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4374 printf (_(" Size of this header: %ld (bytes)\n"),
4375 (long) elf_header.e_ehsize);
4376 printf (_(" Size of program headers: %ld (bytes)\n"),
4377 (long) elf_header.e_phentsize);
2046a35d 4378 printf (_(" Number of program headers: %ld"),
252b5132 4379 (long) elf_header.e_phnum);
2046a35d
AM		 4380 if (section_headers != NULL
4381 && elf_header.e_phnum == PN_XNUM
4382 && section_headers[0].sh_info != 0)
cc5914eb 4383 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4384 putc ('\n', stdout);
252b5132
RH		 4385 printf (_(" Size of section headers: %ld (bytes)\n"),
4386 (long) elf_header.e_shentsize);
560f3c1c 4387 printf (_(" Number of section headers: %ld"),
252b5132 4388 (long) elf_header.e_shnum);
4fbb74a6 4389 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4390 printf (" (%ld)", (long) section_headers[0].sh_size);
4391 putc ('\n', stdout);
4392 printf (_(" Section header string table index: %ld"),
252b5132 4393 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4394 if (section_headers != NULL
4395 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4396 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4397 else if (elf_header.e_shstrndx != SHN_UNDEF
4398 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4399 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4400 putc ('\n', stdout);
4401 }
4402
4403 if (section_headers != NULL)
4404 {
2046a35d
AM		 4405 if (elf_header.e_phnum == PN_XNUM
4406 && section_headers[0].sh_info != 0)
4407 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4408 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4409 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4410 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4411 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4412 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4413 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4414 free (section_headers);
4415 section_headers = NULL;
252b5132 4416 }
103f02d3 4417
9ea033b2
NC		 4418 return 1;
4419}
4420
e0a31db1 4421static bfd_boolean
91d6fa6a 4422get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4423{
2cf0635d
NC		 4424 Elf32_External_Phdr * phdrs;
4425 Elf32_External_Phdr * external;
4426 Elf_Internal_Phdr * internal;
b34976b6 4427 unsigned int i;
e0a31db1
NC		 4428 unsigned int size = elf_header.e_phentsize;
4429 unsigned int num = elf_header.e_phnum;
4430
4431 /* PR binutils/17531: Cope with unexpected section header sizes. */
4432 if (size == 0 || num == 0)
4433 return FALSE;
4434 if (size < sizeof * phdrs)
4435 {
4436 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4437 return FALSE;
4438 }
4439 if (size > sizeof * phdrs)
4440 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4441
3f5e193b 4442 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4443 size, num, _("program headers"));
4444 if (phdrs == NULL)
4445 return FALSE;
9ea033b2 4446
91d6fa6a 4447 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4448 i < elf_header.e_phnum;
b34976b6 4449 i++, internal++, external++)
252b5132 4450 {
9ea033b2
NC		 4451 internal->p_type = BYTE_GET (external->p_type);
4452 internal->p_offset = BYTE_GET (external->p_offset);
4453 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4454 internal->p_paddr = BYTE_GET (external->p_paddr);
4455 internal->p_filesz = BYTE_GET (external->p_filesz);
4456 internal->p_memsz = BYTE_GET (external->p_memsz);
4457 internal->p_flags = BYTE_GET (external->p_flags);
4458 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4459 }
4460
9ea033b2 4461 free (phdrs);
e0a31db1 4462 return TRUE;
252b5132
RH		 4463}
4464
e0a31db1 4465static bfd_boolean
91d6fa6a 4466get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4467{
2cf0635d
NC		 4468 Elf64_External_Phdr * phdrs;
4469 Elf64_External_Phdr * external;
4470 Elf_Internal_Phdr * internal;
b34976b6 4471 unsigned int i;
e0a31db1
NC		 4472 unsigned int size = elf_header.e_phentsize;
4473 unsigned int num = elf_header.e_phnum;
4474
4475 /* PR binutils/17531: Cope with unexpected section header sizes. */
4476 if (size == 0 || num == 0)
4477 return FALSE;
4478 if (size < sizeof * phdrs)
4479 {
4480 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4481 return FALSE;
4482 }
4483 if (size > sizeof * phdrs)
4484 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4485
3f5e193b 4486 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4487 size, num, _("program headers"));
a6e9f9df 4488 if (!phdrs)
e0a31db1 4489 return FALSE;
9ea033b2 4490
91d6fa6a 4491 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4492 i < elf_header.e_phnum;
b34976b6 4493 i++, internal++, external++)
9ea033b2
NC		 4494 {
4495 internal->p_type = BYTE_GET (external->p_type);
4496 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4497 internal->p_offset = BYTE_GET (external->p_offset);
4498 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4499 internal->p_paddr = BYTE_GET (external->p_paddr);
4500 internal->p_filesz = BYTE_GET (external->p_filesz);
4501 internal->p_memsz = BYTE_GET (external->p_memsz);
4502 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4503 }
4504
4505 free (phdrs);
e0a31db1 4506 return TRUE;
9ea033b2 4507}
252b5132 4508
d93f0186
NC		 4509/* Returns 1 if the program headers were read into `program_headers'. */
4510
4511static int
2cf0635d 4512get_program_headers (FILE * file)
d93f0186 4513{
2cf0635d 4514 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4515
4516 /* Check cache of prior read. */
4517 if (program_headers != NULL)
4518 return 1;
4519
3f5e193b
NC		 4520 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4521 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4522
4523 if (phdrs == NULL)
4524 {
8b73c356
NC		 4525 error (_("Out of memory reading %u program headers\n"),
4526 elf_header.e_phnum);
d93f0186
NC		 4527 return 0;
4528 }
4529
4530 if (is_32bit_elf
4531 ? get_32bit_program_headers (file, phdrs)
4532 : get_64bit_program_headers (file, phdrs))
4533 {
4534 program_headers = phdrs;
4535 return 1;
4536 }
4537
4538 free (phdrs);
4539 return 0;
4540}
4541
2f62977e
NC		 4542/* Returns 1 if the program headers were loaded. */
4543
252b5132 4544static int
2cf0635d 4545process_program_headers (FILE * file)
252b5132 4546{
2cf0635d 4547 Elf_Internal_Phdr * segment;
b34976b6 4548 unsigned int i;
252b5132
RH		 4549
4550 if (elf_header.e_phnum == 0)
4551 {
82f2dbf7
NC		 4552 /* PR binutils/12467. */
4553 if (elf_header.e_phoff != 0)
4554 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4555 " header offset, but no program headers\n"));
82f2dbf7 4556 else if (do_segments)
252b5132 4557 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4558 return 0;
252b5132
RH		 4559 }
4560
4561 if (do_segments && !do_header)
4562 {
f7a99963
NC		 4563 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4564 printf (_("Entry point "));
4565 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4566 printf (_("\nThere are %d program headers, starting at offset "),
4567 elf_header.e_phnum);
4568 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4569 printf ("\n");
252b5132
RH		 4570 }
4571
d93f0186 4572 if (! get_program_headers (file))
252b5132 4573 return 0;
103f02d3 4574
252b5132
RH		 4575 if (do_segments)
4576 {
3a1a2036
NC		 4577 if (elf_header.e_phnum > 1)
4578 printf (_("\nProgram Headers:\n"));
4579 else
4580 printf (_("\nProgram Headers:\n"));
76da6bbe 4581
f7a99963
NC		 4582 if (is_32bit_elf)
4583 printf
4584 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4585 else if (do_wide)
4586 printf
4587 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4588 else
4589 {
4590 printf
4591 (_(" Type Offset VirtAddr PhysAddr\n"));
4592 printf
4593 (_(" FileSiz MemSiz Flags Align\n"));
4594 }
252b5132
RH		 4595 }
4596
252b5132 4597 dynamic_addr = 0;
1b228002 4598 dynamic_size = 0;
252b5132
RH		 4599
4600 for (i = 0, segment = program_headers;
4601 i < elf_header.e_phnum;
b34976b6 4602 i++, segment++)
252b5132
RH		 4603 {
4604 if (do_segments)
4605 {
103f02d3 4606 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4607
4608 if (is_32bit_elf)
4609 {
4610 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4611 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4612 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4613 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4614 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4615 printf ("%c%c%c ",
4616 (segment->p_flags & PF_R ? 'R' : ' '),
4617 (segment->p_flags & PF_W ? 'W' : ' '),
4618 (segment->p_flags & PF_X ? 'E' : ' '));
4619 printf ("%#lx", (unsigned long) segment->p_align);
4620 }
d974e256
JJ		 4621 else if (do_wide)
4622 {
4623 if ((unsigned long) segment->p_offset == segment->p_offset)
4624 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4625 else
4626 {
4627 print_vma (segment->p_offset, FULL_HEX);
4628 putchar (' ');
4629 }
4630
4631 print_vma (segment->p_vaddr, FULL_HEX);
4632 putchar (' ');
4633 print_vma (segment->p_paddr, FULL_HEX);
4634 putchar (' ');
4635
4636 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4637 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4638 else
4639 {
4640 print_vma (segment->p_filesz, FULL_HEX);
4641 putchar (' ');
4642 }
4643
4644 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4645 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4646 else
4647 {
f48e6c45 4648 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4649 }
4650
4651 printf (" %c%c%c ",
4652 (segment->p_flags & PF_R ? 'R' : ' '),
4653 (segment->p_flags & PF_W ? 'W' : ' '),
4654 (segment->p_flags & PF_X ? 'E' : ' '));
4655
4656 if ((unsigned long) segment->p_align == segment->p_align)
4657 printf ("%#lx", (unsigned long) segment->p_align);
4658 else
4659 {
4660 print_vma (segment->p_align, PREFIX_HEX);
4661 }
4662 }
f7a99963
NC		 4663 else
4664 {
4665 print_vma (segment->p_offset, FULL_HEX);
4666 putchar (' ');
4667 print_vma (segment->p_vaddr, FULL_HEX);
4668 putchar (' ');
4669 print_vma (segment->p_paddr, FULL_HEX);
4670 printf ("\n ");
4671 print_vma (segment->p_filesz, FULL_HEX);
4672 putchar (' ');
4673 print_vma (segment->p_memsz, FULL_HEX);
4674 printf (" %c%c%c ",
4675 (segment->p_flags & PF_R ? 'R' : ' '),
4676 (segment->p_flags & PF_W ? 'W' : ' '),
4677 (segment->p_flags & PF_X ? 'E' : ' '));
4678 print_vma (segment->p_align, HEX);
4679 }
252b5132
RH		 4680 }
4681
f54498b4
NC		 4682 if (do_segments)
4683 putc ('\n', stdout);
4684
252b5132
RH		 4685 switch (segment->p_type)
4686 {
252b5132
RH		 4687 case PT_DYNAMIC:
4688 if (dynamic_addr)
4689 error (_("more than one dynamic segment\n"));
4690
20737c13
AM		 4691 /* By default, assume that the .dynamic section is the first
4692 section in the DYNAMIC segment. */
4693 dynamic_addr = segment->p_offset;
4694 dynamic_size = segment->p_filesz;
f54498b4
NC		 4695 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4696 if (dynamic_addr + dynamic_size >= current_file_size)
4697 {
4698 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4699 dynamic_addr = dynamic_size = 0;
4700 }
20737c13 4701
b2d38a17
NC		 4702 /* Try to locate the .dynamic section. If there is
4703 a section header table, we can easily locate it. */
4704 if (section_headers != NULL)
4705 {
2cf0635d 4706 Elf_Internal_Shdr * sec;
b2d38a17 4707
89fac5e3
RS		 4708 sec = find_section (".dynamic");
4709 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4710 {
28f997cf
TG		 4711 /* A corresponding .dynamic section is expected, but on
4712 IA-64/OpenVMS it is OK for it to be missing. */
4713 if (!is_ia64_vms ())
4714 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4715 break;
4716 }
4717
42bb2e33 4718 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4719 {
4720 dynamic_size = 0;
4721 break;
4722 }
42bb2e33 4723
b2d38a17
NC		 4724 dynamic_addr = sec->sh_offset;
4725 dynamic_size = sec->sh_size;
4726
4727 if (dynamic_addr < segment->p_offset
4728 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4729 warn (_("the .dynamic section is not contained"
4730 " within the dynamic segment\n"));
b2d38a17 4731 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4732 warn (_("the .dynamic section is not the first section"
4733 " in the dynamic segment.\n"));
b2d38a17 4734 }
252b5132
RH		 4735 break;
4736
4737 case PT_INTERP:
fb52b2f4
NC		 4738 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4739 SEEK_SET))
252b5132
RH		 4740 error (_("Unable to find program interpreter name\n"));
4741 else
4742 {
f8eae8b2 4743 char fmt [32];
9495b2e6 4744 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4745
4746 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4747 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4748
252b5132 4749 program_interpreter[0] = 0;
7bd7b3ef
AM		 4750 if (fscanf (file, fmt, program_interpreter) <= 0)
4751 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4752
4753 if (do_segments)
f54498b4 4754 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4755 program_interpreter);
4756 }
4757 break;
4758 }
252b5132
RH		 4759 }
4760
c256ffe7 4761 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4762 {
4763 printf (_("\n Section to Segment mapping:\n"));
4764 printf (_(" Segment Sections...\n"));
4765
252b5132
RH		 4766 for (i = 0; i < elf_header.e_phnum; i++)
4767 {
9ad5cbcf 4768 unsigned int j;
2cf0635d 4769 Elf_Internal_Shdr * section;
252b5132
RH		 4770
4771 segment = program_headers + i;
b391a3e3 4772 section = section_headers + 1;
252b5132
RH		 4773
4774 printf (" %2.2d ", i);
4775
b34976b6 4776 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4777 {
f4638467
AM		 4778 if (!ELF_TBSS_SPECIAL (section, segment)
4779 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4780 printf ("%s ", printable_section_name (section));
252b5132
RH		 4781 }
4782
4783 putc ('\n',stdout);
4784 }
4785 }
4786
252b5132
RH		 4787 return 1;
4788}
4789
4790
d93f0186
NC		 4791/* Find the file offset corresponding to VMA by using the program headers. */
4792
4793static long
2cf0635d 4794offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4795{
2cf0635d 4796 Elf_Internal_Phdr * seg;
d93f0186
NC		 4797
4798 if (! get_program_headers (file))
4799 {
4800 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4801 return (long) vma;
4802 }
4803
4804 for (seg = program_headers;
4805 seg < program_headers + elf_header.e_phnum;
4806 ++seg)
4807 {
4808 if (seg->p_type != PT_LOAD)
4809 continue;
4810
4811 if (vma >= (seg->p_vaddr & -seg->p_align)
4812 && vma + size <= seg->p_vaddr + seg->p_filesz)
4813 return vma - seg->p_vaddr + seg->p_offset;
4814 }
4815
4816 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4817 (unsigned long) vma);
d93f0186
NC		 4818 return (long) vma;
4819}
4820
4821
049b0c3a
NC		 4822/* Allocate memory and load the sections headers into the global pointer
4823 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4824 generate any error messages if the load fails. */
4825
4826static bfd_boolean
4827get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4828{
2cf0635d
NC		 4829 Elf32_External_Shdr * shdrs;
4830 Elf_Internal_Shdr * internal;
b34976b6 4831 unsigned int i;
049b0c3a
NC		 4832 unsigned int size = elf_header.e_shentsize;
4833 unsigned int num = probe ? 1 : elf_header.e_shnum;
4834
4835 /* PR binutils/17531: Cope with unexpected section header sizes. */
4836 if (size == 0 || num == 0)
4837 return FALSE;
4838 if (size < sizeof * shdrs)
4839 {
4840 if (! probe)
4841 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4842 return FALSE;
4843 }
4844 if (!probe && size > sizeof * shdrs)
4845 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4846
3f5e193b 4847 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4848 size, num,
4849 probe ? NULL : _("section headers"));
4850 if (shdrs == NULL)
4851 return FALSE;
252b5132 4852
049b0c3a
NC		 4853 if (section_headers != NULL)
4854 free (section_headers);
3f5e193b
NC		 4855 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4856 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4857 if (section_headers == NULL)
4858 {
049b0c3a 4859 if (!probe)
8b73c356 4860 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4861 return FALSE;
252b5132
RH		 4862 }
4863
4864 for (i = 0, internal = section_headers;
560f3c1c 4865 i < num;
b34976b6 4866 i++, internal++)
252b5132
RH		 4867 {
4868 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4869 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4870 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4871 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4872 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4873 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4874 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4875 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4876 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4877 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4878 }
4879
4880 free (shdrs);
049b0c3a 4881 return TRUE;
252b5132
RH		 4882}
4883
049b0c3a
NC		 4884static bfd_boolean
4885get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4886{
2cf0635d
NC		 4887 Elf64_External_Shdr * shdrs;
4888 Elf_Internal_Shdr * internal;
b34976b6 4889 unsigned int i;
049b0c3a
NC		 4890 unsigned int size = elf_header.e_shentsize;
4891 unsigned int num = probe ? 1 : elf_header.e_shnum;
4892
4893 /* PR binutils/17531: Cope with unexpected section header sizes. */
4894 if (size == 0 || num == 0)
4895 return FALSE;
4896 if (size < sizeof * shdrs)
4897 {
4898 if (! probe)
4899 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4900 return FALSE;
4901 }
4902 if (! probe && size > sizeof * shdrs)
4903 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4904
3f5e193b 4905 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4906 size, num,
4907 probe ? NULL : _("section headers"));
4908 if (shdrs == NULL)
4909 return FALSE;
9ea033b2 4910
049b0c3a
NC		 4911 if (section_headers != NULL)
4912 free (section_headers);
3f5e193b
NC		 4913 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4914 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4915 if (section_headers == NULL)
4916 {
049b0c3a 4917 if (! probe)
8b73c356 4918 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4919 return FALSE;
9ea033b2
NC		 4920 }
4921
4922 for (i = 0, internal = section_headers;
560f3c1c 4923 i < num;
b34976b6 4924 i++, internal++)
9ea033b2
NC		 4925 {
4926 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4927 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4928 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4929 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4930 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4931 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4932 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4933 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4934 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4935 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4936 }
4937
4938 free (shdrs);
049b0c3a 4939 return TRUE;
9ea033b2
NC		 4940}
4941
252b5132 4942static Elf_Internal_Sym *
ba5cdace
NC		 4943get_32bit_elf_symbols (FILE * file,
4944 Elf_Internal_Shdr * section,
4945 unsigned long * num_syms_return)
252b5132 4946{
ba5cdace 4947 unsigned long number = 0;
dd24e3da 4948 Elf32_External_Sym * esyms = NULL;
ba5cdace 4949 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4950 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4951 Elf_Internal_Sym * psym;
b34976b6 4952 unsigned int j;
252b5132 4953
c9c1d674
EG		 4954 if (section->sh_size == 0)
4955 {
4956 if (num_syms_return != NULL)
4957 * num_syms_return = 0;
4958 return NULL;
4959 }
4960
dd24e3da 4961 /* Run some sanity checks first. */
c9c1d674 4962 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4963 {
c9c1d674
EG		 4964 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4965 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4966 goto exit_point;
dd24e3da
NC		 4967 }
4968
f54498b4
NC		 4969 if (section->sh_size > current_file_size)
4970 {
4971 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4972 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4973 goto exit_point;
4974 }
4975
dd24e3da
NC		 4976 number = section->sh_size / section->sh_entsize;
4977
4978 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4979 {
c9c1d674 4980 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4981 (unsigned long) section->sh_size,
4982 printable_section_name (section),
4983 (unsigned long) section->sh_entsize);
ba5cdace 4984 goto exit_point;
dd24e3da
NC		 4985 }
4986
3f5e193b
NC		 4987 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4988 section->sh_size, _("symbols"));
dd24e3da 4989 if (esyms == NULL)
ba5cdace 4990 goto exit_point;
252b5132 4991
9ad5cbcf
AM		 4992 shndx = NULL;
4993 if (symtab_shndx_hdr != NULL
4994 && (symtab_shndx_hdr->sh_link
4fbb74a6 4995 == (unsigned long) (section - section_headers)))
9ad5cbcf 4996 {
3f5e193b
NC		 4997 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4998 symtab_shndx_hdr->sh_offset,
4999 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5000 _("symbol table section indicies"));
dd24e3da
NC		 5001 if (shndx == NULL)
5002 goto exit_point;
c9c1d674
EG		 5003 /* PR17531: file: heap-buffer-overflow */
5004 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5005 {
5006 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5007 printable_section_name (symtab_shndx_hdr),
5008 (unsigned long) symtab_shndx_hdr->sh_size,
5009 (unsigned long) section->sh_size);
5010 goto exit_point;
5011 }
9ad5cbcf
AM		 5012 }
5013
3f5e193b 5014 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5015
5016 if (isyms == NULL)
5017 {
8b73c356
NC		 5018 error (_("Out of memory reading %lu symbols\n"),
5019 (unsigned long) number);
dd24e3da 5020 goto exit_point;
252b5132
RH		 5021 }
5022
dd24e3da 5023 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5024 {
5025 psym->st_name = BYTE_GET (esyms[j].st_name);
5026 psym->st_value = BYTE_GET (esyms[j].st_value);
5027 psym->st_size = BYTE_GET (esyms[j].st_size);
5028 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5029 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5030 psym->st_shndx
5031 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5032 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5033 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5034 psym->st_info = BYTE_GET (esyms[j].st_info);
5035 psym->st_other = BYTE_GET (esyms[j].st_other);
5036 }
5037
dd24e3da 5038 exit_point:
ba5cdace 5039 if (shndx != NULL)
9ad5cbcf 5040 free (shndx);
ba5cdace 5041 if (esyms != NULL)
dd24e3da 5042 free (esyms);
252b5132 5043
ba5cdace
NC		 5044 if (num_syms_return != NULL)
5045 * num_syms_return = isyms == NULL ? 0 : number;
5046
252b5132
RH		 5047 return isyms;
5048}
5049
9ea033b2 5050static Elf_Internal_Sym *
ba5cdace
NC		 5051get_64bit_elf_symbols (FILE * file,
5052 Elf_Internal_Shdr * section,
5053 unsigned long * num_syms_return)
9ea033b2 5054{
ba5cdace
NC		 5055 unsigned long number = 0;
5056 Elf64_External_Sym * esyms = NULL;
5057 Elf_External_Sym_Shndx * shndx = NULL;
5058 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5059 Elf_Internal_Sym * psym;
b34976b6 5060 unsigned int j;
9ea033b2 5061
c9c1d674
EG		 5062 if (section->sh_size == 0)
5063 {
5064 if (num_syms_return != NULL)
5065 * num_syms_return = 0;
5066 return NULL;
5067 }
5068
dd24e3da 5069 /* Run some sanity checks first. */
c9c1d674 5070 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5071 {
c9c1d674 5072 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5073 printable_section_name (section),
5074 (unsigned long) section->sh_entsize);
ba5cdace 5075 goto exit_point;
dd24e3da
NC		 5076 }
5077
f54498b4
NC		 5078 if (section->sh_size > current_file_size)
5079 {
5080 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5081 printable_section_name (section),
5082 (unsigned long) section->sh_size);
f54498b4
NC		 5083 goto exit_point;
5084 }
5085
dd24e3da
NC		 5086 number = section->sh_size / section->sh_entsize;
5087
5088 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5089 {
c9c1d674 5090 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5091 (unsigned long) section->sh_size,
5092 printable_section_name (section),
5093 (unsigned long) section->sh_entsize);
ba5cdace 5094 goto exit_point;
dd24e3da
NC		 5095 }
5096
3f5e193b
NC		 5097 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5098 section->sh_size, _("symbols"));
a6e9f9df 5099 if (!esyms)
ba5cdace 5100 goto exit_point;
9ea033b2 5101
9ad5cbcf
AM		 5102 if (symtab_shndx_hdr != NULL
5103 && (symtab_shndx_hdr->sh_link
4fbb74a6 5104 == (unsigned long) (section - section_headers)))
9ad5cbcf 5105 {
3f5e193b
NC		 5106 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5107 symtab_shndx_hdr->sh_offset,
5108 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5109 _("symbol table section indicies"));
ba5cdace
NC		 5110 if (shndx == NULL)
5111 goto exit_point;
c9c1d674
EG		 5112 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5113 {
5114 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5115 printable_section_name (symtab_shndx_hdr),
5116 (unsigned long) symtab_shndx_hdr->sh_size,
5117 (unsigned long) section->sh_size);
5118 goto exit_point;
5119 }
9ad5cbcf
AM		 5120 }
5121
3f5e193b 5122 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5123
5124 if (isyms == NULL)
5125 {
8b73c356
NC		 5126 error (_("Out of memory reading %lu symbols\n"),
5127 (unsigned long) number);
ba5cdace 5128 goto exit_point;
9ea033b2
NC		 5129 }
5130
ba5cdace 5131 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5132 {
5133 psym->st_name = BYTE_GET (esyms[j].st_name);
5134 psym->st_info = BYTE_GET (esyms[j].st_info);
5135 psym->st_other = BYTE_GET (esyms[j].st_other);
5136 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5137
4fbb74a6 5138 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5139 psym->st_shndx
5140 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5141 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5142 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5143
66543521
AM		 5144 psym->st_value = BYTE_GET (esyms[j].st_value);
5145 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5146 }
5147
ba5cdace
NC		 5148 exit_point:
5149 if (shndx != NULL)
9ad5cbcf 5150 free (shndx);
ba5cdace
NC		 5151 if (esyms != NULL)
5152 free (esyms);
5153
5154 if (num_syms_return != NULL)
5155 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5156
5157 return isyms;
5158}
5159
d1133906 5160static const char *
d3ba0551 5161get_elf_section_flags (bfd_vma sh_flags)
d1133906 5162{
5477e8a0 5163 static char buff[1024];
2cf0635d 5164 char * p = buff;
8d5ff12c 5165 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5166 int sindex;
5167 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5168 bfd_vma os_flags = 0;
5169 bfd_vma proc_flags = 0;
5170 bfd_vma unknown_flags = 0;
148b93f2 5171 static const struct
5477e8a0 5172 {
2cf0635d 5173 const char * str;
5477e8a0
L		 5174 int len;
5175 }
5176 flags [] =
5177 {
cfcac11d
NC		 5178 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5179 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5180 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5181 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5182 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5183 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5184 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5185 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5186 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5187 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5188 /* IA-64 specific. */
5189 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5190 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5191 /* IA-64 OpenVMS specific. */
5192 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5193 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5194 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5195 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5196 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5197 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5198 /* Generic. */
cfcac11d 5199 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5200 /* SPARC specific. */
77115a4a
L		 5201 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5202 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5203 };
5204
5205 if (do_section_details)
5206 {
8d5ff12c
L		 5207 sprintf (buff, "[%*.*lx]: ",
5208 field_size, field_size, (unsigned long) sh_flags);
5209 p += field_size + 4;
5477e8a0 5210 }
76da6bbe 5211
d1133906
NC		 5212 while (sh_flags)
5213 {
5214 bfd_vma flag;
5215
5216 flag = sh_flags & - sh_flags;
5217 sh_flags &= ~ flag;
76da6bbe 5218
5477e8a0 5219 if (do_section_details)
d1133906 5220 {
5477e8a0
L		 5221 switch (flag)
5222 {
91d6fa6a
NC		 5223 case SHF_WRITE: sindex = 0; break;
5224 case SHF_ALLOC: sindex = 1; break;
5225 case SHF_EXECINSTR: sindex = 2; break;
5226 case SHF_MERGE: sindex = 3; break;
5227 case SHF_STRINGS: sindex = 4; break;
5228 case SHF_INFO_LINK: sindex = 5; break;
5229 case SHF_LINK_ORDER: sindex = 6; break;
5230 case SHF_OS_NONCONFORMING: sindex = 7; break;
5231 case SHF_GROUP: sindex = 8; break;
5232 case SHF_TLS: sindex = 9; break;
18ae9cc1 5233 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5234 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5235
5477e8a0 5236 default:
91d6fa6a 5237 sindex = -1;
cfcac11d 5238 switch (elf_header.e_machine)
148b93f2 5239 {
cfcac11d 5240 case EM_IA_64:
148b93f2 5241 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5242 sindex = 10;
148b93f2 5243 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5244 sindex = 11;
148b93f2
NC		 5245#ifdef BFD64
5246 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5247 switch (flag)
5248 {
91d6fa6a
NC		 5249 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5250 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5251 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5252 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5253 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5254 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5255 default: break;
5256 }
5257#endif
cfcac11d
NC		 5258 break;
5259
caa83f8b 5260 case EM_386:
22abe556 5261 case EM_IAMCU:
caa83f8b 5262 case EM_X86_64:
7f502d6c 5263 case EM_L1OM:
7a9068fe 5264 case EM_K1OM:
cfcac11d
NC		 5265 case EM_OLD_SPARCV9:
5266 case EM_SPARC32PLUS:
5267 case EM_SPARCV9:
5268 case EM_SPARC:
18ae9cc1 5269 if (flag == SHF_ORDERED)
91d6fa6a 5270 sindex = 19;
cfcac11d
NC		 5271 break;
5272 default:
5273 break;
148b93f2 5274 }
5477e8a0
L		 5275 }
5276
91d6fa6a 5277 if (sindex != -1)
5477e8a0 5278 {
8d5ff12c
L		 5279 if (p != buff + field_size + 4)
5280 {
5281 if (size < (10 + 2))
bee0ee85
NC		 5282 {
5283 warn (_("Internal error: not enough buffer room for section flag info"));
5284 return _("<unknown>");
5285 }
8d5ff12c
L		 5286 size -= 2;
5287 *p++ = ',';
5288 *p++ = ' ';
5289 }
5290
91d6fa6a
NC		 5291 size -= flags [sindex].len;
5292 p = stpcpy (p, flags [sindex].str);
5477e8a0 5293 }
3b22753a 5294 else if (flag & SHF_MASKOS)
8d5ff12c 5295 os_flags |= flag;
d1133906 5296 else if (flag & SHF_MASKPROC)
8d5ff12c 5297 proc_flags |= flag;
d1133906 5298 else
8d5ff12c 5299 unknown_flags |= flag;
5477e8a0
L		 5300 }
5301 else
5302 {
5303 switch (flag)
5304 {
5305 case SHF_WRITE: *p = 'W'; break;
5306 case SHF_ALLOC: *p = 'A'; break;
5307 case SHF_EXECINSTR: *p = 'X'; break;
5308 case SHF_MERGE: *p = 'M'; break;
5309 case SHF_STRINGS: *p = 'S'; break;
5310 case SHF_INFO_LINK: *p = 'I'; break;
5311 case SHF_LINK_ORDER: *p = 'L'; break;
5312 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5313 case SHF_GROUP: *p = 'G'; break;
5314 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5315 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5316 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5317
5318 default:
8a9036a4 5319 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5320 || elf_header.e_machine == EM_L1OM
5321 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5322 && flag == SHF_X86_64_LARGE)
5323 *p = 'l';
5324 else if (flag & SHF_MASKOS)
5325 {
5326 *p = 'o';
5327 sh_flags &= ~ SHF_MASKOS;
5328 }
5329 else if (flag & SHF_MASKPROC)
5330 {
5331 *p = 'p';
5332 sh_flags &= ~ SHF_MASKPROC;
5333 }
5334 else
5335 *p = 'x';
5336 break;
5337 }
5338 p++;
d1133906
NC		 5339 }
5340 }
76da6bbe 5341
8d5ff12c
L		 5342 if (do_section_details)
5343 {
5344 if (os_flags)
5345 {
5346 size -= 5 + field_size;
5347 if (p != buff + field_size + 4)
5348 {
5349 if (size < (2 + 1))
bee0ee85
NC		 5350 {
5351 warn (_("Internal error: not enough buffer room for section flag info"));
5352 return _("<unknown>");
5353 }
8d5ff12c
L		 5354 size -= 2;
5355 *p++ = ',';
5356 *p++ = ' ';
5357 }
5358 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5359 (unsigned long) os_flags);
5360 p += 5 + field_size;
5361 }
5362 if (proc_flags)
5363 {
5364 size -= 7 + field_size;
5365 if (p != buff + field_size + 4)
5366 {
5367 if (size < (2 + 1))
bee0ee85
NC		 5368 {
5369 warn (_("Internal error: not enough buffer room for section flag info"));
5370 return _("<unknown>");
5371 }
8d5ff12c
L		 5372 size -= 2;
5373 *p++ = ',';
5374 *p++ = ' ';
5375 }
5376 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5377 (unsigned long) proc_flags);
5378 p += 7 + field_size;
5379 }
5380 if (unknown_flags)
5381 {
5382 size -= 10 + field_size;
5383 if (p != buff + field_size + 4)
5384 {
5385 if (size < (2 + 1))
bee0ee85
NC		 5386 {
5387 warn (_("Internal error: not enough buffer room for section flag info"));
5388 return _("<unknown>");
5389 }
8d5ff12c
L		 5390 size -= 2;
5391 *p++ = ',';
5392 *p++ = ' ';
5393 }
2b692964 5394 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5395 (unsigned long) unknown_flags);
5396 p += 10 + field_size;
5397 }
5398 }
5399
e9e44622 5400 *p = '\0';
d1133906
NC		 5401 return buff;
5402}
5403
77115a4a
L		 5404static unsigned int
5405get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5406{
5407 if (is_32bit_elf)
5408 {
5409 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5410 chdr->ch_type = BYTE_GET (echdr->ch_type);
5411 chdr->ch_size = BYTE_GET (echdr->ch_size);
5412 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5413 return sizeof (*echdr);
5414 }
5415 else
5416 {
5417 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5418 chdr->ch_type = BYTE_GET (echdr->ch_type);
5419 chdr->ch_size = BYTE_GET (echdr->ch_size);
5420 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5421 return sizeof (*echdr);
5422 }
5423}
5424
252b5132 5425static int
2cf0635d 5426process_section_headers (FILE * file)
252b5132 5427{
2cf0635d 5428 Elf_Internal_Shdr * section;
b34976b6 5429 unsigned int i;
252b5132
RH		 5430
5431 section_headers = NULL;
5432
5433 if (elf_header.e_shnum == 0)
5434 {
82f2dbf7
NC		 5435 /* PR binutils/12467. */
5436 if (elf_header.e_shoff != 0)
5437 warn (_("possibly corrupt ELF file header - it has a non-zero"
5438 " section header offset, but no section headers\n"));
5439 else if (do_sections)
252b5132
RH		 5440 printf (_("\nThere are no sections in this file.\n"));
5441
5442 return 1;
5443 }
5444
5445 if (do_sections && !do_header)
9ea033b2 5446 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5447 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5448
9ea033b2
NC		 5449 if (is_32bit_elf)
5450 {
049b0c3a 5451 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5452 return 0;
5453 }
049b0c3a 5454 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5455 return 0;
5456
5457 /* Read in the string table, so that we have names to display. */
0b49d371 5458 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5459 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5460 {
4fbb74a6 5461 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5462
c256ffe7
JJ		 5463 if (section->sh_size != 0)
5464 {
3f5e193b
NC		 5465 string_table = (char *) get_data (NULL, file, section->sh_offset,
5466 1, section->sh_size,
5467 _("string table"));
0de14b54 5468
c256ffe7
JJ		 5469 string_table_length = string_table != NULL ? section->sh_size : 0;
5470 }
252b5132
RH		 5471 }
5472
5473 /* Scan the sections for the dynamic symbol table
e3c8793a 5474 and dynamic string table and debug sections. */
252b5132
RH		 5475 dynamic_symbols = NULL;
5476 dynamic_strings = NULL;
5477 dynamic_syminfo = NULL;
f1ef08cb 5478 symtab_shndx_hdr = NULL;
103f02d3 5479
89fac5e3
RS		 5480 eh_addr_size = is_32bit_elf ? 4 : 8;
5481 switch (elf_header.e_machine)
5482 {
5483 case EM_MIPS:
5484 case EM_MIPS_RS3_LE:
5485 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5486 FDE addresses. However, the ABI also has a semi-official ILP32
5487 variant for which the normal FDE address size rules apply.
5488
5489 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5490 section, where XX is the size of longs in bits. Unfortunately,
5491 earlier compilers provided no way of distinguishing ILP32 objects
5492 from LP64 objects, so if there's any doubt, we should assume that
5493 the official LP64 form is being used. */
5494 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5495 && find_section (".gcc_compiled_long32") == NULL)
5496 eh_addr_size = 8;
5497 break;
0f56a26a
DD		 5498
5499 case EM_H8_300:
5500 case EM_H8_300H:
5501 switch (elf_header.e_flags & EF_H8_MACH)
5502 {
5503 case E_H8_MACH_H8300:
5504 case E_H8_MACH_H8300HN:
5505 case E_H8_MACH_H8300SN:
5506 case E_H8_MACH_H8300SXN:
5507 eh_addr_size = 2;
5508 break;
5509 case E_H8_MACH_H8300H:
5510 case E_H8_MACH_H8300S:
5511 case E_H8_MACH_H8300SX:
5512 eh_addr_size = 4;
5513 break;
5514 }
f4236fe4
DD		 5515 break;
5516
ff7eeb89 5517 case EM_M32C_OLD:
f4236fe4
DD		 5518 case EM_M32C:
5519 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5520 {
5521 case EF_M32C_CPU_M16C:
5522 eh_addr_size = 2;
5523 break;
5524 }
5525 break;
89fac5e3
RS		 5526 }
5527
76ca31c0
NC		 5528#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5529 do \
5530 { \
5531 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5532 if (section->sh_entsize != expected_entsize) \
9dd3a467 5533 { \
76ca31c0
NC		 5534 char buf[40]; \
5535 sprintf_vma (buf, section->sh_entsize); \
5536 /* Note: coded this way so that there is a single string for \
5537 translation. */ \
5538 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5539 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5540 (unsigned) expected_entsize); \
9dd3a467 5541 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5542 } \
5543 } \
08d8fa11 5544 while (0)
9dd3a467
NC		 5545
5546#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5547 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5548 sizeof (Elf64_External_##type))
5549
252b5132
RH		 5550 for (i = 0, section = section_headers;
5551 i < elf_header.e_shnum;
b34976b6 5552 i++, section++)
252b5132 5553 {
2cf0635d 5554 char * name = SECTION_NAME (section);
252b5132
RH		 5555
5556 if (section->sh_type == SHT_DYNSYM)
5557 {
5558 if (dynamic_symbols != NULL)
5559 {
5560 error (_("File contains multiple dynamic symbol tables\n"));
5561 continue;
5562 }
5563
08d8fa11 5564 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5565 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5566 }
5567 else if (section->sh_type == SHT_STRTAB
18bd398b 5568 && streq (name, ".dynstr"))
252b5132
RH		 5569 {
5570 if (dynamic_strings != NULL)
5571 {
5572 error (_("File contains multiple dynamic string tables\n"));
5573 continue;
5574 }
5575
3f5e193b
NC		 5576 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5577 1, section->sh_size,
5578 _("dynamic strings"));
59245841 5579 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5580 }
9ad5cbcf
AM		 5581 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5582 {
5583 if (symtab_shndx_hdr != NULL)
5584 {
5585 error (_("File contains multiple symtab shndx tables\n"));
5586 continue;
5587 }
5588 symtab_shndx_hdr = section;
5589 }
08d8fa11
JJ		 5590 else if (section->sh_type == SHT_SYMTAB)
5591 CHECK_ENTSIZE (section, i, Sym);
5592 else if (section->sh_type == SHT_GROUP)
5593 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5594 else if (section->sh_type == SHT_REL)
5595 CHECK_ENTSIZE (section, i, Rel);
5596 else if (section->sh_type == SHT_RELA)
5597 CHECK_ENTSIZE (section, i, Rela);
252b5132 5598 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5599 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5600 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5601 || do_debug_str || do_debug_loc || do_debug_ranges
5602 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5603 && (const_strneq (name, ".debug_")
5604 || const_strneq (name, ".zdebug_")))
252b5132 5605 {
1b315056
CS		 5606 if (name[1] == 'z')
5607 name += sizeof (".zdebug_") - 1;
5608 else
5609 name += sizeof (".debug_") - 1;
252b5132
RH		 5610
5611 if (do_debugging
4723351a
CC		 5612 || (do_debug_info && const_strneq (name, "info"))
5613 || (do_debug_info && const_strneq (name, "types"))
5614 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5615 || (do_debug_lines && strcmp (name, "line") == 0)
5616 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5617 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5618 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5619 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5620 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5621 || (do_debug_aranges && const_strneq (name, "aranges"))
5622 || (do_debug_ranges && const_strneq (name, "ranges"))
5623 || (do_debug_frames && const_strneq (name, "frame"))
5624 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5625 || (do_debug_macinfo && const_strneq (name, "macro"))
5626 || (do_debug_str && const_strneq (name, "str"))
5627 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5628 || (do_debug_addr && const_strneq (name, "addr"))
5629 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5630 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5631 )
09c11c86 5632 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5633 }
a262ae96 5634 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5635 else if ((do_debugging || do_debug_info)
0112cd26 5636 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5637 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5638 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5639 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5640 else if (do_gdb_index && streq (name, ".gdb_index"))
5641 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5642 /* Trace sections for Itanium VMS. */
5643 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5644 || do_trace_aranges)
5645 && const_strneq (name, ".trace_"))
5646 {
5647 name += sizeof (".trace_") - 1;
5648
5649 if (do_debugging
5650 || (do_trace_info && streq (name, "info"))
5651 || (do_trace_abbrevs && streq (name, "abbrev"))
5652 || (do_trace_aranges && streq (name, "aranges"))
5653 )
5654 request_dump_bynumber (i, DEBUG_DUMP);
5655 }
252b5132
RH		 5656 }
5657
5658 if (! do_sections)
5659 return 1;
5660
3a1a2036
NC		 5661 if (elf_header.e_shnum > 1)
5662 printf (_("\nSection Headers:\n"));
5663 else
5664 printf (_("\nSection Header:\n"));
76da6bbe 5665
f7a99963 5666 if (is_32bit_elf)
595cf52e 5667 {
5477e8a0 5668 if (do_section_details)
595cf52e
L		 5669 {
5670 printf (_(" [Nr] Name\n"));
5477e8a0 5671 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5672 }
5673 else
5674 printf
5675 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5676 }
d974e256 5677 else if (do_wide)
595cf52e 5678 {
5477e8a0 5679 if (do_section_details)
595cf52e
L		 5680 {
5681 printf (_(" [Nr] Name\n"));
5477e8a0 5682 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5683 }
5684 else
5685 printf
5686 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5687 }
f7a99963
NC		 5688 else
5689 {
5477e8a0 5690 if (do_section_details)
595cf52e
L		 5691 {
5692 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5693 printf (_(" Type Address Offset Link\n"));
5694 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5695 }
5696 else
5697 {
5698 printf (_(" [Nr] Name Type Address Offset\n"));
5699 printf (_(" Size EntSize Flags Link Info Align\n"));
5700 }
f7a99963 5701 }
252b5132 5702
5477e8a0
L		 5703 if (do_section_details)
5704 printf (_(" Flags\n"));
5705
252b5132
RH		 5706 for (i = 0, section = section_headers;
5707 i < elf_header.e_shnum;
b34976b6 5708 i++, section++)
252b5132 5709 {
7bfd842d 5710 printf (" [%2u] ", i);
5477e8a0 5711 if (do_section_details)
74e1a04b 5712 printf ("%s\n ", printable_section_name (section));
595cf52e 5713 else
74e1a04b 5714 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5715
ea52a088
NC		 5716 printf (do_wide ? " %-15s " : " %-15.15s ",
5717 get_section_type_name (section->sh_type));
0b4362b0 5718
f7a99963
NC		 5719 if (is_32bit_elf)
5720 {
cfcac11d
NC		 5721 const char * link_too_big = NULL;
5722
f7a99963 5723 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5724
f7a99963
NC		 5725 printf ( " %6.6lx %6.6lx %2.2lx",
5726 (unsigned long) section->sh_offset,
5727 (unsigned long) section->sh_size,
5728 (unsigned long) section->sh_entsize);
d1133906 5729
5477e8a0
L		 5730 if (do_section_details)
5731 fputs (" ", stdout);
5732 else
5733 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5734
cfcac11d
NC		 5735 if (section->sh_link >= elf_header.e_shnum)
5736 {
5737 link_too_big = "";
5738 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5739 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5740 switch (elf_header.e_machine)
5741 {
caa83f8b 5742 case EM_386:
22abe556 5743 case EM_IAMCU:
caa83f8b 5744 case EM_X86_64:
7f502d6c 5745 case EM_L1OM:
7a9068fe 5746 case EM_K1OM:
cfcac11d
NC		 5747 case EM_OLD_SPARCV9:
5748 case EM_SPARC32PLUS:
5749 case EM_SPARCV9:
5750 case EM_SPARC:
5751 if (section->sh_link == (SHN_BEFORE & 0xffff))
5752 link_too_big = "BEFORE";
5753 else if (section->sh_link == (SHN_AFTER & 0xffff))
5754 link_too_big = "AFTER";
5755 break;
5756 default:
5757 break;
5758 }
5759 }
5760
5761 if (do_section_details)
5762 {
5763 if (link_too_big != NULL && * link_too_big)
5764 printf ("<%s> ", link_too_big);
5765 else
5766 printf ("%2u ", section->sh_link);
5767 printf ("%3u %2lu\n", section->sh_info,
5768 (unsigned long) section->sh_addralign);
5769 }
5770 else
5771 printf ("%2u %3u %2lu\n",
5772 section->sh_link,
5773 section->sh_info,
5774 (unsigned long) section->sh_addralign);
5775
5776 if (link_too_big && ! * link_too_big)
5777 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5778 i, section->sh_link);
f7a99963 5779 }
d974e256
JJ		 5780 else if (do_wide)
5781 {
5782 print_vma (section->sh_addr, LONG_HEX);
5783
5784 if ((long) section->sh_offset == section->sh_offset)
5785 printf (" %6.6lx", (unsigned long) section->sh_offset);
5786 else
5787 {
5788 putchar (' ');
5789 print_vma (section->sh_offset, LONG_HEX);
5790 }
5791
5792 if ((unsigned long) section->sh_size == section->sh_size)
5793 printf (" %6.6lx", (unsigned long) section->sh_size);
5794 else
5795 {
5796 putchar (' ');
5797 print_vma (section->sh_size, LONG_HEX);
5798 }
5799
5800 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5801 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5802 else
5803 {
5804 putchar (' ');
5805 print_vma (section->sh_entsize, LONG_HEX);
5806 }
5807
5477e8a0
L		 5808 if (do_section_details)
5809 fputs (" ", stdout);
5810 else
5811 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5812
72de5009 5813 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5814
5815 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5816 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5817 else
5818 {
5819 print_vma (section->sh_addralign, DEC);
5820 putchar ('\n');
5821 }
5822 }
5477e8a0 5823 else if (do_section_details)
595cf52e 5824 {
5477e8a0 5825 printf (" %-15.15s ",
595cf52e 5826 get_section_type_name (section->sh_type));
595cf52e
L		 5827 print_vma (section->sh_addr, LONG_HEX);
5828 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5829 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5830 else
5831 {
5832 printf (" ");
5833 print_vma (section->sh_offset, LONG_HEX);
5834 }
72de5009 5835 printf (" %u\n ", section->sh_link);
595cf52e 5836 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5837 putchar (' ');
595cf52e
L		 5838 print_vma (section->sh_entsize, LONG_HEX);
5839
72de5009
AM		 5840 printf (" %-16u %lu\n",
5841 section->sh_info,
595cf52e
L		 5842 (unsigned long) section->sh_addralign);
5843 }
f7a99963
NC		 5844 else
5845 {
5846 putchar (' ');
5847 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5848 if ((long) section->sh_offset == section->sh_offset)
5849 printf (" %8.8lx", (unsigned long) section->sh_offset);
5850 else
5851 {
5852 printf (" ");
5853 print_vma (section->sh_offset, LONG_HEX);
5854 }
f7a99963
NC		 5855 printf ("\n ");
5856 print_vma (section->sh_size, LONG_HEX);
5857 printf (" ");
5858 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5859
d1133906 5860 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5861
72de5009
AM		 5862 printf (" %2u %3u %lu\n",
5863 section->sh_link,
5864 section->sh_info,
f7a99963
NC		 5865 (unsigned long) section->sh_addralign);
5866 }
5477e8a0
L		 5867
5868 if (do_section_details)
77115a4a
L		 5869 {
5870 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5871 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5872 {
5873 /* Minimum section size is 12 bytes for 32-bit compression
5874 header + 12 bytes for compressed data header. */
5875 unsigned char buf[24];
5876 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5877 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5878 sizeof (buf), _("compression header")))
5879 {
5880 Elf_Internal_Chdr chdr;
5881 get_compression_header (&chdr, buf);
5882 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5883 printf (" ZLIB, ");
5884 else
5885 printf (_(" [<unknown>: 0x%x], "),
5886 chdr.ch_type);
5887 print_vma (chdr.ch_size, LONG_HEX);
5888 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5889 }
5890 }
5891 }
252b5132
RH		 5892 }
5893
5477e8a0 5894 if (!do_section_details)
3dbcc61d
NC		 5895 {
5896 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5897 || elf_header.e_machine == EM_L1OM
5898 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5899 printf (_("Key to Flags:\n\
5900 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5901 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5902 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5903 else
5904 printf (_("Key to Flags:\n\
e3c8793a 5905 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5906 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5907 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5908 }
d1133906 5909
252b5132
RH		 5910 return 1;
5911}
5912
f5842774
L		 5913static const char *
5914get_group_flags (unsigned int flags)
5915{
5916 static char buff[32];
5917 switch (flags)
5918 {
220453ec
AM		 5919 case 0:
5920 return "";
5921
f5842774 5922 case GRP_COMDAT:
220453ec 5923 return "COMDAT ";
f5842774
L		 5924
5925 default:
220453ec 5926 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5927 break;
5928 }
5929 return buff;
5930}
5931
5932static int
2cf0635d 5933process_section_groups (FILE * file)
f5842774 5934{
2cf0635d 5935 Elf_Internal_Shdr * section;
f5842774 5936 unsigned int i;
2cf0635d
NC		 5937 struct group * group;
5938 Elf_Internal_Shdr * symtab_sec;
5939 Elf_Internal_Shdr * strtab_sec;
5940 Elf_Internal_Sym * symtab;
ba5cdace 5941 unsigned long num_syms;
2cf0635d 5942 char * strtab;
c256ffe7 5943 size_t strtab_size;
d1f5c6e3
L		 5944
5945 /* Don't process section groups unless needed. */
5946 if (!do_unwind && !do_section_groups)
5947 return 1;
f5842774
L		 5948
5949 if (elf_header.e_shnum == 0)
5950 {
5951 if (do_section_groups)
82f2dbf7 5952 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5953
5954 return 1;
5955 }
5956
5957 if (section_headers == NULL)
5958 {
5959 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5960 /* PR 13622: This can happen with a corrupt ELF header. */
5961 return 0;
f5842774
L		 5962 }
5963
3f5e193b
NC		 5964 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5965 sizeof (struct group *));
e4b17d5c
L		 5966
5967 if (section_headers_groups == NULL)
5968 {
8b73c356
NC		 5969 error (_("Out of memory reading %u section group headers\n"),
5970 elf_header.e_shnum);
e4b17d5c
L		 5971 return 0;
5972 }
5973
f5842774 5974 /* Scan the sections for the group section. */
d1f5c6e3 5975 group_count = 0;
f5842774
L		 5976 for (i = 0, section = section_headers;
5977 i < elf_header.e_shnum;
5978 i++, section++)
e4b17d5c
L		 5979 if (section->sh_type == SHT_GROUP)
5980 group_count++;
5981
d1f5c6e3
L		 5982 if (group_count == 0)
5983 {
5984 if (do_section_groups)
5985 printf (_("\nThere are no section groups in this file.\n"));
5986
5987 return 1;
5988 }
5989
3f5e193b 5990 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5991
5992 if (section_groups == NULL)
5993 {
8b73c356
NC		 5994 error (_("Out of memory reading %lu groups\n"),
5995 (unsigned long) group_count);
e4b17d5c
L		 5996 return 0;
5997 }
5998
d1f5c6e3
L		 5999 symtab_sec = NULL;
6000 strtab_sec = NULL;
6001 symtab = NULL;
ba5cdace 6002 num_syms = 0;
d1f5c6e3 6003 strtab = NULL;
c256ffe7 6004 strtab_size = 0;
e4b17d5c
L		 6005 for (i = 0, section = section_headers, group = section_groups;
6006 i < elf_header.e_shnum;
6007 i++, section++)
f5842774
L		 6008 {
6009 if (section->sh_type == SHT_GROUP)
6010 {
74e1a04b
NC		 6011 const char * name = printable_section_name (section);
6012 const char * group_name;
2cf0635d
NC		 6013 unsigned char * start;
6014 unsigned char * indices;
f5842774 6015 unsigned int entry, j, size;
2cf0635d
NC		 6016 Elf_Internal_Shdr * sec;
6017 Elf_Internal_Sym * sym;
f5842774
L		 6018
6019 /* Get the symbol table. */
4fbb74a6
AM		 6020 if (section->sh_link >= elf_header.e_shnum
6021 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6022 != SHT_SYMTAB))
f5842774
L		 6023 {
6024 error (_("Bad sh_link in group section `%s'\n"), name);
6025 continue;
6026 }
d1f5c6e3
L		 6027
6028 if (symtab_sec != sec)
6029 {
6030 symtab_sec = sec;
6031 if (symtab)
6032 free (symtab);
ba5cdace 6033 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6034 }
f5842774 6035
dd24e3da
NC		 6036 if (symtab == NULL)
6037 {
6038 error (_("Corrupt header in group section `%s'\n"), name);
6039 continue;
6040 }
6041
ba5cdace
NC		 6042 if (section->sh_info >= num_syms)
6043 {
6044 error (_("Bad sh_info in group section `%s'\n"), name);
6045 continue;
6046 }
6047
f5842774
L		 6048 sym = symtab + section->sh_info;
6049
6050 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6051 {
4fbb74a6
AM		 6052 if (sym->st_shndx == 0
6053 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6054 {
6055 error (_("Bad sh_info in group section `%s'\n"), name);
6056 continue;
6057 }
ba2685cc 6058
4fbb74a6 6059 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6060 strtab_sec = NULL;
6061 if (strtab)
6062 free (strtab);
f5842774 6063 strtab = NULL;
c256ffe7 6064 strtab_size = 0;
f5842774
L		 6065 }
6066 else
6067 {
6068 /* Get the string table. */
4fbb74a6 6069 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6070 {
6071 strtab_sec = NULL;
6072 if (strtab)
6073 free (strtab);
6074 strtab = NULL;
6075 strtab_size = 0;
6076 }
6077 else if (strtab_sec
4fbb74a6 6078 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6079 {
6080 strtab_sec = sec;
6081 if (strtab)
6082 free (strtab);
071436c6 6083
3f5e193b 6084 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6085 1, strtab_sec->sh_size,
6086 _("string table"));
c256ffe7 6087 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6088 }
c256ffe7 6089 group_name = sym->st_name < strtab_size
2b692964 6090 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6091 }
6092
c9c1d674
EG		 6093 /* PR 17531: file: loop. */
6094 if (section->sh_entsize > section->sh_size)
6095 {
6096 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6097 printable_section_name (section),
8066deb1
AM		 6098 (unsigned long) section->sh_entsize,
6099 (unsigned long) section->sh_size);
c9c1d674
EG		 6100 break;
6101 }
6102
3f5e193b
NC		 6103 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6104 1, section->sh_size,
6105 _("section data"));
59245841
NC		 6106 if (start == NULL)
6107 continue;
f5842774
L		 6108
6109 indices = start;
6110 size = (section->sh_size / section->sh_entsize) - 1;
6111 entry = byte_get (indices, 4);
6112 indices += 4;
e4b17d5c
L		 6113
6114 if (do_section_groups)
6115 {
2b692964 6116 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6117 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6118
e4b17d5c
L		 6119 printf (_(" [Index] Name\n"));
6120 }
6121
6122 group->group_index = i;
6123
f5842774
L		 6124 for (j = 0; j < size; j++)
6125 {
2cf0635d 6126 struct group_list * g;
e4b17d5c 6127
f5842774
L		 6128 entry = byte_get (indices, 4);
6129 indices += 4;
6130
4fbb74a6 6131 if (entry >= elf_header.e_shnum)
391cb864 6132 {
57028622
NC		 6133 static unsigned num_group_errors = 0;
6134
6135 if (num_group_errors ++ < 10)
6136 {
6137 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6138 entry, i, elf_header.e_shnum - 1);
6139 if (num_group_errors == 10)
6140 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6141 }
391cb864
L		 6142 continue;
6143 }
391cb864 6144
4fbb74a6 6145 if (section_headers_groups [entry] != NULL)
e4b17d5c 6146 {
d1f5c6e3
L		 6147 if (entry)
6148 {
57028622
NC		 6149 static unsigned num_errs = 0;
6150
6151 if (num_errs ++ < 10)
6152 {
6153 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6154 entry, i,
6155 section_headers_groups [entry]->group_index);
6156 if (num_errs == 10)
6157 warn (_("Further error messages about already contained group sections suppressed\n"));
6158 }
d1f5c6e3
L		 6159 continue;
6160 }
6161 else
6162 {
6163 /* Intel C/C++ compiler may put section 0 in a
6164 section group. We just warn it the first time
6165 and ignore it afterwards. */
6166 static int warned = 0;
6167 if (!warned)
6168 {
6169 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6170 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6171 warned++;
6172 }
6173 }
e4b17d5c
L		 6174 }
6175
4fbb74a6 6176 section_headers_groups [entry] = group;
e4b17d5c
L		 6177
6178 if (do_section_groups)
6179 {
4fbb74a6 6180 sec = section_headers + entry;
74e1a04b 6181 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6182 }
6183
3f5e193b 6184 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6185 g->section_index = entry;
6186 g->next = group->root;
6187 group->root = g;
f5842774
L		 6188 }
6189
f5842774
L		 6190 if (start)
6191 free (start);
e4b17d5c
L		 6192
6193 group++;
f5842774
L		 6194 }
6195 }
6196
d1f5c6e3
L		 6197 if (symtab)
6198 free (symtab);
6199 if (strtab)
6200 free (strtab);
f5842774
L		 6201 return 1;
6202}
6203
28f997cf
TG		 6204/* Data used to display dynamic fixups. */
6205
6206struct ia64_vms_dynfixup
6207{
6208 bfd_vma needed_ident; /* Library ident number. */
6209 bfd_vma needed; /* Index in the dstrtab of the library name. */
6210 bfd_vma fixup_needed; /* Index of the library. */
6211 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6212 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6213};
6214
6215/* Data used to display dynamic relocations. */
6216
6217struct ia64_vms_dynimgrela
6218{
6219 bfd_vma img_rela_cnt; /* Number of relocations. */
6220 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6221};
6222
6223/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6224 library). */
6225
6226static void
6227dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6228 const char *strtab, unsigned int strtab_sz)
6229{
6230 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6231 long i;
6232 const char *lib_name;
6233
6234 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6235 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6236 _("dynamic section image fixups"));
6237 if (!imfs)
6238 return;
6239
6240 if (fixup->needed < strtab_sz)
6241 lib_name = strtab + fixup->needed;
6242 else
6243 {
6244 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6245 (unsigned long) fixup->needed);
28f997cf
TG		 6246 lib_name = "???";
6247 }
6248 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6249 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6250 printf
6251 (_("Seg Offset Type SymVec DataType\n"));
6252
6253 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6254 {
6255 unsigned int type;
6256 const char *rtype;
6257
6258 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6259 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6260 type = BYTE_GET (imfs [i].type);
6261 rtype = elf_ia64_reloc_type (type);
6262 if (rtype == NULL)
6263 printf (" 0x%08x ", type);
6264 else
6265 printf (" %-32s ", rtype);
6266 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6267 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6268 }
6269
6270 free (imfs);
6271}
6272
6273/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6274
6275static void
6276dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6277{
6278 Elf64_External_VMS_IMAGE_RELA *imrs;
6279 long i;
6280
6281 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6282 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6283 _("dynamic section image relocations"));
28f997cf
TG		 6284 if (!imrs)
6285 return;
6286
6287 printf (_("\nImage relocs\n"));
6288 printf
6289 (_("Seg Offset Type Addend Seg Sym Off\n"));
6290
6291 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6292 {
6293 unsigned int type;
6294 const char *rtype;
6295
6296 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6297 printf ("%08" BFD_VMA_FMT "x ",
6298 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6299 type = BYTE_GET (imrs [i].type);
6300 rtype = elf_ia64_reloc_type (type);
6301 if (rtype == NULL)
6302 printf ("0x%08x ", type);
6303 else
6304 printf ("%-31s ", rtype);
6305 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6306 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6307 printf ("%08" BFD_VMA_FMT "x\n",
6308 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6309 }
6310
6311 free (imrs);
6312}
6313
6314/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6315
6316static int
6317process_ia64_vms_dynamic_relocs (FILE *file)
6318{
6319 struct ia64_vms_dynfixup fixup;
6320 struct ia64_vms_dynimgrela imgrela;
6321 Elf_Internal_Dyn *entry;
6322 int res = 0;
6323 bfd_vma strtab_off = 0;
6324 bfd_vma strtab_sz = 0;
6325 char *strtab = NULL;
6326
6327 memset (&fixup, 0, sizeof (fixup));
6328 memset (&imgrela, 0, sizeof (imgrela));
6329
6330 /* Note: the order of the entries is specified by the OpenVMS specs. */
6331 for (entry = dynamic_section;
6332 entry < dynamic_section + dynamic_nent;
6333 entry++)
6334 {
6335 switch (entry->d_tag)
6336 {
6337 case DT_IA_64_VMS_STRTAB_OFFSET:
6338 strtab_off = entry->d_un.d_val;
6339 break;
6340 case DT_STRSZ:
6341 strtab_sz = entry->d_un.d_val;
6342 if (strtab == NULL)
6343 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6344 1, strtab_sz, _("dynamic string section"));
6345 break;
6346
6347 case DT_IA_64_VMS_NEEDED_IDENT:
6348 fixup.needed_ident = entry->d_un.d_val;
6349 break;
6350 case DT_NEEDED:
6351 fixup.needed = entry->d_un.d_val;
6352 break;
6353 case DT_IA_64_VMS_FIXUP_NEEDED:
6354 fixup.fixup_needed = entry->d_un.d_val;
6355 break;
6356 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6357 fixup.fixup_rela_cnt = entry->d_un.d_val;
6358 break;
6359 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6360 fixup.fixup_rela_off = entry->d_un.d_val;
6361 res++;
6362 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6363 break;
6364
6365 case DT_IA_64_VMS_IMG_RELA_CNT:
6366 imgrela.img_rela_cnt = entry->d_un.d_val;
6367 break;
6368 case DT_IA_64_VMS_IMG_RELA_OFF:
6369 imgrela.img_rela_off = entry->d_un.d_val;
6370 res++;
6371 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6372 break;
6373
6374 default:
6375 break;
6376 }
6377 }
6378
6379 if (strtab != NULL)
6380 free (strtab);
6381
6382 return res;
6383}
6384
85b1c36d 6385static struct
566b0d53 6386{
2cf0635d 6387 const char * name;
566b0d53
L		 6388 int reloc;
6389 int size;
6390 int rela;
6391} dynamic_relocations [] =
6392{
6393 { "REL", DT_REL, DT_RELSZ, FALSE },
6394 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6395 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6396};
6397
252b5132 6398/* Process the reloc section. */
18bd398b 6399
252b5132 6400static int
2cf0635d 6401process_relocs (FILE * file)
252b5132 6402{
b34976b6
AM		 6403 unsigned long rel_size;
6404 unsigned long rel_offset;
252b5132
RH		 6405
6406
6407 if (!do_reloc)
6408 return 1;
6409
6410 if (do_using_dynamic)
6411 {
566b0d53 6412 int is_rela;
2cf0635d 6413 const char * name;
566b0d53
L		 6414 int has_dynamic_reloc;
6415 unsigned int i;
0de14b54 6416
566b0d53 6417 has_dynamic_reloc = 0;
252b5132 6418
566b0d53 6419 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6420 {
566b0d53
L		 6421 is_rela = dynamic_relocations [i].rela;
6422 name = dynamic_relocations [i].name;
6423 rel_size = dynamic_info [dynamic_relocations [i].size];
6424 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6425
566b0d53
L		 6426 has_dynamic_reloc |= rel_size;
6427
6428 if (is_rela == UNKNOWN)
aa903cfb 6429 {
566b0d53
L		 6430 if (dynamic_relocations [i].reloc == DT_JMPREL)
6431 switch (dynamic_info[DT_PLTREL])
6432 {
6433 case DT_REL:
6434 is_rela = FALSE;
6435 break;
6436 case DT_RELA:
6437 is_rela = TRUE;
6438 break;
6439 }
aa903cfb 6440 }
252b5132 6441
566b0d53
L		 6442 if (rel_size)
6443 {
6444 printf
6445 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6446 name, rel_offset, rel_size);
252b5132 6447
d93f0186
NC		 6448 dump_relocations (file,
6449 offset_from_vma (file, rel_offset, rel_size),
6450 rel_size,
566b0d53 6451 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6452 dynamic_strings, dynamic_strings_length,
6453 is_rela, 1);
566b0d53 6454 }
252b5132 6455 }
566b0d53 6456
28f997cf
TG		 6457 if (is_ia64_vms ())
6458 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6459
566b0d53 6460 if (! has_dynamic_reloc)
252b5132
RH		 6461 printf (_("\nThere are no dynamic relocations in this file.\n"));
6462 }
6463 else
6464 {
2cf0635d 6465 Elf_Internal_Shdr * section;
b34976b6
AM		 6466 unsigned long i;
6467 int found = 0;
252b5132
RH		 6468
6469 for (i = 0, section = section_headers;
6470 i < elf_header.e_shnum;
b34976b6 6471 i++, section++)
252b5132
RH		 6472 {
6473 if ( section->sh_type != SHT_RELA
6474 && section->sh_type != SHT_REL)
6475 continue;
6476
6477 rel_offset = section->sh_offset;
6478 rel_size = section->sh_size;
6479
6480 if (rel_size)
6481 {
2cf0635d 6482 Elf_Internal_Shdr * strsec;
b34976b6 6483 int is_rela;
103f02d3 6484
252b5132
RH		 6485 printf (_("\nRelocation section "));
6486
6487 if (string_table == NULL)
19936277 6488 printf ("%d", section->sh_name);
252b5132 6489 else
74e1a04b 6490 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6491
6492 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6493 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6494
d79b3d50
NC		 6495 is_rela = section->sh_type == SHT_RELA;
6496
4fbb74a6
AM		 6497 if (section->sh_link != 0
6498 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6499 {
2cf0635d
NC		 6500 Elf_Internal_Shdr * symsec;
6501 Elf_Internal_Sym * symtab;
d79b3d50 6502 unsigned long nsyms;
c256ffe7 6503 unsigned long strtablen = 0;
2cf0635d 6504 char * strtab = NULL;
57346661 6505
4fbb74a6 6506 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6507 if (symsec->sh_type != SHT_SYMTAB
6508 && symsec->sh_type != SHT_DYNSYM)
6509 continue;
6510
ba5cdace 6511 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6512
af3fc3bc
AM		 6513 if (symtab == NULL)
6514 continue;
252b5132 6515
4fbb74a6
AM		 6516 if (symsec->sh_link != 0
6517 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6518 {
4fbb74a6 6519 strsec = section_headers + symsec->sh_link;
103f02d3 6520
3f5e193b 6521 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6522 1, strsec->sh_size,
6523 _("string table"));
c256ffe7
JJ		 6524 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6525 }
252b5132 6526
d79b3d50 6527 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6528 symtab, nsyms, strtab, strtablen,
6529 is_rela,
6530 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6531 if (strtab)
6532 free (strtab);
6533 free (symtab);
6534 }
6535 else
6536 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6537 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6538
6539 found = 1;
6540 }
6541 }
6542
6543 if (! found)
6544 printf (_("\nThere are no relocations in this file.\n"));
6545 }
6546
6547 return 1;
6548}
6549
4d6ed7c8
NC		 6550/* An absolute address consists of a section and an offset. If the
6551 section is NULL, the offset itself is the address, otherwise, the
6552 address equals to LOAD_ADDRESS(section) + offset. */
6553
6554struct absaddr
948f632f
DA		 6555{
6556 unsigned short section;
6557 bfd_vma offset;
6558};
4d6ed7c8 6559
1949de15
L		 6560#define ABSADDR(a) \
6561 ((a).section \
6562 ? section_headers [(a).section].sh_addr + (a).offset \
6563 : (a).offset)
6564
948f632f
DA		 6565/* Find the nearest symbol at or below ADDR. Returns the symbol
6566 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6567
4d6ed7c8 6568static void
2cf0635d 6569find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6570 unsigned long nsyms,
6571 const char * strtab,
6572 unsigned long strtab_size,
6573 struct absaddr addr,
6574 const char ** symname,
6575 bfd_vma * offset)
4d6ed7c8 6576{
d3ba0551 6577 bfd_vma dist = 0x100000;
2cf0635d 6578 Elf_Internal_Sym * sym;
948f632f
DA		 6579 Elf_Internal_Sym * beg;
6580 Elf_Internal_Sym * end;
2cf0635d 6581 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6582
0b6ae522 6583 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6584 beg = symtab;
6585 end = symtab + nsyms;
0b6ae522 6586
948f632f 6587 while (beg < end)
4d6ed7c8 6588 {
948f632f
DA		 6589 bfd_vma value;
6590
6591 sym = beg + (end - beg) / 2;
0b6ae522 6592
948f632f 6593 value = sym->st_value;
0b6ae522
DJ		 6594 REMOVE_ARCH_BITS (value);
6595
948f632f 6596 if (sym->st_name != 0
4d6ed7c8 6597 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6598 && addr.offset >= value
6599 && addr.offset - value < dist)
4d6ed7c8
NC		 6600 {
6601 best = sym;
0b6ae522 6602 dist = addr.offset - value;
4d6ed7c8
NC		 6603 if (!dist)
6604 break;
6605 }
948f632f
DA		 6606
6607 if (addr.offset < value)
6608 end = sym;
6609 else
6610 beg = sym + 1;
4d6ed7c8 6611 }
1b31d05e 6612
4d6ed7c8
NC		 6613 if (best)
6614 {
57346661 6615 *symname = (best->st_name >= strtab_size
2b692964 6616 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6617 *offset = dist;
6618 return;
6619 }
1b31d05e 6620
4d6ed7c8
NC		 6621 *symname = NULL;
6622 *offset = addr.offset;
6623}
6624
948f632f
DA		 6625static int
6626symcmp (const void *p, const void *q)
6627{
6628 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6629 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6630
6631 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6632}
6633
6634/* Process the unwind section. */
6635
6636#include "unwind-ia64.h"
6637
6638struct ia64_unw_table_entry
6639{
6640 struct absaddr start;
6641 struct absaddr end;
6642 struct absaddr info;
6643};
6644
6645struct ia64_unw_aux_info
6646{
6647 struct ia64_unw_table_entry *table; /* Unwind table. */
6648 unsigned long table_len; /* Length of unwind table. */
6649 unsigned char * info; /* Unwind info. */
6650 unsigned long info_size; /* Size of unwind info. */
6651 bfd_vma info_addr; /* Starting address of unwind info. */
6652 bfd_vma seg_base; /* Starting address of segment. */
6653 Elf_Internal_Sym * symtab; /* The symbol table. */
6654 unsigned long nsyms; /* Number of symbols. */
6655 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6656 unsigned long nfuns; /* Number of entries in funtab. */
6657 char * strtab; /* The string table. */
6658 unsigned long strtab_size; /* Size of string table. */
6659};
6660
4d6ed7c8 6661static void
2cf0635d 6662dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6663{
2cf0635d 6664 struct ia64_unw_table_entry * tp;
948f632f 6665 unsigned long j, nfuns;
4d6ed7c8 6666 int in_body;
7036c0e1 6667
948f632f
DA		 6668 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6669 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6670 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6671 aux->funtab[nfuns++] = aux->symtab[j];
6672 aux->nfuns = nfuns;
6673 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6674
4d6ed7c8
NC		 6675 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6676 {
6677 bfd_vma stamp;
6678 bfd_vma offset;
2cf0635d
NC		 6679 const unsigned char * dp;
6680 const unsigned char * head;
53774b7e 6681 const unsigned char * end;
2cf0635d 6682 const char * procname;
4d6ed7c8 6683
948f632f 6684 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6685 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6686
6687 fputs ("\n<", stdout);
6688
6689 if (procname)
6690 {
6691 fputs (procname, stdout);
6692
6693 if (offset)
6694 printf ("+%lx", (unsigned long) offset);
6695 }
6696
6697 fputs (">: [", stdout);
6698 print_vma (tp->start.offset, PREFIX_HEX);
6699 fputc ('-', stdout);
6700 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6701 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6702 (unsigned long) (tp->info.offset - aux->seg_base));
6703
53774b7e
NC		 6704 /* PR 17531: file: 86232b32. */
6705 if (aux->info == NULL)
6706 continue;
6707
6708 /* PR 17531: file: 0997b4d1. */
6709 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6710 {
6711 warn (_("Invalid offset %lx in table entry %ld\n"),
6712 (long) tp->info.offset, (long) (tp - aux->table));
6713 continue;
6714 }
6715
1949de15 6716 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6717 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6718
86f55779 6719 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6720 (unsigned) UNW_VER (stamp),
6721 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6722 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6723 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6724 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6725
6726 if (UNW_VER (stamp) != 1)
6727 {
2b692964 6728 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6729 continue;
6730 }
6731
6732 in_body = 0;
53774b7e
NC		 6733 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6734 /* PR 17531: file: 16ceda89. */
6735 if (end > aux->info + aux->info_size)
6736 end = aux->info + aux->info_size;
6737 for (dp = head + 8; dp < end;)
4d6ed7c8
NC		 6738 dp = unw_decode (dp, in_body, & in_body);
6739 }
948f632f
DA		 6740
6741 free (aux->funtab);
4d6ed7c8
NC		 6742}
6743
53774b7e 6744static bfd_boolean
2cf0635d
NC		 6745slurp_ia64_unwind_table (FILE * file,
6746 struct ia64_unw_aux_info * aux,
6747 Elf_Internal_Shdr * sec)
4d6ed7c8 6748{
89fac5e3 6749 unsigned long size, nrelas, i;
2cf0635d
NC		 6750 Elf_Internal_Phdr * seg;
6751 struct ia64_unw_table_entry * tep;
6752 Elf_Internal_Shdr * relsec;
6753 Elf_Internal_Rela * rela;
6754 Elf_Internal_Rela * rp;
6755 unsigned char * table;
6756 unsigned char * tp;
6757 Elf_Internal_Sym * sym;
6758 const char * relname;
4d6ed7c8 6759
53774b7e
NC		 6760 aux->table_len = 0;
6761
4d6ed7c8
NC		 6762 /* First, find the starting address of the segment that includes
6763 this section: */
6764
6765 if (elf_header.e_phnum)
6766 {
d93f0186 6767 if (! get_program_headers (file))
53774b7e 6768 return FALSE;
4d6ed7c8 6769
d93f0186
NC		 6770 for (seg = program_headers;
6771 seg < program_headers + elf_header.e_phnum;
6772 ++seg)
4d6ed7c8
NC		 6773 {
6774 if (seg->p_type != PT_LOAD)
6775 continue;
6776
6777 if (sec->sh_addr >= seg->p_vaddr
6778 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6779 {
6780 aux->seg_base = seg->p_vaddr;
6781 break;
6782 }
6783 }
4d6ed7c8
NC		 6784 }
6785
6786 /* Second, build the unwind table from the contents of the unwind section: */
6787 size = sec->sh_size;
3f5e193b
NC		 6788 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6789 _("unwind table"));
a6e9f9df 6790 if (!table)
53774b7e 6791 return FALSE;
4d6ed7c8 6792
53774b7e 6793 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6794 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6795 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6796 tep = aux->table;
53774b7e
NC		 6797
6798 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6799 {
6800 tep->start.section = SHN_UNDEF;
6801 tep->end.section = SHN_UNDEF;
6802 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6803 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6804 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6805 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6806 tep->start.offset += aux->seg_base;
6807 tep->end.offset += aux->seg_base;
6808 tep->info.offset += aux->seg_base;
6809 }
6810 free (table);
6811
41e92641 6812 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6813 for (relsec = section_headers;
6814 relsec < section_headers + elf_header.e_shnum;
6815 ++relsec)
6816 {
6817 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6818 || relsec->sh_info >= elf_header.e_shnum
6819 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6820 continue;
6821
6822 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6823 & rela, & nrelas))
53774b7e
NC		 6824 {
6825 free (aux->table);
6826 aux->table = NULL;
6827 aux->table_len = 0;
6828 return FALSE;
6829 }
4d6ed7c8
NC		 6830
6831 for (rp = rela; rp < rela + nrelas; ++rp)
6832 {
aca88567
NC		 6833 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6834 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6835
82b1b41b
NC		 6836 /* PR 17531: file: 9fa67536. */
6837 if (relname == NULL)
6838 {
6839 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6840 continue;
6841 }
948f632f 6842
0112cd26 6843 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6844 {
82b1b41b 6845 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6846 continue;
6847 }
6848
89fac5e3 6849 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6850
53774b7e
NC		 6851 /* PR 17531: file: 5bc8d9bf. */
6852 if (i >= aux->table_len)
6853 {
6854 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6855 continue;
6856 }
6857
6858 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6859 {
6860 case 0:
6861 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6862 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6863 break;
6864 case 1:
6865 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6866 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6867 break;
6868 case 2:
6869 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6870 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6871 break;
6872 default:
6873 break;
6874 }
6875 }
6876
6877 free (rela);
6878 }
6879
53774b7e 6880 return TRUE;
4d6ed7c8
NC		 6881}
6882
1b31d05e 6883static void
2cf0635d 6884ia64_process_unwind (FILE * file)
4d6ed7c8 6885{
2cf0635d
NC		 6886 Elf_Internal_Shdr * sec;
6887 Elf_Internal_Shdr * unwsec = NULL;
6888 Elf_Internal_Shdr * strsec;
89fac5e3 6889 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6890 struct ia64_unw_aux_info aux;
f1467e33 6891
4d6ed7c8
NC		 6892 memset (& aux, 0, sizeof (aux));
6893
4d6ed7c8
NC		 6894 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6895 {
c256ffe7 6896 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6897 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6898 {
ba5cdace 6899 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6900
4fbb74a6 6901 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6902 if (aux.strtab != NULL)
6903 {
6904 error (_("Multiple auxillary string tables encountered\n"));
6905 free (aux.strtab);
6906 }
3f5e193b
NC		 6907 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6908 1, strsec->sh_size,
6909 _("string table"));
c256ffe7 6910 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6911 }
6912 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6913 unwcount++;
6914 }
6915
6916 if (!unwcount)
6917 printf (_("\nThere are no unwind sections in this file.\n"));
6918
6919 while (unwcount-- > 0)
6920 {
2cf0635d 6921 char * suffix;
579f31ac
JJ		 6922 size_t len, len2;
6923
4082ef84 6924 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6925 i < elf_header.e_shnum; ++i, ++sec)
6926 if (sec->sh_type == SHT_IA_64_UNWIND)
6927 {
6928 unwsec = sec;
6929 break;
6930 }
4082ef84
NC		 6931 /* We have already counted the number of SHT_IA64_UNWIND
6932 sections so the loop above should never fail. */
6933 assert (unwsec != NULL);
579f31ac
JJ		 6934
6935 unwstart = i + 1;
6936 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6937
e4b17d5c
L		 6938 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6939 {
6940 /* We need to find which section group it is in. */
4082ef84 6941 struct group_list * g;
e4b17d5c 6942
4082ef84
NC		 6943 if (section_headers_groups == NULL
6944 || section_headers_groups [i] == NULL)
6945 i = elf_header.e_shnum;
6946 else
e4b17d5c 6947 {
4082ef84 6948 g = section_headers_groups [i]->root;
18bd398b 6949
4082ef84
NC		 6950 for (; g != NULL; g = g->next)
6951 {
6952 sec = section_headers + g->section_index;
e4b17d5c 6953
4082ef84
NC		 6954 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6955 break;
6956 }
6957
6958 if (g == NULL)
6959 i = elf_header.e_shnum;
6960 }
e4b17d5c 6961 }
18bd398b 6962 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6963 {
18bd398b 6964 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6965 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6966 suffix = SECTION_NAME (unwsec) + len;
6967 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6968 ++i, ++sec)
18bd398b
NC		 6969 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6970 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6971 break;
6972 }
6973 else
6974 {
6975 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6976 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6977 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6978 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6979 suffix = "";
18bd398b 6980 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6981 suffix = SECTION_NAME (unwsec) + len;
6982 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6983 ++i, ++sec)
18bd398b
NC		 6984 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6985 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6986 break;
6987 }
6988
6989 if (i == elf_header.e_shnum)
6990 {
6991 printf (_("\nCould not find unwind info section for "));
6992
6993 if (string_table == NULL)
6994 printf ("%d", unwsec->sh_name);
6995 else
74e1a04b 6996 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6997 }
6998 else
4d6ed7c8 6999 {
4d6ed7c8 7000 aux.info_addr = sec->sh_addr;
3f5e193b 7001 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7002 sec->sh_size,
7003 _("unwind info"));
59245841 7004 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7005
579f31ac 7006 printf (_("\nUnwind section "));
4d6ed7c8 7007
579f31ac
JJ		 7008 if (string_table == NULL)
7009 printf ("%d", unwsec->sh_name);
7010 else
74e1a04b 7011 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7012
579f31ac 7013 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7014 (unsigned long) unwsec->sh_offset,
89fac5e3 7015 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7016
53774b7e
NC		 7017 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7018 && aux.table_len > 0)
579f31ac
JJ		 7019 dump_ia64_unwind (& aux);
7020
7021 if (aux.table)
7022 free ((char *) aux.table);
7023 if (aux.info)
7024 free ((char *) aux.info);
7025 aux.table = NULL;
7026 aux.info = NULL;
7027 }
4d6ed7c8 7028 }
4d6ed7c8 7029
4d6ed7c8
NC		 7030 if (aux.symtab)
7031 free (aux.symtab);
7032 if (aux.strtab)
7033 free ((char *) aux.strtab);
4d6ed7c8
NC		 7034}
7035
3f5e193b
NC		 7036struct hppa_unw_table_entry
7037 {
7038 struct absaddr start;
7039 struct absaddr end;
948f632f 7040 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7041 unsigned int Millicode:1; /* 1 */
7042 unsigned int Millicode_save_sr0:1; /* 2 */
7043 unsigned int Region_description:2; /* 3..4 */
7044 unsigned int reserved1:1; /* 5 */
7045 unsigned int Entry_SR:1; /* 6 */
7046 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7047 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7048 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7049 unsigned int Variable_Frame:1; /* 17 */
7050 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7051 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7052 unsigned int Stack_Overflow_Check:1; /* 20 */
7053 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7054 unsigned int Ada_Region:1; /* 22 */
7055 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7056 unsigned int cxx_try_catch:1; /* 24 */
7057 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7058 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7059 unsigned int Save_SP:1; /* 27 */
7060 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7061 unsigned int Save_MRP_in_frame:1; /* 29 */
7062 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7063 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7064
948f632f
DA		 7065 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7066 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7067 unsigned int Large_frame:1; /* 2 */
948f632f 7068 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7069 unsigned int reserved4:1; /* 4 */
7070 unsigned int Total_frame_size:27; /* 5..31 */
7071 };
7072
57346661 7073struct hppa_unw_aux_info
948f632f
DA		 7074{
7075 struct hppa_unw_table_entry * table; /* Unwind table. */
7076 unsigned long table_len; /* Length of unwind table. */
7077 bfd_vma seg_base; /* Starting address of segment. */
7078 Elf_Internal_Sym * symtab; /* The symbol table. */
7079 unsigned long nsyms; /* Number of symbols. */
7080 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7081 unsigned long nfuns; /* Number of entries in funtab. */
7082 char * strtab; /* The string table. */
7083 unsigned long strtab_size; /* Size of string table. */
7084};
57346661
AM		 7085
7086static void
2cf0635d 7087dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7088{
2cf0635d 7089 struct hppa_unw_table_entry * tp;
948f632f
DA		 7090 unsigned long j, nfuns;
7091
7092 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7093 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7094 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7095 aux->funtab[nfuns++] = aux->symtab[j];
7096 aux->nfuns = nfuns;
7097 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7098
57346661
AM		 7099 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7100 {
7101 bfd_vma offset;
2cf0635d 7102 const char * procname;
57346661 7103
948f632f 7104 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7105 aux->strtab_size, tp->start, &procname,
7106 &offset);
7107
7108 fputs ("\n<", stdout);
7109
7110 if (procname)
7111 {
7112 fputs (procname, stdout);
7113
7114 if (offset)
7115 printf ("+%lx", (unsigned long) offset);
7116 }
7117
7118 fputs (">: [", stdout);
7119 print_vma (tp->start.offset, PREFIX_HEX);
7120 fputc ('-', stdout);
7121 print_vma (tp->end.offset, PREFIX_HEX);
7122 printf ("]\n\t");
7123
18bd398b
NC		 7124#define PF(_m) if (tp->_m) printf (#_m " ");
7125#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7126 PF(Cannot_unwind);
7127 PF(Millicode);
7128 PF(Millicode_save_sr0);
18bd398b 7129 /* PV(Region_description); */
57346661
AM		 7130 PF(Entry_SR);
7131 PV(Entry_FR);
7132 PV(Entry_GR);
7133 PF(Args_stored);
7134 PF(Variable_Frame);
7135 PF(Separate_Package_Body);
7136 PF(Frame_Extension_Millicode);
7137 PF(Stack_Overflow_Check);
7138 PF(Two_Instruction_SP_Increment);
7139 PF(Ada_Region);
7140 PF(cxx_info);
7141 PF(cxx_try_catch);
7142 PF(sched_entry_seq);
7143 PF(Save_SP);
7144 PF(Save_RP);
7145 PF(Save_MRP_in_frame);
7146 PF(extn_ptr_defined);
7147 PF(Cleanup_defined);
7148 PF(MPE_XL_interrupt_marker);
7149 PF(HP_UX_interrupt_marker);
7150 PF(Large_frame);
7151 PF(Pseudo_SP_Set);
7152 PV(Total_frame_size);
7153#undef PF
7154#undef PV
7155 }
7156
18bd398b 7157 printf ("\n");
948f632f
DA		 7158
7159 free (aux->funtab);
57346661
AM		 7160}
7161
7162static int
2cf0635d
NC		 7163slurp_hppa_unwind_table (FILE * file,
7164 struct hppa_unw_aux_info * aux,
7165 Elf_Internal_Shdr * sec)
57346661 7166{
1c0751b2 7167 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7168 Elf_Internal_Phdr * seg;
7169 struct hppa_unw_table_entry * tep;
7170 Elf_Internal_Shdr * relsec;
7171 Elf_Internal_Rela * rela;
7172 Elf_Internal_Rela * rp;
7173 unsigned char * table;
7174 unsigned char * tp;
7175 Elf_Internal_Sym * sym;
7176 const char * relname;
57346661 7177
57346661
AM		 7178 /* First, find the starting address of the segment that includes
7179 this section. */
7180
7181 if (elf_header.e_phnum)
7182 {
7183 if (! get_program_headers (file))
7184 return 0;
7185
7186 for (seg = program_headers;
7187 seg < program_headers + elf_header.e_phnum;
7188 ++seg)
7189 {
7190 if (seg->p_type != PT_LOAD)
7191 continue;
7192
7193 if (sec->sh_addr >= seg->p_vaddr
7194 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7195 {
7196 aux->seg_base = seg->p_vaddr;
7197 break;
7198 }
7199 }
7200 }
7201
7202 /* Second, build the unwind table from the contents of the unwind
7203 section. */
7204 size = sec->sh_size;
3f5e193b
NC		 7205 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7206 _("unwind table"));
57346661
AM		 7207 if (!table)
7208 return 0;
7209
1c0751b2
DA		 7210 unw_ent_size = 16;
7211 nentries = size / unw_ent_size;
7212 size = unw_ent_size * nentries;
57346661 7213
3f5e193b
NC		 7214 tep = aux->table = (struct hppa_unw_table_entry *)
7215 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7216
1c0751b2 7217 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7218 {
7219 unsigned int tmp1, tmp2;
7220
7221 tep->start.section = SHN_UNDEF;
7222 tep->end.section = SHN_UNDEF;
7223
1c0751b2
DA		 7224 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7225 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7226 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7227 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7228
7229 tep->start.offset += aux->seg_base;
7230 tep->end.offset += aux->seg_base;
57346661
AM		 7231
7232 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7233 tep->Millicode = (tmp1 >> 30) & 0x1;
7234 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7235 tep->Region_description = (tmp1 >> 27) & 0x3;
7236 tep->reserved1 = (tmp1 >> 26) & 0x1;
7237 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7238 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7239 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7240 tep->Args_stored = (tmp1 >> 15) & 0x1;
7241 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7242 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7243 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7244 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7245 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7246 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7247 tep->cxx_info = (tmp1 >> 8) & 0x1;
7248 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7249 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7250 tep->reserved2 = (tmp1 >> 5) & 0x1;
7251 tep->Save_SP = (tmp1 >> 4) & 0x1;
7252 tep->Save_RP = (tmp1 >> 3) & 0x1;
7253 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7254 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7255 tep->Cleanup_defined = tmp1 & 0x1;
7256
7257 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7258 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7259 tep->Large_frame = (tmp2 >> 29) & 0x1;
7260 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7261 tep->reserved4 = (tmp2 >> 27) & 0x1;
7262 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7263 }
7264 free (table);
7265
7266 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7267 for (relsec = section_headers;
7268 relsec < section_headers + elf_header.e_shnum;
7269 ++relsec)
7270 {
7271 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7272 || relsec->sh_info >= elf_header.e_shnum
7273 || section_headers + relsec->sh_info != sec)
57346661
AM		 7274 continue;
7275
7276 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7277 & rela, & nrelas))
7278 return 0;
7279
7280 for (rp = rela; rp < rela + nrelas; ++rp)
7281 {
aca88567
NC		 7282 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7283 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7284
7285 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7286 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7287 {
7288 warn (_("Skipping unexpected relocation type %s\n"), relname);
7289 continue;
7290 }
7291
7292 i = rp->r_offset / unw_ent_size;
7293
89fac5e3 7294 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7295 {
7296 case 0:
7297 aux->table[i].start.section = sym->st_shndx;
1e456d54 7298 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7299 break;
7300 case 1:
7301 aux->table[i].end.section = sym->st_shndx;
1e456d54 7302 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7303 break;
7304 default:
7305 break;
7306 }
7307 }
7308
7309 free (rela);
7310 }
7311
1c0751b2 7312 aux->table_len = nentries;
57346661
AM		 7313
7314 return 1;
7315}
7316
1b31d05e 7317static void
2cf0635d 7318hppa_process_unwind (FILE * file)
57346661 7319{
57346661 7320 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7321 Elf_Internal_Shdr * unwsec = NULL;
7322 Elf_Internal_Shdr * strsec;
7323 Elf_Internal_Shdr * sec;
18bd398b 7324 unsigned long i;
57346661 7325
c256ffe7 7326 if (string_table == NULL)
1b31d05e
NC		 7327 return;
7328
7329 memset (& aux, 0, sizeof (aux));
57346661
AM		 7330
7331 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7332 {
c256ffe7 7333 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7334 && sec->sh_link < elf_header.e_shnum)
57346661 7335 {
ba5cdace 7336 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7337
4fbb74a6 7338 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7339 if (aux.strtab != NULL)
7340 {
7341 error (_("Multiple auxillary string tables encountered\n"));
7342 free (aux.strtab);
7343 }
3f5e193b
NC		 7344 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7345 1, strsec->sh_size,
7346 _("string table"));
c256ffe7 7347 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7348 }
18bd398b 7349 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7350 unwsec = sec;
7351 }
7352
7353 if (!unwsec)
7354 printf (_("\nThere are no unwind sections in this file.\n"));
7355
7356 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7357 {
18bd398b 7358 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7359 {
74e1a04b
NC		 7360 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7361 printable_section_name (sec),
57346661 7362 (unsigned long) sec->sh_offset,
89fac5e3 7363 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7364
7365 slurp_hppa_unwind_table (file, &aux, sec);
7366 if (aux.table_len > 0)
7367 dump_hppa_unwind (&aux);
7368
7369 if (aux.table)
7370 free ((char *) aux.table);
7371 aux.table = NULL;
7372 }
7373 }
7374
7375 if (aux.symtab)
7376 free (aux.symtab);
7377 if (aux.strtab)
7378 free ((char *) aux.strtab);
57346661
AM		 7379}
7380
0b6ae522
DJ		 7381struct arm_section
7382{
a734115a
NC		 7383 unsigned char * data; /* The unwind data. */
7384 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7385 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7386 unsigned long nrelas; /* The number of relocations. */
7387 unsigned int rel_type; /* REL or RELA ? */
7388 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7389};
7390
7391struct arm_unw_aux_info
7392{
a734115a
NC		 7393 FILE * file; /* The file containing the unwind sections. */
7394 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7395 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7396 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7397 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7398 char * strtab; /* The file's string table. */
7399 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7400};
7401
7402static const char *
7403arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7404 bfd_vma fn, struct absaddr addr)
7405{
7406 const char *procname;
7407 bfd_vma sym_offset;
7408
7409 if (addr.section == SHN_UNDEF)
7410 addr.offset = fn;
7411
948f632f 7412 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7413 aux->strtab_size, addr, &procname,
7414 &sym_offset);
7415
7416 print_vma (fn, PREFIX_HEX);
7417
7418 if (procname)
7419 {
7420 fputs (" <", stdout);
7421 fputs (procname, stdout);
7422
7423 if (sym_offset)
7424 printf ("+0x%lx", (unsigned long) sym_offset);
7425 fputc ('>', stdout);
7426 }
7427
7428 return procname;
7429}
7430
7431static void
7432arm_free_section (struct arm_section *arm_sec)
7433{
7434 if (arm_sec->data != NULL)
7435 free (arm_sec->data);
7436
7437 if (arm_sec->rela != NULL)
7438 free (arm_sec->rela);
7439}
7440
a734115a
NC		 7441/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7442 cached section and install SEC instead.
7443 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7444 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7445 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7446 relocation's offset in ADDR.
1b31d05e
NC		 7447 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7448 into the string table of the symbol associated with the reloc. If no
7449 reloc was applied store -1 there.
7450 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7451
7452static bfd_boolean
1b31d05e
NC		 7453get_unwind_section_word (struct arm_unw_aux_info * aux,
7454 struct arm_section * arm_sec,
7455 Elf_Internal_Shdr * sec,
7456 bfd_vma word_offset,
7457 unsigned int * wordp,
7458 struct absaddr * addr,
7459 bfd_vma * sym_name)
0b6ae522
DJ		 7460{
7461 Elf_Internal_Rela *rp;
7462 Elf_Internal_Sym *sym;
7463 const char * relname;
7464 unsigned int word;
7465 bfd_boolean wrapped;
7466
e0a31db1
NC		 7467 if (sec == NULL || arm_sec == NULL)
7468 return FALSE;
7469
0b6ae522
DJ		 7470 addr->section = SHN_UNDEF;
7471 addr->offset = 0;
7472
1b31d05e
NC		 7473 if (sym_name != NULL)
7474 *sym_name = (bfd_vma) -1;
7475
a734115a 7476 /* If necessary, update the section cache. */
0b6ae522
DJ		 7477 if (sec != arm_sec->sec)
7478 {
7479 Elf_Internal_Shdr *relsec;
7480
7481 arm_free_section (arm_sec);
7482
7483 arm_sec->sec = sec;
7484 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7485 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7486 arm_sec->rela = NULL;
7487 arm_sec->nrelas = 0;
7488
7489 for (relsec = section_headers;
7490 relsec < section_headers + elf_header.e_shnum;
7491 ++relsec)
7492 {
7493 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7494 || section_headers + relsec->sh_info != sec
7495 /* PR 15745: Check the section type as well. */
7496 || (relsec->sh_type != SHT_REL
7497 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7498 continue;
7499
a734115a 7500 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7501 if (relsec->sh_type == SHT_REL)
7502 {
7503 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7504 relsec->sh_size,
7505 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7506 return FALSE;
0b6ae522 7507 }
1ae40aa4 7508 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7509 {
7510 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7511 relsec->sh_size,
7512 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7513 return FALSE;
0b6ae522 7514 }
1ae40aa4 7515 break;
0b6ae522
DJ		 7516 }
7517
7518 arm_sec->next_rela = arm_sec->rela;
7519 }
7520
a734115a 7521 /* If there is no unwind data we can do nothing. */
0b6ae522 7522 if (arm_sec->data == NULL)
a734115a 7523 return FALSE;
0b6ae522 7524
e0a31db1
NC		 7525 /* If the offset is invalid then fail. */
7526 if (word_offset > sec->sh_size - 4)
7527 return FALSE;
7528
a734115a 7529 /* Get the word at the required offset. */
0b6ae522
DJ		 7530 word = byte_get (arm_sec->data + word_offset, 4);
7531
0eff7165
NC		 7532 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7533 if (arm_sec->rela == NULL)
7534 {
7535 * wordp = word;
7536 return TRUE;
7537 }
7538
a734115a 7539 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7540 wrapped = FALSE;
7541 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7542 {
7543 bfd_vma prelval, offset;
7544
7545 if (rp->r_offset > word_offset && !wrapped)
7546 {
7547 rp = arm_sec->rela;
7548 wrapped = TRUE;
7549 }
7550 if (rp->r_offset > word_offset)
7551 break;
7552
7553 if (rp->r_offset & 3)
7554 {
7555 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7556 (unsigned long) rp->r_offset);
7557 continue;
7558 }
7559
7560 if (rp->r_offset < word_offset)
7561 continue;
7562
74e1a04b
NC		 7563 /* PR 17531: file: 027-161405-0.004 */
7564 if (aux->symtab == NULL)
7565 continue;
7566
0b6ae522
DJ		 7567 if (arm_sec->rel_type == SHT_REL)
7568 {
7569 offset = word & 0x7fffffff;
7570 if (offset & 0x40000000)
7571 offset |= ~ (bfd_vma) 0x7fffffff;
7572 }
a734115a 7573 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7574 offset = rp->r_addend;
a734115a 7575 else
74e1a04b
NC		 7576 {
7577 error (_("Unknown section relocation type %d encountered\n"),
7578 arm_sec->rel_type);
7579 break;
7580 }
0b6ae522 7581
071436c6
NC		 7582 /* PR 17531 file: 027-1241568-0.004. */
7583 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7584 {
7585 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7586 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7587 break;
7588 }
7589
7590 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7591 offset += sym->st_value;
7592 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7593
a734115a
NC		 7594 /* Check that we are processing the expected reloc type. */
7595 if (elf_header.e_machine == EM_ARM)
7596 {
7597 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7598 if (relname == NULL)
7599 {
7600 warn (_("Skipping unknown ARM relocation type: %d\n"),
7601 (int) ELF32_R_TYPE (rp->r_info));
7602 continue;
7603 }
a734115a
NC		 7604
7605 if (streq (relname, "R_ARM_NONE"))
7606 continue;
0b4362b0 7607
a734115a
NC		 7608 if (! streq (relname, "R_ARM_PREL31"))
7609 {
071436c6 7610 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7611 continue;
7612 }
7613 }
7614 else if (elf_header.e_machine == EM_TI_C6000)
7615 {
7616 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7617 if (relname == NULL)
7618 {
7619 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7620 (int) ELF32_R_TYPE (rp->r_info));
7621 continue;
7622 }
0b4362b0 7623
a734115a
NC		 7624 if (streq (relname, "R_C6000_NONE"))
7625 continue;
7626
7627 if (! streq (relname, "R_C6000_PREL31"))
7628 {
071436c6 7629 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7630 continue;
7631 }
7632
7633 prelval >>= 1;
7634 }
7635 else
74e1a04b
NC		 7636 {
7637 /* This function currently only supports ARM and TI unwinders. */
7638 warn (_("Only TI and ARM unwinders are currently supported\n"));
7639 break;
7640 }
fa197c1c 7641
0b6ae522
DJ		 7642 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7643 addr->section = sym->st_shndx;
7644 addr->offset = offset;
74e1a04b 7645
1b31d05e
NC		 7646 if (sym_name)
7647 * sym_name = sym->st_name;
0b6ae522
DJ		 7648 break;
7649 }
7650
7651 *wordp = word;
7652 arm_sec->next_rela = rp;
7653
a734115a 7654 return TRUE;
0b6ae522
DJ		 7655}
7656
a734115a
NC		 7657static const char *tic6x_unwind_regnames[16] =
7658{
0b4362b0
RM		 7659 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7660 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7661 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7662};
fa197c1c 7663
0b6ae522 7664static void
fa197c1c 7665decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7666{
fa197c1c
PB		 7667 int i;
7668
7669 for (i = 12; mask; mask >>= 1, i--)
7670 {
7671 if (mask & 1)
7672 {
7673 fputs (tic6x_unwind_regnames[i], stdout);
7674 if (mask > 1)
7675 fputs (", ", stdout);
7676 }
7677 }
7678}
0b6ae522
DJ		 7679
7680#define ADVANCE \
7681 if (remaining == 0 && more_words) \
7682 { \
7683 data_offset += 4; \
1b31d05e
NC		 7684 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7685 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7686 return; \
7687 remaining = 4; \
7688 more_words--; \
7689 } \
7690
7691#define GET_OP(OP) \
7692 ADVANCE; \
7693 if (remaining) \
7694 { \
7695 remaining--; \
7696 (OP) = word >> 24; \
7697 word <<= 8; \
7698 } \
7699 else \
7700 { \
2b692964 7701 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7702 return; \
7703 } \
cc5914eb 7704 printf ("0x%02x ", OP)
0b6ae522 7705
fa197c1c 7706static void
948f632f
DA		 7707decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7708 unsigned int word,
7709 unsigned int remaining,
7710 unsigned int more_words,
7711 bfd_vma data_offset,
7712 Elf_Internal_Shdr * data_sec,
7713 struct arm_section * data_arm_sec)
fa197c1c
PB		 7714{
7715 struct absaddr addr;
0b6ae522
DJ		 7716
7717 /* Decode the unwinding instructions. */
7718 while (1)
7719 {
7720 unsigned int op, op2;
7721
7722 ADVANCE;
7723 if (remaining == 0)
7724 break;
7725 remaining--;
7726 op = word >> 24;
7727 word <<= 8;
7728
cc5914eb 7729 printf (" 0x%02x ", op);
0b6ae522
DJ		 7730
7731 if ((op & 0xc0) == 0x00)
7732 {
7733 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7734
cc5914eb 7735 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7736 }
7737 else if ((op & 0xc0) == 0x40)
7738 {
7739 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7740
cc5914eb 7741 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7742 }
7743 else if ((op & 0xf0) == 0x80)
7744 {
7745 GET_OP (op2);
7746 if (op == 0x80 && op2 == 0)
7747 printf (_("Refuse to unwind"));
7748 else
7749 {
7750 unsigned int mask = ((op & 0x0f) << 8) | op2;
7751 int first = 1;
7752 int i;
2b692964 7753
0b6ae522
DJ		 7754 printf ("pop {");
7755 for (i = 0; i < 12; i++)
7756 if (mask & (1 << i))
7757 {
7758 if (first)
7759 first = 0;
7760 else
7761 printf (", ");
7762 printf ("r%d", 4 + i);
7763 }
7764 printf ("}");
7765 }
7766 }
7767 else if ((op & 0xf0) == 0x90)
7768 {
7769 if (op == 0x9d || op == 0x9f)
7770 printf (_(" [Reserved]"));
7771 else
cc5914eb 7772 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7773 }
7774 else if ((op & 0xf0) == 0xa0)
7775 {
7776 int end = 4 + (op & 0x07);
7777 int first = 1;
7778 int i;
61865e30 7779
0b6ae522
DJ		 7780 printf (" pop {");
7781 for (i = 4; i <= end; i++)
7782 {
7783 if (first)
7784 first = 0;
7785 else
7786 printf (", ");
7787 printf ("r%d", i);
7788 }
7789 if (op & 0x08)
7790 {
1b31d05e 7791 if (!first)
0b6ae522
DJ		 7792 printf (", ");
7793 printf ("r14");
7794 }
7795 printf ("}");
7796 }
7797 else if (op == 0xb0)
7798 printf (_(" finish"));
7799 else if (op == 0xb1)
7800 {
7801 GET_OP (op2);
7802 if (op2 == 0 || (op2 & 0xf0) != 0)
7803 printf (_("[Spare]"));
7804 else
7805 {
7806 unsigned int mask = op2 & 0x0f;
7807 int first = 1;
7808 int i;
61865e30 7809
0b6ae522
DJ		 7810 printf ("pop {");
7811 for (i = 0; i < 12; i++)
7812 if (mask & (1 << i))
7813 {
7814 if (first)
7815 first = 0;
7816 else
7817 printf (", ");
7818 printf ("r%d", i);
7819 }
7820 printf ("}");
7821 }
7822 }
7823 else if (op == 0xb2)
7824 {
b115cf96 7825 unsigned char buf[9];
0b6ae522
DJ		 7826 unsigned int i, len;
7827 unsigned long offset;
61865e30 7828
b115cf96 7829 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7830 {
7831 GET_OP (buf[i]);
7832 if ((buf[i] & 0x80) == 0)
7833 break;
7834 }
4082ef84
NC		 7835 if (i == sizeof (buf))
7836 printf (_("corrupt change to vsp"));
7837 else
7838 {
7839 offset = read_uleb128 (buf, &len, buf + i + 1);
7840 assert (len == i + 1);
7841 offset = offset * 4 + 0x204;
7842 printf ("vsp = vsp + %ld", offset);
7843 }
0b6ae522 7844 }
61865e30 7845 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7846 {
61865e30
NC		 7847 unsigned int first, last;
7848
7849 GET_OP (op2);
7850 first = op2 >> 4;
7851 last = op2 & 0x0f;
7852 if (op == 0xc8)
7853 first = first + 16;
7854 printf ("pop {D%d", first);
7855 if (last)
7856 printf ("-D%d", first + last);
7857 printf ("}");
7858 }
7859 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7860 {
7861 unsigned int count = op & 0x07;
7862
7863 printf ("pop {D8");
7864 if (count)
7865 printf ("-D%d", 8 + count);
7866 printf ("}");
7867 }
7868 else if (op >= 0xc0 && op <= 0xc5)
7869 {
7870 unsigned int count = op & 0x07;
7871
7872 printf (" pop {wR10");
7873 if (count)
7874 printf ("-wR%d", 10 + count);
7875 printf ("}");
7876 }
7877 else if (op == 0xc6)
7878 {
7879 unsigned int first, last;
7880
7881 GET_OP (op2);
7882 first = op2 >> 4;
7883 last = op2 & 0x0f;
7884 printf ("pop {wR%d", first);
7885 if (last)
7886 printf ("-wR%d", first + last);
7887 printf ("}");
7888 }
7889 else if (op == 0xc7)
7890 {
7891 GET_OP (op2);
7892 if (op2 == 0 || (op2 & 0xf0) != 0)
7893 printf (_("[Spare]"));
0b6ae522
DJ		 7894 else
7895 {
61865e30
NC		 7896 unsigned int mask = op2 & 0x0f;
7897 int first = 1;
7898 int i;
7899
7900 printf ("pop {");
7901 for (i = 0; i < 4; i++)
7902 if (mask & (1 << i))
7903 {
7904 if (first)
7905 first = 0;
7906 else
7907 printf (", ");
7908 printf ("wCGR%d", i);
7909 }
7910 printf ("}");
0b6ae522
DJ		 7911 }
7912 }
61865e30
NC		 7913 else
7914 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7915 printf ("\n");
7916 }
fa197c1c
PB		 7917}
7918
7919static void
948f632f
DA		 7920decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7921 unsigned int word,
7922 unsigned int remaining,
7923 unsigned int more_words,
7924 bfd_vma data_offset,
7925 Elf_Internal_Shdr * data_sec,
7926 struct arm_section * data_arm_sec)
fa197c1c
PB		 7927{
7928 struct absaddr addr;
7929
7930 /* Decode the unwinding instructions. */
7931 while (1)
7932 {
7933 unsigned int op, op2;
7934
7935 ADVANCE;
7936 if (remaining == 0)
7937 break;
7938 remaining--;
7939 op = word >> 24;
7940 word <<= 8;
7941
9cf03b7e 7942 printf (" 0x%02x ", op);
fa197c1c
PB		 7943
7944 if ((op & 0xc0) == 0x00)
7945 {
7946 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7947 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7948 }
7949 else if ((op & 0xc0) == 0x80)
7950 {
7951 GET_OP (op2);
7952 if (op == 0x80 && op2 == 0)
7953 printf (_("Refuse to unwind"));
7954 else
7955 {
7956 unsigned int mask = ((op & 0x1f) << 8) | op2;
7957 if (op & 0x20)
7958 printf ("pop compact {");
7959 else
7960 printf ("pop {");
7961
7962 decode_tic6x_unwind_regmask (mask);
7963 printf("}");
7964 }
7965 }
7966 else if ((op & 0xf0) == 0xc0)
7967 {
7968 unsigned int reg;
7969 unsigned int nregs;
7970 unsigned int i;
7971 const char *name;
a734115a
NC		 7972 struct
7973 {
fa197c1c
PB		 7974 unsigned int offset;
7975 unsigned int reg;
7976 } regpos[16];
7977
7978 /* Scan entire instruction first so that GET_OP output is not
7979 interleaved with disassembly. */
7980 nregs = 0;
7981 for (i = 0; nregs < (op & 0xf); i++)
7982 {
7983 GET_OP (op2);
7984 reg = op2 >> 4;
7985 if (reg != 0xf)
7986 {
7987 regpos[nregs].offset = i * 2;
7988 regpos[nregs].reg = reg;
7989 nregs++;
7990 }
7991
7992 reg = op2 & 0xf;
7993 if (reg != 0xf)
7994 {
7995 regpos[nregs].offset = i * 2 + 1;
7996 regpos[nregs].reg = reg;
7997 nregs++;
7998 }
7999 }
8000
8001 printf (_("pop frame {"));
8002 reg = nregs - 1;
8003 for (i = i * 2; i > 0; i--)
8004 {
8005 if (regpos[reg].offset == i - 1)
8006 {
8007 name = tic6x_unwind_regnames[regpos[reg].reg];
8008 if (reg > 0)
8009 reg--;
8010 }
8011 else
8012 name = _("[pad]");
8013
8014 fputs (name, stdout);
8015 if (i > 1)
8016 printf (", ");
8017 }
8018
8019 printf ("}");
8020 }
8021 else if (op == 0xd0)
8022 printf (" MOV FP, SP");
8023 else if (op == 0xd1)
8024 printf (" __c6xabi_pop_rts");
8025 else if (op == 0xd2)
8026 {
8027 unsigned char buf[9];
8028 unsigned int i, len;
8029 unsigned long offset;
a734115a 8030
fa197c1c
PB		 8031 for (i = 0; i < sizeof (buf); i++)
8032 {
8033 GET_OP (buf[i]);
8034 if ((buf[i] & 0x80) == 0)
8035 break;
8036 }
0eff7165
NC		 8037 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8038 if (i == sizeof (buf))
8039 {
8040 printf ("<corrupt sp adjust>\n");
8041 warn (_("Corrupt stack pointer adjustment detected\n"));
8042 return;
8043 }
948f632f 8044
f6f0e17b 8045 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8046 assert (len == i + 1);
8047 offset = offset * 8 + 0x408;
8048 printf (_("sp = sp + %ld"), offset);
8049 }
8050 else if ((op & 0xf0) == 0xe0)
8051 {
8052 if ((op & 0x0f) == 7)
8053 printf (" RETURN");
8054 else
8055 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8056 }
8057 else
8058 {
8059 printf (_(" [unsupported opcode]"));
8060 }
8061 putchar ('\n');
8062 }
8063}
8064
8065static bfd_vma
a734115a 8066arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8067{
8068 bfd_vma offset;
8069
8070 offset = word & 0x7fffffff;
8071 if (offset & 0x40000000)
8072 offset |= ~ (bfd_vma) 0x7fffffff;
8073
8074 if (elf_header.e_machine == EM_TI_C6000)
8075 offset <<= 1;
8076
8077 return offset + where;
8078}
8079
8080static void
1b31d05e
NC		 8081decode_arm_unwind (struct arm_unw_aux_info * aux,
8082 unsigned int word,
8083 unsigned int remaining,
8084 bfd_vma data_offset,
8085 Elf_Internal_Shdr * data_sec,
8086 struct arm_section * data_arm_sec)
fa197c1c
PB		 8087{
8088 int per_index;
8089 unsigned int more_words = 0;
37e14bc3 8090 struct absaddr addr;
1b31d05e 8091 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8092
8093 if (remaining == 0)
8094 {
1b31d05e
NC		 8095 /* Fetch the first word.
8096 Note - when decoding an object file the address extracted
8097 here will always be 0. So we also pass in the sym_name
8098 parameter so that we can find the symbol associated with
8099 the personality routine. */
8100 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8101 & word, & addr, & sym_name))
fa197c1c 8102 return;
1b31d05e 8103
fa197c1c
PB		 8104 remaining = 4;
8105 }
8106
8107 if ((word & 0x80000000) == 0)
8108 {
8109 /* Expand prel31 for personality routine. */
8110 bfd_vma fn;
8111 const char *procname;
8112
a734115a 8113 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8114 printf (_(" Personality routine: "));
1b31d05e
NC		 8115 if (fn == 0
8116 && addr.section == SHN_UNDEF && addr.offset == 0
8117 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8118 {
8119 procname = aux->strtab + sym_name;
8120 print_vma (fn, PREFIX_HEX);
8121 if (procname)
8122 {
8123 fputs (" <", stdout);
8124 fputs (procname, stdout);
8125 fputc ('>', stdout);
8126 }
8127 }
8128 else
8129 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8130 fputc ('\n', stdout);
8131
8132 /* The GCC personality routines use the standard compact
8133 encoding, starting with one byte giving the number of
8134 words. */
8135 if (procname != NULL
8136 && (const_strneq (procname, "__gcc_personality_v0")
8137 || const_strneq (procname, "__gxx_personality_v0")
8138 || const_strneq (procname, "__gcj_personality_v0")
8139 || const_strneq (procname, "__gnu_objc_personality_v0")))
8140 {
8141 remaining = 0;
8142 more_words = 1;
8143 ADVANCE;
8144 if (!remaining)
8145 {
8146 printf (_(" [Truncated data]\n"));
8147 return;
8148 }
8149 more_words = word >> 24;
8150 word <<= 8;
8151 remaining--;
8152 per_index = -1;
8153 }
8154 else
8155 return;
8156 }
8157 else
8158 {
1b31d05e 8159 /* ARM EHABI Section 6.3:
0b4362b0 8160
1b31d05e 8161 An exception-handling table entry for the compact model looks like:
0b4362b0 8162
1b31d05e
NC		 8163 31 30-28 27-24 23-0
8164 -- ----- ----- ----
8165 1 0 index Data for personalityRoutine[index] */
8166
8167 if (elf_header.e_machine == EM_ARM
8168 && (word & 0x70000000))
83c257ca 8169 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8170
fa197c1c 8171 per_index = (word >> 24) & 0x7f;
1b31d05e 8172 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8173 if (per_index == 0)
8174 {
8175 more_words = 0;
8176 word <<= 8;
8177 remaining--;
8178 }
8179 else if (per_index < 3)
8180 {
8181 more_words = (word >> 16) & 0xff;
8182 word <<= 16;
8183 remaining -= 2;
8184 }
8185 }
8186
8187 switch (elf_header.e_machine)
8188 {
8189 case EM_ARM:
8190 if (per_index < 3)
8191 {
8192 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8193 data_offset, data_sec, data_arm_sec);
8194 }
8195 else
1b31d05e
NC		 8196 {
8197 warn (_("Unknown ARM compact model index encountered\n"));
8198 printf (_(" [reserved]\n"));
8199 }
fa197c1c
PB		 8200 break;
8201
8202 case EM_TI_C6000:
8203 if (per_index < 3)
8204 {
8205 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8206 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8207 }
8208 else if (per_index < 5)
8209 {
8210 if (((word >> 17) & 0x7f) == 0x7f)
8211 printf (_(" Restore stack from frame pointer\n"));
8212 else
8213 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8214 printf (_(" Registers restored: "));
8215 if (per_index == 4)
8216 printf (" (compact) ");
8217 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8218 putchar ('\n');
8219 printf (_(" Return register: %s\n"),
8220 tic6x_unwind_regnames[word & 0xf]);
8221 }
8222 else
1b31d05e 8223 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8224 break;
8225
8226 default:
74e1a04b 8227 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8228 elf_header.e_machine);
fa197c1c 8229 }
0b6ae522
DJ		 8230
8231 /* Decode the descriptors. Not implemented. */
8232}
8233
8234static void
8235dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8236{
8237 struct arm_section exidx_arm_sec, extab_arm_sec;
8238 unsigned int i, exidx_len;
948f632f 8239 unsigned long j, nfuns;
0b6ae522
DJ		 8240
8241 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8242 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8243 exidx_len = exidx_sec->sh_size / 8;
8244
948f632f
DA		 8245 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8246 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8247 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8248 aux->funtab[nfuns++] = aux->symtab[j];
8249 aux->nfuns = nfuns;
8250 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8251
0b6ae522
DJ		 8252 for (i = 0; i < exidx_len; i++)
8253 {
8254 unsigned int exidx_fn, exidx_entry;
8255 struct absaddr fn_addr, entry_addr;
8256 bfd_vma fn;
8257
8258 fputc ('\n', stdout);
8259
1b31d05e
NC		 8260 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8261 8 * i, & exidx_fn, & fn_addr, NULL)
8262 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8263 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8264 {
948f632f 8265 free (aux->funtab);
1b31d05e
NC		 8266 arm_free_section (& exidx_arm_sec);
8267 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8268 return;
8269 }
8270
83c257ca
NC		 8271 /* ARM EHABI, Section 5:
8272 An index table entry consists of 2 words.
8273 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8274 if (exidx_fn & 0x80000000)
8275 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8276
a734115a 8277 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8278
a734115a 8279 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8280 fputs (": ", stdout);
8281
8282 if (exidx_entry == 1)
8283 {
8284 print_vma (exidx_entry, PREFIX_HEX);
8285 fputs (" [cantunwind]\n", stdout);
8286 }
8287 else if (exidx_entry & 0x80000000)
8288 {
8289 print_vma (exidx_entry, PREFIX_HEX);
8290 fputc ('\n', stdout);
8291 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8292 }
8293 else
8294 {
8f73510c 8295 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8296 Elf_Internal_Shdr *table_sec;
8297
8298 fputs ("@", stdout);
a734115a 8299 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8300 print_vma (table, PREFIX_HEX);
8301 printf ("\n");
8302
8303 /* Locate the matching .ARM.extab. */
8304 if (entry_addr.section != SHN_UNDEF
8305 && entry_addr.section < elf_header.e_shnum)
8306 {
8307 table_sec = section_headers + entry_addr.section;
8308 table_offset = entry_addr.offset;
8309 }
8310 else
8311 {
8312 table_sec = find_section_by_address (table);
8313 if (table_sec != NULL)
8314 table_offset = table - table_sec->sh_addr;
8315 }
8316 if (table_sec == NULL)
8317 {
8318 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8319 (unsigned long) table);
8320 continue;
8321 }
8322 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8323 &extab_arm_sec);
8324 }
8325 }
8326
8327 printf ("\n");
8328
948f632f 8329 free (aux->funtab);
0b6ae522
DJ		 8330 arm_free_section (&exidx_arm_sec);
8331 arm_free_section (&extab_arm_sec);
8332}
8333
fa197c1c 8334/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8335
8336static void
0b6ae522
DJ		 8337arm_process_unwind (FILE *file)
8338{
8339 struct arm_unw_aux_info aux;
8340 Elf_Internal_Shdr *unwsec = NULL;
8341 Elf_Internal_Shdr *strsec;
8342 Elf_Internal_Shdr *sec;
8343 unsigned long i;
fa197c1c 8344 unsigned int sec_type;
0b6ae522 8345
fa197c1c
PB		 8346 switch (elf_header.e_machine)
8347 {
8348 case EM_ARM:
8349 sec_type = SHT_ARM_EXIDX;
8350 break;
8351
8352 case EM_TI_C6000:
8353 sec_type = SHT_C6000_UNWIND;
8354 break;
8355
0b4362b0 8356 default:
74e1a04b 8357 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8358 elf_header.e_machine);
8359 return;
fa197c1c
PB		 8360 }
8361
0b6ae522 8362 if (string_table == NULL)
1b31d05e
NC		 8363 return;
8364
8365 memset (& aux, 0, sizeof (aux));
8366 aux.file = file;
0b6ae522
DJ		 8367
8368 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8369 {
8370 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8371 {
ba5cdace 8372 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8373
8374 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8375
8376 /* PR binutils/17531 file: 011-12666-0.004. */
8377 if (aux.strtab != NULL)
8378 {
4082ef84 8379 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8380 free (aux.strtab);
8381 }
0b6ae522
DJ		 8382 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8383 1, strsec->sh_size, _("string table"));
8384 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8385 }
fa197c1c 8386 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8387 unwsec = sec;
8388 }
8389
1b31d05e 8390 if (unwsec == NULL)
0b6ae522 8391 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8392 else
8393 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8394 {
8395 if (sec->sh_type == sec_type)
8396 {
8397 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8398 printable_section_name (sec),
1b31d05e
NC		 8399 (unsigned long) sec->sh_offset,
8400 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8401
1b31d05e
NC		 8402 dump_arm_unwind (&aux, sec);
8403 }
8404 }
0b6ae522
DJ		 8405
8406 if (aux.symtab)
8407 free (aux.symtab);
8408 if (aux.strtab)
8409 free ((char *) aux.strtab);
0b6ae522
DJ		 8410}
8411
1b31d05e 8412static void
2cf0635d 8413process_unwind (FILE * file)
57346661 8414{
2cf0635d
NC		 8415 struct unwind_handler
8416 {
57346661 8417 int machtype;
1b31d05e 8418 void (* handler)(FILE *);
2cf0635d
NC		 8419 } handlers[] =
8420 {
0b6ae522 8421 { EM_ARM, arm_process_unwind },
57346661
AM		 8422 { EM_IA_64, ia64_process_unwind },
8423 { EM_PARISC, hppa_process_unwind },
fa197c1c 8424 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8425 { 0, 0 }
8426 };
8427 int i;
8428
8429 if (!do_unwind)
1b31d05e 8430 return;
57346661
AM		 8431
8432 for (i = 0; handlers[i].handler != NULL; i++)
8433 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8434 {
8435 handlers[i].handler (file);
8436 return;
8437 }
57346661 8438
1b31d05e
NC		 8439 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8440 get_machine_name (elf_header.e_machine));
57346661
AM		 8441}
8442
252b5132 8443static void
2cf0635d 8444dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8445{
8446 switch (entry->d_tag)
8447 {
8448 case DT_MIPS_FLAGS:
8449 if (entry->d_un.d_val == 0)
4b68bca3 8450 printf (_("NONE"));
252b5132
RH		 8451 else
8452 {
8453 static const char * opts[] =
8454 {
8455 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8456 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8457 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8458 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8459 "RLD_ORDER_SAFE"
8460 };
8461 unsigned int cnt;
8462 int first = 1;
2b692964 8463
60bca95a 8464 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8465 if (entry->d_un.d_val & (1 << cnt))
8466 {
8467 printf ("%s%s", first ? "" : " ", opts[cnt]);
8468 first = 0;
8469 }
252b5132
RH		 8470 }
8471 break;
103f02d3 8472
252b5132 8473 case DT_MIPS_IVERSION:
d79b3d50 8474 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8475 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8476 else
76ca31c0
NC		 8477 {
8478 char buf[40];
8479 sprintf_vma (buf, entry->d_un.d_ptr);
8480 /* Note: coded this way so that there is a single string for translation. */
8481 printf (_("<corrupt: %s>"), buf);
8482 }
252b5132 8483 break;
103f02d3 8484
252b5132
RH		 8485 case DT_MIPS_TIME_STAMP:
8486 {
8487 char timebuf[20];
2cf0635d 8488 struct tm * tmp;
91d6fa6a 8489 time_t atime = entry->d_un.d_val;
82b1b41b 8490
91d6fa6a 8491 tmp = gmtime (&atime);
82b1b41b
NC		 8492 /* PR 17531: file: 6accc532. */
8493 if (tmp == NULL)
8494 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8495 else
8496 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8497 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8498 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8499 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8500 }
8501 break;
103f02d3 8502
252b5132
RH		 8503 case DT_MIPS_RLD_VERSION:
8504 case DT_MIPS_LOCAL_GOTNO:
8505 case DT_MIPS_CONFLICTNO:
8506 case DT_MIPS_LIBLISTNO:
8507 case DT_MIPS_SYMTABNO:
8508 case DT_MIPS_UNREFEXTNO:
8509 case DT_MIPS_HIPAGENO:
8510 case DT_MIPS_DELTA_CLASS_NO:
8511 case DT_MIPS_DELTA_INSTANCE_NO:
8512 case DT_MIPS_DELTA_RELOC_NO:
8513 case DT_MIPS_DELTA_SYM_NO:
8514 case DT_MIPS_DELTA_CLASSSYM_NO:
8515 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8516 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8517 break;
103f02d3
UD		 8518
8519 default:
4b68bca3 8520 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8521 }
4b68bca3 8522 putchar ('\n');
103f02d3
UD		 8523}
8524
103f02d3 8525static void
2cf0635d 8526dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8527{
8528 switch (entry->d_tag)
8529 {
8530 case DT_HP_DLD_FLAGS:
8531 {
8532 static struct
8533 {
8534 long int bit;
2cf0635d 8535 const char * str;
5e220199
NC		 8536 }
8537 flags[] =
8538 {
8539 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8540 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8541 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8542 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8543 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8544 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8545 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8546 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8547 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8548 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8549 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8550 { DT_HP_GST, "HP_GST" },
8551 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8552 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8553 { DT_HP_NODELETE, "HP_NODELETE" },
8554 { DT_HP_GROUP, "HP_GROUP" },
8555 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8556 };
103f02d3 8557 int first = 1;
5e220199 8558 size_t cnt;
f7a99963 8559 bfd_vma val = entry->d_un.d_val;
103f02d3 8560
60bca95a 8561 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8562 if (val & flags[cnt].bit)
30800947
NC		 8563 {
8564 if (! first)
8565 putchar (' ');
8566 fputs (flags[cnt].str, stdout);
8567 first = 0;
8568 val ^= flags[cnt].bit;
8569 }
76da6bbe 8570
103f02d3 8571 if (val != 0 || first)
f7a99963
NC		 8572 {
8573 if (! first)
8574 putchar (' ');
8575 print_vma (val, HEX);
8576 }
103f02d3
UD		 8577 }
8578 break;
76da6bbe 8579
252b5132 8580 default:
f7a99963
NC		 8581 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8582 break;
252b5132 8583 }
35b1837e 8584 putchar ('\n');
252b5132
RH		 8585}
8586
28f997cf
TG		 8587#ifdef BFD64
8588
8589/* VMS vs Unix time offset and factor. */
8590
8591#define VMS_EPOCH_OFFSET 35067168000000000LL
8592#define VMS_GRANULARITY_FACTOR 10000000
8593
8594/* Display a VMS time in a human readable format. */
8595
8596static void
8597print_vms_time (bfd_int64_t vmstime)
8598{
8599 struct tm *tm;
8600 time_t unxtime;
8601
8602 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8603 tm = gmtime (&unxtime);
8604 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8605 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8606 tm->tm_hour, tm->tm_min, tm->tm_sec);
8607}
8608#endif /* BFD64 */
8609
ecc51f48 8610static void
2cf0635d 8611dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8612{
8613 switch (entry->d_tag)
8614 {
0de14b54 8615 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8616 /* First 3 slots reserved. */
ecc51f48
NC		 8617 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8618 printf (" -- ");
8619 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8620 break;
8621
28f997cf
TG		 8622 case DT_IA_64_VMS_LINKTIME:
8623#ifdef BFD64
8624 print_vms_time (entry->d_un.d_val);
8625#endif
8626 break;
8627
8628 case DT_IA_64_VMS_LNKFLAGS:
8629 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8630 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8631 printf (" CALL_DEBUG");
8632 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8633 printf (" NOP0BUFS");
8634 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8635 printf (" P0IMAGE");
8636 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8637 printf (" MKTHREADS");
8638 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8639 printf (" UPCALLS");
8640 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8641 printf (" IMGSTA");
8642 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8643 printf (" INITIALIZE");
8644 if (entry->d_un.d_val & VMS_LF_MAIN)
8645 printf (" MAIN");
8646 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8647 printf (" EXE_INIT");
8648 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8649 printf (" TBK_IN_IMG");
8650 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8651 printf (" DBG_IN_IMG");
8652 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8653 printf (" TBK_IN_DSF");
8654 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8655 printf (" DBG_IN_DSF");
8656 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8657 printf (" SIGNATURES");
8658 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8659 printf (" REL_SEG_OFF");
8660 break;
8661
bdf4d63a
JJ		 8662 default:
8663 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8664 break;
ecc51f48 8665 }
bdf4d63a 8666 putchar ('\n');
ecc51f48
NC		 8667}
8668
252b5132 8669static int
2cf0635d 8670get_32bit_dynamic_section (FILE * file)
252b5132 8671{
2cf0635d
NC		 8672 Elf32_External_Dyn * edyn;
8673 Elf32_External_Dyn * ext;
8674 Elf_Internal_Dyn * entry;
103f02d3 8675
3f5e193b
NC		 8676 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8677 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8678 if (!edyn)
8679 return 0;
103f02d3 8680
071436c6
NC		 8681 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8682 might not have the luxury of section headers. Look for the DT_NULL
8683 terminator to determine the number of entries. */
ba2685cc 8684 for (ext = edyn, dynamic_nent = 0;
071436c6 8685 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8686 ext++)
8687 {
8688 dynamic_nent++;
8689 if (BYTE_GET (ext->d_tag) == DT_NULL)
8690 break;
8691 }
252b5132 8692
3f5e193b
NC		 8693 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8694 sizeof (* entry));
b2d38a17 8695 if (dynamic_section == NULL)
252b5132 8696 {
8b73c356
NC		 8697 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8698 (unsigned long) dynamic_nent);
9ea033b2
NC		 8699 free (edyn);
8700 return 0;
8701 }
252b5132 8702
fb514b26 8703 for (ext = edyn, entry = dynamic_section;
ba2685cc 8704 entry < dynamic_section + dynamic_nent;
fb514b26 8705 ext++, entry++)
9ea033b2 8706 {
fb514b26
AM		 8707 entry->d_tag = BYTE_GET (ext->d_tag);
8708 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8709 }
8710
9ea033b2
NC		 8711 free (edyn);
8712
8713 return 1;
8714}
8715
8716static int
2cf0635d 8717get_64bit_dynamic_section (FILE * file)
9ea033b2 8718{
2cf0635d
NC		 8719 Elf64_External_Dyn * edyn;
8720 Elf64_External_Dyn * ext;
8721 Elf_Internal_Dyn * entry;
103f02d3 8722
071436c6 8723 /* Read in the data. */
3f5e193b
NC		 8724 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8725 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8726 if (!edyn)
8727 return 0;
103f02d3 8728
071436c6
NC		 8729 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8730 might not have the luxury of section headers. Look for the DT_NULL
8731 terminator to determine the number of entries. */
ba2685cc 8732 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8733 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8734 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8735 ext++)
8736 {
8737 dynamic_nent++;
66543521 8738 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8739 break;
8740 }
252b5132 8741
3f5e193b
NC		 8742 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8743 sizeof (* entry));
b2d38a17 8744 if (dynamic_section == NULL)
252b5132 8745 {
8b73c356
NC		 8746 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8747 (unsigned long) dynamic_nent);
252b5132
RH		 8748 free (edyn);
8749 return 0;
8750 }
8751
071436c6 8752 /* Convert from external to internal formats. */
fb514b26 8753 for (ext = edyn, entry = dynamic_section;
ba2685cc 8754 entry < dynamic_section + dynamic_nent;
fb514b26 8755 ext++, entry++)
252b5132 8756 {
66543521
AM		 8757 entry->d_tag = BYTE_GET (ext->d_tag);
8758 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8759 }
8760
8761 free (edyn);
8762
9ea033b2
NC		 8763 return 1;
8764}
8765
e9e44622
JJ		 8766static void
8767print_dynamic_flags (bfd_vma flags)
d1133906 8768{
e9e44622 8769 int first = 1;
13ae64f3 8770
d1133906
NC		 8771 while (flags)
8772 {
8773 bfd_vma flag;
8774
8775 flag = flags & - flags;
8776 flags &= ~ flag;
8777
e9e44622
JJ		 8778 if (first)
8779 first = 0;
8780 else
8781 putc (' ', stdout);
13ae64f3 8782
d1133906
NC		 8783 switch (flag)
8784 {
e9e44622
JJ		 8785 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8786 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8787 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8788 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8789 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8790 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8791 }
8792 }
e9e44622 8793 puts ("");
d1133906
NC		 8794}
8795
b2d38a17
NC		 8796/* Parse and display the contents of the dynamic section. */
8797
9ea033b2 8798static int
2cf0635d 8799process_dynamic_section (FILE * file)
9ea033b2 8800{
2cf0635d 8801 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8802
8803 if (dynamic_size == 0)
8804 {
8805 if (do_dynamic)
b2d38a17 8806 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8807
8808 return 1;
8809 }
8810
8811 if (is_32bit_elf)
8812 {
b2d38a17 8813 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8814 return 0;
8815 }
b2d38a17 8816 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8817 return 0;
8818
252b5132
RH		 8819 /* Find the appropriate symbol table. */
8820 if (dynamic_symbols == NULL)
8821 {
86dba8ee
AM		 8822 for (entry = dynamic_section;
8823 entry < dynamic_section + dynamic_nent;
8824 ++entry)
252b5132 8825 {
c8286bd1 8826 Elf_Internal_Shdr section;
252b5132
RH		 8827
8828 if (entry->d_tag != DT_SYMTAB)
8829 continue;
8830
8831 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8832
8833 /* Since we do not know how big the symbol table is,
8834 we default to reading in the entire file (!) and
8835 processing that. This is overkill, I know, but it
e3c8793a 8836 should work. */
d93f0186 8837 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8838
fb52b2f4
NC		 8839 if (archive_file_offset != 0)
8840 section.sh_size = archive_file_size - section.sh_offset;
8841 else
8842 {
8843 if (fseek (file, 0, SEEK_END))
591a748a 8844 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8845
8846 section.sh_size = ftell (file) - section.sh_offset;
8847 }
252b5132 8848
9ea033b2 8849 if (is_32bit_elf)
9ad5cbcf 8850 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8851 else
9ad5cbcf 8852 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8853 section.sh_name = string_table_length;
252b5132 8854
ba5cdace 8855 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8856 if (num_dynamic_syms < 1)
252b5132
RH		 8857 {
8858 error (_("Unable to determine the number of symbols to load\n"));
8859 continue;
8860 }
252b5132
RH		 8861 }
8862 }
8863
8864 /* Similarly find a string table. */
8865 if (dynamic_strings == NULL)
8866 {
86dba8ee
AM		 8867 for (entry = dynamic_section;
8868 entry < dynamic_section + dynamic_nent;
8869 ++entry)
252b5132
RH		 8870 {
8871 unsigned long offset;
b34976b6 8872 long str_tab_len;
252b5132
RH		 8873
8874 if (entry->d_tag != DT_STRTAB)
8875 continue;
8876
8877 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8878
8879 /* Since we do not know how big the string table is,
8880 we default to reading in the entire file (!) and
8881 processing that. This is overkill, I know, but it
e3c8793a 8882 should work. */
252b5132 8883
d93f0186 8884 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8885
8886 if (archive_file_offset != 0)
8887 str_tab_len = archive_file_size - offset;
8888 else
8889 {
8890 if (fseek (file, 0, SEEK_END))
8891 error (_("Unable to seek to end of file\n"));
8892 str_tab_len = ftell (file) - offset;
8893 }
252b5132
RH		 8894
8895 if (str_tab_len < 1)
8896 {
8897 error
8898 (_("Unable to determine the length of the dynamic string table\n"));
8899 continue;
8900 }
8901
3f5e193b
NC		 8902 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8903 str_tab_len,
8904 _("dynamic string table"));
59245841 8905 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8906 break;
8907 }
8908 }
8909
8910 /* And find the syminfo section if available. */
8911 if (dynamic_syminfo == NULL)
8912 {
3e8bba36 8913 unsigned long syminsz = 0;
252b5132 8914
86dba8ee
AM		 8915 for (entry = dynamic_section;
8916 entry < dynamic_section + dynamic_nent;
8917 ++entry)
252b5132
RH		 8918 {
8919 if (entry->d_tag == DT_SYMINENT)
8920 {
8921 /* Note: these braces are necessary to avoid a syntax
8922 error from the SunOS4 C compiler. */
049b0c3a
NC		 8923 /* PR binutils/17531: A corrupt file can trigger this test.
8924 So do not use an assert, instead generate an error message. */
8925 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8926 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8927 (int) entry->d_un.d_val);
252b5132
RH		 8928 }
8929 else if (entry->d_tag == DT_SYMINSZ)
8930 syminsz = entry->d_un.d_val;
8931 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8932 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8933 syminsz);
252b5132
RH		 8934 }
8935
8936 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8937 {
2cf0635d
NC		 8938 Elf_External_Syminfo * extsyminfo;
8939 Elf_External_Syminfo * extsym;
8940 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8941
8942 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8943 extsyminfo = (Elf_External_Syminfo *)
8944 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8945 _("symbol information"));
a6e9f9df
AM		 8946 if (!extsyminfo)
8947 return 0;
252b5132 8948
3f5e193b 8949 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8950 if (dynamic_syminfo == NULL)
8951 {
8b73c356
NC		 8952 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8953 (unsigned long) syminsz);
252b5132
RH		 8954 return 0;
8955 }
8956
8957 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8958 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8959 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8960 ++syminfo, ++extsym)
252b5132 8961 {
86dba8ee
AM		 8962 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8963 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8964 }
8965
8966 free (extsyminfo);
8967 }
8968 }
8969
8970 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8971 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8972 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8973 if (do_dynamic)
8974 printf (_(" Tag Type Name/Value\n"));
8975
86dba8ee
AM		 8976 for (entry = dynamic_section;
8977 entry < dynamic_section + dynamic_nent;
8978 entry++)
252b5132
RH		 8979 {
8980 if (do_dynamic)
f7a99963 8981 {
2cf0635d 8982 const char * dtype;
e699b9ff 8983
f7a99963
NC		 8984 putchar (' ');
8985 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8986 dtype = get_dynamic_type (entry->d_tag);
8987 printf (" (%s)%*s", dtype,
8988 ((is_32bit_elf ? 27 : 19)
8989 - (int) strlen (dtype)),
f7a99963
NC		 8990 " ");
8991 }
252b5132
RH		 8992
8993 switch (entry->d_tag)
8994 {
d1133906
NC		 8995 case DT_FLAGS:
8996 if (do_dynamic)
e9e44622 8997 print_dynamic_flags (entry->d_un.d_val);
d1133906 8998 break;
76da6bbe 8999
252b5132
RH		 9000 case DT_AUXILIARY:
9001 case DT_FILTER:
019148e4
L		 9002 case DT_CONFIG:
9003 case DT_DEPAUDIT:
9004 case DT_AUDIT:
252b5132
RH		 9005 if (do_dynamic)
9006 {
019148e4 9007 switch (entry->d_tag)
b34976b6 9008 {
019148e4
L		 9009 case DT_AUXILIARY:
9010 printf (_("Auxiliary library"));
9011 break;
9012
9013 case DT_FILTER:
9014 printf (_("Filter library"));
9015 break;
9016
b34976b6 9017 case DT_CONFIG:
019148e4
L		 9018 printf (_("Configuration file"));
9019 break;
9020
9021 case DT_DEPAUDIT:
9022 printf (_("Dependency audit library"));
9023 break;
9024
9025 case DT_AUDIT:
9026 printf (_("Audit library"));
9027 break;
9028 }
252b5132 9029
d79b3d50
NC		 9030 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9031 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9032 else
f7a99963
NC		 9033 {
9034 printf (": ");
9035 print_vma (entry->d_un.d_val, PREFIX_HEX);
9036 putchar ('\n');
9037 }
252b5132
RH		 9038 }
9039 break;
9040
dcefbbbd 9041 case DT_FEATURE:
252b5132
RH		 9042 if (do_dynamic)
9043 {
9044 printf (_("Flags:"));
86f55779 9045
252b5132
RH		 9046 if (entry->d_un.d_val == 0)
9047 printf (_(" None\n"));
9048 else
9049 {
9050 unsigned long int val = entry->d_un.d_val;
86f55779 9051
252b5132
RH		 9052 if (val & DTF_1_PARINIT)
9053 {
9054 printf (" PARINIT");
9055 val ^= DTF_1_PARINIT;
9056 }
dcefbbbd
L		 9057 if (val & DTF_1_CONFEXP)
9058 {
9059 printf (" CONFEXP");
9060 val ^= DTF_1_CONFEXP;
9061 }
252b5132
RH		 9062 if (val != 0)
9063 printf (" %lx", val);
9064 puts ("");
9065 }
9066 }
9067 break;
9068
9069 case DT_POSFLAG_1:
9070 if (do_dynamic)
9071 {
9072 printf (_("Flags:"));
86f55779 9073
252b5132
RH		 9074 if (entry->d_un.d_val == 0)
9075 printf (_(" None\n"));
9076 else
9077 {
9078 unsigned long int val = entry->d_un.d_val;
86f55779 9079
252b5132
RH		 9080 if (val & DF_P1_LAZYLOAD)
9081 {
9082 printf (" LAZYLOAD");
9083 val ^= DF_P1_LAZYLOAD;
9084 }
9085 if (val & DF_P1_GROUPPERM)
9086 {
9087 printf (" GROUPPERM");
9088 val ^= DF_P1_GROUPPERM;
9089 }
9090 if (val != 0)
9091 printf (" %lx", val);
9092 puts ("");
9093 }
9094 }
9095 break;
9096
9097 case DT_FLAGS_1:
9098 if (do_dynamic)
9099 {
9100 printf (_("Flags:"));
9101 if (entry->d_un.d_val == 0)
9102 printf (_(" None\n"));
9103 else
9104 {
9105 unsigned long int val = entry->d_un.d_val;
86f55779 9106
252b5132
RH		 9107 if (val & DF_1_NOW)
9108 {
9109 printf (" NOW");
9110 val ^= DF_1_NOW;
9111 }
9112 if (val & DF_1_GLOBAL)
9113 {
9114 printf (" GLOBAL");
9115 val ^= DF_1_GLOBAL;
9116 }
9117 if (val & DF_1_GROUP)
9118 {
9119 printf (" GROUP");
9120 val ^= DF_1_GROUP;
9121 }
9122 if (val & DF_1_NODELETE)
9123 {
9124 printf (" NODELETE");
9125 val ^= DF_1_NODELETE;
9126 }
9127 if (val & DF_1_LOADFLTR)
9128 {
9129 printf (" LOADFLTR");
9130 val ^= DF_1_LOADFLTR;
9131 }
9132 if (val & DF_1_INITFIRST)
9133 {
9134 printf (" INITFIRST");
9135 val ^= DF_1_INITFIRST;
9136 }
9137 if (val & DF_1_NOOPEN)
9138 {
9139 printf (" NOOPEN");
9140 val ^= DF_1_NOOPEN;
9141 }
9142 if (val & DF_1_ORIGIN)
9143 {
9144 printf (" ORIGIN");
9145 val ^= DF_1_ORIGIN;
9146 }
9147 if (val & DF_1_DIRECT)
9148 {
9149 printf (" DIRECT");
9150 val ^= DF_1_DIRECT;
9151 }
9152 if (val & DF_1_TRANS)
9153 {
9154 printf (" TRANS");
9155 val ^= DF_1_TRANS;
9156 }
9157 if (val & DF_1_INTERPOSE)
9158 {
9159 printf (" INTERPOSE");
9160 val ^= DF_1_INTERPOSE;
9161 }
f7db6139 9162 if (val & DF_1_NODEFLIB)
dcefbbbd 9163 {
f7db6139
L		 9164 printf (" NODEFLIB");
9165 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9166 }
9167 if (val & DF_1_NODUMP)
9168 {
9169 printf (" NODUMP");
9170 val ^= DF_1_NODUMP;
9171 }
34b60028 9172 if (val & DF_1_CONFALT)
dcefbbbd 9173 {
34b60028
L		 9174 printf (" CONFALT");
9175 val ^= DF_1_CONFALT;
9176 }
9177 if (val & DF_1_ENDFILTEE)
9178 {
9179 printf (" ENDFILTEE");
9180 val ^= DF_1_ENDFILTEE;
9181 }
9182 if (val & DF_1_DISPRELDNE)
9183 {
9184 printf (" DISPRELDNE");
9185 val ^= DF_1_DISPRELDNE;
9186 }
9187 if (val & DF_1_DISPRELPND)
9188 {
9189 printf (" DISPRELPND");
9190 val ^= DF_1_DISPRELPND;
9191 }
9192 if (val & DF_1_NODIRECT)
9193 {
9194 printf (" NODIRECT");
9195 val ^= DF_1_NODIRECT;
9196 }
9197 if (val & DF_1_IGNMULDEF)
9198 {
9199 printf (" IGNMULDEF");
9200 val ^= DF_1_IGNMULDEF;
9201 }
9202 if (val & DF_1_NOKSYMS)
9203 {
9204 printf (" NOKSYMS");
9205 val ^= DF_1_NOKSYMS;
9206 }
9207 if (val & DF_1_NOHDR)
9208 {
9209 printf (" NOHDR");
9210 val ^= DF_1_NOHDR;
9211 }
9212 if (val & DF_1_EDITED)
9213 {
9214 printf (" EDITED");
9215 val ^= DF_1_EDITED;
9216 }
9217 if (val & DF_1_NORELOC)
9218 {
9219 printf (" NORELOC");
9220 val ^= DF_1_NORELOC;
9221 }
9222 if (val & DF_1_SYMINTPOSE)
9223 {
9224 printf (" SYMINTPOSE");
9225 val ^= DF_1_SYMINTPOSE;
9226 }
9227 if (val & DF_1_GLOBAUDIT)
9228 {
9229 printf (" GLOBAUDIT");
9230 val ^= DF_1_GLOBAUDIT;
9231 }
9232 if (val & DF_1_SINGLETON)
9233 {
9234 printf (" SINGLETON");
9235 val ^= DF_1_SINGLETON;
dcefbbbd 9236 }
252b5132
RH		 9237 if (val != 0)
9238 printf (" %lx", val);
9239 puts ("");
9240 }
9241 }
9242 break;
9243
9244 case DT_PLTREL:
566b0d53 9245 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9246 if (do_dynamic)
9247 puts (get_dynamic_type (entry->d_un.d_val));
9248 break;
9249
9250 case DT_NULL :
9251 case DT_NEEDED :
9252 case DT_PLTGOT :
9253 case DT_HASH :
9254 case DT_STRTAB :
9255 case DT_SYMTAB :
9256 case DT_RELA :
9257 case DT_INIT :
9258 case DT_FINI :
9259 case DT_SONAME :
9260 case DT_RPATH :
9261 case DT_SYMBOLIC:
9262 case DT_REL :
9263 case DT_DEBUG :
9264 case DT_TEXTREL :
9265 case DT_JMPREL :
019148e4 9266 case DT_RUNPATH :
252b5132
RH		 9267 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9268
9269 if (do_dynamic)
9270 {
2cf0635d 9271 char * name;
252b5132 9272
d79b3d50
NC		 9273 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9274 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9275 else
d79b3d50 9276 name = NULL;
252b5132
RH		 9277
9278 if (name)
9279 {
9280 switch (entry->d_tag)
9281 {
9282 case DT_NEEDED:
9283 printf (_("Shared library: [%s]"), name);
9284
18bd398b 9285 if (streq (name, program_interpreter))
f7a99963 9286 printf (_(" program interpreter"));
252b5132
RH		 9287 break;
9288
9289 case DT_SONAME:
f7a99963 9290 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9291 break;
9292
9293 case DT_RPATH:
f7a99963 9294 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9295 break;
9296
019148e4
L		 9297 case DT_RUNPATH:
9298 printf (_("Library runpath: [%s]"), name);
9299 break;
9300
252b5132 9301 default:
f7a99963
NC		 9302 print_vma (entry->d_un.d_val, PREFIX_HEX);
9303 break;
252b5132
RH		 9304 }
9305 }
9306 else
f7a99963
NC		 9307 print_vma (entry->d_un.d_val, PREFIX_HEX);
9308
9309 putchar ('\n');
252b5132
RH		 9310 }
9311 break;
9312
9313 case DT_PLTRELSZ:
9314 case DT_RELASZ :
9315 case DT_STRSZ :
9316 case DT_RELSZ :
9317 case DT_RELAENT :
9318 case DT_SYMENT :
9319 case DT_RELENT :
566b0d53 9320 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9321 case DT_PLTPADSZ:
9322 case DT_MOVEENT :
9323 case DT_MOVESZ :
9324 case DT_INIT_ARRAYSZ:
9325 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9326 case DT_GNU_CONFLICTSZ:
9327 case DT_GNU_LIBLISTSZ:
252b5132 9328 if (do_dynamic)
f7a99963
NC		 9329 {
9330 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9331 printf (_(" (bytes)\n"));
f7a99963 9332 }
252b5132
RH		 9333 break;
9334
9335 case DT_VERDEFNUM:
9336 case DT_VERNEEDNUM:
9337 case DT_RELACOUNT:
9338 case DT_RELCOUNT:
9339 if (do_dynamic)
f7a99963
NC		 9340 {
9341 print_vma (entry->d_un.d_val, UNSIGNED);
9342 putchar ('\n');
9343 }
252b5132
RH		 9344 break;
9345
9346 case DT_SYMINSZ:
9347 case DT_SYMINENT:
9348 case DT_SYMINFO:
9349 case DT_USED:
9350 case DT_INIT_ARRAY:
9351 case DT_FINI_ARRAY:
9352 if (do_dynamic)
9353 {
d79b3d50
NC		 9354 if (entry->d_tag == DT_USED
9355 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9356 {
2cf0635d 9357 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9358
b34976b6 9359 if (*name)
252b5132
RH		 9360 {
9361 printf (_("Not needed object: [%s]\n"), name);
9362 break;
9363 }
9364 }
103f02d3 9365
f7a99963
NC		 9366 print_vma (entry->d_un.d_val, PREFIX_HEX);
9367 putchar ('\n');
252b5132
RH		 9368 }
9369 break;
9370
9371 case DT_BIND_NOW:
9372 /* The value of this entry is ignored. */
35b1837e
AM		 9373 if (do_dynamic)
9374 putchar ('\n');
252b5132 9375 break;
103f02d3 9376
047b2264
JJ		 9377 case DT_GNU_PRELINKED:
9378 if (do_dynamic)
9379 {
2cf0635d 9380 struct tm * tmp;
91d6fa6a 9381 time_t atime = entry->d_un.d_val;
047b2264 9382
91d6fa6a 9383 tmp = gmtime (&atime);
071436c6
NC		 9384 /* PR 17533 file: 041-1244816-0.004. */
9385 if (tmp == NULL)
5a2cbcf4
L		 9386 printf (_("<corrupt time val: %lx"),
9387 (unsigned long) atime);
071436c6
NC		 9388 else
9389 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9390 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9391 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9392
9393 }
9394 break;
9395
fdc90cb4
JJ		 9396 case DT_GNU_HASH:
9397 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9398 if (do_dynamic)
9399 {
9400 print_vma (entry->d_un.d_val, PREFIX_HEX);
9401 putchar ('\n');
9402 }
9403 break;
9404
252b5132
RH		 9405 default:
9406 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9407 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9408 entry->d_un.d_val;
9409
9410 if (do_dynamic)
9411 {
9412 switch (elf_header.e_machine)
9413 {
9414 case EM_MIPS:
4fe85591 9415 case EM_MIPS_RS3_LE:
b2d38a17 9416 dynamic_section_mips_val (entry);
252b5132 9417 break;
103f02d3 9418 case EM_PARISC:
b2d38a17 9419 dynamic_section_parisc_val (entry);
103f02d3 9420 break;
ecc51f48 9421 case EM_IA_64:
b2d38a17 9422 dynamic_section_ia64_val (entry);
ecc51f48 9423 break;
252b5132 9424 default:
f7a99963
NC		 9425 print_vma (entry->d_un.d_val, PREFIX_HEX);
9426 putchar ('\n');
252b5132
RH		 9427 }
9428 }
9429 break;
9430 }
9431 }
9432
9433 return 1;
9434}
9435
9436static char *
d3ba0551 9437get_ver_flags (unsigned int flags)
252b5132 9438{
b34976b6 9439 static char buff[32];
252b5132
RH		 9440
9441 buff[0] = 0;
9442
9443 if (flags == 0)
9444 return _("none");
9445
9446 if (flags & VER_FLG_BASE)
9447 strcat (buff, "BASE ");
9448
9449 if (flags & VER_FLG_WEAK)
9450 {
9451 if (flags & VER_FLG_BASE)
9452 strcat (buff, "| ");
9453
9454 strcat (buff, "WEAK ");
9455 }
9456
44ec90b9
RO		 9457 if (flags & VER_FLG_INFO)
9458 {
9459 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9460 strcat (buff, "| ");
9461
9462 strcat (buff, "INFO ");
9463 }
9464
9465 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9466 strcat (buff, _("| <unknown>"));
252b5132
RH		 9467
9468 return buff;
9469}
9470
9471/* Display the contents of the version sections. */
98fb390a 9472
252b5132 9473static int
2cf0635d 9474process_version_sections (FILE * file)
252b5132 9475{
2cf0635d 9476 Elf_Internal_Shdr * section;
b34976b6
AM		 9477 unsigned i;
9478 int found = 0;
252b5132
RH		 9479
9480 if (! do_version)
9481 return 1;
9482
9483 for (i = 0, section = section_headers;
9484 i < elf_header.e_shnum;
b34976b6 9485 i++, section++)
252b5132
RH		 9486 {
9487 switch (section->sh_type)
9488 {
9489 case SHT_GNU_verdef:
9490 {
2cf0635d 9491 Elf_External_Verdef * edefs;
b34976b6
AM		 9492 unsigned int idx;
9493 unsigned int cnt;
2cf0635d 9494 char * endbuf;
252b5132
RH		 9495
9496 found = 1;
9497
74e1a04b
NC		 9498 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9499 printable_section_name (section),
9500 section->sh_info);
252b5132
RH		 9501
9502 printf (_(" Addr: 0x"));
9503 printf_vma (section->sh_addr);
74e1a04b 9504 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9505 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9506 printable_section_name_from_index (section->sh_link));
252b5132 9507
3f5e193b
NC		 9508 edefs = (Elf_External_Verdef *)
9509 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9510 _("version definition section"));
a6e9f9df
AM		 9511 if (!edefs)
9512 break;
59245841 9513 endbuf = (char *) edefs + section->sh_size;
252b5132 9514
b34976b6 9515 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9516 {
2cf0635d
NC		 9517 char * vstart;
9518 Elf_External_Verdef * edef;
b34976b6 9519 Elf_Internal_Verdef ent;
2cf0635d 9520 Elf_External_Verdaux * eaux;
b34976b6
AM		 9521 Elf_Internal_Verdaux aux;
9522 int j;
9523 int isum;
103f02d3 9524
7e26601c
NC		 9525 /* Check for very large indicies. */
9526 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9527 break;
9528
252b5132 9529 vstart = ((char *) edefs) + idx;
54806181
AM		 9530 if (vstart + sizeof (*edef) > endbuf)
9531 break;
252b5132
RH		 9532
9533 edef = (Elf_External_Verdef *) vstart;
9534
9535 ent.vd_version = BYTE_GET (edef->vd_version);
9536 ent.vd_flags = BYTE_GET (edef->vd_flags);
9537 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9538 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9539 ent.vd_hash = BYTE_GET (edef->vd_hash);
9540 ent.vd_aux = BYTE_GET (edef->vd_aux);
9541 ent.vd_next = BYTE_GET (edef->vd_next);
9542
9543 printf (_(" %#06x: Rev: %d Flags: %s"),
9544 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9545
9546 printf (_(" Index: %d Cnt: %d "),
9547 ent.vd_ndx, ent.vd_cnt);
9548
dd24e3da 9549 /* Check for overflow. */
7e26601c 9550 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9551 break;
9552
252b5132
RH		 9553 vstart += ent.vd_aux;
9554
9555 eaux = (Elf_External_Verdaux *) vstart;
9556
9557 aux.vda_name = BYTE_GET (eaux->vda_name);
9558 aux.vda_next = BYTE_GET (eaux->vda_next);
9559
d79b3d50
NC		 9560 if (VALID_DYNAMIC_NAME (aux.vda_name))
9561 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9562 else
9563 printf (_("Name index: %ld\n"), aux.vda_name);
9564
9565 isum = idx + ent.vd_aux;
9566
b34976b6 9567 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9568 {
dd24e3da 9569 /* Check for overflow. */
7e26601c 9570 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9571 break;
9572
252b5132
RH		 9573 isum += aux.vda_next;
9574 vstart += aux.vda_next;
9575
9576 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9577 if (vstart + sizeof (*eaux) > endbuf)
9578 break;
252b5132
RH		 9579
9580 aux.vda_name = BYTE_GET (eaux->vda_name);
9581 aux.vda_next = BYTE_GET (eaux->vda_next);
9582
d79b3d50 9583 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9584 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9585 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9586 else
9587 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9588 isum, j, aux.vda_name);
9589 }
dd24e3da 9590
54806181
AM		 9591 if (j < ent.vd_cnt)
9592 printf (_(" Version def aux past end of section\n"));
252b5132 9593
5d921cbd
NC		 9594 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9595 if (idx + ent.vd_next <= idx)
9596 break;
9597
252b5132
RH		 9598 idx += ent.vd_next;
9599 }
dd24e3da 9600
54806181
AM		 9601 if (cnt < section->sh_info)
9602 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9603
9604 free (edefs);
9605 }
9606 break;
103f02d3 9607
252b5132
RH		 9608 case SHT_GNU_verneed:
9609 {
2cf0635d 9610 Elf_External_Verneed * eneed;
b34976b6
AM		 9611 unsigned int idx;
9612 unsigned int cnt;
2cf0635d 9613 char * endbuf;
252b5132
RH		 9614
9615 found = 1;
9616
72de5009 9617 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9618 printable_section_name (section), section->sh_info);
252b5132
RH		 9619
9620 printf (_(" Addr: 0x"));
9621 printf_vma (section->sh_addr);
72de5009 9622 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9623 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9624 printable_section_name_from_index (section->sh_link));
252b5132 9625
3f5e193b
NC		 9626 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9627 section->sh_offset, 1,
9628 section->sh_size,
9cf03b7e 9629 _("Version Needs section"));
a6e9f9df
AM		 9630 if (!eneed)
9631 break;
59245841 9632 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9633
9634 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9635 {
2cf0635d 9636 Elf_External_Verneed * entry;
b34976b6
AM		 9637 Elf_Internal_Verneed ent;
9638 int j;
9639 int isum;
2cf0635d 9640 char * vstart;
252b5132 9641
7e26601c 9642 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9643 break;
9644
252b5132 9645 vstart = ((char *) eneed) + idx;
54806181
AM		 9646 if (vstart + sizeof (*entry) > endbuf)
9647 break;
252b5132
RH		 9648
9649 entry = (Elf_External_Verneed *) vstart;
9650
9651 ent.vn_version = BYTE_GET (entry->vn_version);
9652 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9653 ent.vn_file = BYTE_GET (entry->vn_file);
9654 ent.vn_aux = BYTE_GET (entry->vn_aux);
9655 ent.vn_next = BYTE_GET (entry->vn_next);
9656
9657 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9658
d79b3d50
NC		 9659 if (VALID_DYNAMIC_NAME (ent.vn_file))
9660 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9661 else
9662 printf (_(" File: %lx"), ent.vn_file);
9663
9664 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9665
dd24e3da 9666 /* Check for overflow. */
7e26601c 9667 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9668 break;
252b5132
RH		 9669 vstart += ent.vn_aux;
9670
9671 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9672 {
2cf0635d 9673 Elf_External_Vernaux * eaux;
b34976b6 9674 Elf_Internal_Vernaux aux;
252b5132 9675
54806181
AM		 9676 if (vstart + sizeof (*eaux) > endbuf)
9677 break;
252b5132
RH		 9678 eaux = (Elf_External_Vernaux *) vstart;
9679
9680 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9681 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9682 aux.vna_other = BYTE_GET (eaux->vna_other);
9683 aux.vna_name = BYTE_GET (eaux->vna_name);
9684 aux.vna_next = BYTE_GET (eaux->vna_next);
9685
d79b3d50 9686 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9687 printf (_(" %#06x: Name: %s"),
d79b3d50 9688 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9689 else
ecc2063b 9690 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9691 isum, aux.vna_name);
9692
9693 printf (_(" Flags: %s Version: %d\n"),
9694 get_ver_flags (aux.vna_flags), aux.vna_other);
9695
dd24e3da 9696 /* Check for overflow. */
53774b7e
NC		 9697 if (aux.vna_next > (size_t) (endbuf - vstart)
9698 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9699 {
9700 warn (_("Invalid vna_next field of %lx\n"),
9701 aux.vna_next);
9702 j = ent.vn_cnt;
9703 break;
9704 }
252b5132
RH		 9705 isum += aux.vna_next;
9706 vstart += aux.vna_next;
9707 }
9cf03b7e 9708
54806181 9709 if (j < ent.vn_cnt)
9cf03b7e 9710 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9711
bcf83b2a 9712 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9713 {
9714 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9715 cnt = section->sh_info;
9716 break;
9717 }
252b5132
RH		 9718 idx += ent.vn_next;
9719 }
9cf03b7e 9720
54806181 9721 if (cnt < section->sh_info)
9cf03b7e 9722 warn (_("Missing Version Needs information\n"));
103f02d3 9723
252b5132
RH		 9724 free (eneed);
9725 }
9726 break;
9727
9728 case SHT_GNU_versym:
9729 {
2cf0635d 9730 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9731 size_t total;
9732 unsigned int cnt;
2cf0635d
NC		 9733 unsigned char * edata;
9734 unsigned short * data;
9735 char * strtab;
9736 Elf_Internal_Sym * symbols;
9737 Elf_Internal_Shdr * string_sec;
ba5cdace 9738 unsigned long num_syms;
d3ba0551 9739 long off;
252b5132 9740
4fbb74a6 9741 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9742 break;
9743
4fbb74a6 9744 link_section = section_headers + section->sh_link;
08d8fa11 9745 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9746
4fbb74a6 9747 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9748 break;
9749
252b5132
RH		 9750 found = 1;
9751
ba5cdace 9752 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9753 if (symbols == NULL)
9754 break;
252b5132 9755
4fbb74a6 9756 string_sec = section_headers + link_section->sh_link;
252b5132 9757
3f5e193b
NC		 9758 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9759 string_sec->sh_size,
9760 _("version string table"));
a6e9f9df 9761 if (!strtab)
0429c154
MS		 9762 {
9763 free (symbols);
9764 break;
9765 }
252b5132 9766
8b73c356
NC		 9767 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9768 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9769
9770 printf (_(" Addr: "));
9771 printf_vma (section->sh_addr);
72de5009 9772 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9773 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9774 printable_section_name (link_section));
252b5132 9775
d3ba0551
AM		 9776 off = offset_from_vma (file,
9777 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9778 total * sizeof (short));
3f5e193b
NC		 9779 edata = (unsigned char *) get_data (NULL, file, off, total,
9780 sizeof (short),
9781 _("version symbol data"));
a6e9f9df
AM		 9782 if (!edata)
9783 {
9784 free (strtab);
0429c154 9785 free (symbols);
a6e9f9df
AM		 9786 break;
9787 }
252b5132 9788
3f5e193b 9789 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9790
9791 for (cnt = total; cnt --;)
b34976b6
AM		 9792 data[cnt] = byte_get (edata + cnt * sizeof (short),
9793 sizeof (short));
252b5132
RH		 9794
9795 free (edata);
9796
9797 for (cnt = 0; cnt < total; cnt += 4)
9798 {
9799 int j, nn;
00d93f34 9800 int check_def, check_need;
2cf0635d 9801 char * name;
252b5132
RH		 9802
9803 printf (" %03x:", cnt);
9804
9805 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9806 switch (data[cnt + j])
252b5132
RH		 9807 {
9808 case 0:
9809 fputs (_(" 0 (*local*) "), stdout);
9810 break;
9811
9812 case 1:
9813 fputs (_(" 1 (*global*) "), stdout);
9814 break;
9815
9816 default:
c244d050
NC		 9817 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9818 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9819
dd24e3da 9820 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9821 array, break to avoid an out-of-bounds read. */
9822 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9823 {
9824 warn (_("invalid index into symbol array\n"));
9825 break;
9826 }
9827
00d93f34
JJ		 9828 check_def = 1;
9829 check_need = 1;
4fbb74a6
AM		 9830 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9831 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9832 != SHT_NOBITS)
252b5132 9833 {
b34976b6 9834 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9835 check_def = 0;
9836 else
9837 check_need = 0;
252b5132 9838 }
00d93f34
JJ		 9839
9840 if (check_need
b34976b6 9841 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9842 {
b34976b6
AM		 9843 Elf_Internal_Verneed ivn;
9844 unsigned long offset;
252b5132 9845
d93f0186
NC		 9846 offset = offset_from_vma
9847 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9848 sizeof (Elf_External_Verneed));
252b5132 9849
b34976b6 9850 do
252b5132 9851 {
b34976b6
AM		 9852 Elf_Internal_Vernaux ivna;
9853 Elf_External_Verneed evn;
9854 Elf_External_Vernaux evna;
9855 unsigned long a_off;
252b5132 9856
59245841
NC		 9857 if (get_data (&evn, file, offset, sizeof (evn), 1,
9858 _("version need")) == NULL)
9859 break;
0b4362b0 9860
252b5132
RH		 9861 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9862 ivn.vn_next = BYTE_GET (evn.vn_next);
9863
9864 a_off = offset + ivn.vn_aux;
9865
9866 do
9867 {
59245841
NC		 9868 if (get_data (&evna, file, a_off, sizeof (evna),
9869 1, _("version need aux (2)")) == NULL)
9870 {
9871 ivna.vna_next = 0;
9872 ivna.vna_other = 0;
9873 }
9874 else
9875 {
9876 ivna.vna_next = BYTE_GET (evna.vna_next);
9877 ivna.vna_other = BYTE_GET (evna.vna_other);
9878 }
252b5132
RH		 9879
9880 a_off += ivna.vna_next;
9881 }
b34976b6 9882 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9883 && ivna.vna_next != 0);
9884
b34976b6 9885 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9886 {
9887 ivna.vna_name = BYTE_GET (evna.vna_name);
9888
54806181
AM		 9889 if (ivna.vna_name >= string_sec->sh_size)
9890 name = _("*invalid*");
9891 else
9892 name = strtab + ivna.vna_name;
252b5132 9893 nn += printf ("(%s%-*s",
16062207
ILT		 9894 name,
9895 12 - (int) strlen (name),
252b5132 9896 ")");
00d93f34 9897 check_def = 0;
252b5132
RH		 9898 break;
9899 }
9900
9901 offset += ivn.vn_next;
9902 }
9903 while (ivn.vn_next);
9904 }
00d93f34 9905
b34976b6
AM		 9906 if (check_def && data[cnt + j] != 0x8001
9907 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9908 {
b34976b6
AM		 9909 Elf_Internal_Verdef ivd;
9910 Elf_External_Verdef evd;
9911 unsigned long offset;
252b5132 9912
d93f0186
NC		 9913 offset = offset_from_vma
9914 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9915 sizeof evd);
252b5132
RH		 9916
9917 do
9918 {
59245841
NC		 9919 if (get_data (&evd, file, offset, sizeof (evd), 1,
9920 _("version def")) == NULL)
9921 {
9922 ivd.vd_next = 0;
948f632f 9923 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9924 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9925 break;
59245841
NC		 9926 }
9927 else
9928 {
9929 ivd.vd_next = BYTE_GET (evd.vd_next);
9930 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9931 }
252b5132
RH		 9932
9933 offset += ivd.vd_next;
9934 }
c244d050 9935 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9936 && ivd.vd_next != 0);
9937
c244d050 9938 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9939 {
b34976b6
AM		 9940 Elf_External_Verdaux evda;
9941 Elf_Internal_Verdaux ivda;
252b5132
RH		 9942
9943 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9944
59245841
NC		 9945 if (get_data (&evda, file,
9946 offset - ivd.vd_next + ivd.vd_aux,
9947 sizeof (evda), 1,
9948 _("version def aux")) == NULL)
9949 break;
252b5132
RH		 9950
9951 ivda.vda_name = BYTE_GET (evda.vda_name);
9952
54806181
AM		 9953 if (ivda.vda_name >= string_sec->sh_size)
9954 name = _("*invalid*");
9955 else
9956 name = strtab + ivda.vda_name;
252b5132 9957 nn += printf ("(%s%-*s",
16062207
ILT		 9958 name,
9959 12 - (int) strlen (name),
252b5132
RH		 9960 ")");
9961 }
9962 }
9963
9964 if (nn < 18)
9965 printf ("%*c", 18 - nn, ' ');
9966 }
9967
9968 putchar ('\n');
9969 }
9970
9971 free (data);
9972 free (strtab);
9973 free (symbols);
9974 }
9975 break;
103f02d3 9976
252b5132
RH		 9977 default:
9978 break;
9979 }
9980 }
9981
9982 if (! found)
9983 printf (_("\nNo version information found in this file.\n"));
9984
9985 return 1;
9986}
9987
d1133906 9988static const char *
d3ba0551 9989get_symbol_binding (unsigned int binding)
252b5132 9990{
b34976b6 9991 static char buff[32];
252b5132
RH		 9992
9993 switch (binding)
9994 {
b34976b6
AM		 9995 case STB_LOCAL: return "LOCAL";
9996 case STB_GLOBAL: return "GLOBAL";
9997 case STB_WEAK: return "WEAK";
252b5132
RH		 9998 default:
9999 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10000 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10001 binding);
252b5132 10002 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10003 {
10004 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10005 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10006 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10007 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10008 return "UNIQUE";
10009 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10010 }
252b5132 10011 else
e9e44622 10012 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10013 return buff;
10014 }
10015}
10016
d1133906 10017static const char *
d3ba0551 10018get_symbol_type (unsigned int type)
252b5132 10019{
b34976b6 10020 static char buff[32];
252b5132
RH		 10021
10022 switch (type)
10023 {
b34976b6
AM		 10024 case STT_NOTYPE: return "NOTYPE";
10025 case STT_OBJECT: return "OBJECT";
10026 case STT_FUNC: return "FUNC";
10027 case STT_SECTION: return "SECTION";
10028 case STT_FILE: return "FILE";
10029 case STT_COMMON: return "COMMON";
10030 case STT_TLS: return "TLS";
15ab5209
DB		 10031 case STT_RELC: return "RELC";
10032 case STT_SRELC: return "SRELC";
252b5132
RH		 10033 default:
10034 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10035 {
3510a7b8
NC		 10036 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10037 return "THUMB_FUNC";
103f02d3 10038
351b4b40 10039 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10040 return "REGISTER";
10041
10042 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10043 return "PARISC_MILLI";
10044
e9e44622 10045 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10046 }
252b5132 10047 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10048 {
10049 if (elf_header.e_machine == EM_PARISC)
10050 {
10051 if (type == STT_HP_OPAQUE)
10052 return "HP_OPAQUE";
10053 if (type == STT_HP_STUB)
10054 return "HP_STUB";
10055 }
10056
d8045f23 10057 if (type == STT_GNU_IFUNC
9c55345c 10058 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10059 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10060 /* GNU is still using the default value 0. */
d8045f23
NC		 10061 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10062 return "IFUNC";
10063
e9e44622 10064 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10065 }
252b5132 10066 else
e9e44622 10067 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10068 return buff;
10069 }
10070}
10071
d1133906 10072static const char *
d3ba0551 10073get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10074{
10075 switch (visibility)
10076 {
b34976b6
AM		 10077 case STV_DEFAULT: return "DEFAULT";
10078 case STV_INTERNAL: return "INTERNAL";
10079 case STV_HIDDEN: return "HIDDEN";
d1133906 10080 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10081 default:
10082 error (_("Unrecognized visibility value: %u"), visibility);
10083 return _("<unknown>");
d1133906
NC		 10084 }
10085}
10086
5e2b0d47
NC		 10087static const char *
10088get_mips_symbol_other (unsigned int other)
10089{
10090 switch (other)
10091 {
df58fc94
RS		 10092 case STO_OPTIONAL:
10093 return "OPTIONAL";
10094 case STO_MIPS_PLT:
10095 return "MIPS PLT";
10096 case STO_MIPS_PIC:
10097 return "MIPS PIC";
10098 case STO_MICROMIPS:
10099 return "MICROMIPS";
10100 case STO_MICROMIPS | STO_MIPS_PIC:
10101 return "MICROMIPS, MIPS PIC";
10102 case STO_MIPS16:
10103 return "MIPS16";
10104 default:
10105 return NULL;
5e2b0d47
NC		 10106 }
10107}
10108
28f997cf
TG		 10109static const char *
10110get_ia64_symbol_other (unsigned int other)
10111{
10112 if (is_ia64_vms ())
10113 {
10114 static char res[32];
10115
10116 res[0] = 0;
10117
10118 /* Function types is for images and .STB files only. */
10119 switch (elf_header.e_type)
10120 {
10121 case ET_DYN:
10122 case ET_EXEC:
10123 switch (VMS_ST_FUNC_TYPE (other))
10124 {
10125 case VMS_SFT_CODE_ADDR:
10126 strcat (res, " CA");
10127 break;
10128 case VMS_SFT_SYMV_IDX:
10129 strcat (res, " VEC");
10130 break;
10131 case VMS_SFT_FD:
10132 strcat (res, " FD");
10133 break;
10134 case VMS_SFT_RESERVE:
10135 strcat (res, " RSV");
10136 break;
10137 default:
bee0ee85
NC		 10138 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10139 VMS_ST_FUNC_TYPE (other));
10140 strcat (res, " <unknown>");
10141 break;
28f997cf
TG		 10142 }
10143 break;
10144 default:
10145 break;
10146 }
10147 switch (VMS_ST_LINKAGE (other))
10148 {
10149 case VMS_STL_IGNORE:
10150 strcat (res, " IGN");
10151 break;
10152 case VMS_STL_RESERVE:
10153 strcat (res, " RSV");
10154 break;
10155 case VMS_STL_STD:
10156 strcat (res, " STD");
10157 break;
10158 case VMS_STL_LNK:
10159 strcat (res, " LNK");
10160 break;
10161 default:
bee0ee85
NC		 10162 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10163 VMS_ST_LINKAGE (other));
10164 strcat (res, " <unknown>");
10165 break;
28f997cf
TG		 10166 }
10167
10168 if (res[0] != 0)
10169 return res + 1;
10170 else
10171 return res;
10172 }
10173 return NULL;
10174}
10175
6911b7dc
AM		 10176static const char *
10177get_ppc64_symbol_other (unsigned int other)
10178{
10179 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10180 {
10181 static char buf[32];
10182 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10183 PPC64_LOCAL_ENTRY_OFFSET (other));
10184 return buf;
10185 }
10186 return NULL;
10187}
10188
5e2b0d47
NC		 10189static const char *
10190get_symbol_other (unsigned int other)
10191{
10192 const char * result = NULL;
10193 static char buff [32];
10194
10195 if (other == 0)
10196 return "";
10197
10198 switch (elf_header.e_machine)
10199 {
10200 case EM_MIPS:
10201 result = get_mips_symbol_other (other);
28f997cf
TG		 10202 break;
10203 case EM_IA_64:
10204 result = get_ia64_symbol_other (other);
10205 break;
6911b7dc
AM		 10206 case EM_PPC64:
10207 result = get_ppc64_symbol_other (other);
10208 break;
5e2b0d47
NC		 10209 default:
10210 break;
10211 }
10212
10213 if (result)
10214 return result;
10215
10216 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10217 return buff;
10218}
10219
d1133906 10220static const char *
d3ba0551 10221get_symbol_index_type (unsigned int type)
252b5132 10222{
b34976b6 10223 static char buff[32];
5cf1065c 10224
252b5132
RH		 10225 switch (type)
10226 {
b34976b6
AM		 10227 case SHN_UNDEF: return "UND";
10228 case SHN_ABS: return "ABS";
10229 case SHN_COMMON: return "COM";
252b5132 10230 default:
9ce701e2
L		 10231 if (type == SHN_IA_64_ANSI_COMMON
10232 && elf_header.e_machine == EM_IA_64
10233 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10234 return "ANSI_COM";
8a9036a4 10235 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10236 || elf_header.e_machine == EM_L1OM
10237 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10238 && type == SHN_X86_64_LCOMMON)
10239 return "LARGE_COM";
ac145307
BS		 10240 else if ((type == SHN_MIPS_SCOMMON
10241 && elf_header.e_machine == EM_MIPS)
10242 || (type == SHN_TIC6X_SCOMMON
10243 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10244 return "SCOM";
10245 else if (type == SHN_MIPS_SUNDEFINED
10246 && elf_header.e_machine == EM_MIPS)
10247 return "SUND";
9ce701e2 10248 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10249 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10250 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10251 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10252 else if (type >= SHN_LORESERVE)
10253 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10254 else if (type >= elf_header.e_shnum)
e0a31db1 10255 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10256 else
232e7cb8 10257 sprintf (buff, "%3d", type);
5cf1065c 10258 break;
252b5132 10259 }
5cf1065c
NC		 10260
10261 return buff;
252b5132
RH		 10262}
10263
66543521 10264static bfd_vma *
57028622 10265get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10266{
2cf0635d
NC		 10267 unsigned char * e_data;
10268 bfd_vma * i_data;
252b5132 10269
57028622
NC		 10270 /* If the size_t type is smaller than the bfd_size_type, eg because
10271 you are building a 32-bit tool on a 64-bit host, then make sure
10272 that when (number) is cast to (size_t) no information is lost. */
10273 if (sizeof (size_t) < sizeof (bfd_size_type)
10274 && (bfd_size_type) ((size_t) number) != number)
10275 {
10276 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10277 (unsigned long long) number, ent_size);
10278 return NULL;
10279 }
948f632f 10280
3102e897
NC		 10281 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10282 attempting to allocate memory when the read is bound to fail. */
10283 if (ent_size * number > current_file_size)
10284 {
57028622
NC		 10285 error (_("Invalid number of dynamic entries: %llu\n"),
10286 (unsigned long long) number);
3102e897
NC		 10287 return NULL;
10288 }
10289
57028622 10290 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10291 if (e_data == NULL)
10292 {
57028622
NC		 10293 error (_("Out of memory reading %llu dynamic entries\n"),
10294 (unsigned long long) number);
252b5132
RH		 10295 return NULL;
10296 }
10297
57028622 10298 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10299 {
57028622
NC		 10300 error (_("Unable to read in %llu bytes of dynamic data\n"),
10301 (unsigned long long) (number * ent_size));
3102e897 10302 free (e_data);
252b5132
RH		 10303 return NULL;
10304 }
10305
57028622 10306 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10307 if (i_data == NULL)
10308 {
57028622
NC		 10309 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10310 (unsigned long long) number);
252b5132
RH		 10311 free (e_data);
10312 return NULL;
10313 }
10314
10315 while (number--)
66543521 10316 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10317
10318 free (e_data);
10319
10320 return i_data;
10321}
10322
6bd1a22c
L		 10323static void
10324print_dynamic_symbol (bfd_vma si, unsigned long hn)
10325{
2cf0635d 10326 Elf_Internal_Sym * psym;
6bd1a22c
L		 10327 int n;
10328
6bd1a22c
L		 10329 n = print_vma (si, DEC_5);
10330 if (n < 5)
0b4362b0 10331 fputs (&" "[n], stdout);
6bd1a22c 10332 printf (" %3lu: ", hn);
e0a31db1
NC		 10333
10334 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10335 {
3102e897
NC		 10336 printf (_("<No info available for dynamic symbol number %lu>\n"),
10337 (unsigned long) si);
e0a31db1
NC		 10338 return;
10339 }
10340
10341 psym = dynamic_symbols + si;
6bd1a22c
L		 10342 print_vma (psym->st_value, LONG_HEX);
10343 putchar (' ');
10344 print_vma (psym->st_size, DEC_5);
10345
f4be36b3
AM		 10346 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10347 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10348 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10349 /* Check to see if any other bits in the st_other field are set.
10350 Note - displaying this information disrupts the layout of the
10351 table being generated, but for the moment this case is very
10352 rare. */
10353 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10354 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10355 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10356 if (VALID_DYNAMIC_NAME (psym->st_name))
10357 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10358 else
2b692964 10359 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10360 putchar ('\n');
10361}
10362
bb4d2ac2
L		 10363static const char *
10364get_symbol_version_string (FILE *file, int is_dynsym,
10365 const char *strtab,
10366 unsigned long int strtab_size,
10367 unsigned int si, Elf_Internal_Sym *psym,
10368 enum versioned_symbol_info *sym_info,
10369 unsigned short *vna_other)
10370{
10371 const char *version_string = NULL;
10372
10373 if (is_dynsym
10374 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10375 {
10376 unsigned char data[2];
10377 unsigned short vers_data;
10378 unsigned long offset;
10379 int is_nobits;
10380 int check_def;
10381
10382 offset = offset_from_vma
10383 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10384 sizeof data + si * sizeof (vers_data));
10385
10386 if (get_data (&data, file, offset + si * sizeof (vers_data),
10387 sizeof (data), 1, _("version data")) == NULL)
10388 return NULL;
10389
10390 vers_data = byte_get (data, 2);
10391
53774b7e
NC		 10392 is_nobits = (section_headers != NULL
10393 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10394 && section_headers[psym->st_shndx].sh_type
10395 == SHT_NOBITS);
10396
10397 check_def = (psym->st_shndx != SHN_UNDEF);
10398
10399 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10400 {
10401 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10402 && (is_nobits || ! check_def))
10403 {
10404 Elf_External_Verneed evn;
10405 Elf_Internal_Verneed ivn;
10406 Elf_Internal_Vernaux ivna;
10407
10408 /* We must test both. */
10409 offset = offset_from_vma
10410 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10411 sizeof evn);
10412
10413 do
10414 {
10415 unsigned long vna_off;
10416
10417 if (get_data (&evn, file, offset, sizeof (evn), 1,
10418 _("version need")) == NULL)
10419 {
10420 ivna.vna_next = 0;
10421 ivna.vna_other = 0;
10422 ivna.vna_name = 0;
10423 break;
10424 }
10425
10426 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10427 ivn.vn_next = BYTE_GET (evn.vn_next);
10428
10429 vna_off = offset + ivn.vn_aux;
10430
10431 do
10432 {
10433 Elf_External_Vernaux evna;
10434
10435 if (get_data (&evna, file, vna_off,
10436 sizeof (evna), 1,
10437 _("version need aux (3)")) == NULL)
10438 {
10439 ivna.vna_next = 0;
10440 ivna.vna_other = 0;
10441 ivna.vna_name = 0;
10442 }
10443 else
10444 {
10445 ivna.vna_other = BYTE_GET (evna.vna_other);
10446 ivna.vna_next = BYTE_GET (evna.vna_next);
10447 ivna.vna_name = BYTE_GET (evna.vna_name);
10448 }
10449
10450 vna_off += ivna.vna_next;
10451 }
10452 while (ivna.vna_other != vers_data
10453 && ivna.vna_next != 0);
10454
10455 if (ivna.vna_other == vers_data)
10456 break;
10457
10458 offset += ivn.vn_next;
10459 }
10460 while (ivn.vn_next != 0);
10461
10462 if (ivna.vna_other == vers_data)
10463 {
10464 *sym_info = symbol_undefined;
10465 *vna_other = ivna.vna_other;
10466 version_string = (ivna.vna_name < strtab_size
10467 ? strtab + ivna.vna_name
10468 : _("<corrupt>"));
10469 check_def = 0;
10470 }
10471 else if (! is_nobits)
10472 error (_("bad dynamic symbol\n"));
10473 else
10474 check_def = 1;
10475 }
10476
10477 if (check_def)
10478 {
10479 if (vers_data != 0x8001
10480 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10481 {
10482 Elf_Internal_Verdef ivd;
10483 Elf_Internal_Verdaux ivda;
10484 Elf_External_Verdaux evda;
10485 unsigned long off;
10486
10487 off = offset_from_vma
10488 (file,
10489 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10490 sizeof (Elf_External_Verdef));
10491
10492 do
10493 {
10494 Elf_External_Verdef evd;
10495
10496 if (get_data (&evd, file, off, sizeof (evd),
10497 1, _("version def")) == NULL)
10498 {
10499 ivd.vd_ndx = 0;
10500 ivd.vd_aux = 0;
10501 ivd.vd_next = 0;
10502 }
10503 else
10504 {
10505 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10506 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10507 ivd.vd_next = BYTE_GET (evd.vd_next);
10508 }
10509
10510 off += ivd.vd_next;
10511 }
10512 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10513 && ivd.vd_next != 0);
10514
10515 off -= ivd.vd_next;
10516 off += ivd.vd_aux;
10517
10518 if (get_data (&evda, file, off, sizeof (evda),
10519 1, _("version def aux")) == NULL)
10520 return version_string;
10521
10522 ivda.vda_name = BYTE_GET (evda.vda_name);
10523
10524 if (psym->st_name != ivda.vda_name)
10525 {
10526 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10527 ? symbol_hidden : symbol_public);
10528 version_string = (ivda.vda_name < strtab_size
10529 ? strtab + ivda.vda_name
10530 : _("<corrupt>"));
10531 }
10532 }
10533 }
10534 }
10535 }
10536 return version_string;
10537}
10538
e3c8793a 10539/* Dump the symbol table. */
252b5132 10540static int
2cf0635d 10541process_symbol_table (FILE * file)
252b5132 10542{
2cf0635d 10543 Elf_Internal_Shdr * section;
8b73c356
NC		 10544 bfd_size_type nbuckets = 0;
10545 bfd_size_type nchains = 0;
2cf0635d
NC		 10546 bfd_vma * buckets = NULL;
10547 bfd_vma * chains = NULL;
fdc90cb4 10548 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10549 bfd_vma * gnubuckets = NULL;
10550 bfd_vma * gnuchains = NULL;
6bd1a22c 10551 bfd_vma gnusymidx = 0;
071436c6 10552 bfd_size_type ngnuchains = 0;
252b5132 10553
2c610e4b 10554 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10555 return 1;
10556
6bd1a22c
L		 10557 if (dynamic_info[DT_HASH]
10558 && (do_histogram
2c610e4b
L		 10559 || (do_using_dynamic
10560 && !do_dyn_syms
10561 && dynamic_strings != NULL)))
252b5132 10562 {
66543521
AM		 10563 unsigned char nb[8];
10564 unsigned char nc[8];
8b73c356 10565 unsigned int hash_ent_size = 4;
66543521
AM		 10566
10567 if ((elf_header.e_machine == EM_ALPHA
10568 || elf_header.e_machine == EM_S390
10569 || elf_header.e_machine == EM_S390_OLD)
10570 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10571 hash_ent_size = 8;
10572
fb52b2f4
NC		 10573 if (fseek (file,
10574 (archive_file_offset
10575 + offset_from_vma (file, dynamic_info[DT_HASH],
10576 sizeof nb + sizeof nc)),
d93f0186 10577 SEEK_SET))
252b5132 10578 {
591a748a 10579 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10580 goto no_hash;
252b5132
RH		 10581 }
10582
66543521 10583 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10584 {
10585 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10586 goto no_hash;
252b5132
RH		 10587 }
10588
66543521 10589 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10590 {
10591 error (_("Failed to read in number of chains\n"));
d3a44ec6 10592 goto no_hash;
252b5132
RH		 10593 }
10594
66543521
AM		 10595 nbuckets = byte_get (nb, hash_ent_size);
10596 nchains = byte_get (nc, hash_ent_size);
252b5132 10597
66543521
AM		 10598 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10599 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10600
d3a44ec6 10601 no_hash:
252b5132 10602 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10603 {
10604 if (do_using_dynamic)
10605 return 0;
10606 free (buckets);
10607 free (chains);
10608 buckets = NULL;
10609 chains = NULL;
10610 nbuckets = 0;
10611 nchains = 0;
10612 }
252b5132
RH		 10613 }
10614
6bd1a22c
L		 10615 if (dynamic_info_DT_GNU_HASH
10616 && (do_histogram
2c610e4b
L		 10617 || (do_using_dynamic
10618 && !do_dyn_syms
10619 && dynamic_strings != NULL)))
252b5132 10620 {
6bd1a22c
L		 10621 unsigned char nb[16];
10622 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10623 bfd_vma buckets_vma;
10624
10625 if (fseek (file,
10626 (archive_file_offset
10627 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10628 sizeof nb)),
10629 SEEK_SET))
10630 {
10631 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10632 goto no_gnu_hash;
6bd1a22c 10633 }
252b5132 10634
6bd1a22c
L		 10635 if (fread (nb, 16, 1, file) != 1)
10636 {
10637 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10638 goto no_gnu_hash;
6bd1a22c
L		 10639 }
10640
10641 ngnubuckets = byte_get (nb, 4);
10642 gnusymidx = byte_get (nb + 4, 4);
10643 bitmaskwords = byte_get (nb + 8, 4);
10644 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10645 if (is_32bit_elf)
6bd1a22c 10646 buckets_vma += bitmaskwords * 4;
f7a99963 10647 else
6bd1a22c 10648 buckets_vma += bitmaskwords * 8;
252b5132 10649
6bd1a22c
L		 10650 if (fseek (file,
10651 (archive_file_offset
10652 + offset_from_vma (file, buckets_vma, 4)),
10653 SEEK_SET))
252b5132 10654 {
6bd1a22c 10655 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10656 goto no_gnu_hash;
6bd1a22c
L		 10657 }
10658
10659 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10660
6bd1a22c 10661 if (gnubuckets == NULL)
d3a44ec6 10662 goto no_gnu_hash;
6bd1a22c
L		 10663
10664 for (i = 0; i < ngnubuckets; i++)
10665 if (gnubuckets[i] != 0)
10666 {
10667 if (gnubuckets[i] < gnusymidx)
10668 return 0;
10669
10670 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10671 maxchain = gnubuckets[i];
10672 }
10673
10674 if (maxchain == 0xffffffff)
d3a44ec6 10675 goto no_gnu_hash;
6bd1a22c
L		 10676
10677 maxchain -= gnusymidx;
10678
10679 if (fseek (file,
10680 (archive_file_offset
10681 + offset_from_vma (file, buckets_vma
10682 + 4 * (ngnubuckets + maxchain), 4)),
10683 SEEK_SET))
10684 {
10685 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10686 goto no_gnu_hash;
6bd1a22c
L		 10687 }
10688
10689 do
10690 {
10691 if (fread (nb, 4, 1, file) != 1)
252b5132 10692 {
6bd1a22c 10693 error (_("Failed to determine last chain length\n"));
d3a44ec6 10694 goto no_gnu_hash;
6bd1a22c 10695 }
252b5132 10696
6bd1a22c 10697 if (maxchain + 1 == 0)
d3a44ec6 10698 goto no_gnu_hash;
252b5132 10699
6bd1a22c
L		 10700 ++maxchain;
10701 }
10702 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10703
6bd1a22c
L		 10704 if (fseek (file,
10705 (archive_file_offset
10706 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10707 SEEK_SET))
10708 {
10709 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10710 goto no_gnu_hash;
6bd1a22c
L		 10711 }
10712
10713 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10714 ngnuchains = maxchain;
6bd1a22c 10715
d3a44ec6 10716 no_gnu_hash:
6bd1a22c 10717 if (gnuchains == NULL)
d3a44ec6
JJ		 10718 {
10719 free (gnubuckets);
d3a44ec6
JJ		 10720 gnubuckets = NULL;
10721 ngnubuckets = 0;
f64fddf1
NC		 10722 if (do_using_dynamic)
10723 return 0;
d3a44ec6 10724 }
6bd1a22c
L		 10725 }
10726
10727 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10728 && do_syms
10729 && do_using_dynamic
3102e897
NC		 10730 && dynamic_strings != NULL
10731 && dynamic_symbols != NULL)
6bd1a22c
L		 10732 {
10733 unsigned long hn;
10734
10735 if (dynamic_info[DT_HASH])
10736 {
10737 bfd_vma si;
10738
10739 printf (_("\nSymbol table for image:\n"));
10740 if (is_32bit_elf)
10741 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10742 else
10743 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10744
10745 for (hn = 0; hn < nbuckets; hn++)
10746 {
10747 if (! buckets[hn])
10748 continue;
10749
10750 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10751 print_dynamic_symbol (si, hn);
252b5132
RH		 10752 }
10753 }
6bd1a22c
L		 10754
10755 if (dynamic_info_DT_GNU_HASH)
10756 {
10757 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10758 if (is_32bit_elf)
10759 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10760 else
10761 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10762
10763 for (hn = 0; hn < ngnubuckets; ++hn)
10764 if (gnubuckets[hn] != 0)
10765 {
10766 bfd_vma si = gnubuckets[hn];
10767 bfd_vma off = si - gnusymidx;
10768
10769 do
10770 {
10771 print_dynamic_symbol (si, hn);
10772 si++;
10773 }
071436c6 10774 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10775 }
10776 }
252b5132 10777 }
8b73c356
NC		 10778 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10779 && section_headers != NULL)
252b5132 10780 {
b34976b6 10781 unsigned int i;
252b5132
RH		 10782
10783 for (i = 0, section = section_headers;
10784 i < elf_header.e_shnum;
10785 i++, section++)
10786 {
b34976b6 10787 unsigned int si;
2cf0635d 10788 char * strtab = NULL;
c256ffe7 10789 unsigned long int strtab_size = 0;
2cf0635d
NC		 10790 Elf_Internal_Sym * symtab;
10791 Elf_Internal_Sym * psym;
ba5cdace 10792 unsigned long num_syms;
252b5132 10793
2c610e4b
L		 10794 if ((section->sh_type != SHT_SYMTAB
10795 && section->sh_type != SHT_DYNSYM)
10796 || (!do_syms
10797 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10798 continue;
10799
dd24e3da
NC		 10800 if (section->sh_entsize == 0)
10801 {
10802 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10803 printable_section_name (section));
dd24e3da
NC		 10804 continue;
10805 }
10806
252b5132 10807 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10808 printable_section_name (section),
252b5132 10809 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10810
f7a99963 10811 if (is_32bit_elf)
ca47b30c 10812 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10813 else
ca47b30c 10814 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10815
ba5cdace 10816 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10817 if (symtab == NULL)
10818 continue;
10819
10820 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10821 {
10822 strtab = string_table;
10823 strtab_size = string_table_length;
10824 }
4fbb74a6 10825 else if (section->sh_link < elf_header.e_shnum)
252b5132 10826 {
2cf0635d 10827 Elf_Internal_Shdr * string_sec;
252b5132 10828
4fbb74a6 10829 string_sec = section_headers + section->sh_link;
252b5132 10830
3f5e193b
NC		 10831 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10832 1, string_sec->sh_size,
10833 _("string table"));
c256ffe7 10834 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10835 }
10836
ba5cdace 10837 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10838 {
bb4d2ac2
L		 10839 const char *version_string;
10840 enum versioned_symbol_info sym_info;
10841 unsigned short vna_other;
10842
5e220199 10843 printf ("%6d: ", si);
f7a99963
NC		 10844 print_vma (psym->st_value, LONG_HEX);
10845 putchar (' ');
10846 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10847 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10848 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10849 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10850 /* Check to see if any other bits in the st_other field are set.
10851 Note - displaying this information disrupts the layout of the
10852 table being generated, but for the moment this case is very rare. */
10853 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10854 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10855 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10856 print_symbol (25, psym->st_name < strtab_size
2b692964 10857 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10858
bb4d2ac2
L		 10859 version_string
10860 = get_symbol_version_string (file,
10861 section->sh_type == SHT_DYNSYM,
10862 strtab, strtab_size, si,
10863 psym, &sym_info, &vna_other);
10864 if (version_string)
252b5132 10865 {
bb4d2ac2
L		 10866 if (sym_info == symbol_undefined)
10867 printf ("@%s (%d)", version_string, vna_other);
10868 else
10869 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10870 version_string);
252b5132
RH		 10871 }
10872
10873 putchar ('\n');
10874 }
10875
10876 free (symtab);
10877 if (strtab != string_table)
10878 free (strtab);
10879 }
10880 }
10881 else if (do_syms)
10882 printf
10883 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10884
10885 if (do_histogram && buckets != NULL)
10886 {
2cf0635d
NC		 10887 unsigned long * lengths;
10888 unsigned long * counts;
66543521
AM		 10889 unsigned long hn;
10890 bfd_vma si;
10891 unsigned long maxlength = 0;
10892 unsigned long nzero_counts = 0;
10893 unsigned long nsyms = 0;
94d15024 10894 unsigned long chained;
252b5132 10895
66543521
AM		 10896 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10897 (unsigned long) nbuckets);
252b5132 10898
3f5e193b 10899 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10900 if (lengths == NULL)
10901 {
8b73c356 10902 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10903 return 0;
10904 }
8b73c356
NC		 10905
10906 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10907 for (hn = 0; hn < nbuckets; ++hn)
10908 {
94d15024
MF		 10909 for (si = buckets[hn], chained = 0;
10910 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10911 si = chains[si], ++chained)
252b5132 10912 {
b34976b6 10913 ++nsyms;
252b5132 10914 if (maxlength < ++lengths[hn])
b34976b6 10915 ++maxlength;
252b5132 10916 }
94d15024
MF		 10917
10918 /* PR binutils/17531: A corrupt binary could contain broken
10919 histogram data. Do not go into an infinite loop trying
10920 to process it. */
10921 if (chained > nchains)
10922 {
10923 error (_("histogram chain is corrupt\n"));
10924 break;
10925 }
252b5132
RH		 10926 }
10927
3f5e193b 10928 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10929 if (counts == NULL)
10930 {
b2e951ec 10931 free (lengths);
8b73c356 10932 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10933 return 0;
10934 }
10935
10936 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10937 ++counts[lengths[hn]];
252b5132 10938
103f02d3 10939 if (nbuckets > 0)
252b5132 10940 {
66543521
AM		 10941 unsigned long i;
10942 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10943 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10944 for (i = 1; i <= maxlength; ++i)
103f02d3 10945 {
66543521
AM		 10946 nzero_counts += counts[i] * i;
10947 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10948 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10949 (nzero_counts * 100.0) / nsyms);
10950 }
252b5132
RH		 10951 }
10952
10953 free (counts);
10954 free (lengths);
10955 }
10956
10957 if (buckets != NULL)
10958 {
10959 free (buckets);
10960 free (chains);
10961 }
10962
d3a44ec6 10963 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10964 {
2cf0635d
NC		 10965 unsigned long * lengths;
10966 unsigned long * counts;
fdc90cb4
JJ		 10967 unsigned long hn;
10968 unsigned long maxlength = 0;
10969 unsigned long nzero_counts = 0;
10970 unsigned long nsyms = 0;
fdc90cb4 10971
8b73c356
NC		 10972 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10973 (unsigned long) ngnubuckets);
10974
3f5e193b 10975 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10976 if (lengths == NULL)
10977 {
8b73c356 10978 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10979 return 0;
10980 }
10981
fdc90cb4
JJ		 10982 printf (_(" Length Number %% of total Coverage\n"));
10983
10984 for (hn = 0; hn < ngnubuckets; ++hn)
10985 if (gnubuckets[hn] != 0)
10986 {
10987 bfd_vma off, length = 1;
10988
6bd1a22c 10989 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10990 /* PR 17531 file: 010-77222-0.004. */
10991 off < ngnuchains && (gnuchains[off] & 1) == 0;
10992 ++off)
fdc90cb4
JJ		 10993 ++length;
10994 lengths[hn] = length;
10995 if (length > maxlength)
10996 maxlength = length;
10997 nsyms += length;
10998 }
10999
3f5e193b 11000 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11001 if (counts == NULL)
11002 {
b2e951ec 11003 free (lengths);
8b73c356 11004 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11005 return 0;
11006 }
11007
11008 for (hn = 0; hn < ngnubuckets; ++hn)
11009 ++counts[lengths[hn]];
11010
11011 if (ngnubuckets > 0)
11012 {
11013 unsigned long j;
11014 printf (" 0 %-10lu (%5.1f%%)\n",
11015 counts[0], (counts[0] * 100.0) / ngnubuckets);
11016 for (j = 1; j <= maxlength; ++j)
11017 {
11018 nzero_counts += counts[j] * j;
11019 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11020 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11021 (nzero_counts * 100.0) / nsyms);
11022 }
11023 }
11024
11025 free (counts);
11026 free (lengths);
11027 free (gnubuckets);
11028 free (gnuchains);
11029 }
11030
252b5132
RH		 11031 return 1;
11032}
11033
11034static int
2cf0635d 11035process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11036{
b4c96d0d 11037 unsigned int i;
252b5132
RH		 11038
11039 if (dynamic_syminfo == NULL
11040 || !do_dynamic)
11041 /* No syminfo, this is ok. */
11042 return 1;
11043
11044 /* There better should be a dynamic symbol section. */
11045 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11046 return 0;
11047
11048 if (dynamic_addr)
11049 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11050 dynamic_syminfo_offset, dynamic_syminfo_nent);
11051
11052 printf (_(" Num: Name BoundTo Flags\n"));
11053 for (i = 0; i < dynamic_syminfo_nent; ++i)
11054 {
11055 unsigned short int flags = dynamic_syminfo[i].si_flags;
11056
31104126 11057 printf ("%4d: ", i);
4082ef84
NC		 11058 if (i >= num_dynamic_syms)
11059 printf (_("<corrupt index>"));
11060 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11061 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11062 else
2b692964 11063 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11064 putchar (' ');
252b5132
RH		 11065
11066 switch (dynamic_syminfo[i].si_boundto)
11067 {
11068 case SYMINFO_BT_SELF:
11069 fputs ("SELF ", stdout);
11070 break;
11071 case SYMINFO_BT_PARENT:
11072 fputs ("PARENT ", stdout);
11073 break;
11074 default:
11075 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11076 && dynamic_syminfo[i].si_boundto < dynamic_nent
11077 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11078 {
d79b3d50 11079 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11080 putchar (' ' );
11081 }
252b5132
RH		 11082 else
11083 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11084 break;
11085 }
11086
11087 if (flags & SYMINFO_FLG_DIRECT)
11088 printf (" DIRECT");
11089 if (flags & SYMINFO_FLG_PASSTHRU)
11090 printf (" PASSTHRU");
11091 if (flags & SYMINFO_FLG_COPY)
11092 printf (" COPY");
11093 if (flags & SYMINFO_FLG_LAZYLOAD)
11094 printf (" LAZYLOAD");
11095
11096 puts ("");
11097 }
11098
11099 return 1;
11100}
11101
cf13d699
NC		 11102/* Check to see if the given reloc needs to be handled in a target specific
11103 manner. If so then process the reloc and return TRUE otherwise return
11104 FALSE. */
09c11c86 11105
cf13d699
NC		 11106static bfd_boolean
11107target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11108 unsigned char * start,
11109 Elf_Internal_Sym * symtab)
252b5132 11110{
cf13d699 11111 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11112
cf13d699 11113 switch (elf_header.e_machine)
252b5132 11114 {
13761a11
NC		 11115 case EM_MSP430:
11116 case EM_MSP430_OLD:
11117 {
11118 static Elf_Internal_Sym * saved_sym = NULL;
11119
11120 switch (reloc_type)
11121 {
11122 case 10: /* R_MSP430_SYM_DIFF */
11123 if (uses_msp430x_relocs ())
11124 break;
11125 case 21: /* R_MSP430X_SYM_DIFF */
11126 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11127 return TRUE;
11128
11129 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11130 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11131 goto handle_sym_diff;
0b4362b0 11132
13761a11
NC		 11133 case 5: /* R_MSP430_16_BYTE */
11134 case 9: /* R_MSP430_8 */
11135 if (uses_msp430x_relocs ())
11136 break;
11137 goto handle_sym_diff;
11138
11139 case 2: /* R_MSP430_ABS16 */
11140 case 15: /* R_MSP430X_ABS16 */
11141 if (! uses_msp430x_relocs ())
11142 break;
11143 goto handle_sym_diff;
0b4362b0 11144
13761a11
NC		 11145 handle_sym_diff:
11146 if (saved_sym != NULL)
11147 {
11148 bfd_vma value;
11149
11150 value = reloc->r_addend
11151 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11152 - saved_sym->st_value);
11153
11154 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11155
11156 saved_sym = NULL;
11157 return TRUE;
11158 }
11159 break;
11160
11161 default:
11162 if (saved_sym != NULL)
071436c6 11163 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11164 break;
11165 }
11166 break;
11167 }
11168
cf13d699
NC		 11169 case EM_MN10300:
11170 case EM_CYGNUS_MN10300:
11171 {
11172 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11173
cf13d699
NC		 11174 switch (reloc_type)
11175 {
11176 case 34: /* R_MN10300_ALIGN */
11177 return TRUE;
11178 case 33: /* R_MN10300_SYM_DIFF */
11179 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11180 return TRUE;
11181 case 1: /* R_MN10300_32 */
11182 case 2: /* R_MN10300_16 */
11183 if (saved_sym != NULL)
11184 {
11185 bfd_vma value;
252b5132 11186
cf13d699
NC		 11187 value = reloc->r_addend
11188 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11189 - saved_sym->st_value);
252b5132 11190
cf13d699 11191 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11192
cf13d699
NC		 11193 saved_sym = NULL;
11194 return TRUE;
11195 }
11196 break;
11197 default:
11198 if (saved_sym != NULL)
071436c6 11199 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11200 break;
11201 }
11202 break;
11203 }
6ff71e76
NC		 11204
11205 case EM_RL78:
11206 {
11207 static bfd_vma saved_sym1 = 0;
11208 static bfd_vma saved_sym2 = 0;
11209 static bfd_vma value;
11210
11211 switch (reloc_type)
11212 {
11213 case 0x80: /* R_RL78_SYM. */
11214 saved_sym1 = saved_sym2;
11215 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11216 saved_sym2 += reloc->r_addend;
11217 return TRUE;
11218
11219 case 0x83: /* R_RL78_OPsub. */
11220 value = saved_sym1 - saved_sym2;
11221 saved_sym2 = saved_sym1 = 0;
11222 return TRUE;
11223 break;
11224
11225 case 0x41: /* R_RL78_ABS32. */
11226 byte_put (start + reloc->r_offset, value, 4);
11227 value = 0;
11228 return TRUE;
11229
11230 case 0x43: /* R_RL78_ABS16. */
11231 byte_put (start + reloc->r_offset, value, 2);
11232 value = 0;
11233 return TRUE;
11234
11235 default:
11236 break;
11237 }
11238 break;
11239 }
252b5132
RH		 11240 }
11241
cf13d699 11242 return FALSE;
252b5132
RH		 11243}
11244
aca88567
NC		 11245/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11246 DWARF debug sections. This is a target specific test. Note - we do not
11247 go through the whole including-target-headers-multiple-times route, (as
11248 we have already done with <elf/h8.h>) because this would become very
11249 messy and even then this function would have to contain target specific
11250 information (the names of the relocs instead of their numeric values).
11251 FIXME: This is not the correct way to solve this problem. The proper way
11252 is to have target specific reloc sizing and typing functions created by
11253 the reloc-macros.h header, in the same way that it already creates the
11254 reloc naming functions. */
11255
11256static bfd_boolean
11257is_32bit_abs_reloc (unsigned int reloc_type)
11258{
11259 switch (elf_header.e_machine)
11260 {
41e92641 11261 case EM_386:
22abe556 11262 case EM_IAMCU:
41e92641 11263 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11264 case EM_68K:
11265 return reloc_type == 1; /* R_68K_32. */
11266 case EM_860:
11267 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11268 case EM_960:
11269 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11270 case EM_AARCH64:
11271 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11272 case EM_ALPHA:
137b6b5f 11273 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11274 case EM_ARC:
11275 return reloc_type == 1; /* R_ARC_32. */
11276 case EM_ARM:
11277 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11278 case EM_AVR_OLD:
aca88567
NC		 11279 case EM_AVR:
11280 return reloc_type == 1;
cfb8c092
NC		 11281 case EM_ADAPTEVA_EPIPHANY:
11282 return reloc_type == 3;
aca88567
NC		 11283 case EM_BLACKFIN:
11284 return reloc_type == 0x12; /* R_byte4_data. */
11285 case EM_CRIS:
11286 return reloc_type == 3; /* R_CRIS_32. */
11287 case EM_CR16:
11288 return reloc_type == 3; /* R_CR16_NUM32. */
11289 case EM_CRX:
11290 return reloc_type == 15; /* R_CRX_NUM32. */
11291 case EM_CYGNUS_FRV:
11292 return reloc_type == 1;
41e92641
NC		 11293 case EM_CYGNUS_D10V:
11294 case EM_D10V:
11295 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11296 case EM_CYGNUS_D30V:
11297 case EM_D30V:
11298 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11299 case EM_DLX:
11300 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11301 case EM_CYGNUS_FR30:
11302 case EM_FR30:
11303 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11304 case EM_FT32:
11305 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11306 case EM_H8S:
11307 case EM_H8_300:
11308 case EM_H8_300H:
11309 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11310 case EM_IA_64:
d1c4b12b
NC		 11311 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11312 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11313 case EM_IP2K_OLD:
11314 case EM_IP2K:
11315 return reloc_type == 2; /* R_IP2K_32. */
11316 case EM_IQ2000:
11317 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11318 case EM_LATTICEMICO32:
11319 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11320 case EM_M32C_OLD:
aca88567
NC		 11321 case EM_M32C:
11322 return reloc_type == 3; /* R_M32C_32. */
11323 case EM_M32R:
11324 return reloc_type == 34; /* R_M32R_32_RELA. */
11325 case EM_MCORE:
11326 return reloc_type == 1; /* R_MCORE_ADDR32. */
11327 case EM_CYGNUS_MEP:
11328 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11329 case EM_METAG:
11330 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11331 case EM_MICROBLAZE:
11332 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11333 case EM_MIPS:
11334 return reloc_type == 2; /* R_MIPS_32. */
11335 case EM_MMIX:
11336 return reloc_type == 4; /* R_MMIX_32. */
11337 case EM_CYGNUS_MN10200:
11338 case EM_MN10200:
11339 return reloc_type == 1; /* R_MN10200_32. */
11340 case EM_CYGNUS_MN10300:
11341 case EM_MN10300:
11342 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11343 case EM_MOXIE:
11344 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11345 case EM_MSP430_OLD:
11346 case EM_MSP430:
13761a11 11347 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11348 case EM_MT:
11349 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11350 case EM_NDS32:
11351 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11352 case EM_ALTERA_NIOS2:
36591ba1 11353 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11354 case EM_NIOS32:
11355 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11356 case EM_OR1K:
11357 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11358 case EM_PARISC:
5fda8eca
NC		 11359 return (reloc_type == 1 /* R_PARISC_DIR32. */
11360 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11361 case EM_PJ:
11362 case EM_PJ_OLD:
11363 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11364 case EM_PPC64:
11365 return reloc_type == 1; /* R_PPC64_ADDR32. */
11366 case EM_PPC:
11367 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11368 case EM_RL78:
11369 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11370 case EM_RX:
11371 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11372 case EM_S370:
11373 return reloc_type == 1; /* R_I370_ADDR31. */
11374 case EM_S390_OLD:
11375 case EM_S390:
11376 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11377 case EM_SCORE:
11378 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11379 case EM_SH:
11380 return reloc_type == 1; /* R_SH_DIR32. */
11381 case EM_SPARC32PLUS:
11382 case EM_SPARCV9:
11383 case EM_SPARC:
11384 return reloc_type == 3 /* R_SPARC_32. */
11385 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11386 case EM_SPU:
11387 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11388 case EM_TI_C6000:
11389 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11390 case EM_TILEGX:
11391 return reloc_type == 2; /* R_TILEGX_32. */
11392 case EM_TILEPRO:
11393 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11394 case EM_CYGNUS_V850:
11395 case EM_V850:
11396 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11397 case EM_V800:
11398 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11399 case EM_VAX:
11400 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11401 case EM_VISIUM:
11402 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11403 case EM_X86_64:
8a9036a4 11404 case EM_L1OM:
7a9068fe 11405 case EM_K1OM:
aca88567 11406 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11407 case EM_XC16X:
11408 case EM_C166:
11409 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11410 case EM_XGATE:
11411 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11412 case EM_XSTORMY16:
11413 return reloc_type == 1; /* R_XSTROMY16_32. */
11414 case EM_XTENSA_OLD:
11415 case EM_XTENSA:
11416 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11417 default:
bee0ee85
NC		 11418 {
11419 static unsigned int prev_warn = 0;
11420
11421 /* Avoid repeating the same warning multiple times. */
11422 if (prev_warn != elf_header.e_machine)
11423 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11424 elf_header.e_machine);
11425 prev_warn = elf_header.e_machine;
11426 return FALSE;
11427 }
aca88567
NC		 11428 }
11429}
11430
11431/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11432 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11433
11434static bfd_boolean
11435is_32bit_pcrel_reloc (unsigned int reloc_type)
11436{
11437 switch (elf_header.e_machine)
11438 {
41e92641 11439 case EM_386:
22abe556 11440 case EM_IAMCU:
3e0873ac 11441 return reloc_type == 2; /* R_386_PC32. */
aca88567 11442 case EM_68K:
3e0873ac 11443 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11444 case EM_AARCH64:
11445 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11446 case EM_ADAPTEVA_EPIPHANY:
11447 return reloc_type == 6;
aca88567
NC		 11448 case EM_ALPHA:
11449 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11450 case EM_ARM:
3e0873ac 11451 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11452 case EM_MICROBLAZE:
11453 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11454 case EM_OR1K:
11455 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11456 case EM_PARISC:
85acf597 11457 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11458 case EM_PPC:
11459 return reloc_type == 26; /* R_PPC_REL32. */
11460 case EM_PPC64:
3e0873ac 11461 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11462 case EM_S390_OLD:
11463 case EM_S390:
3e0873ac 11464 return reloc_type == 5; /* R_390_PC32. */
aca88567 11465 case EM_SH:
3e0873ac 11466 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11467 case EM_SPARC32PLUS:
11468 case EM_SPARCV9:
11469 case EM_SPARC:
3e0873ac 11470 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11471 case EM_SPU:
11472 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11473 case EM_TILEGX:
11474 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11475 case EM_TILEPRO:
11476 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11477 case EM_VISIUM:
11478 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11479 case EM_X86_64:
8a9036a4 11480 case EM_L1OM:
7a9068fe 11481 case EM_K1OM:
3e0873ac 11482 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11483 case EM_XTENSA_OLD:
11484 case EM_XTENSA:
11485 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11486 default:
11487 /* Do not abort or issue an error message here. Not all targets use
11488 pc-relative 32-bit relocs in their DWARF debug information and we
11489 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11490 more helpful warning message will be generated by apply_relocations
11491 anyway, so just return. */
aca88567
NC		 11492 return FALSE;
11493 }
11494}
11495
11496/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11497 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11498
11499static bfd_boolean
11500is_64bit_abs_reloc (unsigned int reloc_type)
11501{
11502 switch (elf_header.e_machine)
11503 {
a06ea964
NC		 11504 case EM_AARCH64:
11505 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11506 case EM_ALPHA:
11507 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11508 case EM_IA_64:
11509 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11510 case EM_PARISC:
11511 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11512 case EM_PPC64:
11513 return reloc_type == 38; /* R_PPC64_ADDR64. */
11514 case EM_SPARC32PLUS:
11515 case EM_SPARCV9:
11516 case EM_SPARC:
11517 return reloc_type == 54; /* R_SPARC_UA64. */
11518 case EM_X86_64:
8a9036a4 11519 case EM_L1OM:
7a9068fe 11520 case EM_K1OM:
aca88567 11521 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11522 case EM_S390_OLD:
11523 case EM_S390:
aa137e4d
NC		 11524 return reloc_type == 22; /* R_S390_64. */
11525 case EM_TILEGX:
11526 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11527 case EM_MIPS:
aa137e4d 11528 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11529 default:
11530 return FALSE;
11531 }
11532}
11533
85acf597
RH		 11534/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11535 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11536
11537static bfd_boolean
11538is_64bit_pcrel_reloc (unsigned int reloc_type)
11539{
11540 switch (elf_header.e_machine)
11541 {
a06ea964
NC		 11542 case EM_AARCH64:
11543 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11544 case EM_ALPHA:
aa137e4d 11545 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11546 case EM_IA_64:
aa137e4d 11547 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11548 case EM_PARISC:
aa137e4d 11549 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11550 case EM_PPC64:
aa137e4d 11551 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11552 case EM_SPARC32PLUS:
11553 case EM_SPARCV9:
11554 case EM_SPARC:
aa137e4d 11555 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11556 case EM_X86_64:
8a9036a4 11557 case EM_L1OM:
7a9068fe 11558 case EM_K1OM:
aa137e4d 11559 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11560 case EM_S390_OLD:
11561 case EM_S390:
aa137e4d
NC		 11562 return reloc_type == 23; /* R_S390_PC64. */
11563 case EM_TILEGX:
11564 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11565 default:
11566 return FALSE;
11567 }
11568}
11569
4dc3c23d
AM		 11570/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11571 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11572
11573static bfd_boolean
11574is_24bit_abs_reloc (unsigned int reloc_type)
11575{
11576 switch (elf_header.e_machine)
11577 {
11578 case EM_CYGNUS_MN10200:
11579 case EM_MN10200:
11580 return reloc_type == 4; /* R_MN10200_24. */
11581 default:
11582 return FALSE;
11583 }
11584}
11585
aca88567
NC		 11586/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11587 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11588
11589static bfd_boolean
11590is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11591{
11592 switch (elf_header.e_machine)
11593 {
aca88567
NC		 11594 case EM_AVR_OLD:
11595 case EM_AVR:
11596 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11597 case EM_ADAPTEVA_EPIPHANY:
11598 return reloc_type == 5;
41e92641
NC		 11599 case EM_CYGNUS_D10V:
11600 case EM_D10V:
11601 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11602 case EM_H8S:
11603 case EM_H8_300:
11604 case EM_H8_300H:
aca88567
NC		 11605 return reloc_type == R_H8_DIR16;
11606 case EM_IP2K_OLD:
11607 case EM_IP2K:
11608 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11609 case EM_M32C_OLD:
f4236fe4
DD		 11610 case EM_M32C:
11611 return reloc_type == 1; /* R_M32C_16 */
aca88567 11612 case EM_MSP430:
13761a11
NC		 11613 if (uses_msp430x_relocs ())
11614 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11615 case EM_MSP430_OLD:
aca88567 11616 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11617 case EM_NDS32:
11618 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11619 case EM_ALTERA_NIOS2:
36591ba1 11620 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11621 case EM_NIOS32:
11622 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11623 case EM_OR1K:
11624 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11625 case EM_TI_C6000:
11626 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11627 case EM_XC16X:
11628 case EM_C166:
11629 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11630 case EM_CYGNUS_MN10200:
11631 case EM_MN10200:
11632 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11633 case EM_CYGNUS_MN10300:
11634 case EM_MN10300:
11635 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11636 case EM_VISIUM:
11637 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11638 case EM_XGATE:
11639 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11640 default:
aca88567 11641 return FALSE;
4b78141a
NC		 11642 }
11643}
11644
2a7b2e88
JK		 11645/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11646 relocation entries (possibly formerly used for SHT_GROUP sections). */
11647
11648static bfd_boolean
11649is_none_reloc (unsigned int reloc_type)
11650{
11651 switch (elf_header.e_machine)
11652 {
cb8f3167
NC		 11653 case EM_68K: /* R_68K_NONE. */
11654 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11655 case EM_SPARC32PLUS:
11656 case EM_SPARCV9:
cb8f3167
NC		 11657 case EM_SPARC: /* R_SPARC_NONE. */
11658 case EM_MIPS: /* R_MIPS_NONE. */
11659 case EM_PARISC: /* R_PARISC_NONE. */
11660 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11661 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11662 case EM_PPC: /* R_PPC_NONE. */
11663 case EM_PPC64: /* R_PPC64_NONE. */
11664 case EM_ARM: /* R_ARM_NONE. */
11665 case EM_IA_64: /* R_IA64_NONE. */
11666 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11667 case EM_S390_OLD:
cb8f3167
NC		 11668 case EM_S390: /* R_390_NONE. */
11669 case EM_CRIS: /* R_CRIS_NONE. */
11670 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11671 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11672 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11673 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11674 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11675 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11676 case EM_M32R: /* R_M32R_NONE. */
40b36596 11677 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11678 case EM_TILEGX: /* R_TILEGX_NONE. */
11679 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11680 case EM_XC16X:
11681 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11682 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11683 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11684 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11685 return reloc_type == 0;
a06ea964
NC		 11686 case EM_AARCH64:
11687 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11688 case EM_NDS32:
11689 return (reloc_type == 0 /* R_XTENSA_NONE. */
11690 || reloc_type == 204 /* R_NDS32_DIFF8. */
11691 || reloc_type == 205 /* R_NDS32_DIFF16. */
11692 || reloc_type == 206 /* R_NDS32_DIFF32. */
11693 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11694 case EM_XTENSA_OLD:
11695 case EM_XTENSA:
4dc3c23d
AM		 11696 return (reloc_type == 0 /* R_XTENSA_NONE. */
11697 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11698 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11699 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11700 case EM_METAG:
11701 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11702 }
11703 return FALSE;
11704}
11705
d1c4b12b
NC		 11706/* Returns TRUE if there is a relocation against
11707 section NAME at OFFSET bytes. */
11708
11709bfd_boolean
11710reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11711{
11712 Elf_Internal_Rela * relocs;
11713 Elf_Internal_Rela * rp;
11714
11715 if (dsec == NULL || dsec->reloc_info == NULL)
11716 return FALSE;
11717
11718 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11719
11720 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11721 if (rp->r_offset == offset)
11722 return TRUE;
11723
11724 return FALSE;
11725}
11726
cf13d699
NC		 11727/* Apply relocations to a section.
11728 Note: So far support has been added only for those relocations
11729 which can be found in debug sections.
d1c4b12b
NC		 11730 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11731 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11732 FIXME: Add support for more relocations ? */
1b315056 11733
cf13d699 11734static void
d1c4b12b
NC		 11735apply_relocations (void * file,
11736 const Elf_Internal_Shdr * section,
11737 unsigned char * start,
11738 bfd_size_type size,
11739 void ** relocs_return,
11740 unsigned long * num_relocs_return)
1b315056 11741{
cf13d699 11742 Elf_Internal_Shdr * relsec;
0d2a7a93 11743 unsigned char * end = start + size;
cb8f3167 11744
d1c4b12b
NC		 11745 if (relocs_return != NULL)
11746 {
11747 * (Elf_Internal_Rela **) relocs_return = NULL;
11748 * num_relocs_return = 0;
11749 }
11750
cf13d699
NC		 11751 if (elf_header.e_type != ET_REL)
11752 return;
1b315056 11753
cf13d699 11754 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11755 for (relsec = section_headers;
11756 relsec < section_headers + elf_header.e_shnum;
11757 ++relsec)
252b5132 11758 {
41e92641
NC		 11759 bfd_boolean is_rela;
11760 unsigned long num_relocs;
2cf0635d
NC		 11761 Elf_Internal_Rela * relocs;
11762 Elf_Internal_Rela * rp;
11763 Elf_Internal_Shdr * symsec;
11764 Elf_Internal_Sym * symtab;
ba5cdace 11765 unsigned long num_syms;
2cf0635d 11766 Elf_Internal_Sym * sym;
252b5132 11767
41e92641 11768 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11769 || relsec->sh_info >= elf_header.e_shnum
11770 || section_headers + relsec->sh_info != section
c256ffe7 11771 || relsec->sh_size == 0
4fbb74a6 11772 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11773 continue;
428409d5 11774
41e92641
NC		 11775 is_rela = relsec->sh_type == SHT_RELA;
11776
11777 if (is_rela)
11778 {
3f5e193b
NC		 11779 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11780 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11781 return;
11782 }
11783 else
11784 {
3f5e193b
NC		 11785 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11786 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11787 return;
11788 }
11789
11790 /* SH uses RELA but uses in place value instead of the addend field. */
11791 if (elf_header.e_machine == EM_SH)
11792 is_rela = FALSE;
428409d5 11793
4fbb74a6 11794 symsec = section_headers + relsec->sh_link;
ba5cdace 11795 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11796
41e92641 11797 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11798 {
41e92641
NC		 11799 bfd_vma addend;
11800 unsigned int reloc_type;
11801 unsigned int reloc_size;
91d6fa6a 11802 unsigned char * rloc;
ba5cdace 11803 unsigned long sym_index;
4b78141a 11804
aca88567 11805 reloc_type = get_reloc_type (rp->r_info);
41e92641 11806
98fb390a 11807 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11808 continue;
98fb390a
NC		 11809 else if (is_none_reloc (reloc_type))
11810 continue;
11811 else if (is_32bit_abs_reloc (reloc_type)
11812 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11813 reloc_size = 4;
85acf597
RH		 11814 else if (is_64bit_abs_reloc (reloc_type)
11815 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11816 reloc_size = 8;
4dc3c23d
AM		 11817 else if (is_24bit_abs_reloc (reloc_type))
11818 reloc_size = 3;
aca88567
NC		 11819 else if (is_16bit_abs_reloc (reloc_type))
11820 reloc_size = 2;
11821 else
4b78141a 11822 {
bee0ee85
NC		 11823 static unsigned int prev_reloc = 0;
11824 if (reloc_type != prev_reloc)
11825 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11826 reloc_type, printable_section_name (section));
11827 prev_reloc = reloc_type;
4b78141a
NC		 11828 continue;
11829 }
103f02d3 11830
91d6fa6a 11831 rloc = start + rp->r_offset;
c8da6823 11832 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11833 {
11834 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11835 (unsigned long) rp->r_offset,
74e1a04b 11836 printable_section_name (section));
700dd8b7
L		 11837 continue;
11838 }
103f02d3 11839
ba5cdace
NC		 11840 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11841 if (sym_index >= num_syms)
11842 {
11843 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11844 sym_index, printable_section_name (section));
ba5cdace
NC		 11845 continue;
11846 }
11847 sym = symtab + sym_index;
41e92641
NC		 11848
11849 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11850 make sure that it is of an appropriate type.
11851
11852 Relocations against symbols without type can happen.
11853 Gcc -feliminate-dwarf2-dups may generate symbols
11854 without type for debug info.
11855
11856 Icc generates relocations against function symbols
11857 instead of local labels.
11858
11859 Relocations against object symbols can happen, eg when
11860 referencing a global array. For an example of this see
11861 the _clz.o binary in libgcc.a. */
aca88567 11862 if (sym != symtab
55f25fc3 11863 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11864 {
41e92641 11865 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11866 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11867 (long int)(rp - relocs),
74e1a04b 11868 printable_section_name (relsec));
aca88567 11869 continue;
5b18a4bc 11870 }
252b5132 11871
4dc3c23d
AM		 11872 addend = 0;
11873 if (is_rela)
11874 addend += rp->r_addend;
c47320c3
AM		 11875 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11876 partial_inplace. */
4dc3c23d
AM		 11877 if (!is_rela
11878 || (elf_header.e_machine == EM_XTENSA
11879 && reloc_type == 1)
11880 || ((elf_header.e_machine == EM_PJ
11881 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11882 && reloc_type == 1)
11883 || ((elf_header.e_machine == EM_D30V
11884 || elf_header.e_machine == EM_CYGNUS_D30V)
11885 && reloc_type == 12))
91d6fa6a 11886 addend += byte_get (rloc, reloc_size);
cb8f3167 11887
85acf597
RH		 11888 if (is_32bit_pcrel_reloc (reloc_type)
11889 || is_64bit_pcrel_reloc (reloc_type))
11890 {
11891 /* On HPPA, all pc-relative relocations are biased by 8. */
11892 if (elf_header.e_machine == EM_PARISC)
11893 addend -= 8;
91d6fa6a 11894 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11895 reloc_size);
11896 }
41e92641 11897 else
91d6fa6a 11898 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11899 }
252b5132 11900
5b18a4bc 11901 free (symtab);
d1c4b12b
NC		 11902
11903 if (relocs_return)
11904 {
11905 * (Elf_Internal_Rela **) relocs_return = relocs;
11906 * num_relocs_return = num_relocs;
11907 }
11908 else
11909 free (relocs);
11910
5b18a4bc
NC		 11911 break;
11912 }
5b18a4bc 11913}
103f02d3 11914
cf13d699
NC		 11915#ifdef SUPPORT_DISASSEMBLY
11916static int
11917disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11918{
74e1a04b 11919 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11920
74e1a04b 11921 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11922
11923 return 1;
11924}
11925#endif
11926
11927/* Reads in the contents of SECTION from FILE, returning a pointer
11928 to a malloc'ed buffer or NULL if something went wrong. */
11929
11930static char *
11931get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11932{
11933 bfd_size_type num_bytes;
11934
11935 num_bytes = section->sh_size;
11936
11937 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11938 {
11939 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11940 printable_section_name (section));
cf13d699
NC		 11941 return NULL;
11942 }
11943
3f5e193b
NC		 11944 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11945 _("section contents"));
cf13d699
NC		 11946}
11947
0e602686
NC		 11948/* Uncompresses a section that was compressed using zlib, in place. */
11949
11950static bfd_boolean
11951uncompress_section_contents (unsigned char **buffer,
11952 dwarf_size_type uncompressed_size,
11953 dwarf_size_type *size)
11954{
11955 dwarf_size_type compressed_size = *size;
11956 unsigned char * compressed_buffer = *buffer;
11957 unsigned char * uncompressed_buffer;
11958 z_stream strm;
11959 int rc;
11960
11961 /* It is possible the section consists of several compressed
11962 buffers concatenated together, so we uncompress in a loop. */
11963 /* PR 18313: The state field in the z_stream structure is supposed
11964 to be invisible to the user (ie us), but some compilers will
11965 still complain about it being used without initialisation. So
11966 we first zero the entire z_stream structure and then set the fields
11967 that we need. */
11968 memset (& strm, 0, sizeof strm);
11969 strm.avail_in = compressed_size;
11970 strm.next_in = (Bytef *) compressed_buffer;
11971 strm.avail_out = uncompressed_size;
11972 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11973
11974 rc = inflateInit (& strm);
11975 while (strm.avail_in > 0)
11976 {
11977 if (rc != Z_OK)
11978 goto fail;
11979 strm.next_out = ((Bytef *) uncompressed_buffer
11980 + (uncompressed_size - strm.avail_out));
11981 rc = inflate (&strm, Z_FINISH);
11982 if (rc != Z_STREAM_END)
11983 goto fail;
11984 rc = inflateReset (& strm);
11985 }
11986 rc = inflateEnd (& strm);
11987 if (rc != Z_OK
11988 || strm.avail_out != 0)
11989 goto fail;
11990
11991 *buffer = uncompressed_buffer;
11992 *size = uncompressed_size;
11993 return TRUE;
11994
11995 fail:
11996 free (uncompressed_buffer);
11997 /* Indicate decompression failure. */
11998 *buffer = NULL;
11999 return FALSE;
12000}
dd24e3da 12001
cf13d699
NC		 12002static void
12003dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12004{
0e602686
NC		 12005 Elf_Internal_Shdr * relsec;
12006 bfd_size_type num_bytes;
fd8008d8
L		 12007 unsigned char * data;
12008 unsigned char * end;
12009 unsigned char * real_start;
12010 unsigned char * start;
0e602686 12011 bfd_boolean some_strings_shown;
cf13d699 12012
fd8008d8
L		 12013 real_start = start = (unsigned char *) get_section_contents (section,
12014 file);
cf13d699
NC		 12015 if (start == NULL)
12016 return;
0e602686 12017 num_bytes = section->sh_size;
cf13d699 12018
74e1a04b 12019 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12020
0e602686
NC		 12021 if (decompress_dumps)
12022 {
12023 dwarf_size_type new_size = num_bytes;
12024 dwarf_size_type uncompressed_size = 0;
12025
12026 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12027 {
12028 Elf_Internal_Chdr chdr;
12029 unsigned int compression_header_size
12030 = get_compression_header (& chdr, (unsigned char *) start);
12031
12032 if (chdr.ch_type == ELFCOMPRESS_ZLIB
12033 && chdr.ch_addralign == section->sh_addralign)
12034 {
12035 uncompressed_size = chdr.ch_size;
12036 start += compression_header_size;
12037 new_size -= compression_header_size;
12038 }
12039 }
12040 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12041 {
12042 /* Read the zlib header. In this case, it should be "ZLIB"
12043 followed by the uncompressed section size, 8 bytes in
12044 big-endian order. */
12045 uncompressed_size = start[4]; uncompressed_size <<= 8;
12046 uncompressed_size += start[5]; uncompressed_size <<= 8;
12047 uncompressed_size += start[6]; uncompressed_size <<= 8;
12048 uncompressed_size += start[7]; uncompressed_size <<= 8;
12049 uncompressed_size += start[8]; uncompressed_size <<= 8;
12050 uncompressed_size += start[9]; uncompressed_size <<= 8;
12051 uncompressed_size += start[10]; uncompressed_size <<= 8;
12052 uncompressed_size += start[11];
12053 start += 12;
12054 new_size -= 12;
12055 }
12056
12057 if (uncompressed_size
fd8008d8 12058 && uncompress_section_contents (& start,
0e602686
NC		 12059 uncompressed_size, & new_size))
12060 num_bytes = new_size;
12061 }
fd8008d8 12062
cf13d699
NC		 12063 /* If the section being dumped has relocations against it the user might
12064 be expecting these relocations to have been applied. Check for this
12065 case and issue a warning message in order to avoid confusion.
12066 FIXME: Maybe we ought to have an option that dumps a section with
12067 relocs applied ? */
12068 for (relsec = section_headers;
12069 relsec < section_headers + elf_header.e_shnum;
12070 ++relsec)
12071 {
12072 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12073 || relsec->sh_info >= elf_header.e_shnum
12074 || section_headers + relsec->sh_info != section
12075 || relsec->sh_size == 0
12076 || relsec->sh_link >= elf_header.e_shnum)
12077 continue;
12078
12079 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12080 break;
12081 }
12082
cf13d699
NC		 12083 data = start;
12084 end = start + num_bytes;
12085 some_strings_shown = FALSE;
12086
12087 while (data < end)
12088 {
12089 while (!ISPRINT (* data))
12090 if (++ data >= end)
12091 break;
12092
12093 if (data < end)
12094 {
071436c6
NC		 12095 size_t maxlen = end - data;
12096
cf13d699 12097#ifndef __MSVCRT__
c975cc98
NC		 12098 /* PR 11128: Use two separate invocations in order to work
12099 around bugs in the Solaris 8 implementation of printf. */
12100 printf (" [%6tx] ", data - start);
cf13d699 12101#else
071436c6 12102 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12103#endif
4082ef84
NC		 12104 if (maxlen > 0)
12105 {
fd8008d8 12106 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12107 putchar ('\n');
fd8008d8 12108 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12109 }
12110 else
12111 {
12112 printf (_("<corrupt>\n"));
12113 data = end;
12114 }
cf13d699
NC		 12115 some_strings_shown = TRUE;
12116 }
12117 }
12118
12119 if (! some_strings_shown)
12120 printf (_(" No strings found in this section."));
12121
0e602686 12122 free (real_start);
cf13d699
NC		 12123
12124 putchar ('\n');
12125}
12126
12127static void
12128dump_section_as_bytes (Elf_Internal_Shdr * section,
12129 FILE * file,
12130 bfd_boolean relocate)
12131{
12132 Elf_Internal_Shdr * relsec;
0e602686
NC		 12133 bfd_size_type bytes;
12134 bfd_size_type section_size;
12135 bfd_vma addr;
12136 unsigned char * data;
12137 unsigned char * real_start;
12138 unsigned char * start;
12139
12140 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12141 if (start == NULL)
12142 return;
0e602686 12143 section_size = section->sh_size;
cf13d699 12144
74e1a04b 12145 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12146
0e602686
NC		 12147 if (decompress_dumps)
12148 {
12149 dwarf_size_type new_size = section_size;
12150 dwarf_size_type uncompressed_size = 0;
12151
12152 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12153 {
12154 Elf_Internal_Chdr chdr;
12155 unsigned int compression_header_size
12156 = get_compression_header (& chdr, start);
12157
12158 if (chdr.ch_type == ELFCOMPRESS_ZLIB
12159 && chdr.ch_addralign == section->sh_addralign)
12160 {
12161 uncompressed_size = chdr.ch_size;
12162 start += compression_header_size;
12163 new_size -= compression_header_size;
12164 }
12165 }
12166 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12167 {
12168 /* Read the zlib header. In this case, it should be "ZLIB"
12169 followed by the uncompressed section size, 8 bytes in
12170 big-endian order. */
12171 uncompressed_size = start[4]; uncompressed_size <<= 8;
12172 uncompressed_size += start[5]; uncompressed_size <<= 8;
12173 uncompressed_size += start[6]; uncompressed_size <<= 8;
12174 uncompressed_size += start[7]; uncompressed_size <<= 8;
12175 uncompressed_size += start[8]; uncompressed_size <<= 8;
12176 uncompressed_size += start[9]; uncompressed_size <<= 8;
12177 uncompressed_size += start[10]; uncompressed_size <<= 8;
12178 uncompressed_size += start[11];
12179 start += 12;
12180 new_size -= 12;
12181 }
12182
12183 if (uncompressed_size
12184 && uncompress_section_contents (& start, uncompressed_size,
12185 & new_size))
12186 section_size = new_size;
12187 }
12188
cf13d699
NC		 12189 if (relocate)
12190 {
0e602686 12191 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12192 }
12193 else
12194 {
12195 /* If the section being dumped has relocations against it the user might
12196 be expecting these relocations to have been applied. Check for this
12197 case and issue a warning message in order to avoid confusion.
12198 FIXME: Maybe we ought to have an option that dumps a section with
12199 relocs applied ? */
12200 for (relsec = section_headers;
12201 relsec < section_headers + elf_header.e_shnum;
12202 ++relsec)
12203 {
12204 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12205 || relsec->sh_info >= elf_header.e_shnum
12206 || section_headers + relsec->sh_info != section
12207 || relsec->sh_size == 0
12208 || relsec->sh_link >= elf_header.e_shnum)
12209 continue;
12210
12211 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12212 break;
12213 }
12214 }
12215
12216 addr = section->sh_addr;
0e602686 12217 bytes = section_size;
cf13d699
NC		 12218 data = start;
12219
12220 while (bytes)
12221 {
12222 int j;
12223 int k;
12224 int lbytes;
12225
12226 lbytes = (bytes > 16 ? 16 : bytes);
12227
12228 printf (" 0x%8.8lx ", (unsigned long) addr);
12229
12230 for (j = 0; j < 16; j++)
12231 {
12232 if (j < lbytes)
12233 printf ("%2.2x", data[j]);
12234 else
12235 printf (" ");
12236
12237 if ((j & 3) == 3)
12238 printf (" ");
12239 }
12240
12241 for (j = 0; j < lbytes; j++)
12242 {
12243 k = data[j];
12244 if (k >= ' ' && k < 0x7f)
12245 printf ("%c", k);
12246 else
12247 printf (".");
12248 }
12249
12250 putchar ('\n');
12251
12252 data += lbytes;
12253 addr += lbytes;
12254 bytes -= lbytes;
12255 }
12256
0e602686 12257 free (real_start);
cf13d699
NC		 12258
12259 putchar ('\n');
12260}
12261
d966045b
DJ		 12262static int
12263load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12264 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12265{
2cf0635d 12266 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12267 char buf [64];
1007acb3 12268
19e6b90e
L		 12269 /* If it is already loaded, do nothing. */
12270 if (section->start != NULL)
12271 return 1;
1007acb3 12272
19e6b90e
L		 12273 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12274 section->address = sec->sh_addr;
06614111 12275 section->user_data = NULL;
3f5e193b
NC		 12276 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12277 sec->sh_offset, 1,
12278 sec->sh_size, buf);
59245841
NC		 12279 if (section->start == NULL)
12280 section->size = 0;
12281 else
12282 {
77115a4a
L		 12283 unsigned char *start = section->start;
12284 dwarf_size_type size = sec->sh_size;
dab394de 12285 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12286
12287 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12288 {
12289 Elf_Internal_Chdr chdr;
12290 unsigned int compression_header_size
12291 = get_compression_header (&chdr, start);
12292 if (chdr.ch_type != ELFCOMPRESS_ZLIB
12293 || chdr.ch_addralign != sec->sh_addralign)
12294 return 0;
dab394de 12295 uncompressed_size = chdr.ch_size;
77115a4a
L		 12296 start += compression_header_size;
12297 size -= compression_header_size;
12298 }
dab394de
L		 12299 else if (size > 12 && streq ((char *) start, "ZLIB"))
12300 {
12301 /* Read the zlib header. In this case, it should be "ZLIB"
12302 followed by the uncompressed section size, 8 bytes in
12303 big-endian order. */
12304 uncompressed_size = start[4]; uncompressed_size <<= 8;
12305 uncompressed_size += start[5]; uncompressed_size <<= 8;
12306 uncompressed_size += start[6]; uncompressed_size <<= 8;
12307 uncompressed_size += start[7]; uncompressed_size <<= 8;
12308 uncompressed_size += start[8]; uncompressed_size <<= 8;
12309 uncompressed_size += start[9]; uncompressed_size <<= 8;
12310 uncompressed_size += start[10]; uncompressed_size <<= 8;
12311 uncompressed_size += start[11];
12312 start += 12;
12313 size -= 12;
12314 }
12315
12316 if (uncompressed_size
12317 && uncompress_section_contents (&start, uncompressed_size,
12318 &size))
77115a4a
L		 12319 {
12320 /* Free the compressed buffer, update the section buffer
12321 and the section size if uncompress is successful. */
12322 free (section->start);
12323 section->start = start;
77115a4a
L		 12324 }
12325 section->size = size;
59245841 12326 }
4a114e3e 12327
1b315056
CS		 12328 if (section->start == NULL)
12329 return 0;
12330
19e6b90e 12331 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12332 apply_relocations ((FILE *) file, sec, section->start, section->size,
12333 & section->reloc_info, & section->num_relocs);
12334 else
12335 {
12336 section->reloc_info = NULL;
12337 section->num_relocs = 0;
12338 }
1007acb3 12339
1b315056 12340 return 1;
1007acb3
L		 12341}
12342
657d0d47
CC		 12343/* If this is not NULL, load_debug_section will only look for sections
12344 within the list of sections given here. */
12345unsigned int *section_subset = NULL;
12346
d966045b 12347int
2cf0635d 12348load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12349{
2cf0635d
NC		 12350 struct dwarf_section * section = &debug_displays [debug].section;
12351 Elf_Internal_Shdr * sec;
d966045b
DJ		 12352
12353 /* Locate the debug section. */
657d0d47 12354 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12355 if (sec != NULL)
12356 section->name = section->uncompressed_name;
12357 else
12358 {
657d0d47 12359 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12360 if (sec != NULL)
12361 section->name = section->compressed_name;
12362 }
12363 if (sec == NULL)
12364 return 0;
12365
657d0d47
CC		 12366 /* If we're loading from a subset of sections, and we've loaded
12367 a section matching this name before, it's likely that it's a
12368 different one. */
12369 if (section_subset != NULL)
12370 free_debug_section (debug);
12371
3f5e193b 12372 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12373}
12374
19e6b90e
L		 12375void
12376free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12377{
2cf0635d 12378 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12379
19e6b90e
L		 12380 if (section->start == NULL)
12381 return;
1007acb3 12382
19e6b90e
L		 12383 free ((char *) section->start);
12384 section->start = NULL;
12385 section->address = 0;
12386 section->size = 0;
1007acb3
L		 12387}
12388
1007acb3 12389static int
657d0d47 12390display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12391{
2cf0635d 12392 char * name = SECTION_NAME (section);
74e1a04b 12393 const char * print_name = printable_section_name (section);
19e6b90e
L		 12394 bfd_size_type length;
12395 int result = 1;
3f5e193b 12396 int i;
1007acb3 12397
19e6b90e
L		 12398 length = section->sh_size;
12399 if (length == 0)
1007acb3 12400 {
74e1a04b 12401 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12402 return 0;
1007acb3 12403 }
5dff79d8
NC		 12404 if (section->sh_type == SHT_NOBITS)
12405 {
12406 /* There is no point in dumping the contents of a debugging section
12407 which has the NOBITS type - the bits in the file will be random.
12408 This can happen when a file containing a .eh_frame section is
12409 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12410 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12411 print_name);
5dff79d8
NC		 12412 return 0;
12413 }
1007acb3 12414
0112cd26 12415 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12416 name = ".debug_info";
1007acb3 12417
19e6b90e
L		 12418 /* See if we know how to display the contents of this section. */
12419 for (i = 0; i < max; i++)
1b315056 12420 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12421 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12422 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12423 {
2cf0635d 12424 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12425 int secondary = (section != find_section (name));
12426
12427 if (secondary)
3f5e193b 12428 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12429
b40bf0a2
NC		 12430 if (i == line && const_strneq (name, ".debug_line."))
12431 sec->name = name;
12432 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12433 sec->name = sec->uncompressed_name;
12434 else
12435 sec->name = sec->compressed_name;
3f5e193b
NC		 12436 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12437 section, file))
19e6b90e 12438 {
657d0d47
CC		 12439 /* If this debug section is part of a CU/TU set in a .dwp file,
12440 restrict load_debug_section to the sections in that set. */
12441 section_subset = find_cu_tu_set (file, shndx);
12442
19e6b90e 12443 result &= debug_displays[i].display (sec, file);
1007acb3 12444
657d0d47
CC		 12445 section_subset = NULL;
12446
d966045b 12447 if (secondary || (i != info && i != abbrev))
3f5e193b 12448 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12449 }
1007acb3 12450
19e6b90e
L		 12451 break;
12452 }
1007acb3 12453
19e6b90e 12454 if (i == max)
1007acb3 12455 {
74e1a04b 12456 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12457 result = 0;
1007acb3
L		 12458 }
12459
19e6b90e 12460 return result;
5b18a4bc 12461}
103f02d3 12462
aef1f6d0
DJ		 12463/* Set DUMP_SECTS for all sections where dumps were requested
12464 based on section name. */
12465
12466static void
12467initialise_dumps_byname (void)
12468{
2cf0635d 12469 struct dump_list_entry * cur;
aef1f6d0
DJ		 12470
12471 for (cur = dump_sects_byname; cur; cur = cur->next)
12472 {
12473 unsigned int i;
12474 int any;
12475
12476 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12477 if (streq (SECTION_NAME (section_headers + i), cur->name))
12478 {
09c11c86 12479 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12480 any = 1;
12481 }
12482
12483 if (!any)
12484 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12485 cur->name);
12486 }
12487}
12488
5b18a4bc 12489static void
2cf0635d 12490process_section_contents (FILE * file)
5b18a4bc 12491{
2cf0635d 12492 Elf_Internal_Shdr * section;
19e6b90e 12493 unsigned int i;
103f02d3 12494
19e6b90e
L		 12495 if (! do_dump)
12496 return;
103f02d3 12497
aef1f6d0
DJ		 12498 initialise_dumps_byname ();
12499
19e6b90e
L		 12500 for (i = 0, section = section_headers;
12501 i < elf_header.e_shnum && i < num_dump_sects;
12502 i++, section++)
12503 {
12504#ifdef SUPPORT_DISASSEMBLY
12505 if (dump_sects[i] & DISASS_DUMP)
12506 disassemble_section (section, file);
12507#endif
12508 if (dump_sects[i] & HEX_DUMP)
cf13d699 12509 dump_section_as_bytes (section, file, FALSE);
103f02d3 12510
cf13d699
NC		 12511 if (dump_sects[i] & RELOC_DUMP)
12512 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12513
12514 if (dump_sects[i] & STRING_DUMP)
12515 dump_section_as_strings (section, file);
cf13d699
NC		 12516
12517 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12518 display_debug_section (i, section, file);
5b18a4bc 12519 }
103f02d3 12520
19e6b90e
L		 12521 /* Check to see if the user requested a
12522 dump of a section that does not exist. */
12523 while (i++ < num_dump_sects)
12524 if (dump_sects[i])
12525 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12526}
103f02d3 12527
5b18a4bc 12528static void
19e6b90e 12529process_mips_fpe_exception (int mask)
5b18a4bc 12530{
19e6b90e
L		 12531 if (mask)
12532 {
12533 int first = 1;
12534 if (mask & OEX_FPU_INEX)
12535 fputs ("INEX", stdout), first = 0;
12536 if (mask & OEX_FPU_UFLO)
12537 printf ("%sUFLO", first ? "" : "|"), first = 0;
12538 if (mask & OEX_FPU_OFLO)
12539 printf ("%sOFLO", first ? "" : "|"), first = 0;
12540 if (mask & OEX_FPU_DIV0)
12541 printf ("%sDIV0", first ? "" : "|"), first = 0;
12542 if (mask & OEX_FPU_INVAL)
12543 printf ("%sINVAL", first ? "" : "|");
12544 }
5b18a4bc 12545 else
19e6b90e 12546 fputs ("0", stdout);
5b18a4bc 12547}
103f02d3 12548
f6f0e17b
NC		 12549/* Display's the value of TAG at location P. If TAG is
12550 greater than 0 it is assumed to be an unknown tag, and
12551 a message is printed to this effect. Otherwise it is
12552 assumed that a message has already been printed.
12553
12554 If the bottom bit of TAG is set it assumed to have a
12555 string value, otherwise it is assumed to have an integer
12556 value.
12557
12558 Returns an updated P pointing to the first unread byte
12559 beyond the end of TAG's value.
12560
12561 Reads at or beyond END will not be made. */
12562
12563static unsigned char *
12564display_tag_value (int tag,
12565 unsigned char * p,
12566 const unsigned char * const end)
12567{
12568 unsigned long val;
12569
12570 if (tag > 0)
12571 printf (" Tag_unknown_%d: ", tag);
12572
12573 if (p >= end)
12574 {
4082ef84 12575 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12576 }
12577 else if (tag & 1)
12578 {
071436c6
NC		 12579 /* PR 17531 file: 027-19978-0.004. */
12580 size_t maxlen = (end - p) - 1;
12581
12582 putchar ('"');
4082ef84
NC		 12583 if (maxlen > 0)
12584 {
12585 print_symbol ((int) maxlen, (const char *) p);
12586 p += strnlen ((char *) p, maxlen) + 1;
12587 }
12588 else
12589 {
12590 printf (_("<corrupt string tag>"));
12591 p = (unsigned char *) end;
12592 }
071436c6 12593 printf ("\"\n");
f6f0e17b
NC		 12594 }
12595 else
12596 {
12597 unsigned int len;
12598
12599 val = read_uleb128 (p, &len, end);
12600 p += len;
12601 printf ("%ld (0x%lx)\n", val, val);
12602 }
12603
4082ef84 12604 assert (p <= end);
f6f0e17b
NC		 12605 return p;
12606}
12607
11c1ff18
PB		 12608/* ARM EABI attributes section. */
12609typedef struct
12610{
70e99720 12611 unsigned int tag;
2cf0635d 12612 const char * name;
11c1ff18 12613 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12614 unsigned int type;
2cf0635d 12615 const char ** table;
11c1ff18
PB		 12616} arm_attr_public_tag;
12617
2cf0635d 12618static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12619 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12620 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12621static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12622static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12623 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12624static const char * arm_attr_tag_FP_arch[] =
bca38921 12625 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12626 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12627static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12628static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12629 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12630static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12631 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12632 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12633static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12634 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12635static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12636 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12637static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12638 {"Absolute", "PC-relative", "None"};
2cf0635d 12639static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12640 {"None", "direct", "GOT-indirect"};
2cf0635d 12641static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12642 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12643static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12644static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12645 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12646static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12647static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12648static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12649 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12650static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12651 {"Unused", "small", "int", "forced to int"};
2cf0635d 12652static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12653 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12654static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12655 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12656static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12657 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12658static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12659 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12660 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12661static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12662 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12663 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12664static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12665static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12666 {"Not Allowed", "Allowed"};
2cf0635d 12667static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12668 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12669static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12670 {"Not Allowed", "Allowed"};
12671static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12672 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12673 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12674static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12675static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12676 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12677 "TrustZone and Virtualization Extensions"};
dd24e3da 12678static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12679 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12680
12681#define LOOKUP(id, name) \
12682 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12683static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12684{
12685 {4, "CPU_raw_name", 1, NULL},
12686 {5, "CPU_name", 1, NULL},
12687 LOOKUP(6, CPU_arch),
12688 {7, "CPU_arch_profile", 0, NULL},
12689 LOOKUP(8, ARM_ISA_use),
12690 LOOKUP(9, THUMB_ISA_use),
75375b3e 12691 LOOKUP(10, FP_arch),
11c1ff18 12692 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12693 LOOKUP(12, Advanced_SIMD_arch),
12694 LOOKUP(13, PCS_config),
11c1ff18
PB		 12695 LOOKUP(14, ABI_PCS_R9_use),
12696 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12697 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12698 LOOKUP(17, ABI_PCS_GOT_use),
12699 LOOKUP(18, ABI_PCS_wchar_t),
12700 LOOKUP(19, ABI_FP_rounding),
12701 LOOKUP(20, ABI_FP_denormal),
12702 LOOKUP(21, ABI_FP_exceptions),
12703 LOOKUP(22, ABI_FP_user_exceptions),
12704 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12705 {24, "ABI_align_needed", 0, NULL},
12706 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12707 LOOKUP(26, ABI_enum_size),
12708 LOOKUP(27, ABI_HardFP_use),
12709 LOOKUP(28, ABI_VFP_args),
12710 LOOKUP(29, ABI_WMMX_args),
12711 LOOKUP(30, ABI_optimization_goals),
12712 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12713 {32, "compatibility", 0, NULL},
f5f53991 12714 LOOKUP(34, CPU_unaligned_access),
75375b3e 12715 LOOKUP(36, FP_HP_extension),
8e79c3df 12716 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12717 LOOKUP(42, MPextension_use),
12718 LOOKUP(44, DIV_use),
f5f53991
AS		 12719 {64, "nodefaults", 0, NULL},
12720 {65, "also_compatible_with", 0, NULL},
12721 LOOKUP(66, T2EE_use),
12722 {67, "conformance", 1, NULL},
12723 LOOKUP(68, Virtualization_use),
cd21e546 12724 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12725};
12726#undef LOOKUP
12727
11c1ff18 12728static unsigned char *
f6f0e17b
NC		 12729display_arm_attribute (unsigned char * p,
12730 const unsigned char * const end)
11c1ff18 12731{
70e99720 12732 unsigned int tag;
11c1ff18 12733 unsigned int len;
70e99720 12734 unsigned int val;
2cf0635d 12735 arm_attr_public_tag * attr;
11c1ff18 12736 unsigned i;
70e99720 12737 unsigned int type;
11c1ff18 12738
f6f0e17b 12739 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12740 p += len;
12741 attr = NULL;
2cf0635d 12742 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12743 {
12744 if (arm_attr_public_tags[i].tag == tag)
12745 {
12746 attr = &arm_attr_public_tags[i];
12747 break;
12748 }
12749 }
12750
12751 if (attr)
12752 {
12753 printf (" Tag_%s: ", attr->name);
12754 switch (attr->type)
12755 {
12756 case 0:
12757 switch (tag)
12758 {
12759 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12760 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12761 p += len;
12762 switch (val)
12763 {
2b692964
NC		 12764 case 0: printf (_("None\n")); break;
12765 case 'A': printf (_("Application\n")); break;
12766 case 'R': printf (_("Realtime\n")); break;
12767 case 'M': printf (_("Microcontroller\n")); break;
12768 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12769 default: printf ("??? (%d)\n", val); break;
12770 }
12771 break;
12772
75375b3e 12773 case 24: /* Tag_align_needed. */
f6f0e17b 12774 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12775 p += len;
12776 switch (val)
12777 {
2b692964
NC		 12778 case 0: printf (_("None\n")); break;
12779 case 1: printf (_("8-byte\n")); break;
12780 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12781 case 3: printf ("??? 3\n"); break;
12782 default:
12783 if (val <= 12)
dd24e3da 12784 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12785 1 << val);
12786 else
12787 printf ("??? (%d)\n", val);
12788 break;
12789 }
12790 break;
12791
12792 case 25: /* Tag_align_preserved. */
f6f0e17b 12793 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12794 p += len;
12795 switch (val)
12796 {
2b692964
NC		 12797 case 0: printf (_("None\n")); break;
12798 case 1: printf (_("8-byte, except leaf SP\n")); break;
12799 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12800 case 3: printf ("??? 3\n"); break;
12801 default:
12802 if (val <= 12)
dd24e3da 12803 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12804 1 << val);
12805 else
12806 printf ("??? (%d)\n", val);
12807 break;
12808 }
12809 break;
12810
11c1ff18 12811 case 32: /* Tag_compatibility. */
071436c6 12812 {
071436c6
NC		 12813 val = read_uleb128 (p, &len, end);
12814 p += len;
071436c6 12815 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12816 if (p < end - 1)
12817 {
12818 size_t maxlen = (end - p) - 1;
12819
12820 print_symbol ((int) maxlen, (const char *) p);
12821 p += strnlen ((char *) p, maxlen) + 1;
12822 }
12823 else
12824 {
12825 printf (_("<corrupt>"));
12826 p = (unsigned char *) end;
12827 }
071436c6 12828 putchar ('\n');
071436c6 12829 }
11c1ff18
PB		 12830 break;
12831
f5f53991 12832 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12833 /* PR 17531: file: 001-505008-0.01. */
12834 if (p < end)
12835 p++;
2b692964 12836 printf (_("True\n"));
f5f53991
AS		 12837 break;
12838
12839 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12840 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12841 p += len;
12842 if (val == 6 /* Tag_CPU_arch. */)
12843 {
f6f0e17b 12844 val = read_uleb128 (p, &len, end);
f5f53991 12845 p += len;
071436c6 12846 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12847 printf ("??? (%d)\n", val);
12848 else
12849 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12850 }
12851 else
12852 printf ("???\n");
071436c6
NC		 12853 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12854 ;
f5f53991
AS		 12855 break;
12856
11c1ff18 12857 default:
bee0ee85
NC		 12858 printf (_("<unknown: %d>\n"), tag);
12859 break;
11c1ff18
PB		 12860 }
12861 return p;
12862
12863 case 1:
f6f0e17b 12864 return display_tag_value (-1, p, end);
11c1ff18 12865 case 2:
f6f0e17b 12866 return display_tag_value (0, p, end);
11c1ff18
PB		 12867
12868 default:
12869 assert (attr->type & 0x80);
f6f0e17b 12870 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12871 p += len;
12872 type = attr->type & 0x7f;
12873 if (val >= type)
12874 printf ("??? (%d)\n", val);
12875 else
12876 printf ("%s\n", attr->table[val]);
12877 return p;
12878 }
12879 }
11c1ff18 12880
f6f0e17b 12881 return display_tag_value (tag, p, end);
11c1ff18
PB		 12882}
12883
104d59d1 12884static unsigned char *
60bca95a 12885display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12886 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12887 const unsigned char * const end)
104d59d1
JM		 12888{
12889 int tag;
12890 unsigned int len;
12891 int val;
104d59d1 12892
f6f0e17b 12893 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12894 p += len;
12895
12896 /* Tag_compatibility is the only generic GNU attribute defined at
12897 present. */
12898 if (tag == 32)
12899 {
f6f0e17b 12900 val = read_uleb128 (p, &len, end);
104d59d1 12901 p += len;
071436c6
NC		 12902
12903 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12904 if (p == end)
12905 {
071436c6 12906 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12907 warn (_("corrupt vendor attribute\n"));
12908 }
12909 else
12910 {
4082ef84
NC		 12911 if (p < end - 1)
12912 {
12913 size_t maxlen = (end - p) - 1;
071436c6 12914
4082ef84
NC		 12915 print_symbol ((int) maxlen, (const char *) p);
12916 p += strnlen ((char *) p, maxlen) + 1;
12917 }
12918 else
12919 {
12920 printf (_("<corrupt>"));
12921 p = (unsigned char *) end;
12922 }
071436c6 12923 putchar ('\n');
f6f0e17b 12924 }
104d59d1
JM		 12925 return p;
12926 }
12927
12928 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12929 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12930
f6f0e17b 12931 return display_tag_value (tag, p, end);
104d59d1
JM		 12932}
12933
34c8bcba 12934static unsigned char *
f6f0e17b
NC		 12935display_power_gnu_attribute (unsigned char * p,
12936 int tag,
12937 const unsigned char * const end)
34c8bcba 12938{
34c8bcba
JM		 12939 unsigned int len;
12940 int val;
12941
12942 if (tag == Tag_GNU_Power_ABI_FP)
12943 {
f6f0e17b 12944 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12945 p += len;
12946 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12947
34c8bcba
JM		 12948 switch (val)
12949 {
12950 case 0:
2b692964 12951 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12952 break;
12953 case 1:
2b692964 12954 printf (_("Hard float\n"));
34c8bcba
JM		 12955 break;
12956 case 2:
2b692964 12957 printf (_("Soft float\n"));
34c8bcba 12958 break;
3c7b9897 12959 case 3:
2b692964 12960 printf (_("Single-precision hard float\n"));
3c7b9897 12961 break;
34c8bcba
JM		 12962 default:
12963 printf ("??? (%d)\n", val);
12964 break;
12965 }
12966 return p;
12967 }
12968
c6e65352
DJ		 12969 if (tag == Tag_GNU_Power_ABI_Vector)
12970 {
f6f0e17b 12971 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12972 p += len;
12973 printf (" Tag_GNU_Power_ABI_Vector: ");
12974 switch (val)
12975 {
12976 case 0:
2b692964 12977 printf (_("Any\n"));
c6e65352
DJ		 12978 break;
12979 case 1:
2b692964 12980 printf (_("Generic\n"));
c6e65352
DJ		 12981 break;
12982 case 2:
12983 printf ("AltiVec\n");
12984 break;
12985 case 3:
12986 printf ("SPE\n");
12987 break;
12988 default:
12989 printf ("??? (%d)\n", val);
12990 break;
12991 }
12992 return p;
12993 }
12994
f82e0623
NF		 12995 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12996 {
f6f0e17b
NC		 12997 if (p == end)
12998 {
071436c6 12999 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13000 return p;
13001 }
0b4362b0 13002
f6f0e17b 13003 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13004 p += len;
13005 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13006 switch (val)
13007 {
13008 case 0:
2b692964 13009 printf (_("Any\n"));
f82e0623
NF		 13010 break;
13011 case 1:
13012 printf ("r3/r4\n");
13013 break;
13014 case 2:
2b692964 13015 printf (_("Memory\n"));
f82e0623
NF		 13016 break;
13017 default:
13018 printf ("??? (%d)\n", val);
13019 break;
13020 }
13021 return p;
13022 }
13023
f6f0e17b 13024 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13025}
13026
643f7afb
AK		 13027static unsigned char *
13028display_s390_gnu_attribute (unsigned char * p,
13029 int tag,
13030 const unsigned char * const end)
13031{
13032 unsigned int len;
13033 int val;
13034
13035 if (tag == Tag_GNU_S390_ABI_Vector)
13036 {
13037 val = read_uleb128 (p, &len, end);
13038 p += len;
13039 printf (" Tag_GNU_S390_ABI_Vector: ");
13040
13041 switch (val)
13042 {
13043 case 0:
13044 printf (_("any\n"));
13045 break;
13046 case 1:
13047 printf (_("software\n"));
13048 break;
13049 case 2:
13050 printf (_("hardware\n"));
13051 break;
13052 default:
13053 printf ("??? (%d)\n", val);
13054 break;
13055 }
13056 return p;
13057 }
13058
13059 return display_tag_value (tag & 1, p, end);
13060}
13061
9e8c70f9
DM		 13062static void
13063display_sparc_hwcaps (int mask)
13064{
13065 if (mask)
13066 {
13067 int first = 1;
071436c6 13068
9e8c70f9
DM		 13069 if (mask & ELF_SPARC_HWCAP_MUL32)
13070 fputs ("mul32", stdout), first = 0;
13071 if (mask & ELF_SPARC_HWCAP_DIV32)
13072 printf ("%sdiv32", first ? "" : "|"), first = 0;
13073 if (mask & ELF_SPARC_HWCAP_FSMULD)
13074 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13075 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13076 printf ("%sv8plus", first ? "" : "|"), first = 0;
13077 if (mask & ELF_SPARC_HWCAP_POPC)
13078 printf ("%spopc", first ? "" : "|"), first = 0;
13079 if (mask & ELF_SPARC_HWCAP_VIS)
13080 printf ("%svis", first ? "" : "|"), first = 0;
13081 if (mask & ELF_SPARC_HWCAP_VIS2)
13082 printf ("%svis2", first ? "" : "|"), first = 0;
13083 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13084 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13085 if (mask & ELF_SPARC_HWCAP_FMAF)
13086 printf ("%sfmaf", first ? "" : "|"), first = 0;
13087 if (mask & ELF_SPARC_HWCAP_VIS3)
13088 printf ("%svis3", first ? "" : "|"), first = 0;
13089 if (mask & ELF_SPARC_HWCAP_HPC)
13090 printf ("%shpc", first ? "" : "|"), first = 0;
13091 if (mask & ELF_SPARC_HWCAP_RANDOM)
13092 printf ("%srandom", first ? "" : "|"), first = 0;
13093 if (mask & ELF_SPARC_HWCAP_TRANS)
13094 printf ("%strans", first ? "" : "|"), first = 0;
13095 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13096 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13097 if (mask & ELF_SPARC_HWCAP_IMA)
13098 printf ("%sima", first ? "" : "|"), first = 0;
13099 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13100 printf ("%scspare", first ? "" : "|"), first = 0;
13101 }
13102 else
071436c6
NC		 13103 fputc ('0', stdout);
13104 fputc ('\n', stdout);
9e8c70f9
DM		 13105}
13106
3d68f91c
JM		 13107static void
13108display_sparc_hwcaps2 (int mask)
13109{
13110 if (mask)
13111 {
13112 int first = 1;
071436c6 13113
3d68f91c
JM		 13114 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13115 fputs ("fjathplus", stdout), first = 0;
13116 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13117 printf ("%svis3b", first ? "" : "|"), first = 0;
13118 if (mask & ELF_SPARC_HWCAP2_ADP)
13119 printf ("%sadp", first ? "" : "|"), first = 0;
13120 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13121 printf ("%ssparc5", first ? "" : "|"), first = 0;
13122 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13123 printf ("%smwait", first ? "" : "|"), first = 0;
13124 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13125 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13126 if (mask & ELF_SPARC_HWCAP2_XMONT)
13127 printf ("%sxmont2", first ? "" : "|"), first = 0;
13128 if (mask & ELF_SPARC_HWCAP2_NSEC)
13129 printf ("%snsec", first ? "" : "|"), first = 0;
13130 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13131 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13132 if (mask & ELF_SPARC_HWCAP2_FJDES)
13133 printf ("%sfjdes", first ? "" : "|"), first = 0;
13134 if (mask & ELF_SPARC_HWCAP2_FJAES)
13135 printf ("%sfjaes", first ? "" : "|"), first = 0;
13136 }
13137 else
071436c6
NC		 13138 fputc ('0', stdout);
13139 fputc ('\n', stdout);
3d68f91c
JM		 13140}
13141
9e8c70f9 13142static unsigned char *
f6f0e17b
NC		 13143display_sparc_gnu_attribute (unsigned char * p,
13144 int tag,
13145 const unsigned char * const end)
9e8c70f9 13146{
3d68f91c
JM		 13147 unsigned int len;
13148 int val;
13149
9e8c70f9
DM		 13150 if (tag == Tag_GNU_Sparc_HWCAPS)
13151 {
f6f0e17b 13152 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13153 p += len;
13154 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13155 display_sparc_hwcaps (val);
13156 return p;
3d68f91c
JM		 13157 }
13158 if (tag == Tag_GNU_Sparc_HWCAPS2)
13159 {
13160 val = read_uleb128 (p, &len, end);
13161 p += len;
13162 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13163 display_sparc_hwcaps2 (val);
13164 return p;
13165 }
9e8c70f9 13166
f6f0e17b 13167 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13168}
13169
351cdf24
MF		 13170static void
13171print_mips_fp_abi_value (int val)
13172{
13173 switch (val)
13174 {
13175 case Val_GNU_MIPS_ABI_FP_ANY:
13176 printf (_("Hard or soft float\n"));
13177 break;
13178 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13179 printf (_("Hard float (double precision)\n"));
13180 break;
13181 case Val_GNU_MIPS_ABI_FP_SINGLE:
13182 printf (_("Hard float (single precision)\n"));
13183 break;
13184 case Val_GNU_MIPS_ABI_FP_SOFT:
13185 printf (_("Soft float\n"));
13186 break;
13187 case Val_GNU_MIPS_ABI_FP_OLD_64:
13188 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13189 break;
13190 case Val_GNU_MIPS_ABI_FP_XX:
13191 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13192 break;
13193 case Val_GNU_MIPS_ABI_FP_64:
13194 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13195 break;
13196 case Val_GNU_MIPS_ABI_FP_64A:
13197 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13198 break;
13199 default:
13200 printf ("??? (%d)\n", val);
13201 break;
13202 }
13203}
13204
2cf19d5c 13205static unsigned char *
f6f0e17b
NC		 13206display_mips_gnu_attribute (unsigned char * p,
13207 int tag,
13208 const unsigned char * const end)
2cf19d5c 13209{
2cf19d5c
JM		 13210 if (tag == Tag_GNU_MIPS_ABI_FP)
13211 {
f6f0e17b
NC		 13212 unsigned int len;
13213 int val;
13214
13215 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13216 p += len;
13217 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13218
351cdf24
MF		 13219 print_mips_fp_abi_value (val);
13220
2cf19d5c
JM		 13221 return p;
13222 }
13223
a9f58168
CF		 13224 if (tag == Tag_GNU_MIPS_ABI_MSA)
13225 {
13226 unsigned int len;
13227 int val;
13228
13229 val = read_uleb128 (p, &len, end);
13230 p += len;
13231 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13232
13233 switch (val)
13234 {
13235 case Val_GNU_MIPS_ABI_MSA_ANY:
13236 printf (_("Any MSA or not\n"));
13237 break;
13238 case Val_GNU_MIPS_ABI_MSA_128:
13239 printf (_("128-bit MSA\n"));
13240 break;
13241 default:
13242 printf ("??? (%d)\n", val);
13243 break;
13244 }
13245 return p;
13246 }
13247
f6f0e17b 13248 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13249}
13250
59e6276b 13251static unsigned char *
f6f0e17b
NC		 13252display_tic6x_attribute (unsigned char * p,
13253 const unsigned char * const end)
59e6276b
JM		 13254{
13255 int tag;
13256 unsigned int len;
13257 int val;
13258
f6f0e17b 13259 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13260 p += len;
13261
13262 switch (tag)
13263 {
75fa6dc1 13264 case Tag_ISA:
f6f0e17b 13265 val = read_uleb128 (p, &len, end);
59e6276b 13266 p += len;
75fa6dc1 13267 printf (" Tag_ISA: ");
59e6276b
JM		 13268
13269 switch (val)
13270 {
75fa6dc1 13271 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13272 printf (_("None\n"));
13273 break;
75fa6dc1 13274 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13275 printf ("C62x\n");
13276 break;
75fa6dc1 13277 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13278 printf ("C67x\n");
13279 break;
75fa6dc1 13280 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13281 printf ("C67x+\n");
13282 break;
75fa6dc1 13283 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13284 printf ("C64x\n");
13285 break;
75fa6dc1 13286 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13287 printf ("C64x+\n");
13288 break;
75fa6dc1 13289 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13290 printf ("C674x\n");
13291 break;
13292 default:
13293 printf ("??? (%d)\n", val);
13294 break;
13295 }
13296 return p;
13297
87779176 13298 case Tag_ABI_wchar_t:
f6f0e17b 13299 val = read_uleb128 (p, &len, end);
87779176
JM		 13300 p += len;
13301 printf (" Tag_ABI_wchar_t: ");
13302 switch (val)
13303 {
13304 case 0:
13305 printf (_("Not used\n"));
13306 break;
13307 case 1:
13308 printf (_("2 bytes\n"));
13309 break;
13310 case 2:
13311 printf (_("4 bytes\n"));
13312 break;
13313 default:
13314 printf ("??? (%d)\n", val);
13315 break;
13316 }
13317 return p;
13318
13319 case Tag_ABI_stack_align_needed:
f6f0e17b 13320 val = read_uleb128 (p, &len, end);
87779176
JM		 13321 p += len;
13322 printf (" Tag_ABI_stack_align_needed: ");
13323 switch (val)
13324 {
13325 case 0:
13326 printf (_("8-byte\n"));
13327 break;
13328 case 1:
13329 printf (_("16-byte\n"));
13330 break;
13331 default:
13332 printf ("??? (%d)\n", val);
13333 break;
13334 }
13335 return p;
13336
13337 case Tag_ABI_stack_align_preserved:
f6f0e17b 13338 val = read_uleb128 (p, &len, end);
87779176
JM		 13339 p += len;
13340 printf (" Tag_ABI_stack_align_preserved: ");
13341 switch (val)
13342 {
13343 case 0:
13344 printf (_("8-byte\n"));
13345 break;
13346 case 1:
13347 printf (_("16-byte\n"));
13348 break;
13349 default:
13350 printf ("??? (%d)\n", val);
13351 break;
13352 }
13353 return p;
13354
b5593623 13355 case Tag_ABI_DSBT:
f6f0e17b 13356 val = read_uleb128 (p, &len, end);
b5593623
JM		 13357 p += len;
13358 printf (" Tag_ABI_DSBT: ");
13359 switch (val)
13360 {
13361 case 0:
13362 printf (_("DSBT addressing not used\n"));
13363 break;
13364 case 1:
13365 printf (_("DSBT addressing used\n"));
13366 break;
13367 default:
13368 printf ("??? (%d)\n", val);
13369 break;
13370 }
13371 return p;
13372
87779176 13373 case Tag_ABI_PID:
f6f0e17b 13374 val = read_uleb128 (p, &len, end);
87779176
JM		 13375 p += len;
13376 printf (" Tag_ABI_PID: ");
13377 switch (val)
13378 {
13379 case 0:
13380 printf (_("Data addressing position-dependent\n"));
13381 break;
13382 case 1:
13383 printf (_("Data addressing position-independent, GOT near DP\n"));
13384 break;
13385 case 2:
13386 printf (_("Data addressing position-independent, GOT far from DP\n"));
13387 break;
13388 default:
13389 printf ("??? (%d)\n", val);
13390 break;
13391 }
13392 return p;
13393
13394 case Tag_ABI_PIC:
f6f0e17b 13395 val = read_uleb128 (p, &len, end);
87779176
JM		 13396 p += len;
13397 printf (" Tag_ABI_PIC: ");
13398 switch (val)
13399 {
13400 case 0:
13401 printf (_("Code addressing position-dependent\n"));
13402 break;
13403 case 1:
13404 printf (_("Code addressing position-independent\n"));
13405 break;
13406 default:
13407 printf ("??? (%d)\n", val);
13408 break;
13409 }
13410 return p;
13411
13412 case Tag_ABI_array_object_alignment:
f6f0e17b 13413 val = read_uleb128 (p, &len, end);
87779176
JM		 13414 p += len;
13415 printf (" Tag_ABI_array_object_alignment: ");
13416 switch (val)
13417 {
13418 case 0:
13419 printf (_("8-byte\n"));
13420 break;
13421 case 1:
13422 printf (_("4-byte\n"));
13423 break;
13424 case 2:
13425 printf (_("16-byte\n"));
13426 break;
13427 default:
13428 printf ("??? (%d)\n", val);
13429 break;
13430 }
13431 return p;
13432
13433 case Tag_ABI_array_object_align_expected:
f6f0e17b 13434 val = read_uleb128 (p, &len, end);
87779176
JM		 13435 p += len;
13436 printf (" Tag_ABI_array_object_align_expected: ");
13437 switch (val)
13438 {
13439 case 0:
13440 printf (_("8-byte\n"));
13441 break;
13442 case 1:
13443 printf (_("4-byte\n"));
13444 break;
13445 case 2:
13446 printf (_("16-byte\n"));
13447 break;
13448 default:
13449 printf ("??? (%d)\n", val);
13450 break;
13451 }
13452 return p;
13453
3cbd1c06 13454 case Tag_ABI_compatibility:
071436c6 13455 {
071436c6
NC		 13456 val = read_uleb128 (p, &len, end);
13457 p += len;
13458 printf (" Tag_ABI_compatibility: ");
071436c6 13459 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13460 if (p < end - 1)
13461 {
13462 size_t maxlen = (end - p) - 1;
13463
13464 print_symbol ((int) maxlen, (const char *) p);
13465 p += strnlen ((char *) p, maxlen) + 1;
13466 }
13467 else
13468 {
13469 printf (_("<corrupt>"));
13470 p = (unsigned char *) end;
13471 }
071436c6 13472 putchar ('\n');
071436c6
NC		 13473 return p;
13474 }
87779176
JM		 13475
13476 case Tag_ABI_conformance:
071436c6 13477 {
4082ef84
NC		 13478 printf (" Tag_ABI_conformance: \"");
13479 if (p < end - 1)
13480 {
13481 size_t maxlen = (end - p) - 1;
071436c6 13482
4082ef84
NC		 13483 print_symbol ((int) maxlen, (const char *) p);
13484 p += strnlen ((char *) p, maxlen) + 1;
13485 }
13486 else
13487 {
13488 printf (_("<corrupt>"));
13489 p = (unsigned char *) end;
13490 }
071436c6 13491 printf ("\"\n");
071436c6
NC		 13492 return p;
13493 }
59e6276b
JM		 13494 }
13495
f6f0e17b
NC		 13496 return display_tag_value (tag, p, end);
13497}
59e6276b 13498
f6f0e17b
NC		 13499static void
13500display_raw_attribute (unsigned char * p, unsigned char * end)
13501{
13502 unsigned long addr = 0;
13503 size_t bytes = end - p;
13504
e0a31db1 13505 assert (end > p);
f6f0e17b 13506 while (bytes)
87779176 13507 {
f6f0e17b
NC		 13508 int j;
13509 int k;
13510 int lbytes = (bytes > 16 ? 16 : bytes);
13511
13512 printf (" 0x%8.8lx ", addr);
13513
13514 for (j = 0; j < 16; j++)
13515 {
13516 if (j < lbytes)
13517 printf ("%2.2x", p[j]);
13518 else
13519 printf (" ");
13520
13521 if ((j & 3) == 3)
13522 printf (" ");
13523 }
13524
13525 for (j = 0; j < lbytes; j++)
13526 {
13527 k = p[j];
13528 if (k >= ' ' && k < 0x7f)
13529 printf ("%c", k);
13530 else
13531 printf (".");
13532 }
13533
13534 putchar ('\n');
13535
13536 p += lbytes;
13537 bytes -= lbytes;
13538 addr += lbytes;
87779176 13539 }
59e6276b 13540
f6f0e17b 13541 putchar ('\n');
59e6276b
JM		 13542}
13543
13761a11
NC		 13544static unsigned char *
13545display_msp430x_attribute (unsigned char * p,
13546 const unsigned char * const end)
13547{
13548 unsigned int len;
13549 int val;
13550 int tag;
13551
13552 tag = read_uleb128 (p, & len, end);
13553 p += len;
0b4362b0 13554
13761a11
NC		 13555 switch (tag)
13556 {
13557 case OFBA_MSPABI_Tag_ISA:
13558 val = read_uleb128 (p, &len, end);
13559 p += len;
13560 printf (" Tag_ISA: ");
13561 switch (val)
13562 {
13563 case 0: printf (_("None\n")); break;
13564 case 1: printf (_("MSP430\n")); break;
13565 case 2: printf (_("MSP430X\n")); break;
13566 default: printf ("??? (%d)\n", val); break;
13567 }
13568 break;
13569
13570 case OFBA_MSPABI_Tag_Code_Model:
13571 val = read_uleb128 (p, &len, end);
13572 p += len;
13573 printf (" Tag_Code_Model: ");
13574 switch (val)
13575 {
13576 case 0: printf (_("None\n")); break;
13577 case 1: printf (_("Small\n")); break;
13578 case 2: printf (_("Large\n")); break;
13579 default: printf ("??? (%d)\n", val); break;
13580 }
13581 break;
13582
13583 case OFBA_MSPABI_Tag_Data_Model:
13584 val = read_uleb128 (p, &len, end);
13585 p += len;
13586 printf (" Tag_Data_Model: ");
13587 switch (val)
13588 {
13589 case 0: printf (_("None\n")); break;
13590 case 1: printf (_("Small\n")); break;
13591 case 2: printf (_("Large\n")); break;
13592 case 3: printf (_("Restricted Large\n")); break;
13593 default: printf ("??? (%d)\n", val); break;
13594 }
13595 break;
13596
13597 default:
13598 printf (_(" <unknown tag %d>: "), tag);
13599
13600 if (tag & 1)
13601 {
071436c6 13602 putchar ('"');
4082ef84
NC		 13603 if (p < end - 1)
13604 {
13605 size_t maxlen = (end - p) - 1;
13606
13607 print_symbol ((int) maxlen, (const char *) p);
13608 p += strnlen ((char *) p, maxlen) + 1;
13609 }
13610 else
13611 {
13612 printf (_("<corrupt>"));
13613 p = (unsigned char *) end;
13614 }
071436c6 13615 printf ("\"\n");
13761a11
NC		 13616 }
13617 else
13618 {
13619 val = read_uleb128 (p, &len, end);
13620 p += len;
13621 printf ("%d (0x%x)\n", val, val);
13622 }
13623 break;
13624 }
13625
4082ef84 13626 assert (p <= end);
13761a11
NC		 13627 return p;
13628}
13629
11c1ff18 13630static int
60bca95a
NC		 13631process_attributes (FILE * file,
13632 const char * public_name,
104d59d1 13633 unsigned int proc_type,
f6f0e17b
NC		 13634 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13635 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13636{
2cf0635d 13637 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13638 unsigned i;
13639
13640 /* Find the section header so that we get the size. */
13641 for (i = 0, sect = section_headers;
13642 i < elf_header.e_shnum;
13643 i++, sect++)
13644 {
071436c6
NC		 13645 unsigned char * contents;
13646 unsigned char * p;
13647
104d59d1 13648 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13649 continue;
13650
3f5e193b
NC		 13651 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13652 sect->sh_size, _("attributes"));
60bca95a 13653 if (contents == NULL)
11c1ff18 13654 continue;
60bca95a 13655
11c1ff18
PB		 13656 p = contents;
13657 if (*p == 'A')
13658 {
071436c6
NC		 13659 bfd_vma section_len;
13660
13661 section_len = sect->sh_size - 1;
11c1ff18 13662 p++;
60bca95a 13663
071436c6 13664 while (section_len > 0)
11c1ff18 13665 {
071436c6 13666 bfd_vma attr_len;
e9847026 13667 unsigned int namelen;
11c1ff18 13668 bfd_boolean public_section;
104d59d1 13669 bfd_boolean gnu_section;
11c1ff18 13670
071436c6 13671 if (section_len <= 4)
e0a31db1
NC		 13672 {
13673 error (_("Tag section ends prematurely\n"));
13674 break;
13675 }
071436c6 13676 attr_len = byte_get (p, 4);
11c1ff18 13677 p += 4;
60bca95a 13678
071436c6 13679 if (attr_len > section_len)
11c1ff18 13680 {
071436c6
NC		 13681 error (_("Bad attribute length (%u > %u)\n"),
13682 (unsigned) attr_len, (unsigned) section_len);
13683 attr_len = section_len;
11c1ff18 13684 }
74e1a04b 13685 /* PR 17531: file: 001-101425-0.004 */
071436c6 13686 else if (attr_len < 5)
74e1a04b 13687 {
071436c6 13688 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13689 break;
13690 }
e9847026 13691
071436c6
NC		 13692 section_len -= attr_len;
13693 attr_len -= 4;
13694
13695 namelen = strnlen ((char *) p, attr_len) + 1;
13696 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13697 {
13698 error (_("Corrupt attribute section name\n"));
13699 break;
13700 }
13701
071436c6
NC		 13702 printf (_("Attribute Section: "));
13703 print_symbol (INT_MAX, (const char *) p);
13704 putchar ('\n');
60bca95a
NC		 13705
13706 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13707 public_section = TRUE;
13708 else
13709 public_section = FALSE;
60bca95a
NC		 13710
13711 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13712 gnu_section = TRUE;
13713 else
13714 gnu_section = FALSE;
60bca95a 13715
11c1ff18 13716 p += namelen;
071436c6 13717 attr_len -= namelen;
e0a31db1 13718
071436c6 13719 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13720 {
e0a31db1 13721 int tag;
11c1ff18
PB		 13722 int val;
13723 bfd_vma size;
071436c6 13724 unsigned char * end;
60bca95a 13725
e0a31db1 13726 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13727 if (attr_len < 6)
e0a31db1
NC		 13728 {
13729 error (_("Unused bytes at end of section\n"));
13730 section_len = 0;
13731 break;
13732 }
13733
13734 tag = *(p++);
11c1ff18 13735 size = byte_get (p, 4);
071436c6 13736 if (size > attr_len)
11c1ff18 13737 {
e9847026 13738 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13739 (unsigned) size, (unsigned) attr_len);
13740 size = attr_len;
11c1ff18 13741 }
e0a31db1
NC		 13742 /* PR binutils/17531: Safe handling of corrupt files. */
13743 if (size < 6)
13744 {
13745 error (_("Bad subsection length (%u < 6)\n"),
13746 (unsigned) size);
13747 section_len = 0;
13748 break;
13749 }
60bca95a 13750
071436c6 13751 attr_len -= size;
11c1ff18 13752 end = p + size - 1;
071436c6 13753 assert (end <= contents + sect->sh_size);
11c1ff18 13754 p += 4;
60bca95a 13755
11c1ff18
PB		 13756 switch (tag)
13757 {
13758 case 1:
2b692964 13759 printf (_("File Attributes\n"));
11c1ff18
PB		 13760 break;
13761 case 2:
2b692964 13762 printf (_("Section Attributes:"));
11c1ff18
PB		 13763 goto do_numlist;
13764 case 3:
2b692964 13765 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13766 do_numlist:
13767 for (;;)
13768 {
91d6fa6a 13769 unsigned int j;
60bca95a 13770
f6f0e17b 13771 val = read_uleb128 (p, &j, end);
91d6fa6a 13772 p += j;
11c1ff18
PB		 13773 if (val == 0)
13774 break;
13775 printf (" %d", val);
13776 }
13777 printf ("\n");
13778 break;
13779 default:
2b692964 13780 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13781 public_section = FALSE;
13782 break;
13783 }
60bca95a 13784
071436c6 13785 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13786 {
13787 while (p < end)
f6f0e17b 13788 p = display_pub_attribute (p, end);
071436c6 13789 assert (p <= end);
104d59d1 13790 }
071436c6 13791 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13792 {
13793 while (p < end)
13794 p = display_gnu_attribute (p,
f6f0e17b
NC		 13795 display_proc_gnu_attribute,
13796 end);
071436c6 13797 assert (p <= end);
11c1ff18 13798 }
071436c6 13799 else if (p < end)
11c1ff18 13800 {
071436c6 13801 printf (_(" Unknown attribute:\n"));
f6f0e17b 13802 display_raw_attribute (p, end);
11c1ff18
PB		 13803 p = end;
13804 }
071436c6
NC		 13805 else
13806 attr_len = 0;
11c1ff18
PB		 13807 }
13808 }
13809 }
13810 else
e9847026 13811 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13812
60bca95a 13813 free (contents);
11c1ff18
PB		 13814 }
13815 return 1;
13816}
13817
104d59d1 13818static int
2cf0635d 13819process_arm_specific (FILE * file)
104d59d1
JM		 13820{
13821 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13822 display_arm_attribute, NULL);
13823}
13824
34c8bcba 13825static int
2cf0635d 13826process_power_specific (FILE * file)
34c8bcba
JM		 13827{
13828 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13829 display_power_gnu_attribute);
13830}
13831
643f7afb
AK		 13832static int
13833process_s390_specific (FILE * file)
13834{
13835 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13836 display_s390_gnu_attribute);
13837}
13838
9e8c70f9
DM		 13839static int
13840process_sparc_specific (FILE * file)
13841{
13842 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13843 display_sparc_gnu_attribute);
13844}
13845
59e6276b
JM		 13846static int
13847process_tic6x_specific (FILE * file)
13848{
13849 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13850 display_tic6x_attribute, NULL);
13851}
13852
13761a11
NC		 13853static int
13854process_msp430x_specific (FILE * file)
13855{
13856 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13857 display_msp430x_attribute, NULL);
13858}
13859
ccb4c951
RS		 13860/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13861 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13862 and return the VMA of the next entry, or -1 if there was a problem.
13863 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13864
13865static bfd_vma
82b1b41b
NC		 13866print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13867 unsigned char * data_end)
ccb4c951
RS		 13868{
13869 printf (" ");
13870 print_vma (addr, LONG_HEX);
13871 printf (" ");
13872 if (addr < pltgot + 0xfff0)
13873 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13874 else
13875 printf ("%10s", "");
13876 printf (" ");
13877 if (data == NULL)
2b692964 13878 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13879 else
13880 {
13881 bfd_vma entry;
82b1b41b 13882 unsigned char * from = data + addr - pltgot;
ccb4c951 13883
82b1b41b
NC		 13884 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13885 {
13886 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13887 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13888 return (bfd_vma) -1;
13889 }
13890 else
13891 {
13892 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13893 print_vma (entry, LONG_HEX);
13894 }
ccb4c951
RS		 13895 }
13896 return addr + (is_32bit_elf ? 4 : 8);
13897}
13898
861fb55a
DJ		 13899/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13900 PLTGOT. Print the Address and Initial fields of an entry at VMA
13901 ADDR and return the VMA of the next entry. */
13902
13903static bfd_vma
2cf0635d 13904print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13905{
13906 printf (" ");
13907 print_vma (addr, LONG_HEX);
13908 printf (" ");
13909 if (data == NULL)
2b692964 13910 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13911 else
13912 {
13913 bfd_vma entry;
13914
13915 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13916 print_vma (entry, LONG_HEX);
13917 }
13918 return addr + (is_32bit_elf ? 4 : 8);
13919}
13920
351cdf24
MF		 13921static void
13922print_mips_ases (unsigned int mask)
13923{
13924 if (mask & AFL_ASE_DSP)
13925 fputs ("\n\tDSP ASE", stdout);
13926 if (mask & AFL_ASE_DSPR2)
13927 fputs ("\n\tDSP R2 ASE", stdout);
13928 if (mask & AFL_ASE_EVA)
13929 fputs ("\n\tEnhanced VA Scheme", stdout);
13930 if (mask & AFL_ASE_MCU)
13931 fputs ("\n\tMCU (MicroController) ASE", stdout);
13932 if (mask & AFL_ASE_MDMX)
13933 fputs ("\n\tMDMX ASE", stdout);
13934 if (mask & AFL_ASE_MIPS3D)
13935 fputs ("\n\tMIPS-3D ASE", stdout);
13936 if (mask & AFL_ASE_MT)
13937 fputs ("\n\tMT ASE", stdout);
13938 if (mask & AFL_ASE_SMARTMIPS)
13939 fputs ("\n\tSmartMIPS ASE", stdout);
13940 if (mask & AFL_ASE_VIRT)
13941 fputs ("\n\tVZ ASE", stdout);
13942 if (mask & AFL_ASE_MSA)
13943 fputs ("\n\tMSA ASE", stdout);
13944 if (mask & AFL_ASE_MIPS16)
13945 fputs ("\n\tMIPS16 ASE", stdout);
13946 if (mask & AFL_ASE_MICROMIPS)
13947 fputs ("\n\tMICROMIPS ASE", stdout);
13948 if (mask & AFL_ASE_XPA)
13949 fputs ("\n\tXPA ASE", stdout);
13950 if (mask == 0)
13951 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13952 else if ((mask & ~AFL_ASE_MASK) != 0)
13953 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13954}
13955
13956static void
13957print_mips_isa_ext (unsigned int isa_ext)
13958{
13959 switch (isa_ext)
13960 {
13961 case 0:
13962 fputs (_("None"), stdout);
13963 break;
13964 case AFL_EXT_XLR:
13965 fputs ("RMI XLR", stdout);
13966 break;
2c629856
N		 13967 case AFL_EXT_OCTEON3:
13968 fputs ("Cavium Networks Octeon3", stdout);
13969 break;
351cdf24
MF		 13970 case AFL_EXT_OCTEON2:
13971 fputs ("Cavium Networks Octeon2", stdout);
13972 break;
13973 case AFL_EXT_OCTEONP:
13974 fputs ("Cavium Networks OcteonP", stdout);
13975 break;
13976 case AFL_EXT_LOONGSON_3A:
13977 fputs ("Loongson 3A", stdout);
13978 break;
13979 case AFL_EXT_OCTEON:
13980 fputs ("Cavium Networks Octeon", stdout);
13981 break;
13982 case AFL_EXT_5900:
13983 fputs ("Toshiba R5900", stdout);
13984 break;
13985 case AFL_EXT_4650:
13986 fputs ("MIPS R4650", stdout);
13987 break;
13988 case AFL_EXT_4010:
13989 fputs ("LSI R4010", stdout);
13990 break;
13991 case AFL_EXT_4100:
13992 fputs ("NEC VR4100", stdout);
13993 break;
13994 case AFL_EXT_3900:
13995 fputs ("Toshiba R3900", stdout);
13996 break;
13997 case AFL_EXT_10000:
13998 fputs ("MIPS R10000", stdout);
13999 break;
14000 case AFL_EXT_SB1:
14001 fputs ("Broadcom SB-1", stdout);
14002 break;
14003 case AFL_EXT_4111:
14004 fputs ("NEC VR4111/VR4181", stdout);
14005 break;
14006 case AFL_EXT_4120:
14007 fputs ("NEC VR4120", stdout);
14008 break;
14009 case AFL_EXT_5400:
14010 fputs ("NEC VR5400", stdout);
14011 break;
14012 case AFL_EXT_5500:
14013 fputs ("NEC VR5500", stdout);
14014 break;
14015 case AFL_EXT_LOONGSON_2E:
14016 fputs ("ST Microelectronics Loongson 2E", stdout);
14017 break;
14018 case AFL_EXT_LOONGSON_2F:
14019 fputs ("ST Microelectronics Loongson 2F", stdout);
14020 break;
14021 default:
00ac7aa0 14022 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14023 }
14024}
14025
14026static int
14027get_mips_reg_size (int reg_size)
14028{
14029 return (reg_size == AFL_REG_NONE) ? 0
14030 : (reg_size == AFL_REG_32) ? 32
14031 : (reg_size == AFL_REG_64) ? 64
14032 : (reg_size == AFL_REG_128) ? 128
14033 : -1;
14034}
14035
19e6b90e 14036static int
2cf0635d 14037process_mips_specific (FILE * file)
5b18a4bc 14038{
2cf0635d 14039 Elf_Internal_Dyn * entry;
351cdf24 14040 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14041 size_t liblist_offset = 0;
14042 size_t liblistno = 0;
14043 size_t conflictsno = 0;
14044 size_t options_offset = 0;
14045 size_t conflicts_offset = 0;
861fb55a
DJ		 14046 size_t pltrelsz = 0;
14047 size_t pltrel = 0;
ccb4c951 14048 bfd_vma pltgot = 0;
861fb55a
DJ		 14049 bfd_vma mips_pltgot = 0;
14050 bfd_vma jmprel = 0;
ccb4c951
RS		 14051 bfd_vma local_gotno = 0;
14052 bfd_vma gotsym = 0;
14053 bfd_vma symtabno = 0;
103f02d3 14054
2cf19d5c
JM		 14055 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14056 display_mips_gnu_attribute);
14057
351cdf24
MF		 14058 sect = find_section (".MIPS.abiflags");
14059
14060 if (sect != NULL)
14061 {
14062 Elf_External_ABIFlags_v0 *abiflags_ext;
14063 Elf_Internal_ABIFlags_v0 abiflags_in;
14064
14065 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14066 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14067 else
14068 {
14069 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14070 sect->sh_size, _("MIPS ABI Flags section"));
14071 if (abiflags_ext)
14072 {
14073 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14074 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14075 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14076 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14077 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14078 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14079 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14080 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14081 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14082 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14083 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14084
14085 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14086 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14087 if (abiflags_in.isa_rev > 1)
14088 printf ("r%d", abiflags_in.isa_rev);
14089 printf ("\nGPR size: %d",
14090 get_mips_reg_size (abiflags_in.gpr_size));
14091 printf ("\nCPR1 size: %d",
14092 get_mips_reg_size (abiflags_in.cpr1_size));
14093 printf ("\nCPR2 size: %d",
14094 get_mips_reg_size (abiflags_in.cpr2_size));
14095 fputs ("\nFP ABI: ", stdout);
14096 print_mips_fp_abi_value (abiflags_in.fp_abi);
14097 fputs ("ISA Extension: ", stdout);
14098 print_mips_isa_ext (abiflags_in.isa_ext);
14099 fputs ("\nASEs:", stdout);
14100 print_mips_ases (abiflags_in.ases);
14101 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14102 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14103 fputc ('\n', stdout);
14104 free (abiflags_ext);
14105 }
14106 }
14107 }
14108
19e6b90e
L		 14109 /* We have a lot of special sections. Thanks SGI! */
14110 if (dynamic_section == NULL)
14111 /* No information available. */
14112 return 0;
252b5132 14113
071436c6
NC		 14114 for (entry = dynamic_section;
14115 /* PR 17531 file: 012-50589-0.004. */
14116 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14117 ++entry)
252b5132
RH		 14118 switch (entry->d_tag)
14119 {
14120 case DT_MIPS_LIBLIST:
d93f0186
NC		 14121 liblist_offset
14122 = offset_from_vma (file, entry->d_un.d_val,
14123 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14124 break;
14125 case DT_MIPS_LIBLISTNO:
14126 liblistno = entry->d_un.d_val;
14127 break;
14128 case DT_MIPS_OPTIONS:
d93f0186 14129 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14130 break;
14131 case DT_MIPS_CONFLICT:
d93f0186
NC		 14132 conflicts_offset
14133 = offset_from_vma (file, entry->d_un.d_val,
14134 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14135 break;
14136 case DT_MIPS_CONFLICTNO:
14137 conflictsno = entry->d_un.d_val;
14138 break;
ccb4c951 14139 case DT_PLTGOT:
861fb55a
DJ		 14140 pltgot = entry->d_un.d_ptr;
14141 break;
ccb4c951
RS		 14142 case DT_MIPS_LOCAL_GOTNO:
14143 local_gotno = entry->d_un.d_val;
14144 break;
14145 case DT_MIPS_GOTSYM:
14146 gotsym = entry->d_un.d_val;
14147 break;
14148 case DT_MIPS_SYMTABNO:
14149 symtabno = entry->d_un.d_val;
14150 break;
861fb55a
DJ		 14151 case DT_MIPS_PLTGOT:
14152 mips_pltgot = entry->d_un.d_ptr;
14153 break;
14154 case DT_PLTREL:
14155 pltrel = entry->d_un.d_val;
14156 break;
14157 case DT_PLTRELSZ:
14158 pltrelsz = entry->d_un.d_val;
14159 break;
14160 case DT_JMPREL:
14161 jmprel = entry->d_un.d_ptr;
14162 break;
252b5132
RH		 14163 default:
14164 break;
14165 }
14166
14167 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14168 {
2cf0635d 14169 Elf32_External_Lib * elib;
252b5132
RH		 14170 size_t cnt;
14171
3f5e193b
NC		 14172 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14173 liblistno,
14174 sizeof (Elf32_External_Lib),
9cf03b7e 14175 _("liblist section data"));
a6e9f9df 14176 if (elib)
252b5132 14177 {
2b692964 14178 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14179 (unsigned long) liblistno);
2b692964 14180 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14181 stdout);
14182
14183 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14184 {
a6e9f9df 14185 Elf32_Lib liblist;
91d6fa6a 14186 time_t atime;
a6e9f9df 14187 char timebuf[20];
2cf0635d 14188 struct tm * tmp;
a6e9f9df
AM		 14189
14190 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14191 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14192 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14193 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14194 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14195
91d6fa6a 14196 tmp = gmtime (&atime);
e9e44622
JJ		 14197 snprintf (timebuf, sizeof (timebuf),
14198 "%04u-%02u-%02uT%02u:%02u:%02u",
14199 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14200 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14201
31104126 14202 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14203 if (VALID_DYNAMIC_NAME (liblist.l_name))
14204 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14205 else
2b692964 14206 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14207 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14208 liblist.l_version);
a6e9f9df
AM		 14209
14210 if (liblist.l_flags == 0)
2b692964 14211 puts (_(" NONE"));
a6e9f9df
AM		 14212 else
14213 {
14214 static const struct
252b5132 14215 {
2cf0635d 14216 const char * name;
a6e9f9df 14217 int bit;
252b5132 14218 }
a6e9f9df
AM		 14219 l_flags_vals[] =
14220 {
14221 { " EXACT_MATCH", LL_EXACT_MATCH },
14222 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14223 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14224 { " EXPORTS", LL_EXPORTS },
14225 { " DELAY_LOAD", LL_DELAY_LOAD },
14226 { " DELTA", LL_DELTA }
14227 };
14228 int flags = liblist.l_flags;
14229 size_t fcnt;
14230
60bca95a 14231 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14232 if ((flags & l_flags_vals[fcnt].bit) != 0)
14233 {
14234 fputs (l_flags_vals[fcnt].name, stdout);
14235 flags ^= l_flags_vals[fcnt].bit;
14236 }
14237 if (flags != 0)
14238 printf (" %#x", (unsigned int) flags);
252b5132 14239
a6e9f9df
AM		 14240 puts ("");
14241 }
252b5132 14242 }
252b5132 14243
a6e9f9df
AM		 14244 free (elib);
14245 }
252b5132
RH		 14246 }
14247
14248 if (options_offset != 0)
14249 {
2cf0635d 14250 Elf_External_Options * eopt;
2cf0635d
NC		 14251 Elf_Internal_Options * iopt;
14252 Elf_Internal_Options * option;
252b5132
RH		 14253 size_t offset;
14254 int cnt;
351cdf24 14255 sect = section_headers;
252b5132
RH		 14256
14257 /* Find the section header so that we get the size. */
071436c6 14258 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14259 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14260 if (sect == NULL)
14261 {
14262 error (_("No MIPS_OPTIONS header found\n"));
14263 return 0;
14264 }
252b5132 14265
3f5e193b
NC		 14266 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14267 sect->sh_size, _("options"));
a6e9f9df 14268 if (eopt)
252b5132 14269 {
3f5e193b
NC		 14270 iopt = (Elf_Internal_Options *)
14271 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14272 if (iopt == NULL)
14273 {
8b73c356 14274 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14275 return 0;
14276 }
76da6bbe 14277
a6e9f9df
AM		 14278 offset = cnt = 0;
14279 option = iopt;
252b5132 14280
82b1b41b 14281 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14282 {
2cf0635d 14283 Elf_External_Options * eoption;
252b5132 14284
a6e9f9df 14285 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14286
a6e9f9df
AM		 14287 option->kind = BYTE_GET (eoption->kind);
14288 option->size = BYTE_GET (eoption->size);
14289 option->section = BYTE_GET (eoption->section);
14290 option->info = BYTE_GET (eoption->info);
76da6bbe 14291
82b1b41b
NC		 14292 /* PR 17531: file: ffa0fa3b. */
14293 if (option->size < sizeof (* eopt)
14294 || offset + option->size > sect->sh_size)
14295 {
55325047
NC		 14296 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14297 return 0;
82b1b41b 14298 }
a6e9f9df 14299 offset += option->size;
82b1b41b 14300
a6e9f9df
AM		 14301 ++option;
14302 ++cnt;
14303 }
252b5132 14304
a6e9f9df 14305 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14306 printable_section_name (sect), cnt);
76da6bbe 14307
a6e9f9df 14308 option = iopt;
82b1b41b 14309 offset = 0;
252b5132 14310
a6e9f9df 14311 while (cnt-- > 0)
252b5132 14312 {
a6e9f9df
AM		 14313 size_t len;
14314
14315 switch (option->kind)
252b5132 14316 {
a6e9f9df
AM		 14317 case ODK_NULL:
14318 /* This shouldn't happen. */
14319 printf (" NULL %d %lx", option->section, option->info);
14320 break;
14321 case ODK_REGINFO:
14322 printf (" REGINFO ");
14323 if (elf_header.e_machine == EM_MIPS)
14324 {
14325 /* 32bit form. */
2cf0635d 14326 Elf32_External_RegInfo * ereg;
b34976b6 14327 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14328
14329 ereg = (Elf32_External_RegInfo *) (option + 1);
14330 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14331 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14332 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14333 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14334 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14335 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14336
14337 printf ("GPR %08lx GP 0x%lx\n",
14338 reginfo.ri_gprmask,
14339 (unsigned long) reginfo.ri_gp_value);
14340 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14341 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14342 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14343 }
14344 else
14345 {
14346 /* 64 bit form. */
2cf0635d 14347 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14348 Elf64_Internal_RegInfo reginfo;
14349
14350 ereg = (Elf64_External_RegInfo *) (option + 1);
14351 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14352 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14353 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14354 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14355 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14356 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14357
14358 printf ("GPR %08lx GP 0x",
14359 reginfo.ri_gprmask);
14360 printf_vma (reginfo.ri_gp_value);
14361 printf ("\n");
14362
14363 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14364 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14365 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14366 }
14367 ++option;
14368 continue;
14369 case ODK_EXCEPTIONS:
14370 fputs (" EXCEPTIONS fpe_min(", stdout);
14371 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14372 fputs (") fpe_max(", stdout);
14373 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14374 fputs (")", stdout);
14375
14376 if (option->info & OEX_PAGE0)
14377 fputs (" PAGE0", stdout);
14378 if (option->info & OEX_SMM)
14379 fputs (" SMM", stdout);
14380 if (option->info & OEX_FPDBUG)
14381 fputs (" FPDBUG", stdout);
14382 if (option->info & OEX_DISMISS)
14383 fputs (" DISMISS", stdout);
14384 break;
14385 case ODK_PAD:
14386 fputs (" PAD ", stdout);
14387 if (option->info & OPAD_PREFIX)
14388 fputs (" PREFIX", stdout);
14389 if (option->info & OPAD_POSTFIX)
14390 fputs (" POSTFIX", stdout);
14391 if (option->info & OPAD_SYMBOL)
14392 fputs (" SYMBOL", stdout);
14393 break;
14394 case ODK_HWPATCH:
14395 fputs (" HWPATCH ", stdout);
14396 if (option->info & OHW_R4KEOP)
14397 fputs (" R4KEOP", stdout);
14398 if (option->info & OHW_R8KPFETCH)
14399 fputs (" R8KPFETCH", stdout);
14400 if (option->info & OHW_R5KEOP)
14401 fputs (" R5KEOP", stdout);
14402 if (option->info & OHW_R5KCVTL)
14403 fputs (" R5KCVTL", stdout);
14404 break;
14405 case ODK_FILL:
14406 fputs (" FILL ", stdout);
14407 /* XXX Print content of info word? */
14408 break;
14409 case ODK_TAGS:
14410 fputs (" TAGS ", stdout);
14411 /* XXX Print content of info word? */
14412 break;
14413 case ODK_HWAND:
14414 fputs (" HWAND ", stdout);
14415 if (option->info & OHWA0_R4KEOP_CHECKED)
14416 fputs (" R4KEOP_CHECKED", stdout);
14417 if (option->info & OHWA0_R4KEOP_CLEAN)
14418 fputs (" R4KEOP_CLEAN", stdout);
14419 break;
14420 case ODK_HWOR:
14421 fputs (" HWOR ", stdout);
14422 if (option->info & OHWA0_R4KEOP_CHECKED)
14423 fputs (" R4KEOP_CHECKED", stdout);
14424 if (option->info & OHWA0_R4KEOP_CLEAN)
14425 fputs (" R4KEOP_CLEAN", stdout);
14426 break;
14427 case ODK_GP_GROUP:
14428 printf (" GP_GROUP %#06lx self-contained %#06lx",
14429 option->info & OGP_GROUP,
14430 (option->info & OGP_SELF) >> 16);
14431 break;
14432 case ODK_IDENT:
14433 printf (" IDENT %#06lx self-contained %#06lx",
14434 option->info & OGP_GROUP,
14435 (option->info & OGP_SELF) >> 16);
14436 break;
14437 default:
14438 /* This shouldn't happen. */
14439 printf (" %3d ??? %d %lx",
14440 option->kind, option->section, option->info);
14441 break;
252b5132 14442 }
a6e9f9df 14443
2cf0635d 14444 len = sizeof (* eopt);
a6e9f9df 14445 while (len < option->size)
82b1b41b
NC		 14446 {
14447 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14448
82b1b41b
NC		 14449 if (ISPRINT (datum))
14450 printf ("%c", datum);
14451 else
14452 printf ("\\%03o", datum);
14453 len ++;
14454 }
a6e9f9df 14455 fputs ("\n", stdout);
82b1b41b
NC		 14456
14457 offset += option->size;
252b5132 14458 ++option;
252b5132
RH		 14459 }
14460
a6e9f9df 14461 free (eopt);
252b5132 14462 }
252b5132
RH		 14463 }
14464
14465 if (conflicts_offset != 0 && conflictsno != 0)
14466 {
2cf0635d 14467 Elf32_Conflict * iconf;
252b5132
RH		 14468 size_t cnt;
14469
14470 if (dynamic_symbols == NULL)
14471 {
591a748a 14472 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14473 return 0;
14474 }
14475
3f5e193b 14476 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14477 if (iconf == NULL)
14478 {
8b73c356 14479 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14480 return 0;
14481 }
14482
9ea033b2 14483 if (is_32bit_elf)
252b5132 14484 {
2cf0635d 14485 Elf32_External_Conflict * econf32;
a6e9f9df 14486
3f5e193b
NC		 14487 econf32 = (Elf32_External_Conflict *)
14488 get_data (NULL, file, conflicts_offset, conflictsno,
14489 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14490 if (!econf32)
14491 return 0;
252b5132
RH		 14492
14493 for (cnt = 0; cnt < conflictsno; ++cnt)
14494 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14495
14496 free (econf32);
252b5132
RH		 14497 }
14498 else
14499 {
2cf0635d 14500 Elf64_External_Conflict * econf64;
a6e9f9df 14501
3f5e193b
NC		 14502 econf64 = (Elf64_External_Conflict *)
14503 get_data (NULL, file, conflicts_offset, conflictsno,
14504 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14505 if (!econf64)
14506 return 0;
252b5132
RH		 14507
14508 for (cnt = 0; cnt < conflictsno; ++cnt)
14509 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14510
14511 free (econf64);
252b5132
RH		 14512 }
14513
c7e7ca54
NC		 14514 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14515 (unsigned long) conflictsno);
252b5132
RH		 14516 puts (_(" Num: Index Value Name"));
14517
14518 for (cnt = 0; cnt < conflictsno; ++cnt)
14519 {
b34976b6 14520 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14521
14522 if (iconf[cnt] >= num_dynamic_syms)
14523 printf (_("<corrupt symbol index>"));
d79b3d50 14524 else
e0a31db1
NC		 14525 {
14526 Elf_Internal_Sym * psym;
14527
14528 psym = & dynamic_symbols[iconf[cnt]];
14529 print_vma (psym->st_value, FULL_HEX);
14530 putchar (' ');
14531 if (VALID_DYNAMIC_NAME (psym->st_name))
14532 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14533 else
14534 printf (_("<corrupt: %14ld>"), psym->st_name);
14535 }
31104126 14536 putchar ('\n');
252b5132
RH		 14537 }
14538
252b5132
RH		 14539 free (iconf);
14540 }
14541
ccb4c951
RS		 14542 if (pltgot != 0 && local_gotno != 0)
14543 {
91d6fa6a 14544 bfd_vma ent, local_end, global_end;
bbeee7ea 14545 size_t i, offset;
2cf0635d 14546 unsigned char * data;
82b1b41b 14547 unsigned char * data_end;
bbeee7ea 14548 int addr_size;
ccb4c951 14549
91d6fa6a 14550 ent = pltgot;
ccb4c951
RS		 14551 addr_size = (is_32bit_elf ? 4 : 8);
14552 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14553
74e1a04b
NC		 14554 /* PR binutils/17533 file: 012-111227-0.004 */
14555 if (symtabno < gotsym)
14556 {
14557 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14558 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14559 return 0;
14560 }
82b1b41b 14561
74e1a04b 14562 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14563 /* PR 17531: file: 54c91a34. */
14564 if (global_end < local_end)
14565 {
14566 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14567 return 0;
14568 }
948f632f 14569
ccb4c951 14570 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14571 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14572 global_end - pltgot, 1,
14573 _("Global Offset Table data"));
59245841
NC		 14574 if (data == NULL)
14575 return 0;
82b1b41b 14576 data_end = data + (global_end - pltgot);
59245841 14577
ccb4c951
RS		 14578 printf (_("\nPrimary GOT:\n"));
14579 printf (_(" Canonical gp value: "));
14580 print_vma (pltgot + 0x7ff0, LONG_HEX);
14581 printf ("\n\n");
14582
14583 printf (_(" Reserved entries:\n"));
14584 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14585 addr_size * 2, _("Address"), _("Access"),
14586 addr_size * 2, _("Initial"));
82b1b41b 14587 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14588 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14589 if (ent == (bfd_vma) -1)
14590 goto got_print_fail;
ccb4c951 14591 if (data
91d6fa6a 14592 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14593 >> (addr_size * 8 - 1)) != 0)
14594 {
82b1b41b 14595 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14596 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14597 if (ent == (bfd_vma) -1)
14598 goto got_print_fail;
ccb4c951
RS		 14599 }
14600 printf ("\n");
14601
91d6fa6a 14602 if (ent < local_end)
ccb4c951
RS		 14603 {
14604 printf (_(" Local entries:\n"));
cc5914eb 14605 printf (" %*s %10s %*s\n",
2b692964
NC		 14606 addr_size * 2, _("Address"), _("Access"),
14607 addr_size * 2, _("Initial"));
91d6fa6a 14608 while (ent < local_end)
ccb4c951 14609 {
82b1b41b 14610 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14611 printf ("\n");
82b1b41b
NC		 14612 if (ent == (bfd_vma) -1)
14613 goto got_print_fail;
ccb4c951
RS		 14614 }
14615 printf ("\n");
14616 }
14617
14618 if (gotsym < symtabno)
14619 {
14620 int sym_width;
14621
14622 printf (_(" Global entries:\n"));
cc5914eb 14623 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14624 addr_size * 2, _("Address"),
14625 _("Access"),
2b692964 14626 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14627 addr_size * 2, _("Sym.Val."),
14628 _("Type"),
14629 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14630 _("Ndx"), _("Name"));
0b4362b0 14631
ccb4c951 14632 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14633
ccb4c951
RS		 14634 for (i = gotsym; i < symtabno; i++)
14635 {
82b1b41b 14636 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14637 printf (" ");
e0a31db1
NC		 14638
14639 if (dynamic_symbols == NULL)
14640 printf (_("<no dynamic symbols>"));
14641 else if (i < num_dynamic_syms)
14642 {
14643 Elf_Internal_Sym * psym = dynamic_symbols + i;
14644
14645 print_vma (psym->st_value, LONG_HEX);
14646 printf (" %-7s %3s ",
14647 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14648 get_symbol_index_type (psym->st_shndx));
14649
14650 if (VALID_DYNAMIC_NAME (psym->st_name))
14651 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14652 else
14653 printf (_("<corrupt: %14ld>"), psym->st_name);
14654 }
ccb4c951 14655 else
7fc5ac57
JBG		 14656 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14657 (unsigned long) i);
e0a31db1 14658
ccb4c951 14659 printf ("\n");
82b1b41b
NC		 14660 if (ent == (bfd_vma) -1)
14661 break;
ccb4c951
RS		 14662 }
14663 printf ("\n");
14664 }
14665
82b1b41b 14666 got_print_fail:
ccb4c951
RS		 14667 if (data)
14668 free (data);
14669 }
14670
861fb55a
DJ		 14671 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14672 {
91d6fa6a 14673 bfd_vma ent, end;
861fb55a
DJ		 14674 size_t offset, rel_offset;
14675 unsigned long count, i;
2cf0635d 14676 unsigned char * data;
861fb55a 14677 int addr_size, sym_width;
2cf0635d 14678 Elf_Internal_Rela * rels;
861fb55a
DJ		 14679
14680 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14681 if (pltrel == DT_RELA)
14682 {
14683 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14684 return 0;
14685 }
14686 else
14687 {
14688 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14689 return 0;
14690 }
14691
91d6fa6a 14692 ent = mips_pltgot;
861fb55a
DJ		 14693 addr_size = (is_32bit_elf ? 4 : 8);
14694 end = mips_pltgot + (2 + count) * addr_size;
14695
14696 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14697 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14698 1, _("Procedure Linkage Table data"));
59245841
NC		 14699 if (data == NULL)
14700 return 0;
14701
9cf03b7e 14702 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14703 printf (_(" Reserved entries:\n"));
14704 printf (_(" %*s %*s Purpose\n"),
2b692964 14705 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14706 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14707 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14708 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14709 printf (_(" Module pointer\n"));
861fb55a
DJ		 14710 printf ("\n");
14711
14712 printf (_(" Entries:\n"));
cc5914eb 14713 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14714 addr_size * 2, _("Address"),
14715 addr_size * 2, _("Initial"),
14716 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14717 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14718 for (i = 0; i < count; i++)
14719 {
df97ab2a 14720 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14721
91d6fa6a 14722 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14723 printf (" ");
e0a31db1 14724
df97ab2a
MF		 14725 if (idx >= num_dynamic_syms)
14726 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14727 else
e0a31db1 14728 {
df97ab2a 14729 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14730
14731 print_vma (psym->st_value, LONG_HEX);
14732 printf (" %-7s %3s ",
14733 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14734 get_symbol_index_type (psym->st_shndx));
14735 if (VALID_DYNAMIC_NAME (psym->st_name))
14736 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14737 else
14738 printf (_("<corrupt: %14ld>"), psym->st_name);
14739 }
861fb55a
DJ		 14740 printf ("\n");
14741 }
14742 printf ("\n");
14743
14744 if (data)
14745 free (data);
14746 free (rels);
14747 }
14748
252b5132
RH		 14749 return 1;
14750}
14751
35c08157
KLC		 14752static int
14753process_nds32_specific (FILE * file)
14754{
14755 Elf_Internal_Shdr *sect = NULL;
14756
14757 sect = find_section (".nds32_e_flags");
14758 if (sect != NULL)
14759 {
14760 unsigned int *flag;
14761
14762 printf ("\nNDS32 elf flags section:\n");
14763 flag = get_data (NULL, file, sect->sh_offset, 1,
14764 sect->sh_size, _("NDS32 elf flags section"));
14765
14766 switch ((*flag) & 0x3)
14767 {
14768 case 0:
14769 printf ("(VEC_SIZE):\tNo entry.\n");
14770 break;
14771 case 1:
14772 printf ("(VEC_SIZE):\t4 bytes\n");
14773 break;
14774 case 2:
14775 printf ("(VEC_SIZE):\t16 bytes\n");
14776 break;
14777 case 3:
14778 printf ("(VEC_SIZE):\treserved\n");
14779 break;
14780 }
14781 }
14782
14783 return TRUE;
14784}
14785
047b2264 14786static int
2cf0635d 14787process_gnu_liblist (FILE * file)
047b2264 14788{
2cf0635d
NC		 14789 Elf_Internal_Shdr * section;
14790 Elf_Internal_Shdr * string_sec;
14791 Elf32_External_Lib * elib;
14792 char * strtab;
c256ffe7 14793 size_t strtab_size;
047b2264
JJ		 14794 size_t cnt;
14795 unsigned i;
14796
14797 if (! do_arch)
14798 return 0;
14799
14800 for (i = 0, section = section_headers;
14801 i < elf_header.e_shnum;
b34976b6 14802 i++, section++)
047b2264
JJ		 14803 {
14804 switch (section->sh_type)
14805 {
14806 case SHT_GNU_LIBLIST:
4fbb74a6 14807 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14808 break;
14809
3f5e193b
NC		 14810 elib = (Elf32_External_Lib *)
14811 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14812 _("liblist section data"));
047b2264
JJ		 14813
14814 if (elib == NULL)
14815 break;
4fbb74a6 14816 string_sec = section_headers + section->sh_link;
047b2264 14817
3f5e193b
NC		 14818 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14819 string_sec->sh_size,
14820 _("liblist string table"));
047b2264
JJ		 14821 if (strtab == NULL
14822 || section->sh_entsize != sizeof (Elf32_External_Lib))
14823 {
14824 free (elib);
2842702f 14825 free (strtab);
047b2264
JJ		 14826 break;
14827 }
59245841 14828 strtab_size = string_sec->sh_size;
047b2264
JJ		 14829
14830 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14831 printable_section_name (section),
0af1713e 14832 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14833
2b692964 14834 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14835
14836 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14837 ++cnt)
14838 {
14839 Elf32_Lib liblist;
91d6fa6a 14840 time_t atime;
047b2264 14841 char timebuf[20];
2cf0635d 14842 struct tm * tmp;
047b2264
JJ		 14843
14844 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14845 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14846 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14847 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14848 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14849
91d6fa6a 14850 tmp = gmtime (&atime);
e9e44622
JJ		 14851 snprintf (timebuf, sizeof (timebuf),
14852 "%04u-%02u-%02uT%02u:%02u:%02u",
14853 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14854 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14855
14856 printf ("%3lu: ", (unsigned long) cnt);
14857 if (do_wide)
c256ffe7 14858 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14859 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14860 else
c256ffe7 14861 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14862 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14863 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14864 liblist.l_version, liblist.l_flags);
14865 }
14866
14867 free (elib);
2842702f 14868 free (strtab);
047b2264
JJ		 14869 }
14870 }
14871
14872 return 1;
14873}
14874
9437c45b 14875static const char *
d3ba0551 14876get_note_type (unsigned e_type)
779fe533
NC		 14877{
14878 static char buff[64];
103f02d3 14879
1ec5cd37
NC		 14880 if (elf_header.e_type == ET_CORE)
14881 switch (e_type)
14882 {
57346661 14883 case NT_AUXV:
1ec5cd37 14884 return _("NT_AUXV (auxiliary vector)");
57346661 14885 case NT_PRSTATUS:
1ec5cd37 14886 return _("NT_PRSTATUS (prstatus structure)");
57346661 14887 case NT_FPREGSET:
1ec5cd37 14888 return _("NT_FPREGSET (floating point registers)");
57346661 14889 case NT_PRPSINFO:
1ec5cd37 14890 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14891 case NT_TASKSTRUCT:
1ec5cd37 14892 return _("NT_TASKSTRUCT (task structure)");
57346661 14893 case NT_PRXFPREG:
1ec5cd37 14894 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14895 case NT_PPC_VMX:
14896 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14897 case NT_PPC_VSX:
14898 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14899 case NT_386_TLS:
14900 return _("NT_386_TLS (x86 TLS information)");
14901 case NT_386_IOPERM:
14902 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14903 case NT_X86_XSTATE:
14904 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14905 case NT_S390_HIGH_GPRS:
14906 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14907 case NT_S390_TIMER:
14908 return _("NT_S390_TIMER (s390 timer register)");
14909 case NT_S390_TODCMP:
14910 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14911 case NT_S390_TODPREG:
14912 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14913 case NT_S390_CTRS:
14914 return _("NT_S390_CTRS (s390 control registers)");
14915 case NT_S390_PREFIX:
14916 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14917 case NT_S390_LAST_BREAK:
14918 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14919 case NT_S390_SYSTEM_CALL:
14920 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14921 case NT_S390_TDB:
14922 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14923 case NT_S390_VXRS_LOW:
14924 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14925 case NT_S390_VXRS_HIGH:
14926 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14927 case NT_ARM_VFP:
14928 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14929 case NT_ARM_TLS:
14930 return _("NT_ARM_TLS (AArch TLS registers)");
14931 case NT_ARM_HW_BREAK:
14932 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14933 case NT_ARM_HW_WATCH:
14934 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14935 case NT_PSTATUS:
1ec5cd37 14936 return _("NT_PSTATUS (pstatus structure)");
57346661 14937 case NT_FPREGS:
1ec5cd37 14938 return _("NT_FPREGS (floating point registers)");
57346661 14939 case NT_PSINFO:
1ec5cd37 14940 return _("NT_PSINFO (psinfo structure)");
57346661 14941 case NT_LWPSTATUS:
1ec5cd37 14942 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14943 case NT_LWPSINFO:
1ec5cd37 14944 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14945 case NT_WIN32PSTATUS:
1ec5cd37 14946 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14947 case NT_SIGINFO:
14948 return _("NT_SIGINFO (siginfo_t data)");
14949 case NT_FILE:
14950 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14951 default:
14952 break;
14953 }
14954 else
14955 switch (e_type)
14956 {
14957 case NT_VERSION:
14958 return _("NT_VERSION (version)");
14959 case NT_ARCH:
14960 return _("NT_ARCH (architecture)");
14961 default:
14962 break;
14963 }
14964
e9e44622 14965 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14966 return buff;
779fe533
NC		 14967}
14968
9ece1fa9
TT		 14969static int
14970print_core_note (Elf_Internal_Note *pnote)
14971{
14972 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14973 bfd_vma count, page_size;
14974 unsigned char *descdata, *filenames, *descend;
14975
14976 if (pnote->type != NT_FILE)
14977 return 1;
14978
14979#ifndef BFD64
14980 if (!is_32bit_elf)
14981 {
14982 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14983 /* Still "successful". */
14984 return 1;
14985 }
14986#endif
14987
14988 if (pnote->descsz < 2 * addr_size)
14989 {
14990 printf (_(" Malformed note - too short for header\n"));
14991 return 0;
14992 }
14993
14994 descdata = (unsigned char *) pnote->descdata;
14995 descend = descdata + pnote->descsz;
14996
14997 if (descdata[pnote->descsz - 1] != '\0')
14998 {
14999 printf (_(" Malformed note - does not end with \\0\n"));
15000 return 0;
15001 }
15002
15003 count = byte_get (descdata, addr_size);
15004 descdata += addr_size;
15005
15006 page_size = byte_get (descdata, addr_size);
15007 descdata += addr_size;
15008
15009 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15010 {
15011 printf (_(" Malformed note - too short for supplied file count\n"));
15012 return 0;
15013 }
15014
15015 printf (_(" Page size: "));
15016 print_vma (page_size, DEC);
15017 printf ("\n");
15018
15019 printf (_(" %*s%*s%*s\n"),
15020 (int) (2 + 2 * addr_size), _("Start"),
15021 (int) (4 + 2 * addr_size), _("End"),
15022 (int) (4 + 2 * addr_size), _("Page Offset"));
15023 filenames = descdata + count * 3 * addr_size;
15024 while (--count > 0)
15025 {
15026 bfd_vma start, end, file_ofs;
15027
15028 if (filenames == descend)
15029 {
15030 printf (_(" Malformed note - filenames end too early\n"));
15031 return 0;
15032 }
15033
15034 start = byte_get (descdata, addr_size);
15035 descdata += addr_size;
15036 end = byte_get (descdata, addr_size);
15037 descdata += addr_size;
15038 file_ofs = byte_get (descdata, addr_size);
15039 descdata += addr_size;
15040
15041 printf (" ");
15042 print_vma (start, FULL_HEX);
15043 printf (" ");
15044 print_vma (end, FULL_HEX);
15045 printf (" ");
15046 print_vma (file_ofs, FULL_HEX);
15047 printf ("\n %s\n", filenames);
15048
15049 filenames += 1 + strlen ((char *) filenames);
15050 }
15051
15052 return 1;
15053}
15054
1118d252
RM		 15055static const char *
15056get_gnu_elf_note_type (unsigned e_type)
15057{
15058 static char buff[64];
15059
15060 switch (e_type)
15061 {
15062 case NT_GNU_ABI_TAG:
15063 return _("NT_GNU_ABI_TAG (ABI version tag)");
15064 case NT_GNU_HWCAP:
15065 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15066 case NT_GNU_BUILD_ID:
15067 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15068 case NT_GNU_GOLD_VERSION:
15069 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15070 default:
15071 break;
15072 }
15073
15074 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15075 return buff;
15076}
15077
664f90a3
TT		 15078static int
15079print_gnu_note (Elf_Internal_Note *pnote)
15080{
15081 switch (pnote->type)
15082 {
15083 case NT_GNU_BUILD_ID:
15084 {
15085 unsigned long i;
15086
15087 printf (_(" Build ID: "));
15088 for (i = 0; i < pnote->descsz; ++i)
15089 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15090 printf ("\n");
664f90a3
TT		 15091 }
15092 break;
15093
15094 case NT_GNU_ABI_TAG:
15095 {
15096 unsigned long os, major, minor, subminor;
15097 const char *osname;
15098
3102e897
NC		 15099 /* PR 17531: file: 030-599401-0.004. */
15100 if (pnote->descsz < 16)
15101 {
15102 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15103 break;
15104 }
15105
664f90a3
TT		 15106 os = byte_get ((unsigned char *) pnote->descdata, 4);
15107 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15108 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15109 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15110
15111 switch (os)
15112 {
15113 case GNU_ABI_TAG_LINUX:
15114 osname = "Linux";
15115 break;
15116 case GNU_ABI_TAG_HURD:
15117 osname = "Hurd";
15118 break;
15119 case GNU_ABI_TAG_SOLARIS:
15120 osname = "Solaris";
15121 break;
15122 case GNU_ABI_TAG_FREEBSD:
15123 osname = "FreeBSD";
15124 break;
15125 case GNU_ABI_TAG_NETBSD:
15126 osname = "NetBSD";
15127 break;
15128 default:
15129 osname = "Unknown";
15130 break;
15131 }
15132
15133 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15134 major, minor, subminor);
15135 }
15136 break;
926c5385
CC		 15137
15138 case NT_GNU_GOLD_VERSION:
15139 {
15140 unsigned long i;
15141
15142 printf (_(" Version: "));
15143 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15144 printf ("%c", pnote->descdata[i]);
15145 printf ("\n");
15146 }
15147 break;
664f90a3
TT		 15148 }
15149
15150 return 1;
15151}
15152
685080f2
NC		 15153static const char *
15154get_v850_elf_note_type (enum v850_notes n_type)
15155{
15156 static char buff[64];
15157
15158 switch (n_type)
15159 {
15160 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15161 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15162 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15163 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15164 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15165 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15166 default:
15167 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15168 return buff;
15169 }
15170}
15171
15172static int
15173print_v850_note (Elf_Internal_Note * pnote)
15174{
15175 unsigned int val;
15176
15177 if (pnote->descsz != 4)
15178 return 0;
15179 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15180
15181 if (val == 0)
15182 {
15183 printf (_("not set\n"));
15184 return 1;
15185 }
15186
15187 switch (pnote->type)
15188 {
15189 case V850_NOTE_ALIGNMENT:
15190 switch (val)
15191 {
15192 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15193 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15194 }
15195 break;
15196
15197 case V850_NOTE_DATA_SIZE:
15198 switch (val)
15199 {
15200 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15201 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15202 }
15203 break;
15204
15205 case V850_NOTE_FPU_INFO:
15206 switch (val)
15207 {
15208 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15209 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15210 }
15211 break;
15212
15213 case V850_NOTE_MMU_INFO:
15214 case V850_NOTE_CACHE_INFO:
15215 case V850_NOTE_SIMD_INFO:
15216 if (val == EF_RH850_SIMD)
15217 {
15218 printf (_("yes\n"));
15219 return 1;
15220 }
15221 break;
15222
15223 default:
15224 /* An 'unknown note type' message will already have been displayed. */
15225 break;
15226 }
15227
15228 printf (_("unknown value: %x\n"), val);
15229 return 0;
15230}
15231
9437c45b 15232static const char *
d3ba0551 15233get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15234{
15235 static char buff[64];
15236
b4db1224 15237 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15238 {
15239 /* NetBSD core "procinfo" structure. */
15240 return _("NetBSD procinfo structure");
15241 }
15242
15243 /* As of Jan 2002 there are no other machine-independent notes
15244 defined for NetBSD core files. If the note type is less
15245 than the start of the machine-dependent note types, we don't
15246 understand it. */
15247
b4db1224 15248 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15249 {
e9e44622 15250 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15251 return buff;
15252 }
15253
15254 switch (elf_header.e_machine)
15255 {
15256 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15257 and PT_GETFPREGS == mach+2. */
15258
15259 case EM_OLD_ALPHA:
15260 case EM_ALPHA:
15261 case EM_SPARC:
15262 case EM_SPARC32PLUS:
15263 case EM_SPARCV9:
15264 switch (e_type)
15265 {
2b692964 15266 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15267 return _("PT_GETREGS (reg structure)");
2b692964 15268 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15269 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15270 default:
15271 break;
15272 }
15273 break;
15274
15275 /* On all other arch's, PT_GETREGS == mach+1 and
15276 PT_GETFPREGS == mach+3. */
15277 default:
15278 switch (e_type)
15279 {
2b692964 15280 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15281 return _("PT_GETREGS (reg structure)");
2b692964 15282 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15283 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15284 default:
15285 break;
15286 }
15287 }
15288
9cf03b7e 15289 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15290 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15291 return buff;
15292}
15293
70616151
TT		 15294static const char *
15295get_stapsdt_note_type (unsigned e_type)
15296{
15297 static char buff[64];
15298
15299 switch (e_type)
15300 {
15301 case NT_STAPSDT:
15302 return _("NT_STAPSDT (SystemTap probe descriptors)");
15303
15304 default:
15305 break;
15306 }
15307
15308 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15309 return buff;
15310}
15311
c6a9fc58
TT		 15312static int
15313print_stapsdt_note (Elf_Internal_Note *pnote)
15314{
15315 int addr_size = is_32bit_elf ? 4 : 8;
15316 char *data = pnote->descdata;
15317 char *data_end = pnote->descdata + pnote->descsz;
15318 bfd_vma pc, base_addr, semaphore;
15319 char *provider, *probe, *arg_fmt;
15320
15321 pc = byte_get ((unsigned char *) data, addr_size);
15322 data += addr_size;
15323 base_addr = byte_get ((unsigned char *) data, addr_size);
15324 data += addr_size;
15325 semaphore = byte_get ((unsigned char *) data, addr_size);
15326 data += addr_size;
15327
15328 provider = data;
15329 data += strlen (data) + 1;
15330 probe = data;
15331 data += strlen (data) + 1;
15332 arg_fmt = data;
15333 data += strlen (data) + 1;
15334
15335 printf (_(" Provider: %s\n"), provider);
15336 printf (_(" Name: %s\n"), probe);
15337 printf (_(" Location: "));
15338 print_vma (pc, FULL_HEX);
15339 printf (_(", Base: "));
15340 print_vma (base_addr, FULL_HEX);
15341 printf (_(", Semaphore: "));
15342 print_vma (semaphore, FULL_HEX);
9cf03b7e 15343 printf ("\n");
c6a9fc58
TT		 15344 printf (_(" Arguments: %s\n"), arg_fmt);
15345
15346 return data == data_end;
15347}
15348
00e98fc7
TG		 15349static const char *
15350get_ia64_vms_note_type (unsigned e_type)
15351{
15352 static char buff[64];
15353
15354 switch (e_type)
15355 {
15356 case NT_VMS_MHD:
15357 return _("NT_VMS_MHD (module header)");
15358 case NT_VMS_LNM:
15359 return _("NT_VMS_LNM (language name)");
15360 case NT_VMS_SRC:
15361 return _("NT_VMS_SRC (source files)");
15362 case NT_VMS_TITLE:
9cf03b7e 15363 return "NT_VMS_TITLE";
00e98fc7
TG		 15364 case NT_VMS_EIDC:
15365 return _("NT_VMS_EIDC (consistency check)");
15366 case NT_VMS_FPMODE:
15367 return _("NT_VMS_FPMODE (FP mode)");
15368 case NT_VMS_LINKTIME:
9cf03b7e 15369 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15370 case NT_VMS_IMGNAM:
15371 return _("NT_VMS_IMGNAM (image name)");
15372 case NT_VMS_IMGID:
15373 return _("NT_VMS_IMGID (image id)");
15374 case NT_VMS_LINKID:
15375 return _("NT_VMS_LINKID (link id)");
15376 case NT_VMS_IMGBID:
15377 return _("NT_VMS_IMGBID (build id)");
15378 case NT_VMS_GSTNAM:
15379 return _("NT_VMS_GSTNAM (sym table name)");
15380 case NT_VMS_ORIG_DYN:
9cf03b7e 15381 return "NT_VMS_ORIG_DYN";
00e98fc7 15382 case NT_VMS_PATCHTIME:
9cf03b7e 15383 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15384 default:
15385 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15386 return buff;
15387 }
15388}
15389
15390static int
15391print_ia64_vms_note (Elf_Internal_Note * pnote)
15392{
15393 switch (pnote->type)
15394 {
15395 case NT_VMS_MHD:
15396 if (pnote->descsz > 36)
15397 {
15398 size_t l = strlen (pnote->descdata + 34);
15399 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15400 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15401 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15402 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15403 }
15404 else
15405 printf (_(" Invalid size\n"));
15406 break;
15407 case NT_VMS_LNM:
15408 printf (_(" Language: %s\n"), pnote->descdata);
15409 break;
15410#ifdef BFD64
15411 case NT_VMS_FPMODE:
9cf03b7e 15412 printf (_(" Floating Point mode: "));
4a5cb34f 15413 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15414 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15415 break;
15416 case NT_VMS_LINKTIME:
15417 printf (_(" Link time: "));
15418 print_vms_time
15419 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15420 printf ("\n");
15421 break;
15422 case NT_VMS_PATCHTIME:
15423 printf (_(" Patch time: "));
15424 print_vms_time
15425 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15426 printf ("\n");
15427 break;
15428 case NT_VMS_ORIG_DYN:
15429 printf (_(" Major id: %u, minor id: %u\n"),
15430 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15431 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15432 printf (_(" Last modified : "));
00e98fc7
TG		 15433 print_vms_time
15434 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15435 printf (_("\n Link flags : "));
4a5cb34f 15436 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15437 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15438 printf (_(" Header flags: 0x%08x\n"),
948f632f 15439 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15440 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15441 break;
15442#endif
15443 case NT_VMS_IMGNAM:
15444 printf (_(" Image name: %s\n"), pnote->descdata);
15445 break;
15446 case NT_VMS_GSTNAM:
15447 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15448 break;
15449 case NT_VMS_IMGID:
15450 printf (_(" Image id: %s\n"), pnote->descdata);
15451 break;
15452 case NT_VMS_LINKID:
15453 printf (_(" Linker id: %s\n"), pnote->descdata);
15454 break;
15455 default:
15456 break;
15457 }
15458 return 1;
15459}
15460
6d118b09
NC		 15461/* Note that by the ELF standard, the name field is already null byte
15462 terminated, and namesz includes the terminating null byte.
15463 I.E. the value of namesz for the name "FSF" is 4.
15464
e3c8793a 15465 If the value of namesz is zero, there is no name present. */
779fe533 15466static int
2cf0635d 15467process_note (Elf_Internal_Note * pnote)
779fe533 15468{
2cf0635d
NC		 15469 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15470 const char * nt;
9437c45b
JT		 15471
15472 if (pnote->namesz == 0)
1ec5cd37
NC		 15473 /* If there is no note name, then use the default set of
15474 note type strings. */
15475 nt = get_note_type (pnote->type);
15476
1118d252
RM		 15477 else if (const_strneq (pnote->namedata, "GNU"))
15478 /* GNU-specific object file notes. */
15479 nt = get_gnu_elf_note_type (pnote->type);
15480
0112cd26 15481 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15482 /* NetBSD-specific core file notes. */
15483 nt = get_netbsd_elfcore_note_type (pnote->type);
15484
b15fa79e
AM		 15485 else if (strneq (pnote->namedata, "SPU/", 4))
15486 {
15487 /* SPU-specific core file notes. */
15488 nt = pnote->namedata + 4;
15489 name = "SPU";
15490 }
15491
00e98fc7
TG		 15492 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15493 /* VMS/ia64-specific file notes. */
15494 nt = get_ia64_vms_note_type (pnote->type);
15495
70616151
TT		 15496 else if (const_strneq (pnote->namedata, "stapsdt"))
15497 nt = get_stapsdt_note_type (pnote->type);
15498
9437c45b 15499 else
1ec5cd37
NC		 15500 /* Don't recognize this note name; just use the default set of
15501 note type strings. */
00e98fc7 15502 nt = get_note_type (pnote->type);
9437c45b 15503
2aee03ae 15504 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15505
15506 if (const_strneq (pnote->namedata, "IPF/VMS"))
15507 return print_ia64_vms_note (pnote);
664f90a3
TT		 15508 else if (const_strneq (pnote->namedata, "GNU"))
15509 return print_gnu_note (pnote);
c6a9fc58
TT		 15510 else if (const_strneq (pnote->namedata, "stapsdt"))
15511 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15512 else if (const_strneq (pnote->namedata, "CORE"))
15513 return print_core_note (pnote);
00e98fc7
TG		 15514 else
15515 return 1;
779fe533
NC		 15516}
15517
6d118b09 15518
779fe533 15519static int
2cf0635d 15520process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15521{
2cf0635d
NC		 15522 Elf_External_Note * pnotes;
15523 Elf_External_Note * external;
c8071705 15524 char * end;
b34976b6 15525 int res = 1;
103f02d3 15526
779fe533
NC		 15527 if (length <= 0)
15528 return 0;
103f02d3 15529
3f5e193b 15530 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15531 _("notes"));
dd24e3da 15532 if (pnotes == NULL)
a6e9f9df 15533 return 0;
779fe533 15534
103f02d3 15535 external = pnotes;
103f02d3 15536
9dd3a467 15537 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15538 (unsigned long) offset, (unsigned long) length);
2aee03ae 15539 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15540
c8071705
NC		 15541 end = (char *) pnotes + length;
15542 while ((char *) external < end)
779fe533 15543 {
b34976b6 15544 Elf_Internal_Note inote;
15b42fb0
AM		 15545 size_t min_notesz;
15546 char *next;
2cf0635d 15547 char * temp = NULL;
c8071705 15548 size_t data_remaining = end - (char *) external;
6d118b09 15549
00e98fc7 15550 if (!is_ia64_vms ())
15b42fb0 15551 {
9dd3a467
NC		 15552 /* PR binutils/15191
15553 Make sure that there is enough data to read. */
15b42fb0
AM		 15554 min_notesz = offsetof (Elf_External_Note, name);
15555 if (data_remaining < min_notesz)
9dd3a467
NC		 15556 {
15557 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15558 (int) data_remaining);
15559 break;
15560 }
15b42fb0
AM		 15561 inote.type = BYTE_GET (external->type);
15562 inote.namesz = BYTE_GET (external->namesz);
15563 inote.namedata = external->name;
15564 inote.descsz = BYTE_GET (external->descsz);
15565 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15566 /* PR 17531: file: 3443835e. */
c8071705 15567 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15568 {
15569 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15570 inote.descdata = inote.namedata;
15571 inote.namesz = 0;
15572 }
c8071705 15573
15b42fb0
AM		 15574 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15575 next = inote.descdata + align_power (inote.descsz, 2);
15576 }
00e98fc7 15577 else
15b42fb0
AM		 15578 {
15579 Elf64_External_VMS_Note *vms_external;
00e98fc7 15580
9dd3a467
NC		 15581 /* PR binutils/15191
15582 Make sure that there is enough data to read. */
15b42fb0
AM		 15583 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15584 if (data_remaining < min_notesz)
9dd3a467
NC		 15585 {
15586 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15587 (int) data_remaining);
15588 break;
15589 }
3e55a963 15590
15b42fb0
AM		 15591 vms_external = (Elf64_External_VMS_Note *) external;
15592 inote.type = BYTE_GET (vms_external->type);
15593 inote.namesz = BYTE_GET (vms_external->namesz);
15594 inote.namedata = vms_external->name;
15595 inote.descsz = BYTE_GET (vms_external->descsz);
15596 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15597 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15598 next = inote.descdata + align_power (inote.descsz, 3);
15599 }
15600
15601 if (inote.descdata < (char *) external + min_notesz
15602 || next < (char *) external + min_notesz
5d921cbd
NC		 15603 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15604 || inote.namedata + inote.namesz < inote.namedata
15605 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15606 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15607 {
15b42fb0 15608 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15609 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15610 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15611 inote.type, inote.namesz, inote.descsz);
15612 break;
15613 }
15614
15b42fb0 15615 external = (Elf_External_Note *) next;
dd24e3da 15616
6d118b09
NC		 15617 /* Verify that name is null terminated. It appears that at least
15618 one version of Linux (RedHat 6.0) generates corefiles that don't
15619 comply with the ELF spec by failing to include the null byte in
15620 namesz. */
8b971f9f 15621 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15622 {
3f5e193b 15623 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15624 if (temp == NULL)
15625 {
8b73c356 15626 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15627 res = 0;
15628 break;
15629 }
76da6bbe 15630
6d118b09
NC		 15631 strncpy (temp, inote.namedata, inote.namesz);
15632 temp[inote.namesz] = 0;
76da6bbe 15633
6d118b09
NC		 15634 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15635 inote.namedata = temp;
15636 }
15637
15638 res &= process_note (& inote);
103f02d3 15639
6d118b09
NC		 15640 if (temp != NULL)
15641 {
15642 free (temp);
15643 temp = NULL;
15644 }
779fe533
NC		 15645 }
15646
15647 free (pnotes);
103f02d3 15648
779fe533
NC		 15649 return res;
15650}
15651
15652static int
2cf0635d 15653process_corefile_note_segments (FILE * file)
779fe533 15654{
2cf0635d 15655 Elf_Internal_Phdr * segment;
b34976b6
AM		 15656 unsigned int i;
15657 int res = 1;
103f02d3 15658
d93f0186 15659 if (! get_program_headers (file))
779fe533 15660 return 0;
103f02d3 15661
779fe533
NC		 15662 for (i = 0, segment = program_headers;
15663 i < elf_header.e_phnum;
b34976b6 15664 i++, segment++)
779fe533
NC		 15665 {
15666 if (segment->p_type == PT_NOTE)
103f02d3 15667 res &= process_corefile_note_segment (file,
30800947
NC		 15668 (bfd_vma) segment->p_offset,
15669 (bfd_vma) segment->p_filesz);
779fe533 15670 }
103f02d3 15671
779fe533
NC		 15672 return res;
15673}
15674
685080f2
NC		 15675static int
15676process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15677{
15678 Elf_External_Note * pnotes;
15679 Elf_External_Note * external;
c8071705 15680 char * end;
685080f2
NC		 15681 int res = 1;
15682
15683 if (length <= 0)
15684 return 0;
15685
15686 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15687 _("v850 notes"));
15688 if (pnotes == NULL)
15689 return 0;
15690
15691 external = pnotes;
c8071705 15692 end = (char*) pnotes + length;
685080f2
NC		 15693
15694 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15695 (unsigned long) offset, (unsigned long) length);
15696
c8071705 15697 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15698 {
15699 Elf_External_Note * next;
15700 Elf_Internal_Note inote;
15701
15702 inote.type = BYTE_GET (external->type);
15703 inote.namesz = BYTE_GET (external->namesz);
15704 inote.namedata = external->name;
15705 inote.descsz = BYTE_GET (external->descsz);
15706 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15707 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15708
c8071705
NC		 15709 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15710 {
15711 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15712 inote.descdata = inote.namedata;
15713 inote.namesz = 0;
15714 }
15715
685080f2
NC		 15716 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15717
c8071705 15718 if ( ((char *) next > end)
685080f2
NC		 15719 || ((char *) next < (char *) pnotes))
15720 {
15721 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15722 (unsigned long) ((char *) external - (char *) pnotes));
15723 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15724 inote.type, inote.namesz, inote.descsz);
15725 break;
15726 }
15727
15728 external = next;
15729
15730 /* Prevent out-of-bounds indexing. */
c8071705 15731 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15732 || inote.namedata + inote.namesz < inote.namedata)
15733 {
15734 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15735 (unsigned long) ((char *) external - (char *) pnotes));
15736 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15737 inote.type, inote.namesz, inote.descsz);
15738 break;
15739 }
15740
15741 printf (" %s: ", get_v850_elf_note_type (inote.type));
15742
15743 if (! print_v850_note (& inote))
15744 {
15745 res = 0;
15746 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15747 inote.namesz, inote.descsz);
15748 }
15749 }
15750
15751 free (pnotes);
15752
15753 return res;
15754}
15755
779fe533 15756static int
2cf0635d 15757process_note_sections (FILE * file)
1ec5cd37 15758{
2cf0635d 15759 Elf_Internal_Shdr * section;
1ec5cd37 15760 unsigned long i;
df565f32 15761 int n = 0;
1ec5cd37
NC		 15762 int res = 1;
15763
15764 for (i = 0, section = section_headers;
fa1908fd 15765 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15766 i++, section++)
685080f2
NC		 15767 {
15768 if (section->sh_type == SHT_NOTE)
15769 {
15770 res &= process_corefile_note_segment (file,
15771 (bfd_vma) section->sh_offset,
15772 (bfd_vma) section->sh_size);
15773 n++;
15774 }
15775
15776 if (( elf_header.e_machine == EM_V800
15777 || elf_header.e_machine == EM_V850
15778 || elf_header.e_machine == EM_CYGNUS_V850)
15779 && section->sh_type == SHT_RENESAS_INFO)
15780 {
15781 res &= process_v850_notes (file,
15782 (bfd_vma) section->sh_offset,
15783 (bfd_vma) section->sh_size);
15784 n++;
15785 }
15786 }
df565f32
NC		 15787
15788 if (n == 0)
15789 /* Try processing NOTE segments instead. */
15790 return process_corefile_note_segments (file);
1ec5cd37
NC		 15791
15792 return res;
15793}
15794
15795static int
2cf0635d 15796process_notes (FILE * file)
779fe533
NC		 15797{
15798 /* If we have not been asked to display the notes then do nothing. */
15799 if (! do_notes)
15800 return 1;
103f02d3 15801
779fe533 15802 if (elf_header.e_type != ET_CORE)
1ec5cd37 15803 return process_note_sections (file);
103f02d3 15804
779fe533 15805 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15806 if (elf_header.e_phnum > 0)
15807 return process_corefile_note_segments (file);
779fe533 15808
1ec5cd37
NC		 15809 printf (_("No note segments present in the core file.\n"));
15810 return 1;
779fe533
NC		 15811}
15812
252b5132 15813static int
2cf0635d 15814process_arch_specific (FILE * file)
252b5132 15815{
a952a375
NC		 15816 if (! do_arch)
15817 return 1;
15818
252b5132
RH		 15819 switch (elf_header.e_machine)
15820 {
11c1ff18
PB		 15821 case EM_ARM:
15822 return process_arm_specific (file);
252b5132 15823 case EM_MIPS:
4fe85591 15824 case EM_MIPS_RS3_LE:
252b5132
RH		 15825 return process_mips_specific (file);
15826 break;
35c08157
KLC		 15827 case EM_NDS32:
15828 return process_nds32_specific (file);
15829 break;
34c8bcba
JM		 15830 case EM_PPC:
15831 return process_power_specific (file);
15832 break;
643f7afb
AK		 15833 case EM_S390:
15834 case EM_S390_OLD:
15835 return process_s390_specific (file);
15836 break;
9e8c70f9
DM		 15837 case EM_SPARC:
15838 case EM_SPARC32PLUS:
15839 case EM_SPARCV9:
15840 return process_sparc_specific (file);
15841 break;
59e6276b
JM		 15842 case EM_TI_C6000:
15843 return process_tic6x_specific (file);
15844 break;
13761a11
NC		 15845 case EM_MSP430:
15846 return process_msp430x_specific (file);
252b5132
RH		 15847 default:
15848 break;
15849 }
15850 return 1;
15851}
15852
15853static int
2cf0635d 15854get_file_header (FILE * file)
252b5132 15855{
9ea033b2
NC		 15856 /* Read in the identity array. */
15857 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15858 return 0;
15859
9ea033b2 15860 /* Determine how to read the rest of the header. */
b34976b6 15861 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15862 {
15863 default: /* fall through */
15864 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15865 case ELFDATA2LSB:
15866 byte_get = byte_get_little_endian;
15867 byte_put = byte_put_little_endian;
15868 break;
15869 case ELFDATA2MSB:
15870 byte_get = byte_get_big_endian;
15871 byte_put = byte_put_big_endian;
15872 break;
9ea033b2
NC		 15873 }
15874
15875 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15876 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15877
15878 /* Read in the rest of the header. */
15879 if (is_32bit_elf)
15880 {
15881 Elf32_External_Ehdr ehdr32;
252b5132 15882
9ea033b2
NC		 15883 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15884 return 0;
103f02d3 15885
9ea033b2
NC		 15886 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15887 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15888 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15889 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15890 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15891 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15892 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15893 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15894 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15895 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15896 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15897 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15898 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15899 }
252b5132 15900 else
9ea033b2
NC		 15901 {
15902 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15903
15904 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15905 we will not be able to cope with the 64bit data found in
15906 64 ELF files. Detect this now and abort before we start
50c2245b 15907 overwriting things. */
a952a375
NC		 15908 if (sizeof (bfd_vma) < 8)
15909 {
e3c8793a
NC		 15910 error (_("This instance of readelf has been built without support for a\n\
1591164 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15912 return 0;
15913 }
103f02d3 15914
9ea033b2
NC		 15915 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15916 return 0;
103f02d3 15917
9ea033b2
NC		 15918 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15919 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15920 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15921 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15922 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15923 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15924 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15925 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15926 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15927 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15928 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15929 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15930 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15931 }
252b5132 15932
7ece0d85
JJ		 15933 if (elf_header.e_shoff)
15934 {
15935 /* There may be some extensions in the first section header. Don't
15936 bomb if we can't read it. */
15937 if (is_32bit_elf)
049b0c3a 15938 get_32bit_section_headers (file, TRUE);
7ece0d85 15939 else
049b0c3a 15940 get_64bit_section_headers (file, TRUE);
7ece0d85 15941 }
560f3c1c 15942
252b5132
RH		 15943 return 1;
15944}
15945
fb52b2f4
NC		 15946/* Process one ELF object file according to the command line options.
15947 This file may actually be stored in an archive. The file is
15948 positioned at the start of the ELF object. */
15949
ff78d6d6 15950static int
2cf0635d 15951process_object (char * file_name, FILE * file)
252b5132 15952{
252b5132
RH		 15953 unsigned int i;
15954
252b5132
RH		 15955 if (! get_file_header (file))
15956 {
15957 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15958 return 1;
252b5132
RH		 15959 }
15960
15961 /* Initialise per file variables. */
60bca95a 15962 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15963 version_info[i] = 0;
15964
60bca95a 15965 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15966 dynamic_info[i] = 0;
5115b233 15967 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15968
15969 /* Process the file. */
15970 if (show_name)
15971 printf (_("\nFile: %s\n"), file_name);
15972
18bd398b
NC		 15973 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15974 Note we do this even if cmdline_dump_sects is empty because we
15975 must make sure that the dump_sets array is zeroed out before each
15976 object file is processed. */
15977 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15978 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15979
15980 if (num_cmdline_dump_sects > 0)
15981 {
15982 if (num_dump_sects == 0)
15983 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15984 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15985
15986 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15987 memcpy (dump_sects, cmdline_dump_sects,
15988 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15989 }
d70c5fc7 15990
252b5132 15991 if (! process_file_header ())
fb52b2f4 15992 return 1;
252b5132 15993
d1f5c6e3 15994 if (! process_section_headers (file))
2f62977e 15995 {
d1f5c6e3
L		 15996 /* Without loaded section headers we cannot process lots of
15997 things. */
2f62977e 15998 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15999
2f62977e 16000 if (! do_using_dynamic)
2c610e4b 16001 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16002 }
252b5132 16003
d1f5c6e3
L		 16004 if (! process_section_groups (file))
16005 {
16006 /* Without loaded section groups we cannot process unwind. */
16007 do_unwind = 0;
16008 }
16009
2f62977e 16010 if (process_program_headers (file))
b2d38a17 16011 process_dynamic_section (file);
252b5132
RH		 16012
16013 process_relocs (file);
16014
4d6ed7c8
NC		 16015 process_unwind (file);
16016
252b5132
RH		 16017 process_symbol_table (file);
16018
16019 process_syminfo (file);
16020
16021 process_version_sections (file);
16022
16023 process_section_contents (file);
f5842774 16024
1ec5cd37 16025 process_notes (file);
103f02d3 16026
047b2264
JJ		 16027 process_gnu_liblist (file);
16028
252b5132
RH		 16029 process_arch_specific (file);
16030
d93f0186
NC		 16031 if (program_headers)
16032 {
16033 free (program_headers);
16034 program_headers = NULL;
16035 }
16036
252b5132
RH		 16037 if (section_headers)
16038 {
16039 free (section_headers);
16040 section_headers = NULL;
16041 }
16042
16043 if (string_table)
16044 {
16045 free (string_table);
16046 string_table = NULL;
d40ac9bd 16047 string_table_length = 0;
252b5132
RH		 16048 }
16049
16050 if (dynamic_strings)
16051 {
16052 free (dynamic_strings);
16053 dynamic_strings = NULL;
d79b3d50 16054 dynamic_strings_length = 0;
252b5132
RH		 16055 }
16056
16057 if (dynamic_symbols)
16058 {
16059 free (dynamic_symbols);
16060 dynamic_symbols = NULL;
19936277 16061 num_dynamic_syms = 0;
252b5132
RH		 16062 }
16063
16064 if (dynamic_syminfo)
16065 {
16066 free (dynamic_syminfo);
16067 dynamic_syminfo = NULL;
16068 }
ff78d6d6 16069
293c573e
MR		 16070 if (dynamic_section)
16071 {
16072 free (dynamic_section);
16073 dynamic_section = NULL;
16074 }
16075
e4b17d5c
L		 16076 if (section_headers_groups)
16077 {
16078 free (section_headers_groups);
16079 section_headers_groups = NULL;
16080 }
16081
16082 if (section_groups)
16083 {
2cf0635d
NC		 16084 struct group_list * g;
16085 struct group_list * next;
e4b17d5c
L		 16086
16087 for (i = 0; i < group_count; i++)
16088 {
16089 for (g = section_groups [i].root; g != NULL; g = next)
16090 {
16091 next = g->next;
16092 free (g);
16093 }
16094 }
16095
16096 free (section_groups);
16097 section_groups = NULL;
16098 }
16099
19e6b90e 16100 free_debug_memory ();
18bd398b 16101
ff78d6d6 16102 return 0;
252b5132
RH		 16103}
16104
2cf0635d
NC		 16105/* Process an ELF archive.
16106 On entry the file is positioned just after the ARMAG string. */
16107
16108static int
16109process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16110{
16111 struct archive_info arch;
16112 struct archive_info nested_arch;
16113 size_t got;
2cf0635d
NC		 16114 int ret;
16115
16116 show_name = 1;
16117
16118 /* The ARCH structure is used to hold information about this archive. */
16119 arch.file_name = NULL;
16120 arch.file = NULL;
16121 arch.index_array = NULL;
16122 arch.sym_table = NULL;
16123 arch.longnames = NULL;
16124
16125 /* The NESTED_ARCH structure is used as a single-item cache of information
16126 about a nested archive (when members of a thin archive reside within
16127 another regular archive file). */
16128 nested_arch.file_name = NULL;
16129 nested_arch.file = NULL;
16130 nested_arch.index_array = NULL;
16131 nested_arch.sym_table = NULL;
16132 nested_arch.longnames = NULL;
16133
16134 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16135 {
16136 ret = 1;
16137 goto out;
4145f1d5 16138 }
fb52b2f4 16139
4145f1d5
NC		 16140 if (do_archive_index)
16141 {
2cf0635d 16142 if (arch.sym_table == NULL)
4145f1d5
NC		 16143 error (_("%s: unable to dump the index as none was found\n"), file_name);
16144 else
16145 {
591f7597 16146 unsigned long i, l;
4145f1d5
NC		 16147 unsigned long current_pos;
16148
591f7597
NC		 16149 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16150 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16151 current_pos = ftell (file);
16152
2cf0635d 16153 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16154 {
2cf0635d
NC		 16155 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16156 {
16157 char * member_name;
4145f1d5 16158
2cf0635d
NC		 16159 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16160
16161 if (member_name != NULL)
16162 {
16163 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16164
16165 if (qualified_name != NULL)
16166 {
c2a7d3f5
NC		 16167 printf (_("Contents of binary %s at offset "), qualified_name);
16168 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16169 putchar ('\n');
2cf0635d
NC		 16170 free (qualified_name);
16171 }
4145f1d5
NC		 16172 }
16173 }
2cf0635d
NC		 16174
16175 if (l >= arch.sym_size)
4145f1d5
NC		 16176 {
16177 error (_("%s: end of the symbol table reached before the end of the index\n"),
16178 file_name);
cb8f3167 16179 break;
4145f1d5 16180 }
591f7597
NC		 16181 /* PR 17531: file: 0b6630b2. */
16182 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16183 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16184 }
16185
c2a7d3f5
NC		 16186 if (arch.uses_64bit_indicies)
16187 l = (l + 7) & ~ 7;
16188 else
16189 l += l & 1;
16190
2cf0635d 16191 if (l < arch.sym_size)
c2a7d3f5
NC		 16192 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16193 file_name, arch.sym_size - l);
4145f1d5 16194
4145f1d5
NC		 16195 if (fseek (file, current_pos, SEEK_SET) != 0)
16196 {
16197 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16198 ret = 1;
16199 goto out;
4145f1d5 16200 }
fb52b2f4 16201 }
4145f1d5
NC		 16202
16203 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16204 && !do_segments && !do_header && !do_dump && !do_version
16205 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16206 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16207 {
16208 ret = 0; /* Archive index only. */
16209 goto out;
16210 }
fb52b2f4
NC		 16211 }
16212
d989285c 16213 ret = 0;
fb52b2f4
NC		 16214
16215 while (1)
16216 {
2cf0635d
NC		 16217 char * name;
16218 size_t namelen;
16219 char * qualified_name;
16220
16221 /* Read the next archive header. */
16222 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16223 {
16224 error (_("%s: failed to seek to next archive header\n"), file_name);
16225 return 1;
16226 }
16227 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16228 if (got != sizeof arch.arhdr)
16229 {
16230 if (got == 0)
16231 break;
16232 error (_("%s: failed to read archive header\n"), file_name);
16233 ret = 1;
16234 break;
16235 }
16236 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16237 {
16238 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16239 ret = 1;
16240 break;
16241 }
16242
16243 arch.next_arhdr_offset += sizeof arch.arhdr;
16244
16245 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16246 if (archive_file_size & 01)
16247 ++archive_file_size;
16248
16249 name = get_archive_member_name (&arch, &nested_arch);
16250 if (name == NULL)
fb52b2f4 16251 {
0fd3a477 16252 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16253 ret = 1;
16254 break;
fb52b2f4 16255 }
2cf0635d 16256 namelen = strlen (name);
fb52b2f4 16257
2cf0635d
NC		 16258 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16259 if (qualified_name == NULL)
fb52b2f4 16260 {
2cf0635d 16261 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16262 ret = 1;
16263 break;
fb52b2f4
NC		 16264 }
16265
2cf0635d
NC		 16266 if (is_thin_archive && arch.nested_member_origin == 0)
16267 {
16268 /* This is a proxy for an external member of a thin archive. */
16269 FILE * member_file;
16270 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16271 if (member_file_name == NULL)
16272 {
16273 ret = 1;
16274 break;
16275 }
16276
16277 member_file = fopen (member_file_name, "rb");
16278 if (member_file == NULL)
16279 {
16280 error (_("Input file '%s' is not readable.\n"), member_file_name);
16281 free (member_file_name);
16282 ret = 1;
16283 break;
16284 }
16285
16286 archive_file_offset = arch.nested_member_origin;
16287
16288 ret |= process_object (qualified_name, member_file);
16289
16290 fclose (member_file);
16291 free (member_file_name);
16292 }
16293 else if (is_thin_archive)
16294 {
a043396b
NC		 16295 /* PR 15140: Allow for corrupt thin archives. */
16296 if (nested_arch.file == NULL)
16297 {
16298 error (_("%s: contains corrupt thin archive: %s\n"),
16299 file_name, name);
16300 ret = 1;
16301 break;
16302 }
16303
2cf0635d
NC		 16304 /* This is a proxy for a member of a nested archive. */
16305 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16306
16307 /* The nested archive file will have been opened and setup by
16308 get_archive_member_name. */
16309 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16310 {
16311 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16312 ret = 1;
16313 break;
16314 }
16315
16316 ret |= process_object (qualified_name, nested_arch.file);
16317 }
16318 else
16319 {
16320 archive_file_offset = arch.next_arhdr_offset;
16321 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16322
2cf0635d
NC		 16323 ret |= process_object (qualified_name, file);
16324 }
fb52b2f4 16325
2b52916e
L		 16326 if (dump_sects != NULL)
16327 {
16328 free (dump_sects);
16329 dump_sects = NULL;
16330 num_dump_sects = 0;
16331 }
16332
2cf0635d 16333 free (qualified_name);
fb52b2f4
NC		 16334 }
16335
4145f1d5 16336 out:
2cf0635d
NC		 16337 if (nested_arch.file != NULL)
16338 fclose (nested_arch.file);
16339 release_archive (&nested_arch);
16340 release_archive (&arch);
fb52b2f4 16341
d989285c 16342 return ret;
fb52b2f4
NC		 16343}
16344
16345static int
2cf0635d 16346process_file (char * file_name)
fb52b2f4 16347{
2cf0635d 16348 FILE * file;
fb52b2f4
NC		 16349 struct stat statbuf;
16350 char armag[SARMAG];
16351 int ret;
16352
16353 if (stat (file_name, &statbuf) < 0)
16354 {
f24ddbdd
NC		 16355 if (errno == ENOENT)
16356 error (_("'%s': No such file\n"), file_name);
16357 else
16358 error (_("Could not locate '%s'. System error message: %s\n"),
16359 file_name, strerror (errno));
16360 return 1;
16361 }
16362
16363 if (! S_ISREG (statbuf.st_mode))
16364 {
16365 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16366 return 1;
16367 }
16368
16369 file = fopen (file_name, "rb");
16370 if (file == NULL)
16371 {
f24ddbdd 16372 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16373 return 1;
16374 }
16375
16376 if (fread (armag, SARMAG, 1, file) != 1)
16377 {
4145f1d5 16378 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16379 fclose (file);
16380 return 1;
16381 }
16382
f54498b4
NC		 16383 current_file_size = (bfd_size_type) statbuf.st_size;
16384
fb52b2f4 16385 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16386 ret = process_archive (file_name, file, FALSE);
16387 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16388 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16389 else
16390 {
4145f1d5
NC		 16391 if (do_archive_index)
16392 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16393 file_name);
16394
fb52b2f4
NC		 16395 rewind (file);
16396 archive_file_size = archive_file_offset = 0;
16397 ret = process_object (file_name, file);
16398 }
16399
16400 fclose (file);
16401
f54498b4 16402 current_file_size = 0;
fb52b2f4
NC		 16403 return ret;
16404}
16405
252b5132
RH		 16406#ifdef SUPPORT_DISASSEMBLY
16407/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16408 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16409 symbols. */
252b5132
RH		 16410
16411void
2cf0635d 16412print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16413{
16414 fprintf (outfile,"0x%8.8x", addr);
16415}
16416
e3c8793a 16417/* Needed by the i386 disassembler. */
252b5132
RH		 16418void
16419db_task_printsym (unsigned int addr)
16420{
16421 print_address (addr, stderr);
16422}
16423#endif
16424
16425int
2cf0635d 16426main (int argc, char ** argv)
252b5132 16427{
ff78d6d6
L		 16428 int err;
16429
252b5132
RH		 16430#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16431 setlocale (LC_MESSAGES, "");
3882b010
L		 16432#endif
16433#if defined (HAVE_SETLOCALE)
16434 setlocale (LC_CTYPE, "");
252b5132
RH		 16435#endif
16436 bindtextdomain (PACKAGE, LOCALEDIR);
16437 textdomain (PACKAGE);
16438
869b9d07
MM		 16439 expandargv (&argc, &argv);
16440
252b5132
RH		 16441 parse_args (argc, argv);
16442
18bd398b 16443 if (num_dump_sects > 0)
59f14fc0 16444 {
18bd398b 16445 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16446 cmdline_dump_sects = (dump_type *)
16447 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16448 if (cmdline_dump_sects == NULL)
591a748a 16449 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16450 else
16451 {
09c11c86
NC		 16452 memcpy (cmdline_dump_sects, dump_sects,
16453 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16454 num_cmdline_dump_sects = num_dump_sects;
16455 }
16456 }
16457
18bd398b
NC		 16458 if (optind < (argc - 1))
16459 show_name = 1;
5656ba2c
L		 16460 else if (optind >= argc)
16461 {
16462 warn (_("Nothing to do.\n"));
16463 usage (stderr);
16464 }
18bd398b 16465
ff78d6d6 16466 err = 0;
252b5132 16467 while (optind < argc)
18bd398b 16468 err |= process_file (argv[optind++]);
252b5132
RH		 16469
16470 if (dump_sects != NULL)
16471 free (dump_sects);
59f14fc0
AS		 16472 if (cmdline_dump_sects != NULL)
16473 free (cmdline_dump_sects);
252b5132 16474
ff78d6d6 16475 return err;
252b5132 16476}
GDB Binutils - Deliverables
This page took 3.009283 seconds and 4 git commands to generate.