]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gas line buffer handling
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
b90efa5b 2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
2cf0635d 167char * program_name = "readelf";
c9c1d674 168static unsigned long archive_file_offset;
85b1c36d 169static unsigned long archive_file_size;
f54498b4 170static bfd_size_type current_file_size;
85b1c36d
BE		 171static unsigned long dynamic_addr;
172static bfd_size_type dynamic_size;
8b73c356 173static size_t dynamic_nent;
2cf0635d 174static char * dynamic_strings;
85b1c36d 175static unsigned long dynamic_strings_length;
2cf0635d 176static char * string_table;
85b1c36d
BE		 177static unsigned long string_table_length;
178static unsigned long num_dynamic_syms;
2cf0635d
NC		 179static Elf_Internal_Sym * dynamic_symbols;
180static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 181static unsigned long dynamic_syminfo_offset;
182static unsigned int dynamic_syminfo_nent;
f8eae8b2 183static char program_interpreter[PATH_MAX];
bb8a0291 184static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 185static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 186static bfd_vma version_info[16];
187static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 188static Elf_Internal_Shdr * section_headers;
189static Elf_Internal_Phdr * program_headers;
190static Elf_Internal_Dyn * dynamic_section;
191static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 192static int show_name;
193static int do_dynamic;
194static int do_syms;
2c610e4b 195static int do_dyn_syms;
85b1c36d
BE		 196static int do_reloc;
197static int do_sections;
198static int do_section_groups;
5477e8a0 199static int do_section_details;
85b1c36d
BE		 200static int do_segments;
201static int do_unwind;
202static int do_using_dynamic;
203static int do_header;
204static int do_dump;
205static int do_version;
85b1c36d
BE		 206static int do_histogram;
207static int do_debugging;
85b1c36d
BE		 208static int do_arch;
209static int do_notes;
4145f1d5 210static int do_archive_index;
85b1c36d 211static int is_32bit_elf;
0e602686 212static int decompress_dumps;
252b5132 213
e4b17d5c
L		 214struct group_list
215{
2cf0635d 216 struct group_list * next;
e4b17d5c
L		 217 unsigned int section_index;
218};
219
220struct group
221{
2cf0635d 222 struct group_list * root;
e4b17d5c
L		 223 unsigned int group_index;
224};
225
85b1c36d 226static size_t group_count;
2cf0635d
NC		 227static struct group * section_groups;
228static struct group ** section_headers_groups;
e4b17d5c 229
09c11c86
NC		 230
231/* Flag bits indicating particular types of dump. */
232#define HEX_DUMP (1 << 0) /* The -x command line switch. */
233#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
234#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
235#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 236#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 237
238typedef unsigned char dump_type;
239
240/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 241struct dump_list_entry
242{
2cf0635d 243 char * name;
09c11c86 244 dump_type type;
2cf0635d 245 struct dump_list_entry * next;
aef1f6d0 246};
2cf0635d 247static struct dump_list_entry * dump_sects_byname;
aef1f6d0 248
09c11c86
NC		 249/* A dynamic array of flags indicating for which sections a dump
250 has been requested via command line switches. */
251static dump_type * cmdline_dump_sects = NULL;
252static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 253
254/* A dynamic array of flags indicating for which sections a dump of
255 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 256 basis and then initialised from the cmdline_dump_sects array,
257 the results of interpreting the -w switch, and the
258 dump_sects_byname list. */
09c11c86
NC		 259static dump_type * dump_sects = NULL;
260static unsigned int num_dump_sects = 0;
252b5132 261
252b5132 262
c256ffe7 263/* How to print a vma value. */
843dd992
NC		 264typedef enum print_mode
265{
266 HEX,
267 DEC,
268 DEC_5,
269 UNSIGNED,
270 PREFIX_HEX,
271 FULL_HEX,
272 LONG_HEX
273}
274print_mode;
275
bb4d2ac2
L		 276/* Versioned symbol info. */
277enum versioned_symbol_info
278{
279 symbol_undefined,
280 symbol_hidden,
281 symbol_public
282};
283
284static const char *get_symbol_version_string
285 (FILE *file, int is_dynsym, const char *strtab,
286 unsigned long int strtab_size, unsigned int si,
287 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
288 unsigned short *vna_other);
289
9c19a809
NC		 290#define UNKNOWN -1
291
2b692964
NC		 292#define SECTION_NAME(X) \
293 ((X) == NULL ? _("<none>") \
294 : string_table == NULL ? _("<no-name>") \
295 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 296 : string_table + (X)->sh_name))
252b5132 297
ee42cf8c 298#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 299
ba5cdace
NC		 300#define GET_ELF_SYMBOLS(file, section, sym_count) \
301 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
302 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 303
d79b3d50
NC		 304#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
305/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
306 already been called and verified that the string exists. */
307#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 308
61865e30
NC		 309#define REMOVE_ARCH_BITS(ADDR) \
310 do \
311 { \
312 if (elf_header.e_machine == EM_ARM) \
313 (ADDR) &= ~1; \
314 } \
315 while (0)
d79b3d50 316\f
c9c1d674
EG		 317/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
318 the offset of the current archive member, if we are examining an archive.
59245841
NC		 319 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
320 using malloc and fill that. In either case return the pointer to the start of
321 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 322 and REASON is not NULL then emit an error message using REASON as part of the
323 context. */
59245841 324
c256ffe7 325static void *
57028622
NC		 326get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
327 bfd_size_type nmemb, const char * reason)
a6e9f9df 328{
2cf0635d 329 void * mvar;
57028622 330 bfd_size_type amt = size * nmemb;
a6e9f9df 331
c256ffe7 332 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 333 return NULL;
334
57028622
NC		 335 /* If the size_t type is smaller than the bfd_size_type, eg because
336 you are building a 32-bit tool on a 64-bit host, then make sure
337 that when the sizes are cast to (size_t) no information is lost. */
338 if (sizeof (size_t) < sizeof (bfd_size_type)
339 && ( (bfd_size_type) ((size_t) size) != size
340 || (bfd_size_type) ((size_t) nmemb) != nmemb))
341 {
342 if (reason)
343 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
344 (unsigned long long) nmemb, (unsigned long long) size, reason);
345 return NULL;
346 }
347
348 /* Check for size overflow. */
349 if (amt < nmemb)
350 {
351 if (reason)
352 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
353 (unsigned long long) nmemb, (unsigned long long) size, reason);
354 return NULL;
355 }
356
c9c1d674
EG		 357 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
358 attempting to allocate memory when the read is bound to fail. */
359 if (amt > current_file_size
360 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 361 {
049b0c3a 362 if (reason)
57028622
NC		 363 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
364 (unsigned long long) amt, reason);
a6e9f9df
AM		 365 return NULL;
366 }
367
c9c1d674 368 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 369 {
370 if (reason)
c9c1d674
EG		 371 error (_("Unable to seek to 0x%lx for %s\n"),
372 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 373 return NULL;
374 }
375
a6e9f9df
AM		 376 mvar = var;
377 if (mvar == NULL)
378 {
c256ffe7 379 /* Check for overflow. */
57028622 380 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 381 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 382 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 383
384 if (mvar == NULL)
385 {
049b0c3a 386 if (reason)
57028622
NC		 387 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
388 (unsigned long long) amt, reason);
a6e9f9df
AM		 389 return NULL;
390 }
c256ffe7 391
c9c1d674 392 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 393 }
394
57028622 395 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 396 {
049b0c3a 397 if (reason)
57028622
NC		 398 error (_("Unable to read in 0x%llx bytes of %s\n"),
399 (unsigned long long) amt, reason);
a6e9f9df
AM		 400 if (mvar != var)
401 free (mvar);
402 return NULL;
403 }
404
405 return mvar;
406}
407
14a91970 408/* Print a VMA value. */
cb8f3167 409
66543521 410static int
14a91970 411print_vma (bfd_vma vma, print_mode mode)
66543521 412{
66543521
AM		 413 int nc = 0;
414
14a91970 415 switch (mode)
66543521 416 {
14a91970
AM		 417 case FULL_HEX:
418 nc = printf ("0x");
419 /* Drop through. */
66543521 420
14a91970 421 case LONG_HEX:
f7a99963 422#ifdef BFD64
14a91970 423 if (is_32bit_elf)
437c2fb7 424 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 425#endif
14a91970
AM		 426 printf_vma (vma);
427 return nc + 16;
b19aac67 428
14a91970
AM		 429 case DEC_5:
430 if (vma <= 99999)
431 return printf ("%5" BFD_VMA_FMT "d", vma);
432 /* Drop through. */
66543521 433
14a91970
AM		 434 case PREFIX_HEX:
435 nc = printf ("0x");
436 /* Drop through. */
66543521 437
14a91970
AM		 438 case HEX:
439 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 440
14a91970
AM		 441 case DEC:
442 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 443
14a91970
AM		 444 case UNSIGNED:
445 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 446 }
66543521 447 return 0;
f7a99963
NC		 448}
449
7bfd842d 450/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 451 multibye characters (assuming the host environment supports them).
31104126 452
7bfd842d
NC		 453 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
454
455 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
456 padding as necessary.
171191ba
NC		 457
458 Returns the number of emitted characters. */
459
460static unsigned int
7a88bc9c 461print_symbol (int width, const char *symbol)
31104126 462{
171191ba 463 bfd_boolean extra_padding = FALSE;
7bfd842d 464 int num_printed = 0;
3bfcb652 465#ifdef HAVE_MBSTATE_T
7bfd842d 466 mbstate_t state;
3bfcb652 467#endif
7bfd842d 468 int width_remaining;
961c521f 469
7bfd842d 470 if (width < 0)
961c521f 471 {
961c521f
NC		 472 /* Keep the width positive. This also helps. */
473 width = - width;
171191ba 474 extra_padding = TRUE;
0b4362b0 475 }
74e1a04b 476 assert (width != 0);
961c521f 477
7bfd842d
NC		 478 if (do_wide)
479 /* Set the remaining width to a very large value.
480 This simplifies the code below. */
481 width_remaining = INT_MAX;
482 else
483 width_remaining = width;
cb8f3167 484
3bfcb652 485#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 486 /* Initialise the multibyte conversion state. */
487 memset (& state, 0, sizeof (state));
3bfcb652 488#endif
961c521f 489
7bfd842d
NC		 490 while (width_remaining)
491 {
492 size_t n;
7bfd842d 493 const char c = *symbol++;
961c521f 494
7bfd842d 495 if (c == 0)
961c521f
NC		 496 break;
497
7bfd842d
NC		 498 /* Do not print control characters directly as they can affect terminal
499 settings. Such characters usually appear in the names generated
500 by the assembler for local labels. */
501 if (ISCNTRL (c))
961c521f 502 {
7bfd842d 503 if (width_remaining < 2)
961c521f
NC		 504 break;
505
7bfd842d
NC		 506 printf ("^%c", c + 0x40);
507 width_remaining -= 2;
171191ba 508 num_printed += 2;
961c521f 509 }
7bfd842d
NC		 510 else if (ISPRINT (c))
511 {
512 putchar (c);
513 width_remaining --;
514 num_printed ++;
515 }
961c521f
NC		 516 else
517 {
3bfcb652
NC		 518#ifdef HAVE_MBSTATE_T
519 wchar_t w;
520#endif
7bfd842d
NC		 521 /* Let printf do the hard work of displaying multibyte characters. */
522 printf ("%.1s", symbol - 1);
523 width_remaining --;
524 num_printed ++;
525
3bfcb652 526#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 527 /* Try to find out how many bytes made up the character that was
528 just printed. Advance the symbol pointer past the bytes that
529 were displayed. */
530 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 531#else
532 n = 1;
533#endif
7bfd842d
NC		 534 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
535 symbol += (n - 1);
961c521f 536 }
961c521f 537 }
171191ba 538
7bfd842d 539 if (extra_padding && num_printed < width)
171191ba
NC		 540 {
541 /* Fill in the remaining spaces. */
7bfd842d
NC		 542 printf ("%-*s", width - num_printed, " ");
543 num_printed = width;
171191ba
NC		 544 }
545
546 return num_printed;
31104126
NC		 547}
548
74e1a04b
NC		 549/* Returns a pointer to a static buffer containing a printable version of
550 the given section's name. Like print_symbol, except that it does not try
551 to print multibyte characters, it just interprets them as hex values. */
552
553static const char *
0d2a7a93 554printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 555{
556#define MAX_PRINT_SEC_NAME_LEN 128
557 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
558 const char * name = SECTION_NAME (sec);
559 char * buf = sec_name_buf;
560 char c;
561 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
562
563 while ((c = * name ++) != 0)
564 {
565 if (ISCNTRL (c))
566 {
567 if (remaining < 2)
568 break;
948f632f 569
74e1a04b
NC		 570 * buf ++ = '^';
571 * buf ++ = c + 0x40;
572 remaining -= 2;
573 }
574 else if (ISPRINT (c))
575 {
576 * buf ++ = c;
577 remaining -= 1;
578 }
579 else
580 {
581 static char hex[17] = "0123456789ABCDEF";
582
583 if (remaining < 4)
584 break;
585 * buf ++ = '<';
586 * buf ++ = hex[(c & 0xf0) >> 4];
587 * buf ++ = hex[c & 0x0f];
588 * buf ++ = '>';
589 remaining -= 4;
590 }
591
592 if (remaining == 0)
593 break;
594 }
595
596 * buf = 0;
597 return sec_name_buf;
598}
599
600static const char *
601printable_section_name_from_index (unsigned long ndx)
602{
603 if (ndx >= elf_header.e_shnum)
604 return _("<corrupt>");
605
606 return printable_section_name (section_headers + ndx);
607}
608
89fac5e3
RS		 609/* Return a pointer to section NAME, or NULL if no such section exists. */
610
611static Elf_Internal_Shdr *
2cf0635d 612find_section (const char * name)
89fac5e3
RS		 613{
614 unsigned int i;
615
616 for (i = 0; i < elf_header.e_shnum; i++)
617 if (streq (SECTION_NAME (section_headers + i), name))
618 return section_headers + i;
619
620 return NULL;
621}
622
0b6ae522
DJ		 623/* Return a pointer to a section containing ADDR, or NULL if no such
624 section exists. */
625
626static Elf_Internal_Shdr *
627find_section_by_address (bfd_vma addr)
628{
629 unsigned int i;
630
631 for (i = 0; i < elf_header.e_shnum; i++)
632 {
633 Elf_Internal_Shdr *sec = section_headers + i;
634 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
635 return sec;
636 }
637
638 return NULL;
639}
640
071436c6
NC		 641static Elf_Internal_Shdr *
642find_section_by_type (unsigned int type)
643{
644 unsigned int i;
645
646 for (i = 0; i < elf_header.e_shnum; i++)
647 {
648 Elf_Internal_Shdr *sec = section_headers + i;
649 if (sec->sh_type == type)
650 return sec;
651 }
652
653 return NULL;
654}
655
657d0d47
CC		 656/* Return a pointer to section NAME, or NULL if no such section exists,
657 restricted to the list of sections given in SET. */
658
659static Elf_Internal_Shdr *
660find_section_in_set (const char * name, unsigned int * set)
661{
662 unsigned int i;
663
664 if (set != NULL)
665 {
666 while ((i = *set++) > 0)
667 if (streq (SECTION_NAME (section_headers + i), name))
668 return section_headers + i;
669 }
670
671 return find_section (name);
672}
673
0b6ae522
DJ		 674/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
675 bytes read. */
676
f6f0e17b
NC		 677static inline unsigned long
678read_uleb128 (unsigned char *data,
679 unsigned int *length_return,
680 const unsigned char * const end)
0b6ae522 681{
f6f0e17b 682 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 683}
684
28f997cf
TG		 685/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
686 This OS has so many departures from the ELF standard that we test it at
687 many places. */
688
689static inline int
690is_ia64_vms (void)
691{
692 return elf_header.e_machine == EM_IA_64
693 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
694}
695
bcedfee6 696/* Guess the relocation size commonly used by the specific machines. */
252b5132 697
252b5132 698static int
2dc4cec1 699guess_is_rela (unsigned int e_machine)
252b5132 700{
9c19a809 701 switch (e_machine)
252b5132
RH		 702 {
703 /* Targets that use REL relocations. */
252b5132 704 case EM_386:
22abe556 705 case EM_IAMCU:
63fcb9e9 706 case EM_960:
e9f53129 707 case EM_ARM:
2b0337b0 708 case EM_D10V:
252b5132 709 case EM_CYGNUS_D10V:
e9f53129 710 case EM_DLX:
252b5132 711 case EM_MIPS:
4fe85591 712 case EM_MIPS_RS3_LE:
e9f53129 713 case EM_CYGNUS_M32R:
1c0d3aa6 714 case EM_SCORE:
f6c1a2d5 715 case EM_XGATE:
9c19a809 716 return FALSE;
103f02d3 717
252b5132
RH		 718 /* Targets that use RELA relocations. */
719 case EM_68K:
e9f53129 720 case EM_860:
a06ea964 721 case EM_AARCH64:
cfb8c092 722 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 723 case EM_ALPHA:
724 case EM_ALTERA_NIOS2:
725 case EM_AVR:
726 case EM_AVR_OLD:
727 case EM_BLACKFIN:
60bca95a 728 case EM_CR16:
e9f53129
AM		 729 case EM_CRIS:
730 case EM_CRX:
2b0337b0 731 case EM_D30V:
252b5132 732 case EM_CYGNUS_D30V:
2b0337b0 733 case EM_FR30:
3f8107ab 734 case EM_FT32:
252b5132 735 case EM_CYGNUS_FR30:
5c70f934 736 case EM_CYGNUS_FRV:
e9f53129
AM		 737 case EM_H8S:
738 case EM_H8_300:
739 case EM_H8_300H:
800eeca4 740 case EM_IA_64:
1e4cf259
NC		 741 case EM_IP2K:
742 case EM_IP2K_OLD:
3b36097d 743 case EM_IQ2000:
84e94c90 744 case EM_LATTICEMICO32:
ff7eeb89 745 case EM_M32C_OLD:
49f58d10 746 case EM_M32C:
e9f53129
AM		 747 case EM_M32R:
748 case EM_MCORE:
15ab5209 749 case EM_CYGNUS_MEP:
a3c62988 750 case EM_METAG:
e9f53129
AM		 751 case EM_MMIX:
752 case EM_MN10200:
753 case EM_CYGNUS_MN10200:
754 case EM_MN10300:
755 case EM_CYGNUS_MN10300:
5506d11a 756 case EM_MOXIE:
e9f53129
AM		 757 case EM_MSP430:
758 case EM_MSP430_OLD:
d031aafb 759 case EM_MT:
35c08157 760 case EM_NDS32:
64fd6348 761 case EM_NIOS32:
73589c9d 762 case EM_OR1K:
e9f53129
AM		 763 case EM_PPC64:
764 case EM_PPC:
99c513f6 765 case EM_RL78:
c7927a3c 766 case EM_RX:
e9f53129
AM		 767 case EM_S390:
768 case EM_S390_OLD:
769 case EM_SH:
770 case EM_SPARC:
771 case EM_SPARC32PLUS:
772 case EM_SPARCV9:
773 case EM_SPU:
40b36596 774 case EM_TI_C6000:
aa137e4d
NC		 775 case EM_TILEGX:
776 case EM_TILEPRO:
708e2187 777 case EM_V800:
e9f53129
AM		 778 case EM_V850:
779 case EM_CYGNUS_V850:
780 case EM_VAX:
619ed720 781 case EM_VISIUM:
e9f53129 782 case EM_X86_64:
8a9036a4 783 case EM_L1OM:
7a9068fe 784 case EM_K1OM:
e9f53129
AM		 785 case EM_XSTORMY16:
786 case EM_XTENSA:
787 case EM_XTENSA_OLD:
7ba29e2a
NC		 788 case EM_MICROBLAZE:
789 case EM_MICROBLAZE_OLD:
9c19a809 790 return TRUE;
103f02d3 791
e9f53129
AM		 792 case EM_68HC05:
793 case EM_68HC08:
794 case EM_68HC11:
795 case EM_68HC16:
796 case EM_FX66:
797 case EM_ME16:
d1133906 798 case EM_MMA:
d1133906
NC		 799 case EM_NCPU:
800 case EM_NDR1:
e9f53129 801 case EM_PCP:
d1133906 802 case EM_ST100:
e9f53129 803 case EM_ST19:
d1133906 804 case EM_ST7:
e9f53129
AM		 805 case EM_ST9PLUS:
806 case EM_STARCORE:
d1133906 807 case EM_SVX:
e9f53129 808 case EM_TINYJ:
9c19a809
NC		 809 default:
810 warn (_("Don't know about relocations on this machine architecture\n"));
811 return FALSE;
812 }
813}
252b5132 814
9c19a809 815static int
2cf0635d 816slurp_rela_relocs (FILE * file,
d3ba0551
AM		 817 unsigned long rel_offset,
818 unsigned long rel_size,
2cf0635d
NC		 819 Elf_Internal_Rela ** relasp,
820 unsigned long * nrelasp)
9c19a809 821{
2cf0635d 822 Elf_Internal_Rela * relas;
8b73c356 823 size_t nrelas;
4d6ed7c8 824 unsigned int i;
252b5132 825
4d6ed7c8
NC		 826 if (is_32bit_elf)
827 {
2cf0635d 828 Elf32_External_Rela * erelas;
103f02d3 829
3f5e193b 830 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 831 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 832 if (!erelas)
833 return 0;
252b5132 834
4d6ed7c8 835 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 836
3f5e193b
NC		 837 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
838 sizeof (Elf_Internal_Rela));
103f02d3 839
4d6ed7c8
NC		 840 if (relas == NULL)
841 {
c256ffe7 842 free (erelas);
591a748a 843 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 844 return 0;
845 }
103f02d3 846
4d6ed7c8
NC		 847 for (i = 0; i < nrelas; i++)
848 {
849 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
850 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 851 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 852 }
103f02d3 853
4d6ed7c8
NC		 854 free (erelas);
855 }
856 else
857 {
2cf0635d 858 Elf64_External_Rela * erelas;
103f02d3 859
3f5e193b 860 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 861 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 862 if (!erelas)
863 return 0;
4d6ed7c8
NC		 864
865 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 866
3f5e193b
NC		 867 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
868 sizeof (Elf_Internal_Rela));
103f02d3 869
4d6ed7c8
NC		 870 if (relas == NULL)
871 {
c256ffe7 872 free (erelas);
591a748a 873 error (_("out of memory parsing relocs\n"));
4d6ed7c8 874 return 0;
9c19a809 875 }
4d6ed7c8
NC		 876
877 for (i = 0; i < nrelas; i++)
9c19a809 878 {
66543521
AM		 879 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
880 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 881 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 882
883 /* The #ifdef BFD64 below is to prevent a compile time
884 warning. We know that if we do not have a 64 bit data
885 type that we will never execute this code anyway. */
886#ifdef BFD64
887 if (elf_header.e_machine == EM_MIPS
888 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
889 {
890 /* In little-endian objects, r_info isn't really a
891 64-bit little-endian value: it has a 32-bit
892 little-endian symbol index followed by four
893 individual byte fields. Reorder INFO
894 accordingly. */
91d6fa6a
NC		 895 bfd_vma inf = relas[i].r_info;
896 inf = (((inf & 0xffffffff) << 32)
897 | ((inf >> 56) & 0xff)
898 | ((inf >> 40) & 0xff00)
899 | ((inf >> 24) & 0xff0000)
900 | ((inf >> 8) & 0xff000000));
901 relas[i].r_info = inf;
861fb55a
DJ		 902 }
903#endif /* BFD64 */
4d6ed7c8 904 }
103f02d3 905
4d6ed7c8
NC		 906 free (erelas);
907 }
908 *relasp = relas;
909 *nrelasp = nrelas;
910 return 1;
911}
103f02d3 912
4d6ed7c8 913static int
2cf0635d 914slurp_rel_relocs (FILE * file,
d3ba0551
AM		 915 unsigned long rel_offset,
916 unsigned long rel_size,
2cf0635d
NC		 917 Elf_Internal_Rela ** relsp,
918 unsigned long * nrelsp)
4d6ed7c8 919{
2cf0635d 920 Elf_Internal_Rela * rels;
8b73c356 921 size_t nrels;
4d6ed7c8 922 unsigned int i;
103f02d3 923
4d6ed7c8
NC		 924 if (is_32bit_elf)
925 {
2cf0635d 926 Elf32_External_Rel * erels;
103f02d3 927
3f5e193b 928 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 929 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 930 if (!erels)
931 return 0;
103f02d3 932
4d6ed7c8 933 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 934
3f5e193b 935 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 936
4d6ed7c8
NC		 937 if (rels == NULL)
938 {
c256ffe7 939 free (erels);
591a748a 940 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 941 return 0;
942 }
943
944 for (i = 0; i < nrels; i++)
945 {
946 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
947 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 948 rels[i].r_addend = 0;
9ea033b2 949 }
4d6ed7c8
NC		 950
951 free (erels);
9c19a809
NC		 952 }
953 else
954 {
2cf0635d 955 Elf64_External_Rel * erels;
9ea033b2 956
3f5e193b 957 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 958 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 959 if (!erels)
960 return 0;
103f02d3 961
4d6ed7c8 962 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 963
3f5e193b 964 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 965
4d6ed7c8 966 if (rels == NULL)
9c19a809 967 {
c256ffe7 968 free (erels);
591a748a 969 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 970 return 0;
971 }
103f02d3 972
4d6ed7c8
NC		 973 for (i = 0; i < nrels; i++)
974 {
66543521
AM		 975 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
976 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 977 rels[i].r_addend = 0;
861fb55a
DJ		 978
979 /* The #ifdef BFD64 below is to prevent a compile time
980 warning. We know that if we do not have a 64 bit data
981 type that we will never execute this code anyway. */
982#ifdef BFD64
983 if (elf_header.e_machine == EM_MIPS
984 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
985 {
986 /* In little-endian objects, r_info isn't really a
987 64-bit little-endian value: it has a 32-bit
988 little-endian symbol index followed by four
989 individual byte fields. Reorder INFO
990 accordingly. */
91d6fa6a
NC		 991 bfd_vma inf = rels[i].r_info;
992 inf = (((inf & 0xffffffff) << 32)
993 | ((inf >> 56) & 0xff)
994 | ((inf >> 40) & 0xff00)
995 | ((inf >> 24) & 0xff0000)
996 | ((inf >> 8) & 0xff000000));
997 rels[i].r_info = inf;
861fb55a
DJ		 998 }
999#endif /* BFD64 */
4d6ed7c8 1000 }
103f02d3 1001
4d6ed7c8
NC		 1002 free (erels);
1003 }
1004 *relsp = rels;
1005 *nrelsp = nrels;
1006 return 1;
1007}
103f02d3 1008
aca88567
NC		 1009/* Returns the reloc type extracted from the reloc info field. */
1010
1011static unsigned int
1012get_reloc_type (bfd_vma reloc_info)
1013{
1014 if (is_32bit_elf)
1015 return ELF32_R_TYPE (reloc_info);
1016
1017 switch (elf_header.e_machine)
1018 {
1019 case EM_MIPS:
1020 /* Note: We assume that reloc_info has already been adjusted for us. */
1021 return ELF64_MIPS_R_TYPE (reloc_info);
1022
1023 case EM_SPARCV9:
1024 return ELF64_R_TYPE_ID (reloc_info);
1025
1026 default:
1027 return ELF64_R_TYPE (reloc_info);
1028 }
1029}
1030
1031/* Return the symbol index extracted from the reloc info field. */
1032
1033static bfd_vma
1034get_reloc_symindex (bfd_vma reloc_info)
1035{
1036 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1037}
1038
13761a11
NC		 1039static inline bfd_boolean
1040uses_msp430x_relocs (void)
1041{
1042 return
1043 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1044 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1045 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1046 /* TI compiler uses ELFOSABI_NONE. */
1047 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1048}
1049
d3ba0551
AM		 1050/* Display the contents of the relocation data found at the specified
1051 offset. */
ee42cf8c 1052
41e92641 1053static void
2cf0635d 1054dump_relocations (FILE * file,
d3ba0551
AM		 1055 unsigned long rel_offset,
1056 unsigned long rel_size,
2cf0635d 1057 Elf_Internal_Sym * symtab,
d3ba0551 1058 unsigned long nsyms,
2cf0635d 1059 char * strtab,
d79b3d50 1060 unsigned long strtablen,
bb4d2ac2
L		 1061 int is_rela,
1062 int is_dynsym)
4d6ed7c8 1063{
b34976b6 1064 unsigned int i;
2cf0635d 1065 Elf_Internal_Rela * rels;
103f02d3 1066
4d6ed7c8
NC		 1067 if (is_rela == UNKNOWN)
1068 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1069
4d6ed7c8
NC		 1070 if (is_rela)
1071 {
c8286bd1 1072 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1073 return;
4d6ed7c8
NC		 1074 }
1075 else
1076 {
1077 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1078 return;
252b5132
RH		 1079 }
1080
410f7a12
L		 1081 if (is_32bit_elf)
1082 {
1083 if (is_rela)
2c71103e
NC		 1084 {
1085 if (do_wide)
1086 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1087 else
1088 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1089 }
410f7a12 1090 else
2c71103e
NC		 1091 {
1092 if (do_wide)
1093 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1094 else
1095 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1096 }
410f7a12 1097 }
252b5132 1098 else
410f7a12
L		 1099 {
1100 if (is_rela)
2c71103e
NC		 1101 {
1102 if (do_wide)
8beeaeb7 1103 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1104 else
1105 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1106 }
410f7a12 1107 else
2c71103e
NC		 1108 {
1109 if (do_wide)
8beeaeb7 1110 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1111 else
1112 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1113 }
410f7a12 1114 }
252b5132
RH		 1115
1116 for (i = 0; i < rel_size; i++)
1117 {
2cf0635d 1118 const char * rtype;
b34976b6 1119 bfd_vma offset;
91d6fa6a 1120 bfd_vma inf;
b34976b6
AM		 1121 bfd_vma symtab_index;
1122 bfd_vma type;
103f02d3 1123
b34976b6 1124 offset = rels[i].r_offset;
91d6fa6a 1125 inf = rels[i].r_info;
103f02d3 1126
91d6fa6a
NC		 1127 type = get_reloc_type (inf);
1128 symtab_index = get_reloc_symindex (inf);
252b5132 1129
410f7a12
L		 1130 if (is_32bit_elf)
1131 {
39dbeff8
AM		 1132 printf ("%8.8lx %8.8lx ",
1133 (unsigned long) offset & 0xffffffff,
91d6fa6a 1134 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1135 }
1136 else
1137 {
39dbeff8
AM		 1138#if BFD_HOST_64BIT_LONG
1139 printf (do_wide
1140 ? "%16.16lx %16.16lx "
1141 : "%12.12lx %12.12lx ",
91d6fa6a 1142 offset, inf);
39dbeff8 1143#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1144#ifndef __MSVCRT__
39dbeff8
AM		 1145 printf (do_wide
1146 ? "%16.16llx %16.16llx "
1147 : "%12.12llx %12.12llx ",
91d6fa6a 1148 offset, inf);
6e3d6dc1
NC		 1149#else
1150 printf (do_wide
1151 ? "%16.16I64x %16.16I64x "
1152 : "%12.12I64x %12.12I64x ",
91d6fa6a 1153 offset, inf);
6e3d6dc1 1154#endif
39dbeff8 1155#else
2c71103e
NC		 1156 printf (do_wide
1157 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1158 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1159 _bfd_int64_high (offset),
1160 _bfd_int64_low (offset),
91d6fa6a
NC		 1161 _bfd_int64_high (inf),
1162 _bfd_int64_low (inf));
9ea033b2 1163#endif
410f7a12 1164 }
103f02d3 1165
252b5132
RH		 1166 switch (elf_header.e_machine)
1167 {
1168 default:
1169 rtype = NULL;
1170 break;
1171
a06ea964
NC		 1172 case EM_AARCH64:
1173 rtype = elf_aarch64_reloc_type (type);
1174 break;
1175
2b0337b0 1176 case EM_M32R:
252b5132 1177 case EM_CYGNUS_M32R:
9ea033b2 1178 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1179 break;
1180
1181 case EM_386:
22abe556 1182 case EM_IAMCU:
9ea033b2 1183 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1184 break;
1185
ba2685cc
AM		 1186 case EM_68HC11:
1187 case EM_68HC12:
1188 rtype = elf_m68hc11_reloc_type (type);
1189 break;
75751cd9 1190
252b5132 1191 case EM_68K:
9ea033b2 1192 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1193 break;
1194
63fcb9e9 1195 case EM_960:
9ea033b2 1196 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1197 break;
1198
adde6300 1199 case EM_AVR:
2b0337b0 1200 case EM_AVR_OLD:
adde6300
AM		 1201 rtype = elf_avr_reloc_type (type);
1202 break;
1203
9ea033b2
NC		 1204 case EM_OLD_SPARCV9:
1205 case EM_SPARC32PLUS:
1206 case EM_SPARCV9:
252b5132 1207 case EM_SPARC:
9ea033b2 1208 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1209 break;
1210
e9f53129
AM		 1211 case EM_SPU:
1212 rtype = elf_spu_reloc_type (type);
1213 break;
1214
708e2187
NC		 1215 case EM_V800:
1216 rtype = v800_reloc_type (type);
1217 break;
2b0337b0 1218 case EM_V850:
252b5132 1219 case EM_CYGNUS_V850:
9ea033b2 1220 rtype = v850_reloc_type (type);
252b5132
RH		 1221 break;
1222
2b0337b0 1223 case EM_D10V:
252b5132 1224 case EM_CYGNUS_D10V:
9ea033b2 1225 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1226 break;
1227
2b0337b0 1228 case EM_D30V:
252b5132 1229 case EM_CYGNUS_D30V:
9ea033b2 1230 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1231 break;
1232
d172d4ba
NC		 1233 case EM_DLX:
1234 rtype = elf_dlx_reloc_type (type);
1235 break;
1236
252b5132 1237 case EM_SH:
9ea033b2 1238 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1239 break;
1240
2b0337b0 1241 case EM_MN10300:
252b5132 1242 case EM_CYGNUS_MN10300:
9ea033b2 1243 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1244 break;
1245
2b0337b0 1246 case EM_MN10200:
252b5132 1247 case EM_CYGNUS_MN10200:
9ea033b2 1248 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1249 break;
1250
2b0337b0 1251 case EM_FR30:
252b5132 1252 case EM_CYGNUS_FR30:
9ea033b2 1253 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1254 break;
1255
ba2685cc
AM		 1256 case EM_CYGNUS_FRV:
1257 rtype = elf_frv_reloc_type (type);
1258 break;
5c70f934 1259
3f8107ab
AM		 1260 case EM_FT32:
1261 rtype = elf_ft32_reloc_type (type);
1262 break;
1263
252b5132 1264 case EM_MCORE:
9ea033b2 1265 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1266 break;
1267
3c3bdf30
NC		 1268 case EM_MMIX:
1269 rtype = elf_mmix_reloc_type (type);
1270 break;
1271
5506d11a
AM		 1272 case EM_MOXIE:
1273 rtype = elf_moxie_reloc_type (type);
1274 break;
1275
2469cfa2 1276 case EM_MSP430:
13761a11
NC		 1277 if (uses_msp430x_relocs ())
1278 {
1279 rtype = elf_msp430x_reloc_type (type);
1280 break;
1281 }
2469cfa2
NC		 1282 case EM_MSP430_OLD:
1283 rtype = elf_msp430_reloc_type (type);
1284 break;
1285
35c08157
KLC		 1286 case EM_NDS32:
1287 rtype = elf_nds32_reloc_type (type);
1288 break;
1289
252b5132 1290 case EM_PPC:
9ea033b2 1291 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1292 break;
1293
c833c019
AM		 1294 case EM_PPC64:
1295 rtype = elf_ppc64_reloc_type (type);
1296 break;
1297
252b5132 1298 case EM_MIPS:
4fe85591 1299 case EM_MIPS_RS3_LE:
9ea033b2 1300 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1301 break;
1302
1303 case EM_ALPHA:
9ea033b2 1304 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1305 break;
1306
1307 case EM_ARM:
9ea033b2 1308 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1309 break;
1310
584da044 1311 case EM_ARC:
9ea033b2 1312 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1313 break;
1314
1315 case EM_PARISC:
69e617ca 1316 rtype = elf_hppa_reloc_type (type);
252b5132 1317 break;
7d466069 1318
b8720f9d
JL		 1319 case EM_H8_300:
1320 case EM_H8_300H:
1321 case EM_H8S:
1322 rtype = elf_h8_reloc_type (type);
1323 break;
1324
73589c9d
CS		 1325 case EM_OR1K:
1326 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1327 break;
1328
7d466069 1329 case EM_PJ:
2b0337b0 1330 case EM_PJ_OLD:
7d466069
ILT		 1331 rtype = elf_pj_reloc_type (type);
1332 break;
800eeca4
JW		 1333 case EM_IA_64:
1334 rtype = elf_ia64_reloc_type (type);
1335 break;
1b61cf92
HPN		 1336
1337 case EM_CRIS:
1338 rtype = elf_cris_reloc_type (type);
1339 break;
535c37ff
JE		 1340
1341 case EM_860:
1342 rtype = elf_i860_reloc_type (type);
1343 break;
bcedfee6
NC		 1344
1345 case EM_X86_64:
8a9036a4 1346 case EM_L1OM:
7a9068fe 1347 case EM_K1OM:
bcedfee6
NC		 1348 rtype = elf_x86_64_reloc_type (type);
1349 break;
a85d7ed0 1350
35b1837e
AM		 1351 case EM_S370:
1352 rtype = i370_reloc_type (type);
1353 break;
1354
53c7db4b
KH		 1355 case EM_S390_OLD:
1356 case EM_S390:
1357 rtype = elf_s390_reloc_type (type);
1358 break;
93fbbb04 1359
1c0d3aa6
NC		 1360 case EM_SCORE:
1361 rtype = elf_score_reloc_type (type);
1362 break;
1363
93fbbb04
GK		 1364 case EM_XSTORMY16:
1365 rtype = elf_xstormy16_reloc_type (type);
1366 break;
179d3252 1367
1fe1f39c
NC		 1368 case EM_CRX:
1369 rtype = elf_crx_reloc_type (type);
1370 break;
1371
179d3252
JT		 1372 case EM_VAX:
1373 rtype = elf_vax_reloc_type (type);
1374 break;
1e4cf259 1375
619ed720
EB		 1376 case EM_VISIUM:
1377 rtype = elf_visium_reloc_type (type);
1378 break;
1379
cfb8c092
NC		 1380 case EM_ADAPTEVA_EPIPHANY:
1381 rtype = elf_epiphany_reloc_type (type);
1382 break;
1383
1e4cf259
NC		 1384 case EM_IP2K:
1385 case EM_IP2K_OLD:
1386 rtype = elf_ip2k_reloc_type (type);
1387 break;
3b36097d
SC		 1388
1389 case EM_IQ2000:
1390 rtype = elf_iq2000_reloc_type (type);
1391 break;
88da6820
NC		 1392
1393 case EM_XTENSA_OLD:
1394 case EM_XTENSA:
1395 rtype = elf_xtensa_reloc_type (type);
1396 break;
a34e3ecb 1397
84e94c90
NC		 1398 case EM_LATTICEMICO32:
1399 rtype = elf_lm32_reloc_type (type);
1400 break;
1401
ff7eeb89 1402 case EM_M32C_OLD:
49f58d10
JB		 1403 case EM_M32C:
1404 rtype = elf_m32c_reloc_type (type);
1405 break;
1406
d031aafb
NS		 1407 case EM_MT:
1408 rtype = elf_mt_reloc_type (type);
a34e3ecb 1409 break;
1d65ded4
CM		 1410
1411 case EM_BLACKFIN:
1412 rtype = elf_bfin_reloc_type (type);
1413 break;
15ab5209
DB		 1414
1415 case EM_CYGNUS_MEP:
1416 rtype = elf_mep_reloc_type (type);
1417 break;
60bca95a
NC		 1418
1419 case EM_CR16:
1420 rtype = elf_cr16_reloc_type (type);
1421 break;
dd24e3da 1422
7ba29e2a
NC		 1423 case EM_MICROBLAZE:
1424 case EM_MICROBLAZE_OLD:
1425 rtype = elf_microblaze_reloc_type (type);
1426 break;
c7927a3c 1427
99c513f6
DD		 1428 case EM_RL78:
1429 rtype = elf_rl78_reloc_type (type);
1430 break;
1431
c7927a3c
NC		 1432 case EM_RX:
1433 rtype = elf_rx_reloc_type (type);
1434 break;
c29aca4a 1435
a3c62988
NC		 1436 case EM_METAG:
1437 rtype = elf_metag_reloc_type (type);
1438 break;
1439
c29aca4a
NC		 1440 case EM_XC16X:
1441 case EM_C166:
1442 rtype = elf_xc16x_reloc_type (type);
1443 break;
40b36596
JM		 1444
1445 case EM_TI_C6000:
1446 rtype = elf_tic6x_reloc_type (type);
1447 break;
aa137e4d
NC		 1448
1449 case EM_TILEGX:
1450 rtype = elf_tilegx_reloc_type (type);
1451 break;
1452
1453 case EM_TILEPRO:
1454 rtype = elf_tilepro_reloc_type (type);
1455 break;
f6c1a2d5
NC		 1456
1457 case EM_XGATE:
1458 rtype = elf_xgate_reloc_type (type);
1459 break;
36591ba1
SL		 1460
1461 case EM_ALTERA_NIOS2:
1462 rtype = elf_nios2_reloc_type (type);
1463 break;
252b5132
RH		 1464 }
1465
1466 if (rtype == NULL)
39dbeff8 1467 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1468 else
8beeaeb7 1469 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1470
7ace3541 1471 if (elf_header.e_machine == EM_ALPHA
157c2599 1472 && rtype != NULL
7ace3541
RH		 1473 && streq (rtype, "R_ALPHA_LITUSE")
1474 && is_rela)
1475 {
1476 switch (rels[i].r_addend)
1477 {
1478 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1479 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1480 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1481 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1482 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1483 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1484 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1485 default: rtype = NULL;
1486 }
1487 if (rtype)
1488 printf (" (%s)", rtype);
1489 else
1490 {
1491 putchar (' ');
1492 printf (_("<unknown addend: %lx>"),
1493 (unsigned long) rels[i].r_addend);
1494 }
1495 }
1496 else if (symtab_index)
252b5132 1497 {
af3fc3bc 1498 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1499 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1500 else
19936277 1501 {
2cf0635d 1502 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1503 const char * version_string;
1504 enum versioned_symbol_info sym_info;
1505 unsigned short vna_other;
19936277 1506
af3fc3bc 1507 psym = symtab + symtab_index;
103f02d3 1508
bb4d2ac2
L		 1509 version_string
1510 = get_symbol_version_string (file, is_dynsym,
1511 strtab, strtablen,
1512 symtab_index,
1513 psym,
1514 &sym_info,
1515 &vna_other);
1516
af3fc3bc 1517 printf (" ");
171191ba 1518
d8045f23
NC		 1519 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1520 {
1521 const char * name;
1522 unsigned int len;
1523 unsigned int width = is_32bit_elf ? 8 : 14;
1524
1525 /* Relocations against GNU_IFUNC symbols do not use the value
1526 of the symbol as the address to relocate against. Instead
1527 they invoke the function named by the symbol and use its
1528 result as the address for relocation.
1529
1530 To indicate this to the user, do not display the value of
1531 the symbol in the "Symbols's Value" field. Instead show
1532 its name followed by () as a hint that the symbol is
1533 invoked. */
1534
1535 if (strtab == NULL
1536 || psym->st_name == 0
1537 || psym->st_name >= strtablen)
1538 name = "??";
1539 else
1540 name = strtab + psym->st_name;
1541
1542 len = print_symbol (width, name);
bb4d2ac2
L		 1543 if (version_string)
1544 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1545 version_string);
d8045f23
NC		 1546 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1547 }
1548 else
1549 {
1550 print_vma (psym->st_value, LONG_HEX);
171191ba 1551
d8045f23
NC		 1552 printf (is_32bit_elf ? " " : " ");
1553 }
103f02d3 1554
af3fc3bc 1555 if (psym->st_name == 0)
f1ef08cb 1556 {
2cf0635d 1557 const char * sec_name = "<null>";
f1ef08cb
AM		 1558 char name_buf[40];
1559
1560 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1561 {
4fbb74a6 1562 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1563 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1564 else if (psym->st_shndx == SHN_ABS)
1565 sec_name = "ABS";
1566 else if (psym->st_shndx == SHN_COMMON)
1567 sec_name = "COMMON";
ac145307
BS		 1568 else if ((elf_header.e_machine == EM_MIPS
1569 && psym->st_shndx == SHN_MIPS_SCOMMON)
1570 || (elf_header.e_machine == EM_TI_C6000
1571 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1572 sec_name = "SCOMMON";
1573 else if (elf_header.e_machine == EM_MIPS
1574 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1575 sec_name = "SUNDEF";
8a9036a4 1576 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1577 || elf_header.e_machine == EM_L1OM
1578 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1579 && psym->st_shndx == SHN_X86_64_LCOMMON)
1580 sec_name = "LARGE_COMMON";
9ce701e2
L		 1581 else if (elf_header.e_machine == EM_IA_64
1582 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1583 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1584 sec_name = "ANSI_COM";
28f997cf 1585 else if (is_ia64_vms ()
148b93f2
NC		 1586 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1587 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1588 else
1589 {
1590 sprintf (name_buf, "<section 0x%x>",
1591 (unsigned int) psym->st_shndx);
1592 sec_name = name_buf;
1593 }
1594 }
1595 print_symbol (22, sec_name);
1596 }
af3fc3bc 1597 else if (strtab == NULL)
d79b3d50 1598 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1599 else if (psym->st_name >= strtablen)
d79b3d50 1600 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1601 else
bb4d2ac2
L		 1602 {
1603 print_symbol (22, strtab + psym->st_name);
1604 if (version_string)
1605 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1606 version_string);
1607 }
103f02d3 1608
af3fc3bc 1609 if (is_rela)
171191ba 1610 {
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";
a5499fa4 1698 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1699 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1700 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1701 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1702 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1703 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1704 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1705 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1706 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1707 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1708 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1709 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1710 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1711 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1712 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1713 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1714 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1715 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1716 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1717 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1718 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1719 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1720 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1722 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1723 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1724 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1725 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1726 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1727 default:
1728 return NULL;
1729 }
1730}
1731
9a097730 1732static const char *
d3ba0551 1733get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1734{
1735 switch (type)
1736 {
1737 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1738 default:
1739 return NULL;
1740 }
103f02d3
UD		 1741}
1742
7490d522
AM		 1743static const char *
1744get_ppc_dynamic_type (unsigned long type)
1745{
1746 switch (type)
1747 {
a7f2871e 1748 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1749 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1750 default:
1751 return NULL;
1752 }
1753}
1754
f1cb7e17 1755static const char *
d3ba0551 1756get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1757{
1758 switch (type)
1759 {
a7f2871e
AM		 1760 case DT_PPC64_GLINK: return "PPC64_GLINK";
1761 case DT_PPC64_OPD: return "PPC64_OPD";
1762 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1763 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1764 default:
1765 return NULL;
1766 }
1767}
1768
103f02d3 1769static const char *
d3ba0551 1770get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1771{
1772 switch (type)
1773 {
1774 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1775 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1776 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1777 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1778 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1779 case DT_HP_PREINIT: return "HP_PREINIT";
1780 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1781 case DT_HP_NEEDED: return "HP_NEEDED";
1782 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1783 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1784 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1785 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1786 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1787 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1788 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1789 case DT_HP_FILTERED: return "HP_FILTERED";
1790 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1791 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1792 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1793 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1794 case DT_PLT: return "PLT";
1795 case DT_PLT_SIZE: return "PLT_SIZE";
1796 case DT_DLT: return "DLT";
1797 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1798 default:
1799 return NULL;
1800 }
1801}
9a097730 1802
ecc51f48 1803static const char *
d3ba0551 1804get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1805{
1806 switch (type)
1807 {
148b93f2
NC		 1808 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1809 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1810 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1811 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1812 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1813 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1814 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1815 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1816 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1818 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1819 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1820 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1821 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1822 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1823 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1824 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1825 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1826 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1827 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1828 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1829 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1830 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1831 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1832 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1833 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1834 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1835 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1836 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1837 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1838 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1839 default:
1840 return NULL;
1841 }
1842}
1843
fabcb361
RH		 1844static const char *
1845get_alpha_dynamic_type (unsigned long type)
1846{
1847 switch (type)
1848 {
1849 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1850 default:
1851 return NULL;
1852 }
1853}
1854
1c0d3aa6
NC		 1855static const char *
1856get_score_dynamic_type (unsigned long type)
1857{
1858 switch (type)
1859 {
1860 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1861 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1862 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1863 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1864 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1865 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1866 default:
1867 return NULL;
1868 }
1869}
1870
40b36596
JM		 1871static const char *
1872get_tic6x_dynamic_type (unsigned long type)
1873{
1874 switch (type)
1875 {
1876 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1877 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1878 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1879 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1880 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1881 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1882 default:
1883 return NULL;
1884 }
1885}
1c0d3aa6 1886
36591ba1
SL		 1887static const char *
1888get_nios2_dynamic_type (unsigned long type)
1889{
1890 switch (type)
1891 {
1892 case DT_NIOS2_GP: return "NIOS2_GP";
1893 default:
1894 return NULL;
1895 }
1896}
1897
252b5132 1898static const char *
d3ba0551 1899get_dynamic_type (unsigned long type)
252b5132 1900{
e9e44622 1901 static char buff[64];
252b5132
RH		 1902
1903 switch (type)
1904 {
1905 case DT_NULL: return "NULL";
1906 case DT_NEEDED: return "NEEDED";
1907 case DT_PLTRELSZ: return "PLTRELSZ";
1908 case DT_PLTGOT: return "PLTGOT";
1909 case DT_HASH: return "HASH";
1910 case DT_STRTAB: return "STRTAB";
1911 case DT_SYMTAB: return "SYMTAB";
1912 case DT_RELA: return "RELA";
1913 case DT_RELASZ: return "RELASZ";
1914 case DT_RELAENT: return "RELAENT";
1915 case DT_STRSZ: return "STRSZ";
1916 case DT_SYMENT: return "SYMENT";
1917 case DT_INIT: return "INIT";
1918 case DT_FINI: return "FINI";
1919 case DT_SONAME: return "SONAME";
1920 case DT_RPATH: return "RPATH";
1921 case DT_SYMBOLIC: return "SYMBOLIC";
1922 case DT_REL: return "REL";
1923 case DT_RELSZ: return "RELSZ";
1924 case DT_RELENT: return "RELENT";
1925 case DT_PLTREL: return "PLTREL";
1926 case DT_DEBUG: return "DEBUG";
1927 case DT_TEXTREL: return "TEXTREL";
1928 case DT_JMPREL: return "JMPREL";
1929 case DT_BIND_NOW: return "BIND_NOW";
1930 case DT_INIT_ARRAY: return "INIT_ARRAY";
1931 case DT_FINI_ARRAY: return "FINI_ARRAY";
1932 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1933 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1934 case DT_RUNPATH: return "RUNPATH";
1935 case DT_FLAGS: return "FLAGS";
2d0e6f43 1936
d1133906
NC		 1937 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1938 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1939
05107a46 1940 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1941 case DT_PLTPADSZ: return "PLTPADSZ";
1942 case DT_MOVEENT: return "MOVEENT";
1943 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1944 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1945 case DT_POSFLAG_1: return "POSFLAG_1";
1946 case DT_SYMINSZ: return "SYMINSZ";
1947 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1948
252b5132 1949 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1950 case DT_CONFIG: return "CONFIG";
1951 case DT_DEPAUDIT: return "DEPAUDIT";
1952 case DT_AUDIT: return "AUDIT";
1953 case DT_PLTPAD: return "PLTPAD";
1954 case DT_MOVETAB: return "MOVETAB";
252b5132 1955 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1956
252b5132 1957 case DT_VERSYM: return "VERSYM";
103f02d3 1958
67a4f2b7
AO		 1959 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1960 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1961 case DT_RELACOUNT: return "RELACOUNT";
1962 case DT_RELCOUNT: return "RELCOUNT";
1963 case DT_FLAGS_1: return "FLAGS_1";
1964 case DT_VERDEF: return "VERDEF";
1965 case DT_VERDEFNUM: return "VERDEFNUM";
1966 case DT_VERNEED: return "VERNEED";
1967 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1968
019148e4 1969 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1970 case DT_USED: return "USED";
1971 case DT_FILTER: return "FILTER";
103f02d3 1972
047b2264
JJ		 1973 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1974 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1975 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1976 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1977 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1978 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1979
252b5132
RH		 1980 default:
1981 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1982 {
2cf0635d 1983 const char * result;
103f02d3 1984
252b5132
RH		 1985 switch (elf_header.e_machine)
1986 {
1987 case EM_MIPS:
4fe85591 1988 case EM_MIPS_RS3_LE:
252b5132
RH		 1989 result = get_mips_dynamic_type (type);
1990 break;
9a097730
RH		 1991 case EM_SPARCV9:
1992 result = get_sparc64_dynamic_type (type);
1993 break;
7490d522
AM		 1994 case EM_PPC:
1995 result = get_ppc_dynamic_type (type);
1996 break;
f1cb7e17
AM		 1997 case EM_PPC64:
1998 result = get_ppc64_dynamic_type (type);
1999 break;
ecc51f48
NC		 2000 case EM_IA_64:
2001 result = get_ia64_dynamic_type (type);
2002 break;
fabcb361
RH		 2003 case EM_ALPHA:
2004 result = get_alpha_dynamic_type (type);
2005 break;
1c0d3aa6
NC		 2006 case EM_SCORE:
2007 result = get_score_dynamic_type (type);
2008 break;
40b36596
JM		 2009 case EM_TI_C6000:
2010 result = get_tic6x_dynamic_type (type);
2011 break;
36591ba1
SL		 2012 case EM_ALTERA_NIOS2:
2013 result = get_nios2_dynamic_type (type);
2014 break;
252b5132
RH		 2015 default:
2016 result = NULL;
2017 break;
2018 }
2019
2020 if (result != NULL)
2021 return result;
2022
e9e44622 2023 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2024 }
eec8f817
DA		 2025 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2026 || (elf_header.e_machine == EM_PARISC
2027 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2028 {
2cf0635d 2029 const char * result;
103f02d3
UD		 2030
2031 switch (elf_header.e_machine)
2032 {
2033 case EM_PARISC:
2034 result = get_parisc_dynamic_type (type);
2035 break;
148b93f2
NC		 2036 case EM_IA_64:
2037 result = get_ia64_dynamic_type (type);
2038 break;
103f02d3
UD		 2039 default:
2040 result = NULL;
2041 break;
2042 }
2043
2044 if (result != NULL)
2045 return result;
2046
e9e44622
JJ		 2047 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2048 type);
103f02d3 2049 }
252b5132 2050 else
e9e44622 2051 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2052
252b5132
RH		 2053 return buff;
2054 }
2055}
2056
2057static char *
d3ba0551 2058get_file_type (unsigned e_type)
252b5132 2059{
b34976b6 2060 static char buff[32];
252b5132
RH		 2061
2062 switch (e_type)
2063 {
2064 case ET_NONE: return _("NONE (None)");
2065 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2066 case ET_EXEC: return _("EXEC (Executable file)");
2067 case ET_DYN: return _("DYN (Shared object file)");
2068 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2069
2070 default:
2071 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2072 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2073 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2074 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2075 else
e9e44622 2076 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2077 return buff;
2078 }
2079}
2080
2081static char *
d3ba0551 2082get_machine_name (unsigned e_machine)
252b5132 2083{
b34976b6 2084 static char buff[64]; /* XXX */
252b5132
RH		 2085
2086 switch (e_machine)
2087 {
c45021f2 2088 case EM_NONE: return _("None");
a06ea964 2089 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2090 case EM_M32: return "WE32100";
2091 case EM_SPARC: return "Sparc";
e9f53129 2092 case EM_SPU: return "SPU";
c45021f2
NC		 2093 case EM_386: return "Intel 80386";
2094 case EM_68K: return "MC68000";
2095 case EM_88K: return "MC88000";
22abe556 2096 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2097 case EM_860: return "Intel 80860";
2098 case EM_MIPS: return "MIPS R3000";
2099 case EM_S370: return "IBM System/370";
7036c0e1 2100 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2101 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2102 case EM_PARISC: return "HPPA";
252b5132 2103 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2104 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2105 case EM_960: return "Intel 90860";
2106 case EM_PPC: return "PowerPC";
285d1771 2107 case EM_PPC64: return "PowerPC64";
c45021f2 2108 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2109 case EM_FT32: return "FTDI FT32";
c45021f2 2110 case EM_RH32: return "TRW RH32";
b34976b6 2111 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2112 case EM_ARM: return "ARM";
2113 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2114 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2115 case EM_SPARCV9: return "Sparc v9";
2116 case EM_TRICORE: return "Siemens Tricore";
584da044 2117 case EM_ARC: return "ARC";
c2dcd04e
NC		 2118 case EM_H8_300: return "Renesas H8/300";
2119 case EM_H8_300H: return "Renesas H8/300H";
2120 case EM_H8S: return "Renesas H8S";
2121 case EM_H8_500: return "Renesas H8/500";
30800947 2122 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2123 case EM_MIPS_X: return "Stanford MIPS-X";
2124 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2125 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2126 case EM_CYGNUS_D10V:
2127 case EM_D10V: return "d10v";
2128 case EM_CYGNUS_D30V:
b34976b6 2129 case EM_D30V: return "d30v";
2b0337b0 2130 case EM_CYGNUS_M32R:
26597c86 2131 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2132 case EM_CYGNUS_V850:
708e2187 2133 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2134 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2135 case EM_CYGNUS_MN10300:
2136 case EM_MN10300: return "mn10300";
2137 case EM_CYGNUS_MN10200:
2138 case EM_MN10200: return "mn10200";
5506d11a 2139 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2140 case EM_CYGNUS_FR30:
2141 case EM_FR30: return "Fujitsu FR30";
b34976b6 2142 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2143 case EM_PJ_OLD:
b34976b6 2144 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2145 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2146 case EM_PCP: return "Siemens PCP";
2147 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2148 case EM_NDR1: return "Denso NDR1 microprocesspr";
2149 case EM_STARCORE: return "Motorola Star*Core processor";
2150 case EM_ME16: return "Toyota ME16 processor";
2151 case EM_ST100: return "STMicroelectronics ST100 processor";
2152 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2153 case EM_PDSP: return "Sony DSP processor";
2154 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2155 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2156 case EM_FX66: return "Siemens FX66 microcontroller";
2157 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2159 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2160 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2161 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2162 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2163 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2164 case EM_SVX: return "Silicon Graphics SVx";
2165 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2166 case EM_VAX: return "Digital VAX";
619ed720 2167 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2168 case EM_AVR_OLD:
b34976b6 2169 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2170 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2171 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2172 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2173 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2174 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2175 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2176 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2177 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2178 case EM_L1OM: return "Intel L1OM";
7a9068fe 2179 case EM_K1OM: return "Intel K1OM";
b7498e0e 2180 case EM_S390_OLD:
b34976b6 2181 case EM_S390: return "IBM S/390";
1c0d3aa6 2182 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2183 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2184 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2185 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2186 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2187 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2188 case EM_DLX: return "OpenDLX";
1e4cf259 2189 case EM_IP2K_OLD:
b34976b6 2190 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2191 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2192 case EM_XTENSA_OLD:
2193 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2194 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2195 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2196 case EM_NS32K: return "National Semiconductor 32000 series";
2197 case EM_TPC: return "Tenor Network TPC processor";
2198 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2199 case EM_MAX: return "MAX Processor";
2200 case EM_CR: return "National Semiconductor CompactRISC";
2201 case EM_F2MC16: return "Fujitsu F2MC16";
2202 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2203 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2204 case EM_M32C_OLD:
49f58d10 2205 case EM_M32C: return "Renesas M32c";
d031aafb 2206 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2207 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2208 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2209 case EM_SEP: return "Sharp embedded microprocessor";
2210 case EM_ARCA: return "Arca RISC microprocessor";
2211 case EM_UNICORE: return "Unicore";
2212 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2213 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2214 case EM_NIOS32: return "Altera Nios";
2215 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2216 case EM_C166:
d70c5fc7 2217 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2218 case EM_M16C: return "Renesas M16C series microprocessors";
2219 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2220 case EM_CE: return "Freescale Communication Engine RISC core";
2221 case EM_TSK3000: return "Altium TSK3000 core";
2222 case EM_RS08: return "Freescale RS08 embedded processor";
2223 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2224 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2225 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2226 case EM_SE_C17: return "Seiko Epson C17 family";
2227 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2228 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2229 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2230 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2232 case EM_R32C: return "Renesas R32C series microprocessors";
2233 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2234 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2235 case EM_8051: return "Intel 8051 and variants";
2236 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2237 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2238 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2239 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2241 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2242 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2243 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2244 case EM_CR16:
f6c1a2d5 2245 case EM_MICROBLAZE:
7ba29e2a 2246 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2247 case EM_RL78: return "Renesas RL78";
c7927a3c 2248 case EM_RX: return "Renesas RX";
a3c62988 2249 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2250 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2251 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2252 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2253 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2254 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2255 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2256 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2257 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2258 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2259 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2260 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2261 default:
35d9dd2f 2262 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2263 return buff;
2264 }
2265}
2266
f3485b74 2267static void
d3ba0551 2268decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2269{
2270 unsigned eabi;
2271 int unknown = 0;
2272
2273 eabi = EF_ARM_EABI_VERSION (e_flags);
2274 e_flags &= ~ EF_ARM_EABIMASK;
2275
2276 /* Handle "generic" ARM flags. */
2277 if (e_flags & EF_ARM_RELEXEC)
2278 {
2279 strcat (buf, ", relocatable executable");
2280 e_flags &= ~ EF_ARM_RELEXEC;
2281 }
76da6bbe 2282
f3485b74
NC		 2283 /* Now handle EABI specific flags. */
2284 switch (eabi)
2285 {
2286 default:
2c71103e 2287 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2288 if (e_flags)
2289 unknown = 1;
2290 break;
2291
2292 case EF_ARM_EABI_VER1:
a5bcd848 2293 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2294 while (e_flags)
2295 {
2296 unsigned flag;
76da6bbe 2297
f3485b74
NC		 2298 /* Process flags one bit at a time. */
2299 flag = e_flags & - e_flags;
2300 e_flags &= ~ flag;
76da6bbe 2301
f3485b74
NC		 2302 switch (flag)
2303 {
a5bcd848 2304 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2305 strcat (buf, ", sorted symbol tables");
2306 break;
76da6bbe 2307
f3485b74
NC		 2308 default:
2309 unknown = 1;
2310 break;
2311 }
2312 }
2313 break;
76da6bbe 2314
a5bcd848
PB		 2315 case EF_ARM_EABI_VER2:
2316 strcat (buf, ", Version2 EABI");
2317 while (e_flags)
2318 {
2319 unsigned flag;
2320
2321 /* Process flags one bit at a time. */
2322 flag = e_flags & - e_flags;
2323 e_flags &= ~ flag;
2324
2325 switch (flag)
2326 {
2327 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2328 strcat (buf, ", sorted symbol tables");
2329 break;
2330
2331 case EF_ARM_DYNSYMSUSESEGIDX:
2332 strcat (buf, ", dynamic symbols use segment index");
2333 break;
2334
2335 case EF_ARM_MAPSYMSFIRST:
2336 strcat (buf, ", mapping symbols precede others");
2337 break;
2338
2339 default:
2340 unknown = 1;
2341 break;
2342 }
2343 }
2344 break;
2345
d507cf36
PB		 2346 case EF_ARM_EABI_VER3:
2347 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2348 break;
2349
2350 case EF_ARM_EABI_VER4:
2351 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2352 while (e_flags)
2353 {
2354 unsigned flag;
2355
2356 /* Process flags one bit at a time. */
2357 flag = e_flags & - e_flags;
2358 e_flags &= ~ flag;
2359
2360 switch (flag)
2361 {
2362 case EF_ARM_BE8:
2363 strcat (buf, ", BE8");
2364 break;
2365
2366 case EF_ARM_LE8:
2367 strcat (buf, ", LE8");
2368 break;
2369
2370 default:
2371 unknown = 1;
2372 break;
2373 }
2374 break;
2375 }
2376 break;
3a4a14e9
PB		 2377
2378 case EF_ARM_EABI_VER5:
2379 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2380 while (e_flags)
2381 {
2382 unsigned flag;
2383
2384 /* Process flags one bit at a time. */
2385 flag = e_flags & - e_flags;
2386 e_flags &= ~ flag;
2387
2388 switch (flag)
2389 {
2390 case EF_ARM_BE8:
2391 strcat (buf, ", BE8");
2392 break;
2393
2394 case EF_ARM_LE8:
2395 strcat (buf, ", LE8");
2396 break;
2397
3bfcb652
NC		 2398 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2399 strcat (buf, ", soft-float ABI");
2400 break;
2401
2402 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2403 strcat (buf, ", hard-float ABI");
2404 break;
2405
d507cf36
PB		 2406 default:
2407 unknown = 1;
2408 break;
2409 }
2410 }
2411 break;
2412
f3485b74 2413 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2414 strcat (buf, ", GNU EABI");
f3485b74
NC		 2415 while (e_flags)
2416 {
2417 unsigned flag;
76da6bbe 2418
f3485b74
NC		 2419 /* Process flags one bit at a time. */
2420 flag = e_flags & - e_flags;
2421 e_flags &= ~ flag;
76da6bbe 2422
f3485b74
NC		 2423 switch (flag)
2424 {
a5bcd848 2425 case EF_ARM_INTERWORK:
f3485b74
NC		 2426 strcat (buf, ", interworking enabled");
2427 break;
76da6bbe 2428
a5bcd848 2429 case EF_ARM_APCS_26:
f3485b74
NC		 2430 strcat (buf, ", uses APCS/26");
2431 break;
76da6bbe 2432
a5bcd848 2433 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2434 strcat (buf, ", uses APCS/float");
2435 break;
76da6bbe 2436
a5bcd848 2437 case EF_ARM_PIC:
f3485b74
NC		 2438 strcat (buf, ", position independent");
2439 break;
76da6bbe 2440
a5bcd848 2441 case EF_ARM_ALIGN8:
f3485b74
NC		 2442 strcat (buf, ", 8 bit structure alignment");
2443 break;
76da6bbe 2444
a5bcd848 2445 case EF_ARM_NEW_ABI:
f3485b74
NC		 2446 strcat (buf, ", uses new ABI");
2447 break;
76da6bbe 2448
a5bcd848 2449 case EF_ARM_OLD_ABI:
f3485b74
NC		 2450 strcat (buf, ", uses old ABI");
2451 break;
76da6bbe 2452
a5bcd848 2453 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2454 strcat (buf, ", software FP");
2455 break;
76da6bbe 2456
90e01f86
ILT		 2457 case EF_ARM_VFP_FLOAT:
2458 strcat (buf, ", VFP");
2459 break;
2460
fde78edd
NC		 2461 case EF_ARM_MAVERICK_FLOAT:
2462 strcat (buf, ", Maverick FP");
2463 break;
2464
f3485b74
NC		 2465 default:
2466 unknown = 1;
2467 break;
2468 }
2469 }
2470 }
f3485b74
NC		 2471
2472 if (unknown)
2b692964 2473 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2474}
2475
343433df
AB		 2476static void
2477decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2478{
2479 --size; /* Leave space for null terminator. */
2480
2481 switch (e_flags & EF_AVR_MACH)
2482 {
2483 case E_AVR_MACH_AVR1:
2484 strncat (buf, ", avr:1", size);
2485 break;
2486 case E_AVR_MACH_AVR2:
2487 strncat (buf, ", avr:2", size);
2488 break;
2489 case E_AVR_MACH_AVR25:
2490 strncat (buf, ", avr:25", size);
2491 break;
2492 case E_AVR_MACH_AVR3:
2493 strncat (buf, ", avr:3", size);
2494 break;
2495 case E_AVR_MACH_AVR31:
2496 strncat (buf, ", avr:31", size);
2497 break;
2498 case E_AVR_MACH_AVR35:
2499 strncat (buf, ", avr:35", size);
2500 break;
2501 case E_AVR_MACH_AVR4:
2502 strncat (buf, ", avr:4", size);
2503 break;
2504 case E_AVR_MACH_AVR5:
2505 strncat (buf, ", avr:5", size);
2506 break;
2507 case E_AVR_MACH_AVR51:
2508 strncat (buf, ", avr:51", size);
2509 break;
2510 case E_AVR_MACH_AVR6:
2511 strncat (buf, ", avr:6", size);
2512 break;
2513 case E_AVR_MACH_AVRTINY:
2514 strncat (buf, ", avr:100", size);
2515 break;
2516 case E_AVR_MACH_XMEGA1:
2517 strncat (buf, ", avr:101", size);
2518 break;
2519 case E_AVR_MACH_XMEGA2:
2520 strncat (buf, ", avr:102", size);
2521 break;
2522 case E_AVR_MACH_XMEGA3:
2523 strncat (buf, ", avr:103", size);
2524 break;
2525 case E_AVR_MACH_XMEGA4:
2526 strncat (buf, ", avr:104", size);
2527 break;
2528 case E_AVR_MACH_XMEGA5:
2529 strncat (buf, ", avr:105", size);
2530 break;
2531 case E_AVR_MACH_XMEGA6:
2532 strncat (buf, ", avr:106", size);
2533 break;
2534 case E_AVR_MACH_XMEGA7:
2535 strncat (buf, ", avr:107", size);
2536 break;
2537 default:
2538 strncat (buf, ", avr:<unknown>", size);
2539 break;
2540 }
2541
2542 size -= strlen (buf);
2543 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2544 strncat (buf, ", link-relax", size);
2545}
2546
35c08157
KLC		 2547static void
2548decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2549{
2550 unsigned abi;
2551 unsigned arch;
2552 unsigned config;
2553 unsigned version;
2554 int has_fpu = 0;
2555 int r = 0;
2556
2557 static const char *ABI_STRINGS[] =
2558 {
2559 "ABI v0", /* use r5 as return register; only used in N1213HC */
2560 "ABI v1", /* use r0 as return register */
2561 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2562 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2563 "AABI",
2564 "ABI2 FP+"
35c08157
KLC		 2565 };
2566 static const char *VER_STRINGS[] =
2567 {
2568 "Andes ELF V1.3 or older",
2569 "Andes ELF V1.3.1",
2570 "Andes ELF V1.4"
2571 };
2572 static const char *ARCH_STRINGS[] =
2573 {
2574 "",
2575 "Andes Star v1.0",
2576 "Andes Star v2.0",
2577 "Andes Star v3.0",
2578 "Andes Star v3.0m"
2579 };
2580
2581 abi = EF_NDS_ABI & e_flags;
2582 arch = EF_NDS_ARCH & e_flags;
2583 config = EF_NDS_INST & e_flags;
2584 version = EF_NDS32_ELF_VERSION & e_flags;
2585
2586 memset (buf, 0, size);
2587
2588 switch (abi)
2589 {
2590 case E_NDS_ABI_V0:
2591 case E_NDS_ABI_V1:
2592 case E_NDS_ABI_V2:
2593 case E_NDS_ABI_V2FP:
2594 case E_NDS_ABI_AABI:
40c7a7cb 2595 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2596 /* In case there are holes in the array. */
2597 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2598 break;
2599
2600 default:
2601 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2602 break;
2603 }
2604
2605 switch (version)
2606 {
2607 case E_NDS32_ELF_VER_1_2:
2608 case E_NDS32_ELF_VER_1_3:
2609 case E_NDS32_ELF_VER_1_4:
2610 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2611 break;
2612
2613 default:
2614 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2615 break;
2616 }
2617
2618 if (E_NDS_ABI_V0 == abi)
2619 {
2620 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2621 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2622 if (arch == E_NDS_ARCH_STAR_V1_0)
2623 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2624 return;
2625 }
2626
2627 switch (arch)
2628 {
2629 case E_NDS_ARCH_STAR_V1_0:
2630 case E_NDS_ARCH_STAR_V2_0:
2631 case E_NDS_ARCH_STAR_V3_0:
2632 case E_NDS_ARCH_STAR_V3_M:
2633 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2634 break;
2635
2636 default:
2637 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2638 /* ARCH version determines how the e_flags are interpreted.
2639 If it is unknown, we cannot proceed. */
2640 return;
2641 }
2642
2643 /* Newer ABI; Now handle architecture specific flags. */
2644 if (arch == E_NDS_ARCH_STAR_V1_0)
2645 {
2646 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2647 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2648
2649 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2650 r += snprintf (buf + r, size -r, ", MAC");
2651
2652 if (config & E_NDS32_HAS_DIV_INST)
2653 r += snprintf (buf + r, size -r, ", DIV");
2654
2655 if (config & E_NDS32_HAS_16BIT_INST)
2656 r += snprintf (buf + r, size -r, ", 16b");
2657 }
2658 else
2659 {
2660 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2661 {
2662 if (version <= E_NDS32_ELF_VER_1_3)
2663 r += snprintf (buf + r, size -r, ", [B8]");
2664 else
2665 r += snprintf (buf + r, size -r, ", EX9");
2666 }
2667
2668 if (config & E_NDS32_HAS_MAC_DX_INST)
2669 r += snprintf (buf + r, size -r, ", MAC_DX");
2670
2671 if (config & E_NDS32_HAS_DIV_DX_INST)
2672 r += snprintf (buf + r, size -r, ", DIV_DX");
2673
2674 if (config & E_NDS32_HAS_16BIT_INST)
2675 {
2676 if (version <= E_NDS32_ELF_VER_1_3)
2677 r += snprintf (buf + r, size -r, ", 16b");
2678 else
2679 r += snprintf (buf + r, size -r, ", IFC");
2680 }
2681 }
2682
2683 if (config & E_NDS32_HAS_EXT_INST)
2684 r += snprintf (buf + r, size -r, ", PERF1");
2685
2686 if (config & E_NDS32_HAS_EXT2_INST)
2687 r += snprintf (buf + r, size -r, ", PERF2");
2688
2689 if (config & E_NDS32_HAS_FPU_INST)
2690 {
2691 has_fpu = 1;
2692 r += snprintf (buf + r, size -r, ", FPU_SP");
2693 }
2694
2695 if (config & E_NDS32_HAS_FPU_DP_INST)
2696 {
2697 has_fpu = 1;
2698 r += snprintf (buf + r, size -r, ", FPU_DP");
2699 }
2700
2701 if (config & E_NDS32_HAS_FPU_MAC_INST)
2702 {
2703 has_fpu = 1;
2704 r += snprintf (buf + r, size -r, ", FPU_MAC");
2705 }
2706
2707 if (has_fpu)
2708 {
2709 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2710 {
2711 case E_NDS32_FPU_REG_8SP_4DP:
2712 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2713 break;
2714 case E_NDS32_FPU_REG_16SP_8DP:
2715 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2716 break;
2717 case E_NDS32_FPU_REG_32SP_16DP:
2718 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2719 break;
2720 case E_NDS32_FPU_REG_32SP_32DP:
2721 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2722 break;
2723 }
2724 }
2725
2726 if (config & E_NDS32_HAS_AUDIO_INST)
2727 r += snprintf (buf + r, size -r, ", AUDIO");
2728
2729 if (config & E_NDS32_HAS_STRING_INST)
2730 r += snprintf (buf + r, size -r, ", STR");
2731
2732 if (config & E_NDS32_HAS_REDUCED_REGS)
2733 r += snprintf (buf + r, size -r, ", 16REG");
2734
2735 if (config & E_NDS32_HAS_VIDEO_INST)
2736 {
2737 if (version <= E_NDS32_ELF_VER_1_3)
2738 r += snprintf (buf + r, size -r, ", VIDEO");
2739 else
2740 r += snprintf (buf + r, size -r, ", SATURATION");
2741 }
2742
2743 if (config & E_NDS32_HAS_ENCRIPT_INST)
2744 r += snprintf (buf + r, size -r, ", ENCRP");
2745
2746 if (config & E_NDS32_HAS_L2C_INST)
2747 r += snprintf (buf + r, size -r, ", L2C");
2748}
2749
252b5132 2750static char *
d3ba0551 2751get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2752{
b34976b6 2753 static char buf[1024];
252b5132
RH		 2754
2755 buf[0] = '\0';
76da6bbe 2756
252b5132
RH		 2757 if (e_flags)
2758 {
2759 switch (e_machine)
2760 {
2761 default:
2762 break;
2763
f3485b74
NC		 2764 case EM_ARM:
2765 decode_ARM_machine_flags (e_flags, buf);
2766 break;
76da6bbe 2767
343433df
AB		 2768 case EM_AVR:
2769 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2770 break;
2771
781303ce
MF		 2772 case EM_BLACKFIN:
2773 if (e_flags & EF_BFIN_PIC)
2774 strcat (buf, ", PIC");
2775
2776 if (e_flags & EF_BFIN_FDPIC)
2777 strcat (buf, ", FDPIC");
2778
2779 if (e_flags & EF_BFIN_CODE_IN_L1)
2780 strcat (buf, ", code in L1");
2781
2782 if (e_flags & EF_BFIN_DATA_IN_L1)
2783 strcat (buf, ", data in L1");
2784
2785 break;
2786
ec2dfb42
AO		 2787 case EM_CYGNUS_FRV:
2788 switch (e_flags & EF_FRV_CPU_MASK)
2789 {
2790 case EF_FRV_CPU_GENERIC:
2791 break;
2792
2793 default:
2794 strcat (buf, ", fr???");
2795 break;
57346661 2796
ec2dfb42
AO		 2797 case EF_FRV_CPU_FR300:
2798 strcat (buf, ", fr300");
2799 break;
2800
2801 case EF_FRV_CPU_FR400:
2802 strcat (buf, ", fr400");
2803 break;
2804 case EF_FRV_CPU_FR405:
2805 strcat (buf, ", fr405");
2806 break;
2807
2808 case EF_FRV_CPU_FR450:
2809 strcat (buf, ", fr450");
2810 break;
2811
2812 case EF_FRV_CPU_FR500:
2813 strcat (buf, ", fr500");
2814 break;
2815 case EF_FRV_CPU_FR550:
2816 strcat (buf, ", fr550");
2817 break;
2818
2819 case EF_FRV_CPU_SIMPLE:
2820 strcat (buf, ", simple");
2821 break;
2822 case EF_FRV_CPU_TOMCAT:
2823 strcat (buf, ", tomcat");
2824 break;
2825 }
1c877e87 2826 break;
ec2dfb42 2827
53c7db4b 2828 case EM_68K:
425c6cb0 2829 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2830 strcat (buf, ", m68000");
425c6cb0 2831 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2832 strcat (buf, ", cpu32");
2833 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2834 strcat (buf, ", fido_a");
425c6cb0 2835 else
266abb8f 2836 {
2cf0635d
NC		 2837 char const * isa = _("unknown");
2838 char const * mac = _("unknown mac");
2839 char const * additional = NULL;
0112cd26 2840
c694fd50 2841 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2842 {
c694fd50 2843 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2844 isa = "A";
2845 additional = ", nodiv";
2846 break;
c694fd50 2847 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2848 isa = "A";
2849 break;
c694fd50 2850 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2851 isa = "A+";
2852 break;
c694fd50 2853 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2854 isa = "B";
2855 additional = ", nousp";
2856 break;
c694fd50 2857 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2858 isa = "B";
2859 break;
f608cd77
NS		 2860 case EF_M68K_CF_ISA_C:
2861 isa = "C";
2862 break;
2863 case EF_M68K_CF_ISA_C_NODIV:
2864 isa = "C";
2865 additional = ", nodiv";
2866 break;
266abb8f
NS		 2867 }
2868 strcat (buf, ", cf, isa ");
2869 strcat (buf, isa);
0b2e31dc
NS		 2870 if (additional)
2871 strcat (buf, additional);
c694fd50 2872 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2873 strcat (buf, ", float");
c694fd50 2874 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2875 {
2876 case 0:
2877 mac = NULL;
2878 break;
c694fd50 2879 case EF_M68K_CF_MAC:
266abb8f
NS		 2880 mac = "mac";
2881 break;
c694fd50 2882 case EF_M68K_CF_EMAC:
266abb8f
NS		 2883 mac = "emac";
2884 break;
f608cd77
NS		 2885 case EF_M68K_CF_EMAC_B:
2886 mac = "emac_b";
2887 break;
266abb8f
NS		 2888 }
2889 if (mac)
2890 {
2891 strcat (buf, ", ");
2892 strcat (buf, mac);
2893 }
266abb8f 2894 }
53c7db4b 2895 break;
33c63f9d 2896
153a2776
NC		 2897 case EM_CYGNUS_MEP:
2898 switch (e_flags & EF_MEP_CPU_MASK)
2899 {
2900 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2901 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2902 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2903 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2904 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2905 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2906 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2907 }
2908
2909 switch (e_flags & EF_MEP_COP_MASK)
2910 {
2911 case EF_MEP_COP_NONE: break;
2912 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2913 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2914 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2915 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2916 default: strcat (buf, _("<unknown MeP copro type>")); break;
2917 }
2918
2919 if (e_flags & EF_MEP_LIBRARY)
2920 strcat (buf, ", Built for Library");
2921
2922 if (e_flags & EF_MEP_INDEX_MASK)
2923 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2924 e_flags & EF_MEP_INDEX_MASK);
2925
2926 if (e_flags & ~ EF_MEP_ALL_FLAGS)
2927 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2928 e_flags & ~ EF_MEP_ALL_FLAGS);
2929 break;
2930
252b5132
RH		 2931 case EM_PPC:
2932 if (e_flags & EF_PPC_EMB)
2933 strcat (buf, ", emb");
2934
2935 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2936 strcat (buf, _(", relocatable"));
252b5132
RH		 2937
2938 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2939 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2940 break;
2941
ee67d69a
AM		 2942 case EM_PPC64:
2943 if (e_flags & EF_PPC64_ABI)
2944 {
2945 char abi[] = ", abiv0";
2946
2947 abi[6] += e_flags & EF_PPC64_ABI;
2948 strcat (buf, abi);
2949 }
2950 break;
2951
708e2187
NC		 2952 case EM_V800:
2953 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2954 strcat (buf, ", RH850 ABI");
0b4362b0 2955
708e2187
NC		 2956 if (e_flags & EF_V800_850E3)
2957 strcat (buf, ", V3 architecture");
2958
2959 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2960 strcat (buf, ", FPU not used");
2961
2962 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2963 strcat (buf, ", regmode: COMMON");
2964
2965 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2966 strcat (buf, ", r4 not used");
2967
2968 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2969 strcat (buf, ", r30 not used");
2970
2971 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2972 strcat (buf, ", r5 not used");
2973
2974 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2975 strcat (buf, ", r2 not used");
2976
2977 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2978 {
2979 switch (e_flags & - e_flags)
2980 {
2981 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2982 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2983 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2984 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2985 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2986 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2987 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2988 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2989 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2990 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2991 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2992 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2993 default: break;
2994 }
2995 }
2996 break;
2997
2b0337b0 2998 case EM_V850:
252b5132
RH		 2999 case EM_CYGNUS_V850:
3000 switch (e_flags & EF_V850_ARCH)
3001 {
78c8d46c
NC		 3002 case E_V850E3V5_ARCH:
3003 strcat (buf, ", v850e3v5");
3004 break;
1cd986c5
NC		 3005 case E_V850E2V3_ARCH:
3006 strcat (buf, ", v850e2v3");
3007 break;
3008 case E_V850E2_ARCH:
3009 strcat (buf, ", v850e2");
3010 break;
3011 case E_V850E1_ARCH:
3012 strcat (buf, ", v850e1");
8ad30312 3013 break;
252b5132
RH		 3014 case E_V850E_ARCH:
3015 strcat (buf, ", v850e");
3016 break;
252b5132
RH		 3017 case E_V850_ARCH:
3018 strcat (buf, ", v850");
3019 break;
3020 default:
2b692964 3021 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3022 break;
3023 }
3024 break;
3025
2b0337b0 3026 case EM_M32R:
252b5132
RH		 3027 case EM_CYGNUS_M32R:
3028 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3029 strcat (buf, ", m32r");
252b5132
RH		 3030 break;
3031
3032 case EM_MIPS:
4fe85591 3033 case EM_MIPS_RS3_LE:
252b5132
RH		 3034 if (e_flags & EF_MIPS_NOREORDER)
3035 strcat (buf, ", noreorder");
3036
3037 if (e_flags & EF_MIPS_PIC)
3038 strcat (buf, ", pic");
3039
3040 if (e_flags & EF_MIPS_CPIC)
3041 strcat (buf, ", cpic");
3042
d1bdd336
TS		 3043 if (e_flags & EF_MIPS_UCODE)
3044 strcat (buf, ", ugen_reserved");
3045
252b5132
RH		 3046 if (e_flags & EF_MIPS_ABI2)
3047 strcat (buf, ", abi2");
3048
43521d43
TS		 3049 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3050 strcat (buf, ", odk first");
3051
a5d22d2a
TS		 3052 if (e_flags & EF_MIPS_32BITMODE)
3053 strcat (buf, ", 32bitmode");
3054
ba92f887
MR		 3055 if (e_flags & EF_MIPS_NAN2008)
3056 strcat (buf, ", nan2008");
3057
fef1b0b3
SE		 3058 if (e_flags & EF_MIPS_FP64)
3059 strcat (buf, ", fp64");
3060
156c2f8b
NC		 3061 switch ((e_flags & EF_MIPS_MACH))
3062 {
3063 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3064 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3065 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3066 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3067 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3068 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3069 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3070 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3071 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3072 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3073 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3074 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3075 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3076 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3077 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3078 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3079 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3080 case 0:
3081 /* We simply ignore the field in this case to avoid confusion:
3082 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3083 extension. */
3084 break;
2b692964 3085 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3086 }
43521d43
TS		 3087
3088 switch ((e_flags & EF_MIPS_ABI))
3089 {
3090 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3091 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3092 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3093 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3094 case 0:
3095 /* We simply ignore the field in this case to avoid confusion:
3096 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3097 This means it is likely to be an o32 file, but not for
3098 sure. */
3099 break;
2b692964 3100 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3101 }
3102
3103 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3104 strcat (buf, ", mdmx");
3105
3106 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3107 strcat (buf, ", mips16");
3108
df58fc94
RS		 3109 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3110 strcat (buf, ", micromips");
3111
43521d43
TS		 3112 switch ((e_flags & EF_MIPS_ARCH))
3113 {
3114 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3115 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3116 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3117 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3118 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3119 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3120 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3121 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3122 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3123 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3124 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3125 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3126 }
252b5132 3127 break;
351b4b40 3128
35c08157
KLC		 3129 case EM_NDS32:
3130 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3131 break;
3132
ccde1100
AO		 3133 case EM_SH:
3134 switch ((e_flags & EF_SH_MACH_MASK))
3135 {
3136 case EF_SH1: strcat (buf, ", sh1"); break;
3137 case EF_SH2: strcat (buf, ", sh2"); break;
3138 case EF_SH3: strcat (buf, ", sh3"); break;
3139 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3140 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3141 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3142 case EF_SH3E: strcat (buf, ", sh3e"); break;
3143 case EF_SH4: strcat (buf, ", sh4"); break;
3144 case EF_SH5: strcat (buf, ", sh5"); break;
3145 case EF_SH2E: strcat (buf, ", sh2e"); break;
3146 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3147 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3148 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3149 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3150 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3151 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3152 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3153 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3154 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3155 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3156 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3157 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3158 }
3159
cec6a5b8
MR		 3160 if (e_flags & EF_SH_PIC)
3161 strcat (buf, ", pic");
3162
3163 if (e_flags & EF_SH_FDPIC)
3164 strcat (buf, ", fdpic");
ccde1100 3165 break;
948f632f 3166
73589c9d
CS		 3167 case EM_OR1K:
3168 if (e_flags & EF_OR1K_NODELAY)
3169 strcat (buf, ", no delay");
3170 break;
57346661 3171
351b4b40
RH		 3172 case EM_SPARCV9:
3173 if (e_flags & EF_SPARC_32PLUS)
3174 strcat (buf, ", v8+");
3175
3176 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3177 strcat (buf, ", ultrasparcI");
3178
3179 if (e_flags & EF_SPARC_SUN_US3)
3180 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3181
3182 if (e_flags & EF_SPARC_HAL_R1)
3183 strcat (buf, ", halr1");
3184
3185 if (e_flags & EF_SPARC_LEDATA)
3186 strcat (buf, ", ledata");
3187
3188 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3189 strcat (buf, ", tso");
3190
3191 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3192 strcat (buf, ", pso");
3193
3194 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3195 strcat (buf, ", rmo");
3196 break;
7d466069 3197
103f02d3
UD		 3198 case EM_PARISC:
3199 switch (e_flags & EF_PARISC_ARCH)
3200 {
3201 case EFA_PARISC_1_0:
3202 strcpy (buf, ", PA-RISC 1.0");
3203 break;
3204 case EFA_PARISC_1_1:
3205 strcpy (buf, ", PA-RISC 1.1");
3206 break;
3207 case EFA_PARISC_2_0:
3208 strcpy (buf, ", PA-RISC 2.0");
3209 break;
3210 default:
3211 break;
3212 }
3213 if (e_flags & EF_PARISC_TRAPNIL)
3214 strcat (buf, ", trapnil");
3215 if (e_flags & EF_PARISC_EXT)
3216 strcat (buf, ", ext");
3217 if (e_flags & EF_PARISC_LSB)
3218 strcat (buf, ", lsb");
3219 if (e_flags & EF_PARISC_WIDE)
3220 strcat (buf, ", wide");
3221 if (e_flags & EF_PARISC_NO_KABP)
3222 strcat (buf, ", no kabp");
3223 if (e_flags & EF_PARISC_LAZYSWAP)
3224 strcat (buf, ", lazyswap");
30800947 3225 break;
76da6bbe 3226
7d466069 3227 case EM_PJ:
2b0337b0 3228 case EM_PJ_OLD:
7d466069
ILT		 3229 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3230 strcat (buf, ", new calling convention");
3231
3232 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3233 strcat (buf, ", gnu calling convention");
3234 break;
4d6ed7c8
NC		 3235
3236 case EM_IA_64:
3237 if ((e_flags & EF_IA_64_ABI64))
3238 strcat (buf, ", 64-bit");
3239 else
3240 strcat (buf, ", 32-bit");
3241 if ((e_flags & EF_IA_64_REDUCEDFP))
3242 strcat (buf, ", reduced fp model");
3243 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3244 strcat (buf, ", no function descriptors, constant gp");
3245 else if ((e_flags & EF_IA_64_CONS_GP))
3246 strcat (buf, ", constant gp");
3247 if ((e_flags & EF_IA_64_ABSOLUTE))
3248 strcat (buf, ", absolute");
28f997cf
TG		 3249 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3250 {
3251 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3252 strcat (buf, ", vms_linkages");
3253 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3254 {
3255 case EF_IA_64_VMS_COMCOD_SUCCESS:
3256 break;
3257 case EF_IA_64_VMS_COMCOD_WARNING:
3258 strcat (buf, ", warning");
3259 break;
3260 case EF_IA_64_VMS_COMCOD_ERROR:
3261 strcat (buf, ", error");
3262 break;
3263 case EF_IA_64_VMS_COMCOD_ABORT:
3264 strcat (buf, ", abort");
3265 break;
3266 default:
bee0ee85
NC		 3267 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3268 e_flags & EF_IA_64_VMS_COMCOD);
3269 strcat (buf, ", <unknown>");
28f997cf
TG		 3270 }
3271 }
4d6ed7c8 3272 break;
179d3252
JT		 3273
3274 case EM_VAX:
3275 if ((e_flags & EF_VAX_NONPIC))
3276 strcat (buf, ", non-PIC");
3277 if ((e_flags & EF_VAX_DFLOAT))
3278 strcat (buf, ", D-Float");
3279 if ((e_flags & EF_VAX_GFLOAT))
3280 strcat (buf, ", G-Float");
3281 break;
c7927a3c 3282
619ed720
EB		 3283 case EM_VISIUM:
3284 if (e_flags & EF_VISIUM_ARCH_MCM)
3285 strcat (buf, ", mcm");
3286 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3287 strcat (buf, ", mcm24");
3288 if (e_flags & EF_VISIUM_ARCH_GR6)
3289 strcat (buf, ", gr6");
3290 break;
3291
4046d87a 3292 case EM_RL78:
1740ba0c
NC		 3293 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3294 {
3295 case E_FLAG_RL78_ANY_CPU: break;
3296 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3297 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3298 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3299 }
856ea05c
KP		 3300 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3301 strcat (buf, ", 64-bit doubles");
4046d87a 3302 break;
0b4362b0 3303
c7927a3c
NC		 3304 case EM_RX:
3305 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3306 strcat (buf, ", 64-bit doubles");
3307 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3308 strcat (buf, ", dsp");
d4cb0ea0 3309 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3310 strcat (buf, ", pid");
708e2187
NC		 3311 if (e_flags & E_FLAG_RX_ABI)
3312 strcat (buf, ", RX ABI");
3525236c
NC		 3313 if (e_flags & E_FLAG_RX_SINSNS_SET)
3314 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3315 ? ", uses String instructions" : ", bans String instructions");
d4cb0ea0 3316 break;
55786da2
AK		 3317
3318 case EM_S390:
3319 if (e_flags & EF_S390_HIGH_GPRS)
3320 strcat (buf, ", highgprs");
d4cb0ea0 3321 break;
40b36596
JM		 3322
3323 case EM_TI_C6000:
3324 if ((e_flags & EF_C6000_REL))
3325 strcat (buf, ", relocatable module");
d4cb0ea0 3326 break;
13761a11
NC		 3327
3328 case EM_MSP430:
3329 strcat (buf, _(": architecture variant: "));
3330 switch (e_flags & EF_MSP430_MACH)
3331 {
3332 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3333 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3334 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3335 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3336 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3337 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3338 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3339 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3340 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3341 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3342 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3343 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3344 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3345 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3346 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3347 default:
3348 strcat (buf, _(": unknown")); break;
3349 }
3350
3351 if (e_flags & ~ EF_MSP430_MACH)
3352 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3353 }
3354 }
3355
3356 return buf;
3357}
3358
252b5132 3359static const char *
d3ba0551
AM		 3360get_osabi_name (unsigned int osabi)
3361{
3362 static char buff[32];
3363
3364 switch (osabi)
3365 {
3366 case ELFOSABI_NONE: return "UNIX - System V";
3367 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3368 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3369 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3370 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3371 case ELFOSABI_AIX: return "UNIX - AIX";
3372 case ELFOSABI_IRIX: return "UNIX - IRIX";
3373 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3374 case ELFOSABI_TRU64: return "UNIX - TRU64";
3375 case ELFOSABI_MODESTO: return "Novell - Modesto";
3376 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3377 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3378 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3379 case ELFOSABI_AROS: return "AROS";
11636f9e 3380 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3381 default:
40b36596
JM		 3382 if (osabi >= 64)
3383 switch (elf_header.e_machine)
3384 {
3385 case EM_ARM:
3386 switch (osabi)
3387 {
3388 case ELFOSABI_ARM: return "ARM";
3389 default:
3390 break;
3391 }
3392 break;
3393
3394 case EM_MSP430:
3395 case EM_MSP430_OLD:
619ed720 3396 case EM_VISIUM:
40b36596
JM		 3397 switch (osabi)
3398 {
3399 case ELFOSABI_STANDALONE: return _("Standalone App");
3400 default:
3401 break;
3402 }
3403 break;
3404
3405 case EM_TI_C6000:
3406 switch (osabi)
3407 {
3408 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3409 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3410 default:
3411 break;
3412 }
3413 break;
3414
3415 default:
3416 break;
3417 }
e9e44622 3418 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3419 return buff;
3420 }
3421}
3422
a06ea964
NC		 3423static const char *
3424get_aarch64_segment_type (unsigned long type)
3425{
3426 switch (type)
3427 {
3428 case PT_AARCH64_ARCHEXT:
3429 return "AARCH64_ARCHEXT";
3430 default:
3431 break;
3432 }
3433
3434 return NULL;
3435}
3436
b294bdf8
MM		 3437static const char *
3438get_arm_segment_type (unsigned long type)
3439{
3440 switch (type)
3441 {
3442 case PT_ARM_EXIDX:
3443 return "EXIDX";
3444 default:
3445 break;
3446 }
3447
3448 return NULL;
3449}
3450
d3ba0551
AM		 3451static const char *
3452get_mips_segment_type (unsigned long type)
252b5132
RH		 3453{
3454 switch (type)
3455 {
3456 case PT_MIPS_REGINFO:
3457 return "REGINFO";
3458 case PT_MIPS_RTPROC:
3459 return "RTPROC";
3460 case PT_MIPS_OPTIONS:
3461 return "OPTIONS";
351cdf24
MF		 3462 case PT_MIPS_ABIFLAGS:
3463 return "ABIFLAGS";
252b5132
RH		 3464 default:
3465 break;
3466 }
3467
3468 return NULL;
3469}
3470
103f02d3 3471static const char *
d3ba0551 3472get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3473{
3474 switch (type)
3475 {
3476 case PT_HP_TLS: return "HP_TLS";
3477 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3478 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3479 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3480 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3481 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3482 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3483 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3484 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3485 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3486 case PT_HP_PARALLEL: return "HP_PARALLEL";
3487 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3488 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3489 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3490 case PT_HP_STACK: return "HP_STACK";
3491 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3492 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3493 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3494 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3495 default:
3496 break;
3497 }
3498
3499 return NULL;
3500}
3501
4d6ed7c8 3502static const char *
d3ba0551 3503get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3504{
3505 switch (type)
3506 {
3507 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3508 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3509 case PT_HP_TLS: return "HP_TLS";
3510 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3511 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3512 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3513 default:
3514 break;
3515 }
3516
3517 return NULL;
3518}
3519
40b36596
JM		 3520static const char *
3521get_tic6x_segment_type (unsigned long type)
3522{
3523 switch (type)
3524 {
3525 case PT_C6000_PHATTR: return "C6000_PHATTR";
3526 default:
3527 break;
3528 }
3529
3530 return NULL;
3531}
3532
252b5132 3533static const char *
d3ba0551 3534get_segment_type (unsigned long p_type)
252b5132 3535{
b34976b6 3536 static char buff[32];
252b5132
RH		 3537
3538 switch (p_type)
3539 {
b34976b6
AM		 3540 case PT_NULL: return "NULL";
3541 case PT_LOAD: return "LOAD";
252b5132 3542 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3543 case PT_INTERP: return "INTERP";
3544 case PT_NOTE: return "NOTE";
3545 case PT_SHLIB: return "SHLIB";
3546 case PT_PHDR: return "PHDR";
13ae64f3 3547 case PT_TLS: return "TLS";
252b5132 3548
65765700
JJ		 3549 case PT_GNU_EH_FRAME:
3550 return "GNU_EH_FRAME";
2b05f1b7 3551 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3552 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3553
252b5132
RH		 3554 default:
3555 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3556 {
2cf0635d 3557 const char * result;
103f02d3 3558
252b5132
RH		 3559 switch (elf_header.e_machine)
3560 {
a06ea964
NC		 3561 case EM_AARCH64:
3562 result = get_aarch64_segment_type (p_type);
3563 break;
b294bdf8
MM		 3564 case EM_ARM:
3565 result = get_arm_segment_type (p_type);
3566 break;
252b5132 3567 case EM_MIPS:
4fe85591 3568 case EM_MIPS_RS3_LE:
252b5132
RH		 3569 result = get_mips_segment_type (p_type);
3570 break;
103f02d3
UD		 3571 case EM_PARISC:
3572 result = get_parisc_segment_type (p_type);
3573 break;
4d6ed7c8
NC		 3574 case EM_IA_64:
3575 result = get_ia64_segment_type (p_type);
3576 break;
40b36596
JM		 3577 case EM_TI_C6000:
3578 result = get_tic6x_segment_type (p_type);
3579 break;
252b5132
RH		 3580 default:
3581 result = NULL;
3582 break;
3583 }
103f02d3 3584
252b5132
RH		 3585 if (result != NULL)
3586 return result;
103f02d3 3587
252b5132
RH		 3588 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3589 }
3590 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3591 {
2cf0635d 3592 const char * result;
103f02d3
UD		 3593
3594 switch (elf_header.e_machine)
3595 {
3596 case EM_PARISC:
3597 result = get_parisc_segment_type (p_type);
3598 break;
00428cca
AM		 3599 case EM_IA_64:
3600 result = get_ia64_segment_type (p_type);
3601 break;
103f02d3
UD		 3602 default:
3603 result = NULL;
3604 break;
3605 }
3606
3607 if (result != NULL)
3608 return result;
3609
3610 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3611 }
252b5132 3612 else
e9e44622 3613 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3614
3615 return buff;
3616 }
3617}
3618
3619static const char *
d3ba0551 3620get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3621{
3622 switch (sh_type)
3623 {
b34976b6
AM		 3624 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3625 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3626 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3627 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3628 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3629 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3630 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3631 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3632 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3633 case SHT_MIPS_RELD: return "MIPS_RELD";
3634 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3635 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3636 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3637 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3638 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3639 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3640 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3641 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3642 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3643 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3644 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3645 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3646 case SHT_MIPS_LINE: return "MIPS_LINE";
3647 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3648 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3649 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3650 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3651 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3652 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3653 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3654 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3655 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3656 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3657 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3658 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3659 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3660 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3661 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3662 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3663 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3664 default:
3665 break;
3666 }
3667 return NULL;
3668}
3669
103f02d3 3670static const char *
d3ba0551 3671get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3672{
3673 switch (sh_type)
3674 {
3675 case SHT_PARISC_EXT: return "PARISC_EXT";
3676 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3677 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3678 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3679 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3680 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3681 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3682 default:
3683 break;
3684 }
3685 return NULL;
3686}
3687
4d6ed7c8 3688static const char *
d3ba0551 3689get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3690{
18bd398b 3691 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3692 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3693 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3694
4d6ed7c8
NC		 3695 switch (sh_type)
3696 {
148b93f2
NC		 3697 case SHT_IA_64_EXT: return "IA_64_EXT";
3698 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3699 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3700 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3701 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3702 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3703 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3704 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3705 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3706 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3707 default:
3708 break;
3709 }
3710 return NULL;
3711}
3712
d2b2c203
DJ		 3713static const char *
3714get_x86_64_section_type_name (unsigned int sh_type)
3715{
3716 switch (sh_type)
3717 {
3718 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3719 default:
3720 break;
3721 }
3722 return NULL;
3723}
3724
a06ea964
NC		 3725static const char *
3726get_aarch64_section_type_name (unsigned int sh_type)
3727{
3728 switch (sh_type)
3729 {
3730 case SHT_AARCH64_ATTRIBUTES:
3731 return "AARCH64_ATTRIBUTES";
3732 default:
3733 break;
3734 }
3735 return NULL;
3736}
3737
40a18ebd
NC		 3738static const char *
3739get_arm_section_type_name (unsigned int sh_type)
3740{
3741 switch (sh_type)
3742 {
7f6fed87
NC		 3743 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3744 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3745 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3746 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3747 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3748 default:
3749 break;
3750 }
3751 return NULL;
3752}
3753
40b36596
JM		 3754static const char *
3755get_tic6x_section_type_name (unsigned int sh_type)
3756{
3757 switch (sh_type)
3758 {
3759 case SHT_C6000_UNWIND:
3760 return "C6000_UNWIND";
3761 case SHT_C6000_PREEMPTMAP:
3762 return "C6000_PREEMPTMAP";
3763 case SHT_C6000_ATTRIBUTES:
3764 return "C6000_ATTRIBUTES";
3765 case SHT_TI_ICODE:
3766 return "TI_ICODE";
3767 case SHT_TI_XREF:
3768 return "TI_XREF";
3769 case SHT_TI_HANDLER:
3770 return "TI_HANDLER";
3771 case SHT_TI_INITINFO:
3772 return "TI_INITINFO";
3773 case SHT_TI_PHATTRS:
3774 return "TI_PHATTRS";
3775 default:
3776 break;
3777 }
3778 return NULL;
3779}
3780
13761a11
NC		 3781static const char *
3782get_msp430x_section_type_name (unsigned int sh_type)
3783{
3784 switch (sh_type)
3785 {
3786 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3787 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3788 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3789 default: return NULL;
3790 }
3791}
3792
685080f2
NC		 3793static const char *
3794get_v850_section_type_name (unsigned int sh_type)
3795{
3796 switch (sh_type)
3797 {
3798 case SHT_V850_SCOMMON: return "V850 Small Common";
3799 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3800 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3801 case SHT_RENESAS_IOP: return "RENESAS IOP";
3802 case SHT_RENESAS_INFO: return "RENESAS INFO";
3803 default: return NULL;
3804 }
3805}
3806
252b5132 3807static const char *
d3ba0551 3808get_section_type_name (unsigned int sh_type)
252b5132 3809{
b34976b6 3810 static char buff[32];
252b5132
RH		 3811
3812 switch (sh_type)
3813 {
3814 case SHT_NULL: return "NULL";
3815 case SHT_PROGBITS: return "PROGBITS";
3816 case SHT_SYMTAB: return "SYMTAB";
3817 case SHT_STRTAB: return "STRTAB";
3818 case SHT_RELA: return "RELA";
3819 case SHT_HASH: return "HASH";
3820 case SHT_DYNAMIC: return "DYNAMIC";
3821 case SHT_NOTE: return "NOTE";
3822 case SHT_NOBITS: return "NOBITS";
3823 case SHT_REL: return "REL";
3824 case SHT_SHLIB: return "SHLIB";
3825 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3826 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3827 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3828 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3829 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3830 case SHT_GROUP: return "GROUP";
3831 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3832 case SHT_GNU_verdef: return "VERDEF";
3833 case SHT_GNU_verneed: return "VERNEED";
3834 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3835 case 0x6ffffff0: return "VERSYM";
3836 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3837 case 0x7ffffffd: return "AUXILIARY";
3838 case 0x7fffffff: return "FILTER";
047b2264 3839 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3840
3841 default:
3842 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3843 {
2cf0635d 3844 const char * result;
252b5132
RH		 3845
3846 switch (elf_header.e_machine)
3847 {
3848 case EM_MIPS:
4fe85591 3849 case EM_MIPS_RS3_LE:
252b5132
RH		 3850 result = get_mips_section_type_name (sh_type);
3851 break;
103f02d3
UD		 3852 case EM_PARISC:
3853 result = get_parisc_section_type_name (sh_type);
3854 break;
4d6ed7c8
NC		 3855 case EM_IA_64:
3856 result = get_ia64_section_type_name (sh_type);
3857 break;
d2b2c203 3858 case EM_X86_64:
8a9036a4 3859 case EM_L1OM:
7a9068fe 3860 case EM_K1OM:
d2b2c203
DJ		 3861 result = get_x86_64_section_type_name (sh_type);
3862 break;
a06ea964
NC		 3863 case EM_AARCH64:
3864 result = get_aarch64_section_type_name (sh_type);
3865 break;
40a18ebd
NC		 3866 case EM_ARM:
3867 result = get_arm_section_type_name (sh_type);
3868 break;
40b36596
JM		 3869 case EM_TI_C6000:
3870 result = get_tic6x_section_type_name (sh_type);
3871 break;
13761a11
NC		 3872 case EM_MSP430:
3873 result = get_msp430x_section_type_name (sh_type);
3874 break;
685080f2
NC		 3875 case EM_V800:
3876 case EM_V850:
3877 case EM_CYGNUS_V850:
3878 result = get_v850_section_type_name (sh_type);
3879 break;
252b5132
RH		 3880 default:
3881 result = NULL;
3882 break;
3883 }
3884
3885 if (result != NULL)
3886 return result;
3887
c91d0dfb 3888 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3889 }
3890 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3891 {
2cf0635d 3892 const char * result;
148b93f2
NC		 3893
3894 switch (elf_header.e_machine)
3895 {
3896 case EM_IA_64:
3897 result = get_ia64_section_type_name (sh_type);
3898 break;
3899 default:
3900 result = NULL;
3901 break;
3902 }
3903
3904 if (result != NULL)
3905 return result;
3906
3907 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3908 }
252b5132 3909 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3910 {
3911 switch (elf_header.e_machine)
3912 {
3913 case EM_V800:
3914 case EM_V850:
3915 case EM_CYGNUS_V850:
3916 return get_v850_section_type_name (sh_type);
3917 default:
3918 break;
3919 }
3920
3921 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3922 }
252b5132 3923 else
a7dbfd1c
NC		 3924 /* This message is probably going to be displayed in a 15
3925 character wide field, so put the hex value first. */
3926 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3927
252b5132
RH		 3928 return buff;
3929 }
3930}
3931
2979dc34 3932#define OPTION_DEBUG_DUMP 512
2c610e4b 3933#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3934#define OPTION_DWARF_DEPTH 514
3935#define OPTION_DWARF_START 515
4723351a 3936#define OPTION_DWARF_CHECK 516
2979dc34 3937
85b1c36d 3938static struct option options[] =
252b5132 3939{
b34976b6 3940 {"all", no_argument, 0, 'a'},
252b5132
RH		 3941 {"file-header", no_argument, 0, 'h'},
3942 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3943 {"headers", no_argument, 0, 'e'},
3944 {"histogram", no_argument, 0, 'I'},
3945 {"segments", no_argument, 0, 'l'},
3946 {"sections", no_argument, 0, 'S'},
252b5132 3947 {"section-headers", no_argument, 0, 'S'},
f5842774 3948 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3949 {"section-details", no_argument, 0, 't'},
595cf52e 3950 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3951 {"symbols", no_argument, 0, 's'},
3952 {"syms", no_argument, 0, 's'},
2c610e4b 3953 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3954 {"relocs", no_argument, 0, 'r'},
3955 {"notes", no_argument, 0, 'n'},
3956 {"dynamic", no_argument, 0, 'd'},
a952a375 3957 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3958 {"version-info", no_argument, 0, 'V'},
3959 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3960 {"unwind", no_argument, 0, 'u'},
4145f1d5 3961 {"archive-index", no_argument, 0, 'c'},
b34976b6 3962 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3963 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3964 {"string-dump", required_argument, 0, 'p'},
0e602686 3965 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 3966#ifdef SUPPORT_DISASSEMBLY
3967 {"instruction-dump", required_argument, 0, 'i'},
3968#endif
cf13d699 3969 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3970
fd2f0033
TT		 3971 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3972 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3973 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3974
b34976b6
AM		 3975 {"version", no_argument, 0, 'v'},
3976 {"wide", no_argument, 0, 'W'},
3977 {"help", no_argument, 0, 'H'},
3978 {0, no_argument, 0, 0}
252b5132
RH		 3979};
3980
3981static void
2cf0635d 3982usage (FILE * stream)
252b5132 3983{
92f01d61
JM		 3984 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3985 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3986 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3987 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3988 -h --file-header Display the ELF file header\n\
3989 -l --program-headers Display the program headers\n\
3990 --segments An alias for --program-headers\n\
3991 -S --section-headers Display the sections' header\n\
3992 --sections An alias for --section-headers\n\
f5842774 3993 -g --section-groups Display the section groups\n\
5477e8a0 3994 -t --section-details Display the section details\n\
8b53311e
NC		 3995 -e --headers Equivalent to: -h -l -S\n\
3996 -s --syms Display the symbol table\n\
3f08eb35 3997 --symbols An alias for --syms\n\
2c610e4b 3998 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3999 -n --notes Display the core notes (if present)\n\
4000 -r --relocs Display the relocations (if present)\n\
4001 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4002 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4003 -V --version-info Display the version sections (if present)\n\
1b31d05e 4004 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4005 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4006 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4007 -x --hex-dump=<number|name>\n\
4008 Dump the contents of section <number|name> as bytes\n\
4009 -p --string-dump=<number|name>\n\
4010 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4011 -R --relocated-dump=<number|name>\n\
4012 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4013 -z --decompress Decompress section before dumping it\n\
f9f0e732 4014 -w[lLiaprmfFsoRt] or\n\
1ed06042 4015 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4016 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4017 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4018 =addr,=cu_index]\n\
8b53311e 4019 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4020 fprintf (stream, _("\
4021 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4022 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4023 or deeper\n"));
252b5132 4024#ifdef SUPPORT_DISASSEMBLY
92f01d61 4025 fprintf (stream, _("\
09c11c86
NC		 4026 -i --instruction-dump=<number|name>\n\
4027 Disassemble the contents of section <number|name>\n"));
252b5132 4028#endif
92f01d61 4029 fprintf (stream, _("\
8b53311e
NC		 4030 -I --histogram Display histogram of bucket list lengths\n\
4031 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4032 @<file> Read options from <file>\n\
8b53311e
NC		 4033 -H --help Display this information\n\
4034 -v --version Display the version number of readelf\n"));
1118d252 4035
92f01d61
JM		 4036 if (REPORT_BUGS_TO[0] && stream == stdout)
4037 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4038
92f01d61 4039 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4040}
4041
18bd398b
NC		 4042/* Record the fact that the user wants the contents of section number
4043 SECTION to be displayed using the method(s) encoded as flags bits
4044 in TYPE. Note, TYPE can be zero if we are creating the array for
4045 the first time. */
4046
252b5132 4047static void
09c11c86 4048request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4049{
4050 if (section >= num_dump_sects)
4051 {
2cf0635d 4052 dump_type * new_dump_sects;
252b5132 4053
3f5e193b
NC		 4054 new_dump_sects = (dump_type *) calloc (section + 1,
4055 sizeof (* dump_sects));
252b5132
RH		 4056
4057 if (new_dump_sects == NULL)
591a748a 4058 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4059 else
4060 {
4061 /* Copy current flag settings. */
09c11c86 4062 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4063
4064 free (dump_sects);
4065
4066 dump_sects = new_dump_sects;
4067 num_dump_sects = section + 1;
4068 }
4069 }
4070
4071 if (dump_sects)
b34976b6 4072 dump_sects[section] |= type;
252b5132
RH		 4073
4074 return;
4075}
4076
aef1f6d0
DJ		 4077/* Request a dump by section name. */
4078
4079static void
2cf0635d 4080request_dump_byname (const char * section, dump_type type)
aef1f6d0 4081{
2cf0635d 4082 struct dump_list_entry * new_request;
aef1f6d0 4083
3f5e193b
NC		 4084 new_request = (struct dump_list_entry *)
4085 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4086 if (!new_request)
591a748a 4087 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4088
4089 new_request->name = strdup (section);
4090 if (!new_request->name)
591a748a 4091 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4092
4093 new_request->type = type;
4094
4095 new_request->next = dump_sects_byname;
4096 dump_sects_byname = new_request;
4097}
4098
cf13d699
NC		 4099static inline void
4100request_dump (dump_type type)
4101{
4102 int section;
4103 char * cp;
4104
4105 do_dump++;
4106 section = strtoul (optarg, & cp, 0);
4107
4108 if (! *cp && section >= 0)
4109 request_dump_bynumber (section, type);
4110 else
4111 request_dump_byname (optarg, type);
4112}
4113
4114
252b5132 4115static void
2cf0635d 4116parse_args (int argc, char ** argv)
252b5132
RH		 4117{
4118 int c;
4119
4120 if (argc < 2)
92f01d61 4121 usage (stderr);
252b5132
RH		 4122
4123 while ((c = getopt_long
0e602686 4124 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4125 {
252b5132
RH		 4126 switch (c)
4127 {
4128 case 0:
4129 /* Long options. */
4130 break;
4131 case 'H':
92f01d61 4132 usage (stdout);
252b5132
RH		 4133 break;
4134
4135 case 'a':
b34976b6
AM		 4136 do_syms++;
4137 do_reloc++;
4138 do_unwind++;
4139 do_dynamic++;
4140 do_header++;
4141 do_sections++;
f5842774 4142 do_section_groups++;
b34976b6
AM		 4143 do_segments++;
4144 do_version++;
4145 do_histogram++;
4146 do_arch++;
4147 do_notes++;
252b5132 4148 break;
f5842774
L		 4149 case 'g':
4150 do_section_groups++;
4151 break;
5477e8a0 4152 case 't':
595cf52e 4153 case 'N':
5477e8a0
L		 4154 do_sections++;
4155 do_section_details++;
595cf52e 4156 break;
252b5132 4157 case 'e':
b34976b6
AM		 4158 do_header++;
4159 do_sections++;
4160 do_segments++;
252b5132 4161 break;
a952a375 4162 case 'A':
b34976b6 4163 do_arch++;
a952a375 4164 break;
252b5132 4165 case 'D':
b34976b6 4166 do_using_dynamic++;
252b5132
RH		 4167 break;
4168 case 'r':
b34976b6 4169 do_reloc++;
252b5132 4170 break;
4d6ed7c8 4171 case 'u':
b34976b6 4172 do_unwind++;
4d6ed7c8 4173 break;
252b5132 4174 case 'h':
b34976b6 4175 do_header++;
252b5132
RH		 4176 break;
4177 case 'l':
b34976b6 4178 do_segments++;
252b5132
RH		 4179 break;
4180 case 's':
b34976b6 4181 do_syms++;
252b5132
RH		 4182 break;
4183 case 'S':
b34976b6 4184 do_sections++;
252b5132
RH		 4185 break;
4186 case 'd':
b34976b6 4187 do_dynamic++;
252b5132 4188 break;
a952a375 4189 case 'I':
b34976b6 4190 do_histogram++;
a952a375 4191 break;
779fe533 4192 case 'n':
b34976b6 4193 do_notes++;
779fe533 4194 break;
4145f1d5
NC		 4195 case 'c':
4196 do_archive_index++;
4197 break;
252b5132 4198 case 'x':
cf13d699 4199 request_dump (HEX_DUMP);
aef1f6d0 4200 break;
09c11c86 4201 case 'p':
cf13d699
NC		 4202 request_dump (STRING_DUMP);
4203 break;
4204 case 'R':
4205 request_dump (RELOC_DUMP);
09c11c86 4206 break;
0e602686
NC		 4207 case 'z':
4208 decompress_dumps++;
4209 break;
252b5132 4210 case 'w':
b34976b6 4211 do_dump++;
252b5132 4212 if (optarg == 0)
613ff48b
CC		 4213 {
4214 do_debugging = 1;
4215 dwarf_select_sections_all ();
4216 }
252b5132
RH		 4217 else
4218 {
4219 do_debugging = 0;
4cb93e3b 4220 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4221 }
4222 break;
2979dc34 4223 case OPTION_DEBUG_DUMP:
b34976b6 4224 do_dump++;
2979dc34
JJ		 4225 if (optarg == 0)
4226 do_debugging = 1;
4227 else
4228 {
2979dc34 4229 do_debugging = 0;
4cb93e3b 4230 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4231 }
4232 break;
fd2f0033
TT		 4233 case OPTION_DWARF_DEPTH:
4234 {
4235 char *cp;
4236
4237 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4238 }
4239 break;
4240 case OPTION_DWARF_START:
4241 {
4242 char *cp;
4243
4244 dwarf_start_die = strtoul (optarg, & cp, 0);
4245 }
4246 break;
4723351a
CC		 4247 case OPTION_DWARF_CHECK:
4248 dwarf_check = 1;
4249 break;
2c610e4b
L		 4250 case OPTION_DYN_SYMS:
4251 do_dyn_syms++;
4252 break;
252b5132
RH		 4253#ifdef SUPPORT_DISASSEMBLY
4254 case 'i':
cf13d699
NC		 4255 request_dump (DISASS_DUMP);
4256 break;
252b5132
RH		 4257#endif
4258 case 'v':
4259 print_version (program_name);
4260 break;
4261 case 'V':
b34976b6 4262 do_version++;
252b5132 4263 break;
d974e256 4264 case 'W':
b34976b6 4265 do_wide++;
d974e256 4266 break;
252b5132 4267 default:
252b5132
RH		 4268 /* xgettext:c-format */
4269 error (_("Invalid option '-%c'\n"), c);
4270 /* Drop through. */
4271 case '?':
92f01d61 4272 usage (stderr);
252b5132
RH		 4273 }
4274 }
4275
4d6ed7c8 4276 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4277 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4278 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4279 && !do_section_groups && !do_archive_index
4280 && !do_dyn_syms)
92f01d61 4281 usage (stderr);
252b5132
RH		 4282}
4283
4284static const char *
d3ba0551 4285get_elf_class (unsigned int elf_class)
252b5132 4286{
b34976b6 4287 static char buff[32];
103f02d3 4288
252b5132
RH		 4289 switch (elf_class)
4290 {
4291 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4292 case ELFCLASS32: return "ELF32";
4293 case ELFCLASS64: return "ELF64";
ab5e7794 4294 default:
e9e44622 4295 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4296 return buff;
252b5132
RH		 4297 }
4298}
4299
4300static const char *
d3ba0551 4301get_data_encoding (unsigned int encoding)
252b5132 4302{
b34976b6 4303 static char buff[32];
103f02d3 4304
252b5132
RH		 4305 switch (encoding)
4306 {
4307 case ELFDATANONE: return _("none");
33c63f9d
CM		 4308 case ELFDATA2LSB: return _("2's complement, little endian");
4309 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4310 default:
e9e44622 4311 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4312 return buff;
252b5132
RH		 4313 }
4314}
4315
252b5132 4316/* Decode the data held in 'elf_header'. */
ee42cf8c 4317
252b5132 4318static int
d3ba0551 4319process_file_header (void)
252b5132 4320{
b34976b6
AM		 4321 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4322 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4323 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4324 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4325 {
4326 error
4327 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4328 return 0;
4329 }
4330
2dc4cec1
L		 4331 init_dwarf_regnames (elf_header.e_machine);
4332
252b5132
RH		 4333 if (do_header)
4334 {
4335 int i;
4336
4337 printf (_("ELF Header:\n"));
4338 printf (_(" Magic: "));
b34976b6
AM		 4339 for (i = 0; i < EI_NIDENT; i++)
4340 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4341 printf ("\n");
4342 printf (_(" Class: %s\n"),
b34976b6 4343 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4344 printf (_(" Data: %s\n"),
b34976b6 4345 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4346 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4347 elf_header.e_ident[EI_VERSION],
4348 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4349 ? "(current)"
b34976b6 4350 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4351 ? _("<unknown: %lx>")
789be9f7 4352 : "")));
252b5132 4353 printf (_(" OS/ABI: %s\n"),
b34976b6 4354 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4355 printf (_(" ABI Version: %d\n"),
b34976b6 4356 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4357 printf (_(" Type: %s\n"),
4358 get_file_type (elf_header.e_type));
4359 printf (_(" Machine: %s\n"),
4360 get_machine_name (elf_header.e_machine));
4361 printf (_(" Version: 0x%lx\n"),
4362 (unsigned long) elf_header.e_version);
76da6bbe 4363
f7a99963
NC		 4364 printf (_(" Entry point address: "));
4365 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4366 printf (_("\n Start of program headers: "));
4367 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4368 printf (_(" (bytes into file)\n Start of section headers: "));
4369 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4370 printf (_(" (bytes into file)\n"));
76da6bbe 4371
252b5132
RH		 4372 printf (_(" Flags: 0x%lx%s\n"),
4373 (unsigned long) elf_header.e_flags,
4374 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4375 printf (_(" Size of this header: %ld (bytes)\n"),
4376 (long) elf_header.e_ehsize);
4377 printf (_(" Size of program headers: %ld (bytes)\n"),
4378 (long) elf_header.e_phentsize);
2046a35d 4379 printf (_(" Number of program headers: %ld"),
252b5132 4380 (long) elf_header.e_phnum);
2046a35d
AM		 4381 if (section_headers != NULL
4382 && elf_header.e_phnum == PN_XNUM
4383 && section_headers[0].sh_info != 0)
cc5914eb 4384 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4385 putc ('\n', stdout);
252b5132
RH		 4386 printf (_(" Size of section headers: %ld (bytes)\n"),
4387 (long) elf_header.e_shentsize);
560f3c1c 4388 printf (_(" Number of section headers: %ld"),
252b5132 4389 (long) elf_header.e_shnum);
4fbb74a6 4390 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4391 printf (" (%ld)", (long) section_headers[0].sh_size);
4392 putc ('\n', stdout);
4393 printf (_(" Section header string table index: %ld"),
252b5132 4394 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4395 if (section_headers != NULL
4396 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4397 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4398 else if (elf_header.e_shstrndx != SHN_UNDEF
4399 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4400 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4401 putc ('\n', stdout);
4402 }
4403
4404 if (section_headers != NULL)
4405 {
2046a35d
AM		 4406 if (elf_header.e_phnum == PN_XNUM
4407 && section_headers[0].sh_info != 0)
4408 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4409 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4410 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4411 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4412 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4413 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4414 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4415 free (section_headers);
4416 section_headers = NULL;
252b5132 4417 }
103f02d3 4418
9ea033b2
NC		 4419 return 1;
4420}
4421
e0a31db1 4422static bfd_boolean
91d6fa6a 4423get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4424{
2cf0635d
NC		 4425 Elf32_External_Phdr * phdrs;
4426 Elf32_External_Phdr * external;
4427 Elf_Internal_Phdr * internal;
b34976b6 4428 unsigned int i;
e0a31db1
NC		 4429 unsigned int size = elf_header.e_phentsize;
4430 unsigned int num = elf_header.e_phnum;
4431
4432 /* PR binutils/17531: Cope with unexpected section header sizes. */
4433 if (size == 0 || num == 0)
4434 return FALSE;
4435 if (size < sizeof * phdrs)
4436 {
4437 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4438 return FALSE;
4439 }
4440 if (size > sizeof * phdrs)
4441 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4442
3f5e193b 4443 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4444 size, num, _("program headers"));
4445 if (phdrs == NULL)
4446 return FALSE;
9ea033b2 4447
91d6fa6a 4448 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4449 i < elf_header.e_phnum;
b34976b6 4450 i++, internal++, external++)
252b5132 4451 {
9ea033b2
NC		 4452 internal->p_type = BYTE_GET (external->p_type);
4453 internal->p_offset = BYTE_GET (external->p_offset);
4454 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4455 internal->p_paddr = BYTE_GET (external->p_paddr);
4456 internal->p_filesz = BYTE_GET (external->p_filesz);
4457 internal->p_memsz = BYTE_GET (external->p_memsz);
4458 internal->p_flags = BYTE_GET (external->p_flags);
4459 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4460 }
4461
9ea033b2 4462 free (phdrs);
e0a31db1 4463 return TRUE;
252b5132
RH		 4464}
4465
e0a31db1 4466static bfd_boolean
91d6fa6a 4467get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4468{
2cf0635d
NC		 4469 Elf64_External_Phdr * phdrs;
4470 Elf64_External_Phdr * external;
4471 Elf_Internal_Phdr * internal;
b34976b6 4472 unsigned int i;
e0a31db1
NC		 4473 unsigned int size = elf_header.e_phentsize;
4474 unsigned int num = elf_header.e_phnum;
4475
4476 /* PR binutils/17531: Cope with unexpected section header sizes. */
4477 if (size == 0 || num == 0)
4478 return FALSE;
4479 if (size < sizeof * phdrs)
4480 {
4481 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4482 return FALSE;
4483 }
4484 if (size > sizeof * phdrs)
4485 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4486
3f5e193b 4487 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4488 size, num, _("program headers"));
a6e9f9df 4489 if (!phdrs)
e0a31db1 4490 return FALSE;
9ea033b2 4491
91d6fa6a 4492 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4493 i < elf_header.e_phnum;
b34976b6 4494 i++, internal++, external++)
9ea033b2
NC		 4495 {
4496 internal->p_type = BYTE_GET (external->p_type);
4497 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4498 internal->p_offset = BYTE_GET (external->p_offset);
4499 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4500 internal->p_paddr = BYTE_GET (external->p_paddr);
4501 internal->p_filesz = BYTE_GET (external->p_filesz);
4502 internal->p_memsz = BYTE_GET (external->p_memsz);
4503 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4504 }
4505
4506 free (phdrs);
e0a31db1 4507 return TRUE;
9ea033b2 4508}
252b5132 4509
d93f0186
NC		 4510/* Returns 1 if the program headers were read into `program_headers'. */
4511
4512static int
2cf0635d 4513get_program_headers (FILE * file)
d93f0186 4514{
2cf0635d 4515 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4516
4517 /* Check cache of prior read. */
4518 if (program_headers != NULL)
4519 return 1;
4520
3f5e193b
NC		 4521 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4522 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4523
4524 if (phdrs == NULL)
4525 {
8b73c356
NC		 4526 error (_("Out of memory reading %u program headers\n"),
4527 elf_header.e_phnum);
d93f0186
NC		 4528 return 0;
4529 }
4530
4531 if (is_32bit_elf
4532 ? get_32bit_program_headers (file, phdrs)
4533 : get_64bit_program_headers (file, phdrs))
4534 {
4535 program_headers = phdrs;
4536 return 1;
4537 }
4538
4539 free (phdrs);
4540 return 0;
4541}
4542
2f62977e
NC		 4543/* Returns 1 if the program headers were loaded. */
4544
252b5132 4545static int
2cf0635d 4546process_program_headers (FILE * file)
252b5132 4547{
2cf0635d 4548 Elf_Internal_Phdr * segment;
b34976b6 4549 unsigned int i;
252b5132
RH		 4550
4551 if (elf_header.e_phnum == 0)
4552 {
82f2dbf7
NC		 4553 /* PR binutils/12467. */
4554 if (elf_header.e_phoff != 0)
4555 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4556 " header offset, but no program headers\n"));
82f2dbf7 4557 else if (do_segments)
252b5132 4558 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4559 return 0;
252b5132
RH		 4560 }
4561
4562 if (do_segments && !do_header)
4563 {
f7a99963
NC		 4564 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4565 printf (_("Entry point "));
4566 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4567 printf (_("\nThere are %d program headers, starting at offset "),
4568 elf_header.e_phnum);
4569 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4570 printf ("\n");
252b5132
RH		 4571 }
4572
d93f0186 4573 if (! get_program_headers (file))
252b5132 4574 return 0;
103f02d3 4575
252b5132
RH		 4576 if (do_segments)
4577 {
3a1a2036
NC		 4578 if (elf_header.e_phnum > 1)
4579 printf (_("\nProgram Headers:\n"));
4580 else
4581 printf (_("\nProgram Headers:\n"));
76da6bbe 4582
f7a99963
NC		 4583 if (is_32bit_elf)
4584 printf
4585 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4586 else if (do_wide)
4587 printf
4588 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4589 else
4590 {
4591 printf
4592 (_(" Type Offset VirtAddr PhysAddr\n"));
4593 printf
4594 (_(" FileSiz MemSiz Flags Align\n"));
4595 }
252b5132
RH		 4596 }
4597
252b5132 4598 dynamic_addr = 0;
1b228002 4599 dynamic_size = 0;
252b5132
RH		 4600
4601 for (i = 0, segment = program_headers;
4602 i < elf_header.e_phnum;
b34976b6 4603 i++, segment++)
252b5132
RH		 4604 {
4605 if (do_segments)
4606 {
103f02d3 4607 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4608
4609 if (is_32bit_elf)
4610 {
4611 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4612 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4613 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4614 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4615 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4616 printf ("%c%c%c ",
4617 (segment->p_flags & PF_R ? 'R' : ' '),
4618 (segment->p_flags & PF_W ? 'W' : ' '),
4619 (segment->p_flags & PF_X ? 'E' : ' '));
4620 printf ("%#lx", (unsigned long) segment->p_align);
4621 }
d974e256
JJ		 4622 else if (do_wide)
4623 {
4624 if ((unsigned long) segment->p_offset == segment->p_offset)
4625 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4626 else
4627 {
4628 print_vma (segment->p_offset, FULL_HEX);
4629 putchar (' ');
4630 }
4631
4632 print_vma (segment->p_vaddr, FULL_HEX);
4633 putchar (' ');
4634 print_vma (segment->p_paddr, FULL_HEX);
4635 putchar (' ');
4636
4637 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4638 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4639 else
4640 {
4641 print_vma (segment->p_filesz, FULL_HEX);
4642 putchar (' ');
4643 }
4644
4645 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4646 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4647 else
4648 {
f48e6c45 4649 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4650 }
4651
4652 printf (" %c%c%c ",
4653 (segment->p_flags & PF_R ? 'R' : ' '),
4654 (segment->p_flags & PF_W ? 'W' : ' '),
4655 (segment->p_flags & PF_X ? 'E' : ' '));
4656
4657 if ((unsigned long) segment->p_align == segment->p_align)
4658 printf ("%#lx", (unsigned long) segment->p_align);
4659 else
4660 {
4661 print_vma (segment->p_align, PREFIX_HEX);
4662 }
4663 }
f7a99963
NC		 4664 else
4665 {
4666 print_vma (segment->p_offset, FULL_HEX);
4667 putchar (' ');
4668 print_vma (segment->p_vaddr, FULL_HEX);
4669 putchar (' ');
4670 print_vma (segment->p_paddr, FULL_HEX);
4671 printf ("\n ");
4672 print_vma (segment->p_filesz, FULL_HEX);
4673 putchar (' ');
4674 print_vma (segment->p_memsz, FULL_HEX);
4675 printf (" %c%c%c ",
4676 (segment->p_flags & PF_R ? 'R' : ' '),
4677 (segment->p_flags & PF_W ? 'W' : ' '),
4678 (segment->p_flags & PF_X ? 'E' : ' '));
4679 print_vma (segment->p_align, HEX);
4680 }
252b5132
RH		 4681 }
4682
f54498b4
NC		 4683 if (do_segments)
4684 putc ('\n', stdout);
4685
252b5132
RH		 4686 switch (segment->p_type)
4687 {
252b5132
RH		 4688 case PT_DYNAMIC:
4689 if (dynamic_addr)
4690 error (_("more than one dynamic segment\n"));
4691
20737c13
AM		 4692 /* By default, assume that the .dynamic section is the first
4693 section in the DYNAMIC segment. */
4694 dynamic_addr = segment->p_offset;
4695 dynamic_size = segment->p_filesz;
f54498b4
NC		 4696 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4697 if (dynamic_addr + dynamic_size >= current_file_size)
4698 {
4699 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4700 dynamic_addr = dynamic_size = 0;
4701 }
20737c13 4702
b2d38a17
NC		 4703 /* Try to locate the .dynamic section. If there is
4704 a section header table, we can easily locate it. */
4705 if (section_headers != NULL)
4706 {
2cf0635d 4707 Elf_Internal_Shdr * sec;
b2d38a17 4708
89fac5e3
RS		 4709 sec = find_section (".dynamic");
4710 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4711 {
28f997cf
TG		 4712 /* A corresponding .dynamic section is expected, but on
4713 IA-64/OpenVMS it is OK for it to be missing. */
4714 if (!is_ia64_vms ())
4715 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4716 break;
4717 }
4718
42bb2e33 4719 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4720 {
4721 dynamic_size = 0;
4722 break;
4723 }
42bb2e33 4724
b2d38a17
NC		 4725 dynamic_addr = sec->sh_offset;
4726 dynamic_size = sec->sh_size;
4727
4728 if (dynamic_addr < segment->p_offset
4729 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4730 warn (_("the .dynamic section is not contained"
4731 " within the dynamic segment\n"));
b2d38a17 4732 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4733 warn (_("the .dynamic section is not the first section"
4734 " in the dynamic segment.\n"));
b2d38a17 4735 }
252b5132
RH		 4736 break;
4737
4738 case PT_INTERP:
fb52b2f4
NC		 4739 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4740 SEEK_SET))
252b5132
RH		 4741 error (_("Unable to find program interpreter name\n"));
4742 else
4743 {
f8eae8b2 4744 char fmt [32];
9495b2e6 4745 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4746
4747 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4748 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4749
252b5132 4750 program_interpreter[0] = 0;
7bd7b3ef
AM		 4751 if (fscanf (file, fmt, program_interpreter) <= 0)
4752 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4753
4754 if (do_segments)
f54498b4 4755 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4756 program_interpreter);
4757 }
4758 break;
4759 }
252b5132
RH		 4760 }
4761
c256ffe7 4762 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4763 {
4764 printf (_("\n Section to Segment mapping:\n"));
4765 printf (_(" Segment Sections...\n"));
4766
252b5132
RH		 4767 for (i = 0; i < elf_header.e_phnum; i++)
4768 {
9ad5cbcf 4769 unsigned int j;
2cf0635d 4770 Elf_Internal_Shdr * section;
252b5132
RH		 4771
4772 segment = program_headers + i;
b391a3e3 4773 section = section_headers + 1;
252b5132
RH		 4774
4775 printf (" %2.2d ", i);
4776
b34976b6 4777 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4778 {
f4638467
AM		 4779 if (!ELF_TBSS_SPECIAL (section, segment)
4780 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4781 printf ("%s ", printable_section_name (section));
252b5132
RH		 4782 }
4783
4784 putc ('\n',stdout);
4785 }
4786 }
4787
252b5132
RH		 4788 return 1;
4789}
4790
4791
d93f0186
NC		 4792/* Find the file offset corresponding to VMA by using the program headers. */
4793
4794static long
2cf0635d 4795offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4796{
2cf0635d 4797 Elf_Internal_Phdr * seg;
d93f0186
NC		 4798
4799 if (! get_program_headers (file))
4800 {
4801 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4802 return (long) vma;
4803 }
4804
4805 for (seg = program_headers;
4806 seg < program_headers + elf_header.e_phnum;
4807 ++seg)
4808 {
4809 if (seg->p_type != PT_LOAD)
4810 continue;
4811
4812 if (vma >= (seg->p_vaddr & -seg->p_align)
4813 && vma + size <= seg->p_vaddr + seg->p_filesz)
4814 return vma - seg->p_vaddr + seg->p_offset;
4815 }
4816
4817 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4818 (unsigned long) vma);
d93f0186
NC		 4819 return (long) vma;
4820}
4821
4822
049b0c3a
NC		 4823/* Allocate memory and load the sections headers into the global pointer
4824 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4825 generate any error messages if the load fails. */
4826
4827static bfd_boolean
4828get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4829{
2cf0635d
NC		 4830 Elf32_External_Shdr * shdrs;
4831 Elf_Internal_Shdr * internal;
b34976b6 4832 unsigned int i;
049b0c3a
NC		 4833 unsigned int size = elf_header.e_shentsize;
4834 unsigned int num = probe ? 1 : elf_header.e_shnum;
4835
4836 /* PR binutils/17531: Cope with unexpected section header sizes. */
4837 if (size == 0 || num == 0)
4838 return FALSE;
4839 if (size < sizeof * shdrs)
4840 {
4841 if (! probe)
4842 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4843 return FALSE;
4844 }
4845 if (!probe && size > sizeof * shdrs)
4846 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4847
3f5e193b 4848 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4849 size, num,
4850 probe ? NULL : _("section headers"));
4851 if (shdrs == NULL)
4852 return FALSE;
252b5132 4853
049b0c3a
NC		 4854 if (section_headers != NULL)
4855 free (section_headers);
3f5e193b
NC		 4856 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4857 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4858 if (section_headers == NULL)
4859 {
049b0c3a 4860 if (!probe)
8b73c356 4861 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4862 return FALSE;
252b5132
RH		 4863 }
4864
4865 for (i = 0, internal = section_headers;
560f3c1c 4866 i < num;
b34976b6 4867 i++, internal++)
252b5132
RH		 4868 {
4869 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4870 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4871 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4872 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4873 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4874 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4875 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4876 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4877 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4878 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4879 }
4880
4881 free (shdrs);
049b0c3a 4882 return TRUE;
252b5132
RH		 4883}
4884
049b0c3a
NC		 4885static bfd_boolean
4886get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4887{
2cf0635d
NC		 4888 Elf64_External_Shdr * shdrs;
4889 Elf_Internal_Shdr * internal;
b34976b6 4890 unsigned int i;
049b0c3a
NC		 4891 unsigned int size = elf_header.e_shentsize;
4892 unsigned int num = probe ? 1 : elf_header.e_shnum;
4893
4894 /* PR binutils/17531: Cope with unexpected section header sizes. */
4895 if (size == 0 || num == 0)
4896 return FALSE;
4897 if (size < sizeof * shdrs)
4898 {
4899 if (! probe)
4900 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4901 return FALSE;
4902 }
4903 if (! probe && size > sizeof * shdrs)
4904 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4905
3f5e193b 4906 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4907 size, num,
4908 probe ? NULL : _("section headers"));
4909 if (shdrs == NULL)
4910 return FALSE;
9ea033b2 4911
049b0c3a
NC		 4912 if (section_headers != NULL)
4913 free (section_headers);
3f5e193b
NC		 4914 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4915 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4916 if (section_headers == NULL)
4917 {
049b0c3a 4918 if (! probe)
8b73c356 4919 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4920 return FALSE;
9ea033b2
NC		 4921 }
4922
4923 for (i = 0, internal = section_headers;
560f3c1c 4924 i < num;
b34976b6 4925 i++, internal++)
9ea033b2
NC		 4926 {
4927 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4928 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4929 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4930 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4931 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4932 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4933 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4934 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4935 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4936 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4937 }
4938
4939 free (shdrs);
049b0c3a 4940 return TRUE;
9ea033b2
NC		 4941}
4942
252b5132 4943static Elf_Internal_Sym *
ba5cdace
NC		 4944get_32bit_elf_symbols (FILE * file,
4945 Elf_Internal_Shdr * section,
4946 unsigned long * num_syms_return)
252b5132 4947{
ba5cdace 4948 unsigned long number = 0;
dd24e3da 4949 Elf32_External_Sym * esyms = NULL;
ba5cdace 4950 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4951 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4952 Elf_Internal_Sym * psym;
b34976b6 4953 unsigned int j;
252b5132 4954
c9c1d674
EG		 4955 if (section->sh_size == 0)
4956 {
4957 if (num_syms_return != NULL)
4958 * num_syms_return = 0;
4959 return NULL;
4960 }
4961
dd24e3da 4962 /* Run some sanity checks first. */
c9c1d674 4963 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4964 {
c9c1d674
EG		 4965 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4966 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4967 goto exit_point;
dd24e3da
NC		 4968 }
4969
f54498b4
NC		 4970 if (section->sh_size > current_file_size)
4971 {
4972 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4973 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4974 goto exit_point;
4975 }
4976
dd24e3da
NC		 4977 number = section->sh_size / section->sh_entsize;
4978
4979 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4980 {
c9c1d674 4981 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4982 (unsigned long) section->sh_size,
4983 printable_section_name (section),
4984 (unsigned long) section->sh_entsize);
ba5cdace 4985 goto exit_point;
dd24e3da
NC		 4986 }
4987
3f5e193b
NC		 4988 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4989 section->sh_size, _("symbols"));
dd24e3da 4990 if (esyms == NULL)
ba5cdace 4991 goto exit_point;
252b5132 4992
9ad5cbcf
AM		 4993 shndx = NULL;
4994 if (symtab_shndx_hdr != NULL
4995 && (symtab_shndx_hdr->sh_link
4fbb74a6 4996 == (unsigned long) (section - section_headers)))
9ad5cbcf 4997 {
3f5e193b
NC		 4998 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4999 symtab_shndx_hdr->sh_offset,
5000 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5001 _("symbol table section indicies"));
dd24e3da
NC		 5002 if (shndx == NULL)
5003 goto exit_point;
c9c1d674
EG		 5004 /* PR17531: file: heap-buffer-overflow */
5005 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5006 {
5007 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5008 printable_section_name (symtab_shndx_hdr),
5009 (unsigned long) symtab_shndx_hdr->sh_size,
5010 (unsigned long) section->sh_size);
5011 goto exit_point;
5012 }
9ad5cbcf
AM		 5013 }
5014
3f5e193b 5015 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5016
5017 if (isyms == NULL)
5018 {
8b73c356
NC		 5019 error (_("Out of memory reading %lu symbols\n"),
5020 (unsigned long) number);
dd24e3da 5021 goto exit_point;
252b5132
RH		 5022 }
5023
dd24e3da 5024 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5025 {
5026 psym->st_name = BYTE_GET (esyms[j].st_name);
5027 psym->st_value = BYTE_GET (esyms[j].st_value);
5028 psym->st_size = BYTE_GET (esyms[j].st_size);
5029 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5030 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5031 psym->st_shndx
5032 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5033 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5034 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5035 psym->st_info = BYTE_GET (esyms[j].st_info);
5036 psym->st_other = BYTE_GET (esyms[j].st_other);
5037 }
5038
dd24e3da 5039 exit_point:
ba5cdace 5040 if (shndx != NULL)
9ad5cbcf 5041 free (shndx);
ba5cdace 5042 if (esyms != NULL)
dd24e3da 5043 free (esyms);
252b5132 5044
ba5cdace
NC		 5045 if (num_syms_return != NULL)
5046 * num_syms_return = isyms == NULL ? 0 : number;
5047
252b5132
RH		 5048 return isyms;
5049}
5050
9ea033b2 5051static Elf_Internal_Sym *
ba5cdace
NC		 5052get_64bit_elf_symbols (FILE * file,
5053 Elf_Internal_Shdr * section,
5054 unsigned long * num_syms_return)
9ea033b2 5055{
ba5cdace
NC		 5056 unsigned long number = 0;
5057 Elf64_External_Sym * esyms = NULL;
5058 Elf_External_Sym_Shndx * shndx = NULL;
5059 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5060 Elf_Internal_Sym * psym;
b34976b6 5061 unsigned int j;
9ea033b2 5062
c9c1d674
EG		 5063 if (section->sh_size == 0)
5064 {
5065 if (num_syms_return != NULL)
5066 * num_syms_return = 0;
5067 return NULL;
5068 }
5069
dd24e3da 5070 /* Run some sanity checks first. */
c9c1d674 5071 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5072 {
c9c1d674 5073 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5074 printable_section_name (section),
5075 (unsigned long) section->sh_entsize);
ba5cdace 5076 goto exit_point;
dd24e3da
NC		 5077 }
5078
f54498b4
NC		 5079 if (section->sh_size > current_file_size)
5080 {
5081 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5082 printable_section_name (section),
5083 (unsigned long) section->sh_size);
f54498b4
NC		 5084 goto exit_point;
5085 }
5086
dd24e3da
NC		 5087 number = section->sh_size / section->sh_entsize;
5088
5089 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5090 {
c9c1d674 5091 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5092 (unsigned long) section->sh_size,
5093 printable_section_name (section),
5094 (unsigned long) section->sh_entsize);
ba5cdace 5095 goto exit_point;
dd24e3da
NC		 5096 }
5097
3f5e193b
NC		 5098 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5099 section->sh_size, _("symbols"));
a6e9f9df 5100 if (!esyms)
ba5cdace 5101 goto exit_point;
9ea033b2 5102
9ad5cbcf
AM		 5103 if (symtab_shndx_hdr != NULL
5104 && (symtab_shndx_hdr->sh_link
4fbb74a6 5105 == (unsigned long) (section - section_headers)))
9ad5cbcf 5106 {
3f5e193b
NC		 5107 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5108 symtab_shndx_hdr->sh_offset,
5109 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5110 _("symbol table section indicies"));
ba5cdace
NC		 5111 if (shndx == NULL)
5112 goto exit_point;
c9c1d674
EG		 5113 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5114 {
5115 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5116 printable_section_name (symtab_shndx_hdr),
5117 (unsigned long) symtab_shndx_hdr->sh_size,
5118 (unsigned long) section->sh_size);
5119 goto exit_point;
5120 }
9ad5cbcf
AM		 5121 }
5122
3f5e193b 5123 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5124
5125 if (isyms == NULL)
5126 {
8b73c356
NC		 5127 error (_("Out of memory reading %lu symbols\n"),
5128 (unsigned long) number);
ba5cdace 5129 goto exit_point;
9ea033b2
NC		 5130 }
5131
ba5cdace 5132 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5133 {
5134 psym->st_name = BYTE_GET (esyms[j].st_name);
5135 psym->st_info = BYTE_GET (esyms[j].st_info);
5136 psym->st_other = BYTE_GET (esyms[j].st_other);
5137 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5138
4fbb74a6 5139 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5140 psym->st_shndx
5141 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5142 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5143 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5144
66543521
AM		 5145 psym->st_value = BYTE_GET (esyms[j].st_value);
5146 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5147 }
5148
ba5cdace
NC		 5149 exit_point:
5150 if (shndx != NULL)
9ad5cbcf 5151 free (shndx);
ba5cdace
NC		 5152 if (esyms != NULL)
5153 free (esyms);
5154
5155 if (num_syms_return != NULL)
5156 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5157
5158 return isyms;
5159}
5160
d1133906 5161static const char *
d3ba0551 5162get_elf_section_flags (bfd_vma sh_flags)
d1133906 5163{
5477e8a0 5164 static char buff[1024];
2cf0635d 5165 char * p = buff;
8d5ff12c 5166 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5167 int sindex;
5168 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5169 bfd_vma os_flags = 0;
5170 bfd_vma proc_flags = 0;
5171 bfd_vma unknown_flags = 0;
148b93f2 5172 static const struct
5477e8a0 5173 {
2cf0635d 5174 const char * str;
5477e8a0
L		 5175 int len;
5176 }
5177 flags [] =
5178 {
cfcac11d
NC		 5179 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5180 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5181 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5182 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5183 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5184 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5185 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5186 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5187 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5188 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5189 /* IA-64 specific. */
5190 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5191 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5192 /* IA-64 OpenVMS specific. */
5193 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5194 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5195 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5196 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5197 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5198 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5199 /* Generic. */
cfcac11d 5200 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5201 /* SPARC specific. */
77115a4a
L		 5202 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5203 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5204 };
5205
5206 if (do_section_details)
5207 {
8d5ff12c
L		 5208 sprintf (buff, "[%*.*lx]: ",
5209 field_size, field_size, (unsigned long) sh_flags);
5210 p += field_size + 4;
5477e8a0 5211 }
76da6bbe 5212
d1133906
NC		 5213 while (sh_flags)
5214 {
5215 bfd_vma flag;
5216
5217 flag = sh_flags & - sh_flags;
5218 sh_flags &= ~ flag;
76da6bbe 5219
5477e8a0 5220 if (do_section_details)
d1133906 5221 {
5477e8a0
L		 5222 switch (flag)
5223 {
91d6fa6a
NC		 5224 case SHF_WRITE: sindex = 0; break;
5225 case SHF_ALLOC: sindex = 1; break;
5226 case SHF_EXECINSTR: sindex = 2; break;
5227 case SHF_MERGE: sindex = 3; break;
5228 case SHF_STRINGS: sindex = 4; break;
5229 case SHF_INFO_LINK: sindex = 5; break;
5230 case SHF_LINK_ORDER: sindex = 6; break;
5231 case SHF_OS_NONCONFORMING: sindex = 7; break;
5232 case SHF_GROUP: sindex = 8; break;
5233 case SHF_TLS: sindex = 9; break;
18ae9cc1 5234 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5235 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5236
5477e8a0 5237 default:
91d6fa6a 5238 sindex = -1;
cfcac11d 5239 switch (elf_header.e_machine)
148b93f2 5240 {
cfcac11d 5241 case EM_IA_64:
148b93f2 5242 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5243 sindex = 10;
148b93f2 5244 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5245 sindex = 11;
148b93f2
NC		 5246#ifdef BFD64
5247 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5248 switch (flag)
5249 {
91d6fa6a
NC		 5250 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5251 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5252 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5253 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5254 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5255 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5256 default: break;
5257 }
5258#endif
cfcac11d
NC		 5259 break;
5260
caa83f8b 5261 case EM_386:
22abe556 5262 case EM_IAMCU:
caa83f8b 5263 case EM_X86_64:
7f502d6c 5264 case EM_L1OM:
7a9068fe 5265 case EM_K1OM:
cfcac11d
NC		 5266 case EM_OLD_SPARCV9:
5267 case EM_SPARC32PLUS:
5268 case EM_SPARCV9:
5269 case EM_SPARC:
18ae9cc1 5270 if (flag == SHF_ORDERED)
91d6fa6a 5271 sindex = 19;
cfcac11d
NC		 5272 break;
5273 default:
5274 break;
148b93f2 5275 }
5477e8a0
L		 5276 }
5277
91d6fa6a 5278 if (sindex != -1)
5477e8a0 5279 {
8d5ff12c
L		 5280 if (p != buff + field_size + 4)
5281 {
5282 if (size < (10 + 2))
bee0ee85
NC		 5283 {
5284 warn (_("Internal error: not enough buffer room for section flag info"));
5285 return _("<unknown>");
5286 }
8d5ff12c
L		 5287 size -= 2;
5288 *p++ = ',';
5289 *p++ = ' ';
5290 }
5291
91d6fa6a
NC		 5292 size -= flags [sindex].len;
5293 p = stpcpy (p, flags [sindex].str);
5477e8a0 5294 }
3b22753a 5295 else if (flag & SHF_MASKOS)
8d5ff12c 5296 os_flags |= flag;
d1133906 5297 else if (flag & SHF_MASKPROC)
8d5ff12c 5298 proc_flags |= flag;
d1133906 5299 else
8d5ff12c 5300 unknown_flags |= flag;
5477e8a0
L		 5301 }
5302 else
5303 {
5304 switch (flag)
5305 {
5306 case SHF_WRITE: *p = 'W'; break;
5307 case SHF_ALLOC: *p = 'A'; break;
5308 case SHF_EXECINSTR: *p = 'X'; break;
5309 case SHF_MERGE: *p = 'M'; break;
5310 case SHF_STRINGS: *p = 'S'; break;
5311 case SHF_INFO_LINK: *p = 'I'; break;
5312 case SHF_LINK_ORDER: *p = 'L'; break;
5313 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5314 case SHF_GROUP: *p = 'G'; break;
5315 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5316 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5317 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5318
5319 default:
8a9036a4 5320 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5321 || elf_header.e_machine == EM_L1OM
5322 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5323 && flag == SHF_X86_64_LARGE)
5324 *p = 'l';
5325 else if (flag & SHF_MASKOS)
5326 {
5327 *p = 'o';
5328 sh_flags &= ~ SHF_MASKOS;
5329 }
5330 else if (flag & SHF_MASKPROC)
5331 {
5332 *p = 'p';
5333 sh_flags &= ~ SHF_MASKPROC;
5334 }
5335 else
5336 *p = 'x';
5337 break;
5338 }
5339 p++;
d1133906
NC		 5340 }
5341 }
76da6bbe 5342
8d5ff12c
L		 5343 if (do_section_details)
5344 {
5345 if (os_flags)
5346 {
5347 size -= 5 + field_size;
5348 if (p != buff + field_size + 4)
5349 {
5350 if (size < (2 + 1))
bee0ee85
NC		 5351 {
5352 warn (_("Internal error: not enough buffer room for section flag info"));
5353 return _("<unknown>");
5354 }
8d5ff12c
L		 5355 size -= 2;
5356 *p++ = ',';
5357 *p++ = ' ';
5358 }
5359 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5360 (unsigned long) os_flags);
5361 p += 5 + field_size;
5362 }
5363 if (proc_flags)
5364 {
5365 size -= 7 + field_size;
5366 if (p != buff + field_size + 4)
5367 {
5368 if (size < (2 + 1))
bee0ee85
NC		 5369 {
5370 warn (_("Internal error: not enough buffer room for section flag info"));
5371 return _("<unknown>");
5372 }
8d5ff12c
L		 5373 size -= 2;
5374 *p++ = ',';
5375 *p++ = ' ';
5376 }
5377 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5378 (unsigned long) proc_flags);
5379 p += 7 + field_size;
5380 }
5381 if (unknown_flags)
5382 {
5383 size -= 10 + field_size;
5384 if (p != buff + field_size + 4)
5385 {
5386 if (size < (2 + 1))
bee0ee85
NC		 5387 {
5388 warn (_("Internal error: not enough buffer room for section flag info"));
5389 return _("<unknown>");
5390 }
8d5ff12c
L		 5391 size -= 2;
5392 *p++ = ',';
5393 *p++ = ' ';
5394 }
2b692964 5395 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5396 (unsigned long) unknown_flags);
5397 p += 10 + field_size;
5398 }
5399 }
5400
e9e44622 5401 *p = '\0';
d1133906
NC		 5402 return buff;
5403}
5404
77115a4a
L		 5405static unsigned int
5406get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5407{
5408 if (is_32bit_elf)
5409 {
5410 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5411 chdr->ch_type = BYTE_GET (echdr->ch_type);
5412 chdr->ch_size = BYTE_GET (echdr->ch_size);
5413 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5414 return sizeof (*echdr);
5415 }
5416 else
5417 {
5418 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5419 chdr->ch_type = BYTE_GET (echdr->ch_type);
5420 chdr->ch_size = BYTE_GET (echdr->ch_size);
5421 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5422 return sizeof (*echdr);
5423 }
5424}
5425
252b5132 5426static int
2cf0635d 5427process_section_headers (FILE * file)
252b5132 5428{
2cf0635d 5429 Elf_Internal_Shdr * section;
b34976b6 5430 unsigned int i;
252b5132
RH		 5431
5432 section_headers = NULL;
5433
5434 if (elf_header.e_shnum == 0)
5435 {
82f2dbf7
NC		 5436 /* PR binutils/12467. */
5437 if (elf_header.e_shoff != 0)
5438 warn (_("possibly corrupt ELF file header - it has a non-zero"
5439 " section header offset, but no section headers\n"));
5440 else if (do_sections)
252b5132
RH		 5441 printf (_("\nThere are no sections in this file.\n"));
5442
5443 return 1;
5444 }
5445
5446 if (do_sections && !do_header)
9ea033b2 5447 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5448 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5449
9ea033b2
NC		 5450 if (is_32bit_elf)
5451 {
049b0c3a 5452 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5453 return 0;
5454 }
049b0c3a 5455 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5456 return 0;
5457
5458 /* Read in the string table, so that we have names to display. */
0b49d371 5459 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5460 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5461 {
4fbb74a6 5462 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5463
c256ffe7
JJ		 5464 if (section->sh_size != 0)
5465 {
3f5e193b
NC		 5466 string_table = (char *) get_data (NULL, file, section->sh_offset,
5467 1, section->sh_size,
5468 _("string table"));
0de14b54 5469
c256ffe7
JJ		 5470 string_table_length = string_table != NULL ? section->sh_size : 0;
5471 }
252b5132
RH		 5472 }
5473
5474 /* Scan the sections for the dynamic symbol table
e3c8793a 5475 and dynamic string table and debug sections. */
252b5132
RH		 5476 dynamic_symbols = NULL;
5477 dynamic_strings = NULL;
5478 dynamic_syminfo = NULL;
f1ef08cb 5479 symtab_shndx_hdr = NULL;
103f02d3 5480
89fac5e3
RS		 5481 eh_addr_size = is_32bit_elf ? 4 : 8;
5482 switch (elf_header.e_machine)
5483 {
5484 case EM_MIPS:
5485 case EM_MIPS_RS3_LE:
5486 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5487 FDE addresses. However, the ABI also has a semi-official ILP32
5488 variant for which the normal FDE address size rules apply.
5489
5490 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5491 section, where XX is the size of longs in bits. Unfortunately,
5492 earlier compilers provided no way of distinguishing ILP32 objects
5493 from LP64 objects, so if there's any doubt, we should assume that
5494 the official LP64 form is being used. */
5495 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5496 && find_section (".gcc_compiled_long32") == NULL)
5497 eh_addr_size = 8;
5498 break;
0f56a26a
DD		 5499
5500 case EM_H8_300:
5501 case EM_H8_300H:
5502 switch (elf_header.e_flags & EF_H8_MACH)
5503 {
5504 case E_H8_MACH_H8300:
5505 case E_H8_MACH_H8300HN:
5506 case E_H8_MACH_H8300SN:
5507 case E_H8_MACH_H8300SXN:
5508 eh_addr_size = 2;
5509 break;
5510 case E_H8_MACH_H8300H:
5511 case E_H8_MACH_H8300S:
5512 case E_H8_MACH_H8300SX:
5513 eh_addr_size = 4;
5514 break;
5515 }
f4236fe4
DD		 5516 break;
5517
ff7eeb89 5518 case EM_M32C_OLD:
f4236fe4
DD		 5519 case EM_M32C:
5520 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5521 {
5522 case EF_M32C_CPU_M16C:
5523 eh_addr_size = 2;
5524 break;
5525 }
5526 break;
89fac5e3
RS		 5527 }
5528
76ca31c0
NC		 5529#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5530 do \
5531 { \
5532 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5533 if (section->sh_entsize != expected_entsize) \
9dd3a467 5534 { \
76ca31c0
NC		 5535 char buf[40]; \
5536 sprintf_vma (buf, section->sh_entsize); \
5537 /* Note: coded this way so that there is a single string for \
5538 translation. */ \
5539 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5540 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5541 (unsigned) expected_entsize); \
9dd3a467 5542 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5543 } \
5544 } \
08d8fa11 5545 while (0)
9dd3a467
NC		 5546
5547#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5548 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5549 sizeof (Elf64_External_##type))
5550
252b5132
RH		 5551 for (i = 0, section = section_headers;
5552 i < elf_header.e_shnum;
b34976b6 5553 i++, section++)
252b5132 5554 {
2cf0635d 5555 char * name = SECTION_NAME (section);
252b5132
RH		 5556
5557 if (section->sh_type == SHT_DYNSYM)
5558 {
5559 if (dynamic_symbols != NULL)
5560 {
5561 error (_("File contains multiple dynamic symbol tables\n"));
5562 continue;
5563 }
5564
08d8fa11 5565 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5566 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5567 }
5568 else if (section->sh_type == SHT_STRTAB
18bd398b 5569 && streq (name, ".dynstr"))
252b5132
RH		 5570 {
5571 if (dynamic_strings != NULL)
5572 {
5573 error (_("File contains multiple dynamic string tables\n"));
5574 continue;
5575 }
5576
3f5e193b
NC		 5577 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5578 1, section->sh_size,
5579 _("dynamic strings"));
59245841 5580 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5581 }
9ad5cbcf
AM		 5582 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5583 {
5584 if (symtab_shndx_hdr != NULL)
5585 {
5586 error (_("File contains multiple symtab shndx tables\n"));
5587 continue;
5588 }
5589 symtab_shndx_hdr = section;
5590 }
08d8fa11
JJ		 5591 else if (section->sh_type == SHT_SYMTAB)
5592 CHECK_ENTSIZE (section, i, Sym);
5593 else if (section->sh_type == SHT_GROUP)
5594 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5595 else if (section->sh_type == SHT_REL)
5596 CHECK_ENTSIZE (section, i, Rel);
5597 else if (section->sh_type == SHT_RELA)
5598 CHECK_ENTSIZE (section, i, Rela);
252b5132 5599 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5600 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5601 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5602 || do_debug_str || do_debug_loc || do_debug_ranges
5603 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5604 && (const_strneq (name, ".debug_")
5605 || const_strneq (name, ".zdebug_")))
252b5132 5606 {
1b315056
CS		 5607 if (name[1] == 'z')
5608 name += sizeof (".zdebug_") - 1;
5609 else
5610 name += sizeof (".debug_") - 1;
252b5132
RH		 5611
5612 if (do_debugging
4723351a
CC		 5613 || (do_debug_info && const_strneq (name, "info"))
5614 || (do_debug_info && const_strneq (name, "types"))
5615 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5616 || (do_debug_lines && strcmp (name, "line") == 0)
5617 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5618 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5619 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5620 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5621 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5622 || (do_debug_aranges && const_strneq (name, "aranges"))
5623 || (do_debug_ranges && const_strneq (name, "ranges"))
5624 || (do_debug_frames && const_strneq (name, "frame"))
5625 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5626 || (do_debug_macinfo && const_strneq (name, "macro"))
5627 || (do_debug_str && const_strneq (name, "str"))
5628 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5629 || (do_debug_addr && const_strneq (name, "addr"))
5630 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5631 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5632 )
09c11c86 5633 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5634 }
a262ae96 5635 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5636 else if ((do_debugging || do_debug_info)
0112cd26 5637 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5638 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5639 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5640 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5641 else if (do_gdb_index && streq (name, ".gdb_index"))
5642 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5643 /* Trace sections for Itanium VMS. */
5644 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5645 || do_trace_aranges)
5646 && const_strneq (name, ".trace_"))
5647 {
5648 name += sizeof (".trace_") - 1;
5649
5650 if (do_debugging
5651 || (do_trace_info && streq (name, "info"))
5652 || (do_trace_abbrevs && streq (name, "abbrev"))
5653 || (do_trace_aranges && streq (name, "aranges"))
5654 )
5655 request_dump_bynumber (i, DEBUG_DUMP);
5656 }
252b5132
RH		 5657 }
5658
5659 if (! do_sections)
5660 return 1;
5661
3a1a2036
NC		 5662 if (elf_header.e_shnum > 1)
5663 printf (_("\nSection Headers:\n"));
5664 else
5665 printf (_("\nSection Header:\n"));
76da6bbe 5666
f7a99963 5667 if (is_32bit_elf)
595cf52e 5668 {
5477e8a0 5669 if (do_section_details)
595cf52e
L		 5670 {
5671 printf (_(" [Nr] Name\n"));
5477e8a0 5672 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5673 }
5674 else
5675 printf
5676 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5677 }
d974e256 5678 else if (do_wide)
595cf52e 5679 {
5477e8a0 5680 if (do_section_details)
595cf52e
L		 5681 {
5682 printf (_(" [Nr] Name\n"));
5477e8a0 5683 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5684 }
5685 else
5686 printf
5687 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5688 }
f7a99963
NC		 5689 else
5690 {
5477e8a0 5691 if (do_section_details)
595cf52e
L		 5692 {
5693 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5694 printf (_(" Type Address Offset Link\n"));
5695 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5696 }
5697 else
5698 {
5699 printf (_(" [Nr] Name Type Address Offset\n"));
5700 printf (_(" Size EntSize Flags Link Info Align\n"));
5701 }
f7a99963 5702 }
252b5132 5703
5477e8a0
L		 5704 if (do_section_details)
5705 printf (_(" Flags\n"));
5706
252b5132
RH		 5707 for (i = 0, section = section_headers;
5708 i < elf_header.e_shnum;
b34976b6 5709 i++, section++)
252b5132 5710 {
7bfd842d 5711 printf (" [%2u] ", i);
5477e8a0 5712 if (do_section_details)
74e1a04b 5713 printf ("%s\n ", printable_section_name (section));
595cf52e 5714 else
74e1a04b 5715 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5716
ea52a088
NC		 5717 printf (do_wide ? " %-15s " : " %-15.15s ",
5718 get_section_type_name (section->sh_type));
0b4362b0 5719
f7a99963
NC		 5720 if (is_32bit_elf)
5721 {
cfcac11d
NC		 5722 const char * link_too_big = NULL;
5723
f7a99963 5724 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5725
f7a99963
NC		 5726 printf ( " %6.6lx %6.6lx %2.2lx",
5727 (unsigned long) section->sh_offset,
5728 (unsigned long) section->sh_size,
5729 (unsigned long) section->sh_entsize);
d1133906 5730
5477e8a0
L		 5731 if (do_section_details)
5732 fputs (" ", stdout);
5733 else
5734 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5735
cfcac11d
NC		 5736 if (section->sh_link >= elf_header.e_shnum)
5737 {
5738 link_too_big = "";
5739 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5740 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5741 switch (elf_header.e_machine)
5742 {
caa83f8b 5743 case EM_386:
22abe556 5744 case EM_IAMCU:
caa83f8b 5745 case EM_X86_64:
7f502d6c 5746 case EM_L1OM:
7a9068fe 5747 case EM_K1OM:
cfcac11d
NC		 5748 case EM_OLD_SPARCV9:
5749 case EM_SPARC32PLUS:
5750 case EM_SPARCV9:
5751 case EM_SPARC:
5752 if (section->sh_link == (SHN_BEFORE & 0xffff))
5753 link_too_big = "BEFORE";
5754 else if (section->sh_link == (SHN_AFTER & 0xffff))
5755 link_too_big = "AFTER";
5756 break;
5757 default:
5758 break;
5759 }
5760 }
5761
5762 if (do_section_details)
5763 {
5764 if (link_too_big != NULL && * link_too_big)
5765 printf ("<%s> ", link_too_big);
5766 else
5767 printf ("%2u ", section->sh_link);
5768 printf ("%3u %2lu\n", section->sh_info,
5769 (unsigned long) section->sh_addralign);
5770 }
5771 else
5772 printf ("%2u %3u %2lu\n",
5773 section->sh_link,
5774 section->sh_info,
5775 (unsigned long) section->sh_addralign);
5776
5777 if (link_too_big && ! * link_too_big)
5778 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5779 i, section->sh_link);
f7a99963 5780 }
d974e256
JJ		 5781 else if (do_wide)
5782 {
5783 print_vma (section->sh_addr, LONG_HEX);
5784
5785 if ((long) section->sh_offset == section->sh_offset)
5786 printf (" %6.6lx", (unsigned long) section->sh_offset);
5787 else
5788 {
5789 putchar (' ');
5790 print_vma (section->sh_offset, LONG_HEX);
5791 }
5792
5793 if ((unsigned long) section->sh_size == section->sh_size)
5794 printf (" %6.6lx", (unsigned long) section->sh_size);
5795 else
5796 {
5797 putchar (' ');
5798 print_vma (section->sh_size, LONG_HEX);
5799 }
5800
5801 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5802 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5803 else
5804 {
5805 putchar (' ');
5806 print_vma (section->sh_entsize, LONG_HEX);
5807 }
5808
5477e8a0
L		 5809 if (do_section_details)
5810 fputs (" ", stdout);
5811 else
5812 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5813
72de5009 5814 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5815
5816 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5817 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5818 else
5819 {
5820 print_vma (section->sh_addralign, DEC);
5821 putchar ('\n');
5822 }
5823 }
5477e8a0 5824 else if (do_section_details)
595cf52e 5825 {
5477e8a0 5826 printf (" %-15.15s ",
595cf52e 5827 get_section_type_name (section->sh_type));
595cf52e
L		 5828 print_vma (section->sh_addr, LONG_HEX);
5829 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5830 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5831 else
5832 {
5833 printf (" ");
5834 print_vma (section->sh_offset, LONG_HEX);
5835 }
72de5009 5836 printf (" %u\n ", section->sh_link);
595cf52e 5837 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5838 putchar (' ');
595cf52e
L		 5839 print_vma (section->sh_entsize, LONG_HEX);
5840
72de5009
AM		 5841 printf (" %-16u %lu\n",
5842 section->sh_info,
595cf52e
L		 5843 (unsigned long) section->sh_addralign);
5844 }
f7a99963
NC		 5845 else
5846 {
5847 putchar (' ');
5848 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5849 if ((long) section->sh_offset == section->sh_offset)
5850 printf (" %8.8lx", (unsigned long) section->sh_offset);
5851 else
5852 {
5853 printf (" ");
5854 print_vma (section->sh_offset, LONG_HEX);
5855 }
f7a99963
NC		 5856 printf ("\n ");
5857 print_vma (section->sh_size, LONG_HEX);
5858 printf (" ");
5859 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5860
d1133906 5861 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5862
72de5009
AM		 5863 printf (" %2u %3u %lu\n",
5864 section->sh_link,
5865 section->sh_info,
f7a99963
NC		 5866 (unsigned long) section->sh_addralign);
5867 }
5477e8a0
L		 5868
5869 if (do_section_details)
77115a4a
L		 5870 {
5871 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5872 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5873 {
5874 /* Minimum section size is 12 bytes for 32-bit compression
5875 header + 12 bytes for compressed data header. */
5876 unsigned char buf[24];
5877 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5878 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5879 sizeof (buf), _("compression header")))
5880 {
5881 Elf_Internal_Chdr chdr;
5882 get_compression_header (&chdr, buf);
5883 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5884 printf (" ZLIB, ");
5885 else
5886 printf (_(" [<unknown>: 0x%x], "),
5887 chdr.ch_type);
5888 print_vma (chdr.ch_size, LONG_HEX);
5889 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5890 }
5891 }
5892 }
252b5132
RH		 5893 }
5894
5477e8a0 5895 if (!do_section_details)
3dbcc61d
NC		 5896 {
5897 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5898 || elf_header.e_machine == EM_L1OM
5899 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5900 printf (_("Key to Flags:\n\
5901 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5902 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5903 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5904 else
5905 printf (_("Key to Flags:\n\
e3c8793a 5906 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5907 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5908 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5909 }
d1133906 5910
252b5132
RH		 5911 return 1;
5912}
5913
f5842774
L		 5914static const char *
5915get_group_flags (unsigned int flags)
5916{
5917 static char buff[32];
5918 switch (flags)
5919 {
220453ec
AM		 5920 case 0:
5921 return "";
5922
f5842774 5923 case GRP_COMDAT:
220453ec 5924 return "COMDAT ";
f5842774
L		 5925
5926 default:
220453ec 5927 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5928 break;
5929 }
5930 return buff;
5931}
5932
5933static int
2cf0635d 5934process_section_groups (FILE * file)
f5842774 5935{
2cf0635d 5936 Elf_Internal_Shdr * section;
f5842774 5937 unsigned int i;
2cf0635d
NC		 5938 struct group * group;
5939 Elf_Internal_Shdr * symtab_sec;
5940 Elf_Internal_Shdr * strtab_sec;
5941 Elf_Internal_Sym * symtab;
ba5cdace 5942 unsigned long num_syms;
2cf0635d 5943 char * strtab;
c256ffe7 5944 size_t strtab_size;
d1f5c6e3
L		 5945
5946 /* Don't process section groups unless needed. */
5947 if (!do_unwind && !do_section_groups)
5948 return 1;
f5842774
L		 5949
5950 if (elf_header.e_shnum == 0)
5951 {
5952 if (do_section_groups)
82f2dbf7 5953 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5954
5955 return 1;
5956 }
5957
5958 if (section_headers == NULL)
5959 {
5960 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5961 /* PR 13622: This can happen with a corrupt ELF header. */
5962 return 0;
f5842774
L		 5963 }
5964
3f5e193b
NC		 5965 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5966 sizeof (struct group *));
e4b17d5c
L		 5967
5968 if (section_headers_groups == NULL)
5969 {
8b73c356
NC		 5970 error (_("Out of memory reading %u section group headers\n"),
5971 elf_header.e_shnum);
e4b17d5c
L		 5972 return 0;
5973 }
5974
f5842774 5975 /* Scan the sections for the group section. */
d1f5c6e3 5976 group_count = 0;
f5842774
L		 5977 for (i = 0, section = section_headers;
5978 i < elf_header.e_shnum;
5979 i++, section++)
e4b17d5c
L		 5980 if (section->sh_type == SHT_GROUP)
5981 group_count++;
5982
d1f5c6e3
L		 5983 if (group_count == 0)
5984 {
5985 if (do_section_groups)
5986 printf (_("\nThere are no section groups in this file.\n"));
5987
5988 return 1;
5989 }
5990
3f5e193b 5991 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5992
5993 if (section_groups == NULL)
5994 {
8b73c356
NC		 5995 error (_("Out of memory reading %lu groups\n"),
5996 (unsigned long) group_count);
e4b17d5c
L		 5997 return 0;
5998 }
5999
d1f5c6e3
L		 6000 symtab_sec = NULL;
6001 strtab_sec = NULL;
6002 symtab = NULL;
ba5cdace 6003 num_syms = 0;
d1f5c6e3 6004 strtab = NULL;
c256ffe7 6005 strtab_size = 0;
e4b17d5c
L		 6006 for (i = 0, section = section_headers, group = section_groups;
6007 i < elf_header.e_shnum;
6008 i++, section++)
f5842774
L		 6009 {
6010 if (section->sh_type == SHT_GROUP)
6011 {
74e1a04b
NC		 6012 const char * name = printable_section_name (section);
6013 const char * group_name;
2cf0635d
NC		 6014 unsigned char * start;
6015 unsigned char * indices;
f5842774 6016 unsigned int entry, j, size;
2cf0635d
NC		 6017 Elf_Internal_Shdr * sec;
6018 Elf_Internal_Sym * sym;
f5842774
L		 6019
6020 /* Get the symbol table. */
4fbb74a6
AM		 6021 if (section->sh_link >= elf_header.e_shnum
6022 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6023 != SHT_SYMTAB))
f5842774
L		 6024 {
6025 error (_("Bad sh_link in group section `%s'\n"), name);
6026 continue;
6027 }
d1f5c6e3
L		 6028
6029 if (symtab_sec != sec)
6030 {
6031 symtab_sec = sec;
6032 if (symtab)
6033 free (symtab);
ba5cdace 6034 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6035 }
f5842774 6036
dd24e3da
NC		 6037 if (symtab == NULL)
6038 {
6039 error (_("Corrupt header in group section `%s'\n"), name);
6040 continue;
6041 }
6042
ba5cdace
NC		 6043 if (section->sh_info >= num_syms)
6044 {
6045 error (_("Bad sh_info in group section `%s'\n"), name);
6046 continue;
6047 }
6048
f5842774
L		 6049 sym = symtab + section->sh_info;
6050
6051 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6052 {
4fbb74a6
AM		 6053 if (sym->st_shndx == 0
6054 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6055 {
6056 error (_("Bad sh_info in group section `%s'\n"), name);
6057 continue;
6058 }
ba2685cc 6059
4fbb74a6 6060 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6061 strtab_sec = NULL;
6062 if (strtab)
6063 free (strtab);
f5842774 6064 strtab = NULL;
c256ffe7 6065 strtab_size = 0;
f5842774
L		 6066 }
6067 else
6068 {
6069 /* Get the string table. */
4fbb74a6 6070 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6071 {
6072 strtab_sec = NULL;
6073 if (strtab)
6074 free (strtab);
6075 strtab = NULL;
6076 strtab_size = 0;
6077 }
6078 else if (strtab_sec
4fbb74a6 6079 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6080 {
6081 strtab_sec = sec;
6082 if (strtab)
6083 free (strtab);
071436c6 6084
3f5e193b 6085 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6086 1, strtab_sec->sh_size,
6087 _("string table"));
c256ffe7 6088 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6089 }
c256ffe7 6090 group_name = sym->st_name < strtab_size
2b692964 6091 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6092 }
6093
c9c1d674
EG		 6094 /* PR 17531: file: loop. */
6095 if (section->sh_entsize > section->sh_size)
6096 {
6097 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6098 printable_section_name (section),
8066deb1
AM		 6099 (unsigned long) section->sh_entsize,
6100 (unsigned long) section->sh_size);
c9c1d674
EG		 6101 break;
6102 }
6103
3f5e193b
NC		 6104 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6105 1, section->sh_size,
6106 _("section data"));
59245841
NC		 6107 if (start == NULL)
6108 continue;
f5842774
L		 6109
6110 indices = start;
6111 size = (section->sh_size / section->sh_entsize) - 1;
6112 entry = byte_get (indices, 4);
6113 indices += 4;
e4b17d5c
L		 6114
6115 if (do_section_groups)
6116 {
2b692964 6117 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6118 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6119
e4b17d5c
L		 6120 printf (_(" [Index] Name\n"));
6121 }
6122
6123 group->group_index = i;
6124
f5842774
L		 6125 for (j = 0; j < size; j++)
6126 {
2cf0635d 6127 struct group_list * g;
e4b17d5c 6128
f5842774
L		 6129 entry = byte_get (indices, 4);
6130 indices += 4;
6131
4fbb74a6 6132 if (entry >= elf_header.e_shnum)
391cb864 6133 {
57028622
NC		 6134 static unsigned num_group_errors = 0;
6135
6136 if (num_group_errors ++ < 10)
6137 {
6138 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6139 entry, i, elf_header.e_shnum - 1);
6140 if (num_group_errors == 10)
6141 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6142 }
391cb864
L		 6143 continue;
6144 }
391cb864 6145
4fbb74a6 6146 if (section_headers_groups [entry] != NULL)
e4b17d5c 6147 {
d1f5c6e3
L		 6148 if (entry)
6149 {
57028622
NC		 6150 static unsigned num_errs = 0;
6151
6152 if (num_errs ++ < 10)
6153 {
6154 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6155 entry, i,
6156 section_headers_groups [entry]->group_index);
6157 if (num_errs == 10)
6158 warn (_("Further error messages about already contained group sections suppressed\n"));
6159 }
d1f5c6e3
L		 6160 continue;
6161 }
6162 else
6163 {
6164 /* Intel C/C++ compiler may put section 0 in a
6165 section group. We just warn it the first time
6166 and ignore it afterwards. */
6167 static int warned = 0;
6168 if (!warned)
6169 {
6170 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6171 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6172 warned++;
6173 }
6174 }
e4b17d5c
L		 6175 }
6176
4fbb74a6 6177 section_headers_groups [entry] = group;
e4b17d5c
L		 6178
6179 if (do_section_groups)
6180 {
4fbb74a6 6181 sec = section_headers + entry;
74e1a04b 6182 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6183 }
6184
3f5e193b 6185 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6186 g->section_index = entry;
6187 g->next = group->root;
6188 group->root = g;
f5842774
L		 6189 }
6190
f5842774
L		 6191 if (start)
6192 free (start);
e4b17d5c
L		 6193
6194 group++;
f5842774
L		 6195 }
6196 }
6197
d1f5c6e3
L		 6198 if (symtab)
6199 free (symtab);
6200 if (strtab)
6201 free (strtab);
f5842774
L		 6202 return 1;
6203}
6204
28f997cf
TG		 6205/* Data used to display dynamic fixups. */
6206
6207struct ia64_vms_dynfixup
6208{
6209 bfd_vma needed_ident; /* Library ident number. */
6210 bfd_vma needed; /* Index in the dstrtab of the library name. */
6211 bfd_vma fixup_needed; /* Index of the library. */
6212 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6213 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6214};
6215
6216/* Data used to display dynamic relocations. */
6217
6218struct ia64_vms_dynimgrela
6219{
6220 bfd_vma img_rela_cnt; /* Number of relocations. */
6221 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6222};
6223
6224/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6225 library). */
6226
6227static void
6228dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6229 const char *strtab, unsigned int strtab_sz)
6230{
6231 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6232 long i;
6233 const char *lib_name;
6234
6235 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6236 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6237 _("dynamic section image fixups"));
6238 if (!imfs)
6239 return;
6240
6241 if (fixup->needed < strtab_sz)
6242 lib_name = strtab + fixup->needed;
6243 else
6244 {
6245 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6246 (unsigned long) fixup->needed);
28f997cf
TG		 6247 lib_name = "???";
6248 }
6249 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6250 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6251 printf
6252 (_("Seg Offset Type SymVec DataType\n"));
6253
6254 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6255 {
6256 unsigned int type;
6257 const char *rtype;
6258
6259 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6260 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6261 type = BYTE_GET (imfs [i].type);
6262 rtype = elf_ia64_reloc_type (type);
6263 if (rtype == NULL)
6264 printf (" 0x%08x ", type);
6265 else
6266 printf (" %-32s ", rtype);
6267 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6268 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6269 }
6270
6271 free (imfs);
6272}
6273
6274/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6275
6276static void
6277dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6278{
6279 Elf64_External_VMS_IMAGE_RELA *imrs;
6280 long i;
6281
6282 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6283 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6284 _("dynamic section image relocations"));
28f997cf
TG		 6285 if (!imrs)
6286 return;
6287
6288 printf (_("\nImage relocs\n"));
6289 printf
6290 (_("Seg Offset Type Addend Seg Sym Off\n"));
6291
6292 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6293 {
6294 unsigned int type;
6295 const char *rtype;
6296
6297 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6298 printf ("%08" BFD_VMA_FMT "x ",
6299 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6300 type = BYTE_GET (imrs [i].type);
6301 rtype = elf_ia64_reloc_type (type);
6302 if (rtype == NULL)
6303 printf ("0x%08x ", type);
6304 else
6305 printf ("%-31s ", rtype);
6306 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6307 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6308 printf ("%08" BFD_VMA_FMT "x\n",
6309 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6310 }
6311
6312 free (imrs);
6313}
6314
6315/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6316
6317static int
6318process_ia64_vms_dynamic_relocs (FILE *file)
6319{
6320 struct ia64_vms_dynfixup fixup;
6321 struct ia64_vms_dynimgrela imgrela;
6322 Elf_Internal_Dyn *entry;
6323 int res = 0;
6324 bfd_vma strtab_off = 0;
6325 bfd_vma strtab_sz = 0;
6326 char *strtab = NULL;
6327
6328 memset (&fixup, 0, sizeof (fixup));
6329 memset (&imgrela, 0, sizeof (imgrela));
6330
6331 /* Note: the order of the entries is specified by the OpenVMS specs. */
6332 for (entry = dynamic_section;
6333 entry < dynamic_section + dynamic_nent;
6334 entry++)
6335 {
6336 switch (entry->d_tag)
6337 {
6338 case DT_IA_64_VMS_STRTAB_OFFSET:
6339 strtab_off = entry->d_un.d_val;
6340 break;
6341 case DT_STRSZ:
6342 strtab_sz = entry->d_un.d_val;
6343 if (strtab == NULL)
6344 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6345 1, strtab_sz, _("dynamic string section"));
6346 break;
6347
6348 case DT_IA_64_VMS_NEEDED_IDENT:
6349 fixup.needed_ident = entry->d_un.d_val;
6350 break;
6351 case DT_NEEDED:
6352 fixup.needed = entry->d_un.d_val;
6353 break;
6354 case DT_IA_64_VMS_FIXUP_NEEDED:
6355 fixup.fixup_needed = entry->d_un.d_val;
6356 break;
6357 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6358 fixup.fixup_rela_cnt = entry->d_un.d_val;
6359 break;
6360 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6361 fixup.fixup_rela_off = entry->d_un.d_val;
6362 res++;
6363 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6364 break;
6365
6366 case DT_IA_64_VMS_IMG_RELA_CNT:
6367 imgrela.img_rela_cnt = entry->d_un.d_val;
6368 break;
6369 case DT_IA_64_VMS_IMG_RELA_OFF:
6370 imgrela.img_rela_off = entry->d_un.d_val;
6371 res++;
6372 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6373 break;
6374
6375 default:
6376 break;
6377 }
6378 }
6379
6380 if (strtab != NULL)
6381 free (strtab);
6382
6383 return res;
6384}
6385
85b1c36d 6386static struct
566b0d53 6387{
2cf0635d 6388 const char * name;
566b0d53
L		 6389 int reloc;
6390 int size;
6391 int rela;
6392} dynamic_relocations [] =
6393{
6394 { "REL", DT_REL, DT_RELSZ, FALSE },
6395 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6396 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6397};
6398
252b5132 6399/* Process the reloc section. */
18bd398b 6400
252b5132 6401static int
2cf0635d 6402process_relocs (FILE * file)
252b5132 6403{
b34976b6
AM		 6404 unsigned long rel_size;
6405 unsigned long rel_offset;
252b5132
RH		 6406
6407
6408 if (!do_reloc)
6409 return 1;
6410
6411 if (do_using_dynamic)
6412 {
566b0d53 6413 int is_rela;
2cf0635d 6414 const char * name;
566b0d53
L		 6415 int has_dynamic_reloc;
6416 unsigned int i;
0de14b54 6417
566b0d53 6418 has_dynamic_reloc = 0;
252b5132 6419
566b0d53 6420 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6421 {
566b0d53
L		 6422 is_rela = dynamic_relocations [i].rela;
6423 name = dynamic_relocations [i].name;
6424 rel_size = dynamic_info [dynamic_relocations [i].size];
6425 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6426
566b0d53
L		 6427 has_dynamic_reloc |= rel_size;
6428
6429 if (is_rela == UNKNOWN)
aa903cfb 6430 {
566b0d53
L		 6431 if (dynamic_relocations [i].reloc == DT_JMPREL)
6432 switch (dynamic_info[DT_PLTREL])
6433 {
6434 case DT_REL:
6435 is_rela = FALSE;
6436 break;
6437 case DT_RELA:
6438 is_rela = TRUE;
6439 break;
6440 }
aa903cfb 6441 }
252b5132 6442
566b0d53
L		 6443 if (rel_size)
6444 {
6445 printf
6446 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6447 name, rel_offset, rel_size);
252b5132 6448
d93f0186
NC		 6449 dump_relocations (file,
6450 offset_from_vma (file, rel_offset, rel_size),
6451 rel_size,
566b0d53 6452 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6453 dynamic_strings, dynamic_strings_length,
6454 is_rela, 1);
566b0d53 6455 }
252b5132 6456 }
566b0d53 6457
28f997cf
TG		 6458 if (is_ia64_vms ())
6459 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6460
566b0d53 6461 if (! has_dynamic_reloc)
252b5132
RH		 6462 printf (_("\nThere are no dynamic relocations in this file.\n"));
6463 }
6464 else
6465 {
2cf0635d 6466 Elf_Internal_Shdr * section;
b34976b6
AM		 6467 unsigned long i;
6468 int found = 0;
252b5132
RH		 6469
6470 for (i = 0, section = section_headers;
6471 i < elf_header.e_shnum;
b34976b6 6472 i++, section++)
252b5132
RH		 6473 {
6474 if ( section->sh_type != SHT_RELA
6475 && section->sh_type != SHT_REL)
6476 continue;
6477
6478 rel_offset = section->sh_offset;
6479 rel_size = section->sh_size;
6480
6481 if (rel_size)
6482 {
2cf0635d 6483 Elf_Internal_Shdr * strsec;
b34976b6 6484 int is_rela;
103f02d3 6485
252b5132
RH		 6486 printf (_("\nRelocation section "));
6487
6488 if (string_table == NULL)
19936277 6489 printf ("%d", section->sh_name);
252b5132 6490 else
74e1a04b 6491 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6492
6493 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6494 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6495
d79b3d50
NC		 6496 is_rela = section->sh_type == SHT_RELA;
6497
4fbb74a6
AM		 6498 if (section->sh_link != 0
6499 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6500 {
2cf0635d
NC		 6501 Elf_Internal_Shdr * symsec;
6502 Elf_Internal_Sym * symtab;
d79b3d50 6503 unsigned long nsyms;
c256ffe7 6504 unsigned long strtablen = 0;
2cf0635d 6505 char * strtab = NULL;
57346661 6506
4fbb74a6 6507 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6508 if (symsec->sh_type != SHT_SYMTAB
6509 && symsec->sh_type != SHT_DYNSYM)
6510 continue;
6511
ba5cdace 6512 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6513
af3fc3bc
AM		 6514 if (symtab == NULL)
6515 continue;
252b5132 6516
4fbb74a6
AM		 6517 if (symsec->sh_link != 0
6518 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6519 {
4fbb74a6 6520 strsec = section_headers + symsec->sh_link;
103f02d3 6521
3f5e193b 6522 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6523 1, strsec->sh_size,
6524 _("string table"));
c256ffe7
JJ		 6525 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6526 }
252b5132 6527
d79b3d50 6528 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6529 symtab, nsyms, strtab, strtablen,
6530 is_rela,
6531 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6532 if (strtab)
6533 free (strtab);
6534 free (symtab);
6535 }
6536 else
6537 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6538 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6539
6540 found = 1;
6541 }
6542 }
6543
6544 if (! found)
6545 printf (_("\nThere are no relocations in this file.\n"));
6546 }
6547
6548 return 1;
6549}
6550
4d6ed7c8
NC		 6551/* An absolute address consists of a section and an offset. If the
6552 section is NULL, the offset itself is the address, otherwise, the
6553 address equals to LOAD_ADDRESS(section) + offset. */
6554
6555struct absaddr
948f632f
DA		 6556{
6557 unsigned short section;
6558 bfd_vma offset;
6559};
4d6ed7c8 6560
1949de15
L		 6561#define ABSADDR(a) \
6562 ((a).section \
6563 ? section_headers [(a).section].sh_addr + (a).offset \
6564 : (a).offset)
6565
948f632f
DA		 6566/* Find the nearest symbol at or below ADDR. Returns the symbol
6567 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6568
4d6ed7c8 6569static void
2cf0635d 6570find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6571 unsigned long nsyms,
6572 const char * strtab,
6573 unsigned long strtab_size,
6574 struct absaddr addr,
6575 const char ** symname,
6576 bfd_vma * offset)
4d6ed7c8 6577{
d3ba0551 6578 bfd_vma dist = 0x100000;
2cf0635d 6579 Elf_Internal_Sym * sym;
948f632f
DA		 6580 Elf_Internal_Sym * beg;
6581 Elf_Internal_Sym * end;
2cf0635d 6582 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6583
0b6ae522 6584 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6585 beg = symtab;
6586 end = symtab + nsyms;
0b6ae522 6587
948f632f 6588 while (beg < end)
4d6ed7c8 6589 {
948f632f
DA		 6590 bfd_vma value;
6591
6592 sym = beg + (end - beg) / 2;
0b6ae522 6593
948f632f 6594 value = sym->st_value;
0b6ae522
DJ		 6595 REMOVE_ARCH_BITS (value);
6596
948f632f 6597 if (sym->st_name != 0
4d6ed7c8 6598 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6599 && addr.offset >= value
6600 && addr.offset - value < dist)
4d6ed7c8
NC		 6601 {
6602 best = sym;
0b6ae522 6603 dist = addr.offset - value;
4d6ed7c8
NC		 6604 if (!dist)
6605 break;
6606 }
948f632f
DA		 6607
6608 if (addr.offset < value)
6609 end = sym;
6610 else
6611 beg = sym + 1;
4d6ed7c8 6612 }
1b31d05e 6613
4d6ed7c8
NC		 6614 if (best)
6615 {
57346661 6616 *symname = (best->st_name >= strtab_size
2b692964 6617 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6618 *offset = dist;
6619 return;
6620 }
1b31d05e 6621
4d6ed7c8
NC		 6622 *symname = NULL;
6623 *offset = addr.offset;
6624}
6625
948f632f
DA		 6626static int
6627symcmp (const void *p, const void *q)
6628{
6629 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6630 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6631
6632 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6633}
6634
6635/* Process the unwind section. */
6636
6637#include "unwind-ia64.h"
6638
6639struct ia64_unw_table_entry
6640{
6641 struct absaddr start;
6642 struct absaddr end;
6643 struct absaddr info;
6644};
6645
6646struct ia64_unw_aux_info
6647{
6648 struct ia64_unw_table_entry *table; /* Unwind table. */
6649 unsigned long table_len; /* Length of unwind table. */
6650 unsigned char * info; /* Unwind info. */
6651 unsigned long info_size; /* Size of unwind info. */
6652 bfd_vma info_addr; /* Starting address of unwind info. */
6653 bfd_vma seg_base; /* Starting address of segment. */
6654 Elf_Internal_Sym * symtab; /* The symbol table. */
6655 unsigned long nsyms; /* Number of symbols. */
6656 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6657 unsigned long nfuns; /* Number of entries in funtab. */
6658 char * strtab; /* The string table. */
6659 unsigned long strtab_size; /* Size of string table. */
6660};
6661
4d6ed7c8 6662static void
2cf0635d 6663dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6664{
2cf0635d 6665 struct ia64_unw_table_entry * tp;
948f632f 6666 unsigned long j, nfuns;
4d6ed7c8 6667 int in_body;
7036c0e1 6668
948f632f
DA		 6669 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6670 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6671 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6672 aux->funtab[nfuns++] = aux->symtab[j];
6673 aux->nfuns = nfuns;
6674 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6675
4d6ed7c8
NC		 6676 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6677 {
6678 bfd_vma stamp;
6679 bfd_vma offset;
2cf0635d
NC		 6680 const unsigned char * dp;
6681 const unsigned char * head;
53774b7e 6682 const unsigned char * end;
2cf0635d 6683 const char * procname;
4d6ed7c8 6684
948f632f 6685 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6686 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6687
6688 fputs ("\n<", stdout);
6689
6690 if (procname)
6691 {
6692 fputs (procname, stdout);
6693
6694 if (offset)
6695 printf ("+%lx", (unsigned long) offset);
6696 }
6697
6698 fputs (">: [", stdout);
6699 print_vma (tp->start.offset, PREFIX_HEX);
6700 fputc ('-', stdout);
6701 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6702 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6703 (unsigned long) (tp->info.offset - aux->seg_base));
6704
53774b7e
NC		 6705 /* PR 17531: file: 86232b32. */
6706 if (aux->info == NULL)
6707 continue;
6708
6709 /* PR 17531: file: 0997b4d1. */
6710 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6711 {
6712 warn (_("Invalid offset %lx in table entry %ld\n"),
6713 (long) tp->info.offset, (long) (tp - aux->table));
6714 continue;
6715 }
6716
1949de15 6717 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6718 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6719
86f55779 6720 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6721 (unsigned) UNW_VER (stamp),
6722 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6723 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6724 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6725 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6726
6727 if (UNW_VER (stamp) != 1)
6728 {
2b692964 6729 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6730 continue;
6731 }
6732
6733 in_body = 0;
53774b7e
NC		 6734 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6735 /* PR 17531: file: 16ceda89. */
6736 if (end > aux->info + aux->info_size)
6737 end = aux->info + aux->info_size;
6738 for (dp = head + 8; dp < end;)
b4477bc8 6739 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6740 }
948f632f
DA		 6741
6742 free (aux->funtab);
4d6ed7c8
NC		 6743}
6744
53774b7e 6745static bfd_boolean
2cf0635d
NC		 6746slurp_ia64_unwind_table (FILE * file,
6747 struct ia64_unw_aux_info * aux,
6748 Elf_Internal_Shdr * sec)
4d6ed7c8 6749{
89fac5e3 6750 unsigned long size, nrelas, i;
2cf0635d
NC		 6751 Elf_Internal_Phdr * seg;
6752 struct ia64_unw_table_entry * tep;
6753 Elf_Internal_Shdr * relsec;
6754 Elf_Internal_Rela * rela;
6755 Elf_Internal_Rela * rp;
6756 unsigned char * table;
6757 unsigned char * tp;
6758 Elf_Internal_Sym * sym;
6759 const char * relname;
4d6ed7c8 6760
53774b7e
NC		 6761 aux->table_len = 0;
6762
4d6ed7c8
NC		 6763 /* First, find the starting address of the segment that includes
6764 this section: */
6765
6766 if (elf_header.e_phnum)
6767 {
d93f0186 6768 if (! get_program_headers (file))
53774b7e 6769 return FALSE;
4d6ed7c8 6770
d93f0186
NC		 6771 for (seg = program_headers;
6772 seg < program_headers + elf_header.e_phnum;
6773 ++seg)
4d6ed7c8
NC		 6774 {
6775 if (seg->p_type != PT_LOAD)
6776 continue;
6777
6778 if (sec->sh_addr >= seg->p_vaddr
6779 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6780 {
6781 aux->seg_base = seg->p_vaddr;
6782 break;
6783 }
6784 }
4d6ed7c8
NC		 6785 }
6786
6787 /* Second, build the unwind table from the contents of the unwind section: */
6788 size = sec->sh_size;
3f5e193b
NC		 6789 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6790 _("unwind table"));
a6e9f9df 6791 if (!table)
53774b7e 6792 return FALSE;
4d6ed7c8 6793
53774b7e 6794 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6795 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6796 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6797 tep = aux->table;
53774b7e
NC		 6798
6799 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6800 {
6801 tep->start.section = SHN_UNDEF;
6802 tep->end.section = SHN_UNDEF;
6803 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6804 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6805 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6806 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6807 tep->start.offset += aux->seg_base;
6808 tep->end.offset += aux->seg_base;
6809 tep->info.offset += aux->seg_base;
6810 }
6811 free (table);
6812
41e92641 6813 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6814 for (relsec = section_headers;
6815 relsec < section_headers + elf_header.e_shnum;
6816 ++relsec)
6817 {
6818 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6819 || relsec->sh_info >= elf_header.e_shnum
6820 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6821 continue;
6822
6823 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6824 & rela, & nrelas))
53774b7e
NC		 6825 {
6826 free (aux->table);
6827 aux->table = NULL;
6828 aux->table_len = 0;
6829 return FALSE;
6830 }
4d6ed7c8
NC		 6831
6832 for (rp = rela; rp < rela + nrelas; ++rp)
6833 {
aca88567
NC		 6834 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6835 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6836
82b1b41b
NC		 6837 /* PR 17531: file: 9fa67536. */
6838 if (relname == NULL)
6839 {
6840 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6841 continue;
6842 }
948f632f 6843
0112cd26 6844 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6845 {
82b1b41b 6846 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6847 continue;
6848 }
6849
89fac5e3 6850 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6851
53774b7e
NC		 6852 /* PR 17531: file: 5bc8d9bf. */
6853 if (i >= aux->table_len)
6854 {
6855 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6856 continue;
6857 }
6858
6859 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6860 {
6861 case 0:
6862 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6863 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6864 break;
6865 case 1:
6866 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6867 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6868 break;
6869 case 2:
6870 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6871 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6872 break;
6873 default:
6874 break;
6875 }
6876 }
6877
6878 free (rela);
6879 }
6880
53774b7e 6881 return TRUE;
4d6ed7c8
NC		 6882}
6883
1b31d05e 6884static void
2cf0635d 6885ia64_process_unwind (FILE * file)
4d6ed7c8 6886{
2cf0635d
NC		 6887 Elf_Internal_Shdr * sec;
6888 Elf_Internal_Shdr * unwsec = NULL;
6889 Elf_Internal_Shdr * strsec;
89fac5e3 6890 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6891 struct ia64_unw_aux_info aux;
f1467e33 6892
4d6ed7c8
NC		 6893 memset (& aux, 0, sizeof (aux));
6894
4d6ed7c8
NC		 6895 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6896 {
c256ffe7 6897 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6898 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6899 {
ba5cdace 6900 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6901
4fbb74a6 6902 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6903 if (aux.strtab != NULL)
6904 {
6905 error (_("Multiple auxillary string tables encountered\n"));
6906 free (aux.strtab);
6907 }
3f5e193b
NC		 6908 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6909 1, strsec->sh_size,
6910 _("string table"));
c256ffe7 6911 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6912 }
6913 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6914 unwcount++;
6915 }
6916
6917 if (!unwcount)
6918 printf (_("\nThere are no unwind sections in this file.\n"));
6919
6920 while (unwcount-- > 0)
6921 {
2cf0635d 6922 char * suffix;
579f31ac
JJ		 6923 size_t len, len2;
6924
4082ef84 6925 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6926 i < elf_header.e_shnum; ++i, ++sec)
6927 if (sec->sh_type == SHT_IA_64_UNWIND)
6928 {
6929 unwsec = sec;
6930 break;
6931 }
4082ef84
NC		 6932 /* We have already counted the number of SHT_IA64_UNWIND
6933 sections so the loop above should never fail. */
6934 assert (unwsec != NULL);
579f31ac
JJ		 6935
6936 unwstart = i + 1;
6937 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6938
e4b17d5c
L		 6939 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6940 {
6941 /* We need to find which section group it is in. */
4082ef84 6942 struct group_list * g;
e4b17d5c 6943
4082ef84
NC		 6944 if (section_headers_groups == NULL
6945 || section_headers_groups [i] == NULL)
6946 i = elf_header.e_shnum;
6947 else
e4b17d5c 6948 {
4082ef84 6949 g = section_headers_groups [i]->root;
18bd398b 6950
4082ef84
NC		 6951 for (; g != NULL; g = g->next)
6952 {
6953 sec = section_headers + g->section_index;
e4b17d5c 6954
4082ef84
NC		 6955 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6956 break;
6957 }
6958
6959 if (g == NULL)
6960 i = elf_header.e_shnum;
6961 }
e4b17d5c 6962 }
18bd398b 6963 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6964 {
18bd398b 6965 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6966 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6967 suffix = SECTION_NAME (unwsec) + len;
6968 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6969 ++i, ++sec)
18bd398b
NC		 6970 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6971 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6972 break;
6973 }
6974 else
6975 {
6976 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6977 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6978 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6979 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6980 suffix = "";
18bd398b 6981 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6982 suffix = SECTION_NAME (unwsec) + len;
6983 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6984 ++i, ++sec)
18bd398b
NC		 6985 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6986 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6987 break;
6988 }
6989
6990 if (i == elf_header.e_shnum)
6991 {
6992 printf (_("\nCould not find unwind info section for "));
6993
6994 if (string_table == NULL)
6995 printf ("%d", unwsec->sh_name);
6996 else
74e1a04b 6997 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6998 }
6999 else
4d6ed7c8 7000 {
4d6ed7c8 7001 aux.info_addr = sec->sh_addr;
3f5e193b 7002 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7003 sec->sh_size,
7004 _("unwind info"));
59245841 7005 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7006
579f31ac 7007 printf (_("\nUnwind section "));
4d6ed7c8 7008
579f31ac
JJ		 7009 if (string_table == NULL)
7010 printf ("%d", unwsec->sh_name);
7011 else
74e1a04b 7012 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7013
579f31ac 7014 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7015 (unsigned long) unwsec->sh_offset,
89fac5e3 7016 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7017
53774b7e
NC		 7018 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7019 && aux.table_len > 0)
579f31ac
JJ		 7020 dump_ia64_unwind (& aux);
7021
7022 if (aux.table)
7023 free ((char *) aux.table);
7024 if (aux.info)
7025 free ((char *) aux.info);
7026 aux.table = NULL;
7027 aux.info = NULL;
7028 }
4d6ed7c8 7029 }
4d6ed7c8 7030
4d6ed7c8
NC		 7031 if (aux.symtab)
7032 free (aux.symtab);
7033 if (aux.strtab)
7034 free ((char *) aux.strtab);
4d6ed7c8
NC		 7035}
7036
3f5e193b
NC		 7037struct hppa_unw_table_entry
7038 {
7039 struct absaddr start;
7040 struct absaddr end;
948f632f 7041 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7042 unsigned int Millicode:1; /* 1 */
7043 unsigned int Millicode_save_sr0:1; /* 2 */
7044 unsigned int Region_description:2; /* 3..4 */
7045 unsigned int reserved1:1; /* 5 */
7046 unsigned int Entry_SR:1; /* 6 */
7047 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7048 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7049 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7050 unsigned int Variable_Frame:1; /* 17 */
7051 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7052 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7053 unsigned int Stack_Overflow_Check:1; /* 20 */
7054 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7055 unsigned int Ada_Region:1; /* 22 */
7056 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7057 unsigned int cxx_try_catch:1; /* 24 */
7058 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7059 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7060 unsigned int Save_SP:1; /* 27 */
7061 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7062 unsigned int Save_MRP_in_frame:1; /* 29 */
7063 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7064 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7065
948f632f
DA		 7066 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7067 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7068 unsigned int Large_frame:1; /* 2 */
948f632f 7069 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7070 unsigned int reserved4:1; /* 4 */
7071 unsigned int Total_frame_size:27; /* 5..31 */
7072 };
7073
57346661 7074struct hppa_unw_aux_info
948f632f
DA		 7075{
7076 struct hppa_unw_table_entry * table; /* Unwind table. */
7077 unsigned long table_len; /* Length of unwind table. */
7078 bfd_vma seg_base; /* Starting address of segment. */
7079 Elf_Internal_Sym * symtab; /* The symbol table. */
7080 unsigned long nsyms; /* Number of symbols. */
7081 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7082 unsigned long nfuns; /* Number of entries in funtab. */
7083 char * strtab; /* The string table. */
7084 unsigned long strtab_size; /* Size of string table. */
7085};
57346661
AM		 7086
7087static void
2cf0635d 7088dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7089{
2cf0635d 7090 struct hppa_unw_table_entry * tp;
948f632f
DA		 7091 unsigned long j, nfuns;
7092
7093 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7094 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7095 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7096 aux->funtab[nfuns++] = aux->symtab[j];
7097 aux->nfuns = nfuns;
7098 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7099
57346661
AM		 7100 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7101 {
7102 bfd_vma offset;
2cf0635d 7103 const char * procname;
57346661 7104
948f632f 7105 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7106 aux->strtab_size, tp->start, &procname,
7107 &offset);
7108
7109 fputs ("\n<", stdout);
7110
7111 if (procname)
7112 {
7113 fputs (procname, stdout);
7114
7115 if (offset)
7116 printf ("+%lx", (unsigned long) offset);
7117 }
7118
7119 fputs (">: [", stdout);
7120 print_vma (tp->start.offset, PREFIX_HEX);
7121 fputc ('-', stdout);
7122 print_vma (tp->end.offset, PREFIX_HEX);
7123 printf ("]\n\t");
7124
18bd398b
NC		 7125#define PF(_m) if (tp->_m) printf (#_m " ");
7126#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7127 PF(Cannot_unwind);
7128 PF(Millicode);
7129 PF(Millicode_save_sr0);
18bd398b 7130 /* PV(Region_description); */
57346661
AM		 7131 PF(Entry_SR);
7132 PV(Entry_FR);
7133 PV(Entry_GR);
7134 PF(Args_stored);
7135 PF(Variable_Frame);
7136 PF(Separate_Package_Body);
7137 PF(Frame_Extension_Millicode);
7138 PF(Stack_Overflow_Check);
7139 PF(Two_Instruction_SP_Increment);
7140 PF(Ada_Region);
7141 PF(cxx_info);
7142 PF(cxx_try_catch);
7143 PF(sched_entry_seq);
7144 PF(Save_SP);
7145 PF(Save_RP);
7146 PF(Save_MRP_in_frame);
7147 PF(extn_ptr_defined);
7148 PF(Cleanup_defined);
7149 PF(MPE_XL_interrupt_marker);
7150 PF(HP_UX_interrupt_marker);
7151 PF(Large_frame);
7152 PF(Pseudo_SP_Set);
7153 PV(Total_frame_size);
7154#undef PF
7155#undef PV
7156 }
7157
18bd398b 7158 printf ("\n");
948f632f
DA		 7159
7160 free (aux->funtab);
57346661
AM		 7161}
7162
7163static int
2cf0635d
NC		 7164slurp_hppa_unwind_table (FILE * file,
7165 struct hppa_unw_aux_info * aux,
7166 Elf_Internal_Shdr * sec)
57346661 7167{
1c0751b2 7168 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7169 Elf_Internal_Phdr * seg;
7170 struct hppa_unw_table_entry * tep;
7171 Elf_Internal_Shdr * relsec;
7172 Elf_Internal_Rela * rela;
7173 Elf_Internal_Rela * rp;
7174 unsigned char * table;
7175 unsigned char * tp;
7176 Elf_Internal_Sym * sym;
7177 const char * relname;
57346661 7178
57346661
AM		 7179 /* First, find the starting address of the segment that includes
7180 this section. */
7181
7182 if (elf_header.e_phnum)
7183 {
7184 if (! get_program_headers (file))
7185 return 0;
7186
7187 for (seg = program_headers;
7188 seg < program_headers + elf_header.e_phnum;
7189 ++seg)
7190 {
7191 if (seg->p_type != PT_LOAD)
7192 continue;
7193
7194 if (sec->sh_addr >= seg->p_vaddr
7195 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7196 {
7197 aux->seg_base = seg->p_vaddr;
7198 break;
7199 }
7200 }
7201 }
7202
7203 /* Second, build the unwind table from the contents of the unwind
7204 section. */
7205 size = sec->sh_size;
3f5e193b
NC		 7206 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7207 _("unwind table"));
57346661
AM		 7208 if (!table)
7209 return 0;
7210
1c0751b2
DA		 7211 unw_ent_size = 16;
7212 nentries = size / unw_ent_size;
7213 size = unw_ent_size * nentries;
57346661 7214
3f5e193b
NC		 7215 tep = aux->table = (struct hppa_unw_table_entry *)
7216 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7217
1c0751b2 7218 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7219 {
7220 unsigned int tmp1, tmp2;
7221
7222 tep->start.section = SHN_UNDEF;
7223 tep->end.section = SHN_UNDEF;
7224
1c0751b2
DA		 7225 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7226 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7227 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7228 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7229
7230 tep->start.offset += aux->seg_base;
7231 tep->end.offset += aux->seg_base;
57346661
AM		 7232
7233 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7234 tep->Millicode = (tmp1 >> 30) & 0x1;
7235 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7236 tep->Region_description = (tmp1 >> 27) & 0x3;
7237 tep->reserved1 = (tmp1 >> 26) & 0x1;
7238 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7239 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7240 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7241 tep->Args_stored = (tmp1 >> 15) & 0x1;
7242 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7243 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7244 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7245 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7246 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7247 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7248 tep->cxx_info = (tmp1 >> 8) & 0x1;
7249 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7250 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7251 tep->reserved2 = (tmp1 >> 5) & 0x1;
7252 tep->Save_SP = (tmp1 >> 4) & 0x1;
7253 tep->Save_RP = (tmp1 >> 3) & 0x1;
7254 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7255 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7256 tep->Cleanup_defined = tmp1 & 0x1;
7257
7258 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7259 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7260 tep->Large_frame = (tmp2 >> 29) & 0x1;
7261 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7262 tep->reserved4 = (tmp2 >> 27) & 0x1;
7263 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7264 }
7265 free (table);
7266
7267 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7268 for (relsec = section_headers;
7269 relsec < section_headers + elf_header.e_shnum;
7270 ++relsec)
7271 {
7272 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7273 || relsec->sh_info >= elf_header.e_shnum
7274 || section_headers + relsec->sh_info != sec)
57346661
AM		 7275 continue;
7276
7277 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7278 & rela, & nrelas))
7279 return 0;
7280
7281 for (rp = rela; rp < rela + nrelas; ++rp)
7282 {
aca88567
NC		 7283 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7284 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7285
7286 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7287 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7288 {
7289 warn (_("Skipping unexpected relocation type %s\n"), relname);
7290 continue;
7291 }
7292
7293 i = rp->r_offset / unw_ent_size;
7294
89fac5e3 7295 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7296 {
7297 case 0:
7298 aux->table[i].start.section = sym->st_shndx;
1e456d54 7299 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7300 break;
7301 case 1:
7302 aux->table[i].end.section = sym->st_shndx;
1e456d54 7303 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7304 break;
7305 default:
7306 break;
7307 }
7308 }
7309
7310 free (rela);
7311 }
7312
1c0751b2 7313 aux->table_len = nentries;
57346661
AM		 7314
7315 return 1;
7316}
7317
1b31d05e 7318static void
2cf0635d 7319hppa_process_unwind (FILE * file)
57346661 7320{
57346661 7321 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7322 Elf_Internal_Shdr * unwsec = NULL;
7323 Elf_Internal_Shdr * strsec;
7324 Elf_Internal_Shdr * sec;
18bd398b 7325 unsigned long i;
57346661 7326
c256ffe7 7327 if (string_table == NULL)
1b31d05e
NC		 7328 return;
7329
7330 memset (& aux, 0, sizeof (aux));
57346661
AM		 7331
7332 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7333 {
c256ffe7 7334 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7335 && sec->sh_link < elf_header.e_shnum)
57346661 7336 {
ba5cdace 7337 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7338
4fbb74a6 7339 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7340 if (aux.strtab != NULL)
7341 {
7342 error (_("Multiple auxillary string tables encountered\n"));
7343 free (aux.strtab);
7344 }
3f5e193b
NC		 7345 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7346 1, strsec->sh_size,
7347 _("string table"));
c256ffe7 7348 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7349 }
18bd398b 7350 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7351 unwsec = sec;
7352 }
7353
7354 if (!unwsec)
7355 printf (_("\nThere are no unwind sections in this file.\n"));
7356
7357 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7358 {
18bd398b 7359 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7360 {
74e1a04b
NC		 7361 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7362 printable_section_name (sec),
57346661 7363 (unsigned long) sec->sh_offset,
89fac5e3 7364 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7365
7366 slurp_hppa_unwind_table (file, &aux, sec);
7367 if (aux.table_len > 0)
7368 dump_hppa_unwind (&aux);
7369
7370 if (aux.table)
7371 free ((char *) aux.table);
7372 aux.table = NULL;
7373 }
7374 }
7375
7376 if (aux.symtab)
7377 free (aux.symtab);
7378 if (aux.strtab)
7379 free ((char *) aux.strtab);
57346661
AM		 7380}
7381
0b6ae522
DJ		 7382struct arm_section
7383{
a734115a
NC		 7384 unsigned char * data; /* The unwind data. */
7385 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7386 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7387 unsigned long nrelas; /* The number of relocations. */
7388 unsigned int rel_type; /* REL or RELA ? */
7389 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7390};
7391
7392struct arm_unw_aux_info
7393{
a734115a
NC		 7394 FILE * file; /* The file containing the unwind sections. */
7395 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7396 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7397 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7398 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7399 char * strtab; /* The file's string table. */
7400 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7401};
7402
7403static const char *
7404arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7405 bfd_vma fn, struct absaddr addr)
7406{
7407 const char *procname;
7408 bfd_vma sym_offset;
7409
7410 if (addr.section == SHN_UNDEF)
7411 addr.offset = fn;
7412
948f632f 7413 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7414 aux->strtab_size, addr, &procname,
7415 &sym_offset);
7416
7417 print_vma (fn, PREFIX_HEX);
7418
7419 if (procname)
7420 {
7421 fputs (" <", stdout);
7422 fputs (procname, stdout);
7423
7424 if (sym_offset)
7425 printf ("+0x%lx", (unsigned long) sym_offset);
7426 fputc ('>', stdout);
7427 }
7428
7429 return procname;
7430}
7431
7432static void
7433arm_free_section (struct arm_section *arm_sec)
7434{
7435 if (arm_sec->data != NULL)
7436 free (arm_sec->data);
7437
7438 if (arm_sec->rela != NULL)
7439 free (arm_sec->rela);
7440}
7441
a734115a
NC		 7442/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7443 cached section and install SEC instead.
7444 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7445 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7446 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7447 relocation's offset in ADDR.
1b31d05e
NC		 7448 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7449 into the string table of the symbol associated with the reloc. If no
7450 reloc was applied store -1 there.
7451 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7452
7453static bfd_boolean
1b31d05e
NC		 7454get_unwind_section_word (struct arm_unw_aux_info * aux,
7455 struct arm_section * arm_sec,
7456 Elf_Internal_Shdr * sec,
7457 bfd_vma word_offset,
7458 unsigned int * wordp,
7459 struct absaddr * addr,
7460 bfd_vma * sym_name)
0b6ae522
DJ		 7461{
7462 Elf_Internal_Rela *rp;
7463 Elf_Internal_Sym *sym;
7464 const char * relname;
7465 unsigned int word;
7466 bfd_boolean wrapped;
7467
e0a31db1
NC		 7468 if (sec == NULL || arm_sec == NULL)
7469 return FALSE;
7470
0b6ae522
DJ		 7471 addr->section = SHN_UNDEF;
7472 addr->offset = 0;
7473
1b31d05e
NC		 7474 if (sym_name != NULL)
7475 *sym_name = (bfd_vma) -1;
7476
a734115a 7477 /* If necessary, update the section cache. */
0b6ae522
DJ		 7478 if (sec != arm_sec->sec)
7479 {
7480 Elf_Internal_Shdr *relsec;
7481
7482 arm_free_section (arm_sec);
7483
7484 arm_sec->sec = sec;
7485 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7486 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7487 arm_sec->rela = NULL;
7488 arm_sec->nrelas = 0;
7489
7490 for (relsec = section_headers;
7491 relsec < section_headers + elf_header.e_shnum;
7492 ++relsec)
7493 {
7494 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7495 || section_headers + relsec->sh_info != sec
7496 /* PR 15745: Check the section type as well. */
7497 || (relsec->sh_type != SHT_REL
7498 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7499 continue;
7500
a734115a 7501 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7502 if (relsec->sh_type == SHT_REL)
7503 {
7504 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7505 relsec->sh_size,
7506 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7507 return FALSE;
0b6ae522 7508 }
1ae40aa4 7509 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7510 {
7511 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7512 relsec->sh_size,
7513 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7514 return FALSE;
0b6ae522 7515 }
1ae40aa4 7516 break;
0b6ae522
DJ		 7517 }
7518
7519 arm_sec->next_rela = arm_sec->rela;
7520 }
7521
a734115a 7522 /* If there is no unwind data we can do nothing. */
0b6ae522 7523 if (arm_sec->data == NULL)
a734115a 7524 return FALSE;
0b6ae522 7525
e0a31db1
NC		 7526 /* If the offset is invalid then fail. */
7527 if (word_offset > sec->sh_size - 4)
7528 return FALSE;
7529
a734115a 7530 /* Get the word at the required offset. */
0b6ae522
DJ		 7531 word = byte_get (arm_sec->data + word_offset, 4);
7532
0eff7165
NC		 7533 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7534 if (arm_sec->rela == NULL)
7535 {
7536 * wordp = word;
7537 return TRUE;
7538 }
7539
a734115a 7540 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7541 wrapped = FALSE;
7542 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7543 {
7544 bfd_vma prelval, offset;
7545
7546 if (rp->r_offset > word_offset && !wrapped)
7547 {
7548 rp = arm_sec->rela;
7549 wrapped = TRUE;
7550 }
7551 if (rp->r_offset > word_offset)
7552 break;
7553
7554 if (rp->r_offset & 3)
7555 {
7556 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7557 (unsigned long) rp->r_offset);
7558 continue;
7559 }
7560
7561 if (rp->r_offset < word_offset)
7562 continue;
7563
74e1a04b
NC		 7564 /* PR 17531: file: 027-161405-0.004 */
7565 if (aux->symtab == NULL)
7566 continue;
7567
0b6ae522
DJ		 7568 if (arm_sec->rel_type == SHT_REL)
7569 {
7570 offset = word & 0x7fffffff;
7571 if (offset & 0x40000000)
7572 offset |= ~ (bfd_vma) 0x7fffffff;
7573 }
a734115a 7574 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7575 offset = rp->r_addend;
a734115a 7576 else
74e1a04b
NC		 7577 {
7578 error (_("Unknown section relocation type %d encountered\n"),
7579 arm_sec->rel_type);
7580 break;
7581 }
0b6ae522 7582
071436c6
NC		 7583 /* PR 17531 file: 027-1241568-0.004. */
7584 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7585 {
7586 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7587 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7588 break;
7589 }
7590
7591 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7592 offset += sym->st_value;
7593 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7594
a734115a
NC		 7595 /* Check that we are processing the expected reloc type. */
7596 if (elf_header.e_machine == EM_ARM)
7597 {
7598 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7599 if (relname == NULL)
7600 {
7601 warn (_("Skipping unknown ARM relocation type: %d\n"),
7602 (int) ELF32_R_TYPE (rp->r_info));
7603 continue;
7604 }
a734115a
NC		 7605
7606 if (streq (relname, "R_ARM_NONE"))
7607 continue;
0b4362b0 7608
a734115a
NC		 7609 if (! streq (relname, "R_ARM_PREL31"))
7610 {
071436c6 7611 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7612 continue;
7613 }
7614 }
7615 else if (elf_header.e_machine == EM_TI_C6000)
7616 {
7617 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7618 if (relname == NULL)
7619 {
7620 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7621 (int) ELF32_R_TYPE (rp->r_info));
7622 continue;
7623 }
0b4362b0 7624
a734115a
NC		 7625 if (streq (relname, "R_C6000_NONE"))
7626 continue;
7627
7628 if (! streq (relname, "R_C6000_PREL31"))
7629 {
071436c6 7630 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7631 continue;
7632 }
7633
7634 prelval >>= 1;
7635 }
7636 else
74e1a04b
NC		 7637 {
7638 /* This function currently only supports ARM and TI unwinders. */
7639 warn (_("Only TI and ARM unwinders are currently supported\n"));
7640 break;
7641 }
fa197c1c 7642
0b6ae522
DJ		 7643 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7644 addr->section = sym->st_shndx;
7645 addr->offset = offset;
74e1a04b 7646
1b31d05e
NC		 7647 if (sym_name)
7648 * sym_name = sym->st_name;
0b6ae522
DJ		 7649 break;
7650 }
7651
7652 *wordp = word;
7653 arm_sec->next_rela = rp;
7654
a734115a 7655 return TRUE;
0b6ae522
DJ		 7656}
7657
a734115a
NC		 7658static const char *tic6x_unwind_regnames[16] =
7659{
0b4362b0
RM		 7660 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7661 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7662 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7663};
fa197c1c 7664
0b6ae522 7665static void
fa197c1c 7666decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7667{
fa197c1c
PB		 7668 int i;
7669
7670 for (i = 12; mask; mask >>= 1, i--)
7671 {
7672 if (mask & 1)
7673 {
7674 fputs (tic6x_unwind_regnames[i], stdout);
7675 if (mask > 1)
7676 fputs (", ", stdout);
7677 }
7678 }
7679}
0b6ae522
DJ		 7680
7681#define ADVANCE \
7682 if (remaining == 0 && more_words) \
7683 { \
7684 data_offset += 4; \
1b31d05e
NC		 7685 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7686 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7687 return; \
7688 remaining = 4; \
7689 more_words--; \
7690 } \
7691
7692#define GET_OP(OP) \
7693 ADVANCE; \
7694 if (remaining) \
7695 { \
7696 remaining--; \
7697 (OP) = word >> 24; \
7698 word <<= 8; \
7699 } \
7700 else \
7701 { \
2b692964 7702 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7703 return; \
7704 } \
cc5914eb 7705 printf ("0x%02x ", OP)
0b6ae522 7706
fa197c1c 7707static void
948f632f
DA		 7708decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7709 unsigned int word,
7710 unsigned int remaining,
7711 unsigned int more_words,
7712 bfd_vma data_offset,
7713 Elf_Internal_Shdr * data_sec,
7714 struct arm_section * data_arm_sec)
fa197c1c
PB		 7715{
7716 struct absaddr addr;
0b6ae522
DJ		 7717
7718 /* Decode the unwinding instructions. */
7719 while (1)
7720 {
7721 unsigned int op, op2;
7722
7723 ADVANCE;
7724 if (remaining == 0)
7725 break;
7726 remaining--;
7727 op = word >> 24;
7728 word <<= 8;
7729
cc5914eb 7730 printf (" 0x%02x ", op);
0b6ae522
DJ		 7731
7732 if ((op & 0xc0) == 0x00)
7733 {
7734 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7735
cc5914eb 7736 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7737 }
7738 else if ((op & 0xc0) == 0x40)
7739 {
7740 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7741
cc5914eb 7742 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7743 }
7744 else if ((op & 0xf0) == 0x80)
7745 {
7746 GET_OP (op2);
7747 if (op == 0x80 && op2 == 0)
7748 printf (_("Refuse to unwind"));
7749 else
7750 {
7751 unsigned int mask = ((op & 0x0f) << 8) | op2;
7752 int first = 1;
7753 int i;
2b692964 7754
0b6ae522
DJ		 7755 printf ("pop {");
7756 for (i = 0; i < 12; i++)
7757 if (mask & (1 << i))
7758 {
7759 if (first)
7760 first = 0;
7761 else
7762 printf (", ");
7763 printf ("r%d", 4 + i);
7764 }
7765 printf ("}");
7766 }
7767 }
7768 else if ((op & 0xf0) == 0x90)
7769 {
7770 if (op == 0x9d || op == 0x9f)
7771 printf (_(" [Reserved]"));
7772 else
cc5914eb 7773 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7774 }
7775 else if ((op & 0xf0) == 0xa0)
7776 {
7777 int end = 4 + (op & 0x07);
7778 int first = 1;
7779 int i;
61865e30 7780
0b6ae522
DJ		 7781 printf (" pop {");
7782 for (i = 4; i <= end; i++)
7783 {
7784 if (first)
7785 first = 0;
7786 else
7787 printf (", ");
7788 printf ("r%d", i);
7789 }
7790 if (op & 0x08)
7791 {
1b31d05e 7792 if (!first)
0b6ae522
DJ		 7793 printf (", ");
7794 printf ("r14");
7795 }
7796 printf ("}");
7797 }
7798 else if (op == 0xb0)
7799 printf (_(" finish"));
7800 else if (op == 0xb1)
7801 {
7802 GET_OP (op2);
7803 if (op2 == 0 || (op2 & 0xf0) != 0)
7804 printf (_("[Spare]"));
7805 else
7806 {
7807 unsigned int mask = op2 & 0x0f;
7808 int first = 1;
7809 int i;
61865e30 7810
0b6ae522
DJ		 7811 printf ("pop {");
7812 for (i = 0; i < 12; i++)
7813 if (mask & (1 << i))
7814 {
7815 if (first)
7816 first = 0;
7817 else
7818 printf (", ");
7819 printf ("r%d", i);
7820 }
7821 printf ("}");
7822 }
7823 }
7824 else if (op == 0xb2)
7825 {
b115cf96 7826 unsigned char buf[9];
0b6ae522
DJ		 7827 unsigned int i, len;
7828 unsigned long offset;
61865e30 7829
b115cf96 7830 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7831 {
7832 GET_OP (buf[i]);
7833 if ((buf[i] & 0x80) == 0)
7834 break;
7835 }
4082ef84
NC		 7836 if (i == sizeof (buf))
7837 printf (_("corrupt change to vsp"));
7838 else
7839 {
7840 offset = read_uleb128 (buf, &len, buf + i + 1);
7841 assert (len == i + 1);
7842 offset = offset * 4 + 0x204;
7843 printf ("vsp = vsp + %ld", offset);
7844 }
0b6ae522 7845 }
61865e30 7846 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7847 {
61865e30
NC		 7848 unsigned int first, last;
7849
7850 GET_OP (op2);
7851 first = op2 >> 4;
7852 last = op2 & 0x0f;
7853 if (op == 0xc8)
7854 first = first + 16;
7855 printf ("pop {D%d", first);
7856 if (last)
7857 printf ("-D%d", first + last);
7858 printf ("}");
7859 }
7860 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7861 {
7862 unsigned int count = op & 0x07;
7863
7864 printf ("pop {D8");
7865 if (count)
7866 printf ("-D%d", 8 + count);
7867 printf ("}");
7868 }
7869 else if (op >= 0xc0 && op <= 0xc5)
7870 {
7871 unsigned int count = op & 0x07;
7872
7873 printf (" pop {wR10");
7874 if (count)
7875 printf ("-wR%d", 10 + count);
7876 printf ("}");
7877 }
7878 else if (op == 0xc6)
7879 {
7880 unsigned int first, last;
7881
7882 GET_OP (op2);
7883 first = op2 >> 4;
7884 last = op2 & 0x0f;
7885 printf ("pop {wR%d", first);
7886 if (last)
7887 printf ("-wR%d", first + last);
7888 printf ("}");
7889 }
7890 else if (op == 0xc7)
7891 {
7892 GET_OP (op2);
7893 if (op2 == 0 || (op2 & 0xf0) != 0)
7894 printf (_("[Spare]"));
0b6ae522
DJ		 7895 else
7896 {
61865e30
NC		 7897 unsigned int mask = op2 & 0x0f;
7898 int first = 1;
7899 int i;
7900
7901 printf ("pop {");
7902 for (i = 0; i < 4; i++)
7903 if (mask & (1 << i))
7904 {
7905 if (first)
7906 first = 0;
7907 else
7908 printf (", ");
7909 printf ("wCGR%d", i);
7910 }
7911 printf ("}");
0b6ae522
DJ		 7912 }
7913 }
61865e30
NC		 7914 else
7915 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7916 printf ("\n");
7917 }
fa197c1c
PB		 7918}
7919
7920static void
948f632f
DA		 7921decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7922 unsigned int word,
7923 unsigned int remaining,
7924 unsigned int more_words,
7925 bfd_vma data_offset,
7926 Elf_Internal_Shdr * data_sec,
7927 struct arm_section * data_arm_sec)
fa197c1c
PB		 7928{
7929 struct absaddr addr;
7930
7931 /* Decode the unwinding instructions. */
7932 while (1)
7933 {
7934 unsigned int op, op2;
7935
7936 ADVANCE;
7937 if (remaining == 0)
7938 break;
7939 remaining--;
7940 op = word >> 24;
7941 word <<= 8;
7942
9cf03b7e 7943 printf (" 0x%02x ", op);
fa197c1c
PB		 7944
7945 if ((op & 0xc0) == 0x00)
7946 {
7947 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7948 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7949 }
7950 else if ((op & 0xc0) == 0x80)
7951 {
7952 GET_OP (op2);
7953 if (op == 0x80 && op2 == 0)
7954 printf (_("Refuse to unwind"));
7955 else
7956 {
7957 unsigned int mask = ((op & 0x1f) << 8) | op2;
7958 if (op & 0x20)
7959 printf ("pop compact {");
7960 else
7961 printf ("pop {");
7962
7963 decode_tic6x_unwind_regmask (mask);
7964 printf("}");
7965 }
7966 }
7967 else if ((op & 0xf0) == 0xc0)
7968 {
7969 unsigned int reg;
7970 unsigned int nregs;
7971 unsigned int i;
7972 const char *name;
a734115a
NC		 7973 struct
7974 {
fa197c1c
PB		 7975 unsigned int offset;
7976 unsigned int reg;
7977 } regpos[16];
7978
7979 /* Scan entire instruction first so that GET_OP output is not
7980 interleaved with disassembly. */
7981 nregs = 0;
7982 for (i = 0; nregs < (op & 0xf); i++)
7983 {
7984 GET_OP (op2);
7985 reg = op2 >> 4;
7986 if (reg != 0xf)
7987 {
7988 regpos[nregs].offset = i * 2;
7989 regpos[nregs].reg = reg;
7990 nregs++;
7991 }
7992
7993 reg = op2 & 0xf;
7994 if (reg != 0xf)
7995 {
7996 regpos[nregs].offset = i * 2 + 1;
7997 regpos[nregs].reg = reg;
7998 nregs++;
7999 }
8000 }
8001
8002 printf (_("pop frame {"));
8003 reg = nregs - 1;
8004 for (i = i * 2; i > 0; i--)
8005 {
8006 if (regpos[reg].offset == i - 1)
8007 {
8008 name = tic6x_unwind_regnames[regpos[reg].reg];
8009 if (reg > 0)
8010 reg--;
8011 }
8012 else
8013 name = _("[pad]");
8014
8015 fputs (name, stdout);
8016 if (i > 1)
8017 printf (", ");
8018 }
8019
8020 printf ("}");
8021 }
8022 else if (op == 0xd0)
8023 printf (" MOV FP, SP");
8024 else if (op == 0xd1)
8025 printf (" __c6xabi_pop_rts");
8026 else if (op == 0xd2)
8027 {
8028 unsigned char buf[9];
8029 unsigned int i, len;
8030 unsigned long offset;
a734115a 8031
fa197c1c
PB		 8032 for (i = 0; i < sizeof (buf); i++)
8033 {
8034 GET_OP (buf[i]);
8035 if ((buf[i] & 0x80) == 0)
8036 break;
8037 }
0eff7165
NC		 8038 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8039 if (i == sizeof (buf))
8040 {
8041 printf ("<corrupt sp adjust>\n");
8042 warn (_("Corrupt stack pointer adjustment detected\n"));
8043 return;
8044 }
948f632f 8045
f6f0e17b 8046 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8047 assert (len == i + 1);
8048 offset = offset * 8 + 0x408;
8049 printf (_("sp = sp + %ld"), offset);
8050 }
8051 else if ((op & 0xf0) == 0xe0)
8052 {
8053 if ((op & 0x0f) == 7)
8054 printf (" RETURN");
8055 else
8056 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8057 }
8058 else
8059 {
8060 printf (_(" [unsupported opcode]"));
8061 }
8062 putchar ('\n');
8063 }
8064}
8065
8066static bfd_vma
a734115a 8067arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8068{
8069 bfd_vma offset;
8070
8071 offset = word & 0x7fffffff;
8072 if (offset & 0x40000000)
8073 offset |= ~ (bfd_vma) 0x7fffffff;
8074
8075 if (elf_header.e_machine == EM_TI_C6000)
8076 offset <<= 1;
8077
8078 return offset + where;
8079}
8080
8081static void
1b31d05e
NC		 8082decode_arm_unwind (struct arm_unw_aux_info * aux,
8083 unsigned int word,
8084 unsigned int remaining,
8085 bfd_vma data_offset,
8086 Elf_Internal_Shdr * data_sec,
8087 struct arm_section * data_arm_sec)
fa197c1c
PB		 8088{
8089 int per_index;
8090 unsigned int more_words = 0;
37e14bc3 8091 struct absaddr addr;
1b31d05e 8092 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8093
8094 if (remaining == 0)
8095 {
1b31d05e
NC		 8096 /* Fetch the first word.
8097 Note - when decoding an object file the address extracted
8098 here will always be 0. So we also pass in the sym_name
8099 parameter so that we can find the symbol associated with
8100 the personality routine. */
8101 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8102 & word, & addr, & sym_name))
fa197c1c 8103 return;
1b31d05e 8104
fa197c1c
PB		 8105 remaining = 4;
8106 }
8107
8108 if ((word & 0x80000000) == 0)
8109 {
8110 /* Expand prel31 for personality routine. */
8111 bfd_vma fn;
8112 const char *procname;
8113
a734115a 8114 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8115 printf (_(" Personality routine: "));
1b31d05e
NC		 8116 if (fn == 0
8117 && addr.section == SHN_UNDEF && addr.offset == 0
8118 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8119 {
8120 procname = aux->strtab + sym_name;
8121 print_vma (fn, PREFIX_HEX);
8122 if (procname)
8123 {
8124 fputs (" <", stdout);
8125 fputs (procname, stdout);
8126 fputc ('>', stdout);
8127 }
8128 }
8129 else
8130 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8131 fputc ('\n', stdout);
8132
8133 /* The GCC personality routines use the standard compact
8134 encoding, starting with one byte giving the number of
8135 words. */
8136 if (procname != NULL
8137 && (const_strneq (procname, "__gcc_personality_v0")
8138 || const_strneq (procname, "__gxx_personality_v0")
8139 || const_strneq (procname, "__gcj_personality_v0")
8140 || const_strneq (procname, "__gnu_objc_personality_v0")))
8141 {
8142 remaining = 0;
8143 more_words = 1;
8144 ADVANCE;
8145 if (!remaining)
8146 {
8147 printf (_(" [Truncated data]\n"));
8148 return;
8149 }
8150 more_words = word >> 24;
8151 word <<= 8;
8152 remaining--;
8153 per_index = -1;
8154 }
8155 else
8156 return;
8157 }
8158 else
8159 {
1b31d05e 8160 /* ARM EHABI Section 6.3:
0b4362b0 8161
1b31d05e 8162 An exception-handling table entry for the compact model looks like:
0b4362b0 8163
1b31d05e
NC		 8164 31 30-28 27-24 23-0
8165 -- ----- ----- ----
8166 1 0 index Data for personalityRoutine[index] */
8167
8168 if (elf_header.e_machine == EM_ARM
8169 && (word & 0x70000000))
83c257ca 8170 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8171
fa197c1c 8172 per_index = (word >> 24) & 0x7f;
1b31d05e 8173 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8174 if (per_index == 0)
8175 {
8176 more_words = 0;
8177 word <<= 8;
8178 remaining--;
8179 }
8180 else if (per_index < 3)
8181 {
8182 more_words = (word >> 16) & 0xff;
8183 word <<= 16;
8184 remaining -= 2;
8185 }
8186 }
8187
8188 switch (elf_header.e_machine)
8189 {
8190 case EM_ARM:
8191 if (per_index < 3)
8192 {
8193 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8194 data_offset, data_sec, data_arm_sec);
8195 }
8196 else
1b31d05e
NC		 8197 {
8198 warn (_("Unknown ARM compact model index encountered\n"));
8199 printf (_(" [reserved]\n"));
8200 }
fa197c1c
PB		 8201 break;
8202
8203 case EM_TI_C6000:
8204 if (per_index < 3)
8205 {
8206 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8207 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8208 }
8209 else if (per_index < 5)
8210 {
8211 if (((word >> 17) & 0x7f) == 0x7f)
8212 printf (_(" Restore stack from frame pointer\n"));
8213 else
8214 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8215 printf (_(" Registers restored: "));
8216 if (per_index == 4)
8217 printf (" (compact) ");
8218 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8219 putchar ('\n');
8220 printf (_(" Return register: %s\n"),
8221 tic6x_unwind_regnames[word & 0xf]);
8222 }
8223 else
1b31d05e 8224 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8225 break;
8226
8227 default:
74e1a04b 8228 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8229 elf_header.e_machine);
fa197c1c 8230 }
0b6ae522
DJ		 8231
8232 /* Decode the descriptors. Not implemented. */
8233}
8234
8235static void
8236dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8237{
8238 struct arm_section exidx_arm_sec, extab_arm_sec;
8239 unsigned int i, exidx_len;
948f632f 8240 unsigned long j, nfuns;
0b6ae522
DJ		 8241
8242 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8243 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8244 exidx_len = exidx_sec->sh_size / 8;
8245
948f632f
DA		 8246 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8247 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8248 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8249 aux->funtab[nfuns++] = aux->symtab[j];
8250 aux->nfuns = nfuns;
8251 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8252
0b6ae522
DJ		 8253 for (i = 0; i < exidx_len; i++)
8254 {
8255 unsigned int exidx_fn, exidx_entry;
8256 struct absaddr fn_addr, entry_addr;
8257 bfd_vma fn;
8258
8259 fputc ('\n', stdout);
8260
1b31d05e
NC		 8261 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8262 8 * i, & exidx_fn, & fn_addr, NULL)
8263 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8264 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8265 {
948f632f 8266 free (aux->funtab);
1b31d05e
NC		 8267 arm_free_section (& exidx_arm_sec);
8268 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8269 return;
8270 }
8271
83c257ca
NC		 8272 /* ARM EHABI, Section 5:
8273 An index table entry consists of 2 words.
8274 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8275 if (exidx_fn & 0x80000000)
8276 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8277
a734115a 8278 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8279
a734115a 8280 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8281 fputs (": ", stdout);
8282
8283 if (exidx_entry == 1)
8284 {
8285 print_vma (exidx_entry, PREFIX_HEX);
8286 fputs (" [cantunwind]\n", stdout);
8287 }
8288 else if (exidx_entry & 0x80000000)
8289 {
8290 print_vma (exidx_entry, PREFIX_HEX);
8291 fputc ('\n', stdout);
8292 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8293 }
8294 else
8295 {
8f73510c 8296 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8297 Elf_Internal_Shdr *table_sec;
8298
8299 fputs ("@", stdout);
a734115a 8300 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8301 print_vma (table, PREFIX_HEX);
8302 printf ("\n");
8303
8304 /* Locate the matching .ARM.extab. */
8305 if (entry_addr.section != SHN_UNDEF
8306 && entry_addr.section < elf_header.e_shnum)
8307 {
8308 table_sec = section_headers + entry_addr.section;
8309 table_offset = entry_addr.offset;
8310 }
8311 else
8312 {
8313 table_sec = find_section_by_address (table);
8314 if (table_sec != NULL)
8315 table_offset = table - table_sec->sh_addr;
8316 }
8317 if (table_sec == NULL)
8318 {
8319 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8320 (unsigned long) table);
8321 continue;
8322 }
8323 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8324 &extab_arm_sec);
8325 }
8326 }
8327
8328 printf ("\n");
8329
948f632f 8330 free (aux->funtab);
0b6ae522
DJ		 8331 arm_free_section (&exidx_arm_sec);
8332 arm_free_section (&extab_arm_sec);
8333}
8334
fa197c1c 8335/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8336
8337static void
0b6ae522
DJ		 8338arm_process_unwind (FILE *file)
8339{
8340 struct arm_unw_aux_info aux;
8341 Elf_Internal_Shdr *unwsec = NULL;
8342 Elf_Internal_Shdr *strsec;
8343 Elf_Internal_Shdr *sec;
8344 unsigned long i;
fa197c1c 8345 unsigned int sec_type;
0b6ae522 8346
fa197c1c
PB		 8347 switch (elf_header.e_machine)
8348 {
8349 case EM_ARM:
8350 sec_type = SHT_ARM_EXIDX;
8351 break;
8352
8353 case EM_TI_C6000:
8354 sec_type = SHT_C6000_UNWIND;
8355 break;
8356
0b4362b0 8357 default:
74e1a04b 8358 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8359 elf_header.e_machine);
8360 return;
fa197c1c
PB		 8361 }
8362
0b6ae522 8363 if (string_table == NULL)
1b31d05e
NC		 8364 return;
8365
8366 memset (& aux, 0, sizeof (aux));
8367 aux.file = file;
0b6ae522
DJ		 8368
8369 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8370 {
8371 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8372 {
ba5cdace 8373 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8374
8375 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8376
8377 /* PR binutils/17531 file: 011-12666-0.004. */
8378 if (aux.strtab != NULL)
8379 {
4082ef84 8380 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8381 free (aux.strtab);
8382 }
0b6ae522
DJ		 8383 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8384 1, strsec->sh_size, _("string table"));
8385 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8386 }
fa197c1c 8387 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8388 unwsec = sec;
8389 }
8390
1b31d05e 8391 if (unwsec == NULL)
0b6ae522 8392 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8393 else
8394 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8395 {
8396 if (sec->sh_type == sec_type)
8397 {
8398 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8399 printable_section_name (sec),
1b31d05e
NC		 8400 (unsigned long) sec->sh_offset,
8401 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8402
1b31d05e
NC		 8403 dump_arm_unwind (&aux, sec);
8404 }
8405 }
0b6ae522
DJ		 8406
8407 if (aux.symtab)
8408 free (aux.symtab);
8409 if (aux.strtab)
8410 free ((char *) aux.strtab);
0b6ae522
DJ		 8411}
8412
1b31d05e 8413static void
2cf0635d 8414process_unwind (FILE * file)
57346661 8415{
2cf0635d
NC		 8416 struct unwind_handler
8417 {
57346661 8418 int machtype;
1b31d05e 8419 void (* handler)(FILE *);
2cf0635d
NC		 8420 } handlers[] =
8421 {
0b6ae522 8422 { EM_ARM, arm_process_unwind },
57346661
AM		 8423 { EM_IA_64, ia64_process_unwind },
8424 { EM_PARISC, hppa_process_unwind },
fa197c1c 8425 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8426 { 0, 0 }
8427 };
8428 int i;
8429
8430 if (!do_unwind)
1b31d05e 8431 return;
57346661
AM		 8432
8433 for (i = 0; handlers[i].handler != NULL; i++)
8434 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8435 {
8436 handlers[i].handler (file);
8437 return;
8438 }
57346661 8439
1b31d05e
NC		 8440 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8441 get_machine_name (elf_header.e_machine));
57346661
AM		 8442}
8443
252b5132 8444static void
2cf0635d 8445dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8446{
8447 switch (entry->d_tag)
8448 {
8449 case DT_MIPS_FLAGS:
8450 if (entry->d_un.d_val == 0)
4b68bca3 8451 printf (_("NONE"));
252b5132
RH		 8452 else
8453 {
8454 static const char * opts[] =
8455 {
8456 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8457 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8458 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8459 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8460 "RLD_ORDER_SAFE"
8461 };
8462 unsigned int cnt;
8463 int first = 1;
2b692964 8464
60bca95a 8465 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8466 if (entry->d_un.d_val & (1 << cnt))
8467 {
8468 printf ("%s%s", first ? "" : " ", opts[cnt]);
8469 first = 0;
8470 }
252b5132
RH		 8471 }
8472 break;
103f02d3 8473
252b5132 8474 case DT_MIPS_IVERSION:
d79b3d50 8475 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8476 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8477 else
76ca31c0
NC		 8478 {
8479 char buf[40];
8480 sprintf_vma (buf, entry->d_un.d_ptr);
8481 /* Note: coded this way so that there is a single string for translation. */
8482 printf (_("<corrupt: %s>"), buf);
8483 }
252b5132 8484 break;
103f02d3 8485
252b5132
RH		 8486 case DT_MIPS_TIME_STAMP:
8487 {
8488 char timebuf[20];
2cf0635d 8489 struct tm * tmp;
91d6fa6a 8490 time_t atime = entry->d_un.d_val;
82b1b41b 8491
91d6fa6a 8492 tmp = gmtime (&atime);
82b1b41b
NC		 8493 /* PR 17531: file: 6accc532. */
8494 if (tmp == NULL)
8495 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8496 else
8497 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8498 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8499 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8500 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8501 }
8502 break;
103f02d3 8503
252b5132
RH		 8504 case DT_MIPS_RLD_VERSION:
8505 case DT_MIPS_LOCAL_GOTNO:
8506 case DT_MIPS_CONFLICTNO:
8507 case DT_MIPS_LIBLISTNO:
8508 case DT_MIPS_SYMTABNO:
8509 case DT_MIPS_UNREFEXTNO:
8510 case DT_MIPS_HIPAGENO:
8511 case DT_MIPS_DELTA_CLASS_NO:
8512 case DT_MIPS_DELTA_INSTANCE_NO:
8513 case DT_MIPS_DELTA_RELOC_NO:
8514 case DT_MIPS_DELTA_SYM_NO:
8515 case DT_MIPS_DELTA_CLASSSYM_NO:
8516 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8517 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8518 break;
103f02d3
UD		 8519
8520 default:
4b68bca3 8521 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8522 }
4b68bca3 8523 putchar ('\n');
103f02d3
UD		 8524}
8525
103f02d3 8526static void
2cf0635d 8527dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8528{
8529 switch (entry->d_tag)
8530 {
8531 case DT_HP_DLD_FLAGS:
8532 {
8533 static struct
8534 {
8535 long int bit;
2cf0635d 8536 const char * str;
5e220199
NC		 8537 }
8538 flags[] =
8539 {
8540 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8541 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8542 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8543 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8544 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8545 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8546 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8547 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8548 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8549 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8550 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8551 { DT_HP_GST, "HP_GST" },
8552 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8553 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8554 { DT_HP_NODELETE, "HP_NODELETE" },
8555 { DT_HP_GROUP, "HP_GROUP" },
8556 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8557 };
103f02d3 8558 int first = 1;
5e220199 8559 size_t cnt;
f7a99963 8560 bfd_vma val = entry->d_un.d_val;
103f02d3 8561
60bca95a 8562 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8563 if (val & flags[cnt].bit)
30800947
NC		 8564 {
8565 if (! first)
8566 putchar (' ');
8567 fputs (flags[cnt].str, stdout);
8568 first = 0;
8569 val ^= flags[cnt].bit;
8570 }
76da6bbe 8571
103f02d3 8572 if (val != 0 || first)
f7a99963
NC		 8573 {
8574 if (! first)
8575 putchar (' ');
8576 print_vma (val, HEX);
8577 }
103f02d3
UD		 8578 }
8579 break;
76da6bbe 8580
252b5132 8581 default:
f7a99963
NC		 8582 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8583 break;
252b5132 8584 }
35b1837e 8585 putchar ('\n');
252b5132
RH		 8586}
8587
28f997cf
TG		 8588#ifdef BFD64
8589
8590/* VMS vs Unix time offset and factor. */
8591
8592#define VMS_EPOCH_OFFSET 35067168000000000LL
8593#define VMS_GRANULARITY_FACTOR 10000000
8594
8595/* Display a VMS time in a human readable format. */
8596
8597static void
8598print_vms_time (bfd_int64_t vmstime)
8599{
8600 struct tm *tm;
8601 time_t unxtime;
8602
8603 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8604 tm = gmtime (&unxtime);
8605 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8606 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8607 tm->tm_hour, tm->tm_min, tm->tm_sec);
8608}
8609#endif /* BFD64 */
8610
ecc51f48 8611static void
2cf0635d 8612dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8613{
8614 switch (entry->d_tag)
8615 {
0de14b54 8616 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8617 /* First 3 slots reserved. */
ecc51f48
NC		 8618 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8619 printf (" -- ");
8620 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8621 break;
8622
28f997cf
TG		 8623 case DT_IA_64_VMS_LINKTIME:
8624#ifdef BFD64
8625 print_vms_time (entry->d_un.d_val);
8626#endif
8627 break;
8628
8629 case DT_IA_64_VMS_LNKFLAGS:
8630 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8631 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8632 printf (" CALL_DEBUG");
8633 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8634 printf (" NOP0BUFS");
8635 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8636 printf (" P0IMAGE");
8637 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8638 printf (" MKTHREADS");
8639 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8640 printf (" UPCALLS");
8641 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8642 printf (" IMGSTA");
8643 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8644 printf (" INITIALIZE");
8645 if (entry->d_un.d_val & VMS_LF_MAIN)
8646 printf (" MAIN");
8647 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8648 printf (" EXE_INIT");
8649 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8650 printf (" TBK_IN_IMG");
8651 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8652 printf (" DBG_IN_IMG");
8653 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8654 printf (" TBK_IN_DSF");
8655 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8656 printf (" DBG_IN_DSF");
8657 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8658 printf (" SIGNATURES");
8659 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8660 printf (" REL_SEG_OFF");
8661 break;
8662
bdf4d63a
JJ		 8663 default:
8664 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8665 break;
ecc51f48 8666 }
bdf4d63a 8667 putchar ('\n');
ecc51f48
NC		 8668}
8669
252b5132 8670static int
2cf0635d 8671get_32bit_dynamic_section (FILE * file)
252b5132 8672{
2cf0635d
NC		 8673 Elf32_External_Dyn * edyn;
8674 Elf32_External_Dyn * ext;
8675 Elf_Internal_Dyn * entry;
103f02d3 8676
3f5e193b
NC		 8677 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8678 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8679 if (!edyn)
8680 return 0;
103f02d3 8681
071436c6
NC		 8682 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8683 might not have the luxury of section headers. Look for the DT_NULL
8684 terminator to determine the number of entries. */
ba2685cc 8685 for (ext = edyn, dynamic_nent = 0;
53c3012c 8686 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8687 ext++)
8688 {
8689 dynamic_nent++;
8690 if (BYTE_GET (ext->d_tag) == DT_NULL)
8691 break;
8692 }
252b5132 8693
3f5e193b
NC		 8694 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8695 sizeof (* entry));
b2d38a17 8696 if (dynamic_section == NULL)
252b5132 8697 {
8b73c356
NC		 8698 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8699 (unsigned long) dynamic_nent);
9ea033b2
NC		 8700 free (edyn);
8701 return 0;
8702 }
252b5132 8703
fb514b26 8704 for (ext = edyn, entry = dynamic_section;
ba2685cc 8705 entry < dynamic_section + dynamic_nent;
fb514b26 8706 ext++, entry++)
9ea033b2 8707 {
fb514b26
AM		 8708 entry->d_tag = BYTE_GET (ext->d_tag);
8709 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8710 }
8711
9ea033b2
NC		 8712 free (edyn);
8713
8714 return 1;
8715}
8716
8717static int
2cf0635d 8718get_64bit_dynamic_section (FILE * file)
9ea033b2 8719{
2cf0635d
NC		 8720 Elf64_External_Dyn * edyn;
8721 Elf64_External_Dyn * ext;
8722 Elf_Internal_Dyn * entry;
103f02d3 8723
071436c6 8724 /* Read in the data. */
3f5e193b
NC		 8725 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8726 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8727 if (!edyn)
8728 return 0;
103f02d3 8729
071436c6
NC		 8730 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8731 might not have the luxury of section headers. Look for the DT_NULL
8732 terminator to determine the number of entries. */
ba2685cc 8733 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8734 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8735 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8736 ext++)
8737 {
8738 dynamic_nent++;
66543521 8739 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8740 break;
8741 }
252b5132 8742
3f5e193b
NC		 8743 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8744 sizeof (* entry));
b2d38a17 8745 if (dynamic_section == NULL)
252b5132 8746 {
8b73c356
NC		 8747 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8748 (unsigned long) dynamic_nent);
252b5132
RH		 8749 free (edyn);
8750 return 0;
8751 }
8752
071436c6 8753 /* Convert from external to internal formats. */
fb514b26 8754 for (ext = edyn, entry = dynamic_section;
ba2685cc 8755 entry < dynamic_section + dynamic_nent;
fb514b26 8756 ext++, entry++)
252b5132 8757 {
66543521
AM		 8758 entry->d_tag = BYTE_GET (ext->d_tag);
8759 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8760 }
8761
8762 free (edyn);
8763
9ea033b2
NC		 8764 return 1;
8765}
8766
e9e44622
JJ		 8767static void
8768print_dynamic_flags (bfd_vma flags)
d1133906 8769{
e9e44622 8770 int first = 1;
13ae64f3 8771
d1133906
NC		 8772 while (flags)
8773 {
8774 bfd_vma flag;
8775
8776 flag = flags & - flags;
8777 flags &= ~ flag;
8778
e9e44622
JJ		 8779 if (first)
8780 first = 0;
8781 else
8782 putc (' ', stdout);
13ae64f3 8783
d1133906
NC		 8784 switch (flag)
8785 {
e9e44622
JJ		 8786 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8787 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8788 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8789 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8790 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8791 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8792 }
8793 }
e9e44622 8794 puts ("");
d1133906
NC		 8795}
8796
b2d38a17
NC		 8797/* Parse and display the contents of the dynamic section. */
8798
9ea033b2 8799static int
2cf0635d 8800process_dynamic_section (FILE * file)
9ea033b2 8801{
2cf0635d 8802 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8803
8804 if (dynamic_size == 0)
8805 {
8806 if (do_dynamic)
b2d38a17 8807 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8808
8809 return 1;
8810 }
8811
8812 if (is_32bit_elf)
8813 {
b2d38a17 8814 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8815 return 0;
8816 }
b2d38a17 8817 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8818 return 0;
8819
252b5132
RH		 8820 /* Find the appropriate symbol table. */
8821 if (dynamic_symbols == NULL)
8822 {
86dba8ee
AM		 8823 for (entry = dynamic_section;
8824 entry < dynamic_section + dynamic_nent;
8825 ++entry)
252b5132 8826 {
c8286bd1 8827 Elf_Internal_Shdr section;
252b5132
RH		 8828
8829 if (entry->d_tag != DT_SYMTAB)
8830 continue;
8831
8832 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8833
8834 /* Since we do not know how big the symbol table is,
8835 we default to reading in the entire file (!) and
8836 processing that. This is overkill, I know, but it
e3c8793a 8837 should work. */
d93f0186 8838 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8839
fb52b2f4
NC		 8840 if (archive_file_offset != 0)
8841 section.sh_size = archive_file_size - section.sh_offset;
8842 else
8843 {
8844 if (fseek (file, 0, SEEK_END))
591a748a 8845 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8846
8847 section.sh_size = ftell (file) - section.sh_offset;
8848 }
252b5132 8849
9ea033b2 8850 if (is_32bit_elf)
9ad5cbcf 8851 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8852 else
9ad5cbcf 8853 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8854 section.sh_name = string_table_length;
252b5132 8855
ba5cdace 8856 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8857 if (num_dynamic_syms < 1)
252b5132
RH		 8858 {
8859 error (_("Unable to determine the number of symbols to load\n"));
8860 continue;
8861 }
252b5132
RH		 8862 }
8863 }
8864
8865 /* Similarly find a string table. */
8866 if (dynamic_strings == NULL)
8867 {
86dba8ee
AM		 8868 for (entry = dynamic_section;
8869 entry < dynamic_section + dynamic_nent;
8870 ++entry)
252b5132
RH		 8871 {
8872 unsigned long offset;
b34976b6 8873 long str_tab_len;
252b5132
RH		 8874
8875 if (entry->d_tag != DT_STRTAB)
8876 continue;
8877
8878 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8879
8880 /* Since we do not know how big the string table is,
8881 we default to reading in the entire file (!) and
8882 processing that. This is overkill, I know, but it
e3c8793a 8883 should work. */
252b5132 8884
d93f0186 8885 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8886
8887 if (archive_file_offset != 0)
8888 str_tab_len = archive_file_size - offset;
8889 else
8890 {
8891 if (fseek (file, 0, SEEK_END))
8892 error (_("Unable to seek to end of file\n"));
8893 str_tab_len = ftell (file) - offset;
8894 }
252b5132
RH		 8895
8896 if (str_tab_len < 1)
8897 {
8898 error
8899 (_("Unable to determine the length of the dynamic string table\n"));
8900 continue;
8901 }
8902
3f5e193b
NC		 8903 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8904 str_tab_len,
8905 _("dynamic string table"));
59245841 8906 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8907 break;
8908 }
8909 }
8910
8911 /* And find the syminfo section if available. */
8912 if (dynamic_syminfo == NULL)
8913 {
3e8bba36 8914 unsigned long syminsz = 0;
252b5132 8915
86dba8ee
AM		 8916 for (entry = dynamic_section;
8917 entry < dynamic_section + dynamic_nent;
8918 ++entry)
252b5132
RH		 8919 {
8920 if (entry->d_tag == DT_SYMINENT)
8921 {
8922 /* Note: these braces are necessary to avoid a syntax
8923 error from the SunOS4 C compiler. */
049b0c3a
NC		 8924 /* PR binutils/17531: A corrupt file can trigger this test.
8925 So do not use an assert, instead generate an error message. */
8926 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8927 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8928 (int) entry->d_un.d_val);
252b5132
RH		 8929 }
8930 else if (entry->d_tag == DT_SYMINSZ)
8931 syminsz = entry->d_un.d_val;
8932 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8933 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8934 syminsz);
252b5132
RH		 8935 }
8936
8937 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8938 {
2cf0635d
NC		 8939 Elf_External_Syminfo * extsyminfo;
8940 Elf_External_Syminfo * extsym;
8941 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8942
8943 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8944 extsyminfo = (Elf_External_Syminfo *)
8945 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8946 _("symbol information"));
a6e9f9df
AM		 8947 if (!extsyminfo)
8948 return 0;
252b5132 8949
3f5e193b 8950 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8951 if (dynamic_syminfo == NULL)
8952 {
8b73c356
NC		 8953 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8954 (unsigned long) syminsz);
252b5132
RH		 8955 return 0;
8956 }
8957
8958 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8959 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8960 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8961 ++syminfo, ++extsym)
252b5132 8962 {
86dba8ee
AM		 8963 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8964 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8965 }
8966
8967 free (extsyminfo);
8968 }
8969 }
8970
8971 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8972 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8973 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8974 if (do_dynamic)
8975 printf (_(" Tag Type Name/Value\n"));
8976
86dba8ee
AM		 8977 for (entry = dynamic_section;
8978 entry < dynamic_section + dynamic_nent;
8979 entry++)
252b5132
RH		 8980 {
8981 if (do_dynamic)
f7a99963 8982 {
2cf0635d 8983 const char * dtype;
e699b9ff 8984
f7a99963
NC		 8985 putchar (' ');
8986 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8987 dtype = get_dynamic_type (entry->d_tag);
8988 printf (" (%s)%*s", dtype,
8989 ((is_32bit_elf ? 27 : 19)
8990 - (int) strlen (dtype)),
f7a99963
NC		 8991 " ");
8992 }
252b5132
RH		 8993
8994 switch (entry->d_tag)
8995 {
d1133906
NC		 8996 case DT_FLAGS:
8997 if (do_dynamic)
e9e44622 8998 print_dynamic_flags (entry->d_un.d_val);
d1133906 8999 break;
76da6bbe 9000
252b5132
RH		 9001 case DT_AUXILIARY:
9002 case DT_FILTER:
019148e4
L		 9003 case DT_CONFIG:
9004 case DT_DEPAUDIT:
9005 case DT_AUDIT:
252b5132
RH		 9006 if (do_dynamic)
9007 {
019148e4 9008 switch (entry->d_tag)
b34976b6 9009 {
019148e4
L		 9010 case DT_AUXILIARY:
9011 printf (_("Auxiliary library"));
9012 break;
9013
9014 case DT_FILTER:
9015 printf (_("Filter library"));
9016 break;
9017
b34976b6 9018 case DT_CONFIG:
019148e4
L		 9019 printf (_("Configuration file"));
9020 break;
9021
9022 case DT_DEPAUDIT:
9023 printf (_("Dependency audit library"));
9024 break;
9025
9026 case DT_AUDIT:
9027 printf (_("Audit library"));
9028 break;
9029 }
252b5132 9030
d79b3d50
NC		 9031 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9032 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9033 else
f7a99963
NC		 9034 {
9035 printf (": ");
9036 print_vma (entry->d_un.d_val, PREFIX_HEX);
9037 putchar ('\n');
9038 }
252b5132
RH		 9039 }
9040 break;
9041
dcefbbbd 9042 case DT_FEATURE:
252b5132
RH		 9043 if (do_dynamic)
9044 {
9045 printf (_("Flags:"));
86f55779 9046
252b5132
RH		 9047 if (entry->d_un.d_val == 0)
9048 printf (_(" None\n"));
9049 else
9050 {
9051 unsigned long int val = entry->d_un.d_val;
86f55779 9052
252b5132
RH		 9053 if (val & DTF_1_PARINIT)
9054 {
9055 printf (" PARINIT");
9056 val ^= DTF_1_PARINIT;
9057 }
dcefbbbd
L		 9058 if (val & DTF_1_CONFEXP)
9059 {
9060 printf (" CONFEXP");
9061 val ^= DTF_1_CONFEXP;
9062 }
252b5132
RH		 9063 if (val != 0)
9064 printf (" %lx", val);
9065 puts ("");
9066 }
9067 }
9068 break;
9069
9070 case DT_POSFLAG_1:
9071 if (do_dynamic)
9072 {
9073 printf (_("Flags:"));
86f55779 9074
252b5132
RH		 9075 if (entry->d_un.d_val == 0)
9076 printf (_(" None\n"));
9077 else
9078 {
9079 unsigned long int val = entry->d_un.d_val;
86f55779 9080
252b5132
RH		 9081 if (val & DF_P1_LAZYLOAD)
9082 {
9083 printf (" LAZYLOAD");
9084 val ^= DF_P1_LAZYLOAD;
9085 }
9086 if (val & DF_P1_GROUPPERM)
9087 {
9088 printf (" GROUPPERM");
9089 val ^= DF_P1_GROUPPERM;
9090 }
9091 if (val != 0)
9092 printf (" %lx", val);
9093 puts ("");
9094 }
9095 }
9096 break;
9097
9098 case DT_FLAGS_1:
9099 if (do_dynamic)
9100 {
9101 printf (_("Flags:"));
9102 if (entry->d_un.d_val == 0)
9103 printf (_(" None\n"));
9104 else
9105 {
9106 unsigned long int val = entry->d_un.d_val;
86f55779 9107
252b5132
RH		 9108 if (val & DF_1_NOW)
9109 {
9110 printf (" NOW");
9111 val ^= DF_1_NOW;
9112 }
9113 if (val & DF_1_GLOBAL)
9114 {
9115 printf (" GLOBAL");
9116 val ^= DF_1_GLOBAL;
9117 }
9118 if (val & DF_1_GROUP)
9119 {
9120 printf (" GROUP");
9121 val ^= DF_1_GROUP;
9122 }
9123 if (val & DF_1_NODELETE)
9124 {
9125 printf (" NODELETE");
9126 val ^= DF_1_NODELETE;
9127 }
9128 if (val & DF_1_LOADFLTR)
9129 {
9130 printf (" LOADFLTR");
9131 val ^= DF_1_LOADFLTR;
9132 }
9133 if (val & DF_1_INITFIRST)
9134 {
9135 printf (" INITFIRST");
9136 val ^= DF_1_INITFIRST;
9137 }
9138 if (val & DF_1_NOOPEN)
9139 {
9140 printf (" NOOPEN");
9141 val ^= DF_1_NOOPEN;
9142 }
9143 if (val & DF_1_ORIGIN)
9144 {
9145 printf (" ORIGIN");
9146 val ^= DF_1_ORIGIN;
9147 }
9148 if (val & DF_1_DIRECT)
9149 {
9150 printf (" DIRECT");
9151 val ^= DF_1_DIRECT;
9152 }
9153 if (val & DF_1_TRANS)
9154 {
9155 printf (" TRANS");
9156 val ^= DF_1_TRANS;
9157 }
9158 if (val & DF_1_INTERPOSE)
9159 {
9160 printf (" INTERPOSE");
9161 val ^= DF_1_INTERPOSE;
9162 }
f7db6139 9163 if (val & DF_1_NODEFLIB)
dcefbbbd 9164 {
f7db6139
L		 9165 printf (" NODEFLIB");
9166 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9167 }
9168 if (val & DF_1_NODUMP)
9169 {
9170 printf (" NODUMP");
9171 val ^= DF_1_NODUMP;
9172 }
34b60028 9173 if (val & DF_1_CONFALT)
dcefbbbd 9174 {
34b60028
L		 9175 printf (" CONFALT");
9176 val ^= DF_1_CONFALT;
9177 }
9178 if (val & DF_1_ENDFILTEE)
9179 {
9180 printf (" ENDFILTEE");
9181 val ^= DF_1_ENDFILTEE;
9182 }
9183 if (val & DF_1_DISPRELDNE)
9184 {
9185 printf (" DISPRELDNE");
9186 val ^= DF_1_DISPRELDNE;
9187 }
9188 if (val & DF_1_DISPRELPND)
9189 {
9190 printf (" DISPRELPND");
9191 val ^= DF_1_DISPRELPND;
9192 }
9193 if (val & DF_1_NODIRECT)
9194 {
9195 printf (" NODIRECT");
9196 val ^= DF_1_NODIRECT;
9197 }
9198 if (val & DF_1_IGNMULDEF)
9199 {
9200 printf (" IGNMULDEF");
9201 val ^= DF_1_IGNMULDEF;
9202 }
9203 if (val & DF_1_NOKSYMS)
9204 {
9205 printf (" NOKSYMS");
9206 val ^= DF_1_NOKSYMS;
9207 }
9208 if (val & DF_1_NOHDR)
9209 {
9210 printf (" NOHDR");
9211 val ^= DF_1_NOHDR;
9212 }
9213 if (val & DF_1_EDITED)
9214 {
9215 printf (" EDITED");
9216 val ^= DF_1_EDITED;
9217 }
9218 if (val & DF_1_NORELOC)
9219 {
9220 printf (" NORELOC");
9221 val ^= DF_1_NORELOC;
9222 }
9223 if (val & DF_1_SYMINTPOSE)
9224 {
9225 printf (" SYMINTPOSE");
9226 val ^= DF_1_SYMINTPOSE;
9227 }
9228 if (val & DF_1_GLOBAUDIT)
9229 {
9230 printf (" GLOBAUDIT");
9231 val ^= DF_1_GLOBAUDIT;
9232 }
9233 if (val & DF_1_SINGLETON)
9234 {
9235 printf (" SINGLETON");
9236 val ^= DF_1_SINGLETON;
dcefbbbd 9237 }
252b5132
RH		 9238 if (val != 0)
9239 printf (" %lx", val);
9240 puts ("");
9241 }
9242 }
9243 break;
9244
9245 case DT_PLTREL:
566b0d53 9246 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9247 if (do_dynamic)
9248 puts (get_dynamic_type (entry->d_un.d_val));
9249 break;
9250
9251 case DT_NULL :
9252 case DT_NEEDED :
9253 case DT_PLTGOT :
9254 case DT_HASH :
9255 case DT_STRTAB :
9256 case DT_SYMTAB :
9257 case DT_RELA :
9258 case DT_INIT :
9259 case DT_FINI :
9260 case DT_SONAME :
9261 case DT_RPATH :
9262 case DT_SYMBOLIC:
9263 case DT_REL :
9264 case DT_DEBUG :
9265 case DT_TEXTREL :
9266 case DT_JMPREL :
019148e4 9267 case DT_RUNPATH :
252b5132
RH		 9268 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9269
9270 if (do_dynamic)
9271 {
2cf0635d 9272 char * name;
252b5132 9273
d79b3d50
NC		 9274 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9275 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9276 else
d79b3d50 9277 name = NULL;
252b5132
RH		 9278
9279 if (name)
9280 {
9281 switch (entry->d_tag)
9282 {
9283 case DT_NEEDED:
9284 printf (_("Shared library: [%s]"), name);
9285
18bd398b 9286 if (streq (name, program_interpreter))
f7a99963 9287 printf (_(" program interpreter"));
252b5132
RH		 9288 break;
9289
9290 case DT_SONAME:
f7a99963 9291 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9292 break;
9293
9294 case DT_RPATH:
f7a99963 9295 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9296 break;
9297
019148e4
L		 9298 case DT_RUNPATH:
9299 printf (_("Library runpath: [%s]"), name);
9300 break;
9301
252b5132 9302 default:
f7a99963
NC		 9303 print_vma (entry->d_un.d_val, PREFIX_HEX);
9304 break;
252b5132
RH		 9305 }
9306 }
9307 else
f7a99963
NC		 9308 print_vma (entry->d_un.d_val, PREFIX_HEX);
9309
9310 putchar ('\n');
252b5132
RH		 9311 }
9312 break;
9313
9314 case DT_PLTRELSZ:
9315 case DT_RELASZ :
9316 case DT_STRSZ :
9317 case DT_RELSZ :
9318 case DT_RELAENT :
9319 case DT_SYMENT :
9320 case DT_RELENT :
566b0d53 9321 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9322 case DT_PLTPADSZ:
9323 case DT_MOVEENT :
9324 case DT_MOVESZ :
9325 case DT_INIT_ARRAYSZ:
9326 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9327 case DT_GNU_CONFLICTSZ:
9328 case DT_GNU_LIBLISTSZ:
252b5132 9329 if (do_dynamic)
f7a99963
NC		 9330 {
9331 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9332 printf (_(" (bytes)\n"));
f7a99963 9333 }
252b5132
RH		 9334 break;
9335
9336 case DT_VERDEFNUM:
9337 case DT_VERNEEDNUM:
9338 case DT_RELACOUNT:
9339 case DT_RELCOUNT:
9340 if (do_dynamic)
f7a99963
NC		 9341 {
9342 print_vma (entry->d_un.d_val, UNSIGNED);
9343 putchar ('\n');
9344 }
252b5132
RH		 9345 break;
9346
9347 case DT_SYMINSZ:
9348 case DT_SYMINENT:
9349 case DT_SYMINFO:
9350 case DT_USED:
9351 case DT_INIT_ARRAY:
9352 case DT_FINI_ARRAY:
9353 if (do_dynamic)
9354 {
d79b3d50
NC		 9355 if (entry->d_tag == DT_USED
9356 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9357 {
2cf0635d 9358 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9359
b34976b6 9360 if (*name)
252b5132
RH		 9361 {
9362 printf (_("Not needed object: [%s]\n"), name);
9363 break;
9364 }
9365 }
103f02d3 9366
f7a99963
NC		 9367 print_vma (entry->d_un.d_val, PREFIX_HEX);
9368 putchar ('\n');
252b5132
RH		 9369 }
9370 break;
9371
9372 case DT_BIND_NOW:
9373 /* The value of this entry is ignored. */
35b1837e
AM		 9374 if (do_dynamic)
9375 putchar ('\n');
252b5132 9376 break;
103f02d3 9377
047b2264
JJ		 9378 case DT_GNU_PRELINKED:
9379 if (do_dynamic)
9380 {
2cf0635d 9381 struct tm * tmp;
91d6fa6a 9382 time_t atime = entry->d_un.d_val;
047b2264 9383
91d6fa6a 9384 tmp = gmtime (&atime);
071436c6
NC		 9385 /* PR 17533 file: 041-1244816-0.004. */
9386 if (tmp == NULL)
5a2cbcf4
L		 9387 printf (_("<corrupt time val: %lx"),
9388 (unsigned long) atime);
071436c6
NC		 9389 else
9390 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9391 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9392 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9393
9394 }
9395 break;
9396
fdc90cb4
JJ		 9397 case DT_GNU_HASH:
9398 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9399 if (do_dynamic)
9400 {
9401 print_vma (entry->d_un.d_val, PREFIX_HEX);
9402 putchar ('\n');
9403 }
9404 break;
9405
252b5132
RH		 9406 default:
9407 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9408 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9409 entry->d_un.d_val;
9410
9411 if (do_dynamic)
9412 {
9413 switch (elf_header.e_machine)
9414 {
9415 case EM_MIPS:
4fe85591 9416 case EM_MIPS_RS3_LE:
b2d38a17 9417 dynamic_section_mips_val (entry);
252b5132 9418 break;
103f02d3 9419 case EM_PARISC:
b2d38a17 9420 dynamic_section_parisc_val (entry);
103f02d3 9421 break;
ecc51f48 9422 case EM_IA_64:
b2d38a17 9423 dynamic_section_ia64_val (entry);
ecc51f48 9424 break;
252b5132 9425 default:
f7a99963
NC		 9426 print_vma (entry->d_un.d_val, PREFIX_HEX);
9427 putchar ('\n');
252b5132
RH		 9428 }
9429 }
9430 break;
9431 }
9432 }
9433
9434 return 1;
9435}
9436
9437static char *
d3ba0551 9438get_ver_flags (unsigned int flags)
252b5132 9439{
b34976b6 9440 static char buff[32];
252b5132
RH		 9441
9442 buff[0] = 0;
9443
9444 if (flags == 0)
9445 return _("none");
9446
9447 if (flags & VER_FLG_BASE)
9448 strcat (buff, "BASE ");
9449
9450 if (flags & VER_FLG_WEAK)
9451 {
9452 if (flags & VER_FLG_BASE)
9453 strcat (buff, "| ");
9454
9455 strcat (buff, "WEAK ");
9456 }
9457
44ec90b9
RO		 9458 if (flags & VER_FLG_INFO)
9459 {
9460 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9461 strcat (buff, "| ");
9462
9463 strcat (buff, "INFO ");
9464 }
9465
9466 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9467 strcat (buff, _("| <unknown>"));
252b5132
RH		 9468
9469 return buff;
9470}
9471
9472/* Display the contents of the version sections. */
98fb390a 9473
252b5132 9474static int
2cf0635d 9475process_version_sections (FILE * file)
252b5132 9476{
2cf0635d 9477 Elf_Internal_Shdr * section;
b34976b6
AM		 9478 unsigned i;
9479 int found = 0;
252b5132
RH		 9480
9481 if (! do_version)
9482 return 1;
9483
9484 for (i = 0, section = section_headers;
9485 i < elf_header.e_shnum;
b34976b6 9486 i++, section++)
252b5132
RH		 9487 {
9488 switch (section->sh_type)
9489 {
9490 case SHT_GNU_verdef:
9491 {
2cf0635d 9492 Elf_External_Verdef * edefs;
b34976b6
AM		 9493 unsigned int idx;
9494 unsigned int cnt;
2cf0635d 9495 char * endbuf;
252b5132
RH		 9496
9497 found = 1;
9498
74e1a04b
NC		 9499 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9500 printable_section_name (section),
9501 section->sh_info);
252b5132
RH		 9502
9503 printf (_(" Addr: 0x"));
9504 printf_vma (section->sh_addr);
74e1a04b 9505 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9506 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9507 printable_section_name_from_index (section->sh_link));
252b5132 9508
3f5e193b
NC		 9509 edefs = (Elf_External_Verdef *)
9510 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9511 _("version definition section"));
a6e9f9df
AM		 9512 if (!edefs)
9513 break;
59245841 9514 endbuf = (char *) edefs + section->sh_size;
252b5132 9515
b34976b6 9516 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9517 {
2cf0635d
NC		 9518 char * vstart;
9519 Elf_External_Verdef * edef;
b34976b6 9520 Elf_Internal_Verdef ent;
2cf0635d 9521 Elf_External_Verdaux * eaux;
b34976b6
AM		 9522 Elf_Internal_Verdaux aux;
9523 int j;
9524 int isum;
103f02d3 9525
7e26601c
NC		 9526 /* Check for very large indicies. */
9527 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9528 break;
9529
252b5132 9530 vstart = ((char *) edefs) + idx;
54806181
AM		 9531 if (vstart + sizeof (*edef) > endbuf)
9532 break;
252b5132
RH		 9533
9534 edef = (Elf_External_Verdef *) vstart;
9535
9536 ent.vd_version = BYTE_GET (edef->vd_version);
9537 ent.vd_flags = BYTE_GET (edef->vd_flags);
9538 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9539 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9540 ent.vd_hash = BYTE_GET (edef->vd_hash);
9541 ent.vd_aux = BYTE_GET (edef->vd_aux);
9542 ent.vd_next = BYTE_GET (edef->vd_next);
9543
9544 printf (_(" %#06x: Rev: %d Flags: %s"),
9545 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9546
9547 printf (_(" Index: %d Cnt: %d "),
9548 ent.vd_ndx, ent.vd_cnt);
9549
dd24e3da 9550 /* Check for overflow. */
7e26601c 9551 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9552 break;
9553
252b5132
RH		 9554 vstart += ent.vd_aux;
9555
9556 eaux = (Elf_External_Verdaux *) vstart;
9557
9558 aux.vda_name = BYTE_GET (eaux->vda_name);
9559 aux.vda_next = BYTE_GET (eaux->vda_next);
9560
d79b3d50
NC		 9561 if (VALID_DYNAMIC_NAME (aux.vda_name))
9562 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9563 else
9564 printf (_("Name index: %ld\n"), aux.vda_name);
9565
9566 isum = idx + ent.vd_aux;
9567
b34976b6 9568 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9569 {
dd24e3da 9570 /* Check for overflow. */
7e26601c 9571 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9572 break;
9573
252b5132
RH		 9574 isum += aux.vda_next;
9575 vstart += aux.vda_next;
9576
9577 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9578 if (vstart + sizeof (*eaux) > endbuf)
9579 break;
252b5132
RH		 9580
9581 aux.vda_name = BYTE_GET (eaux->vda_name);
9582 aux.vda_next = BYTE_GET (eaux->vda_next);
9583
d79b3d50 9584 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9585 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9586 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9587 else
9588 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9589 isum, j, aux.vda_name);
9590 }
dd24e3da 9591
54806181
AM		 9592 if (j < ent.vd_cnt)
9593 printf (_(" Version def aux past end of section\n"));
252b5132 9594
5d921cbd
NC		 9595 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9596 if (idx + ent.vd_next <= idx)
9597 break;
9598
252b5132
RH		 9599 idx += ent.vd_next;
9600 }
dd24e3da 9601
54806181
AM		 9602 if (cnt < section->sh_info)
9603 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9604
9605 free (edefs);
9606 }
9607 break;
103f02d3 9608
252b5132
RH		 9609 case SHT_GNU_verneed:
9610 {
2cf0635d 9611 Elf_External_Verneed * eneed;
b34976b6
AM		 9612 unsigned int idx;
9613 unsigned int cnt;
2cf0635d 9614 char * endbuf;
252b5132
RH		 9615
9616 found = 1;
9617
72de5009 9618 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9619 printable_section_name (section), section->sh_info);
252b5132
RH		 9620
9621 printf (_(" Addr: 0x"));
9622 printf_vma (section->sh_addr);
72de5009 9623 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9624 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9625 printable_section_name_from_index (section->sh_link));
252b5132 9626
3f5e193b
NC		 9627 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9628 section->sh_offset, 1,
9629 section->sh_size,
9cf03b7e 9630 _("Version Needs section"));
a6e9f9df
AM		 9631 if (!eneed)
9632 break;
59245841 9633 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9634
9635 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9636 {
2cf0635d 9637 Elf_External_Verneed * entry;
b34976b6
AM		 9638 Elf_Internal_Verneed ent;
9639 int j;
9640 int isum;
2cf0635d 9641 char * vstart;
252b5132 9642
7e26601c 9643 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9644 break;
9645
252b5132 9646 vstart = ((char *) eneed) + idx;
54806181
AM		 9647 if (vstart + sizeof (*entry) > endbuf)
9648 break;
252b5132
RH		 9649
9650 entry = (Elf_External_Verneed *) vstart;
9651
9652 ent.vn_version = BYTE_GET (entry->vn_version);
9653 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9654 ent.vn_file = BYTE_GET (entry->vn_file);
9655 ent.vn_aux = BYTE_GET (entry->vn_aux);
9656 ent.vn_next = BYTE_GET (entry->vn_next);
9657
9658 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9659
d79b3d50
NC		 9660 if (VALID_DYNAMIC_NAME (ent.vn_file))
9661 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9662 else
9663 printf (_(" File: %lx"), ent.vn_file);
9664
9665 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9666
dd24e3da 9667 /* Check for overflow. */
7e26601c 9668 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9669 break;
252b5132
RH		 9670 vstart += ent.vn_aux;
9671
9672 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9673 {
2cf0635d 9674 Elf_External_Vernaux * eaux;
b34976b6 9675 Elf_Internal_Vernaux aux;
252b5132 9676
54806181
AM		 9677 if (vstart + sizeof (*eaux) > endbuf)
9678 break;
252b5132
RH		 9679 eaux = (Elf_External_Vernaux *) vstart;
9680
9681 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9682 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9683 aux.vna_other = BYTE_GET (eaux->vna_other);
9684 aux.vna_name = BYTE_GET (eaux->vna_name);
9685 aux.vna_next = BYTE_GET (eaux->vna_next);
9686
d79b3d50 9687 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9688 printf (_(" %#06x: Name: %s"),
d79b3d50 9689 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9690 else
ecc2063b 9691 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9692 isum, aux.vna_name);
9693
9694 printf (_(" Flags: %s Version: %d\n"),
9695 get_ver_flags (aux.vna_flags), aux.vna_other);
9696
dd24e3da 9697 /* Check for overflow. */
53774b7e
NC		 9698 if (aux.vna_next > (size_t) (endbuf - vstart)
9699 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9700 {
9701 warn (_("Invalid vna_next field of %lx\n"),
9702 aux.vna_next);
9703 j = ent.vn_cnt;
9704 break;
9705 }
252b5132
RH		 9706 isum += aux.vna_next;
9707 vstart += aux.vna_next;
9708 }
9cf03b7e 9709
54806181 9710 if (j < ent.vn_cnt)
9cf03b7e 9711 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9712
bcf83b2a 9713 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9714 {
9715 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9716 cnt = section->sh_info;
9717 break;
9718 }
252b5132
RH		 9719 idx += ent.vn_next;
9720 }
9cf03b7e 9721
54806181 9722 if (cnt < section->sh_info)
9cf03b7e 9723 warn (_("Missing Version Needs information\n"));
103f02d3 9724
252b5132
RH		 9725 free (eneed);
9726 }
9727 break;
9728
9729 case SHT_GNU_versym:
9730 {
2cf0635d 9731 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9732 size_t total;
9733 unsigned int cnt;
2cf0635d
NC		 9734 unsigned char * edata;
9735 unsigned short * data;
9736 char * strtab;
9737 Elf_Internal_Sym * symbols;
9738 Elf_Internal_Shdr * string_sec;
ba5cdace 9739 unsigned long num_syms;
d3ba0551 9740 long off;
252b5132 9741
4fbb74a6 9742 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9743 break;
9744
4fbb74a6 9745 link_section = section_headers + section->sh_link;
08d8fa11 9746 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9747
4fbb74a6 9748 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9749 break;
9750
252b5132
RH		 9751 found = 1;
9752
ba5cdace 9753 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9754 if (symbols == NULL)
9755 break;
252b5132 9756
4fbb74a6 9757 string_sec = section_headers + link_section->sh_link;
252b5132 9758
3f5e193b
NC		 9759 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9760 string_sec->sh_size,
9761 _("version string table"));
a6e9f9df 9762 if (!strtab)
0429c154
MS		 9763 {
9764 free (symbols);
9765 break;
9766 }
252b5132 9767
8b73c356
NC		 9768 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9769 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9770
9771 printf (_(" Addr: "));
9772 printf_vma (section->sh_addr);
72de5009 9773 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9774 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9775 printable_section_name (link_section));
252b5132 9776
d3ba0551
AM		 9777 off = offset_from_vma (file,
9778 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9779 total * sizeof (short));
3f5e193b
NC		 9780 edata = (unsigned char *) get_data (NULL, file, off, total,
9781 sizeof (short),
9782 _("version symbol data"));
a6e9f9df
AM		 9783 if (!edata)
9784 {
9785 free (strtab);
0429c154 9786 free (symbols);
a6e9f9df
AM		 9787 break;
9788 }
252b5132 9789
3f5e193b 9790 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9791
9792 for (cnt = total; cnt --;)
b34976b6
AM		 9793 data[cnt] = byte_get (edata + cnt * sizeof (short),
9794 sizeof (short));
252b5132
RH		 9795
9796 free (edata);
9797
9798 for (cnt = 0; cnt < total; cnt += 4)
9799 {
9800 int j, nn;
00d93f34 9801 int check_def, check_need;
2cf0635d 9802 char * name;
252b5132
RH		 9803
9804 printf (" %03x:", cnt);
9805
9806 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9807 switch (data[cnt + j])
252b5132
RH		 9808 {
9809 case 0:
9810 fputs (_(" 0 (*local*) "), stdout);
9811 break;
9812
9813 case 1:
9814 fputs (_(" 1 (*global*) "), stdout);
9815 break;
9816
9817 default:
c244d050
NC		 9818 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9819 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9820
dd24e3da 9821 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9822 array, break to avoid an out-of-bounds read. */
9823 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9824 {
9825 warn (_("invalid index into symbol array\n"));
9826 break;
9827 }
9828
00d93f34
JJ		 9829 check_def = 1;
9830 check_need = 1;
4fbb74a6
AM		 9831 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9832 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9833 != SHT_NOBITS)
252b5132 9834 {
b34976b6 9835 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9836 check_def = 0;
9837 else
9838 check_need = 0;
252b5132 9839 }
00d93f34
JJ		 9840
9841 if (check_need
b34976b6 9842 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9843 {
b34976b6
AM		 9844 Elf_Internal_Verneed ivn;
9845 unsigned long offset;
252b5132 9846
d93f0186
NC		 9847 offset = offset_from_vma
9848 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9849 sizeof (Elf_External_Verneed));
252b5132 9850
b34976b6 9851 do
252b5132 9852 {
b34976b6
AM		 9853 Elf_Internal_Vernaux ivna;
9854 Elf_External_Verneed evn;
9855 Elf_External_Vernaux evna;
9856 unsigned long a_off;
252b5132 9857
59245841
NC		 9858 if (get_data (&evn, file, offset, sizeof (evn), 1,
9859 _("version need")) == NULL)
9860 break;
0b4362b0 9861
252b5132
RH		 9862 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9863 ivn.vn_next = BYTE_GET (evn.vn_next);
9864
9865 a_off = offset + ivn.vn_aux;
9866
9867 do
9868 {
59245841
NC		 9869 if (get_data (&evna, file, a_off, sizeof (evna),
9870 1, _("version need aux (2)")) == NULL)
9871 {
9872 ivna.vna_next = 0;
9873 ivna.vna_other = 0;
9874 }
9875 else
9876 {
9877 ivna.vna_next = BYTE_GET (evna.vna_next);
9878 ivna.vna_other = BYTE_GET (evna.vna_other);
9879 }
252b5132
RH		 9880
9881 a_off += ivna.vna_next;
9882 }
b34976b6 9883 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9884 && ivna.vna_next != 0);
9885
b34976b6 9886 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9887 {
9888 ivna.vna_name = BYTE_GET (evna.vna_name);
9889
54806181
AM		 9890 if (ivna.vna_name >= string_sec->sh_size)
9891 name = _("*invalid*");
9892 else
9893 name = strtab + ivna.vna_name;
252b5132 9894 nn += printf ("(%s%-*s",
16062207
ILT		 9895 name,
9896 12 - (int) strlen (name),
252b5132 9897 ")");
00d93f34 9898 check_def = 0;
252b5132
RH		 9899 break;
9900 }
9901
9902 offset += ivn.vn_next;
9903 }
9904 while (ivn.vn_next);
9905 }
00d93f34 9906
b34976b6
AM		 9907 if (check_def && data[cnt + j] != 0x8001
9908 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9909 {
b34976b6
AM		 9910 Elf_Internal_Verdef ivd;
9911 Elf_External_Verdef evd;
9912 unsigned long offset;
252b5132 9913
d93f0186
NC		 9914 offset = offset_from_vma
9915 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9916 sizeof evd);
252b5132
RH		 9917
9918 do
9919 {
59245841
NC		 9920 if (get_data (&evd, file, offset, sizeof (evd), 1,
9921 _("version def")) == NULL)
9922 {
9923 ivd.vd_next = 0;
948f632f 9924 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9925 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9926 break;
59245841
NC		 9927 }
9928 else
9929 {
9930 ivd.vd_next = BYTE_GET (evd.vd_next);
9931 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9932 }
252b5132
RH		 9933
9934 offset += ivd.vd_next;
9935 }
c244d050 9936 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9937 && ivd.vd_next != 0);
9938
c244d050 9939 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9940 {
b34976b6
AM		 9941 Elf_External_Verdaux evda;
9942 Elf_Internal_Verdaux ivda;
252b5132
RH		 9943
9944 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9945
59245841
NC		 9946 if (get_data (&evda, file,
9947 offset - ivd.vd_next + ivd.vd_aux,
9948 sizeof (evda), 1,
9949 _("version def aux")) == NULL)
9950 break;
252b5132
RH		 9951
9952 ivda.vda_name = BYTE_GET (evda.vda_name);
9953
54806181
AM		 9954 if (ivda.vda_name >= string_sec->sh_size)
9955 name = _("*invalid*");
9956 else
9957 name = strtab + ivda.vda_name;
252b5132 9958 nn += printf ("(%s%-*s",
16062207
ILT		 9959 name,
9960 12 - (int) strlen (name),
252b5132
RH		 9961 ")");
9962 }
9963 }
9964
9965 if (nn < 18)
9966 printf ("%*c", 18 - nn, ' ');
9967 }
9968
9969 putchar ('\n');
9970 }
9971
9972 free (data);
9973 free (strtab);
9974 free (symbols);
9975 }
9976 break;
103f02d3 9977
252b5132
RH		 9978 default:
9979 break;
9980 }
9981 }
9982
9983 if (! found)
9984 printf (_("\nNo version information found in this file.\n"));
9985
9986 return 1;
9987}
9988
d1133906 9989static const char *
d3ba0551 9990get_symbol_binding (unsigned int binding)
252b5132 9991{
b34976b6 9992 static char buff[32];
252b5132
RH		 9993
9994 switch (binding)
9995 {
b34976b6
AM		 9996 case STB_LOCAL: return "LOCAL";
9997 case STB_GLOBAL: return "GLOBAL";
9998 case STB_WEAK: return "WEAK";
252b5132
RH		 9999 default:
10000 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10001 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10002 binding);
252b5132 10003 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10004 {
10005 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10006 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10007 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10008 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10009 return "UNIQUE";
10010 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10011 }
252b5132 10012 else
e9e44622 10013 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10014 return buff;
10015 }
10016}
10017
d1133906 10018static const char *
d3ba0551 10019get_symbol_type (unsigned int type)
252b5132 10020{
b34976b6 10021 static char buff[32];
252b5132
RH		 10022
10023 switch (type)
10024 {
b34976b6
AM		 10025 case STT_NOTYPE: return "NOTYPE";
10026 case STT_OBJECT: return "OBJECT";
10027 case STT_FUNC: return "FUNC";
10028 case STT_SECTION: return "SECTION";
10029 case STT_FILE: return "FILE";
10030 case STT_COMMON: return "COMMON";
10031 case STT_TLS: return "TLS";
15ab5209
DB		 10032 case STT_RELC: return "RELC";
10033 case STT_SRELC: return "SRELC";
252b5132
RH		 10034 default:
10035 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10036 {
3510a7b8
NC		 10037 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10038 return "THUMB_FUNC";
103f02d3 10039
351b4b40 10040 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10041 return "REGISTER";
10042
10043 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10044 return "PARISC_MILLI";
10045
e9e44622 10046 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10047 }
252b5132 10048 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10049 {
10050 if (elf_header.e_machine == EM_PARISC)
10051 {
10052 if (type == STT_HP_OPAQUE)
10053 return "HP_OPAQUE";
10054 if (type == STT_HP_STUB)
10055 return "HP_STUB";
10056 }
10057
d8045f23 10058 if (type == STT_GNU_IFUNC
9c55345c 10059 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10060 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10061 /* GNU is still using the default value 0. */
d8045f23
NC		 10062 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10063 return "IFUNC";
10064
e9e44622 10065 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10066 }
252b5132 10067 else
e9e44622 10068 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10069 return buff;
10070 }
10071}
10072
d1133906 10073static const char *
d3ba0551 10074get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10075{
10076 switch (visibility)
10077 {
b34976b6
AM		 10078 case STV_DEFAULT: return "DEFAULT";
10079 case STV_INTERNAL: return "INTERNAL";
10080 case STV_HIDDEN: return "HIDDEN";
d1133906 10081 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10082 default:
10083 error (_("Unrecognized visibility value: %u"), visibility);
10084 return _("<unknown>");
d1133906
NC		 10085 }
10086}
10087
5e2b0d47
NC		 10088static const char *
10089get_mips_symbol_other (unsigned int other)
10090{
10091 switch (other)
10092 {
df58fc94
RS		 10093 case STO_OPTIONAL:
10094 return "OPTIONAL";
10095 case STO_MIPS_PLT:
10096 return "MIPS PLT";
10097 case STO_MIPS_PIC:
10098 return "MIPS PIC";
10099 case STO_MICROMIPS:
10100 return "MICROMIPS";
10101 case STO_MICROMIPS | STO_MIPS_PIC:
10102 return "MICROMIPS, MIPS PIC";
10103 case STO_MIPS16:
10104 return "MIPS16";
10105 default:
10106 return NULL;
5e2b0d47
NC		 10107 }
10108}
10109
28f997cf
TG		 10110static const char *
10111get_ia64_symbol_other (unsigned int other)
10112{
10113 if (is_ia64_vms ())
10114 {
10115 static char res[32];
10116
10117 res[0] = 0;
10118
10119 /* Function types is for images and .STB files only. */
10120 switch (elf_header.e_type)
10121 {
10122 case ET_DYN:
10123 case ET_EXEC:
10124 switch (VMS_ST_FUNC_TYPE (other))
10125 {
10126 case VMS_SFT_CODE_ADDR:
10127 strcat (res, " CA");
10128 break;
10129 case VMS_SFT_SYMV_IDX:
10130 strcat (res, " VEC");
10131 break;
10132 case VMS_SFT_FD:
10133 strcat (res, " FD");
10134 break;
10135 case VMS_SFT_RESERVE:
10136 strcat (res, " RSV");
10137 break;
10138 default:
bee0ee85
NC		 10139 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10140 VMS_ST_FUNC_TYPE (other));
10141 strcat (res, " <unknown>");
10142 break;
28f997cf
TG		 10143 }
10144 break;
10145 default:
10146 break;
10147 }
10148 switch (VMS_ST_LINKAGE (other))
10149 {
10150 case VMS_STL_IGNORE:
10151 strcat (res, " IGN");
10152 break;
10153 case VMS_STL_RESERVE:
10154 strcat (res, " RSV");
10155 break;
10156 case VMS_STL_STD:
10157 strcat (res, " STD");
10158 break;
10159 case VMS_STL_LNK:
10160 strcat (res, " LNK");
10161 break;
10162 default:
bee0ee85
NC		 10163 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10164 VMS_ST_LINKAGE (other));
10165 strcat (res, " <unknown>");
10166 break;
28f997cf
TG		 10167 }
10168
10169 if (res[0] != 0)
10170 return res + 1;
10171 else
10172 return res;
10173 }
10174 return NULL;
10175}
10176
6911b7dc
AM		 10177static const char *
10178get_ppc64_symbol_other (unsigned int other)
10179{
10180 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10181 {
10182 static char buf[32];
10183 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10184 PPC64_LOCAL_ENTRY_OFFSET (other));
10185 return buf;
10186 }
10187 return NULL;
10188}
10189
5e2b0d47
NC		 10190static const char *
10191get_symbol_other (unsigned int other)
10192{
10193 const char * result = NULL;
10194 static char buff [32];
10195
10196 if (other == 0)
10197 return "";
10198
10199 switch (elf_header.e_machine)
10200 {
10201 case EM_MIPS:
10202 result = get_mips_symbol_other (other);
28f997cf
TG		 10203 break;
10204 case EM_IA_64:
10205 result = get_ia64_symbol_other (other);
10206 break;
6911b7dc
AM		 10207 case EM_PPC64:
10208 result = get_ppc64_symbol_other (other);
10209 break;
5e2b0d47
NC		 10210 default:
10211 break;
10212 }
10213
10214 if (result)
10215 return result;
10216
10217 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10218 return buff;
10219}
10220
d1133906 10221static const char *
d3ba0551 10222get_symbol_index_type (unsigned int type)
252b5132 10223{
b34976b6 10224 static char buff[32];
5cf1065c 10225
252b5132
RH		 10226 switch (type)
10227 {
b34976b6
AM		 10228 case SHN_UNDEF: return "UND";
10229 case SHN_ABS: return "ABS";
10230 case SHN_COMMON: return "COM";
252b5132 10231 default:
9ce701e2
L		 10232 if (type == SHN_IA_64_ANSI_COMMON
10233 && elf_header.e_machine == EM_IA_64
10234 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10235 return "ANSI_COM";
8a9036a4 10236 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10237 || elf_header.e_machine == EM_L1OM
10238 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10239 && type == SHN_X86_64_LCOMMON)
10240 return "LARGE_COM";
ac145307
BS		 10241 else if ((type == SHN_MIPS_SCOMMON
10242 && elf_header.e_machine == EM_MIPS)
10243 || (type == SHN_TIC6X_SCOMMON
10244 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10245 return "SCOM";
10246 else if (type == SHN_MIPS_SUNDEFINED
10247 && elf_header.e_machine == EM_MIPS)
10248 return "SUND";
9ce701e2 10249 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10250 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10251 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10252 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10253 else if (type >= SHN_LORESERVE)
10254 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10255 else if (type >= elf_header.e_shnum)
e0a31db1 10256 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10257 else
232e7cb8 10258 sprintf (buff, "%3d", type);
5cf1065c 10259 break;
252b5132 10260 }
5cf1065c
NC		 10261
10262 return buff;
252b5132
RH		 10263}
10264
66543521 10265static bfd_vma *
57028622 10266get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10267{
2cf0635d
NC		 10268 unsigned char * e_data;
10269 bfd_vma * i_data;
252b5132 10270
57028622
NC		 10271 /* If the size_t type is smaller than the bfd_size_type, eg because
10272 you are building a 32-bit tool on a 64-bit host, then make sure
10273 that when (number) is cast to (size_t) no information is lost. */
10274 if (sizeof (size_t) < sizeof (bfd_size_type)
10275 && (bfd_size_type) ((size_t) number) != number)
10276 {
10277 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10278 (unsigned long long) number, ent_size);
10279 return NULL;
10280 }
948f632f 10281
3102e897
NC		 10282 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10283 attempting to allocate memory when the read is bound to fail. */
10284 if (ent_size * number > current_file_size)
10285 {
57028622
NC		 10286 error (_("Invalid number of dynamic entries: %llu\n"),
10287 (unsigned long long) number);
3102e897
NC		 10288 return NULL;
10289 }
10290
57028622 10291 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10292 if (e_data == NULL)
10293 {
57028622
NC		 10294 error (_("Out of memory reading %llu dynamic entries\n"),
10295 (unsigned long long) number);
252b5132
RH		 10296 return NULL;
10297 }
10298
57028622 10299 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10300 {
57028622
NC		 10301 error (_("Unable to read in %llu bytes of dynamic data\n"),
10302 (unsigned long long) (number * ent_size));
3102e897 10303 free (e_data);
252b5132
RH		 10304 return NULL;
10305 }
10306
57028622 10307 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10308 if (i_data == NULL)
10309 {
57028622
NC		 10310 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10311 (unsigned long long) number);
252b5132
RH		 10312 free (e_data);
10313 return NULL;
10314 }
10315
10316 while (number--)
66543521 10317 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10318
10319 free (e_data);
10320
10321 return i_data;
10322}
10323
6bd1a22c
L		 10324static void
10325print_dynamic_symbol (bfd_vma si, unsigned long hn)
10326{
2cf0635d 10327 Elf_Internal_Sym * psym;
6bd1a22c
L		 10328 int n;
10329
6bd1a22c
L		 10330 n = print_vma (si, DEC_5);
10331 if (n < 5)
0b4362b0 10332 fputs (&" "[n], stdout);
6bd1a22c 10333 printf (" %3lu: ", hn);
e0a31db1
NC		 10334
10335 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10336 {
3102e897
NC		 10337 printf (_("<No info available for dynamic symbol number %lu>\n"),
10338 (unsigned long) si);
e0a31db1
NC		 10339 return;
10340 }
10341
10342 psym = dynamic_symbols + si;
6bd1a22c
L		 10343 print_vma (psym->st_value, LONG_HEX);
10344 putchar (' ');
10345 print_vma (psym->st_size, DEC_5);
10346
f4be36b3
AM		 10347 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10348 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10349 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10350 /* Check to see if any other bits in the st_other field are set.
10351 Note - displaying this information disrupts the layout of the
10352 table being generated, but for the moment this case is very
10353 rare. */
10354 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10355 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10356 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10357 if (VALID_DYNAMIC_NAME (psym->st_name))
10358 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10359 else
2b692964 10360 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10361 putchar ('\n');
10362}
10363
bb4d2ac2
L		 10364static const char *
10365get_symbol_version_string (FILE *file, int is_dynsym,
10366 const char *strtab,
10367 unsigned long int strtab_size,
10368 unsigned int si, Elf_Internal_Sym *psym,
10369 enum versioned_symbol_info *sym_info,
10370 unsigned short *vna_other)
10371{
10372 const char *version_string = NULL;
10373
10374 if (is_dynsym
10375 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10376 {
10377 unsigned char data[2];
10378 unsigned short vers_data;
10379 unsigned long offset;
10380 int is_nobits;
10381 int check_def;
10382
10383 offset = offset_from_vma
10384 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10385 sizeof data + si * sizeof (vers_data));
10386
10387 if (get_data (&data, file, offset + si * sizeof (vers_data),
10388 sizeof (data), 1, _("version data")) == NULL)
10389 return NULL;
10390
10391 vers_data = byte_get (data, 2);
10392
53774b7e
NC		 10393 is_nobits = (section_headers != NULL
10394 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10395 && section_headers[psym->st_shndx].sh_type
10396 == SHT_NOBITS);
10397
10398 check_def = (psym->st_shndx != SHN_UNDEF);
10399
10400 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10401 {
10402 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10403 && (is_nobits || ! check_def))
10404 {
10405 Elf_External_Verneed evn;
10406 Elf_Internal_Verneed ivn;
10407 Elf_Internal_Vernaux ivna;
10408
10409 /* We must test both. */
10410 offset = offset_from_vma
10411 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10412 sizeof evn);
10413
10414 do
10415 {
10416 unsigned long vna_off;
10417
10418 if (get_data (&evn, file, offset, sizeof (evn), 1,
10419 _("version need")) == NULL)
10420 {
10421 ivna.vna_next = 0;
10422 ivna.vna_other = 0;
10423 ivna.vna_name = 0;
10424 break;
10425 }
10426
10427 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10428 ivn.vn_next = BYTE_GET (evn.vn_next);
10429
10430 vna_off = offset + ivn.vn_aux;
10431
10432 do
10433 {
10434 Elf_External_Vernaux evna;
10435
10436 if (get_data (&evna, file, vna_off,
10437 sizeof (evna), 1,
10438 _("version need aux (3)")) == NULL)
10439 {
10440 ivna.vna_next = 0;
10441 ivna.vna_other = 0;
10442 ivna.vna_name = 0;
10443 }
10444 else
10445 {
10446 ivna.vna_other = BYTE_GET (evna.vna_other);
10447 ivna.vna_next = BYTE_GET (evna.vna_next);
10448 ivna.vna_name = BYTE_GET (evna.vna_name);
10449 }
10450
10451 vna_off += ivna.vna_next;
10452 }
10453 while (ivna.vna_other != vers_data
10454 && ivna.vna_next != 0);
10455
10456 if (ivna.vna_other == vers_data)
10457 break;
10458
10459 offset += ivn.vn_next;
10460 }
10461 while (ivn.vn_next != 0);
10462
10463 if (ivna.vna_other == vers_data)
10464 {
10465 *sym_info = symbol_undefined;
10466 *vna_other = ivna.vna_other;
10467 version_string = (ivna.vna_name < strtab_size
10468 ? strtab + ivna.vna_name
10469 : _("<corrupt>"));
10470 check_def = 0;
10471 }
10472 else if (! is_nobits)
10473 error (_("bad dynamic symbol\n"));
10474 else
10475 check_def = 1;
10476 }
10477
10478 if (check_def)
10479 {
10480 if (vers_data != 0x8001
10481 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10482 {
10483 Elf_Internal_Verdef ivd;
10484 Elf_Internal_Verdaux ivda;
10485 Elf_External_Verdaux evda;
10486 unsigned long off;
10487
10488 off = offset_from_vma
10489 (file,
10490 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10491 sizeof (Elf_External_Verdef));
10492
10493 do
10494 {
10495 Elf_External_Verdef evd;
10496
10497 if (get_data (&evd, file, off, sizeof (evd),
10498 1, _("version def")) == NULL)
10499 {
10500 ivd.vd_ndx = 0;
10501 ivd.vd_aux = 0;
10502 ivd.vd_next = 0;
10503 }
10504 else
10505 {
10506 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10507 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10508 ivd.vd_next = BYTE_GET (evd.vd_next);
10509 }
10510
10511 off += ivd.vd_next;
10512 }
10513 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10514 && ivd.vd_next != 0);
10515
10516 off -= ivd.vd_next;
10517 off += ivd.vd_aux;
10518
10519 if (get_data (&evda, file, off, sizeof (evda),
10520 1, _("version def aux")) == NULL)
10521 return version_string;
10522
10523 ivda.vda_name = BYTE_GET (evda.vda_name);
10524
10525 if (psym->st_name != ivda.vda_name)
10526 {
10527 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10528 ? symbol_hidden : symbol_public);
10529 version_string = (ivda.vda_name < strtab_size
10530 ? strtab + ivda.vda_name
10531 : _("<corrupt>"));
10532 }
10533 }
10534 }
10535 }
10536 }
10537 return version_string;
10538}
10539
e3c8793a 10540/* Dump the symbol table. */
252b5132 10541static int
2cf0635d 10542process_symbol_table (FILE * file)
252b5132 10543{
2cf0635d 10544 Elf_Internal_Shdr * section;
8b73c356
NC		 10545 bfd_size_type nbuckets = 0;
10546 bfd_size_type nchains = 0;
2cf0635d
NC		 10547 bfd_vma * buckets = NULL;
10548 bfd_vma * chains = NULL;
fdc90cb4 10549 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10550 bfd_vma * gnubuckets = NULL;
10551 bfd_vma * gnuchains = NULL;
6bd1a22c 10552 bfd_vma gnusymidx = 0;
071436c6 10553 bfd_size_type ngnuchains = 0;
252b5132 10554
2c610e4b 10555 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10556 return 1;
10557
6bd1a22c
L		 10558 if (dynamic_info[DT_HASH]
10559 && (do_histogram
2c610e4b
L		 10560 || (do_using_dynamic
10561 && !do_dyn_syms
10562 && dynamic_strings != NULL)))
252b5132 10563 {
66543521
AM		 10564 unsigned char nb[8];
10565 unsigned char nc[8];
8b73c356 10566 unsigned int hash_ent_size = 4;
66543521
AM		 10567
10568 if ((elf_header.e_machine == EM_ALPHA
10569 || elf_header.e_machine == EM_S390
10570 || elf_header.e_machine == EM_S390_OLD)
10571 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10572 hash_ent_size = 8;
10573
fb52b2f4
NC		 10574 if (fseek (file,
10575 (archive_file_offset
10576 + offset_from_vma (file, dynamic_info[DT_HASH],
10577 sizeof nb + sizeof nc)),
d93f0186 10578 SEEK_SET))
252b5132 10579 {
591a748a 10580 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10581 goto no_hash;
252b5132
RH		 10582 }
10583
66543521 10584 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10585 {
10586 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10587 goto no_hash;
252b5132
RH		 10588 }
10589
66543521 10590 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10591 {
10592 error (_("Failed to read in number of chains\n"));
d3a44ec6 10593 goto no_hash;
252b5132
RH		 10594 }
10595
66543521
AM		 10596 nbuckets = byte_get (nb, hash_ent_size);
10597 nchains = byte_get (nc, hash_ent_size);
252b5132 10598
66543521
AM		 10599 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10600 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10601
d3a44ec6 10602 no_hash:
252b5132 10603 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10604 {
10605 if (do_using_dynamic)
10606 return 0;
10607 free (buckets);
10608 free (chains);
10609 buckets = NULL;
10610 chains = NULL;
10611 nbuckets = 0;
10612 nchains = 0;
10613 }
252b5132
RH		 10614 }
10615
6bd1a22c
L		 10616 if (dynamic_info_DT_GNU_HASH
10617 && (do_histogram
2c610e4b
L		 10618 || (do_using_dynamic
10619 && !do_dyn_syms
10620 && dynamic_strings != NULL)))
252b5132 10621 {
6bd1a22c
L		 10622 unsigned char nb[16];
10623 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10624 bfd_vma buckets_vma;
10625
10626 if (fseek (file,
10627 (archive_file_offset
10628 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10629 sizeof nb)),
10630 SEEK_SET))
10631 {
10632 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10633 goto no_gnu_hash;
6bd1a22c 10634 }
252b5132 10635
6bd1a22c
L		 10636 if (fread (nb, 16, 1, file) != 1)
10637 {
10638 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10639 goto no_gnu_hash;
6bd1a22c
L		 10640 }
10641
10642 ngnubuckets = byte_get (nb, 4);
10643 gnusymidx = byte_get (nb + 4, 4);
10644 bitmaskwords = byte_get (nb + 8, 4);
10645 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10646 if (is_32bit_elf)
6bd1a22c 10647 buckets_vma += bitmaskwords * 4;
f7a99963 10648 else
6bd1a22c 10649 buckets_vma += bitmaskwords * 8;
252b5132 10650
6bd1a22c
L		 10651 if (fseek (file,
10652 (archive_file_offset
10653 + offset_from_vma (file, buckets_vma, 4)),
10654 SEEK_SET))
252b5132 10655 {
6bd1a22c 10656 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10657 goto no_gnu_hash;
6bd1a22c
L		 10658 }
10659
10660 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10661
6bd1a22c 10662 if (gnubuckets == NULL)
d3a44ec6 10663 goto no_gnu_hash;
6bd1a22c
L		 10664
10665 for (i = 0; i < ngnubuckets; i++)
10666 if (gnubuckets[i] != 0)
10667 {
10668 if (gnubuckets[i] < gnusymidx)
10669 return 0;
10670
10671 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10672 maxchain = gnubuckets[i];
10673 }
10674
10675 if (maxchain == 0xffffffff)
d3a44ec6 10676 goto no_gnu_hash;
6bd1a22c
L		 10677
10678 maxchain -= gnusymidx;
10679
10680 if (fseek (file,
10681 (archive_file_offset
10682 + offset_from_vma (file, buckets_vma
10683 + 4 * (ngnubuckets + maxchain), 4)),
10684 SEEK_SET))
10685 {
10686 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10687 goto no_gnu_hash;
6bd1a22c
L		 10688 }
10689
10690 do
10691 {
10692 if (fread (nb, 4, 1, file) != 1)
252b5132 10693 {
6bd1a22c 10694 error (_("Failed to determine last chain length\n"));
d3a44ec6 10695 goto no_gnu_hash;
6bd1a22c 10696 }
252b5132 10697
6bd1a22c 10698 if (maxchain + 1 == 0)
d3a44ec6 10699 goto no_gnu_hash;
252b5132 10700
6bd1a22c
L		 10701 ++maxchain;
10702 }
10703 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10704
6bd1a22c
L		 10705 if (fseek (file,
10706 (archive_file_offset
10707 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10708 SEEK_SET))
10709 {
10710 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10711 goto no_gnu_hash;
6bd1a22c
L		 10712 }
10713
10714 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10715 ngnuchains = maxchain;
6bd1a22c 10716
d3a44ec6 10717 no_gnu_hash:
6bd1a22c 10718 if (gnuchains == NULL)
d3a44ec6
JJ		 10719 {
10720 free (gnubuckets);
d3a44ec6
JJ		 10721 gnubuckets = NULL;
10722 ngnubuckets = 0;
f64fddf1
NC		 10723 if (do_using_dynamic)
10724 return 0;
d3a44ec6 10725 }
6bd1a22c
L		 10726 }
10727
10728 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10729 && do_syms
10730 && do_using_dynamic
3102e897
NC		 10731 && dynamic_strings != NULL
10732 && dynamic_symbols != NULL)
6bd1a22c
L		 10733 {
10734 unsigned long hn;
10735
10736 if (dynamic_info[DT_HASH])
10737 {
10738 bfd_vma si;
10739
10740 printf (_("\nSymbol table for image:\n"));
10741 if (is_32bit_elf)
10742 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10743 else
10744 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10745
10746 for (hn = 0; hn < nbuckets; hn++)
10747 {
10748 if (! buckets[hn])
10749 continue;
10750
10751 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10752 print_dynamic_symbol (si, hn);
252b5132
RH		 10753 }
10754 }
6bd1a22c
L		 10755
10756 if (dynamic_info_DT_GNU_HASH)
10757 {
10758 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10759 if (is_32bit_elf)
10760 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10761 else
10762 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10763
10764 for (hn = 0; hn < ngnubuckets; ++hn)
10765 if (gnubuckets[hn] != 0)
10766 {
10767 bfd_vma si = gnubuckets[hn];
10768 bfd_vma off = si - gnusymidx;
10769
10770 do
10771 {
10772 print_dynamic_symbol (si, hn);
10773 si++;
10774 }
071436c6 10775 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10776 }
10777 }
252b5132 10778 }
8b73c356
NC		 10779 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10780 && section_headers != NULL)
252b5132 10781 {
b34976b6 10782 unsigned int i;
252b5132
RH		 10783
10784 for (i = 0, section = section_headers;
10785 i < elf_header.e_shnum;
10786 i++, section++)
10787 {
b34976b6 10788 unsigned int si;
2cf0635d 10789 char * strtab = NULL;
c256ffe7 10790 unsigned long int strtab_size = 0;
2cf0635d
NC		 10791 Elf_Internal_Sym * symtab;
10792 Elf_Internal_Sym * psym;
ba5cdace 10793 unsigned long num_syms;
252b5132 10794
2c610e4b
L		 10795 if ((section->sh_type != SHT_SYMTAB
10796 && section->sh_type != SHT_DYNSYM)
10797 || (!do_syms
10798 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10799 continue;
10800
dd24e3da
NC		 10801 if (section->sh_entsize == 0)
10802 {
10803 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10804 printable_section_name (section));
dd24e3da
NC		 10805 continue;
10806 }
10807
252b5132 10808 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10809 printable_section_name (section),
252b5132 10810 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10811
f7a99963 10812 if (is_32bit_elf)
ca47b30c 10813 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10814 else
ca47b30c 10815 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10816
ba5cdace 10817 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10818 if (symtab == NULL)
10819 continue;
10820
10821 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10822 {
10823 strtab = string_table;
10824 strtab_size = string_table_length;
10825 }
4fbb74a6 10826 else if (section->sh_link < elf_header.e_shnum)
252b5132 10827 {
2cf0635d 10828 Elf_Internal_Shdr * string_sec;
252b5132 10829
4fbb74a6 10830 string_sec = section_headers + section->sh_link;
252b5132 10831
3f5e193b
NC		 10832 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10833 1, string_sec->sh_size,
10834 _("string table"));
c256ffe7 10835 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10836 }
10837
ba5cdace 10838 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10839 {
bb4d2ac2
L		 10840 const char *version_string;
10841 enum versioned_symbol_info sym_info;
10842 unsigned short vna_other;
10843
5e220199 10844 printf ("%6d: ", si);
f7a99963
NC		 10845 print_vma (psym->st_value, LONG_HEX);
10846 putchar (' ');
10847 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10848 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10849 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10850 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10851 /* Check to see if any other bits in the st_other field are set.
10852 Note - displaying this information disrupts the layout of the
10853 table being generated, but for the moment this case is very rare. */
10854 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10855 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10856 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10857 print_symbol (25, psym->st_name < strtab_size
2b692964 10858 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10859
bb4d2ac2
L		 10860 version_string
10861 = get_symbol_version_string (file,
10862 section->sh_type == SHT_DYNSYM,
10863 strtab, strtab_size, si,
10864 psym, &sym_info, &vna_other);
10865 if (version_string)
252b5132 10866 {
bb4d2ac2
L		 10867 if (sym_info == symbol_undefined)
10868 printf ("@%s (%d)", version_string, vna_other);
10869 else
10870 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10871 version_string);
252b5132
RH		 10872 }
10873
10874 putchar ('\n');
10875 }
10876
10877 free (symtab);
10878 if (strtab != string_table)
10879 free (strtab);
10880 }
10881 }
10882 else if (do_syms)
10883 printf
10884 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10885
10886 if (do_histogram && buckets != NULL)
10887 {
2cf0635d
NC		 10888 unsigned long * lengths;
10889 unsigned long * counts;
66543521
AM		 10890 unsigned long hn;
10891 bfd_vma si;
10892 unsigned long maxlength = 0;
10893 unsigned long nzero_counts = 0;
10894 unsigned long nsyms = 0;
94d15024 10895 unsigned long chained;
252b5132 10896
66543521
AM		 10897 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10898 (unsigned long) nbuckets);
252b5132 10899
3f5e193b 10900 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10901 if (lengths == NULL)
10902 {
8b73c356 10903 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10904 return 0;
10905 }
8b73c356
NC		 10906
10907 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10908 for (hn = 0; hn < nbuckets; ++hn)
10909 {
94d15024
MF		 10910 for (si = buckets[hn], chained = 0;
10911 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10912 si = chains[si], ++chained)
252b5132 10913 {
b34976b6 10914 ++nsyms;
252b5132 10915 if (maxlength < ++lengths[hn])
b34976b6 10916 ++maxlength;
252b5132 10917 }
94d15024
MF		 10918
10919 /* PR binutils/17531: A corrupt binary could contain broken
10920 histogram data. Do not go into an infinite loop trying
10921 to process it. */
10922 if (chained > nchains)
10923 {
10924 error (_("histogram chain is corrupt\n"));
10925 break;
10926 }
252b5132
RH		 10927 }
10928
3f5e193b 10929 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10930 if (counts == NULL)
10931 {
b2e951ec 10932 free (lengths);
8b73c356 10933 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10934 return 0;
10935 }
10936
10937 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10938 ++counts[lengths[hn]];
252b5132 10939
103f02d3 10940 if (nbuckets > 0)
252b5132 10941 {
66543521
AM		 10942 unsigned long i;
10943 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10944 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10945 for (i = 1; i <= maxlength; ++i)
103f02d3 10946 {
66543521
AM		 10947 nzero_counts += counts[i] * i;
10948 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10949 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10950 (nzero_counts * 100.0) / nsyms);
10951 }
252b5132
RH		 10952 }
10953
10954 free (counts);
10955 free (lengths);
10956 }
10957
10958 if (buckets != NULL)
10959 {
10960 free (buckets);
10961 free (chains);
10962 }
10963
d3a44ec6 10964 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10965 {
2cf0635d
NC		 10966 unsigned long * lengths;
10967 unsigned long * counts;
fdc90cb4
JJ		 10968 unsigned long hn;
10969 unsigned long maxlength = 0;
10970 unsigned long nzero_counts = 0;
10971 unsigned long nsyms = 0;
fdc90cb4 10972
8b73c356
NC		 10973 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10974 (unsigned long) ngnubuckets);
10975
3f5e193b 10976 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10977 if (lengths == NULL)
10978 {
8b73c356 10979 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10980 return 0;
10981 }
10982
fdc90cb4
JJ		 10983 printf (_(" Length Number %% of total Coverage\n"));
10984
10985 for (hn = 0; hn < ngnubuckets; ++hn)
10986 if (gnubuckets[hn] != 0)
10987 {
10988 bfd_vma off, length = 1;
10989
6bd1a22c 10990 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10991 /* PR 17531 file: 010-77222-0.004. */
10992 off < ngnuchains && (gnuchains[off] & 1) == 0;
10993 ++off)
fdc90cb4
JJ		 10994 ++length;
10995 lengths[hn] = length;
10996 if (length > maxlength)
10997 maxlength = length;
10998 nsyms += length;
10999 }
11000
3f5e193b 11001 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11002 if (counts == NULL)
11003 {
b2e951ec 11004 free (lengths);
8b73c356 11005 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11006 return 0;
11007 }
11008
11009 for (hn = 0; hn < ngnubuckets; ++hn)
11010 ++counts[lengths[hn]];
11011
11012 if (ngnubuckets > 0)
11013 {
11014 unsigned long j;
11015 printf (" 0 %-10lu (%5.1f%%)\n",
11016 counts[0], (counts[0] * 100.0) / ngnubuckets);
11017 for (j = 1; j <= maxlength; ++j)
11018 {
11019 nzero_counts += counts[j] * j;
11020 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11021 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11022 (nzero_counts * 100.0) / nsyms);
11023 }
11024 }
11025
11026 free (counts);
11027 free (lengths);
11028 free (gnubuckets);
11029 free (gnuchains);
11030 }
11031
252b5132
RH		 11032 return 1;
11033}
11034
11035static int
2cf0635d 11036process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11037{
b4c96d0d 11038 unsigned int i;
252b5132
RH		 11039
11040 if (dynamic_syminfo == NULL
11041 || !do_dynamic)
11042 /* No syminfo, this is ok. */
11043 return 1;
11044
11045 /* There better should be a dynamic symbol section. */
11046 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11047 return 0;
11048
11049 if (dynamic_addr)
11050 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11051 dynamic_syminfo_offset, dynamic_syminfo_nent);
11052
11053 printf (_(" Num: Name BoundTo Flags\n"));
11054 for (i = 0; i < dynamic_syminfo_nent; ++i)
11055 {
11056 unsigned short int flags = dynamic_syminfo[i].si_flags;
11057
31104126 11058 printf ("%4d: ", i);
4082ef84
NC		 11059 if (i >= num_dynamic_syms)
11060 printf (_("<corrupt index>"));
11061 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11062 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11063 else
2b692964 11064 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11065 putchar (' ');
252b5132
RH		 11066
11067 switch (dynamic_syminfo[i].si_boundto)
11068 {
11069 case SYMINFO_BT_SELF:
11070 fputs ("SELF ", stdout);
11071 break;
11072 case SYMINFO_BT_PARENT:
11073 fputs ("PARENT ", stdout);
11074 break;
11075 default:
11076 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11077 && dynamic_syminfo[i].si_boundto < dynamic_nent
11078 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11079 {
d79b3d50 11080 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11081 putchar (' ' );
11082 }
252b5132
RH		 11083 else
11084 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11085 break;
11086 }
11087
11088 if (flags & SYMINFO_FLG_DIRECT)
11089 printf (" DIRECT");
11090 if (flags & SYMINFO_FLG_PASSTHRU)
11091 printf (" PASSTHRU");
11092 if (flags & SYMINFO_FLG_COPY)
11093 printf (" COPY");
11094 if (flags & SYMINFO_FLG_LAZYLOAD)
11095 printf (" LAZYLOAD");
11096
11097 puts ("");
11098 }
11099
11100 return 1;
11101}
11102
cf13d699
NC		 11103/* Check to see if the given reloc needs to be handled in a target specific
11104 manner. If so then process the reloc and return TRUE otherwise return
11105 FALSE. */
09c11c86 11106
cf13d699
NC		 11107static bfd_boolean
11108target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11109 unsigned char * start,
11110 Elf_Internal_Sym * symtab)
252b5132 11111{
cf13d699 11112 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11113
cf13d699 11114 switch (elf_header.e_machine)
252b5132 11115 {
13761a11
NC		 11116 case EM_MSP430:
11117 case EM_MSP430_OLD:
11118 {
11119 static Elf_Internal_Sym * saved_sym = NULL;
11120
11121 switch (reloc_type)
11122 {
11123 case 10: /* R_MSP430_SYM_DIFF */
11124 if (uses_msp430x_relocs ())
11125 break;
11126 case 21: /* R_MSP430X_SYM_DIFF */
11127 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11128 return TRUE;
11129
11130 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11131 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11132 goto handle_sym_diff;
0b4362b0 11133
13761a11
NC		 11134 case 5: /* R_MSP430_16_BYTE */
11135 case 9: /* R_MSP430_8 */
11136 if (uses_msp430x_relocs ())
11137 break;
11138 goto handle_sym_diff;
11139
11140 case 2: /* R_MSP430_ABS16 */
11141 case 15: /* R_MSP430X_ABS16 */
11142 if (! uses_msp430x_relocs ())
11143 break;
11144 goto handle_sym_diff;
0b4362b0 11145
13761a11
NC		 11146 handle_sym_diff:
11147 if (saved_sym != NULL)
11148 {
11149 bfd_vma value;
11150
11151 value = reloc->r_addend
11152 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11153 - saved_sym->st_value);
11154
11155 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11156
11157 saved_sym = NULL;
11158 return TRUE;
11159 }
11160 break;
11161
11162 default:
11163 if (saved_sym != NULL)
071436c6 11164 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11165 break;
11166 }
11167 break;
11168 }
11169
cf13d699
NC		 11170 case EM_MN10300:
11171 case EM_CYGNUS_MN10300:
11172 {
11173 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11174
cf13d699
NC		 11175 switch (reloc_type)
11176 {
11177 case 34: /* R_MN10300_ALIGN */
11178 return TRUE;
11179 case 33: /* R_MN10300_SYM_DIFF */
11180 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11181 return TRUE;
11182 case 1: /* R_MN10300_32 */
11183 case 2: /* R_MN10300_16 */
11184 if (saved_sym != NULL)
11185 {
11186 bfd_vma value;
252b5132 11187
cf13d699
NC		 11188 value = reloc->r_addend
11189 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11190 - saved_sym->st_value);
252b5132 11191
cf13d699 11192 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11193
cf13d699
NC		 11194 saved_sym = NULL;
11195 return TRUE;
11196 }
11197 break;
11198 default:
11199 if (saved_sym != NULL)
071436c6 11200 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11201 break;
11202 }
11203 break;
11204 }
6ff71e76
NC		 11205
11206 case EM_RL78:
11207 {
11208 static bfd_vma saved_sym1 = 0;
11209 static bfd_vma saved_sym2 = 0;
11210 static bfd_vma value;
11211
11212 switch (reloc_type)
11213 {
11214 case 0x80: /* R_RL78_SYM. */
11215 saved_sym1 = saved_sym2;
11216 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11217 saved_sym2 += reloc->r_addend;
11218 return TRUE;
11219
11220 case 0x83: /* R_RL78_OPsub. */
11221 value = saved_sym1 - saved_sym2;
11222 saved_sym2 = saved_sym1 = 0;
11223 return TRUE;
11224 break;
11225
11226 case 0x41: /* R_RL78_ABS32. */
11227 byte_put (start + reloc->r_offset, value, 4);
11228 value = 0;
11229 return TRUE;
11230
11231 case 0x43: /* R_RL78_ABS16. */
11232 byte_put (start + reloc->r_offset, value, 2);
11233 value = 0;
11234 return TRUE;
11235
11236 default:
11237 break;
11238 }
11239 break;
11240 }
252b5132
RH		 11241 }
11242
cf13d699 11243 return FALSE;
252b5132
RH		 11244}
11245
aca88567
NC		 11246/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11247 DWARF debug sections. This is a target specific test. Note - we do not
11248 go through the whole including-target-headers-multiple-times route, (as
11249 we have already done with <elf/h8.h>) because this would become very
11250 messy and even then this function would have to contain target specific
11251 information (the names of the relocs instead of their numeric values).
11252 FIXME: This is not the correct way to solve this problem. The proper way
11253 is to have target specific reloc sizing and typing functions created by
11254 the reloc-macros.h header, in the same way that it already creates the
11255 reloc naming functions. */
11256
11257static bfd_boolean
11258is_32bit_abs_reloc (unsigned int reloc_type)
11259{
11260 switch (elf_header.e_machine)
11261 {
41e92641 11262 case EM_386:
22abe556 11263 case EM_IAMCU:
41e92641 11264 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11265 case EM_68K:
11266 return reloc_type == 1; /* R_68K_32. */
11267 case EM_860:
11268 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11269 case EM_960:
11270 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11271 case EM_AARCH64:
11272 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11273 case EM_ALPHA:
137b6b5f 11274 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11275 case EM_ARC:
11276 return reloc_type == 1; /* R_ARC_32. */
11277 case EM_ARM:
11278 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11279 case EM_AVR_OLD:
aca88567
NC		 11280 case EM_AVR:
11281 return reloc_type == 1;
cfb8c092
NC		 11282 case EM_ADAPTEVA_EPIPHANY:
11283 return reloc_type == 3;
aca88567
NC		 11284 case EM_BLACKFIN:
11285 return reloc_type == 0x12; /* R_byte4_data. */
11286 case EM_CRIS:
11287 return reloc_type == 3; /* R_CRIS_32. */
11288 case EM_CR16:
11289 return reloc_type == 3; /* R_CR16_NUM32. */
11290 case EM_CRX:
11291 return reloc_type == 15; /* R_CRX_NUM32. */
11292 case EM_CYGNUS_FRV:
11293 return reloc_type == 1;
41e92641
NC		 11294 case EM_CYGNUS_D10V:
11295 case EM_D10V:
11296 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11297 case EM_CYGNUS_D30V:
11298 case EM_D30V:
11299 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11300 case EM_DLX:
11301 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11302 case EM_CYGNUS_FR30:
11303 case EM_FR30:
11304 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11305 case EM_FT32:
11306 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11307 case EM_H8S:
11308 case EM_H8_300:
11309 case EM_H8_300H:
11310 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11311 case EM_IA_64:
d1c4b12b
NC		 11312 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11313 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11314 case EM_IP2K_OLD:
11315 case EM_IP2K:
11316 return reloc_type == 2; /* R_IP2K_32. */
11317 case EM_IQ2000:
11318 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11319 case EM_LATTICEMICO32:
11320 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11321 case EM_M32C_OLD:
aca88567
NC		 11322 case EM_M32C:
11323 return reloc_type == 3; /* R_M32C_32. */
11324 case EM_M32R:
11325 return reloc_type == 34; /* R_M32R_32_RELA. */
11326 case EM_MCORE:
11327 return reloc_type == 1; /* R_MCORE_ADDR32. */
11328 case EM_CYGNUS_MEP:
11329 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11330 case EM_METAG:
11331 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11332 case EM_MICROBLAZE:
11333 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11334 case EM_MIPS:
11335 return reloc_type == 2; /* R_MIPS_32. */
11336 case EM_MMIX:
11337 return reloc_type == 4; /* R_MMIX_32. */
11338 case EM_CYGNUS_MN10200:
11339 case EM_MN10200:
11340 return reloc_type == 1; /* R_MN10200_32. */
11341 case EM_CYGNUS_MN10300:
11342 case EM_MN10300:
11343 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11344 case EM_MOXIE:
11345 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11346 case EM_MSP430_OLD:
11347 case EM_MSP430:
13761a11 11348 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11349 case EM_MT:
11350 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11351 case EM_NDS32:
11352 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11353 case EM_ALTERA_NIOS2:
36591ba1 11354 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11355 case EM_NIOS32:
11356 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11357 case EM_OR1K:
11358 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11359 case EM_PARISC:
5fda8eca
NC		 11360 return (reloc_type == 1 /* R_PARISC_DIR32. */
11361 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11362 case EM_PJ:
11363 case EM_PJ_OLD:
11364 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11365 case EM_PPC64:
11366 return reloc_type == 1; /* R_PPC64_ADDR32. */
11367 case EM_PPC:
11368 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11369 case EM_RL78:
11370 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11371 case EM_RX:
11372 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11373 case EM_S370:
11374 return reloc_type == 1; /* R_I370_ADDR31. */
11375 case EM_S390_OLD:
11376 case EM_S390:
11377 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11378 case EM_SCORE:
11379 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11380 case EM_SH:
11381 return reloc_type == 1; /* R_SH_DIR32. */
11382 case EM_SPARC32PLUS:
11383 case EM_SPARCV9:
11384 case EM_SPARC:
11385 return reloc_type == 3 /* R_SPARC_32. */
11386 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11387 case EM_SPU:
11388 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11389 case EM_TI_C6000:
11390 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11391 case EM_TILEGX:
11392 return reloc_type == 2; /* R_TILEGX_32. */
11393 case EM_TILEPRO:
11394 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11395 case EM_CYGNUS_V850:
11396 case EM_V850:
11397 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11398 case EM_V800:
11399 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11400 case EM_VAX:
11401 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11402 case EM_VISIUM:
11403 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11404 case EM_X86_64:
8a9036a4 11405 case EM_L1OM:
7a9068fe 11406 case EM_K1OM:
aca88567 11407 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11408 case EM_XC16X:
11409 case EM_C166:
11410 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11411 case EM_XGATE:
11412 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11413 case EM_XSTORMY16:
11414 return reloc_type == 1; /* R_XSTROMY16_32. */
11415 case EM_XTENSA_OLD:
11416 case EM_XTENSA:
11417 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11418 default:
bee0ee85
NC		 11419 {
11420 static unsigned int prev_warn = 0;
11421
11422 /* Avoid repeating the same warning multiple times. */
11423 if (prev_warn != elf_header.e_machine)
11424 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11425 elf_header.e_machine);
11426 prev_warn = elf_header.e_machine;
11427 return FALSE;
11428 }
aca88567
NC		 11429 }
11430}
11431
11432/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11433 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11434
11435static bfd_boolean
11436is_32bit_pcrel_reloc (unsigned int reloc_type)
11437{
11438 switch (elf_header.e_machine)
11439 {
41e92641 11440 case EM_386:
22abe556 11441 case EM_IAMCU:
3e0873ac 11442 return reloc_type == 2; /* R_386_PC32. */
aca88567 11443 case EM_68K:
3e0873ac 11444 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11445 case EM_AARCH64:
11446 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11447 case EM_ADAPTEVA_EPIPHANY:
11448 return reloc_type == 6;
aca88567
NC		 11449 case EM_ALPHA:
11450 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11451 case EM_ARM:
3e0873ac 11452 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11453 case EM_MICROBLAZE:
11454 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11455 case EM_OR1K:
11456 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11457 case EM_PARISC:
85acf597 11458 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11459 case EM_PPC:
11460 return reloc_type == 26; /* R_PPC_REL32. */
11461 case EM_PPC64:
3e0873ac 11462 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11463 case EM_S390_OLD:
11464 case EM_S390:
3e0873ac 11465 return reloc_type == 5; /* R_390_PC32. */
aca88567 11466 case EM_SH:
3e0873ac 11467 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11468 case EM_SPARC32PLUS:
11469 case EM_SPARCV9:
11470 case EM_SPARC:
3e0873ac 11471 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11472 case EM_SPU:
11473 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11474 case EM_TILEGX:
11475 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11476 case EM_TILEPRO:
11477 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11478 case EM_VISIUM:
11479 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11480 case EM_X86_64:
8a9036a4 11481 case EM_L1OM:
7a9068fe 11482 case EM_K1OM:
3e0873ac 11483 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11484 case EM_XTENSA_OLD:
11485 case EM_XTENSA:
11486 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11487 default:
11488 /* Do not abort or issue an error message here. Not all targets use
11489 pc-relative 32-bit relocs in their DWARF debug information and we
11490 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11491 more helpful warning message will be generated by apply_relocations
11492 anyway, so just return. */
aca88567
NC		 11493 return FALSE;
11494 }
11495}
11496
11497/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11498 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11499
11500static bfd_boolean
11501is_64bit_abs_reloc (unsigned int reloc_type)
11502{
11503 switch (elf_header.e_machine)
11504 {
a06ea964
NC		 11505 case EM_AARCH64:
11506 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11507 case EM_ALPHA:
11508 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11509 case EM_IA_64:
11510 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11511 case EM_PARISC:
11512 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11513 case EM_PPC64:
11514 return reloc_type == 38; /* R_PPC64_ADDR64. */
11515 case EM_SPARC32PLUS:
11516 case EM_SPARCV9:
11517 case EM_SPARC:
11518 return reloc_type == 54; /* R_SPARC_UA64. */
11519 case EM_X86_64:
8a9036a4 11520 case EM_L1OM:
7a9068fe 11521 case EM_K1OM:
aca88567 11522 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11523 case EM_S390_OLD:
11524 case EM_S390:
aa137e4d
NC		 11525 return reloc_type == 22; /* R_S390_64. */
11526 case EM_TILEGX:
11527 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11528 case EM_MIPS:
aa137e4d 11529 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11530 default:
11531 return FALSE;
11532 }
11533}
11534
85acf597
RH		 11535/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11536 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11537
11538static bfd_boolean
11539is_64bit_pcrel_reloc (unsigned int reloc_type)
11540{
11541 switch (elf_header.e_machine)
11542 {
a06ea964
NC		 11543 case EM_AARCH64:
11544 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11545 case EM_ALPHA:
aa137e4d 11546 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11547 case EM_IA_64:
aa137e4d 11548 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11549 case EM_PARISC:
aa137e4d 11550 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11551 case EM_PPC64:
aa137e4d 11552 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11553 case EM_SPARC32PLUS:
11554 case EM_SPARCV9:
11555 case EM_SPARC:
aa137e4d 11556 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11557 case EM_X86_64:
8a9036a4 11558 case EM_L1OM:
7a9068fe 11559 case EM_K1OM:
aa137e4d 11560 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11561 case EM_S390_OLD:
11562 case EM_S390:
aa137e4d
NC		 11563 return reloc_type == 23; /* R_S390_PC64. */
11564 case EM_TILEGX:
11565 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11566 default:
11567 return FALSE;
11568 }
11569}
11570
4dc3c23d
AM		 11571/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11572 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11573
11574static bfd_boolean
11575is_24bit_abs_reloc (unsigned int reloc_type)
11576{
11577 switch (elf_header.e_machine)
11578 {
11579 case EM_CYGNUS_MN10200:
11580 case EM_MN10200:
11581 return reloc_type == 4; /* R_MN10200_24. */
11582 default:
11583 return FALSE;
11584 }
11585}
11586
aca88567
NC		 11587/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11588 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11589
11590static bfd_boolean
11591is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11592{
11593 switch (elf_header.e_machine)
11594 {
aca88567
NC		 11595 case EM_AVR_OLD:
11596 case EM_AVR:
11597 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11598 case EM_ADAPTEVA_EPIPHANY:
11599 return reloc_type == 5;
41e92641
NC		 11600 case EM_CYGNUS_D10V:
11601 case EM_D10V:
11602 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11603 case EM_H8S:
11604 case EM_H8_300:
11605 case EM_H8_300H:
aca88567
NC		 11606 return reloc_type == R_H8_DIR16;
11607 case EM_IP2K_OLD:
11608 case EM_IP2K:
11609 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11610 case EM_M32C_OLD:
f4236fe4
DD		 11611 case EM_M32C:
11612 return reloc_type == 1; /* R_M32C_16 */
aca88567 11613 case EM_MSP430:
13761a11
NC		 11614 if (uses_msp430x_relocs ())
11615 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11616 case EM_MSP430_OLD:
aca88567 11617 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11618 case EM_NDS32:
11619 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11620 case EM_ALTERA_NIOS2:
36591ba1 11621 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11622 case EM_NIOS32:
11623 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11624 case EM_OR1K:
11625 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11626 case EM_TI_C6000:
11627 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11628 case EM_XC16X:
11629 case EM_C166:
11630 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11631 case EM_CYGNUS_MN10200:
11632 case EM_MN10200:
11633 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11634 case EM_CYGNUS_MN10300:
11635 case EM_MN10300:
11636 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11637 case EM_VISIUM:
11638 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11639 case EM_XGATE:
11640 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11641 default:
aca88567 11642 return FALSE;
4b78141a
NC		 11643 }
11644}
11645
2a7b2e88
JK		 11646/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11647 relocation entries (possibly formerly used for SHT_GROUP sections). */
11648
11649static bfd_boolean
11650is_none_reloc (unsigned int reloc_type)
11651{
11652 switch (elf_header.e_machine)
11653 {
cb8f3167
NC		 11654 case EM_68K: /* R_68K_NONE. */
11655 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11656 case EM_SPARC32PLUS:
11657 case EM_SPARCV9:
cb8f3167
NC		 11658 case EM_SPARC: /* R_SPARC_NONE. */
11659 case EM_MIPS: /* R_MIPS_NONE. */
11660 case EM_PARISC: /* R_PARISC_NONE. */
11661 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11662 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11663 case EM_PPC: /* R_PPC_NONE. */
11664 case EM_PPC64: /* R_PPC64_NONE. */
11665 case EM_ARM: /* R_ARM_NONE. */
11666 case EM_IA_64: /* R_IA64_NONE. */
11667 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11668 case EM_S390_OLD:
cb8f3167
NC		 11669 case EM_S390: /* R_390_NONE. */
11670 case EM_CRIS: /* R_CRIS_NONE. */
11671 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11672 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11673 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11674 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11675 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11676 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11677 case EM_M32R: /* R_M32R_NONE. */
40b36596 11678 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11679 case EM_TILEGX: /* R_TILEGX_NONE. */
11680 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11681 case EM_XC16X:
11682 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11683 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11684 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11685 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11686 return reloc_type == 0;
a06ea964
NC		 11687 case EM_AARCH64:
11688 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11689 case EM_NDS32:
11690 return (reloc_type == 0 /* R_XTENSA_NONE. */
11691 || reloc_type == 204 /* R_NDS32_DIFF8. */
11692 || reloc_type == 205 /* R_NDS32_DIFF16. */
11693 || reloc_type == 206 /* R_NDS32_DIFF32. */
11694 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11695 case EM_XTENSA_OLD:
11696 case EM_XTENSA:
4dc3c23d
AM		 11697 return (reloc_type == 0 /* R_XTENSA_NONE. */
11698 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11699 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11700 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11701 case EM_METAG:
11702 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11703 }
11704 return FALSE;
11705}
11706
d1c4b12b
NC		 11707/* Returns TRUE if there is a relocation against
11708 section NAME at OFFSET bytes. */
11709
11710bfd_boolean
11711reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11712{
11713 Elf_Internal_Rela * relocs;
11714 Elf_Internal_Rela * rp;
11715
11716 if (dsec == NULL || dsec->reloc_info == NULL)
11717 return FALSE;
11718
11719 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11720
11721 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11722 if (rp->r_offset == offset)
11723 return TRUE;
11724
11725 return FALSE;
11726}
11727
cf13d699
NC		 11728/* Apply relocations to a section.
11729 Note: So far support has been added only for those relocations
11730 which can be found in debug sections.
d1c4b12b
NC		 11731 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11732 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11733 FIXME: Add support for more relocations ? */
1b315056 11734
cf13d699 11735static void
d1c4b12b
NC		 11736apply_relocations (void * file,
11737 const Elf_Internal_Shdr * section,
11738 unsigned char * start,
11739 bfd_size_type size,
11740 void ** relocs_return,
11741 unsigned long * num_relocs_return)
1b315056 11742{
cf13d699 11743 Elf_Internal_Shdr * relsec;
0d2a7a93 11744 unsigned char * end = start + size;
cb8f3167 11745
d1c4b12b
NC		 11746 if (relocs_return != NULL)
11747 {
11748 * (Elf_Internal_Rela **) relocs_return = NULL;
11749 * num_relocs_return = 0;
11750 }
11751
cf13d699
NC		 11752 if (elf_header.e_type != ET_REL)
11753 return;
1b315056 11754
cf13d699 11755 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11756 for (relsec = section_headers;
11757 relsec < section_headers + elf_header.e_shnum;
11758 ++relsec)
252b5132 11759 {
41e92641
NC		 11760 bfd_boolean is_rela;
11761 unsigned long num_relocs;
2cf0635d
NC		 11762 Elf_Internal_Rela * relocs;
11763 Elf_Internal_Rela * rp;
11764 Elf_Internal_Shdr * symsec;
11765 Elf_Internal_Sym * symtab;
ba5cdace 11766 unsigned long num_syms;
2cf0635d 11767 Elf_Internal_Sym * sym;
252b5132 11768
41e92641 11769 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11770 || relsec->sh_info >= elf_header.e_shnum
11771 || section_headers + relsec->sh_info != section
c256ffe7 11772 || relsec->sh_size == 0
4fbb74a6 11773 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11774 continue;
428409d5 11775
41e92641
NC		 11776 is_rela = relsec->sh_type == SHT_RELA;
11777
11778 if (is_rela)
11779 {
3f5e193b
NC		 11780 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11781 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11782 return;
11783 }
11784 else
11785 {
3f5e193b
NC		 11786 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11787 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11788 return;
11789 }
11790
11791 /* SH uses RELA but uses in place value instead of the addend field. */
11792 if (elf_header.e_machine == EM_SH)
11793 is_rela = FALSE;
428409d5 11794
4fbb74a6 11795 symsec = section_headers + relsec->sh_link;
ba5cdace 11796 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11797
41e92641 11798 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11799 {
41e92641
NC		 11800 bfd_vma addend;
11801 unsigned int reloc_type;
11802 unsigned int reloc_size;
91d6fa6a 11803 unsigned char * rloc;
ba5cdace 11804 unsigned long sym_index;
4b78141a 11805
aca88567 11806 reloc_type = get_reloc_type (rp->r_info);
41e92641 11807
98fb390a 11808 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11809 continue;
98fb390a
NC		 11810 else if (is_none_reloc (reloc_type))
11811 continue;
11812 else if (is_32bit_abs_reloc (reloc_type)
11813 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11814 reloc_size = 4;
85acf597
RH		 11815 else if (is_64bit_abs_reloc (reloc_type)
11816 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11817 reloc_size = 8;
4dc3c23d
AM		 11818 else if (is_24bit_abs_reloc (reloc_type))
11819 reloc_size = 3;
aca88567
NC		 11820 else if (is_16bit_abs_reloc (reloc_type))
11821 reloc_size = 2;
11822 else
4b78141a 11823 {
bee0ee85
NC		 11824 static unsigned int prev_reloc = 0;
11825 if (reloc_type != prev_reloc)
11826 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11827 reloc_type, printable_section_name (section));
11828 prev_reloc = reloc_type;
4b78141a
NC		 11829 continue;
11830 }
103f02d3 11831
91d6fa6a 11832 rloc = start + rp->r_offset;
c8da6823 11833 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11834 {
11835 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11836 (unsigned long) rp->r_offset,
74e1a04b 11837 printable_section_name (section));
700dd8b7
L		 11838 continue;
11839 }
103f02d3 11840
ba5cdace
NC		 11841 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11842 if (sym_index >= num_syms)
11843 {
11844 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11845 sym_index, printable_section_name (section));
ba5cdace
NC		 11846 continue;
11847 }
11848 sym = symtab + sym_index;
41e92641
NC		 11849
11850 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11851 make sure that it is of an appropriate type.
11852
11853 Relocations against symbols without type can happen.
11854 Gcc -feliminate-dwarf2-dups may generate symbols
11855 without type for debug info.
11856
11857 Icc generates relocations against function symbols
11858 instead of local labels.
11859
11860 Relocations against object symbols can happen, eg when
11861 referencing a global array. For an example of this see
11862 the _clz.o binary in libgcc.a. */
aca88567 11863 if (sym != symtab
55f25fc3 11864 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11865 {
41e92641 11866 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11867 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11868 (long int)(rp - relocs),
74e1a04b 11869 printable_section_name (relsec));
aca88567 11870 continue;
5b18a4bc 11871 }
252b5132 11872
4dc3c23d
AM		 11873 addend = 0;
11874 if (is_rela)
11875 addend += rp->r_addend;
c47320c3
AM		 11876 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11877 partial_inplace. */
4dc3c23d
AM		 11878 if (!is_rela
11879 || (elf_header.e_machine == EM_XTENSA
11880 && reloc_type == 1)
11881 || ((elf_header.e_machine == EM_PJ
11882 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11883 && reloc_type == 1)
11884 || ((elf_header.e_machine == EM_D30V
11885 || elf_header.e_machine == EM_CYGNUS_D30V)
11886 && reloc_type == 12))
91d6fa6a 11887 addend += byte_get (rloc, reloc_size);
cb8f3167 11888
85acf597
RH		 11889 if (is_32bit_pcrel_reloc (reloc_type)
11890 || is_64bit_pcrel_reloc (reloc_type))
11891 {
11892 /* On HPPA, all pc-relative relocations are biased by 8. */
11893 if (elf_header.e_machine == EM_PARISC)
11894 addend -= 8;
91d6fa6a 11895 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11896 reloc_size);
11897 }
41e92641 11898 else
91d6fa6a 11899 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11900 }
252b5132 11901
5b18a4bc 11902 free (symtab);
d1c4b12b
NC		 11903
11904 if (relocs_return)
11905 {
11906 * (Elf_Internal_Rela **) relocs_return = relocs;
11907 * num_relocs_return = num_relocs;
11908 }
11909 else
11910 free (relocs);
11911
5b18a4bc
NC		 11912 break;
11913 }
5b18a4bc 11914}
103f02d3 11915
cf13d699
NC		 11916#ifdef SUPPORT_DISASSEMBLY
11917static int
11918disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11919{
74e1a04b 11920 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11921
74e1a04b 11922 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11923
11924 return 1;
11925}
11926#endif
11927
11928/* Reads in the contents of SECTION from FILE, returning a pointer
11929 to a malloc'ed buffer or NULL if something went wrong. */
11930
11931static char *
11932get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11933{
11934 bfd_size_type num_bytes;
11935
11936 num_bytes = section->sh_size;
11937
11938 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11939 {
11940 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11941 printable_section_name (section));
cf13d699
NC		 11942 return NULL;
11943 }
11944
3f5e193b
NC		 11945 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11946 _("section contents"));
cf13d699
NC		 11947}
11948
0e602686
NC		 11949/* Uncompresses a section that was compressed using zlib, in place. */
11950
11951static bfd_boolean
11952uncompress_section_contents (unsigned char **buffer,
11953 dwarf_size_type uncompressed_size,
11954 dwarf_size_type *size)
11955{
11956 dwarf_size_type compressed_size = *size;
11957 unsigned char * compressed_buffer = *buffer;
11958 unsigned char * uncompressed_buffer;
11959 z_stream strm;
11960 int rc;
11961
11962 /* It is possible the section consists of several compressed
11963 buffers concatenated together, so we uncompress in a loop. */
11964 /* PR 18313: The state field in the z_stream structure is supposed
11965 to be invisible to the user (ie us), but some compilers will
11966 still complain about it being used without initialisation. So
11967 we first zero the entire z_stream structure and then set the fields
11968 that we need. */
11969 memset (& strm, 0, sizeof strm);
11970 strm.avail_in = compressed_size;
11971 strm.next_in = (Bytef *) compressed_buffer;
11972 strm.avail_out = uncompressed_size;
11973 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11974
11975 rc = inflateInit (& strm);
11976 while (strm.avail_in > 0)
11977 {
11978 if (rc != Z_OK)
11979 goto fail;
11980 strm.next_out = ((Bytef *) uncompressed_buffer
11981 + (uncompressed_size - strm.avail_out));
11982 rc = inflate (&strm, Z_FINISH);
11983 if (rc != Z_STREAM_END)
11984 goto fail;
11985 rc = inflateReset (& strm);
11986 }
11987 rc = inflateEnd (& strm);
11988 if (rc != Z_OK
11989 || strm.avail_out != 0)
11990 goto fail;
11991
11992 *buffer = uncompressed_buffer;
11993 *size = uncompressed_size;
11994 return TRUE;
11995
11996 fail:
11997 free (uncompressed_buffer);
11998 /* Indicate decompression failure. */
11999 *buffer = NULL;
12000 return FALSE;
12001}
dd24e3da 12002
cf13d699
NC		 12003static void
12004dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12005{
0e602686
NC		 12006 Elf_Internal_Shdr * relsec;
12007 bfd_size_type num_bytes;
fd8008d8
L		 12008 unsigned char * data;
12009 unsigned char * end;
12010 unsigned char * real_start;
12011 unsigned char * start;
0e602686 12012 bfd_boolean some_strings_shown;
cf13d699 12013
fd8008d8
L		 12014 real_start = start = (unsigned char *) get_section_contents (section,
12015 file);
cf13d699
NC		 12016 if (start == NULL)
12017 return;
0e602686 12018 num_bytes = section->sh_size;
cf13d699 12019
74e1a04b 12020 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12021
0e602686
NC		 12022 if (decompress_dumps)
12023 {
12024 dwarf_size_type new_size = num_bytes;
12025 dwarf_size_type uncompressed_size = 0;
12026
12027 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12028 {
12029 Elf_Internal_Chdr chdr;
12030 unsigned int compression_header_size
12031 = get_compression_header (& chdr, (unsigned char *) start);
12032
813dabb9 12033 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12034 {
813dabb9
L		 12035 warn (_("section '%s' has unsupported compress type: %d\n"),
12036 printable_section_name (section), chdr.ch_type);
12037 return;
12038 }
12039 else if (chdr.ch_addralign != section->sh_addralign)
12040 {
12041 warn (_("compressed section '%s' is corrupted\n"),
12042 printable_section_name (section));
12043 return;
0e602686 12044 }
813dabb9
L		 12045 uncompressed_size = chdr.ch_size;
12046 start += compression_header_size;
12047 new_size -= compression_header_size;
0e602686
NC		 12048 }
12049 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12050 {
12051 /* Read the zlib header. In this case, it should be "ZLIB"
12052 followed by the uncompressed section size, 8 bytes in
12053 big-endian order. */
12054 uncompressed_size = start[4]; uncompressed_size <<= 8;
12055 uncompressed_size += start[5]; uncompressed_size <<= 8;
12056 uncompressed_size += start[6]; uncompressed_size <<= 8;
12057 uncompressed_size += start[7]; uncompressed_size <<= 8;
12058 uncompressed_size += start[8]; uncompressed_size <<= 8;
12059 uncompressed_size += start[9]; uncompressed_size <<= 8;
12060 uncompressed_size += start[10]; uncompressed_size <<= 8;
12061 uncompressed_size += start[11];
12062 start += 12;
12063 new_size -= 12;
12064 }
12065
12066 if (uncompressed_size
fd8008d8 12067 && uncompress_section_contents (& start,
0e602686
NC		 12068 uncompressed_size, & new_size))
12069 num_bytes = new_size;
12070 }
fd8008d8 12071
cf13d699
NC		 12072 /* If the section being dumped has relocations against it the user might
12073 be expecting these relocations to have been applied. Check for this
12074 case and issue a warning message in order to avoid confusion.
12075 FIXME: Maybe we ought to have an option that dumps a section with
12076 relocs applied ? */
12077 for (relsec = section_headers;
12078 relsec < section_headers + elf_header.e_shnum;
12079 ++relsec)
12080 {
12081 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12082 || relsec->sh_info >= elf_header.e_shnum
12083 || section_headers + relsec->sh_info != section
12084 || relsec->sh_size == 0
12085 || relsec->sh_link >= elf_header.e_shnum)
12086 continue;
12087
12088 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12089 break;
12090 }
12091
cf13d699
NC		 12092 data = start;
12093 end = start + num_bytes;
12094 some_strings_shown = FALSE;
12095
12096 while (data < end)
12097 {
12098 while (!ISPRINT (* data))
12099 if (++ data >= end)
12100 break;
12101
12102 if (data < end)
12103 {
071436c6
NC		 12104 size_t maxlen = end - data;
12105
cf13d699 12106#ifndef __MSVCRT__
c975cc98
NC		 12107 /* PR 11128: Use two separate invocations in order to work
12108 around bugs in the Solaris 8 implementation of printf. */
12109 printf (" [%6tx] ", data - start);
cf13d699 12110#else
071436c6 12111 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12112#endif
4082ef84
NC		 12113 if (maxlen > 0)
12114 {
fd8008d8 12115 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12116 putchar ('\n');
fd8008d8 12117 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12118 }
12119 else
12120 {
12121 printf (_("<corrupt>\n"));
12122 data = end;
12123 }
cf13d699
NC		 12124 some_strings_shown = TRUE;
12125 }
12126 }
12127
12128 if (! some_strings_shown)
12129 printf (_(" No strings found in this section."));
12130
0e602686 12131 free (real_start);
cf13d699
NC		 12132
12133 putchar ('\n');
12134}
12135
12136static void
12137dump_section_as_bytes (Elf_Internal_Shdr * section,
12138 FILE * file,
12139 bfd_boolean relocate)
12140{
12141 Elf_Internal_Shdr * relsec;
0e602686
NC		 12142 bfd_size_type bytes;
12143 bfd_size_type section_size;
12144 bfd_vma addr;
12145 unsigned char * data;
12146 unsigned char * real_start;
12147 unsigned char * start;
12148
12149 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12150 if (start == NULL)
12151 return;
0e602686 12152 section_size = section->sh_size;
cf13d699 12153
74e1a04b 12154 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12155
0e602686
NC		 12156 if (decompress_dumps)
12157 {
12158 dwarf_size_type new_size = section_size;
12159 dwarf_size_type uncompressed_size = 0;
12160
12161 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12162 {
12163 Elf_Internal_Chdr chdr;
12164 unsigned int compression_header_size
12165 = get_compression_header (& chdr, start);
12166
813dabb9 12167 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12168 {
813dabb9
L		 12169 warn (_("section '%s' has unsupported compress type: %d\n"),
12170 printable_section_name (section), chdr.ch_type);
12171 return;
0e602686 12172 }
813dabb9
L		 12173 else if (chdr.ch_addralign != section->sh_addralign)
12174 {
12175 warn (_("compressed section '%s' is corrupted\n"),
12176 printable_section_name (section));
12177 return;
12178 }
12179 uncompressed_size = chdr.ch_size;
12180 start += compression_header_size;
12181 new_size -= compression_header_size;
0e602686
NC		 12182 }
12183 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12184 {
12185 /* Read the zlib header. In this case, it should be "ZLIB"
12186 followed by the uncompressed section size, 8 bytes in
12187 big-endian order. */
12188 uncompressed_size = start[4]; uncompressed_size <<= 8;
12189 uncompressed_size += start[5]; uncompressed_size <<= 8;
12190 uncompressed_size += start[6]; uncompressed_size <<= 8;
12191 uncompressed_size += start[7]; uncompressed_size <<= 8;
12192 uncompressed_size += start[8]; uncompressed_size <<= 8;
12193 uncompressed_size += start[9]; uncompressed_size <<= 8;
12194 uncompressed_size += start[10]; uncompressed_size <<= 8;
12195 uncompressed_size += start[11];
12196 start += 12;
12197 new_size -= 12;
12198 }
12199
12200 if (uncompressed_size
12201 && uncompress_section_contents (& start, uncompressed_size,
12202 & new_size))
12203 section_size = new_size;
12204 }
14ae95f2 12205
cf13d699
NC		 12206 if (relocate)
12207 {
0e602686 12208 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12209 }
12210 else
12211 {
12212 /* If the section being dumped has relocations against it the user might
12213 be expecting these relocations to have been applied. Check for this
12214 case and issue a warning message in order to avoid confusion.
12215 FIXME: Maybe we ought to have an option that dumps a section with
12216 relocs applied ? */
12217 for (relsec = section_headers;
12218 relsec < section_headers + elf_header.e_shnum;
12219 ++relsec)
12220 {
12221 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12222 || relsec->sh_info >= elf_header.e_shnum
12223 || section_headers + relsec->sh_info != section
12224 || relsec->sh_size == 0
12225 || relsec->sh_link >= elf_header.e_shnum)
12226 continue;
12227
12228 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12229 break;
12230 }
12231 }
12232
12233 addr = section->sh_addr;
0e602686 12234 bytes = section_size;
cf13d699
NC		 12235 data = start;
12236
12237 while (bytes)
12238 {
12239 int j;
12240 int k;
12241 int lbytes;
12242
12243 lbytes = (bytes > 16 ? 16 : bytes);
12244
12245 printf (" 0x%8.8lx ", (unsigned long) addr);
12246
12247 for (j = 0; j < 16; j++)
12248 {
12249 if (j < lbytes)
12250 printf ("%2.2x", data[j]);
12251 else
12252 printf (" ");
12253
12254 if ((j & 3) == 3)
12255 printf (" ");
12256 }
12257
12258 for (j = 0; j < lbytes; j++)
12259 {
12260 k = data[j];
12261 if (k >= ' ' && k < 0x7f)
12262 printf ("%c", k);
12263 else
12264 printf (".");
12265 }
12266
12267 putchar ('\n');
12268
12269 data += lbytes;
12270 addr += lbytes;
12271 bytes -= lbytes;
12272 }
12273
0e602686 12274 free (real_start);
cf13d699
NC		 12275
12276 putchar ('\n');
12277}
12278
d966045b
DJ		 12279static int
12280load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12281 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12282{
2cf0635d 12283 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12284 char buf [64];
1007acb3 12285
19e6b90e
L		 12286 /* If it is already loaded, do nothing. */
12287 if (section->start != NULL)
12288 return 1;
1007acb3 12289
19e6b90e
L		 12290 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12291 section->address = sec->sh_addr;
06614111 12292 section->user_data = NULL;
3f5e193b
NC		 12293 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12294 sec->sh_offset, 1,
12295 sec->sh_size, buf);
59245841
NC		 12296 if (section->start == NULL)
12297 section->size = 0;
12298 else
12299 {
77115a4a
L		 12300 unsigned char *start = section->start;
12301 dwarf_size_type size = sec->sh_size;
dab394de 12302 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12303
12304 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12305 {
12306 Elf_Internal_Chdr chdr;
12307 unsigned int compression_header_size
12308 = get_compression_header (&chdr, start);
813dabb9
L		 12309 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12310 {
12311 warn (_("section '%s' has unsupported compress type: %d\n"),
12312 section->name, chdr.ch_type);
12313 return 0;
12314 }
12315 else if (chdr.ch_addralign != sec->sh_addralign)
12316 {
12317 warn (_("compressed section '%s' is corrupted\n"),
12318 section->name);
12319 return 0;
12320 }
dab394de 12321 uncompressed_size = chdr.ch_size;
77115a4a
L		 12322 start += compression_header_size;
12323 size -= compression_header_size;
12324 }
dab394de
L		 12325 else if (size > 12 && streq ((char *) start, "ZLIB"))
12326 {
12327 /* Read the zlib header. In this case, it should be "ZLIB"
12328 followed by the uncompressed section size, 8 bytes in
12329 big-endian order. */
12330 uncompressed_size = start[4]; uncompressed_size <<= 8;
12331 uncompressed_size += start[5]; uncompressed_size <<= 8;
12332 uncompressed_size += start[6]; uncompressed_size <<= 8;
12333 uncompressed_size += start[7]; uncompressed_size <<= 8;
12334 uncompressed_size += start[8]; uncompressed_size <<= 8;
12335 uncompressed_size += start[9]; uncompressed_size <<= 8;
12336 uncompressed_size += start[10]; uncompressed_size <<= 8;
12337 uncompressed_size += start[11];
12338 start += 12;
12339 size -= 12;
12340 }
12341
12342 if (uncompressed_size
12343 && uncompress_section_contents (&start, uncompressed_size,
12344 &size))
77115a4a
L		 12345 {
12346 /* Free the compressed buffer, update the section buffer
12347 and the section size if uncompress is successful. */
12348 free (section->start);
12349 section->start = start;
77115a4a
L		 12350 }
12351 section->size = size;
59245841 12352 }
4a114e3e 12353
1b315056
CS		 12354 if (section->start == NULL)
12355 return 0;
12356
19e6b90e 12357 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12358 apply_relocations ((FILE *) file, sec, section->start, section->size,
12359 & section->reloc_info, & section->num_relocs);
12360 else
12361 {
12362 section->reloc_info = NULL;
12363 section->num_relocs = 0;
12364 }
1007acb3 12365
1b315056 12366 return 1;
1007acb3
L		 12367}
12368
657d0d47
CC		 12369/* If this is not NULL, load_debug_section will only look for sections
12370 within the list of sections given here. */
12371unsigned int *section_subset = NULL;
12372
d966045b 12373int
2cf0635d 12374load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12375{
2cf0635d
NC		 12376 struct dwarf_section * section = &debug_displays [debug].section;
12377 Elf_Internal_Shdr * sec;
d966045b
DJ		 12378
12379 /* Locate the debug section. */
657d0d47 12380 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12381 if (sec != NULL)
12382 section->name = section->uncompressed_name;
12383 else
12384 {
657d0d47 12385 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12386 if (sec != NULL)
12387 section->name = section->compressed_name;
12388 }
12389 if (sec == NULL)
12390 return 0;
12391
657d0d47
CC		 12392 /* If we're loading from a subset of sections, and we've loaded
12393 a section matching this name before, it's likely that it's a
12394 different one. */
12395 if (section_subset != NULL)
12396 free_debug_section (debug);
12397
3f5e193b 12398 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12399}
12400
19e6b90e
L		 12401void
12402free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12403{
2cf0635d 12404 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12405
19e6b90e
L		 12406 if (section->start == NULL)
12407 return;
1007acb3 12408
19e6b90e
L		 12409 free ((char *) section->start);
12410 section->start = NULL;
12411 section->address = 0;
12412 section->size = 0;
1007acb3
L		 12413}
12414
1007acb3 12415static int
657d0d47 12416display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12417{
2cf0635d 12418 char * name = SECTION_NAME (section);
74e1a04b 12419 const char * print_name = printable_section_name (section);
19e6b90e
L		 12420 bfd_size_type length;
12421 int result = 1;
3f5e193b 12422 int i;
1007acb3 12423
19e6b90e
L		 12424 length = section->sh_size;
12425 if (length == 0)
1007acb3 12426 {
74e1a04b 12427 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12428 return 0;
1007acb3 12429 }
5dff79d8
NC		 12430 if (section->sh_type == SHT_NOBITS)
12431 {
12432 /* There is no point in dumping the contents of a debugging section
12433 which has the NOBITS type - the bits in the file will be random.
12434 This can happen when a file containing a .eh_frame section is
12435 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12436 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12437 print_name);
5dff79d8
NC		 12438 return 0;
12439 }
1007acb3 12440
0112cd26 12441 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12442 name = ".debug_info";
1007acb3 12443
19e6b90e
L		 12444 /* See if we know how to display the contents of this section. */
12445 for (i = 0; i < max; i++)
1b315056 12446 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12447 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12448 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12449 {
2cf0635d 12450 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12451 int secondary = (section != find_section (name));
12452
12453 if (secondary)
3f5e193b 12454 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12455
b40bf0a2
NC		 12456 if (i == line && const_strneq (name, ".debug_line."))
12457 sec->name = name;
12458 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12459 sec->name = sec->uncompressed_name;
12460 else
12461 sec->name = sec->compressed_name;
3f5e193b
NC		 12462 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12463 section, file))
19e6b90e 12464 {
657d0d47
CC		 12465 /* If this debug section is part of a CU/TU set in a .dwp file,
12466 restrict load_debug_section to the sections in that set. */
12467 section_subset = find_cu_tu_set (file, shndx);
12468
19e6b90e 12469 result &= debug_displays[i].display (sec, file);
1007acb3 12470
657d0d47
CC		 12471 section_subset = NULL;
12472
d966045b 12473 if (secondary || (i != info && i != abbrev))
3f5e193b 12474 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12475 }
1007acb3 12476
19e6b90e
L		 12477 break;
12478 }
1007acb3 12479
19e6b90e 12480 if (i == max)
1007acb3 12481 {
74e1a04b 12482 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12483 result = 0;
1007acb3
L		 12484 }
12485
19e6b90e 12486 return result;
5b18a4bc 12487}
103f02d3 12488
aef1f6d0
DJ		 12489/* Set DUMP_SECTS for all sections where dumps were requested
12490 based on section name. */
12491
12492static void
12493initialise_dumps_byname (void)
12494{
2cf0635d 12495 struct dump_list_entry * cur;
aef1f6d0
DJ		 12496
12497 for (cur = dump_sects_byname; cur; cur = cur->next)
12498 {
12499 unsigned int i;
12500 int any;
12501
12502 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12503 if (streq (SECTION_NAME (section_headers + i), cur->name))
12504 {
09c11c86 12505 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12506 any = 1;
12507 }
12508
12509 if (!any)
12510 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12511 cur->name);
12512 }
12513}
12514
5b18a4bc 12515static void
2cf0635d 12516process_section_contents (FILE * file)
5b18a4bc 12517{
2cf0635d 12518 Elf_Internal_Shdr * section;
19e6b90e 12519 unsigned int i;
103f02d3 12520
19e6b90e
L		 12521 if (! do_dump)
12522 return;
103f02d3 12523
aef1f6d0
DJ		 12524 initialise_dumps_byname ();
12525
19e6b90e
L		 12526 for (i = 0, section = section_headers;
12527 i < elf_header.e_shnum && i < num_dump_sects;
12528 i++, section++)
12529 {
12530#ifdef SUPPORT_DISASSEMBLY
12531 if (dump_sects[i] & DISASS_DUMP)
12532 disassemble_section (section, file);
12533#endif
12534 if (dump_sects[i] & HEX_DUMP)
cf13d699 12535 dump_section_as_bytes (section, file, FALSE);
103f02d3 12536
cf13d699
NC		 12537 if (dump_sects[i] & RELOC_DUMP)
12538 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12539
12540 if (dump_sects[i] & STRING_DUMP)
12541 dump_section_as_strings (section, file);
cf13d699
NC		 12542
12543 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12544 display_debug_section (i, section, file);
5b18a4bc 12545 }
103f02d3 12546
19e6b90e
L		 12547 /* Check to see if the user requested a
12548 dump of a section that does not exist. */
12549 while (i++ < num_dump_sects)
12550 if (dump_sects[i])
12551 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12552}
103f02d3 12553
5b18a4bc 12554static void
19e6b90e 12555process_mips_fpe_exception (int mask)
5b18a4bc 12556{
19e6b90e
L		 12557 if (mask)
12558 {
12559 int first = 1;
12560 if (mask & OEX_FPU_INEX)
12561 fputs ("INEX", stdout), first = 0;
12562 if (mask & OEX_FPU_UFLO)
12563 printf ("%sUFLO", first ? "" : "|"), first = 0;
12564 if (mask & OEX_FPU_OFLO)
12565 printf ("%sOFLO", first ? "" : "|"), first = 0;
12566 if (mask & OEX_FPU_DIV0)
12567 printf ("%sDIV0", first ? "" : "|"), first = 0;
12568 if (mask & OEX_FPU_INVAL)
12569 printf ("%sINVAL", first ? "" : "|");
12570 }
5b18a4bc 12571 else
19e6b90e 12572 fputs ("0", stdout);
5b18a4bc 12573}
103f02d3 12574
f6f0e17b
NC		 12575/* Display's the value of TAG at location P. If TAG is
12576 greater than 0 it is assumed to be an unknown tag, and
12577 a message is printed to this effect. Otherwise it is
12578 assumed that a message has already been printed.
12579
12580 If the bottom bit of TAG is set it assumed to have a
12581 string value, otherwise it is assumed to have an integer
12582 value.
12583
12584 Returns an updated P pointing to the first unread byte
12585 beyond the end of TAG's value.
12586
12587 Reads at or beyond END will not be made. */
12588
12589static unsigned char *
12590display_tag_value (int tag,
12591 unsigned char * p,
12592 const unsigned char * const end)
12593{
12594 unsigned long val;
12595
12596 if (tag > 0)
12597 printf (" Tag_unknown_%d: ", tag);
12598
12599 if (p >= end)
12600 {
4082ef84 12601 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12602 }
12603 else if (tag & 1)
12604 {
071436c6
NC		 12605 /* PR 17531 file: 027-19978-0.004. */
12606 size_t maxlen = (end - p) - 1;
12607
12608 putchar ('"');
4082ef84
NC		 12609 if (maxlen > 0)
12610 {
12611 print_symbol ((int) maxlen, (const char *) p);
12612 p += strnlen ((char *) p, maxlen) + 1;
12613 }
12614 else
12615 {
12616 printf (_("<corrupt string tag>"));
12617 p = (unsigned char *) end;
12618 }
071436c6 12619 printf ("\"\n");
f6f0e17b
NC		 12620 }
12621 else
12622 {
12623 unsigned int len;
12624
12625 val = read_uleb128 (p, &len, end);
12626 p += len;
12627 printf ("%ld (0x%lx)\n", val, val);
12628 }
12629
4082ef84 12630 assert (p <= end);
f6f0e17b
NC		 12631 return p;
12632}
12633
11c1ff18
PB		 12634/* ARM EABI attributes section. */
12635typedef struct
12636{
70e99720 12637 unsigned int tag;
2cf0635d 12638 const char * name;
11c1ff18 12639 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12640 unsigned int type;
2cf0635d 12641 const char ** table;
11c1ff18
PB		 12642} arm_attr_public_tag;
12643
2cf0635d 12644static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12645 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12646 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12647static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12648static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12649 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12650static const char * arm_attr_tag_FP_arch[] =
bca38921 12651 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12652 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12653static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12654static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12655 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12656static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12657 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12658 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12659static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12660 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12661static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12662 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12663static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12664 {"Absolute", "PC-relative", "None"};
2cf0635d 12665static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12666 {"None", "direct", "GOT-indirect"};
2cf0635d 12667static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12668 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12669static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12670static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12671 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12672static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12673static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12674static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12675 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12676static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12677 {"Unused", "small", "int", "forced to int"};
2cf0635d 12678static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12679 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12680static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12681 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12682static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12683 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12684static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12685 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12686 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12687static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12688 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12689 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12690static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12691static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12692 {"Not Allowed", "Allowed"};
2cf0635d 12693static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12694 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12695static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12696 {"Not Allowed", "Allowed"};
12697static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12698 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12699 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12700static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12701static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12702 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12703 "TrustZone and Virtualization Extensions"};
dd24e3da 12704static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12705 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12706
12707#define LOOKUP(id, name) \
12708 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12709static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12710{
12711 {4, "CPU_raw_name", 1, NULL},
12712 {5, "CPU_name", 1, NULL},
12713 LOOKUP(6, CPU_arch),
12714 {7, "CPU_arch_profile", 0, NULL},
12715 LOOKUP(8, ARM_ISA_use),
12716 LOOKUP(9, THUMB_ISA_use),
75375b3e 12717 LOOKUP(10, FP_arch),
11c1ff18 12718 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12719 LOOKUP(12, Advanced_SIMD_arch),
12720 LOOKUP(13, PCS_config),
11c1ff18
PB		 12721 LOOKUP(14, ABI_PCS_R9_use),
12722 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12723 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12724 LOOKUP(17, ABI_PCS_GOT_use),
12725 LOOKUP(18, ABI_PCS_wchar_t),
12726 LOOKUP(19, ABI_FP_rounding),
12727 LOOKUP(20, ABI_FP_denormal),
12728 LOOKUP(21, ABI_FP_exceptions),
12729 LOOKUP(22, ABI_FP_user_exceptions),
12730 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12731 {24, "ABI_align_needed", 0, NULL},
12732 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12733 LOOKUP(26, ABI_enum_size),
12734 LOOKUP(27, ABI_HardFP_use),
12735 LOOKUP(28, ABI_VFP_args),
12736 LOOKUP(29, ABI_WMMX_args),
12737 LOOKUP(30, ABI_optimization_goals),
12738 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12739 {32, "compatibility", 0, NULL},
f5f53991 12740 LOOKUP(34, CPU_unaligned_access),
75375b3e 12741 LOOKUP(36, FP_HP_extension),
8e79c3df 12742 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12743 LOOKUP(42, MPextension_use),
12744 LOOKUP(44, DIV_use),
f5f53991
AS		 12745 {64, "nodefaults", 0, NULL},
12746 {65, "also_compatible_with", 0, NULL},
12747 LOOKUP(66, T2EE_use),
12748 {67, "conformance", 1, NULL},
12749 LOOKUP(68, Virtualization_use),
cd21e546 12750 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12751};
12752#undef LOOKUP
12753
11c1ff18 12754static unsigned char *
f6f0e17b
NC		 12755display_arm_attribute (unsigned char * p,
12756 const unsigned char * const end)
11c1ff18 12757{
70e99720 12758 unsigned int tag;
11c1ff18 12759 unsigned int len;
70e99720 12760 unsigned int val;
2cf0635d 12761 arm_attr_public_tag * attr;
11c1ff18 12762 unsigned i;
70e99720 12763 unsigned int type;
11c1ff18 12764
f6f0e17b 12765 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12766 p += len;
12767 attr = NULL;
2cf0635d 12768 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12769 {
12770 if (arm_attr_public_tags[i].tag == tag)
12771 {
12772 attr = &arm_attr_public_tags[i];
12773 break;
12774 }
12775 }
12776
12777 if (attr)
12778 {
12779 printf (" Tag_%s: ", attr->name);
12780 switch (attr->type)
12781 {
12782 case 0:
12783 switch (tag)
12784 {
12785 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12786 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12787 p += len;
12788 switch (val)
12789 {
2b692964
NC		 12790 case 0: printf (_("None\n")); break;
12791 case 'A': printf (_("Application\n")); break;
12792 case 'R': printf (_("Realtime\n")); break;
12793 case 'M': printf (_("Microcontroller\n")); break;
12794 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12795 default: printf ("??? (%d)\n", val); break;
12796 }
12797 break;
12798
75375b3e 12799 case 24: /* Tag_align_needed. */
f6f0e17b 12800 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12801 p += len;
12802 switch (val)
12803 {
2b692964
NC		 12804 case 0: printf (_("None\n")); break;
12805 case 1: printf (_("8-byte\n")); break;
12806 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12807 case 3: printf ("??? 3\n"); break;
12808 default:
12809 if (val <= 12)
dd24e3da 12810 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12811 1 << val);
12812 else
12813 printf ("??? (%d)\n", val);
12814 break;
12815 }
12816 break;
12817
12818 case 25: /* Tag_align_preserved. */
f6f0e17b 12819 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12820 p += len;
12821 switch (val)
12822 {
2b692964
NC		 12823 case 0: printf (_("None\n")); break;
12824 case 1: printf (_("8-byte, except leaf SP\n")); break;
12825 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12826 case 3: printf ("??? 3\n"); break;
12827 default:
12828 if (val <= 12)
dd24e3da 12829 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12830 1 << val);
12831 else
12832 printf ("??? (%d)\n", val);
12833 break;
12834 }
12835 break;
12836
11c1ff18 12837 case 32: /* Tag_compatibility. */
071436c6 12838 {
071436c6
NC		 12839 val = read_uleb128 (p, &len, end);
12840 p += len;
071436c6 12841 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12842 if (p < end - 1)
12843 {
12844 size_t maxlen = (end - p) - 1;
12845
12846 print_symbol ((int) maxlen, (const char *) p);
12847 p += strnlen ((char *) p, maxlen) + 1;
12848 }
12849 else
12850 {
12851 printf (_("<corrupt>"));
12852 p = (unsigned char *) end;
12853 }
071436c6 12854 putchar ('\n');
071436c6 12855 }
11c1ff18
PB		 12856 break;
12857
f5f53991 12858 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12859 /* PR 17531: file: 001-505008-0.01. */
12860 if (p < end)
12861 p++;
2b692964 12862 printf (_("True\n"));
f5f53991
AS		 12863 break;
12864
12865 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12866 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12867 p += len;
12868 if (val == 6 /* Tag_CPU_arch. */)
12869 {
f6f0e17b 12870 val = read_uleb128 (p, &len, end);
f5f53991 12871 p += len;
071436c6 12872 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12873 printf ("??? (%d)\n", val);
12874 else
12875 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12876 }
12877 else
12878 printf ("???\n");
071436c6
NC		 12879 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12880 ;
f5f53991
AS		 12881 break;
12882
11c1ff18 12883 default:
bee0ee85
NC		 12884 printf (_("<unknown: %d>\n"), tag);
12885 break;
11c1ff18
PB		 12886 }
12887 return p;
12888
12889 case 1:
f6f0e17b 12890 return display_tag_value (-1, p, end);
11c1ff18 12891 case 2:
f6f0e17b 12892 return display_tag_value (0, p, end);
11c1ff18
PB		 12893
12894 default:
12895 assert (attr->type & 0x80);
f6f0e17b 12896 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12897 p += len;
12898 type = attr->type & 0x7f;
12899 if (val >= type)
12900 printf ("??? (%d)\n", val);
12901 else
12902 printf ("%s\n", attr->table[val]);
12903 return p;
12904 }
12905 }
11c1ff18 12906
f6f0e17b 12907 return display_tag_value (tag, p, end);
11c1ff18
PB		 12908}
12909
104d59d1 12910static unsigned char *
60bca95a 12911display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12912 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12913 const unsigned char * const end)
104d59d1
JM		 12914{
12915 int tag;
12916 unsigned int len;
12917 int val;
104d59d1 12918
f6f0e17b 12919 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12920 p += len;
12921
12922 /* Tag_compatibility is the only generic GNU attribute defined at
12923 present. */
12924 if (tag == 32)
12925 {
f6f0e17b 12926 val = read_uleb128 (p, &len, end);
104d59d1 12927 p += len;
071436c6
NC		 12928
12929 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12930 if (p == end)
12931 {
071436c6 12932 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12933 warn (_("corrupt vendor attribute\n"));
12934 }
12935 else
12936 {
4082ef84
NC		 12937 if (p < end - 1)
12938 {
12939 size_t maxlen = (end - p) - 1;
071436c6 12940
4082ef84
NC		 12941 print_symbol ((int) maxlen, (const char *) p);
12942 p += strnlen ((char *) p, maxlen) + 1;
12943 }
12944 else
12945 {
12946 printf (_("<corrupt>"));
12947 p = (unsigned char *) end;
12948 }
071436c6 12949 putchar ('\n');
f6f0e17b 12950 }
104d59d1
JM		 12951 return p;
12952 }
12953
12954 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12955 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12956
f6f0e17b 12957 return display_tag_value (tag, p, end);
104d59d1
JM		 12958}
12959
34c8bcba 12960static unsigned char *
f6f0e17b
NC		 12961display_power_gnu_attribute (unsigned char * p,
12962 int tag,
12963 const unsigned char * const end)
34c8bcba 12964{
34c8bcba
JM		 12965 unsigned int len;
12966 int val;
12967
12968 if (tag == Tag_GNU_Power_ABI_FP)
12969 {
f6f0e17b 12970 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12971 p += len;
12972 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12973
34c8bcba
JM		 12974 switch (val)
12975 {
12976 case 0:
2b692964 12977 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12978 break;
12979 case 1:
2b692964 12980 printf (_("Hard float\n"));
34c8bcba
JM		 12981 break;
12982 case 2:
2b692964 12983 printf (_("Soft float\n"));
34c8bcba 12984 break;
3c7b9897 12985 case 3:
2b692964 12986 printf (_("Single-precision hard float\n"));
3c7b9897 12987 break;
34c8bcba
JM		 12988 default:
12989 printf ("??? (%d)\n", val);
12990 break;
12991 }
12992 return p;
12993 }
12994
c6e65352
DJ		 12995 if (tag == Tag_GNU_Power_ABI_Vector)
12996 {
f6f0e17b 12997 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12998 p += len;
12999 printf (" Tag_GNU_Power_ABI_Vector: ");
13000 switch (val)
13001 {
13002 case 0:
2b692964 13003 printf (_("Any\n"));
c6e65352
DJ		 13004 break;
13005 case 1:
2b692964 13006 printf (_("Generic\n"));
c6e65352
DJ		 13007 break;
13008 case 2:
13009 printf ("AltiVec\n");
13010 break;
13011 case 3:
13012 printf ("SPE\n");
13013 break;
13014 default:
13015 printf ("??? (%d)\n", val);
13016 break;
13017 }
13018 return p;
13019 }
13020
f82e0623
NF		 13021 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13022 {
f6f0e17b
NC		 13023 if (p == end)
13024 {
071436c6 13025 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13026 return p;
13027 }
0b4362b0 13028
f6f0e17b 13029 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13030 p += len;
13031 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13032 switch (val)
13033 {
13034 case 0:
2b692964 13035 printf (_("Any\n"));
f82e0623
NF		 13036 break;
13037 case 1:
13038 printf ("r3/r4\n");
13039 break;
13040 case 2:
2b692964 13041 printf (_("Memory\n"));
f82e0623
NF		 13042 break;
13043 default:
13044 printf ("??? (%d)\n", val);
13045 break;
13046 }
13047 return p;
13048 }
13049
f6f0e17b 13050 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13051}
13052
643f7afb
AK		 13053static unsigned char *
13054display_s390_gnu_attribute (unsigned char * p,
13055 int tag,
13056 const unsigned char * const end)
13057{
13058 unsigned int len;
13059 int val;
13060
13061 if (tag == Tag_GNU_S390_ABI_Vector)
13062 {
13063 val = read_uleb128 (p, &len, end);
13064 p += len;
13065 printf (" Tag_GNU_S390_ABI_Vector: ");
13066
13067 switch (val)
13068 {
13069 case 0:
13070 printf (_("any\n"));
13071 break;
13072 case 1:
13073 printf (_("software\n"));
13074 break;
13075 case 2:
13076 printf (_("hardware\n"));
13077 break;
13078 default:
13079 printf ("??? (%d)\n", val);
13080 break;
13081 }
13082 return p;
13083 }
13084
13085 return display_tag_value (tag & 1, p, end);
13086}
13087
9e8c70f9
DM		 13088static void
13089display_sparc_hwcaps (int mask)
13090{
13091 if (mask)
13092 {
13093 int first = 1;
071436c6 13094
9e8c70f9
DM		 13095 if (mask & ELF_SPARC_HWCAP_MUL32)
13096 fputs ("mul32", stdout), first = 0;
13097 if (mask & ELF_SPARC_HWCAP_DIV32)
13098 printf ("%sdiv32", first ? "" : "|"), first = 0;
13099 if (mask & ELF_SPARC_HWCAP_FSMULD)
13100 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13101 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13102 printf ("%sv8plus", first ? "" : "|"), first = 0;
13103 if (mask & ELF_SPARC_HWCAP_POPC)
13104 printf ("%spopc", first ? "" : "|"), first = 0;
13105 if (mask & ELF_SPARC_HWCAP_VIS)
13106 printf ("%svis", first ? "" : "|"), first = 0;
13107 if (mask & ELF_SPARC_HWCAP_VIS2)
13108 printf ("%svis2", first ? "" : "|"), first = 0;
13109 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13110 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13111 if (mask & ELF_SPARC_HWCAP_FMAF)
13112 printf ("%sfmaf", first ? "" : "|"), first = 0;
13113 if (mask & ELF_SPARC_HWCAP_VIS3)
13114 printf ("%svis3", first ? "" : "|"), first = 0;
13115 if (mask & ELF_SPARC_HWCAP_HPC)
13116 printf ("%shpc", first ? "" : "|"), first = 0;
13117 if (mask & ELF_SPARC_HWCAP_RANDOM)
13118 printf ("%srandom", first ? "" : "|"), first = 0;
13119 if (mask & ELF_SPARC_HWCAP_TRANS)
13120 printf ("%strans", first ? "" : "|"), first = 0;
13121 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13122 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13123 if (mask & ELF_SPARC_HWCAP_IMA)
13124 printf ("%sima", first ? "" : "|"), first = 0;
13125 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13126 printf ("%scspare", first ? "" : "|"), first = 0;
13127 }
13128 else
071436c6
NC		 13129 fputc ('0', stdout);
13130 fputc ('\n', stdout);
9e8c70f9
DM		 13131}
13132
3d68f91c
JM		 13133static void
13134display_sparc_hwcaps2 (int mask)
13135{
13136 if (mask)
13137 {
13138 int first = 1;
071436c6 13139
3d68f91c
JM		 13140 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13141 fputs ("fjathplus", stdout), first = 0;
13142 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13143 printf ("%svis3b", first ? "" : "|"), first = 0;
13144 if (mask & ELF_SPARC_HWCAP2_ADP)
13145 printf ("%sadp", first ? "" : "|"), first = 0;
13146 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13147 printf ("%ssparc5", first ? "" : "|"), first = 0;
13148 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13149 printf ("%smwait", first ? "" : "|"), first = 0;
13150 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13151 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13152 if (mask & ELF_SPARC_HWCAP2_XMONT)
13153 printf ("%sxmont2", first ? "" : "|"), first = 0;
13154 if (mask & ELF_SPARC_HWCAP2_NSEC)
13155 printf ("%snsec", first ? "" : "|"), first = 0;
13156 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13157 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13158 if (mask & ELF_SPARC_HWCAP2_FJDES)
13159 printf ("%sfjdes", first ? "" : "|"), first = 0;
13160 if (mask & ELF_SPARC_HWCAP2_FJAES)
13161 printf ("%sfjaes", first ? "" : "|"), first = 0;
13162 }
13163 else
071436c6
NC		 13164 fputc ('0', stdout);
13165 fputc ('\n', stdout);
3d68f91c
JM		 13166}
13167
9e8c70f9 13168static unsigned char *
f6f0e17b
NC		 13169display_sparc_gnu_attribute (unsigned char * p,
13170 int tag,
13171 const unsigned char * const end)
9e8c70f9 13172{
3d68f91c
JM		 13173 unsigned int len;
13174 int val;
13175
9e8c70f9
DM		 13176 if (tag == Tag_GNU_Sparc_HWCAPS)
13177 {
f6f0e17b 13178 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13179 p += len;
13180 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13181 display_sparc_hwcaps (val);
13182 return p;
3d68f91c
JM		 13183 }
13184 if (tag == Tag_GNU_Sparc_HWCAPS2)
13185 {
13186 val = read_uleb128 (p, &len, end);
13187 p += len;
13188 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13189 display_sparc_hwcaps2 (val);
13190 return p;
13191 }
9e8c70f9 13192
f6f0e17b 13193 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13194}
13195
351cdf24
MF		 13196static void
13197print_mips_fp_abi_value (int val)
13198{
13199 switch (val)
13200 {
13201 case Val_GNU_MIPS_ABI_FP_ANY:
13202 printf (_("Hard or soft float\n"));
13203 break;
13204 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13205 printf (_("Hard float (double precision)\n"));
13206 break;
13207 case Val_GNU_MIPS_ABI_FP_SINGLE:
13208 printf (_("Hard float (single precision)\n"));
13209 break;
13210 case Val_GNU_MIPS_ABI_FP_SOFT:
13211 printf (_("Soft float\n"));
13212 break;
13213 case Val_GNU_MIPS_ABI_FP_OLD_64:
13214 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13215 break;
13216 case Val_GNU_MIPS_ABI_FP_XX:
13217 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13218 break;
13219 case Val_GNU_MIPS_ABI_FP_64:
13220 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13221 break;
13222 case Val_GNU_MIPS_ABI_FP_64A:
13223 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13224 break;
3350cc01
CM		 13225 case Val_GNU_MIPS_ABI_FP_NAN2008:
13226 printf (_("NaN 2008 compatibility\n"));
13227 break;
351cdf24
MF		 13228 default:
13229 printf ("??? (%d)\n", val);
13230 break;
13231 }
13232}
13233
2cf19d5c 13234static unsigned char *
f6f0e17b
NC		 13235display_mips_gnu_attribute (unsigned char * p,
13236 int tag,
13237 const unsigned char * const end)
2cf19d5c 13238{
2cf19d5c
JM		 13239 if (tag == Tag_GNU_MIPS_ABI_FP)
13240 {
f6f0e17b
NC		 13241 unsigned int len;
13242 int val;
13243
13244 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13245 p += len;
13246 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13247
351cdf24
MF		 13248 print_mips_fp_abi_value (val);
13249
2cf19d5c
JM		 13250 return p;
13251 }
13252
a9f58168
CF		 13253 if (tag == Tag_GNU_MIPS_ABI_MSA)
13254 {
13255 unsigned int len;
13256 int val;
13257
13258 val = read_uleb128 (p, &len, end);
13259 p += len;
13260 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13261
13262 switch (val)
13263 {
13264 case Val_GNU_MIPS_ABI_MSA_ANY:
13265 printf (_("Any MSA or not\n"));
13266 break;
13267 case Val_GNU_MIPS_ABI_MSA_128:
13268 printf (_("128-bit MSA\n"));
13269 break;
13270 default:
13271 printf ("??? (%d)\n", val);
13272 break;
13273 }
13274 return p;
13275 }
13276
f6f0e17b 13277 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13278}
13279
59e6276b 13280static unsigned char *
f6f0e17b
NC		 13281display_tic6x_attribute (unsigned char * p,
13282 const unsigned char * const end)
59e6276b
JM		 13283{
13284 int tag;
13285 unsigned int len;
13286 int val;
13287
f6f0e17b 13288 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13289 p += len;
13290
13291 switch (tag)
13292 {
75fa6dc1 13293 case Tag_ISA:
f6f0e17b 13294 val = read_uleb128 (p, &len, end);
59e6276b 13295 p += len;
75fa6dc1 13296 printf (" Tag_ISA: ");
59e6276b
JM		 13297
13298 switch (val)
13299 {
75fa6dc1 13300 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13301 printf (_("None\n"));
13302 break;
75fa6dc1 13303 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13304 printf ("C62x\n");
13305 break;
75fa6dc1 13306 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13307 printf ("C67x\n");
13308 break;
75fa6dc1 13309 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13310 printf ("C67x+\n");
13311 break;
75fa6dc1 13312 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13313 printf ("C64x\n");
13314 break;
75fa6dc1 13315 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13316 printf ("C64x+\n");
13317 break;
75fa6dc1 13318 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13319 printf ("C674x\n");
13320 break;
13321 default:
13322 printf ("??? (%d)\n", val);
13323 break;
13324 }
13325 return p;
13326
87779176 13327 case Tag_ABI_wchar_t:
f6f0e17b 13328 val = read_uleb128 (p, &len, end);
87779176
JM		 13329 p += len;
13330 printf (" Tag_ABI_wchar_t: ");
13331 switch (val)
13332 {
13333 case 0:
13334 printf (_("Not used\n"));
13335 break;
13336 case 1:
13337 printf (_("2 bytes\n"));
13338 break;
13339 case 2:
13340 printf (_("4 bytes\n"));
13341 break;
13342 default:
13343 printf ("??? (%d)\n", val);
13344 break;
13345 }
13346 return p;
13347
13348 case Tag_ABI_stack_align_needed:
f6f0e17b 13349 val = read_uleb128 (p, &len, end);
87779176
JM		 13350 p += len;
13351 printf (" Tag_ABI_stack_align_needed: ");
13352 switch (val)
13353 {
13354 case 0:
13355 printf (_("8-byte\n"));
13356 break;
13357 case 1:
13358 printf (_("16-byte\n"));
13359 break;
13360 default:
13361 printf ("??? (%d)\n", val);
13362 break;
13363 }
13364 return p;
13365
13366 case Tag_ABI_stack_align_preserved:
f6f0e17b 13367 val = read_uleb128 (p, &len, end);
87779176
JM		 13368 p += len;
13369 printf (" Tag_ABI_stack_align_preserved: ");
13370 switch (val)
13371 {
13372 case 0:
13373 printf (_("8-byte\n"));
13374 break;
13375 case 1:
13376 printf (_("16-byte\n"));
13377 break;
13378 default:
13379 printf ("??? (%d)\n", val);
13380 break;
13381 }
13382 return p;
13383
b5593623 13384 case Tag_ABI_DSBT:
f6f0e17b 13385 val = read_uleb128 (p, &len, end);
b5593623
JM		 13386 p += len;
13387 printf (" Tag_ABI_DSBT: ");
13388 switch (val)
13389 {
13390 case 0:
13391 printf (_("DSBT addressing not used\n"));
13392 break;
13393 case 1:
13394 printf (_("DSBT addressing used\n"));
13395 break;
13396 default:
13397 printf ("??? (%d)\n", val);
13398 break;
13399 }
13400 return p;
13401
87779176 13402 case Tag_ABI_PID:
f6f0e17b 13403 val = read_uleb128 (p, &len, end);
87779176
JM		 13404 p += len;
13405 printf (" Tag_ABI_PID: ");
13406 switch (val)
13407 {
13408 case 0:
13409 printf (_("Data addressing position-dependent\n"));
13410 break;
13411 case 1:
13412 printf (_("Data addressing position-independent, GOT near DP\n"));
13413 break;
13414 case 2:
13415 printf (_("Data addressing position-independent, GOT far from DP\n"));
13416 break;
13417 default:
13418 printf ("??? (%d)\n", val);
13419 break;
13420 }
13421 return p;
13422
13423 case Tag_ABI_PIC:
f6f0e17b 13424 val = read_uleb128 (p, &len, end);
87779176
JM		 13425 p += len;
13426 printf (" Tag_ABI_PIC: ");
13427 switch (val)
13428 {
13429 case 0:
13430 printf (_("Code addressing position-dependent\n"));
13431 break;
13432 case 1:
13433 printf (_("Code addressing position-independent\n"));
13434 break;
13435 default:
13436 printf ("??? (%d)\n", val);
13437 break;
13438 }
13439 return p;
13440
13441 case Tag_ABI_array_object_alignment:
f6f0e17b 13442 val = read_uleb128 (p, &len, end);
87779176
JM		 13443 p += len;
13444 printf (" Tag_ABI_array_object_alignment: ");
13445 switch (val)
13446 {
13447 case 0:
13448 printf (_("8-byte\n"));
13449 break;
13450 case 1:
13451 printf (_("4-byte\n"));
13452 break;
13453 case 2:
13454 printf (_("16-byte\n"));
13455 break;
13456 default:
13457 printf ("??? (%d)\n", val);
13458 break;
13459 }
13460 return p;
13461
13462 case Tag_ABI_array_object_align_expected:
f6f0e17b 13463 val = read_uleb128 (p, &len, end);
87779176
JM		 13464 p += len;
13465 printf (" Tag_ABI_array_object_align_expected: ");
13466 switch (val)
13467 {
13468 case 0:
13469 printf (_("8-byte\n"));
13470 break;
13471 case 1:
13472 printf (_("4-byte\n"));
13473 break;
13474 case 2:
13475 printf (_("16-byte\n"));
13476 break;
13477 default:
13478 printf ("??? (%d)\n", val);
13479 break;
13480 }
13481 return p;
13482
3cbd1c06 13483 case Tag_ABI_compatibility:
071436c6 13484 {
071436c6
NC		 13485 val = read_uleb128 (p, &len, end);
13486 p += len;
13487 printf (" Tag_ABI_compatibility: ");
071436c6 13488 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13489 if (p < end - 1)
13490 {
13491 size_t maxlen = (end - p) - 1;
13492
13493 print_symbol ((int) maxlen, (const char *) p);
13494 p += strnlen ((char *) p, maxlen) + 1;
13495 }
13496 else
13497 {
13498 printf (_("<corrupt>"));
13499 p = (unsigned char *) end;
13500 }
071436c6 13501 putchar ('\n');
071436c6
NC		 13502 return p;
13503 }
87779176
JM		 13504
13505 case Tag_ABI_conformance:
071436c6 13506 {
4082ef84
NC		 13507 printf (" Tag_ABI_conformance: \"");
13508 if (p < end - 1)
13509 {
13510 size_t maxlen = (end - p) - 1;
071436c6 13511
4082ef84
NC		 13512 print_symbol ((int) maxlen, (const char *) p);
13513 p += strnlen ((char *) p, maxlen) + 1;
13514 }
13515 else
13516 {
13517 printf (_("<corrupt>"));
13518 p = (unsigned char *) end;
13519 }
071436c6 13520 printf ("\"\n");
071436c6
NC		 13521 return p;
13522 }
59e6276b
JM		 13523 }
13524
f6f0e17b
NC		 13525 return display_tag_value (tag, p, end);
13526}
59e6276b 13527
f6f0e17b
NC		 13528static void
13529display_raw_attribute (unsigned char * p, unsigned char * end)
13530{
13531 unsigned long addr = 0;
13532 size_t bytes = end - p;
13533
e0a31db1 13534 assert (end > p);
f6f0e17b 13535 while (bytes)
87779176 13536 {
f6f0e17b
NC		 13537 int j;
13538 int k;
13539 int lbytes = (bytes > 16 ? 16 : bytes);
13540
13541 printf (" 0x%8.8lx ", addr);
13542
13543 for (j = 0; j < 16; j++)
13544 {
13545 if (j < lbytes)
13546 printf ("%2.2x", p[j]);
13547 else
13548 printf (" ");
13549
13550 if ((j & 3) == 3)
13551 printf (" ");
13552 }
13553
13554 for (j = 0; j < lbytes; j++)
13555 {
13556 k = p[j];
13557 if (k >= ' ' && k < 0x7f)
13558 printf ("%c", k);
13559 else
13560 printf (".");
13561 }
13562
13563 putchar ('\n');
13564
13565 p += lbytes;
13566 bytes -= lbytes;
13567 addr += lbytes;
87779176 13568 }
59e6276b 13569
f6f0e17b 13570 putchar ('\n');
59e6276b
JM		 13571}
13572
13761a11
NC		 13573static unsigned char *
13574display_msp430x_attribute (unsigned char * p,
13575 const unsigned char * const end)
13576{
13577 unsigned int len;
13578 int val;
13579 int tag;
13580
13581 tag = read_uleb128 (p, & len, end);
13582 p += len;
0b4362b0 13583
13761a11
NC		 13584 switch (tag)
13585 {
13586 case OFBA_MSPABI_Tag_ISA:
13587 val = read_uleb128 (p, &len, end);
13588 p += len;
13589 printf (" Tag_ISA: ");
13590 switch (val)
13591 {
13592 case 0: printf (_("None\n")); break;
13593 case 1: printf (_("MSP430\n")); break;
13594 case 2: printf (_("MSP430X\n")); break;
13595 default: printf ("??? (%d)\n", val); break;
13596 }
13597 break;
13598
13599 case OFBA_MSPABI_Tag_Code_Model:
13600 val = read_uleb128 (p, &len, end);
13601 p += len;
13602 printf (" Tag_Code_Model: ");
13603 switch (val)
13604 {
13605 case 0: printf (_("None\n")); break;
13606 case 1: printf (_("Small\n")); break;
13607 case 2: printf (_("Large\n")); break;
13608 default: printf ("??? (%d)\n", val); break;
13609 }
13610 break;
13611
13612 case OFBA_MSPABI_Tag_Data_Model:
13613 val = read_uleb128 (p, &len, end);
13614 p += len;
13615 printf (" Tag_Data_Model: ");
13616 switch (val)
13617 {
13618 case 0: printf (_("None\n")); break;
13619 case 1: printf (_("Small\n")); break;
13620 case 2: printf (_("Large\n")); break;
13621 case 3: printf (_("Restricted Large\n")); break;
13622 default: printf ("??? (%d)\n", val); break;
13623 }
13624 break;
13625
13626 default:
13627 printf (_(" <unknown tag %d>: "), tag);
13628
13629 if (tag & 1)
13630 {
071436c6 13631 putchar ('"');
4082ef84
NC		 13632 if (p < end - 1)
13633 {
13634 size_t maxlen = (end - p) - 1;
13635
13636 print_symbol ((int) maxlen, (const char *) p);
13637 p += strnlen ((char *) p, maxlen) + 1;
13638 }
13639 else
13640 {
13641 printf (_("<corrupt>"));
13642 p = (unsigned char *) end;
13643 }
071436c6 13644 printf ("\"\n");
13761a11
NC		 13645 }
13646 else
13647 {
13648 val = read_uleb128 (p, &len, end);
13649 p += len;
13650 printf ("%d (0x%x)\n", val, val);
13651 }
13652 break;
13653 }
13654
4082ef84 13655 assert (p <= end);
13761a11
NC		 13656 return p;
13657}
13658
11c1ff18 13659static int
60bca95a
NC		 13660process_attributes (FILE * file,
13661 const char * public_name,
104d59d1 13662 unsigned int proc_type,
f6f0e17b
NC		 13663 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13664 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13665{
2cf0635d 13666 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13667 unsigned i;
13668
13669 /* Find the section header so that we get the size. */
13670 for (i = 0, sect = section_headers;
13671 i < elf_header.e_shnum;
13672 i++, sect++)
13673 {
071436c6
NC		 13674 unsigned char * contents;
13675 unsigned char * p;
13676
104d59d1 13677 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13678 continue;
13679
3f5e193b
NC		 13680 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13681 sect->sh_size, _("attributes"));
60bca95a 13682 if (contents == NULL)
11c1ff18 13683 continue;
60bca95a 13684
11c1ff18
PB		 13685 p = contents;
13686 if (*p == 'A')
13687 {
071436c6
NC		 13688 bfd_vma section_len;
13689
13690 section_len = sect->sh_size - 1;
11c1ff18 13691 p++;
60bca95a 13692
071436c6 13693 while (section_len > 0)
11c1ff18 13694 {
071436c6 13695 bfd_vma attr_len;
e9847026 13696 unsigned int namelen;
11c1ff18 13697 bfd_boolean public_section;
104d59d1 13698 bfd_boolean gnu_section;
11c1ff18 13699
071436c6 13700 if (section_len <= 4)
e0a31db1
NC		 13701 {
13702 error (_("Tag section ends prematurely\n"));
13703 break;
13704 }
071436c6 13705 attr_len = byte_get (p, 4);
11c1ff18 13706 p += 4;
60bca95a 13707
071436c6 13708 if (attr_len > section_len)
11c1ff18 13709 {
071436c6
NC		 13710 error (_("Bad attribute length (%u > %u)\n"),
13711 (unsigned) attr_len, (unsigned) section_len);
13712 attr_len = section_len;
11c1ff18 13713 }
74e1a04b 13714 /* PR 17531: file: 001-101425-0.004 */
071436c6 13715 else if (attr_len < 5)
74e1a04b 13716 {
071436c6 13717 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13718 break;
13719 }
e9847026 13720
071436c6
NC		 13721 section_len -= attr_len;
13722 attr_len -= 4;
13723
13724 namelen = strnlen ((char *) p, attr_len) + 1;
13725 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13726 {
13727 error (_("Corrupt attribute section name\n"));
13728 break;
13729 }
13730
071436c6
NC		 13731 printf (_("Attribute Section: "));
13732 print_symbol (INT_MAX, (const char *) p);
13733 putchar ('\n');
60bca95a
NC		 13734
13735 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13736 public_section = TRUE;
13737 else
13738 public_section = FALSE;
60bca95a
NC		 13739
13740 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13741 gnu_section = TRUE;
13742 else
13743 gnu_section = FALSE;
60bca95a 13744
11c1ff18 13745 p += namelen;
071436c6 13746 attr_len -= namelen;
e0a31db1 13747
071436c6 13748 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13749 {
e0a31db1 13750 int tag;
11c1ff18
PB		 13751 int val;
13752 bfd_vma size;
071436c6 13753 unsigned char * end;
60bca95a 13754
e0a31db1 13755 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13756 if (attr_len < 6)
e0a31db1
NC		 13757 {
13758 error (_("Unused bytes at end of section\n"));
13759 section_len = 0;
13760 break;
13761 }
13762
13763 tag = *(p++);
11c1ff18 13764 size = byte_get (p, 4);
071436c6 13765 if (size > attr_len)
11c1ff18 13766 {
e9847026 13767 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13768 (unsigned) size, (unsigned) attr_len);
13769 size = attr_len;
11c1ff18 13770 }
e0a31db1
NC		 13771 /* PR binutils/17531: Safe handling of corrupt files. */
13772 if (size < 6)
13773 {
13774 error (_("Bad subsection length (%u < 6)\n"),
13775 (unsigned) size);
13776 section_len = 0;
13777 break;
13778 }
60bca95a 13779
071436c6 13780 attr_len -= size;
11c1ff18 13781 end = p + size - 1;
071436c6 13782 assert (end <= contents + sect->sh_size);
11c1ff18 13783 p += 4;
60bca95a 13784
11c1ff18
PB		 13785 switch (tag)
13786 {
13787 case 1:
2b692964 13788 printf (_("File Attributes\n"));
11c1ff18
PB		 13789 break;
13790 case 2:
2b692964 13791 printf (_("Section Attributes:"));
11c1ff18
PB		 13792 goto do_numlist;
13793 case 3:
2b692964 13794 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13795 do_numlist:
13796 for (;;)
13797 {
91d6fa6a 13798 unsigned int j;
60bca95a 13799
f6f0e17b 13800 val = read_uleb128 (p, &j, end);
91d6fa6a 13801 p += j;
11c1ff18
PB		 13802 if (val == 0)
13803 break;
13804 printf (" %d", val);
13805 }
13806 printf ("\n");
13807 break;
13808 default:
2b692964 13809 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13810 public_section = FALSE;
13811 break;
13812 }
60bca95a 13813
071436c6 13814 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13815 {
13816 while (p < end)
f6f0e17b 13817 p = display_pub_attribute (p, end);
071436c6 13818 assert (p <= end);
104d59d1 13819 }
071436c6 13820 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13821 {
13822 while (p < end)
13823 p = display_gnu_attribute (p,
f6f0e17b
NC		 13824 display_proc_gnu_attribute,
13825 end);
071436c6 13826 assert (p <= end);
11c1ff18 13827 }
071436c6 13828 else if (p < end)
11c1ff18 13829 {
071436c6 13830 printf (_(" Unknown attribute:\n"));
f6f0e17b 13831 display_raw_attribute (p, end);
11c1ff18
PB		 13832 p = end;
13833 }
071436c6
NC		 13834 else
13835 attr_len = 0;
11c1ff18
PB		 13836 }
13837 }
13838 }
13839 else
e9847026 13840 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13841
60bca95a 13842 free (contents);
11c1ff18
PB		 13843 }
13844 return 1;
13845}
13846
104d59d1 13847static int
2cf0635d 13848process_arm_specific (FILE * file)
104d59d1
JM		 13849{
13850 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13851 display_arm_attribute, NULL);
13852}
13853
34c8bcba 13854static int
2cf0635d 13855process_power_specific (FILE * file)
34c8bcba
JM		 13856{
13857 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13858 display_power_gnu_attribute);
13859}
13860
643f7afb
AK		 13861static int
13862process_s390_specific (FILE * file)
13863{
13864 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13865 display_s390_gnu_attribute);
13866}
13867
9e8c70f9
DM		 13868static int
13869process_sparc_specific (FILE * file)
13870{
13871 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13872 display_sparc_gnu_attribute);
13873}
13874
59e6276b
JM		 13875static int
13876process_tic6x_specific (FILE * file)
13877{
13878 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13879 display_tic6x_attribute, NULL);
13880}
13881
13761a11
NC		 13882static int
13883process_msp430x_specific (FILE * file)
13884{
13885 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13886 display_msp430x_attribute, NULL);
13887}
13888
ccb4c951
RS		 13889/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13890 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13891 and return the VMA of the next entry, or -1 if there was a problem.
13892 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13893
13894static bfd_vma
82b1b41b
NC		 13895print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13896 unsigned char * data_end)
ccb4c951
RS		 13897{
13898 printf (" ");
13899 print_vma (addr, LONG_HEX);
13900 printf (" ");
13901 if (addr < pltgot + 0xfff0)
13902 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13903 else
13904 printf ("%10s", "");
13905 printf (" ");
13906 if (data == NULL)
2b692964 13907 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13908 else
13909 {
13910 bfd_vma entry;
82b1b41b 13911 unsigned char * from = data + addr - pltgot;
ccb4c951 13912
82b1b41b
NC		 13913 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13914 {
13915 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13916 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13917 return (bfd_vma) -1;
13918 }
13919 else
13920 {
13921 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13922 print_vma (entry, LONG_HEX);
13923 }
ccb4c951
RS		 13924 }
13925 return addr + (is_32bit_elf ? 4 : 8);
13926}
13927
861fb55a
DJ		 13928/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13929 PLTGOT. Print the Address and Initial fields of an entry at VMA
13930 ADDR and return the VMA of the next entry. */
13931
13932static bfd_vma
2cf0635d 13933print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13934{
13935 printf (" ");
13936 print_vma (addr, LONG_HEX);
13937 printf (" ");
13938 if (data == NULL)
2b692964 13939 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13940 else
13941 {
13942 bfd_vma entry;
13943
13944 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13945 print_vma (entry, LONG_HEX);
13946 }
13947 return addr + (is_32bit_elf ? 4 : 8);
13948}
13949
351cdf24
MF		 13950static void
13951print_mips_ases (unsigned int mask)
13952{
13953 if (mask & AFL_ASE_DSP)
13954 fputs ("\n\tDSP ASE", stdout);
13955 if (mask & AFL_ASE_DSPR2)
13956 fputs ("\n\tDSP R2 ASE", stdout);
13957 if (mask & AFL_ASE_EVA)
13958 fputs ("\n\tEnhanced VA Scheme", stdout);
13959 if (mask & AFL_ASE_MCU)
13960 fputs ("\n\tMCU (MicroController) ASE", stdout);
13961 if (mask & AFL_ASE_MDMX)
13962 fputs ("\n\tMDMX ASE", stdout);
13963 if (mask & AFL_ASE_MIPS3D)
13964 fputs ("\n\tMIPS-3D ASE", stdout);
13965 if (mask & AFL_ASE_MT)
13966 fputs ("\n\tMT ASE", stdout);
13967 if (mask & AFL_ASE_SMARTMIPS)
13968 fputs ("\n\tSmartMIPS ASE", stdout);
13969 if (mask & AFL_ASE_VIRT)
13970 fputs ("\n\tVZ ASE", stdout);
13971 if (mask & AFL_ASE_MSA)
13972 fputs ("\n\tMSA ASE", stdout);
13973 if (mask & AFL_ASE_MIPS16)
13974 fputs ("\n\tMIPS16 ASE", stdout);
13975 if (mask & AFL_ASE_MICROMIPS)
13976 fputs ("\n\tMICROMIPS ASE", stdout);
13977 if (mask & AFL_ASE_XPA)
13978 fputs ("\n\tXPA ASE", stdout);
13979 if (mask == 0)
13980 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13981 else if ((mask & ~AFL_ASE_MASK) != 0)
13982 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13983}
13984
13985static void
13986print_mips_isa_ext (unsigned int isa_ext)
13987{
13988 switch (isa_ext)
13989 {
13990 case 0:
13991 fputs (_("None"), stdout);
13992 break;
13993 case AFL_EXT_XLR:
13994 fputs ("RMI XLR", stdout);
13995 break;
2c629856
N		 13996 case AFL_EXT_OCTEON3:
13997 fputs ("Cavium Networks Octeon3", stdout);
13998 break;
351cdf24
MF		 13999 case AFL_EXT_OCTEON2:
14000 fputs ("Cavium Networks Octeon2", stdout);
14001 break;
14002 case AFL_EXT_OCTEONP:
14003 fputs ("Cavium Networks OcteonP", stdout);
14004 break;
14005 case AFL_EXT_LOONGSON_3A:
14006 fputs ("Loongson 3A", stdout);
14007 break;
14008 case AFL_EXT_OCTEON:
14009 fputs ("Cavium Networks Octeon", stdout);
14010 break;
14011 case AFL_EXT_5900:
14012 fputs ("Toshiba R5900", stdout);
14013 break;
14014 case AFL_EXT_4650:
14015 fputs ("MIPS R4650", stdout);
14016 break;
14017 case AFL_EXT_4010:
14018 fputs ("LSI R4010", stdout);
14019 break;
14020 case AFL_EXT_4100:
14021 fputs ("NEC VR4100", stdout);
14022 break;
14023 case AFL_EXT_3900:
14024 fputs ("Toshiba R3900", stdout);
14025 break;
14026 case AFL_EXT_10000:
14027 fputs ("MIPS R10000", stdout);
14028 break;
14029 case AFL_EXT_SB1:
14030 fputs ("Broadcom SB-1", stdout);
14031 break;
14032 case AFL_EXT_4111:
14033 fputs ("NEC VR4111/VR4181", stdout);
14034 break;
14035 case AFL_EXT_4120:
14036 fputs ("NEC VR4120", stdout);
14037 break;
14038 case AFL_EXT_5400:
14039 fputs ("NEC VR5400", stdout);
14040 break;
14041 case AFL_EXT_5500:
14042 fputs ("NEC VR5500", stdout);
14043 break;
14044 case AFL_EXT_LOONGSON_2E:
14045 fputs ("ST Microelectronics Loongson 2E", stdout);
14046 break;
14047 case AFL_EXT_LOONGSON_2F:
14048 fputs ("ST Microelectronics Loongson 2F", stdout);
14049 break;
14050 default:
00ac7aa0 14051 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14052 }
14053}
14054
14055static int
14056get_mips_reg_size (int reg_size)
14057{
14058 return (reg_size == AFL_REG_NONE) ? 0
14059 : (reg_size == AFL_REG_32) ? 32
14060 : (reg_size == AFL_REG_64) ? 64
14061 : (reg_size == AFL_REG_128) ? 128
14062 : -1;
14063}
14064
19e6b90e 14065static int
2cf0635d 14066process_mips_specific (FILE * file)
5b18a4bc 14067{
2cf0635d 14068 Elf_Internal_Dyn * entry;
351cdf24 14069 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14070 size_t liblist_offset = 0;
14071 size_t liblistno = 0;
14072 size_t conflictsno = 0;
14073 size_t options_offset = 0;
14074 size_t conflicts_offset = 0;
861fb55a
DJ		 14075 size_t pltrelsz = 0;
14076 size_t pltrel = 0;
ccb4c951 14077 bfd_vma pltgot = 0;
861fb55a
DJ		 14078 bfd_vma mips_pltgot = 0;
14079 bfd_vma jmprel = 0;
ccb4c951
RS		 14080 bfd_vma local_gotno = 0;
14081 bfd_vma gotsym = 0;
14082 bfd_vma symtabno = 0;
103f02d3 14083
2cf19d5c
JM		 14084 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14085 display_mips_gnu_attribute);
14086
351cdf24
MF		 14087 sect = find_section (".MIPS.abiflags");
14088
14089 if (sect != NULL)
14090 {
14091 Elf_External_ABIFlags_v0 *abiflags_ext;
14092 Elf_Internal_ABIFlags_v0 abiflags_in;
14093
14094 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14095 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14096 else
14097 {
14098 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14099 sect->sh_size, _("MIPS ABI Flags section"));
14100 if (abiflags_ext)
14101 {
14102 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14103 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14104 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14105 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14106 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14107 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14108 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14109 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14110 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14111 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14112 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14113
14114 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14115 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14116 if (abiflags_in.isa_rev > 1)
14117 printf ("r%d", abiflags_in.isa_rev);
14118 printf ("\nGPR size: %d",
14119 get_mips_reg_size (abiflags_in.gpr_size));
14120 printf ("\nCPR1 size: %d",
14121 get_mips_reg_size (abiflags_in.cpr1_size));
14122 printf ("\nCPR2 size: %d",
14123 get_mips_reg_size (abiflags_in.cpr2_size));
14124 fputs ("\nFP ABI: ", stdout);
14125 print_mips_fp_abi_value (abiflags_in.fp_abi);
14126 fputs ("ISA Extension: ", stdout);
14127 print_mips_isa_ext (abiflags_in.isa_ext);
14128 fputs ("\nASEs:", stdout);
14129 print_mips_ases (abiflags_in.ases);
14130 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14131 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14132 fputc ('\n', stdout);
14133 free (abiflags_ext);
14134 }
14135 }
14136 }
14137
19e6b90e
L		 14138 /* We have a lot of special sections. Thanks SGI! */
14139 if (dynamic_section == NULL)
14140 /* No information available. */
14141 return 0;
252b5132 14142
071436c6
NC		 14143 for (entry = dynamic_section;
14144 /* PR 17531 file: 012-50589-0.004. */
14145 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14146 ++entry)
252b5132
RH		 14147 switch (entry->d_tag)
14148 {
14149 case DT_MIPS_LIBLIST:
d93f0186
NC		 14150 liblist_offset
14151 = offset_from_vma (file, entry->d_un.d_val,
14152 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14153 break;
14154 case DT_MIPS_LIBLISTNO:
14155 liblistno = entry->d_un.d_val;
14156 break;
14157 case DT_MIPS_OPTIONS:
d93f0186 14158 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14159 break;
14160 case DT_MIPS_CONFLICT:
d93f0186
NC		 14161 conflicts_offset
14162 = offset_from_vma (file, entry->d_un.d_val,
14163 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14164 break;
14165 case DT_MIPS_CONFLICTNO:
14166 conflictsno = entry->d_un.d_val;
14167 break;
ccb4c951 14168 case DT_PLTGOT:
861fb55a
DJ		 14169 pltgot = entry->d_un.d_ptr;
14170 break;
ccb4c951
RS		 14171 case DT_MIPS_LOCAL_GOTNO:
14172 local_gotno = entry->d_un.d_val;
14173 break;
14174 case DT_MIPS_GOTSYM:
14175 gotsym = entry->d_un.d_val;
14176 break;
14177 case DT_MIPS_SYMTABNO:
14178 symtabno = entry->d_un.d_val;
14179 break;
861fb55a
DJ		 14180 case DT_MIPS_PLTGOT:
14181 mips_pltgot = entry->d_un.d_ptr;
14182 break;
14183 case DT_PLTREL:
14184 pltrel = entry->d_un.d_val;
14185 break;
14186 case DT_PLTRELSZ:
14187 pltrelsz = entry->d_un.d_val;
14188 break;
14189 case DT_JMPREL:
14190 jmprel = entry->d_un.d_ptr;
14191 break;
252b5132
RH		 14192 default:
14193 break;
14194 }
14195
14196 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14197 {
2cf0635d 14198 Elf32_External_Lib * elib;
252b5132
RH		 14199 size_t cnt;
14200
3f5e193b
NC		 14201 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14202 liblistno,
14203 sizeof (Elf32_External_Lib),
9cf03b7e 14204 _("liblist section data"));
a6e9f9df 14205 if (elib)
252b5132 14206 {
2b692964 14207 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14208 (unsigned long) liblistno);
2b692964 14209 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14210 stdout);
14211
14212 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14213 {
a6e9f9df 14214 Elf32_Lib liblist;
91d6fa6a 14215 time_t atime;
a6e9f9df 14216 char timebuf[20];
2cf0635d 14217 struct tm * tmp;
a6e9f9df
AM		 14218
14219 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14220 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14221 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14222 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14223 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14224
91d6fa6a 14225 tmp = gmtime (&atime);
e9e44622
JJ		 14226 snprintf (timebuf, sizeof (timebuf),
14227 "%04u-%02u-%02uT%02u:%02u:%02u",
14228 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14229 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14230
31104126 14231 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14232 if (VALID_DYNAMIC_NAME (liblist.l_name))
14233 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14234 else
2b692964 14235 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14236 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14237 liblist.l_version);
a6e9f9df
AM		 14238
14239 if (liblist.l_flags == 0)
2b692964 14240 puts (_(" NONE"));
a6e9f9df
AM		 14241 else
14242 {
14243 static const struct
252b5132 14244 {
2cf0635d 14245 const char * name;
a6e9f9df 14246 int bit;
252b5132 14247 }
a6e9f9df
AM		 14248 l_flags_vals[] =
14249 {
14250 { " EXACT_MATCH", LL_EXACT_MATCH },
14251 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14252 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14253 { " EXPORTS", LL_EXPORTS },
14254 { " DELAY_LOAD", LL_DELAY_LOAD },
14255 { " DELTA", LL_DELTA }
14256 };
14257 int flags = liblist.l_flags;
14258 size_t fcnt;
14259
60bca95a 14260 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14261 if ((flags & l_flags_vals[fcnt].bit) != 0)
14262 {
14263 fputs (l_flags_vals[fcnt].name, stdout);
14264 flags ^= l_flags_vals[fcnt].bit;
14265 }
14266 if (flags != 0)
14267 printf (" %#x", (unsigned int) flags);
252b5132 14268
a6e9f9df
AM		 14269 puts ("");
14270 }
252b5132 14271 }
252b5132 14272
a6e9f9df
AM		 14273 free (elib);
14274 }
252b5132
RH		 14275 }
14276
14277 if (options_offset != 0)
14278 {
2cf0635d 14279 Elf_External_Options * eopt;
2cf0635d
NC		 14280 Elf_Internal_Options * iopt;
14281 Elf_Internal_Options * option;
252b5132
RH		 14282 size_t offset;
14283 int cnt;
351cdf24 14284 sect = section_headers;
252b5132
RH		 14285
14286 /* Find the section header so that we get the size. */
071436c6 14287 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14288 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14289 if (sect == NULL)
14290 {
14291 error (_("No MIPS_OPTIONS header found\n"));
14292 return 0;
14293 }
252b5132 14294
3f5e193b
NC		 14295 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14296 sect->sh_size, _("options"));
a6e9f9df 14297 if (eopt)
252b5132 14298 {
3f5e193b
NC		 14299 iopt = (Elf_Internal_Options *)
14300 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14301 if (iopt == NULL)
14302 {
8b73c356 14303 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14304 return 0;
14305 }
76da6bbe 14306
a6e9f9df
AM		 14307 offset = cnt = 0;
14308 option = iopt;
252b5132 14309
82b1b41b 14310 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14311 {
2cf0635d 14312 Elf_External_Options * eoption;
252b5132 14313
a6e9f9df 14314 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14315
a6e9f9df
AM		 14316 option->kind = BYTE_GET (eoption->kind);
14317 option->size = BYTE_GET (eoption->size);
14318 option->section = BYTE_GET (eoption->section);
14319 option->info = BYTE_GET (eoption->info);
76da6bbe 14320
82b1b41b
NC		 14321 /* PR 17531: file: ffa0fa3b. */
14322 if (option->size < sizeof (* eopt)
14323 || offset + option->size > sect->sh_size)
14324 {
55325047
NC		 14325 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14326 return 0;
82b1b41b 14327 }
a6e9f9df 14328 offset += option->size;
14ae95f2 14329
a6e9f9df
AM		 14330 ++option;
14331 ++cnt;
14332 }
252b5132 14333
a6e9f9df 14334 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14335 printable_section_name (sect), cnt);
76da6bbe 14336
a6e9f9df 14337 option = iopt;
82b1b41b 14338 offset = 0;
252b5132 14339
a6e9f9df 14340 while (cnt-- > 0)
252b5132 14341 {
a6e9f9df
AM		 14342 size_t len;
14343
14344 switch (option->kind)
252b5132 14345 {
a6e9f9df
AM		 14346 case ODK_NULL:
14347 /* This shouldn't happen. */
14348 printf (" NULL %d %lx", option->section, option->info);
14349 break;
14350 case ODK_REGINFO:
14351 printf (" REGINFO ");
14352 if (elf_header.e_machine == EM_MIPS)
14353 {
14354 /* 32bit form. */
2cf0635d 14355 Elf32_External_RegInfo * ereg;
b34976b6 14356 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14357
14358 ereg = (Elf32_External_RegInfo *) (option + 1);
14359 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14360 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14361 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14362 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14363 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14364 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14365
14366 printf ("GPR %08lx GP 0x%lx\n",
14367 reginfo.ri_gprmask,
14368 (unsigned long) reginfo.ri_gp_value);
14369 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14370 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14371 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14372 }
14373 else
14374 {
14375 /* 64 bit form. */
2cf0635d 14376 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14377 Elf64_Internal_RegInfo reginfo;
14378
14379 ereg = (Elf64_External_RegInfo *) (option + 1);
14380 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14381 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14382 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14383 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14384 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14385 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14386
14387 printf ("GPR %08lx GP 0x",
14388 reginfo.ri_gprmask);
14389 printf_vma (reginfo.ri_gp_value);
14390 printf ("\n");
14391
14392 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14393 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14394 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14395 }
14396 ++option;
14397 continue;
14398 case ODK_EXCEPTIONS:
14399 fputs (" EXCEPTIONS fpe_min(", stdout);
14400 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14401 fputs (") fpe_max(", stdout);
14402 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14403 fputs (")", stdout);
14404
14405 if (option->info & OEX_PAGE0)
14406 fputs (" PAGE0", stdout);
14407 if (option->info & OEX_SMM)
14408 fputs (" SMM", stdout);
14409 if (option->info & OEX_FPDBUG)
14410 fputs (" FPDBUG", stdout);
14411 if (option->info & OEX_DISMISS)
14412 fputs (" DISMISS", stdout);
14413 break;
14414 case ODK_PAD:
14415 fputs (" PAD ", stdout);
14416 if (option->info & OPAD_PREFIX)
14417 fputs (" PREFIX", stdout);
14418 if (option->info & OPAD_POSTFIX)
14419 fputs (" POSTFIX", stdout);
14420 if (option->info & OPAD_SYMBOL)
14421 fputs (" SYMBOL", stdout);
14422 break;
14423 case ODK_HWPATCH:
14424 fputs (" HWPATCH ", stdout);
14425 if (option->info & OHW_R4KEOP)
14426 fputs (" R4KEOP", stdout);
14427 if (option->info & OHW_R8KPFETCH)
14428 fputs (" R8KPFETCH", stdout);
14429 if (option->info & OHW_R5KEOP)
14430 fputs (" R5KEOP", stdout);
14431 if (option->info & OHW_R5KCVTL)
14432 fputs (" R5KCVTL", stdout);
14433 break;
14434 case ODK_FILL:
14435 fputs (" FILL ", stdout);
14436 /* XXX Print content of info word? */
14437 break;
14438 case ODK_TAGS:
14439 fputs (" TAGS ", stdout);
14440 /* XXX Print content of info word? */
14441 break;
14442 case ODK_HWAND:
14443 fputs (" HWAND ", stdout);
14444 if (option->info & OHWA0_R4KEOP_CHECKED)
14445 fputs (" R4KEOP_CHECKED", stdout);
14446 if (option->info & OHWA0_R4KEOP_CLEAN)
14447 fputs (" R4KEOP_CLEAN", stdout);
14448 break;
14449 case ODK_HWOR:
14450 fputs (" HWOR ", stdout);
14451 if (option->info & OHWA0_R4KEOP_CHECKED)
14452 fputs (" R4KEOP_CHECKED", stdout);
14453 if (option->info & OHWA0_R4KEOP_CLEAN)
14454 fputs (" R4KEOP_CLEAN", stdout);
14455 break;
14456 case ODK_GP_GROUP:
14457 printf (" GP_GROUP %#06lx self-contained %#06lx",
14458 option->info & OGP_GROUP,
14459 (option->info & OGP_SELF) >> 16);
14460 break;
14461 case ODK_IDENT:
14462 printf (" IDENT %#06lx self-contained %#06lx",
14463 option->info & OGP_GROUP,
14464 (option->info & OGP_SELF) >> 16);
14465 break;
14466 default:
14467 /* This shouldn't happen. */
14468 printf (" %3d ??? %d %lx",
14469 option->kind, option->section, option->info);
14470 break;
252b5132 14471 }
a6e9f9df 14472
2cf0635d 14473 len = sizeof (* eopt);
a6e9f9df 14474 while (len < option->size)
82b1b41b
NC		 14475 {
14476 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14477
82b1b41b
NC		 14478 if (ISPRINT (datum))
14479 printf ("%c", datum);
14480 else
14481 printf ("\\%03o", datum);
14482 len ++;
14483 }
a6e9f9df 14484 fputs ("\n", stdout);
82b1b41b
NC		 14485
14486 offset += option->size;
252b5132 14487 ++option;
252b5132
RH		 14488 }
14489
a6e9f9df 14490 free (eopt);
252b5132 14491 }
252b5132
RH		 14492 }
14493
14494 if (conflicts_offset != 0 && conflictsno != 0)
14495 {
2cf0635d 14496 Elf32_Conflict * iconf;
252b5132
RH		 14497 size_t cnt;
14498
14499 if (dynamic_symbols == NULL)
14500 {
591a748a 14501 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14502 return 0;
14503 }
14504
3f5e193b 14505 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14506 if (iconf == NULL)
14507 {
8b73c356 14508 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14509 return 0;
14510 }
14511
9ea033b2 14512 if (is_32bit_elf)
252b5132 14513 {
2cf0635d 14514 Elf32_External_Conflict * econf32;
a6e9f9df 14515
3f5e193b
NC		 14516 econf32 = (Elf32_External_Conflict *)
14517 get_data (NULL, file, conflicts_offset, conflictsno,
14518 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14519 if (!econf32)
14520 return 0;
252b5132
RH		 14521
14522 for (cnt = 0; cnt < conflictsno; ++cnt)
14523 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14524
14525 free (econf32);
252b5132
RH		 14526 }
14527 else
14528 {
2cf0635d 14529 Elf64_External_Conflict * econf64;
a6e9f9df 14530
3f5e193b
NC		 14531 econf64 = (Elf64_External_Conflict *)
14532 get_data (NULL, file, conflicts_offset, conflictsno,
14533 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14534 if (!econf64)
14535 return 0;
252b5132
RH		 14536
14537 for (cnt = 0; cnt < conflictsno; ++cnt)
14538 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14539
14540 free (econf64);
252b5132
RH		 14541 }
14542
c7e7ca54
NC		 14543 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14544 (unsigned long) conflictsno);
252b5132
RH		 14545 puts (_(" Num: Index Value Name"));
14546
14547 for (cnt = 0; cnt < conflictsno; ++cnt)
14548 {
b34976b6 14549 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14550
14551 if (iconf[cnt] >= num_dynamic_syms)
14552 printf (_("<corrupt symbol index>"));
d79b3d50 14553 else
e0a31db1
NC		 14554 {
14555 Elf_Internal_Sym * psym;
14556
14557 psym = & dynamic_symbols[iconf[cnt]];
14558 print_vma (psym->st_value, FULL_HEX);
14559 putchar (' ');
14560 if (VALID_DYNAMIC_NAME (psym->st_name))
14561 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14562 else
14563 printf (_("<corrupt: %14ld>"), psym->st_name);
14564 }
31104126 14565 putchar ('\n');
252b5132
RH		 14566 }
14567
252b5132
RH		 14568 free (iconf);
14569 }
14570
ccb4c951
RS		 14571 if (pltgot != 0 && local_gotno != 0)
14572 {
91d6fa6a 14573 bfd_vma ent, local_end, global_end;
bbeee7ea 14574 size_t i, offset;
2cf0635d 14575 unsigned char * data;
82b1b41b 14576 unsigned char * data_end;
bbeee7ea 14577 int addr_size;
ccb4c951 14578
91d6fa6a 14579 ent = pltgot;
ccb4c951
RS		 14580 addr_size = (is_32bit_elf ? 4 : 8);
14581 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14582
74e1a04b
NC		 14583 /* PR binutils/17533 file: 012-111227-0.004 */
14584 if (symtabno < gotsym)
14585 {
14586 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14587 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14588 return 0;
14589 }
82b1b41b 14590
74e1a04b 14591 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14592 /* PR 17531: file: 54c91a34. */
14593 if (global_end < local_end)
14594 {
14595 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14596 return 0;
14597 }
948f632f 14598
ccb4c951 14599 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14600 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14601 global_end - pltgot, 1,
14602 _("Global Offset Table data"));
59245841
NC		 14603 if (data == NULL)
14604 return 0;
82b1b41b 14605 data_end = data + (global_end - pltgot);
59245841 14606
ccb4c951
RS		 14607 printf (_("\nPrimary GOT:\n"));
14608 printf (_(" Canonical gp value: "));
14609 print_vma (pltgot + 0x7ff0, LONG_HEX);
14610 printf ("\n\n");
14611
14612 printf (_(" Reserved entries:\n"));
14613 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14614 addr_size * 2, _("Address"), _("Access"),
14615 addr_size * 2, _("Initial"));
82b1b41b 14616 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14617 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14618 if (ent == (bfd_vma) -1)
14619 goto got_print_fail;
ccb4c951 14620 if (data
91d6fa6a 14621 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14622 >> (addr_size * 8 - 1)) != 0)
14623 {
82b1b41b 14624 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14625 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14626 if (ent == (bfd_vma) -1)
14627 goto got_print_fail;
ccb4c951
RS		 14628 }
14629 printf ("\n");
14630
91d6fa6a 14631 if (ent < local_end)
ccb4c951
RS		 14632 {
14633 printf (_(" Local entries:\n"));
cc5914eb 14634 printf (" %*s %10s %*s\n",
2b692964
NC		 14635 addr_size * 2, _("Address"), _("Access"),
14636 addr_size * 2, _("Initial"));
91d6fa6a 14637 while (ent < local_end)
ccb4c951 14638 {
82b1b41b 14639 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14640 printf ("\n");
82b1b41b
NC		 14641 if (ent == (bfd_vma) -1)
14642 goto got_print_fail;
ccb4c951
RS		 14643 }
14644 printf ("\n");
14645 }
14646
14647 if (gotsym < symtabno)
14648 {
14649 int sym_width;
14650
14651 printf (_(" Global entries:\n"));
cc5914eb 14652 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14653 addr_size * 2, _("Address"),
14654 _("Access"),
2b692964 14655 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14656 addr_size * 2, _("Sym.Val."),
14657 _("Type"),
14658 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14659 _("Ndx"), _("Name"));
0b4362b0 14660
ccb4c951 14661 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14662
ccb4c951
RS		 14663 for (i = gotsym; i < symtabno; i++)
14664 {
82b1b41b 14665 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14666 printf (" ");
e0a31db1
NC		 14667
14668 if (dynamic_symbols == NULL)
14669 printf (_("<no dynamic symbols>"));
14670 else if (i < num_dynamic_syms)
14671 {
14672 Elf_Internal_Sym * psym = dynamic_symbols + i;
14673
14674 print_vma (psym->st_value, LONG_HEX);
14675 printf (" %-7s %3s ",
14676 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14677 get_symbol_index_type (psym->st_shndx));
14678
14679 if (VALID_DYNAMIC_NAME (psym->st_name))
14680 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14681 else
14682 printf (_("<corrupt: %14ld>"), psym->st_name);
14683 }
ccb4c951 14684 else
7fc5ac57
JBG		 14685 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14686 (unsigned long) i);
e0a31db1 14687
ccb4c951 14688 printf ("\n");
82b1b41b
NC		 14689 if (ent == (bfd_vma) -1)
14690 break;
ccb4c951
RS		 14691 }
14692 printf ("\n");
14693 }
14694
82b1b41b 14695 got_print_fail:
ccb4c951
RS		 14696 if (data)
14697 free (data);
14698 }
14699
861fb55a
DJ		 14700 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14701 {
91d6fa6a 14702 bfd_vma ent, end;
861fb55a
DJ		 14703 size_t offset, rel_offset;
14704 unsigned long count, i;
2cf0635d 14705 unsigned char * data;
861fb55a 14706 int addr_size, sym_width;
2cf0635d 14707 Elf_Internal_Rela * rels;
861fb55a
DJ		 14708
14709 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14710 if (pltrel == DT_RELA)
14711 {
14712 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14713 return 0;
14714 }
14715 else
14716 {
14717 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14718 return 0;
14719 }
14720
91d6fa6a 14721 ent = mips_pltgot;
861fb55a
DJ		 14722 addr_size = (is_32bit_elf ? 4 : 8);
14723 end = mips_pltgot + (2 + count) * addr_size;
14724
14725 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14726 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14727 1, _("Procedure Linkage Table data"));
59245841
NC		 14728 if (data == NULL)
14729 return 0;
14730
9cf03b7e 14731 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14732 printf (_(" Reserved entries:\n"));
14733 printf (_(" %*s %*s Purpose\n"),
2b692964 14734 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14735 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14736 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14737 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14738 printf (_(" Module pointer\n"));
861fb55a
DJ		 14739 printf ("\n");
14740
14741 printf (_(" Entries:\n"));
cc5914eb 14742 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14743 addr_size * 2, _("Address"),
14744 addr_size * 2, _("Initial"),
14745 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14746 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14747 for (i = 0; i < count; i++)
14748 {
df97ab2a 14749 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14750
91d6fa6a 14751 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14752 printf (" ");
e0a31db1 14753
df97ab2a
MF		 14754 if (idx >= num_dynamic_syms)
14755 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14756 else
e0a31db1 14757 {
df97ab2a 14758 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14759
14760 print_vma (psym->st_value, LONG_HEX);
14761 printf (" %-7s %3s ",
14762 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14763 get_symbol_index_type (psym->st_shndx));
14764 if (VALID_DYNAMIC_NAME (psym->st_name))
14765 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14766 else
14767 printf (_("<corrupt: %14ld>"), psym->st_name);
14768 }
861fb55a
DJ		 14769 printf ("\n");
14770 }
14771 printf ("\n");
14772
14773 if (data)
14774 free (data);
14775 free (rels);
14776 }
14777
252b5132
RH		 14778 return 1;
14779}
14780
35c08157
KLC		 14781static int
14782process_nds32_specific (FILE * file)
14783{
14784 Elf_Internal_Shdr *sect = NULL;
14785
14786 sect = find_section (".nds32_e_flags");
14787 if (sect != NULL)
14788 {
14789 unsigned int *flag;
14790
14791 printf ("\nNDS32 elf flags section:\n");
14792 flag = get_data (NULL, file, sect->sh_offset, 1,
14793 sect->sh_size, _("NDS32 elf flags section"));
14794
14795 switch ((*flag) & 0x3)
14796 {
14797 case 0:
14798 printf ("(VEC_SIZE):\tNo entry.\n");
14799 break;
14800 case 1:
14801 printf ("(VEC_SIZE):\t4 bytes\n");
14802 break;
14803 case 2:
14804 printf ("(VEC_SIZE):\t16 bytes\n");
14805 break;
14806 case 3:
14807 printf ("(VEC_SIZE):\treserved\n");
14808 break;
14809 }
14810 }
14811
14812 return TRUE;
14813}
14814
047b2264 14815static int
2cf0635d 14816process_gnu_liblist (FILE * file)
047b2264 14817{
2cf0635d
NC		 14818 Elf_Internal_Shdr * section;
14819 Elf_Internal_Shdr * string_sec;
14820 Elf32_External_Lib * elib;
14821 char * strtab;
c256ffe7 14822 size_t strtab_size;
047b2264
JJ		 14823 size_t cnt;
14824 unsigned i;
14825
14826 if (! do_arch)
14827 return 0;
14828
14829 for (i = 0, section = section_headers;
14830 i < elf_header.e_shnum;
b34976b6 14831 i++, section++)
047b2264
JJ		 14832 {
14833 switch (section->sh_type)
14834 {
14835 case SHT_GNU_LIBLIST:
4fbb74a6 14836 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14837 break;
14838
3f5e193b
NC		 14839 elib = (Elf32_External_Lib *)
14840 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14841 _("liblist section data"));
047b2264
JJ		 14842
14843 if (elib == NULL)
14844 break;
4fbb74a6 14845 string_sec = section_headers + section->sh_link;
047b2264 14846
3f5e193b
NC		 14847 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14848 string_sec->sh_size,
14849 _("liblist string table"));
047b2264
JJ		 14850 if (strtab == NULL
14851 || section->sh_entsize != sizeof (Elf32_External_Lib))
14852 {
14853 free (elib);
2842702f 14854 free (strtab);
047b2264
JJ		 14855 break;
14856 }
59245841 14857 strtab_size = string_sec->sh_size;
047b2264
JJ		 14858
14859 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14860 printable_section_name (section),
0af1713e 14861 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14862
2b692964 14863 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14864
14865 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14866 ++cnt)
14867 {
14868 Elf32_Lib liblist;
91d6fa6a 14869 time_t atime;
047b2264 14870 char timebuf[20];
2cf0635d 14871 struct tm * tmp;
047b2264
JJ		 14872
14873 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14874 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14875 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14876 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14877 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14878
91d6fa6a 14879 tmp = gmtime (&atime);
e9e44622
JJ		 14880 snprintf (timebuf, sizeof (timebuf),
14881 "%04u-%02u-%02uT%02u:%02u:%02u",
14882 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14883 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14884
14885 printf ("%3lu: ", (unsigned long) cnt);
14886 if (do_wide)
c256ffe7 14887 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14888 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14889 else
c256ffe7 14890 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14891 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14892 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14893 liblist.l_version, liblist.l_flags);
14894 }
14895
14896 free (elib);
2842702f 14897 free (strtab);
047b2264
JJ		 14898 }
14899 }
14900
14901 return 1;
14902}
14903
9437c45b 14904static const char *
d3ba0551 14905get_note_type (unsigned e_type)
779fe533
NC		 14906{
14907 static char buff[64];
103f02d3 14908
1ec5cd37
NC		 14909 if (elf_header.e_type == ET_CORE)
14910 switch (e_type)
14911 {
57346661 14912 case NT_AUXV:
1ec5cd37 14913 return _("NT_AUXV (auxiliary vector)");
57346661 14914 case NT_PRSTATUS:
1ec5cd37 14915 return _("NT_PRSTATUS (prstatus structure)");
57346661 14916 case NT_FPREGSET:
1ec5cd37 14917 return _("NT_FPREGSET (floating point registers)");
57346661 14918 case NT_PRPSINFO:
1ec5cd37 14919 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14920 case NT_TASKSTRUCT:
1ec5cd37 14921 return _("NT_TASKSTRUCT (task structure)");
57346661 14922 case NT_PRXFPREG:
1ec5cd37 14923 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14924 case NT_PPC_VMX:
14925 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14926 case NT_PPC_VSX:
14927 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14928 case NT_386_TLS:
14929 return _("NT_386_TLS (x86 TLS information)");
14930 case NT_386_IOPERM:
14931 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14932 case NT_X86_XSTATE:
14933 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14934 case NT_S390_HIGH_GPRS:
14935 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14936 case NT_S390_TIMER:
14937 return _("NT_S390_TIMER (s390 timer register)");
14938 case NT_S390_TODCMP:
14939 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14940 case NT_S390_TODPREG:
14941 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14942 case NT_S390_CTRS:
14943 return _("NT_S390_CTRS (s390 control registers)");
14944 case NT_S390_PREFIX:
14945 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14946 case NT_S390_LAST_BREAK:
14947 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14948 case NT_S390_SYSTEM_CALL:
14949 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14950 case NT_S390_TDB:
14951 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14952 case NT_S390_VXRS_LOW:
14953 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14954 case NT_S390_VXRS_HIGH:
14955 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14956 case NT_ARM_VFP:
14957 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14958 case NT_ARM_TLS:
14959 return _("NT_ARM_TLS (AArch TLS registers)");
14960 case NT_ARM_HW_BREAK:
14961 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14962 case NT_ARM_HW_WATCH:
14963 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14964 case NT_PSTATUS:
1ec5cd37 14965 return _("NT_PSTATUS (pstatus structure)");
57346661 14966 case NT_FPREGS:
1ec5cd37 14967 return _("NT_FPREGS (floating point registers)");
57346661 14968 case NT_PSINFO:
1ec5cd37 14969 return _("NT_PSINFO (psinfo structure)");
57346661 14970 case NT_LWPSTATUS:
1ec5cd37 14971 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14972 case NT_LWPSINFO:
1ec5cd37 14973 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14974 case NT_WIN32PSTATUS:
1ec5cd37 14975 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14976 case NT_SIGINFO:
14977 return _("NT_SIGINFO (siginfo_t data)");
14978 case NT_FILE:
14979 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14980 default:
14981 break;
14982 }
14983 else
14984 switch (e_type)
14985 {
14986 case NT_VERSION:
14987 return _("NT_VERSION (version)");
14988 case NT_ARCH:
14989 return _("NT_ARCH (architecture)");
14990 default:
14991 break;
14992 }
14993
e9e44622 14994 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14995 return buff;
779fe533
NC		 14996}
14997
9ece1fa9
TT		 14998static int
14999print_core_note (Elf_Internal_Note *pnote)
15000{
15001 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15002 bfd_vma count, page_size;
15003 unsigned char *descdata, *filenames, *descend;
15004
15005 if (pnote->type != NT_FILE)
15006 return 1;
15007
15008#ifndef BFD64
15009 if (!is_32bit_elf)
15010 {
15011 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15012 /* Still "successful". */
15013 return 1;
15014 }
15015#endif
15016
15017 if (pnote->descsz < 2 * addr_size)
15018 {
15019 printf (_(" Malformed note - too short for header\n"));
15020 return 0;
15021 }
15022
15023 descdata = (unsigned char *) pnote->descdata;
15024 descend = descdata + pnote->descsz;
15025
15026 if (descdata[pnote->descsz - 1] != '\0')
15027 {
15028 printf (_(" Malformed note - does not end with \\0\n"));
15029 return 0;
15030 }
15031
15032 count = byte_get (descdata, addr_size);
15033 descdata += addr_size;
15034
15035 page_size = byte_get (descdata, addr_size);
15036 descdata += addr_size;
15037
15038 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15039 {
15040 printf (_(" Malformed note - too short for supplied file count\n"));
15041 return 0;
15042 }
15043
15044 printf (_(" Page size: "));
15045 print_vma (page_size, DEC);
15046 printf ("\n");
15047
15048 printf (_(" %*s%*s%*s\n"),
15049 (int) (2 + 2 * addr_size), _("Start"),
15050 (int) (4 + 2 * addr_size), _("End"),
15051 (int) (4 + 2 * addr_size), _("Page Offset"));
15052 filenames = descdata + count * 3 * addr_size;
15053 while (--count > 0)
15054 {
15055 bfd_vma start, end, file_ofs;
15056
15057 if (filenames == descend)
15058 {
15059 printf (_(" Malformed note - filenames end too early\n"));
15060 return 0;
15061 }
15062
15063 start = byte_get (descdata, addr_size);
15064 descdata += addr_size;
15065 end = byte_get (descdata, addr_size);
15066 descdata += addr_size;
15067 file_ofs = byte_get (descdata, addr_size);
15068 descdata += addr_size;
15069
15070 printf (" ");
15071 print_vma (start, FULL_HEX);
15072 printf (" ");
15073 print_vma (end, FULL_HEX);
15074 printf (" ");
15075 print_vma (file_ofs, FULL_HEX);
15076 printf ("\n %s\n", filenames);
15077
15078 filenames += 1 + strlen ((char *) filenames);
15079 }
15080
15081 return 1;
15082}
15083
1118d252
RM		 15084static const char *
15085get_gnu_elf_note_type (unsigned e_type)
15086{
15087 static char buff[64];
15088
15089 switch (e_type)
15090 {
15091 case NT_GNU_ABI_TAG:
15092 return _("NT_GNU_ABI_TAG (ABI version tag)");
15093 case NT_GNU_HWCAP:
15094 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15095 case NT_GNU_BUILD_ID:
15096 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15097 case NT_GNU_GOLD_VERSION:
15098 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15099 default:
15100 break;
15101 }
15102
15103 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15104 return buff;
15105}
15106
664f90a3
TT		 15107static int
15108print_gnu_note (Elf_Internal_Note *pnote)
15109{
15110 switch (pnote->type)
15111 {
15112 case NT_GNU_BUILD_ID:
15113 {
15114 unsigned long i;
15115
15116 printf (_(" Build ID: "));
15117 for (i = 0; i < pnote->descsz; ++i)
15118 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15119 printf ("\n");
664f90a3
TT		 15120 }
15121 break;
15122
15123 case NT_GNU_ABI_TAG:
15124 {
15125 unsigned long os, major, minor, subminor;
15126 const char *osname;
15127
3102e897
NC		 15128 /* PR 17531: file: 030-599401-0.004. */
15129 if (pnote->descsz < 16)
15130 {
15131 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15132 break;
15133 }
15134
664f90a3
TT		 15135 os = byte_get ((unsigned char *) pnote->descdata, 4);
15136 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15137 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15138 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15139
15140 switch (os)
15141 {
15142 case GNU_ABI_TAG_LINUX:
15143 osname = "Linux";
15144 break;
15145 case GNU_ABI_TAG_HURD:
15146 osname = "Hurd";
15147 break;
15148 case GNU_ABI_TAG_SOLARIS:
15149 osname = "Solaris";
15150 break;
15151 case GNU_ABI_TAG_FREEBSD:
15152 osname = "FreeBSD";
15153 break;
15154 case GNU_ABI_TAG_NETBSD:
15155 osname = "NetBSD";
15156 break;
14ae95f2
RM		 15157 case GNU_ABI_TAG_SYLLABLE:
15158 osname = "Syllable";
15159 break;
15160 case GNU_ABI_TAG_NACL:
15161 osname = "NaCl";
15162 break;
664f90a3
TT		 15163 default:
15164 osname = "Unknown";
15165 break;
15166 }
15167
15168 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15169 major, minor, subminor);
15170 }
15171 break;
926c5385
CC		 15172
15173 case NT_GNU_GOLD_VERSION:
15174 {
15175 unsigned long i;
15176
15177 printf (_(" Version: "));
15178 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15179 printf ("%c", pnote->descdata[i]);
15180 printf ("\n");
15181 }
15182 break;
664f90a3
TT		 15183 }
15184
15185 return 1;
15186}
15187
685080f2
NC		 15188static const char *
15189get_v850_elf_note_type (enum v850_notes n_type)
15190{
15191 static char buff[64];
15192
15193 switch (n_type)
15194 {
15195 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15196 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15197 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15198 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15199 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15200 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15201 default:
15202 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15203 return buff;
15204 }
15205}
15206
15207static int
15208print_v850_note (Elf_Internal_Note * pnote)
15209{
15210 unsigned int val;
15211
15212 if (pnote->descsz != 4)
15213 return 0;
15214 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15215
15216 if (val == 0)
15217 {
15218 printf (_("not set\n"));
15219 return 1;
15220 }
15221
15222 switch (pnote->type)
15223 {
15224 case V850_NOTE_ALIGNMENT:
15225 switch (val)
15226 {
15227 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15228 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15229 }
15230 break;
14ae95f2 15231
685080f2
NC		 15232 case V850_NOTE_DATA_SIZE:
15233 switch (val)
15234 {
15235 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15236 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15237 }
15238 break;
14ae95f2 15239
685080f2
NC		 15240 case V850_NOTE_FPU_INFO:
15241 switch (val)
15242 {
15243 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15244 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15245 }
15246 break;
14ae95f2 15247
685080f2
NC		 15248 case V850_NOTE_MMU_INFO:
15249 case V850_NOTE_CACHE_INFO:
15250 case V850_NOTE_SIMD_INFO:
15251 if (val == EF_RH850_SIMD)
15252 {
15253 printf (_("yes\n"));
15254 return 1;
15255 }
15256 break;
15257
15258 default:
15259 /* An 'unknown note type' message will already have been displayed. */
15260 break;
15261 }
15262
15263 printf (_("unknown value: %x\n"), val);
15264 return 0;
15265}
15266
9437c45b 15267static const char *
d3ba0551 15268get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15269{
15270 static char buff[64];
15271
b4db1224 15272 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15273 {
15274 /* NetBSD core "procinfo" structure. */
15275 return _("NetBSD procinfo structure");
15276 }
15277
15278 /* As of Jan 2002 there are no other machine-independent notes
15279 defined for NetBSD core files. If the note type is less
15280 than the start of the machine-dependent note types, we don't
15281 understand it. */
15282
b4db1224 15283 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15284 {
e9e44622 15285 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15286 return buff;
15287 }
15288
15289 switch (elf_header.e_machine)
15290 {
15291 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15292 and PT_GETFPREGS == mach+2. */
15293
15294 case EM_OLD_ALPHA:
15295 case EM_ALPHA:
15296 case EM_SPARC:
15297 case EM_SPARC32PLUS:
15298 case EM_SPARCV9:
15299 switch (e_type)
15300 {
2b692964 15301 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15302 return _("PT_GETREGS (reg structure)");
2b692964 15303 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15304 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15305 default:
15306 break;
15307 }
15308 break;
15309
15310 /* On all other arch's, PT_GETREGS == mach+1 and
15311 PT_GETFPREGS == mach+3. */
15312 default:
15313 switch (e_type)
15314 {
2b692964 15315 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15316 return _("PT_GETREGS (reg structure)");
2b692964 15317 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15318 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15319 default:
15320 break;
15321 }
15322 }
15323
9cf03b7e 15324 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15325 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15326 return buff;
15327}
15328
70616151
TT		 15329static const char *
15330get_stapsdt_note_type (unsigned e_type)
15331{
15332 static char buff[64];
15333
15334 switch (e_type)
15335 {
15336 case NT_STAPSDT:
15337 return _("NT_STAPSDT (SystemTap probe descriptors)");
15338
15339 default:
15340 break;
15341 }
15342
15343 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15344 return buff;
15345}
15346
c6a9fc58
TT		 15347static int
15348print_stapsdt_note (Elf_Internal_Note *pnote)
15349{
15350 int addr_size = is_32bit_elf ? 4 : 8;
15351 char *data = pnote->descdata;
15352 char *data_end = pnote->descdata + pnote->descsz;
15353 bfd_vma pc, base_addr, semaphore;
15354 char *provider, *probe, *arg_fmt;
15355
15356 pc = byte_get ((unsigned char *) data, addr_size);
15357 data += addr_size;
15358 base_addr = byte_get ((unsigned char *) data, addr_size);
15359 data += addr_size;
15360 semaphore = byte_get ((unsigned char *) data, addr_size);
15361 data += addr_size;
15362
15363 provider = data;
15364 data += strlen (data) + 1;
15365 probe = data;
15366 data += strlen (data) + 1;
15367 arg_fmt = data;
15368 data += strlen (data) + 1;
15369
15370 printf (_(" Provider: %s\n"), provider);
15371 printf (_(" Name: %s\n"), probe);
15372 printf (_(" Location: "));
15373 print_vma (pc, FULL_HEX);
15374 printf (_(", Base: "));
15375 print_vma (base_addr, FULL_HEX);
15376 printf (_(", Semaphore: "));
15377 print_vma (semaphore, FULL_HEX);
9cf03b7e 15378 printf ("\n");
c6a9fc58
TT		 15379 printf (_(" Arguments: %s\n"), arg_fmt);
15380
15381 return data == data_end;
15382}
15383
00e98fc7
TG		 15384static const char *
15385get_ia64_vms_note_type (unsigned e_type)
15386{
15387 static char buff[64];
15388
15389 switch (e_type)
15390 {
15391 case NT_VMS_MHD:
15392 return _("NT_VMS_MHD (module header)");
15393 case NT_VMS_LNM:
15394 return _("NT_VMS_LNM (language name)");
15395 case NT_VMS_SRC:
15396 return _("NT_VMS_SRC (source files)");
15397 case NT_VMS_TITLE:
9cf03b7e 15398 return "NT_VMS_TITLE";
00e98fc7
TG		 15399 case NT_VMS_EIDC:
15400 return _("NT_VMS_EIDC (consistency check)");
15401 case NT_VMS_FPMODE:
15402 return _("NT_VMS_FPMODE (FP mode)");
15403 case NT_VMS_LINKTIME:
9cf03b7e 15404 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15405 case NT_VMS_IMGNAM:
15406 return _("NT_VMS_IMGNAM (image name)");
15407 case NT_VMS_IMGID:
15408 return _("NT_VMS_IMGID (image id)");
15409 case NT_VMS_LINKID:
15410 return _("NT_VMS_LINKID (link id)");
15411 case NT_VMS_IMGBID:
15412 return _("NT_VMS_IMGBID (build id)");
15413 case NT_VMS_GSTNAM:
15414 return _("NT_VMS_GSTNAM (sym table name)");
15415 case NT_VMS_ORIG_DYN:
9cf03b7e 15416 return "NT_VMS_ORIG_DYN";
00e98fc7 15417 case NT_VMS_PATCHTIME:
9cf03b7e 15418 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15419 default:
15420 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15421 return buff;
15422 }
15423}
15424
15425static int
15426print_ia64_vms_note (Elf_Internal_Note * pnote)
15427{
15428 switch (pnote->type)
15429 {
15430 case NT_VMS_MHD:
15431 if (pnote->descsz > 36)
15432 {
15433 size_t l = strlen (pnote->descdata + 34);
15434 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15435 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15436 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15437 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15438 }
15439 else
15440 printf (_(" Invalid size\n"));
15441 break;
15442 case NT_VMS_LNM:
15443 printf (_(" Language: %s\n"), pnote->descdata);
15444 break;
15445#ifdef BFD64
15446 case NT_VMS_FPMODE:
9cf03b7e 15447 printf (_(" Floating Point mode: "));
4a5cb34f 15448 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15449 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15450 break;
15451 case NT_VMS_LINKTIME:
15452 printf (_(" Link time: "));
15453 print_vms_time
15454 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15455 printf ("\n");
15456 break;
15457 case NT_VMS_PATCHTIME:
15458 printf (_(" Patch time: "));
15459 print_vms_time
15460 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15461 printf ("\n");
15462 break;
15463 case NT_VMS_ORIG_DYN:
15464 printf (_(" Major id: %u, minor id: %u\n"),
15465 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15466 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15467 printf (_(" Last modified : "));
00e98fc7
TG		 15468 print_vms_time
15469 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15470 printf (_("\n Link flags : "));
4a5cb34f 15471 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15472 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15473 printf (_(" Header flags: 0x%08x\n"),
948f632f 15474 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15475 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15476 break;
15477#endif
15478 case NT_VMS_IMGNAM:
15479 printf (_(" Image name: %s\n"), pnote->descdata);
15480 break;
15481 case NT_VMS_GSTNAM:
15482 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15483 break;
15484 case NT_VMS_IMGID:
15485 printf (_(" Image id: %s\n"), pnote->descdata);
15486 break;
15487 case NT_VMS_LINKID:
15488 printf (_(" Linker id: %s\n"), pnote->descdata);
15489 break;
15490 default:
15491 break;
15492 }
15493 return 1;
15494}
15495
6d118b09
NC		 15496/* Note that by the ELF standard, the name field is already null byte
15497 terminated, and namesz includes the terminating null byte.
15498 I.E. the value of namesz for the name "FSF" is 4.
15499
e3c8793a 15500 If the value of namesz is zero, there is no name present. */
779fe533 15501static int
2cf0635d 15502process_note (Elf_Internal_Note * pnote)
779fe533 15503{
2cf0635d
NC		 15504 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15505 const char * nt;
9437c45b
JT		 15506
15507 if (pnote->namesz == 0)
1ec5cd37
NC		 15508 /* If there is no note name, then use the default set of
15509 note type strings. */
15510 nt = get_note_type (pnote->type);
15511
1118d252
RM		 15512 else if (const_strneq (pnote->namedata, "GNU"))
15513 /* GNU-specific object file notes. */
15514 nt = get_gnu_elf_note_type (pnote->type);
15515
0112cd26 15516 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15517 /* NetBSD-specific core file notes. */
15518 nt = get_netbsd_elfcore_note_type (pnote->type);
15519
b15fa79e
AM		 15520 else if (strneq (pnote->namedata, "SPU/", 4))
15521 {
15522 /* SPU-specific core file notes. */
15523 nt = pnote->namedata + 4;
15524 name = "SPU";
15525 }
15526
00e98fc7
TG		 15527 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15528 /* VMS/ia64-specific file notes. */
15529 nt = get_ia64_vms_note_type (pnote->type);
15530
70616151
TT		 15531 else if (const_strneq (pnote->namedata, "stapsdt"))
15532 nt = get_stapsdt_note_type (pnote->type);
15533
9437c45b 15534 else
1ec5cd37
NC		 15535 /* Don't recognize this note name; just use the default set of
15536 note type strings. */
00e98fc7 15537 nt = get_note_type (pnote->type);
9437c45b 15538
2aee03ae 15539 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15540
15541 if (const_strneq (pnote->namedata, "IPF/VMS"))
15542 return print_ia64_vms_note (pnote);
664f90a3
TT		 15543 else if (const_strneq (pnote->namedata, "GNU"))
15544 return print_gnu_note (pnote);
c6a9fc58
TT		 15545 else if (const_strneq (pnote->namedata, "stapsdt"))
15546 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15547 else if (const_strneq (pnote->namedata, "CORE"))
15548 return print_core_note (pnote);
00e98fc7
TG		 15549 else
15550 return 1;
779fe533
NC		 15551}
15552
6d118b09 15553
779fe533 15554static int
2cf0635d 15555process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15556{
2cf0635d
NC		 15557 Elf_External_Note * pnotes;
15558 Elf_External_Note * external;
c8071705 15559 char * end;
b34976b6 15560 int res = 1;
103f02d3 15561
779fe533
NC		 15562 if (length <= 0)
15563 return 0;
103f02d3 15564
3f5e193b 15565 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15566 _("notes"));
dd24e3da 15567 if (pnotes == NULL)
a6e9f9df 15568 return 0;
779fe533 15569
103f02d3 15570 external = pnotes;
103f02d3 15571
9dd3a467 15572 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15573 (unsigned long) offset, (unsigned long) length);
2aee03ae 15574 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15575
c8071705
NC		 15576 end = (char *) pnotes + length;
15577 while ((char *) external < end)
779fe533 15578 {
b34976b6 15579 Elf_Internal_Note inote;
15b42fb0
AM		 15580 size_t min_notesz;
15581 char *next;
2cf0635d 15582 char * temp = NULL;
c8071705 15583 size_t data_remaining = end - (char *) external;
6d118b09 15584
00e98fc7 15585 if (!is_ia64_vms ())
15b42fb0 15586 {
9dd3a467
NC		 15587 /* PR binutils/15191
15588 Make sure that there is enough data to read. */
15b42fb0
AM		 15589 min_notesz = offsetof (Elf_External_Note, name);
15590 if (data_remaining < min_notesz)
9dd3a467
NC		 15591 {
15592 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15593 (int) data_remaining);
15594 break;
15595 }
15b42fb0
AM		 15596 inote.type = BYTE_GET (external->type);
15597 inote.namesz = BYTE_GET (external->namesz);
15598 inote.namedata = external->name;
15599 inote.descsz = BYTE_GET (external->descsz);
15600 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15601 /* PR 17531: file: 3443835e. */
c8071705 15602 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15603 {
15604 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15605 inote.descdata = inote.namedata;
15606 inote.namesz = 0;
15607 }
14ae95f2 15608
15b42fb0
AM		 15609 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15610 next = inote.descdata + align_power (inote.descsz, 2);
15611 }
00e98fc7 15612 else
15b42fb0
AM		 15613 {
15614 Elf64_External_VMS_Note *vms_external;
00e98fc7 15615
9dd3a467
NC		 15616 /* PR binutils/15191
15617 Make sure that there is enough data to read. */
15b42fb0
AM		 15618 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15619 if (data_remaining < min_notesz)
9dd3a467
NC		 15620 {
15621 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15622 (int) data_remaining);
15623 break;
15624 }
3e55a963 15625
15b42fb0
AM		 15626 vms_external = (Elf64_External_VMS_Note *) external;
15627 inote.type = BYTE_GET (vms_external->type);
15628 inote.namesz = BYTE_GET (vms_external->namesz);
15629 inote.namedata = vms_external->name;
15630 inote.descsz = BYTE_GET (vms_external->descsz);
15631 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15632 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15633 next = inote.descdata + align_power (inote.descsz, 3);
15634 }
15635
15636 if (inote.descdata < (char *) external + min_notesz
15637 || next < (char *) external + min_notesz
5d921cbd
NC		 15638 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15639 || inote.namedata + inote.namesz < inote.namedata
15640 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15641 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15642 {
15b42fb0 15643 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15644 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15645 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15646 inote.type, inote.namesz, inote.descsz);
15647 break;
15648 }
15649
15b42fb0 15650 external = (Elf_External_Note *) next;
dd24e3da 15651
6d118b09
NC		 15652 /* Verify that name is null terminated. It appears that at least
15653 one version of Linux (RedHat 6.0) generates corefiles that don't
15654 comply with the ELF spec by failing to include the null byte in
15655 namesz. */
8b971f9f 15656 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15657 {
3f5e193b 15658 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15659 if (temp == NULL)
15660 {
8b73c356 15661 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15662 res = 0;
15663 break;
15664 }
76da6bbe 15665
6d118b09
NC		 15666 strncpy (temp, inote.namedata, inote.namesz);
15667 temp[inote.namesz] = 0;
76da6bbe 15668
6d118b09
NC		 15669 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15670 inote.namedata = temp;
15671 }
15672
15673 res &= process_note (& inote);
103f02d3 15674
6d118b09
NC		 15675 if (temp != NULL)
15676 {
15677 free (temp);
15678 temp = NULL;
15679 }
779fe533
NC		 15680 }
15681
15682 free (pnotes);
103f02d3 15683
779fe533
NC		 15684 return res;
15685}
15686
15687static int
2cf0635d 15688process_corefile_note_segments (FILE * file)
779fe533 15689{
2cf0635d 15690 Elf_Internal_Phdr * segment;
b34976b6
AM		 15691 unsigned int i;
15692 int res = 1;
103f02d3 15693
d93f0186 15694 if (! get_program_headers (file))
779fe533 15695 return 0;
103f02d3 15696
779fe533
NC		 15697 for (i = 0, segment = program_headers;
15698 i < elf_header.e_phnum;
b34976b6 15699 i++, segment++)
779fe533
NC		 15700 {
15701 if (segment->p_type == PT_NOTE)
103f02d3 15702 res &= process_corefile_note_segment (file,
30800947
NC		 15703 (bfd_vma) segment->p_offset,
15704 (bfd_vma) segment->p_filesz);
779fe533 15705 }
103f02d3 15706
779fe533
NC		 15707 return res;
15708}
15709
685080f2
NC		 15710static int
15711process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15712{
15713 Elf_External_Note * pnotes;
15714 Elf_External_Note * external;
c8071705 15715 char * end;
685080f2
NC		 15716 int res = 1;
15717
15718 if (length <= 0)
15719 return 0;
15720
15721 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15722 _("v850 notes"));
15723 if (pnotes == NULL)
15724 return 0;
15725
15726 external = pnotes;
c8071705 15727 end = (char*) pnotes + length;
685080f2
NC		 15728
15729 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15730 (unsigned long) offset, (unsigned long) length);
15731
c8071705 15732 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15733 {
15734 Elf_External_Note * next;
15735 Elf_Internal_Note inote;
15736
15737 inote.type = BYTE_GET (external->type);
15738 inote.namesz = BYTE_GET (external->namesz);
15739 inote.namedata = external->name;
15740 inote.descsz = BYTE_GET (external->descsz);
15741 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15742 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15743
c8071705
NC		 15744 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15745 {
15746 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15747 inote.descdata = inote.namedata;
15748 inote.namesz = 0;
15749 }
15750
685080f2
NC		 15751 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15752
c8071705 15753 if ( ((char *) next > end)
685080f2
NC		 15754 || ((char *) next < (char *) pnotes))
15755 {
15756 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15757 (unsigned long) ((char *) external - (char *) pnotes));
15758 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15759 inote.type, inote.namesz, inote.descsz);
15760 break;
15761 }
15762
15763 external = next;
15764
15765 /* Prevent out-of-bounds indexing. */
c8071705 15766 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15767 || inote.namedata + inote.namesz < inote.namedata)
15768 {
15769 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15770 (unsigned long) ((char *) external - (char *) pnotes));
15771 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15772 inote.type, inote.namesz, inote.descsz);
15773 break;
15774 }
15775
15776 printf (" %s: ", get_v850_elf_note_type (inote.type));
15777
15778 if (! print_v850_note (& inote))
15779 {
15780 res = 0;
15781 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15782 inote.namesz, inote.descsz);
15783 }
15784 }
15785
15786 free (pnotes);
15787
15788 return res;
15789}
15790
779fe533 15791static int
2cf0635d 15792process_note_sections (FILE * file)
1ec5cd37 15793{
2cf0635d 15794 Elf_Internal_Shdr * section;
1ec5cd37 15795 unsigned long i;
df565f32 15796 int n = 0;
1ec5cd37
NC		 15797 int res = 1;
15798
15799 for (i = 0, section = section_headers;
fa1908fd 15800 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15801 i++, section++)
685080f2
NC		 15802 {
15803 if (section->sh_type == SHT_NOTE)
15804 {
15805 res &= process_corefile_note_segment (file,
15806 (bfd_vma) section->sh_offset,
15807 (bfd_vma) section->sh_size);
15808 n++;
15809 }
15810
15811 if (( elf_header.e_machine == EM_V800
15812 || elf_header.e_machine == EM_V850
15813 || elf_header.e_machine == EM_CYGNUS_V850)
15814 && section->sh_type == SHT_RENESAS_INFO)
15815 {
15816 res &= process_v850_notes (file,
15817 (bfd_vma) section->sh_offset,
15818 (bfd_vma) section->sh_size);
15819 n++;
15820 }
15821 }
df565f32
NC		 15822
15823 if (n == 0)
15824 /* Try processing NOTE segments instead. */
15825 return process_corefile_note_segments (file);
1ec5cd37
NC		 15826
15827 return res;
15828}
15829
15830static int
2cf0635d 15831process_notes (FILE * file)
779fe533
NC		 15832{
15833 /* If we have not been asked to display the notes then do nothing. */
15834 if (! do_notes)
15835 return 1;
103f02d3 15836
779fe533 15837 if (elf_header.e_type != ET_CORE)
1ec5cd37 15838 return process_note_sections (file);
103f02d3 15839
779fe533 15840 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15841 if (elf_header.e_phnum > 0)
15842 return process_corefile_note_segments (file);
779fe533 15843
1ec5cd37
NC		 15844 printf (_("No note segments present in the core file.\n"));
15845 return 1;
779fe533
NC		 15846}
15847
252b5132 15848static int
2cf0635d 15849process_arch_specific (FILE * file)
252b5132 15850{
a952a375
NC		 15851 if (! do_arch)
15852 return 1;
15853
252b5132
RH		 15854 switch (elf_header.e_machine)
15855 {
11c1ff18
PB		 15856 case EM_ARM:
15857 return process_arm_specific (file);
252b5132 15858 case EM_MIPS:
4fe85591 15859 case EM_MIPS_RS3_LE:
252b5132
RH		 15860 return process_mips_specific (file);
15861 break;
35c08157
KLC		 15862 case EM_NDS32:
15863 return process_nds32_specific (file);
15864 break;
34c8bcba
JM		 15865 case EM_PPC:
15866 return process_power_specific (file);
15867 break;
643f7afb
AK		 15868 case EM_S390:
15869 case EM_S390_OLD:
15870 return process_s390_specific (file);
15871 break;
9e8c70f9
DM		 15872 case EM_SPARC:
15873 case EM_SPARC32PLUS:
15874 case EM_SPARCV9:
15875 return process_sparc_specific (file);
15876 break;
59e6276b
JM		 15877 case EM_TI_C6000:
15878 return process_tic6x_specific (file);
15879 break;
13761a11
NC		 15880 case EM_MSP430:
15881 return process_msp430x_specific (file);
252b5132
RH		 15882 default:
15883 break;
15884 }
15885 return 1;
15886}
15887
15888static int
2cf0635d 15889get_file_header (FILE * file)
252b5132 15890{
9ea033b2
NC		 15891 /* Read in the identity array. */
15892 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15893 return 0;
15894
9ea033b2 15895 /* Determine how to read the rest of the header. */
b34976b6 15896 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15897 {
15898 default: /* fall through */
15899 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15900 case ELFDATA2LSB:
15901 byte_get = byte_get_little_endian;
15902 byte_put = byte_put_little_endian;
15903 break;
15904 case ELFDATA2MSB:
15905 byte_get = byte_get_big_endian;
15906 byte_put = byte_put_big_endian;
15907 break;
9ea033b2
NC		 15908 }
15909
15910 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15911 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15912
15913 /* Read in the rest of the header. */
15914 if (is_32bit_elf)
15915 {
15916 Elf32_External_Ehdr ehdr32;
252b5132 15917
9ea033b2
NC		 15918 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15919 return 0;
103f02d3 15920
9ea033b2
NC		 15921 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15922 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15923 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15924 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15925 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15926 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15927 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15928 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15929 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15930 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15931 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15932 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15933 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15934 }
252b5132 15935 else
9ea033b2
NC		 15936 {
15937 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15938
15939 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15940 we will not be able to cope with the 64bit data found in
15941 64 ELF files. Detect this now and abort before we start
50c2245b 15942 overwriting things. */
a952a375
NC		 15943 if (sizeof (bfd_vma) < 8)
15944 {
e3c8793a
NC		 15945 error (_("This instance of readelf has been built without support for a\n\
1594664 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15947 return 0;
15948 }
103f02d3 15949
9ea033b2
NC		 15950 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15951 return 0;
103f02d3 15952
9ea033b2
NC		 15953 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15954 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15955 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15956 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15957 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15958 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15959 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15960 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15961 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15962 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15963 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15964 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15965 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15966 }
252b5132 15967
7ece0d85
JJ		 15968 if (elf_header.e_shoff)
15969 {
15970 /* There may be some extensions in the first section header. Don't
15971 bomb if we can't read it. */
15972 if (is_32bit_elf)
049b0c3a 15973 get_32bit_section_headers (file, TRUE);
7ece0d85 15974 else
049b0c3a 15975 get_64bit_section_headers (file, TRUE);
7ece0d85 15976 }
560f3c1c 15977
252b5132
RH		 15978 return 1;
15979}
15980
fb52b2f4
NC		 15981/* Process one ELF object file according to the command line options.
15982 This file may actually be stored in an archive. The file is
15983 positioned at the start of the ELF object. */
15984
ff78d6d6 15985static int
2cf0635d 15986process_object (char * file_name, FILE * file)
252b5132 15987{
252b5132
RH		 15988 unsigned int i;
15989
252b5132
RH		 15990 if (! get_file_header (file))
15991 {
15992 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15993 return 1;
252b5132
RH		 15994 }
15995
15996 /* Initialise per file variables. */
60bca95a 15997 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15998 version_info[i] = 0;
15999
60bca95a 16000 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16001 dynamic_info[i] = 0;
5115b233 16002 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16003
16004 /* Process the file. */
16005 if (show_name)
16006 printf (_("\nFile: %s\n"), file_name);
16007
18bd398b
NC		 16008 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16009 Note we do this even if cmdline_dump_sects is empty because we
16010 must make sure that the dump_sets array is zeroed out before each
16011 object file is processed. */
16012 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16013 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16014
16015 if (num_cmdline_dump_sects > 0)
16016 {
16017 if (num_dump_sects == 0)
16018 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16019 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16020
16021 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16022 memcpy (dump_sects, cmdline_dump_sects,
16023 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16024 }
d70c5fc7 16025
252b5132 16026 if (! process_file_header ())
fb52b2f4 16027 return 1;
252b5132 16028
d1f5c6e3 16029 if (! process_section_headers (file))
2f62977e 16030 {
d1f5c6e3
L		 16031 /* Without loaded section headers we cannot process lots of
16032 things. */
2f62977e 16033 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16034
2f62977e 16035 if (! do_using_dynamic)
2c610e4b 16036 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16037 }
252b5132 16038
d1f5c6e3
L		 16039 if (! process_section_groups (file))
16040 {
16041 /* Without loaded section groups we cannot process unwind. */
16042 do_unwind = 0;
16043 }
16044
2f62977e 16045 if (process_program_headers (file))
b2d38a17 16046 process_dynamic_section (file);
252b5132
RH		 16047
16048 process_relocs (file);
16049
4d6ed7c8
NC		 16050 process_unwind (file);
16051
252b5132
RH		 16052 process_symbol_table (file);
16053
16054 process_syminfo (file);
16055
16056 process_version_sections (file);
16057
16058 process_section_contents (file);
f5842774 16059
1ec5cd37 16060 process_notes (file);
103f02d3 16061
047b2264
JJ		 16062 process_gnu_liblist (file);
16063
252b5132
RH		 16064 process_arch_specific (file);
16065
d93f0186
NC		 16066 if (program_headers)
16067 {
16068 free (program_headers);
16069 program_headers = NULL;
16070 }
16071
252b5132
RH		 16072 if (section_headers)
16073 {
16074 free (section_headers);
16075 section_headers = NULL;
16076 }
16077
16078 if (string_table)
16079 {
16080 free (string_table);
16081 string_table = NULL;
d40ac9bd 16082 string_table_length = 0;
252b5132
RH		 16083 }
16084
16085 if (dynamic_strings)
16086 {
16087 free (dynamic_strings);
16088 dynamic_strings = NULL;
d79b3d50 16089 dynamic_strings_length = 0;
252b5132
RH		 16090 }
16091
16092 if (dynamic_symbols)
16093 {
16094 free (dynamic_symbols);
16095 dynamic_symbols = NULL;
19936277 16096 num_dynamic_syms = 0;
252b5132
RH		 16097 }
16098
16099 if (dynamic_syminfo)
16100 {
16101 free (dynamic_syminfo);
16102 dynamic_syminfo = NULL;
16103 }
ff78d6d6 16104
293c573e
MR		 16105 if (dynamic_section)
16106 {
16107 free (dynamic_section);
16108 dynamic_section = NULL;
16109 }
16110
e4b17d5c
L		 16111 if (section_headers_groups)
16112 {
16113 free (section_headers_groups);
16114 section_headers_groups = NULL;
16115 }
16116
16117 if (section_groups)
16118 {
2cf0635d
NC		 16119 struct group_list * g;
16120 struct group_list * next;
e4b17d5c
L		 16121
16122 for (i = 0; i < group_count; i++)
16123 {
16124 for (g = section_groups [i].root; g != NULL; g = next)
16125 {
16126 next = g->next;
16127 free (g);
16128 }
16129 }
16130
16131 free (section_groups);
16132 section_groups = NULL;
16133 }
16134
19e6b90e 16135 free_debug_memory ();
18bd398b 16136
ff78d6d6 16137 return 0;
252b5132
RH		 16138}
16139
2cf0635d
NC		 16140/* Process an ELF archive.
16141 On entry the file is positioned just after the ARMAG string. */
16142
16143static int
16144process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16145{
16146 struct archive_info arch;
16147 struct archive_info nested_arch;
16148 size_t got;
2cf0635d
NC		 16149 int ret;
16150
16151 show_name = 1;
16152
16153 /* The ARCH structure is used to hold information about this archive. */
16154 arch.file_name = NULL;
16155 arch.file = NULL;
16156 arch.index_array = NULL;
16157 arch.sym_table = NULL;
16158 arch.longnames = NULL;
16159
16160 /* The NESTED_ARCH structure is used as a single-item cache of information
16161 about a nested archive (when members of a thin archive reside within
16162 another regular archive file). */
16163 nested_arch.file_name = NULL;
16164 nested_arch.file = NULL;
16165 nested_arch.index_array = NULL;
16166 nested_arch.sym_table = NULL;
16167 nested_arch.longnames = NULL;
16168
16169 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16170 {
16171 ret = 1;
16172 goto out;
4145f1d5 16173 }
fb52b2f4 16174
4145f1d5
NC		 16175 if (do_archive_index)
16176 {
2cf0635d 16177 if (arch.sym_table == NULL)
4145f1d5
NC		 16178 error (_("%s: unable to dump the index as none was found\n"), file_name);
16179 else
16180 {
591f7597 16181 unsigned long i, l;
4145f1d5
NC		 16182 unsigned long current_pos;
16183
591f7597
NC		 16184 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16185 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16186 current_pos = ftell (file);
16187
2cf0635d 16188 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16189 {
2cf0635d
NC		 16190 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16191 {
16192 char * member_name;
4145f1d5 16193
2cf0635d
NC		 16194 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16195
16196 if (member_name != NULL)
16197 {
16198 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16199
16200 if (qualified_name != NULL)
16201 {
c2a7d3f5
NC		 16202 printf (_("Contents of binary %s at offset "), qualified_name);
16203 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16204 putchar ('\n');
2cf0635d
NC		 16205 free (qualified_name);
16206 }
4145f1d5
NC		 16207 }
16208 }
2cf0635d
NC		 16209
16210 if (l >= arch.sym_size)
4145f1d5
NC		 16211 {
16212 error (_("%s: end of the symbol table reached before the end of the index\n"),
16213 file_name);
cb8f3167 16214 break;
4145f1d5 16215 }
591f7597
NC		 16216 /* PR 17531: file: 0b6630b2. */
16217 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16218 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16219 }
16220
c2a7d3f5
NC		 16221 if (arch.uses_64bit_indicies)
16222 l = (l + 7) & ~ 7;
16223 else
16224 l += l & 1;
16225
2cf0635d 16226 if (l < arch.sym_size)
c2a7d3f5
NC		 16227 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16228 file_name, arch.sym_size - l);
4145f1d5 16229
4145f1d5
NC		 16230 if (fseek (file, current_pos, SEEK_SET) != 0)
16231 {
16232 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16233 ret = 1;
16234 goto out;
4145f1d5 16235 }
fb52b2f4 16236 }
4145f1d5
NC		 16237
16238 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16239 && !do_segments && !do_header && !do_dump && !do_version
16240 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16241 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16242 {
16243 ret = 0; /* Archive index only. */
16244 goto out;
16245 }
fb52b2f4
NC		 16246 }
16247
d989285c 16248 ret = 0;
fb52b2f4
NC		 16249
16250 while (1)
16251 {
2cf0635d
NC		 16252 char * name;
16253 size_t namelen;
16254 char * qualified_name;
16255
16256 /* Read the next archive header. */
16257 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16258 {
16259 error (_("%s: failed to seek to next archive header\n"), file_name);
16260 return 1;
16261 }
16262 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16263 if (got != sizeof arch.arhdr)
16264 {
16265 if (got == 0)
16266 break;
16267 error (_("%s: failed to read archive header\n"), file_name);
16268 ret = 1;
16269 break;
16270 }
16271 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16272 {
16273 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16274 ret = 1;
16275 break;
16276 }
16277
16278 arch.next_arhdr_offset += sizeof arch.arhdr;
16279
16280 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16281 if (archive_file_size & 01)
16282 ++archive_file_size;
16283
16284 name = get_archive_member_name (&arch, &nested_arch);
16285 if (name == NULL)
fb52b2f4 16286 {
0fd3a477 16287 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16288 ret = 1;
16289 break;
fb52b2f4 16290 }
2cf0635d 16291 namelen = strlen (name);
fb52b2f4 16292
2cf0635d
NC		 16293 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16294 if (qualified_name == NULL)
fb52b2f4 16295 {
2cf0635d 16296 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16297 ret = 1;
16298 break;
fb52b2f4
NC		 16299 }
16300
2cf0635d
NC		 16301 if (is_thin_archive && arch.nested_member_origin == 0)
16302 {
16303 /* This is a proxy for an external member of a thin archive. */
16304 FILE * member_file;
16305 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16306 if (member_file_name == NULL)
16307 {
16308 ret = 1;
16309 break;
16310 }
16311
16312 member_file = fopen (member_file_name, "rb");
16313 if (member_file == NULL)
16314 {
16315 error (_("Input file '%s' is not readable.\n"), member_file_name);
16316 free (member_file_name);
16317 ret = 1;
16318 break;
16319 }
16320
16321 archive_file_offset = arch.nested_member_origin;
16322
16323 ret |= process_object (qualified_name, member_file);
16324
16325 fclose (member_file);
16326 free (member_file_name);
16327 }
16328 else if (is_thin_archive)
16329 {
a043396b
NC		 16330 /* PR 15140: Allow for corrupt thin archives. */
16331 if (nested_arch.file == NULL)
16332 {
16333 error (_("%s: contains corrupt thin archive: %s\n"),
16334 file_name, name);
16335 ret = 1;
16336 break;
16337 }
16338
2cf0635d
NC		 16339 /* This is a proxy for a member of a nested archive. */
16340 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16341
16342 /* The nested archive file will have been opened and setup by
16343 get_archive_member_name. */
16344 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16345 {
16346 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16347 ret = 1;
16348 break;
16349 }
16350
16351 ret |= process_object (qualified_name, nested_arch.file);
16352 }
16353 else
16354 {
16355 archive_file_offset = arch.next_arhdr_offset;
16356 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16357
2cf0635d
NC		 16358 ret |= process_object (qualified_name, file);
16359 }
fb52b2f4 16360
2b52916e
L		 16361 if (dump_sects != NULL)
16362 {
16363 free (dump_sects);
16364 dump_sects = NULL;
16365 num_dump_sects = 0;
16366 }
16367
2cf0635d 16368 free (qualified_name);
fb52b2f4
NC		 16369 }
16370
4145f1d5 16371 out:
2cf0635d
NC		 16372 if (nested_arch.file != NULL)
16373 fclose (nested_arch.file);
16374 release_archive (&nested_arch);
16375 release_archive (&arch);
fb52b2f4 16376
d989285c 16377 return ret;
fb52b2f4
NC		 16378}
16379
16380static int
2cf0635d 16381process_file (char * file_name)
fb52b2f4 16382{
2cf0635d 16383 FILE * file;
fb52b2f4
NC		 16384 struct stat statbuf;
16385 char armag[SARMAG];
16386 int ret;
16387
16388 if (stat (file_name, &statbuf) < 0)
16389 {
f24ddbdd
NC		 16390 if (errno == ENOENT)
16391 error (_("'%s': No such file\n"), file_name);
16392 else
16393 error (_("Could not locate '%s'. System error message: %s\n"),
16394 file_name, strerror (errno));
16395 return 1;
16396 }
16397
16398 if (! S_ISREG (statbuf.st_mode))
16399 {
16400 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16401 return 1;
16402 }
16403
16404 file = fopen (file_name, "rb");
16405 if (file == NULL)
16406 {
f24ddbdd 16407 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16408 return 1;
16409 }
16410
16411 if (fread (armag, SARMAG, 1, file) != 1)
16412 {
4145f1d5 16413 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16414 fclose (file);
16415 return 1;
16416 }
16417
f54498b4
NC		 16418 current_file_size = (bfd_size_type) statbuf.st_size;
16419
fb52b2f4 16420 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16421 ret = process_archive (file_name, file, FALSE);
16422 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16423 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16424 else
16425 {
4145f1d5
NC		 16426 if (do_archive_index)
16427 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16428 file_name);
16429
fb52b2f4
NC		 16430 rewind (file);
16431 archive_file_size = archive_file_offset = 0;
16432 ret = process_object (file_name, file);
16433 }
16434
16435 fclose (file);
16436
f54498b4 16437 current_file_size = 0;
fb52b2f4
NC		 16438 return ret;
16439}
16440
252b5132
RH		 16441#ifdef SUPPORT_DISASSEMBLY
16442/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16443 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16444 symbols. */
252b5132
RH		 16445
16446void
2cf0635d 16447print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16448{
16449 fprintf (outfile,"0x%8.8x", addr);
16450}
16451
e3c8793a 16452/* Needed by the i386 disassembler. */
252b5132
RH		 16453void
16454db_task_printsym (unsigned int addr)
16455{
16456 print_address (addr, stderr);
16457}
16458#endif
16459
16460int
2cf0635d 16461main (int argc, char ** argv)
252b5132 16462{
ff78d6d6
L		 16463 int err;
16464
252b5132
RH		 16465#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16466 setlocale (LC_MESSAGES, "");
3882b010
L		 16467#endif
16468#if defined (HAVE_SETLOCALE)
16469 setlocale (LC_CTYPE, "");
252b5132
RH		 16470#endif
16471 bindtextdomain (PACKAGE, LOCALEDIR);
16472 textdomain (PACKAGE);
16473
869b9d07
MM		 16474 expandargv (&argc, &argv);
16475
252b5132
RH		 16476 parse_args (argc, argv);
16477
18bd398b 16478 if (num_dump_sects > 0)
59f14fc0 16479 {
18bd398b 16480 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16481 cmdline_dump_sects = (dump_type *)
16482 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16483 if (cmdline_dump_sects == NULL)
591a748a 16484 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16485 else
16486 {
09c11c86
NC		 16487 memcpy (cmdline_dump_sects, dump_sects,
16488 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16489 num_cmdline_dump_sects = num_dump_sects;
16490 }
16491 }
16492
18bd398b
NC		 16493 if (optind < (argc - 1))
16494 show_name = 1;
5656ba2c
L		 16495 else if (optind >= argc)
16496 {
16497 warn (_("Nothing to do.\n"));
16498 usage (stderr);
16499 }
18bd398b 16500
ff78d6d6 16501 err = 0;
252b5132 16502 while (optind < argc)
18bd398b 16503 err |= process_file (argv[optind++]);
252b5132
RH		 16504
16505 if (dump_sects != NULL)
16506 free (dump_sects);
59f14fc0
AS		 16507 if (cmdline_dump_sects != NULL)
16508 free (cmdline_dump_sects);
252b5132 16509
ff78d6d6 16510 return err;
252b5132 16511}
A mirror of the official binutils-gdb repository