]> 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
Updated to accept .debug_* sections
[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;
071436c6 8686 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
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;
071436c6
NC		 8734 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8735 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
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
12033 if (chdr.ch_type == ELFCOMPRESS_ZLIB
12034 && chdr.ch_addralign == section->sh_addralign)
12035 {
12036 uncompressed_size = chdr.ch_size;
12037 start += compression_header_size;
12038 new_size -= compression_header_size;
12039 }
12040 }
12041 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12042 {
12043 /* Read the zlib header. In this case, it should be "ZLIB"
12044 followed by the uncompressed section size, 8 bytes in
12045 big-endian order. */
12046 uncompressed_size = start[4]; uncompressed_size <<= 8;
12047 uncompressed_size += start[5]; uncompressed_size <<= 8;
12048 uncompressed_size += start[6]; uncompressed_size <<= 8;
12049 uncompressed_size += start[7]; uncompressed_size <<= 8;
12050 uncompressed_size += start[8]; uncompressed_size <<= 8;
12051 uncompressed_size += start[9]; uncompressed_size <<= 8;
12052 uncompressed_size += start[10]; uncompressed_size <<= 8;
12053 uncompressed_size += start[11];
12054 start += 12;
12055 new_size -= 12;
12056 }
12057
12058 if (uncompressed_size
fd8008d8 12059 && uncompress_section_contents (& start,
0e602686
NC		 12060 uncompressed_size, & new_size))
12061 num_bytes = new_size;
12062 }
fd8008d8 12063
cf13d699
NC		 12064 /* If the section being dumped has relocations against it the user might
12065 be expecting these relocations to have been applied. Check for this
12066 case and issue a warning message in order to avoid confusion.
12067 FIXME: Maybe we ought to have an option that dumps a section with
12068 relocs applied ? */
12069 for (relsec = section_headers;
12070 relsec < section_headers + elf_header.e_shnum;
12071 ++relsec)
12072 {
12073 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12074 || relsec->sh_info >= elf_header.e_shnum
12075 || section_headers + relsec->sh_info != section
12076 || relsec->sh_size == 0
12077 || relsec->sh_link >= elf_header.e_shnum)
12078 continue;
12079
12080 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12081 break;
12082 }
12083
cf13d699
NC		 12084 data = start;
12085 end = start + num_bytes;
12086 some_strings_shown = FALSE;
12087
12088 while (data < end)
12089 {
12090 while (!ISPRINT (* data))
12091 if (++ data >= end)
12092 break;
12093
12094 if (data < end)
12095 {
071436c6
NC		 12096 size_t maxlen = end - data;
12097
cf13d699 12098#ifndef __MSVCRT__
c975cc98
NC		 12099 /* PR 11128: Use two separate invocations in order to work
12100 around bugs in the Solaris 8 implementation of printf. */
12101 printf (" [%6tx] ", data - start);
cf13d699 12102#else
071436c6 12103 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12104#endif
4082ef84
NC		 12105 if (maxlen > 0)
12106 {
fd8008d8 12107 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12108 putchar ('\n');
fd8008d8 12109 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12110 }
12111 else
12112 {
12113 printf (_("<corrupt>\n"));
12114 data = end;
12115 }
cf13d699
NC		 12116 some_strings_shown = TRUE;
12117 }
12118 }
12119
12120 if (! some_strings_shown)
12121 printf (_(" No strings found in this section."));
12122
0e602686 12123 free (real_start);
cf13d699
NC		 12124
12125 putchar ('\n');
12126}
12127
12128static void
12129dump_section_as_bytes (Elf_Internal_Shdr * section,
12130 FILE * file,
12131 bfd_boolean relocate)
12132{
12133 Elf_Internal_Shdr * relsec;
0e602686
NC		 12134 bfd_size_type bytes;
12135 bfd_size_type section_size;
12136 bfd_vma addr;
12137 unsigned char * data;
12138 unsigned char * real_start;
12139 unsigned char * start;
12140
12141 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12142 if (start == NULL)
12143 return;
0e602686 12144 section_size = section->sh_size;
cf13d699 12145
74e1a04b 12146 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12147
0e602686
NC		 12148 if (decompress_dumps)
12149 {
12150 dwarf_size_type new_size = section_size;
12151 dwarf_size_type uncompressed_size = 0;
12152
12153 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12154 {
12155 Elf_Internal_Chdr chdr;
12156 unsigned int compression_header_size
12157 = get_compression_header (& chdr, start);
12158
12159 if (chdr.ch_type == ELFCOMPRESS_ZLIB
12160 && chdr.ch_addralign == section->sh_addralign)
12161 {
12162 uncompressed_size = chdr.ch_size;
12163 start += compression_header_size;
12164 new_size -= compression_header_size;
12165 }
12166 }
12167 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12168 {
12169 /* Read the zlib header. In this case, it should be "ZLIB"
12170 followed by the uncompressed section size, 8 bytes in
12171 big-endian order. */
12172 uncompressed_size = start[4]; uncompressed_size <<= 8;
12173 uncompressed_size += start[5]; uncompressed_size <<= 8;
12174 uncompressed_size += start[6]; uncompressed_size <<= 8;
12175 uncompressed_size += start[7]; uncompressed_size <<= 8;
12176 uncompressed_size += start[8]; uncompressed_size <<= 8;
12177 uncompressed_size += start[9]; uncompressed_size <<= 8;
12178 uncompressed_size += start[10]; uncompressed_size <<= 8;
12179 uncompressed_size += start[11];
12180 start += 12;
12181 new_size -= 12;
12182 }
12183
12184 if (uncompressed_size
12185 && uncompress_section_contents (& start, uncompressed_size,
12186 & new_size))
12187 section_size = new_size;
12188 }
14ae95f2 12189
cf13d699
NC		 12190 if (relocate)
12191 {
0e602686 12192 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12193 }
12194 else
12195 {
12196 /* If the section being dumped has relocations against it the user might
12197 be expecting these relocations to have been applied. Check for this
12198 case and issue a warning message in order to avoid confusion.
12199 FIXME: Maybe we ought to have an option that dumps a section with
12200 relocs applied ? */
12201 for (relsec = section_headers;
12202 relsec < section_headers + elf_header.e_shnum;
12203 ++relsec)
12204 {
12205 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12206 || relsec->sh_info >= elf_header.e_shnum
12207 || section_headers + relsec->sh_info != section
12208 || relsec->sh_size == 0
12209 || relsec->sh_link >= elf_header.e_shnum)
12210 continue;
12211
12212 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12213 break;
12214 }
12215 }
12216
12217 addr = section->sh_addr;
0e602686 12218 bytes = section_size;
cf13d699
NC		 12219 data = start;
12220
12221 while (bytes)
12222 {
12223 int j;
12224 int k;
12225 int lbytes;
12226
12227 lbytes = (bytes > 16 ? 16 : bytes);
12228
12229 printf (" 0x%8.8lx ", (unsigned long) addr);
12230
12231 for (j = 0; j < 16; j++)
12232 {
12233 if (j < lbytes)
12234 printf ("%2.2x", data[j]);
12235 else
12236 printf (" ");
12237
12238 if ((j & 3) == 3)
12239 printf (" ");
12240 }
12241
12242 for (j = 0; j < lbytes; j++)
12243 {
12244 k = data[j];
12245 if (k >= ' ' && k < 0x7f)
12246 printf ("%c", k);
12247 else
12248 printf (".");
12249 }
12250
12251 putchar ('\n');
12252
12253 data += lbytes;
12254 addr += lbytes;
12255 bytes -= lbytes;
12256 }
12257
0e602686 12258 free (real_start);
cf13d699
NC		 12259
12260 putchar ('\n');
12261}
12262
d966045b
DJ		 12263static int
12264load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12265 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12266{
2cf0635d 12267 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12268 char buf [64];
1007acb3 12269
19e6b90e
L		 12270 /* If it is already loaded, do nothing. */
12271 if (section->start != NULL)
12272 return 1;
1007acb3 12273
19e6b90e
L		 12274 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12275 section->address = sec->sh_addr;
06614111 12276 section->user_data = NULL;
3f5e193b
NC		 12277 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12278 sec->sh_offset, 1,
12279 sec->sh_size, buf);
59245841
NC		 12280 if (section->start == NULL)
12281 section->size = 0;
12282 else
12283 {
77115a4a
L		 12284 unsigned char *start = section->start;
12285 dwarf_size_type size = sec->sh_size;
dab394de 12286 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12287
12288 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12289 {
12290 Elf_Internal_Chdr chdr;
12291 unsigned int compression_header_size
12292 = get_compression_header (&chdr, start);
12293 if (chdr.ch_type != ELFCOMPRESS_ZLIB
12294 || chdr.ch_addralign != sec->sh_addralign)
12295 return 0;
dab394de 12296 uncompressed_size = chdr.ch_size;
77115a4a
L		 12297 start += compression_header_size;
12298 size -= compression_header_size;
12299 }
dab394de
L		 12300 else if (size > 12 && streq ((char *) start, "ZLIB"))
12301 {
12302 /* Read the zlib header. In this case, it should be "ZLIB"
12303 followed by the uncompressed section size, 8 bytes in
12304 big-endian order. */
12305 uncompressed_size = start[4]; uncompressed_size <<= 8;
12306 uncompressed_size += start[5]; uncompressed_size <<= 8;
12307 uncompressed_size += start[6]; uncompressed_size <<= 8;
12308 uncompressed_size += start[7]; uncompressed_size <<= 8;
12309 uncompressed_size += start[8]; uncompressed_size <<= 8;
12310 uncompressed_size += start[9]; uncompressed_size <<= 8;
12311 uncompressed_size += start[10]; uncompressed_size <<= 8;
12312 uncompressed_size += start[11];
12313 start += 12;
12314 size -= 12;
12315 }
12316
12317 if (uncompressed_size
12318 && uncompress_section_contents (&start, uncompressed_size,
12319 &size))
77115a4a
L		 12320 {
12321 /* Free the compressed buffer, update the section buffer
12322 and the section size if uncompress is successful. */
12323 free (section->start);
12324 section->start = start;
77115a4a
L		 12325 }
12326 section->size = size;
59245841 12327 }
4a114e3e 12328
1b315056
CS		 12329 if (section->start == NULL)
12330 return 0;
12331
19e6b90e 12332 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12333 apply_relocations ((FILE *) file, sec, section->start, section->size,
12334 & section->reloc_info, & section->num_relocs);
12335 else
12336 {
12337 section->reloc_info = NULL;
12338 section->num_relocs = 0;
12339 }
1007acb3 12340
1b315056 12341 return 1;
1007acb3
L		 12342}
12343
657d0d47
CC		 12344/* If this is not NULL, load_debug_section will only look for sections
12345 within the list of sections given here. */
12346unsigned int *section_subset = NULL;
12347
d966045b 12348int
2cf0635d 12349load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12350{
2cf0635d
NC		 12351 struct dwarf_section * section = &debug_displays [debug].section;
12352 Elf_Internal_Shdr * sec;
d966045b
DJ		 12353
12354 /* Locate the debug section. */
657d0d47 12355 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12356 if (sec != NULL)
12357 section->name = section->uncompressed_name;
12358 else
12359 {
657d0d47 12360 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12361 if (sec != NULL)
12362 section->name = section->compressed_name;
12363 }
12364 if (sec == NULL)
12365 return 0;
12366
657d0d47
CC		 12367 /* If we're loading from a subset of sections, and we've loaded
12368 a section matching this name before, it's likely that it's a
12369 different one. */
12370 if (section_subset != NULL)
12371 free_debug_section (debug);
12372
3f5e193b 12373 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12374}
12375
19e6b90e
L		 12376void
12377free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12378{
2cf0635d 12379 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12380
19e6b90e
L		 12381 if (section->start == NULL)
12382 return;
1007acb3 12383
19e6b90e
L		 12384 free ((char *) section->start);
12385 section->start = NULL;
12386 section->address = 0;
12387 section->size = 0;
1007acb3
L		 12388}
12389
1007acb3 12390static int
657d0d47 12391display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12392{
2cf0635d 12393 char * name = SECTION_NAME (section);
74e1a04b 12394 const char * print_name = printable_section_name (section);
19e6b90e
L		 12395 bfd_size_type length;
12396 int result = 1;
3f5e193b 12397 int i;
1007acb3 12398
19e6b90e
L		 12399 length = section->sh_size;
12400 if (length == 0)
1007acb3 12401 {
74e1a04b 12402 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12403 return 0;
1007acb3 12404 }
5dff79d8
NC		 12405 if (section->sh_type == SHT_NOBITS)
12406 {
12407 /* There is no point in dumping the contents of a debugging section
12408 which has the NOBITS type - the bits in the file will be random.
12409 This can happen when a file containing a .eh_frame section is
12410 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12411 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12412 print_name);
5dff79d8
NC		 12413 return 0;
12414 }
1007acb3 12415
0112cd26 12416 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12417 name = ".debug_info";
1007acb3 12418
19e6b90e
L		 12419 /* See if we know how to display the contents of this section. */
12420 for (i = 0; i < max; i++)
1b315056 12421 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12422 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12423 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12424 {
2cf0635d 12425 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12426 int secondary = (section != find_section (name));
12427
12428 if (secondary)
3f5e193b 12429 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12430
b40bf0a2
NC		 12431 if (i == line && const_strneq (name, ".debug_line."))
12432 sec->name = name;
12433 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12434 sec->name = sec->uncompressed_name;
12435 else
12436 sec->name = sec->compressed_name;
3f5e193b
NC		 12437 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12438 section, file))
19e6b90e 12439 {
657d0d47
CC		 12440 /* If this debug section is part of a CU/TU set in a .dwp file,
12441 restrict load_debug_section to the sections in that set. */
12442 section_subset = find_cu_tu_set (file, shndx);
12443
19e6b90e 12444 result &= debug_displays[i].display (sec, file);
1007acb3 12445
657d0d47
CC		 12446 section_subset = NULL;
12447
d966045b 12448 if (secondary || (i != info && i != abbrev))
3f5e193b 12449 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12450 }
1007acb3 12451
19e6b90e
L		 12452 break;
12453 }
1007acb3 12454
19e6b90e 12455 if (i == max)
1007acb3 12456 {
74e1a04b 12457 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12458 result = 0;
1007acb3
L		 12459 }
12460
19e6b90e 12461 return result;
5b18a4bc 12462}
103f02d3 12463
aef1f6d0
DJ		 12464/* Set DUMP_SECTS for all sections where dumps were requested
12465 based on section name. */
12466
12467static void
12468initialise_dumps_byname (void)
12469{
2cf0635d 12470 struct dump_list_entry * cur;
aef1f6d0
DJ		 12471
12472 for (cur = dump_sects_byname; cur; cur = cur->next)
12473 {
12474 unsigned int i;
12475 int any;
12476
12477 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12478 if (streq (SECTION_NAME (section_headers + i), cur->name))
12479 {
09c11c86 12480 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12481 any = 1;
12482 }
12483
12484 if (!any)
12485 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12486 cur->name);
12487 }
12488}
12489
5b18a4bc 12490static void
2cf0635d 12491process_section_contents (FILE * file)
5b18a4bc 12492{
2cf0635d 12493 Elf_Internal_Shdr * section;
19e6b90e 12494 unsigned int i;
103f02d3 12495
19e6b90e
L		 12496 if (! do_dump)
12497 return;
103f02d3 12498
aef1f6d0
DJ		 12499 initialise_dumps_byname ();
12500
19e6b90e
L		 12501 for (i = 0, section = section_headers;
12502 i < elf_header.e_shnum && i < num_dump_sects;
12503 i++, section++)
12504 {
12505#ifdef SUPPORT_DISASSEMBLY
12506 if (dump_sects[i] & DISASS_DUMP)
12507 disassemble_section (section, file);
12508#endif
12509 if (dump_sects[i] & HEX_DUMP)
cf13d699 12510 dump_section_as_bytes (section, file, FALSE);
103f02d3 12511
cf13d699
NC		 12512 if (dump_sects[i] & RELOC_DUMP)
12513 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12514
12515 if (dump_sects[i] & STRING_DUMP)
12516 dump_section_as_strings (section, file);
cf13d699
NC		 12517
12518 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12519 display_debug_section (i, section, file);
5b18a4bc 12520 }
103f02d3 12521
19e6b90e
L		 12522 /* Check to see if the user requested a
12523 dump of a section that does not exist. */
12524 while (i++ < num_dump_sects)
12525 if (dump_sects[i])
12526 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12527}
103f02d3 12528
5b18a4bc 12529static void
19e6b90e 12530process_mips_fpe_exception (int mask)
5b18a4bc 12531{
19e6b90e
L		 12532 if (mask)
12533 {
12534 int first = 1;
12535 if (mask & OEX_FPU_INEX)
12536 fputs ("INEX", stdout), first = 0;
12537 if (mask & OEX_FPU_UFLO)
12538 printf ("%sUFLO", first ? "" : "|"), first = 0;
12539 if (mask & OEX_FPU_OFLO)
12540 printf ("%sOFLO", first ? "" : "|"), first = 0;
12541 if (mask & OEX_FPU_DIV0)
12542 printf ("%sDIV0", first ? "" : "|"), first = 0;
12543 if (mask & OEX_FPU_INVAL)
12544 printf ("%sINVAL", first ? "" : "|");
12545 }
5b18a4bc 12546 else
19e6b90e 12547 fputs ("0", stdout);
5b18a4bc 12548}
103f02d3 12549
f6f0e17b
NC		 12550/* Display's the value of TAG at location P. If TAG is
12551 greater than 0 it is assumed to be an unknown tag, and
12552 a message is printed to this effect. Otherwise it is
12553 assumed that a message has already been printed.
12554
12555 If the bottom bit of TAG is set it assumed to have a
12556 string value, otherwise it is assumed to have an integer
12557 value.
12558
12559 Returns an updated P pointing to the first unread byte
12560 beyond the end of TAG's value.
12561
12562 Reads at or beyond END will not be made. */
12563
12564static unsigned char *
12565display_tag_value (int tag,
12566 unsigned char * p,
12567 const unsigned char * const end)
12568{
12569 unsigned long val;
12570
12571 if (tag > 0)
12572 printf (" Tag_unknown_%d: ", tag);
12573
12574 if (p >= end)
12575 {
4082ef84 12576 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12577 }
12578 else if (tag & 1)
12579 {
071436c6
NC		 12580 /* PR 17531 file: 027-19978-0.004. */
12581 size_t maxlen = (end - p) - 1;
12582
12583 putchar ('"');
4082ef84
NC		 12584 if (maxlen > 0)
12585 {
12586 print_symbol ((int) maxlen, (const char *) p);
12587 p += strnlen ((char *) p, maxlen) + 1;
12588 }
12589 else
12590 {
12591 printf (_("<corrupt string tag>"));
12592 p = (unsigned char *) end;
12593 }
071436c6 12594 printf ("\"\n");
f6f0e17b
NC		 12595 }
12596 else
12597 {
12598 unsigned int len;
12599
12600 val = read_uleb128 (p, &len, end);
12601 p += len;
12602 printf ("%ld (0x%lx)\n", val, val);
12603 }
12604
4082ef84 12605 assert (p <= end);
f6f0e17b
NC		 12606 return p;
12607}
12608
11c1ff18
PB		 12609/* ARM EABI attributes section. */
12610typedef struct
12611{
70e99720 12612 unsigned int tag;
2cf0635d 12613 const char * name;
11c1ff18 12614 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12615 unsigned int type;
2cf0635d 12616 const char ** table;
11c1ff18
PB		 12617} arm_attr_public_tag;
12618
2cf0635d 12619static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12620 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12621 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12622static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12623static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12624 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12625static const char * arm_attr_tag_FP_arch[] =
bca38921 12626 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12627 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12628static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12629static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12630 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12631static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12632 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12633 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12634static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12635 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12636static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12637 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12638static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12639 {"Absolute", "PC-relative", "None"};
2cf0635d 12640static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12641 {"None", "direct", "GOT-indirect"};
2cf0635d 12642static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12643 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12644static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12645static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12646 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12647static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12648static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12649static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12650 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12651static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12652 {"Unused", "small", "int", "forced to int"};
2cf0635d 12653static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12654 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12655static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12656 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12657static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12658 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12659static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12660 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12661 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12662static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12663 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12664 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12665static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12666static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12667 {"Not Allowed", "Allowed"};
2cf0635d 12668static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12669 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12670static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12671 {"Not Allowed", "Allowed"};
12672static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12673 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12674 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12675static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12676static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12677 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12678 "TrustZone and Virtualization Extensions"};
dd24e3da 12679static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12680 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12681
12682#define LOOKUP(id, name) \
12683 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12684static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12685{
12686 {4, "CPU_raw_name", 1, NULL},
12687 {5, "CPU_name", 1, NULL},
12688 LOOKUP(6, CPU_arch),
12689 {7, "CPU_arch_profile", 0, NULL},
12690 LOOKUP(8, ARM_ISA_use),
12691 LOOKUP(9, THUMB_ISA_use),
75375b3e 12692 LOOKUP(10, FP_arch),
11c1ff18 12693 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12694 LOOKUP(12, Advanced_SIMD_arch),
12695 LOOKUP(13, PCS_config),
11c1ff18
PB		 12696 LOOKUP(14, ABI_PCS_R9_use),
12697 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12698 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12699 LOOKUP(17, ABI_PCS_GOT_use),
12700 LOOKUP(18, ABI_PCS_wchar_t),
12701 LOOKUP(19, ABI_FP_rounding),
12702 LOOKUP(20, ABI_FP_denormal),
12703 LOOKUP(21, ABI_FP_exceptions),
12704 LOOKUP(22, ABI_FP_user_exceptions),
12705 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12706 {24, "ABI_align_needed", 0, NULL},
12707 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12708 LOOKUP(26, ABI_enum_size),
12709 LOOKUP(27, ABI_HardFP_use),
12710 LOOKUP(28, ABI_VFP_args),
12711 LOOKUP(29, ABI_WMMX_args),
12712 LOOKUP(30, ABI_optimization_goals),
12713 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12714 {32, "compatibility", 0, NULL},
f5f53991 12715 LOOKUP(34, CPU_unaligned_access),
75375b3e 12716 LOOKUP(36, FP_HP_extension),
8e79c3df 12717 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12718 LOOKUP(42, MPextension_use),
12719 LOOKUP(44, DIV_use),
f5f53991
AS		 12720 {64, "nodefaults", 0, NULL},
12721 {65, "also_compatible_with", 0, NULL},
12722 LOOKUP(66, T2EE_use),
12723 {67, "conformance", 1, NULL},
12724 LOOKUP(68, Virtualization_use),
cd21e546 12725 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12726};
12727#undef LOOKUP
12728
11c1ff18 12729static unsigned char *
f6f0e17b
NC		 12730display_arm_attribute (unsigned char * p,
12731 const unsigned char * const end)
11c1ff18 12732{
70e99720 12733 unsigned int tag;
11c1ff18 12734 unsigned int len;
70e99720 12735 unsigned int val;
2cf0635d 12736 arm_attr_public_tag * attr;
11c1ff18 12737 unsigned i;
70e99720 12738 unsigned int type;
11c1ff18 12739
f6f0e17b 12740 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12741 p += len;
12742 attr = NULL;
2cf0635d 12743 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12744 {
12745 if (arm_attr_public_tags[i].tag == tag)
12746 {
12747 attr = &arm_attr_public_tags[i];
12748 break;
12749 }
12750 }
12751
12752 if (attr)
12753 {
12754 printf (" Tag_%s: ", attr->name);
12755 switch (attr->type)
12756 {
12757 case 0:
12758 switch (tag)
12759 {
12760 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12761 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12762 p += len;
12763 switch (val)
12764 {
2b692964
NC		 12765 case 0: printf (_("None\n")); break;
12766 case 'A': printf (_("Application\n")); break;
12767 case 'R': printf (_("Realtime\n")); break;
12768 case 'M': printf (_("Microcontroller\n")); break;
12769 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12770 default: printf ("??? (%d)\n", val); break;
12771 }
12772 break;
12773
75375b3e 12774 case 24: /* Tag_align_needed. */
f6f0e17b 12775 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12776 p += len;
12777 switch (val)
12778 {
2b692964
NC		 12779 case 0: printf (_("None\n")); break;
12780 case 1: printf (_("8-byte\n")); break;
12781 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12782 case 3: printf ("??? 3\n"); break;
12783 default:
12784 if (val <= 12)
dd24e3da 12785 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12786 1 << val);
12787 else
12788 printf ("??? (%d)\n", val);
12789 break;
12790 }
12791 break;
12792
12793 case 25: /* Tag_align_preserved. */
f6f0e17b 12794 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12795 p += len;
12796 switch (val)
12797 {
2b692964
NC		 12798 case 0: printf (_("None\n")); break;
12799 case 1: printf (_("8-byte, except leaf SP\n")); break;
12800 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12801 case 3: printf ("??? 3\n"); break;
12802 default:
12803 if (val <= 12)
dd24e3da 12804 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12805 1 << val);
12806 else
12807 printf ("??? (%d)\n", val);
12808 break;
12809 }
12810 break;
12811
11c1ff18 12812 case 32: /* Tag_compatibility. */
071436c6 12813 {
071436c6
NC		 12814 val = read_uleb128 (p, &len, end);
12815 p += len;
071436c6 12816 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12817 if (p < end - 1)
12818 {
12819 size_t maxlen = (end - p) - 1;
12820
12821 print_symbol ((int) maxlen, (const char *) p);
12822 p += strnlen ((char *) p, maxlen) + 1;
12823 }
12824 else
12825 {
12826 printf (_("<corrupt>"));
12827 p = (unsigned char *) end;
12828 }
071436c6 12829 putchar ('\n');
071436c6 12830 }
11c1ff18
PB		 12831 break;
12832
f5f53991 12833 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12834 /* PR 17531: file: 001-505008-0.01. */
12835 if (p < end)
12836 p++;
2b692964 12837 printf (_("True\n"));
f5f53991
AS		 12838 break;
12839
12840 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12841 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12842 p += len;
12843 if (val == 6 /* Tag_CPU_arch. */)
12844 {
f6f0e17b 12845 val = read_uleb128 (p, &len, end);
f5f53991 12846 p += len;
071436c6 12847 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12848 printf ("??? (%d)\n", val);
12849 else
12850 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12851 }
12852 else
12853 printf ("???\n");
071436c6
NC		 12854 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12855 ;
f5f53991
AS		 12856 break;
12857
11c1ff18 12858 default:
bee0ee85
NC		 12859 printf (_("<unknown: %d>\n"), tag);
12860 break;
11c1ff18
PB		 12861 }
12862 return p;
12863
12864 case 1:
f6f0e17b 12865 return display_tag_value (-1, p, end);
11c1ff18 12866 case 2:
f6f0e17b 12867 return display_tag_value (0, p, end);
11c1ff18
PB		 12868
12869 default:
12870 assert (attr->type & 0x80);
f6f0e17b 12871 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12872 p += len;
12873 type = attr->type & 0x7f;
12874 if (val >= type)
12875 printf ("??? (%d)\n", val);
12876 else
12877 printf ("%s\n", attr->table[val]);
12878 return p;
12879 }
12880 }
11c1ff18 12881
f6f0e17b 12882 return display_tag_value (tag, p, end);
11c1ff18
PB		 12883}
12884
104d59d1 12885static unsigned char *
60bca95a 12886display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12887 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12888 const unsigned char * const end)
104d59d1
JM		 12889{
12890 int tag;
12891 unsigned int len;
12892 int val;
104d59d1 12893
f6f0e17b 12894 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12895 p += len;
12896
12897 /* Tag_compatibility is the only generic GNU attribute defined at
12898 present. */
12899 if (tag == 32)
12900 {
f6f0e17b 12901 val = read_uleb128 (p, &len, end);
104d59d1 12902 p += len;
071436c6
NC		 12903
12904 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12905 if (p == end)
12906 {
071436c6 12907 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12908 warn (_("corrupt vendor attribute\n"));
12909 }
12910 else
12911 {
4082ef84
NC		 12912 if (p < end - 1)
12913 {
12914 size_t maxlen = (end - p) - 1;
071436c6 12915
4082ef84
NC		 12916 print_symbol ((int) maxlen, (const char *) p);
12917 p += strnlen ((char *) p, maxlen) + 1;
12918 }
12919 else
12920 {
12921 printf (_("<corrupt>"));
12922 p = (unsigned char *) end;
12923 }
071436c6 12924 putchar ('\n');
f6f0e17b 12925 }
104d59d1
JM		 12926 return p;
12927 }
12928
12929 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12930 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12931
f6f0e17b 12932 return display_tag_value (tag, p, end);
104d59d1
JM		 12933}
12934
34c8bcba 12935static unsigned char *
f6f0e17b
NC		 12936display_power_gnu_attribute (unsigned char * p,
12937 int tag,
12938 const unsigned char * const end)
34c8bcba 12939{
34c8bcba
JM		 12940 unsigned int len;
12941 int val;
12942
12943 if (tag == Tag_GNU_Power_ABI_FP)
12944 {
f6f0e17b 12945 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12946 p += len;
12947 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12948
34c8bcba
JM		 12949 switch (val)
12950 {
12951 case 0:
2b692964 12952 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12953 break;
12954 case 1:
2b692964 12955 printf (_("Hard float\n"));
34c8bcba
JM		 12956 break;
12957 case 2:
2b692964 12958 printf (_("Soft float\n"));
34c8bcba 12959 break;
3c7b9897 12960 case 3:
2b692964 12961 printf (_("Single-precision hard float\n"));
3c7b9897 12962 break;
34c8bcba
JM		 12963 default:
12964 printf ("??? (%d)\n", val);
12965 break;
12966 }
12967 return p;
12968 }
12969
c6e65352
DJ		 12970 if (tag == Tag_GNU_Power_ABI_Vector)
12971 {
f6f0e17b 12972 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12973 p += len;
12974 printf (" Tag_GNU_Power_ABI_Vector: ");
12975 switch (val)
12976 {
12977 case 0:
2b692964 12978 printf (_("Any\n"));
c6e65352
DJ		 12979 break;
12980 case 1:
2b692964 12981 printf (_("Generic\n"));
c6e65352
DJ		 12982 break;
12983 case 2:
12984 printf ("AltiVec\n");
12985 break;
12986 case 3:
12987 printf ("SPE\n");
12988 break;
12989 default:
12990 printf ("??? (%d)\n", val);
12991 break;
12992 }
12993 return p;
12994 }
12995
f82e0623
NF		 12996 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12997 {
f6f0e17b
NC		 12998 if (p == end)
12999 {
071436c6 13000 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13001 return p;
13002 }
0b4362b0 13003
f6f0e17b 13004 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13005 p += len;
13006 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13007 switch (val)
13008 {
13009 case 0:
2b692964 13010 printf (_("Any\n"));
f82e0623
NF		 13011 break;
13012 case 1:
13013 printf ("r3/r4\n");
13014 break;
13015 case 2:
2b692964 13016 printf (_("Memory\n"));
f82e0623
NF		 13017 break;
13018 default:
13019 printf ("??? (%d)\n", val);
13020 break;
13021 }
13022 return p;
13023 }
13024
f6f0e17b 13025 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13026}
13027
643f7afb
AK		 13028static unsigned char *
13029display_s390_gnu_attribute (unsigned char * p,
13030 int tag,
13031 const unsigned char * const end)
13032{
13033 unsigned int len;
13034 int val;
13035
13036 if (tag == Tag_GNU_S390_ABI_Vector)
13037 {
13038 val = read_uleb128 (p, &len, end);
13039 p += len;
13040 printf (" Tag_GNU_S390_ABI_Vector: ");
13041
13042 switch (val)
13043 {
13044 case 0:
13045 printf (_("any\n"));
13046 break;
13047 case 1:
13048 printf (_("software\n"));
13049 break;
13050 case 2:
13051 printf (_("hardware\n"));
13052 break;
13053 default:
13054 printf ("??? (%d)\n", val);
13055 break;
13056 }
13057 return p;
13058 }
13059
13060 return display_tag_value (tag & 1, p, end);
13061}
13062
9e8c70f9
DM		 13063static void
13064display_sparc_hwcaps (int mask)
13065{
13066 if (mask)
13067 {
13068 int first = 1;
071436c6 13069
9e8c70f9
DM		 13070 if (mask & ELF_SPARC_HWCAP_MUL32)
13071 fputs ("mul32", stdout), first = 0;
13072 if (mask & ELF_SPARC_HWCAP_DIV32)
13073 printf ("%sdiv32", first ? "" : "|"), first = 0;
13074 if (mask & ELF_SPARC_HWCAP_FSMULD)
13075 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13076 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13077 printf ("%sv8plus", first ? "" : "|"), first = 0;
13078 if (mask & ELF_SPARC_HWCAP_POPC)
13079 printf ("%spopc", first ? "" : "|"), first = 0;
13080 if (mask & ELF_SPARC_HWCAP_VIS)
13081 printf ("%svis", first ? "" : "|"), first = 0;
13082 if (mask & ELF_SPARC_HWCAP_VIS2)
13083 printf ("%svis2", first ? "" : "|"), first = 0;
13084 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13085 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13086 if (mask & ELF_SPARC_HWCAP_FMAF)
13087 printf ("%sfmaf", first ? "" : "|"), first = 0;
13088 if (mask & ELF_SPARC_HWCAP_VIS3)
13089 printf ("%svis3", first ? "" : "|"), first = 0;
13090 if (mask & ELF_SPARC_HWCAP_HPC)
13091 printf ("%shpc", first ? "" : "|"), first = 0;
13092 if (mask & ELF_SPARC_HWCAP_RANDOM)
13093 printf ("%srandom", first ? "" : "|"), first = 0;
13094 if (mask & ELF_SPARC_HWCAP_TRANS)
13095 printf ("%strans", first ? "" : "|"), first = 0;
13096 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13097 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13098 if (mask & ELF_SPARC_HWCAP_IMA)
13099 printf ("%sima", first ? "" : "|"), first = 0;
13100 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13101 printf ("%scspare", first ? "" : "|"), first = 0;
13102 }
13103 else
071436c6
NC		 13104 fputc ('0', stdout);
13105 fputc ('\n', stdout);
9e8c70f9
DM		 13106}
13107
3d68f91c
JM		 13108static void
13109display_sparc_hwcaps2 (int mask)
13110{
13111 if (mask)
13112 {
13113 int first = 1;
071436c6 13114
3d68f91c
JM		 13115 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13116 fputs ("fjathplus", stdout), first = 0;
13117 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13118 printf ("%svis3b", first ? "" : "|"), first = 0;
13119 if (mask & ELF_SPARC_HWCAP2_ADP)
13120 printf ("%sadp", first ? "" : "|"), first = 0;
13121 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13122 printf ("%ssparc5", first ? "" : "|"), first = 0;
13123 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13124 printf ("%smwait", first ? "" : "|"), first = 0;
13125 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13126 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13127 if (mask & ELF_SPARC_HWCAP2_XMONT)
13128 printf ("%sxmont2", first ? "" : "|"), first = 0;
13129 if (mask & ELF_SPARC_HWCAP2_NSEC)
13130 printf ("%snsec", first ? "" : "|"), first = 0;
13131 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13132 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13133 if (mask & ELF_SPARC_HWCAP2_FJDES)
13134 printf ("%sfjdes", first ? "" : "|"), first = 0;
13135 if (mask & ELF_SPARC_HWCAP2_FJAES)
13136 printf ("%sfjaes", first ? "" : "|"), first = 0;
13137 }
13138 else
071436c6
NC		 13139 fputc ('0', stdout);
13140 fputc ('\n', stdout);
3d68f91c
JM		 13141}
13142
9e8c70f9 13143static unsigned char *
f6f0e17b
NC		 13144display_sparc_gnu_attribute (unsigned char * p,
13145 int tag,
13146 const unsigned char * const end)
9e8c70f9 13147{
3d68f91c
JM		 13148 unsigned int len;
13149 int val;
13150
9e8c70f9
DM		 13151 if (tag == Tag_GNU_Sparc_HWCAPS)
13152 {
f6f0e17b 13153 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13154 p += len;
13155 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13156 display_sparc_hwcaps (val);
13157 return p;
3d68f91c
JM		 13158 }
13159 if (tag == Tag_GNU_Sparc_HWCAPS2)
13160 {
13161 val = read_uleb128 (p, &len, end);
13162 p += len;
13163 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13164 display_sparc_hwcaps2 (val);
13165 return p;
13166 }
9e8c70f9 13167
f6f0e17b 13168 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13169}
13170
351cdf24
MF		 13171static void
13172print_mips_fp_abi_value (int val)
13173{
13174 switch (val)
13175 {
13176 case Val_GNU_MIPS_ABI_FP_ANY:
13177 printf (_("Hard or soft float\n"));
13178 break;
13179 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13180 printf (_("Hard float (double precision)\n"));
13181 break;
13182 case Val_GNU_MIPS_ABI_FP_SINGLE:
13183 printf (_("Hard float (single precision)\n"));
13184 break;
13185 case Val_GNU_MIPS_ABI_FP_SOFT:
13186 printf (_("Soft float\n"));
13187 break;
13188 case Val_GNU_MIPS_ABI_FP_OLD_64:
13189 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13190 break;
13191 case Val_GNU_MIPS_ABI_FP_XX:
13192 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13193 break;
13194 case Val_GNU_MIPS_ABI_FP_64:
13195 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13196 break;
13197 case Val_GNU_MIPS_ABI_FP_64A:
13198 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13199 break;
3350cc01
CM		 13200 case Val_GNU_MIPS_ABI_FP_NAN2008:
13201 printf (_("NaN 2008 compatibility\n"));
13202 break;
351cdf24
MF		 13203 default:
13204 printf ("??? (%d)\n", val);
13205 break;
13206 }
13207}
13208
2cf19d5c 13209static unsigned char *
f6f0e17b
NC		 13210display_mips_gnu_attribute (unsigned char * p,
13211 int tag,
13212 const unsigned char * const end)
2cf19d5c 13213{
2cf19d5c
JM		 13214 if (tag == Tag_GNU_MIPS_ABI_FP)
13215 {
f6f0e17b
NC		 13216 unsigned int len;
13217 int val;
13218
13219 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13220 p += len;
13221 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13222
351cdf24
MF		 13223 print_mips_fp_abi_value (val);
13224
2cf19d5c
JM		 13225 return p;
13226 }
13227
a9f58168
CF		 13228 if (tag == Tag_GNU_MIPS_ABI_MSA)
13229 {
13230 unsigned int len;
13231 int val;
13232
13233 val = read_uleb128 (p, &len, end);
13234 p += len;
13235 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13236
13237 switch (val)
13238 {
13239 case Val_GNU_MIPS_ABI_MSA_ANY:
13240 printf (_("Any MSA or not\n"));
13241 break;
13242 case Val_GNU_MIPS_ABI_MSA_128:
13243 printf (_("128-bit MSA\n"));
13244 break;
13245 default:
13246 printf ("??? (%d)\n", val);
13247 break;
13248 }
13249 return p;
13250 }
13251
f6f0e17b 13252 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13253}
13254
59e6276b 13255static unsigned char *
f6f0e17b
NC		 13256display_tic6x_attribute (unsigned char * p,
13257 const unsigned char * const end)
59e6276b
JM		 13258{
13259 int tag;
13260 unsigned int len;
13261 int val;
13262
f6f0e17b 13263 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13264 p += len;
13265
13266 switch (tag)
13267 {
75fa6dc1 13268 case Tag_ISA:
f6f0e17b 13269 val = read_uleb128 (p, &len, end);
59e6276b 13270 p += len;
75fa6dc1 13271 printf (" Tag_ISA: ");
59e6276b
JM		 13272
13273 switch (val)
13274 {
75fa6dc1 13275 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13276 printf (_("None\n"));
13277 break;
75fa6dc1 13278 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13279 printf ("C62x\n");
13280 break;
75fa6dc1 13281 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13282 printf ("C67x\n");
13283 break;
75fa6dc1 13284 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13285 printf ("C67x+\n");
13286 break;
75fa6dc1 13287 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13288 printf ("C64x\n");
13289 break;
75fa6dc1 13290 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13291 printf ("C64x+\n");
13292 break;
75fa6dc1 13293 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13294 printf ("C674x\n");
13295 break;
13296 default:
13297 printf ("??? (%d)\n", val);
13298 break;
13299 }
13300 return p;
13301
87779176 13302 case Tag_ABI_wchar_t:
f6f0e17b 13303 val = read_uleb128 (p, &len, end);
87779176
JM		 13304 p += len;
13305 printf (" Tag_ABI_wchar_t: ");
13306 switch (val)
13307 {
13308 case 0:
13309 printf (_("Not used\n"));
13310 break;
13311 case 1:
13312 printf (_("2 bytes\n"));
13313 break;
13314 case 2:
13315 printf (_("4 bytes\n"));
13316 break;
13317 default:
13318 printf ("??? (%d)\n", val);
13319 break;
13320 }
13321 return p;
13322
13323 case Tag_ABI_stack_align_needed:
f6f0e17b 13324 val = read_uleb128 (p, &len, end);
87779176
JM		 13325 p += len;
13326 printf (" Tag_ABI_stack_align_needed: ");
13327 switch (val)
13328 {
13329 case 0:
13330 printf (_("8-byte\n"));
13331 break;
13332 case 1:
13333 printf (_("16-byte\n"));
13334 break;
13335 default:
13336 printf ("??? (%d)\n", val);
13337 break;
13338 }
13339 return p;
13340
13341 case Tag_ABI_stack_align_preserved:
f6f0e17b 13342 val = read_uleb128 (p, &len, end);
87779176
JM		 13343 p += len;
13344 printf (" Tag_ABI_stack_align_preserved: ");
13345 switch (val)
13346 {
13347 case 0:
13348 printf (_("8-byte\n"));
13349 break;
13350 case 1:
13351 printf (_("16-byte\n"));
13352 break;
13353 default:
13354 printf ("??? (%d)\n", val);
13355 break;
13356 }
13357 return p;
13358
b5593623 13359 case Tag_ABI_DSBT:
f6f0e17b 13360 val = read_uleb128 (p, &len, end);
b5593623
JM		 13361 p += len;
13362 printf (" Tag_ABI_DSBT: ");
13363 switch (val)
13364 {
13365 case 0:
13366 printf (_("DSBT addressing not used\n"));
13367 break;
13368 case 1:
13369 printf (_("DSBT addressing used\n"));
13370 break;
13371 default:
13372 printf ("??? (%d)\n", val);
13373 break;
13374 }
13375 return p;
13376
87779176 13377 case Tag_ABI_PID:
f6f0e17b 13378 val = read_uleb128 (p, &len, end);
87779176
JM		 13379 p += len;
13380 printf (" Tag_ABI_PID: ");
13381 switch (val)
13382 {
13383 case 0:
13384 printf (_("Data addressing position-dependent\n"));
13385 break;
13386 case 1:
13387 printf (_("Data addressing position-independent, GOT near DP\n"));
13388 break;
13389 case 2:
13390 printf (_("Data addressing position-independent, GOT far from DP\n"));
13391 break;
13392 default:
13393 printf ("??? (%d)\n", val);
13394 break;
13395 }
13396 return p;
13397
13398 case Tag_ABI_PIC:
f6f0e17b 13399 val = read_uleb128 (p, &len, end);
87779176
JM		 13400 p += len;
13401 printf (" Tag_ABI_PIC: ");
13402 switch (val)
13403 {
13404 case 0:
13405 printf (_("Code addressing position-dependent\n"));
13406 break;
13407 case 1:
13408 printf (_("Code addressing position-independent\n"));
13409 break;
13410 default:
13411 printf ("??? (%d)\n", val);
13412 break;
13413 }
13414 return p;
13415
13416 case Tag_ABI_array_object_alignment:
f6f0e17b 13417 val = read_uleb128 (p, &len, end);
87779176
JM		 13418 p += len;
13419 printf (" Tag_ABI_array_object_alignment: ");
13420 switch (val)
13421 {
13422 case 0:
13423 printf (_("8-byte\n"));
13424 break;
13425 case 1:
13426 printf (_("4-byte\n"));
13427 break;
13428 case 2:
13429 printf (_("16-byte\n"));
13430 break;
13431 default:
13432 printf ("??? (%d)\n", val);
13433 break;
13434 }
13435 return p;
13436
13437 case Tag_ABI_array_object_align_expected:
f6f0e17b 13438 val = read_uleb128 (p, &len, end);
87779176
JM		 13439 p += len;
13440 printf (" Tag_ABI_array_object_align_expected: ");
13441 switch (val)
13442 {
13443 case 0:
13444 printf (_("8-byte\n"));
13445 break;
13446 case 1:
13447 printf (_("4-byte\n"));
13448 break;
13449 case 2:
13450 printf (_("16-byte\n"));
13451 break;
13452 default:
13453 printf ("??? (%d)\n", val);
13454 break;
13455 }
13456 return p;
13457
3cbd1c06 13458 case Tag_ABI_compatibility:
071436c6 13459 {
071436c6
NC		 13460 val = read_uleb128 (p, &len, end);
13461 p += len;
13462 printf (" Tag_ABI_compatibility: ");
071436c6 13463 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13464 if (p < end - 1)
13465 {
13466 size_t maxlen = (end - p) - 1;
13467
13468 print_symbol ((int) maxlen, (const char *) p);
13469 p += strnlen ((char *) p, maxlen) + 1;
13470 }
13471 else
13472 {
13473 printf (_("<corrupt>"));
13474 p = (unsigned char *) end;
13475 }
071436c6 13476 putchar ('\n');
071436c6
NC		 13477 return p;
13478 }
87779176
JM		 13479
13480 case Tag_ABI_conformance:
071436c6 13481 {
4082ef84
NC		 13482 printf (" Tag_ABI_conformance: \"");
13483 if (p < end - 1)
13484 {
13485 size_t maxlen = (end - p) - 1;
071436c6 13486
4082ef84
NC		 13487 print_symbol ((int) maxlen, (const char *) p);
13488 p += strnlen ((char *) p, maxlen) + 1;
13489 }
13490 else
13491 {
13492 printf (_("<corrupt>"));
13493 p = (unsigned char *) end;
13494 }
071436c6 13495 printf ("\"\n");
071436c6
NC		 13496 return p;
13497 }
59e6276b
JM		 13498 }
13499
f6f0e17b
NC		 13500 return display_tag_value (tag, p, end);
13501}
59e6276b 13502
f6f0e17b
NC		 13503static void
13504display_raw_attribute (unsigned char * p, unsigned char * end)
13505{
13506 unsigned long addr = 0;
13507 size_t bytes = end - p;
13508
e0a31db1 13509 assert (end > p);
f6f0e17b 13510 while (bytes)
87779176 13511 {
f6f0e17b
NC		 13512 int j;
13513 int k;
13514 int lbytes = (bytes > 16 ? 16 : bytes);
13515
13516 printf (" 0x%8.8lx ", addr);
13517
13518 for (j = 0; j < 16; j++)
13519 {
13520 if (j < lbytes)
13521 printf ("%2.2x", p[j]);
13522 else
13523 printf (" ");
13524
13525 if ((j & 3) == 3)
13526 printf (" ");
13527 }
13528
13529 for (j = 0; j < lbytes; j++)
13530 {
13531 k = p[j];
13532 if (k >= ' ' && k < 0x7f)
13533 printf ("%c", k);
13534 else
13535 printf (".");
13536 }
13537
13538 putchar ('\n');
13539
13540 p += lbytes;
13541 bytes -= lbytes;
13542 addr += lbytes;
87779176 13543 }
59e6276b 13544
f6f0e17b 13545 putchar ('\n');
59e6276b
JM		 13546}
13547
13761a11
NC		 13548static unsigned char *
13549display_msp430x_attribute (unsigned char * p,
13550 const unsigned char * const end)
13551{
13552 unsigned int len;
13553 int val;
13554 int tag;
13555
13556 tag = read_uleb128 (p, & len, end);
13557 p += len;
0b4362b0 13558
13761a11
NC		 13559 switch (tag)
13560 {
13561 case OFBA_MSPABI_Tag_ISA:
13562 val = read_uleb128 (p, &len, end);
13563 p += len;
13564 printf (" Tag_ISA: ");
13565 switch (val)
13566 {
13567 case 0: printf (_("None\n")); break;
13568 case 1: printf (_("MSP430\n")); break;
13569 case 2: printf (_("MSP430X\n")); break;
13570 default: printf ("??? (%d)\n", val); break;
13571 }
13572 break;
13573
13574 case OFBA_MSPABI_Tag_Code_Model:
13575 val = read_uleb128 (p, &len, end);
13576 p += len;
13577 printf (" Tag_Code_Model: ");
13578 switch (val)
13579 {
13580 case 0: printf (_("None\n")); break;
13581 case 1: printf (_("Small\n")); break;
13582 case 2: printf (_("Large\n")); break;
13583 default: printf ("??? (%d)\n", val); break;
13584 }
13585 break;
13586
13587 case OFBA_MSPABI_Tag_Data_Model:
13588 val = read_uleb128 (p, &len, end);
13589 p += len;
13590 printf (" Tag_Data_Model: ");
13591 switch (val)
13592 {
13593 case 0: printf (_("None\n")); break;
13594 case 1: printf (_("Small\n")); break;
13595 case 2: printf (_("Large\n")); break;
13596 case 3: printf (_("Restricted Large\n")); break;
13597 default: printf ("??? (%d)\n", val); break;
13598 }
13599 break;
13600
13601 default:
13602 printf (_(" <unknown tag %d>: "), tag);
13603
13604 if (tag & 1)
13605 {
071436c6 13606 putchar ('"');
4082ef84
NC		 13607 if (p < end - 1)
13608 {
13609 size_t maxlen = (end - p) - 1;
13610
13611 print_symbol ((int) maxlen, (const char *) p);
13612 p += strnlen ((char *) p, maxlen) + 1;
13613 }
13614 else
13615 {
13616 printf (_("<corrupt>"));
13617 p = (unsigned char *) end;
13618 }
071436c6 13619 printf ("\"\n");
13761a11
NC		 13620 }
13621 else
13622 {
13623 val = read_uleb128 (p, &len, end);
13624 p += len;
13625 printf ("%d (0x%x)\n", val, val);
13626 }
13627 break;
13628 }
13629
4082ef84 13630 assert (p <= end);
13761a11
NC		 13631 return p;
13632}
13633
11c1ff18 13634static int
60bca95a
NC		 13635process_attributes (FILE * file,
13636 const char * public_name,
104d59d1 13637 unsigned int proc_type,
f6f0e17b
NC		 13638 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13639 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13640{
2cf0635d 13641 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13642 unsigned i;
13643
13644 /* Find the section header so that we get the size. */
13645 for (i = 0, sect = section_headers;
13646 i < elf_header.e_shnum;
13647 i++, sect++)
13648 {
071436c6
NC		 13649 unsigned char * contents;
13650 unsigned char * p;
13651
104d59d1 13652 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13653 continue;
13654
3f5e193b
NC		 13655 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13656 sect->sh_size, _("attributes"));
60bca95a 13657 if (contents == NULL)
11c1ff18 13658 continue;
60bca95a 13659
11c1ff18
PB		 13660 p = contents;
13661 if (*p == 'A')
13662 {
071436c6
NC		 13663 bfd_vma section_len;
13664
13665 section_len = sect->sh_size - 1;
11c1ff18 13666 p++;
60bca95a 13667
071436c6 13668 while (section_len > 0)
11c1ff18 13669 {
071436c6 13670 bfd_vma attr_len;
e9847026 13671 unsigned int namelen;
11c1ff18 13672 bfd_boolean public_section;
104d59d1 13673 bfd_boolean gnu_section;
11c1ff18 13674
071436c6 13675 if (section_len <= 4)
e0a31db1
NC		 13676 {
13677 error (_("Tag section ends prematurely\n"));
13678 break;
13679 }
071436c6 13680 attr_len = byte_get (p, 4);
11c1ff18 13681 p += 4;
60bca95a 13682
071436c6 13683 if (attr_len > section_len)
11c1ff18 13684 {
071436c6
NC		 13685 error (_("Bad attribute length (%u > %u)\n"),
13686 (unsigned) attr_len, (unsigned) section_len);
13687 attr_len = section_len;
11c1ff18 13688 }
74e1a04b 13689 /* PR 17531: file: 001-101425-0.004 */
071436c6 13690 else if (attr_len < 5)
74e1a04b 13691 {
071436c6 13692 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13693 break;
13694 }
e9847026 13695
071436c6
NC		 13696 section_len -= attr_len;
13697 attr_len -= 4;
13698
13699 namelen = strnlen ((char *) p, attr_len) + 1;
13700 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13701 {
13702 error (_("Corrupt attribute section name\n"));
13703 break;
13704 }
13705
071436c6
NC		 13706 printf (_("Attribute Section: "));
13707 print_symbol (INT_MAX, (const char *) p);
13708 putchar ('\n');
60bca95a
NC		 13709
13710 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13711 public_section = TRUE;
13712 else
13713 public_section = FALSE;
60bca95a
NC		 13714
13715 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13716 gnu_section = TRUE;
13717 else
13718 gnu_section = FALSE;
60bca95a 13719
11c1ff18 13720 p += namelen;
071436c6 13721 attr_len -= namelen;
e0a31db1 13722
071436c6 13723 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13724 {
e0a31db1 13725 int tag;
11c1ff18
PB		 13726 int val;
13727 bfd_vma size;
071436c6 13728 unsigned char * end;
60bca95a 13729
e0a31db1 13730 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13731 if (attr_len < 6)
e0a31db1
NC		 13732 {
13733 error (_("Unused bytes at end of section\n"));
13734 section_len = 0;
13735 break;
13736 }
13737
13738 tag = *(p++);
11c1ff18 13739 size = byte_get (p, 4);
071436c6 13740 if (size > attr_len)
11c1ff18 13741 {
e9847026 13742 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13743 (unsigned) size, (unsigned) attr_len);
13744 size = attr_len;
11c1ff18 13745 }
e0a31db1
NC		 13746 /* PR binutils/17531: Safe handling of corrupt files. */
13747 if (size < 6)
13748 {
13749 error (_("Bad subsection length (%u < 6)\n"),
13750 (unsigned) size);
13751 section_len = 0;
13752 break;
13753 }
60bca95a 13754
071436c6 13755 attr_len -= size;
11c1ff18 13756 end = p + size - 1;
071436c6 13757 assert (end <= contents + sect->sh_size);
11c1ff18 13758 p += 4;
60bca95a 13759
11c1ff18
PB		 13760 switch (tag)
13761 {
13762 case 1:
2b692964 13763 printf (_("File Attributes\n"));
11c1ff18
PB		 13764 break;
13765 case 2:
2b692964 13766 printf (_("Section Attributes:"));
11c1ff18
PB		 13767 goto do_numlist;
13768 case 3:
2b692964 13769 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13770 do_numlist:
13771 for (;;)
13772 {
91d6fa6a 13773 unsigned int j;
60bca95a 13774
f6f0e17b 13775 val = read_uleb128 (p, &j, end);
91d6fa6a 13776 p += j;
11c1ff18
PB		 13777 if (val == 0)
13778 break;
13779 printf (" %d", val);
13780 }
13781 printf ("\n");
13782 break;
13783 default:
2b692964 13784 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13785 public_section = FALSE;
13786 break;
13787 }
60bca95a 13788
071436c6 13789 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13790 {
13791 while (p < end)
f6f0e17b 13792 p = display_pub_attribute (p, end);
071436c6 13793 assert (p <= end);
104d59d1 13794 }
071436c6 13795 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13796 {
13797 while (p < end)
13798 p = display_gnu_attribute (p,
f6f0e17b
NC		 13799 display_proc_gnu_attribute,
13800 end);
071436c6 13801 assert (p <= end);
11c1ff18 13802 }
071436c6 13803 else if (p < end)
11c1ff18 13804 {
071436c6 13805 printf (_(" Unknown attribute:\n"));
f6f0e17b 13806 display_raw_attribute (p, end);
11c1ff18
PB		 13807 p = end;
13808 }
071436c6
NC		 13809 else
13810 attr_len = 0;
11c1ff18
PB		 13811 }
13812 }
13813 }
13814 else
e9847026 13815 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13816
60bca95a 13817 free (contents);
11c1ff18
PB		 13818 }
13819 return 1;
13820}
13821
104d59d1 13822static int
2cf0635d 13823process_arm_specific (FILE * file)
104d59d1
JM		 13824{
13825 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13826 display_arm_attribute, NULL);
13827}
13828
34c8bcba 13829static int
2cf0635d 13830process_power_specific (FILE * file)
34c8bcba
JM		 13831{
13832 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13833 display_power_gnu_attribute);
13834}
13835
643f7afb
AK		 13836static int
13837process_s390_specific (FILE * file)
13838{
13839 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13840 display_s390_gnu_attribute);
13841}
13842
9e8c70f9
DM		 13843static int
13844process_sparc_specific (FILE * file)
13845{
13846 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13847 display_sparc_gnu_attribute);
13848}
13849
59e6276b
JM		 13850static int
13851process_tic6x_specific (FILE * file)
13852{
13853 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13854 display_tic6x_attribute, NULL);
13855}
13856
13761a11
NC		 13857static int
13858process_msp430x_specific (FILE * file)
13859{
13860 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13861 display_msp430x_attribute, NULL);
13862}
13863
ccb4c951
RS		 13864/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13865 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13866 and return the VMA of the next entry, or -1 if there was a problem.
13867 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13868
13869static bfd_vma
82b1b41b
NC		 13870print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13871 unsigned char * data_end)
ccb4c951
RS		 13872{
13873 printf (" ");
13874 print_vma (addr, LONG_HEX);
13875 printf (" ");
13876 if (addr < pltgot + 0xfff0)
13877 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13878 else
13879 printf ("%10s", "");
13880 printf (" ");
13881 if (data == NULL)
2b692964 13882 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13883 else
13884 {
13885 bfd_vma entry;
82b1b41b 13886 unsigned char * from = data + addr - pltgot;
ccb4c951 13887
82b1b41b
NC		 13888 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13889 {
13890 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13891 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13892 return (bfd_vma) -1;
13893 }
13894 else
13895 {
13896 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13897 print_vma (entry, LONG_HEX);
13898 }
ccb4c951
RS		 13899 }
13900 return addr + (is_32bit_elf ? 4 : 8);
13901}
13902
861fb55a
DJ		 13903/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13904 PLTGOT. Print the Address and Initial fields of an entry at VMA
13905 ADDR and return the VMA of the next entry. */
13906
13907static bfd_vma
2cf0635d 13908print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13909{
13910 printf (" ");
13911 print_vma (addr, LONG_HEX);
13912 printf (" ");
13913 if (data == NULL)
2b692964 13914 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13915 else
13916 {
13917 bfd_vma entry;
13918
13919 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13920 print_vma (entry, LONG_HEX);
13921 }
13922 return addr + (is_32bit_elf ? 4 : 8);
13923}
13924
351cdf24
MF		 13925static void
13926print_mips_ases (unsigned int mask)
13927{
13928 if (mask & AFL_ASE_DSP)
13929 fputs ("\n\tDSP ASE", stdout);
13930 if (mask & AFL_ASE_DSPR2)
13931 fputs ("\n\tDSP R2 ASE", stdout);
13932 if (mask & AFL_ASE_EVA)
13933 fputs ("\n\tEnhanced VA Scheme", stdout);
13934 if (mask & AFL_ASE_MCU)
13935 fputs ("\n\tMCU (MicroController) ASE", stdout);
13936 if (mask & AFL_ASE_MDMX)
13937 fputs ("\n\tMDMX ASE", stdout);
13938 if (mask & AFL_ASE_MIPS3D)
13939 fputs ("\n\tMIPS-3D ASE", stdout);
13940 if (mask & AFL_ASE_MT)
13941 fputs ("\n\tMT ASE", stdout);
13942 if (mask & AFL_ASE_SMARTMIPS)
13943 fputs ("\n\tSmartMIPS ASE", stdout);
13944 if (mask & AFL_ASE_VIRT)
13945 fputs ("\n\tVZ ASE", stdout);
13946 if (mask & AFL_ASE_MSA)
13947 fputs ("\n\tMSA ASE", stdout);
13948 if (mask & AFL_ASE_MIPS16)
13949 fputs ("\n\tMIPS16 ASE", stdout);
13950 if (mask & AFL_ASE_MICROMIPS)
13951 fputs ("\n\tMICROMIPS ASE", stdout);
13952 if (mask & AFL_ASE_XPA)
13953 fputs ("\n\tXPA ASE", stdout);
13954 if (mask == 0)
13955 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13956 else if ((mask & ~AFL_ASE_MASK) != 0)
13957 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13958}
13959
13960static void
13961print_mips_isa_ext (unsigned int isa_ext)
13962{
13963 switch (isa_ext)
13964 {
13965 case 0:
13966 fputs (_("None"), stdout);
13967 break;
13968 case AFL_EXT_XLR:
13969 fputs ("RMI XLR", stdout);
13970 break;
2c629856
N		 13971 case AFL_EXT_OCTEON3:
13972 fputs ("Cavium Networks Octeon3", stdout);
13973 break;
351cdf24
MF		 13974 case AFL_EXT_OCTEON2:
13975 fputs ("Cavium Networks Octeon2", stdout);
13976 break;
13977 case AFL_EXT_OCTEONP:
13978 fputs ("Cavium Networks OcteonP", stdout);
13979 break;
13980 case AFL_EXT_LOONGSON_3A:
13981 fputs ("Loongson 3A", stdout);
13982 break;
13983 case AFL_EXT_OCTEON:
13984 fputs ("Cavium Networks Octeon", stdout);
13985 break;
13986 case AFL_EXT_5900:
13987 fputs ("Toshiba R5900", stdout);
13988 break;
13989 case AFL_EXT_4650:
13990 fputs ("MIPS R4650", stdout);
13991 break;
13992 case AFL_EXT_4010:
13993 fputs ("LSI R4010", stdout);
13994 break;
13995 case AFL_EXT_4100:
13996 fputs ("NEC VR4100", stdout);
13997 break;
13998 case AFL_EXT_3900:
13999 fputs ("Toshiba R3900", stdout);
14000 break;
14001 case AFL_EXT_10000:
14002 fputs ("MIPS R10000", stdout);
14003 break;
14004 case AFL_EXT_SB1:
14005 fputs ("Broadcom SB-1", stdout);
14006 break;
14007 case AFL_EXT_4111:
14008 fputs ("NEC VR4111/VR4181", stdout);
14009 break;
14010 case AFL_EXT_4120:
14011 fputs ("NEC VR4120", stdout);
14012 break;
14013 case AFL_EXT_5400:
14014 fputs ("NEC VR5400", stdout);
14015 break;
14016 case AFL_EXT_5500:
14017 fputs ("NEC VR5500", stdout);
14018 break;
14019 case AFL_EXT_LOONGSON_2E:
14020 fputs ("ST Microelectronics Loongson 2E", stdout);
14021 break;
14022 case AFL_EXT_LOONGSON_2F:
14023 fputs ("ST Microelectronics Loongson 2F", stdout);
14024 break;
14025 default:
00ac7aa0 14026 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14027 }
14028}
14029
14030static int
14031get_mips_reg_size (int reg_size)
14032{
14033 return (reg_size == AFL_REG_NONE) ? 0
14034 : (reg_size == AFL_REG_32) ? 32
14035 : (reg_size == AFL_REG_64) ? 64
14036 : (reg_size == AFL_REG_128) ? 128
14037 : -1;
14038}
14039
19e6b90e 14040static int
2cf0635d 14041process_mips_specific (FILE * file)
5b18a4bc 14042{
2cf0635d 14043 Elf_Internal_Dyn * entry;
351cdf24 14044 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14045 size_t liblist_offset = 0;
14046 size_t liblistno = 0;
14047 size_t conflictsno = 0;
14048 size_t options_offset = 0;
14049 size_t conflicts_offset = 0;
861fb55a
DJ		 14050 size_t pltrelsz = 0;
14051 size_t pltrel = 0;
ccb4c951 14052 bfd_vma pltgot = 0;
861fb55a
DJ		 14053 bfd_vma mips_pltgot = 0;
14054 bfd_vma jmprel = 0;
ccb4c951
RS		 14055 bfd_vma local_gotno = 0;
14056 bfd_vma gotsym = 0;
14057 bfd_vma symtabno = 0;
103f02d3 14058
2cf19d5c
JM		 14059 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14060 display_mips_gnu_attribute);
14061
351cdf24
MF		 14062 sect = find_section (".MIPS.abiflags");
14063
14064 if (sect != NULL)
14065 {
14066 Elf_External_ABIFlags_v0 *abiflags_ext;
14067 Elf_Internal_ABIFlags_v0 abiflags_in;
14068
14069 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14070 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14071 else
14072 {
14073 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14074 sect->sh_size, _("MIPS ABI Flags section"));
14075 if (abiflags_ext)
14076 {
14077 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14078 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14079 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14080 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14081 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14082 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14083 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14084 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14085 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14086 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14087 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14088
14089 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14090 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14091 if (abiflags_in.isa_rev > 1)
14092 printf ("r%d", abiflags_in.isa_rev);
14093 printf ("\nGPR size: %d",
14094 get_mips_reg_size (abiflags_in.gpr_size));
14095 printf ("\nCPR1 size: %d",
14096 get_mips_reg_size (abiflags_in.cpr1_size));
14097 printf ("\nCPR2 size: %d",
14098 get_mips_reg_size (abiflags_in.cpr2_size));
14099 fputs ("\nFP ABI: ", stdout);
14100 print_mips_fp_abi_value (abiflags_in.fp_abi);
14101 fputs ("ISA Extension: ", stdout);
14102 print_mips_isa_ext (abiflags_in.isa_ext);
14103 fputs ("\nASEs:", stdout);
14104 print_mips_ases (abiflags_in.ases);
14105 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14106 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14107 fputc ('\n', stdout);
14108 free (abiflags_ext);
14109 }
14110 }
14111 }
14112
19e6b90e
L		 14113 /* We have a lot of special sections. Thanks SGI! */
14114 if (dynamic_section == NULL)
14115 /* No information available. */
14116 return 0;
252b5132 14117
071436c6
NC		 14118 for (entry = dynamic_section;
14119 /* PR 17531 file: 012-50589-0.004. */
14120 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14121 ++entry)
252b5132
RH		 14122 switch (entry->d_tag)
14123 {
14124 case DT_MIPS_LIBLIST:
d93f0186
NC		 14125 liblist_offset
14126 = offset_from_vma (file, entry->d_un.d_val,
14127 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14128 break;
14129 case DT_MIPS_LIBLISTNO:
14130 liblistno = entry->d_un.d_val;
14131 break;
14132 case DT_MIPS_OPTIONS:
d93f0186 14133 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14134 break;
14135 case DT_MIPS_CONFLICT:
d93f0186
NC		 14136 conflicts_offset
14137 = offset_from_vma (file, entry->d_un.d_val,
14138 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14139 break;
14140 case DT_MIPS_CONFLICTNO:
14141 conflictsno = entry->d_un.d_val;
14142 break;
ccb4c951 14143 case DT_PLTGOT:
861fb55a
DJ		 14144 pltgot = entry->d_un.d_ptr;
14145 break;
ccb4c951
RS		 14146 case DT_MIPS_LOCAL_GOTNO:
14147 local_gotno = entry->d_un.d_val;
14148 break;
14149 case DT_MIPS_GOTSYM:
14150 gotsym = entry->d_un.d_val;
14151 break;
14152 case DT_MIPS_SYMTABNO:
14153 symtabno = entry->d_un.d_val;
14154 break;
861fb55a
DJ		 14155 case DT_MIPS_PLTGOT:
14156 mips_pltgot = entry->d_un.d_ptr;
14157 break;
14158 case DT_PLTREL:
14159 pltrel = entry->d_un.d_val;
14160 break;
14161 case DT_PLTRELSZ:
14162 pltrelsz = entry->d_un.d_val;
14163 break;
14164 case DT_JMPREL:
14165 jmprel = entry->d_un.d_ptr;
14166 break;
252b5132
RH		 14167 default:
14168 break;
14169 }
14170
14171 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14172 {
2cf0635d 14173 Elf32_External_Lib * elib;
252b5132
RH		 14174 size_t cnt;
14175
3f5e193b
NC		 14176 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14177 liblistno,
14178 sizeof (Elf32_External_Lib),
9cf03b7e 14179 _("liblist section data"));
a6e9f9df 14180 if (elib)
252b5132 14181 {
2b692964 14182 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14183 (unsigned long) liblistno);
2b692964 14184 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14185 stdout);
14186
14187 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14188 {
a6e9f9df 14189 Elf32_Lib liblist;
91d6fa6a 14190 time_t atime;
a6e9f9df 14191 char timebuf[20];
2cf0635d 14192 struct tm * tmp;
a6e9f9df
AM		 14193
14194 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14195 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14196 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14197 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14198 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14199
91d6fa6a 14200 tmp = gmtime (&atime);
e9e44622
JJ		 14201 snprintf (timebuf, sizeof (timebuf),
14202 "%04u-%02u-%02uT%02u:%02u:%02u",
14203 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14204 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14205
31104126 14206 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14207 if (VALID_DYNAMIC_NAME (liblist.l_name))
14208 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14209 else
2b692964 14210 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14211 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14212 liblist.l_version);
a6e9f9df
AM		 14213
14214 if (liblist.l_flags == 0)
2b692964 14215 puts (_(" NONE"));
a6e9f9df
AM		 14216 else
14217 {
14218 static const struct
252b5132 14219 {
2cf0635d 14220 const char * name;
a6e9f9df 14221 int bit;
252b5132 14222 }
a6e9f9df
AM		 14223 l_flags_vals[] =
14224 {
14225 { " EXACT_MATCH", LL_EXACT_MATCH },
14226 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14227 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14228 { " EXPORTS", LL_EXPORTS },
14229 { " DELAY_LOAD", LL_DELAY_LOAD },
14230 { " DELTA", LL_DELTA }
14231 };
14232 int flags = liblist.l_flags;
14233 size_t fcnt;
14234
60bca95a 14235 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14236 if ((flags & l_flags_vals[fcnt].bit) != 0)
14237 {
14238 fputs (l_flags_vals[fcnt].name, stdout);
14239 flags ^= l_flags_vals[fcnt].bit;
14240 }
14241 if (flags != 0)
14242 printf (" %#x", (unsigned int) flags);
252b5132 14243
a6e9f9df
AM		 14244 puts ("");
14245 }
252b5132 14246 }
252b5132 14247
a6e9f9df
AM		 14248 free (elib);
14249 }
252b5132
RH		 14250 }
14251
14252 if (options_offset != 0)
14253 {
2cf0635d 14254 Elf_External_Options * eopt;
2cf0635d
NC		 14255 Elf_Internal_Options * iopt;
14256 Elf_Internal_Options * option;
252b5132
RH		 14257 size_t offset;
14258 int cnt;
351cdf24 14259 sect = section_headers;
252b5132
RH		 14260
14261 /* Find the section header so that we get the size. */
071436c6 14262 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14263 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14264 if (sect == NULL)
14265 {
14266 error (_("No MIPS_OPTIONS header found\n"));
14267 return 0;
14268 }
252b5132 14269
3f5e193b
NC		 14270 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14271 sect->sh_size, _("options"));
a6e9f9df 14272 if (eopt)
252b5132 14273 {
3f5e193b
NC		 14274 iopt = (Elf_Internal_Options *)
14275 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14276 if (iopt == NULL)
14277 {
8b73c356 14278 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14279 return 0;
14280 }
76da6bbe 14281
a6e9f9df
AM		 14282 offset = cnt = 0;
14283 option = iopt;
252b5132 14284
82b1b41b 14285 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14286 {
2cf0635d 14287 Elf_External_Options * eoption;
252b5132 14288
a6e9f9df 14289 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14290
a6e9f9df
AM		 14291 option->kind = BYTE_GET (eoption->kind);
14292 option->size = BYTE_GET (eoption->size);
14293 option->section = BYTE_GET (eoption->section);
14294 option->info = BYTE_GET (eoption->info);
76da6bbe 14295
82b1b41b
NC		 14296 /* PR 17531: file: ffa0fa3b. */
14297 if (option->size < sizeof (* eopt)
14298 || offset + option->size > sect->sh_size)
14299 {
55325047
NC		 14300 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14301 return 0;
82b1b41b 14302 }
a6e9f9df 14303 offset += option->size;
14ae95f2 14304
a6e9f9df
AM		 14305 ++option;
14306 ++cnt;
14307 }
252b5132 14308
a6e9f9df 14309 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14310 printable_section_name (sect), cnt);
76da6bbe 14311
a6e9f9df 14312 option = iopt;
82b1b41b 14313 offset = 0;
252b5132 14314
a6e9f9df 14315 while (cnt-- > 0)
252b5132 14316 {
a6e9f9df
AM		 14317 size_t len;
14318
14319 switch (option->kind)
252b5132 14320 {
a6e9f9df
AM		 14321 case ODK_NULL:
14322 /* This shouldn't happen. */
14323 printf (" NULL %d %lx", option->section, option->info);
14324 break;
14325 case ODK_REGINFO:
14326 printf (" REGINFO ");
14327 if (elf_header.e_machine == EM_MIPS)
14328 {
14329 /* 32bit form. */
2cf0635d 14330 Elf32_External_RegInfo * ereg;
b34976b6 14331 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14332
14333 ereg = (Elf32_External_RegInfo *) (option + 1);
14334 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14335 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14336 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14337 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14338 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14339 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14340
14341 printf ("GPR %08lx GP 0x%lx\n",
14342 reginfo.ri_gprmask,
14343 (unsigned long) reginfo.ri_gp_value);
14344 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14345 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14346 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14347 }
14348 else
14349 {
14350 /* 64 bit form. */
2cf0635d 14351 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14352 Elf64_Internal_RegInfo reginfo;
14353
14354 ereg = (Elf64_External_RegInfo *) (option + 1);
14355 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14356 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14357 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14358 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14359 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14360 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14361
14362 printf ("GPR %08lx GP 0x",
14363 reginfo.ri_gprmask);
14364 printf_vma (reginfo.ri_gp_value);
14365 printf ("\n");
14366
14367 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14368 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14369 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14370 }
14371 ++option;
14372 continue;
14373 case ODK_EXCEPTIONS:
14374 fputs (" EXCEPTIONS fpe_min(", stdout);
14375 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14376 fputs (") fpe_max(", stdout);
14377 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14378 fputs (")", stdout);
14379
14380 if (option->info & OEX_PAGE0)
14381 fputs (" PAGE0", stdout);
14382 if (option->info & OEX_SMM)
14383 fputs (" SMM", stdout);
14384 if (option->info & OEX_FPDBUG)
14385 fputs (" FPDBUG", stdout);
14386 if (option->info & OEX_DISMISS)
14387 fputs (" DISMISS", stdout);
14388 break;
14389 case ODK_PAD:
14390 fputs (" PAD ", stdout);
14391 if (option->info & OPAD_PREFIX)
14392 fputs (" PREFIX", stdout);
14393 if (option->info & OPAD_POSTFIX)
14394 fputs (" POSTFIX", stdout);
14395 if (option->info & OPAD_SYMBOL)
14396 fputs (" SYMBOL", stdout);
14397 break;
14398 case ODK_HWPATCH:
14399 fputs (" HWPATCH ", stdout);
14400 if (option->info & OHW_R4KEOP)
14401 fputs (" R4KEOP", stdout);
14402 if (option->info & OHW_R8KPFETCH)
14403 fputs (" R8KPFETCH", stdout);
14404 if (option->info & OHW_R5KEOP)
14405 fputs (" R5KEOP", stdout);
14406 if (option->info & OHW_R5KCVTL)
14407 fputs (" R5KCVTL", stdout);
14408 break;
14409 case ODK_FILL:
14410 fputs (" FILL ", stdout);
14411 /* XXX Print content of info word? */
14412 break;
14413 case ODK_TAGS:
14414 fputs (" TAGS ", stdout);
14415 /* XXX Print content of info word? */
14416 break;
14417 case ODK_HWAND:
14418 fputs (" HWAND ", stdout);
14419 if (option->info & OHWA0_R4KEOP_CHECKED)
14420 fputs (" R4KEOP_CHECKED", stdout);
14421 if (option->info & OHWA0_R4KEOP_CLEAN)
14422 fputs (" R4KEOP_CLEAN", stdout);
14423 break;
14424 case ODK_HWOR:
14425 fputs (" HWOR ", stdout);
14426 if (option->info & OHWA0_R4KEOP_CHECKED)
14427 fputs (" R4KEOP_CHECKED", stdout);
14428 if (option->info & OHWA0_R4KEOP_CLEAN)
14429 fputs (" R4KEOP_CLEAN", stdout);
14430 break;
14431 case ODK_GP_GROUP:
14432 printf (" GP_GROUP %#06lx self-contained %#06lx",
14433 option->info & OGP_GROUP,
14434 (option->info & OGP_SELF) >> 16);
14435 break;
14436 case ODK_IDENT:
14437 printf (" IDENT %#06lx self-contained %#06lx",
14438 option->info & OGP_GROUP,
14439 (option->info & OGP_SELF) >> 16);
14440 break;
14441 default:
14442 /* This shouldn't happen. */
14443 printf (" %3d ??? %d %lx",
14444 option->kind, option->section, option->info);
14445 break;
252b5132 14446 }
a6e9f9df 14447
2cf0635d 14448 len = sizeof (* eopt);
a6e9f9df 14449 while (len < option->size)
82b1b41b
NC		 14450 {
14451 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14452
82b1b41b
NC		 14453 if (ISPRINT (datum))
14454 printf ("%c", datum);
14455 else
14456 printf ("\\%03o", datum);
14457 len ++;
14458 }
a6e9f9df 14459 fputs ("\n", stdout);
82b1b41b
NC		 14460
14461 offset += option->size;
252b5132 14462 ++option;
252b5132
RH		 14463 }
14464
a6e9f9df 14465 free (eopt);
252b5132 14466 }
252b5132
RH		 14467 }
14468
14469 if (conflicts_offset != 0 && conflictsno != 0)
14470 {
2cf0635d 14471 Elf32_Conflict * iconf;
252b5132
RH		 14472 size_t cnt;
14473
14474 if (dynamic_symbols == NULL)
14475 {
591a748a 14476 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14477 return 0;
14478 }
14479
3f5e193b 14480 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14481 if (iconf == NULL)
14482 {
8b73c356 14483 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14484 return 0;
14485 }
14486
9ea033b2 14487 if (is_32bit_elf)
252b5132 14488 {
2cf0635d 14489 Elf32_External_Conflict * econf32;
a6e9f9df 14490
3f5e193b
NC		 14491 econf32 = (Elf32_External_Conflict *)
14492 get_data (NULL, file, conflicts_offset, conflictsno,
14493 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14494 if (!econf32)
14495 return 0;
252b5132
RH		 14496
14497 for (cnt = 0; cnt < conflictsno; ++cnt)
14498 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14499
14500 free (econf32);
252b5132
RH		 14501 }
14502 else
14503 {
2cf0635d 14504 Elf64_External_Conflict * econf64;
a6e9f9df 14505
3f5e193b
NC		 14506 econf64 = (Elf64_External_Conflict *)
14507 get_data (NULL, file, conflicts_offset, conflictsno,
14508 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14509 if (!econf64)
14510 return 0;
252b5132
RH		 14511
14512 for (cnt = 0; cnt < conflictsno; ++cnt)
14513 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14514
14515 free (econf64);
252b5132
RH		 14516 }
14517
c7e7ca54
NC		 14518 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14519 (unsigned long) conflictsno);
252b5132
RH		 14520 puts (_(" Num: Index Value Name"));
14521
14522 for (cnt = 0; cnt < conflictsno; ++cnt)
14523 {
b34976b6 14524 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14525
14526 if (iconf[cnt] >= num_dynamic_syms)
14527 printf (_("<corrupt symbol index>"));
d79b3d50 14528 else
e0a31db1
NC		 14529 {
14530 Elf_Internal_Sym * psym;
14531
14532 psym = & dynamic_symbols[iconf[cnt]];
14533 print_vma (psym->st_value, FULL_HEX);
14534 putchar (' ');
14535 if (VALID_DYNAMIC_NAME (psym->st_name))
14536 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14537 else
14538 printf (_("<corrupt: %14ld>"), psym->st_name);
14539 }
31104126 14540 putchar ('\n');
252b5132
RH		 14541 }
14542
252b5132
RH		 14543 free (iconf);
14544 }
14545
ccb4c951
RS		 14546 if (pltgot != 0 && local_gotno != 0)
14547 {
91d6fa6a 14548 bfd_vma ent, local_end, global_end;
bbeee7ea 14549 size_t i, offset;
2cf0635d 14550 unsigned char * data;
82b1b41b 14551 unsigned char * data_end;
bbeee7ea 14552 int addr_size;
ccb4c951 14553
91d6fa6a 14554 ent = pltgot;
ccb4c951
RS		 14555 addr_size = (is_32bit_elf ? 4 : 8);
14556 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14557
74e1a04b
NC		 14558 /* PR binutils/17533 file: 012-111227-0.004 */
14559 if (symtabno < gotsym)
14560 {
14561 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14562 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14563 return 0;
14564 }
82b1b41b 14565
74e1a04b 14566 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14567 /* PR 17531: file: 54c91a34. */
14568 if (global_end < local_end)
14569 {
14570 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14571 return 0;
14572 }
948f632f 14573
ccb4c951 14574 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14575 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14576 global_end - pltgot, 1,
14577 _("Global Offset Table data"));
59245841
NC		 14578 if (data == NULL)
14579 return 0;
82b1b41b 14580 data_end = data + (global_end - pltgot);
59245841 14581
ccb4c951
RS		 14582 printf (_("\nPrimary GOT:\n"));
14583 printf (_(" Canonical gp value: "));
14584 print_vma (pltgot + 0x7ff0, LONG_HEX);
14585 printf ("\n\n");
14586
14587 printf (_(" Reserved entries:\n"));
14588 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14589 addr_size * 2, _("Address"), _("Access"),
14590 addr_size * 2, _("Initial"));
82b1b41b 14591 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14592 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14593 if (ent == (bfd_vma) -1)
14594 goto got_print_fail;
ccb4c951 14595 if (data
91d6fa6a 14596 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14597 >> (addr_size * 8 - 1)) != 0)
14598 {
82b1b41b 14599 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14600 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14601 if (ent == (bfd_vma) -1)
14602 goto got_print_fail;
ccb4c951
RS		 14603 }
14604 printf ("\n");
14605
91d6fa6a 14606 if (ent < local_end)
ccb4c951
RS		 14607 {
14608 printf (_(" Local entries:\n"));
cc5914eb 14609 printf (" %*s %10s %*s\n",
2b692964
NC		 14610 addr_size * 2, _("Address"), _("Access"),
14611 addr_size * 2, _("Initial"));
91d6fa6a 14612 while (ent < local_end)
ccb4c951 14613 {
82b1b41b 14614 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14615 printf ("\n");
82b1b41b
NC		 14616 if (ent == (bfd_vma) -1)
14617 goto got_print_fail;
ccb4c951
RS		 14618 }
14619 printf ("\n");
14620 }
14621
14622 if (gotsym < symtabno)
14623 {
14624 int sym_width;
14625
14626 printf (_(" Global entries:\n"));
cc5914eb 14627 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14628 addr_size * 2, _("Address"),
14629 _("Access"),
2b692964 14630 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14631 addr_size * 2, _("Sym.Val."),
14632 _("Type"),
14633 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14634 _("Ndx"), _("Name"));
0b4362b0 14635
ccb4c951 14636 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14637
ccb4c951
RS		 14638 for (i = gotsym; i < symtabno; i++)
14639 {
82b1b41b 14640 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14641 printf (" ");
e0a31db1
NC		 14642
14643 if (dynamic_symbols == NULL)
14644 printf (_("<no dynamic symbols>"));
14645 else if (i < num_dynamic_syms)
14646 {
14647 Elf_Internal_Sym * psym = dynamic_symbols + i;
14648
14649 print_vma (psym->st_value, LONG_HEX);
14650 printf (" %-7s %3s ",
14651 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14652 get_symbol_index_type (psym->st_shndx));
14653
14654 if (VALID_DYNAMIC_NAME (psym->st_name))
14655 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14656 else
14657 printf (_("<corrupt: %14ld>"), psym->st_name);
14658 }
ccb4c951 14659 else
7fc5ac57
JBG		 14660 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14661 (unsigned long) i);
e0a31db1 14662
ccb4c951 14663 printf ("\n");
82b1b41b
NC		 14664 if (ent == (bfd_vma) -1)
14665 break;
ccb4c951
RS		 14666 }
14667 printf ("\n");
14668 }
14669
82b1b41b 14670 got_print_fail:
ccb4c951
RS		 14671 if (data)
14672 free (data);
14673 }
14674
861fb55a
DJ		 14675 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14676 {
91d6fa6a 14677 bfd_vma ent, end;
861fb55a
DJ		 14678 size_t offset, rel_offset;
14679 unsigned long count, i;
2cf0635d 14680 unsigned char * data;
861fb55a 14681 int addr_size, sym_width;
2cf0635d 14682 Elf_Internal_Rela * rels;
861fb55a
DJ		 14683
14684 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14685 if (pltrel == DT_RELA)
14686 {
14687 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14688 return 0;
14689 }
14690 else
14691 {
14692 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14693 return 0;
14694 }
14695
91d6fa6a 14696 ent = mips_pltgot;
861fb55a
DJ		 14697 addr_size = (is_32bit_elf ? 4 : 8);
14698 end = mips_pltgot + (2 + count) * addr_size;
14699
14700 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14701 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14702 1, _("Procedure Linkage Table data"));
59245841
NC		 14703 if (data == NULL)
14704 return 0;
14705
9cf03b7e 14706 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14707 printf (_(" Reserved entries:\n"));
14708 printf (_(" %*s %*s Purpose\n"),
2b692964 14709 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14710 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14711 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14712 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14713 printf (_(" Module pointer\n"));
861fb55a
DJ		 14714 printf ("\n");
14715
14716 printf (_(" Entries:\n"));
cc5914eb 14717 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14718 addr_size * 2, _("Address"),
14719 addr_size * 2, _("Initial"),
14720 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14721 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14722 for (i = 0; i < count; i++)
14723 {
df97ab2a 14724 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14725
91d6fa6a 14726 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14727 printf (" ");
e0a31db1 14728
df97ab2a
MF		 14729 if (idx >= num_dynamic_syms)
14730 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14731 else
e0a31db1 14732 {
df97ab2a 14733 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14734
14735 print_vma (psym->st_value, LONG_HEX);
14736 printf (" %-7s %3s ",
14737 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14738 get_symbol_index_type (psym->st_shndx));
14739 if (VALID_DYNAMIC_NAME (psym->st_name))
14740 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14741 else
14742 printf (_("<corrupt: %14ld>"), psym->st_name);
14743 }
861fb55a
DJ		 14744 printf ("\n");
14745 }
14746 printf ("\n");
14747
14748 if (data)
14749 free (data);
14750 free (rels);
14751 }
14752
252b5132
RH		 14753 return 1;
14754}
14755
35c08157
KLC		 14756static int
14757process_nds32_specific (FILE * file)
14758{
14759 Elf_Internal_Shdr *sect = NULL;
14760
14761 sect = find_section (".nds32_e_flags");
14762 if (sect != NULL)
14763 {
14764 unsigned int *flag;
14765
14766 printf ("\nNDS32 elf flags section:\n");
14767 flag = get_data (NULL, file, sect->sh_offset, 1,
14768 sect->sh_size, _("NDS32 elf flags section"));
14769
14770 switch ((*flag) & 0x3)
14771 {
14772 case 0:
14773 printf ("(VEC_SIZE):\tNo entry.\n");
14774 break;
14775 case 1:
14776 printf ("(VEC_SIZE):\t4 bytes\n");
14777 break;
14778 case 2:
14779 printf ("(VEC_SIZE):\t16 bytes\n");
14780 break;
14781 case 3:
14782 printf ("(VEC_SIZE):\treserved\n");
14783 break;
14784 }
14785 }
14786
14787 return TRUE;
14788}
14789
047b2264 14790static int
2cf0635d 14791process_gnu_liblist (FILE * file)
047b2264 14792{
2cf0635d
NC		 14793 Elf_Internal_Shdr * section;
14794 Elf_Internal_Shdr * string_sec;
14795 Elf32_External_Lib * elib;
14796 char * strtab;
c256ffe7 14797 size_t strtab_size;
047b2264
JJ		 14798 size_t cnt;
14799 unsigned i;
14800
14801 if (! do_arch)
14802 return 0;
14803
14804 for (i = 0, section = section_headers;
14805 i < elf_header.e_shnum;
b34976b6 14806 i++, section++)
047b2264
JJ		 14807 {
14808 switch (section->sh_type)
14809 {
14810 case SHT_GNU_LIBLIST:
4fbb74a6 14811 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14812 break;
14813
3f5e193b
NC		 14814 elib = (Elf32_External_Lib *)
14815 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14816 _("liblist section data"));
047b2264
JJ		 14817
14818 if (elib == NULL)
14819 break;
4fbb74a6 14820 string_sec = section_headers + section->sh_link;
047b2264 14821
3f5e193b
NC		 14822 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14823 string_sec->sh_size,
14824 _("liblist string table"));
047b2264
JJ		 14825 if (strtab == NULL
14826 || section->sh_entsize != sizeof (Elf32_External_Lib))
14827 {
14828 free (elib);
2842702f 14829 free (strtab);
047b2264
JJ		 14830 break;
14831 }
59245841 14832 strtab_size = string_sec->sh_size;
047b2264
JJ		 14833
14834 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14835 printable_section_name (section),
0af1713e 14836 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14837
2b692964 14838 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14839
14840 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14841 ++cnt)
14842 {
14843 Elf32_Lib liblist;
91d6fa6a 14844 time_t atime;
047b2264 14845 char timebuf[20];
2cf0635d 14846 struct tm * tmp;
047b2264
JJ		 14847
14848 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14849 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14850 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14851 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14852 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14853
91d6fa6a 14854 tmp = gmtime (&atime);
e9e44622
JJ		 14855 snprintf (timebuf, sizeof (timebuf),
14856 "%04u-%02u-%02uT%02u:%02u:%02u",
14857 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14858 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14859
14860 printf ("%3lu: ", (unsigned long) cnt);
14861 if (do_wide)
c256ffe7 14862 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14863 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14864 else
c256ffe7 14865 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14866 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14867 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14868 liblist.l_version, liblist.l_flags);
14869 }
14870
14871 free (elib);
2842702f 14872 free (strtab);
047b2264
JJ		 14873 }
14874 }
14875
14876 return 1;
14877}
14878
9437c45b 14879static const char *
d3ba0551 14880get_note_type (unsigned e_type)
779fe533
NC		 14881{
14882 static char buff[64];
103f02d3 14883
1ec5cd37
NC		 14884 if (elf_header.e_type == ET_CORE)
14885 switch (e_type)
14886 {
57346661 14887 case NT_AUXV:
1ec5cd37 14888 return _("NT_AUXV (auxiliary vector)");
57346661 14889 case NT_PRSTATUS:
1ec5cd37 14890 return _("NT_PRSTATUS (prstatus structure)");
57346661 14891 case NT_FPREGSET:
1ec5cd37 14892 return _("NT_FPREGSET (floating point registers)");
57346661 14893 case NT_PRPSINFO:
1ec5cd37 14894 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14895 case NT_TASKSTRUCT:
1ec5cd37 14896 return _("NT_TASKSTRUCT (task structure)");
57346661 14897 case NT_PRXFPREG:
1ec5cd37 14898 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14899 case NT_PPC_VMX:
14900 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14901 case NT_PPC_VSX:
14902 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14903 case NT_386_TLS:
14904 return _("NT_386_TLS (x86 TLS information)");
14905 case NT_386_IOPERM:
14906 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14907 case NT_X86_XSTATE:
14908 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14909 case NT_S390_HIGH_GPRS:
14910 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14911 case NT_S390_TIMER:
14912 return _("NT_S390_TIMER (s390 timer register)");
14913 case NT_S390_TODCMP:
14914 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14915 case NT_S390_TODPREG:
14916 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14917 case NT_S390_CTRS:
14918 return _("NT_S390_CTRS (s390 control registers)");
14919 case NT_S390_PREFIX:
14920 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14921 case NT_S390_LAST_BREAK:
14922 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14923 case NT_S390_SYSTEM_CALL:
14924 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14925 case NT_S390_TDB:
14926 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14927 case NT_S390_VXRS_LOW:
14928 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14929 case NT_S390_VXRS_HIGH:
14930 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14931 case NT_ARM_VFP:
14932 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14933 case NT_ARM_TLS:
14934 return _("NT_ARM_TLS (AArch TLS registers)");
14935 case NT_ARM_HW_BREAK:
14936 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14937 case NT_ARM_HW_WATCH:
14938 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14939 case NT_PSTATUS:
1ec5cd37 14940 return _("NT_PSTATUS (pstatus structure)");
57346661 14941 case NT_FPREGS:
1ec5cd37 14942 return _("NT_FPREGS (floating point registers)");
57346661 14943 case NT_PSINFO:
1ec5cd37 14944 return _("NT_PSINFO (psinfo structure)");
57346661 14945 case NT_LWPSTATUS:
1ec5cd37 14946 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14947 case NT_LWPSINFO:
1ec5cd37 14948 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14949 case NT_WIN32PSTATUS:
1ec5cd37 14950 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14951 case NT_SIGINFO:
14952 return _("NT_SIGINFO (siginfo_t data)");
14953 case NT_FILE:
14954 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14955 default:
14956 break;
14957 }
14958 else
14959 switch (e_type)
14960 {
14961 case NT_VERSION:
14962 return _("NT_VERSION (version)");
14963 case NT_ARCH:
14964 return _("NT_ARCH (architecture)");
14965 default:
14966 break;
14967 }
14968
e9e44622 14969 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14970 return buff;
779fe533
NC		 14971}
14972
9ece1fa9
TT		 14973static int
14974print_core_note (Elf_Internal_Note *pnote)
14975{
14976 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14977 bfd_vma count, page_size;
14978 unsigned char *descdata, *filenames, *descend;
14979
14980 if (pnote->type != NT_FILE)
14981 return 1;
14982
14983#ifndef BFD64
14984 if (!is_32bit_elf)
14985 {
14986 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14987 /* Still "successful". */
14988 return 1;
14989 }
14990#endif
14991
14992 if (pnote->descsz < 2 * addr_size)
14993 {
14994 printf (_(" Malformed note - too short for header\n"));
14995 return 0;
14996 }
14997
14998 descdata = (unsigned char *) pnote->descdata;
14999 descend = descdata + pnote->descsz;
15000
15001 if (descdata[pnote->descsz - 1] != '\0')
15002 {
15003 printf (_(" Malformed note - does not end with \\0\n"));
15004 return 0;
15005 }
15006
15007 count = byte_get (descdata, addr_size);
15008 descdata += addr_size;
15009
15010 page_size = byte_get (descdata, addr_size);
15011 descdata += addr_size;
15012
15013 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15014 {
15015 printf (_(" Malformed note - too short for supplied file count\n"));
15016 return 0;
15017 }
15018
15019 printf (_(" Page size: "));
15020 print_vma (page_size, DEC);
15021 printf ("\n");
15022
15023 printf (_(" %*s%*s%*s\n"),
15024 (int) (2 + 2 * addr_size), _("Start"),
15025 (int) (4 + 2 * addr_size), _("End"),
15026 (int) (4 + 2 * addr_size), _("Page Offset"));
15027 filenames = descdata + count * 3 * addr_size;
15028 while (--count > 0)
15029 {
15030 bfd_vma start, end, file_ofs;
15031
15032 if (filenames == descend)
15033 {
15034 printf (_(" Malformed note - filenames end too early\n"));
15035 return 0;
15036 }
15037
15038 start = byte_get (descdata, addr_size);
15039 descdata += addr_size;
15040 end = byte_get (descdata, addr_size);
15041 descdata += addr_size;
15042 file_ofs = byte_get (descdata, addr_size);
15043 descdata += addr_size;
15044
15045 printf (" ");
15046 print_vma (start, FULL_HEX);
15047 printf (" ");
15048 print_vma (end, FULL_HEX);
15049 printf (" ");
15050 print_vma (file_ofs, FULL_HEX);
15051 printf ("\n %s\n", filenames);
15052
15053 filenames += 1 + strlen ((char *) filenames);
15054 }
15055
15056 return 1;
15057}
15058
1118d252
RM		 15059static const char *
15060get_gnu_elf_note_type (unsigned e_type)
15061{
15062 static char buff[64];
15063
15064 switch (e_type)
15065 {
15066 case NT_GNU_ABI_TAG:
15067 return _("NT_GNU_ABI_TAG (ABI version tag)");
15068 case NT_GNU_HWCAP:
15069 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15070 case NT_GNU_BUILD_ID:
15071 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15072 case NT_GNU_GOLD_VERSION:
15073 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15074 default:
15075 break;
15076 }
15077
15078 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15079 return buff;
15080}
15081
664f90a3
TT		 15082static int
15083print_gnu_note (Elf_Internal_Note *pnote)
15084{
15085 switch (pnote->type)
15086 {
15087 case NT_GNU_BUILD_ID:
15088 {
15089 unsigned long i;
15090
15091 printf (_(" Build ID: "));
15092 for (i = 0; i < pnote->descsz; ++i)
15093 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15094 printf ("\n");
664f90a3
TT		 15095 }
15096 break;
15097
15098 case NT_GNU_ABI_TAG:
15099 {
15100 unsigned long os, major, minor, subminor;
15101 const char *osname;
15102
3102e897
NC		 15103 /* PR 17531: file: 030-599401-0.004. */
15104 if (pnote->descsz < 16)
15105 {
15106 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15107 break;
15108 }
15109
664f90a3
TT		 15110 os = byte_get ((unsigned char *) pnote->descdata, 4);
15111 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15112 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15113 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15114
15115 switch (os)
15116 {
15117 case GNU_ABI_TAG_LINUX:
15118 osname = "Linux";
15119 break;
15120 case GNU_ABI_TAG_HURD:
15121 osname = "Hurd";
15122 break;
15123 case GNU_ABI_TAG_SOLARIS:
15124 osname = "Solaris";
15125 break;
15126 case GNU_ABI_TAG_FREEBSD:
15127 osname = "FreeBSD";
15128 break;
15129 case GNU_ABI_TAG_NETBSD:
15130 osname = "NetBSD";
15131 break;
14ae95f2
RM		 15132 case GNU_ABI_TAG_SYLLABLE:
15133 osname = "Syllable";
15134 break;
15135 case GNU_ABI_TAG_NACL:
15136 osname = "NaCl";
15137 break;
664f90a3
TT		 15138 default:
15139 osname = "Unknown";
15140 break;
15141 }
15142
15143 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15144 major, minor, subminor);
15145 }
15146 break;
926c5385
CC		 15147
15148 case NT_GNU_GOLD_VERSION:
15149 {
15150 unsigned long i;
15151
15152 printf (_(" Version: "));
15153 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15154 printf ("%c", pnote->descdata[i]);
15155 printf ("\n");
15156 }
15157 break;
664f90a3
TT		 15158 }
15159
15160 return 1;
15161}
15162
685080f2
NC		 15163static const char *
15164get_v850_elf_note_type (enum v850_notes n_type)
15165{
15166 static char buff[64];
15167
15168 switch (n_type)
15169 {
15170 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15171 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15172 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15173 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15174 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15175 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15176 default:
15177 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15178 return buff;
15179 }
15180}
15181
15182static int
15183print_v850_note (Elf_Internal_Note * pnote)
15184{
15185 unsigned int val;
15186
15187 if (pnote->descsz != 4)
15188 return 0;
15189 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15190
15191 if (val == 0)
15192 {
15193 printf (_("not set\n"));
15194 return 1;
15195 }
15196
15197 switch (pnote->type)
15198 {
15199 case V850_NOTE_ALIGNMENT:
15200 switch (val)
15201 {
15202 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15203 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15204 }
15205 break;
14ae95f2 15206
685080f2
NC		 15207 case V850_NOTE_DATA_SIZE:
15208 switch (val)
15209 {
15210 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15211 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15212 }
15213 break;
14ae95f2 15214
685080f2
NC		 15215 case V850_NOTE_FPU_INFO:
15216 switch (val)
15217 {
15218 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15219 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15220 }
15221 break;
14ae95f2 15222
685080f2
NC		 15223 case V850_NOTE_MMU_INFO:
15224 case V850_NOTE_CACHE_INFO:
15225 case V850_NOTE_SIMD_INFO:
15226 if (val == EF_RH850_SIMD)
15227 {
15228 printf (_("yes\n"));
15229 return 1;
15230 }
15231 break;
15232
15233 default:
15234 /* An 'unknown note type' message will already have been displayed. */
15235 break;
15236 }
15237
15238 printf (_("unknown value: %x\n"), val);
15239 return 0;
15240}
15241
9437c45b 15242static const char *
d3ba0551 15243get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15244{
15245 static char buff[64];
15246
b4db1224 15247 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15248 {
15249 /* NetBSD core "procinfo" structure. */
15250 return _("NetBSD procinfo structure");
15251 }
15252
15253 /* As of Jan 2002 there are no other machine-independent notes
15254 defined for NetBSD core files. If the note type is less
15255 than the start of the machine-dependent note types, we don't
15256 understand it. */
15257
b4db1224 15258 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15259 {
e9e44622 15260 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15261 return buff;
15262 }
15263
15264 switch (elf_header.e_machine)
15265 {
15266 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15267 and PT_GETFPREGS == mach+2. */
15268
15269 case EM_OLD_ALPHA:
15270 case EM_ALPHA:
15271 case EM_SPARC:
15272 case EM_SPARC32PLUS:
15273 case EM_SPARCV9:
15274 switch (e_type)
15275 {
2b692964 15276 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15277 return _("PT_GETREGS (reg structure)");
2b692964 15278 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15279 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15280 default:
15281 break;
15282 }
15283 break;
15284
15285 /* On all other arch's, PT_GETREGS == mach+1 and
15286 PT_GETFPREGS == mach+3. */
15287 default:
15288 switch (e_type)
15289 {
2b692964 15290 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15291 return _("PT_GETREGS (reg structure)");
2b692964 15292 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15293 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15294 default:
15295 break;
15296 }
15297 }
15298
9cf03b7e 15299 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15300 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15301 return buff;
15302}
15303
70616151
TT		 15304static const char *
15305get_stapsdt_note_type (unsigned e_type)
15306{
15307 static char buff[64];
15308
15309 switch (e_type)
15310 {
15311 case NT_STAPSDT:
15312 return _("NT_STAPSDT (SystemTap probe descriptors)");
15313
15314 default:
15315 break;
15316 }
15317
15318 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15319 return buff;
15320}
15321
c6a9fc58
TT		 15322static int
15323print_stapsdt_note (Elf_Internal_Note *pnote)
15324{
15325 int addr_size = is_32bit_elf ? 4 : 8;
15326 char *data = pnote->descdata;
15327 char *data_end = pnote->descdata + pnote->descsz;
15328 bfd_vma pc, base_addr, semaphore;
15329 char *provider, *probe, *arg_fmt;
15330
15331 pc = byte_get ((unsigned char *) data, addr_size);
15332 data += addr_size;
15333 base_addr = byte_get ((unsigned char *) data, addr_size);
15334 data += addr_size;
15335 semaphore = byte_get ((unsigned char *) data, addr_size);
15336 data += addr_size;
15337
15338 provider = data;
15339 data += strlen (data) + 1;
15340 probe = data;
15341 data += strlen (data) + 1;
15342 arg_fmt = data;
15343 data += strlen (data) + 1;
15344
15345 printf (_(" Provider: %s\n"), provider);
15346 printf (_(" Name: %s\n"), probe);
15347 printf (_(" Location: "));
15348 print_vma (pc, FULL_HEX);
15349 printf (_(", Base: "));
15350 print_vma (base_addr, FULL_HEX);
15351 printf (_(", Semaphore: "));
15352 print_vma (semaphore, FULL_HEX);
9cf03b7e 15353 printf ("\n");
c6a9fc58
TT		 15354 printf (_(" Arguments: %s\n"), arg_fmt);
15355
15356 return data == data_end;
15357}
15358
00e98fc7
TG		 15359static const char *
15360get_ia64_vms_note_type (unsigned e_type)
15361{
15362 static char buff[64];
15363
15364 switch (e_type)
15365 {
15366 case NT_VMS_MHD:
15367 return _("NT_VMS_MHD (module header)");
15368 case NT_VMS_LNM:
15369 return _("NT_VMS_LNM (language name)");
15370 case NT_VMS_SRC:
15371 return _("NT_VMS_SRC (source files)");
15372 case NT_VMS_TITLE:
9cf03b7e 15373 return "NT_VMS_TITLE";
00e98fc7
TG		 15374 case NT_VMS_EIDC:
15375 return _("NT_VMS_EIDC (consistency check)");
15376 case NT_VMS_FPMODE:
15377 return _("NT_VMS_FPMODE (FP mode)");
15378 case NT_VMS_LINKTIME:
9cf03b7e 15379 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15380 case NT_VMS_IMGNAM:
15381 return _("NT_VMS_IMGNAM (image name)");
15382 case NT_VMS_IMGID:
15383 return _("NT_VMS_IMGID (image id)");
15384 case NT_VMS_LINKID:
15385 return _("NT_VMS_LINKID (link id)");
15386 case NT_VMS_IMGBID:
15387 return _("NT_VMS_IMGBID (build id)");
15388 case NT_VMS_GSTNAM:
15389 return _("NT_VMS_GSTNAM (sym table name)");
15390 case NT_VMS_ORIG_DYN:
9cf03b7e 15391 return "NT_VMS_ORIG_DYN";
00e98fc7 15392 case NT_VMS_PATCHTIME:
9cf03b7e 15393 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15394 default:
15395 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15396 return buff;
15397 }
15398}
15399
15400static int
15401print_ia64_vms_note (Elf_Internal_Note * pnote)
15402{
15403 switch (pnote->type)
15404 {
15405 case NT_VMS_MHD:
15406 if (pnote->descsz > 36)
15407 {
15408 size_t l = strlen (pnote->descdata + 34);
15409 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15410 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15411 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15412 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15413 }
15414 else
15415 printf (_(" Invalid size\n"));
15416 break;
15417 case NT_VMS_LNM:
15418 printf (_(" Language: %s\n"), pnote->descdata);
15419 break;
15420#ifdef BFD64
15421 case NT_VMS_FPMODE:
9cf03b7e 15422 printf (_(" Floating Point mode: "));
4a5cb34f 15423 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15424 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15425 break;
15426 case NT_VMS_LINKTIME:
15427 printf (_(" Link time: "));
15428 print_vms_time
15429 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15430 printf ("\n");
15431 break;
15432 case NT_VMS_PATCHTIME:
15433 printf (_(" Patch time: "));
15434 print_vms_time
15435 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15436 printf ("\n");
15437 break;
15438 case NT_VMS_ORIG_DYN:
15439 printf (_(" Major id: %u, minor id: %u\n"),
15440 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15441 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15442 printf (_(" Last modified : "));
00e98fc7
TG		 15443 print_vms_time
15444 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15445 printf (_("\n Link flags : "));
4a5cb34f 15446 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15447 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15448 printf (_(" Header flags: 0x%08x\n"),
948f632f 15449 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15450 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15451 break;
15452#endif
15453 case NT_VMS_IMGNAM:
15454 printf (_(" Image name: %s\n"), pnote->descdata);
15455 break;
15456 case NT_VMS_GSTNAM:
15457 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15458 break;
15459 case NT_VMS_IMGID:
15460 printf (_(" Image id: %s\n"), pnote->descdata);
15461 break;
15462 case NT_VMS_LINKID:
15463 printf (_(" Linker id: %s\n"), pnote->descdata);
15464 break;
15465 default:
15466 break;
15467 }
15468 return 1;
15469}
15470
6d118b09
NC		 15471/* Note that by the ELF standard, the name field is already null byte
15472 terminated, and namesz includes the terminating null byte.
15473 I.E. the value of namesz for the name "FSF" is 4.
15474
e3c8793a 15475 If the value of namesz is zero, there is no name present. */
779fe533 15476static int
2cf0635d 15477process_note (Elf_Internal_Note * pnote)
779fe533 15478{
2cf0635d
NC		 15479 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15480 const char * nt;
9437c45b
JT		 15481
15482 if (pnote->namesz == 0)
1ec5cd37
NC		 15483 /* If there is no note name, then use the default set of
15484 note type strings. */
15485 nt = get_note_type (pnote->type);
15486
1118d252
RM		 15487 else if (const_strneq (pnote->namedata, "GNU"))
15488 /* GNU-specific object file notes. */
15489 nt = get_gnu_elf_note_type (pnote->type);
15490
0112cd26 15491 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15492 /* NetBSD-specific core file notes. */
15493 nt = get_netbsd_elfcore_note_type (pnote->type);
15494
b15fa79e
AM		 15495 else if (strneq (pnote->namedata, "SPU/", 4))
15496 {
15497 /* SPU-specific core file notes. */
15498 nt = pnote->namedata + 4;
15499 name = "SPU";
15500 }
15501
00e98fc7
TG		 15502 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15503 /* VMS/ia64-specific file notes. */
15504 nt = get_ia64_vms_note_type (pnote->type);
15505
70616151
TT		 15506 else if (const_strneq (pnote->namedata, "stapsdt"))
15507 nt = get_stapsdt_note_type (pnote->type);
15508
9437c45b 15509 else
1ec5cd37
NC		 15510 /* Don't recognize this note name; just use the default set of
15511 note type strings. */
00e98fc7 15512 nt = get_note_type (pnote->type);
9437c45b 15513
2aee03ae 15514 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15515
15516 if (const_strneq (pnote->namedata, "IPF/VMS"))
15517 return print_ia64_vms_note (pnote);
664f90a3
TT		 15518 else if (const_strneq (pnote->namedata, "GNU"))
15519 return print_gnu_note (pnote);
c6a9fc58
TT		 15520 else if (const_strneq (pnote->namedata, "stapsdt"))
15521 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15522 else if (const_strneq (pnote->namedata, "CORE"))
15523 return print_core_note (pnote);
00e98fc7
TG		 15524 else
15525 return 1;
779fe533
NC		 15526}
15527
6d118b09 15528
779fe533 15529static int
2cf0635d 15530process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15531{
2cf0635d
NC		 15532 Elf_External_Note * pnotes;
15533 Elf_External_Note * external;
c8071705 15534 char * end;
b34976b6 15535 int res = 1;
103f02d3 15536
779fe533
NC		 15537 if (length <= 0)
15538 return 0;
103f02d3 15539
3f5e193b 15540 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15541 _("notes"));
dd24e3da 15542 if (pnotes == NULL)
a6e9f9df 15543 return 0;
779fe533 15544
103f02d3 15545 external = pnotes;
103f02d3 15546
9dd3a467 15547 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15548 (unsigned long) offset, (unsigned long) length);
2aee03ae 15549 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15550
c8071705
NC		 15551 end = (char *) pnotes + length;
15552 while ((char *) external < end)
779fe533 15553 {
b34976b6 15554 Elf_Internal_Note inote;
15b42fb0
AM		 15555 size_t min_notesz;
15556 char *next;
2cf0635d 15557 char * temp = NULL;
c8071705 15558 size_t data_remaining = end - (char *) external;
6d118b09 15559
00e98fc7 15560 if (!is_ia64_vms ())
15b42fb0 15561 {
9dd3a467
NC		 15562 /* PR binutils/15191
15563 Make sure that there is enough data to read. */
15b42fb0
AM		 15564 min_notesz = offsetof (Elf_External_Note, name);
15565 if (data_remaining < min_notesz)
9dd3a467
NC		 15566 {
15567 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15568 (int) data_remaining);
15569 break;
15570 }
15b42fb0
AM		 15571 inote.type = BYTE_GET (external->type);
15572 inote.namesz = BYTE_GET (external->namesz);
15573 inote.namedata = external->name;
15574 inote.descsz = BYTE_GET (external->descsz);
15575 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15576 /* PR 17531: file: 3443835e. */
c8071705 15577 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15578 {
15579 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15580 inote.descdata = inote.namedata;
15581 inote.namesz = 0;
15582 }
14ae95f2 15583
15b42fb0
AM		 15584 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15585 next = inote.descdata + align_power (inote.descsz, 2);
15586 }
00e98fc7 15587 else
15b42fb0
AM		 15588 {
15589 Elf64_External_VMS_Note *vms_external;
00e98fc7 15590
9dd3a467
NC		 15591 /* PR binutils/15191
15592 Make sure that there is enough data to read. */
15b42fb0
AM		 15593 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15594 if (data_remaining < min_notesz)
9dd3a467
NC		 15595 {
15596 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15597 (int) data_remaining);
15598 break;
15599 }
3e55a963 15600
15b42fb0
AM		 15601 vms_external = (Elf64_External_VMS_Note *) external;
15602 inote.type = BYTE_GET (vms_external->type);
15603 inote.namesz = BYTE_GET (vms_external->namesz);
15604 inote.namedata = vms_external->name;
15605 inote.descsz = BYTE_GET (vms_external->descsz);
15606 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15607 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15608 next = inote.descdata + align_power (inote.descsz, 3);
15609 }
15610
15611 if (inote.descdata < (char *) external + min_notesz
15612 || next < (char *) external + min_notesz
5d921cbd
NC		 15613 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15614 || inote.namedata + inote.namesz < inote.namedata
15615 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15616 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15617 {
15b42fb0 15618 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15619 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15620 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15621 inote.type, inote.namesz, inote.descsz);
15622 break;
15623 }
15624
15b42fb0 15625 external = (Elf_External_Note *) next;
dd24e3da 15626
6d118b09
NC		 15627 /* Verify that name is null terminated. It appears that at least
15628 one version of Linux (RedHat 6.0) generates corefiles that don't
15629 comply with the ELF spec by failing to include the null byte in
15630 namesz. */
8b971f9f 15631 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15632 {
3f5e193b 15633 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15634 if (temp == NULL)
15635 {
8b73c356 15636 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15637 res = 0;
15638 break;
15639 }
76da6bbe 15640
6d118b09
NC		 15641 strncpy (temp, inote.namedata, inote.namesz);
15642 temp[inote.namesz] = 0;
76da6bbe 15643
6d118b09
NC		 15644 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15645 inote.namedata = temp;
15646 }
15647
15648 res &= process_note (& inote);
103f02d3 15649
6d118b09
NC		 15650 if (temp != NULL)
15651 {
15652 free (temp);
15653 temp = NULL;
15654 }
779fe533
NC		 15655 }
15656
15657 free (pnotes);
103f02d3 15658
779fe533
NC		 15659 return res;
15660}
15661
15662static int
2cf0635d 15663process_corefile_note_segments (FILE * file)
779fe533 15664{
2cf0635d 15665 Elf_Internal_Phdr * segment;
b34976b6
AM		 15666 unsigned int i;
15667 int res = 1;
103f02d3 15668
d93f0186 15669 if (! get_program_headers (file))
779fe533 15670 return 0;
103f02d3 15671
779fe533
NC		 15672 for (i = 0, segment = program_headers;
15673 i < elf_header.e_phnum;
b34976b6 15674 i++, segment++)
779fe533
NC		 15675 {
15676 if (segment->p_type == PT_NOTE)
103f02d3 15677 res &= process_corefile_note_segment (file,
30800947
NC		 15678 (bfd_vma) segment->p_offset,
15679 (bfd_vma) segment->p_filesz);
779fe533 15680 }
103f02d3 15681
779fe533
NC		 15682 return res;
15683}
15684
685080f2
NC		 15685static int
15686process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15687{
15688 Elf_External_Note * pnotes;
15689 Elf_External_Note * external;
c8071705 15690 char * end;
685080f2
NC		 15691 int res = 1;
15692
15693 if (length <= 0)
15694 return 0;
15695
15696 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15697 _("v850 notes"));
15698 if (pnotes == NULL)
15699 return 0;
15700
15701 external = pnotes;
c8071705 15702 end = (char*) pnotes + length;
685080f2
NC		 15703
15704 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15705 (unsigned long) offset, (unsigned long) length);
15706
c8071705 15707 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15708 {
15709 Elf_External_Note * next;
15710 Elf_Internal_Note inote;
15711
15712 inote.type = BYTE_GET (external->type);
15713 inote.namesz = BYTE_GET (external->namesz);
15714 inote.namedata = external->name;
15715 inote.descsz = BYTE_GET (external->descsz);
15716 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15717 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15718
c8071705
NC		 15719 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15720 {
15721 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15722 inote.descdata = inote.namedata;
15723 inote.namesz = 0;
15724 }
15725
685080f2
NC		 15726 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15727
c8071705 15728 if ( ((char *) next > end)
685080f2
NC		 15729 || ((char *) next < (char *) pnotes))
15730 {
15731 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15732 (unsigned long) ((char *) external - (char *) pnotes));
15733 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15734 inote.type, inote.namesz, inote.descsz);
15735 break;
15736 }
15737
15738 external = next;
15739
15740 /* Prevent out-of-bounds indexing. */
c8071705 15741 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15742 || inote.namedata + inote.namesz < inote.namedata)
15743 {
15744 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15745 (unsigned long) ((char *) external - (char *) pnotes));
15746 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15747 inote.type, inote.namesz, inote.descsz);
15748 break;
15749 }
15750
15751 printf (" %s: ", get_v850_elf_note_type (inote.type));
15752
15753 if (! print_v850_note (& inote))
15754 {
15755 res = 0;
15756 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15757 inote.namesz, inote.descsz);
15758 }
15759 }
15760
15761 free (pnotes);
15762
15763 return res;
15764}
15765
779fe533 15766static int
2cf0635d 15767process_note_sections (FILE * file)
1ec5cd37 15768{
2cf0635d 15769 Elf_Internal_Shdr * section;
1ec5cd37 15770 unsigned long i;
df565f32 15771 int n = 0;
1ec5cd37
NC		 15772 int res = 1;
15773
15774 for (i = 0, section = section_headers;
fa1908fd 15775 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15776 i++, section++)
685080f2
NC		 15777 {
15778 if (section->sh_type == SHT_NOTE)
15779 {
15780 res &= process_corefile_note_segment (file,
15781 (bfd_vma) section->sh_offset,
15782 (bfd_vma) section->sh_size);
15783 n++;
15784 }
15785
15786 if (( elf_header.e_machine == EM_V800
15787 || elf_header.e_machine == EM_V850
15788 || elf_header.e_machine == EM_CYGNUS_V850)
15789 && section->sh_type == SHT_RENESAS_INFO)
15790 {
15791 res &= process_v850_notes (file,
15792 (bfd_vma) section->sh_offset,
15793 (bfd_vma) section->sh_size);
15794 n++;
15795 }
15796 }
df565f32
NC		 15797
15798 if (n == 0)
15799 /* Try processing NOTE segments instead. */
15800 return process_corefile_note_segments (file);
1ec5cd37
NC		 15801
15802 return res;
15803}
15804
15805static int
2cf0635d 15806process_notes (FILE * file)
779fe533
NC		 15807{
15808 /* If we have not been asked to display the notes then do nothing. */
15809 if (! do_notes)
15810 return 1;
103f02d3 15811
779fe533 15812 if (elf_header.e_type != ET_CORE)
1ec5cd37 15813 return process_note_sections (file);
103f02d3 15814
779fe533 15815 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15816 if (elf_header.e_phnum > 0)
15817 return process_corefile_note_segments (file);
779fe533 15818
1ec5cd37
NC		 15819 printf (_("No note segments present in the core file.\n"));
15820 return 1;
779fe533
NC		 15821}
15822
252b5132 15823static int
2cf0635d 15824process_arch_specific (FILE * file)
252b5132 15825{
a952a375
NC		 15826 if (! do_arch)
15827 return 1;
15828
252b5132
RH		 15829 switch (elf_header.e_machine)
15830 {
11c1ff18
PB		 15831 case EM_ARM:
15832 return process_arm_specific (file);
252b5132 15833 case EM_MIPS:
4fe85591 15834 case EM_MIPS_RS3_LE:
252b5132
RH		 15835 return process_mips_specific (file);
15836 break;
35c08157
KLC		 15837 case EM_NDS32:
15838 return process_nds32_specific (file);
15839 break;
34c8bcba
JM		 15840 case EM_PPC:
15841 return process_power_specific (file);
15842 break;
643f7afb
AK		 15843 case EM_S390:
15844 case EM_S390_OLD:
15845 return process_s390_specific (file);
15846 break;
9e8c70f9
DM		 15847 case EM_SPARC:
15848 case EM_SPARC32PLUS:
15849 case EM_SPARCV9:
15850 return process_sparc_specific (file);
15851 break;
59e6276b
JM		 15852 case EM_TI_C6000:
15853 return process_tic6x_specific (file);
15854 break;
13761a11
NC		 15855 case EM_MSP430:
15856 return process_msp430x_specific (file);
252b5132
RH		 15857 default:
15858 break;
15859 }
15860 return 1;
15861}
15862
15863static int
2cf0635d 15864get_file_header (FILE * file)
252b5132 15865{
9ea033b2
NC		 15866 /* Read in the identity array. */
15867 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15868 return 0;
15869
9ea033b2 15870 /* Determine how to read the rest of the header. */
b34976b6 15871 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15872 {
15873 default: /* fall through */
15874 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15875 case ELFDATA2LSB:
15876 byte_get = byte_get_little_endian;
15877 byte_put = byte_put_little_endian;
15878 break;
15879 case ELFDATA2MSB:
15880 byte_get = byte_get_big_endian;
15881 byte_put = byte_put_big_endian;
15882 break;
9ea033b2
NC		 15883 }
15884
15885 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15886 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15887
15888 /* Read in the rest of the header. */
15889 if (is_32bit_elf)
15890 {
15891 Elf32_External_Ehdr ehdr32;
252b5132 15892
9ea033b2
NC		 15893 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15894 return 0;
103f02d3 15895
9ea033b2
NC		 15896 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15897 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15898 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15899 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15900 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15901 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15902 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15903 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15904 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15905 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15906 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15907 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15908 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15909 }
252b5132 15910 else
9ea033b2
NC		 15911 {
15912 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15913
15914 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15915 we will not be able to cope with the 64bit data found in
15916 64 ELF files. Detect this now and abort before we start
50c2245b 15917 overwriting things. */
a952a375
NC		 15918 if (sizeof (bfd_vma) < 8)
15919 {
e3c8793a
NC		 15920 error (_("This instance of readelf has been built without support for a\n\
1592164 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15922 return 0;
15923 }
103f02d3 15924
9ea033b2
NC		 15925 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15926 return 0;
103f02d3 15927
9ea033b2
NC		 15928 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15929 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15930 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15931 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15932 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15933 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15934 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15935 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15936 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15937 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15938 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15939 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15940 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15941 }
252b5132 15942
7ece0d85
JJ		 15943 if (elf_header.e_shoff)
15944 {
15945 /* There may be some extensions in the first section header. Don't
15946 bomb if we can't read it. */
15947 if (is_32bit_elf)
049b0c3a 15948 get_32bit_section_headers (file, TRUE);
7ece0d85 15949 else
049b0c3a 15950 get_64bit_section_headers (file, TRUE);
7ece0d85 15951 }
560f3c1c 15952
252b5132
RH		 15953 return 1;
15954}
15955
fb52b2f4
NC		 15956/* Process one ELF object file according to the command line options.
15957 This file may actually be stored in an archive. The file is
15958 positioned at the start of the ELF object. */
15959
ff78d6d6 15960static int
2cf0635d 15961process_object (char * file_name, FILE * file)
252b5132 15962{
252b5132
RH		 15963 unsigned int i;
15964
252b5132
RH		 15965 if (! get_file_header (file))
15966 {
15967 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15968 return 1;
252b5132
RH		 15969 }
15970
15971 /* Initialise per file variables. */
60bca95a 15972 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15973 version_info[i] = 0;
15974
60bca95a 15975 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15976 dynamic_info[i] = 0;
5115b233 15977 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15978
15979 /* Process the file. */
15980 if (show_name)
15981 printf (_("\nFile: %s\n"), file_name);
15982
18bd398b
NC		 15983 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15984 Note we do this even if cmdline_dump_sects is empty because we
15985 must make sure that the dump_sets array is zeroed out before each
15986 object file is processed. */
15987 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15988 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15989
15990 if (num_cmdline_dump_sects > 0)
15991 {
15992 if (num_dump_sects == 0)
15993 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15994 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15995
15996 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15997 memcpy (dump_sects, cmdline_dump_sects,
15998 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15999 }
d70c5fc7 16000
252b5132 16001 if (! process_file_header ())
fb52b2f4 16002 return 1;
252b5132 16003
d1f5c6e3 16004 if (! process_section_headers (file))
2f62977e 16005 {
d1f5c6e3
L		 16006 /* Without loaded section headers we cannot process lots of
16007 things. */
2f62977e 16008 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16009
2f62977e 16010 if (! do_using_dynamic)
2c610e4b 16011 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16012 }
252b5132 16013
d1f5c6e3
L		 16014 if (! process_section_groups (file))
16015 {
16016 /* Without loaded section groups we cannot process unwind. */
16017 do_unwind = 0;
16018 }
16019
2f62977e 16020 if (process_program_headers (file))
b2d38a17 16021 process_dynamic_section (file);
252b5132
RH		 16022
16023 process_relocs (file);
16024
4d6ed7c8
NC		 16025 process_unwind (file);
16026
252b5132
RH		 16027 process_symbol_table (file);
16028
16029 process_syminfo (file);
16030
16031 process_version_sections (file);
16032
16033 process_section_contents (file);
f5842774 16034
1ec5cd37 16035 process_notes (file);
103f02d3 16036
047b2264
JJ		 16037 process_gnu_liblist (file);
16038
252b5132
RH		 16039 process_arch_specific (file);
16040
d93f0186
NC		 16041 if (program_headers)
16042 {
16043 free (program_headers);
16044 program_headers = NULL;
16045 }
16046
252b5132
RH		 16047 if (section_headers)
16048 {
16049 free (section_headers);
16050 section_headers = NULL;
16051 }
16052
16053 if (string_table)
16054 {
16055 free (string_table);
16056 string_table = NULL;
d40ac9bd 16057 string_table_length = 0;
252b5132
RH		 16058 }
16059
16060 if (dynamic_strings)
16061 {
16062 free (dynamic_strings);
16063 dynamic_strings = NULL;
d79b3d50 16064 dynamic_strings_length = 0;
252b5132
RH		 16065 }
16066
16067 if (dynamic_symbols)
16068 {
16069 free (dynamic_symbols);
16070 dynamic_symbols = NULL;
19936277 16071 num_dynamic_syms = 0;
252b5132
RH		 16072 }
16073
16074 if (dynamic_syminfo)
16075 {
16076 free (dynamic_syminfo);
16077 dynamic_syminfo = NULL;
16078 }
ff78d6d6 16079
293c573e
MR		 16080 if (dynamic_section)
16081 {
16082 free (dynamic_section);
16083 dynamic_section = NULL;
16084 }
16085
e4b17d5c
L		 16086 if (section_headers_groups)
16087 {
16088 free (section_headers_groups);
16089 section_headers_groups = NULL;
16090 }
16091
16092 if (section_groups)
16093 {
2cf0635d
NC		 16094 struct group_list * g;
16095 struct group_list * next;
e4b17d5c
L		 16096
16097 for (i = 0; i < group_count; i++)
16098 {
16099 for (g = section_groups [i].root; g != NULL; g = next)
16100 {
16101 next = g->next;
16102 free (g);
16103 }
16104 }
16105
16106 free (section_groups);
16107 section_groups = NULL;
16108 }
16109
19e6b90e 16110 free_debug_memory ();
18bd398b 16111
ff78d6d6 16112 return 0;
252b5132
RH		 16113}
16114
2cf0635d
NC		 16115/* Process an ELF archive.
16116 On entry the file is positioned just after the ARMAG string. */
16117
16118static int
16119process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16120{
16121 struct archive_info arch;
16122 struct archive_info nested_arch;
16123 size_t got;
2cf0635d
NC		 16124 int ret;
16125
16126 show_name = 1;
16127
16128 /* The ARCH structure is used to hold information about this archive. */
16129 arch.file_name = NULL;
16130 arch.file = NULL;
16131 arch.index_array = NULL;
16132 arch.sym_table = NULL;
16133 arch.longnames = NULL;
16134
16135 /* The NESTED_ARCH structure is used as a single-item cache of information
16136 about a nested archive (when members of a thin archive reside within
16137 another regular archive file). */
16138 nested_arch.file_name = NULL;
16139 nested_arch.file = NULL;
16140 nested_arch.index_array = NULL;
16141 nested_arch.sym_table = NULL;
16142 nested_arch.longnames = NULL;
16143
16144 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16145 {
16146 ret = 1;
16147 goto out;
4145f1d5 16148 }
fb52b2f4 16149
4145f1d5
NC		 16150 if (do_archive_index)
16151 {
2cf0635d 16152 if (arch.sym_table == NULL)
4145f1d5
NC		 16153 error (_("%s: unable to dump the index as none was found\n"), file_name);
16154 else
16155 {
591f7597 16156 unsigned long i, l;
4145f1d5
NC		 16157 unsigned long current_pos;
16158
591f7597
NC		 16159 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16160 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16161 current_pos = ftell (file);
16162
2cf0635d 16163 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16164 {
2cf0635d
NC		 16165 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16166 {
16167 char * member_name;
4145f1d5 16168
2cf0635d
NC		 16169 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16170
16171 if (member_name != NULL)
16172 {
16173 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16174
16175 if (qualified_name != NULL)
16176 {
c2a7d3f5
NC		 16177 printf (_("Contents of binary %s at offset "), qualified_name);
16178 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16179 putchar ('\n');
2cf0635d
NC		 16180 free (qualified_name);
16181 }
4145f1d5
NC		 16182 }
16183 }
2cf0635d
NC		 16184
16185 if (l >= arch.sym_size)
4145f1d5
NC		 16186 {
16187 error (_("%s: end of the symbol table reached before the end of the index\n"),
16188 file_name);
cb8f3167 16189 break;
4145f1d5 16190 }
591f7597
NC		 16191 /* PR 17531: file: 0b6630b2. */
16192 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16193 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16194 }
16195
c2a7d3f5
NC		 16196 if (arch.uses_64bit_indicies)
16197 l = (l + 7) & ~ 7;
16198 else
16199 l += l & 1;
16200
2cf0635d 16201 if (l < arch.sym_size)
c2a7d3f5
NC		 16202 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16203 file_name, arch.sym_size - l);
4145f1d5 16204
4145f1d5
NC		 16205 if (fseek (file, current_pos, SEEK_SET) != 0)
16206 {
16207 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16208 ret = 1;
16209 goto out;
4145f1d5 16210 }
fb52b2f4 16211 }
4145f1d5
NC		 16212
16213 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16214 && !do_segments && !do_header && !do_dump && !do_version
16215 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16216 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16217 {
16218 ret = 0; /* Archive index only. */
16219 goto out;
16220 }
fb52b2f4
NC		 16221 }
16222
d989285c 16223 ret = 0;
fb52b2f4
NC		 16224
16225 while (1)
16226 {
2cf0635d
NC		 16227 char * name;
16228 size_t namelen;
16229 char * qualified_name;
16230
16231 /* Read the next archive header. */
16232 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16233 {
16234 error (_("%s: failed to seek to next archive header\n"), file_name);
16235 return 1;
16236 }
16237 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16238 if (got != sizeof arch.arhdr)
16239 {
16240 if (got == 0)
16241 break;
16242 error (_("%s: failed to read archive header\n"), file_name);
16243 ret = 1;
16244 break;
16245 }
16246 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16247 {
16248 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16249 ret = 1;
16250 break;
16251 }
16252
16253 arch.next_arhdr_offset += sizeof arch.arhdr;
16254
16255 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16256 if (archive_file_size & 01)
16257 ++archive_file_size;
16258
16259 name = get_archive_member_name (&arch, &nested_arch);
16260 if (name == NULL)
fb52b2f4 16261 {
0fd3a477 16262 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16263 ret = 1;
16264 break;
fb52b2f4 16265 }
2cf0635d 16266 namelen = strlen (name);
fb52b2f4 16267
2cf0635d
NC		 16268 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16269 if (qualified_name == NULL)
fb52b2f4 16270 {
2cf0635d 16271 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16272 ret = 1;
16273 break;
fb52b2f4
NC		 16274 }
16275
2cf0635d
NC		 16276 if (is_thin_archive && arch.nested_member_origin == 0)
16277 {
16278 /* This is a proxy for an external member of a thin archive. */
16279 FILE * member_file;
16280 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16281 if (member_file_name == NULL)
16282 {
16283 ret = 1;
16284 break;
16285 }
16286
16287 member_file = fopen (member_file_name, "rb");
16288 if (member_file == NULL)
16289 {
16290 error (_("Input file '%s' is not readable.\n"), member_file_name);
16291 free (member_file_name);
16292 ret = 1;
16293 break;
16294 }
16295
16296 archive_file_offset = arch.nested_member_origin;
16297
16298 ret |= process_object (qualified_name, member_file);
16299
16300 fclose (member_file);
16301 free (member_file_name);
16302 }
16303 else if (is_thin_archive)
16304 {
a043396b
NC		 16305 /* PR 15140: Allow for corrupt thin archives. */
16306 if (nested_arch.file == NULL)
16307 {
16308 error (_("%s: contains corrupt thin archive: %s\n"),
16309 file_name, name);
16310 ret = 1;
16311 break;
16312 }
16313
2cf0635d
NC		 16314 /* This is a proxy for a member of a nested archive. */
16315 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16316
16317 /* The nested archive file will have been opened and setup by
16318 get_archive_member_name. */
16319 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16320 {
16321 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16322 ret = 1;
16323 break;
16324 }
16325
16326 ret |= process_object (qualified_name, nested_arch.file);
16327 }
16328 else
16329 {
16330 archive_file_offset = arch.next_arhdr_offset;
16331 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16332
2cf0635d
NC		 16333 ret |= process_object (qualified_name, file);
16334 }
fb52b2f4 16335
2b52916e
L		 16336 if (dump_sects != NULL)
16337 {
16338 free (dump_sects);
16339 dump_sects = NULL;
16340 num_dump_sects = 0;
16341 }
16342
2cf0635d 16343 free (qualified_name);
fb52b2f4
NC		 16344 }
16345
4145f1d5 16346 out:
2cf0635d
NC		 16347 if (nested_arch.file != NULL)
16348 fclose (nested_arch.file);
16349 release_archive (&nested_arch);
16350 release_archive (&arch);
fb52b2f4 16351
d989285c 16352 return ret;
fb52b2f4
NC		 16353}
16354
16355static int
2cf0635d 16356process_file (char * file_name)
fb52b2f4 16357{
2cf0635d 16358 FILE * file;
fb52b2f4
NC		 16359 struct stat statbuf;
16360 char armag[SARMAG];
16361 int ret;
16362
16363 if (stat (file_name, &statbuf) < 0)
16364 {
f24ddbdd
NC		 16365 if (errno == ENOENT)
16366 error (_("'%s': No such file\n"), file_name);
16367 else
16368 error (_("Could not locate '%s'. System error message: %s\n"),
16369 file_name, strerror (errno));
16370 return 1;
16371 }
16372
16373 if (! S_ISREG (statbuf.st_mode))
16374 {
16375 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16376 return 1;
16377 }
16378
16379 file = fopen (file_name, "rb");
16380 if (file == NULL)
16381 {
f24ddbdd 16382 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16383 return 1;
16384 }
16385
16386 if (fread (armag, SARMAG, 1, file) != 1)
16387 {
4145f1d5 16388 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16389 fclose (file);
16390 return 1;
16391 }
16392
f54498b4
NC		 16393 current_file_size = (bfd_size_type) statbuf.st_size;
16394
fb52b2f4 16395 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16396 ret = process_archive (file_name, file, FALSE);
16397 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16398 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16399 else
16400 {
4145f1d5
NC		 16401 if (do_archive_index)
16402 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16403 file_name);
16404
fb52b2f4
NC		 16405 rewind (file);
16406 archive_file_size = archive_file_offset = 0;
16407 ret = process_object (file_name, file);
16408 }
16409
16410 fclose (file);
16411
f54498b4 16412 current_file_size = 0;
fb52b2f4
NC		 16413 return ret;
16414}
16415
252b5132
RH		 16416#ifdef SUPPORT_DISASSEMBLY
16417/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16418 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16419 symbols. */
252b5132
RH		 16420
16421void
2cf0635d 16422print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16423{
16424 fprintf (outfile,"0x%8.8x", addr);
16425}
16426
e3c8793a 16427/* Needed by the i386 disassembler. */
252b5132
RH		 16428void
16429db_task_printsym (unsigned int addr)
16430{
16431 print_address (addr, stderr);
16432}
16433#endif
16434
16435int
2cf0635d 16436main (int argc, char ** argv)
252b5132 16437{
ff78d6d6
L		 16438 int err;
16439
252b5132
RH		 16440#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16441 setlocale (LC_MESSAGES, "");
3882b010
L		 16442#endif
16443#if defined (HAVE_SETLOCALE)
16444 setlocale (LC_CTYPE, "");
252b5132
RH		 16445#endif
16446 bindtextdomain (PACKAGE, LOCALEDIR);
16447 textdomain (PACKAGE);
16448
869b9d07
MM		 16449 expandargv (&argc, &argv);
16450
252b5132
RH		 16451 parse_args (argc, argv);
16452
18bd398b 16453 if (num_dump_sects > 0)
59f14fc0 16454 {
18bd398b 16455 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16456 cmdline_dump_sects = (dump_type *)
16457 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16458 if (cmdline_dump_sects == NULL)
591a748a 16459 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16460 else
16461 {
09c11c86
NC		 16462 memcpy (cmdline_dump_sects, dump_sects,
16463 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16464 num_cmdline_dump_sects = num_dump_sects;
16465 }
16466 }
16467
18bd398b
NC		 16468 if (optind < (argc - 1))
16469 show_name = 1;
5656ba2c
L		 16470 else if (optind >= argc)
16471 {
16472 warn (_("Nothing to do.\n"));
16473 usage (stderr);
16474 }
18bd398b 16475
ff78d6d6 16476 err = 0;
252b5132 16477 while (optind < argc)
18bd398b 16478 err |= process_file (argv[optind++]);
252b5132
RH		 16479
16480 if (dump_sects != NULL)
16481 free (dump_sects);
59f14fc0
AS		 16482 if (cmdline_dump_sects != NULL)
16483 free (cmdline_dump_sects);
252b5132 16484
ff78d6d6 16485 return err;
252b5132 16486}
A mirror of the official binutils-gdb repository